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

package/dist/spawn.js

@@ -2,14 +2,15 @@ import { spawn as spawnChild } from 'node:child_process';
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { parse, stringify } from 'yaml';
-import { agentDir, fleetDDir } from './paths.js';
+import { agentDir, defaultConfigPath } from './paths.js';
 import { validateIsolationConfig } from './isolation/policy.js';
-import { loadConfig, resolveAuthProxy, resolveModelChain, resolveMonitorConfig, resolveOwnerChannelConfig, resolvePermissions, resolveRoleModel, resolveWorklogPolicy, validateMonitorConfig, } from './config.js';
+import { loadConfig, resolveAuthProxy, resolveModelChain, resolveMonitorConfig, resolveOwnerChannelConfig, resolvePermissions, resolveRoleModel, resolveWorklogPolicy, splitRootFor, validateMonitorConfig, } from './config.js';
 import { resolveRoleModelEnv } from './model-env.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';
 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';
@@ -34,8 +35,9 @@ export function profileValues(o) {
 /** Pure option-to-role mapping shared by CLI and application services. */
 export function buildRoleConfig(o, defaultHarness) {
     const r = {};
-    if (o.harness)
-        r.harness = o.harness;
+    const harness = o.harness ?? defaultHarness;
+    if (harness)
+        r.harness = harness;
     if (o.session)
         r.session = o.session;
     if (o.identity)
@@ -52,7 +54,8 @@ export function buildRoleConfig(o, defaultHarness) {
         r.model = null;
     else if (o.model?.trim())
         r.model = o.model.trim();
-    const harness = o.harness ?? defaultHarness;
+    if (o.reasoningEffort?.trim())
+        r.effort = o.reasoningEffort.trim();
     const harnessOptions = {};
     if (o.permissionMode)
         harnessOptions[harness === 'claude-code' ? 'permission_mode' : 'approval'] = o.permissionMode;
@@ -65,12 +68,8 @@ export function buildRoleConfig(o, defaultHarness) {
     if (o.search === true)
         harnessOptions.search = true;
     const codexConfig = { ...(o.codexConfig ?? {}) };
-    if (o.reasoningEffort && harness === 'codex')
-        codexConfig.model_reasoning_effort = o.reasoningEffort;
     if (Object.keys(codexConfig).length)
         harnessOptions.config = codexConfig;
-    if (o.reasoningEffort && harness === 'claude-code')
-        harnessOptions.effort = o.reasoningEffort;
     if (o.addDirs?.length)
         harnessOptions.add_dirs = o.addDirs;
     if (o.monitor === true)
@@ -123,8 +122,10 @@ export function readIsolationFile(path) {
 export function validateSpawnOpts(o) {
     if (o.mission !== undefined && o.missionFile)
         throw new Error('--mission and --mission-file are mutually exclusive');
-    if (o.session && !['tmux', 'acp'].includes(o.session))
-        throw new Error(`invalid --session '${o.session}'; allowed: tmux, acp`);
+    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))
@@ -172,6 +173,23 @@ 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.
@@ -184,7 +202,7 @@ export function spawnDryRun(o) {
         readMissionFile(o.missionFile);
     assertNameFree(o);
     const cfg = loadConfig(o.configPath);
-    const raw = buildRoleConfig(o, cfg.defaults.harness);
+    const raw = buildRoleConfig(o, cfg.defaults.harness ?? 'claude-code');
     const harnessOptions = {
         ...(cfg.defaults.harness_options ?? {}),
         ...(raw.harness_options ?? {}),
@@ -202,23 +220,30 @@ export function spawnDryRun(o) {
         roleEnv: raw.env,
         ...(authProxy ? { authProxyBaseUrl: authProxy.base_url } : {}),
     });
-    const model = modelEnv.model;
-    const session = raw.session ?? cfg.defaults.session ?? 'tmux';
+    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(fleetDDir(), `${o.name}.yaml`),
+        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: Object.keys(harnessOptions).length ? harnessOptions : 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),
@@ -226,7 +251,6 @@ export function spawnDryRun(o) {
         auth_proxy: authProxy,
     };
     resolvedRole.env = modelEnv.env;
-    const adapter = getAdapter(resolvedRole.harness);
     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);
@@ -235,7 +259,7 @@ export function spawnDryRun(o) {
     return {
         schemaVersion: 1,
         warning: 'collision checks are a snapshot; a real spawn reserves names atomically',
-        roleDocument: { roles: { [o.name]: raw } },
+        roleDocument: buildAgentDocument(raw),
         resolvedRole,
     };
 }
@@ -255,7 +279,7 @@ function provenanceSettings(o, defaults) {
     const inheritedModel = resolveRoleModel(undefined, o.harness, defaults);
     return {
         harness: tagged('harness', provenanceOf(o.harness, defaults.harness, 'claude-code')),
-        session: tagged('session', provenanceOf(o.session, defaults.session, 'tmux')),
+        session: tagged('session', provenanceOf(o.session, defaults.session, 'acp')),
         identity: o.identity
             ? { value: o.identity, source: 'cli' }
             : { value: o.name, source: 'built-in' }, // defaults to the role name
@@ -276,7 +300,7 @@ function provenanceSettings(o, defaults) {
         monitor: tagged('monitorConfig', provenanceOf(o.monitorConfig, defaults.monitor, { mode: 'fleet' })),
     };
 }
-/** Permanent spawn: persist to ~/fleet.d/<Name>.yaml, then bring it up. */
+/** Permanent spawn: persist one bare Agent document under the selected v2 root. */
 export async function spawnPermanent(o, deps, creation = {}) {
     validateSpawnOpts(o);
     if (o.isolationFile)
@@ -305,12 +329,11 @@ export async function spawnPermanent(o, deps, creation = {}) {
                     await creation.identityProvisioner?.remove?.(effectiveIdentity(o));
                 },
             });
-        mkdirSync(fleetDDir(), { recursive: true });
+        const agentRoot = join(splitRootFor(o.configPath ?? defaultConfigPath()), 'agents');
+        mkdirSync(agentRoot, { recursive: true });
         creation.onStage?.('writing_role');
-        const file = join(fleetDDir(), `${o.name}.yaml`);
-        writeRoleFile(tx, file, stringify({
-            roles: { [o.name]: buildRoleConfig(o, cfg.defaults.harness) },
-        }));
+        const file = join(agentRoot, `${o.name}.yaml`);
+        writeRoleFile(tx, file, stringify(buildAgentDocument(buildRoleConfig(o, cfg.defaults.harness ?? 'claude-code'))));
         // `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.
@@ -341,6 +364,7 @@ export async function spawnPermanent(o, deps, creation = {}) {
         });
         mkdirSync(agentDir(o.name), { recursive: true });
         writeProvenance(agentDir(o.name), provenance);
+        recordGeneratedAgentSource(agentDir(o.name), o.configPath ?? defaultConfigPath(), file);
         creation.onStage?.('registering_supervisor');
         await up(loadConfig(o.configPath), [o.name], {
             ...deps,
@@ -416,19 +440,26 @@ async function spawnTempInner(o, binPath, launch, tx, onStage) {
         roleEnv: fromOpts.env,
         ...(tempAuthProxy ? { authProxyBaseUrl: tempAuthProxy.base_url } : {}),
     });
-    const model = modelEnv.model;
-    const session = o.session ?? cfg.defaults.session ?? 'tmux';
+    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: Object.keys(mergedHarnessOptions).length ? mergedHarnessOptions : 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.
@@ -467,10 +498,7 @@ async function spawnTempInner(o, binPath, launch, tx, onStage) {
     if (cfg.startStaggerMs > 0)
         writeFileSync(join(dir, START_STAGGER_FILE), String(cfg.startStaggerMs));
     prepareTempSupervisor(dir, o.name);
-    // Run the supervisor independently — NOT inside a tmux session named <name>.
-    // `_run-temp` -> runOnce() creates AND kills the tmux session <name> for the
-    // agent itself; a supervisor sharing that session name would SIGHUP its own
-    // process before the agent ever launches. On a service-managed host the temp
+    // Run the supervisor independently. On a service-managed host the temp
     // runner gets its own transient unit/job, so stopping the coordinator's unit
     // cannot kill a live worker in the coordinator's cgroup.
     onStage?.('starting_temp');

package/dist/supervisor/none.d.ts

@@ -1,7 +1,7 @@
 import { type Exec } from '../exec.js';
 import type { SupervisorBackend } from './types.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).
  */

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/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.js

@@ -31,7 +31,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 = [];
@@ -61,9 +61,11 @@ export function resolveWatchdogs(baseDoc, baseFile, roles, vars, defaults) {
             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'`);
+        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.prompt_file !== undefined) {
             if (typeof w.prompt_file !== 'string' || !isAbsolute(w.prompt_file))
                 throw new ConfigError(`${where}: prompt_file must be an absolute path`);

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';
@@ -15,8 +14,6 @@ import { loadConfig, resolveMonitorConfig, resolveWorklogPolicy, ROLE_NAME_RE, }
 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 {
@@ -121,19 +110,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>;
 }