@ours.network/fleet 1.1.0-nightly.2 → 1.1.0-nightly.4

package/dist/spawn.js

@@ -4,8 +4,7 @@ import { join } from 'node:path';
 import { parse, stringify } from 'yaml';
 import { agentDir, defaultConfigPath } from './paths.js';
 import { validateIsolationConfig } from './isolation/policy.js';
-import { loadConfig, resolveAuthProxy, resolveModelChain, resolveMonitorConfig, resolveOwnerChannelConfig, resolvePermissions, resolveRoleModel, resolveWorklogPolicy, splitRootFor, validateMonitorConfig, } from './config.js';
-import { resolveRoleModelEnv } from './model-env.js';
+import { loadConfig, findRole, splitRootFor, validateMonitorConfig, } from './config.js';
 import { applyRole, up } from './ops.js';
 import { START_STAGGER_FILE } from './runner.js';
 import { buildProvenance, daemonIdentityProvisioner, ensureIdentity, provenanceOf, withCreationTransaction, writeProvenance, writeRoleFile, } from './creation.js';
@@ -13,86 +12,46 @@ import { VERSION } from './version.js';
 import { recordGeneratedAgentSource } from './generated-agent-source.js';
 import './harness/claude-code.js';
 import './harness/codex.js';
-import { getAdapter } from './harness/registry.js';
 import { archiveTempState, makeTempSupervisorLauncher, prepareTempSupervisor, reclaimStaleTempState, } from './temp-lifecycle.js';
 /**
  * The provenance record written by the most recent spawn in this process, so
  * the CLI can print the same summary it persisted rather than rebuilding it.
  */
 export let lastProvenance;
-export function profileValues(o) {
-    if (o.bio !== undefined && o.bioFile)
-        throw new Error('bio and bioFile are mutually exclusive');
-    if (o.persona !== undefined && o.personaFile)
-        throw new Error('persona and personaFile are mutually exclusive');
+export function agentDefinitionFromSpawn(o) {
+    if (o.agentDefinition) {
+        if (o.brain !== undefined || o.role !== undefined || o.cwd !== undefined
+            || o.coordinator !== undefined || o.approval !== undefined || o.filesystem !== undefined
+            || o.unattended !== undefined || o.isolationFile !== undefined || o.monitorConfig !== undefined)
+            throw new Error('canonical agentDefinition conflicts with separate Agent fields');
+        const definition = structuredClone(o.agentDefinition);
+        if (o.identity)
+            definition.identity = o.identity;
+        return definition;
+    }
+    if (!o.role)
+        throw new Error('--role is required (declared ID or inline mapping)');
+    if (!o.brain)
+        throw new Error('--brain is required (declared ID or inline mapping)');
+    const permissions = o.approval || o.filesystem || o.unattended ? {
+        ...(o.approval ? { approval: o.approval } : {}),
+        ...(o.filesystem ? { filesystem: o.filesystem } : {}),
+        ...(o.unattended ? { unattended: o.unattended } : {}),
+    } : undefined;
     return {
-        bio: o.bio !== undefined ? o.bio.trim()
-            : o.bioFile ? readFileSync(o.bioFile, 'utf8').trim() : undefined,
-        persona: o.persona !== undefined ? o.persona.trim()
-            : o.personaFile ? readFileSync(o.personaFile, 'utf8').trim() : undefined,
+        role: structuredClone(o.role), brain: structuredClone(o.brain),
+        ...(o.identity ? { identity: o.identity } : {}),
+        ...(o.cwd ? { cwd: o.cwd } : {}),
+        ...(o.coordinator ? { coordinator: o.coordinator } : {}),
+        ...(permissions ? { permissions } : {}),
+        ...(o.isolationFile ? { isolation: readIsolationFile(o.isolationFile) } : {}),
+        ...(o.monitorConfig ? { monitor: structuredClone(o.monitorConfig) } : {}),
     };
 }
-/** Pure option-to-role mapping shared by CLI and application services. */
-export function buildRoleConfig(o, defaultHarness) {
-    const r = {};
-    const harness = o.harness ?? defaultHarness;
-    if (harness)
-        r.harness = harness;
-    if (o.session)
-        r.session = o.session;
-    if (o.identity)
-        r.identity = o.identity;
-    if (o.cwd)
-        r.cwd = o.cwd;
-    if (o.coordinator)
-        r.coordinator = o.coordinator;
-    if (o.missionFile)
-        r.mission = readMissionFile(o.missionFile);
-    else if (o.mission !== undefined)
-        r.mission = o.mission;
-    if (o.model === null)
-        r.model = null;
-    else if (o.model?.trim())
-        r.model = o.model.trim();
-    if (o.reasoningEffort?.trim())
-        r.effort = o.reasoningEffort.trim();
-    const harnessOptions = {};
-    if (o.permissionMode)
-        harnessOptions[harness === 'claude-code' ? 'permission_mode' : 'approval'] = o.permissionMode;
-    if (o.sandbox)
-        harnessOptions.sandbox = o.sandbox;
-    if (o.profile)
-        harnessOptions.profile = o.profile;
-    if (o.launcher)
-        harnessOptions.launcher = o.launcher;
-    if (o.search === true)
-        harnessOptions.search = true;
-    const codexConfig = { ...(o.codexConfig ?? {}) };
-    if (Object.keys(codexConfig).length)
-        harnessOptions.config = codexConfig;
-    if (o.addDirs?.length)
-        harnessOptions.add_dirs = o.addDirs;
-    if (o.monitor === true)
-        harnessOptions.monitor = true;
-    if (Object.keys(harnessOptions).length)
-        r.harness_options = harnessOptions;
-    if (o.approval || o.filesystem || o.unattended) {
-        r.permissions = {
-            ...(o.approval ? { approval: o.approval } : {}),
-            ...(o.filesystem ? { filesystem: o.filesystem } : {}),
-            ...(o.unattended ? { unattended: o.unattended } : {}),
-        };
-    }
-    const profile = profileValues(o);
-    if (profile.bio)
-        r.bio = profile.bio;
-    if (profile.persona)
-        r.persona = profile.persona;
-    if (o.isolationFile)
-        r.isolation = readIsolationFile(o.isolationFile);
-    if (o.monitorConfig)
-        r.monitor = { ...o.monitorConfig };
-    return r;
+function resolvedSpawn(o) {
+    const definition = agentDefinitionFromSpawn(o);
+    const cfg = loadConfig(o.configPath, { additionalAgent: { id: o.name, definition } });
+    return { definition, role: findRole(cfg, o.name) };
 }
 /**
  * Read and validate an `--isolation-file`. The file is the existing
@@ -120,12 +79,6 @@ export function readIsolationFile(path) {
     return cfg;
 }
 export function validateSpawnOpts(o) {
-    if (o.mission !== undefined && o.missionFile)
-        throw new Error('--mission and --mission-file are mutually exclusive');
-    if (o.session === 'tmux')
-        throw new Error("invalid --session 'tmux'; tmux is no longer supported; use --session acp");
-    if (o.session && o.session !== 'acp')
-        throw new Error(`invalid --session '${o.session}'; allowed: acp`);
     if (o.approval && !['ask', 'auto', 'allow', 'deny'].includes(o.approval))
         throw new Error(`invalid --approval '${o.approval}'; allowed: ask, auto, allow (deprecated alias: deny)`);
     if (o.filesystem && !['read-only', 'workspace', 'unrestricted'].includes(o.filesystem))
@@ -136,23 +89,12 @@ export function validateSpawnOpts(o) {
         throw new Error(`invalid role name '${o.name}'`);
     if (o.identity && !/^[A-Za-z0-9_-]+$/.test(o.identity))
         throw new Error(`invalid identity name '${o.identity}'`);
-    if (o.model && (o.model.length > 128 || /[\0-\x1f\x7f]/.test(o.model)))
-        throw new Error('model must be printable and at most 128 characters');
     if (o.monitorConfig) {
         const problems = validateMonitorConfig(o.monitorConfig);
         if (problems.length)
             throw new Error(problems.join('; '));
     }
 }
-/** Read mission text without trimming or newline rewriting. */
-export function readMissionFile(path) {
-    try {
-        return readFileSync(path, 'utf8');
-    }
-    catch (e) {
-        throw new Error(`--mission-file ${path}: ${e.message}`);
-    }
-}
 /**
  * Reject names that are already USED. This is a precondition, not a claim: it
  * runs INSIDE the creation transaction, after both names are reserved, so the
@@ -173,23 +115,6 @@ function assertNameFree(o) {
 }
 /** The ours identity a spawn will bind: explicit, else the role name. */
 export const effectiveIdentity = (o) => o.identity ?? o.name;
-/** Bare Agent document written by v2 spawn: inline Role × inline Brain + operations. */
-export function buildAgentDocument(raw) {
-    const role = Object.fromEntries(['mission', 'persona', 'bio', 'briefing_file']
-        .filter(key => raw[key] !== undefined)
-        .map(key => [key, raw[key]]));
-    const brain = Object.fromEntries([
-        'harness', 'session', 'session_options', 'model', 'model_chain', 'max_tokens',
-        'autocompact_pct', 'harness_options', 'effort',
-    ].filter(key => raw[key] !== undefined)
-        .map(key => [key, raw[key]]));
-    const operational = Object.fromEntries([
-        'permissions', 'identity', 'cwd', 'coordinator', 'env', 'oversee', 'isolation',
-        'monitor', 'owner_channel', 'worklog', 'auth_proxy',
-    ].filter(key => raw[key] !== undefined)
-        .map(key => [key, raw[key]]));
-    return { role: { inline: role }, brain: { inline: brain }, ...operational };
-}
 /**
  * Validate and resolve a spawn without reserving names, contacting the daemon,
  * or writing state. Collision checks are necessarily a point-in-time snapshot.
@@ -198,68 +123,13 @@ export function spawnDryRun(o) {
     validateSpawnOpts(o);
     if (o.isolationFile)
         readIsolationFile(o.isolationFile);
-    if (o.missionFile)
-        readMissionFile(o.missionFile);
     assertNameFree(o);
-    const cfg = loadConfig(o.configPath);
-    const raw = buildRoleConfig(o, cfg.defaults.harness ?? 'claude-code');
-    const harnessOptions = {
-        ...(cfg.defaults.harness_options ?? {}),
-        ...(raw.harness_options ?? {}),
-    };
-    const harness = raw.harness ?? cfg.defaults.harness ?? 'claude-code';
-    const defaultHarness = cfg.defaults.harness ?? 'claude-code';
-    const inheritsModelDefaults = harness === defaultHarness && raw.model !== null;
-    const authProxy = resolveAuthProxy(cfg.defaults.auth_proxy, raw.auth_proxy);
-    // One resolution for the environment and the model it pins (src/model-env.ts).
-    const modelEnv = resolveRoleModelEnv({
-        harness,
-        model: resolveRoleModel(raw.model, raw.harness, cfg.defaults),
-        modelWasExplicit: raw.model !== undefined,
-        defaultsEnv: (cfg.defaults.env ?? {}),
-        roleEnv: raw.env,
-        ...(authProxy ? { authProxyBaseUrl: authProxy.base_url } : {}),
-    });
-    const adapter = getAdapter(harness);
-    const brain = adapter.agentSession.resolveBrain({
-        model: modelEnv.model,
-        effort: raw.effort,
-        harnessOptions: Object.keys(harnessOptions).length ? harnessOptions : undefined,
-    });
-    const model = brain.model ?? undefined;
-    const session = raw.session ?? cfg.defaults.session ?? 'acp';
-    const resolvedRole = {
-        ...raw,
-        name: o.name,
-        sourceFile: o.temp ? '(temp dry-run)' : join(splitRootFor(o.configPath ?? defaultConfigPath()), 'agents', `${o.name}.yaml`),
-        harness,
-        session,
-        session_options: raw.session_options,
-        permissions: resolvePermissions(cfg.defaults.permissions, raw.permissions),
-        permissionsDeclared: raw.permissions !== undefined || cfg.defaults.permissions !== undefined,
-        identity: effectiveIdentity(o),
-        effort: raw.effort,
-        model,
-        model_chain: resolveModelChain(model, raw.model_chain ?? (inheritsModelDefaults
-            ? cfg.defaults.model_chain
-            : undefined)),
-        harness_options: brain.harnessOptions,
-        isolation: raw.isolation ?? cfg.defaults.isolation,
-        monitor: resolveMonitorConfig(cfg.defaults.monitor, raw.monitor),
-        owner_channel: resolveOwnerChannelConfig(cfg.defaults.owner_channel, raw.owner_channel, session),
-        worklog: resolveWorklogPolicy(cfg.defaults.worklog, raw.worklog),
-        auth_proxy: authProxy,
-    };
-    resolvedRole.env = modelEnv.env;
-    if (resolvedRole.auth_proxy && resolvedRole.harness !== 'claude-code')
-        throw new Error('auth_proxy is supported only by claude-code');
-    const optionProblems = adapter.validateOptions(resolvedRole.harness_options, resolvedRole);
-    if (optionProblems.length)
-        throw new Error(optionProblems.map(problem => `${problem.path}: ${problem.message}`).join('; '));
+    const resolved = resolvedSpawn(o);
+    const resolvedRole = resolved.role;
     return {
         schemaVersion: 1,
         warning: 'collision checks are a snapshot; a real spawn reserves names atomically',
-        roleDocument: buildAgentDocument(raw),
+        roleDocument: structuredClone(resolved.definition),
         resolvedRole,
     };
 }
@@ -275,22 +145,15 @@ function provenanceSettings(o, defaults) {
     const perms = (defaults.permissions ?? {});
     const callerDefaults = new Set(o.inheritedFromCaller ?? []);
     const tagged = (key, entry) => callerDefaults.has(key) ? { ...entry, source: 'caller-role' } : entry;
-    const explicitModel = typeof o.model === 'string' ? o.model.trim() : undefined;
-    const inheritedModel = resolveRoleModel(undefined, o.harness, defaults);
+    const selection = (value) => value && 'ref' in value ? `ref:${value.ref}` : value ? 'inline' : undefined;
     return {
-        harness: tagged('harness', provenanceOf(o.harness, defaults.harness, 'claude-code')),
-        session: tagged('session', provenanceOf(o.session, defaults.session, 'acp')),
+        brain: tagged('brain', provenanceOf(selection(o.brain), undefined, undefined)),
+        role: tagged('role', provenanceOf(selection(o.role), undefined, undefined)),
         identity: o.identity
             ? { value: o.identity, source: 'cli' }
             : { value: o.name, source: 'built-in' }, // defaults to the role name
         cwd: tagged('cwd', provenanceOf(o.cwd, undefined, undefined)),
-        model: tagged('model', o.model === null
-            ? { value: undefined, source: 'cli' }
-            : explicitModel
-                ? { value: explicitModel, source: 'cli' }
-                : { value: inheritedModel, source: inheritedModel ? 'fleet-default' : 'built-in' }),
         coordinator: tagged('coordinator', provenanceOf(o.coordinator, undefined, undefined)),
-        permission_mode: provenanceOf(o.permissionMode, undefined, undefined),
         approval: tagged('approval', provenanceOf(o.approval, perms.approval, 'ask')),
         filesystem: tagged('filesystem', provenanceOf(o.filesystem, perms.filesystem, 'workspace')),
         unattended: tagged('unattended', provenanceOf(o.unattended, perms.unattended, 'deny')),
@@ -305,8 +168,7 @@ export async function spawnPermanent(o, deps, creation = {}) {
     validateSpawnOpts(o);
     if (o.isolationFile)
         readIsolationFile(o.isolationFile); // fail before reserving
-    if (o.missionFile)
-        readMissionFile(o.missionFile); // fail before reserving
+    const prepared = resolvedSpawn(o); // canonical validation before mutation
     // Reserve name and identity together before anything is written or started.
     // A loser of the race creates no config, state, or service.
     creation.onStage?.('reserving');
@@ -316,7 +178,7 @@ export async function spawnPermanent(o, deps, creation = {}) {
         // Establish the identity BEFORE the service is enabled, and record
         // what was actually guaranteed so the briefing can say something true.
         creation.onStage?.('checking_identity');
-        const guarantee = await ensureIdentity(effectiveIdentity(o), profileValues(o), creation.identityProvisioner ?? deps.identityProvisioner ?? daemonIdentityProvisioner(), deps.log);
+        const guarantee = await ensureIdentity(effectiveIdentity(o), { bio: prepared.role.bio, persona: prepared.role.persona }, creation.identityProvisioner ?? deps.identityProvisioner ?? daemonIdentityProvisioner(), deps.log);
         creation.onStage?.('checking_identity', {
             result: guarantee.evidence, guarantee: guarantee.state,
         });
@@ -333,7 +195,7 @@ export async function spawnPermanent(o, deps, creation = {}) {
         mkdirSync(agentRoot, { recursive: true });
         creation.onStage?.('writing_role');
         const file = join(agentRoot, `${o.name}.yaml`);
-        writeRoleFile(tx, file, stringify(buildAgentDocument(buildRoleConfig(o, cfg.defaults.harness ?? 'claude-code'))));
+        writeRoleFile(tx, file, stringify(agentDefinitionFromSpawn(o)));
         // `up` materialises the state dir and registers the service. Journal the
         // dir before it exists so a failure leaves the name genuinely reusable
         // rather than blocked by a half-built directory.
@@ -402,8 +264,7 @@ export async function spawnTemp(o, binPath, launch = independentSupervisor, crea
     validateSpawnOpts(o);
     if (o.isolationFile)
         readIsolationFile(o.isolationFile); // fail before reserving
-    if (o.missionFile)
-        readMissionFile(o.missionFile); // fail before reserving
+    const prepared = resolvedSpawn(o); // canonical validation before mutation
     // Retire only supervisors whose recorded owner is definitively stopped. This
     // bounded pass keeps the active roster clean without deleting old evidence.
     await reclaimStaleTempState();
@@ -416,63 +277,14 @@ export async function spawnTemp(o, binPath, launch = independentSupervisor, crea
         creation.onStage?.('checking_identity', {
             result: 'unknown', guarantee: 'unverified',
         });
-        return spawnTempInner(o, binPath, launch, tx, creation.onStage);
+        return spawnTempInner(o, prepared.role, binPath, launch, tx, creation.onStage);
     }, creation);
 }
-async function spawnTempInner(o, binPath, launch, tx, onStage) {
+async function spawnTempInner(o, preparedRole, binPath, launch, tx, onStage) {
     const cfg = loadConfig(o.configPath);
-    const defaultHarness = cfg.defaults.harness;
-    const fromOpts = buildRoleConfig(o, defaultHarness);
-    const mergedHarnessOptions = {
-        ...(cfg.defaults.harness_options ?? {}),
-        ...(fromOpts.harness_options ?? {}),
-    };
-    const harness = o.harness ?? defaultHarness ?? 'claude-code';
-    const inheritsModelDefaults = harness === (defaultHarness ?? 'claude-code') && o.model !== null;
-    const tempAuthProxy = resolveAuthProxy(cfg.defaults.auth_proxy, fromOpts.auth_proxy);
-    // An explicitly requested --model must reach the child, not just the banner
-    // (src/model-env.ts).
-    const modelEnv = resolveRoleModelEnv({
-        harness,
-        model: resolveRoleModel(o.model, o.harness, cfg.defaults),
-        modelWasExplicit: o.model !== undefined,
-        defaultsEnv: (cfg.defaults.env ?? {}),
-        roleEnv: fromOpts.env,
-        ...(tempAuthProxy ? { authProxyBaseUrl: tempAuthProxy.base_url } : {}),
-    });
-    const adapter = getAdapter(harness);
-    const brain = adapter.agentSession.resolveBrain({
-        model: modelEnv.model,
-        effort: fromOpts.effort,
-        harnessOptions: Object.keys(mergedHarnessOptions).length ? mergedHarnessOptions : undefined,
-    });
-    const model = brain.model ?? undefined;
-    const session = o.session ?? cfg.defaults.session ?? 'acp';
     const role = {
-        ...fromOpts, // includes `isolation` when --isolation-file was given
-        name: o.name,
-        harness,
-        session,
-        identity: o.identity ?? o.name,
-        effort: fromOpts.effort,
-        model,
-        model_chain: resolveModelChain(model, fromOpts.model_chain ?? (inheritsModelDefaults
-            ? cfg.defaults.model_chain
-            : undefined)),
-        harness_options: brain.harnessOptions,
-        permissions: resolvePermissions(cfg.defaults.permissions, fromOpts.permissions),
-        permissionsDeclared: fromOpts.permissions !== undefined || cfg.defaults.permissions !== undefined,
-        // Temp agents inherit the fleet-wide monitor defaults via the snapshot.
-        monitor: resolveMonitorConfig(cfg.defaults.monitor, fromOpts.monitor),
-        owner_channel: resolveOwnerChannelConfig(cfg.defaults.owner_channel, fromOpts.owner_channel, session),
-        worklog: resolveWorklogPolicy(cfg.defaults.worklog, fromOpts.worklog),
-        auth_proxy: tempAuthProxy,
-        sourceFile: '(temp)',
-        roomMemberStartup: o.roomMemberStartup,
+        ...preparedRole, sourceFile: '(temp)', loops: undefined, roomMemberStartup: o.roomMemberStartup,
     };
-    role.env = modelEnv.env;
-    if (role.auth_proxy && role.harness !== 'claude-code')
-        throw new Error('auth_proxy is supported only by claude-code');
     onStage?.('writing_role');
     const dir = applyRole(role, { temp: true, identityGuarantee: 'unverified' });
     const provenance = buildProvenance({

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 [];
@@ -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/topology-promote.js

@@ -126,7 +126,14 @@ function agentEntry(node) {
  */
 function watchdogEntry(node, merged) {
     const scoped = linked(merged, node.id, 'watches');
-    return { ...pick(node, WATCHDOG_FIELDS), ...(scoped.length ? { watch: scoped } : {}) };
+    return {
+        ...pick(node, WATCHDOG_FIELDS),
+        agent: {
+            role: { inline: {} },
+            brain: { inline: { harness: 'claude-code', ...pick(node, BRAIN_FIELDS) } },
+        },
+        ...(scoped.length ? { watch: scoped } : {}),
+    };
 }
 function loopEntry(node, merged) {
     const roles = linked(merged, node.id, 'targets');