@ours.network/fleet 1.1.0-nightly.4 → 1.1.0-nightly.6

package/dist/rooms-tasks/cli.js

@@ -1,4 +1,5 @@
 import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { loadConfig, ConfigError } from '../config.js';
 import { provisionMembers, getBinPath } from './provision.js';
 import { launchFleetWorker } from './external-worker.js';
@@ -9,6 +10,7 @@ import { createCoworkAdapter, CoworkProtocolError } from './cowork-adapter.js';
 import { markdownCode, markdownProse, renderMarkdownFailure, renderMarkdownList, renderMarkdownResult, roomStatus, taskStatus, } from './markdown.js';
 import { TaskRoomApplicationError, TaskRoomApplicationService } from '../application/task-room-service.js';
 import { TaskListError } from './task-lists.js';
+import { recordFleetAuditFailure, recordFleetAuditPresentation, recordFleetAuditResource, } from '../fleet-command-audit.js';
 class TaskRoomPublicError extends Error {
     code;
     fields;
@@ -89,8 +91,29 @@ function die(e) {
     const msg = e instanceof TaskRoomPublicError
         ? taskRoomPublicFailure(e).legacy : e instanceof Error ? e.message : String(e);
     process.stderr.write(`error: ${msg}\n`);
+    recordFleetAuditFailure(classifyTaskRoomFailure(e));
     process.exit(1);
 }
+function classifyTaskRoomFailure(e) {
+    if (e instanceof TaskRoomApplicationError)
+        e = taskRoomPublicError(e.code, e.fields);
+    if (e instanceof TaskRoomPublicError || e instanceof TaskListError || e instanceof ConfigError)
+        return { class: 'validation', effect: 'not_started' };
+    if (e instanceof TaskStateError) {
+        const known = /^task not found: [A-Za-z0-9_-]{1,128}$/u.test(e.message)
+            || e.message === 'invalid task ID: expected the canonical 17-character lowercase ID'
+            || isKnownTaskStateMessage(e.message);
+        return known ? { class: 'validation', effect: 'not_started' }
+            : { class: 'runtime', effect: 'unknown' };
+    }
+    if (e instanceof RoomStateError) {
+        const known = /^room not found: [A-Za-z0-9_-]{1,128}$/u.test(e.message)
+            || isKnownRoomStateMessage(e.message);
+        return known ? { class: 'validation', effect: 'not_started' }
+            : { class: 'runtime', effect: 'unknown' };
+    }
+    return { class: 'runtime', effect: 'unknown' };
+}
 const TASK_STATE_WORD = '(?:backlog|provisioning|active|review|done|cancelled|failed)';
 const SAFE_ID_WORD = '[A-Za-z0-9_-]{1,128}';
 function isKnownTaskStateMessage(message) {
@@ -127,6 +150,7 @@ function dieTaskRoom(e) {
             action: failure.action,
         });
         process.stderr.write(`${output}\n`);
+        recordFleetAuditFailure({ class: 'validation', effect: 'not_started' });
         process.exit(1);
     }
     if (e instanceof TaskListError) {
@@ -142,6 +166,7 @@ function dieTaskRoom(e) {
                     : 'Use a valid NFC-normalized name of at most 64 Unicode code points.',
         });
         process.stderr.write(`${output}\n`);
+        recordFleetAuditFailure({ class: 'validation', effect: 'not_started' });
         process.exit(1);
     }
     const taskMissing = e instanceof TaskStateError
@@ -167,6 +192,7 @@ function dieTaskRoom(e) {
                     : 'Retry once; if it repeats, run ours-fleet doctor and inspect the role logs.',
     });
     process.stderr.write(`${output}\n`);
+    recordFleetAuditFailure(classifyTaskRoomFailure(e));
     process.exit(1);
 }
 const taskListMarkdown = (tasks, title = 'Tasks') => renderMarkdownList({
@@ -175,23 +201,61 @@ const taskListMarkdown = (tasks, title = 'Tasks') => renderMarkdownList({
         + ` — List ${markdownCode(t.list_name ?? 'default')}`
         + (t.blocked ? ` — 🚧 Blocked: ${markdownProse(t.blocked.reason)}` : '')),
 });
-const taskActionMarkdown = (title, task, fields = []) => renderMarkdownResult({
-    icon: '📋', title,
-    fields: [
-        { label: 'ID', value: task.task_id, kind: 'code' },
-        { label: 'Status', value: taskStatus(task.state), kind: 'markdown' },
-        { label: 'List', value: task.list_name ?? 'default', kind: 'code' },
-        ...fields,
-    ],
-});
-const roomActionMarkdown = (title, room, fields = []) => renderMarkdownResult({
-    icon: '🏠', title,
-    fields: [
-        { label: 'ID', value: room.room_id, kind: 'code' },
-        { label: 'Status', value: roomStatus(room.state), kind: 'markdown' },
-        ...fields,
-    ],
-});
+const taskActionMarkdown = (title, task, fields = []) => {
+    recordFleetAuditResource('task', task.task_id);
+    if (task.room_id)
+        recordFleetAuditResource('room', task.room_id);
+    return renderMarkdownResult({
+        icon: '📋', title,
+        fields: [
+            { label: 'ID', value: task.task_id, kind: 'code' },
+            { label: 'Status', value: taskStatus(task.state), kind: 'markdown' },
+            { label: 'List', value: task.list_name ?? 'default', kind: 'code' },
+            ...fields,
+        ],
+    });
+};
+function safeBrainSummary(definition) {
+    const brain = definition?.brain;
+    if (!brain || typeof brain !== 'object' || Array.isArray(brain))
+        return 'unresolved';
+    const selection = brain;
+    if (typeof selection.ref === 'string')
+        return `ref:${selection.ref}`;
+    if (!Object.hasOwn(selection, 'inline'))
+        return 'unresolved';
+    const fingerprint = createHash('sha256').update(JSON.stringify(selection.inline)).digest('hex').slice(0, 16);
+    return `inline:sha256:${fingerprint}`;
+}
+function auditTask(operation, task, previousState, newState = task.state) {
+    recordFleetAuditResource('task', task.task_id);
+    if (task.room_id)
+        recordFleetAuditResource('room', task.room_id);
+    const room = task.room_id ? getRoomRecord(task.room_id) : undefined;
+    const brains = new Map(room?.member_seats.map(seat => [seat.role_name, safeBrainSummary(seat.launch?.agent_definition)]) ?? []);
+    recordFleetAuditPresentation({ kind: 'task', operation, id: task.task_id, title: task.title,
+        previousState, newState,
+        template: task.template ? `${task.template.name}@${task.template.version}` : undefined,
+        roomId: task.room_id, agents: task.member_roles.map(member => ({ name: member.name,
+            brain: brains.get(member.name) ?? 'unresolved', role: member.cowork_role })) });
+}
+function auditRoom(operation, room, previousState, newState = room.state) {
+    recordFleetAuditResource('room', room.room_id);
+    recordFleetAuditPresentation({ kind: 'room', operation, id: room.room_id, previousState, newState,
+        template: room.template_snapshot ? `${room.template_snapshot.name}@${room.template_snapshot.version}` : undefined,
+        participants: room.member_seats.map(member => ({ name: member.role_name, role: member.cowork_role })) });
+}
+const roomActionMarkdown = (title, room, fields = []) => {
+    recordFleetAuditResource('room', room.room_id);
+    return renderMarkdownResult({
+        icon: '🏠', title,
+        fields: [
+            { label: 'ID', value: room.room_id, kind: 'code' },
+            { label: 'Status', value: roomStatus(room.state), kind: 'markdown' },
+            ...fields,
+        ],
+    });
+};
 const PUBLIC_SETTLE_WAIT_MS = 60_000;
 const PUBLIC_SETTLE_POLL_MS = 100;
 const sleep = (ms) => new Promise(resolve => { setTimeout(resolve, ms); });
@@ -465,6 +529,7 @@ export function registerTaskCommands(parent, cOpt) {
                 idempotencyKey: opts.idempotencyKey, origin: { type: 'cli' },
                 list: opts.list,
             });
+            auditTask('create', record, 'none');
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: record }, null, 2));
                 return;
@@ -651,9 +716,11 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getTask(id).state;
             const t = await taskRoomService(opts.configuration).startTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
+            auditTask('start', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -677,9 +744,11 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((id, opts) => {
         try {
+            const previous = getTask(id).state;
             const t = taskRoomService().blockTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id, reason: opts.reason,
             });
+            auditTask('block', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -697,9 +766,11 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((id, opts) => {
         try {
+            const previous = getTask(id).state;
             const t = taskRoomService().unblockTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
+            auditTask('unblock', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -717,9 +788,11 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((id, opts) => {
         try {
+            const previous = getTask(id).state;
             const t = taskRoomService().reviewTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
+            auditTask('review', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -739,6 +812,7 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getTask(id).state;
             let summary = opts.summary;
             if (opts.summaryFile)
                 summary = readFileSync(opts.summaryFile, 'utf8');
@@ -750,6 +824,7 @@ export function registerTaskCommands(parent, cOpt) {
                 ? await launchTaskSettleWorker(id, opts.configuration)
                 : { task: plan.task, timedOut: false };
             const t = settled.task;
+            auditTask('done', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -777,6 +852,7 @@ export function registerTaskCommands(parent, cOpt) {
         try {
             if (id !== confirmId)
                 throw taskRoomPublicError('task_confirmation_mismatch');
+            const previous = getTask(id).state;
             const plan = await taskRoomService(opts.configuration).cancelTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
@@ -784,6 +860,7 @@ export function registerTaskCommands(parent, cOpt) {
                 ? await launchTaskSettleWorker(id, opts.configuration)
                 : { task: plan.task, timedOut: false };
             const t = settled.task;
+            auditTask('cancel', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -811,9 +888,16 @@ export function registerTaskCommands(parent, cOpt) {
         try {
             if (id !== confirmId)
                 throw taskRoomPublicError('task_confirmation_mismatch');
+            let prior;
+            try {
+                prior = getTask(id);
+            }
+            catch { /* idempotent already-absent delete */ }
             const deleted = taskRoomService().deleteTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
+            if (prior)
+                auditTask('delete', prior, prior.state, 'deleted');
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task_id: id, deleted }, null, 2));
                 return;
@@ -834,6 +918,7 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getTask(id).state;
             const app = taskRoomService(opts.configuration);
             const actor = { kind: 'local_control', surface: 'cli' };
             const begin = await app.beginTaskRecovery({ actor, taskId: id });
@@ -844,6 +929,7 @@ export function registerTaskCommands(parent, cOpt) {
                 })()
                 : begin.result;
             const t = recovered.task;
+            auditTask('recover', t, previous);
             const room = recovered.room;
             const recoveryActions = recovered.issues.map(issue => {
                 if (issue.code === 'terminal_pending')
@@ -951,10 +1037,12 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getTask(id).state;
             const result = await taskRoomService(opts.configuration).ensureTaskWork({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id, template: opts.template,
             });
             const t = result.task;
+            auditTask('work', t, previous);
             if (result.status === 'already_active') {
                 if (opts.json) {
                     console.log(JSON.stringify({ schema_version: 1, task: t, status: 'already_active' }, null, 2));
@@ -993,6 +1081,7 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getTask(id).state;
             let summary = opts.summary;
             if (opts.summaryFile)
                 summary = readFileSync(opts.summaryFile, 'utf8');
@@ -1004,6 +1093,7 @@ export function registerTaskCommands(parent, cOpt) {
                 ? await launchTaskSettleWorker(id, opts.configuration)
                 : { task: plan.task, timedOut: false };
             const t = settled.task;
+            auditTask('finish', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -1043,6 +1133,7 @@ export function registerRoomCommands(parent, cOpt) {
                 actor: { kind: 'local_control', surface: 'cli' }, name: opts.name,
                 template: opts.template, goal: opts.goal, brief: opts.brief, briefFile: opts.briefFile,
             });
+            auditRoom('create', record, 'none');
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room: record }, null, 2));
                 return;
@@ -1127,7 +1218,9 @@ export function registerRoomCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
-            const { room } = await taskRoomService(opts.configuration).getRoomDetail(id);
+            const { room, orchestration } = await taskRoomService(opts.configuration).getRoomDetail(id);
+            if (orchestration)
+                auditRoom('open', orchestration, orchestration.state);
             const url = `http://localhost:4460/room/${id}`;
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room_id: id, url, room_name: room.room_name }, null, 2));
@@ -1154,6 +1247,8 @@ export function registerRoomCommands(parent, cOpt) {
         .action(async (id, opts) => {
         try {
             const { orchestration: r, members } = await taskRoomService(opts.configuration).getRoomMembers(id);
+            if (r)
+                auditRoom('members', r, r.state);
             if (opts.json) {
                 console.log(JSON.stringify({
                     schema_version: 1,
@@ -1187,10 +1282,13 @@ export function registerRoomCommands(parent, cOpt) {
         try {
             if (id !== confirmId)
                 throw taskRoomPublicError('room_confirmation_mismatch');
+            const previous = getRoomRecord(id);
             await taskRoomService(opts.configuration).requestRoomDeletion({
                 actor: { kind: 'local_control', surface: 'cli' }, roomId: id,
             });
             const settled = await launchRoomDeleteWorker(id, opts.configuration);
+            if (previous)
+                auditRoom('delete', previous, previous.state, settled.deleted ? 'deleted' : 'closing');
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room_id: id, deleted: settled.deleted }, null, 2));
                 return;
@@ -1227,11 +1325,14 @@ export function registerRoomCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getRoomRecord(id);
             const recovered = await taskRoomService(opts.configuration).recoverRoom({
                 actor: { kind: 'local_control', surface: 'cli' }, roomId: id,
             });
             if (recovered.kind === 'deletion_worker_required') {
                 const settled = await launchRoomDeleteWorker(id, opts.configuration);
+                if (previous)
+                    auditRoom('recover', previous, previous.state, settled.deleted ? 'deleted' : 'closing');
                 if (opts.json) {
                     console.log(JSON.stringify({
                         schema_version: 1, room: null, orchestration: null,
@@ -1252,6 +1353,8 @@ export function registerRoomCommands(parent, cOpt) {
                 return;
             }
             const { room: cowork, orchestration: r, issues: actions } = recovered;
+            if (r)
+                auditRoom('recover', r, previous?.state ?? 'unresolved', r.state);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room: cowork, orchestration: r ?? null, recovery_actions: actions }, null, 2));
                 return;

package/dist/rooms-tasks/external-worker.d.ts

@@ -1,2 +1,3 @@
+export declare function fleetWorkerEnv(source?: NodeJS.ProcessEnv): Record<string, string>;
 /** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
 export declare function launchFleetWorker(args: string[], operation: string, configPath?: string): Promise<void>;

package/dist/rooms-tasks/external-worker.js

@@ -1,14 +1,23 @@
 import { execFile, spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
-/** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
-export function launchFleetWorker(args, operation, configPath) {
-    const cli = [process.argv[1], ...args, ...(configPath ? ['-c', configPath] : [])];
+import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV } from '../fleet-proxy.js';
+export function fleetWorkerEnv(source = process.env) {
     const inheritedKeys = [
         'HOME', 'PATH', 'XDG_RUNTIME_DIR', 'OURS_FLEET_HOME', 'OURS_CONFIG',
         'OURS_PORT', 'OURS_STATE_DIR', 'OURS_API_TOKEN', 'OURS_COWORK_CONFIG',
     ];
-    const inherited = inheritedKeys
-        .flatMap(key => process.env[key] === undefined ? [] : [`${key}=${process.env[key]}`]);
+    const env = Object.fromEntries(inheritedKeys.flatMap(key => source[key] === undefined ? [] : [[key, source[key]]]));
+    // Explicit defense: trusted settle/recover/delete/close workers are effects
+    // nested inside the outer audited command, never fresh agent attempts.
+    delete env[FLEET_PROXY_STATE_DIR_ENV];
+    delete env[FLEET_PROXY_CALLER_ENV];
+    return env;
+}
+/** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
+export function launchFleetWorker(args, operation, configPath) {
+    const cli = [process.argv[1], ...args, ...(configPath ? ['-c', configPath] : [])];
+    const env = fleetWorkerEnv();
+    const inherited = Object.entries(env).map(([key, value]) => `${key}=${value}`);
     const suffix = randomUUID().slice(0, 8);
     const safeOperation = operation.replace(/[^A-Za-z0-9_.-]/g, '-');
     return new Promise((resolve, reject) => {
@@ -29,10 +38,6 @@ export function launchFleetWorker(args, operation, configPath) {
             ], { timeout: 15_000 }, error => error ? reject(error) : resolve());
             return;
         }
-        const env = Object.fromEntries(inherited.map(value => {
-            const split = value.indexOf('=');
-            return [value.slice(0, split), value.slice(split + 1)];
-        }));
         const child = spawn(process.execPath, cli, { detached: true, stdio: 'ignore', env });
         child.once('error', reject);
         child.once('spawn', () => { child.unref(); resolve(); });

package/dist/runner.d.ts

@@ -23,7 +23,7 @@ export interface RunnerDeps {
     /** Neutral construction seam for deterministic runner lifecycle tests. */
     startAgentSession(adapter: AgentSessionAdapter, options: AgentSessionStartOptions): Promise<AgentSession>;
     /** Construct the authenticated role control route (injectable where sockets are unavailable). */
-    createControlServer(stateDir: string, session: AgentSession, log: (line: string) => void): Pick<RoleControlServer, 'start' | 'close' | 'setFleetSpawner' | 'setOwnerChannel' | 'setConfigReloader' | 'setLoopManager'>;
+    createControlServer(stateDir: string, session: AgentSession, log: (line: string) => void): Pick<RoleControlServer, 'start' | 'close' | 'setFleetSpawner' | 'setFleetAuditor' | 'setOwnerChannel' | 'setConfigReloader' | 'setLoopManager'>;
     /** Acquire the cross-process owner-channel binder lease before replacing the control socket. */
     acquireOwnerBinder(stateDir: string, role: string, identity: string): Promise<OwnerBinderLease>;
     /** Ask the still-authenticated predecessor to emit the fixed recovery notice. */

package/dist/runner.js

@@ -544,7 +544,6 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     let sessionClosed = false;
     let ownerChannel;
     let ownerBinder;
-    const pendingFleetSpawnNotices = [];
     let loopManager;
     let arbiter;
     let reloadLoopConfig;
@@ -607,21 +606,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             throw error;
         }
         control.setFleetSpawner(async (requested) => {
-            const event = await executeManagedSpawn(role, configPath, requested, deps.log);
-            if (!role.owner_channel)
-                return event;
-            if (ownerChannel?.notifyFleetSpawn) {
-                try {
-                    await ownerChannel.notifyFleetSpawn(event);
-                }
-                catch (error) {
-                    deps.log(`[${name}] spawned-agent owner notice failed: `
-                        + `${error?.message ?? String(error)}`);
-                }
-            }
-            else
-                pendingFleetSpawnNotices.push(event);
-            return event;
+            return executeManagedSpawn(role, configPath, requested, deps.log);
         });
         resolvedMonitorDeps.delivery = {
             // A wake is only delivered when its turn TERMINATES successfully. A
@@ -743,18 +728,14 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 throw new Error(`[${name}] owner channel failed to start: `
                     + `${error?.message ?? String(error)}`);
             }
-            for (const event of pendingFleetSpawnNotices.splice(0)) {
-                try {
-                    await ownerChannel.notifyFleetSpawn?.(event);
-                }
-                catch (error) {
-                    deps.log(`[${name}] deferred spawned-agent owner notice failed: `
-                        + `${error?.message ?? String(error)}`);
-                }
-            }
         }
-        if (ownerChannel)
+        if (ownerChannel) {
             control.setOwnerChannel(ownerChannel);
+            control.setFleetAuditor({
+                begin: (requestId, argv) => ownerChannel.beginFleetCommandAudit(requestId, argv),
+                finish: input => ownerChannel.finishFleetCommandAudit(input),
+            });
+        }
         reloadLoopConfig = async () => {
             const nextRole = findRole(loadConfig(configPath), name);
             const definitions = nextRole.loops ?? [];

package/dist/session/control.d.ts

@@ -4,11 +4,12 @@ import type { OwnerChannelHandle, OwnerChannelManagementRequest } from '../owner
 import type { ScheduledLoopManagerHandle } from '../loops/manager.js';
 import type { SpawnOpts } from '../spawn.js';
 import type { ManagedFleetSpawnResult } from '../fleet-proxy.js';
+import { type FleetAuditPresentation, type FleetCommandOutcomeClass } from '../fleet-command-audit.js';
 export interface ControlRequest {
     version: 1 | 2 | 3;
     id: string;
     token: string;
-    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config' | 'conversation_page' | 'conversation_follow' | 'submit_prompt_v2' | 'interrupt_v2' | 'respond_permission_v2' | 'fleet_spawn';
+    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config' | 'conversation_page' | 'conversation_follow' | 'submit_prompt_v2' | 'interrupt_v2' | 'respond_permission_v2' | 'fleet_spawn' | 'fleet_audit_begin' | 'fleet_audit_finish';
     text?: string;
     permissionId?: string;
     optionId?: string;
@@ -30,6 +31,16 @@ export interface ControlRequest {
     sessionGeneration?: string;
     /** Typed managed-spawn request accepted only over the authenticated role control plane. */
     spawn?: SpawnOpts;
+    audit?: {
+        requestId?: string;
+        argv?: string[];
+        correlationId?: string;
+        class?: FleetCommandOutcomeClass;
+        exitCode?: number;
+        effect?: 'not_started' | 'completed' | 'unknown';
+        resourceIds?: Record<string, string>;
+        presentation?: FleetAuditPresentation;
+    };
 }
 export interface ControlResponse {
     version: 1;
@@ -105,6 +116,7 @@ export declare class RoleControlServer {
     private loopManager?;
     private reloadConfig?;
     private fleetSpawner?;
+    private fleetAuditor?;
     constructor(stateDir: string, session: AgentSession, log: (line: string) => void);
     start(): Promise<void>;
     close(): Promise<void>;
@@ -113,6 +125,7 @@ export declare class RoleControlServer {
     setLoopManager(loopManager: ScheduledLoopManagerHandle | undefined): void;
     setConfigReloader(reloadConfig: (() => Promise<unknown>) | undefined): void;
     setFleetSpawner(fleetSpawner: ((options: SpawnOpts) => Promise<ManagedFleetSpawnResult>) | undefined): void;
+    setFleetAuditor(auditor: RoleControlServer['fleetAuditor']): void;
     private accept;
     private handle;
     /** Version and capability gate shared by every conversation v3 command. */

package/dist/session/control.js

@@ -3,6 +3,7 @@ import { chmodSync, existsSync, readFileSync, rmSync, writeFileSync } from 'node
 import { createConnection, createServer } from 'node:net';
 import { join } from 'node:path';
 import { SessionControlError } from './types.js';
+import { validateFleetAuditBegin, validateFleetAuditFinish, } from '../fleet-command-audit.js';
 import { interruptSession, queueSessionPrompt, respondSessionPermission, respondSessionPermissionV2, } from '../application/session-mutations.js';
 const MAX_LINE_BYTES = 64 * 1024;
 /** Commands that require protocol version 3. */
@@ -119,6 +120,7 @@ export class RoleControlServer {
     loopManager;
     reloadConfig;
     fleetSpawner;
+    fleetAuditor;
     constructor(stateDir, session, log) {
         this.session = session;
         this.log = log;
@@ -164,6 +166,7 @@ export class RoleControlServer {
     setFleetSpawner(fleetSpawner) {
         this.fleetSpawner = fleetSpawner;
     }
+    setFleetAuditor(auditor) { this.fleetAuditor = auditor; }
     accept(socket) {
         this.sockets.add(socket);
         socket.setEncoding('utf8');
@@ -311,6 +314,38 @@ export class RoleControlServer {
                     this.write(socket, { version: 1, id: request.id, ok: true, result });
                     return;
                 }
+                case 'fleet_audit_begin': {
+                    if (!this.fleetAuditor)
+                        throw new SessionControlError('rejected', 'fleet auditing is unavailable');
+                    try {
+                        validateFleetAuditBegin(request.audit);
+                    }
+                    catch {
+                        throw new SessionControlError('rejected', 'valid fleet audit begin fields are required');
+                    }
+                    const result = await this.fleetAuditor.begin(request.audit.requestId, request.audit.argv);
+                    this.write(socket, { version: 1, id: request.id, ok: true, result });
+                    return;
+                }
+                case 'fleet_audit_finish': {
+                    if (!this.fleetAuditor)
+                        throw new SessionControlError('rejected', 'fleet auditing is unavailable');
+                    try {
+                        validateFleetAuditFinish(request.audit);
+                    }
+                    catch {
+                        throw new SessionControlError('rejected', 'valid fleet audit finish fields are required');
+                    }
+                    const audit = request.audit;
+                    const result = await this.fleetAuditor.finish({
+                        correlationId: audit.correlationId, class: audit.class, effect: audit.effect,
+                        ...(audit.exitCode === undefined ? {} : { exitCode: audit.exitCode }),
+                        ...(audit.resourceIds ? { resourceIds: audit.resourceIds } : {}),
+                        ...(audit.presentation ? { presentation: audit.presentation } : {}),
+                    });
+                    this.write(socket, { version: 1, id: request.id, ok: true, result });
+                    return;
+                }
                 case 'owner_channel_manage': {
                     if (!request.ownerChannel || typeof request.ownerChannel.action !== 'string')
                         throw new SessionControlError('rejected', 'owner-channel management action is required');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.1.0-nightly.4",
+  "version": "1.1.0-nightly.6",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",