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

package/dist/rooms-tasks/cli.js

@@ -1,16 +1,227 @@
 import { readFileSync } from 'node:fs';
 import { loadConfig, ConfigError } from '../config.js';
-import { provisionMembers, cleanupMembers, getBinPath } from './provision.js';
+import { provisionMembers, getBinPath } from './provision.js';
+import { acceptManagedRoomClose, deleteLegacyClosedRooms, deleteManagedRoom, recordManagedRoomCloseError, } from './close.js';
+import { acceptTaskTerminalIntent, recordTaskTerminalIntentError, settleTaskTerminalIntent, } from './terminal.js';
+import { launchFleetWorker } from './external-worker.js';
 import { resolveTemplate, listTemplates, snapshotTemplate, hashTemplate, } from './templates.js';
-import { createTask, getTask, listTasks, startTask, activateTask, blockTask, unblockTask, reviewTask, completeTask, cancelTask, updateTaskRoom, updateTaskTemplate, } from './task-state.js';
-import { createRoomRecord, getRoomRecord, listRoomRecords, closeRoom as closeRoomRecord, advanceSaga, setOwnerSeat, setSagaError, activateRoom, } from './room-state.js';
+import { createTask, getTask, listTasks, startTask, activateTask, blockTask, unblockTask, reviewTask, updateTaskRoom, updateTaskTemplate, deleteTask, TaskStateError, } from './task-state.js';
+import { createRoomRecord, getRoomRecord, listRoomRecords, advanceSaga, setOwnerSeat, setSagaError, activateRoom, RoomStateError, } from './room-state.js';
 import { createCoworkAdapter, CoworkProtocolError, CoworkUnavailableError } from './cowork-adapter.js';
-import { TASK_TERMINAL_STATES } from './types.js';
+import { TASK_CANCELLABLE_STATES, TASK_TERMINAL_STATES } from './types.js';
+import { markdownCode, markdownProse, renderMarkdownFailure, renderMarkdownList, renderMarkdownResult, roomStatus, taskStatus, } from './markdown.js';
+class TaskRoomPublicError extends Error {
+    code;
+    fields;
+    constructor(code, fields = {}) {
+        super(code);
+        this.code = code;
+        this.fields = fields;
+        this.name = 'TaskRoomPublicError';
+    }
+}
+const PUBLIC_ERROR_FIELD = /^[A-Za-z0-9._:@-]{1,160}$/u;
+function taskRoomPublicError(code, fields = {}) {
+    const validated = Object.fromEntries(Object.entries(fields).flatMap(([key, value]) => {
+        const text = String(value ?? '');
+        return PUBLIC_ERROR_FIELD.test(text) ? [[key, text]] : [];
+    }));
+    return new TaskRoomPublicError(code, validated);
+}
+function taskRoomPublicFailure(error) {
+    const f = error.fields;
+    switch (error.code) {
+        case 'task_confirmation_mismatch': return {
+            legacy: 'confirmation ID must match task ID', kind: 'usage',
+            detail: 'The two task IDs must match.', action: 'Repeat the same task ID twice.',
+        };
+        case 'room_confirmation_mismatch': return {
+            legacy: 'confirmation ID must match room ID', kind: 'usage',
+            detail: 'The two room IDs must match.', action: 'Repeat the same room ID twice.',
+        };
+        case 'template_not_found': return {
+            legacy: `template not found: ${f.template ?? 'requested-template'}`, kind: 'not_found',
+            detail: `The requested template ${f.template ?? ''}`.trim() + ' was not found.',
+            action: 'Run ours-fleet template list and retry with an available template.',
+        };
+        case 'template_mismatch': return {
+            legacy: `template ${f.requested ?? 'requested-template'} does not match room ${f.room ?? 'requested-room'}'s provisioned template ${f.provisioned ?? 'recorded-template'}`,
+            kind: 'state', detail: 'The requested template does not match the room’s provisioned template.',
+            action: 'Use the room’s recorded template or create a new room.',
+        };
+        case 'task_template_drift': return {
+            legacy: `task template snapshot no longer matches ${f.template ?? 'the recorded template'}`,
+            kind: 'state', detail: 'The task template snapshot no longer matches the recorded template.',
+            action: 'Run the matching show and recover commands before retrying.',
+        };
+        case 'task_terminal': return {
+            legacy: `task ${f.task ?? 'requested-task'} is in terminal state '${f.state ?? 'terminal'}'`,
+            kind: 'state', detail: 'The task is already in a terminal state.',
+            action: 'Run ours-fleet task show to inspect the completed task.',
+        };
+        case 'task_terminal_already': return {
+            legacy: `task ${f.task ?? 'requested-task'} is already in terminal state '${f.state ?? 'terminal'}'`,
+            kind: 'state', detail: 'The task is already in a terminal state.',
+            action: 'Run ours-fleet task show to inspect the completed task.',
+        };
+        case 'task_non_resumable': return {
+            legacy: `task ${f.task ?? 'requested-task'} has room ${f.room ?? 'requested-room'} in a non-resumable state — run 'task recover ${f.task ?? 'requested-task'}'`,
+            kind: 'state', detail: 'The task’s room is in a non-resumable state.',
+            action: `Run ours-fleet task recover ${f.task ?? '<id>'}.`,
+        };
+        case 'room_filter': return {
+            legacy: 'room state filter must be active, provisioning, or all', kind: 'usage',
+            detail: 'The room state filter must be active, provisioning, or all.',
+            action: 'Choose one of the supported room state filters.',
+        };
+        case 'room_not_found': return {
+            legacy: `room not found: ${f.room ?? 'requested-room'}`, kind: 'not_found',
+            detail: `Room ${f.room ?? ''}`.trim() + ' was not found.',
+            action: 'Run ours-fleet room list to find a live room ID.',
+        };
+        case 'room_record_not_found': return {
+            legacy: `room not found in Fleet orchestration: ${f.room ?? 'requested-room'}`, kind: 'not_found',
+            detail: `Room ${f.room ?? ''}`.trim() + ' was not found in Fleet orchestration.',
+            action: 'Run ours-fleet room list to find a live room ID.',
+        };
+    }
+}
 function die(e) {
-    const msg = e instanceof Error ? e.message : String(e);
+    const msg = e instanceof TaskRoomPublicError
+        ? taskRoomPublicFailure(e).legacy : e instanceof Error ? e.message : String(e);
     process.stderr.write(`error: ${msg}\n`);
     process.exit(1);
 }
+const TASK_STATE_WORD = '(?:backlog|provisioning|active|review|done|cancelled|failed)';
+const SAFE_ID_WORD = '[A-Za-z0-9_-]{1,128}';
+function isKnownTaskStateMessage(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(`^task ${SAFE_ID_WORD} is not tied to room ${SAFE_ID_WORD}$`, 'u'),
+        new RegExp(`^task ${SAFE_ID_WORD} has no terminal intent$`, 'u'),
+        new RegExp(`^task ${SAFE_ID_WORD} reached terminal state '${TASK_STATE_WORD}' outside its intent$`, 'u'),
+        new RegExp(`^cannot delete a '${TASK_STATE_WORD}' task; only 'done' tasks can be deleted$`, 'u'),
+    ].some(pattern => pattern.test(message));
+}
+function isKnownRoomStateMessage(message) {
+    return [
+        new RegExp(`^room ${SAFE_ID_WORD} history cursor cannot move backward$`, 'u'),
+        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} member .{1,128} (?:launch|briefing|retirement) cannot move backward to [A-Za-z_]+$`, 'u'),
+        new RegExp(`^room ${SAFE_ID_WORD} member .{1,128} launch changed from ${SAFE_ID_WORD} to ${SAFE_ID_WORD}$`, 'u'),
+        new RegExp(`^room ${SAFE_ID_WORD} close cannot move backward to [A-Za-z_]+$`, 'u'),
+    ].some(pattern => pattern.test(message));
+}
+function dieTaskRoom(e) {
+    if (e instanceof TaskRoomPublicError) {
+        const failure = taskRoomPublicFailure(e);
+        const output = renderMarkdownFailure({
+            kind: failure.kind, subject: 'ours-fleet task/room', detail: failure.detail,
+            action: failure.action,
+        });
+        process.stderr.write(`${output}\n`);
+        process.exit(1);
+    }
+    const taskMissing = e instanceof TaskStateError
+        ? /^task not found: ([A-Za-z0-9_-]{1,128})$/u.exec(e.message) : null;
+    const roomMissing = e instanceof RoomStateError
+        ? /^room not found: ([A-Za-z0-9_-]{1,128})$/u.exec(e.message) : null;
+    const notFoundId = taskMissing?.[1] ?? roomMissing?.[1];
+    const state = e instanceof TaskStateError ? isKnownTaskStateMessage(e.message)
+        : e instanceof RoomStateError ? isKnownRoomStateMessage(e.message) : false;
+    const validation = e instanceof ConfigError
+        || (e instanceof TaskStateError
+            && e.message === 'invalid task ID: expected the canonical 17-character lowercase ID');
+    const kind = notFoundId ? 'not_found' : state ? 'state' : validation ? 'usage' : 'unexpected';
+    const output = renderMarkdownFailure({
+        kind,
+        subject: 'ours-fleet task/room',
+        ...(notFoundId ? { detail: `${taskMissing ? 'Task' : 'Room'} ${notFoundId} was not found.` }
+            : state ? { detail: 'The current task or room state does not allow that action.' }
+                : validation ? { detail: 'Fleet configuration is invalid or incomplete.' } : {}),
+        action: notFoundId ? 'Run the matching list command to find a valid ID.'
+            : state ? 'Run the matching show command to inspect the current state.'
+                : validation ? 'Check the command options and configuration, then retry.'
+                    : 'Retry once; if it repeats, run ours-fleet doctor and inspect the role logs.',
+    });
+    process.stderr.write(`${output}\n`);
+    process.exit(1);
+}
+const taskListMarkdown = (tasks, title = 'Tasks') => renderMarkdownList({
+    icon: '📋', title, empty: 'No tasks found.',
+    records: tasks.map(t => `${taskStatus(t.state)} ${markdownCode(t.task_id)} — ${markdownProse(t.title)}`
+        + (t.blocked ? ` — 🚧 Blocked: ${markdownProse(t.blocked.reason)}` : '')),
+});
+const taskActionMarkdown = (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 roomActionMarkdown = (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 PUBLIC_SETTLE_WAIT_MS = 60_000;
+const PUBLIC_SETTLE_POLL_MS = 100;
+const sleep = (ms) => new Promise(resolve => { setTimeout(resolve, ms); });
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function launchTaskSettleWorker(taskId, configPath) {
+    const previousErrorAt = getTask(taskId).terminal_intent?.error_at;
+    try {
+        await launchFleetWorker(['task', '_settle', taskId], `task-settle-${taskId}`, configPath);
+    }
+    catch (error) {
+        await recordTaskTerminalIntentError(taskId, errorText(error), `External settle worker failed to start. Retry task recover ${taskId}.`);
+        throw error;
+    }
+    const deadline = Date.now() + PUBLIC_SETTLE_WAIT_MS;
+    while (Date.now() < deadline) {
+        const task = getTask(taskId);
+        if (task.terminal_intent?.status === 'settled')
+            return { task, timedOut: false };
+        if (task.terminal_intent?.error_at !== previousErrorAt && task.terminal_intent?.error) {
+            throw new TaskStateError(task.terminal_intent.error);
+        }
+        await sleep(PUBLIC_SETTLE_POLL_MS);
+    }
+    return { task: getTask(taskId), timedOut: true };
+}
+async function launchRoomDeleteWorker(roomId, configPath) {
+    const previousErrorAt = getRoomRecord(roomId)?.close?.error_at;
+    try {
+        await launchFleetWorker(['room', '_delete', roomId], `room-delete-${roomId}`, configPath);
+    }
+    catch (error) {
+        await recordManagedRoomCloseError(roomId, errorText(error), `External delete worker failed to start. Retry room delete ${roomId} ${roomId}.`);
+        throw error;
+    }
+    const deadline = Date.now() + PUBLIC_SETTLE_WAIT_MS;
+    while (Date.now() < deadline) {
+        const room = getRoomRecord(roomId);
+        if (!room)
+            return { deleted: true, timedOut: false };
+        if (room.close?.error_at !== previousErrorAt && room.close?.error) {
+            throw new RoomStateError(room.close.error);
+        }
+        await sleep(PUBLIC_SETTLE_POLL_MS);
+    }
+    return { deleted: getRoomRecord(roomId) === undefined, timedOut: true };
+}
 function loadCfg(opts) {
     return loadConfig(opts.configuration);
 }
@@ -18,8 +229,8 @@ function allTemplates(cfg) {
     return cfg.roomTemplates ?? {};
 }
 function coworkFor(cfg) {
-    if (!cfg.rooms || cfg.rooms.provider !== 'cowork')
-        throw new ConfigError('rooms: configure provider: cowork before creating or querying rooms');
+    if (!cfg.rooms)
+        throw new ConfigError('rooms: configuration is required before creating or querying rooms');
     return createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
 }
 function resolveRoomTemplate(cfg, name) {
@@ -30,6 +241,43 @@ function resolveRoomTemplate(cfg, name) {
         throw new Error(`template not found: ${name}`);
     return snapshotTemplate(template);
 }
+function durableTaskRoomTemplate(task, room) {
+    const snapshot = room.template_snapshot;
+    if (!snapshot)
+        throw new Error(`room ${room.room_id} has no durable template snapshot`);
+    const ref = task.template;
+    if (!ref || ref.name !== snapshot.name || ref.version !== snapshot.version
+        || ref.content_hash !== snapshot.content_hash) {
+        throw new Error(`task ${task.task_id} template reference does not match room ${room.room_id}'s durable snapshot`);
+    }
+    return snapshot;
+}
+function roomStartupSections(room) {
+    const sections = [];
+    const definitions = Object.values(room.role_briefings ?? {});
+    if (definitions.length) {
+        sections.push({
+            heading: 'Role briefings',
+            markdownItems: definitions.sort((a, b) => a.role.localeCompare(b.role)).map(definition => `${markdownCode(definition.role)} — version ${markdownCode(definition.version ?? '?')} — ${markdownProse(definition.state)}`),
+        });
+    }
+    if (room.member_seats.length) {
+        sections.push({
+            heading: 'Fleet startup evidence',
+            markdownItems: room.member_seats.map(seat => {
+                const launch = seat.launch?.state ?? 'unrecorded';
+                const briefing = seat.briefing?.state ?? 'unrecorded';
+                return `${markdownCode(seat.role_name)} — ${markdownProse(seat.cowork_role)} — `
+                    + `seat ${markdownProse(seat.seat_state)}, launch ${markdownProse(launch)}, briefing ${markdownProse(briefing)}`
+                    + (seat.briefing?.acknowledgement_message_id ? ' — acknowledgement recorded' : '')
+                    + (seat.briefing?.last_rejected_ack_reason
+                        ? ' — rejected acknowledgement recorded; inspect role logs' : '')
+                    + (seat.launch?.error ? ' — launch failure recorded; inspect role logs' : '');
+            }),
+        });
+    }
+    return sections;
+}
 async function provisionRoom(cfg, input) {
     const rooms = cfg.rooms;
     if (!rooms)
@@ -200,7 +448,7 @@ export function registerTaskCommands(parent, cOpt) {
             if (opts.template) {
                 const t = resolveTemplate(opts.template, allTemplates(cfg));
                 if (!t)
-                    die(new Error(`template not found: ${opts.template}`));
+                    throw taskRoomPublicError('template_not_found', { template: opts.template });
                 const snap = snapshotTemplate(t);
                 templateRef = { name: snap.name, version: snap.version, content_hash: snap.content_hash };
             }
@@ -252,12 +500,15 @@ export function registerTaskCommands(parent, cOpt) {
                 console.log(JSON.stringify({ schema_version: 1, task: record }, null, 2));
                 return;
             }
-            console.log(`Task ${record.task_id} created · ${record.state}`);
-            if (templateRef)
-                console.log(`Template: ${templateRef.name}@${templateRef.version}`);
+            console.log(taskActionMarkdown('Task created', record, [
+                { label: 'Title', value: record.title },
+                ...(templateRef ? [{ label: 'Template', value: `${templateRef.name}@${templateRef.version}`, kind: 'code' }] : []),
+            ]));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     cOpt(taskCmd.command('list'))
@@ -275,17 +526,12 @@ export function registerTaskCommands(parent, cOpt) {
                 console.log(JSON.stringify({ schema_version: 1, tasks }, null, 2));
                 return;
             }
-            if (!tasks.length) {
-                console.log('No tasks.');
-                return;
-            }
-            for (const t of tasks) {
-                const blocked = t.blocked ? ` [BLOCKED: ${t.blocked.reason}]` : '';
-                console.log(`${t.task_id}  ${t.state}${blocked}  ${t.title}`);
-            }
+            console.log(taskListMarkdown(tasks));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     taskCmd.command('show <id>')
@@ -294,35 +540,41 @@ export function registerTaskCommands(parent, cOpt) {
         .action((id, opts) => {
         try {
             const t = getTask(id);
+            const room = t.room_id ? getRoomRecord(t.room_id) : undefined;
             if (opts.json) {
-                console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
+                console.log(JSON.stringify({
+                    schema_version: 1, task: t, orchestration: room ?? null,
+                }, null, 2));
                 return;
             }
-            console.log(`Task: ${t.task_id}`);
-            console.log(`Title: ${t.title}`);
-            console.log(`State: ${t.state}${t.blocked ? ` [BLOCKED: ${t.blocked.reason}]` : ''}`);
-            if (t.template)
-                console.log(`Template: ${t.template.name}@${t.template.version}`);
-            if (t.room_id)
-                console.log(`Room: ${t.room_id}`);
-            if (t.room_identity_cid)
-                console.log(`Room CID: ${t.room_identity_cid}`);
-            if (t.member_roles.length) {
-                console.log('Members:');
-                for (const m of t.member_roles)
-                    console.log(`  ${m.name} (${m.cowork_role}) ${m.identity_cid}`);
-            }
-            console.log(`Origin: ${t.origin.type}`);
-            console.log(`Created: ${t.created_at}`);
-            if (t.started_at)
-                console.log(`Started: ${t.started_at}`);
-            if (t.ended_at)
-                console.log(`Ended: ${t.ended_at}`);
-            if (t.outcome)
-                console.log(`Outcome: ${t.outcome.summary}`);
+            console.log(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' }] : []),
+                    ...(t.room_identity_cid ? [{ label: 'Room CID', value: t.room_identity_cid, kind: 'code' }] : []),
+                    { label: 'Origin', value: t.origin.type },
+                    { label: 'Created', value: t.created_at, kind: 'code' },
+                    ...(t.started_at ? [{ label: 'Started', value: t.started_at, kind: 'code' }] : []),
+                    ...(t.ended_at ? [{ label: 'Ended', value: t.ended_at, kind: 'code' }] : []),
+                    ...(t.outcome ? [{ label: 'Outcome', value: t.outcome.summary, multiline: true }] : []),
+                ],
+                sections: [
+                    ...(t.member_roles.length ? [{
+                            heading: 'Members', markdownItems: t.member_roles.map(m => `${markdownCode(m.name)} — ${markdownProse(m.cowork_role)} — ${markdownCode(m.identity_cid)}`),
+                        }] : []),
+                    ...(room ? roomStartupSections(room) : []),
+                ],
+            }));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     cOpt(taskCmd.command('start <id>'))
@@ -335,7 +587,9 @@ export function registerTaskCommands(parent, cOpt) {
             if (t.template && !t.room_id) {
                 const template = resolveRoomTemplate(cfg, t.template.name);
                 if (!template || template.content_hash !== t.template.content_hash)
-                    throw new Error(`task template snapshot no longer matches ${t.template.name}@${t.template.version}`);
+                    throw taskRoomPublicError('task_template_drift', {
+                        template: `${t.template.name}@${t.template.version}`,
+                    });
                 await provisionRoom(cfg, {
                     name: t.title,
                     goal: t.title,
@@ -352,10 +606,12 @@ export function registerTaskCommands(parent, cOpt) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
             }
-            console.log(`Task ${t.task_id} · provisioning`);
+            console.log(taskActionMarkdown('Task started', t));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     taskCmd.command('block <id>')
@@ -369,10 +625,12 @@ export function registerTaskCommands(parent, cOpt) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
             }
-            console.log(`Task ${t.task_id} · blocked: ${opts.reason}`);
+            console.log(taskActionMarkdown('Task blocked', t, [{ label: 'Reason', value: opts.reason }]));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     taskCmd.command('unblock <id>')
@@ -385,10 +643,12 @@ export function registerTaskCommands(parent, cOpt) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
             }
-            console.log(`Task ${t.task_id} · unblocked`);
+            console.log(taskActionMarkdown('Task unblocked', t));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     taskCmd.command('review <id>')
@@ -401,10 +661,12 @@ export function registerTaskCommands(parent, cOpt) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
             }
-            console.log(`Task ${t.task_id} · review`);
+            console.log(taskActionMarkdown('Task ready for review', t));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     cOpt(taskCmd.command('done <id>'))
@@ -418,29 +680,44 @@ export function registerTaskCommands(parent, cOpt) {
             if (opts.summaryFile)
                 summary = readFileSync(opts.summaryFile, 'utf8');
             const outcome = summary ? { summary } : undefined;
-            const t = completeTask(id, outcome);
-            if (t.room_id) {
-                const cfg = loadCfg(opts);
+            const current = getTask(id);
+            if (TASK_TERMINAL_STATES.includes(current.state))
+                throw new TaskStateError(`task ${id} is already in terminal state '${current.state}'`);
+            if (current.state !== 'review')
+                throw new TaskStateError(`cannot transition from '${current.state}' to 'done'`);
+            let roomId;
+            let cfg;
+            if (current.room_id) {
+                cfg = loadCfg(opts);
                 const shouldClose = cfg.tasks?.close_room_on_done
                     ?? cfg.rooms?.defaults?.close_when_task_done
                     ?? false;
-                if (shouldClose) {
-                    try {
-                        await coworkFor(cfg).closeRoom(t.room_id);
-                        closeRoomRecord(t.room_id);
-                    }
-                    catch { /* room close is best-effort on task done */ }
-                    await cleanupMembers({ roomId: t.room_id, taskId: id }).catch(() => { });
-                }
+                if (shouldClose)
+                    roomId = current.room_id;
             }
+            await acceptTaskTerminalIntent({ taskId: id, kind: 'done', roomId, outcome });
+            const settled = roomId
+                ? await launchTaskSettleWorker(id, opts.configuration)
+                : { task: getTask(id), timedOut: false };
+            const t = settled.task;
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
             }
-            console.log(`Task ${t.task_id} · done`);
+            if (settled.timedOut) {
+                console.log(renderMarkdownFailure({
+                    kind: 'pending', subject: `task done ${id}`,
+                    detail: 'The completion request was accepted and is still being settled.',
+                    action: `Run ours-fleet task recover ${id}.`,
+                }));
+                return;
+            }
+            console.log(taskActionMarkdown('Task completed', t, t.outcome ? [{ label: 'Summary', value: t.outcome.summary, multiline: true }] : []));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     cOpt(taskCmd.command('cancel <id> <confirm-id>'))
@@ -449,25 +726,60 @@ export function registerTaskCommands(parent, cOpt) {
         .action(async (id, confirmId, opts) => {
         try {
             if (id !== confirmId)
-                die(new Error('confirmation ID must match task ID'));
-            const t = cancelTask(id);
-            if (t.room_id) {
-                const cfg = loadCfg(opts);
-                await cleanupMembers({
-                    roomId: t.room_id,
-                    taskId: id,
-                    closeCoworkRoom: true,
-                    cowork: coworkFor(cfg),
-                }).catch(() => { });
-            }
+                throw taskRoomPublicError('task_confirmation_mismatch');
+            const current = getTask(id);
+            if (!TASK_CANCELLABLE_STATES.includes(current.state))
+                throw new TaskStateError(`cannot cancel a '${current.state}' task`);
+            if (current.room_id)
+                loadCfg(opts);
+            await acceptTaskTerminalIntent({
+                taskId: id, kind: 'cancelled', roomId: current.room_id,
+            });
+            const settled = current.room_id
+                ? await launchTaskSettleWorker(id, opts.configuration)
+                : { task: getTask(id), timedOut: false };
+            const t = settled.task;
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
             }
-            console.log(`Task ${t.task_id} · cancelled`);
+            if (settled.timedOut) {
+                console.log(renderMarkdownFailure({
+                    kind: 'pending', subject: `task cancel ${id} ${id}`,
+                    detail: 'The cancellation request was accepted and is still being settled.',
+                    action: `Run ours-fleet task recover ${id}.`,
+                }));
+                return;
+            }
+            console.log(taskActionMarkdown('Task cancelled', t));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
+    cOpt(taskCmd.command('delete <id> <confirm-id>'))
+        .description('delete a done task from the backlog (requires ID twice for confirmation)')
+        .option('--json', 'JSON output')
+        .action((id, confirmId, opts) => {
+        try {
+            if (id !== confirmId)
+                throw taskRoomPublicError('task_confirmation_mismatch');
+            const deleted = deleteTask(id);
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, task_id: id, deleted }, null, 2));
+                return;
+            }
+            console.log(renderMarkdownResult({
+                icon: '🗑️', title: deleted ? 'Task deleted' : 'Task already absent',
+                fields: [{ label: 'ID', value: id, kind: 'code' }],
+            }));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     cOpt(taskCmd.command('recover <id>'))
@@ -476,13 +788,22 @@ export function registerTaskCommands(parent, cOpt) {
         .action(async (id, opts) => {
         try {
             const cfg = loadCfg(opts);
-            const t = getTask(id);
-            const room = t.room_id ? getRoomRecord(t.room_id) : undefined;
+            let t = getTask(id);
+            let terminalTimedOut = false;
+            if (t.terminal_intent?.status === 'pending') {
+                const settled = await launchTaskSettleWorker(id, opts.configuration);
+                t = settled.task;
+                terminalTimedOut = settled.timedOut;
+            }
+            let room = t.room_id ? getRoomRecord(t.room_id) : undefined;
             const result = {
                 task: t,
                 room: room ?? null,
                 recovery_actions: [],
             };
+            if (terminalTimedOut) {
+                result.recovery_actions.push(`Terminal intent remains pending — retry task recover ${id}`);
+            }
             if (t.state === 'provisioning' && room) {
                 if (room.provisioning_detail === 'waiting_cowork')
                     result.recovery_actions.push('Cowork management socket unreachable — check ours-cowork service');
@@ -492,9 +813,14 @@ export function registerTaskCommands(parent, cOpt) {
                     result.recovery_actions.push('Owner CID mismatch — verify rooms.owner.expected_cid matches Messenger identity');
                 if (room.provisioning_detail === 'member_failed')
                     result.recovery_actions.push(`Member creation failed at saga step ${room.saga.step_index} — inspect and retry`);
-                const resumable = ['create_members', 'join_role_groups', 'wait_seats', 'launch_work', 'activate'];
+                if (room.provisioning_detail === 'waiting_briefing_acks')
+                    result.recovery_actions.push('Members are not ready — inspect per-seat briefing and ACK evidence, then retry recovery');
+                if (room.provisioning_detail === 'briefing_delivery_failed')
+                    result.recovery_actions.push('Cowork briefing relay failed terminally — replace the seat or use a Cowork-supported redelivery');
+                const resumable = ['create_members', 'configure_briefings', 'join_role_groups', 'wait_seats',
+                    'launch_work', 'wait_briefing_acks', 'activate'];
                 if (resumable.includes(room.saga.phase)) {
-                    const template = t.template ? resolveRoomTemplate(cfg, t.template.name) : undefined;
+                    const template = durableTaskRoomTemplate(t, room);
                     if (template) {
                         try {
                             await provisionMembers({
@@ -507,7 +833,11 @@ export function registerTaskCommands(parent, cOpt) {
                                 brief: t.brief,
                                 goal: t.title,
                             });
-                            result.recovery_actions.push('Provisioning resumed successfully');
+                            t = getTask(t.task_id);
+                            room = getRoomRecord(room.room_id);
+                            result.task = t;
+                            result.room = room ?? null;
+                            result.recovery_actions = ['Provisioning resumed successfully'];
                         }
                         catch (error) {
                             result.recovery_actions.push(`Resume failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -519,20 +849,46 @@ export function registerTaskCommands(parent, cOpt) {
                 console.log(JSON.stringify({ schema_version: 1, ...result }, null, 2));
                 return;
             }
-            console.log(`Task ${t.task_id} · ${t.state}`);
-            if (room)
-                console.log(`Room ${room.room_id} · ${room.state} · saga: ${room.saga.phase}`);
-            if (result.recovery_actions.length) {
-                console.log('Recovery actions:');
-                for (const a of result.recovery_actions)
-                    console.log(`  - ${a}`);
-            }
-            else {
-                console.log('No automated recovery actions available.');
+            console.log(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: result.recovery_actions.length
+                    ? [{ heading: 'Next steps', items: result.recovery_actions }]
+                    : [{ heading: 'Result', items: ['No automated recovery action is available.'] }],
+            }));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
+    cOpt(taskCmd.command('_settle <id>', { hidden: true }))
+        .description('internal: settle a previously accepted task terminal intent')
+        .option('--json', 'JSON output')
+        .action(async (id, opts) => {
+        try {
+            const cfg = loadCfg(opts);
+            const t = await settleTaskTerminalIntent({ taskId: id, cowork: coworkFor(cfg) });
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
+                return;
             }
+            console.log(taskActionMarkdown('Task terminal action settled', t));
         }
         catch (e) {
-            die(e);
+            await recordTaskTerminalIntentError(id, errorText(e), `External settle worker failed. Retry task recover ${id}.`).catch(() => { });
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     cOpt(taskCmd.command('work <id>'))
@@ -544,46 +900,70 @@ export function registerTaskCommands(parent, cOpt) {
             const cfg = loadCfg(opts);
             let t = getTask(id);
             if (TASK_TERMINAL_STATES.includes(t.state))
-                die(new Error(`task ${id} is in terminal state '${t.state}'`));
+                throw taskRoomPublicError('task_terminal', { task: id, state: t.state });
             if (t.state === 'active' && t.room_id) {
                 // An explicit --template must agree with the room the task already
                 // runs in; a conflicting override is an error, not a silent no-op.
                 if (opts.template) {
                     const override = resolveTemplate(opts.template, allTemplates(cfg));
                     if (!override)
-                        die(new Error(`template not found: ${opts.template}`));
+                        throw taskRoomPublicError('template_not_found', { template: opts.template });
                     const overrideSnap = snapshotTemplate(override);
                     const roomSnap = getRoomRecord(t.room_id)?.template_snapshot ?? t.template;
                     if (roomSnap && (roomSnap.name !== overrideSnap.name || roomSnap.content_hash !== overrideSnap.content_hash))
-                        die(new Error(`template ${overrideSnap.name}@${overrideSnap.version} does not match room ${t.room_id}'s provisioned template ${roomSnap.name}@${roomSnap.version}`));
+                        throw taskRoomPublicError('template_mismatch', {
+                            requested: `${overrideSnap.name}@${overrideSnap.version}`, room: t.room_id,
+                            provisioned: `${roomSnap.name}@${roomSnap.version}`,
+                        });
                 }
                 if (opts.json) {
                     console.log(JSON.stringify({ schema_version: 1, task: t, status: 'already_active' }, null, 2));
                     return;
                 }
-                console.log('Task already has an active room');
+                console.log(taskActionMarkdown('Task already active', t, t.room_id ? [{ label: 'Room', value: t.room_id, kind: 'code' }] : []));
                 return;
             }
             // Select and validate the template snapshot before any state change or
             // provisioning. An explicit --template re-pins the task; a stored ref
             // must still match its snapshot (same contract as `task start`).
+            const existingRoom = t.room_id ? getRoomRecord(t.room_id) : undefined;
+            const durableSnapshot = existingRoom ? durableTaskRoomTemplate(t, existingRoom) : undefined;
             const templateName = opts.template
+                ?? durableSnapshot?.name
                 ?? t.template?.name
                 ?? cfg.tasks?.default_room_template
                 ?? cfg.rooms?.defaults?.template
                 ?? 'single';
-            const resolved = resolveTemplate(templateName, allTemplates(cfg));
-            if (!resolved)
-                die(new Error(`template not found: ${templateName}`));
-            const snap = snapshotTemplate(resolved);
+            const resolved = durableSnapshot && !opts.template
+                ? undefined : resolveTemplate(templateName, allTemplates(cfg));
+            if (!durableSnapshot && !resolved)
+                throw taskRoomPublicError('template_not_found', { template: templateName });
+            if (opts.template && !resolved)
+                throw taskRoomPublicError('template_not_found', { template: templateName });
+            if (durableSnapshot && resolved) {
+                const requested = snapshotTemplate(resolved);
+                if (requested.name !== durableSnapshot.name
+                    || requested.content_hash !== durableSnapshot.content_hash) {
+                    throw taskRoomPublicError('template_mismatch', {
+                        requested: `${requested.name}@${requested.version}`, room: existingRoom.room_id,
+                        provisioned: `${durableSnapshot.name}@${durableSnapshot.version}`,
+                    });
+                }
+            }
+            const snap = durableSnapshot ?? snapshotTemplate(resolved);
             if (!opts.template && t.template && snap.content_hash !== t.template.content_hash)
-                die(new Error(`task template snapshot no longer matches ${t.template.name}@${t.template.version}`));
+                throw taskRoomPublicError('task_template_drift', {
+                    template: `${t.template.name}@${t.template.version}`,
+                });
             // A provisioned room is pinned to its snapshot: never resume or re-pin
             // an existing room under a different template.
             if (t.room_id) {
-                const roomSnap = getRoomRecord(t.room_id)?.template_snapshot ?? t.template;
+                const roomSnap = getRoomRecord(t.room_id)?.template_snapshot;
                 if (roomSnap && (roomSnap.name !== snap.name || roomSnap.content_hash !== snap.content_hash))
-                    die(new Error(`template ${snap.name}@${snap.version} does not match room ${t.room_id}'s provisioned template ${roomSnap.name}@${roomSnap.version}`));
+                    throw taskRoomPublicError('template_mismatch', {
+                        requested: `${snap.name}@${snap.version}`, room: t.room_id,
+                        provisioned: `${roomSnap.name}@${roomSnap.version}`,
+                    });
             }
             let templateRef = t.template;
             if (!templateRef || templateRef.name !== snap.name || templateRef.content_hash !== snap.content_hash) {
@@ -618,7 +998,8 @@ export function registerTaskCommands(parent, cOpt) {
                 // The task already has a room mid-provisioning (e.g. seats were still
                 // pending on the last run). Resume it exactly as `task recover` does.
                 const room = getRoomRecord(t.room_id);
-                const resumable = ['create_members', 'join_role_groups', 'wait_seats', 'launch_work', 'activate'];
+                const resumable = ['create_members', 'configure_briefings', 'join_role_groups', 'wait_seats',
+                    'launch_work', 'wait_briefing_acks', 'activate'];
                 if (room && resumable.includes(room.saga.phase)) {
                     try {
                         await provisionMembers({
@@ -641,26 +1022,30 @@ export function registerTaskCommands(parent, cOpt) {
                     t = getTask(t.task_id);
                 }
                 else {
-                    die(new Error(`task ${id} has room ${t.room_id} in a non-resumable state — run 'task recover ${id}'`));
+                    throw taskRoomPublicError('task_non_resumable', { task: id, room: t.room_id });
                 }
             }
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
             }
-            console.log(`Task ${t.task_id} · ${t.state}`);
-            if (templateRef)
-                console.log(`Template: ${templateRef.name}@${templateRef.version}`);
-            if (t.room_id)
-                console.log(`Room: ${t.room_id}`);
-            if (t.member_roles.length) {
-                console.log('Agents:');
-                for (const m of t.member_roles)
-                    console.log(`  ${m.name} (${m.cowork_role})`);
-            }
+            console.log(renderMarkdownResult({
+                icon: '🛠️', title: 'Task work ready',
+                fields: [
+                    { label: 'ID', value: t.task_id, kind: 'code' },
+                    { label: 'Status', value: taskStatus(t.state), kind: 'markdown' },
+                    ...(templateRef ? [{ label: 'Template', value: `${templateRef.name}@${templateRef.version}`, kind: 'code' }] : []),
+                    ...(t.room_id ? [{ label: 'Room', value: t.room_id, kind: 'code' }] : []),
+                ],
+                sections: t.member_roles.length ? [{
+                        heading: 'Agents', markdownItems: t.member_roles.map(m => `${markdownCode(m.name)} — ${markdownProse(m.cowork_role)}`),
+                    }] : [],
+            }));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     cOpt(taskCmd.command('finish <id>'))
@@ -676,31 +1061,35 @@ export function registerTaskCommands(parent, cOpt) {
             const outcome = summary ? { summary } : undefined;
             let t = getTask(id);
             if (TASK_TERMINAL_STATES.includes(t.state))
-                die(new Error(`task ${id} is already in terminal state '${t.state}'`));
+                throw taskRoomPublicError('task_terminal_already', { task: id, state: t.state });
             if (t.state === 'active') {
                 reviewTask(id);
             }
-            t = completeTask(id, outcome);
-            if (t.room_id) {
-                const cfg = loadCfg(opts);
-                try {
-                    await cleanupMembers({
-                        roomId: t.room_id,
-                        taskId: id,
-                        closeCoworkRoom: true,
-                        cowork: coworkFor(cfg),
-                    });
-                }
-                catch { /* room cleanup is best-effort */ }
-            }
+            if (t.room_id)
+                loadCfg(opts); // validate configuration before durable acceptance
+            await acceptTaskTerminalIntent({ taskId: id, kind: 'done', roomId: t.room_id, outcome });
+            const settled = t.room_id
+                ? await launchTaskSettleWorker(id, opts.configuration)
+                : { task: getTask(id), timedOut: false };
+            t = settled.task;
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
             }
-            console.log(`Task ${t.task_id} · done`);
+            if (settled.timedOut) {
+                console.log(renderMarkdownFailure({
+                    kind: 'pending', subject: `task finish ${id}`,
+                    detail: 'The finish request was accepted and is still being settled.',
+                    action: `Run ours-fleet task recover ${id}.`,
+                }));
+                return;
+            }
+            console.log(taskActionMarkdown('Task finished', t, t.outcome ? [{ label: 'Summary', value: t.outcome.summary, multiline: true }] : []));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
 }
@@ -724,7 +1113,7 @@ export function registerRoomCommands(parent, cOpt) {
             if (opts.template) {
                 const t = resolveTemplate(opts.template, allTemplates(cfg));
                 if (!t)
-                    die(new Error(`template not found: ${opts.template}`));
+                    throw taskRoomPublicError('template_not_found', { template: opts.template });
                 templateSnapshot = snapshotTemplate(t);
             }
             const record = await provisionRoom(cfg, {
@@ -737,43 +1126,54 @@ export function registerRoomCommands(parent, cOpt) {
                 console.log(JSON.stringify({ schema_version: 1, room: record }, null, 2));
                 return;
             }
-            console.log(`Room ${record.room_id} created · ${record.state}`);
-            if (templateSnapshot)
-                console.log(`Template: ${templateSnapshot.name}@${templateSnapshot.version}`);
+            console.log(roomActionMarkdown('Room created', record, [
+                { label: 'Name', value: record.room_name },
+                ...(templateSnapshot ? [{ label: 'Template', value: `${templateSnapshot.name}@${templateSnapshot.version}`, kind: 'code' }] : []),
+            ]));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     cOpt(roomCmd.command('list'))
         .description('list rooms')
-        .option('--state <state>', 'filter by state (active|provisioning|closing|closed|all)')
+        .option('--state <state>', 'filter live rooms by state (active|provisioning|all)')
         .option('--json', 'JSON output')
         .action(async (opts) => {
         try {
             const cfg = loadCfg(opts);
-            let stateFilter;
-            if (opts.state && opts.state !== 'all') {
-                stateFilter = opts.state;
-            }
+            if (opts.state && !['active', 'provisioning', 'all'].includes(opts.state))
+                throw taskRoomPublicError('room_filter');
+            const stateFilter = opts.state === 'active' || opts.state === 'provisioning'
+                ? opts.state : undefined;
+            const adapter = coworkFor(cfg);
+            await deleteLegacyClosedRooms({ cowork: adapter });
             const local = new Map(listRoomRecords().map(room => [room.room_id, room]));
-            const coworkRooms = await coworkFor(cfg).listRooms();
+            const coworkRooms = await adapter.listRooms();
             const rooms = coworkRooms
+                .filter(room => room.state === 'active' || room.state === 'provisioning')
+                .filter(room => {
+                const tracked = local.get(room.room_id);
+                return !tracked || tracked.state === 'active' || tracked.state === 'provisioning';
+            })
                 .filter(room => !stateFilter || room.state === stateFilter)
                 .map(room => ({ ...room, orchestration: local.get(room.room_id) ?? null }));
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, rooms }, null, 2));
                 return;
             }
-            if (!rooms.length) {
-                console.log('No rooms.');
-                return;
-            }
-            for (const r of rooms)
-                console.log(`${r.room_id}  ${r.state}  ${r.room_name}${r.orchestration?.task_id ? ` (task: ${r.orchestration.task_id})` : ''}`);
+            console.log(renderMarkdownList({
+                icon: '🏠', title: 'Rooms', empty: 'No rooms found.',
+                records: rooms.map(r => `${roomStatus(r.state)} ${markdownCode(r.room_id)} — ${markdownProse(r.room_name)}`
+                    + (r.orchestration?.task_id ? ` — Task ${markdownCode(r.orchestration.task_id)}` : '')),
+            }));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     cOpt(roomCmd.command('show <id>'))
@@ -782,36 +1182,42 @@ export function registerRoomCommands(parent, cOpt) {
         .action(async (id, opts) => {
         try {
             const cfg = loadCfg(opts);
+            const tracked = getRoomRecord(id);
+            if (tracked?.state === 'closing' || tracked?.state === 'closed')
+                throw taskRoomPublicError('room_not_found', { room: id });
             const cowork = await coworkFor(cfg).getRoom(id);
-            if (!cowork)
-                die(new Error(`room not found: ${id}`));
-            const r = getRoomRecord(id);
+            if (!cowork || cowork.state === 'closing' || cowork.state === 'closed')
+                throw taskRoomPublicError('room_not_found', { room: id });
+            const r = tracked;
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room: cowork, orchestration: r ?? null }, null, 2));
                 return;
             }
-            console.log(`Room: ${cowork.room_id}`);
-            console.log(`Name: ${cowork.room_name}`);
-            console.log(`State: ${cowork.state}`);
-            console.log(`Identity CID: ${cowork.identity_cid}`);
-            if (r?.task_id)
-                console.log(`Task: ${r.task_id}`);
-            if (r)
-                console.log(`Saga: ${r.saga.phase} (step ${r.saga.step_index})`);
-            if (r?.provisioning_detail)
-                console.log(`Detail: ${r.provisioning_detail}`);
-            if (r?.saga.error)
-                console.log(`Error: ${r.saga.error}`);
-            if (cowork.seats.length) {
-                console.log('Members:');
-                for (const s of cowork.seats)
-                    console.log(`  ${s.identity_cid} (${s.role}) ${s.seat_state}`);
-            }
-            if (r)
-                console.log(`Tracked by Fleet since: ${r.created_at}`);
+            console.log(renderMarkdownResult({
+                icon: '🏠', title: 'Room details',
+                fields: [
+                    { label: 'ID', value: cowork.room_id, kind: 'code' },
+                    { label: 'Name', value: cowork.room_name },
+                    { label: 'Status', value: roomStatus(cowork.state), kind: 'markdown' },
+                    { label: 'Identity CID', value: cowork.identity_cid, kind: 'code' },
+                    ...(r?.task_id ? [{ label: 'Task', value: r.task_id, kind: 'code' }] : []),
+                    ...(r ? [{ label: 'Saga', value: `${r.saga.phase} (step ${r.saga.step_index})` }] : []),
+                    ...(r?.provisioning_detail ? [{ label: 'Detail', value: r.provisioning_detail }] : []),
+                    ...(r?.saga.error ? [{ label: 'Last error', value: 'Provisioning failure recorded; inspect role logs.' }] : []),
+                    ...(r ? [{ label: 'Tracked since', value: r.created_at, kind: 'code' }] : []),
+                ],
+                sections: [
+                    ...(cowork.seats.length ? [{
+                            heading: 'Members', markdownItems: cowork.seats.map(s => `${markdownCode(s.identity_cid)} — ${markdownProse(s.role)} — ${markdownProse(s.seat_state)}`),
+                        }] : []),
+                    ...(r ? roomStartupSections(r) : []),
+                ],
+            }));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     cOpt(roomCmd.command('open <id>'))
@@ -820,19 +1226,30 @@ export function registerRoomCommands(parent, cOpt) {
         .action(async (id, opts) => {
         try {
             const cfg = loadCfg(opts);
+            const tracked = getRoomRecord(id);
+            if (tracked?.state === 'closing' || tracked?.state === 'closed')
+                throw taskRoomPublicError('room_not_found', { room: id });
             const room = await coworkFor(cfg).getRoom(id);
-            if (!room)
-                die(new Error(`room not found: ${id}`));
+            if (!room || room.state === 'closing' || room.state === 'closed')
+                throw taskRoomPublicError('room_not_found', { room: id });
             const url = `http://localhost:4460/room/${id}`;
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room_id: id, url, room_name: room.room_name }, null, 2));
                 return;
             }
-            console.log(`Room ${id} — ${room.room_name}`);
-            console.log(`Local console: ${url}`);
+            console.log(renderMarkdownResult({
+                icon: '🏠', title: 'Room console',
+                fields: [
+                    { label: 'Room', value: id, kind: 'code' },
+                    { label: 'Name', value: room.room_name },
+                    { label: 'Local console', value: url, kind: 'code' },
+                ],
+            }));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
     cOpt(roomCmd.command('members <id>'))
@@ -842,7 +1259,13 @@ export function registerRoomCommands(parent, cOpt) {
         try {
             const cfg = loadCfg(opts);
             const r = getRoomRecord(id);
-            const members = await coworkFor(cfg).getSeats(id);
+            if (r?.state === 'closing' || r?.state === 'closed')
+                throw taskRoomPublicError('room_not_found', { room: id });
+            const adapter = coworkFor(cfg);
+            const room = await adapter.getRoom(id);
+            if (!room || room.state === 'closing' || room.state === 'closed')
+                throw taskRoomPublicError('room_not_found', { room: id });
+            const members = await adapter.getSeats(id);
             if (opts.json) {
                 console.log(JSON.stringify({
                     schema_version: 1,
@@ -852,41 +1275,67 @@ export function registerRoomCommands(parent, cOpt) {
                 }, null, 2));
                 return;
             }
-            console.log(`Room ${id}${r ? ` — ${r.room_name}` : ''}`);
-            if (r?.owner_seat_cid)
-                console.log(`Owner: ${r.owner_seat_cid}`);
-            if (!members.length) {
-                console.log('No members.');
-                return;
-            }
-            for (const s of members)
-                console.log(`  ${s.identity_cid} (${s.role}) ${s.seat_state}`);
+            console.log(renderMarkdownResult({
+                icon: '👥', title: 'Room members',
+                fields: [
+                    { label: 'Room', value: id, kind: 'code' },
+                    ...(r ? [{ label: 'Name', value: r.room_name }] : []),
+                    ...(r?.owner_seat_cid ? [{ label: 'Owner', value: r.owner_seat_cid, kind: 'code' }] : []),
+                ],
+                sections: [{
+                        heading: 'Members',
+                        ...(members.length ? { markdownItems: members.map(s => `${markdownCode(s.identity_cid)} — ${markdownProse(s.role)} — ${markdownProse(s.seat_state)}`) }
+                            : { items: ['No members found.'] }),
+                    }],
+            }));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
-    cOpt(roomCmd.command('close <id> <confirm-id>'))
-        .description('close a room (requires ID twice for confirmation)')
-        .option('--json', 'JSON output')
-        .action(async (id, confirmId, opts) => {
+    const deleteAction = async (id, confirmId, opts) => {
         try {
             if (id !== confirmId)
-                die(new Error('confirmation ID must match room ID'));
-            const cfg = loadCfg(opts);
-            await coworkFor(cfg).closeRoom(id);
+                throw taskRoomPublicError('room_confirmation_mismatch');
+            coworkFor(loadCfg(opts));
             const existing = getRoomRecord(id);
-            const r = existing ? closeRoomRecord(id) : undefined;
+            if (!existing)
+                throw taskRoomPublicError('room_record_not_found', { room: id });
+            await acceptManagedRoomClose(id);
+            const settled = await launchRoomDeleteWorker(id, opts.configuration);
             if (opts.json) {
-                console.log(JSON.stringify({ schema_version: 1, room_id: id, state: 'closed', orchestration: r ?? null }, null, 2));
+                console.log(JSON.stringify({ schema_version: 1, room_id: id, deleted: settled.deleted }, null, 2));
                 return;
             }
-            console.log(`Room ${id} · closed`);
+            if (settled.timedOut) {
+                console.log(renderMarkdownFailure({
+                    kind: 'pending', subject: `room delete ${id} ${id}`,
+                    detail: 'The deletion request was accepted and is still being settled.',
+                    action: `Run ours-fleet room delete ${id} ${id} or room recover ${id}.`,
+                }));
+                return;
+            }
+            console.log(renderMarkdownResult({
+                icon: '🗑️', title: 'Room deleted',
+                fields: [{ label: 'ID', value: id, kind: 'code' }],
+            }));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
-    });
+    };
+    cOpt(roomCmd.command('delete <id> <confirm-id>'))
+        .description('delete a room (requires ID twice for confirmation)')
+        .option('--json', 'JSON output')
+        .action(deleteAction);
+    cOpt(roomCmd.command('close <id> <confirm-id>'))
+        .description('deprecated alias for room delete (requires ID twice for confirmation)')
+        .option('--json', 'JSON output')
+        .action(deleteAction);
     cOpt(roomCmd.command('recover <id>'))
         .description('attempt to recover a stuck room')
         .option('--json', 'JSON output')
@@ -894,8 +1343,32 @@ export function registerRoomCommands(parent, cOpt) {
         try {
             const cfg = loadCfg(opts);
             const adapter = coworkFor(cfg);
-            const cowork = await adapter.recoverRoom(id);
             let r = getRoomRecord(id);
+            if (r?.state === 'closing' || r?.state === 'closed') {
+                const settled = await launchRoomDeleteWorker(id, opts.configuration);
+                if (opts.json) {
+                    console.log(JSON.stringify({
+                        schema_version: 1, room: null, orchestration: null,
+                        recovery_actions: [settled.timedOut
+                                ? `Deletion remains pending — retry room delete ${id} ${id}`
+                                : 'Deletion completed successfully'],
+                    }, null, 2));
+                    return;
+                }
+                console.log(renderMarkdownResult({
+                    icon: settled.timedOut ? '⏳' : '🗑️',
+                    title: settled.timedOut ? 'Room deletion pending' : 'Room deleted',
+                    fields: [{ label: 'ID', value: id, kind: 'code' }],
+                    sections: [{ heading: 'Next step', items: [
+                                settled.timedOut
+                                    ? `Run ours-fleet room delete ${id} ${id} or room recover ${id} again.`
+                                    : 'No recovery action is needed.',
+                            ] }],
+                }));
+                return;
+            }
+            const cowork = await adapter.recoverRoom(id);
+            r = getRoomRecord(id);
             if (r && !r.owner_seat_cid
                 && (r.provisioning_detail === 'waiting_owner_invite'
                     || r.provisioning_detail === 'owner_cid_mismatch')) {
@@ -917,18 +1390,25 @@ export function registerRoomCommands(parent, cOpt) {
             }
             const actions = [];
             if (r?.saga.error)
-                actions.push(`Last error: ${r.saga.error}`);
+                actions.push('A provisioning failure is recorded; inspect role logs for diagnostics.');
             if (r?.saga.recovery_hint)
-                actions.push(r.saga.recovery_hint);
+                actions.push('Recovery guidance is recorded; inspect role logs for diagnostics.');
             if (r?.provisioning_detail === 'waiting_cowork')
                 actions.push('Check ours-cowork service status');
             if (r?.provisioning_detail === 'waiting_owner_invite')
                 actions.push('Rotate rooms.owner.public_invite in config, then re-run recover');
+            if (r?.provisioning_detail === 'waiting_briefing_acks')
+                actions.push('Inspect per-seat briefing and ACK evidence, then re-run recover');
+            if (r?.provisioning_detail === 'briefing_delivery_failed')
+                actions.push('Replace the failed seat or use a Cowork-supported briefing redelivery');
             if (r && r.state === 'provisioning') {
-                const resumable = ['create_members', 'join_role_groups', 'wait_seats', 'launch_work', 'activate'];
+                const resumable = ['create_members', 'configure_briefings', 'join_role_groups', 'wait_seats',
+                    'launch_work', 'wait_briefing_acks', 'activate'];
                 if (resumable.includes(r.saga.phase) && r.template_snapshot) {
                     try {
-                        const template = resolveRoomTemplate(cfg, r.template_snapshot.name);
+                        const template = r.task_id
+                            ? durableTaskRoomTemplate(getTask(r.task_id), r)
+                            : r.template_snapshot;
                         if (template) {
                             await provisionMembers({
                                 cfg,
@@ -940,7 +1420,7 @@ export function registerRoomCommands(parent, cOpt) {
                                 goal: r.room_name,
                             });
                             r = getRoomRecord(id);
-                            actions.push('Provisioning resumed successfully');
+                            actions.splice(0, actions.length, 'Provisioning resumed successfully');
                         }
                     }
                     catch (error) {
@@ -952,18 +1432,50 @@ export function registerRoomCommands(parent, cOpt) {
                 console.log(JSON.stringify({ schema_version: 1, room: cowork, orchestration: r ?? null, recovery_actions: actions }, null, 2));
                 return;
             }
-            console.log(`Room ${cowork.room_id} · ${cowork.state}${r ? ` · saga: ${r.saga.phase}` : ''}`);
-            if (actions.length) {
-                console.log('Recovery:');
-                for (const a of actions)
-                    console.log(`  - ${a}`);
-            }
-            else {
-                console.log('No recovery actions needed.');
-            }
+            console.log(renderMarkdownResult({
+                icon: '🛟', title: 'Room recovery',
+                fields: [
+                    { label: 'Room', value: cowork.room_id, kind: 'code' },
+                    { label: 'Status', value: roomStatus(cowork.state), kind: 'markdown' },
+                    ...(r ? [{ label: 'Saga', value: r.saga.phase, kind: 'code' }] : []),
+                ],
+                sections: actions.length
+                    ? [{ heading: 'Next steps', items: actions }]
+                    : [{ heading: 'Result', items: ['No recovery action is needed.'] }],
+            }));
         }
         catch (e) {
-            die(e);
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
         }
     });
+    const internalDeleteAction = async (id, opts) => {
+        try {
+            const cfg = loadCfg(opts);
+            const result = await deleteManagedRoom({ roomId: id, cowork: coworkFor(cfg) });
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, ...result }, null, 2));
+                return;
+            }
+            console.log(renderMarkdownResult({
+                icon: '🗑️', title: 'Room deleted',
+                fields: [{ label: 'ID', value: id, kind: 'code' }],
+            }));
+        }
+        catch (e) {
+            await recordManagedRoomCloseError(id, errorText(e), `External delete worker failed. Retry room delete ${id} ${id}.`).catch(() => { });
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    };
+    cOpt(roomCmd.command('_delete <id>', { hidden: true }))
+        .description('internal: settle an accepted room deletion')
+        .option('--json', 'JSON output')
+        .action(internalDeleteAction);
+    cOpt(roomCmd.command('_close <id>', { hidden: true }))
+        .description('deprecated internal alias for room _delete')
+        .option('--json', 'JSON output')
+        .action(internalDeleteAction);
 }