@borgee/agents-host 0.2.94 → 0.2.101

package/dist/policy/gateway-authorization.d.ts

@@ -2,7 +2,7 @@ import type { IncomingMessage } from 'node:http';
 export type GatewayDecisionReason = 'browser-origin-not-allowed' | 'method-not-allowed' | 'missing-or-invalid-token' | 'invalid-token' | 'channel-mismatch' | 'not-found' | 'bootstrap-unavailable' | 'authorized';
 export interface GatewayChannelRoute {
     channelId: string;
-    resource: 'bootstrap' | 'me' | 'history' | 'draft' | 'users' | 'messages' | 'tasks' | 'current-task';
+    resource: 'bootstrap' | 'me' | 'history' | 'files' | 'file-content' | 'file-download' | 'file-sync' | 'file-publish' | 'draft' | 'users' | 'messages' | 'tasks' | 'current-task';
 }
 export interface GatewayTaskRoute {
     taskId: string;

package/dist/policy/gateway-authorization.js

@@ -31,9 +31,23 @@ function decodePathSegment(segment) {
     }
 }
 export function matchChannelRoute(pathname, allowCollaborationRoutes = false) {
+    const fileOperation = /^\/v1\/channels\/([^/]+)\/files\/(content|download|sync|publish)$/.exec(pathname);
+    if (fileOperation) {
+        const channelId = decodePathSegment(fileOperation[1]);
+        if (channelId == null) {
+            return null;
+        }
+        const resources = {
+            content: 'file-content',
+            download: 'file-download',
+            sync: 'file-sync',
+            publish: 'file-publish',
+        };
+        return { channelId, resource: resources[fileOperation[2]] };
+    }
     const resources = allowCollaborationRoutes
-        ? '(bootstrap|me|history|draft|users|messages|tasks|current-task)'
-        : '(bootstrap|me|history|users|tasks|current-task)';
+        ? '(bootstrap|me|history|files|draft|users|messages|tasks|current-task)'
+        : '(bootstrap|me|history|files|users|tasks|current-task)';
     const match = new RegExp(`^/v1/channels/([^/]+)/${resources}$`).exec(pathname);
     if (!match) {
         return null;
@@ -91,10 +105,16 @@ function allowedMethodsForRoute(route, collaborationRoutesEnabled) {
         case 'bootstrap':
         case 'me':
         case 'history':
+        case 'files':
+        case 'file-content':
         case 'draft':
         case 'users':
         case 'task-history':
             return ['GET'];
+        case 'file-download':
+        case 'file-sync':
+        case 'file-publish':
+            return ['POST'];
         case 'messages':
             return collaborationRoutesEnabled ? ['POST'] : [];
         case 'tasks':

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

@@ -55,11 +55,22 @@ export class ClaudeProviderAdapter {
         const preparedTurn = await this.turnPreparer.prepare(input);
         const text = await this.cli.generateReply(preparedTurn, {
             onProgress: createAwaitingUserProgressHandler(options?.onProgress),
+            ...(options?.onUsage ? { onUsage: options.onUsage } : {}),
         });
         // Read the session AFTER the turn: a first turn on a channel opens the
         // 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

@@ -9,6 +9,7 @@ import { assertClaudeCommandCompatibility, DEFAULT_CLAUDE_COMMAND, isLegacyClaud
 import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
 import { HostLogger, summarizeChildStderr, summarizeError } from '../../debug.js';
 import { AcpProgressCollector } from '../acp-progress-collector.js';
+import { normalizeAcpPromptUsage } from '../prompt-usage.js';
 import { ProviderTurnCancelledError } from '../provider-adapter.js';
 import { readClaudeActivityMetadata } from './activity-metadata.js';
 import { ClaudeBackgroundRunObserver } from './background-run-observer.js';
@@ -18,17 +19,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 +59,7 @@ class ClaudeSessionUpdatePump {
         const turn = {
             queue: [],
             foregroundIsolationFence,
+            ownedForegroundTurn: this.resolveForegroundTurn(foregroundIsolationFence),
         };
         this.activeTurn = turn;
         this.observer.setOnProgress(onProgress);
@@ -85,9 +96,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 +299,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 +936,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 +965,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 +999,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 +1146,7 @@ export class ClaudeCliClient {
                 sessionPersistence,
                 backgroundTasksActive: false,
                 backgroundContinuationPending: false,
+                sessionHasPendingAutonomousTurn: false,
                 persistentFollowUpAdopted: false,
                 processing: false,
                 queue: [],
@@ -1170,8 +1381,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 +1396,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 +1433,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) {
@@ -1259,6 +1507,9 @@ export class ClaudeCliClient {
                     catch (error) {
                         throw markSessionTainted(error);
                     }
+                    const usage = normalizeAcpPromptUsage(response.usage);
+                    if (usage)
+                        options?.onUsage?.(usage);
                     const output = collector.getFinalText();
                     if (response.stopReason === 'cancelled') {
                         throw new ProviderTurnCancelledError('Claude ACP turn cancelled', {
@@ -1270,12 +1521,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 +1560,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 +1593,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 +1619,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 +1657,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 +1675,8 @@ export class ClaudeCliClient {
         }
         if (state.sessionPersistence !== 'ephemeral'
             || state.backgroundTasksActive
-            || state.backgroundContinuationPending) {
+            || state.backgroundContinuationPending
+            || state.sessionHasPendingAutonomousTurn) {
             return;
         }
         const session = state.session;
@@ -1633,9 +1884,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 +1923,7 @@ export class ClaudeCliClient {
             if (state.activeTurn ||
                 state.backgroundTasksActive ||
                 state.backgroundContinuationPending ||
+                state.sessionHasPendingAutonomousTurn ||
                 state.queue.length > 0 ||
                 state.sessionPromise ||
                 state.processing) {

package/dist/providers/codex/adapter.js

@@ -27,6 +27,7 @@ export class CodexProviderAdapter {
         const preparedTurn = await this.turnPreparer.prepare(input);
         const text = await this.cli.generateReply(preparedTurn, {
             onProgress: createAwaitingUserProgressHandler(options?.onProgress),
+            ...(options?.onUsage ? { onUsage: options.onUsage } : {}),
         });
         // Read the session AFTER the turn: a first turn on a channel opens the
         // session as it runs, so before this point there is nothing to report.

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

@@ -6,6 +6,7 @@ import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
 import { HostLogger, summarizeChildStderr, summarizeError } from '../../debug.js';
 import { AcpProgressCollector } from '../acp-progress-collector.js';
+import { normalizeAcpPromptUsage } from '../prompt-usage.js';
 import { ProviderTurnCancelledError } from '../provider-adapter.js';
 import { assertCodexProjectDocumentSize, buildCodexProjectDocument } from './project-doc.js';
 import { isGatewayCredentialSidecarBasename } from '../../context/injection.js';
@@ -850,6 +851,10 @@ export class CodexCliClient {
                 catch (error) {
                     throw markSessionTainted(error);
                 }
+                const usage = normalizeAcpPromptUsage(response.usage);
+                if (usage) {
+                    options?.onUsage?.(usage);
+                }
                 const output = collector.getFinalText();
                 if (response.stopReason === 'cancelled') {
                     throw new ProviderTurnCancelledError('Codex ACP turn cancelled', {

package/dist/providers/copilot/adapter.js

@@ -27,6 +27,10 @@ export class CopilotProviderAdapter {
         const preparedTurn = await this.turnPreparer.prepare(input);
         const text = await this.cli.generateReply(preparedTurn, {
             onProgress: createAwaitingUserProgressHandler(options?.onProgress),
+            ...(options?.onUsage ? { onUsage: options.onUsage } : {}),
+            ...(options?.onExecutionContinuation
+                ? { onExecutionContinuation: options.onExecutionContinuation }
+                : {}),
         });
         // Read the session AFTER the turn: a first turn on a channel opens the
         // session as it runs, so before this point there is nothing to report.

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

@@ -4,6 +4,7 @@ import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientpr
 import { toCopilotBackgroundActivity } from './activity-metadata.js';
 import { HostLogger, summarizeChildStderr, summarizeError } from '../../debug.js';
 import { AcpProgressCollector, } from '../acp-progress-collector.js';
+import { normalizeAcpPromptUsage } from '../prompt-usage.js';
 import { ProviderTurnCancelledError } from '../provider-adapter.js';
 import { resolveCopilotPermissionResponse, resolveCopilotSdkPermissionResponse, } from '../../policy/copilot-permission.js';
 import { isDiscussionOnlyResolvedWorkingFolder } from '../../context/resolved-working-folder.js';
@@ -1001,7 +1002,12 @@ export class CopilotCliClient {
         this.closeSession(session);
     }
     async runTurn(session, prompt, options, onBackgroundAgentStarted) {
-        const promptPromise = this.raceWithFatal(session.prompt(prompt));
+        const promptPromise = this.raceWithFatal(isCopilotSdkSession(session)
+            ? session.prompt(prompt, {
+                onUsage: options?.onUsage,
+                onExecutionContinuation: options?.onExecutionContinuation,
+            })
+            : session.prompt(prompt));
         const promptFailure = new Promise((_, reject) => {
             void promptPromise.catch((error) => reject(markSessionTainted(error)));
         });
@@ -1042,6 +1048,10 @@ export class CopilotCliClient {
                 catch (error) {
                     throw markSessionTainted(error);
                 }
+                const usage = normalizeAcpPromptUsage(response.usage);
+                if (usage) {
+                    options?.onUsage?.(usage);
+                }
                 if (response.stopReason === 'cancelled') {
                     throw new ProviderTurnCancelledError('Copilot turn cancelled');
                 }