@ours.network/fleet 1.1.0-nightly.2 → 1.1.0-nightly.21

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>;
+        presentations?: 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');
@@ -233,6 +236,9 @@ export class RoleControlServer {
                             features: [
                                 'events_since', 'observer_follow', 'retained_range',
                                 ...(this.session.conversationPage ? ['conversation_v3'] : []),
+                                ...(this.session.capabilities?.steering ? ['steering'] : []),
+                                ...(this.session.capabilities?.permissions ? ['permissions'] : []),
+                                ...(this.session.capabilities?.messagePhases ? ['message_phases'] : []),
                             ],
                         },
                     });
@@ -311,6 +317,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.presentations ? { presentations: audit.presentations } : {}),
+                    });
+                    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/dist/session/conversation-types.d.ts

@@ -1,14 +1,14 @@
 import type { PromptOrigin, TurnCancellationSource, TurnOutcome } from './types.js';
 /**
- * Durable conversation domain schema for the ACP web console.
+ * Durable conversation domain schema for managed-session consoles.
  *
  * `SessionEvent` in ./types.js remains the compact diagnostic projection; the
  * types here describe the durable per-role conversation ledger. Nothing in this
- * file touches the wire: ACP updates are reduced into these shapes by the
- * normalizer, and the store assigns `seq`/`eventId`/timestamps.
+ * file touches the wire: transport updates are reduced into these shapes by a
+ * session adapter, and the store assigns `seq`/`eventId`/timestamps.
  */
 export type ConversationEventKind = 'prompt.admitted' | 'prompt.started' | 'prompt.interrupt_requested' | 'message.chunk' | 'message.replace' | 'thought.chunk' | 'thought.replace' | 'plan.replace' | 'tool.upsert' | 'tool.content_chunk' | 'permission.requested' | 'permission.resolved' | 'monitor.delivery' | 'usage.updated' | 'turn.state' | 'turn.completed' | 'session.state' | 'session.info' | 'capabilities.updated' | 'error'
-/** A well-formed ACP update this version cannot represent. Bounded, never a crash. */
+/** A well-formed transport update this version cannot represent. Bounded, never a crash. */
  | 'unsupported';
 /** Where a conversation record came from. Typed provenance, never prompt text. */
 export type ConversationSource = 'owner_admin_console' | 'owner_channel' | 'fleet_monitor' | 'scheduled_loop' | 'startup' | 'local_console' | 'agent' | 'agent_replay';

package/dist/session/types.d.ts

@@ -33,7 +33,7 @@ export type PromptOrigin = {
     commandId: string;
 };
 export interface RuntimeSelectorMetadata {
-    /** Exact provider/model identifier reported by the live ACP session. */
+    /** Exact provider/model identifier reported by the live managed session. */
     value: string;
     /** Complete provider-supplied label for that exact value, when available. */
     label?: string;
@@ -75,6 +75,8 @@ export interface TurnResult {
 export type ControlFailureKind = 'offline' | 'control-unavailable' | 'timeout' | 'rejected' | 'backend';
 /** Stable body-free reason shared by ACP recovery and durable ingress. */
 export declare const ACP_CANCEL_DEADLINE_EXCEEDED = "ACP_CANCEL_DEADLINE_EXCEEDED";
+/** Native Codex equivalent; kept distinct so diagnostics name the failing transport. */
+export declare const CODEX_APP_SERVER_CANCEL_DEADLINE_EXCEEDED = "CODEX_APP_SERVER_CANCEL_DEADLINE_EXCEEDED";
 export declare class SessionControlError extends Error {
     readonly kind: ControlFailureKind;
     /** Stable body-free machine reason for recovery/audit decisions. */
@@ -170,7 +172,7 @@ export interface SubmitPromptOptions {
     interruptSource?: TurnCancellationSource;
     /** Typed in-process provenance. Text markers never grant this origin. */
     origin?: PromptOrigin;
-    /** Use the ACP steering extension when available; ignored by other backends. */
+    /** Inject into active work when the selected backend supports steering. */
     steer?: boolean;
     /** Audit-grade actor detail persisted with the conversation admission record. */
     actor?: {
@@ -200,11 +202,25 @@ export interface SessionSnapshot {
     activity?: SessionActivity;
 }
 export interface SessionActivity {
-    /** ACP tool calls currently reserved (lifecycle open or permission pending). */
+    /** Tool calls currently reserved (lifecycle open or permission pending). */
     activeToolCalls: number;
     /** When the agent last sent ANY session update, replay excluded. */
     lastUpdateAt?: string;
 }
+/** Provider-neutral behavior exposed by a session transport. */
+export interface AgentSessionCapabilities {
+    streaming: boolean;
+    durableConversation: boolean;
+    promptInput: boolean;
+    interrupt: boolean;
+    steering: boolean;
+    permissions: boolean;
+    toolBoundaryDelivery: boolean;
+    messagePhases: boolean;
+    resume: boolean;
+}
+/** Conservative static capabilities used before a live session is reachable. */
+export declare function sessionBackendCapabilities(backend: SessionBackendId, harness?: string): AgentSessionCapabilities;
 export type SessionEventKind = 'state' | 'agent_text' | 'thought' | 'tool_call' | 'tool_update' | 'permission' | 'monitor_delivery' | 'turn_stop' | 'error';
 /** What a settled permission request resolved to. */
 export type PermissionDecision = 'allowed' | 'denied' | 'cancelled';
@@ -219,7 +235,7 @@ export interface SessionEvent {
     text?: string;
     /**
      * Adapter-authenticated presentation phase for assistant text. Only the
-     * exact Codex ACP marker is promoted; absence/unknown values stay unset.
+     * exact Codex phase marker is promoted; absence/unknown values stay unset.
      */
     messagePhase?: 'commentary' | 'final_answer';
     /** Stable adapter message/item id when supplied. */
@@ -261,11 +277,13 @@ export interface ConversationHandlePage {
 /**
  * The live, harness-neutral contract between Fleet and one agent session.
  * Harness adapters construct this handle; orchestration code must not depend
- * on the ACP transport which currently implements it.
+ * on any concrete transport which implements it.
  */
 export interface AgentSession {
     readonly backend: SessionBackendId;
     readonly pid: number;
+    /** Live capabilities; optional only for source compatibility with external adapters. */
+    readonly capabilities?: AgentSessionCapabilities;
     isAlive(): boolean;
     snapshot(): SessionSnapshot;
     conversationPage?(request: {
@@ -283,7 +301,7 @@ export interface AgentSession {
     queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
     /** Queue a prompt and wait for its terminal result. */
     submitPrompt(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
-    /** Monitor-only ACP safe-boundary delivery. Never implies human/control cancellation. */
+    /** Monitor-only safe-boundary delivery. Never implies human/control cancellation. */
     submitPromptAfterTool?(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
     /**
      * Cancel the active turn. Resolves when the cancellation has taken effect —

package/dist/session/types.js

@@ -1,5 +1,7 @@
 /** Stable body-free reason shared by ACP recovery and durable ingress. */
 export const ACP_CANCEL_DEADLINE_EXCEEDED = 'ACP_CANCEL_DEADLINE_EXCEEDED';
+/** Native Codex equivalent; kept distinct so diagnostics name the failing transport. */
+export const CODEX_APP_SERVER_CANCEL_DEADLINE_EXCEEDED = 'CODEX_APP_SERVER_CANCEL_DEADLINE_EXCEEDED';
 export class SessionControlError extends Error {
     kind;
     reasonCode;
@@ -53,3 +55,29 @@ export function turnResult(accepted, outcome, detail, output, cancellationSource
         ...(outcome === 'cancelled' && cancellationSource ? { cancellationSource } : {}),
     };
 }
+/** Conservative static capabilities used before a live session is reachable. */
+export function sessionBackendCapabilities(backend, harness) {
+    if (backend === 'codex-app-server')
+        return {
+            streaming: true,
+            durableConversation: true,
+            promptInput: true,
+            interrupt: true,
+            steering: true,
+            permissions: true,
+            toolBoundaryDelivery: false,
+            messagePhases: true,
+            resume: true,
+        };
+    return {
+        streaming: true,
+        durableConversation: true,
+        promptInput: true,
+        interrupt: true,
+        steering: false,
+        permissions: true,
+        toolBoundaryDelivery: true,
+        messagePhases: harness === 'codex',
+        resume: true,
+    };
+}

package/dist/spawn.d.ts

@@ -1,5 +1,6 @@
 import type { IsolationConfig } from './isolation/types.js';
-import { type ApprovalMode, type FilesystemMode, type ResolvedRole, type RoleConfig, type MonitorConfig, type SessionBackendId, type UnattendedMode, type RoomMemberStartup } from './config.js';
+import type { AgentLoopsConfig } from './loops/config.js';
+import { type ApprovalMode, type FilesystemMode, type ResolvedRole, type MonitorConfig, type UnattendedMode, type RoomMemberStartup, type AgentDefinition, type AgentSelection } from './config.js';
 import { type OpsDeps } from './ops.js';
 import { type CreationDeps, type CreationProvenance } from './creation.js';
 import './harness/claude-code.js';
@@ -13,34 +14,18 @@ export declare let lastProvenance: CreationProvenance | undefined;
 export interface SpawnOpts {
     name: string;
     temp?: boolean;
-    harness?: string;
-    session?: SessionBackendId;
-    mission?: string;
-    missionFile?: string;
+    brain?: AgentSelection;
+    role?: AgentSelection;
+    /** Trusted canonical definition used by room provisioning; never a second schema. */
+    agentDefinition?: AgentDefinition;
     identity?: string;
     cwd?: string;
     coordinator?: string;
-    /** null explicitly selects the harness default; undefined retains normal fleet inheritance. */
-    model?: string | null;
-    permissionMode?: string;
     approval?: ApprovalMode;
     filesystem?: FilesystemMode;
     unattended?: UnattendedMode;
-    sandbox?: string;
-    profile?: string;
-    launcher?: string;
-    search?: boolean;
-    codexConfig?: Record<string, string | number | boolean>;
-    reasoningEffort?: string | null;
-    addDirs?: string[];
-    monitor?: boolean;
     /** Typed external monitor configuration used by trusted creation surfaces. */
     monitorConfig?: Partial<MonitorConfig>;
-    bioFile?: string;
-    personaFile?: string;
-    /** Inline profile values for trusted typed callers such as the local web service. */
-    bio?: string;
-    persona?: string;
     /** Internal, non-sensitive provenance correlation for typed presentation layers. */
     surface?: 'cli' | 'web' | 'agent';
     creationActionId?: string;
@@ -56,17 +41,18 @@ export interface SpawnOpts {
      * input in this release.
      */
     isolationFile?: string;
+    /** Trusted YAML containing exactly a top-level `loops:` map. Temporary launches only. */
+    loopsFile?: string;
+    /** Explicitly override any selected Agent Template loops with none. */
+    noLoops?: boolean;
+    /** Internal source label retained after room-member plan resolution. */
+    loopSource?: 'agent-template' | 'cli' | 'omitted';
     overseeInterval?: string;
     configPath?: string;
     dryRun?: boolean;
     json?: boolean;
 }
-export declare function profileValues(o: SpawnOpts): {
-    bio?: string;
-    persona?: string;
-};
-/** Pure option-to-role mapping shared by CLI and application services. */
-export declare function buildRoleConfig(o: SpawnOpts, defaultHarness?: string): RoleConfig;
+export declare function agentDefinitionFromSpawn(o: SpawnOpts): AgentDefinition;
 /**
  * Read and validate an `--isolation-file`. The file is the existing
  * `isolation:` mapping and nothing else — the same schema, the same validator
@@ -77,9 +63,9 @@ export declare function buildRoleConfig(o: SpawnOpts, defaultHarness?: string):
  * must fail before any artifact exists.
  */
 export declare function readIsolationFile(path: string): IsolationConfig;
+/** Read a private canonical temporary-loop override before any creation side effect. */
+export declare function readLoopsFile(path: string): AgentLoopsConfig;
 export declare function validateSpawnOpts(o: SpawnOpts): void;
-/** Read mission text without trimming or newline rewriting. */
-export declare function readMissionFile(path: string): string;
 /** The ours identity a spawn will bind: explicit, else the role name. */
 export declare const effectiveIdentity: (o: SpawnOpts) => string;
 export interface SpawnDryRun {
@@ -88,8 +74,6 @@ export interface SpawnDryRun {
     roleDocument: Record<string, unknown>;
     resolvedRole: ResolvedRole;
 }
-/** Bare Agent document written by v2 spawn: inline Role × inline Brain + operations. */
-export declare function buildAgentDocument(raw: RoleConfig): Record<string, unknown>;
 /**
  * Validate and resolve a spawn without reserving names, contacting the daemon,
  * or writing state. Collision checks are necessarily a point-in-time snapshot.