@ours.network/fleet 0.15.0 → 0.15.3

package/dist/owner-channel/state.d.ts

@@ -11,7 +11,7 @@ export declare class OwnerChannelState {
     has(wireId: string): boolean;
     remember(wireId: string): void;
 }
-export type OwnerConversationRouteBasis = 'last-inbound' | 'sole-owner';
+export type OwnerConversationRouteBasis = 'last-inbound' | 'sole-owner' | 'source-wire';
 interface OwnerProactiveSend {
     id: string;
     contact: string;
@@ -28,6 +28,7 @@ interface OwnerProactiveSend {
 export declare class OwnerConversationState {
     private readonly path;
     private conversations;
+    private routes;
     private sends;
     private corruptReason?;
     constructor(path: string);
@@ -41,12 +42,17 @@ export declare class OwnerConversationState {
         contact: string;
         basis: OwnerConversationRouteBasis;
     };
+    routeForWire(wireId: string, effective: Set<string>): {
+        contact: string;
+        basis: OwnerConversationRouteBasis;
+    };
     beginSend(contact: string, digest: string, now?: number, minIntervalMs?: number, dedupe?: 'contact' | 'all'): OwnerProactiveSend;
     finishSend(id: string, status: 'delivered' | 'uncertain'): void;
     private mutate;
     private persist;
     private assertHealthy;
     private validConversation;
+    private validRoute;
     private validSend;
 }
 export type OwnerSource = 'baseline' | 'dynamic';

package/dist/owner-channel/state.js

@@ -42,6 +42,7 @@ export class OwnerChannelState {
     }
 }
 const CONVERSATION_LIMIT = 64;
+const WIRE_ROUTE_LIMIT = 512;
 const PROACTIVE_SEND_LIMIT = 256;
 const PROACTIVE_MIN_INTERVAL_MS = 30_000;
 const HEX_64_LOWER = /^[a-f0-9]{64}$/;
@@ -55,6 +56,7 @@ const CID = /^[A-Fa-f0-9]{64}$/;
 export class OwnerConversationState {
     path;
     conversations = [];
+    routes = [];
     sends = [];
     corruptReason;
     constructor(path) {
@@ -63,18 +65,29 @@ export class OwnerConversationState {
             return;
         try {
             const raw = JSON.parse(readFileSync(path, 'utf8'));
-            if (raw.version !== 1 || !Array.isArray(raw.conversations) || !Array.isArray(raw.sends)
+            const legacy = raw.version === 1;
+            const routes = legacy
+                ? (raw.conversations ?? []).map(record => ({
+                    contact: record.contact, wireId: record.lastInboundWireId, at: record.lastInboundAt,
+                }))
+                : raw.routes;
+            if (![1, 2].includes(raw.version ?? 0)
+                || !Array.isArray(raw.conversations) || !Array.isArray(routes) || !Array.isArray(raw.sends)
                 || raw.conversations.length > CONVERSATION_LIMIT
+                || routes.length > WIRE_ROUTE_LIMIT
                 || raw.sends.length > PROACTIVE_SEND_LIMIT
                 || !raw.conversations.every(record => this.validConversation(record))
+                || !routes.every(route => this.validRoute(route))
                 || !raw.sends.every(send => this.validSend(send)))
                 throw new Error('invalid or unbounded conversation state');
             if (new Set(raw.conversations.map(record => record.contact)).size !== raw.conversations.length
+                || new Set(routes.map(route => route.wireId)).size !== routes.length
                 || new Set(raw.sends.map(send => send.id)).size !== raw.sends.length)
                 throw new Error('duplicate conversation state entry');
             this.conversations = raw.conversations.map(record => ({ ...record }));
+            this.routes = routes.map(route => ({ ...route }));
             this.sends = raw.sends.map(send => ({ ...send }));
-            let recovered = false;
+            let recovered = legacy;
             for (const send of this.sends) {
                 if (send.status === 'sending') {
                     send.status = 'uncertain';
@@ -88,6 +101,7 @@ export class OwnerConversationState {
         catch {
             this.corruptReason = 'invalid persisted owner conversation state';
             this.conversations = [];
+            this.routes = [];
             this.sends = [];
             try {
                 chmodSync(path, 0o600);
@@ -118,6 +132,9 @@ export class OwnerConversationState {
                     throw new Error(`owner conversations are limited to ${CONVERSATION_LIMIT}`);
                 this.conversations.push({ contact, lastInboundAt: acceptedAt, lastInboundWireId: wireId });
             }
+            this.routes = this.routes.filter(route => route.wireId !== wireId);
+            this.routes.push({ contact, wireId, at: acceptedAt });
+            this.routes = this.routes.slice(-WIRE_ROUTE_LIMIT);
         });
     }
     remove(contact) {
@@ -127,6 +144,7 @@ export class OwnerConversationState {
             return;
         this.mutate(() => {
             this.conversations = this.conversations.filter(record => canonicalCid(record.contact) !== canonical);
+            this.routes = this.routes.filter(route => canonicalCid(route.contact) !== canonical);
         });
     }
     route(effective) {
@@ -146,6 +164,14 @@ export class OwnerConversationState {
             return { contact: [...effective][0], basis: 'sole-owner' };
         throw new Error('no authenticated owner conversation route is available yet');
     }
+    routeForWire(wireId, effective) {
+        this.assertHealthy();
+        const route = [...this.routes].reverse().find(item => item.wireId === wireId);
+        const allowed = new Set([...effective].map(canonicalCid));
+        if (!route || !allowed.has(canonicalCid(route.contact)))
+            throw new Error('no authenticated owner route matches the source wire');
+        return { contact: route.contact, basis: 'source-wire' };
+    }
     beginSend(contact, digest, now = Date.now(), minIntervalMs = PROACTIVE_MIN_INTERVAL_MS, dedupe = 'contact') {
         this.assertHealthy();
         if (!CID.test(contact) || !HEX_64_LOWER.test(digest))
@@ -177,7 +203,9 @@ export class OwnerConversationState {
         this.mutate(() => { send.status = status; });
     }
     mutate(change) {
-        const snapshot = JSON.stringify({ conversations: this.conversations, sends: this.sends });
+        const snapshot = JSON.stringify({
+            conversations: this.conversations, routes: this.routes, sends: this.sends,
+        });
         change();
         try {
             this.persist();
@@ -185,13 +213,14 @@ export class OwnerConversationState {
         catch (error) {
             const old = JSON.parse(snapshot);
             this.conversations = old.conversations;
+            this.routes = old.routes;
             this.sends = old.sends;
             throw error;
         }
     }
     persist() {
         replaceFileAtomically(this.path, JSON.stringify({
-            version: 1, conversations: this.conversations, sends: this.sends,
+            version: 2, conversations: this.conversations, routes: this.routes, sends: this.sends,
         }) + '\n', 0o600);
         chmodSync(this.path, 0o600);
     }
@@ -207,6 +236,14 @@ export class OwnerConversationState {
             && record.lastInboundAt >= 0 && typeof record.lastInboundWireId === 'string'
             && record.lastInboundWireId.length > 0 && record.lastInboundWireId.length <= 1_024;
     }
+    validRoute(value) {
+        if (!value || typeof value !== 'object')
+            return false;
+        const route = value;
+        return CID.test(route.contact) && typeof route.wireId === 'string'
+            && route.wireId.length > 0 && route.wireId.length <= 1_024
+            && Number.isSafeInteger(route.at) && route.at >= 0;
+    }
     validSend(value) {
         if (!value || typeof value !== 'object')
             return false;

package/dist/runner.d.ts

@@ -5,6 +5,7 @@ import { type MonitorHandle, type MonitorOpts, type FetchLike } from './monitor.
 import { type Exec } from './exec.js';
 import type { ExitRecord } from './session/types.js';
 import { type OwnerChannelHandle, type OwnerChannelOptions } from './owner-channel/channel.js';
+import { type OwnerBinderLease } from './owner-channel/binder.js';
 export interface RunnerDeps {
     tmux: Tmux;
     exec: Exec;
@@ -19,9 +20,15 @@ export interface RunnerDeps {
     createMonitor(opts: MonitorOpts): MonitorHandle;
     /** Construct trusted owner ingress (injectable for lifecycle tests). */
     createOwnerChannel(opts: OwnerChannelOptions): OwnerChannelHandle;
+    /** Acquire the cross-process owner-channel binder lease before replacing the control socket. */
+    acquireOwnerBinder(stateDir: string, role: string, identity: string): Promise<OwnerBinderLease>;
+    /** Ask the still-authenticated predecessor to emit the fixed recovery notice. */
+    reportOwnerStartupFailure(stateDir: string): Promise<'delivered' | 'duplicate'>;
     /** Lets a test (or a shutdown path) end the supervised restart loop. */
     shouldStop?(): boolean;
 }
+/** Environment injected only into the managed harness process. */
+export declare function managedFleetProxyEnv(role: ResolvedRole, stateDir: string): Record<string, string>;
 /**
  * Record who owns wake delivery for this run. Returning true means a fleet
  * monitor is taking ownership back from a native harness and must start at the

package/dist/runner.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, realpathSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { parse } from 'yaml';
@@ -13,14 +13,16 @@ import { selectIsolationBackend } from './isolation/registry.js';
 import { resourceArgs, cpuControllerDelegated } from './isolation/resources.js';
 import { resolveLaunchRuntime } from './isolation/runtime.js';
 import { AcpSession } from './session/acp.js';
-import { RoleControlServer } from './session/control.js';
+import { controlRequest, RoleControlServer } from './session/control.js';
 import { TmuxSession } from './session/tmux.js';
 import { classifyShellStatus } from './session/types.js';
 import { effectiveModelForRole, modelRecoveryHeld, reconcileModelRecovery, recordModelFailure, classifyFailureText, } from './model-recovery.js';
 import { rotateWorklog } from './worklog.js';
 import { OwnerChannel } from './owner-channel/channel.js';
+import { acquireOwnerBinderLease, OwnerBinderHandoffTimeoutError, } from './owner-channel/binder.js';
 import { RoleTurnArbiter } from './session/arbiter.js';
 import { ScheduledLoopManager, } from './loops/manager.js';
+import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, inheritCallerSpawnDefaults, } from './fleet-proxy.js';
 const defaultDeps = () => ({
     tmux: new Tmux(),
     exec: realExec,
@@ -38,8 +40,75 @@ const defaultDeps = () => ({
     fetch: (url, init) => globalThis.fetch(url, init),
     createMonitor: opts => createMonitor(opts),
     createOwnerChannel: opts => new OwnerChannel(opts),
+    acquireOwnerBinder: (stateDir, role, identity) => acquireOwnerBinderLease(stateDir, role, identity),
+    reportOwnerStartupFailure: async (stateDir) => {
+        const response = await controlRequest(stateDir, {
+            command: 'owner_channel_manage', ownerChannel: { action: 'startup_failure' },
+        }, 2_000);
+        if (!response.ok)
+            throw new Error(response.error ?? 'prior owner channel refused startup notice');
+        const result = response.result;
+        if (result?.action !== 'startup_failure'
+            || (result.status !== 'delivered' && result.status !== 'duplicate'))
+            throw new Error('prior owner channel returned an invalid startup notice result');
+        return result.status;
+    },
 });
 const MONITOR_OWNER_FILE = '.monitor-owner';
+/** Environment injected only into the managed harness process. */
+export function managedFleetProxyEnv(role, stateDir) {
+    return {
+        ...(role.env ?? {}),
+        [FLEET_PROXY_STATE_DIR_ENV]: stateDir,
+        [FLEET_PROXY_CALLER_ENV]: role.name,
+    };
+}
+/**
+ * Execute a typed proxy request in the caller's supervisor. Dynamic imports
+ * avoid a runner↔spawn initialization cycle (spawn imports runner constants).
+ */
+async function executeManagedSpawn(caller, configPath, requested, log) {
+    const { options, inherited } = inheritCallerSpawnDefaults(caller, requested, configPath);
+    const creationActionId = randomUUID();
+    options.creationActionId = creationActionId;
+    const spawnModule = await import('./spawn.js');
+    const preview = spawnModule.spawnDryRun(options).resolvedRole;
+    const runtimeBinPath = (() => {
+        try {
+            return realpathSync(process.argv[1]);
+        }
+        catch {
+            return process.argv[1];
+        }
+    })();
+    let statePath;
+    if (options.temp) {
+        statePath = await spawnModule.spawnTemp(options, runtimeBinPath);
+    }
+    else {
+        const { pickBackend } = await import('./supervisor/index.js');
+        const { WatchdogServiceManager } = await import('./watchdog/service.js');
+        statePath = await spawnModule.spawnPermanent(options, {
+            backend: pickBackend(), binPath: runtimeBinPath, log,
+            watchdogService: new WatchdogServiceManager(),
+        });
+    }
+    const result = {
+        caller: caller.name,
+        role: options.name,
+        lifetime: options.temp ? 'temporary' : 'permanent',
+        statePath,
+        harness: preview.harness,
+        session: preview.session,
+        ...(preview.model ? { model: preview.model } : {}),
+        monitor: { mode: preview.monitor.mode, interrupt: preview.monitor.interrupt },
+        inherited,
+        creationActionId,
+    };
+    log(`[${caller.name}] managed fleet proxy spawned ${result.lifetime} role ${result.role} `
+        + `harness=${result.harness} session=${result.session}`);
+    return result;
+}
 /**
  * Record who owns wake delivery for this run. Returning true means a fleet
  * monitor is taking ownership back from a native harness and must start at the
@@ -420,6 +489,8 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     let monitorLoop;
     let acpStartupComplete = false;
     let ownerChannel;
+    let ownerBinder;
+    const pendingFleetSpawnNotices = [];
     let loopManager;
     let arbiter;
     let reloadLoopConfig;
@@ -438,7 +509,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             name,
             argv: wrappedArgv,
             cwd: runCwd,
-            env: { ...launch.env, ...(role.env ?? {}) },
+            env: { ...launch.env, ...managedFleetProxyEnv(role, dir) },
             stateDir: dir,
             mode,
             permissions: perms,
@@ -455,8 +526,54 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             if (evidence)
                 resolvedMonitorDeps.onFailureEvidence?.(evidence);
         });
+        if (role.owner_channel) {
+            try {
+                ownerBinder = await deps.acquireOwnerBinder(dir, name, role.owner_channel.identity);
+            }
+            catch (error) {
+                if (error instanceof OwnerBinderHandoffTimeoutError) {
+                    try {
+                        const status = await deps.reportOwnerStartupFailure(dir);
+                        deps.log(`[${name}] owner channel startup recovery notice ${status} by authenticated predecessor`);
+                    }
+                    catch (notifyError) {
+                        deps.log(`[${name}] owner channel startup recovery notice unavailable: `
+                            + `${notifyError?.message ?? String(notifyError)}`);
+                    }
+                }
+                await acpSession.close();
+                unsubscribeRecovery?.();
+                throw new Error(`[${name}] owner channel failed to start: `
+                    + `${error?.message ?? String(error)}`);
+            }
+        }
         control = new RoleControlServer(dir, arbiter, deps.log);
-        await control.start();
+        try {
+            await control.start();
+        }
+        catch (error) {
+            ownerBinder?.release();
+            await acpSession.close();
+            unsubscribeRecovery?.();
+            throw error;
+        }
+        control.setFleetSpawner(async (requested) => {
+            const event = await executeManagedSpawn(role, configPath, requested, deps.log);
+            if (!role.owner_channel)
+                return event;
+            if (ownerChannel?.notifyFleetSpawn) {
+                try {
+                    await ownerChannel.notifyFleetSpawn(event);
+                }
+                catch (error) {
+                    deps.log(`[${name}] spawned-agent owner notice failed: `
+                        + `${error?.message ?? String(error)}`);
+                }
+            }
+            else
+                pendingFleetSpawnNotices.push(event);
+            return event;
+        });
         resolvedMonitorDeps.delivery = {
             // A wake is only delivered when its turn TERMINATES successfully. A
             // refusal or a cancellation reached the agent and was not acted on, so
@@ -496,6 +613,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         if (!started.succeeded) {
             monitor?.stop();
             await control.close();
+            ownerBinder?.release();
             await acpSession.close();
             unsubscribeRecovery?.();
             if (modelRecovery) {
@@ -526,6 +644,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 stateDir: dir,
                 env: role.env,
                 log: deps.log,
+                ...(ownerBinder ? { binderLease: ownerBinder } : {}),
                 ...(configPath ? { configPath } : {}),
             });
             try {
@@ -535,14 +654,26 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 monitor?.stop();
                 if (monitorLoop)
                     await monitorLoop;
+                await ownerChannel.close().catch(() => undefined);
                 await control.close();
+                ownerBinder?.release();
                 await acpSession.close();
                 unsubscribeRecovery?.();
                 throw new Error(`[${name}] owner channel failed to start: `
                     + `${error?.message ?? String(error)}`);
             }
-            control.setOwnerChannel(ownerChannel);
+            for (const event of pendingFleetSpawnNotices.splice(0)) {
+                try {
+                    await ownerChannel.notifyFleetSpawn?.(event);
+                }
+                catch (error) {
+                    deps.log(`[${name}] deferred spawned-agent owner notice failed: `
+                        + `${error?.message ?? String(error)}`);
+                }
+            }
         }
+        if (ownerChannel)
+            control.setOwnerChannel(ownerChannel);
         reloadLoopConfig = async () => {
             const nextRole = findRole(loadConfig(configPath), name);
             const definitions = nextRole.loops ?? [];
@@ -628,17 +759,21 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         await loopManager.stop();
     }
     control?.setConfigReloader(undefined);
-    if (ownerChannel) {
-        control?.setOwnerChannel(undefined);
-        await ownerChannel.close();
+    // Close the authenticated control route before releasing the binder lease;
+    // otherwise the predecessor can unlink the replacement's new socket.
+    if (control) {
+        control.setOwnerChannel(undefined);
+        await control.close();
+        control = undefined;
     }
+    if (ownerChannel)
+        await ownerChannel.close();
+    ownerBinder?.release();
     if (monitor) {
         monitor.stop();
         await monitorLoop;
     }
     unsubscribeRecovery?.();
-    if (control)
-        await control.close();
     if (acpSession)
         await acpSession.close();
     const elapsed = (deps.now() - start) / 1000;

package/dist/session/control.d.ts

@@ -2,11 +2,13 @@ import { type Socket } from 'node:net';
 import type { ControlFailureKind, SessionHandle } from './types.js';
 import type { OwnerChannelHandle, OwnerChannelManagementRequest } from '../owner-channel/channel.js';
 import type { ScheduledLoopManagerHandle } from '../loops/manager.js';
+import type { SpawnOpts } from '../spawn.js';
+import type { ManagedFleetSpawnResult } from '../fleet-proxy.js';
 export interface ControlRequest {
     version: 1 | 2;
     id: string;
     token: string;
-    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config';
+    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config' | 'fleet_spawn';
     text?: string;
     permissionId?: string;
     optionId?: string;
@@ -15,6 +17,7 @@ export interface ControlRequest {
     controller?: boolean;
     ownerChannel?: OwnerChannelManagementRequest;
     loop?: string;
+    spawn?: SpawnOpts;
 }
 export interface ControlResponse {
     version: 1;
@@ -78,6 +81,7 @@ export declare class RoleControlServer {
     private ownerChannel?;
     private loopManager?;
     private reloadConfig?;
+    private fleetSpawner?;
     constructor(stateDir: string, session: SessionHandle, log: (line: string) => void);
     start(): Promise<void>;
     close(): Promise<void>;
@@ -85,6 +89,7 @@ export declare class RoleControlServer {
     setOwnerChannel(ownerChannel: OwnerChannelHandle | undefined): void;
     setLoopManager(loopManager: ScheduledLoopManagerHandle | undefined): void;
     setConfigReloader(reloadConfig: (() => Promise<unknown>) | undefined): void;
+    setFleetSpawner(fleetSpawner: ((options: SpawnOpts) => Promise<ManagedFleetSpawnResult>) | undefined): void;
     private accept;
     private handle;
     private write;

package/dist/session/control.js

@@ -98,6 +98,7 @@ export class RoleControlServer {
     ownerChannel;
     loopManager;
     reloadConfig;
+    fleetSpawner;
     constructor(stateDir, session, log) {
         this.session = session;
         this.log = log;
@@ -140,6 +141,9 @@ export class RoleControlServer {
     setConfigReloader(reloadConfig) {
         this.reloadConfig = reloadConfig;
     }
+    setFleetSpawner(fleetSpawner) {
+        this.fleetSpawner = fleetSpawner;
+    }
     accept(socket) {
         this.sockets.add(socket);
         socket.setEncoding('utf8');
@@ -271,6 +275,15 @@ export class RoleControlServer {
                     });
                     return;
                 }
+                case 'fleet_spawn': {
+                    if (request.version !== 2 || !request.spawn || typeof request.spawn.name !== 'string')
+                        throw new SessionControlError('rejected', 'version 2 and typed spawn options are required');
+                    if (!this.fleetSpawner)
+                        throw new SessionControlError('rejected', 'managed fleet spawning is unavailable for this role');
+                    const result = await this.fleetSpawner(request.spawn);
+                    this.write(socket, { version: 1, id: request.id, ok: true, result });
+                    return;
+                }
                 case 'owner_channel_manage': {
                     if (!request.ownerChannel || typeof request.ownerChannel.action !== 'string')
                         throw new SessionControlError('rejected', 'owner-channel management action is required');

package/dist/spawn.d.ts

@@ -40,8 +40,12 @@ export interface SpawnOpts {
     bio?: string;
     persona?: string;
     /** Internal, non-sensitive provenance correlation for typed presentation layers. */
-    surface?: 'cli' | 'web';
+    surface?: 'cli' | 'web' | 'agent';
     creationActionId?: string;
+    /** Set only by a live role supervisor after a role-scoped proxy request. */
+    callerRole?: string;
+    /** Internal provenance labels for values filled by the caller's supervisor. */
+    inheritedFromCaller?: string[];
     /**
      * Path to a file holding exactly the existing `isolation:` mapping — the same
      * schema fleet.yaml uses, not a second policy language. The ONE new operator

package/dist/spawn.js

@@ -238,29 +238,31 @@ export function spawnDryRun(o) {
  */
 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);
     return {
-        harness: provenanceOf(o.harness, defaults.harness, 'claude-code'),
-        session: provenanceOf(o.session, defaults.session, 'tmux'),
+        harness: tagged('harness', provenanceOf(o.harness, defaults.harness, 'claude-code')),
+        session: tagged('session', provenanceOf(o.session, defaults.session, 'tmux')),
         identity: o.identity
             ? { value: o.identity, source: 'cli' }
             : { value: o.name, source: 'built-in' }, // defaults to the role name
-        cwd: provenanceOf(o.cwd, undefined, undefined),
-        model: o.model === null
+        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: provenanceOf(o.coordinator, undefined, undefined),
+                : { value: inheritedModel, source: inheritedModel ? 'fleet-default' : 'built-in' }),
+        coordinator: tagged('coordinator', provenanceOf(o.coordinator, undefined, undefined)),
         permission_mode: provenanceOf(o.permissionMode, undefined, undefined),
-        approval: provenanceOf(o.approval, perms.approval, 'ask'),
-        filesystem: provenanceOf(o.filesystem, perms.filesystem, 'workspace'),
-        unattended: provenanceOf(o.unattended, perms.unattended, 'deny'),
+        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')),
         isolation: o.isolationFile
             ? { value: 'declared via --isolation-file', source: 'cli' }
             : { value: defaults.isolation ? 'from fleet defaults' : undefined, source: defaults.isolation ? 'fleet-default' : 'built-in' },
-        monitor: provenanceOf(o.monitorConfig, defaults.monitor, { mode: 'fleet' }),
+        monitor: tagged('monitorConfig', provenanceOf(o.monitorConfig, defaults.monitor, { mode: 'fleet' })),
     };
 }
 /** Permanent spawn: persist to ~/fleet.d/<Name>.yaml, then bring it up. */
@@ -324,7 +326,7 @@ export async function spawnPermanent(o, deps, creation = {}) {
         const provenance = buildProvenance({
             role: o.name, lifetime: 'permanent', fleetVersion: VERSION,
             settings: provenanceSettings(o, cfg.defaults),
-            surface: o.surface, creationActionId: o.creationActionId,
+            surface: o.surface, creationActionId: o.creationActionId, callerRole: o.callerRole,
         });
         mkdirSync(agentDir(o.name), { recursive: true });
         writeProvenance(agentDir(o.name), provenance);
@@ -414,7 +416,7 @@ async function spawnTempInner(o, binPath, launch, tx, guarantee, onStage) {
     const provenance = buildProvenance({
         role: o.name, lifetime: 'temporary', fleetVersion: VERSION,
         settings: provenanceSettings(o, cfg.defaults),
-        surface: o.surface, creationActionId: o.creationActionId,
+        surface: o.surface, creationActionId: o.creationActionId, callerRole: o.callerRole,
     });
     writeProvenance(dir, provenance);
     lastProvenance = provenance;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "0.15.0",
+  "version": "0.15.3",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, tmux or ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",