@ours.network/fleet 0.10.1 → 0.10.3

package/README.md

@@ -581,3 +581,52 @@ separate **commercial licence** from Adapt Framework Solutions Ltd — see
 **Audit status.** The core has not yet had an independent security audit. We're raising funding to commission one from a recognized firm and prove these guarantees, and we'll open-source the full core once it passes. Until then it's source-available and documented, but not independently audited — run anything critical on it at your own risk.
 
 Copyright 2026 Adapt Framework Solutions Ltd.
+# Open-issues configuration contracts
+
+`ours-fleet config --json` emits a deterministic, versioned, secret-safe
+resolved plan (`schemaVersion: 1`). Environment keys are visible for policy
+checks but values are always redacted. Human output remains the default.
+
+The YAML loader explicitly rejects duplicate keys. During the compatibility
+rollout, anchors, aliases, explicit tags, non-scalar keys, and multiple documents
+produce source-positioned warnings; opt into enforcement with
+`--yaml-mode strict`. Strict mode will become the next-major default.
+
+Long-running roles may opt into bounded durable logs:
+
+```yaml
+worklog:
+  max_kb: 1024
+  keep_tail_kb: 256
+  max_archives: 12
+```
+
+Rotation is conservative: a concurrent change aborts the attempt and retries at
+a later fleet lifecycle point. Archives remain in the role state directory and
+may contain the same sensitive material as `WORKLOG.md`.
+
+Claude roles can use a credential-free loopback proxy:
+
+```yaml
+auth_proxy:
+  kind: anthropic
+  base_url: http://127.0.0.1:9411
+  required: true
+  health_url: http://127.0.0.1:9411/healthz
+```
+
+Only `ANTHROPIC_BASE_URL` is injected. Do not put provider credentials in fleet
+configuration. See `contrib/anthropic-auth-proxy.mjs` for the separately
+deployed, dedicated-service-account reference and its 0600 token-file contract.
+
+Approved automatic recovery is opt-in:
+
+```yaml
+model: primary-model
+model_chain: [primary-model, approved-fallback]
+```
+
+Only sustained, high-confidence model entitlement/quota 429 evidence advances
+the chain. Generic rate limits, overload, authentication, policy, and unknown
+errors remain detection-only. Exhaustion holds the role down; fleet never edits
+human-owned YAML or selects a model outside the declared chain.

package/contrib/anthropic-auth-proxy.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+/**
+ * Minimal credential-isolating Anthropic reverse proxy.
+ *
+ * Run as a dedicated service account. Configuration is environment-only:
+ *   FLEET_PROXY_TOKEN_FILE=/run/secrets/anthropic-token   (root-owned 0600)
+ *   FLEET_PROXY_UPSTREAM=https://api.anthropic.com
+ *   FLEET_PROXY_PORT=9411
+ *
+ * Deploy one loopback listener per role with OS-level access controls. This
+ * companion deliberately has no install/sudo lifecycle in ours-fleet.
+ */
+import http from 'node:http';
+import https from 'node:https';
+import { readFileSync, statSync } from 'node:fs';
+
+const tokenFile = process.env.FLEET_PROXY_TOKEN_FILE;
+const upstream = new URL(process.env.FLEET_PROXY_UPSTREAM ?? 'https://api.anthropic.com');
+const port = Number(process.env.FLEET_PROXY_PORT ?? 9411);
+if (!tokenFile) throw new Error('FLEET_PROXY_TOKEN_FILE is required');
+if (upstream.protocol !== 'https:') throw new Error('FLEET_PROXY_UPSTREAM must use https');
+if (upstream.username || upstream.password) throw new Error('upstream URL must not contain credentials');
+if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error('invalid FLEET_PROXY_PORT');
+
+const secret = () => {
+  const stat = statSync(tokenFile);
+  if ((stat.mode & 0o077) !== 0) throw new Error('token file must not be group/world accessible');
+  return readFileSync(tokenFile, 'utf8').trim();
+};
+const sanitizedHeaders = headers => {
+  const next = { ...headers };
+  for (const key of Object.keys(next))
+    if (/^(authorization|proxy-authorization|x-api-key|anthropic-api-key|host)$/i.test(key))
+      delete next[key];
+  next.authorization = `Bearer ${secret()}`;
+  next.host = upstream.host;
+  return next;
+};
+const log = (status, started) => {
+  process.stdout.write(`${JSON.stringify({
+    timestamp: new Date().toISOString(),
+    upstreamStatus: status,
+    latencyMs: Date.now() - started,
+  })}\n`);
+};
+
+http.createServer((req, res) => {
+  const started = Date.now();
+  if (req.method === 'CONNECT') {
+    res.writeHead(405).end();
+    return;
+  }
+  if (req.url === '/healthz') {
+    res.setHeader('content-type', 'application/json');
+    res.end('{"schemaVersion":1,"kind":"anthropic-auth-proxy","ok":true}\n');
+    return;
+  }
+  const target = new URL(req.url ?? '/', upstream);
+  if (target.origin !== upstream.origin) {
+    res.writeHead(403).end();
+    return;
+  }
+  const outbound = https.request(target, {
+    method: req.method,
+    headers: sanitizedHeaders(req.headers),
+  }, upstreamResponse => {
+    const headers = { ...upstreamResponse.headers };
+    delete headers.location; // never allow an upstream redirect to retarget credentials
+    res.writeHead(upstreamResponse.statusCode ?? 502, headers);
+    upstreamResponse.pipe(res);
+    log(upstreamResponse.statusCode ?? 502, started);
+  });
+  outbound.on('error', error => {
+    if (!res.headersSent) res.writeHead(502);
+    res.end();
+    process.stderr.write(`${JSON.stringify({
+      timestamp: new Date().toISOString(),
+      errorClass: error.code ?? 'upstream-error',
+      latencyMs: Date.now() - started,
+    })}\n`);
+  });
+  req.pipe(outbound);
+}).listen(port, '127.0.0.1', () => {
+  process.stderr.write(`anthropic auth proxy listening on 127.0.0.1:${port}\n`);
+});

package/dist/briefing.js

@@ -99,6 +99,11 @@ export function generateBriefing(role, v, opts) {
     L.push('', '## Durable log');
     L.push(`Append important commands / decisions / results to \`${opts.worklogPath}\` as you go —`);
     L.push('it survives restarts.');
+    if (role.worklog) {
+        L.push(`Fleet rotates it above ${role.worklog.max_kb} KiB, keeps approximately the newest ` +
+            `${role.worklog.keep_tail_kb} KiB here, and retains ${role.worklog.max_archives} archives ` +
+            'beside it. Continue writing only WORKLOG.md.');
+    }
     L.push('', '## Routines');
     L.push(`If \`${opts.routinesPath}\` exists, re-read it at the START of every wake — before acting`);
     L.push('on messages, timers, or prompts — and follow it for recurring or scheduled work. It may');

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { spawn as spawnChild } from 'node:child_process';
-import { existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { realpathSync } from 'node:fs';
 import { join as joinPath } from 'node:path';
 import { createInterface } from 'node:readline';
@@ -8,11 +8,14 @@ import { Command } from 'commander';
 import { VERSION } from './version.js';
 import { agentDir, agentsRoot, tmpRoot, logsRoot, deriveXdgRuntimeDir } from './paths.js';
 import { loadConfig } from './config.js';
+import { resolvedPlan } from './resolved-plan.js';
 import { Tmux, tmuxArgs } from './tmux.js';
 import { pickBackend } from './supervisor/index.js';
 import { up, down, restartRoles, rmRole } from './ops.js';
 import { readRestartLedger, runSupervised, runTemp } from './runner.js';
-import { lastProvenance, spawnPermanent, spawnTemp } from './spawn.js';
+import { lastProvenance, spawnDryRun, spawnPermanent, spawnTemp, } from './spawn.js';
+import { stringify } from 'yaml';
+import { resolvedRolePlan } from './resolved-plan.js';
 import { formatProvenance } from './creation.js';
 import { doctor } from './doctor.js';
 import { allWarnings, analyzeFleetPermissions, formatNative } from './permissions.js';
@@ -116,10 +119,22 @@ function parseCodexConfig(values) {
     return out;
 }
 cOpt(program.command('config').description('validate + print the merged plan (no side effects)'))
+    .option('--json', 'emit the stable, versioned, secret-safe resolved plan')
+    .option('--yaml-mode <mode>', 'non-plain YAML policy: compat|strict', 'compat')
     .action(opts => {
     try {
-        const cfg = loadConfig(opts.configuration);
+        if (!['compat', 'strict'].includes(opts.yamlMode))
+            throw new Error(`invalid --yaml-mode '${opts.yamlMode}'; allowed: compat, strict`);
+        const cfg = loadConfig(opts.configuration, { yamlMode: opts.yamlMode });
+        if (opts.json) {
+            for (const diagnostic of cfg.diagnostics)
+                console.error(`warning: ${diagnostic.message}`);
+            process.stdout.write(`${JSON.stringify(resolvedPlan(cfg), null, 2)}\n`);
+            return;
+        }
         console.log(`config: ${cfg.files.join(' + ') || '(none)'}`);
+        for (const diagnostic of cfg.diagnostics)
+            console.log(`warning: ${diagnostic.message}`);
         const analyses = analyzeFleetPermissions(cfg.roles);
         for (const r of cfg.roles) {
             const perms = analyses.find(a => a.role === r.name);
@@ -353,6 +368,20 @@ program.command('status <name>').description('unit/agent state')
     else if (ledger.consecutiveImmediateFailures > 0)
         console.log(`restarts: ${ledger.consecutiveImmediateFailures} consecutive immediate `
             + `failures, next delay ${ledger.nextDelayMs}ms (${ledger.lastReason})`);
+    const modelStatus = joinPath(agentDir(name), '.model-status');
+    if (existsSync(modelStatus)) {
+        try {
+            const status = JSON.parse(readFileSync(modelStatus, 'utf8'));
+            console.log(`model: declared=${status.declaredModel} effective=${status.effectiveModel}`
+                + `${status.heldDown ? ' HELD DOWN (chain exhausted)' : ' (runtime drift)'}`);
+        }
+        catch {
+            console.log('model: recovery status unreadable (fail-closed)');
+        }
+    }
+    const worklog = joinPath(agentDir(name), 'WORKLOG.md');
+    if (existsSync(worklog))
+        console.log(`worklog: ${statSync(worklog).size} bytes`);
     const stateDir = acpStateDir(name);
     if (stateDir) {
         try {
@@ -379,6 +408,7 @@ cOpt(program.command('spawn <name>').description('spawn a new agent (permanent b
     .option('--harness <id>', 'harness adapter (default: defaults.harness)')
     .option('--session <backend>', 'session backend: tmux|acp (default: defaults.session or tmux)')
     .option('--mission <text>', 'one-line mission')
+    .option('--mission-file <path>', 'UTF-8 mission text (mutually exclusive with --mission)')
     .option('--identity <name>', 'ours identity to bind (default: role name)')
     .option('--cwd <dir>', 'working directory')
     .option('--coordinator <name>', 'announce target')
@@ -397,10 +427,13 @@ cOpt(program.command('spawn <name>').description('spawn a new agent (permanent b
     .option('--bio-file <file>', 'public bio (file)')
     .option('--persona-file <file>', 'persona / operating contract (file)')
     .option('--isolation-file <path>', 'file holding an isolation: mapping (same schema as fleet.yaml)')
+    .option('--dry-run', 'validate and print without reserving or creating anything')
+    .option('--json', 'with --dry-run, emit a stable secret-safe JSON result')
     .action(async (name, opts) => {
     try {
         const o = {
             name, temp: opts.temp, harness: opts.harness, session: opts.session, mission: opts.mission,
+            missionFile: opts.missionFile,
             identity: opts.identity, cwd: opts.cwd, coordinator: opts.coordinator,
             model: opts.model,
             permissionMode: opts.permissionMode, approval: opts.approval,
@@ -410,7 +443,26 @@ cOpt(program.command('spawn <name>').description('spawn a new agent (permanent b
             codexConfig: parseCodexConfig(opts.codexConfig), addDirs: opts.addDir, monitor: opts.monitor,
             bioFile: opts.bioFile, personaFile: opts.personaFile,
             isolationFile: opts.isolationFile, configPath: opts.configuration,
+            dryRun: opts.dryRun, json: opts.json,
         };
+        if (o.json && !o.dryRun)
+            throw new Error('--json is currently valid only with --dry-run');
+        if (o.dryRun) {
+            const result = spawnDryRun(o);
+            if (o.json) {
+                process.stdout.write(`${JSON.stringify({
+                    schemaVersion: result.schemaVersion,
+                    warning: result.warning,
+                    roleDocument: result.roleDocument,
+                    resolvedRole: resolvedRolePlan(result.resolvedRole),
+                }, null, 2)}\n`);
+            }
+            else {
+                console.log(`# dry-run: ${result.warning}`);
+                process.stdout.write(stringify(result.roleDocument));
+            }
+            return;
+        }
         if (o.temp) {
             const dir = await spawnTemp(o, binPath);
             console.log(`spawned temp agent '${name}' (state: ${dir}; gone on exit/reboot)`);
@@ -435,8 +487,15 @@ cOpt(program.command('spawn <name>').description('spawn a new agent (permanent b
 });
 cOpt(program.command('doctor').description('prerequisite report'))
     .option('--harness <id>', 'check one harness explicitly')
+    .option('--yaml-mode <mode>', 'non-plain YAML policy: compat|strict', 'compat')
     .action(async (opts) => {
-    const rep = await doctor({ harness: opts.harness, configPath: opts.configuration });
+    if (!['compat', 'strict'].includes(opts.yamlMode))
+        die(`invalid --yaml-mode '${opts.yamlMode}'; allowed: compat, strict`);
+    const rep = await doctor({
+        harness: opts.harness,
+        configPath: opts.configuration,
+        yamlMode: opts.yamlMode,
+    });
     for (const c of rep.checks)
         console.log(`${c.ok ? 'ok  ' : 'MISS'} ${c.name.padEnd(22)} ${c.detail}`);
     process.exit(rep.ok ? 0 : 1);

package/dist/config-yaml.d.ts

@@ -0,0 +1,20 @@
+export type YamlMode = 'compat' | 'strict';
+export type ConfigDiagnosticKind = 'anchor' | 'alias' | 'explicit-tag' | 'non-scalar-key' | 'multiple-documents';
+export interface ConfigDiagnostic {
+    severity: 'warning';
+    kind: ConfigDiagnosticKind;
+    file: string;
+    line: number;
+    column: number;
+    message: string;
+}
+export interface ParsedFleetDocument {
+    value: Record<string, unknown>;
+    diagnostics: ConfigDiagnostic[];
+}
+/**
+ * Parse fleet-owned YAML with an explicit, shared contract. Duplicate keys and
+ * syntax errors always fail. YAML graph/type features are warning-first in
+ * compat mode and fail under strict mode.
+ */
+export declare function parseFleetDocument(file: string, text: string, yamlMode?: YamlMode): ParsedFleetDocument;

package/dist/config-yaml.js

@@ -0,0 +1,76 @@
+import { LineCounter, isAlias, isMap, isPair, isScalar, isSeq, parseAllDocuments, } from 'yaml';
+const position = (counter, node) => {
+    const start = node?.range?.[0] ?? 0;
+    const at = counter.linePos(start);
+    return { line: at.line, column: at.col };
+};
+/**
+ * Parse fleet-owned YAML with an explicit, shared contract. Duplicate keys and
+ * syntax errors always fail. YAML graph/type features are warning-first in
+ * compat mode and fail under strict mode.
+ */
+export function parseFleetDocument(file, text, yamlMode = 'compat') {
+    const lineCounter = new LineCounter();
+    const documents = parseAllDocuments(text, {
+        strict: true,
+        uniqueKeys: true,
+        lineCounter,
+        prettyErrors: true,
+    });
+    const parseErrors = documents.flatMap(document => document.errors);
+    if (parseErrors.length)
+        throw new Error(`${file}: ${parseErrors.map(error => error.message).join('; ')}`);
+    const diagnostics = [];
+    const add = (kind, node, description) => {
+        const at = position(lineCounter, node);
+        diagnostics.push({
+            severity: 'warning',
+            kind,
+            file,
+            ...at,
+            message: `${file}:${at.line}:${at.column}: non-plain YAML ${description}`,
+        });
+    };
+    if (documents.length > 1)
+        add('multiple-documents', documents[1]?.contents, 'multiple documents');
+    const walk = (node) => {
+        if (!node || typeof node !== 'object')
+            return;
+        const tagged = node;
+        if (tagged.anchor)
+            add('anchor', node, `anchor '&${tagged.anchor}'`);
+        if (tagged.tag)
+            add('explicit-tag', node, `explicit tag '${tagged.tag}'`);
+        if (isAlias(node)) {
+            add('alias', node, `alias '*${String(node.source ?? '')}'`);
+            return;
+        }
+        if (isMap(node)) {
+            for (const item of node.items) {
+                if (!isPair(item))
+                    continue;
+                if (!isScalar(item.key))
+                    add('non-scalar-key', item.key, 'non-scalar mapping key');
+                walk(item.key);
+                walk(item.value);
+            }
+            return;
+        }
+        if (isSeq(node))
+            for (const item of node.items)
+                walk(item);
+    };
+    for (const document of documents)
+        walk(document.contents);
+    const unique = diagnostics.filter((diagnostic, index, all) => all.findIndex(other => other.kind === diagnostic.kind
+        && other.line === diagnostic.line && other.column === diagnostic.column) === index);
+    if (yamlMode === 'strict' && unique.length)
+        throw new Error(unique.map(diagnostic => diagnostic.message).join('; '));
+    const first = documents[0];
+    const value = first?.contents == null
+        ? {}
+        : first.toJS({ maxAliasCount: 100 });
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${file}: top-level YAML document must be a mapping`);
+    return { value, diagnostics: unique };
+}

package/dist/config.d.ts

@@ -1,8 +1,20 @@
+import { type ConfigDiagnostic, type YamlMode } from './config-yaml.js';
 import type { IsolationConfig, WrapContext } from './isolation/types.js';
 export interface OverseeEntry {
     role: string;
     interval: string;
 }
+export interface WorklogPolicy {
+    max_kb: number;
+    keep_tail_kb: number;
+    max_archives: number;
+}
+export interface AuthProxyConfig {
+    kind: 'anthropic';
+    base_url: string;
+    required: boolean;
+    health_url: string;
+}
 /** The 8 content-free event types the ours daemon appends to notifications.log. */
 export declare const NOTIFY_EVENT_TYPES: readonly ["message_received", "file_received", "sibling_contact_added", "local_contact_request", "pending_message", "contact_restored", "inbound_error", "state_import_failed"];
 export type NotifyEventType = (typeof NOTIFY_EVENT_TYPES)[number];
@@ -62,6 +74,7 @@ export interface RoleConfig {
     bio?: string;
     briefing_file?: string;
     model?: string;
+    model_chain?: string[];
     max_tokens?: number;
     autocompact_pct?: number;
     env?: Record<string, string>;
@@ -69,6 +82,8 @@ export interface RoleConfig {
     harness_options?: Record<string, unknown>;
     isolation?: IsolationConfig;
     monitor?: Partial<MonitorConfig>;
+    worklog?: WorklogPolicy;
+    auth_proxy?: Partial<AuthProxyConfig>;
 }
 export interface ResolvedRole extends RoleConfig {
     name: string;
@@ -85,6 +100,8 @@ export interface ResolvedRole extends RoleConfig {
     identity: string;
     sourceFile: string;
     monitor: MonitorConfig;
+    worklog?: WorklogPolicy;
+    auth_proxy?: AuthProxyConfig;
 }
 export interface FleetConfig {
     roles: ResolvedRole[];
@@ -93,6 +110,8 @@ export interface FleetConfig {
     files: string[];
     /** Fleet-wide delay (ms) enforced between agent launches to avoid boot bursts (0 = none). */
     startStaggerMs: number;
+    /** Warning-first non-plain YAML migration diagnostics, in source order. */
+    diagnostics: ConfigDiagnostic[];
 }
 export declare class ConfigError extends Error {
 }
@@ -104,7 +123,12 @@ export declare class ConfigError extends Error {
  */
 export declare function isolationContextFor(role: ResolvedRole): WrapContext;
 /** Load ~/fleet.yaml (or an explicit path) merged with ~/fleet.d/*.yaml drop-ins. */
-export declare function loadConfig(configPath?: string): FleetConfig;
+export declare function loadConfig(configPath?: string, options?: {
+    yamlMode?: YamlMode;
+}): FleetConfig;
+export declare function resolveModelChain(model: string | undefined, chain: string[] | undefined, file?: string, name?: string): string[] | undefined;
+export declare function resolveAuthProxy(defaults: unknown, role: Partial<AuthProxyConfig> | undefined, file?: string, name?: string): AuthProxyConfig | undefined;
+export declare function resolveWorklogPolicy(defaults: unknown, role: WorklogPolicy | undefined, file?: string, name?: string): WorklogPolicy | undefined;
 export declare function resolvePermissions(defaults: unknown, role: Partial<CommonPermissions> | undefined, file?: string, name?: string): CommonPermissions;
 /**
  * Merge `defaults.monitor` under the role's own `monitor:` key-by-key, validate the

package/dist/config.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { parse } from 'yaml';
 import { agentDir, defaultConfigPath, fleetDDir, home } from './paths.js';
+import { parseFleetDocument, } from './config-yaml.js';
 import { harnessRuntimeDir, resolveIsolation, validateIsolationConfig, } from './isolation/policy.js';
 import { getAdapter } from './harness/registry.js';
 /** The 8 content-free event types the ours daemon appends to notifications.log. */
@@ -94,8 +94,8 @@ export function isolationContextFor(role) {
 const NAME_RE = /^[A-Za-z0-9_-]+$/;
 const ROLE_KEYS = [
     'harness', 'session', 'session_options', 'permissions', 'identity', 'cwd', 'coordinator', 'mission', 'persona', 'bio',
-    'briefing_file', 'model', 'max_tokens', 'autocompact_pct', 'env', 'oversee', 'harness_options',
-    'isolation', 'monitor',
+    'briefing_file', 'model', 'model_chain', 'max_tokens', 'autocompact_pct', 'env', 'oversee', 'harness_options',
+    'isolation', 'monitor', 'worklog', 'auth_proxy',
 ];
 function deepSub(v, vars) {
     if (typeof v === 'string')
@@ -107,12 +107,15 @@ function deepSub(v, vars) {
     return v;
 }
 /** Load ~/fleet.yaml (or an explicit path) merged with ~/fleet.d/*.yaml drop-ins. */
-export function loadConfig(configPath) {
+export function loadConfig(configPath, options = {}) {
     const base = configPath ?? defaultConfigPath();
     const files = [];
+    const diagnostics = [];
     const docs = [];
     if (existsSync(base)) {
-        docs.push({ file: base, doc: (parse(readFileSync(base, 'utf8')) ?? {}) });
+        const parsed = parseFleetDocument(base, readFileSync(base, 'utf8'), options.yamlMode);
+        docs.push({ file: base, doc: parsed.value });
+        diagnostics.push(...parsed.diagnostics);
         files.push(base);
     }
     else if (configPath) {
@@ -122,7 +125,9 @@ export function loadConfig(configPath) {
     if (existsSync(dd)) {
         for (const f of readdirSync(dd).filter(f => f.endsWith('.yaml') || f.endsWith('.yml')).sort()) {
             const p = join(dd, f);
-            const doc = (parse(readFileSync(p, 'utf8')) ?? {});
+            const parsed = parseFleetDocument(p, readFileSync(p, 'utf8'), options.yamlMode);
+            const doc = parsed.value;
+            diagnostics.push(...parsed.diagnostics);
             const extra = Object.keys(doc).filter(k => k !== 'roles');
             if (extra.length)
                 throw new ConfigError(`${p}: fleet.d files may only define roles: (found: ${extra.join(', ')})`);
@@ -170,21 +175,37 @@ export function loadConfig(configPath) {
                     throw new ConfigError(`${file}: role '${name}' ${problems.join('; ')}`);
             }
             const monitor = resolveMonitorConfig(defaults.monitor, r.monitor, { base, file, name });
+            const worklog = resolveWorklogPolicy(defaults.worklog, r.worklog, file, name);
+            const authProxy = resolveAuthProxy(defaults.auth_proxy, r.auth_proxy, file, name);
+            const model = r.model ?? defaults.model;
+            const modelChain = resolveModelChain(model, r.model_chain ?? defaults.model_chain, file, name);
+            const harness = r.harness ?? defaults.harness ?? 'claude-code';
+            if (authProxy && harness !== 'claude-code')
+                throw new ConfigError(`${file}: role '${name}' auth_proxy is supported only by claude-code`);
+            const env = {
+                ...(defaults.env ?? {}),
+                ...(r.env ?? {}),
+                ...(authProxy ? { ANTHROPIC_BASE_URL: authProxy.base_url } : {}),
+            };
             roles.push({
                 ...r,
                 name,
                 sourceFile: file,
-                harness: r.harness ?? defaults.harness ?? 'claude-code',
+                harness,
                 session,
                 session_options: sessionOptions,
                 permissions,
                 permissionsDeclared,
                 identity: r.identity ?? name,
-                model: r.model ?? defaults.model,
+                model,
+                model_chain: modelChain,
                 max_tokens: r.max_tokens ?? defaults.max_tokens,
                 harness_options: harnessOptions,
                 isolation,
                 monitor,
+                worklog,
+                auth_proxy: authProxy,
+                env: Object.keys(env).length ? env : undefined,
             });
             // Forbidden-path enforcement (5.2): a mount that would breach the policy
             // is a configuration error, caught by `config` rather than at launch.
@@ -199,7 +220,92 @@ export function loadConfig(configPath) {
             }
         }
     }
-    return { roles, vars, defaults, files, startStaggerMs };
+    return { roles, vars, defaults, files, startStaggerMs, diagnostics };
+}
+export function resolveModelChain(model, chain, file = 'config', name = 'role') {
+    if (chain === undefined)
+        return undefined;
+    if (!Array.isArray(chain) || chain.length === 0)
+        throw new ConfigError(`${file}: role '${name}' model_chain must be a non-empty list`);
+    if (chain.some(entry => typeof entry !== 'string' || entry.trim() === ''))
+        throw new ConfigError(`${file}: role '${name}' model_chain entries must be non-blank strings`);
+    const normalized = chain.map(entry => entry.trim());
+    if (new Set(normalized).size !== normalized.length)
+        throw new ConfigError(`${file}: role '${name}' model_chain must not contain duplicates`);
+    if (model !== undefined && model !== normalized[0])
+        throw new ConfigError(`${file}: role '${name}' model must equal model_chain[0]`);
+    return normalized;
+}
+export function resolveAuthProxy(defaults, role, file = 'config', name = 'role') {
+    if (defaults === undefined && role === undefined)
+        return undefined;
+    if (defaults !== undefined && !isPlainObject(defaults))
+        throw new ConfigError(`${file}: defaults.auth_proxy must be a map`);
+    if (role !== undefined && !isPlainObject(role))
+        throw new ConfigError(`${file}: role '${name}' auth_proxy must be a map`);
+    const merged = {
+        ...(defaults ?? {}),
+        ...(role ?? {}),
+    };
+    const bad = Object.keys(merged).filter(key => !['kind', 'base_url', 'required', 'health_url'].includes(key));
+    if (bad.length)
+        throw new ConfigError(`${file}: role '${name}' auth_proxy: unknown key(s) ${bad.join(', ')}`);
+    if (merged.kind !== 'anthropic')
+        throw new ConfigError(`${file}: role '${name}' auth_proxy.kind must be 'anthropic'`);
+    if (typeof merged.base_url !== 'string')
+        throw new ConfigError(`${file}: role '${name}' auth_proxy.base_url is required`);
+    const checked = (label, raw) => {
+        let url;
+        try {
+            url = new URL(raw);
+        }
+        catch {
+            throw new ConfigError(`${file}: role '${name}' auth_proxy.${label} must be a valid URL`);
+        }
+        if (!['http:', 'https:'].includes(url.protocol))
+            throw new ConfigError(`${file}: role '${name}' auth_proxy.${label} must use http or https`);
+        if (!['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname))
+            throw new ConfigError(`${file}: role '${name}' auth_proxy.${label} must be loopback-only`);
+        if (url.username || url.password)
+            throw new ConfigError(`${file}: role '${name}' auth_proxy.${label} must not contain credentials`);
+        return url;
+    };
+    const base = checked('base_url', merged.base_url);
+    const healthRaw = merged.health_url ?? new URL('/healthz', base).toString();
+    checked('health_url', healthRaw);
+    if (merged.required !== undefined && typeof merged.required !== 'boolean')
+        throw new ConfigError(`${file}: role '${name}' auth_proxy.required must be true or false`);
+    return {
+        kind: 'anthropic',
+        base_url: base.toString().replace(/\/$/, ''),
+        required: merged.required ?? true,
+        health_url: healthRaw,
+    };
+}
+export function resolveWorklogPolicy(defaults, role, file = 'config', name = 'role') {
+    if (defaults === undefined && role === undefined)
+        return undefined;
+    if (defaults !== undefined && !isPlainObject(defaults))
+        throw new ConfigError(`${file}: defaults.worklog must be a map`);
+    if (role !== undefined && !isPlainObject(role))
+        throw new ConfigError(`${file}: role '${name}' worklog must be a map`);
+    const merged = {
+        ...(defaults ?? {}),
+        ...(role ?? {}),
+    };
+    const bad = Object.keys(merged).filter(key => !['max_kb', 'keep_tail_kb', 'max_archives'].includes(key));
+    if (bad.length)
+        throw new ConfigError(`${file}: role '${name}' worklog: unknown key(s) ${bad.join(', ')}`);
+    for (const key of ['max_kb', 'keep_tail_kb', 'max_archives']) {
+        const value = merged[key];
+        if (!Number.isInteger(value) || value <= 0)
+            throw new ConfigError(`${file}: role '${name}' worklog.${key} must be a positive integer`);
+    }
+    if (merged.max_archives > 1000)
+        throw new ConfigError(`${file}: role '${name}' worklog.max_archives must be at most 1000`);
+    if (merged.keep_tail_kb >= merged.max_kb)
+        throw new ConfigError(`${file}: role '${name}' worklog.keep_tail_kb must be less than max_kb`);
+    return merged;
 }
 function resolveSession(raw, file, name) {
     const value = raw ?? 'tmux';