@ours.network/fleet 1.0.3 → 1.0.5

package/dist/owner-channel/commands.js

@@ -4,12 +4,15 @@ import { RoomStateError } from '../rooms-tasks/room-state.js';
 import { TaskStateError } from '../rooms-tasks/task-state.js';
 import { markdownCode, markdownProse, renderMarkdownFailure, renderMarkdownList, renderMarkdownResult, roomStatus, taskStatus, } from '../rooms-tasks/markdown.js';
 import { OWNER_COMMENT_LABEL, ownerNotices } from './notices.js';
+import { TaskRoomApplicationError } from '../application/task-room-service.js';
+import { TaskListError } from '../rooms-tasks/task-lists.js';
 /** A malformed invocation; the dispatcher answers it with annotated help. */
 class OwnerCommandUsageError extends Error {
 }
 const MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
 const REPLY_MAX_CHARS = 3_500;
 const taskListRecord = (task) => `${taskStatus(task.state)} ${markdownCode(task.task_id)} — ${markdownProse(task.title)}`
+    + ` — List ${markdownCode(task.list_name ?? 'default')}`
     + (task.blocked ? ` — 🚧 Blocked: ${markdownProse(task.blocked.reason)}` : '');
 const roomListRecord = (room) => `${roomStatus(room.state)} ${markdownCode(room.room_id)} — ${markdownProse(room.room_name)}`
     + (room.task_id ? ` — Task ${markdownCode(room.task_id)}` : '');
@@ -34,6 +37,14 @@ function isKnownOwnerRoomState(message) {
     ].some(pattern => pattern.test(message));
 }
 function ownerTaskFailure(error) {
+    if (error instanceof TaskListError)
+        return {
+            kind: error.code === 'list_not_found' ? 'not_found'
+                : error.code === 'invalid_name' ? 'usage' : 'state',
+            detail: error.message,
+            action: error.code === 'list_not_found' ? 'Run /task lists to find a valid list.'
+                : 'Choose a valid list name or an explicit different destination.',
+        };
     if (error instanceof TaskStateError) {
         const missing = /^task not found: ([A-Za-z0-9_-]{1,128})$/u.exec(error.message);
         if (missing)
@@ -53,6 +64,12 @@ function ownerTaskFailure(error) {
     };
 }
 function ownerRoomFailure(error) {
+    if (error instanceof TaskRoomApplicationError
+        && (error.code === 'room_not_found' || error.code === 'room_record_not_found'))
+        return {
+            kind: 'not_found', detail: `Room ${error.fields.room} was not found.`,
+            action: 'Run /room list to find a valid room ID.',
+        };
     if (error instanceof RoomStateError) {
         const missing = /^room not found: ([A-Za-z0-9_-]{1,128})$/u.exec(error.message);
         if (missing)
@@ -228,9 +245,8 @@ export const ownerCommands = [
         name: 'tasks', usage: '/tasks [state]',
         summary: 'list tasks (optionally filter by state)',
         execute: async (ctx, args) => {
-            const { listTasks } = await import('../rooms-tasks/task-state.js');
             const stateFilter = args?.trim() || undefined;
-            const tasks = listTasks(stateFilter && stateFilter !== 'all' ? { state: stateFilter } : undefined);
+            const tasks = ctx.listTasks(stateFilter && stateFilter !== 'all' ? { state: stateFilter } : undefined);
             await ctx.reply(renderMarkdownList({
                 icon: '📋', title: 'Tasks', empty: 'No tasks found.',
                 records: tasks.map(taskListRecord),
@@ -250,14 +266,14 @@ export const ownerCommands = [
             const rest = firstLineTokens.slice(1);
             const trailingLines = argLines.slice(1).join('\n').trim() || undefined;
             const showTask = async (id) => {
-                const { getTask } = await import('../rooms-tasks/task-state.js');
-                const t = getTask(id);
+                const { task: t } = ctx.getTask(id);
                 await ctx.reply(renderMarkdownResult({
                     icon: '📋', title: 'Task details',
                     fields: [
                         { label: 'ID', value: t.task_id, kind: 'code' },
                         { label: 'Title', value: t.title },
                         { label: 'Status', value: taskStatus(t.state), kind: 'markdown' },
+                        { label: 'List', value: t.list_name ?? 'default', kind: 'code' },
                         ...(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' }] : []),
@@ -275,17 +291,15 @@ export const ownerCommands = [
                         const tplFlag = rest.find(r => r.startsWith('--template='));
                         const template = tplFlag ? tplFlag.slice('--template='.length) : undefined;
                         const noRoom = rest.includes('--no-room');
-                        const titleParts = rest.filter(r => r !== '--backlog' && !r.startsWith('--template=') && r !== '--no-room');
+                        const listFlag = rest.find(r => r.startsWith('--list='));
+                        const list = listFlag?.slice('--list='.length);
+                        const titleParts = rest.filter(r => r !== '--backlog' && !r.startsWith('--template=')
+                            && !r.startsWith('--list=') && r !== '--no-room');
                         if (!titleParts.length)
                             throw new OwnerCommandUsageError('usage: /task create [--backlog] [--template=<name>|--no-room] <title>');
-                        const { createTask } = await import('../rooms-tasks/task-state.js');
-                        const t = createTask({
-                            title: titleParts.join(' '),
-                            origin: { type: 'owner_channel' },
-                            start: !backlog,
-                            ...(template ? { template: { name: template, version: 1, content_hash: '' } } : {}),
-                            ...(noRoom ? { no_room: true } : {}),
-                            ...(trailingLines ? { brief: trailingLines } : {}),
+                        const t = await ctx.createTask({
+                            title: titleParts.join(' '), origin: { type: 'owner_channel' },
+                            backlog, template, noRoom, brief: trailingLines, list,
                         });
                         await ctx.reply(taskAction('Task created', t, [
                             { label: 'Title', value: t.title },
@@ -295,8 +309,10 @@ export const ownerCommands = [
                         break;
                     }
                     case 'list': {
-                        const { listTasks } = await import('../rooms-tasks/task-state.js');
-                        const filter = rest[0];
+                        const listFlag = rest.find(r => r.startsWith('--list='));
+                        const list = trailingLines ?? listFlag?.slice('--list='.length);
+                        const grouped = rest.includes('--group-by-list');
+                        const filter = rest.find(r => !r.startsWith('--'));
                         const stateMap = {
                             backlog: 'backlog', active: 'active', blocked: 'active',
                             done: 'done', all: ['backlog', 'provisioning', 'active', 'review', 'done', 'cancelled', 'failed'],
@@ -304,7 +320,8 @@ export const ownerCommands = [
                         const stateFilter = filter && stateMap[filter]
                             ? { state: stateMap[filter] }
                             : undefined;
-                        const tasks = listTasks(stateFilter);
+                        const combined = { ...(stateFilter ?? {}), ...(list ? { list } : {}) };
+                        const tasks = ctx.listTasks(combined);
                         if (filter === 'blocked') {
                             const blocked = tasks.filter(t => t.blocked);
                             await ctx.reply(renderMarkdownList({
@@ -313,12 +330,63 @@ export const ownerCommands = [
                             }));
                             break;
                         }
+                        if (grouped) {
+                            const groups = ctx.groupedTasks(combined);
+                            await ctx.reply(groups.map(group => renderMarkdownList({
+                                icon: '📋', title: `Tasks — ${group.list.name}`, empty: 'No tasks found.',
+                                records: group.tasks.map(taskListRecord),
+                            })).join('\n\n'));
+                            break;
+                        }
                         await ctx.reply(renderMarkdownList({
                             icon: '📋', title: 'Tasks', empty: 'No tasks found.',
                             records: tasks.map(taskListRecord),
                         }));
                         break;
                     }
+                    case 'lists': {
+                        const lists = ctx.listTaskLists();
+                        await ctx.reply(renderMarkdownList({ icon: '📚', title: 'Task lists', empty: 'No task lists found.',
+                            records: lists.map(list => `${markdownCode(list.name)}${list.built_in ? ' — built-in' : ''}`) }));
+                        break;
+                    }
+                    case 'list-create': {
+                        const name = trailingLines ?? rest.join(' ');
+                        if (!name)
+                            throw new OwnerCommandUsageError('usage: /task list-create\n<name>');
+                        const list = await ctx.createTaskList(name);
+                        await ctx.reply(renderMarkdownResult({ icon: '📚', title: 'Task list created', fields: [{ label: 'Name', value: list.name }] }));
+                        break;
+                    }
+                    case 'list-rename': {
+                        const names = argLines.slice(1).map(line => line.trim()).filter(Boolean);
+                        const current = names.length === 2 ? names[0] : rest[0];
+                        const next = names.length === 2 ? names[1] : rest[1];
+                        if (!current || !next)
+                            throw new OwnerCommandUsageError('usage: /task list-rename\n<name>\n<new-name>');
+                        const list = await ctx.renameTaskList(current, next);
+                        await ctx.reply(renderMarkdownResult({ icon: '📚', title: 'Task list renamed', fields: [{ label: 'Name', value: list.name }] }));
+                        break;
+                    }
+                    case 'list-delete': {
+                        const names = argLines.slice(1).map(line => line.trim()).filter(Boolean);
+                        const name = names[0] ?? rest[0];
+                        const destination = names[1] ?? rest.find(r => r.startsWith('--move-to='))?.slice('--move-to='.length);
+                        if (!name)
+                            throw new OwnerCommandUsageError('usage: /task list-delete\n<name>\n[move-to-name]');
+                        const result = await ctx.deleteTaskList(name, destination);
+                        await ctx.reply(renderMarkdownResult({ icon: '🗑️', title: 'Task list deleted', fields: [
+                                { label: 'Name', value: result.deleted.name }, { label: 'Tasks moved', value: String(result.moved) },
+                            ] }));
+                        break;
+                    }
+                    case 'move': {
+                        const destination = trailingLines ?? rest.find(r => r.startsWith('--list='))?.slice('--list='.length);
+                        if (!rest[0] || !destination)
+                            throw new OwnerCommandUsageError('usage: /task move <id> --list=<name>');
+                        await showTask((await ctx.moveTask(rest[0], destination)).task_id);
+                        break;
+                    }
                     case 'show': {
                         if (!rest[0])
                             throw new OwnerCommandUsageError('usage: /task show <id>');
@@ -328,33 +396,29 @@ export const ownerCommands = [
                     case 'start': {
                         if (!rest[0])
                             throw new OwnerCommandUsageError('usage: /task start <id>');
-                        const { startTask } = await import('../rooms-tasks/task-state.js');
-                        const t = startTask(rest[0]);
+                        const t = await ctx.startTask(rest[0]);
                         await ctx.reply(taskAction('Task started', t));
                         break;
                     }
                     case 'block': {
                         if (!rest[0] || !rest[1])
                             throw new OwnerCommandUsageError('usage: /task block <id> <reason>');
-                        const { blockTask } = await import('../rooms-tasks/task-state.js');
                         const reason = rest.slice(1).join(' ');
-                        const t = blockTask(rest[0], reason);
+                        const t = ctx.blockTask(rest[0], reason);
                         await ctx.reply(taskAction('Task blocked', t, [{ label: 'Reason', value: reason }]));
                         break;
                     }
                     case 'unblock': {
                         if (!rest[0])
                             throw new OwnerCommandUsageError('usage: /task unblock <id>');
-                        const { unblockTask } = await import('../rooms-tasks/task-state.js');
-                        const t = unblockTask(rest[0]);
+                        const t = ctx.unblockTask(rest[0]);
                         await ctx.reply(taskAction('Task unblocked', t));
                         break;
                     }
                     case 'review': {
                         if (!rest[0])
                             throw new OwnerCommandUsageError('usage: /task review <id>');
-                        const { reviewTask } = await import('../rooms-tasks/task-state.js');
-                        const t = reviewTask(rest[0]);
+                        const t = ctx.reviewTask(rest[0]);
                         await ctx.reply(taskAction('Task ready for review', t));
                         break;
                     }
@@ -374,8 +438,7 @@ export const ownerCommands = [
                     case 'delete': {
                         if (rest.length !== 2 || rest[0] !== rest[1])
                             throw new OwnerCommandUsageError('destructive: /task delete <id> <id> — provide the task ID twice');
-                        const { deleteTask } = await import('../rooms-tasks/task-state.js');
-                        const deleted = deleteTask(rest[0]);
+                        const deleted = ctx.deleteTask(rest[0]);
                         await ctx.reply(renderMarkdownResult({
                             icon: '🗑️', title: deleted ? 'Task deleted' : 'Task already absent',
                             fields: [{ label: 'ID', value: rest[0], kind: 'code' }],
@@ -385,40 +448,7 @@ export const ownerCommands = [
                     case 'recover': {
                         if (!rest[0])
                             throw new OwnerCommandUsageError('usage: /task recover <id>');
-                        const { getTask } = await import('../rooms-tasks/task-state.js');
-                        const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
-                        const t = getTask(rest[0]);
-                        if (t.terminal_intent?.status === 'pending') {
-                            await ctx.terminalTask(t.task_id, t.terminal_intent.kind, t.terminal_intent.outcome);
-                            break;
-                        }
-                        const room = t.room_id ? getRoomRecord(t.room_id) : undefined;
-                        const hints = [];
-                        if (t.state === 'provisioning' && room) {
-                            if (room.provisioning_detail === 'waiting_cowork')
-                                hints.push('Cowork socket unreachable');
-                            if (room.provisioning_detail === 'waiting_owner_invite')
-                                hints.push('Owner invite missing or invalid');
-                            if (room.provisioning_detail === 'owner_cid_mismatch')
-                                hints.push('Owner CID mismatch');
-                            if (room.provisioning_detail === 'member_failed')
-                                hints.push(`Member failed at step ${room.saga.step_index}`);
-                        }
-                        await ctx.reply(renderMarkdownResult({
-                            icon: '🛟', title: 'Task recovery',
-                            fields: [
-                                { label: 'Task', value: t.task_id, kind: 'code' },
-                                { label: 'Status', value: taskStatus(t.state), kind: 'markdown' },
-                                ...(room ? [
-                                    { label: 'Room', value: room.room_id, kind: 'code' },
-                                    { label: 'Room status', value: roomStatus(room.state), kind: 'markdown' },
-                                    { label: 'Saga', value: room.saga.phase, kind: 'code' },
-                                ] : []),
-                            ],
-                            sections: hints.length
-                                ? [{ heading: 'Next steps', items: hints }]
-                                : [{ heading: 'Result', items: ['No automated recovery action is available.'] }],
-                        }));
+                        await ctx.recoverTask(rest[0]);
                         break;
                     }
                     default:
@@ -442,11 +472,11 @@ export const ownerCommands = [
     {
         name: 'rooms', summary: 'list rooms',
         execute: noArgs('/rooms', async (ctx) => {
-            const { listRoomRecords } = await import('../rooms-tasks/room-state.js');
-            const rooms = listRoomRecords().filter(room => room.state === 'active' || room.state === 'provisioning');
+            const rooms = await ctx.listRoomQueries();
             await ctx.reply(renderMarkdownList({
                 icon: '🏠', title: 'Rooms', empty: 'No rooms found.',
-                records: rooms.map(roomListRecord),
+                records: rooms.map(room => `${roomStatus(room.state)} ${markdownCode(room.room_id)} — ${markdownProse(room.room_name)}`
+                    + (room.orchestration?.task_id ? ` — Task ${markdownCode(room.orchestration.task_id)}` : '')),
             }));
         }),
     },
@@ -463,24 +493,28 @@ export const ownerCommands = [
             const rest = firstLineTokens.slice(1);
             const roomTrailingLines = argLines.slice(1).join('\n').trim() || undefined;
             const showRoom = async (id) => {
-                const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
-                const r = getRoomRecord(id);
-                if (!r || r.state === 'closing' || r.state === 'closed')
-                    return ctx.reply(renderMarkdownFailure({
-                        kind: 'not_found', subject: `/room show ${id}`,
-                        detail: `Room ${id} was not found.`, action: 'Run /room list to find a valid room ID.',
-                    }));
+                let detail;
+                try {
+                    detail = await ctx.getRoomQuery(id);
+                }
+                catch (error) {
+                    if (!(error instanceof TaskRoomApplicationError && error.code === 'room_not_found'))
+                        throw error;
+                    return ctx.reply(renderMarkdownFailure({ kind: 'not_found', subject: `/room show ${id}`,
+                        detail: `Room ${id} was not found.`, action: 'Run /room list to find a valid room ID.' }));
+                }
+                const { room, orchestration: r } = detail;
                 await ctx.reply(renderMarkdownResult({
                     icon: '🏠', title: 'Room details',
                     fields: [
-                        { label: 'ID', value: r.room_id, kind: 'code' },
-                        { label: 'Name', value: r.room_name },
-                        { label: 'Status', value: roomStatus(r.state), kind: 'markdown' },
-                        { label: 'Saga', value: `${r.saga.phase} (step ${r.saga.step_index})` },
-                        ...(r.task_id ? [{ label: 'Task', value: r.task_id, kind: 'code' }] : []),
-                        ...(r.provisioning_detail ? [{ label: 'Detail', value: r.provisioning_detail }] : []),
-                        ...(r.saga.error ? [{ label: 'Last error', value: 'Provisioning failure recorded; inspect role logs.' }] : []),
-                        { label: 'Created', value: r.created_at, kind: 'code' },
+                        { label: 'ID', value: room.room_id, kind: 'code' },
+                        { label: 'Name', value: room.room_name },
+                        { label: 'Status', value: roomStatus(room.state), kind: 'markdown' },
+                        ...(r ? [{ label: 'Saga', value: `${r.saga.phase} (step ${r.saga.step_index})` }] : []),
+                        ...(r?.task_id ? [{ label: 'Task', value: r.task_id, kind: 'code' }] : []),
+                        ...(r?.provisioning_detail ? [{ label: 'Detail', value: r.provisioning_detail }] : []),
+                        ...(r?.saga.error ? [{ label: 'Last error', value: 'Provisioning failure recorded; inspect role logs.' }] : []),
+                        ...(r ? [{ label: 'Created', value: r.created_at, kind: 'code' }] : []),
                     ],
                 }));
             };
@@ -492,22 +526,16 @@ export const ownerCommands = [
                         const nameParts = rest.filter(r => !r.startsWith('--'));
                         if (!nameParts.length)
                             throw new OwnerCommandUsageError('usage: /room create --template=<name> <room name>');
-                        const { randomUUID } = await import('node:crypto');
-                        const { createRoomRecord } = await import('../rooms-tasks/room-state.js');
-                        const { resolveTemplate, snapshotTemplate } = await import('../rooms-tasks/templates.js');
-                        let templateSnapshot;
-                        if (templateName) {
-                            const tpl = resolveTemplate(templateName, {});
-                            if (!tpl)
+                        let r;
+                        try {
+                            r = await ctx.createRoom({ name: nameParts.join(' '), template: templateName,
+                                goal: roomTrailingLines });
+                        }
+                        catch (error) {
+                            if (error instanceof TaskRoomApplicationError && error.code === 'template_not_found')
                                 throw new OwnerCommandUsageError(`unknown template: ${templateName}`);
-                            templateSnapshot = snapshotTemplate(tpl);
+                            throw error;
                         }
-                        const r = createRoomRecord({
-                            room_id: randomUUID().replace(/-/g, '').slice(0, 16),
-                            room_name: nameParts.join(' '),
-                            ...(templateSnapshot ? { template_snapshot: templateSnapshot } : {}),
-                            ...(roomTrailingLines ? { goal: roomTrailingLines } : {}),
-                        });
                         await ctx.reply(roomAction('Room created', r, [
                             { label: 'Name', value: r.room_name },
                             ...(templateName ? [{ label: 'Template', value: templateName, kind: 'code' }] : []),
@@ -515,14 +543,14 @@ export const ownerCommands = [
                         break;
                     }
                     case 'list': {
-                        const { listRoomRecords } = await import('../rooms-tasks/room-state.js');
                         const filter = rest[0];
-                        let rooms = listRoomRecords().filter(room => room.state === 'active' || room.state === 'provisioning');
-                        if (filter === 'active')
-                            rooms = rooms.filter(r => r.state === 'active');
+                        if (filter && !['active', 'provisioning', 'all'].includes(filter))
+                            throw new OwnerCommandUsageError('usage: /room list [active|provisioning|all]');
+                        const rooms = await ctx.listRoomQueries(filter === 'active' || filter === 'provisioning' ? { state: filter } : undefined);
                         await ctx.reply(renderMarkdownList({
                             icon: '🏠', title: 'Rooms', empty: 'No rooms found.',
-                            records: rooms.map(roomListRecord),
+                            records: rooms.map(room => `${roomStatus(room.state)} ${markdownCode(room.room_id)} — ${markdownProse(room.room_name)}`
+                                + (room.orchestration?.task_id ? ` — Task ${markdownCode(room.orchestration.task_id)}` : '')),
                         }));
                         break;
                     }
@@ -542,32 +570,7 @@ export const ownerCommands = [
                     case 'recover': {
                         if (!rest[0])
                             throw new OwnerCommandUsageError('usage: /room recover <id>');
-                        const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
-                        const r = getRoomRecord(rest[0]);
-                        if (!r) {
-                            await ctx.reply(renderMarkdownFailure({
-                                kind: 'not_found', subject: `/room recover ${rest[0]}`,
-                                detail: `Room ${rest[0]} was not found.`, action: 'Run /room list to find a valid room ID.',
-                            }));
-                            break;
-                        }
-                        if (r.state === 'closing' || r.state === 'closed') {
-                            await ctx.closeRoom(r.room_id);
-                            break;
-                        }
-                        await ctx.reply(renderMarkdownResult({
-                            icon: '🛟', title: 'Room recovery',
-                            fields: [
-                                { label: 'Room', value: r.room_id, kind: 'code' },
-                                { label: 'Status', value: roomStatus(r.state), kind: 'markdown' },
-                                { label: 'Saga', value: r.saga.phase, kind: 'code' },
-                                ...(r.saga.error ? [{ label: 'Last error', value: 'Provisioning failure recorded; inspect role logs.' }] : []),
-                                ...(r.provisioning_detail ? [{ label: 'Detail', value: r.provisioning_detail }] : []),
-                            ],
-                            sections: [{ heading: 'Next step', items: [r.saga.error
-                                            ? 'Run ours-fleet room recover from the CLI for full recovery.'
-                                            : 'No recovery action is needed.'] }],
-                        }));
+                        await ctx.recoverRoom(rest[0]);
                         break;
                     }
                     default:
@@ -592,8 +595,7 @@ export const ownerCommands = [
         name: 'templates', aliases: ['template-list'],
         summary: 'list available room templates',
         execute: noArgs('/templates', async (ctx) => {
-            const { listTemplates } = await import('../rooms-tasks/templates.js');
-            const templates = listTemplates({});
+            const templates = ctx.listTemplateQueries();
             if (!templates.length)
                 return ctx.reply('📐 No templates.');
             const lines = templates.map(t => {
@@ -613,10 +615,15 @@ export const ownerCommands = [
             const parts = args.trim().split(/\s+/);
             const sub = parts[0];
             const showTemplate = async (nameStr) => {
-                const { resolveTemplate } = await import('../rooms-tasks/templates.js');
-                const t = resolveTemplate(nameStr, {});
-                if (!t)
+                let t;
+                try {
+                    t = ctx.getTemplateQuery(nameStr);
+                }
+                catch (error) {
+                    if (!(error instanceof TaskRoomApplicationError && error.code === 'template_not_found'))
+                        throw error;
                     return ctx.reply(`⚠️ template not found: ${nameStr}`);
+                }
                 const lines = [
                     `📐 Template: ${t.name}@${t.version}`,
                     `Description: ${t.description}`,
@@ -635,8 +642,7 @@ export const ownerCommands = [
                     break;
                 }
                 case 'list': {
-                    const { listTemplates } = await import('../rooms-tasks/templates.js');
-                    const templates = listTemplates({});
+                    const templates = ctx.listTemplateQueries();
                     if (!templates.length)
                         return ctx.reply('📐 No templates.');
                     const lines = templates.map(t => {
@@ -710,5 +716,6 @@ export function fleetCliOps(role, configPath) {
         }),
         closeRoom: roomId => launchFleetWorker(['room', '_delete', roomId], `room-delete-${roomId}`, configPath),
         settleTask: taskId => launchFleetWorker(['task', '_settle', taskId], `task-settle-${taskId}`, configPath),
+        recoverTask: taskId => launchFleetWorker(['task', '_recover', taskId], `task-recover-${taskId}`, configPath),
     };
 }