@ours.network/fleet 1.0.3 → 1.0.5

package/dist/rooms-tasks/cli.js

@@ -1,15 +1,14 @@
 import { readFileSync } from 'node:fs';
 import { loadConfig, ConfigError } from '../config.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, 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_CANCELLABLE_STATES, TASK_TERMINAL_STATES } from './types.js';
+import { resolveTemplate, snapshotTemplate, } from './templates.js';
+import { getTask, activateTask, TaskStateError, } from './task-state.js';
+import { createRoomRecord, getRoomRecord, advanceSaga, setOwnerSeat, setSagaError, activateRoom, RoomStateError, } from './room-state.js';
+import { createCoworkAdapter, CoworkProtocolError } from './cowork-adapter.js';
 import { markdownCode, markdownProse, renderMarkdownFailure, renderMarkdownList, renderMarkdownResult, roomStatus, taskStatus, } from './markdown.js';
+import { TaskRoomApplicationError, TaskRoomApplicationService } from '../application/task-room-service.js';
+import { TaskListError } from './task-lists.js';
 class TaskRoomPublicError extends Error {
     code;
     fields;
@@ -119,6 +118,8 @@ function isKnownRoomStateMessage(message) {
     ].some(pattern => pattern.test(message));
 }
 function dieTaskRoom(e) {
+    if (e instanceof TaskRoomApplicationError)
+        e = taskRoomPublicError(e.code, e.fields);
     if (e instanceof TaskRoomPublicError) {
         const failure = taskRoomPublicFailure(e);
         const output = renderMarkdownFailure({
@@ -128,6 +129,21 @@ function dieTaskRoom(e) {
         process.stderr.write(`${output}\n`);
         process.exit(1);
     }
+    if (e instanceof TaskListError) {
+        const notFound = e.code === 'list_not_found';
+        const conflict = ['duplicate_name', 'reserved_name', 'default_immutable',
+            'destination_required', 'same_destination'].includes(e.code);
+        const output = renderMarkdownFailure({
+            kind: notFound ? 'not_found' : conflict ? 'state' : 'usage',
+            subject: 'ours-fleet task list',
+            detail: e.message,
+            action: notFound ? 'Run ours-fleet task lists to find a valid list.'
+                : conflict ? 'Choose a different list name or an explicit valid destination.'
+                    : 'Use a valid NFC-normalized name of at most 64 Unicode code points.',
+        });
+        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
@@ -156,6 +172,7 @@ function dieTaskRoom(e) {
 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)}`
+        + ` — List ${markdownCode(t.list_name ?? 'default')}`
         + (t.blocked ? ` — 🚧 Blocked: ${markdownProse(t.blocked.reason)}` : '')),
 });
 const taskActionMarkdown = (title, task, fields = []) => renderMarkdownResult({
@@ -163,6 +180,7 @@ const taskActionMarkdown = (title, task, fields = []) => renderMarkdownResult({
     fields: [
         { label: 'ID', value: task.task_id, kind: 'code' },
         { label: 'Status', value: taskStatus(task.state), kind: 'markdown' },
+        { label: 'List', value: task.list_name ?? 'default', kind: 'code' },
         ...fields,
     ],
 });
@@ -186,7 +204,10 @@ async function launchTaskSettleWorker(taskId, configPath) {
         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}.`);
+        await taskRoomService(configPath).recordSettlementError({
+            actor: { kind: 'local_control', surface: 'cli' }, taskId, error: errorText(error),
+            recoveryHint: `External settle worker failed to start. Retry task recover ${taskId}.`,
+        });
         throw error;
     }
     const deadline = Date.now() + PUBLIC_SETTLE_WAIT_MS;
@@ -207,7 +228,10 @@ async function launchRoomDeleteWorker(roomId, configPath) {
         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}.`);
+        await taskRoomService(configPath).recordRoomSettlementError({
+            actor: { kind: 'local_control', surface: 'cli' }, roomId, error: errorText(error),
+            recoveryHint: `External delete worker failed to start. Retry room delete ${roomId} ${roomId}.`,
+        });
         throw error;
     }
     const deadline = Date.now() + PUBLIC_SETTLE_WAIT_MS;
@@ -225,6 +249,14 @@ async function launchRoomDeleteWorker(roomId, configPath) {
 function loadCfg(opts) {
     return loadConfig(opts.configuration);
 }
+function taskRoomService(configuration) {
+    return new TaskRoomApplicationService(configuration, {
+        loadConfiguration: loadConfig,
+        cowork: coworkFor,
+        binPath: getBinPath,
+        provisionMembers,
+    });
+}
 function allTemplates(cfg) {
     return cfg.roomTemplates ?? {};
 }
@@ -344,8 +376,7 @@ export function registerTemplateCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((opts) => {
         try {
-            const cfg = loadCfg(opts);
-            const templates = listTemplates(allTemplates(cfg));
+            const templates = taskRoomService(opts.configuration).listTemplates();
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, templates }, null, 2));
                 return;
@@ -368,12 +399,9 @@ export function registerTemplateCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((name, opts) => {
         try {
-            const cfg = loadCfg(opts);
-            const t = resolveTemplate(name, allTemplates(cfg));
-            if (!t)
-                die(new Error(`template not found: ${name}`));
+            const t = taskRoomService(opts.configuration).getTemplate(name);
             if (opts.json) {
-                console.log(JSON.stringify({ schema_version: 1, template: { ...t, content_hash: hashTemplate(t) } }, null, 2));
+                console.log(JSON.stringify({ schema_version: 1, template: t }, null, 2));
                 return;
             }
             console.log(`${t.name}@${t.version}  ${t.description}`);
@@ -382,7 +410,7 @@ export function registerTemplateCommands(parent, cOpt) {
             console.log(`\nMembers:`);
             for (const m of t.members)
                 console.log(`  ${m.slot}: ${m.count}× ${m.role} (ref: ${m.role_ref})`);
-            console.log(`\nContent hash: ${hashTemplate(t)}`);
+            console.log(`\nContent hash: ${t.content_hash}`);
         }
         catch (e) {
             die(e);
@@ -393,18 +421,7 @@ export function registerTemplateCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((opts) => {
         try {
-            const cfg = loadCfg(opts);
-            const templates = listTemplates(allTemplates(cfg));
-            const problems = [];
-            for (const t of templates) {
-                const issues = [];
-                for (const m of t.members) {
-                    if (!cfg.roles.some(r => r.name === m.role_ref))
-                        issues.push(`member ${m.slot}: role_ref '${m.role_ref}' not found in fleet roles`);
-                }
-                if (issues.length)
-                    problems.push({ template: `${t.name}@${t.version}`, issues });
-            }
+            const problems = taskRoomService(opts.configuration).validateTemplates();
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, valid: !problems.length, problems }, null, 2));
                 return;
@@ -436,72 +453,29 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--backlog', 'create in backlog (do not start immediately)')
         .option('--no-room', 'create task without a room')
         .option('--idempotency-key <key>', 'idempotency key')
+        .option('--list <name>', 'task list (default: default)')
         .option('--json', 'JSON output')
         .action(async (opts) => {
         try {
-            const cfg = loadCfg(opts);
-            let templateRef;
-            if (opts.template) {
-                const t = resolveTemplate(opts.template, allTemplates(cfg));
-                if (!t)
-                    throw taskRoomPublicError('template_not_found', { template: opts.template });
-                const snap = snapshotTemplate(t);
-                templateRef = { name: snap.name, version: snap.version, content_hash: snap.content_hash };
-            }
-            else if (opts.room !== false) {
-                const defaultTpl = cfg.tasks?.default_room_template ?? cfg.rooms?.defaults?.template ?? 'team';
-                const t = resolveTemplate(defaultTpl, allTemplates(cfg));
-                if (t) {
-                    const snap = snapshotTemplate(t);
-                    templateRef = { name: snap.name, version: snap.version, content_hash: snap.content_hash };
-                }
-            }
-            let brief = opts.brief;
-            if (opts.briefFile) {
-                brief = readFileSync(opts.briefFile, 'utf8');
-            }
-            const origin = { type: 'cli' };
-            let record = createTask({
-                title: opts.title,
-                brief,
-                brief_file: opts.briefFile,
-                template: templateRef,
-                origin,
-                idempotency_key: opts.idempotencyKey,
-                start: !opts.backlog,
+            const record = await taskRoomService(opts.configuration).createTask({
+                actor: { kind: 'local_control', surface: 'cli' }, title: opts.title,
+                brief: opts.brief, briefFile: opts.briefFile, template: opts.template,
+                backlog: opts.backlog, noRoom: opts.room === false,
+                idempotencyKey: opts.idempotencyKey, origin: { type: 'cli' },
+                list: opts.list,
             });
-            if (!opts.backlog && opts.room !== false && templateRef && !record.room_id) {
-                const template = resolveRoomTemplate(cfg, templateRef.name);
-                try {
-                    await provisionRoom(cfg, {
-                        name: opts.title,
-                        goal: opts.title,
-                        brief,
-                        template,
-                        taskId: record.task_id,
-                        onCreated: room => {
-                            record = updateTaskRoom(record.task_id, room.room_id, room.room_identity_cid);
-                        },
-                    });
-                    record = getTask(record.task_id);
-                }
-                catch (error) {
-                    if (error instanceof CoworkUnavailableError) {
-                        blockTask(record.task_id, 'Cowork management socket is unavailable');
-                    }
-                    throw error;
-                }
-            }
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: record }, null, 2));
                 return;
             }
             console.log(taskActionMarkdown('Task created', record, [
                 { label: 'Title', value: record.title },
-                ...(templateRef ? [{ label: 'Template', value: `${templateRef.name}@${templateRef.version}`, kind: 'code' }] : []),
+                ...(record.template ? [{ label: 'Template', value: `${record.template.name}@${record.template.version}`, kind: 'code' }] : []),
             ]));
         }
         catch (e) {
+            if (e instanceof TaskRoomApplicationError && e.code === 'template_not_found')
+                e = taskRoomPublicError('template_not_found', { template: opts.template });
             if (opts.json)
                 die(e);
             dieTaskRoom(e);
@@ -510,6 +484,8 @@ export function registerTaskCommands(parent, cOpt) {
     cOpt(taskCmd.command('list'))
         .description('list tasks')
         .option('--state <state>', 'filter by state (backlog|active|provisioning|review|done|cancelled|failed|all)')
+        .option('--list <name>', 'filter by task list')
+        .option('--group-by-list', 'group deterministic results by list (JSON)')
         .option('--json', 'JSON output')
         .action((opts) => {
         try {
@@ -517,9 +493,13 @@ export function registerTaskCommands(parent, cOpt) {
             if (opts.state && opts.state !== 'all') {
                 stateFilter = opts.state;
             }
-            const tasks = listTasks(stateFilter ? { state: stateFilter } : undefined);
+            const service = taskRoomService(opts.configuration);
+            const filter = { ...(stateFilter ? { state: stateFilter } : {}), ...(opts.list ? { list: opts.list } : {}) };
+            const tasks = service.listTasks(filter);
             if (opts.json) {
-                console.log(JSON.stringify({ schema_version: 1, tasks }, null, 2));
+                console.log(JSON.stringify(opts.groupByList
+                    ? { schema_version: 1, groups: service.groupedTasks(filter) }
+                    : { schema_version: 1, tasks }, null, 2));
                 return;
             }
             console.log(taskListMarkdown(tasks));
@@ -530,13 +510,105 @@ export function registerTaskCommands(parent, cOpt) {
             dieTaskRoom(e);
         }
     });
+    taskCmd.command('lists')
+        .description('list named task lists')
+        .option('--json', 'JSON output')
+        .action((opts) => {
+        try {
+            const lists = taskRoomService().listTaskLists();
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, lists }, null, 2));
+                return;
+            }
+            console.log(renderMarkdownList({ icon: '📚', title: 'Task lists', empty: 'No task lists found.',
+                records: lists.map(list => `${markdownCode(list.name)}${list.built_in ? ' — built-in' : ''}`) }));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
+    taskCmd.command('list-create <name>')
+        .description('create a named task list')
+        .option('--json', 'JSON output')
+        .action(async (name, opts) => {
+        try {
+            const list = await taskRoomService().createTaskList({ actor: { kind: 'local_control', surface: 'cli' }, name });
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, list }, null, 2));
+                return;
+            }
+            console.log(renderMarkdownResult({ icon: '📚', title: 'Task list created', fields: [{ label: 'Name', value: list.name }] }));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
+    taskCmd.command('list-rename <name> <new-name>')
+        .description('rename a named task list')
+        .option('--json', 'JSON output')
+        .action(async (name, newName, opts) => {
+        try {
+            const list = await taskRoomService().renameTaskList({ actor: { kind: 'local_control', surface: 'cli' }, name, newName });
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, list }, null, 2));
+                return;
+            }
+            console.log(renderMarkdownResult({ icon: '📚', title: 'Task list renamed', fields: [{ label: 'Name', value: list.name }] }));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
+    taskCmd.command('list-delete <name>')
+        .description('delete a task list; non-empty lists require --move-to')
+        .option('--move-to <name>', 'destination for assigned tasks')
+        .option('--json', 'JSON output')
+        .action(async (name, opts) => {
+        try {
+            const result = await taskRoomService().deleteTaskList({ actor: { kind: 'local_control', surface: 'cli' }, name, destination: opts.moveTo });
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, ...result }, null, 2));
+                return;
+            }
+            console.log(renderMarkdownResult({ icon: '🗑️', title: 'Task list deleted', fields: [{ label: 'Name', value: result.deleted.name }, { label: 'Tasks moved', value: String(result.moved) }] }));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
+    taskCmd.command('move <id>')
+        .description('move a task to another list without changing its lifecycle')
+        .requiredOption('--list <name>', 'destination task list')
+        .option('--json', 'JSON output')
+        .action(async (id, opts) => {
+        try {
+            const task = await taskRoomService().moveTask({ actor: { kind: 'local_control', surface: 'cli' }, taskId: id, list: opts.list });
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, task }, null, 2));
+                return;
+            }
+            console.log(taskActionMarkdown('Task moved', task));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
     taskCmd.command('show <id>')
         .description('show task details')
         .option('--json', 'JSON output')
         .action((id, opts) => {
         try {
-            const t = getTask(id);
-            const room = t.room_id ? getRoomRecord(t.room_id) : undefined;
+            const { task: t, orchestration: room } = taskRoomService().getTask(id);
             if (opts.json) {
                 console.log(JSON.stringify({
                     schema_version: 1, task: t, orchestration: room ?? null,
@@ -578,26 +650,9 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
-            const cfg = loadCfg(opts);
-            let t = startTask(id);
-            if (t.template && !t.room_id) {
-                const template = resolveRoomTemplate(cfg, t.template.name);
-                if (!template || template.content_hash !== t.template.content_hash)
-                    throw taskRoomPublicError('task_template_drift', {
-                        template: `${t.template.name}@${t.template.version}`,
-                    });
-                await provisionRoom(cfg, {
-                    name: t.title,
-                    goal: t.title,
-                    brief: t.brief,
-                    template,
-                    taskId: t.task_id,
-                    onCreated: room => {
-                        t = updateTaskRoom(t.task_id, room.room_id, room.room_identity_cid);
-                    },
-                });
-                t = getTask(t.task_id);
-            }
+            const t = await taskRoomService(opts.configuration).startTask({
+                actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
+            });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -605,6 +660,11 @@ export function registerTaskCommands(parent, cOpt) {
             console.log(taskActionMarkdown('Task started', t));
         }
         catch (e) {
+            if (e instanceof TaskRoomApplicationError && e.code === 'task_template_drift')
+                e = taskRoomPublicError('task_template_drift', {
+                    template: getTask(id).template
+                        ? `${getTask(id).template.name}@${getTask(id).template.version}` : undefined,
+                });
             if (opts.json)
                 die(e);
             dieTaskRoom(e);
@@ -616,7 +676,9 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((id, opts) => {
         try {
-            const t = blockTask(id, opts.reason);
+            const t = taskRoomService().blockTask({
+                actor: { kind: 'local_control', surface: 'cli' }, taskId: id, reason: opts.reason,
+            });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -634,7 +696,9 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((id, opts) => {
         try {
-            const t = unblockTask(id);
+            const t = taskRoomService().unblockTask({
+                actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
+            });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -652,7 +716,9 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((id, opts) => {
         try {
-            const t = reviewTask(id);
+            const t = taskRoomService().reviewTask({
+                actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
+            });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -676,25 +742,12 @@ export function registerTaskCommands(parent, cOpt) {
             if (opts.summaryFile)
                 summary = readFileSync(opts.summaryFile, 'utf8');
             const outcome = summary ? { summary } : undefined;
-            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)
-                    roomId = current.room_id;
-            }
-            await acceptTaskTerminalIntent({ taskId: id, kind: 'done', roomId, outcome });
-            const settled = roomId
+            const plan = await taskRoomService(opts.configuration).completeTask({
+                actor: { kind: 'local_control', surface: 'cli' }, taskId: id, outcome,
+            });
+            const settled = plan.settlementRequired
                 ? await launchTaskSettleWorker(id, opts.configuration)
-                : { task: getTask(id), timedOut: false };
+                : { task: plan.task, timedOut: false };
             const t = settled.task;
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
@@ -723,17 +776,12 @@ export function registerTaskCommands(parent, cOpt) {
         try {
             if (id !== confirmId)
                 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 plan = await taskRoomService(opts.configuration).cancelTask({
+                actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
-            const settled = current.room_id
+            const settled = plan.settlementRequired
                 ? await launchTaskSettleWorker(id, opts.configuration)
-                : { task: getTask(id), timedOut: false };
+                : { task: plan.task, timedOut: false };
             const t = settled.task;
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
@@ -762,7 +810,9 @@ export function registerTaskCommands(parent, cOpt) {
         try {
             if (id !== confirmId)
                 throw taskRoomPublicError('task_confirmation_mismatch');
-            const deleted = deleteTask(id);
+            const deleted = taskRoomService().deleteTask({
+                actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
+            });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task_id: id, deleted }, null, 2));
                 return;
@@ -783,61 +833,35 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
-            const cfg = loadCfg(opts);
-            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');
-                if (room.provisioning_detail === 'waiting_owner_invite')
-                    result.recovery_actions.push('Owner invite invalid or expired — rotate rooms.owner.public_invite in config');
-                if (room.provisioning_detail === 'owner_cid_mismatch')
-                    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`);
-                if (room.provisioning_detail === 'waiting_seats')
-                    result.recovery_actions.push('Members have not accepted their one-time room invites yet — inspect role logs, then retry recovery');
-                const resumable = ['create_members', 'join_role_groups', 'wait_seats', 'launch_work', 'activate'];
-                if (resumable.includes(room.saga.phase)) {
-                    const template = durableTaskRoomTemplate(t, room);
-                    if (template) {
-                        try {
-                            await provisionMembers({
-                                cfg,
-                                cowork: coworkFor(cfg),
-                                roomId: room.room_id,
-                                taskId: t.task_id,
-                                template,
-                                binPath: getBinPath(),
-                                brief: t.brief,
-                                goal: t.title,
-                            });
-                            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)}`);
-                        }
-                    }
-                }
-            }
+            const app = taskRoomService(opts.configuration);
+            const actor = { kind: 'local_control', surface: 'cli' };
+            const begin = await app.beginTaskRecovery({ actor, taskId: id });
+            const recovered = begin.kind === 'terminal_worker_required'
+                ? await (async () => {
+                    const settled = await launchTaskSettleWorker(id, opts.configuration);
+                    return app.continueTaskRecovery({ actor, taskId: id, terminalTimedOut: settled.timedOut });
+                })()
+                : begin.result;
+            const t = recovered.task;
+            const room = recovered.room;
+            const recoveryActions = recovered.issues.map(issue => {
+                if (issue.code === 'terminal_pending')
+                    return `Terminal intent remains pending — retry task recover ${id}`;
+                if (issue.code === 'waiting_cowork')
+                    return 'Cowork management socket unreachable — check ours-cowork service';
+                if (issue.code === 'waiting_owner_invite')
+                    return 'Owner invite invalid or expired — rotate rooms.owner.public_invite in config';
+                if (issue.code === 'owner_cid_mismatch')
+                    return 'Owner CID mismatch — verify rooms.owner.expected_cid matches Messenger identity';
+                if (issue.code === 'member_failed')
+                    return `Member creation failed at saga step ${issue.stepIndex} — inspect and retry`;
+                if (issue.code === 'waiting_seats')
+                    return 'Members have not accepted their one-time room invites yet — inspect role logs, then retry recovery';
+                if (issue.code === 'resume_failed')
+                    return `Resume failed: ${issue.error}`;
+                return 'Provisioning resumed successfully';
+            });
+            const result = { task: t, room: room ?? null, recovery_actions: recoveryActions };
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, ...result }, null, 2));
                 return;
@@ -853,8 +877,8 @@ export function registerTaskCommands(parent, cOpt) {
                         { label: 'Saga', value: room.saga.phase, kind: 'code' },
                     ] : []),
                 ],
-                sections: result.recovery_actions.length
-                    ? [{ heading: 'Next steps', items: result.recovery_actions }]
+                sections: recoveryActions.length
+                    ? [{ heading: 'Next steps', items: recoveryActions }]
                     : [{ heading: 'Result', items: ['No automated recovery action is available.'] }],
             }));
         }
@@ -869,8 +893,10 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
-            const cfg = loadCfg(opts);
-            const t = await settleTaskTerminalIntent({ taskId: id, cowork: coworkFor(cfg) });
+            const app = taskRoomService(opts.configuration);
+            const t = await app.settleTask({
+                actor: { kind: 'internal_worker', surface: 'cli' }, taskId: id,
+            });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -878,7 +904,41 @@ export function registerTaskCommands(parent, cOpt) {
             console.log(taskActionMarkdown('Task terminal action settled', t));
         }
         catch (e) {
-            await recordTaskTerminalIntentError(id, errorText(e), `External settle worker failed. Retry task recover ${id}.`).catch(() => { });
+            await taskRoomService(opts.configuration).recordSettlementError({
+                actor: { kind: 'internal_worker', surface: 'cli' }, taskId: id,
+                error: errorText(e), recoveryHint: `External settle worker failed. Retry task recover ${id}.`,
+            }).catch(() => { });
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
+    cOpt(taskCmd.command('_recover <id>', { hidden: true }))
+        .description('internal: settle and continue task recovery')
+        .option('--json', 'JSON output')
+        .action(async (id, opts) => {
+        const app = taskRoomService(opts.configuration);
+        const actor = { kind: 'internal_worker', surface: 'cli' };
+        try {
+            const begin = await app.beginTaskRecovery({ actor, taskId: id });
+            const result = begin.kind === 'terminal_worker_required'
+                ? await (async () => {
+                    try {
+                        await app.settleTask({ actor, taskId: id });
+                    }
+                    catch (error) {
+                        await app.recordSettlementError({
+                            actor, taskId: id, error: errorText(error),
+                            recoveryHint: `External settle worker failed. Retry task recover ${id}.`,
+                        }).catch(() => { });
+                        throw error;
+                    }
+                    return app.continueTaskRecovery({ actor, taskId: id, terminalTimedOut: false });
+                })()
+                : begin.result;
+            console.log(JSON.stringify({ schema_version: 1, recovery: result }, null, 2));
+        }
+        catch (e) {
             if (opts.json)
                 die(e);
             dieTaskRoom(e);
@@ -890,25 +950,11 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
-            const cfg = loadCfg(opts);
-            let t = getTask(id);
-            if (TASK_TERMINAL_STATES.includes(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)
-                        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))
-                        throw taskRoomPublicError('template_mismatch', {
-                            requested: `${overrideSnap.name}@${overrideSnap.version}`, room: t.room_id,
-                            provisioned: `${roomSnap.name}@${roomSnap.version}`,
-                        });
-                }
+            const result = await taskRoomService(opts.configuration).ensureTaskWork({
+                actor: { kind: 'local_control', surface: 'cli' }, taskId: id, template: opts.template,
+            });
+            const t = result.task;
+            if (result.status === 'already_active') {
                 if (opts.json) {
                     console.log(JSON.stringify({ schema_version: 1, task: t, status: 'already_active' }, null, 2));
                     return;
@@ -916,107 +962,6 @@ export function registerTaskCommands(parent, cOpt) {
                 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 = 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)
-                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;
-                if (roomSnap && (roomSnap.name !== snap.name || roomSnap.content_hash !== snap.content_hash))
-                    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) {
-                templateRef = { name: snap.name, version: snap.version, content_hash: snap.content_hash };
-                t = updateTaskTemplate(t.task_id, templateRef);
-            }
-            if (t.state === 'backlog') {
-                t = startTask(id);
-            }
-            if (!t.room_id) {
-                try {
-                    await provisionRoom(cfg, {
-                        name: t.title,
-                        goal: t.title,
-                        brief: t.brief,
-                        template: snap,
-                        taskId: t.task_id,
-                        onCreated: room => {
-                            t = updateTaskRoom(t.task_id, room.room_id, room.room_identity_cid);
-                        },
-                    });
-                    t = getTask(t.task_id);
-                }
-                catch (error) {
-                    if (error instanceof CoworkUnavailableError) {
-                        blockTask(t.task_id, 'Cowork management socket is unavailable');
-                    }
-                    throw error;
-                }
-            }
-            else if (t.state === 'provisioning') {
-                // 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'];
-                if (room && resumable.includes(room.saga.phase)) {
-                    try {
-                        await provisionMembers({
-                            cfg,
-                            cowork: coworkFor(cfg),
-                            roomId: room.room_id,
-                            taskId: t.task_id,
-                            template: snap,
-                            binPath: getBinPath(),
-                            brief: t.brief,
-                            goal: t.title,
-                        });
-                    }
-                    catch (error) {
-                        if (error instanceof CoworkUnavailableError) {
-                            blockTask(t.task_id, 'Cowork management socket is unavailable');
-                        }
-                        throw error;
-                    }
-                    t = getTask(t.task_id);
-                }
-                else {
-                    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;
@@ -1026,15 +971,15 @@ export function registerTaskCommands(parent, cOpt) {
                 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.template ? [{ label: 'Template', value: `${t.template.name}@${t.template.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)}`),
-                    }] : [],
+                sections: t.member_roles.length ? [{ heading: 'Agents', markdownItems: t.member_roles.map(m => `${markdownCode(m.name)} — ${markdownProse(m.cowork_role)}`) }] : [],
             }));
         }
         catch (e) {
+            if (e instanceof TaskRoomApplicationError)
+                e = taskRoomPublicError(e.code, e.fields);
             if (opts.json)
                 die(e);
             dieTaskRoom(e);
@@ -1051,19 +996,13 @@ export function registerTaskCommands(parent, cOpt) {
             if (opts.summaryFile)
                 summary = readFileSync(opts.summaryFile, 'utf8');
             const outcome = summary ? { summary } : undefined;
-            let t = getTask(id);
-            if (TASK_TERMINAL_STATES.includes(t.state))
-                throw taskRoomPublicError('task_terminal_already', { task: id, state: t.state });
-            if (t.state === 'active') {
-                reviewTask(id);
-            }
-            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
+            const plan = await taskRoomService(opts.configuration).finishTask({
+                actor: { kind: 'local_control', surface: 'cli' }, taskId: id, outcome,
+            });
+            const settled = plan.settlementRequired
                 ? await launchTaskSettleWorker(id, opts.configuration)
-                : { task: getTask(id), timedOut: false };
-            t = settled.task;
+                : { task: plan.task, timedOut: false };
+            const t = settled.task;
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -1079,6 +1018,8 @@ export function registerTaskCommands(parent, cOpt) {
             console.log(taskActionMarkdown('Task finished', t, t.outcome ? [{ label: 'Summary', value: t.outcome.summary, multiline: true }] : []));
         }
         catch (e) {
+            if (e instanceof TaskRoomApplicationError)
+                e = taskRoomPublicError(e.code, e.fields);
             if (opts.json)
                 die(e);
             dieTaskRoom(e);
@@ -1097,22 +1038,9 @@ export function registerRoomCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (opts) => {
         try {
-            const cfg = loadCfg(opts);
-            let brief = opts.brief;
-            if (opts.briefFile)
-                brief = readFileSync(opts.briefFile, 'utf8');
-            let templateSnapshot;
-            if (opts.template) {
-                const t = resolveTemplate(opts.template, allTemplates(cfg));
-                if (!t)
-                    throw taskRoomPublicError('template_not_found', { template: opts.template });
-                templateSnapshot = snapshotTemplate(t);
-            }
-            const record = await provisionRoom(cfg, {
-                name: opts.name,
-                goal: opts.goal,
-                brief,
-                template: templateSnapshot,
+            const record = await taskRoomService(opts.configuration).createRoom({
+                actor: { kind: 'local_control', surface: 'cli' }, name: opts.name,
+                template: opts.template, goal: opts.goal, brief: opts.brief, briefFile: opts.briefFile,
             });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room: record }, null, 2));
@@ -1120,7 +1048,7 @@ export function registerRoomCommands(parent, cOpt) {
             }
             console.log(roomActionMarkdown('Room created', record, [
                 { label: 'Name', value: record.room_name },
-                ...(templateSnapshot ? [{ label: 'Template', value: `${templateSnapshot.name}@${templateSnapshot.version}`, kind: 'code' }] : []),
+                ...(record.template_snapshot ? [{ label: 'Template', value: `${record.template_snapshot.name}@${record.template_snapshot.version}`, kind: 'code' }] : []),
             ]));
         }
         catch (e) {
@@ -1135,23 +1063,11 @@ export function registerRoomCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (opts) => {
         try {
-            const cfg = loadCfg(opts);
             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 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 }));
+            const rooms = await taskRoomService(opts.configuration).listRooms(stateFilter ? { state: stateFilter } : undefined);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, rooms }, null, 2));
                 return;
@@ -1173,14 +1089,7 @@ export function registerRoomCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .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 || cowork.state === 'closing' || cowork.state === 'closed')
-                throw taskRoomPublicError('room_not_found', { room: id });
-            const r = tracked;
+            const { room: cowork, orchestration: r } = await taskRoomService(opts.configuration).getRoomDetail(id);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room: cowork, orchestration: r ?? null }, null, 2));
                 return;
@@ -1217,13 +1126,7 @@ export function registerRoomCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .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 || room.state === 'closing' || room.state === 'closed')
-                throw taskRoomPublicError('room_not_found', { room: id });
+            const { room } = await taskRoomService(opts.configuration).getRoomDetail(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));
@@ -1249,15 +1152,7 @@ export function registerRoomCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
-            const cfg = loadCfg(opts);
-            const r = getRoomRecord(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);
+            const { orchestration: r, members } = await taskRoomService(opts.configuration).getRoomMembers(id);
             if (opts.json) {
                 console.log(JSON.stringify({
                     schema_version: 1,
@@ -1291,11 +1186,9 @@ export function registerRoomCommands(parent, cOpt) {
         try {
             if (id !== confirmId)
                 throw taskRoomPublicError('room_confirmation_mismatch');
-            coworkFor(loadCfg(opts));
-            const existing = getRoomRecord(id);
-            if (!existing)
-                throw taskRoomPublicError('room_record_not_found', { room: id });
-            await acceptManagedRoomClose(id);
+            await taskRoomService(opts.configuration).requestRoomDeletion({
+                actor: { kind: 'local_control', surface: 'cli' }, roomId: id,
+            });
             const settled = await launchRoomDeleteWorker(id, opts.configuration);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room_id: id, deleted: settled.deleted }, null, 2));
@@ -1333,10 +1226,10 @@ export function registerRoomCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
-            const cfg = loadCfg(opts);
-            const adapter = coworkFor(cfg);
-            let r = getRoomRecord(id);
-            if (r?.state === 'closing' || r?.state === 'closed') {
+            const recovered = await taskRoomService(opts.configuration).recoverRoom({
+                actor: { kind: 'local_control', surface: 'cli' }, roomId: id,
+            });
+            if (recovered.kind === 'deletion_worker_required') {
                 const settled = await launchRoomDeleteWorker(id, opts.configuration);
                 if (opts.json) {
                     console.log(JSON.stringify({
@@ -1351,72 +1244,13 @@ export function registerRoomCommands(parent, cOpt) {
                     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
+                    sections: [{ heading: 'Next step', items: [settled.timedOut
                                     ? `Run ours-fleet room delete ${id} ${id} or room recover ${id} again.`
-                                    : 'No recovery action is needed.',
-                            ] }],
+                                    : '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')) {
-                const expected = cfg.rooms.owner.expected_cid.toLowerCase();
-                const existing = (await adapter.getSeats(id))
-                    .find(seat => seat.identity_cid.toLowerCase() === expected && seat.seat_state !== 'removed');
-                if (!existing && !cfg.ownerInvite)
-                    throw new ConfigError('rooms.owner: configure public_invite or public_invite_file before recovery');
-                let acceptedCid = existing?.identity_cid;
-                if (!acceptedCid) {
-                    const accepted = await adapter.acceptInvite(id, cfg.ownerInvite, {
-                        role: cfg.rooms.owner.role,
-                        expected_cid: cfg.rooms.owner.expected_cid,
-                    });
-                    acceptedCid = accepted.seat_cid;
-                }
-                setOwnerSeat(id, acceptedCid, cfg.ownerInviteFingerprint ?? '');
-                r = advanceSaga(id, 'create_members', 3);
-            }
-            const actions = [];
-            if (r?.saga.error)
-                actions.push('A provisioning failure is recorded; inspect role logs for diagnostics.');
-            if (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_seats')
-                actions.push('Inspect temporary member logs for invite acceptance, then re-run recover');
-            if (r && r.state === 'provisioning') {
-                const resumable = ['create_members', 'join_role_groups', 'wait_seats', 'launch_work', 'activate'];
-                if (resumable.includes(r.saga.phase) && r.template_snapshot) {
-                    try {
-                        const template = r.task_id
-                            ? durableTaskRoomTemplate(getTask(r.task_id), r)
-                            : r.template_snapshot;
-                        if (template) {
-                            await provisionMembers({
-                                cfg,
-                                cowork: adapter,
-                                roomId: r.room_id,
-                                taskId: r.task_id,
-                                template,
-                                binPath: getBinPath(),
-                                goal: r.room_name,
-                            });
-                            r = getRoomRecord(id);
-                            actions.splice(0, actions.length, 'Provisioning resumed successfully');
-                        }
-                    }
-                    catch (error) {
-                        actions.push(`Resume failed: ${error instanceof Error ? error.message : String(error)}`);
-                    }
-                }
-            }
+            const { room: cowork, orchestration: r, issues: actions } = recovered;
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room: cowork, orchestration: r ?? null, recovery_actions: actions }, null, 2));
                 return;
@@ -1428,8 +1262,7 @@ export function registerRoomCommands(parent, cOpt) {
                     { 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 }]
+                sections: actions.length ? [{ heading: 'Next steps', items: actions }]
                     : [{ heading: 'Result', items: ['No recovery action is needed.'] }],
             }));
         }
@@ -1441,8 +1274,10 @@ export function registerRoomCommands(parent, cOpt) {
     });
     const internalDeleteAction = async (id, opts) => {
         try {
-            const cfg = loadCfg(opts);
-            const result = await deleteManagedRoom({ roomId: id, cowork: coworkFor(cfg) });
+            const app = taskRoomService(opts.configuration);
+            const result = await app.settleRoomDeletion({
+                actor: { kind: 'internal_worker', surface: 'cli' }, roomId: id,
+            });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, ...result }, null, 2));
                 return;
@@ -1453,7 +1288,10 @@ export function registerRoomCommands(parent, cOpt) {
             }));
         }
         catch (e) {
-            await recordManagedRoomCloseError(id, errorText(e), `External delete worker failed. Retry room delete ${id} ${id}.`).catch(() => { });
+            await taskRoomService(opts.configuration).recordRoomSettlementError({
+                actor: { kind: 'internal_worker', surface: 'cli' }, roomId: id, error: errorText(e),
+                recoveryHint: `External delete worker failed. Retry room delete ${id} ${id}.`,
+            }).catch(() => { });
             if (opts.json)
                 die(e);
             dieTaskRoom(e);