@ours.network/fleet 1.0.3 → 1.0.5

package/dist/owner-channel/attachments.js

@@ -94,16 +94,9 @@ function parseTranscription(value, wireId) {
             fileWireId: wireId,
         } };
 }
-// Voice notes ride "<base>; x-ours-kind=voice-message" verbatim end to end
-// (the recorder's real container varies: audio/webm Chrome/Android, audio/mp4
-// iOS Safari, audio/ogg fallback), so policy for voice messages applies to the
-// base container type. Ordinary files keep exact allowlist matching.
 function baseMime(mime) {
     return mime.split(';')[0].trim();
 }
-function policyMime(file) {
-    return file.kind === 'voice_message' ? baseMime(file.mime) : file.mime;
-}
 export function validateAttachmentSelection(files, config) {
     if (!config.enabled)
         return 'attachments are disabled for this owner channel';
@@ -111,11 +104,6 @@ export function validateAttachmentSelection(files, config) {
         return `the request exceeds the ${config.max_files_per_request}-file limit`;
     let total = 0;
     for (const file of files) {
-        const mime = policyMime(file);
-        if (file.kind === 'voice_message' && !mime.startsWith('audio/'))
-            return `voice-message MIME type ${file.mime || '(missing)'} is not an audio container`;
-        if (!config.allowed_mime.includes(mime))
-            return `MIME type ${file.mime || '(missing)'} is not allowed`;
         if (file.size > config.max_file_bytes)
             return `a file exceeds the ${config.max_file_bytes}-byte limit`;
         total += file.size;
@@ -126,7 +114,7 @@ export function validateAttachmentSelection(files, config) {
 }
 /**
  * Managed-agent -> owner egress limits. This intentionally does not consult
- * `enabled` or `allowed_mime`: those are owner -> agent admission policy.
+ * `enabled`: that is owner -> agent admission policy.
  */
 export function validateAttachmentRelaySelection(files, config) {
     if (files.length > config.max_files_per_request)
@@ -157,7 +145,7 @@ export async function prepareAttachmentDirectory(root, requestId) {
     await chmod(dir, 0o700);
     return dir;
 }
-export async function admitAttachments(files, dir, config, options = {}) {
+export async function admitAttachments(files, dir, config) {
     const admitted = [];
     let total = 0;
     for (let index = 0; index < files.length; index++) {
@@ -184,11 +172,8 @@ export async function admitAttachments(files, dir, config, options = {}) {
         total += bytes.length;
         if (total > config.max_request_bytes)
             throw new Error('retrieved attachments exceed the request size limit');
-        const declaredMime = policyMime(file);
-        const detectedMime = detectMime(bytes, declaredMime);
-        if ((options.mimePolicy ?? 'strict') === 'strict'
-            && !mimeCompatible(declaredMime, detectedMime))
-            throw new Error(`retrieved attachment content does not match declared MIME ${declaredMime}`);
+        const declaredMime = file.mime;
+        const detectedMime = detectMime(bytes, baseMime(declaredMime));
         const filename = sanitizeFilename(file.filename);
         const finalPath = join(dir, `${index + 1}-${file.wireId.slice(0, 12)}-${filename}`);
         const tmp = join(dir, `.${basename(finalPath)}.${randomUUID()}.tmp`);
@@ -417,6 +402,8 @@ export function sanitizeFilename(value) {
     return clean || 'attachment.bin';
 }
 function detectMime(bytes, declared) {
+    if (bytes.length === 0)
+        return 'application/octet-stream';
     if (bytes.subarray(0, 5).toString() === '%PDF-')
         return 'application/pdf';
     if (bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
@@ -443,27 +430,7 @@ function detectMime(bytes, declared) {
         return 'application/x-cfb';
     const text = bytes.toString('utf8');
     if (!text.includes('\ufffd') && !/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/u.test(text)) {
-        if (declared === 'application/json') {
-            try {
-                JSON.parse(text);
-                return 'application/json';
-            }
-            catch { }
-        }
         return 'text/plain';
     }
     return 'application/octet-stream';
 }
-function mimeCompatible(declared, detected) {
-    if (declared === detected)
-        return true;
-    if (['audio/wav', 'audio/x-wav'].includes(declared) && detected === 'audio/wav')
-        return true;
-    if (detected === 'application/zip' && declared.startsWith('application/vnd.openxmlformats-officedocument.'))
-        return true;
-    if (detected === 'application/x-cfb' && [
-        'application/msword', 'application/vnd.ms-excel', 'application/vnd.ms-powerpoint',
-    ].includes(declared))
-        return true;
-    return false;
-}

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

@@ -19,6 +19,8 @@ export interface OwnerChannelOptions {
     client?: OursOps;
     /** Test seam; production uses the detached ours-fleet CLI (`fleetCliOps`). */
     fleet?: OwnerFleetOps;
+    /** Read-only restart validation; production uses the shared lifecycle service. */
+    prepareRestart?: (role: string, mode: 'keep' | 'fresh') => Promise<void>;
     /** Forwarded to fleet CLI invocations spawned for owner commands. */
     configPath?: string;
     /** Deterministic clock/process seams for binder handoff tests. */
@@ -164,6 +166,7 @@ export declare class OwnerChannel implements OwnerChannelHandle {
     private binder?;
     private binderOwnedInternally;
     private readonly fleetOps;
+    private readonly prepareRestart;
     constructor(options: OwnerChannelOptions);
     start(): Promise<void>;
     drain(): Promise<void>;
@@ -222,7 +225,9 @@ export declare class OwnerChannel implements OwnerChannelHandle {
      * before an external worker starts a saga that can retire this process.
      */
     private closeRoomFromOwner;
+    private recoverRoomFromOwner;
     /** Carry a task terminal request through a worker that survives this role. */
+    private recoverTaskFromOwner;
     private terminalTaskFromOwner;
     /** Code-point-safe tail of the worklog, or undefined when there is none. */
     private readWorklogTail;

package/dist/owner-channel/channel.js

@@ -2,11 +2,17 @@ import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { mkdir, readFile, readdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
-import { DEFAULT_OWNER_ATTACHMENT_MIME, canonicalCid, } from '../config.js';
+import { canonicalCid } from '../config.js';
 import { replaceFileAtomically } from '../atomic-file.js';
-import { ACP_CANCEL_DEADLINE_EXCEEDED, SessionControlError, interruptOutcome, } from '../session/types.js';
+import { TaskRoomApplicationService } from '../application/task-room-service.js';
+import { RoleLifecycleService } from '../application/role-command-service.js';
+import { RoleRepository } from '../application/role-repository.js';
+import { FleetQueryService } from '../application/fleet-query-service.js';
+import { interruptSession, queueSessionPrompt } from '../application/session-mutations.js';
+import { pickBackend } from '../supervisor/index.js';
+import { ACP_CANCEL_DEADLINE_EXCEEDED, SessionControlError, } from '../session/types.js';
 import { VERSION } from '../version.js';
-import { renderMarkdownFailure, renderMarkdownResult, taskStatus, } from '../rooms-tasks/markdown.js';
+import { renderMarkdownFailure, renderMarkdownResult, roomStatus, taskStatus, } from '../rooms-tasks/markdown.js';
 import { dispatchOwnerCommand, fleetCliOps, isOwnerCommandText, } from './commands.js';
 import { OURS_BOUND_ELSEWHERE, OursSdkClient, oursErrorCode, } from './ours-client.js';
 import { ownerNotices, } from './notices.js';
@@ -74,10 +80,21 @@ export class OwnerChannel {
     binder;
     binderOwnedInternally = false;
     fleetOps;
+    prepareRestart;
     constructor(options) {
         this.options = options;
         this.client = options.client ?? new OursSdkClient(options.env, line => options.log(`[${options.role}] owner channel ${line}`));
         this.fleetOps = options.fleet ?? fleetCliOps(options.role, options.configPath);
+        this.prepareRestart = options.prepareRestart ?? (async (role, mode) => {
+            const backend = pickBackend();
+            const repository = new RoleRepository({ configPath: options.configPath });
+            const query = new FleetQueryService({ repository, supervisor: backend });
+            const lifecycle = new RoleLifecycleService({ repository,
+                ops: { backend, binPath: process.argv[1], log: options.log },
+                configPath: options.configPath,
+                status: async (roleId) => (await query.detail(roleId)).status });
+            await lifecycle.prepareRestart({ roleIds: [role], mode });
+        });
         this.state = new OwnerChannelState(join(options.stateDir, '.owner-channel-state.json'));
         this.authorizations = new OwnerAuthorizationState(join(options.stateDir, '.owner-channel-owners.json'), options.config.owners);
         this.conversations = new OwnerConversationState(join(options.stateDir, '.owner-channel-conversations.json'));
@@ -92,7 +109,6 @@ export class OwnerChannel {
         this.attachmentConfig = options.config.attachments ?? {
             enabled: true, max_files_per_request: 4, max_file_bytes: 10 * 1024 * 1024,
             max_request_bytes: 20 * 1024 * 1024, retention_ms: 24 * 60 * 60 * 1_000,
-            allowed_mime: [...DEFAULT_OWNER_ATTACHMENT_MIME],
         };
         const integrity = this.authorizationIntegrity();
         if (!integrity.ok)
@@ -793,7 +809,7 @@ export class OwnerChannel {
             outbox = this.outboxDir(originWireId);
             await mkdir(outbox, { recursive: true, mode: 0o700 });
             const activityCursor = this.latestEventSeq(this.options.session.eventsSince(0));
-            const queued = await this.options.session.queuePrompt(this.ownerAttachmentPrompt(sender, originWireId, requestId, admitted, group.caption), {
+            const queued = await queueSessionPrompt(this.options.session, this.ownerAttachmentPrompt(sender, originWireId, requestId, admitted, group.caption), {
                 interrupt: this.options.config.interrupt,
                 ...(this.options.config.interrupt ? { interruptSource: 'owner' } : {}),
                 origin: { kind: 'owner', requestId,
@@ -918,7 +934,7 @@ export class OwnerChannel {
         let queued;
         const activityCursor = this.latestEventSeq(this.options.session.eventsSince(0));
         try {
-            queued = await this.options.session.queuePrompt(this.ownerPrompt(sender, text, wireId), {
+            queued = await queueSessionPrompt(this.options.session, this.ownerPrompt(sender, text, wireId), {
                 interrupt: this.options.config.interrupt,
                 ...(this.options.config.interrupt ? { interruptSource: 'owner' } : {}),
                 origin: { kind: 'owner', requestId, displayText: text },
@@ -977,7 +993,7 @@ export class OwnerChannel {
             harness: this.options.harness,
             version: VERSION,
             snapshot: () => this.options.session.snapshot(),
-            interrupt: async () => interruptOutcome(await this.options.session.interrupt('owner')),
+            interrupt: () => interruptSession(this.options.session, 'owner'),
             runHarnessCommand: command => this.runHarnessCommand(sender, command, wireId),
             restart: mode => this.restartSelf(sender, mode, wireId),
             comments: () => this.commentsState(),
@@ -990,7 +1006,51 @@ export class OwnerChannel {
             },
             fleetList: () => this.fleetOps.list(),
             closeRoom: roomId => this.closeRoomFromOwner(sender, roomId, wireId),
+            recoverRoom: roomId => this.recoverRoomFromOwner(sender, roomId, wireId),
             terminalTask: (taskId, kind, outcome) => this.terminalTaskFromOwner(sender, taskId, kind, outcome, wireId),
+            recoverTask: taskId => this.recoverTaskFromOwner(sender, taskId, wireId),
+            createTask: input => new TaskRoomApplicationService(this.options.configPath).createTask({
+                ...input,
+                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id },
+            }),
+            startTask: taskId => new TaskRoomApplicationService(this.options.configPath).startTask({
+                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId,
+            }),
+            listTasks: filter => new TaskRoomApplicationService(this.options.configPath).listTasks(filter),
+            groupedTasks: filter => new TaskRoomApplicationService(this.options.configPath).groupedTasks(filter),
+            listTaskLists: () => new TaskRoomApplicationService(this.options.configPath).listTaskLists(),
+            createTaskList: name => new TaskRoomApplicationService(this.options.configPath).createTaskList({
+                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, name,
+            }),
+            renameTaskList: (name, newName) => new TaskRoomApplicationService(this.options.configPath).renameTaskList({
+                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, name, newName,
+            }),
+            deleteTaskList: (name, destination) => new TaskRoomApplicationService(this.options.configPath).deleteTaskList({
+                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, name, destination,
+            }),
+            moveTask: (taskId, list) => new TaskRoomApplicationService(this.options.configPath).moveTask({
+                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId, list,
+            }),
+            getTask: taskId => new TaskRoomApplicationService(this.options.configPath).getTask(taskId),
+            blockTask: (taskId, reason) => new TaskRoomApplicationService(this.options.configPath).blockTask({
+                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId, reason,
+            }),
+            unblockTask: taskId => new TaskRoomApplicationService(this.options.configPath).unblockTask({
+                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId,
+            }),
+            reviewTask: taskId => new TaskRoomApplicationService(this.options.configPath).reviewTask({
+                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId,
+            }),
+            deleteTask: taskId => new TaskRoomApplicationService(this.options.configPath).deleteTask({
+                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId,
+            }),
+            listRoomQueries: filter => new TaskRoomApplicationService(this.options.configPath).listRooms(filter),
+            getRoomQuery: id => new TaskRoomApplicationService(this.options.configPath).getRoomDetail(id),
+            listTemplateQueries: () => new TaskRoomApplicationService(this.options.configPath).listTemplates(),
+            getTemplateQuery: name => new TaskRoomApplicationService(this.options.configPath).getTemplate(name),
+            createRoom: input => new TaskRoomApplicationService(this.options.configPath).createRoom({
+                ...input, actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id },
+            }),
             recentEvents: limit => this.options.session.eventsSince(0).slice(-limit),
             readWorklogTail: maxChars => this.readWorklogTail(maxChars),
             reply: async (replyText) => { await this.send(sender.id, replyText, wireId); },
@@ -1009,7 +1069,7 @@ export class OwnerChannel {
     /** Queue raw slash text to the harness and report the turn's outcome. */
     async runHarnessCommand(sender, command, wireId) {
         const requestId = this.requestId(wireId);
-        const queued = await this.options.session.queuePrompt(command, {
+        const queued = await queueSessionPrompt(this.options.session, command, {
             origin: { kind: 'owner', requestId },
         });
         this.inFlight.add(wireId);
@@ -1036,6 +1096,7 @@ export class OwnerChannel {
      */
     async restartSelf(sender, mode, wireId) {
         const command = mode === 'fresh' ? '/force-restart' : '/restart';
+        await this.prepareRestart(this.options.role, mode);
         await this.send(sender.id, ownerNotices.restarting(this.options.role, command, mode), wireId);
         this.state.remember(wireId);
         this.options.log(`[${this.options.role}] owner requested ${command}`);
@@ -1046,8 +1107,9 @@ export class OwnerChannel {
      * before an external worker starts a saga that can retire this process.
      */
     async closeRoomFromOwner(sender, roomId, wireId) {
-        const { acceptManagedRoomClose, recordManagedRoomCloseError } = await import('../rooms-tasks/close.js');
-        await acceptManagedRoomClose(roomId);
+        const app = new TaskRoomApplicationService(this.options.configPath);
+        const actor = { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id };
+        await app.requestRoomDeletion({ actor, roomId });
         await this.send(sender.id, renderMarkdownFailure({
             kind: 'pending', subject: `/room delete ${roomId} ${roomId}`,
             detail: 'The deletion request was accepted and is still being settled.',
@@ -1058,24 +1120,97 @@ export class OwnerChannel {
             await this.fleetOps.closeRoom(roomId);
         }
         catch (error) {
-            await recordManagedRoomCloseError(roomId, error instanceof Error ? error.message : String(error), `External delete worker failed to start. Retry /room delete ${roomId} ${roomId}.`);
+            await app.recordRoomSettlementError({ actor, roomId,
+                error: error instanceof Error ? error.message : String(error),
+                recoveryHint: `External delete worker failed to start. Retry /room delete ${roomId} ${roomId}.` });
             throw error;
         }
     }
+    async recoverRoomFromOwner(sender, roomId, wireId) {
+        const app = new TaskRoomApplicationService(this.options.configPath);
+        const actor = { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id };
+        const result = await app.recoverRoom({ actor, roomId });
+        if (result.kind === 'deletion_worker_required') {
+            await this.send(sender.id, renderMarkdownFailure({ kind: 'pending',
+                subject: `/room recover ${roomId}`,
+                detail: 'The deletion recovery is still being settled.',
+                action: `Run /room recover ${roomId} if deletion remains pending.` }), wireId);
+            this.state.remember(wireId);
+            try {
+                await this.fleetOps.closeRoom(roomId);
+            }
+            catch (error) {
+                await app.recordRoomSettlementError({ actor, roomId,
+                    error: error instanceof Error ? error.message : String(error),
+                    recoveryHint: `External delete worker failed to start. Retry /room delete ${roomId} ${roomId}.` });
+                throw error;
+            }
+            return;
+        }
+        const r = result.orchestration;
+        await this.send(sender.id, renderMarkdownResult({ icon: '🛟', title: 'Room recovery',
+            fields: [{ label: 'Room', value: result.room.room_id, kind: 'code' },
+                { label: 'Status', value: roomStatus(result.room.state), kind: 'markdown' },
+                ...(r ? [{ label: 'Saga', value: r.saga.phase, kind: 'code' }] : [])],
+            sections: result.issues.length ? [{ heading: 'Next steps', items: result.issues }]
+                : [{ heading: 'Result', items: ['No recovery action is needed.'] }] }), wireId);
+        this.state.remember(wireId);
+    }
     /** Carry a task terminal request through a worker that survives this role. */
+    async recoverTaskFromOwner(sender, taskId, wireId) {
+        const app = new TaskRoomApplicationService(this.options.configPath);
+        const actor = { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id };
+        const begin = await app.beginTaskRecovery({ actor, taskId });
+        if (begin.kind === 'terminal_worker_required') {
+            await this.send(sender.id, renderMarkdownFailure({
+                kind: 'pending', subject: `/task recover ${taskId}`,
+                detail: 'The recovery request was accepted and is still being settled.',
+                action: `Run /task recover ${taskId} if it remains pending.`,
+            }), wireId);
+            this.state.remember(wireId);
+            try {
+                await this.fleetOps.recoverTask(taskId);
+            }
+            catch (error) {
+                await app.recordSettlementError({ actor, taskId,
+                    error: error instanceof Error ? error.message : String(error),
+                    recoveryHint: `External settle worker failed to start. Retry /task recover ${taskId}.` });
+                throw error;
+            }
+            return;
+        }
+        const { task, room, issues } = begin.result;
+        const hints = issues.map(issue => issue.code === 'waiting_cowork' ? 'Cowork socket unreachable'
+            : issue.code === 'waiting_owner_invite' ? 'Owner invite missing or invalid'
+                : issue.code === 'owner_cid_mismatch' ? 'Owner CID mismatch'
+                    : issue.code === 'member_failed' ? `Member failed at step ${issue.stepIndex}`
+                        : issue.code === 'resume_failed' ? `Resume failed: ${issue.error}`
+                            : issue.code === 'provisioning_resumed' ? 'Provisioning resumed successfully'
+                                : issue.code);
+        await this.send(sender.id, renderMarkdownResult({
+            icon: '🛟', title: 'Task recovery',
+            fields: [{ label: 'Task', value: task.task_id, kind: 'code' },
+                { label: 'Status', value: taskStatus(task.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.'] }],
+        }), wireId);
+        this.state.remember(wireId);
+    }
     async terminalTaskFromOwner(sender, taskId, kind, outcome, wireId) {
-        const { getTask } = await import('../rooms-tasks/task-state.js');
-        const { acceptTaskTerminalIntent, recordTaskTerminalIntentError, } = await import('../rooms-tasks/terminal.js');
-        const task = getTask(taskId);
-        const accepted = await acceptTaskTerminalIntent({
-            taskId, kind, roomId: task.room_id, outcome,
-        });
-        if (accepted.terminal_intent?.status === 'settled') {
+        const app = new TaskRoomApplicationService(this.options.configPath);
+        const actor = { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id };
+        const plan = kind === 'done'
+            ? await app.completeTask({ actor, taskId, outcome })
+            : await app.cancelTask({ actor, taskId });
+        if (!plan.settlementRequired) {
             await this.send(sender.id, renderMarkdownResult({
                 icon: '📋', title: 'Task terminal action complete',
                 fields: [
                     { label: 'ID', value: taskId, kind: 'code' },
-                    { label: 'Status', value: taskStatus(accepted.state), kind: 'markdown' },
+                    { label: 'Status', value: taskStatus(plan.task.state), kind: 'markdown' },
                 ],
             }), wireId);
             this.state.remember(wireId);
@@ -1091,7 +1226,10 @@ export class OwnerChannel {
             await this.fleetOps.settleTask(taskId);
         }
         catch (error) {
-            await recordTaskTerminalIntentError(taskId, error instanceof Error ? error.message : String(error), `External settle worker failed to start. Retry the identical task command or run task recover ${taskId}.`);
+            await app.recordSettlementError({
+                actor, taskId, error: error instanceof Error ? error.message : String(error),
+                recoveryHint: `External settle worker failed to start. Retry the identical task command or run task recover ${taskId}.`,
+            });
             throw error;
         }
     }
@@ -1224,7 +1362,7 @@ export class OwnerChannel {
             }
             const order = new Map(group.files.map((file, index) => [file.wireId, index]));
             retrieved.sort((a, b) => order.get(a.wireId) - order.get(b.wireId));
-            const admitted = await admitAttachments(retrieved, requestDir, this.attachmentConfig, { mimePolicy: 'report-only' });
+            const admitted = await admitAttachments(retrieved, requestDir, this.attachmentConfig);
             const digest = createHash('sha256').update(`managed-agent-attachment\0${handledWireIds.slice().sort().join('\0')}`).digest('hex');
             const sending = this.conversations.beginSend(route.contact, digest, Date.now(), 0, 'all');
             try {

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

@@ -1,6 +1,8 @@
 import type { InterruptOutcome, SessionEvent, SessionSnapshot } from '../session/types.js';
-import type { TaskOutcome, TaskTerminalIntent } from '../rooms-tasks/types.js';
+import type { RoomOrchestrationRecord, TaskOutcome, TaskRecord, TaskTerminalIntent, TaskListRecord } from '../rooms-tasks/types.js';
 import { type OwnerCommentsState } from './notices.js';
+import type { CreateRoomRequest, CreateTaskRequest, TaskRoomApplicationService } from '../application/task-room-service.js';
+import type { TaskState } from '../rooms-tasks/types.js';
 /**
  * Fleet-level effects a deterministic owner command may trigger. Production
  * uses the detached CLI (`fleetCliOps`); tests inject fakes so no command can
@@ -15,6 +17,7 @@ export interface OwnerFleetOps {
     closeRoom(roomId: string): Promise<void>;
     /** Resume a task terminal intent outside the caller role's supervisor lifecycle. */
     settleTask(taskId: string): Promise<void>;
+    recoverTask(taskId: string): Promise<void>;
 }
 /**
  * The narrow capability surface a command executor sees. Everything here is
@@ -47,8 +50,47 @@ export interface OwnerCommandContext {
     fleetList(): Promise<string>;
     /** Persist acceptance, acknowledge it, then launch the external close worker. */
     closeRoom(roomId: string): Promise<void>;
+    recoverRoom(roomId: string): Promise<void>;
     /** Persist terminal intent, acknowledge it, then launch the external settle worker. */
     terminalTask(taskId: string, kind: TaskTerminalIntent['kind'], outcome?: TaskOutcome): Promise<void>;
+    recoverTask(taskId: string): Promise<void>;
+    createTask(input: Omit<CreateTaskRequest, 'actor'>): Promise<TaskRecord>;
+    startTask(taskId: string): Promise<TaskRecord>;
+    listTasks(filter?: {
+        state?: TaskState | TaskState[];
+        list?: string;
+    }): TaskRecord[];
+    groupedTasks(filter?: {
+        state?: TaskState | TaskState[];
+        list?: string;
+    }): Array<{
+        list: TaskListRecord;
+        tasks: TaskRecord[];
+    }>;
+    listTaskLists(): TaskListRecord[];
+    createTaskList(name: string): Promise<TaskListRecord>;
+    renameTaskList(name: string, newName: string): Promise<TaskListRecord>;
+    deleteTaskList(name: string, destination?: string): Promise<{
+        deleted: TaskListRecord;
+        moved: number;
+        destination?: TaskListRecord;
+    }>;
+    moveTask(taskId: string, list: string): Promise<TaskRecord>;
+    getTask(taskId: string): {
+        task: TaskRecord;
+        orchestration: RoomOrchestrationRecord | undefined;
+    };
+    blockTask(taskId: string, reason: string): TaskRecord;
+    unblockTask(taskId: string): TaskRecord;
+    reviewTask(taskId: string): TaskRecord;
+    deleteTask(taskId: string): boolean;
+    listRoomQueries(filter?: {
+        state?: 'active' | 'provisioning';
+    }): ReturnType<TaskRoomApplicationService['listRooms']>;
+    getRoomQuery(id: string): ReturnType<TaskRoomApplicationService['getRoomDetail']>;
+    listTemplateQueries(): ReturnType<TaskRoomApplicationService['listTemplates']>;
+    getTemplateQuery(name: string): ReturnType<TaskRoomApplicationService['getTemplate']>;
+    createRoom(input: Omit<CreateRoomRequest, 'actor'>): Promise<RoomOrchestrationRecord>;
     recentEvents(limit: number): SessionEvent[];
     readWorklogTail(maxChars: number): Promise<string | undefined>;
     reply(text: string): Promise<void>;