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

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.41",
-  "buildId": "aa7ed657a14a",
-  "commit": "bbdc34de495026f1119ce9df3442a787d8d02dc0",
+  "version": "1.2.0-nightly.42",
+  "buildId": "536c9cc8b8d7",
+  "commit": "c51b38eaa547d240e97f776e09286590222e727e",
   "dirty": true,
-  "builtAt": "2026-10-03T12:50:11.407Z",
+  "builtAt": "2026-10-03T20:14:35.466Z",
   "capabilities": [
     "workspace.enroll.preserve-profile-v1",
     "cowork.http-management-v1",

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

@@ -626,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;
@@ -654,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);
@@ -739,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 = {
@@ -750,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);
@@ -787,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) {
@@ -850,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 ?? [];
@@ -907,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,
@@ -1028,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.41",
+  "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",