@ours.network/fleet 0.18.0-nightly.5 → 0.18.0

package/dist/owner-channel/mcp.d.ts

@@ -0,0 +1,24 @@
+export declare class OursMcpError extends Error {
+}
+export interface OursToolClient {
+    start(): Promise<void>;
+    callTool(name: string, args?: Record<string, unknown>): Promise<unknown>;
+    close(): Promise<void>;
+}
+/** Minimal MCP stdio client. One instance owns exactly one ours identity binding. */
+export declare class OursMcpClient implements OursToolClient {
+    private readonly command;
+    private readonly env;
+    private readonly log;
+    private child?;
+    private nextId;
+    private tail;
+    constructor(command?: string, env?: Record<string, string>, log?: (line: string) => void);
+    start(): Promise<void>;
+    callTool(name: string, args?: Record<string, unknown>): Promise<unknown>;
+    close(): Promise<void>;
+    private request;
+    private requestNow;
+    private notify;
+    private write;
+}

package/dist/owner-channel/mcp.js

@@ -0,0 +1,145 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { createInterface } from 'node:readline';
+export class OursMcpError extends Error {
+}
+/** Minimal MCP stdio client. One instance owns exactly one ours identity binding. */
+export class OursMcpClient {
+    command;
+    env;
+    log;
+    child;
+    nextId = 0;
+    tail = Promise.resolve();
+    constructor(command = 'ours-mcp', env = {}, log = () => undefined) {
+        this.command = command;
+        this.env = env;
+        this.log = log;
+    }
+    async start() {
+        if (this.child && this.child.exitCode === null)
+            return;
+        // ours-mcp normally records the long-lived client PID so an identity lease
+        // survives connector churn. An owner-channel connector has the opposite
+        // lifecycle: each supervised attempt owns a fresh connector and must make
+        // its lease reclaimable when that connector exits, even though the fleet
+        // supervisor itself remains alive. POSIX exec preserves the shell PID as
+        // the proxy PID, giving the daemon an exact process-lifetime fence without
+        // interpolating the command path into shell text.
+        const child = spawn('/bin/sh', [
+            '-c', 'OURS_CLIENT_PID=$$; export OURS_CLIENT_PID; exec "$1" "$2"',
+            'ours-fleet-owner-proxy', this.command, 'proxy',
+        ], {
+            env: {
+                ...process.env,
+                ...this.env,
+                // Bindings are keyed by this value. Sharing it would silently rebind a
+                // role's normal mailbox or another owner channel.
+                CLAUDE_CODE_SESSION_ID: `ours-fleet-owner-${process.pid}-${randomUUID()}`,
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        await new Promise((resolve, reject) => {
+            child.once('spawn', resolve);
+            child.once('error', reject);
+        });
+        this.child = child;
+        child.once('exit', (code, signal) => {
+            this.log(`ours-mcp proxy launcher exited (${code ?? signal ?? 'unknown'})`);
+        });
+        child.stdin.on('error', error => this.log(`ours-mcp stdin: ${error.message}`));
+        createInterface({ input: child.stderr }).on('line', line => this.log(`ours-mcp: ${line}`));
+        try {
+            await this.request('initialize', {
+                protocolVersion: '2025-03-26', capabilities: {},
+                clientInfo: { name: 'ours-fleet-owner-channel', version: '1' },
+            });
+            await this.notify('notifications/initialized', {});
+        }
+        catch (error) {
+            await this.close();
+            throw error;
+        }
+    }
+    async callTool(name, args = {}) {
+        const result = await this.request('tools/call', { name, arguments: args });
+        const text = (result.content ?? [])
+            .filter(item => item.type === 'text').map(item => item.text ?? '').join('\n').trim();
+        if (result.isError)
+            throw new OursMcpError(text || `ours tool ${name} failed`);
+        if (result.structuredContent !== undefined)
+            return result.structuredContent;
+        if (!text)
+            return {};
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    async close() {
+        const child = this.child;
+        this.child = undefined;
+        if (!child || child.exitCode !== null)
+            return;
+        // EOF asks the proxy to close normally. Once this exact process exits, the
+        // daemon can reclaim its lease even while the supervisor stays alive.
+        child.stdin.end();
+        const exited = await new Promise(resolve => {
+            const timer = setTimeout(() => resolve(false), 1_000);
+            child.once('exit', () => { clearTimeout(timer); resolve(true); });
+        });
+        if (exited || child.exitCode !== null)
+            return;
+        child.kill('SIGTERM');
+        await new Promise(resolve => {
+            const timer = setTimeout(() => { child.kill('SIGKILL'); resolve(); }, 5_000);
+            child.once('exit', () => { clearTimeout(timer); resolve(); });
+        });
+    }
+    request(method, params) {
+        const run = this.tail.then(() => this.requestNow(method, params));
+        this.tail = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async requestNow(method, params) {
+        const child = this.child;
+        if (!child || child.exitCode !== null)
+            throw new OursMcpError('ours-mcp proxy is not running');
+        const id = ++this.nextId;
+        await this.write(child, { jsonrpc: '2.0', id, method, params });
+        const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
+        try {
+            for await (const line of lines) {
+                let response;
+                try {
+                    response = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (response.id !== id)
+                    continue;
+                if (response.error !== undefined)
+                    throw new OursMcpError(JSON.stringify(response.error));
+                return response.result ?? {};
+            }
+            throw new OursMcpError('ours-mcp proxy closed its output');
+        }
+        finally {
+            lines.close();
+        }
+    }
+    async notify(method, params) {
+        const child = this.child;
+        if (!child || child.exitCode !== null)
+            throw new OursMcpError('ours-mcp proxy is not running');
+        await this.write(child, { jsonrpc: '2.0', method, params });
+    }
+    write(child, value) {
+        return new Promise((resolve, reject) => {
+            child.stdin.write(JSON.stringify(value) + '\n', error => error ? reject(error) : resolve());
+        });
+    }
+}

package/dist/owner-channel/notices.d.ts

@@ -22,6 +22,13 @@ export declare const ownerNotices: {
     receivedStarted: () => string;
     receivedQueued: (queuedBehind: number) => string;
     receivedInterrupting: () => string;
+    /**
+     * The honest answer when the agent is mid-task and pre-empting it would have
+     * corrupted the conversation. Says "not started yet" rather than borrowing
+     * `receivedInterrupting`'s claim that something was cancelled for this
+     * request.
+     */
+    receivedDeferred: () => string;
     status: (role: string, snapshot: SessionSnapshot) => string;
     interrupted: (role: string) => string;
     /** The turn IS cancelled — say how, without implying the owner must retry. */

package/dist/owner-channel/notices.js

@@ -26,6 +26,15 @@ export const ownerNotices = {
     receivedInterrupting: () => "ℹ️ Message received. The agent's previous task was interrupted to prioritize "
         + 'this request, and it is now working on a response. '
         + 'The response will arrive in this channel when ready.',
+    /**
+     * The honest answer when the agent is mid-task and pre-empting it would have
+     * corrupted the conversation. Says "not started yet" rather than borrowing
+     * `receivedInterrupting`'s claim that something was cancelled for this
+     * request.
+     */
+    receivedDeferred: () => 'ℹ️ Message received and held. The agent is in the middle of a task that '
+        + 'cannot be interrupted safely; this request starts as soon as that work '
+        + 'reaches a stopping point. The response will arrive in this channel when ready.',
     status: (role, snapshot) => `📊 ${role} status: ${snapshot.readiness}; session is ${snapshot.alive ? 'online' : 'offline'}.`,
     interrupted: (role) => `🛑 Interrupt sent to ${role}'s active turn.`,
     /** The turn IS cancelled — say how, without implying the owner must retry. */

package/dist/resolved-plan.js

@@ -18,6 +18,7 @@ export function resolvedPlan(cfg) {
         schemaVersion: RESOLVED_PLAN_SCHEMA_VERSION,
         sourceFiles: [...cfg.files],
         startStaggerMs: cfg.startStaggerMs,
+        harnesses: cfg.harnessPlugins,
         diagnostics: cfg.diagnostics.map(diagnostic => ({ ...diagnostic })),
         roles: cfg.roles.map(resolvedRolePlan),
         loops: cfg.loops.map(loop => sortedObject({

package/dist/runner.d.ts

@@ -35,6 +35,15 @@ export interface RunnerDeps {
 }
 /** Environment injected only into the managed harness process. */
 export declare function managedFleetProxyEnv(role: ResolvedRole, stateDir: string): Record<string, string>;
+/**
+ * The environment a managed harness child actually receives, checked at the one
+ * point where it is composed. `role.env` deliberately wins over harness prep,
+ * which is exactly how a stale fleet-wide model pin used to outrank the model
+ * the role was spawned with — so the model pin is verified here rather than
+ * trusted, and a disagreement stops the launch instead of being reported as a
+ * success (see src/model-env.ts).
+ */
+export declare function harnessChildEnv(role: ResolvedRole, launchEnv: Record<string, string> | undefined, stateDir: string): Record<string, string>;
 /**
  * Record who owns wake delivery for this run. Returning true means a fleet
  * monitor is taking ownership back from a native harness and must start at the
@@ -61,6 +70,23 @@ export declare function readExitRecord(path: string): ExitRecord | null;
 export declare const RESTART_LEDGER_FILE = ".restart-ledger.json";
 /** Consecutive immediate failures tolerated before the agent is held down. */
 export declare const RESTART_FAIL_THRESHOLD = 5;
+/**
+ * How the previous supervisor process ended.
+ *
+ * `abrupt` is the case the ledger used to miss entirely: an OOM-kill or any
+ * other external signal takes the supervisor down before it can write anything,
+ * the service manager restarts the unit, and every durable indicator still
+ * describes the run that died. A health check reading them reported "no
+ * restarts" for a role that had died and come back.
+ */
+export interface TerminationRecord {
+    class: 'clean' | 'abrupt' | 'unknown';
+    detail: string;
+    /** When the SURVIVING process observed it, not when it happened. */
+    observedAt: string;
+    /** Start time of the run that ended, when it was recorded. */
+    runStartedAt?: string;
+}
 export interface RestartLedger {
     version: 1;
     consecutiveImmediateFailures: number;
@@ -72,7 +98,29 @@ export interface RestartLedger {
     updatedAt: string;
     /** When the circuit opened, for the held-down status line. */
     openedAt?: string;
+    /** How the previous supervisor process ended, including abnormal exits. */
+    lastTermination?: TerminationRecord;
+    /** Supervisor processes that died without closing their run marker. */
+    abruptTerminations?: number;
+    /** Start of the supervisor run that owns this state directory now. */
+    supervisorStartedAt?: string;
 }
+/**
+ * Carried across a supervisor process's life so its successor can tell an
+ * orderly exit from a kill. Present on disk == "a supervisor believed it was
+ * running"; the next start finding one that is not its own is proof the
+ * previous process died without getting to write anything.
+ */
+export declare const RUN_MARKER_FILE = ".supervisor-run.json";
+/**
+ * Claim this state directory for the current supervisor process and report how
+ * the previous one ended. Runs BEFORE the first attempt, which is the whole
+ * point: after an abrupt kill nothing else writes until an attempt finishes,
+ * and an attempt can take minutes.
+ */
+export declare function claimSupervisorRun(dir: string, startedAt: string, pid?: number): TerminationRecord;
+/** Orderly exit: the successor must not read this run as a kill. */
+export declare function releaseSupervisorRun(dir: string): void;
 /** Bounded exponential backoff for the nth consecutive immediate failure. */
 export declare function backoffFor(consecutiveFailures: number): number;
 /** Read a role's restart ledger; a missing or corrupt one starts clean. */