@ours.network/fleet 1.1.0 → 1.1.2

package/dist/session/stall-watchdog.js

@@ -0,0 +1,210 @@
+import { createHash } from 'node:crypto';
+import { closeSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { replaceFileAtomically } from '../atomic-file.js';
+export const DEFAULT_STALL_TIMEOUT_MS = 15 * 60_000;
+export const STALL_RECOVERY_PROMPT = 'This is a diagnostic interruption. The previous turn showed no progress. '
+    + 'Inspect recorded terminal events and re-check completed actions before continuing. '
+    + 'Never assume an issued side effect failed: do not replay ambiguous or already-completed mutations. '
+    + 'Continue the previous task if safe; otherwise report an actionable blocker.';
+const digest = (text) => createHash('sha256').update(text).digest('hex');
+/** Presence, including an incomplete claim, restores conservative mail policy. */
+export function hasStallRecoveryClaim(stateDir, sessionId) {
+    try {
+        lstatSync(join(stateDir, '.stall-recovery', `${digest(sessionId)}.claim`));
+        return true;
+    }
+    catch (error) {
+        return error.code !== 'ENOENT';
+    }
+}
+/** ACP has no turn IDs on tool updates. Reuse across turns is ambiguous. */
+export class StallToolHistory {
+    turns = new Map();
+    healthy = true;
+    directory;
+    path;
+    session;
+    constructor(stateDir, sessionId, resume) {
+        this.session = digest(sessionId);
+        this.directory = join(stateDir, '.stall-recovery');
+        this.path = join(this.directory, `${this.session}.tools.json`);
+        try {
+            const stored = JSON.parse(readFileSync(this.path, 'utf8'));
+            if (stored.version !== 1 || stored.session !== this.session || !Array.isArray(stored.tools)
+                || stored.tools.length > 4096 || !stored.tools.every((id) => typeof id === 'string' && /^[a-f0-9]{64}$/.test(id)))
+                throw new Error('invalid history');
+            for (const id of stored.tools)
+                this.turns.set(id, 'previous-generation');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT' || resume)
+                this.healthy = false;
+            else {
+                try {
+                    mkdirSync(this.directory, { recursive: true, mode: 0o700 });
+                    this.persist();
+                    const fd = openSync(stateDir, 'r');
+                    try {
+                        fsyncSync(fd);
+                    }
+                    finally {
+                        closeSync(fd);
+                    }
+                }
+                catch {
+                    this.healthy = false;
+                }
+            }
+        }
+    }
+    available() { return this.healthy; }
+    /** Record before relying on a tool event. False means cancellation is unsafe. */
+    observe(toolId, turnId) {
+        if (!this.healthy || !toolId)
+            return false;
+        const id = digest(toolId);
+        const previous = this.turns.get(id);
+        if (previous !== undefined)
+            return previous === turnId;
+        if (this.turns.size >= 4096) {
+            this.healthy = false;
+            return false;
+        }
+        this.turns.set(id, turnId);
+        try {
+            this.persist();
+        }
+        catch {
+            this.healthy = false;
+        }
+        return this.healthy;
+    }
+    persist() {
+        replaceFileAtomically(this.path, JSON.stringify({ version: 1, session: this.session,
+            tools: [...this.turns.keys()] }) + '\n');
+        const fd = openSync(this.directory, 'r');
+        try {
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+}
+/**
+ * One durable attempt per ACP session, deliberately stricter than one per turn.
+ * A restarted supervisor never guesses whether cancellation or recovery ran.
+ * Claim files are never reclaimed automatically, including malformed/empty ones.
+ */
+export class StallWatchdog {
+    options;
+    checking = false;
+    disabled = false;
+    unavailableTurn;
+    constructor(options) {
+        this.options = options;
+    }
+    async tick() {
+        if (this.checking || this.disabled)
+            return;
+        const observed = this.options.observe();
+        if (!observed)
+            return;
+        const missingBoundary = observed.boundaryEvidenceAvailable === false;
+        if (!observed.safe && !missingBoundary && !this.options.previouslyClaimed)
+            return;
+        const missingEvidence = observed.progressCount === 0 || missingBoundary;
+        // Turn age can only produce an informational blocker, never cancellation.
+        const idleMs = this.options.now() - (observed.progressCount === 0 ? observed.startedAt : observed.lastProgressAt);
+        // Generic silence needs two full windows. Authenticated repeated transport
+        // failures strengthen evidence, but never bypass protected-operation checks.
+        const threshold = this.options.timeoutMs * (!missingEvidence && observed.transportFailures >= 2 ? 1 : 2);
+        if (!Number.isFinite(idleMs) || (idleMs < threshold && !this.options.previouslyClaimed))
+            return;
+        this.checking = true;
+        const session = digest(observed.sessionId);
+        const turn = digest(observed.generation + '\0' + observed.turnId);
+        const directory = join(this.options.stateDir, '.stall-recovery');
+        const report = (status) => {
+            const event = {
+                version: 1, kind: 'stall_recovery', eventId: `${turn}:${status}`,
+                session, turn, status, idleMs: Math.floor(idleMs),
+                evidence: observed.transportFailures >= 2 ? 'adapter_transport' : 'no_progress',
+            };
+            const fd = openSync(join(directory, 'audit.jsonl'), 'a', 0o600);
+            try {
+                writeFileSync(fd, JSON.stringify(event) + '\n');
+                fsyncSync(fd);
+            }
+            finally {
+                closeSync(fd);
+            }
+            this.options.diagnostic(event);
+        };
+        try {
+            mkdirSync(directory, { recursive: true, mode: 0o700 });
+            const parentFd = openSync(this.options.stateDir, 'r');
+            try {
+                fsyncSync(parentFd);
+            }
+            finally {
+                closeSync(parentFd);
+            }
+            if (this.options.previouslyClaimed) {
+                this.disabled = true;
+                report('blocked_previous_attempt');
+                return;
+            }
+            if (missingEvidence) {
+                if (this.unavailableTurn !== turn) {
+                    this.unavailableTurn = turn;
+                    report('blocked_evidence');
+                }
+                return;
+            }
+            let fd;
+            try {
+                fd = openSync(join(directory, `${session}.claim`), 'wx', 0o600);
+            }
+            catch (error) {
+                this.disabled = true;
+                if (error.code === 'EEXIST') {
+                    report('blocked_previous_attempt');
+                    return;
+                }
+                throw error;
+            }
+            // Even a crash before this write leaves a permanent conservative fence.
+            try {
+                writeFileSync(fd, JSON.stringify({ version: 1, session, turn }) + '\n');
+                fsyncSync(fd);
+            }
+            finally {
+                closeSync(fd);
+            }
+            const dirFd = openSync(directory, 'r');
+            try {
+                fsyncSync(dirFd);
+            }
+            finally {
+                closeSync(dirFd);
+            }
+            this.disabled = true;
+            report('interrupt_requested');
+            // No await between the durable claim and the adapter's final atomic
+            // observation check. Recovery itself must re-check before session/cancel.
+            await this.options.recover(observed, report);
+        }
+        catch {
+            this.disabled = true;
+            // Never include an exception string: it may contain paths or wire data.
+            this.options.diagnostic({ version: 1, kind: 'stall_recovery',
+                eventId: `${turn}:blocked_persistence`, session, turn,
+                status: 'blocked_persistence', evidence: 'no_progress', idleMs: Math.floor(idleMs) });
+        }
+        finally {
+            this.checking = false;
+        }
+    }
+}

package/dist/session/types.d.ts

@@ -13,9 +13,11 @@ import type { ConversationEventV1, ConversationSnapshot, PromptReceipt, SubmitPr
  */
 export type SessionReadiness = 'starting' | 'idle' | 'running' | 'awaiting_permission' | 'failed';
 export type TurnOutcome = 'completed' | 'refused' | 'cancelled' | 'failed' | 'inconclusive';
-export type TurnCancellationSource = 'owner' | 'local-console' | 'fleet-monitor' | 'scheduled-loop' | 'shutdown';
+export type TurnCancellationSource = 'owner' | 'local-console' | 'fleet-monitor' | 'scheduled-loop' | 'shutdown' | 'stall-watchdog';
 export type PromptOrigin = {
     kind: 'startup';
+} | {
+    kind: 'stall-watchdog';
 } | {
     kind: 'local-console';
 } | {
@@ -221,7 +223,7 @@ export interface AgentSessionCapabilities {
 }
 /** 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';
+export type SessionEventKind = 'state' | 'agent_text' | 'thought' | 'tool_call' | 'tool_update' | 'permission' | 'stall_recovery' | 'monitor_delivery' | 'turn_stop' | 'error';
 /** What a settled permission request resolved to. */
 export type PermissionDecision = 'allowed' | 'denied' | 'cancelled';
 export interface SessionEvent {
@@ -263,6 +265,7 @@ export interface SessionEvent {
     /** The option actually selected, when one was. */
     optionId?: string;
     /** Body-free evidence for monitor safe-boundary delivery. */
+    stallDiagnostic?: import('./stall-watchdog.js').StallDiagnostic;
     monitorPolicy?: 'after_tool';
     activeToolCount?: number;
     waitedMs?: number;

package/dist/temp-lifecycle.js

@@ -60,6 +60,9 @@ export function makeTempSupervisorLauncher(options = {}) {
     return async (binPath, args, dir) => {
         const inherited = [
             'HOME', 'PATH', 'XDG_RUNTIME_DIR', 'OURS_FLEET_HOME', 'CODEX_HOME',
+            // Preserve runtime selection across the service-manager boundary, including
+            // an explicit empty value which selects the bundle over manager defaults.
+            'CODEX_PATH',
             // The child supervisor performs daemon identity and wake probes itself;
             // it must resolve the same ours profile as the spawning supervisor.
             'OURS_PORT', 'OURS_STATE_DIR', 'OURS_API_TOKEN', 'OURS_CONFIG',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, managed native/ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",
@@ -52,7 +52,7 @@
   },
   "optionalDependencies": {
     "@agentclientprotocol/claude-agent-acp": "^0.63.0",
-    "@agentclientprotocol/codex-acp": "1.1.7"
+    "@agentclientprotocol/codex-acp": "1.10.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.54.1",