@borgee/agents-host 0.2.94 → 0.2.97

package/dist/progress-to-activity.d.ts

@@ -1,8 +1,8 @@
 import type { AgentActivity } from './plugin-sdk.js';
 import type { ProviderProgressUpdate } from './types.js';
-/** Everything a provider reports. The turn boundary is the reporter's own and never arrives here. */
-export type ReportedActivity = Exclude<AgentActivity, {
-    shape: 'turn' | 'background_run';
+/** Absolute provider state accepted by the foreground activity coalescer. */
+export type ReportedActivity = Extract<AgentActivity, {
+    shape: 'activity' | 'plan' | 'output';
 }>;
 /**
  * Restates one progress update in the rail's own vocabulary.

package/dist/providers/claude/adapter.d.ts

@@ -1,5 +1,5 @@
 import { type ProviderAdapter } from '../provider-adapter.js';
-import type { ProviderGenerateOptions, ProviderInput, ProviderReply } from '../../types.js';
+import type { ProviderAutonomousReply, ProviderGenerateOptions, ProviderInput, ProviderReply } from '../../types.js';
 import { ProviderTurnPreparer } from '../../context/turn-preparation.js';
 import { ClaudeCliClient } from './cli-client.js';
 export declare const CLAUDE_HOSTED_PROVIDER_CAPABILITIES: import("../provider-adapter.js").ProviderCapabilities;
@@ -10,6 +10,7 @@ export declare class ClaudeProviderAdapter implements ProviderAdapter {
     readonly cancelBackgroundRun?: (channelId: string, providerRunId: string) => Promise<boolean>;
     constructor(cli: ClaudeCliClient, turnPreparer: Pick<ProviderTurnPreparer, 'prepare'>);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
+    onAutonomousReply(handler: ((reply: ProviderAutonomousReply) => void) | undefined): void;
     cancelTurn(channelId: string): Promise<boolean>;
     dispose(): Promise<void>;
 }

package/dist/providers/claude/adapter.js

@@ -60,6 +60,16 @@ export class ClaudeProviderAdapter {
         // session as it runs, so before this point there is nothing to report.
         return { ...parseProviderReply(text), sessionId: this.cli.sessionIdForChannel(input.channelId) };
     }
+    onAutonomousReply(handler) {
+        this.cli.onAutonomousReply(handler
+            ? (reply) => {
+                const parsed = parseProviderReply(reply.text);
+                if (parsed.text.trim()) {
+                    handler({ ...reply, text: parsed.text });
+                }
+            }
+            : undefined);
+    }
     async cancelTurn(channelId) {
         return this.cli.cancelTurn(channelId);
     }

package/dist/providers/claude/cli-client.d.ts

@@ -1,7 +1,7 @@
 import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream } from '@agentclientprotocol/sdk';
 import { type DebugLogger } from '../../debug.js';
-import type { PreparedProviderTurnInput, ProviderGenerateOptions } from '../../types.js';
+import type { PreparedProviderTurnInput, ProviderAutonomousReply, ProviderGenerateOptions } from '../../types.js';
 import type { ClaudeChannelSessionStore } from './session-store.js';
 interface ClaudeAcpRuntime {
     spawn: typeof spawn;
@@ -78,9 +78,11 @@ export declare class ClaudeCliClient {
     private sessionStoreWriteQueue;
     private sessionCapabilities;
     private targetedBackgroundRunCancellationAvailable;
+    private autonomousReplyHandler?;
     private readonly idleBackendShutdown;
     private childStderr;
     constructor(command: string, args?: string[], runtimeOverrides?: Partial<ClaudeAcpRuntime>, sessionStore?: ClaudeChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger, imageInputConfig?: ClaudeHostedImageInputConfig);
+    onAutonomousReply(handler: ((reply: ProviderAutonomousReply) => void) | undefined): void;
     generateReply(turn: PreparedProviderTurnInput, options?: ProviderGenerateOptions): Promise<string>;
     generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
     dispose(): Promise<void>;

package/dist/providers/claude/cli-client.js

@@ -18,17 +18,26 @@ import { buildClaudeSessionPromptAppend } from '../../context/prompt.js';
 import { isDiscussionOnlyResolvedWorkingFolder } from '../../context/resolved-working-folder.js';
 import { IDLE_BACKEND_SHUTDOWN_DISABLED_MS, IdleBackendShutdownScheduler, } from '../idle-backend-shutdown.js';
 import { CLAUDE_TASK_CANCELLATION_METHOD, supportsClaudeTaskCancellation, } from './task-cancellation-protocol.js';
+const BACKGROUND_COMPLETION_SIGNAL_TTL_MS = 30_000;
+const MAX_BACKGROUND_COMPLETION_SIGNALS = 32;
+const AUTONOMOUS_REPLY_IDLE_FLUSH_MS = 100;
 class ClaudeSessionUpdatePump {
     session;
     onFailure;
+    autonomousEvents;
     onForegroundSettledWithBackground;
     observer;
     activeTurn;
+    autonomousTurns = new Map();
+    backgroundCompletionSignals = [];
+    backgroundCompletionSignalExpiry;
+    autonomousTurnPending = false;
     closed = false;
     failure;
-    constructor(session, onFailure, onBackgroundTasksActiveChanged, onForegroundSettledWithBackground, targetedCancellationSupported) {
+    constructor(session, onFailure, onBackgroundTasksActiveChanged, autonomousEvents, onForegroundSettledWithBackground, targetedCancellationSupported) {
         this.session = session;
         this.onFailure = onFailure;
+        this.autonomousEvents = autonomousEvents;
         this.onForegroundSettledWithBackground = onForegroundSettledWithBackground;
         this.observer = new ClaudeBackgroundRunObserver(undefined, {
             onBackgroundTasksActiveChanged,
@@ -49,6 +58,7 @@ class ClaudeSessionUpdatePump {
         const turn = {
             queue: [],
             foregroundIsolationFence,
+            ownedForegroundTurn: this.resolveForegroundTurn(foregroundIsolationFence),
         };
         this.activeTurn = turn;
         this.observer.setOnProgress(onProgress);
@@ -85,9 +95,199 @@ class ClaudeSessionUpdatePump {
         }
         this.closed = true;
         this.observer.dispose();
+        if (this.backgroundCompletionSignalExpiry) {
+            clearTimeout(this.backgroundCompletionSignalExpiry);
+            this.backgroundCompletionSignalExpiry = undefined;
+        }
+        this.backgroundCompletionSignals.length = 0;
+        for (const turn of this.autonomousTurns.values()) {
+            if (turn.flushTimer) {
+                clearTimeout(turn.flushTimer);
+            }
+            if (turn.discardTimer) {
+                clearTimeout(turn.discardTimer);
+            }
+        }
+        this.autonomousTurns.clear();
+        this.refreshAutonomousTurnPresence();
         const turn = this.activeTurn;
         this.activeTurn = undefined;
-        turn?.waiter?.reject(new Error('Claude ACP session update pump is closed'));
+        turn?.waiter?.reject(new Error('Claude ACP session update stream is closed'));
+    }
+    resolveForegroundTurn(foregroundIsolationFence) {
+        const nextForegroundTurn = foregroundIsolationFence === undefined ? 1 : foregroundIsolationFence + 1;
+        return Number.isSafeInteger(nextForegroundTurn) && nextForegroundTurn > 0
+            ? nextForegroundTurn
+            : undefined;
+    }
+    autonomousTurnFor(foregroundTurn) {
+        let turn = this.autonomousTurns.get(foregroundTurn);
+        if (turn) {
+            return turn;
+        }
+        turn = {
+            eventId: `claude-background-${foregroundTurn}`,
+            confirmed: false,
+            text: '',
+        };
+        this.autonomousTurns.set(foregroundTurn, turn);
+        return turn;
+    }
+    noteBackgroundCompletionSignal(foregroundTurn, eventId) {
+        const turn = this.autonomousTurnFor(foregroundTurn);
+        if (turn.discardTimer) {
+            clearTimeout(turn.discardTimer);
+            turn.discardTimer = undefined;
+        }
+        this.pruneBackgroundCompletionSignals();
+        const existingIndex = this.backgroundCompletionSignals.findIndex((signal) => signal.foregroundTurn === foregroundTurn);
+        if (existingIndex >= 0) {
+            this.backgroundCompletionSignals.splice(existingIndex, 1);
+        }
+        this.backgroundCompletionSignals.push({
+            eventId,
+            foregroundTurn,
+            expiresAt: Date.now() + BACKGROUND_COMPLETION_SIGNAL_TTL_MS,
+        });
+        if (this.backgroundCompletionSignals.length > MAX_BACKGROUND_COMPLETION_SIGNALS) {
+            this.backgroundCompletionSignals.splice(0, this.backgroundCompletionSignals.length - MAX_BACKGROUND_COMPLETION_SIGNALS);
+        }
+        this.scheduleBackgroundCompletionSignalExpiry();
+        turn.confirmed = true;
+        turn.eventId = eventId;
+        if (turn.text.trim()) {
+            this.scheduleAutonomousReplyFlush(foregroundTurn, turn);
+        }
+        this.refreshAutonomousTurnPresence();
+        return turn;
+    }
+    consumeAutonomousLifecycle(update) {
+        if (update.update.sessionUpdate !== 'session_info_update') {
+            return;
+        }
+        const provider = asObject(update.update._meta)?.claudeCode;
+        const lifecycle = asObject(asObject(provider)?.taskLifecycle);
+        if (lifecycle?.event !== 'notification' || lifecycle?.status !== 'completed') {
+            return;
+        }
+        const foregroundTurn = asObject(provider)?.foregroundTurn;
+        if (!Number.isSafeInteger(foregroundTurn) || foregroundTurn <= 0) {
+            return;
+        }
+        const taskId = typeof lifecycle.taskId === 'string' ? lifecycle.taskId : 'task';
+        this.noteBackgroundCompletionSignal(foregroundTurn, `${taskId}:completed`);
+    }
+    consumeAutonomousUpdate(update) {
+        if (update.update.sessionUpdate !== 'agent_message_chunk' || update.update.content.type !== 'text') {
+            return;
+        }
+        const provider = asObject(update.update._meta)?.claudeCode;
+        const foregroundTurn = asObject(provider)?.foregroundTurn;
+        if (!Number.isSafeInteger(foregroundTurn) || foregroundTurn <= 0) {
+            return;
+        }
+        const lane = asObject(provider)?.foregroundLane;
+        const activeForegroundTurn = this.activeTurn?.ownedForegroundTurn;
+        if (foregroundTurn === activeForegroundTurn) {
+            return;
+        }
+        if (lane !== 'background' && !this.backgroundCompletionSignals.some((signal) => signal.foregroundTurn === foregroundTurn)) {
+            return;
+        }
+        const turn = this.autonomousTurnFor(foregroundTurn);
+        turn.text += update.update.content.text;
+        if (turn.confirmed) {
+            this.scheduleAutonomousReplyFlush(foregroundTurn, turn);
+        }
+    }
+    scheduleAutonomousReplyFlush(foregroundTurn, turn) {
+        if (turn.flushTimer) {
+            clearTimeout(turn.flushTimer);
+        }
+        turn.flushTimer = setTimeout(() => {
+            turn.flushTimer = undefined;
+            this.flushAutonomousReply(foregroundTurn, turn);
+        }, AUTONOMOUS_REPLY_IDLE_FLUSH_MS);
+        turn.flushTimer.unref?.();
+    }
+    flushAutonomousReply(foregroundTurn, turn) {
+        const text = turn.text.trim();
+        if (turn.confirmed && text) {
+            this.autonomousEvents.onReply?.({
+                eventId: turn.eventId,
+                text,
+            });
+        }
+        else if (turn.confirmed) {
+            turn.discardTimer = setTimeout(() => {
+                turn.discardTimer = undefined;
+                this.discardAutonomousTurn(foregroundTurn, turn);
+            }, BACKGROUND_COMPLETION_SIGNAL_TTL_MS);
+            turn.discardTimer.unref?.();
+            this.refreshAutonomousTurnPresence();
+            return;
+        }
+        this.discardAutonomousTurn(foregroundTurn, turn);
+    }
+    discardAutonomousTurn(foregroundTurn, turn) {
+        if (turn.flushTimer) {
+            clearTimeout(turn.flushTimer);
+            turn.flushTimer = undefined;
+        }
+        if (turn.discardTimer) {
+            clearTimeout(turn.discardTimer);
+            turn.discardTimer = undefined;
+        }
+        if (this.autonomousTurns.get(foregroundTurn) === turn) {
+            this.autonomousTurns.delete(foregroundTurn);
+        }
+        const signalIndex = this.backgroundCompletionSignals.findIndex((signal) => signal.foregroundTurn === foregroundTurn);
+        if (signalIndex >= 0) {
+            this.backgroundCompletionSignals.splice(signalIndex, 1);
+            this.scheduleBackgroundCompletionSignalExpiry();
+            return;
+        }
+        this.refreshAutonomousTurnPresence();
+    }
+    pruneBackgroundCompletionSignals() {
+        const now = Date.now();
+        while (this.backgroundCompletionSignals.length > 0
+            && this.backgroundCompletionSignals[0].expiresAt <= now) {
+            const expired = this.backgroundCompletionSignals.shift();
+            if (!expired) {
+                continue;
+            }
+            const turn = this.autonomousTurns.get(expired.foregroundTurn);
+            if (turn && !turn.text.trim()) {
+                this.discardAutonomousTurn(expired.foregroundTurn, turn);
+            }
+        }
+    }
+    scheduleBackgroundCompletionSignalExpiry() {
+        if (this.backgroundCompletionSignalExpiry) {
+            clearTimeout(this.backgroundCompletionSignalExpiry);
+            this.backgroundCompletionSignalExpiry = undefined;
+        }
+        this.pruneBackgroundCompletionSignals();
+        const next = this.backgroundCompletionSignals[0];
+        if (!next) {
+            this.refreshAutonomousTurnPresence();
+            return;
+        }
+        this.backgroundCompletionSignalExpiry = setTimeout(() => {
+            this.backgroundCompletionSignalExpiry = undefined;
+            this.pruneBackgroundCompletionSignals();
+            this.scheduleBackgroundCompletionSignalExpiry();
+        }, Math.max(0, next.expiresAt - Date.now()));
+        this.backgroundCompletionSignalExpiry.unref?.();
+    }
+    refreshAutonomousTurnPresence() {
+        const pending = this.autonomousTurns.size > 0 || this.backgroundCompletionSignals.length > 0;
+        if (pending === this.autonomousTurnPending) {
+            return;
+        }
+        this.autonomousTurnPending = pending;
+        this.autonomousEvents.onPendingChanged?.(pending);
     }
     async run() {
         try {
@@ -98,8 +298,12 @@ class ClaudeSessionUpdatePump {
                 }
                 const lifecycle = update.kind === 'session_update' && this.observer.consume(update.update);
                 if (lifecycle) {
+                    this.consumeAutonomousLifecycle(update);
                     continue;
                 }
+                if (update.kind === 'session_update') {
+                    this.consumeAutonomousUpdate(update);
+                }
                 if (update.kind === 'session_update'
                     && isClaudeUpdateFromIsolatedTurn(update.update, this.activeTurn?.foregroundIsolationFence)) {
                     continue;
@@ -731,6 +935,7 @@ export class ClaudeCliClient {
     sessionStoreWriteQueue = Promise.resolve();
     sessionCapabilities = DEFAULT_SESSION_CAPABILITIES;
     targetedBackgroundRunCancellationAvailable = false;
+    autonomousReplyHandler;
     idleBackendShutdown;
     childStderr = '';
     constructor(command, args = [], runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined, logger = new HostLogger(), imageInputConfig = {}) {
@@ -759,6 +964,9 @@ export class ClaudeCliClient {
         });
         void this.fatalPromise.catch(() => { });
     }
+    onAutonomousReply(handler) {
+        this.autonomousReplyHandler = handler;
+    }
     async generateReply(channelIdOrTurn, promptOrOptions, maybeOptions) {
         if (this.fatalError) {
             throw this.fatalError;
@@ -790,6 +998,7 @@ export class ClaudeCliClient {
     async dispose() {
         const error = new Error('Claude ACP backend stopped');
         this.disposing = true;
+        this.autonomousReplyHandler = undefined;
         this.idleBackendShutdown.cancel();
         this.logger?.debug('stopping Claude ACP backend');
         const closed = this.connection?.closed ?? Promise.resolve();
@@ -936,6 +1145,7 @@ export class ClaudeCliClient {
                 sessionPersistence,
                 backgroundTasksActive: false,
                 backgroundContinuationPending: false,
+                sessionHasPendingAutonomousTurn: false,
                 persistentFollowUpAdopted: false,
                 processing: false,
                 queue: [],
@@ -1170,8 +1380,10 @@ export class ClaudeCliClient {
             && state.sessionVisibilityKey === state.visibilityKey) {
             return;
         }
-        if (state.backgroundTasksActive || state.backgroundContinuationPending) {
-            throw new Error('Claude session scope cannot change while provider-owned background work is running');
+        if (state.backgroundTasksActive
+            || state.backgroundContinuationPending
+            || state.sessionHasPendingAutonomousTurn) {
+            throw new Error('Claude session scope cannot change while provider-owned background delivery is running');
         }
         this.logger?.debug('recycling Claude ACP session after session scope changed', {
             channelId,
@@ -1183,6 +1395,7 @@ export class ClaudeCliClient {
         state.session = undefined;
         state.backgroundTasksActive = false;
         state.backgroundContinuationPending = false;
+        state.sessionHasPendingAutonomousTurn = false;
         state.foregroundIsolationFence = undefined;
         state.sessionCwd = undefined;
         state.sessionVisibilityKey = undefined;
@@ -1219,6 +1432,40 @@ export class ClaudeCliClient {
                 }
                 this.reconcileIdleChannelState(state);
                 this.idleBackendShutdown.reconcile();
+            }, {
+                onReply: (reply) => {
+                    const binding = [...this.channels.entries()].find(([, candidate]) => candidate.session === session);
+                    if (!binding) {
+                        return;
+                    }
+                    const [, state] = binding;
+                    if (state.session !== session) {
+                        return;
+                    }
+                    this.autonomousReplyHandler?.({
+                        channelId: state.channelId,
+                        eventId: reply.eventId,
+                        text: reply.text,
+                    });
+                },
+                onPendingChanged: (active) => {
+                    const binding = [...this.channels.entries()].find(([, candidate]) => candidate.session === session);
+                    if (!binding) {
+                        return;
+                    }
+                    const [, state] = binding;
+                    if (state.session !== session) {
+                        return;
+                    }
+                    state.sessionHasPendingAutonomousTurn = active;
+                    if (active) {
+                        this.promoteWorkerRoute(state, session);
+                        this.idleBackendShutdown.cancel();
+                        return;
+                    }
+                    this.reconcileIdleChannelState(state);
+                    this.idleBackendShutdown.reconcile();
+                },
             }, (foregroundTurn) => {
                 const binding = [...this.channels.entries()].find(([, candidate]) => candidate.session === session);
                 if (!binding) {
@@ -1270,12 +1517,6 @@ export class ClaudeCliClient {
                     }
                     return output;
                 }
-                const settledForegroundTurn = update.kind === 'session_update'
-                    ? readClaudeForegroundSettledTurn(update.update)
-                    : undefined;
-                if (settledForegroundTurn !== undefined) {
-                    return collector.getFinalText();
-                }
                 if (update.update.sessionUpdate === 'agent_message_chunk' &&
                     update.update.content.type === 'text') {
                     compactionObserver.consumeAnswerChunk(update.update.content.text);
@@ -1315,11 +1556,13 @@ export class ClaudeCliClient {
             state.session = undefined;
             state.backgroundTasksActive = false;
             state.backgroundContinuationPending = false;
+            state.sessionHasPendingAutonomousTurn = false;
             state.foregroundIsolationFence = undefined;
             state.sessionCwd = undefined;
             state.sessionVisibilityKey = undefined;
             state.sessionPromise = undefined;
             state.activeTurn = undefined;
+            state.persistentFollowUpAdopted = false;
             if (!state.processing) {
                 this.channels.delete(channelId);
             }
@@ -1346,9 +1589,11 @@ export class ClaudeCliClient {
             state.session = undefined;
             state.backgroundTasksActive = false;
             state.backgroundContinuationPending = false;
+            state.sessionHasPendingAutonomousTurn = false;
             state.foregroundIsolationFence = undefined;
             state.sessionCwd = undefined;
             state.sessionVisibilityKey = undefined;
+            state.persistentFollowUpAdopted = false;
         }
         this.logger?.debug('discarding tainted Claude ACP session', { channelId });
         this.closeSession(session);
@@ -1370,7 +1615,7 @@ export class ClaudeCliClient {
             if (route?.state !== state
                 || route.phase !== 'promoted'
                 || state.session !== session
-                || (!state.backgroundTasksActive && !state.persistentFollowUpAdopted)) {
+                || (!state.backgroundTasksActive && !state.sessionHasPendingAutonomousTurn && !state.persistentFollowUpAdopted)) {
                 return;
             }
             await this.persistSessionBestEffort(state.channelId, session.sessionId, state.visibilityKey, state.sessionCwd ?? state.cwd ?? this.runtime.cwd);
@@ -1408,7 +1653,8 @@ export class ClaudeCliClient {
         if (route?.state === state
             && route.phase === 'promoted'
             && !state.backgroundTasksActive
-            && !state.backgroundContinuationPending) {
+            && !state.backgroundContinuationPending
+            && !state.sessionHasPendingAutonomousTurn) {
             if (state.routingKey === state.channelId) {
                 this.releaseWorkerRoute(state);
             }
@@ -1425,7 +1671,8 @@ export class ClaudeCliClient {
         }
         if (state.sessionPersistence !== 'ephemeral'
             || state.backgroundTasksActive
-            || state.backgroundContinuationPending) {
+            || state.backgroundContinuationPending
+            || state.sessionHasPendingAutonomousTurn) {
             return;
         }
         const session = state.session;
@@ -1633,9 +1880,11 @@ export class ClaudeCliClient {
             state.session = undefined;
             state.backgroundTasksActive = false;
             state.backgroundContinuationPending = false;
+            state.sessionHasPendingAutonomousTurn = false;
             state.foregroundIsolationFence = undefined;
             state.sessionCwd = undefined;
             state.sessionVisibilityKey = undefined;
+            state.persistentFollowUpAdopted = false;
             this.channels.delete(channelId);
         }
         this.channelWorkerRoutes.clear();
@@ -1670,6 +1919,7 @@ export class ClaudeCliClient {
             if (state.activeTurn ||
                 state.backgroundTasksActive ||
                 state.backgroundContinuationPending ||
+                state.sessionHasPendingAutonomousTurn ||
                 state.queue.length > 0 ||
                 state.sessionPromise ||
                 state.processing) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borgee/agents-host",
-  "version": "0.2.94",
+  "version": "0.2.97",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -38,24 +38,24 @@
     "tsx": "^4.20.5",
     "typescript": "^5.9.3",
     "vitest": "^4.1.5",
-    "@borgee/plugin-sdk": "0.14.1"
+    "@borgee/plugin-sdk": "0.15.0"
   },
   "scripts": {
-    "predev": "pnpm --filter @borgee/plugin-sdk build && pnpm run vendor:claude",
+    "predev": "pnpm --filter @borgee/agent-remote-protocol build && pnpm --filter @borgee/plugin-sdk build && pnpm run vendor:claude",
     "dev": "tsx src/index.ts",
-    "precli": "pnpm --filter @borgee/plugin-sdk build && pnpm run vendor:claude",
+    "precli": "pnpm --filter @borgee/agent-remote-protocol build && pnpm --filter @borgee/plugin-sdk build && pnpm run vendor:claude",
     "cli": "tsx src/cli.ts",
-    "prestart": "pnpm --filter @borgee/plugin-sdk build",
+    "prestart": "pnpm --filter @borgee/agent-remote-protocol build && pnpm --filter @borgee/plugin-sdk build",
     "start": "node dist/index.js",
-    "prebuild": "pnpm --filter @borgee/plugin-sdk build",
+    "prebuild": "pnpm --filter @borgee/agent-remote-protocol build && pnpm --filter @borgee/plugin-sdk build",
     "build": "tsc && node scripts/bundle-plugin-sdk.mjs && node scripts/vendor-claude-acp.mjs",
     "test:package": "node --test --test-timeout=10000 scripts/packed-package-descriptor.test.mjs && pnpm run build && node scripts/test-packed-claude-lifecycle.mjs",
     "typecheck": "tsc --noEmit",
-    "pretest": "pnpm --filter @borgee/plugin-sdk build && pnpm run vendor:claude",
+    "pretest": "pnpm --filter @borgee/agent-remote-protocol build && pnpm --filter @borgee/plugin-sdk build && pnpm run vendor:claude",
     "test": "vitest run --testTimeout=10000",
-    "pretest:e2e": "pnpm --filter @borgee/plugin-sdk build && pnpm run vendor:claude",
+    "pretest:e2e": "pnpm --filter @borgee/agent-remote-protocol build && pnpm --filter @borgee/plugin-sdk build && pnpm run vendor:claude",
     "test:e2e": "vitest run --config vitest.e2e.config.ts --testTimeout=120000",
-    "pretypecheck": "pnpm --filter @borgee/plugin-sdk build",
+    "pretypecheck": "pnpm --filter @borgee/agent-remote-protocol build && pnpm --filter @borgee/plugin-sdk build",
     "vendor:claude": "node scripts/vendor-claude-acp.mjs"
   }
 }