@ours.network/fleet 0.17.7 → 0.17.9

package/dist/session/acp.d.ts

@@ -1,5 +1,6 @@
 import * as acp from '@agentclientprotocol/sdk';
 import type { CommonPermissions } from '../config.js';
+import type { AcpMcpServer } from '../harness/types.js';
 import { ConversationEventStore } from './conversation-store.js';
 import type { ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
 import type { ConversationHandlePage, ExitRecord, InterruptOutcome, QueuedPrompt, SessionEvent, RuntimeSelectorMetadata, SessionHandle, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnOutcome, TurnResult } from './types.js';
@@ -37,6 +38,20 @@ export interface AcpSessionOptions {
     permissionMode?: NonNullable<SessionSnapshot['permissionMode']>;
     /** Adapter-authenticated request-metadata vocabulary; never inferred from ACP `_meta`. */
     permissionMetadataSource?: 'codex-acp';
+    /**
+     * MCP servers the ROLE declares, for every session/new, resume and load. Empty
+     * or omitted sends `[]`, which is what fleet has always sent and leaves the
+     * agent's own configuration untouched.
+     */
+    mcpServers?: AcpMcpServer[];
+    /**
+     * Adapter-supplied `_meta` for session/new — the only route by which a
+     * capability the CLI takes as a flag reaches an agent that accepts none.
+     * Per-agent vocabulary, so the ADAPTER decides whether there is anything to
+     * send; this layer only forwards it. Never sent on resume or load: it carries
+     * session-creation options the agent has already applied.
+     */
+    sessionMeta?: Record<string, unknown>;
     log(line: string): void;
     /** Test seam for the cancel-escalation grace period; production uses the default. */
     cancelGraceMs?: number;
@@ -172,6 +187,28 @@ export declare class AcpSession implements SessionHandle {
      * for it is what turned a busy agent into a timeout and then into "dead".
      */
     queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
+    /**
+     * Prepare the session for a prompt that asked to pre-empt current work.
+     *
+     * The old behaviour was one unconditional `session/cancel` notification
+     * followed immediately by `session/prompt`. That is what produced the owner's
+     * "request failed before completion":
+     *
+     *  - `cancelActive` only awaits settlement when `this.activeTurn` is set, and
+     *    a turn the ADAPTER started (steering's `startedNewTurn`) is never tracked
+     *    here. So the cancel raced the adapter's own transcript repair and the new
+     *    prompt landed while the last assistant message still held an unresolved
+     *    `tool_use` — rejected with `stop_reason=tool_use`.
+     *  - With nothing running at all, it still sent the cancel, and the prompt
+     *    landed on a bare interrupted user message — rejected with
+     *    `stop_reason=null`.
+     *
+     * So: never cancel across a tool boundary, and never cancel something whose
+     * settlement cannot be awaited. Everything else is queued, which the ACP queue
+     * already does correctly. The returned state is what the caller may claim to a
+     * human — `interrupted` only when a turn really was cancelled.
+     */
+    private prepareInterruptingDelivery;
     /**
      * Durably record a prompt admission BEFORE acceptance is returned. Browser
      * admissions are transactional — a prompt the ledger cannot hold is refused,
@@ -219,6 +256,15 @@ export declare class AcpSession implements SessionHandle {
     private settlePendingAutomatically;
     exitResult(): ExitRecord | null;
     close(): Promise<void>;
+    /**
+     * The role's declared MCP servers, or `[]`.
+     *
+     * Sent on resume and load as well as on new: the agent builds its server set
+     * once per session, so a resumed session that omitted them would come back
+     * without the tools the role's config declares — which is exactly the shape of
+     * silent drop this plumbing exists to end.
+     */
+    private declaredMcpServers;
     private initialize;
     private captureRuntimeMetadata;
     private runPrompt;

package/dist/session/acp.js

@@ -598,15 +598,19 @@ export class AcpSession {
             throw new SessionControlError('control-unavailable', 'ACP adapter restart is in progress after the cancellation deadline', ACP_CANCEL_DEADLINE_EXCEEDED);
         if (this.closing || !this.sessionId || !this.isAlive())
             throw new SessionControlError('offline', this.lastError ?? 'ACP session is offline');
-        if (options.interrupt)
-            await this.cancelActive(options.interruptSource ?? 'local-console');
+        const delivery = options.interrupt
+            ? await this.prepareInterruptingDelivery(options.interruptSource ?? 'local-console')
+            : undefined;
         // Interrupting delivery must still use steering when supported. With no
         // 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) {
             const promptId = randomUUID();
-            return { promptId, queuedBehind: 0, completion: this.steerPrompt(text), origin: options.origin };
+            return {
+                promptId, queuedBehind: 0, completion: this.steerPrompt(text), origin: options.origin,
+                ...(delivery ? { delivery } : {}),
+            };
         }
         const promptId = randomUUID();
         const queuedBehind = this.queueDepth;
@@ -618,7 +622,46 @@ export class AcpSession {
             this.queueDepth = Math.max(0, this.queueDepth - 1);
             return turnResult(false, 'failed', error?.message ?? String(error));
         });
-        return { promptId, queuedBehind, completion, origin: options.origin };
+        return {
+            promptId, queuedBehind, completion, origin: options.origin,
+            delivery: delivery ?? (queuedBehind > 0 ? 'queued' : 'started'),
+        };
+    }
+    /**
+     * Prepare the session for a prompt that asked to pre-empt current work.
+     *
+     * The old behaviour was one unconditional `session/cancel` notification
+     * followed immediately by `session/prompt`. That is what produced the owner's
+     * "request failed before completion":
+     *
+     *  - `cancelActive` only awaits settlement when `this.activeTurn` is set, and
+     *    a turn the ADAPTER started (steering's `startedNewTurn`) is never tracked
+     *    here. So the cancel raced the adapter's own transcript repair and the new
+     *    prompt landed while the last assistant message still held an unresolved
+     *    `tool_use` — rejected with `stop_reason=tool_use`.
+     *  - With nothing running at all, it still sent the cancel, and the prompt
+     *    landed on a bare interrupted user message — rejected with
+     *    `stop_reason=null`.
+     *
+     * So: never cancel across a tool boundary, and never cancel something whose
+     * settlement cannot be awaited. Everything else is queued, which the ACP queue
+     * already does correctly. The returned state is what the caller may claim to a
+     * human — `interrupted` only when a turn really was cancelled.
+     */
+    async prepareInterruptingDelivery(source) {
+        if (!this.sessionId)
+            return 'started';
+        // No fleet-tracked turn to await. Either the session is idle — cancelling it
+        // corrupts the transcript for no gain — or the adapter is running a turn
+        // fleet never started, whose settlement nothing here can wait for. Queue in
+        // both cases: the ACP queue already orders this correctly.
+        if (!this.activeTurn)
+            return this.activeToolCalls.size > 0 ? 'deferred' : 'started';
+        // A tracked turn IS safe to cancel: cancelActive settles pending permissions
+        // and awaits the turn's own settlement before this returns, so the prompt
+        // below cannot race the adapter's transcript repair.
+        await this.cancelActive(source);
+        return 'interrupted';
     }
     /**
      * Durably record a prompt admission BEFORE acceptance is returned. Browser
@@ -945,6 +988,17 @@ export class AcpSession {
         });
         this.conversation.close();
     }
+    /**
+     * The role's declared MCP servers, or `[]`.
+     *
+     * Sent on resume and load as well as on new: the agent builds its server set
+     * once per session, so a resumed session that omitted them would come back
+     * without the tools the role's config declares — which is exactly the shape of
+     * silent drop this plumbing exists to end.
+     */
+    declaredMcpServers() {
+        return this.options.mcpServers ?? [];
+    }
     async initialize() {
         const initialized = await this.connection.agent.request(acp.methods.agent.initialize, {
             protocolVersion: acp.PROTOCOL_VERSION,
@@ -964,7 +1018,7 @@ export class AcpSession {
             const resumed = await this.connection.agent.request(acp.methods.agent.session.resume, {
                 sessionId: persisted,
                 cwd: this.options.cwd,
-                mcpServers: [],
+                mcpServers: this.declaredMcpServers(),
             });
             this.captureRuntimeMetadata(resumed.configOptions);
             this.sessionId = persisted;
@@ -977,7 +1031,7 @@ export class AcpSession {
                 const loaded = await this.connection.agent.request(acp.methods.agent.session.load, {
                     sessionId: persisted,
                     cwd: this.options.cwd,
-                    mcpServers: [],
+                    mcpServers: this.declaredMcpServers(),
                 });
                 this.captureRuntimeMetadata(loaded.configOptions);
             }
@@ -989,7 +1043,8 @@ export class AcpSession {
         else {
             const created = await this.connection.agent.request(acp.methods.agent.session.new, {
                 cwd: this.options.cwd,
-                mcpServers: [],
+                mcpServers: this.declaredMcpServers(),
+                ...(this.options.sessionMeta ? { _meta: this.options.sessionMeta } : {}),
             });
             this.sessionId = created.sessionId;
             this.captureRuntimeMetadata(created.configOptions);

package/dist/session/types.d.ts

@@ -110,6 +110,15 @@ export declare function interruptOutcome(result: InterruptResult): InterruptOutc
  * stop here: the session has the prompt, and waiting for the turn to finish is
  * a different question with a different, much longer, timescale.
  */
+/**
+ * What actually happened to an admitted prompt, so a caller reporting to a
+ * human can be accurate instead of repeating what it asked for.
+ *
+ * `interrupted` is only ever returned when a turn was really cancelled for this
+ * prompt. `deferred` says the session is busy with work this prompt could not
+ * safely pre-empt — the prompt is admitted and will run, just not yet.
+ */
+export type PromptDelivery = 'started' | 'queued' | 'interrupted' | 'deferred';
 export interface QueuedPrompt {
     promptId: string;
     /** Turns already queued ahead of this one. 0 means it starts immediately. */
@@ -117,6 +126,8 @@ export interface QueuedPrompt {
     origin?: PromptOrigin;
     /** The turn's terminal result. Never rejects. */
     completion: Promise<TurnResult>;
+    /** Observed admission outcome. Absent on backends that do not report it. */
+    delivery?: PromptDelivery;
 }
 /**
  * How a session's process ended.

package/dist/spawn.js

@@ -224,7 +224,7 @@ export function spawnDryRun(o) {
     const adapter = getAdapter(resolvedRole.harness);
     if (resolvedRole.auth_proxy && resolvedRole.harness !== 'claude-code')
         throw new Error('auth_proxy is supported only by claude-code');
-    const optionProblems = adapter.validateOptions(resolvedRole.harness_options);
+    const optionProblems = adapter.validateOptions(resolvedRole.harness_options, resolvedRole);
     if (optionProblems.length)
         throw new Error(optionProblems.map(problem => `${problem.path}: ${problem.message}`).join('; '));
     return {

package/package.json

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