@ours.network/fleet 1.0.3 → 1.0.4

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';
@@ -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)'} `

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.3",
+  "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",