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

package/dist/harness/codex-app-server-proxy.js

@@ -9,9 +9,281 @@ const SANDBOX_ENV = 'OURS_FLEET_CODEX_SANDBOX';
 const REAL_CODEX_ENV = 'OURS_FLEET_REAL_CODEX_PATH';
 const ACP_MANIFEST_ENV = 'OURS_FLEET_CODEX_ACP_MANIFEST';
 const DISABLE_INHERITED_MCP_ENV = 'OURS_FLEET_CODEX_DISABLE_INHERITED_MCP';
+/**
+ * Codex 0.145 can finish a tool-enabled turn without emitting the documented
+ * `turn/completed` notification. Keep this short: the authoritative
+ * `thread/read` reconciliation below, rather than elapsed time, is what makes
+ * inference safe.
+ */
+const TERMINAL_RECONCILE_QUIET_MS = 2_000;
+const MAX_LATE_TERMINAL_DEDUPLICATIONS = 1_024;
 const APPROVAL_POLICIES = new Set(['untrusted', 'on-request', 'never']);
 const SANDBOX_MODES = new Set(['read-only', 'workspace-write', 'danger-full-access']);
 const isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const jsonRpcId = (value) => typeof value === 'string' || typeof value === 'number' ? value : undefined;
+const stringField = (value, field) => isObject(value) && typeof value[field] === 'string' ? value[field] : undefined;
+const turnKey = (threadId, turnId) => `${threadId}\0${turnId}`;
+/**
+ * Reconcile Codex's missing terminal notification without guessing from a
+ * wall-clock timeout. A candidate needs the exact turn's authoritative final
+ * assistant item, no live items or server requests, and a quiet period. The
+ * proxy then asks app-server for the current thread snapshot. Only a terminal
+ * stored turn, or an idle thread containing that exact turn, may synthesize the
+ * missing notification.
+ *
+ * This lives in the authenticated bundled-Codex proxy, not the generic ACP
+ * session: only here are App Server thread/turn IDs and item lifecycles visible.
+ */
+export class CodexTerminalRecovery {
+    options;
+    turns = new Map();
+    pendingTurnStarts = new Map();
+    serverRequests = new Map();
+    reconcileRequests = new Map();
+    inferredTurns = new Set();
+    reconcileSequence = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    observeClientLine(line) {
+        const message = this.parse(line);
+        if (!message)
+            return;
+        const id = jsonRpcId(message.id);
+        if (message.method === 'turn/start' && id !== undefined) {
+            const threadId = stringField(message.params, 'threadId');
+            if (threadId)
+                this.pendingTurnStarts.set(id, threadId);
+            return;
+        }
+        if (id === undefined || message.method !== undefined)
+            return;
+        const key = this.serverRequests.get(id);
+        if (!key)
+            return;
+        this.serverRequests.delete(id);
+        const turn = this.turns.get(key);
+        turn?.openServerRequests.delete(id);
+        if (turn)
+            this.scheduleReconciliation(turn);
+    }
+    /** Return false when an internal response or late duplicate was consumed. */
+    observeServerLine(line) {
+        const message = this.parse(line);
+        if (!message)
+            return true;
+        const id = jsonRpcId(message.id);
+        if (id !== undefined && message.method === undefined) {
+            const reconcileKey = this.reconcileRequests.get(id);
+            if (reconcileKey) {
+                this.reconcileRequests.delete(id);
+                this.handleReconcileResponse(reconcileKey, message);
+                return false;
+            }
+            const threadId = this.pendingTurnStarts.get(id);
+            if (threadId) {
+                this.pendingTurnStarts.delete(id);
+                const turn = isObject(message.result) && isObject(message.result.turn)
+                    ? message.result.turn : undefined;
+                const turnId = stringField(turn, 'id');
+                if (turn && turnId)
+                    this.ensureTurn(threadId, turnId, turn);
+            }
+            return true;
+        }
+        if (message.method === 'turn/started') {
+            const threadId = stringField(message.params, 'threadId');
+            const turn = isObject(message.params) && isObject(message.params.turn)
+                ? message.params.turn : undefined;
+            const turnId = stringField(turn, 'id');
+            if (threadId && turn && turnId)
+                this.ensureTurn(threadId, turnId, turn);
+            return true;
+        }
+        if (message.method === 'turn/completed') {
+            const threadId = stringField(message.params, 'threadId');
+            const turn = isObject(message.params) && isObject(message.params.turn)
+                ? message.params.turn : undefined;
+            const turnId = stringField(turn, 'id');
+            if (!threadId || !turnId)
+                return true;
+            const key = turnKey(threadId, turnId);
+            if (this.inferredTurns.delete(key)) {
+                this.options.log(`suppressed late turn/completed after inferred terminal (${threadId}/${turnId})`);
+                return false;
+            }
+            this.finishTurn(key);
+            return true;
+        }
+        if (message.method === 'thread/status/changed') {
+            const threadId = stringField(message.params, 'threadId');
+            const status = isObject(message.params) && isObject(message.params.status)
+                ? message.params.status : undefined;
+            if (threadId && status?.type === 'idle') {
+                for (const turn of this.turns.values()) {
+                    if (turn.threadId !== threadId)
+                        continue;
+                    turn.idleObserved = true;
+                    this.scheduleReconciliation(turn);
+                }
+            }
+            return true;
+        }
+        const params = isObject(message.params) ? message.params : undefined;
+        const threadId = stringField(params, 'threadId');
+        const routedTurnId = stringField(params, 'turnId');
+        const routed = threadId && routedTurnId
+            ? this.turns.get(turnKey(threadId, routedTurnId)) : undefined;
+        if (routed && message.method === 'item/started') {
+            const item = isObject(params?.item) ? params.item : undefined;
+            const itemId = stringField(item, 'id');
+            if (itemId)
+                routed.openItems.add(itemId);
+            // Work after a final answer invalidates that candidate. A later exact
+            // final answer can establish a new one.
+            if (item?.type !== 'agentMessage' || item?.phase !== 'final_answer')
+                routed.finalAssistantItem = undefined;
+            this.cancelReconciliation(routed);
+        }
+        else if (routed && message.method === 'item/completed') {
+            const item = isObject(params?.item) ? params.item : undefined;
+            const itemId = stringField(item, 'id');
+            if (itemId)
+                routed.openItems.delete(itemId);
+            if (item?.type === 'agentMessage' && item.phase === 'final_answer'
+                && typeof item.text === 'string' && item.text.length > 0)
+                routed.finalAssistantItem = item;
+            this.scheduleReconciliation(routed);
+        }
+        // App-server requests (approvals, elicitation, user input) are obligations
+        // the client still owes. Never infer while one for this turn is unresolved.
+        if (routed && id !== undefined && typeof message.method === 'string') {
+            this.serverRequests.set(id, turnKey(routed.threadId, routed.turnId));
+            routed.openServerRequests.add(id);
+            this.cancelReconciliation(routed);
+        }
+        return true;
+    }
+    close() {
+        for (const turn of this.turns.values())
+            this.cancelReconciliation(turn);
+        this.turns.clear();
+        this.pendingTurnStarts.clear();
+        this.serverRequests.clear();
+        this.reconcileRequests.clear();
+        this.inferredTurns.clear();
+    }
+    parse(line) {
+        try {
+            const parsed = JSON.parse(line);
+            return isObject(parsed) ? parsed : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    ensureTurn(threadId, turnId, turn) {
+        const key = turnKey(threadId, turnId);
+        const existing = this.turns.get(key);
+        if (existing) {
+            existing.turn = turn;
+            return existing;
+        }
+        const created = {
+            threadId, turnId, turn, openItems: new Set(), openServerRequests: new Set(),
+            idleObserved: false,
+        };
+        this.turns.set(key, created);
+        return created;
+    }
+    candidate(turn) {
+        return turn.finalAssistantItem !== undefined
+            && turn.openItems.size === 0 && turn.openServerRequests.size === 0
+            && turn.reconcileRequestId === undefined;
+    }
+    cancelReconciliation(turn) {
+        if (turn.reconcileTimer)
+            clearTimeout(turn.reconcileTimer);
+        turn.reconcileTimer = undefined;
+    }
+    scheduleReconciliation(turn) {
+        this.cancelReconciliation(turn);
+        if (!this.candidate(turn))
+            return;
+        turn.reconcileTimer = setTimeout(() => this.reconcile(turn), this.options.quietMs ?? TERMINAL_RECONCILE_QUIET_MS);
+        turn.reconcileTimer.unref?.();
+    }
+    reconcile(turn) {
+        turn.reconcileTimer = undefined;
+        if (!this.candidate(turn))
+            return;
+        const id = `ours-fleet-terminal-reconcile-${++this.reconcileSequence}`;
+        const key = turnKey(turn.threadId, turn.turnId);
+        turn.reconcileRequestId = id;
+        this.reconcileRequests.set(id, key);
+        this.options.sendToCodex(JSON.stringify({
+            id, method: 'thread/read', params: { threadId: turn.threadId, includeTurns: true },
+        }));
+    }
+    handleReconcileResponse(key, message) {
+        const tracked = this.turns.get(key);
+        if (!tracked)
+            return;
+        tracked.reconcileRequestId = undefined;
+        if (!this.candidate(tracked))
+            return;
+        const thread = isObject(message.result) && isObject(message.result.thread)
+            ? message.result.thread : undefined;
+        const turns = thread && Array.isArray(thread.turns) ? thread.turns : [];
+        const snapshot = turns.find(candidate => isObject(candidate) && candidate.id === tracked.turnId);
+        if (!snapshot) {
+            this.scheduleReconciliation(tracked);
+            return;
+        }
+        const status = typeof snapshot.status === 'string' ? snapshot.status : undefined;
+        const threadStatus = thread && isObject(thread.status) ? thread.status.type : undefined;
+        const storedTerminal = status === 'completed' || status === 'failed' || status === 'interrupted';
+        if (!storedTerminal && threadStatus !== 'idle' && !tracked.idleObserved) {
+            // A final answer can precede stop hooks or other short-lived runtime
+            // effects. Keep reconciling while the exact thread still reports active;
+            // never convert elapsed time alone into success.
+            this.scheduleReconciliation(tracked);
+            return;
+        }
+        const inferredTurn = storedTerminal ? snapshot : {
+            ...snapshot,
+            status: 'completed',
+            error: null,
+            completedAt: snapshot.completedAt ?? new Date().toISOString(),
+        };
+        this.inferredTurns.add(key);
+        if (this.inferredTurns.size > MAX_LATE_TERMINAL_DEDUPLICATIONS) {
+            const oldest = this.inferredTurns.values().next().value;
+            if (oldest)
+                this.inferredTurns.delete(oldest);
+        }
+        this.options.log(`inferred missing turn/completed after authoritative reconciliation (${tracked.threadId}/${tracked.turnId})`);
+        this.options.emitToClient(JSON.stringify({
+            method: 'turn/completed',
+            params: { threadId: tracked.threadId, turn: inferredTurn },
+            _meta: { oursFleet: { terminalSource: 'inferred_missing_notification' } },
+        }));
+        this.finishTurn(key);
+    }
+    finishTurn(key) {
+        const turn = this.turns.get(key);
+        if (!turn)
+            return;
+        this.cancelReconciliation(turn);
+        if (turn.reconcileRequestId !== undefined) {
+            this.reconcileRequests.delete(turn.reconcileRequestId);
+            turn.reconcileRequestId = undefined;
+        }
+        for (const id of turn.openServerRequests)
+            this.serverRequests.delete(id);
+        this.turns.delete(key);
+    }
+}
 function sandboxMode(policy) {
     if (!isObject(policy))
         return undefined;
@@ -94,24 +366,83 @@ export function runCodexAppServerProxy() {
     const child = spawn(launch.command, launch.args, {
         env, shell: launch.shell, stdio: ['pipe', 'pipe', 'pipe'],
     });
-    child.stdout.pipe(process.stdout);
-    child.stderr.pipe(process.stderr);
+    child.stderr.pipe(process.stderr, { end: false });
     const input = createInterface({ input: process.stdin });
+    const output = createInterface({ input: child.stdout });
     let finished = false;
+    let clientBackpressured = false;
+    const writeToClient = (line) => {
+        if (finished)
+            return;
+        if (!process.stdout.write(line + '\n')) {
+            if (!clientBackpressured) {
+                clientBackpressured = true;
+                output.pause();
+                process.stdout.once('drain', () => {
+                    clientBackpressured = false;
+                    if (!finished)
+                        output.resume();
+                });
+            }
+        }
+    };
+    let childBackpressured = false;
+    const pendingChildLines = [];
+    const writeToChild = (line) => {
+        if (finished || child.stdin.destroyed)
+            return;
+        if (childBackpressured) {
+            pendingChildLines.push(line);
+            return;
+        }
+        if (!child.stdin.write(line + '\n')) {
+            childBackpressured = true;
+            input.pause();
+            child.stdin.once('drain', () => {
+                childBackpressured = false;
+                while (!childBackpressured && pendingChildLines.length > 0) {
+                    const pending = pendingChildLines.shift();
+                    if (!child.stdin.write(pending + '\n'))
+                        childBackpressured = true;
+                }
+                if (!finished && !childBackpressured)
+                    input.resume();
+            });
+        }
+    };
+    const recovery = new CodexTerminalRecovery({
+        sendToCodex: writeToChild,
+        emitToClient: writeToClient,
+        log: line => process.stderr.write(`ours-fleet Codex terminal recovery: ${line}\n`),
+    });
     const finish = (code) => {
         if (finished)
             return;
         finished = true;
-        process.exitCode = code;
+        recovery.close();
         input.close();
         process.stdin.destroy();
+        // stdout/stderr are often pipes under Fleet and tests. Setting exitCode
+        // before their pending writes flush can drop the child's last diagnostic
+        // or protocol line. Empty writes provide ordered flush barriers.
+        // Let readable `data`/`line` callbacks queued with the child's `close`
+        // notification run before placing the barriers.
+        setImmediate(() => {
+            process.stdout.write('', () => {
+                process.stderr.write('', () => { process.exitCode = code; });
+            });
+        });
     };
+    let spawnFailed = false;
     child.once('error', error => {
+        spawnFailed = true;
         process.stderr.write(`ours-fleet Codex app-server proxy: ${error.message}\n`);
-        finish(1);
     });
-    child.once('exit', (code, signal) => {
-        finish(code ?? (signal ? 1 : 0));
+    // `exit` can precede the final stdout/stderr chunks. Wait for `close`, which
+    // is emitted only after the child's stdio streams have closed, so a fast
+    // failure cannot lose its diagnostic or the last protocol envelope.
+    child.once('close', (code, signal) => {
+        finish(spawnFailed ? 1 : code ?? (signal ? 1 : 0));
     });
     // A child can close its input before Node delivers its exit event. Its exit
     // status is the authoritative failure; do not let the resulting EPIPE race it.
@@ -119,19 +450,22 @@ export function runCodexAppServerProxy() {
     input.on('line', line => {
         if (finished)
             return;
-        const output = rewriteCodexAppServerRequest(line, approval, expectedSandbox, disableInheritedMcp) + '\n';
-        if (!child.stdin.write(output)) {
-            input.pause();
-            child.stdin.once('drain', () => {
-                if (!finished)
-                    input.resume();
-            });
-        }
+        const rewritten = rewriteCodexAppServerRequest(line, approval, expectedSandbox, disableInheritedMcp);
+        recovery.observeClientLine(rewritten);
+        writeToChild(rewritten);
+    });
+    output.on('line', line => {
+        if (!finished && recovery.observeServerLine(line))
+            writeToClient(line);
     });
     input.once('close', () => {
         if (!child.stdin.destroyed)
             child.stdin.end();
     });
+    process.stdin.once('end', () => {
+        if (!child.stdin.destroyed)
+            child.stdin.end();
+    });
     for (const signal of ['SIGINT', 'SIGTERM'])
         process.once(signal, () => child.kill(signal));
 }

package/dist/harness/codex-session.d.ts

@@ -1,4 +1,5 @@
 import type { ResolvedRole } from '../config.js';
+import { CodexAppServerSession } from '../session/codex-app-server.js';
 import type { AcpMcpServer, SessionPrep } from './types.js';
 import type { AgentSessionAdapter, AgentSessionStartOptions, PreparedAgentSessionLaunch } from './agent-session.js';
 import { type AcpSessionTransport } from './acp-session-transport.js';
@@ -10,15 +11,21 @@ export interface CodexSessionStrategy {
     permissionModeId(role: ResolvedRole): string | undefined;
     mcpServers(role: ResolvedRole): AcpMcpServer[] | undefined;
     sessionMeta(role: ResolvedRole, prep: SessionPrep): Record<string, unknown> | undefined;
+    approvalPolicy(role: ResolvedRole): string;
+    sandbox(role: ResolvedRole): string;
+    nativeConfig(role: ResolvedRole): Record<string, unknown> | undefined;
+    addDirs(role: ResolvedRole): string[] | undefined;
 }
+export type CodexAppServerSessionTransport = typeof CodexAppServerSession.start;
 /** Explicit Codex implementation of Fleet's shared agent-session factory. */
 export declare class CodexAgentSessionAdapter implements AgentSessionAdapter {
     private readonly strategy;
     private readonly transport;
-    constructor(strategy: CodexSessionStrategy, transport?: AcpSessionTransport);
+    private readonly nativeTransport;
+    constructor(strategy: CodexSessionStrategy, transport?: AcpSessionTransport, nativeTransport?: CodexAppServerSessionTransport);
     resolveBrain(brain: Parameters<AgentSessionAdapter['resolveBrain']>[0]): import("./agent-session.js").ResolvedBrainSelection;
     modelEnvironmentVariable(): string | undefined;
     prepareLaunch(role: ResolvedRole, prep: SessionPrep): PreparedAgentSessionLaunch;
     sessionConfigSelections(role: ResolvedRole): import("./agent-session.js").AgentSessionConfigSelection[];
-    start(options: AgentSessionStartOptions): Promise<import("../index.js").AgentSession>;
+    start(options: AgentSessionStartOptions): Promise<import("../index.js").AgentSession> | Promise<CodexAppServerSession>;
 }

package/dist/harness/codex-session.js

@@ -1,12 +1,15 @@
 import { AcpSession } from '../session/acp.js';
+import { CodexAppServerSession } from '../session/codex-app-server.js';
 import { acpAdapterState, } from './acp-session-transport.js';
 /** Explicit Codex implementation of Fleet's shared agent-session factory. */
 export class CodexAgentSessionAdapter {
     strategy;
     transport;
-    constructor(strategy, transport = AcpSession.start) {
+    nativeTransport;
+    constructor(strategy, transport = AcpSession.start, nativeTransport = CodexAppServerSession.start) {
         this.strategy = strategy;
         this.transport = transport;
+        this.nativeTransport = nativeTransport;
     }
     resolveBrain(brain) {
         return this.strategy.resolveBrain(brain);
@@ -20,8 +23,21 @@ export class CodexAgentSessionAdapter {
     }
     start(options) {
         const { role, prep, launch } = options;
+        if (role.session === 'codex-app-server')
+            return this.nativeTransport({
+                name: role.name, argv: launch.argv, cwd: options.cwd, env: launch.env,
+                stateDir: options.stateDir, mode: options.mode, permissions: options.permissions,
+                permissionMode: options.permissionMode,
+                model: role.model, effort: role.effort,
+                approvalPolicy: this.strategy.approvalPolicy(role),
+                sandbox: this.strategy.sandbox(role),
+                config: this.strategy.nativeConfig(role),
+                addDirs: this.strategy.addDirs(role),
+                log: options.log,
+            });
         return this.transport({
-            name: role.name, argv: launch.argv, cwd: options.cwd, env: launch.env,
+            name: role.name, harness: role.harness,
+            argv: launch.argv, cwd: options.cwd, env: launch.env,
             stateDir: options.stateDir, mode: options.mode, permissions: options.permissions,
             modeId: this.strategy.permissionModeId(role),
             mcpServers: this.strategy.mcpServers(role),

package/dist/harness/codex.d.ts

@@ -1,14 +1,18 @@
 import { type Exec } from '../exec.js';
+import type { ResolvedRole } from '../config.js';
 import type { AcpLaunch, HarnessAdapter, UnattendedCapability } from './types.js';
 import { type AcpAgentResolution } from './acp-agent.js';
 import type { AcpSessionTransport } from './acp-session-transport.js';
+import type { CodexAppServerSessionTransport } from './codex-session.js';
 /**
  * What an unattended role can actually do under Codex's native settings.
  * `on-request` and `untrusted` stop to ask, and with no console attached that
  * request is refused rather than answered — so the role can only read.
  */
 export declare function codexCapabilities(approval: string, sandbox: string): UnattendedCapability[];
+/** Defense in depth for callers which launch a role after validation was bypassed. */
+export declare function nativeCodexConfig(role: ResolvedRole): Record<string, unknown> | undefined;
 /** Bind launch argv and metadata provenance to one already-completed resolution. */
 export declare function codexAcpLaunchForResolution(resolution: AcpAgentResolution): Pick<AcpLaunch, 'argv' | 'permissionMetadataSource'>;
-export declare function makeCodexAdapter(exec?: Exec, transport?: AcpSessionTransport): HarnessAdapter;
+export declare function makeCodexAdapter(exec?: Exec, transport?: AcpSessionTransport, nativeTransport?: CodexAppServerSessionTransport): HarnessAdapter;
 export declare const codexAdapter: HarnessAdapter;