@ours.network/fleet 1.1.0-nightly.8 → 1.1.0

package/dist/owner-channel/channel.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
-import { mkdir, readFile, readdir, rm } from 'node:fs/promises';
+import { mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { canonicalCid } from '../config.js';
 import { DAEMON_RECOVERY_DEADLINE_MS } from '../daemon-recovery.js';
@@ -11,14 +11,15 @@ 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 { ACP_CANCEL_DEADLINE_EXCEEDED, CODEX_APP_SERVER_CANCEL_DEADLINE_EXCEEDED, SessionControlError, } from '../session/types.js';
 import { VERSION } from '../version.js';
-import { renderMarkdownFailure, renderMarkdownResult, roomStatus, taskStatus, } from '../rooms-tasks/markdown.js';
-import { dispatchOwnerCommand, fleetCliOps, isOwnerCommandText, } from './commands.js';
-import { FleetCommandAuditStore, renderFleetAuditInvocation, renderFleetAuditOutcome, } from '../fleet-command-audit.js';
+import { renderMarkdownFailure, renderMarkdownResult, taskStatus, } from '../rooms-tasks/markdown.js';
+import { dispatchOwnerCommand, fleetCliOps, isOwnerCommandText, ownerTypedCommandCatalog, ownerTypedCommandText, } from './commands.js';
+import { beginFleetAuditCollection, consumeFleetAuditCollection, FleetCommandAuditStore, lifecycleEventDigestBasis, renderFleetLifecycleEvent, setFleetAuditLifecycleCheckpoint, } from '../fleet-command-audit.js';
 import { OURS_BOUND_ELSEWHERE, OursSdkClient, oursErrorCode, } from './ours-client.js';
 import { ownerNotices, } from './notices.js';
 import { DuplicateSendError, OwnerAuthorizationState, OwnerChannelState, OwnerConversationState, } from './state.js';
+import { FleetLifecycleOutbox } from './lifecycle-outbox.js';
 import { OwnerTaskState, ownerTaskAuditId, ownerTaskDigest, } from './tasks.js';
 import { AttachmentRecoveryState, admitAttachments, cleanupAttachmentRoot, parseIncomingAttachments, parseRetrievedAttachments, prepareAttachmentDirectory, recoveredAttachment, removeRequestDirectory, safeField, validateAttachmentSelection, validateAttachmentRelaySelection, writeRecoveredAttachment, } from './attachments.js';
 import { acquireOwnerBinderLease, OWNER_BIND_HANDOFF_TIMEOUT_MS, } from './binder.js';
@@ -78,6 +79,8 @@ export class OwnerChannel {
      * (a crash must replay them) but must not be queued twice while live.
      */
     inFlight = new Set();
+    /** SDK handlers entered during the current getMessages call. */
+    typedHandlersEntered = new Set();
     /** Wires already NACKed to the managed agent, so a history replay stays quiet. */
     relayNacks = new Set();
     /**
@@ -112,6 +115,7 @@ export class OwnerChannel {
     fleetOps;
     prepareRestart;
     commandAudits;
+    lifecycleOutbox;
     constructor(options) {
         this.options = options;
         this.client = options.client ?? new OursSdkClient(options.env, line => options.log(`[${options.role}] owner channel ${line}`));
@@ -128,6 +132,7 @@ export class OwnerChannel {
         });
         this.state = new OwnerChannelState(join(options.stateDir, '.owner-channel-state.json'));
         this.commandAudits = new FleetCommandAuditStore(join(options.stateDir, '.owner-channel-command-audit.json'));
+        this.lifecycleOutbox = new FleetLifecycleOutbox(join(options.stateDir, '.owner-channel-lifecycle-outbox.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'));
         this.tasks = new OwnerTaskState(join(options.stateDir, '.owner-channel-tasks.json'));
@@ -153,6 +158,8 @@ export class OwnerChannel {
             options.log(`[${options.role}] owner message recovery state corrupt; message intake disabled`);
         if (!this.attachmentRecovery.integrity())
             options.log(`[${options.role}] owner attachment recovery state corrupt; attachments disabled`);
+        if (!this.lifecycleOutbox.integrity().ok)
+            options.log(`[${options.role}] owner lifecycle outbox corrupt; lifecycle delivery disabled`);
     }
     async start() {
         this.stopping = false;
@@ -168,6 +175,7 @@ export class OwnerChannel {
             for (;;) {
                 try {
                     await this.client.bindIdentity(this.options.config.identity);
+                    await this.registerTypedCommands();
                     break;
                 }
                 catch (error) {
@@ -199,6 +207,8 @@ export class OwnerChannel {
         }
         this.startedOnce = true;
         this.ready = true;
+        await this.flushPendingFleetCommandAudits();
+        await this.flushPendingFleetLifecycle();
         // Do not make role startup wait for an old owner request to finish a turn.
         // watchLoop itself drains before every establishment, including this first
         // one, so there is no drain-to-tip race.
@@ -263,40 +273,57 @@ export class OwnerChannel {
         return this.queueManagement(async () => {
             if (!this.ready || this.stopping)
                 throw new Error('owner-channel MCP client is unavailable');
-            const model = event.model ? `, model ${event.model}` : '';
-            const monitorPolicy = event.monitor.interrupt === true
-                ? ' with interruption'
-                : event.monitor.interrupt === 'after_tool' ? ' with after-tool steering' : '';
-            const monitor = `${event.monitor.mode} monitor${monitorPolicy}`;
             const permission = event.permissionMode
-                ? `; permission ${event.permissionMode.fleetMode}, native ${event.permissionMode.nativeMode}`
-                : '';
-            const inherited = event.inherited.length
-                ? ` Supervisor inherited omitted defaults: ${event.inherited.join(', ')}.` : '';
-            await this.sendProactiveMessage(`🧑‍💻 ${event.caller} spawned ${event.lifetime} agent ${event.role} `
-                + `(${event.harness}/${event.session}${model}; ${monitor}${permission}).${inherited}`, `fleet-spawn\0${event.creationActionId}`, 0);
+                ? `${event.permissionMode.fleetMode}/${event.permissionMode.nativeMode}` : undefined;
+            await this.sendProactiveMessage(renderFleetLifecycleEvent({ kind: 'agent_started', eventId: event.creationActionId,
+                id: event.role, name: event.role,
+                lifetime: event.lifetime, brain: event.brainSummary, role: event.roleSummary,
+                harness: event.harness, session: event.session, model: event.model,
+                permissions: permission, parent: event.caller, actionId: event.creationActionId,
+                inherited: event.inherited,
+                ...(event.configuration ? { configuration: event.configuration } : {}) }), `fleet-spawn\0${event.creationActionId}`, 0);
         });
     }
+    notifyFleetLifecycle(presentations) {
+        const run = this.managementTail.then(async () => {
+            // Acceptance is durable before delivery. A detached worker may exit
+            // while the Owner channel is reconnecting; startup/recovery flushes the
+            // pending event through the existing exactly-once send ledger.
+            this.lifecycleOutbox.enqueue(presentations);
+            if (this.ready && !this.stopping)
+                await this.flushPendingFleetLifecycle();
+        });
+        this.managementTail = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async flushPendingFleetLifecycle() {
+        for (const entry of this.lifecycleOutbox.pending()) {
+            try {
+                await this.sendProactiveMessage(renderFleetLifecycleEvent(entry.presentation), `fleet-lifecycle\0${lifecycleEventDigestBasis(entry.presentation)}`, 0);
+                this.lifecycleOutbox.finish(entry.digest, 'delivered');
+            }
+            catch (error) {
+                if (error instanceof DuplicateSendError) {
+                    this.lifecycleOutbox.finish(entry.digest, error.status === 'delivered' ? 'delivered' : 'uncertain');
+                    this.options.log(`[${this.options.role}] duplicate Fleet lifecycle event suppressed`);
+                    continue;
+                }
+                // If the send crossed the uncertain boundary, the proactive ledger
+                // will refuse it on the next flush. A pre-send outage stays pending.
+                this.logError('pending Fleet lifecycle delivery deferred', error);
+                return;
+            }
+        }
+    }
     beginFleetCommandAudit(requestId, argv) {
         const run = this.managementTail.then(async () => {
             let attempt = this.commandAudits.begin(requestId, this.options.role, argv);
             if (attempt.invocation === 'delivered')
                 return attempt;
             if (attempt.invocation === 'uncertain')
-                throw new Error('fleet command invocation delivery is uncertain; execution is denied');
-            if (!this.ready || this.stopping) {
-                this.commandAudits.invocation(attempt.correlationId, this.options.role, 'uncertain');
-                this.options.log(`[${this.options.role}] fleet command invocation ${attempt.correlationId} `
-                    + 'delivery unavailable; execution denied');
-                throw new Error('owner-channel MCP client is unavailable; invocation recorded uncertain');
-            }
-            try {
-                await this.sendProactiveMessage(renderFleetAuditInvocation(attempt), `fleet-command-invocation\0${attempt.correlationId}`, 0);
-            }
-            catch (error) {
-                this.commandAudits.invocation(attempt.correlationId, this.options.role, 'uncertain');
-                throw error;
-            }
+                return attempt;
+            this.options.log(`[${this.options.role}] fleet proxy command ${attempt.correlationId} `
+                + `route=${attempt.classification.route} decision=${attempt.classification.decision}`);
             attempt = this.commandAudits.invocation(attempt.correlationId, this.options.role, 'delivered');
             return attempt;
         });
@@ -309,31 +336,56 @@ export class OwnerChannel {
                 class: input.class, effect: input.effect,
                 ...(input.exitCode === undefined ? {} : { exitCode: input.exitCode }),
                 ...(input.resourceIds ? { resourceIds: input.resourceIds } : {}),
-                ...(input.presentation ? { presentation: input.presentation } : {}),
+                ...(input.presentations ? { presentations: input.presentations } : {}),
             });
             if (attempt.outcome?.delivery === 'delivered')
                 return attempt;
             if (attempt.outcome?.delivery === 'uncertain')
-                throw new Error(`fleet command outcome delivery is uncertain after execution; effect status=${attempt.outcome.effect}`);
-            if (!this.ready || this.stopping) {
-                this.commandAudits.outcome(attempt.correlationId, this.options.role, 'uncertain');
-                this.options.log(`[${this.options.role}] fleet command outcome ${attempt.correlationId} `
-                    + `delivery unavailable after execution; effect status=${attempt.outcome?.effect}`);
-                throw new Error(`owner-channel unavailable after execution; effect status=${attempt.outcome?.effect}`);
-            }
-            try {
-                await this.sendProactiveMessage(renderFleetAuditOutcome(attempt), `fleet-command-outcome\0${attempt.correlationId}`, 0);
-            }
-            catch (error) {
-                this.commandAudits.outcome(attempt.correlationId, this.options.role, 'uncertain');
-                throw new Error(`fleet command outcome delivery is uncertain after execution; effect status=${attempt.outcome?.effect}`, { cause: error });
-            }
-            attempt = this.commandAudits.outcome(attempt.correlationId, this.options.role, 'delivered');
-            return attempt;
+                return attempt;
+            // Before the Owner sink is attached, ordinary commands have nothing to
+            // deliver. Lifecycle presentations remain in the never-attempted
+            // `sending` state and are flushed exactly once when start() makes the
+            // authenticated sink ready. A restart converts them to `uncertain`, so
+            // effects are never replayed after an unproven delivery boundary.
+            if (!attempt.outcome?.presentations?.length)
+                return this.commandAudits.outcome(attempt.correlationId, this.options.role, 'delivered');
+            if (!this.ready)
+                return attempt;
+            return this.deliverFleetCommandOutcome(attempt);
         });
         this.managementTail = run.then(() => undefined, () => undefined);
         return run;
     }
+    async flushPendingFleetCommandAudits() {
+        for (const attempt of this.commandAudits.list())
+            if (attempt.outcome?.delivery === 'sending')
+                await this.deliverFleetCommandOutcome(attempt);
+    }
+    async deliverFleetCommandOutcome(attempt) {
+        let uncertain = false;
+        try {
+            for (const event of attempt.outcome?.presentations ?? []) {
+                try {
+                    await this.sendProactiveMessage(renderFleetLifecycleEvent(event), `fleet-lifecycle\0${lifecycleEventDigestBasis(event)}`, 0);
+                }
+                catch (error) {
+                    if (error instanceof DuplicateSendError) {
+                        if (error.status !== 'delivered')
+                            uncertain = true;
+                        this.options.log(`[${this.options.role}] duplicate Fleet lifecycle event suppressed`);
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            uncertain = true;
+            this.logError(`fleet lifecycle delivery uncertain correlation=${attempt.correlationId}`, error);
+        }
+        attempt = this.commandAudits.outcome(attempt.correlationId, this.options.role, uncertain ? 'uncertain' : 'delivered');
+        return attempt;
+    }
     recover(epoch) {
         if (this.stopping)
             return Promise.reject(new Error('owner channel is stopping'));
@@ -375,6 +427,9 @@ export class OwnerChannel {
                 if (superseded())
                     throw new Error('owner recovery epoch superseded');
                 await this.recoveryStage('bind', this.client.bindIdentity(this.options.config.identity), deadlineAt);
+                if (superseded())
+                    throw new Error('owner recovery epoch superseded');
+                await this.recoveryStage('register_commands', this.registerTypedCommands(), deadlineAt);
                 if (superseded())
                     throw new Error('owner recovery epoch superseded');
                 // Journal-aware drain is the only operation allowed to mark owner mail
@@ -384,6 +439,7 @@ export class OwnerChannel {
                 if (superseded())
                     throw new Error('owner recovery epoch superseded');
                 this.ready = true;
+                await this.flushPendingFleetLifecycle();
                 this.watchTask = this.watchLoop(watchGeneration);
             }
             catch (error) {
@@ -834,27 +890,61 @@ export class OwnerChannel {
             throw new Error('the ours daemon returned invalid unread message metadata');
         const preflight = listed.slice(0, OWNER_MESSAGE_BATCH_LIMIT);
         const now = Date.now();
-        const claims = preflight.map(item => this.messageClaim(item, now));
-        const claimKeys = new Set(claims.map(item => `${item.seq}\0${item.wireId}`));
-        if (claimKeys.size !== claims.length)
+        const metadata = preflight.map(item => ({ item, claim: this.messageClaim(item, now),
+            kind: item.message_kind }));
+        if (metadata.some(item => !['text', 'command', 'command_result'].includes(item.kind)))
+            throw new Error('the ours daemon returned an unknown unread message kind');
+        // The SDK marks the entire batch read before invoking typed handlers. Claim
+        // every text AND command row first: if an earlier lifecycle handler exits
+        // this process, a later command is recovered from persistent history even
+        // though its SDK handler was never entered. Command-result rows are inert.
+        const recoverable = metadata.filter(item => item.kind !== 'command_result');
+        const claims = recoverable.map(item => item.claim);
+        const textClaims = metadata.filter(item => item.kind === 'text').map(item => item.claim);
+        const textClaimKeys = new Set(textClaims.map(item => `${item.seq}\0${item.wireId}`));
+        const preflightKeys = new Set(metadata.map(item => `${item.claim.seq}\0${item.claim.wireId}`));
+        if (preflightKeys.size !== metadata.length)
             throw new Error('the ours daemon returned duplicate unread message metadata');
         this.messageRecovery.claim(claims);
         let fresh = [];
         let remaining = 0;
         // SDK batchLimit rejects zero. An empty preflight is a read-only drain.
-        if (claims.length) {
-            const payload = await this.client.getMessages(claims.length);
-            if (!payload || !Array.isArray(payload.messages)
+        if (preflight.length) {
+            const payload = await this.client.getMessages(preflight.length);
+            if (!payload || !Array.isArray(payload.messages) || !Array.isArray(payload.command_results)
+                || !Number.isSafeInteger(payload.commands_handled) || payload.commands_handled < 0
                 || !Number.isSafeInteger(payload.remaining) || payload.remaining < 0)
                 throw new Error('the ours daemon returned an invalid claimed message batch');
             fresh = payload.messages.map(message => this.historyMessage(message));
             remaining = payload.remaining;
-            const expected = claimKeys;
+            const expected = textClaimKeys;
             const actual = new Set(fresh.map(item => `${item.seq}\0${item.wire_id}`));
-            if (fresh.length !== claims.length || actual.size !== fresh.length
+            if (fresh.length !== textClaims.length || actual.size !== fresh.length
                 || actual.size !== expected.size
                 || [...expected].some(item => !actual.has(item)))
                 throw new Error('the ours daemon claimed a different message batch than fleet journaled');
+            const expectedCommands = metadata.filter(item => item.kind === 'command');
+            if (payload.commands_handled !== expectedCommands.length)
+                throw new Error('the ours daemon handled a different typed-command batch than fleet inspected');
+            const expectedResults = new Set(metadata.filter(item => item.kind === 'command_result')
+                .map(item => `${item.claim.seq}\0${item.claim.wireId}`));
+            const actualResults = new Set(payload.command_results
+                .map(item => `${item.seq}\0${item.wire_id}`));
+            if (actualResults.size !== payload.command_results.length
+                || actualResults.size !== expectedResults.size
+                || [...expectedResults].some(item => !actualResults.has(item)))
+                throw new Error('the ours daemon returned a different typed-command result batch than fleet inspected');
+            for (const item of expectedCommands) {
+                // Invalid envelopes and unregistered commands never enter a handler;
+                // the SDK has already returned handler_failed, so consume those now.
+                // Entered harness commands keep their claim until async completion.
+                if (!this.typedHandlersEntered.has(item.claim.wireId))
+                    this.state.remember(item.claim.wireId);
+                this.typedHandlersEntered.delete(item.claim.wireId);
+            }
+            for (const item of metadata)
+                if (item.kind === 'command_result')
+                    this.state.remember(item.claim.wireId);
         }
         const merged = new Map();
         for (const message of [...recovered, ...fresh]) {
@@ -1110,6 +1200,8 @@ export class OwnerChannel {
         const wireId = this.wireId(message);
         if (!wireId || this.state.has(wireId) || this.inFlight.has(wireId))
             return false;
+        if (message.message_kind === 'command')
+            return this.handleRecoveredTypedCommand(message, wireId);
         const sender = this.sender(message);
         if (this.isAgentSender(sender.id)) {
             try {
@@ -1177,12 +1269,13 @@ export class OwnerChannel {
         catch (error) {
             await rm(outbox, { recursive: true, force: true });
             if (error instanceof SessionControlError
-                && error.reasonCode === ACP_CANCEL_DEADLINE_EXCEEDED) {
+                && (error.reasonCode === ACP_CANCEL_DEADLINE_EXCEEDED
+                    || error.reasonCode === CODEX_APP_SERVER_CANCEL_DEADLINE_EXCEEDED)) {
                 // drainAll journaled this authenticated message before delivery. The
                 // adapter generation is terminating, so leave the wire unhandled and
                 // body-free: the resumed owner channel recovers it exactly once.
                 this.options.log(`[${this.options.role}] owner request ${requestId.slice(0, 12)} `
-                    + `held for adapter resume reason=${ACP_CANCEL_DEADLINE_EXCEEDED}`);
+                    + `held for adapter resume reason=${error.reasonCode}`);
                 return false;
             }
             this.logError('request delivery failed', error);
@@ -1222,7 +1315,21 @@ export class OwnerChannel {
      * agent itself can execute /force-restart, /model, or any other command.
      */
     async handleCommand(sender, text, wireId) {
+        const provisioningCommand = async (run) => {
+            beginFleetAuditCollection();
+            setFleetAuditLifecycleCheckpoint(events => this.notifyFleetLifecycle(events));
+            try {
+                return await run();
+            }
+            finally {
+                setFleetAuditLifecycleCheckpoint(undefined);
+                const remaining = consumeFleetAuditCollection().presentations;
+                if (remaining?.length)
+                    await this.notifyFleetLifecycle(remaining);
+            }
+        };
         const ctx = {
+            authenticatedCid: sender.id,
             role: this.options.role,
             harness: this.options.harness,
             version: VERSION,
@@ -1240,16 +1347,36 @@ 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 },
+            createTask: input => provisioningCommand(async () => {
+                const service = new TaskRoomApplicationService(this.options.configPath);
+                const task = await service.createTask({
+                    ...input,
+                    actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id },
+                });
+                if (!input.backlog && !input.noRoom && task.room_id) {
+                    const outcome = service.taskProvisioningOutcome(task.task_id);
+                    if (outcome.kind === 'in_progress' && !outcome.next_action)
+                        await this.fleetOps.provisionTask(task.task_id);
+                }
+                return task;
             }),
-            startTask: taskId => new TaskRoomApplicationService(this.options.configPath).startTask({
-                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId,
+            startTask: taskId => provisioningCommand(async () => {
+                const service = new TaskRoomApplicationService(this.options.configPath);
+                const task = await service.startTask({
+                    actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId,
+                });
+                // A zero-duration observation repairs a ready notice after a crash or
+                // duplicate start without extending the start command's existing wait.
+                const outcome = await service.awaitTaskProvisioning({
+                    actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id },
+                    taskId: task.task_id, waitMs: 0,
+                });
+                if (outcome.kind === 'in_progress' && !outcome.next_action)
+                    await this.fleetOps.provisionTask(task.task_id);
+                return outcome;
             }),
+            taskProvisioningOutcome: taskId => new TaskRoomApplicationService(this.options.configPath).taskProvisioningOutcome(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(),
@@ -1275,19 +1402,29 @@ export class OwnerChannel {
             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,
-            }),
+            deleteTask: taskId => this.deleteTaskFromOwner(sender, taskId, wireId),
             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({
+            createRoom: input => provisioningCommand(() => 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); },
+            replyHtml: async (filename, html) => {
+                const directory = join(this.options.stateDir, '.owner-channel-report-outbox', this.requestId(wireId));
+                const path = join(directory, filename);
+                await mkdir(directory, { recursive: true, mode: 0o700 });
+                try {
+                    await writeFile(path, html, { flag: 'wx', mode: 0o600 });
+                    await this.client.sendFile({ contact: sender.id, path, filename, replyToWireId: wireId });
+                }
+                finally {
+                    await rm(directory, { recursive: true, force: true });
+                }
+            },
         };
         try {
             await dispatchOwnerCommand(text, ctx);
@@ -1300,6 +1437,84 @@ export class OwnerChannel {
         if (!this.inFlight.has(wireId))
             this.state.remember(wireId);
     }
+    /**
+     * Register one typed adapter per primary slash command. The adapter performs
+     * the live CID check before constructing the same slash text and entering the
+     * existing dispatcher; its null SDK result avoids duplicating the ordinary
+     * owner-channel replies that remain the command's result contract.
+     */
+    registerTypedCommands() {
+        const commands = ownerTypedCommandCatalog().map(definition => ({
+            name: definition.name,
+            description: definition.description,
+            input_schema: definition.input_schema,
+            handler: (input, context) => {
+                this.typedHandlersEntered.add(context.request_wire_id);
+                return this.handleTypedCommand(definition.name, input, context);
+            },
+        }));
+        return this.client.registerCommands(commands);
+    }
+    async handleRecoveredTypedCommand(message, wireId) {
+        let payload;
+        try {
+            const parsed = JSON.parse(String(message.body ?? message.text ?? ''));
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)
+                || Object.keys(parsed).length !== 2
+                || typeof parsed.command !== 'string'
+                || !('arguments' in parsed))
+                throw new Error('invalid command payload');
+            payload = parsed;
+        }
+        catch {
+            // The original SDK attempt would have emitted handler_failed without
+            // entering Fleet. Recovery mirrors that terminal no-effect outcome.
+            this.state.remember(wireId);
+            return true;
+        }
+        const sender = this.sender(message);
+        try {
+            await this.handleTypedCommand(payload.command, payload.arguments, {
+                sender_cid: sender.id, sender_name: sender.name, request_wire_id: wireId,
+            });
+        }
+        catch (error) {
+            // Expected handler failures (unauthorized/invalid typed input) are
+            // terminal and already recorded, just as the SDK swallows them.
+            if (!this.state.has(wireId))
+                throw error;
+        }
+        return true;
+    }
+    async handleTypedCommand(name, input, context) {
+        const sender = { id: context.sender_cid, name: context.sender_name };
+        const wireId = context.request_wire_id;
+        if (!this.isEffectiveOwner(sender.id)) {
+            this.options.log(`[${this.options.role}] owner channel ignored unauthorized typed-command sender `
+                + `${sender.id || '<unknown>'}`);
+            await this.warnOwnerOfUnauthorizedSender(sender.id);
+            if (wireId)
+                this.state.remember(wireId);
+            throw new Error('typed owner command denied');
+        }
+        try {
+            try {
+                this.conversations.recordInbound(sender.id, wireId);
+            }
+            catch (error) {
+                this.logError('owner conversation route update failed', error);
+            }
+            await this.handleCommand(sender, ownerTypedCommandText(name, input), wireId);
+            return null;
+        }
+        catch (error) {
+            // Structural typed-input failures are terminal handler_failed outcomes,
+            // not indefinitely replayable work.
+            if (wireId)
+                this.state.remember(wireId);
+            throw error;
+        }
+    }
     /** Queue raw slash text to the harness and report the turn's outcome. */
     async runHarnessCommand(sender, command, wireId) {
         const requestId = this.requestId(wireId);
@@ -1347,7 +1562,7 @@ export class OwnerChannel {
         await this.send(sender.id, renderMarkdownFailure({
             kind: 'pending', subject: `/room delete ${roomId} ${roomId}`,
             detail: 'The deletion request was accepted and is still being settled.',
-            action: `Run /room recover ${roomId} if deletion remains pending.`,
+            action: `Run /room delete ${roomId} ${roomId} again if deletion remains pending.`,
         }), wireId);
         this.state.remember(wireId);
         try {
@@ -1360,78 +1575,35 @@ export class OwnerChannel {
             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) {
+    /** Accept a permanent any-state deletion, acknowledge it, then hand cleanup to a durable worker. */
+    async deleteTaskFromOwner(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.`,
+        const accepted = await app.requestTaskDeletion({ actor, taskId });
+        if (accepted.status === 'already_absent') {
+            await this.send(sender.id, renderMarkdownResult({
+                icon: '🗑️', title: 'Task already absent',
+                fields: [{ label: 'ID', value: taskId, kind: 'code' }],
             }), 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.'] }],
+        await this.send(sender.id, renderMarkdownFailure({
+            kind: 'pending', subject: `/task delete ${taskId} ${taskId}`,
+            detail: 'The deletion was accepted; cleanup is settling in the background.',
+            action: `Repeat /task delete ${taskId} ${taskId} if it remains pending.`,
         }), wireId);
         this.state.remember(wireId);
+        try {
+            await this.fleetOps.settleTaskDeletion(taskId);
+        }
+        catch (error) {
+            await app.recordDeletionError({
+                actor, taskId, error: error instanceof Error ? error.message : String(error),
+                recoveryHint: `External delete worker failed to start. Retry /task delete ${taskId} ${taskId}.`,
+            });
+            throw error;
+        }
     }
     async terminalTaskFromOwner(sender, taskId, kind, outcome, wireId) {
         const app = new TaskRoomApplicationService(this.options.configPath);
@@ -1453,7 +1625,7 @@ export class OwnerChannel {
         await this.send(sender.id, renderMarkdownFailure({
             kind: 'pending', subject: `/task ${kind === 'done' ? 'done' : 'cancel'} ${taskId}`,
             detail: 'The terminal request was accepted and is still being settled.',
-            action: `Run /task recover ${taskId} if it remains pending.`,
+            action: `Repeat /task ${kind === 'done' ? 'done' : 'cancel'} ${taskId} if it remains pending.`,
         }), wireId);
         this.state.remember(wireId);
         try {
@@ -1462,7 +1634,7 @@ export class OwnerChannel {
         catch (error) {
             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}.`,
+                recoveryHint: `External settle worker failed to start. Retry the identical task command.`,
             });
             throw error;
         }
@@ -1920,7 +2092,8 @@ export class OwnerChannel {
                 startProgress(event);
                 // Automatic commentary is an ACP phase extension. Other backends and
                 // older adapters retain their established final-only behavior.
-                if (this.options.session.backend === 'acp')
+                if (this.options.session.capabilities?.messagePhases
+                    ?? this.options.session.backend === 'acp')
                     acceptCommentary(event);
             })
             : () => undefined;
@@ -1962,7 +2135,8 @@ export class OwnerChannel {
             enabled: this.commentsEnabled,
             baseline: this.commentsBaseline,
             // Only the ACP backend emits the phase marker commentary relaying needs.
-            supported: this.options.session.backend === 'acp',
+            supported: this.options.session.capabilities?.messagePhases
+                ?? this.options.session.backend === 'acp',
         };
     }
     /** Model-authored commentary only; raw protocol/tool data never reaches here. */