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

package/dist/session/acp.d.ts

@@ -28,6 +28,8 @@ export declare function promptContentBlocks(text: string, origin?: PromptOrigin)
 export declare function runtimeSelector(options: acp.SessionConfigOption[] | null | undefined, category: string): RuntimeSelectorMetadata | undefined;
 export interface AcpSessionOptions {
     name: string;
+    /** Harness identity used only for honest optional capability reporting. */
+    harness?: string;
     argv: string[];
     cwd: string;
     env: Record<string, string>;
@@ -36,6 +38,11 @@ export interface AcpSessionOptions {
     permissions: CommonPermissions;
     /** Native permission-mode id to request via session/set_mode; undefined keeps the agent default. */
     modeId?: string;
+    /** Ordered explicit Brain choices that must be applied before readiness. */
+    configSelections?: Array<{
+        configId: string;
+        value: string;
+    }>;
     /** Adapter-resolved live permission policy; separate from ACP agent-specific session modes. */
     permissionMode?: NonNullable<SessionSnapshot['permissionMode']>;
     /** Adapter-authenticated request-metadata vocabulary; never inferred from ACP `_meta`. */
@@ -84,6 +91,7 @@ export declare function classifyStopReason(stopReason: string | undefined): Turn
 export declare class AcpSession implements AgentSession {
     private readonly options;
     readonly backend: "acp";
+    readonly capabilities: import("./types.js").AgentSessionCapabilities;
     readonly pid: number;
     private readonly child;
     private readonly events;
@@ -110,7 +118,7 @@ export declare class AcpSession implements AgentSession {
     private queueDepth;
     private exit;
     private steeringSupported;
-    private capabilities?;
+    private agentCapabilities?;
     private runtimeModel?;
     private reasoningEffort?;
     private controllerCount;

package/dist/session/acp.js

@@ -7,7 +7,7 @@ import * as acp from '@agentclientprotocol/sdk';
 import { normalizeSessionUpdate } from './conversation-normalizer.js';
 import { ConversationEventStore } from './conversation-store.js';
 import { SessionEvents } from './events.js';
-import { ACP_CANCEL_DEADLINE_EXCEEDED, SessionControlError, classifyChildExit, turnResult, } from './types.js';
+import { ACP_CANCEL_DEADLINE_EXCEEDED, SessionControlError, classifyChildExit, sessionBackendCapabilities, turnResult, } from './types.js';
 const CANCEL_SETTLE_GRACE_MS = 15_000;
 const CANCEL_TERMINATE_GRACE_MS = 5_000;
 /** A permission no human answered is eventually a decision nobody made. */
@@ -206,6 +206,7 @@ export function classifyStopReason(stopReason) {
 export class AcpSession {
     options;
     backend = 'acp';
+    capabilities;
     pid;
     child;
     events;
@@ -232,7 +233,7 @@ export class AcpSession {
     queueDepth = 0;
     exit = null;
     steeringSupported = false;
-    capabilities;
+    agentCapabilities;
     runtimeModel;
     reasoningEffort;
     controllerCount = 0;
@@ -265,6 +266,7 @@ export class AcpSession {
         this.child = child;
         this.connection = connection;
         this.pid = child.pid ?? -1;
+        this.capabilities = sessionBackendCapabilities('acp', options.harness);
         this.events = new SessionEvents(join(options.stateDir, '.session-events.jsonl'));
         this.conversation = new ConversationEventStore(join(options.stateDir, '.conversation'), {
             roleId: options.name, log: line => options.log(`[${options.name}] ${line}`),
@@ -994,7 +996,7 @@ export class AcpSession {
         for (const [permissionId, pending] of [...this.pendingPermissions])
             this.settlePendingAutomatically(permissionId, pending, 'cancelled', undefined, 'the session closed while this request was pending');
         this.releaseAllTools();
-        if (this.sessionId && this.capabilities?.sessionCapabilities?.close != null) {
+        if (this.sessionId && this.agentCapabilities?.sessionCapabilities?.close != null) {
             await this.connection.agent.request(acp.methods.agent.session.close, { sessionId: this.sessionId }).catch(() => undefined);
         }
         this.connection.close();
@@ -1020,23 +1022,25 @@ export class AcpSession {
         });
         if (initialized.protocolVersion !== acp.PROTOCOL_VERSION)
             throw new Error(`ACP protocol mismatch: agent selected ${initialized.protocolVersion}, client supports ${acp.PROTOCOL_VERSION}`);
-        this.capabilities = initialized.agentCapabilities;
+        this.agentCapabilities = initialized.agentCapabilities;
         const steering = initialized._meta?.steering;
         this.steeringSupported = steering !== null && typeof steering === 'object'
             && steering.supported === true;
         const persisted = this.options.mode === 'resume' && existsSync(this.sessionFile)
             ? readFileSync(this.sessionFile, 'utf8').trim()
             : '';
-        if (persisted && this.capabilities?.sessionCapabilities?.resume != null) {
+        let advertisedConfigOptions;
+        if (persisted && this.agentCapabilities?.sessionCapabilities?.resume != null) {
             const resumed = await this.connection.agent.request(acp.methods.agent.session.resume, {
                 sessionId: persisted,
                 cwd: this.options.cwd,
                 mcpServers: this.declaredMcpServers(),
             });
-            this.captureRuntimeMetadata(resumed.configOptions);
+            advertisedConfigOptions = resumed.configOptions;
+            this.captureRuntimeMetadata(advertisedConfigOptions);
             this.sessionId = persisted;
         }
-        else if (persisted && this.capabilities?.loadSession) {
+        else if (persisted && this.agentCapabilities?.loadSession) {
             // `session/load` replays prior history as ordinary updates before the
             // response; those records carry `agent_replay` provenance, never `agent`.
             this.replaying = true;
@@ -1046,7 +1050,8 @@ export class AcpSession {
                     cwd: this.options.cwd,
                     mcpServers: this.declaredMcpServers(),
                 });
-                this.captureRuntimeMetadata(loaded.configOptions);
+                advertisedConfigOptions = loaded.configOptions;
+                this.captureRuntimeMetadata(advertisedConfigOptions);
             }
             finally {
                 this.replaying = false;
@@ -1060,8 +1065,29 @@ export class AcpSession {
                 ...(this.options.sessionMeta ? { _meta: this.options.sessionMeta } : {}),
             });
             this.sessionId = created.sessionId;
-            this.captureRuntimeMetadata(created.configOptions);
+            advertisedConfigOptions = created.configOptions;
+            this.captureRuntimeMetadata(advertisedConfigOptions);
+        }
+        for (const selection of this.options.configSelections ?? []) {
+            if (!advertisedConfigOptions?.some(option => option.id === selection.configId))
+                throw new Error(`ACP agent did not advertise required session config option '${selection.configId}'`);
+            let configured;
+            try {
+                configured = await this.connection.agent.request(acp.methods.agent.session.setConfigOption, { sessionId: this.sessionId, configId: selection.configId, value: selection.value });
+            }
+            catch (error) {
+                throw new Error(`ACP agent refused required session config option '${selection.configId}' value '${selection.value}': `
+                    + (error instanceof Error ? error.message : String(error)));
+            }
+            advertisedConfigOptions = configured.configOptions;
+            this.captureRuntimeMetadata(advertisedConfigOptions);
+            const applied = advertisedConfigOptions.find(option => option.id === selection.configId);
+            if (applied?.currentValue !== selection.value)
+                throw new Error(`ACP agent did not apply required session config option '${selection.configId}' value '${selection.value}'`);
         }
+        // Do not persist a session until every required Brain choice is live. A
+        // failed startup closes the ACP session; persisting its id first would make
+        // a later resume repeatedly target that invalid session.
         writeFileSync(this.sessionFile, this.sessionId + '\n', { mode: 0o600 });
         // Deliver the configured permission mode whichever way the session came up
         // (new, resume or load) — the launch flag never reaches an ACP agent. A

package/dist/session/arbiter.d.ts

@@ -17,8 +17,9 @@ export type ScheduledAttempt = {
  */
 export declare class RoleTurnArbiter implements AgentSession {
     private readonly session;
-    readonly backend: "acp";
+    readonly backend: import("../config.js").SessionBackendId;
     readonly pid: number;
+    readonly capabilities: import("./types.js").AgentSessionCapabilities | undefined;
     private tail;
     private unsettled;
     private stopping;

package/dist/session/arbiter.js

@@ -25,6 +25,7 @@ export class RoleTurnArbiter {
     session;
     backend;
     pid;
+    capabilities;
     tail = Promise.resolve();
     unsettled = 0;
     stopping = false;
@@ -36,6 +37,7 @@ export class RoleTurnArbiter {
         this.session = session;
         this.backend = session.backend;
         this.pid = session.pid;
+        this.capabilities = session.capabilities;
     }
     /**
      * Waiters race the tail against their own generation's retirement, so a

package/dist/session/codex-app-server-transport.d.ts

@@ -0,0 +1,53 @@
+import { type ChildProcessWithoutNullStreams } from 'node:child_process';
+import type { ExitRecord } from './types.js';
+type JsonObject = Record<string, unknown>;
+type RequestId = string | number;
+export interface CodexAppServerTransportOptions {
+    name: string;
+    argv: string[];
+    cwd: string;
+    env: Record<string, string>;
+    log(line: string): void;
+    requestTimeoutMs?: number;
+    onNotification?(method: string, params: JsonObject): void;
+    onRequest?(method: string, id: RequestId, params: JsonObject): void;
+    onExit?(exit: ExitRecord): void;
+}
+export interface CodexAppServerConnection {
+    readonly pid: number;
+    readonly child: Pick<ChildProcessWithoutNullStreams, 'kill'>;
+    isAlive(): boolean;
+    exitResult(): ExitRecord | null;
+    request<T = unknown>(method: string, params?: JsonObject, timeoutMs?: number): Promise<T>;
+    notify(method: string, params?: JsonObject): void;
+    respond(id: RequestId, result: unknown): void;
+    respondError(id: RequestId, code: number, message: string): void;
+    close(): Promise<void>;
+}
+export type CodexAppServerTransportFactory = (options: CodexAppServerTransportOptions) => Promise<CodexAppServerConnection>;
+/** Minimal, version-tolerant JSONL client for Codex app-server's stdio transport. */
+export declare class CodexAppServerTransport implements CodexAppServerConnection {
+    private readonly options;
+    readonly child: ChildProcessWithoutNullStreams;
+    readonly pid: number;
+    private nextId;
+    private readonly pending;
+    private readonly requestTimeoutMs;
+    private readonly exited;
+    private resolveExited;
+    private closed;
+    private exit;
+    private constructor();
+    static start(options: CodexAppServerTransportOptions): Promise<CodexAppServerTransport>;
+    isAlive(): boolean;
+    exitResult(): ExitRecord | null;
+    request<T = unknown>(method: string, params?: JsonObject, timeoutMs?: number): Promise<T>;
+    notify(method: string, params?: JsonObject): void;
+    respond(id: RequestId, result: unknown): void;
+    respondError(id: RequestId, code: number, message: string): void;
+    close(): Promise<void>;
+    private waitForExit;
+    private write;
+    private receive;
+}
+export {};

package/dist/session/codex-app-server-transport.js

@@ -0,0 +1,184 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { SessionControlError, classifyChildExit } from './types.js';
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function responseError(value) {
+    if (!isObject(value))
+        return new Error('Codex app-server returned an unknown error');
+    const message = typeof value.message === 'string' ? value.message : JSON.stringify(value);
+    const error = new Error(message);
+    error.name = 'CodexAppServerError';
+    return error;
+}
+/** Minimal, version-tolerant JSONL client for Codex app-server's stdio transport. */
+export class CodexAppServerTransport {
+    options;
+    child;
+    pid;
+    nextId = 1;
+    pending = new Map();
+    requestTimeoutMs;
+    exited;
+    resolveExited;
+    closed = false;
+    exit = null;
+    constructor(options, child) {
+        this.options = options;
+        this.child = child;
+        this.pid = child.pid ?? -1;
+        this.requestTimeoutMs = options.requestTimeoutMs ?? 90_000;
+        this.exited = new Promise(resolve => { this.resolveExited = resolve; });
+        child.stderr.on('data', chunk => {
+            const text = String(chunk).trimEnd();
+            if (text)
+                options.log(`[${options.name}] codex app-server: ${text}`);
+        });
+        child.once('error', error => {
+            this.options.log(`[${options.name}] codex app-server process error: ${error.message}`);
+        });
+        const lines = createInterface({ input: child.stdout });
+        lines.on('line', line => this.receive(line));
+        child.once('exit', (code, signal) => {
+            this.exit = classifyChildExit(code, signal);
+            const error = new SessionControlError('offline', `Codex app-server ${this.exit.detail}`);
+            for (const pending of this.pending.values()) {
+                clearTimeout(pending.timer);
+                pending.reject(error);
+            }
+            this.pending.clear();
+            options.onExit?.(this.exit);
+            this.resolveExited();
+        });
+    }
+    static async start(options) {
+        if (!options.argv.length)
+            throw new Error('Codex app-server command is empty');
+        const child = spawn(options.argv[0], options.argv.slice(1), {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // `pid` is assigned synchronously on a successful local spawn. Checking it
+        // first avoids missing an exceptionally fast `spawn` event before the
+        // listeners below are attached (observable with tiny test/app-server shims).
+        if (child.pid === undefined)
+            await new Promise((resolve, reject) => {
+                let settled = false;
+                const finish = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    child.off('spawn', spawned);
+                    child.off('error', failed);
+                    error ? reject(error) : resolve();
+                };
+                const spawned = () => finish();
+                const failed = (error) => finish(error);
+                child.once('spawn', spawned);
+                child.once('error', failed);
+                setImmediate(() => { if (child.pid !== undefined)
+                    finish(); });
+            });
+        return new CodexAppServerTransport(options, child);
+    }
+    isAlive() {
+        return this.child.exitCode === null && (this.child.signalCode ?? null) === null;
+    }
+    exitResult() { return this.exit; }
+    request(method, params = {}, timeoutMs) {
+        if (this.closed || !this.isAlive())
+            return Promise.reject(new SessionControlError('offline', 'Codex app-server is offline'));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new SessionControlError('timeout', `Codex app-server ${method} timed out after ${timeoutMs ?? this.requestTimeoutMs}ms`));
+            }, timeoutMs ?? this.requestTimeoutMs);
+            timer.unref?.();
+            this.pending.set(id, {
+                method, timer,
+                resolve: value => resolve(value), reject,
+            });
+            try {
+                this.write({ id, method, params });
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    notify(method, params) {
+        this.write(params === undefined ? { method } : { method, params });
+    }
+    respond(id, result) { this.write({ id, result }); }
+    respondError(id, code, message) {
+        this.write({ id, error: { code, message } });
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (!this.isAlive())
+            return;
+        this.child.kill('SIGTERM');
+        if (await this.waitForExit(2_500))
+            return;
+        this.child.kill('SIGKILL');
+        await this.waitForExit(2_500);
+    }
+    async waitForExit(timeoutMs) {
+        let timer;
+        const timedOut = new Promise(resolve => {
+            timer = setTimeout(() => resolve(false), timeoutMs);
+            timer.unref?.();
+        });
+        const exited = await Promise.race([this.exited.then(() => true), timedOut]);
+        if (timer)
+            clearTimeout(timer);
+        return exited;
+    }
+    write(value) {
+        if (this.closed || this.child.stdin.destroyed)
+            throw new SessionControlError('offline', 'Codex app-server input is closed');
+        this.child.stdin.write(JSON.stringify(value) + '\n', error => {
+            if (error)
+                this.options.log(`[${this.options.name}] codex app-server write failed: ${error.message}`);
+        });
+    }
+    receive(line) {
+        let value;
+        try {
+            const parsed = JSON.parse(line);
+            if (!isObject(parsed))
+                throw new Error('message is not an object');
+            value = parsed;
+        }
+        catch (error) {
+            this.options.log(`[${this.options.name}] codex app-server: ignored malformed JSONL (${error.message})`);
+            return;
+        }
+        const method = typeof value.method === 'string' ? value.method : undefined;
+        const hasId = typeof value.id === 'string' || typeof value.id === 'number';
+        if (method && hasId) {
+            this.options.onRequest?.(method, value.id, isObject(value.params) ? value.params : {});
+            return;
+        }
+        if (method) {
+            this.options.onNotification?.(method, isObject(value.params) ? value.params : {});
+            return;
+        }
+        if (!hasId)
+            return;
+        const pending = this.pending.get(value.id);
+        if (!pending)
+            return;
+        this.pending.delete(value.id);
+        clearTimeout(pending.timer);
+        if (value.error !== undefined)
+            pending.reject(responseError(value.error));
+        else
+            pending.resolve(value.result);
+    }
+}

package/dist/session/codex-app-server.d.ts

@@ -0,0 +1,122 @@
+import type { CommonPermissions } from '../config.js';
+import type { ConversationEventV1, ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
+import type { CodexAppServerTransportFactory } from './codex-app-server-transport.js';
+import type { AgentSession, ConversationHandlePage, ExitRecord, InterruptOutcome, QueuedPrompt, SessionEvent, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnResult } from './types.js';
+type JsonObject = Record<string, unknown>;
+export interface CodexAppServerSessionOptions {
+    name: string;
+    argv: string[];
+    cwd: string;
+    env: Record<string, string>;
+    stateDir: string;
+    mode: 'fresh' | 'resume';
+    permissions: CommonPermissions;
+    permissionMode: NonNullable<SessionSnapshot['permissionMode']>;
+    model?: string | null;
+    effort?: string;
+    approvalPolicy: string;
+    sandbox: string;
+    config?: Record<string, unknown>;
+    addDirs?: string[];
+    log(line: string): void;
+    permissionTimeoutMs?: number;
+    controllerGraceMs?: number;
+    interruptSettleMs?: number;
+    interruptTerminateGraceMs?: number;
+    terminalReconcileQuietMs?: number;
+    terminalReconcileRequestTimeoutMs?: number;
+}
+/** Server-generated application provenance for authenticated browser prompts only. */
+export declare function nativePromptAdditionalContext(origin: PromptOrigin | undefined): JsonObject | undefined;
+/** Native Codex session implementing Fleet's provider-neutral live-session contract. */
+export declare class CodexAppServerSession implements AgentSession {
+    private readonly options;
+    readonly backend: "codex-app-server";
+    readonly capabilities: import("./types.js").AgentSessionCapabilities;
+    readonly pid: number;
+    private readonly events;
+    private readonly conversation;
+    private readonly conversationStartCursor?;
+    private readonly sessionGeneration;
+    private readonly threadFile;
+    private readonly pendingPermissions;
+    private readonly activeTools;
+    private readonly activeItems;
+    private readonly itemPhases;
+    private readonly itemText;
+    private transport;
+    private threadId?;
+    private readiness;
+    private runtimeModel?;
+    private reasoningEffort?;
+    private lastUpdateAt?;
+    private lastError?;
+    private exit;
+    private queueDepth;
+    private promptTail;
+    private activeTurn?;
+    private controllerCount;
+    private controllerGrace?;
+    private interruptForceKill?;
+    private terminalReconcile?;
+    private terminalReconcileInFlight;
+    private finalAnswerObserved;
+    private closing;
+    private constructor();
+    static start(options: CodexAppServerSessionOptions, transportFactory?: CodexAppServerTransportFactory): Promise<CodexAppServerSession>;
+    isAlive(): boolean;
+    snapshot(): SessionSnapshot;
+    queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
+    submitPrompt(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
+    interrupt(source?: TurnCancellationSource): Promise<InterruptOutcome>;
+    respondPermission(permissionId: string, optionId: string): boolean;
+    respondPermissionV2(permissionId: string, optionId: string, sessionGeneration: string): 'accepted' | 'stale';
+    eventsSince(seq: number): SessionEvent[];
+    subscribe(listener: (event: SessionEvent) => void): () => void;
+    setControllerAttached(attached: boolean): void;
+    exitResult(): ExitRecord | null;
+    close(): Promise<void>;
+    conversationPage(request?: {
+        after?: string;
+        limit?: number;
+    }): ConversationHandlePage;
+    conversationSnapshot(): ConversationSnapshot;
+    subscribeConversation(listener: (event: ConversationEventV1) => void): () => void;
+    submitPromptBrowser(command: SubmitPromptCommand): Promise<PromptReceipt>;
+    private initialize;
+    private recoverOpenPrompts;
+    private admit;
+    private runPrompt;
+    private steer;
+    private notification;
+    private itemStarted;
+    private itemCompleted;
+    private messageDelta;
+    private emitMessage;
+    private thoughtDelta;
+    private planUpdated;
+    private recordTool;
+    private finishTurn;
+    /**
+     * Some supported Codex versions can persist a completed turn without
+     * emitting `turn/completed`. Reconcile only an exact, quiescent final-answer
+     * candidate against the app-server's authoritative thread snapshot.
+     */
+    private scheduleTerminalReconciliation;
+    private terminalCandidate;
+    private reconcileTerminal;
+    private cancelTerminalReconciliation;
+    private clearInterruptForceKill;
+    private terminateFailedTransport;
+    private serverRequest;
+    private requestPermission;
+    private serverRequestResolved;
+    private autoResolvePermission;
+    private resolvePermission;
+    private currentEvent;
+    private isActiveNotification;
+    private permissionResponse;
+    private transportExited;
+    private fail;
+}
+export {};