@ours.network/fleet 1.1.0 → 1.1.2

package/dist/harness/codex-runtime.js

@@ -0,0 +1,70 @@
+import { createRequire } from 'node:module';
+import { accessSync, constants, existsSync, realpathSync } from 'node:fs';
+import { dirname, join, isAbsolute, resolve, delimiter } from 'node:path';
+import { realExec } from '../exec.js';
+export const VERIFIED_CODEX_ACP_VERSIONS = new Set(['1.1.7', '1.10.0']);
+export function executableOnPath(command, env, cwd = process.cwd()) {
+    if (isAbsolute(command) || command.includes('/') || command.includes('\\'))
+        return resolve(cwd, command);
+    for (const dir of (env.PATH ?? '').split(delimiter)) {
+        for (const suffix of process.platform === 'win32' ? ['', '.exe', '.cmd'] : ['']) {
+            const path = resolve(cwd, dir, command + suffix);
+            try {
+                accessSync(path, constants.X_OK);
+                return path;
+            }
+            catch { /* next PATH entry */ }
+        }
+    }
+    throw new Error(`${command} not found on PATH`);
+}
+/** Match the npm Codex wrapper's platform-package/vendor selection. */
+export function codexExecutable(entry) {
+    const canonical = realpathSync(entry);
+    if (!canonical.endsWith('/bin/codex.js') && !canonical.endsWith('\\bin\\codex.js'))
+        return canonical;
+    const platform = process.platform === 'android' ? 'linux' : process.platform;
+    const cpu = process.arch === 'x64' ? 'x86_64' : process.arch === 'arm64' ? 'aarch64' : undefined;
+    const target = platform === 'linux' ? `${cpu}-unknown-linux-musl`
+        : platform === 'darwin' ? `${cpu}-apple-darwin`
+            : platform === 'win32' ? `${cpu}-pc-windows-msvc` : undefined;
+    if (!cpu || !target)
+        throw new Error(`Unsupported Codex platform ${platform}/${process.arch}`);
+    let vendor;
+    try {
+        vendor = join(dirname(createRequire(canonical).resolve(`@openai/codex-${platform}-${process.arch}/package.json`)), 'vendor');
+    }
+    catch {
+        vendor = join(dirname(canonical), '..', 'vendor');
+    }
+    const name = platform === 'win32' ? 'codex.exe' : 'codex';
+    // 0.153 uses bin/, while the supported legacy 0.145 wrapper uses codex/.
+    for (const dir of ['bin', 'codex']) {
+        const binary = join(vendor, target, dir, name);
+        if (existsSync(binary))
+            return realpathSync(binary);
+    }
+    throw new Error(`Codex platform binary missing under ${vendor}; reinstall Fleet with optional dependencies`);
+}
+export async function probeCodexRuntime(adapter, env, exec = realExec, cwd = process.cwd()) {
+    const configured = env.CODEX_PATH;
+    if (!configured && !adapter.manifestPath)
+        throw new Error('ACP runtime is unknown for a PATH/custom adapter; set CODEX_PATH to an absolute executable or use the bundled adapter');
+    const entry = configured ? executableOnPath(configured, env, cwd)
+        : createRequire(adapter.manifestPath).resolve('@openai/codex/bin/codex.js');
+    const executable = codexExecutable(entry);
+    const result = await exec(!configured ? process.execPath : entry, !configured ? [entry, '--version'] : ['--version'], { env, timeout: 5_000 });
+    const version = result.stdout.match(/\b(\d+\.\d+\.\d+)\b/)?.[1];
+    if (result.code !== 0 || !version)
+        throw new Error(`Cannot read Codex version from ${entry}; check CODEX_PATH and executable permissions`);
+    return { source: configured ? 'CODEX_PATH' : 'bundled', entry, executable, version };
+}
+export function codexVersionAtLeast(version, minimum) {
+    const actual = version.split('.').map(Number);
+    const required = minimum.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if (actual[i] !== required[i])
+            return actual[i] > required[i];
+    }
+    return true;
+}

package/dist/harness/codex-session.js

@@ -46,6 +46,9 @@ export class CodexAgentSessionAdapter {
             permissionMode: options.permissionMode,
             permissionMetadataSource: acpAdapterState(launch.adapterState).permissionMetadataSource,
             scrubObsoleteOursAutostart: true,
+            ...(role.monitor?.mode === 'fleet' && role.monitor.stall_recovery ? {
+                stallRecovery: { timeoutMs: role.monitor.stall_timeout_ms },
+            } : {}),
             log: options.log,
         });
     }

package/dist/harness/codex.js

@@ -6,6 +6,7 @@ import { realExec } from '../exec.js';
 import { registerAdapter } from './registry.js';
 import { harnessRuntimeDir } from '../isolation/policy.js';
 import { resolveBundledAcpAgent, } from './acp-agent.js';
+import { VERIFIED_CODEX_ACP_VERSIONS, probeCodexRuntime, codexVersionAtLeast } from './codex-runtime.js';
 import { CodexAgentSessionAdapter } from './codex-session.js';
 const OPTION_KEYS = [
     'launcher', 'sandbox', 'approval', 'permission_mode', 'search', 'profile', 'config', 'add_dirs',
@@ -17,7 +18,6 @@ const SANDBOX_MODES = ['read-only', 'workspace-write', 'danger-full-access'];
 /** Codex CLI's accepted `--ask-for-approval` values. */
 const APPROVAL_POLICIES = ['untrusted', 'on-request', 'never'];
 const NATIVE_CONFIG_ALLOWLIST = new Set(['model_reasoning_effort']);
-const BUNDLED_CODEX_ACP_VERSION = '1.1.7';
 const CODEX_ACP_PACKAGE = '@agentclientprotocol/codex-acp';
 const CODEX_PROXY_APPROVAL_ENV = 'OURS_FLEET_CODEX_APPROVAL';
 const CODEX_PROXY_SANDBOX_ENV = 'OURS_FLEET_CODEX_SANDBOX';
@@ -205,7 +205,7 @@ function codexAgentLaunch(role, prep) {
 /** Bind launch argv and metadata provenance to one already-completed resolution. */
 export function codexAcpLaunchForResolution(resolution) {
     const permissionMetadataSource = resolution.bundled
-        && resolution.version === BUNDLED_CODEX_ACP_VERSION
+        && VERIFIED_CODEX_ACP_VERSIONS.has(resolution.version ?? '')
         && resolution.manifestPath !== undefined
         ? 'codex-acp'
         : undefined;
@@ -216,7 +216,7 @@ export function codexAcpLaunchForResolution(resolution) {
 }
 function canOverrideBundledAcpApproval() {
     const resolution = bundledCodexAcp();
-    return resolution.bundled && resolution.version === BUNDLED_CODEX_ACP_VERSION
+    return resolution.bundled && VERIFIED_CODEX_ACP_VERSIONS.has(resolution.version ?? '')
         && resolution.manifestPath !== undefined && compiledProxyModule() !== undefined;
 }
 function compiledProxyModule() {
@@ -239,7 +239,7 @@ function codexAcpEnvironment(role, dirs) {
     if (role.session !== 'acp' || role.session_options?.acp?.command != null)
         return {};
     const resolution = bundledCodexAcp();
-    if (!resolution.bundled || resolution.version !== BUNDLED_CODEX_ACP_VERSION
+    if (!resolution.bundled || !VERIFIED_CODEX_ACP_VERSIONS.has(resolution.version ?? '')
         || !resolution.manifestPath)
         return {};
     const runtimeDir = harnessRuntimeDir(dirs.stateDir, 'codex');
@@ -261,7 +261,7 @@ function codexAcpEnvironment(role, dirs) {
         [CODEX_PROXY_APPROVAL_ENV]: approvalPolicy(role) ?? 'on-request',
         [CODEX_PROXY_SANDBOX_ENV]: acpRuntimeSandbox(role),
         [CODEX_PROXY_MANIFEST_ENV]: resolution.manifestPath,
-        ...(process.env.CODEX_PATH ? { [CODEX_PROXY_REAL_PATH_ENV]: process.env.CODEX_PATH } : {}),
+        [CODEX_PROXY_REAL_PATH_ENV]: role.env?.CODEX_PATH ?? process.env.CODEX_PATH ?? '',
     };
 }
 function encodeTomlValue(value) {
@@ -459,6 +459,22 @@ export function makeCodexAdapter(exec = realExec, transport, nativeTransport) {
             // sandbox needs this directory to exist before entry.
             if (role.isolation)
                 mkdirSync(harnessRuntimeDir(dirs.stateDir, 'codex'), { recursive: true });
+            if (role.session === 'acp' && role.session_options?.acp?.command == null) {
+                const resolution = bundledCodexAcp();
+                if (resolution.bundled && VERIFIED_CODEX_ACP_VERSIONS.has(resolution.version ?? '')) {
+                    let runtime;
+                    try {
+                        runtime = await probeCodexRuntime(resolution, { ...process.env, ...role.env }, realExec, dirs.runCwd);
+                    }
+                    catch (error) {
+                        throw new Error(`Codex ACP runtime check failed: ${error.message}; check CODEX_PATH or reinstall Fleet with optional dependencies`);
+                    }
+                    const minimum = role.model === 'gpt-6-astra' || resolution.version === '1.10.0'
+                        ? '0.153.3' : '0.145.0';
+                    if (!codexVersionAtLeast(runtime.version, minimum))
+                        throw new Error(`${role.model ?? 'Codex ACP'} requires a newer Codex (>=${minimum}): ACP selects ${runtime.executable} (${runtime.version}); upgrade Fleet or set CODEX_PATH to a supported executable in the agent/service environment`);
+                }
+            }
             return {
                 // OURS_BIND_IDENTITY is the connector's startup bind seed — see the note in
                 // claude-code.ts's prepareSession. It belongs on EVERY harness that runs a

package/dist/runner.js

@@ -119,6 +119,13 @@ export function managedFleetProxyEnv(role, stateDir) {
  */
 export function harnessChildEnv(role, launchEnv, stateDir) {
     const env = { ...(launchEnv ?? {}), ...managedFleetProxyEnv(role, stateDir) };
+    // CODEX_PATH selects the underlying runtime, not a bypass around Fleet's proxy.
+    if (role.harness === 'codex' && role.session === 'acp'
+        && launchEnv?.OURS_FLEET_CODEX_ACP_MANIFEST && launchEnv.CODEX_PATH) {
+        env.CODEX_PATH = launchEnv.CODEX_PATH;
+        env.OURS_FLEET_REAL_CODEX_PATH = role.env?.CODEX_PATH
+            ?? launchEnv.OURS_FLEET_REAL_CODEX_PATH ?? '';
+    }
     assertModelPinReachesChild(role, env);
     return env;
 }
@@ -612,7 +619,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         arbiter = new RoleTurnArbiter(agentSession);
         sessionHandle = arbiter;
         unsubscribeRecovery = agentSession.subscribe(event => {
-            if (event.kind !== 'error' || !event.text)
+            if (event.kind !== 'error' || !event.text || event.origin?.kind === 'stall-watchdog')
                 return;
             const evidence = classifyFailureText(event.text, sessionBackend, new Date(deps.now()).toISOString());
             if (evidence)
@@ -747,7 +754,8 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         // valid. Keep every unproven cancellation, refusal, shutdown, and genuine
         // failure terminal so a role that never accepted its briefing is not
         // silently reported as healthy.
-        const interruptedForWake = isRecoverableTempStartupCancellation(temp, started);
+        const interruptedForWake = isRecoverableTempStartupCancellation(temp, started)
+            || (started.outcome === 'cancelled' && started.cancellationSource === 'stall-watchdog');
         if (!started.succeeded && !interruptedForWake) {
             monitor?.stop();
             await control.close();
@@ -772,7 +780,9 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             throw new Error(`[${name}] ${sessionLabel} startup prompt ${started.outcome}` +
                 `${started.detail ? `: ${started.detail}` : ''}`);
         }
-        if (interruptedForWake)
+        if (started.cancellationSource === 'stall-watchdog')
+            deps.log(`[${name}] ${sessionLabel} startup diagnostic recovery requires operator attention; keeping supervisor alive`);
+        else if (interruptedForWake)
             deps.log(`[${name}] ${sessionLabel} startup prompt cancelled by ${started.cancellationSource}; `
                 + 'keeping temporary supervisor alive');
         sessionStartupComplete = true;

package/dist/session/acp.d.ts

@@ -27,6 +27,12 @@ export declare const CODEX_DISABLE_INHERITED_MCP_ENV = "OURS_FLEET_CODEX_DISABLE
 export declare function promptContentBlocks(text: string, origin?: PromptOrigin): acp.ContentBlock[];
 export declare function runtimeSelector(options: acp.SessionConfigOption[] | null | undefined, category: string): RuntimeSelectorMetadata | undefined;
 export interface AcpSessionOptions {
+    /** Opt-in Fleet watchdog, owned by this ACP session, never a process restart. */
+    stallRecovery?: {
+        timeoutMs?: number;
+        tickMs?: number;
+        cancelWaitMs?: number;
+    };
     name: string;
     /** Harness identity used only for honest optional capability reporting. */
     harness?: string;
@@ -144,6 +150,15 @@ export declare class AcpSession implements AgentSession {
     private terminate;
     /** ACP-authenticated in-flight calls, including independently reserved permissions. */
     private readonly activeToolCalls;
+    private stallWatchdog?;
+    private stallToolHistory?;
+    private stallRecoveryClaimed;
+    private managedTurnCount;
+    private steeringWasUsed;
+    private steeringRequests;
+    private retryNativeTurnId?;
+    private stallTimer?;
+    private stallAttempt?;
     private readonly toolBoundaryWaiters;
     private activeTurn?;
     private constructor();
@@ -275,7 +290,13 @@ export declare class AcpSession implements AgentSession {
     private declaredMcpServers;
     private initialize;
     private captureRuntimeMetadata;
+    private startStallWatchdog;
+    private checkStallWatchdog;
+    private stallObservation;
+    private recoverStall;
+    /** Keep the original queue slot (including startup) until recovery finishes. */
     private runPrompt;
+    private runSinglePrompt;
     private steerPrompt;
     private requestPermission;
     /**
@@ -294,6 +315,8 @@ export declare class AcpSession implements AgentSession {
      * malformed requests on the ordinary fail-closed path.
      */
     private isEffectiveCodexProtectedMcpApproval;
+    /** Pinned codex-acp 1.1.7 structured metadata, never stderr or assistant text. */
+    private recordStallMetadata;
     private recordUpdate;
     /**
      * Codex ACP's phase extension is the only currently supported visibility