@ours.network/fleet 2.0.1 → 2.0.3

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "2.0.1",
-  "buildId": "a95d59036b13",
-  "commit": "c69e410496f65f9526084899a70fcd3e7d1967cf",
+  "version": "2.0.3",
+  "buildId": "495dcfb38c4e",
+  "commit": "6bc5bab0c0b088acd40d1a79fe5244730dde4708",
   "dirty": false,
-  "builtAt": "2026-10-22T09:52:14.193Z",
+  "builtAt": "2026-10-23T08:54:42.810Z",
   "capabilities": [
     "service.refresh-v1",
     "managed-cli.codex-reasoning-effort-v1",

package/dist/session/acp.d.ts

@@ -264,6 +264,14 @@ export declare class AcpSession implements AgentSession {
      * session/cancel and never resolves a pending permission.
      */
     submitPromptAfterTool(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
+    /**
+     * Start a wake as a turn this client owns when none is running. Steering an
+     * idle adapter starts a turn only the adapter knows about: its stopReason
+     * never reaches Fleet, so an interrupt could cancel it but never see it
+     * settle, and the role stayed `running` for the whole occupancy lease. Like
+     * a steered start, the caller learns only that the turn began.
+     */
+    private startOwnedWake;
     /**
      * Accept responsibility for a prompt, then return. The turn itself may run
      * for minutes behind other queued turns; making an interactive caller wait
@@ -329,6 +337,12 @@ export declare class AcpSession implements AgentSession {
     interruptPrompt(generation: string, promptId: string): Promise<InterruptOutcome>;
     interrupt(source?: TurnCancellationSource): Promise<InterruptOutcome>;
     private cancelActive;
+    /**
+     * Restart a cancelled adapter whose turn cannot be seen to settle. The child
+     * exit releases any steering lease and the runner resumes the context; the
+     * returned error is the caller's typed `forced` outcome.
+     */
+    private forceCancellationRecovery;
     /**
      * Do not admit work behind a turn whose adapter may already require restart.
      * A cooperative adapter settles this promise immediately through runPrompt's

package/dist/session/acp.js

@@ -658,6 +658,16 @@ export class AcpSession {
             return this.submitPrompt(text, { ...options, interrupt: false, steer: false });
         if (this.stallRecoveryClaimed)
             return this.submitPrompt(text, { ...options, interrupt: false, steer: false });
+        if (!this.activeTurn) {
+            try {
+                return (await this.startOwnedWake(text, options)).result;
+            }
+            catch (error) {
+                if (error instanceof SessionControlError)
+                    return turnResult(false, 'failed', error.message);
+                throw error;
+            }
+        }
         const steered = await this.steerPrompt(text);
         if (steered.accepted || steered.detail !== 'ACP steering failed'
             || this.closing || !this.isAlive())
@@ -715,6 +725,18 @@ export class AcpSession {
             safeBoundary: { state, waitedMs, activeToolCount: remainingToolCount },
         };
     }
+    /**
+     * Start a wake as a turn this client owns when none is running. Steering an
+     * idle adapter starts a turn only the adapter knows about: its stopReason
+     * never reaches Fleet, so an interrupt could cancel it but never see it
+     * settle, and the role stayed `running` for the whole occupancy lease. Like
+     * a steered start, the caller learns only that the turn began.
+     */
+    async startOwnedWake(text, options) {
+        const queued = await this.queuePrompt(text, { ...options, interrupt: false, steer: false });
+        void queued.completion.catch(() => undefined);
+        return { queued, result: turnResult(true, 'inconclusive', 'startedNewTurn') };
+    }
     /**
      * Accept responsibility for a prompt, then return. The turn itself may run
      * for minutes behind other queued turns; making an interactive caller wait
@@ -737,6 +759,10 @@ export class AcpSession {
         // live turn, the extension starts one and acknowledges `startedNewTurn`
         // immediately; a normal session/prompt would keep the monitor blocked until
         // the entire wake-triggered turn terminated.
+        if (options.steer && this.steeringSupported && !this.activeTurn) {
+            const { queued, result } = await this.startOwnedWake(text, options);
+            return { ...queued, completion: Promise.resolve(result), ...(delivery ? { delivery } : {}) };
+        }
         if (options.steer && this.steeringSupported) {
             const promptId = randomUUID();
             return {
@@ -986,6 +1012,48 @@ export class AcpSession {
             active.cancellationWait ??= this.awaitCancellationSettlement(active);
             await active.cancellationWait;
         }
+        else if (!active && this.steeringOccupied) {
+            // Steering raced the end of an owned turn and started one only the
+            // adapter knows about. Nothing will report its end, so no interrupt can
+            // see it settle; a resumed adapter restart does end it.
+            throw this.forceCancellationRecovery(undefined, 'steering-started ACP turn cannot report its cancellation');
+        }
+    }
+    /**
+     * Restart a cancelled adapter whose turn cannot be seen to settle. The child
+     * exit releases any steering lease and the runner resumes the context; the
+     * returned error is the caller's typed `forced` outcome.
+     */
+    forceCancellationRecovery(active, reason) {
+        const error = new SessionControlError('control-unavailable', 'ACP adapter restart is in progress after the cancellation deadline', ACP_CANCEL_DEADLINE_EXCEEDED);
+        if (this.cancelRecoveryReason)
+            return error;
+        this.cancelRecoveryReason = ACP_CANCEL_DEADLINE_EXCEEDED;
+        this.readiness = 'failed';
+        this.lastError = `${ACP_CANCEL_DEADLINE_EXCEEDED}: ${reason}`;
+        this.options.log(`[${this.options.name}] ${this.lastError}; restarting adapter with resume`);
+        this.events.emit('error', {
+            turnId: active?.id, origin: active?.origin, status: ACP_CANCEL_DEADLINE_EXCEEDED,
+            text: this.lastError,
+        });
+        this.conversation.appendSafe({
+            kind: 'session.state', sessionGeneration: this.sessionGeneration,
+            acpSessionId: this.sessionId,
+            ...(active ? { promptId: active.id, turnId: active.id } : {}),
+            payload: { status: 'failed', detail: this.lastError },
+        });
+        this.observation.publish();
+        this.child.kill('SIGTERM');
+        const terminateMs = this.options.cancelTerminateGraceMs ?? CANCEL_TERMINATE_GRACE_MS;
+        this.cancelForceKill = setTimeout(() => {
+            if (this.child.exitCode === null) {
+                this.options.log(`[${this.options.name}] ${ACP_CANCEL_DEADLINE_EXCEEDED}: `
+                    + `adapter ignored SIGTERM for ${terminateMs}ms; sending SIGKILL`);
+                this.child.kill('SIGKILL');
+            }
+        }, terminateMs);
+        this.cancelForceKill.unref?.();
+        return error;
     }
     /**
      * Do not admit work behind a turn whose adapter may already require restart.
@@ -1010,31 +1078,7 @@ export class AcpSession {
                     return;
                 }
                 active.cancellationDeadlineExceeded = true;
-                this.cancelRecoveryReason = ACP_CANCEL_DEADLINE_EXCEEDED;
-                this.readiness = 'failed';
-                this.lastError = `${ACP_CANCEL_DEADLINE_EXCEEDED}: ACP turn did not settle within ${settleMs}ms`;
-                this.options.log(`[${this.options.name}] ${this.lastError}; restarting adapter with resume`);
-                this.events.emit('error', {
-                    turnId: active.id, origin: active.origin, status: ACP_CANCEL_DEADLINE_EXCEEDED,
-                    text: this.lastError,
-                });
-                this.conversation.appendSafe({
-                    kind: 'session.state', sessionGeneration: this.sessionGeneration,
-                    acpSessionId: this.sessionId,
-                    promptId: active.id, turnId: active.id,
-                    payload: { status: 'failed', detail: this.lastError },
-                });
-                this.child.kill('SIGTERM');
-                const terminateMs = this.options.cancelTerminateGraceMs ?? CANCEL_TERMINATE_GRACE_MS;
-                this.cancelForceKill = setTimeout(() => {
-                    if (this.child.exitCode === null) {
-                        this.options.log(`[${this.options.name}] ${ACP_CANCEL_DEADLINE_EXCEEDED}: `
-                            + `adapter ignored SIGTERM for ${terminateMs}ms; sending SIGKILL`);
-                        this.child.kill('SIGKILL');
-                    }
-                }, terminateMs);
-                this.cancelForceKill.unref?.();
-                reject(new SessionControlError('control-unavailable', 'ACP adapter restart is in progress after the cancellation deadline', ACP_CANCEL_DEADLINE_EXCEEDED));
+                reject(this.forceCancellationRecovery(active, `ACP turn did not settle within ${settleMs}ms`));
             }, settleMs);
             this.cancelEscalation.unref?.();
         });

package/dist/session/control.d.ts

@@ -121,6 +121,8 @@ export declare class RoleControlServer {
     private readonly sockets;
     /** Interrupt idempotency: same command id returns the first receipt. */
     private readonly interruptCommands;
+    /** A Stop retried while its first attempt is settling joins that attempt instead of cancelling the next turn. */
+    private readonly interruptsInFlight;
     private correspondence?;
     setCorrespondence(value: SupervisorCorrespondence): void;
     private ownerChannel?;

package/dist/session/control.js

@@ -118,6 +118,8 @@ export class RoleControlServer {
     sockets = new Set();
     /** Interrupt idempotency: same command id returns the first receipt. */
     interruptCommands = new Map();
+    /** A Stop retried while its first attempt is settling joins that attempt instead of cancelling the next turn. */
+    interruptsInFlight = new Map();
     correspondence;
     setCorrespondence(value) { this.correspondence = value; }
     ownerChannel;
@@ -602,17 +604,21 @@ export class RoleControlServer {
                         this.write(socket, { version: 1, id: request.id, ok: true, result: existing });
                         return;
                     }
-                    const outcome = await interruptSession(this.session, 'local-console');
-                    const receipt = {
-                        accepted: true, commandId: request.commandId, at: new Date().toISOString(),
-                        ...outcome,
-                    };
-                    this.interruptCommands.set(request.commandId, receipt);
-                    if (this.interruptCommands.size > 200) {
-                        const oldest = this.interruptCommands.keys().next().value;
-                        this.interruptCommands.delete(oldest);
+                    const commandId = request.commandId;
+                    let attempt = this.interruptsInFlight.get(commandId);
+                    if (!attempt) {
+                        attempt = interruptSession(this.session, 'local-console').then(outcome => {
+                            const receipt = { accepted: true, commandId, at: new Date().toISOString(), ...outcome };
+                            this.interruptCommands.set(commandId, receipt);
+                            if (this.interruptCommands.size > 200) {
+                                const oldest = this.interruptCommands.keys().next().value;
+                                this.interruptCommands.delete(oldest);
+                            }
+                            return receipt;
+                        }).finally(() => this.interruptsInFlight.delete(commandId));
+                        this.interruptsInFlight.set(commandId, attempt);
                     }
-                    this.write(socket, { version: 1, id: request.id, ok: true, result: receipt });
+                    this.write(socket, { version: 1, id: request.id, ok: true, result: await attempt });
                     return;
                 }
                 case 'respond_permission_v2': {

package/package.json

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