@ours.network/fleet 1.0.5 → 1.1.0-nightly.10

package/dist/supervisor/none.js

@@ -1,7 +1,7 @@
 import { Tmux, tmuxArgs } from '../tmux.js';
 import { realExec, shq } from '../exec.js';
 /**
- * No supervision: sessions are plain tmux, nothing survives a reboot and
+ * No service supervision: tmux contains the direct runner process, nothing survives a reboot and
  * nothing restarts on crash. Used for temp agents and CI tests
  * (OURS_FLEET_SUPERVISOR=none).
  */
@@ -9,7 +9,7 @@ export function makeNoneBackend(exec = realExec) {
     const tmux = new Tmux(exec);
     return {
         id: 'none',
-        async init() { return ['no supervisor: sessions are plain tmux (no reboot survival)']; },
+        async init() { return ['no service supervisor: direct runner containment only (no reboot survival)']; },
         async install(name, binPath) {
             const existed = await tmux.kill(name); // true when a session was there
             await tmux.newSession(name, process.cwd(), `${shq(binPath)} _run ${shq(name)}`);

package/dist/temp-lifecycle.d.ts

@@ -5,7 +5,7 @@ export declare const TEMP_STOP_REQUEST_FILE = ".temp-stop-request.json";
 export declare const TEMP_RECLAIM_BATCH = 32;
 export declare const TEMP_LAUNCH_GRACE_MS = 60000;
 export type TempSupervisorKind = 'systemd-transient' | 'launchd-transient' | 'detached';
-export type TempTerminationReason = 'identity-closed' | 'session-ended' | 'operator-stop' | 'supervisor-signal' | 'startup-failure' | 'stale-supervisor';
+export type TempTerminationReason = 'identity-closed' | 'session-ended' | 'operator-stop' | 'supervisor-signal' | 'supervisor-recycle' | 'startup-failure' | 'stale-supervisor';
 export interface TempSupervisorRecord {
     version: 1;
     role: string;

package/dist/tmux.d.ts

@@ -20,7 +20,7 @@ export declare const tmuxSocket: (session: string) => string;
  * the shared default server and re-creates #32.
  */
 export declare const tmuxArgs: (session: string, args: string[]) => string[];
-/** Thin tmux wrapper; all session handling in the core goes through this. */
+/** Thin tmux wrapper retained only for supervisor=none process containment. */
 export declare class Tmux {
     private exec;
     constructor(exec?: Exec);
@@ -32,17 +32,4 @@ export declare class Tmux {
      * program inside it exited on its own".
      */
     kill(name: string): Promise<boolean>;
-    capture(name: string, lines?: number): Promise<string>;
-    /** Bounded ANSI/history seed for the browser terminal projection. */
-    captureHistory(name: string, lines?: number): Promise<string>;
-    panePid(name: string): Promise<number | null>;
-    /**
-     * List the live sessions among `names`, asking each server in turn.
-     * There is no fleet-wide `tmux ls` any more: a session per server means the
-     * caller says which sessions to ask about. A server that is not running
-     * answers non-zero and contributes nothing.
-     */
-    list(names: readonly string[]): Promise<string>;
-    sendText(name: string, text: string): Promise<void>;
-    sendKey(name: string, key: string): Promise<void>;
 }

package/dist/tmux.js

@@ -20,7 +20,7 @@ export const tmuxSocket = (session) => `${TMUX_SOCKET_PREFIX}${session}`;
  * the shared default server and re-creates #32.
  */
 export const tmuxArgs = (session, args) => ['-L', tmuxSocket(session), ...args];
-/** Thin tmux wrapper; all session handling in the core goes through this. */
+/** Thin tmux wrapper retained only for supervisor=none process containment. */
 export class Tmux {
     exec;
     constructor(exec = realExec) {
@@ -42,54 +42,4 @@ export class Tmux {
     async kill(name) {
         return (await this.exec('tmux', tmuxArgs(name, ['kill-session', '-t', name]))).code === 0;
     }
-    async capture(name, lines = 40) {
-        const r = await this.exec('tmux', tmuxArgs(name, ['capture-pane', '-t', name, '-p']));
-        if (r.code !== 0)
-            throw new Error(`tmux capture-pane '${name}' failed: ${r.stderr.trim()}`);
-        const all = r.stdout.replace(/\n+$/, '').split('\n');
-        return all.slice(-lines).join('\n');
-    }
-    /** Bounded ANSI/history seed for the browser terminal projection. */
-    async captureHistory(name, lines = 5_000) {
-        const bounded = Math.min(Math.max(Math.trunc(lines), 1), 20_000);
-        const r = await this.exec('tmux', tmuxArgs(name, ['capture-pane', '-t', name, '-p', '-e', '-J', '-S', `-${bounded}`]));
-        if (r.code !== 0)
-            throw new Error(`tmux capture-pane '${name}' failed: ${r.stderr.trim()}`);
-        return Buffer.from(r.stdout).subarray(0, 4 * 1024 * 1024).toString();
-    }
-    async panePid(name) {
-        const r = await this.exec('tmux', tmuxArgs(name, ['list-panes', '-t', name, '-F', '#{pane_pid}']));
-        if (r.code !== 0)
-            return null;
-        const pid = parseInt(r.stdout.trim().split('\n')[0], 10);
-        return Number.isFinite(pid) ? pid : null;
-    }
-    /**
-     * List the live sessions among `names`, asking each server in turn.
-     * There is no fleet-wide `tmux ls` any more: a session per server means the
-     * caller says which sessions to ask about. A server that is not running
-     * answers non-zero and contributes nothing.
-     */
-    async list(names) {
-        const lines = [];
-        for (const name of names) {
-            const r = await this.exec('tmux', tmuxArgs(name, ['ls']));
-            if (r.code === 0 && r.stdout.trim())
-                lines.push(r.stdout.trimEnd());
-        }
-        return lines.join('\n');
-    }
-    async sendText(name, text) {
-        let r = await this.exec('tmux', tmuxArgs(name, ['send-keys', '-t', name, '-l', text]));
-        if (r.code !== 0)
-            throw new Error(`tmux send-keys '${name}' failed: ${r.stderr.trim()}`);
-        r = await this.exec('tmux', tmuxArgs(name, ['send-keys', '-t', name, 'Enter']));
-        if (r.code !== 0)
-            throw new Error(`tmux send-keys Enter '${name}' failed: ${r.stderr.trim()}`);
-    }
-    async sendKey(name, key) {
-        const r = await this.exec('tmux', tmuxArgs(name, ['send-keys', '-t', name, key]));
-        if (r.code !== 0)
-            throw new Error(`tmux send-keys '${name}' failed: ${r.stderr.trim()}`);
-    }
 }

package/dist/watchdog/config.d.ts

@@ -1,19 +1,19 @@
-import type { FleetConfig, ResolvedRole, SessionBackendId } from '../config.js';
+import type { AgentDefinition, FleetConfig, ResolvedRole } from '../config.js';
+import type { SessionBackendId } from '../config.js';
 import type { IsolationConfig } from '../isolation/types.js';
 export interface WatchdogConfig {
     coordinator?: string;
     enabled?: boolean;
     interval?: string;
     watch?: string[];
-    harness?: string;
-    model?: string | null;
-    session?: string;
+    agent?: {
+        ref: string;
+    } | AgentDefinition;
     identity?: string;
     timeout?: string;
     keep_reports?: number;
     alert_cooldown?: string;
     prompt_file?: string;
-    isolation?: IsolationConfig;
 }
 export interface ResolvedWatchdog {
     name: string;
@@ -22,15 +22,18 @@ export interface ResolvedWatchdog {
     intervalMs: number;
     watch: string[];
     watchExplicit: boolean;
+    agentDefinition: AgentDefinition;
+    resolvedAgent: ResolvedRole;
+    /** Resolved/read-only runtime facts; never independent authoring fields. */
     harness: string;
     session: SessionBackendId;
     model?: string;
+    isolation?: IsolationConfig;
     identity: string;
     timeoutMs: number;
     keepReports: number;
     alertCooldownMs: number;
     promptFile?: string;
-    isolation?: IsolationConfig;
     sourceFile: string;
 }
 export declare const WATCHDOG_DEFAULT_INTERVAL_MS = 600000;
@@ -38,7 +41,7 @@ export declare const WATCHDOG_MIN_INTERVAL_MS = 60000;
 export declare const WATCHDOG_DEFAULT_TIMEOUT_MS = 300000;
 export declare const WATCHDOG_DEFAULT_KEEP_REPORTS = 50;
 export declare const WATCHDOG_DEFAULT_COOLDOWN_MS = 3600000;
-export declare function resolveWatchdogs(baseDoc: Record<string, unknown>, baseFile: string, roles: ResolvedRole[], vars: Record<string, string>, defaults: Record<string, unknown>): ResolvedWatchdog[];
+export declare function resolveWatchdogs(baseDoc: Record<string, unknown>, baseFile: string, roles: ResolvedRole[], vars: Record<string, string>, agentDefinitions: Record<string, AgentDefinition>, resolveInline: (name: string, definition: AgentDefinition) => ResolvedRole): ResolvedWatchdog[];
 /**
  * Split `restart`'s argument names into watchdogs (a release, handled
  * directly) and roles (handed to restartRoles). Watchdog names can't collide

package/dist/watchdog/config.js

@@ -1,11 +1,10 @@
 import { existsSync } from 'node:fs';
 import { isAbsolute } from 'node:path';
 import { parseDuration } from '../duration.js';
-import { ConfigError, ROLE_NAME_RE, resolveRoleModel } from '../config.js';
-import { validateIsolationConfig } from '../isolation/policy.js';
+import { ConfigError, ROLE_NAME_RE } from '../config.js';
 const WATCHDOG_KEYS = [
-    'coordinator', 'enabled', 'interval', 'watch', 'harness', 'model', 'session',
-    'identity', 'timeout', 'keep_reports', 'alert_cooldown', 'prompt_file', 'isolation',
+    'coordinator', 'enabled', 'interval', 'watch', 'agent',
+    'identity', 'timeout', 'keep_reports', 'alert_cooldown', 'prompt_file',
 ];
 export const WATCHDOG_DEFAULT_INTERVAL_MS = 600_000;
 export const WATCHDOG_MIN_INTERVAL_MS = 60_000;
@@ -21,7 +20,7 @@ function deepSub(v, vars) {
         return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, deepSub(x, vars)]));
     return v;
 }
-export function resolveWatchdogs(baseDoc, baseFile, roles, vars, defaults) {
+export function resolveWatchdogs(baseDoc, baseFile, roles, vars, agentDefinitions, resolveInline) {
     const block = baseDoc.watchdogs;
     if (block === undefined || block === null)
         return [];
@@ -31,7 +30,7 @@ export function resolveWatchdogs(baseDoc, baseFile, roles, vars, defaults) {
     const roleIdentities = new Set(roles.map(r => r.identity));
     // Tracks identity -> owning watchdog name across entries:
     // two watchdogs declaring the same identity would otherwise share a temp
-    // dir, tmux session, and run lock with no error until they collide at
+    // dir, agent session, and run lock with no error until they collide at
     // runtime.
     const watchdogIdentities = new Map();
     const out = [];
@@ -42,6 +41,9 @@ export function resolveWatchdogs(baseDoc, baseFile, roles, vars, defaults) {
         if (roleNames.has(name))
             throw new ConfigError(`${baseFile}: watchdog '${name}' collides with a role name`);
         const w = deepSub(rawEntry ?? {}, vars);
+        const legacy = ['harness', 'model', 'session', 'isolation'].filter(key => Object.hasOwn(w, key));
+        if (legacy.length)
+            throw new ConfigError(`${where}: E_LEGACY Brain/Agent-owned field(s) ${legacy.join(', ')} are unsupported; select a canonical Agent with agent`);
         const bad = Object.keys(w).filter(k => !WATCHDOG_KEYS.includes(k));
         if (bad.length)
             throw new ConfigError(`${where} has unknown key(s) ${bad.join(', ')}; allowed: ${WATCHDOG_KEYS.join(', ')}`);
@@ -60,21 +62,29 @@ export function resolveWatchdogs(baseDoc, baseFile, roles, vars, defaults) {
         if (collidingWatchdog !== undefined)
             throw new ConfigError(`${where}: identity '${identity}' collides with watchdog '${collidingWatchdog}'`);
         watchdogIdentities.set(identity, name);
-        const harness = w.harness ?? defaults.harness ?? 'claude-code';
-        const sessionRaw = w.session ?? defaults.session ?? 'tmux';
-        if (sessionRaw !== 'tmux' && sessionRaw !== 'acp')
-            throw new ConfigError(`${where}: session must be 'tmux' or 'acp'`);
+        if (!w.agent || typeof w.agent !== 'object' || Array.isArray(w.agent))
+            throw new ConfigError(`${where}: agent is required (Agent ref or canonical Agent definition)`);
+        let agentDefinition;
+        let resolvedAgent;
+        if ('ref' in w.agent) {
+            const ref = w.agent.ref;
+            if (typeof ref !== 'string' || !ref)
+                throw new ConfigError(`${where}: agent.ref must be a declared Agent ID`);
+            agentDefinition = agentDefinitions[ref];
+            resolvedAgent = roles.find(role => role.name === ref);
+            if (!agentDefinition || !resolvedAgent)
+                throw new ConfigError(`${where}: Agent ref '${ref}' was not found`);
+        }
+        else {
+            agentDefinition = structuredClone(w.agent);
+            resolvedAgent = resolveInline(name, agentDefinition);
+        }
         if (w.prompt_file !== undefined) {
             if (typeof w.prompt_file !== 'string' || !isAbsolute(w.prompt_file))
                 throw new ConfigError(`${where}: prompt_file must be an absolute path`);
             if (!existsSync(w.prompt_file))
                 throw new ConfigError(`${where}: prompt_file not found: ${w.prompt_file}`);
         }
-        if (w.isolation !== undefined) {
-            const problems = validateIsolationConfig(w.isolation);
-            if (problems.length)
-                throw new ConfigError(`${where} ${problems.join('; ')}`);
-        }
         const dur = (v, key, fallback, minMs) => {
             if (v === undefined)
                 return fallback;
@@ -94,13 +104,15 @@ export function resolveWatchdogs(baseDoc, baseFile, roles, vars, defaults) {
             name, coordinator: w.coordinator.trim(),
             enabled: w.enabled ?? true,
             intervalMs: dur(w.interval, 'interval', WATCHDOG_DEFAULT_INTERVAL_MS, WATCHDOG_MIN_INTERVAL_MS),
-            watch, watchExplicit: w.watch !== undefined, harness, session: sessionRaw,
-            model: resolveRoleModel(w.model, w.harness, defaults),
+            watch, watchExplicit: w.watch !== undefined,
+            agentDefinition: structuredClone(agentDefinition), resolvedAgent: structuredClone(resolvedAgent),
+            harness: resolvedAgent.harness, session: resolvedAgent.session,
+            model: resolvedAgent.model, isolation: resolvedAgent.isolation,
             identity,
             timeoutMs: dur(w.timeout, 'timeout', WATCHDOG_DEFAULT_TIMEOUT_MS),
             keepReports,
             alertCooldownMs: dur(w.alert_cooldown, 'alert_cooldown', WATCHDOG_DEFAULT_COOLDOWN_MS),
-            promptFile: w.prompt_file, isolation: w.isolation, sourceFile: baseFile,
+            promptFile: w.prompt_file, sourceFile: baseFile,
         });
     }
     return out;

package/dist/watchdog/run.js

@@ -1,7 +1,6 @@
 import { closeSync, existsSync, openSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from 'node:fs';
-import { spawn as spawnChild, execFile } from 'node:child_process';
+import { spawn as spawnChild } from 'node:child_process';
 import { join } from 'node:path';
-import { promisify } from 'node:util';
 import { stringify } from 'yaml';
 import { errorReport, normalizeWatchdogReport, validateWatchdogReport } from './report.js';
 import { acquireRunLock, formatRunId, pruneReports, releaseRunLock, writeReport } from './store.js';
@@ -11,12 +10,10 @@ import { applyRole } from '../ops.js';
 import { daemonIdentityInventoryProvisioner, ensureIdentity, } from '../creation.js';
 import { runOnce, START_STAGGER_FILE } from '../runner.js';
 import { agentDir, tmpRoot } from '../paths.js';
-import { loadConfig, resolveMonitorConfig, resolveWorklogPolicy, ROLE_NAME_RE, } from '../config.js';
+import { loadConfig, ROLE_NAME_RE, } from '../config.js';
 import { getAdapter } from '../harness/registry.js';
 import { redactLogLine } from '../application/log-service.js';
 import { controlRequest, controlSocketPath } from '../session/control.js';
-import { Tmux } from '../tmux.js';
-const execFileAsync = promisify(execFile);
 /** How often the deadline loop polls for a completed report or a dead child. */
 const POLL_MS = 1000;
 /** A `report.json` this old, with no further writes, is treated as finished. */
@@ -56,7 +53,6 @@ async function killIfNeeded(reason, child, roleName, sleep) {
         if (reason === 'stable')
             await sleep(HARVEST_GRACE_MS);
         child.kill();
-        await killTmuxSession(roleName);
     }
 }
 function defaultLaunchChild(binPath, roleName, runDir) {
@@ -77,13 +73,6 @@ function defaultLaunchChild(binPath, roleName, runDir) {
         }),
     };
 }
-/** Best-effort: the tmux session outlives the supervisor child (`runOnce` created it). */
-async function killTmuxSession(roleName) {
-    try {
-        await execFileAsync('tmux', ['kill-session', '-t', roleName]);
-    }
-    catch { /* best effort */ }
-}
 /** Last 4096 chars of run.log, redacted — attached to error reports as diagnostic tail. */
 function readTail(runDir) {
     try {
@@ -95,19 +84,10 @@ function readTail(runDir) {
     }
 }
 /** The temp role every watchdog-family run launches under. Isolation is opt-in. */
-function buildWatchdogRole(wd, cfg) {
+function buildWatchdogRole(wd, _cfg) {
     return {
-        name: wd.identity, sourceFile: '(watchdog)',
-        harness: wd.harness, session: wd.session,
-        identity: wd.identity, model: wd.model,
-        // Watchdogs are observe-only by contract, but their sanctioned status commands
-        // must reach host control sockets. Keep approvals/unattended escalation denied
-        // while disabling the harness's native filesystem/network sandbox.
-        permissions: { approval: 'deny', filesystem: 'unrestricted', unattended: 'deny' },
-        permissionsDeclared: true,
-        monitor: resolveMonitorConfig(cfg.defaults.monitor, undefined),
-        worklog: resolveWorklogPolicy(cfg.defaults.worklog, undefined),
-        isolation: wd.isolation,
+        ...structuredClone(wd.resolvedAgent),
+        name: wd.identity, sourceFile: '(watchdog)', identity: wd.identity,
     };
 }
 /** Discover temporary sessions that are live now, not merely stale dirs on disk. */
@@ -121,19 +101,15 @@ async function discoverLiveTemporaryRoles() {
     catch {
         return [];
     }
-    const tmux = new Tmux();
     const live = await Promise.all(names.map(async (name) => {
         const dir = agentDir(name, true);
-        const [acpAlive, tmuxAlive] = await Promise.all([
-            existsSync(controlSocketPath(dir))
-                ? controlRequest(dir, { command: 'status' }, 2_000)
-                    .then(response => response.ok
-                    && response.result?.alive === true)
-                    .catch(() => false)
-                : Promise.resolve(false),
-            tmux.has(name).catch(() => false),
-        ]);
-        return acpAlive || tmuxAlive ? name : undefined;
+        const alive = existsSync(controlSocketPath(dir))
+            ? await controlRequest(dir, { command: 'status' }, 2_000)
+                .then(response => response.ok
+                && response.result?.alive === true)
+                .catch(() => false)
+            : false;
+        return alive ? name : undefined;
     }));
     return live.filter((name) => name !== undefined);
 }

package/dist/web/auth.d.ts

@@ -16,7 +16,7 @@ export interface AuthResult {
 interface Ticket {
     value: string;
     sessionId: string;
-    purpose: 'events' | 'terminal' | 'conversation';
+    purpose: 'events' | 'conversation';
     roleId?: string;
     expiresAt: number;
 }

package/dist/web/fleet-config-service.d.ts

@@ -1,10 +1,13 @@
 import type { PrereqReport } from '../harness/types.js';
 export declare const REDACTED_ENV_VALUE = "__OURS_FLEET_SECRET_REDACTED__";
-export type EditableFleetModel = Record<string, unknown>;
+export interface EditableFleetModel {
+    manifest: Record<string, unknown>;
+    agents: Record<string, Record<string, unknown>>;
+}
 export interface ConfigReadResult {
     path: string;
-    exists: boolean;
-    firstRun: boolean;
+    exists: true;
+    firstRun: false;
     revision: string;
     model: EditableFleetModel;
     redactions: string[];
@@ -33,15 +36,15 @@ export interface ConfigWriteResult extends ConfigPreviewResult {
 export interface FleetConfigServiceOptions {
     configPath?: string;
     preflight?(configPath: string): Promise<PrereqReport>;
+    /** Fault-injection seam; called under lock immediately before each mutation. */
+    beforeMutation?(relativePath: string, index: number): void;
 }
 export declare class FleetConfigService {
     readonly path: string;
     private readonly preflight;
+    private readonly beforeMutation?;
     constructor(options?: FleetConfigServiceOptions);
     read(): ConfigReadResult;
-    preview(baseRevision: string, model: unknown): Promise<ConfigPreviewResult>;
-    write(baseRevision: string, model: unknown): Promise<ConfigWriteResult>;
-    private readSource;
-    private assertRevision;
-    private validateCandidate;
+    preview(baseRevision: string, input: unknown): Promise<ConfigPreviewResult>;
+    write(baseRevision: string, input: unknown): Promise<ConfigWriteResult>;
 }