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

package/dist/fleet-command-audit.d.ts

@@ -8,6 +8,8 @@ export declare class FleetCliExit extends Error {
 }
 export type FleetAuditPresentation = {
     kind: 'agent_started';
+    eventId: string;
+    id: string;
     name: string;
     lifetime: 'permanent' | 'temporary';
     brain: string;
@@ -21,40 +23,65 @@ export type FleetAuditPresentation = {
     inherited: string[];
 } | {
     kind: 'task';
-    operation: string;
+    operation: 'create' | 'start' | 'work' | 'block' | 'unblock' | 'review' | 'done' | 'cancel' | 'finish' | 'delete' | 'settling';
+    eventId: string;
     id: string;
     title?: string;
     previousState?: string;
     newState: string;
     template?: string;
     roomId?: string;
+    revision?: string;
+    list?: string;
     agents: Array<{
         name: string;
         brain?: string;
         role: string;
+        permissions?: string;
     }>;
 } | {
     kind: 'room';
-    operation: string;
+    operation: 'create' | 'activate' | 'close' | 'delete';
+    eventId: string;
     id: string;
     previousState?: string;
     newState: string;
+    revision?: string;
+    name?: string;
     template?: string;
+    taskId?: string;
     participants: Array<{
         name: string;
+        id?: string;
+        brain?: string;
         role: string;
+        permissions?: string;
     }>;
+} | {
+    kind: 'lifecycle_failure';
+    eventId: string;
+    resource: 'Agent' | 'Task' | 'Room';
+    id: string;
+    state: string;
+    category: 'provision_failed' | 'provision_pending' | 'readiness_failed' | 'settlement_failed' | 'settlement_pending' | 'cleanup_failed' | 'cleanup_pending';
 };
+/** Commands are Owner-silent unless they record one of these semantic lifecycle kinds. */
+export declare const FLEET_LIFECYCLE_EVENT_KINDS: readonly ["agent_started", "task", "room", "lifecycle_failure"];
+/** Stable semantic dedupe basis: resource kind + stable resource ID + transition/action ID. */
+export declare function lifecycleEventDigestBasis(value: FleetAuditPresentation): string;
 export declare function beginFleetAuditCollection(): void;
 export declare function recordFleetAuditResource(kind: 'agent' | 'task' | 'room', id: string | undefined): void;
-export declare function recordFleetAuditPresentation(value: FleetAuditPresentation): void;
+type FleetAuditPresentationInput = FleetAuditPresentation extends infer T ? T extends FleetAuditPresentation ? Omit<T, 'eventId'> & {
+    eventId?: string;
+} : never : never;
+export declare function recordFleetAuditPresentation(value: FleetAuditPresentationInput): void;
 export declare function recordFleetAuditFailure(failure: {
     class: FleetCommandOutcomeClass;
     effect: 'not_started' | 'completed' | 'unknown';
 }): void;
 export declare function consumeFleetAuditCollection(): {
     resourceIds?: Record<string, string>;
-    presentation?: FleetAuditPresentation;
+    presentations?: FleetAuditPresentation[];
     failure?: {
         class: FleetCommandOutcomeClass;
         effect: 'not_started' | 'completed' | 'unknown';
@@ -81,7 +108,7 @@ export interface FleetAuditAttempt {
         effect: 'not_started' | 'completed' | 'unknown';
         delivery: 'sending' | 'delivered' | 'uncertain';
         resourceIds?: Record<string, string>;
-        presentation?: FleetAuditPresentation;
+        presentations?: FleetAuditPresentation[];
     };
 }
 export declare const fleetProxyCommandInventory: Readonly<{
@@ -90,6 +117,7 @@ export declare const fleetProxyCommandInventory: Readonly<{
 export declare const fleetProxyTopLevelInventory: Readonly<{
     safeRead: string[];
     agent: string[];
+    public: string[];
     denied: string[];
     hidden: string[];
     aliases: string[];
@@ -125,7 +153,8 @@ export declare function validateFleetAuditFinish(value: unknown): asserts value
     exitCode?: number;
     effect: 'not_started' | 'completed' | 'unknown';
     resourceIds?: Record<string, string>;
-    presentation?: FleetAuditPresentation;
+    presentations?: FleetAuditPresentation[];
 };
-export declare function renderFleetAuditInvocation(attempt: FleetAuditAttempt): string;
-export declare function renderFleetAuditOutcome(attempt: FleetAuditAttempt): string;
+/** Compact Owner presentation. It intentionally has no command, argv, environment, or correlation data. */
+export declare function renderFleetLifecycleEvent(value: FleetAuditPresentation): string;
+export {};

package/dist/fleet-command-audit.js

@@ -13,15 +13,35 @@ export class FleetCliExit extends Error {
         this.effect = effect;
     }
 }
+/** Commands are Owner-silent unless they record one of these semantic lifecycle kinds. */
+export const FLEET_LIFECYCLE_EVENT_KINDS = Object.freeze([
+    'agent_started', 'task', 'room', 'lifecycle_failure',
+]);
+/** Stable semantic dedupe basis: resource kind + stable resource ID + transition/action ID. */
+export function lifecycleEventDigestBasis(value) {
+    const resourceKind = value.kind === 'lifecycle_failure' ? value.resource : value.kind;
+    return `${resourceKind}\0${value.id}\0${value.eventId}`;
+}
 let collection;
-export function beginFleetAuditCollection() { collection = { resourceIds: {} }; }
+export function beginFleetAuditCollection() { collection = { resourceIds: {}, presentations: [] }; }
 export function recordFleetAuditResource(kind, id) {
     if (id && collection)
         collection.resourceIds[kind] = id;
 }
 export function recordFleetAuditPresentation(value) {
-    if (collection)
-        collection.presentation = structuredClone(value);
+    if (collection && FLEET_LIFECYCLE_EVENT_KINDS.includes(value.kind)) {
+        const basis = value.eventId ?? (value.kind === 'agent_started' ? value.actionId
+            : value.kind === 'task' || value.kind === 'room'
+                ? `${value.operation}:${value.revision ?? `${value.previousState ?? 'none'}:${value.newState}`}`
+                : `${value.category}:${value.state}`);
+        collection.presentations.push(structuredClone({ ...value, eventId: basis }));
+        if (value.kind === 'task')
+            collection.resourceIds.task = value.id;
+        if (value.kind === 'room')
+            collection.resourceIds.room = value.id;
+        if (value.kind === 'agent_started')
+            collection.resourceIds.agent = value.id;
+    }
 }
 export function recordFleetAuditFailure(failure) { if (collection)
     collection.failure = failure; }
@@ -30,7 +50,7 @@ export function consumeFleetAuditCollection() {
     collection = undefined;
     return {
         ...(current && Object.keys(current.resourceIds).length ? { resourceIds: current.resourceIds } : {}),
-        ...(current?.presentation ? { presentation: current.presentation } : {}),
+        ...(current?.presentations.length ? { presentations: current.presentations } : {}),
         ...(current?.failure ? { failure: current.failure } : {}),
     };
 }
@@ -43,12 +63,11 @@ const AGENT_SURFACES = {
     room: new Set(['create', 'list', 'show', 'open', 'members', 'delete', 'close', 'recover']),
 };
 export const fleetProxyCommandInventory = Object.freeze(Object.fromEntries(Object.entries(AGENT_SURFACES).map(([surface, commands]) => [surface, [...commands]])));
-const DENIED = new Set([
-    'up', 'down', 'restart', 'force-restart', 'attach', 'send', 'loops', 'owner-channel',
-    'watchdog-run', 'watchdog-report', 'rm', 'init', 'web',
-]);
 export const fleetProxyTopLevelInventory = Object.freeze({
-    safeRead: [...SAFE_READ], agent: Object.keys(AGENT_SURFACES), denied: [...DENIED],
+    safeRead: [...SAFE_READ], agent: Object.keys(AGENT_SURFACES), public: [
+        'up', 'down', 'restart', 'force-restart', 'attach', 'send', 'loops', 'owner-channel',
+        'watchdog-run', 'watchdog-report', 'rm', 'init', 'web',
+    ], denied: [],
     hidden: ['_run', '_run-temp', '_run-watchdog', '_run-watchdogs'], aliases: ['man'],
 });
 const globalValueOptions = new Set(['-c', '--configuration']);
@@ -92,13 +111,14 @@ export function classifyFleetArgv(argv) {
         if (sub.startsWith('_'))
             return { command: `${command} ${sub}`, route: 'supervisor-proxy/internal', decision: 'deny' };
         if (command !== 'spawn' && !AGENT_SURFACES[command].has(sub))
-            return { command: `${command} ${sub}`, route: 'supervisor-proxy/unsupported', decision: 'unsupported' };
+            return { command: `${command} ${sub}`, route: `supervisor-proxy/${command}`, decision: 'allow' };
         return { command: sub.startsWith('-') ? command : `${command} ${sub}`,
             route: `supervisor-proxy/${command}`, decision: 'allow' };
     }
-    if (DENIED.has(command))
-        return { command, route: 'supervisor-proxy/permission-denied', decision: 'deny' };
-    return { command, route: 'supervisor-proxy/unsupported', decision: 'unsupported' };
+    // The proxy is attribution and routing, not a product permission boundary.
+    // Commander validates every public command. Hidden process entry points above
+    // remain guarded because recursively invoking them breaks the supervisor protocol.
+    return { command, route: 'supervisor-proxy/public', decision: 'allow' };
 }
 const marker = (value) => value === '' ? '[REDACTED:empty]' : '[REDACTED:value]';
 const sensitiveValueFlags = new Set([
@@ -251,7 +271,7 @@ export class FleetCommandAuditStore {
             const prior = { class: attempt.outcome.class, effect: attempt.outcome.effect,
                 ...(attempt.outcome.exitCode === undefined ? {} : { exitCode: attempt.outcome.exitCode }),
                 ...(attempt.outcome.resourceIds ? { resourceIds: attempt.outcome.resourceIds } : {}),
-                ...(attempt.outcome.presentation ? { presentation: attempt.outcome.presentation } : {}) };
+                ...(attempt.outcome.presentations ? { presentations: attempt.outcome.presentations } : {}) };
             if (JSON.stringify(prior) !== JSON.stringify(outcome))
                 throw new Error('conflicting fleet command outcome for existing correlation');
         }
@@ -293,7 +313,7 @@ export function validateFleetAuditBegin(value) {
 }
 export function validateFleetAuditFinish(value) {
     const input = value;
-    const allowed = ['correlationId', 'class', 'exitCode', 'effect', 'resourceIds', 'presentation'];
+    const allowed = ['correlationId', 'class', 'exitCode', 'effect', 'resourceIds', 'presentations'];
     const resources = input?.resourceIds;
     if (!input || Object.keys(input).some(key => !allowed.includes(key))
         || typeof input.correlationId !== 'string' || !UUID.test(input.correlationId)
@@ -302,7 +322,8 @@ export function validateFleetAuditFinish(value) {
         || (resources !== undefined && (!resources || typeof resources !== 'object' || Array.isArray(resources)
             || Object.entries(resources).some(([key, id]) => !['agent', 'task', 'room'].includes(key)
                 || typeof id !== 'string' || !SAFE_RESOURCE_ID.test(id))))
-        || (input.presentation !== undefined && !validPresentation(input.presentation)))
+        || (input.presentations !== undefined && (!Array.isArray(input.presentations)
+            || input.presentations.length > 128 || !input.presentations.every(validPresentation))))
         throw new Error('invalid fleet audit finish fields');
 }
 function validPresentation(value) {
@@ -312,64 +333,101 @@ function validPresentation(value) {
     const safe = (v) => typeof v === 'string' && SAFE_RESOURCE_ID.test(v);
     const text = (v) => typeof v === 'string' && v.length <= 256
         && !/[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u.test(v);
+    const exact = (record, keys) => Object.keys(record).every(key => keys.includes(key));
+    const transition = (allowed) => typeof p.operation === 'string' && typeof p.newState === 'string'
+        && allowed[p.operation]?.includes(`${String(p.previousState ?? 'none')}→${p.newState}`);
     if (p.kind === 'agent_started')
-        return safe(p.name) && ['permanent', 'temporary'].includes(String(p.lifetime))
+        return exact(p, ['kind', 'eventId', 'id', 'name', 'lifetime', 'brain', 'role',
+            'harness', 'session', 'model', 'permissions', 'parent', 'actionId', 'inherited'])
+            && safe(p.eventId) && safe(p.id) && safe(p.name) && ['permanent', 'temporary'].includes(String(p.lifetime))
             && text(p.brain) && text(p.role) && safe(p.harness) && p.session === 'acp' && safe(p.parent) && safe(p.actionId)
             && (p.model === undefined || text(p.model)) && (p.permissions === undefined || text(p.permissions))
             && Array.isArray(p.inherited) && p.inherited.every(text);
     if (p.kind === 'task')
-        return safe(p.operation) && safe(p.id) && safe(p.newState)
+        return exact(p, ['kind', 'operation', 'eventId', 'id', 'title', 'previousState',
+            'newState', 'template', 'roomId', 'revision', 'list', 'agents'])
+            && ['create', 'start', 'work', 'block', 'unblock', 'review', 'done',
+                'cancel', 'finish', 'delete', 'settling'].includes(String(p.operation)) && safe(p.eventId) && safe(p.id) && safe(p.newState)
+            && transition({ create: ['none→backlog', 'none→provisioning', 'none→active'],
+                start: ['backlog→provisioning'], work: ['provisioning→active'],
+                block: ['backlog→backlog', 'provisioning→provisioning', 'active→active', 'review→review'],
+                unblock: ['backlog→backlog', 'provisioning→provisioning', 'active→active', 'review→review'],
+                review: ['active→review'], done: ['review→done'], finish: ['active→done', 'review→done'],
+                cancel: ['backlog→cancelled', 'provisioning→cancelled', 'active→cancelled', 'review→cancelled'],
+                delete: ['done→deleted'], settling: ['active→active', 'review→review', 'backlog→backlog',
+                    'provisioning→provisioning'] })
             && (p.title === undefined || text(p.title)) && (p.previousState === undefined || safe(p.previousState))
             && (p.template === undefined || text(p.template)) && (p.roomId === undefined || safe(p.roomId))
+            && (p.list === undefined || text(p.list)) && (p.revision === undefined || text(p.revision))
             && Array.isArray(p.agents) && p.agents.length <= 64
-            && p.agents.every(a => a && typeof a === 'object' && safe(a.name)
+            && p.agents.every(a => a && typeof a === 'object'
+                && exact(a, ['name', 'brain', 'role', 'permissions'])
+                && safe(a.name)
                 && text(a.role)
-                && (a.brain === undefined || text(a.brain)));
+                && (a.brain === undefined || text(a.brain))
+                && (a.permissions === undefined || text(a.permissions)));
     if (p.kind === 'room')
-        return safe(p.operation) && safe(p.id) && safe(p.newState)
+        return exact(p, ['kind', 'operation', 'eventId', 'id', 'previousState', 'newState',
+            'revision', 'name', 'template', 'taskId', 'participants'])
+            && ['create', 'activate', 'close', 'delete'].includes(String(p.operation))
+            && safe(p.eventId) && safe(p.id) && safe(p.newState)
+            && transition({ create: ['none→provisioning'], activate: ['provisioning→active'],
+                close: ['active→closing', 'provisioning→closing'],
+                delete: ['closing→deleted'] })
             && (p.previousState === undefined || safe(p.previousState))
-            && (p.template === undefined || text(p.template))
+            && (p.name === undefined || text(p.name)) && (p.template === undefined || text(p.template))
+            && (p.taskId === undefined || safe(p.taskId)) && (p.revision === undefined || text(p.revision))
             && Array.isArray(p.participants) && p.participants.length <= 64
-            && p.participants.every(a => a && typeof a === 'object' && safe(a.name)
-                && text(a.role));
+            && p.participants.every(a => a && typeof a === 'object'
+                && exact(a, ['name', 'id', 'brain', 'role', 'permissions'])
+                && safe(a.name)
+                && text(a.role)
+                && (a.id === undefined || safe(a.id))
+                && (a.brain === undefined || text(a.brain))
+                && (a.permissions === undefined || text(a.permissions)));
+    if (p.kind === 'lifecycle_failure')
+        return exact(p, ['kind', 'eventId', 'resource', 'id', 'state', 'category'])
+            && ['Agent', 'Task', 'Room'].includes(String(p.resource))
+            && safe(p.eventId) && safe(p.id) && safe(p.state) && ['provision_failed', 'provision_pending', 'readiness_failed', 'settlement_failed',
+            'settlement_pending', 'cleanup_failed', 'cleanup_pending'].includes(String(p.category));
     return false;
 }
-export function renderFleetAuditInvocation(attempt) {
-    return ['🧾 Fleet command invoked', `Correlation: ${attempt.correlationId}`, `Agent: ${attempt.caller}`,
-        `Route: ${attempt.classification.route}`, `Fleet action: ${attempt.classification.command}`,
-        `Decision: ${attempt.classification.decision}`, `Invoked: ${attempt.invokedAt}`,
-        `Raw argv (redacted): ${JSON.stringify(attempt.argv)}`].join('\n');
-}
-export function renderFleetAuditOutcome(attempt) {
-    if (!attempt.outcome)
-        throw new Error('fleet command audit outcome is absent');
-    return ['🧾 Fleet command outcome', `Correlation: ${attempt.correlationId}`, `Agent: ${attempt.caller}`,
-        `Route: ${attempt.classification.route}`, `Fleet action: ${attempt.classification.command}`,
-        `Result: ${attempt.outcome.class}`, `Effect: ${attempt.outcome.effect}`,
-        ...(attempt.outcome.exitCode === undefined ? [] : [`Exit: ${attempt.outcome.exitCode}`]),
-        ...Object.entries(attempt.outcome.resourceIds ?? {}).sort(([a], [b]) => a.localeCompare(b))
-            .map(([kind, id]) => `${kind[0]?.toUpperCase()}${kind.slice(1)} ID: ${id}`),
-        `Completed: ${attempt.outcome.completedAt}`, `Raw argv (redacted): ${JSON.stringify(attempt.argv)}`,
-        ...renderPresentation(attempt.outcome.presentation)].join('\n');
-}
-function renderPresentation(value) {
-    if (!value)
-        return [];
-    if (value.kind === 'agent_started')
-        return ['Structured result: Agent started', `Agent: ${value.name}`,
-            `Brain: ${value.brain}`, `Role: ${value.role}`,
-            `Runtime: ${value.harness}/${value.session}${value.model ? ` model=${value.model}` : ''}`,
-            ...(value.permissions ? [`Permissions: ${value.permissions}`] : []), `Parent: ${value.parent}`,
-            `Agent action ID: ${value.actionId}`,
-            `Inheritance: ${value.inherited.length ? value.inherited.join(', ') : 'none'}`];
-    if (value.kind === 'task')
-        return ['Structured result: Task', `Operation: ${value.operation}`,
-            `Task: ${value.title ? `${value.title} (` : ''}${value.id}${value.title ? ')' : ''}`,
-            `Status: ${value.previousState ?? 'unresolved'} -> ${value.newState}`,
-            ...(value.template ? [`Template: ${value.template}`] : []), ...(value.roomId ? [`Room: ${value.roomId}`] : []),
-            `Responsible Agents: ${value.agents.length ? value.agents.map(a => `${a.name} [Brain ${a.brain ?? 'unresolved'}; Role ${a.role}]`).join('; ') : 'none'}`];
-    return ['Structured result: Room', `Operation: ${value.operation}`, `Room: ${value.id}`,
-        `Status: ${value.previousState ?? 'unresolved'} -> ${value.newState}`,
-        ...(value.template ? [`Template: ${value.template}`] : []),
-        `Participants: ${value.participants.length ? value.participants.map(a => `${a.name} [Role ${a.role}]`).join('; ') : 'none'}`];
+/** Compact Owner presentation. It intentionally has no command, argv, environment, or correlation data. */
+export function renderFleetLifecycleEvent(value) {
+    if (value.kind === 'lifecycle_failure') {
+        const actions = {
+            provision_failed: 'Inspect Fleet service logs, correct configuration, then recover the resource.',
+            provision_pending: 'Run Task or Room recover after checking member readiness.',
+            readiness_failed: 'Inspect the Agent log, correct its configuration, then retry creation.',
+            settlement_failed: 'Inspect Fleet service logs, then run Task recover.',
+            settlement_pending: 'Run Task recover to continue settlement.',
+            cleanup_failed: 'Inspect Fleet service logs, then run Room recover.',
+            cleanup_pending: 'Run Room recover to continue cleanup.',
+        };
+        const lifecycle = value.category.endsWith('_pending') ? 'lifecycle pending' : 'lifecycle failure';
+        return `⚠️ ${value.resource} ${value.id} ${lifecycle} (${value.category}); `
+            + `state ${value.state}. Action: ${actions[value.category]}`;
+    }
+    if (value.kind === 'agent_started') {
+        const permission = value.permissions ? `; permissions ${value.permissions}` : '';
+        return `🧑‍💻 ${value.parent} spawned ${value.lifetime} Agent ${value.name} (${value.id}) — ready. `
+            + `Brain ${value.brain ?? 'unresolved'}; Role ${value.role ?? 'unresolved'}${permission}.`;
+    }
+    if (value.kind === 'task') {
+        const title = value.title ? ` “${value.title}”` : '';
+        const context = [value.list ? `List ${value.list}` : undefined,
+            value.template ? `template ${value.template}` : undefined,
+            value.roomId ? `Room ${value.roomId}` : undefined].filter(Boolean).join('; ');
+        const agents = value.agents.length ? ` Agents: ${value.agents.map(agent => `${agent.name} [Brain ${agent.brain ?? 'unresolved'}; Role ${agent.role}`
+            + `${agent.permissions ? `; permissions ${agent.permissions}` : ''}]`).join('; ')}.` : '';
+        return `📋 Task${title} (${value.id}) ${value.operation}: `
+            + `${value.previousState ?? 'none'} → ${value.newState}.${context ? ` ${context}.` : ''}${agents}`;
+    }
+    const context = [value.template ? `template ${value.template}` : undefined,
+        value.taskId ? `Task ${value.taskId}` : undefined].filter(Boolean).join('; ');
+    const participants = value.participants.length ? ` Participants: ${value.participants.map(participant => `${participant.name}${participant.id ? ` (${participant.id})` : ''} [Role ${participant.role}`
+        + `${participant.brain ? `; Brain ${participant.brain}` : ''}`
+        + `${participant.permissions ? `; permissions ${participant.permissions}` : ''}]`).join('; ')}.` : '';
+    return `🏠 Room${value.name ? ` “${value.name}”` : ''} (${value.id}) ${value.operation}: `
+        + `${value.previousState ?? 'none'} → ${value.newState}.${context ? ` ${context}.` : ''}${participants}`;
 }

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

@@ -53,7 +53,7 @@ export interface OwnerChannelHandle {
         exitCode?: number;
         effect: 'not_started' | 'completed' | 'unknown';
         resourceIds?: Record<string, string>;
-        presentation?: FleetAuditPresentation;
+        presentations?: FleetAuditPresentation[];
     }): Promise<FleetAuditAttempt>;
 }
 export declare const OWNER_RECOVERY_QUEUE_CAPACITY = 32;
@@ -223,7 +223,7 @@ export declare class OwnerChannel implements OwnerChannelHandle {
         exitCode?: number;
         effect: 'not_started' | 'completed' | 'unknown';
         resourceIds?: Record<string, string>;
-        presentation?: FleetAuditPresentation;
+        presentations?: FleetAuditPresentation[];
     }): Promise<FleetAuditAttempt>;
     recover(epoch: string): Promise<void>;
     private recoveryStage;

package/dist/owner-channel/channel.js

@@ -15,7 +15,7 @@ import { ACP_CANCEL_DEADLINE_EXCEEDED, SessionControlError, } from '../session/t
 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 { FleetCommandAuditStore, lifecycleEventDigestBasis, renderFleetLifecycleEvent, } 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';
@@ -263,18 +263,14 @@ 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 }), `fleet-spawn\0${event.creationActionId}`, 0);
         });
     }
     beginFleetCommandAudit(requestId, argv) {
@@ -283,20 +279,9 @@ export class OwnerChannel {
             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,26 +294,34 @@ 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}`);
-            }
+                return attempt;
+            let uncertain = false;
             try {
-                await this.sendProactiveMessage(renderFleetAuditOutcome(attempt), `fleet-command-outcome\0${attempt.correlationId}`, 0);
+                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) {
-                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 });
+                uncertain = true;
+                this.logError(`fleet lifecycle delivery uncertain correlation=${attempt.correlationId}`, error);
             }
-            attempt = this.commandAudits.outcome(attempt.correlationId, this.options.role, 'delivered');
+            attempt = this.commandAudits.outcome(attempt.correlationId, this.options.role, uncertain ? 'uncertain' : 'delivered');
             return attempt;
         });
         this.managementTail = run.then(() => undefined, () => undefined);

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

@@ -1,5 +1,7 @@
 /** A send whose (dedupe-scoped) digest was already recorded: it must not repeat. */
 export declare class DuplicateSendError extends Error {
+    readonly status: OwnerProactiveSend['status'];
+    constructor(status: OwnerProactiveSend['status']);
 }
 /** Durable bounded dedupe containing wire IDs only — never message or reply plaintext. */
 export declare class OwnerChannelState {

package/dist/owner-channel/state.js

@@ -5,6 +5,11 @@ import { replaceFileAtomically } from '../atomic-file.js';
 import { canonicalCid } from '../config.js';
 /** A send whose (dedupe-scoped) digest was already recorded: it must not repeat. */
 export class DuplicateSendError extends Error {
+    status;
+    constructor(status) {
+        super('duplicate proactive owner message refused');
+        this.status = status;
+    }
 }
 /** Durable bounded dedupe containing wire IDs only — never message or reply plaintext. */
 export class OwnerChannelState {
@@ -184,8 +189,9 @@ export class OwnerConversationState {
         // 'all' scope serves wire-keyed idempotency: a crash replay must not
         // deliver the same wire to a second owner after the route moved.
         const scope = dedupe === 'all' ? this.sends : recent;
-        if (scope.some(send => send.digest === digest))
-            throw new DuplicateSendError('duplicate proactive owner message refused');
+        const duplicate = scope.find(send => send.digest === digest);
+        if (duplicate)
+            throw new DuplicateSendError(duplicate.status);
         const last = recent.at(-1);
         if (last && now - last.at < minIntervalMs)
             throw new Error(`proactive owner messages are rate-limited to one every ${minIntervalMs}ms`);