@ours.network/fleet 1.2.0-nightly.40 → 1.2.0-nightly.42

package/dist/application/role-repository.js

@@ -1,7 +1,7 @@
 import { lstatSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import { parse } from 'yaml';
-import { loadConfig, resolveMonitorConfig, resolvePermissions, ROLE_NAME_RE, } from '../config.js';
+import { loadConfig, resolveSnapshotMonitor, resolvePermissions, ROLE_NAME_RE, } from '../config.js';
 import { agentsRoot, tmpRoot } from '../paths.js';
 import { readSpawnLineage } from '../web/topology.js';
 const MAX_SNAPSHOT_BYTES = 256 * 1024;
@@ -54,7 +54,7 @@ function snapshot(path, name) {
                 session, identity: typeof raw.identity === 'string' ? raw.identity : name,
                 permissions: resolvePermissions(undefined, raw.permissions),
                 permissionsDeclared: raw.permissions !== undefined,
-                monitor: resolveMonitorConfig(undefined, raw.monitor),
+                monitor: resolveSnapshotMonitor(raw.monitor),
                 sourceFile: '(temp)',
             },
         };

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.40",
-  "buildId": "de6076ea1748",
-  "commit": "147b0e1859d9dc59f46140b0171329e9a479d3cc",
+  "version": "1.2.0-nightly.42",
+  "buildId": "536c9cc8b8d7",
+  "commit": "c51b38eaa547d240e97f776e09286590222e727e",
   "dirty": true,
-  "builtAt": "2026-10-03T11:45:41.330Z",
+  "builtAt": "2026-10-03T20:14:35.466Z",
   "capabilities": [
     "workspace.enroll.preserve-profile-v1",
     "cowork.http-management-v1",

package/dist/config.d.ts

@@ -343,6 +343,11 @@ export declare function resolvePermissions(defaults: unknown, role: Partial<Comm
  * without tool-boundary steering fall back to non-cancelling delivery.
  */
 export declare function defaultMonitorInterrupt(harness: string | undefined): MonitorInterrupt;
+/**
+ * Resolve a persisted temporary-role monitor. A snapshot written before
+ * monitor.interrupt existed keeps the non-interrupting delivery it ran with.
+ */
+export declare function resolveSnapshotMonitor(monitor: unknown): MonitorConfig;
 export declare function resolveMonitorConfig(defMonitor: unknown, roleMonitor?: Partial<MonitorConfig>, labels?: {
     base?: string;
     file?: string;

package/dist/config.js

@@ -1150,6 +1150,15 @@ function resolveStartStaggerMs(raw, base) {
 export function defaultMonitorInterrupt(harness) {
     return harness === 'hermes' ? false : 'after_tool';
 }
+/**
+ * Resolve a persisted temporary-role monitor. A snapshot written before
+ * monitor.interrupt existed keeps the non-interrupting delivery it ran with.
+ */
+export function resolveSnapshotMonitor(monitor) {
+    if (!isPlainObject(monitor))
+        return resolveMonitorConfig(undefined, monitor);
+    return resolveMonitorConfig(undefined, { interrupt: false, ...monitor });
+}
 export function resolveMonitorConfig(defMonitor, roleMonitor, labels = {}) {
     const where = labels.file && labels.name ? `${labels.file}: role '${labels.name}' ` : '';
     if (defMonitor !== undefined && !isPlainObject(defMonitor))

package/dist/rooms-tasks/add-member.js

@@ -45,9 +45,9 @@ export async function requestMemberAddition(input) {
         }
         const task = getTask(taskId);
         const room = task.room_id && getRoomRecord(task.room_id);
-        if (!room || !['active', 'review'].includes(task.state) || task.terminal_intent || task.blocked || room.state !== 'active'
+        if (!room || !['active', 'review'].includes(task.state) || task.terminal_intent || room.state !== 'active'
             || room.task_id !== taskId || room.room_identity_cid !== task.room_identity_cid)
-            throw new MemberAdditionRejected('Adding an agent requires an active, unblocked task room');
+            throw new MemberAdditionRejected('Adding an agent requires an active task room');
         const roleId = `${taskId.slice(0, 8)}-${r.slot}-1`;
         if (room.member_seats.some(s => s.role_name === roleId))
             throw new MemberAdditionRejected('This member slot already exists');

package/dist/rooms-tasks/provision.js

@@ -379,9 +379,9 @@ export async function provisionMembers(input) {
         if (input.append) {
             const task = input.taskId ? getTask(input.taskId) : undefined;
             const room = getRoomRecord(input.roomId);
-            if (!task || !['active', 'review'].includes(task.state) || task.blocked || room?.state !== 'active'
+            if (!task || !['active', 'review'].includes(task.state) || room?.state !== 'active'
                 || room.task_id !== task.task_id || room.room_identity_cid !== task.room_identity_cid)
-                throw new Error('Adding an agent requires the exact active, unblocked task room');
+                throw new Error('Adding an agent requires the exact active task room');
             const names = expandMembers(input.template, shortId(task.task_id)).map(m => m.name);
             if (room.member_seats.some(seat => names.includes(seat.role_name)))
                 throw new Error('Member slot is already recorded; inspect its existing launch');

package/dist/runner.js

@@ -8,7 +8,7 @@ import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
 import { parse } from 'yaml';
 import { agentDir, stateRoot } from './paths.js';
-import { loadConfig, findRole, isolationContextFor, resolveMonitorConfig, resolvePermissions, } from './config.js';
+import { loadConfig, findRole, isolationContextFor, resolveSnapshotMonitor, resolvePermissions, } from './config.js';
 import { getAdapter } from './harness/registry.js';
 import { createMonitor, probeIdentityPresence, } from './monitor.js';
 import { DaemonGenerationObserver, RoleRecoveryController, probeDaemonGeneration, } from './daemon-recovery.js';
@@ -432,12 +432,9 @@ export function loadTempRole(name) {
         throw new Error(`temp role '${name}' has no snapshot at ${p}`);
     const role = parse(readFileSync(p, 'utf8'));
     // Upgrade snapshots written before monitor.mode/interrupt existed. A snapshot
-    // with no monitor block keeps the historical native/no-supervisor behavior,
-    // and one without interrupt keeps the non-interrupting delivery it ran with.
+    // with no monitor block keeps the historical native/no-supervisor behavior.
     if (role.monitor)
-        role.monitor = resolveMonitorConfig(undefined, {
-            interrupt: false, ...role.monitor,
-        });
+        role.monitor = resolveSnapshotMonitor(role.monitor);
     role.__temp = true;
     return role;
 }
@@ -629,6 +626,16 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         let unsubscribeRecovery;
         let monitorLoop;
         let sessionStartupComplete = false;
+        let startupRecoveryAllowed = false;
+        let successfulTurnObserved = false;
+        let monitorMayStart = false;
+        let monitorStarted = false;
+        const startMonitorAfterStartup = () => {
+            if (!monitorStarted && monitorMayStart && sessionStartupComplete && !deps.shouldStop?.()) {
+                monitorStarted = true;
+                monitorLoop = monitor?.run(pid);
+            }
+        };
         let sessionClosed = false;
         let ownerChannel;
         let ownerBinder;
@@ -657,13 +664,23 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             pid = agentSession.pid;
             arbiter = new RoleTurnArbiter(agentSession);
             sessionHandle = arbiter;
-            unsubscribeRecovery = agentSession.subscribe(event => {
+            const unsubscribeFailure = agentSession.subscribe(event => {
                 if (event.kind !== 'error' || !event.text || event.origin?.kind === 'stall-watchdog')
                     return;
                 const evidence = classifyFailureText(event.text, sessionBackend, new Date(deps.now()).toISOString());
                 if (evidence)
                     resolvedMonitorDeps.onFailureEvidence?.(evidence);
             });
+            const unsubscribeStartup = agentSession.subscribeConversation?.(event => {
+                if (event.kind !== 'turn.completed' || !('outcome' in event.payload) || event.payload.outcome !== 'completed')
+                    return;
+                successfulTurnObserved = true;
+                if (startupRecoveryAllowed) {
+                    sessionStartupComplete = true;
+                    startMonitorAfterStartup();
+                }
+            });
+            unsubscribeRecovery = () => { unsubscribeFailure(); unsubscribeStartup?.(); };
             if (role.owner_channel) {
                 try {
                     ownerBinder = await deps.acquireOwnerBinder(dir, name, role.owner_channel.identity);
@@ -742,10 +759,8 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 // refusal or a cancellation reached the agent and was not acted on, so
                 // the monitor must keep its cursor and try again.
                 submit: async (text, options) => {
-                    // Cancelling the runner-owned startup prompt makes startup look failed
-                    // and closes the session before the wake turn can run. During startup,
-                    // steer into the live turn instead; after it completes, honor the
-                    // configured interrupt policy normally.
+                    // Delivery starts after the protected startup turn succeeds. Honor the
+                    // configured interrupt policy for subsequent turns.
                     const policy = options?.interrupt;
                     const interrupt = policy === true && sessionStartupComplete;
                     const promptOptions = {
@@ -753,8 +768,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                         ...(interrupt ? { interruptSource: 'fleet-monitor' } : {}),
                         origin: { kind: 'fleet-monitor' },
                     };
-                    // Startup is already a protected boundary: as with immediate mode,
-                    // steer rather than waiting on/cancelling the runner-owned first turn.
+                    // after_tool waits for a safe boundary in subsequent active turns.
                     const result = policy === 'after_tool' && sessionStartupComplete
                         ? await arbiter.submitPromptAfterTool(text, promptOptions)
                         : await arbiter.submitPrompt(text, promptOptions);
@@ -790,10 +804,8 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             // startup prompt and then refuses it has not started; logging the role as
             // up would hide a role that never read its briefing.
             const starting = arbiter.submitPrompt(firstPrompt, { origin: { kind: 'startup' } });
-            // Monitoring starts immediately. The delivery adapter above downgrades
-            // interruption to steering until this startup turn reaches a terminal
-            // success, so there is neither a deaf gap nor a boot-cancellation loop.
-            monitorLoop = monitor?.run(pid);
+            // Keep the early cursor baseline; do not deliver wakes into the protected
+            // first turn. Steering can pre-empt startup just like cancellation.
             // Owner traffic and agent replies must be observed during a long first
             // turn. Ordinary owner input steers until startup has proved successful.
             if (ownerChannel) {
@@ -853,7 +865,8 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             else if (interruptedForWake)
                 deps.log(`[${name}] ${sessionLabel} startup prompt cancelled by ${started.cancellationSource}; `
                     + 'keeping temporary supervisor alive');
-            sessionStartupComplete = true;
+            startupRecoveryAllowed = interruptedForWake;
+            sessionStartupComplete = started.succeeded || (interruptedForWake && successfulTurnObserved);
             reloadLoopConfig = async () => {
                 const nextRole = findRole(loadConfig(configPath), name);
                 const definitions = nextRole.loops ?? [];
@@ -910,9 +923,10 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             }
         }
         deps.log(`[${name}] up; pid=${pid} cwd=${runCwd} harness=${role.harness} session=${sessionBackend} mode=${mode}`);
-        // The monitor loop lives exactly as long as the session: it starts once the
-        // pane pid is known and is stopped when that pid dies (task dies with runner).
-        monitorLoop ??= monitor?.run(pid);
+        // Keep arrivals behind the early prime() cursor; never re-prime at startup.
+        // Recoverable cancellation preserves the supervisor, not monitor readiness.
+        monitorMayStart = true;
+        startMonitorAfterStartup();
         recoveryController = new RoleRecoveryController({
             role: name, identity: role.identity, stateDir: dir, now: deps.now, sleep: deps.sleep,
             log: deps.log,
@@ -1031,6 +1045,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 }
             }
         }
+        monitorMayStart = false;
         if (loopManager) {
             control?.setLoopManager(undefined);
             await loopManager.stop();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.2.0-nightly.40",
+  "version": "1.2.0-nightly.42",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, managed native/ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",