@borgee/agents-host 0.2.74 → 0.2.94

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

@@ -1,27 +1,35 @@
 import { Readable, Writable } from 'node:stream';
 import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
+import { toCopilotBackgroundActivity } from './activity-metadata.js';
 import { HostLogger, summarizeChildStderr, summarizeError } from '../../debug.js';
-import { AcpProgressCollector } from '../acp-progress-collector.js';
+import { AcpProgressCollector, } from '../acp-progress-collector.js';
 import { ProviderTurnCancelledError } from '../provider-adapter.js';
-import { resolveCopilotPermissionResponse } from '../../policy/copilot-permission.js';
-import { isDiscussionOnlyResolvedWorkspace } from '../../context/resolved-workspace.js';
+import { resolveCopilotPermissionResponse, resolveCopilotSdkPermissionResponse, } from '../../policy/copilot-permission.js';
+import { isDiscussionOnlyResolvedWorkingFolder } from '../../context/resolved-working-folder.js';
 import { IDLE_BACKEND_SHUTDOWN_DISABLED_MS, IdleBackendShutdownScheduler, } from '../idle-backend-shutdown.js';
+import { CopilotSdkSessionAdapter, createCopilotSdkClient, createCopilotSdkSessionConfig, } from './sdk-session.js';
 const SESSION_TAINTED_ERRORS = new WeakSet();
 const DEFAULT_IDLE_SESSION_TTL_MS = 2 * 24 * 60 * 60 * 1000;
-const IDLE_BACKEND_STOPPED_MESSAGE = 'Copilot ACP backend stopped after idle timeout';
+const IDLE_BACKEND_STOPPED_MESSAGE = 'Copilot runtime backend stopped after idle timeout';
 /**
  * A fatal teardown has callers waiting on it, so it force-kills quickly. An
  * idle recycle has nobody waiting, and the CLIs unlink their on-disk session
  * locks during SIGTERM cleanup — a lock left behind by SIGKILL makes the next
- * restore believe the session is still in use (github/copilot-cli#3255). So the
- * idle path trades latency nobody observes for a clean exit.
+ * restore believe the session is still in use. The idle path therefore trades
+ * latency nobody observes for a clean exit.
  */
 const DEFAULT_IDLE_SHUTDOWN_GRACE_PERIOD_MS = 5_000;
+const DEFAULT_SESSION_CLOSE_TIMEOUT_MS = 5_000;
 const DEFAULT_SHUTDOWN_GRACE_PERIOD_MS = 250;
 const DEFAULT_SHUTDOWN_FORCE_KILL_WAIT_MS = 250;
-const QUEUED_TURN_DROPPED_MESSAGE = 'Copilot ACP session was reset after a failed turn; queued turns were dropped instead of replaying them on a fresh session';
+const QUEUED_TURN_DROPPED_MESSAGE = 'Copilot session was reset after a failed turn; queued turns were dropped instead of replaying them on a fresh session';
+function isCopilotSdkSession(session) {
+    return session instanceof CopilotSdkSessionAdapter;
+}
 const DEFAULT_RUNTIME = {
+    transport: 'sdk',
+    createSdkClient: createCopilotSdkClient,
     spawn,
     client,
     ndJsonStream,
@@ -31,6 +39,7 @@ const DEFAULT_RUNTIME = {
     idleSessionTtlMs: DEFAULT_IDLE_SESSION_TTL_MS,
     idleBackendShutdownMs: IDLE_BACKEND_SHUTDOWN_DISABLED_MS,
     idleShutdownGracePeriodMs: DEFAULT_IDLE_SHUTDOWN_GRACE_PERIOD_MS,
+    sessionCloseTimeoutMs: DEFAULT_SESSION_CLOSE_TIMEOUT_MS,
     shutdownGracePeriodMs: DEFAULT_SHUTDOWN_GRACE_PERIOD_MS,
     shutdownForceKillWaitMs: DEFAULT_SHUTDOWN_FORCE_KILL_WAIT_MS,
     fetch: async (input, init) => fetch(input, init),
@@ -38,6 +47,7 @@ const DEFAULT_RUNTIME = {
 const DEFAULT_SESSION_CAPABILITIES = {
     loadSession: false,
     resumeSession: false,
+    closeSession: false,
 };
 function isAbsoluteHttpUrl(value) {
     return value.startsWith('http://') || value.startsWith('https://');
@@ -75,6 +85,7 @@ function createDeferredTurn(channelId, preparedTurn, sessionPersistence, options
         sessionPersistence,
         options,
         promise,
+        cancelled: false,
         resolve(value) {
             if (settled)
                 return;
@@ -97,20 +108,61 @@ function parsePersistedSessionRecord(rawValue) {
     if (trimmed.startsWith('{')) {
         const parsed = JSON.parse(trimmed);
         if (typeof parsed.sessionId === 'string' && parsed.sessionId.trim().length > 0) {
+            const backgroundTaskExecutions = parseBackgroundTaskExecutions(parsed.backgroundTaskExecutions);
             return {
                 sessionId: parsed.sessionId,
                 cwd: typeof parsed.cwd === 'string' && parsed.cwd.trim().length > 0
                     ? parsed.cwd
                     : undefined,
+                ...(backgroundTaskExecutions ? { backgroundTaskExecutions } : {}),
             };
         }
     }
     return { sessionId: rawValue };
 }
+function parseBackgroundTaskExecutions(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const executions = {};
+    for (const [taskId, candidate] of Object.entries(value).slice(0, 128)) {
+        if (!taskId ||
+            !candidate ||
+            typeof candidate !== 'object' ||
+            Array.isArray(candidate)) {
+            continue;
+        }
+        const execution = candidate;
+        if (typeof execution.startedAt !== 'number' ||
+            !Number.isFinite(execution.startedAt) ||
+            typeof execution.terminal !== 'boolean' ||
+            typeof execution.waiting !== 'boolean') {
+            continue;
+        }
+        const activeStartedAt = typeof execution.activeStartedAt === 'number' &&
+            Number.isFinite(execution.activeStartedAt)
+            ? execution.activeStartedAt
+            : undefined;
+        const terminalAt = typeof execution.terminalAt === 'number' && Number.isFinite(execution.terminalAt)
+            ? execution.terminalAt
+            : undefined;
+        executions[taskId] = {
+            startedAt: execution.startedAt,
+            terminal: execution.terminal,
+            waiting: execution.waiting,
+            ...(activeStartedAt !== undefined ? { activeStartedAt } : {}),
+            ...(terminalAt !== undefined ? { terminalAt } : {}),
+        };
+    }
+    return Object.keys(executions).length > 0 ? executions : undefined;
+}
 function serializePersistedSessionRecord(record) {
     return JSON.stringify({
         sessionId: record.sessionId,
         ...(record.cwd ? { cwd: record.cwd } : {}),
+        ...(record.backgroundTaskExecutions
+            ? { backgroundTaskExecutions: record.backgroundTaskExecutions }
+            : {}),
     });
 }
 function resolveSessionRouting(turn) {
@@ -136,6 +188,7 @@ function readSessionCapabilities(response) {
     return {
         loadSession: agentCapabilities?.loadSession === true,
         resumeSession: asObject(sessionCapabilities?.resume) !== null,
+        closeSession: asObject(sessionCapabilities?.close) !== null,
     };
 }
 function markSessionTainted(error) {
@@ -146,13 +199,64 @@ function markSessionTainted(error) {
 function isSessionTainted(error) {
     return error instanceof Error && SESSION_TAINTED_ERRORS.has(error);
 }
+function isAgentTaskInput(value) {
+    const input = asObject(value);
+    return typeof input?.agent_type === 'string'
+        && typeof input.name === 'string'
+        && typeof input.description === 'string'
+        && typeof input.prompt === 'string'
+        && (input.mode === undefined
+            || input.mode === 'sync'
+            || input.mode === 'background');
+}
+const COPILOT_BACKGROUND_AGENT_ID = '[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}';
+const COPILOT_SYNC_TASK_TIMEOUT_RESULT = new RegExp('^Agent is still running \\(agent_id: '
+    + COPILOT_BACKGROUND_AGENT_ID
+    + '\\)\\.'
+    + '(?: The agent is actively working \\([\\s\\S]*\\)\\.)?'
+    + ' Use read_agent to check for results'
+    + '(?:, or write_agent to send follow-up messages)?\\.$', 'i');
+function isBackgroundAgentTaskResult(value) {
+    const result = asObject(value);
+    return typeof result?.content === 'string'
+        && COPILOT_SYNC_TASK_TIMEOUT_RESULT.test(result.content.trim());
+}
+class BackgroundAgentLaunchTracker {
+    taskCalls = new Map();
+    consume(notification) {
+        const update = notification.update;
+        if (update.sessionUpdate === 'tool_call') {
+            if (isAgentTaskInput(update.rawInput)) {
+                const input = asObject(update.rawInput);
+                this.taskCalls.set(update.toolCallId, {
+                    requestedBackground: input?.mode === 'background',
+                });
+            }
+            return false;
+        }
+        if (update.sessionUpdate !== 'tool_call_update'
+            || !this.taskCalls.has(update.toolCallId)) {
+            return false;
+        }
+        if (update.status === 'failed') {
+            this.taskCalls.delete(update.toolCallId);
+            return false;
+        }
+        if (update.status !== 'completed') {
+            return false;
+        }
+        const taskCall = this.taskCalls.get(update.toolCallId);
+        this.taskCalls.delete(update.toolCallId);
+        return taskCall.requestedBackground || isBackgroundAgentTaskResult(update.rawOutput);
+    }
+}
 /**
- * Persistent ACP-backed client for the GitHub Copilot CLI (`copilot --acp`).
+ * Persistent session client for the GitHub Copilot CLI.
  *
- * The legacy one-shot `COPILOT_ARGS` / constructor args are intentionally
- * ignored here: the prototype always launches the child as `copilot --acp`,
- * performs the ACP initialize handshake once, then reuses one ACP session per
- * Borgee channel for the process lifetime.
+ * Production uses the Copilot SDK headless JSON-RPC transport. The ACP runtime
+ * remains injectable for compatibility tests. Both paths reuse one provider
+ * session per Borgee channel because the background-agent registry belongs to
+ * that session and later read_agent/write_agent turns must keep that identity.
  */
 export class CopilotCliClient {
     command;
@@ -163,22 +267,75 @@ export class CopilotCliClient {
     imageInputConfig;
     runtime;
     channels = new Map();
+    channelWorkerRoutes = new Map();
+    sessionAuthorizationLeases = new Map();
     /**
      * The provider session currently bound to channelId, or undefined before a
      * turn has opened one. Surfaced so agents-host can record which session
      * worked a task without the agent being asked to report its own id.
      */
     sessionIdForChannel(channelId) {
-        return this.channels.get(channelId)?.session?.sessionId;
+        return this.channelWorkerRoutes.get(channelId)?.state.session?.sessionId
+            ?? this.channels.get(channelId)?.session?.sessionId;
     }
-    async cancelTurn(channelId) {
-        const state = this.channels.get(channelId);
+    async interruptTurn(channelId) {
+        const workerRoute = this.channelWorkerRoutes.get(channelId);
+        const state = workerRoute?.phase === 'promoted' && workerRoute.state.activeTurn
+            ? workerRoute.state
+            : this.channels.get(channelId) ?? workerRoute?.state;
+        const activeTurn = state?.activeTurn;
+        const session = state?.session;
+        if (!state || !activeTurn) {
+            return false;
+        }
+        activeTurn.cancelled = true;
+        if (!session) {
+            return true;
+        }
+        if (!isCopilotSdkSession(session)) {
+            return true;
+        }
+        this.clearIdleTimer(state);
+        this.idleBackendShutdown.cancel();
+        return session.interruptMainTurn();
+    }
+    async cancelSession(channelId) {
+        const workerRoute = this.channelWorkerRoutes.get(channelId);
+        const state = workerRoute?.phase === 'promoted'
+            ? workerRoute.state
+            : this.channels.get(channelId) ?? workerRoute?.state;
         const session = state?.session;
-        if (!state?.activeTurn || !session) {
+        if (!state) {
             return false;
         }
+        if (state.activeTurn) {
+            state.activeTurn.cancelled = true;
+        }
+        if (!session) {
+            if (!state.activeTurn) {
+                return false;
+            }
+            state.activeTurn.cancelled = true;
+            return true;
+        }
         this.clearIdleTimer(state);
         this.idleBackendShutdown.cancel();
+        if (isCopilotSdkSession(session)) {
+            const [foreground, background] = await Promise.allSettled([
+                state.activeTurn ? session.interruptMainTurn() : Promise.resolve(false),
+                session.cancelAllBackgroundWork(),
+            ]);
+            if (foreground.status === 'rejected' || background.status === 'rejected') {
+                const errors = [foreground, background]
+                    .filter((result) => result.status === 'rejected')
+                    .map((result) => normalizeError(result.reason));
+                throw new AggregateError(errors, 'Copilot SDK session cancellation failed');
+            }
+            return foreground.value || background.value;
+        }
+        if (!state.activeTurn) {
+            return false;
+        }
         const activeSession = session;
         if (typeof activeSession.cancel === 'function') {
             await activeSession.cancel({ sessionId: session.sessionId });
@@ -188,8 +345,23 @@ export class CopilotCliClient {
         await this.connection?.agent.notify(cancelMethod, { sessionId: session.sessionId });
         return true;
     }
+    async cancelTurn(channelId) {
+        return this.cancelSession(channelId);
+    }
+    async cancelBackgroundRun(channelId, providerRunId) {
+        const workerRoute = this.channelWorkerRoutes.get(channelId);
+        const state = workerRoute?.phase === 'promoted'
+            ? workerRoute.state
+            : this.channels.get(channelId) ?? workerRoute?.state;
+        const session = state?.session;
+        if (!session || !isCopilotSdkSession(session)) {
+            return false;
+        }
+        return session.cancelBackgroundRun(providerRunId);
+    }
     persistedSessions = new Map();
     closingSessions = new WeakSet();
+    orphanedSessions = new Set();
     pendingSessionStarts = new Set();
     pendingSessionCloses = new Set();
     pendingSessionStoreOperations = new Set();
@@ -197,6 +369,7 @@ export class CopilotCliClient {
     rejectFatalPromise;
     child;
     connection;
+    sdkClient;
     startPromise;
     shutdownPromise;
     childExitPromise;
@@ -207,6 +380,7 @@ export class CopilotCliClient {
      */
     backendGeneration = 0;
     idleShutdownPromise;
+    backendShutdownInProgress = false;
     fatalError = null;
     disposing = false;
     backendClosed = false;
@@ -214,6 +388,8 @@ export class CopilotCliClient {
     sessionStoreLoadPromise = null;
     sessionStoreWriteQueue = Promise.resolve();
     sessionCapabilities = DEFAULT_SESSION_CAPABILITIES;
+    backendRecycleRequired = false;
+    autonomousReplyHandler;
     idleBackendShutdown;
     constructor(command, _ignoredArgs = [], runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined, logger = new HostLogger(), permissionPolicy = {}, imageInputConfig = {}) {
         this.command = command;
@@ -228,7 +404,7 @@ export class CopilotCliClient {
             isIdle: () => this.isBackendIdle(),
             shutdown: () => this.shutdownIdleBackend(),
             onShutdownFailed: (error) => {
-                this.logger.error('failed to stop the idle Copilot ACP backend', {
+                this.logger.error('failed to stop the idle Copilot runtime backend', {
                     error: summarizeError(error),
                 });
             },
@@ -259,19 +435,26 @@ export class CopilotCliClient {
             ? maybeOptions
             : promptOrOptions;
         const sessionRouting = resolveSessionRouting(preparedTurn);
-        const state = this.getOrCreateChannelState(sessionRouting.key, preparedTurn.channelId, sessionRouting.persistence);
+        const state = this.resolveChannelState(sessionRouting);
+        if (options?.onProgress) {
+            state.backgroundProgress = options.onProgress;
+        }
         this.clearIdleTimer(state);
         this.idleBackendShutdown.cancel();
         const turn = createDeferredTurn(preparedTurn.channelId, preparedTurn, sessionRouting.persistence, options);
         state.queue.push(turn);
-        this.processChannelQueue(sessionRouting.key, state);
+        this.processChannelQueue(state);
         return turn.promise;
     }
+    onAutonomousReply(handler) {
+        this.autonomousReplyHandler = handler;
+    }
     async dispose() {
-        const error = new Error('Copilot ACP backend stopped');
+        const error = new Error('Copilot runtime backend stopped');
         this.disposing = true;
+        this.autonomousReplyHandler = undefined;
         this.idleBackendShutdown.cancel();
-        this.logger?.debug('stopping Copilot ACP backend');
+        this.logger?.debug('stopping Copilot runtime backend');
         const closed = this.connection?.closed ?? Promise.resolve();
         this.failAll(error);
         let thrown;
@@ -314,11 +497,15 @@ export class CopilotCliClient {
         if (this.fatalError) {
             throw this.fatalError;
         }
-        if (!this.connection) {
-            throw new Error('Copilot ACP connection is not available');
+        if (this.runtime.transport === 'sdk' ? !this.sdkClient : !this.connection) {
+            throw new Error('Copilot runtime connection is not available');
         }
     }
     async startBackend() {
+        if (this.runtime.transport === 'sdk') {
+            await this.startSdkBackend();
+            return;
+        }
         const generation = ++this.backendGeneration;
         const ownsCurrentBackend = () => (this.backendGeneration === generation && !this.disposing);
         this.logger?.debug('starting Copilot ACP process', {
@@ -384,6 +571,7 @@ export class CopilotCliClient {
             this.logger?.debug('initialized Copilot ACP connection', {
                 loadSession: this.sessionCapabilities.loadSession,
                 resumeSession: this.sessionCapabilities.resumeSession,
+                closeSession: this.sessionCapabilities.closeSession,
             });
         }
         catch (error) {
@@ -393,25 +581,73 @@ export class CopilotCliClient {
             throw normalized;
         }
     }
-    getOrCreateChannelState(channelId, resolvedChannelId, sessionPersistence) {
-        let state = this.channels.get(channelId);
+    async startSdkBackend() {
+        this.logger?.debug('starting Copilot SDK runtime', {
+            command: this.command,
+            cwd: this.runtime.cwd,
+        });
+        const sdkClient = this.runtime.createSdkClient(this.command, this.runtime.cwd, this.logger.enabled);
+        this.sdkClient = sdkClient;
+        try {
+            await sdkClient.start();
+            this.sessionCapabilities = {
+                loadSession: false,
+                resumeSession: true,
+                closeSession: true,
+            };
+            this.logger?.debug('initialized Copilot SDK runtime');
+        }
+        catch (error) {
+            const normalized = new Error(`Copilot SDK startup failed: ${normalizeError(error).message}`);
+            this.logger?.debugError('Copilot SDK startup failed', normalized);
+            this.failAll(normalized);
+            throw normalized;
+        }
+    }
+    getOrCreateChannelState(routingKey, resolvedChannelId, sessionPersistence) {
+        let state = this.channels.get(routingKey);
         if (!state) {
             state = {
+                routingKey,
                 channelId: resolvedChannelId,
                 sessionPersistence,
+                sessionHasBackgroundAgents: false,
+                sessionHasPendingAutonomousTurn: false,
                 idleTimerGeneration: 0,
                 processing: false,
                 queue: [],
             };
-            this.channels.set(channelId, state);
+            this.channels.set(routingKey, state);
         }
         else if (state.channelId !== resolvedChannelId
             || state.sessionPersistence !== sessionPersistence) {
-            throw new Error(`Copilot session routing changed for key "${channelId}"`);
+            throw new Error(`Copilot session routing changed for key "${routingKey}"`);
         }
         return state;
     }
-    processChannelQueue(channelId, state) {
+    resolveChannelState(routing) {
+        const workerRoute = this.channelWorkerRoutes.get(routing.channelId);
+        if (workerRoute) {
+            // Candidate ownership reserves the whole channel so a foreground turn
+            // cannot open a competing worker registry before promotion.
+            return workerRoute.state;
+        }
+        if (routing.persistence === 'ephemeral') {
+            const foregroundState = this.channels.get(routing.channelId);
+            const state = foregroundState
+                && foregroundState.channelId === routing.channelId
+                && foregroundState.sessionPersistence === 'persistent'
+                ? foregroundState
+                : this.getOrCreateChannelState(routing.key, routing.channelId, routing.persistence);
+            this.channelWorkerRoutes.set(routing.channelId, {
+                phase: 'candidate',
+                state,
+            });
+            return state;
+        }
+        return this.getOrCreateChannelState(routing.key, routing.channelId, routing.persistence);
+    }
+    processChannelQueue(state) {
         if (state.processing) {
             return;
         }
@@ -426,20 +662,42 @@ export class CopilotCliClient {
                     state.activeTurn = turn;
                     try {
                         state.cwd = await this.resolveSessionCwd(turn.preparedTurn.promptContext);
-                        state.toolPermissionMode = isDiscussionOnlyResolvedWorkspace(turn.preparedTurn.promptContext)
+                        state.toolPermissionMode = isDiscussionOnlyResolvedWorkingFolder(turn.preparedTurn.promptContext)
                             ? 'deny-all'
                             : 'default';
+                        const adoptingPersistentRoute = (turn.sessionPersistence === 'persistent'
+                            && state.sessionPersistence === 'ephemeral');
+                        if (adoptingPersistentRoute) {
+                            // Delay the upgrade until this turn reaches the queue head so
+                            // enqueueing it cannot change or abort the active kickoff.
+                            state.sessionPersistence = 'persistent';
+                        }
                         await this.ensureStarted();
-                        await this.recycleSessionIfCwdChanged(channelId, state);
-                        const session = await this.getOrCreateSession(channelId, state);
+                        await this.recycleSessionIfCwdChanged(state);
+                        const existingSession = state.session;
+                        const session = await this.getOrCreateSession(state);
+                        if (turn.cancelled) {
+                            throw new ProviderTurnCancelledError('Copilot turn cancelled');
+                        }
+                        if (adoptingPersistentRoute && existingSession === session) {
+                            await this.persistSessionBestEffort(state, session.sessionId, state.sessionCwd ?? state.cwd ?? this.runtime.cwd);
+                        }
+                        this.bindSessionAuthorization(session, state);
                         let reply;
                         try {
                             const promptInput = await this.buildPromptInput(turn.preparedTurn);
-                            reply = await this.runTurn(session, promptInput, turn.options);
+                            if (turn.cancelled) {
+                                throw new ProviderTurnCancelledError('Copilot turn cancelled');
+                            }
+                            reply = await this.runTurn(session, promptInput, turn.options, () => {
+                                if (state.session === session) {
+                                    this.promoteWorkerRoute(state, session);
+                                }
+                            });
                         }
                         catch (error) {
                             if (isSessionTainted(error)) {
-                                this.invalidateSession(channelId, state, session);
+                                this.invalidateSession(state, session);
                                 this.rejectQueuedTurnsAfterSessionTaint(state, error);
                             }
                             throw error;
@@ -456,28 +714,28 @@ export class CopilotCliClient {
             }
             finally {
                 state.processing = false;
-                this.reconcileIdleChannelState(channelId, state);
-                this.idleBackendShutdown.reconcile();
+                this.reconcileIdleChannelState(state);
+                this.reconcileBackendLifecycle();
             }
         })();
     }
-    async getOrCreateSession(channelId, state) {
+    async getOrCreateSession(state) {
         if (state.session) {
             return state.session;
         }
         if (state.sessionPromise) {
             return state.sessionPromise;
         }
-        if (!this.connection) {
-            throw new Error('Copilot ACP connection is not available');
+        if (this.runtime.transport === 'sdk' ? !this.sdkClient : !this.connection) {
+            throw new Error('Copilot runtime connection is not available');
         }
         const cwd = state.cwd ?? this.runtime.cwd;
         const persistedSessionId = state.sessionPersistence === 'persistent'
-            ? await this.readPersistedSessionId(channelId, cwd)
+            ? await this.readPersistedSessionId(state.channelId, cwd)
             : undefined;
         const sessionPromise = persistedSessionId
-            ? this.restoreOrCreateSession(channelId, persistedSessionId, cwd)
-            : this.startFreshSession(channelId, cwd);
+            ? this.restoreOrCreateSession(state, persistedSessionId, cwd)
+            : this.startFreshSession(state, cwd);
         this.pendingSessionStarts.add(sessionPromise);
         state.sessionPromise = sessionPromise;
         let sessionAdopted = false;
@@ -501,6 +759,19 @@ export class CopilotCliClient {
             sessionAdopted = true;
             state.session = session;
             state.sessionCwd = cwd;
+            state.sessionHasBackgroundAgents = false;
+            state.sessionHasPendingAutonomousTurn = false;
+            if (isCopilotSdkSession(session)) {
+                await session.reconcileBackgroundTasks();
+                const hasBackgroundAgents = await session.hasBackgroundAgents();
+                if (!state.sessionHasBackgroundAgents && hasBackgroundAgents) {
+                    this.promoteWorkerRoute(state, session);
+                }
+            }
+            if (state.sessionPersistence === 'persistent'
+                && session.sessionId !== persistedSessionId) {
+                await this.persistSessionBestEffort(state, session.sessionId, cwd);
+            }
             return session;
         }
         catch (error) {
@@ -514,27 +785,33 @@ export class CopilotCliClient {
             }
         }
     }
-    async startFreshSession(channelId, cwd) {
+    async startFreshSession(state, cwd) {
+        if (this.runtime.transport === 'sdk') {
+            if (!this.sdkClient) {
+                throw new Error('Copilot SDK runtime is not available');
+            }
+            const session = this.createSdkSessionAdapter(await this.sdkClient.createSession(createCopilotSdkSessionConfig(cwd, (request, invocation) => this.handleSdkPermissionRequest(request, invocation.sessionId))), state);
+            this.logger?.debug('started fresh Copilot SDK session', { channelId: state.channelId });
+            return session;
+        }
         if (!this.connection) {
             throw new Error('Copilot ACP connection is not available');
         }
         const session = await this.connection.agent.buildSession(cwd).start();
-        this.logger?.debug('started fresh Copilot ACP session', { channelId });
-        const state = this.channels.get(channelId);
-        if (state?.sessionPersistence === 'persistent') {
-            await this.persistSessionBestEffort(channelId, session.sessionId, cwd);
-        }
+        this.logger?.debug('started fresh Copilot ACP session', { channelId: state.channelId });
         return session;
     }
-    async restoreOrCreateSession(channelId, sessionId, cwd) {
+    async restoreOrCreateSession(state, sessionId, cwd) {
         if (!this.sessionCapabilities.resumeSession && !this.sessionCapabilities.loadSession) {
-            this.logger?.debug('Copilot ACP restore unsupported; starting fresh session', { channelId });
-            return this.startFreshSession(channelId, cwd);
+            this.logger?.debug('Copilot session restore unsupported; starting fresh session', {
+                channelId: state.channelId,
+            });
+            return this.startFreshSession(state, cwd);
         }
         try {
-            const session = await this.restoreSession(sessionId, cwd);
-            this.logger?.debug('restored Copilot ACP session', {
-                channelId,
+            const session = await this.restoreSession(state, sessionId, cwd);
+            this.logger?.debug('restored Copilot session', {
+                channelId: state.channelId,
                 restoreMethod: this.sessionCapabilities.resumeSession ? 'session/resume' : 'session/load',
             });
             return session;
@@ -543,12 +820,21 @@ export class CopilotCliClient {
             if (!isStaleRestoreFailure(error)) {
                 throw normalizeError(error);
             }
-            this.logger?.debug('discarded stale Copilot ACP session and started fresh', { channelId });
-            await this.clearPersistedSessionBestEffort(channelId);
-            return this.startFreshSession(channelId, cwd);
+            this.logger?.debug('discarded stale Copilot session and started fresh', {
+                channelId: state.channelId,
+            });
+            await this.clearPersistedSessionBestEffort(state.channelId, sessionId);
+            return this.startFreshSession(state, cwd);
         }
     }
-    async restoreSession(sessionId, cwd) {
+    async restoreSession(state, sessionId, cwd) {
+        if (this.runtime.transport === 'sdk') {
+            if (!this.sdkClient) {
+                throw new Error('Copilot SDK runtime is not available');
+            }
+            const session = await this.sdkClient.resumeSession(sessionId, createCopilotSdkSessionConfig(cwd, (request, invocation) => this.handleSdkPermissionRequest(request, invocation.sessionId)));
+            return this.createSdkSessionAdapter(session, state);
+        }
         if (!this.connection) {
             throw new Error('Copilot ACP connection is not available');
         }
@@ -578,18 +864,77 @@ export class CopilotCliClient {
             throw new Error('Copilot ACP agent does not advertise session restore capabilities');
         }
         catch (error) {
-            session.dispose();
+            this.closeSession(session);
             throw normalizeError(error);
         }
     }
+    createSdkSessionAdapter(session, state) {
+        const persistedRecord = this.persistedSessions.get(state.channelId);
+        const initialBackgroundTaskExecutions = persistedRecord?.sessionId === session.sessionId
+            ? persistedRecord.backgroundTaskExecutions
+            : undefined;
+        return new CopilotSdkSessionAdapter(session, (run) => {
+            state.backgroundProgress?.({ type: 'background_run', run });
+            state.backgroundProgress?.({
+                type: 'activity',
+                activity: toCopilotBackgroundActivity(session.sessionId, run),
+            });
+        }, (active) => {
+            const currentSession = state.session;
+            if (!currentSession || currentSession.sessionId !== session.sessionId) {
+                return;
+            }
+            if (active) {
+                this.promoteWorkerRoute(state, currentSession);
+                return;
+            }
+            state.sessionHasBackgroundAgents = false;
+            this.reconcileIdleChannelState(state);
+            this.reconcileBackendLifecycle();
+        }, (error) => {
+            this.logger.debugError('failed to refresh Copilot background task registry', {
+                channelId: state.channelId,
+                error: summarizeError(error),
+            });
+        }, (reply) => {
+            const currentSession = state.session;
+            if (!currentSession || currentSession.sessionId !== session.sessionId) {
+                return;
+            }
+            this.autonomousReplyHandler?.({
+                channelId: state.channelId,
+                eventId: reply.eventId,
+                text: reply.text,
+            });
+        }, (active) => {
+            const currentSession = state.session;
+            if (!currentSession || currentSession.sessionId !== session.sessionId) {
+                return;
+            }
+            state.sessionHasPendingAutonomousTurn = active;
+            if (active) {
+                this.promoteWorkerRoute(state, currentSession);
+                this.clearIdleTimer(state);
+                this.idleBackendShutdown.cancel();
+                return;
+            }
+            this.reconcileIdleChannelState(state);
+            this.reconcileBackendLifecycle();
+        }, initialBackgroundTaskExecutions, async (backgroundTaskExecutions) => {
+            await this.persistSessionBestEffort(state, session.sessionId, state.sessionCwd ?? state.cwd ?? this.runtime.cwd, backgroundTaskExecutions);
+        });
+    }
     clearBufferedSessionReplay(session) {
+        if (isCopilotSdkSession(session)) {
+            return;
+        }
         const updates = session.updates;
         if (updates && Array.isArray(updates.values)) {
             updates.values = [];
         }
     }
     async resolveSessionCwd(promptContext) {
-        return promptContext?.resolvedWorkspace?.rootPath ?? this.runtime.cwd;
+        return promptContext?.resolvedWorkingFolder?.rootPath ?? this.runtime.cwd;
     }
     async buildPromptInput(turn) {
         const imageParts = turn.incomingParts.map(asImagePart).filter((part) => part !== null);
@@ -622,7 +967,7 @@ export class CopilotCliClient {
             uri: response.url || resolvedUrl,
         };
     }
-    async recycleSessionIfCwdChanged(channelId, state) {
+    async recycleSessionIfCwdChanged(state) {
         const session = state.session;
         if (!session) {
             return;
@@ -631,25 +976,53 @@ export class CopilotCliClient {
         if (state.sessionCwd === nextCwd) {
             return;
         }
-        this.logger?.debug('recycling Copilot ACP session after cwd changed', {
-            channelId,
+        if (state.sessionHasBackgroundAgents || state.sessionHasPendingAutonomousTurn) {
+            this.logger?.debug('keeping Copilot session cwd while background delivery is active', {
+                channelId: state.channelId,
+                sessionCwd: state.sessionCwd,
+                requestedCwd: nextCwd,
+            });
+            state.cwd = state.sessionCwd;
+            return;
+        }
+        this.logger?.debug('recycling Copilot session after cwd changed', {
+            channelId: state.channelId,
             previousCwd: state.sessionCwd,
             nextCwd,
         });
         state.session = undefined;
         state.sessionCwd = undefined;
+        state.sessionHasBackgroundAgents = false;
+        state.sessionHasPendingAutonomousTurn = false;
         this.clearIdleTimer(state);
         if (!this.disposing && !this.backendClosed && state.sessionPersistence === 'persistent') {
-            await this.clearPersistedSessionBestEffort(channelId);
+            await this.clearPersistedSessionBestEffort(state.channelId, session.sessionId);
         }
         this.closeSession(session);
     }
-    async runTurn(session, prompt, options) {
+    async runTurn(session, prompt, options, onBackgroundAgentStarted) {
         const promptPromise = this.raceWithFatal(session.prompt(prompt));
         const promptFailure = new Promise((_, reject) => {
             void promptPromise.catch((error) => reject(markSessionTainted(error)));
         });
         const collector = new AcpProgressCollector(options?.onProgress);
+        const backgroundAgentLaunches = new BackgroundAgentLaunchTracker();
+        let backgroundAgentStarted = false;
+        let backgroundRoutePromoted = false;
+        const promoteBackgroundRoute = () => {
+            if (backgroundRoutePromoted) {
+                return;
+            }
+            backgroundRoutePromoted = true;
+            onBackgroundAgentStarted?.();
+        };
+        const noteBackgroundAgentStarted = () => {
+            if (backgroundAgentStarted) {
+                return;
+            }
+            backgroundAgentStarted = true;
+            promoteBackgroundRoute();
+        };
         for (;;) {
             let update;
             try {
@@ -670,17 +1043,27 @@ export class CopilotCliClient {
                     throw markSessionTainted(error);
                 }
                 if (response.stopReason === 'cancelled') {
-                    throw new ProviderTurnCancelledError('Copilot ACP turn cancelled');
+                    throw new ProviderTurnCancelledError('Copilot turn cancelled');
                 }
                 if (response.stopReason !== 'end_turn') {
-                    throw new Error(`Copilot ACP turn stopped with stopReason "${response.stopReason}"`);
+                    throw new Error(`Copilot turn stopped with stopReason "${response.stopReason}"`);
+                }
+                if (isCopilotSdkSession(session) && await session.hasBackgroundAgents()) {
+                    backgroundAgentStarted = true;
+                    promoteBackgroundRoute();
                 }
                 const output = collector.getFinalText();
                 if (!output) {
-                    throw new Error('Copilot ACP returned empty output');
+                    if (backgroundAgentStarted) {
+                        return 'Background worker started.';
+                    }
+                    throw new Error('Copilot returned empty output');
                 }
                 return output;
             }
+            if (!isCopilotSdkSession(session) && backgroundAgentLaunches.consume(update)) {
+                noteBackgroundAgentStarted();
+            }
             collector.consume(update);
         }
     }
@@ -691,7 +1074,7 @@ export class CopilotCliClient {
         return Promise.race([promise, this.fatalPromise]);
     }
     handlePermissionRequest(params) {
-        const state = this.findChannelStateBySessionId(params.sessionId);
+        const lease = this.sessionAuthorizationLeases.get(params.sessionId);
         return resolveCopilotPermissionResponse({
             gateEnabled: this.permissionPolicy.gateEnabled ?? false,
             policyMode: this.permissionPolicy.policyMode ?? 'audit-only',
@@ -699,8 +1082,25 @@ export class CopilotCliClient {
             logger: this.logger,
             auditSink: this.permissionPolicy.auditSink,
             agentId: this.resolveSessionStoreAgentId()?.trim() || undefined,
-            channelId: state?.channelId,
-            toolPermissionMode: state?.toolPermissionMode ?? 'default',
+            channelId: lease?.channelId,
+            sessionBound: lease !== undefined,
+            toolPermissionMode: lease?.toolPermissionMode ?? 'default',
+        });
+    }
+    handleSdkPermissionRequest(request, sessionId) {
+        const lease = this.sessionAuthorizationLeases.get(sessionId);
+        return resolveCopilotSdkPermissionResponse({
+            gateEnabled: this.permissionPolicy.gateEnabled ?? false,
+            policyMode: this.permissionPolicy.policyMode ?? 'audit-only',
+            request,
+            sessionId,
+            logger: this.logger,
+            auditSink: this.permissionPolicy.auditSink,
+            auditSurface: 'copilot-sdk-permission',
+            agentId: this.resolveSessionStoreAgentId()?.trim() || undefined,
+            channelId: lease?.channelId,
+            sessionBound: lease !== undefined,
+            toolPermissionMode: lease?.toolPermissionMode ?? 'default',
         });
     }
     failAll(error) {
@@ -710,37 +1110,48 @@ export class CopilotCliClient {
         this.fatalError = error;
         this.rejectFatalPromise(error);
         this.idleBackendShutdown.cancel();
-        for (const [channelId, state] of this.channels.entries()) {
+        for (const [routingKey, state] of this.channels.entries()) {
             this.clearIdleTimer(state);
             state.activeTurn?.reject(error);
             for (const turn of state.queue) {
                 turn.reject(error);
             }
             state.queue.length = 0;
-            if (state.session) {
-                this.closeSession(state.session);
+            const session = state.session;
+            if (session) {
+                this.releaseWorkerRoute(state, session.sessionId);
+                this.closeSession(session);
+            }
+            else {
+                this.releaseWorkerRoute(state);
             }
             state.session = undefined;
             state.sessionCwd = undefined;
+            state.sessionHasBackgroundAgents = false;
+            state.sessionHasPendingAutonomousTurn = false;
             state.sessionPromise = undefined;
             state.activeTurn = undefined;
             if (!state.processing) {
-                this.channels.delete(channelId);
+                this.channels.delete(routingKey);
             }
         }
         this.channels.clear();
+        this.channelWorkerRoutes.clear();
         this.shutdownPromise = this.shutdownBackend(error);
     }
-    invalidateSession(channelId, state, session) {
+    invalidateSession(state, session) {
         this.clearIdleTimer(state);
         if (state.session === session) {
             state.session = undefined;
             state.sessionCwd = undefined;
+            state.sessionHasBackgroundAgents = false;
+            state.sessionHasPendingAutonomousTurn = false;
         }
-        this.logger?.debug('discarding tainted Copilot ACP session', { channelId });
+        this.releaseWorkerRoute(state, session.sessionId);
+        this.logger?.debug('discarding tainted Copilot session', { channelId: state.channelId });
         this.closeSession(session);
         if (!this.disposing && !this.backendClosed && state.sessionPersistence === 'persistent') {
-            void this.clearPersistedSessionBestEffort(channelId);
+            void this.clearPersistedSessionBestEffort(state.channelId, session.sessionId);
         }
     }
     closeSession(session) {
@@ -748,26 +1159,79 @@ export class CopilotCliClient {
             return;
         }
         this.closingSessions.add(session);
-        const agent = this.connection?.agent;
+        if (isCopilotSdkSession(session)) {
+            let trackedClosePromise;
+            trackedClosePromise = this.waitForSessionClose(session.close())
+                .then((closed) => {
+                if (closed) {
+                    this.sessionAuthorizationLeases.delete(session.sessionId);
+                    return;
+                }
+                if (!this.backendClosed && !this.backendShutdownInProgress) {
+                    this.logger?.debug('Copilot SDK session close timed out; recycling backend', {
+                        sessionId: session.sessionId,
+                        timeoutMs: this.runtime.sessionCloseTimeoutMs,
+                    });
+                    this.markSessionOrphaned(session);
+                }
+            })
+                .catch(() => {
+                if (!this.backendClosed && !this.backendShutdownInProgress) {
+                    this.markSessionOrphaned(session);
+                }
+            })
+                .finally(() => {
+                this.pendingSessionCloses.delete(trackedClosePromise);
+            });
+            this.pendingSessionCloses.add(trackedClosePromise);
+            return;
+        }
+        session.dispose();
+        if (!this.sessionCapabilities.closeSession || !this.connection) {
+            this.markSessionOrphaned(session);
+            return;
+        }
+        const agent = this.connection.agent;
         const closeMethod = this.runtime.methods.agent.session?.close;
-        const closePromise = typeof agent?.closeSession === 'function'
+        const closePromise = typeof agent.closeSession === 'function'
             ? agent.closeSession({ sessionId: session.sessionId })
             : closeMethod
-                ? this.connection?.agent.request(closeMethod, { sessionId: session.sessionId })
+                ? this.connection.agent.request(closeMethod, { sessionId: session.sessionId })
                 : undefined;
-        session.dispose();
         if (!closePromise) {
+            this.markSessionOrphaned(session);
             return;
         }
         let trackedClosePromise;
-        trackedClosePromise = Promise.resolve(closePromise)
-            .then(() => undefined)
-            .catch(() => { })
+        trackedClosePromise = this.waitForSessionClose(closePromise)
+            .then((closed) => {
+            if (closed) {
+                this.sessionAuthorizationLeases.delete(session.sessionId);
+                return;
+            }
+            if (!this.backendClosed && !this.backendShutdownInProgress) {
+                this.logger?.debug('Copilot session close timed out; recycling backend', {
+                    sessionId: session.sessionId,
+                    timeoutMs: this.runtime.sessionCloseTimeoutMs,
+                });
+                this.markSessionOrphaned(session);
+            }
+        })
+            .catch(() => {
+            if (!this.backendClosed && !this.backendShutdownInProgress) {
+                this.markSessionOrphaned(session);
+            }
+        })
             .finally(() => {
             this.pendingSessionCloses.delete(trackedClosePromise);
         });
         this.pendingSessionCloses.add(trackedClosePromise);
     }
+    markSessionOrphaned(session) {
+        this.orphanedSessions.add(session);
+        this.backendRecycleRequired = true;
+        this.reconcileBackendLifecycle();
+    }
     rejectQueuedTurnsAfterSessionTaint(state, error) {
         if (state.queue.length === 0) {
             return;
@@ -788,16 +1252,45 @@ export class CopilotCliClient {
         clearTimeout(state.idleTimer);
         state.idleTimer = undefined;
     }
-    findChannelStateBySessionId(sessionId) {
-        for (const state of this.channels.values()) {
-            if (state.session?.sessionId === sessionId) {
-                return state;
-            }
+    bindSessionAuthorization(session, state) {
+        this.sessionAuthorizationLeases.set(session.sessionId, {
+            channelId: state.channelId,
+            toolPermissionMode: state.toolPermissionMode ?? 'default',
+        });
+    }
+    promoteWorkerRoute(state, session) {
+        state.sessionHasBackgroundAgents = true;
+        this.channelWorkerRoutes.set(state.channelId, {
+            phase: 'promoted',
+            state,
+        });
+        state.sessionPersistence = 'persistent';
+        void this.persistSessionBestEffort(state, session.sessionId, state.sessionCwd ?? state.cwd ?? this.runtime.cwd, isCopilotSdkSession(session) ? session.backgroundTaskExecutionState() : undefined);
+    }
+    releaseWorkerRoute(state, sessionId) {
+        const route = this.channelWorkerRoutes.get(state.channelId);
+        if (route?.state !== state) {
+            return;
+        }
+        this.channelWorkerRoutes.delete(state.channelId);
+        if (route.phase === 'promoted' && sessionId) {
+            void this.clearPersistedSessionBestEffort(state.channelId, sessionId);
         }
-        return undefined;
     }
-    reconcileIdleChannelState(channelId, state) {
-        if (this.channels.get(channelId) !== state) {
+    releaseInactiveWorkerRoute(state) {
+        const route = this.channelWorkerRoutes.get(state.channelId);
+        if (route?.state !== state || route.phase !== 'promoted') {
+            return;
+        }
+        if (state.routingKey === state.channelId) {
+            this.releaseWorkerRoute(state);
+            return;
+        }
+        state.sessionPersistence = 'ephemeral';
+        this.releaseWorkerRoute(state, state.session?.sessionId);
+    }
+    reconcileIdleChannelState(state) {
+        if (this.channels.get(state.routingKey) !== state) {
             return;
         }
         if (this.disposing || this.fatalError || this.backendClosed) {
@@ -810,22 +1303,29 @@ export class CopilotCliClient {
         }
         if (!state.session) {
             this.clearIdleTimer(state);
-            this.channels.delete(channelId);
+            this.releaseWorkerRoute(state);
+            this.channels.delete(state.routingKey);
             return;
         }
-        if (state.sessionPersistence === 'ephemeral') {
+        if (!state.sessionHasBackgroundAgents && !state.sessionHasPendingAutonomousTurn) {
+            this.releaseInactiveWorkerRoute(state);
+        }
+        if (state.sessionPersistence === 'ephemeral'
+            && !state.sessionHasBackgroundAgents
+            && !state.sessionHasPendingAutonomousTurn) {
             this.clearIdleTimer(state);
             const session = state.session;
             state.session = undefined;
             state.sessionCwd = undefined;
+            this.releaseWorkerRoute(state);
             this.closeSession(session);
-            this.channels.delete(channelId);
+            this.channels.delete(state.routingKey);
             return;
         }
         this.clearIdleTimer(state);
         const generation = state.idleTimerGeneration;
         state.idleTimer = setTimeout(() => {
-            this.evictIdleChannel(channelId, state, generation);
+            this.evictIdleChannel(state, generation);
         }, this.runtime.idleSessionTtlMs);
     }
     async ensureSessionStoreLoaded() {
@@ -860,42 +1360,67 @@ export class CopilotCliClient {
             return undefined;
         }
         if (!record.cwd || record.cwd !== cwd) {
-            await this.clearPersistedSessionBestEffort(channelId);
+            await this.clearPersistedSessionBestEffort(channelId, record.sessionId);
             return undefined;
         }
         return record.sessionId;
     }
-    async persistSession(channelId, sessionId, cwd) {
+    isPersistentRouteOwner(state) {
+        const workerRoute = this.channelWorkerRoutes.get(state.channelId);
+        if (workerRoute) {
+            return workerRoute.state === state && state.sessionPersistence === 'persistent';
+        }
+        return this.channels.get(state.channelId) === state;
+    }
+    async persistSession(state, sessionId, cwd, backgroundTaskExecutions) {
         await this.ensureSessionStoreLoaded();
-        this.persistedSessions.set(channelId, { sessionId, cwd });
+        if (!this.isPersistentRouteOwner(state) || state.session?.sessionId !== sessionId) {
+            return;
+        }
+        const existingRecord = this.persistedSessions.get(state.channelId);
+        const retainedBackgroundTaskExecutions = backgroundTaskExecutions ??
+            (existingRecord?.sessionId === sessionId
+                ? existingRecord.backgroundTaskExecutions
+                : undefined);
+        this.persistedSessions.set(state.channelId, {
+            sessionId,
+            cwd,
+            ...(retainedBackgroundTaskExecutions
+                ? { backgroundTaskExecutions: { ...retainedBackgroundTaskExecutions } }
+                : {}),
+        });
         await this.flushSessionStore();
     }
-    async persistSessionBestEffort(channelId, sessionId, cwd) {
+    async persistSessionBestEffort(state, sessionId, cwd, backgroundTaskExecutions) {
         await this.trackSessionStoreOperation((async () => {
             try {
-                await this.persistSession(channelId, sessionId, cwd);
+                await this.persistSession(state, sessionId, cwd, backgroundTaskExecutions);
             }
             catch (error) {
                 this.logger.error('failed to persist Copilot session map; keeping reply delivery', {
                     agentId: this.loadedSessionStoreAgentId,
-                    channelId,
+                    channelId: state.channelId,
                     sessionId,
                     error: summarizeError(error),
                 });
             }
         })());
     }
-    async clearPersistedSession(channelId) {
+    async clearPersistedSession(channelId, expectedSessionId) {
         await this.ensureSessionStoreLoaded();
+        if (expectedSessionId
+            && this.persistedSessions.get(channelId)?.sessionId !== expectedSessionId) {
+            return;
+        }
         if (!this.persistedSessions.delete(channelId)) {
             return;
         }
         await this.flushSessionStore();
     }
-    async clearPersistedSessionBestEffort(channelId) {
+    async clearPersistedSessionBestEffort(channelId, expectedSessionId) {
         await this.trackSessionStoreOperation((async () => {
             try {
-                await this.clearPersistedSession(channelId);
+                await this.clearPersistedSession(channelId, expectedSessionId);
             }
             catch (error) {
                 this.logger.error('failed to clear Copilot session map; retrying in-memory only', {
@@ -926,89 +1451,178 @@ export class CopilotCliClient {
         this.pendingSessionStoreOperations.add(tracked);
         return tracked;
     }
-    evictIdleChannel(channelId, state, generation) {
+    evictIdleChannel(state, generation) {
         if (this.disposing || this.fatalError || this.backendClosed) {
             return;
         }
-        if (this.channels.get(channelId) !== state || state.idleTimerGeneration !== generation) {
+        if (this.channels.get(state.routingKey) !== state
+            || state.idleTimerGeneration !== generation) {
             return;
         }
         state.idleTimer = undefined;
-        if (state.activeTurn || state.queue.length > 0 || state.sessionPromise || state.processing) {
+        if (state.activeTurn
+            || state.queue.length > 0
+            || state.sessionPromise
+            || state.processing
+            || state.sessionHasPendingAutonomousTurn) {
             return;
         }
         const session = state.session;
         state.session = undefined;
         state.sessionCwd = undefined;
+        state.sessionHasBackgroundAgents = false;
+        state.sessionHasPendingAutonomousTurn = false;
         if (session) {
-            this.logger?.debug('evicting idle Copilot ACP session', { channelId });
+            this.logger?.debug('evicting idle Copilot session', { channelId: state.channelId });
+            this.releaseWorkerRoute(state, session.sessionId);
             this.closeSession(session);
         }
-        this.channels.delete(channelId);
+        else {
+            this.releaseWorkerRoute(state);
+        }
+        this.channels.delete(state.routingKey);
+        this.reconcileBackendLifecycle();
     }
     async shutdownBackend(error) {
         if (this.backendClosed) {
             return;
         }
         this.backendClosed = true;
-        await this.closeBackendProcess(error, this.runtime.shutdownGracePeriodMs);
+        const terminated = await this.closeBackendProcess(error, this.runtime.shutdownGracePeriodMs);
+        if (terminated) {
+            this.releaseBackendAuthorizationLeases();
+        }
     }
     /**
      * Backend teardown without the fatal latch: the client stays usable and
      * `ensureStarted()` spawns a replacement process on the next turn. Only safe
-     * while `isBackendIdle()` holds, because every channel's live ACP session is
+     * while `isBackendIdle()` holds, because every channel's live session is
      * dropped here and no turn is ever replayed onto its successor.
      */
     async shutdownIdleBackend() {
+        if (this.backendShutdownInProgress) {
+            return;
+        }
+        this.backendShutdownInProgress = true;
         // Detach the running backend before any signal reaches it, so its own exit
         // and connection-closed handlers read this teardown as deliberate instead
         // of latching a fatal error on a client that stays usable.
         this.backendGeneration += 1;
         const error = new Error(IDLE_BACKEND_STOPPED_MESSAGE);
         const sessions = [];
-        for (const [channelId, state] of [...this.channels.entries()]) {
+        for (const [routingKey, state] of [...this.channels.entries()]) {
             this.clearIdleTimer(state);
             if (state.session) {
                 sessions.push(state.session);
+                this.releaseWorkerRoute(state, state.session.sessionId);
+            }
+            else {
+                this.releaseWorkerRoute(state);
             }
             state.session = undefined;
             state.sessionCwd = undefined;
-            this.channels.delete(channelId);
+            state.sessionHasBackgroundAgents = false;
+            state.sessionHasPendingAutonomousTurn = false;
+            this.channels.delete(routingKey);
         }
-        this.logger?.debug('stopping idle Copilot ACP backend', {
+        this.channelWorkerRoutes.clear();
+        sessions.push(...this.orphanedSessions);
+        this.logger?.debug('stopping idle Copilot runtime backend', {
             channels: sessions.length,
             idleShutdownMs: this.runtime.idleBackendShutdownMs,
         });
         for (const session of sessions) {
             this.closeSession(session);
         }
-        const idleShutdownPromise = this.closeBackendProcess(error, this.runtime.idleShutdownGracePeriodMs).finally(() => {
+        const idleShutdownPromise = this.closeBackendProcess(error, this.runtime.idleShutdownGracePeriodMs).then((terminated) => {
+            if (!terminated) {
+                const terminationError = new Error('Copilot runtime backend termination could not be confirmed after SIGKILL');
+                this.backendClosed = true;
+                this.fatalError = terminationError;
+                this.rejectFatalPromise(terminationError);
+                throw terminationError;
+            }
+            this.releaseBackendAuthorizationLeases();
+        }).finally(() => {
             this.startPromise = undefined;
             this.childExitPromise = undefined;
+            this.sdkClient = undefined;
             this.sessionCapabilities = DEFAULT_SESSION_CAPABILITIES;
+            this.backendRecycleRequired = this.fatalError !== null;
+            this.backendShutdownInProgress = false;
             this.idleShutdownPromise = undefined;
         });
         this.idleShutdownPromise = idleShutdownPromise;
         await idleShutdownPromise;
     }
     isBackendIdle() {
-        if (this.disposing || this.fatalError || this.backendClosed || this.idleShutdownPromise) {
+        if (this.disposing
+            || this.fatalError
+            || this.backendClosed
+            || this.idleShutdownPromise
+            || this.backendShutdownInProgress) {
             return false;
         }
-        if (!this.child) {
+        if (!this.child && !this.sdkClient) {
             return false;
         }
         if (this.pendingSessionStarts.size > 0) {
             return false;
         }
         for (const state of this.channels.values()) {
-            if (state.activeTurn || state.queue.length > 0 || state.sessionPromise || state.processing) {
+            // The flag is deliberately sticky until that channel reaches its own
+            // cleanup boundary. Recycling sooner would erase the backend-owned
+            // read_agent/write_agent registry for another channel's worker.
+            if (state.activeTurn
+                || state.queue.length > 0
+                || state.sessionPromise
+                || state.processing
+                || state.sessionHasBackgroundAgents
+                || state.sessionHasPendingAutonomousTurn) {
                 return false;
             }
         }
         return true;
     }
+    reconcileBackendLifecycle() {
+        if (this.backendRecycleRequired && this.isBackendIdle()) {
+            if (!this.idleShutdownPromise) {
+                void this.shutdownIdleBackend().catch((error) => {
+                    this.logger.error('failed to recycle Copilot runtime backend after session cleanup', {
+                        error: summarizeError(error),
+                    });
+                });
+            }
+            return;
+        }
+        this.idleBackendShutdown.reconcile();
+    }
+    releaseBackendAuthorizationLeases() {
+        this.sessionAuthorizationLeases.clear();
+        this.orphanedSessions.clear();
+    }
     async closeBackendProcess(error, gracePeriodMs) {
+        if (this.sdkClient) {
+            const sdkClient = this.sdkClient;
+            this.sdkClient = undefined;
+            await this.waitForPendingSessionStarts();
+            await this.waitForPendingSessionCloses();
+            const stopPromise = sdkClient.stop();
+            const stopResult = await Promise.race([
+                stopPromise.then((errors) => ({ completed: true, errors })),
+                new Promise((resolvePromise) => {
+                    setTimeout(() => resolvePromise({ completed: false }), gracePeriodMs);
+                }),
+            ]);
+            if (!stopResult.completed) {
+                await sdkClient.forceStop();
+                return true;
+            }
+            if (stopResult.errors.length > 0) {
+                throw new AggregateError(stopResult.errors, error.message);
+            }
+            return true;
+        }
         const connection = this.connection;
         const child = this.child;
         await this.waitForPendingSessionStarts();
@@ -1017,7 +1631,7 @@ export class CopilotCliClient {
         this.connection = undefined;
         if (!child) {
             this.child = undefined;
-            return;
+            return true;
         }
         const childExitPromise = this.childExitPromise ?? Promise.resolve();
         this.logger?.debug('sending SIGTERM to Copilot ACP process', { gracePeriodMs });
@@ -1026,12 +1640,13 @@ export class CopilotCliClient {
         if (exitedAfterTerm) {
             this.logger?.debug('Copilot ACP process exited after SIGTERM');
             this.child = undefined;
-            return;
+            return true;
         }
         this.logger?.debug('sending SIGKILL to Copilot ACP process after SIGTERM grace timeout');
         child.kill('SIGKILL');
-        await this.waitForChildExit(childExitPromise, this.runtime.shutdownForceKillWaitMs);
+        const exitedAfterKill = await this.waitForChildExit(childExitPromise, this.runtime.shutdownForceKillWaitMs);
         this.child = undefined;
+        return exitedAfterKill;
     }
     async waitForPendingSessionStarts() {
         if (this.pendingSessionStarts.size === 0) {
@@ -1055,6 +1670,25 @@ export class CopilotCliClient {
             }),
         ]);
     }
+    async waitForSessionClose(closePromise) {
+        if (this.runtime.sessionCloseTimeoutMs <= 0) {
+            return false;
+        }
+        let timeout;
+        try {
+            return await Promise.race([
+                Promise.resolve(closePromise).then(() => true),
+                new Promise((resolve) => {
+                    timeout = setTimeout(() => resolve(false), this.runtime.sessionCloseTimeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+        }
+    }
     async waitForChildExit(childExitPromise, timeoutMs) {
         if (timeoutMs <= 0) {
             return false;