@ours.network/fleet 1.1.0-nightly.1 → 1.1.0-nightly.3

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 [];
@@ -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,23 +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 ?? 'acp';
-        if (sessionRaw === 'tmux')
-            throw new ConfigError(`${where}: session 'tmux' is no longer supported; use session: acp`);
-        if (sessionRaw !== 'acp')
-            throw new ConfigError(`${where}: session must be '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;
@@ -96,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

@@ -10,7 +10,7 @@ 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';
@@ -84,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. */

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>;
 }