@ours.network/fleet 1.0.2 → 1.0.4

package/dist/rooms-tasks/provision.js

@@ -5,6 +5,9 @@ import { advanceSaga, setSagaError, updateMemberSeats, updateMemberStartup, acti
 import { activateTask, updateTaskMembers, blockTask, unblockTask, getTask, } from './task-state.js';
 import { spawnTemp } from '../spawn.js';
 import { findRole } from '../config.js';
+import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from '../fleet-proxy.js';
+import { controlRequest } from '../session/control.js';
+import { SessionControlError } from '../session/types.js';
 import { closeManagedRoom } from './close.js';
 import { buildRoomMemberTask, sha256Text } from './member-startup.js';
 import { agentDir } from '../paths.js';
@@ -18,6 +21,28 @@ export function getBinPath() {
         return process.argv[1];
     }
 }
+async function spawnRoomMember(options, binPath) {
+    const stateDir = process.env[FLEET_PROXY_STATE_DIR_ENV];
+    if (!stateDir)
+        return {
+            statePath: await spawnTemp(options, binPath),
+            creationActionId: options.creationActionId,
+        };
+    const response = await controlRequest(stateDir, { command: 'fleet_spawn', spawn: options }, 10 * 60_000);
+    if (!response.ok) {
+        throw new SessionControlError(response.kind ?? 'backend', response.error ?? 'managed room member spawn failed');
+    }
+    const result = response.result;
+    const expectedCaller = process.env[FLEET_PROXY_CALLER_ENV];
+    if (expectedCaller && result.caller !== expectedCaller) {
+        throw new Error(`fleet proxy caller mismatch: expected '${expectedCaller}', got '${result.caller}'`);
+    }
+    return {
+        statePath: result.statePath,
+        creationActionId: result.creationActionId,
+        callerRole: result.caller,
+    };
+}
 function shortId(id) { return id.slice(0, 8); }
 function expandMembers(template, prefix) {
     const result = [];
@@ -40,11 +65,15 @@ function settingsFor(member, cfg) {
         refRole = findRole(cfg, member.roleRef);
     }
     catch { /* no ref role */ }
+    const permissions = member.overrides?.permissions;
     return {
         model: member.overrides?.model ?? refRole?.model,
         harness: member.overrides?.harness ?? refRole?.harness,
         cwd: member.overrides?.cwd ?? refRole?.cwd,
         persona: member.overrides?.persona ?? refRole?.persona,
+        approval: permissions?.approval,
+        filesystem: permissions?.filesystem,
+        unattended: permissions?.unattended,
     };
 }
 function roomTask(input, member, settings, members, roomIdentityCid, ownerSeatCid) {
@@ -96,9 +125,24 @@ async function retainRunningLaunch(input) {
         .find(candidate => candidate.role_name === member.name);
     const dir = agentDir(member.name, true);
     const taskSha = sha256Text(task);
-    if ((seat.launch?.state === 'intent' || seat.launch?.state === 'launched') && existsSync(dir)) {
+    if ((seat.launch?.state === 'intent' || seat.launch?.state === 'launched'
+        || seat.launch?.state === 'failed') && existsSync(dir)) {
         if (!seat.launch.action_id || !launchMatches(dir, member, seat.launch.action_id, taskSha, provision.roomId, roomIdentityCid, seat.invite_id)) {
-            throw new Error(`existing launch for ${member.name} does not match its durable intent`);
+            const provenance = readProvenance(dir);
+            const adoptable = (seat.launch.state === 'intent' || seat.launch.state === 'failed')
+                && Boolean(seat.launch.caller_role)
+                && provenance?.surface === 'agent'
+                && provenance.callerRole === seat.launch.caller_role
+                && typeof provenance.creationActionId === 'string'
+                && launchMatches(dir, member, provenance.creationActionId, taskSha, provision.roomId, roomIdentityCid, seat.invite_id);
+            if (!adoptable)
+                throw new Error(`existing launch for ${member.name} does not match its durable intent`);
+            updateMemberStartup(provision.roomId, member.name, { launch: {
+                    ...seat.launch, state: 'intent', action_id: provenance.creationActionId,
+                    updated_at: new Date().toISOString(),
+                } });
+            seat = getRoomRecord(provision.roomId).member_seats
+                .find(candidate => candidate.role_name === member.name);
         }
         const supervisor = readTempSupervisor(dir);
         if (!supervisor || supervisor.role !== member.name)
@@ -106,16 +150,17 @@ async function retainRunningLaunch(input) {
         const live = await tempSupervisorLiveness(dir);
         if (live === 'unknown')
             throw new Error(`existing launch for ${member.name} has unknown liveness`);
+        const retainedLaunch = seat.launch;
         if (live === 'running') {
             updateMemberStartup(provision.roomId, member.name, { launch: {
-                    ...seat.launch, state: 'launched', launch_id: supervisor.launchId,
+                    ...retainedLaunch, state: 'launched', launch_id: supervisor.launchId,
                     updated_at: new Date().toISOString(),
                 } });
             return true;
         }
         await secureStoppedTempArchive(member.name, supervisor.launchId);
         updateMemberStartup(provision.roomId, member.name, { launch: {
-                ...seat.launch, state: 'stopped', launch_id: supervisor.launchId,
+                ...retainedLaunch, state: 'stopped', launch_id: supervisor.launchId,
                 updated_at: new Date().toISOString(),
             } });
         return false;
@@ -151,14 +196,18 @@ async function launchMember(input) {
     const seat = getRoomRecord(provision.roomId).member_seats
         .find(candidate => candidate.role_name === member.name);
     const actionId = randomUUID();
+    let effectiveActionId = actionId;
     const attempt = (seat.launch?.attempt ?? 0) + 1;
     const taskSha = sha256Text(startup.task);
+    const proxyCaller = process.env[FLEET_PROXY_STATE_DIR_ENV]
+        ? process.env[FLEET_PROXY_CALLER_ENV] : undefined;
     updateMemberStartup(provision.roomId, member.name, { launch: {
             state: 'intent', attempt, action_id: actionId, mission_sha256: taskSha,
+            ...(proxyCaller ? { caller_role: proxyCaller } : {}),
             updated_at: new Date().toISOString(),
         } });
     try {
-        const launchedDir = await spawnTemp({
+        const launched = await spawnRoomMember({
             name: member.name,
             temp: true,
             identity: member.name,
@@ -166,22 +215,36 @@ async function launchMember(input) {
             model: settings.model,
             harness: settings.harness,
             cwd: settings.cwd,
+            approval: settings.approval,
+            filesystem: settings.filesystem,
+            unattended: settings.unattended,
             surface: 'agent',
             creationActionId: actionId,
             roomMemberStartup: startup,
         }, provision.binPath);
+        const launchedDir = launched.statePath;
+        effectiveActionId = launched.creationActionId;
+        if (launched.creationActionId !== actionId) {
+            updateMemberStartup(provision.roomId, member.name, { launch: {
+                    state: 'intent', attempt, action_id: launched.creationActionId,
+                    mission_sha256: taskSha, updated_at: new Date().toISOString(),
+                    ...(launched.callerRole ? { caller_role: launched.callerRole } : {}),
+                } });
+        }
         const supervisor = readTempSupervisor(launchedDir);
-        if (!supervisor || supervisor.role !== member.name || !launchMatches(launchedDir, member, actionId, taskSha, provision.roomId, startup.room_identity_cid, startup.invite_id)) {
+        if (!supervisor || supervisor.role !== member.name || !launchMatches(launchedDir, member, launched.creationActionId, taskSha, provision.roomId, startup.room_identity_cid, startup.invite_id)) {
             throw new Error(`new launch for ${member.name} did not persist matching provenance`);
         }
         updateMemberStartup(provision.roomId, member.name, { launch: {
-                state: 'launched', attempt, action_id: actionId, mission_sha256: taskSha,
+                state: 'launched', attempt, action_id: launched.creationActionId, mission_sha256: taskSha,
+                ...(launched.callerRole ? { caller_role: launched.callerRole } : {}),
                 launch_id: supervisor.launchId, updated_at: new Date().toISOString(),
             } });
     }
     catch (error) {
         updateMemberStartup(provision.roomId, member.name, { launch: {
-                state: 'failed', attempt, action_id: actionId, mission_sha256: taskSha,
+                state: 'failed', attempt, action_id: effectiveActionId, mission_sha256: taskSha,
+                ...(proxyCaller ? { caller_role: proxyCaller } : {}),
                 updated_at: new Date().toISOString(),
                 error: error instanceof Error ? error.message : String(error),
             } });

package/dist/rooms-tasks/types.d.ts

@@ -87,6 +87,8 @@ export interface RoomMemberLaunchState {
     state: 'pending' | 'intent' | 'launched' | 'stopped' | 'failed';
     attempt: number;
     action_id?: string;
+    /** Expected authenticated proxy caller while adopting a post-spawn crash. */
+    caller_role?: string;
     mission_sha256?: string;
     launch_id?: string;
     updated_at: string;

package/dist/runner.js

@@ -23,7 +23,7 @@ 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';
+import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from './fleet-proxy.js';
 import { effectivePermissionMode } from './permissions.js';
 import { assertModelPinReachesChild, effectiveRoleModel, repinModelEnv } from './model-env.js';
 import { archiveTempState, markTempSupervisorActive, requestedTempStopReason, } from './temp-lifecycle.js';
@@ -61,15 +61,15 @@ const defaultDeps = () => ({
     },
 });
 const MONITOR_OWNER_FILE = '.monitor-owner';
-/** Fleet roles consume the operator-owned daemon; a role session never starts it. */
-const FLEET_OURS_AUTOSTART = '0';
+const OBSOLETE_OURS_AUTOSTART_ENV = 'OURS_AUTOSTART';
 /** Environment injected only into the managed harness process. */
 export function managedFleetProxyEnv(role, stateDir) {
+    const roleEnv = { ...(role.env ?? {}) };
+    // ours-mcp 1.0 treats presence (even "0") as a fatal legacy lifecycle mode.
+    // Managed children are daemon clients; the proxy itself never starts one.
+    delete roleEnv[OBSOLETE_OURS_AUTOSTART_ENV];
     return {
-        ...(role.env ?? {}),
-        // This must win over both inherited/configured auto-start. ACP agents run
-        // directly rather than through ours-codex, so the runner owns this fence.
-        OURS_AUTOSTART: FLEET_OURS_AUTOSTART,
+        ...roleEnv,
         [FLEET_PROXY_STATE_DIR_ENV]: stateDir,
         [FLEET_PROXY_CALLER_ENV]: role.name,
     };
@@ -92,11 +92,6 @@ export function harnessChildEnv(role, launchEnv, stateDir) {
  * 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]);
@@ -105,33 +100,15 @@ async function executeManagedSpawn(caller, configPath, requested, log) {
             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,
-        // Read back from the resolved environment, not from the request: the banner
-        // must name the model the child will run, not the one that was asked for.
-        ...(effectiveRoleModel(preview) ? { model: effectiveRoleModel(preview) } : {}),
-        monitor: { mode: preview.monitor.mode, interrupt: preview.monitor.interrupt },
-        permissionMode: effectivePermissionMode(preview),
-        inherited,
-        creationActionId,
-    };
+    const [{ RoleCreationService }, { pickBackend }, { WatchdogServiceManager }] = await Promise.all([
+        import('./application/role-creation-service.js'), import('./supervisor/index.js'),
+        import('./watchdog/service.js'),
+    ]);
+    const service = new RoleCreationService({ configPath,
+        ops: { backend: pickBackend(), binPath: runtimeBinPath, log,
+            watchdogService: new WatchdogServiceManager() },
+        binPath: runtimeBinPath, journal: false });
+    const result = await service.createManaged(caller, requested);
     log(`[${caller.name}] managed fleet proxy spawned ${result.lifetime} role ${result.role} `
         + `harness=${result.harness} session=${result.session} `
         + `model=${result.model ?? '(harness default)'} `
@@ -166,17 +143,14 @@ export function recordMonitorOwner(dir, owner) {
 export function buildPaneCommand(launch, roleEnv, exitStatusPath, paneArgv = launch.argv) {
     const env = {
         PATH: process.env.PATH ?? '', COLORTERM: 'truecolor', ...launch.env, ...(roleEnv ?? {}),
-        // Tmux roles have the same daemon-client boundary as ACP roles. Keep this
-        // last so neither harness preparation nor a role env block can take over
-        // the shared daemon lifecycle.
-        OURS_AUTOSTART: FLEET_OURS_AUTOSTART,
     };
+    delete env[OBSOLETE_OURS_AUTOSTART_ENV];
     // Interactive panes should advertise colour even when the supervisor itself
     // was launched with NO_COLOR. A role may still deliberately opt back in to
     // NO_COLOR (or replace COLORTERM) through its explicit env block.
     const unsetNoColor = Object.prototype.hasOwnProperty.call(roleEnv ?? {}, 'NO_COLOR')
         ? '' : '-u NO_COLOR ';
-    const envPfx = 'env ' + unsetNoColor
+    const envPfx = 'env -u OURS_AUTOSTART ' + unsetNoColor
         + Object.entries(env).map(([k, v]) => `${k}=${shq(v)}`).join(' ');
     const cmd = paneArgv.map(shq).join(' ');
     // Write a structured record, not a bare number: the wait status alone cannot
@@ -645,6 +619,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             // role-only adapter hook prevents a PATH fallback or resolver skew from
             // claiming metadata trust for an argv it did not authenticate.
             permissionMetadataSource: launch.permissionMetadataSource,
+            scrubObsoleteOursAutostart: true,
             log: deps.log,
         });
         pid = acpSession.pid;

package/dist/session/acp.d.ts

@@ -21,6 +21,8 @@ export declare const AFTER_TOOL_BOUNDARY_TIMEOUT_MS = 120000;
  * live role.
  */
 export declare const STEERING_OCCUPANCY_IDLE_MS = 150000;
+/** Consumed only by Fleet's authenticated bundled-Codex app-server proxy. */
+export declare const CODEX_DISABLE_INHERITED_MCP_ENV = "OURS_FLEET_CODEX_DISABLE_INHERITED_MCP";
 /** Server-generated typed provenance followed by the exact human-authored body. */
 export declare function promptContentBlocks(text: string, origin?: PromptOrigin): acp.ContentBlock[];
 export declare function runtimeSelector(options: acp.SessionConfigOption[] | null | undefined, category: string): RuntimeSelectorMetadata | undefined;
@@ -38,10 +40,13 @@ export interface AcpSessionOptions {
     permissionMode?: NonNullable<SessionSnapshot['permissionMode']>;
     /** Adapter-authenticated request-metadata vocabulary; never inferred from ACP `_meta`. */
     permissionMetadataSource?: 'codex-acp';
+    /** Fleet-managed ours proxies must never receive the obsolete presence-sensitive flag. */
+    scrubObsoleteOursAutostart?: boolean;
     /**
      * MCP servers the ROLE declares, for every session/new, resume and load.
-     * Omitted preserves inherited configuration; an explicit empty array disables
-     * every inherited server.
+     * Omitted preserves inherited configuration (encoded as ACP's required `[]`);
+     * an explicit empty array disables every inherited server through the
+     * authenticated bundled-adapter compatibility path.
      */
     mcpServers?: AcpMcpServer[];
     /**
@@ -258,7 +263,7 @@ export declare class AcpSession implements SessionHandle {
     private settlePendingAutomatically;
     exitResult(): ExitRecord | null;
     close(): Promise<void>;
-    /** Preserve inheritance on omission; carry even an explicit empty override. */
+    /** ACP requires the field. Bundled agents treat [] as no client-added servers. */
     private declaredMcpServers;
     private initialize;
     private captureRuntimeMetadata;

package/dist/session/acp.js

@@ -32,6 +32,8 @@ export const AFTER_TOOL_BOUNDARY_TIMEOUT_MS = 120_000;
  */
 export const STEERING_OCCUPANCY_IDLE_MS = 150_000;
 const TERMINAL_TOOL_STATUSES = new Set(['completed', 'failed']);
+/** Consumed only by Fleet's authenticated bundled-Codex app-server proxy. */
+export const CODEX_DISABLE_INHERITED_MCP_ENV = 'OURS_FLEET_CODEX_DISABLE_INHERITED_MCP';
 const SCHEDULED_LOOP_REDACTION = '[scheduled-loop content redacted]';
 const OWNER_COMMENTARY_REDACTION = '[assistant commentary redacted]';
 const MAX_CANONICAL_SYMLINK_DEPTH = 40;
@@ -304,9 +306,25 @@ export class AcpSession {
     static async start(options) {
         if (!options.argv.length)
             throw new Error('ACP agent command is empty');
+        const disableInheritedCodexMcp = options.permissionMetadataSource === 'codex-acp'
+            && options.mcpServers !== undefined && options.mcpServers.length === 0;
+        // Obsolete ours-mcp lifecycle flags are presence-sensitive. The shared
+        // daemon remains operator-owned; managed ACP children are clients only.
+        const childEnv = {
+            ...process.env,
+            ...options.env,
+        };
+        if (options.scrubObsoleteOursAutostart)
+            delete childEnv.OURS_AUTOSTART;
+        Object.assign(childEnv, 
+        // Write both states for the authenticated proxy: a stale ambient `1`
+        // must never leak explicit-empty semantics into a later inherited role.
+        options.permissionMetadataSource === 'codex-acp'
+            ? { [CODEX_DISABLE_INHERITED_MCP_ENV]: disableInheritedCodexMcp ? '1' : '0' }
+            : {});
         const child = spawn(options.argv[0], options.argv.slice(1), {
             cwd: options.cwd,
-            env: { ...process.env, ...options.env },
+            env: childEnv,
             stdio: ['pipe', 'pipe', 'pipe'],
         });
         await new Promise((resolve, reject) => {
@@ -991,11 +1009,9 @@ export class AcpSession {
         });
         this.conversation.close();
     }
-    /** Preserve inheritance on omission; carry even an explicit empty override. */
+    /** ACP requires the field. Bundled agents treat [] as no client-added servers. */
     declaredMcpServers() {
-        return this.options.mcpServers === undefined
-            ? {}
-            : { mcpServers: this.options.mcpServers };
+        return this.options.mcpServers ?? [];
     }
     async initialize() {
         const initialized = await this.connection.agent.request(acp.methods.agent.initialize, {
@@ -1016,7 +1032,7 @@ export class AcpSession {
             const resumed = await this.connection.agent.request(acp.methods.agent.session.resume, {
                 sessionId: persisted,
                 cwd: this.options.cwd,
-                ...this.declaredMcpServers(),
+                mcpServers: this.declaredMcpServers(),
             });
             this.captureRuntimeMetadata(resumed.configOptions);
             this.sessionId = persisted;
@@ -1029,7 +1045,7 @@ export class AcpSession {
                 const loaded = await this.connection.agent.request(acp.methods.agent.session.load, {
                     sessionId: persisted,
                     cwd: this.options.cwd,
-                    ...this.declaredMcpServers(),
+                    mcpServers: this.declaredMcpServers(),
                 });
                 this.captureRuntimeMetadata(loaded.configOptions);
             }
@@ -1041,7 +1057,7 @@ export class AcpSession {
         else {
             const created = await this.connection.agent.request(acp.methods.agent.session.new, {
                 cwd: this.options.cwd,
-                ...this.declaredMcpServers(),
+                mcpServers: this.declaredMcpServers(),
                 ...(this.options.sessionMeta ? { _meta: this.options.sessionMeta } : {}),
             });
             this.sessionId = created.sessionId;

package/dist/session/control.d.ts

@@ -1,5 +1,5 @@
 import { type Socket } from 'node:net';
-import type { ControlFailureKind, SessionHandle } from './types.js';
+import type { ControlFailureKind, SessionEvent, SessionHandle, SessionSnapshot } 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';
@@ -40,6 +40,15 @@ export interface ControlResponse {
     /** Why it failed, so the caller does not have to guess from the text. */
     kind?: ControlFailureKind;
 }
+export interface RetainedEventPage {
+    events: SessionEvent[];
+    snapshot: SessionSnapshot;
+    firstSeq: number;
+    lastSeq: number;
+    truncated: boolean;
+}
+/** The one retained-range projection shared by polling and live-follow admission. */
+export declare function retainedEventPage(session: SessionHandle, since: number): RetainedEventPage;
 /**
  * One line saying what a control failure does — and does not — prove about the
  * agent. Only `offline` is evidence that it is gone; every other kind used to

package/dist/session/control.js

@@ -2,13 +2,26 @@ import { randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { chmodSync, existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { createConnection, createServer } from 'node:net';
 import { join } from 'node:path';
-import { SessionControlError, interruptOutcome } from './types.js';
+import { SessionControlError } from './types.js';
+import { interruptSession, queueSessionPrompt, respondSessionPermission, respondSessionPermissionV2, } from '../application/session-mutations.js';
 const MAX_LINE_BYTES = 64 * 1024;
 /** Commands that require protocol version 3. */
 const V3_COMMANDS = new Set([
     'conversation_page', 'conversation_follow', 'submit_prompt_v2', 'interrupt_v2',
     'respond_permission_v2',
 ]);
+/** The one retained-range projection shared by polling and live-follow admission. */
+export function retainedEventPage(session, since) {
+    const events = session.eventsSince(since);
+    const all = session.eventsSince(0);
+    return {
+        events,
+        snapshot: session.snapshot(),
+        firstSeq: all[0]?.seq ?? 0,
+        lastSeq: all.at(-1)?.seq ?? 0,
+        truncated: Boolean(all[0] && since > 0 && since < all[0].seq - 1),
+    };
+}
 /**
  * One line saying what a control failure does — and does not — prove about the
  * agent. Only `offline` is evidence that it is gone; every other kind used to
@@ -230,7 +243,7 @@ export class RoleControlServer {
                     // Answer on QUEUE ACCEPTANCE, not on turn completion. A turn can run
                     // for minutes; blocking here made every `send` into a busy agent time
                     // out, and the timeout was then reported as a dead agent.
-                    const queued = await this.session.queuePrompt(request.text, {
+                    const queued = await queueSessionPrompt(this.session, request.text, {
                         origin: { kind: 'local-console' },
                     });
                     this.write(socket, {
@@ -244,7 +257,7 @@ export class RoleControlServer {
                 case 'respond_permission': {
                     if (!request.permissionId || !request.optionId)
                         throw new SessionControlError('rejected', 'permissionId and optionId are required');
-                    const accepted = this.session.respondPermission(request.permissionId, request.optionId);
+                    const accepted = respondSessionPermission(this.session, request.permissionId, request.optionId);
                     this.write(socket, {
                         version: 1, id: request.id, ok: accepted,
                         result: { accepted },
@@ -256,7 +269,7 @@ export class RoleControlServer {
                 case 'interrupt': {
                     // Forced recovery cancelled the turn just as surely as a cooperative
                     // stop did. Report HOW, never as a failed operation.
-                    const outcome = interruptOutcome(await this.session.interrupt('local-console'));
+                    const outcome = await interruptSession(this.session, 'local-console');
                     this.write(socket, { version: 1, id: request.id, ok: true, result: outcome });
                     return;
                 }
@@ -309,29 +322,17 @@ export class RoleControlServer {
                 }
                 case 'events_since': {
                     const since = Number.isFinite(request.since) ? Number(request.since) : 0;
-                    const events = this.session.eventsSince(since);
-                    const all = this.session.eventsSince(0);
                     this.write(socket, {
                         version: 1, id: request.id, ok: true,
-                        result: {
-                            events, snapshot: this.session.snapshot(),
-                            firstSeq: all[0]?.seq ?? 0, lastSeq: all.at(-1)?.seq ?? 0,
-                            truncated: Boolean(all[0] && since > 0 && since < all[0].seq - 1),
-                        },
+                        result: retainedEventPage(this.session, since),
                     });
                     return;
                 }
                 case 'follow': {
                     const since = Number.isFinite(request.since) ? Number(request.since) : 0;
-                    const events = this.session.eventsSince(since);
-                    const all = this.session.eventsSince(0);
                     this.write(socket, {
                         version: 1, id: request.id, ok: true,
-                        result: {
-                            events, snapshot: this.session.snapshot(),
-                            firstSeq: all[0]?.seq ?? 0, lastSeq: all.at(-1)?.seq ?? 0,
-                            truncated: Boolean(all[0] && since > 0 && since < all[0].seq - 1),
-                        },
+                        result: retainedEventPage(this.session, since),
                     });
                     const controller = request.controller !== false;
                     if (controller)
@@ -399,7 +400,7 @@ export class RoleControlServer {
                         this.write(socket, { version: 1, id: request.id, ok: true, result: existing });
                         return;
                     }
-                    const outcome = interruptOutcome(await this.session.interrupt('local-console'));
+                    const outcome = await interruptSession(this.session, 'local-console');
                     const receipt = {
                         accepted: true, commandId: request.commandId, at: new Date().toISOString(),
                         ...outcome,
@@ -417,9 +418,9 @@ export class RoleControlServer {
                     if (!request.commandId?.trim() || !request.permissionId?.trim()
                         || !request.optionId?.trim() || !request.sessionGeneration?.trim())
                         throw new SessionControlError('rejected', 'commandId, permissionId, optionId and sessionGeneration are required');
-                    if (!this.session.respondPermissionV2)
+                    const result = respondSessionPermissionV2(this.session, request.permissionId, request.optionId, request.sessionGeneration);
+                    if (result === 'unavailable')
                         throw new SessionControlError('rejected', 'generation-bound permission responses are unavailable for this role');
-                    const result = this.session.respondPermissionV2(request.permissionId, request.optionId, request.sessionGeneration);
                     if (result === 'stale')
                         throw new SessionControlError('rejected', 'stale_state: permission is settled, expired, invalid, or belongs to another session generation');
                     this.write(socket, {

package/dist/watchdog/query.d.ts

@@ -6,6 +6,8 @@ export interface WatchdogRoleFinding {
     status: WatchdogRoleStatus;
     reason: string;
 }
+/** Shared configured-or-surviving-history addressability rule. */
+export declare function watchdogAddressable(name: string, configured: readonly string[], historyExists?: (validName: string) => boolean): boolean;
 /**
  * Needs-attention integration: worst current finding per role across
  * every configured watchdog, for FleetQueryService.status() to fold into a

package/dist/watchdog/query.js

@@ -6,6 +6,12 @@ import { watchdogsRoot } from '../paths.js';
 import { WATCHDOG_STATUS_RANK } from './alerts.js';
 import { readSchedulerState } from './scheduler.js';
 import { listRuns, readReport } from './store.js';
+/** Shared configured-or-surviving-history addressability rule. */
+export function watchdogAddressable(name, configured, historyExists = validName => existsSync(join(watchdogsRoot(), validName))) {
+    if (configured.includes(name))
+        return true;
+    return ROLE_NAME_RE.test(name) && historyExists(name);
+}
 /**
  * Needs-attention integration: worst current finding per role across
  * every configured watchdog, for FleetQueryService.status() to fold into a
@@ -115,9 +121,7 @@ export class WatchdogQueryService {
      */
     requireKnown(name) {
         const cfg = this.cfgProvider();
-        if (cfg.watchdogs.some(wd => wd.name === name))
-            return;
-        if (ROLE_NAME_RE.test(name) && existsSync(join(watchdogsRoot(), name)))
+        if (watchdogAddressable(name, cfg.watchdogs.map(wd => wd.name)))
             return;
         throw new FleetError('role_not_found', `no such watchdog '${name}'`);
     }

package/dist/web/server.js

@@ -209,7 +209,7 @@ export async function buildWebServer(services, boundary, options = {}) {
             throw new FleetError('invalid_request', 'invalid role name');
         if (!services.removal)
             throw new FleetError('capability_unavailable', 'role removal is unavailable');
-        return services.removal.preview(request.params.id);
+        return services.removal.previewWeb(request.params.id);
     });
     app.post('/api/v1/roles/:id/remove', async (request) => {
         const session = auth.authenticate(request, true);
@@ -218,7 +218,7 @@ export async function buildWebServer(services, boundary, options = {}) {
         if (!services.removal)
             throw new FleetError('capability_unavailable', 'role removal is unavailable');
         const body = request.body;
-        const result = await services.removal.remove({ role: request.params.id, ...body });
+        const result = await services.removal.removeWeb({ role: request.params.id, ...body });
         events.publish('role.removed', { role: result.role }, result.role);
         await audit.record({ requestId: request.id, browser: session.id, roleId: result.role, action: 'role.remove', result: 'succeeded' });
         return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "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",