@borgee/agents-host 0.2.74 → 0.2.84

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

@@ -1,6 +1,6 @@
 import type { DebugLogger } from '../debug.js';
 import type { InternalPolicyMode } from '../compatibility-gates.js';
-export type AuthorizationAuditSurface = 'copilot-acp-permission' | 'localhost-gateway';
+export type AuthorizationAuditSurface = 'copilot-acp-permission' | 'copilot-sdk-permission' | 'localhost-gateway';
 export interface AuthorizationAuditRecord {
     timestamp: string;
     surface: AuthorizationAuditSurface;

package/dist/policy/copilot-permission.d.ts

@@ -1,7 +1,9 @@
 import type { RequestPermissionRequest, RequestPermissionResponse } from '@agentclientprotocol/sdk';
+import type { PermissionRequest as CopilotSdkPermissionRequest, PermissionRequestResult as CopilotSdkPermissionRequestResult } from '@github/copilot-sdk';
 import type { DebugLogger } from '../debug.js';
 import type { InternalPolicyMode } from '../compatibility-gates.js';
 import type { AuthorizationAuditSinkLike } from './authorization-audit.js';
+import type { AuthorizationAuditSurface } from './authorization-audit.js';
 export interface CopilotPermissionPolicyContext {
     gateEnabled: boolean;
     policyMode: InternalPolicyMode;
@@ -10,7 +12,14 @@ export interface CopilotPermissionPolicyContext {
     auditSink?: AuthorizationAuditSinkLike;
     agentId?: string;
     channelId?: string;
+    sessionBound?: boolean;
     toolPermissionMode?: 'default' | 'deny-all';
+    auditSurface?: AuthorizationAuditSurface;
+}
+export interface CopilotSdkPermissionPolicyContext extends Omit<CopilotPermissionPolicyContext, 'params'> {
+    request: CopilotSdkPermissionRequest;
+    sessionId: string;
 }
 export declare function resolveCopilotPermissionResponse(context: CopilotPermissionPolicyContext): RequestPermissionResponse;
+export declare function resolveCopilotSdkPermissionResponse(context: CopilotSdkPermissionPolicyContext): CopilotSdkPermissionRequestResult;
 export declare function createLegacyMissingAllowOptionError(): Error;

package/dist/policy/copilot-permission.js

@@ -1,5 +1,8 @@
 import { summarizeError } from '../debug.js';
 const LEGACY_MISSING_ALLOW_OPTION_MESSAGE = 'Copilot ACP requested permission but did not offer an allow option';
+const SDK_APPROVE_FOR_SESSION_OPTION_ID = 'sdk-approve-for-session';
+const SDK_APPROVE_ONCE_OPTION_ID = 'sdk-approve-once';
+const SDK_REJECT_OPTION_ID = 'sdk-reject';
 function legacySelectPermissionOption(options) {
     const option = options.find((candidate) => candidate.kind === 'allow_always')
         ?? options.find((candidate) => candidate.kind === 'allow_once');
@@ -71,7 +74,7 @@ function decisionToResponse(decision) {
 function appendAuditRecord(context, effectiveDecision, reason, policyDecision) {
     context.auditSink?.append({
         timestamp: new Date().toISOString(),
-        surface: 'copilot-acp-permission',
+        surface: context.auditSurface ?? 'copilot-acp-permission',
         policyMode: context.policyMode,
         effectiveOutcome: effectiveDecision?.outcome ?? 'error',
         reason,
@@ -84,6 +87,30 @@ function appendAuditRecord(context, effectiveDecision, reason, policyDecision) {
     });
 }
 export function resolveCopilotPermissionResponse(context) {
+    if (context.sessionBound === false) {
+        const rejectOption = resolveRejectOption(context.params.options);
+        const unboundDecision = rejectOption
+            ? {
+                outcome: 'selected',
+                optionId: rejectOption.optionId,
+                optionKind: rejectOption.kind,
+                reason: 'unbound-session',
+                toolKind: normalizeToolKind(context.params.toolCall.kind),
+            }
+            : {
+                outcome: 'cancelled',
+                reason: 'unbound-session',
+                toolKind: normalizeToolKind(context.params.toolCall.kind),
+            };
+        context.logger.error('Copilot ACP permission request rejected for an unbound session', {
+            agentId: context.agentId,
+            sessionId: context.params.sessionId,
+            toolKind: unboundDecision.toolKind,
+            reason: unboundDecision.reason,
+        });
+        appendAuditRecord(context, unboundDecision, unboundDecision.reason, unboundDecision);
+        return decisionToResponse(unboundDecision);
+    }
     if (context.toolPermissionMode === 'deny-all') {
         const rejectOption = resolveRejectOption(context.params.options);
         const deniedDecision = rejectOption
@@ -206,6 +233,98 @@ export function resolveCopilotPermissionResponse(context) {
         return decisionToResponse(failedClosedDecision);
     }
 }
+function sdkPermissionToolKind(request) {
+    switch (request.kind) {
+        case 'read':
+            return 'read';
+        case 'write':
+            return 'edit';
+        case 'shell':
+            return 'execute';
+        case 'url':
+            return 'fetch';
+        default:
+            return 'other';
+    }
+}
+function sdkPermissionTitle(request) {
+    if ('fullCommandText' in request && typeof request.fullCommandText === 'string') {
+        return request.fullCommandText;
+    }
+    if ('fileName' in request && typeof request.fileName === 'string') {
+        return request.fileName;
+    }
+    if ('toolName' in request && typeof request.toolName === 'string') {
+        return request.toolName;
+    }
+    return request.kind;
+}
+export function resolveCopilotSdkPermissionResponse(context) {
+    if (context.request.managedApprovalRequired === true) {
+        context.auditSink?.append({
+            timestamp: new Date().toISOString(),
+            surface: context.auditSurface ?? 'copilot-sdk-permission',
+            policyMode: context.policyMode,
+            effectiveOutcome: 'rejected',
+            reason: 'managed-approval-required',
+            agentId: context.agentId,
+            channelId: context.channelId,
+            selectedOptionKind: 'reject_once',
+            policyOutcome: 'selected',
+            policySelectedOptionKind: 'reject_once',
+            toolKind: sdkPermissionToolKind(context.request),
+        });
+        return {
+            kind: 'reject',
+            feedback: 'Managed policy requires interactive approval, which this hosted runtime cannot provide.',
+        };
+    }
+    const options = [
+        {
+            optionId: SDK_APPROVE_FOR_SESSION_OPTION_ID,
+            name: 'Allow for this session',
+            kind: 'allow_always',
+        },
+        {
+            optionId: SDK_APPROVE_ONCE_OPTION_ID,
+            name: 'Allow once',
+            kind: 'allow_once',
+        },
+        {
+            optionId: SDK_REJECT_OPTION_ID,
+            name: 'Reject',
+            kind: 'reject_once',
+        },
+    ];
+    const response = resolveCopilotPermissionResponse({
+        ...context,
+        params: {
+            sessionId: context.sessionId,
+            toolCall: {
+                toolCallId: requestToolCallId(context.request),
+                title: sdkPermissionTitle(context.request),
+                kind: sdkPermissionToolKind(context.request),
+            },
+            options,
+        },
+    });
+    if (response.outcome.outcome !== 'selected') {
+        return { kind: 'reject' };
+    }
+    switch (response.outcome.optionId) {
+        case SDK_APPROVE_FOR_SESSION_OPTION_ID:
+            return { kind: 'approve-for-session' };
+        case SDK_APPROVE_ONCE_OPTION_ID:
+            return { kind: 'approve-once' };
+        default:
+            return { kind: 'reject' };
+    }
+}
+function requestToolCallId(request) {
+    return 'toolCallId' in request && typeof request.toolCallId === 'string'
+        ? request.toolCallId
+        : 'copilot-sdk-permission';
+}
 export function createLegacyMissingAllowOptionError() {
     return new Error(LEGACY_MISSING_ALLOW_OPTION_MESSAGE);
 }

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

@@ -2,7 +2,7 @@ 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';
+    shape: 'turn' | 'background_run';
 }>;
 /**
  * Restates one progress update in the rail's own vocabulary.

package/dist/progress-to-activity.js

@@ -19,6 +19,7 @@ export function toReportedActivity(update) {
         case 'activity':
             return { shape: 'activity', ...update.activity };
         case 'compaction':
+        case 'background_run':
             return null;
     }
 }

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

@@ -7,7 +7,7 @@ export declare class ClaudeProviderAdapter implements ProviderAdapter {
     private readonly cli;
     private readonly turnPreparer;
     readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
-    constructor(cli: ClaudeCliClient, turnPreparer: ProviderTurnPreparer);
+    constructor(cli: ClaudeCliClient, turnPreparer: Pick<ProviderTurnPreparer, 'prepare'>);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
     cancelTurn(channelId: string): Promise<boolean>;
     dispose(): Promise<void>;

package/dist/providers/claude/adapter.js

@@ -7,6 +7,13 @@ export const CLAUDE_HOSTED_PROVIDER_CAPABILITIES = createHostedProviderCapabilit
         reason: 'real-media-delivered',
         delivery: ['blob'],
     },
+    progressUpdates: {
+        support: 'supported',
+    },
+    backgroundRuns: {
+        lifecycle: 'not-supported',
+        targetedCancellation: 'not-supported',
+    },
 });
 export class ClaudeProviderAdapter {
     cli;

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

@@ -13,7 +13,7 @@ import { ProviderTurnCancelledError } from '../provider-adapter.js';
 import { readClaudeActivityMetadata } from './activity-metadata.js';
 import { resolveCopilotPermissionResponse } from '../../policy/copilot-permission.js';
 import { buildClaudeSessionPromptAppend } from '../../context/prompt.js';
-import { isDiscussionOnlyResolvedWorkspace } from '../../context/resolved-workspace.js';
+import { isDiscussionOnlyResolvedWorkingFolder } from '../../context/resolved-working-folder.js';
 import { IDLE_BACKEND_SHUTDOWN_DISABLED_MS, IdleBackendShutdownScheduler, } from '../idle-backend-shutdown.js';
 const SESSION_TAINTED_ERRORS = new WeakSet();
 const IDLE_BACKEND_STOPPED_MESSAGE = 'Claude ACP backend stopped after idle timeout';
@@ -761,7 +761,7 @@ export class ClaudeCliClient {
                     state.activeTurn = turn;
                     try {
                         state.cwd = this.resolveSessionCwd(turn.preparedTurn.promptContext);
-                        state.toolPermissionMode = isDiscussionOnlyResolvedWorkspace(turn.preparedTurn.promptContext)
+                        state.toolPermissionMode = isDiscussionOnlyResolvedWorkingFolder(turn.preparedTurn.promptContext)
                             ? 'deny-all'
                             : 'default';
                         const sessionPromptAppend = resolveTurnSessionPromptAppend(turn.preparedTurn);
@@ -939,7 +939,7 @@ export class ClaudeCliClient {
         }
     }
     resolveSessionCwd(promptContext) {
-        return promptContext?.resolvedWorkspace?.rootPath ?? this.runtime.cwd;
+        return promptContext?.resolvedWorkingFolder?.rootPath ?? this.runtime.cwd;
     }
     async recycleSessionIfScopeChanged(channelId, state) {
         const session = state.session;
@@ -1055,6 +1055,7 @@ export class ClaudeCliClient {
             logger: this.logger,
             agentId: this.resolveSessionStoreAgentId()?.trim() || undefined,
             channelId: state?.channelId,
+            sessionBound: state !== undefined,
             toolPermissionMode: state?.toolPermissionMode ?? 'default',
         });
     }

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

@@ -7,7 +7,7 @@ export declare class CodexProviderAdapter implements ProviderAdapter {
     private readonly cli;
     private readonly turnPreparer;
     readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
-    constructor(cli: CodexCliClient, turnPreparer: ProviderTurnPreparer);
+    constructor(cli: CodexCliClient, turnPreparer: Pick<ProviderTurnPreparer, 'prepare'>);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
     cancelTurn(channelId: string): Promise<boolean>;
     dispose(): Promise<void>;

package/dist/providers/codex/adapter.js

@@ -7,6 +7,13 @@ export const CODEX_HOSTED_PROVIDER_CAPABILITIES = createHostedProviderCapabiliti
         reason: 'real-media-delivered',
         delivery: ['blob'],
     },
+    progressUpdates: {
+        support: 'supported',
+    },
+    backgroundRuns: {
+        lifecycle: 'not-supported',
+        targetedCancellation: 'not-supported',
+    },
 });
 export class CodexProviderAdapter {
     cli;

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

@@ -9,7 +9,7 @@ import { AcpProgressCollector } from '../acp-progress-collector.js';
 import { ProviderTurnCancelledError } from '../provider-adapter.js';
 import { assertCodexProjectDocumentSize, buildCodexProjectDocument } from './project-doc.js';
 import { isGatewayCredentialSidecarBasename } from '../../context/injection.js';
-import { isDiscussionOnlyResolvedWorkspace } from '../../context/resolved-workspace.js';
+import { isDiscussionOnlyResolvedWorkingFolder } from '../../context/resolved-working-folder.js';
 import { resolveCopilotPermissionResponse } from '../../policy/copilot-permission.js';
 import { IDLE_BACKEND_SHUTDOWN_DISABLED_MS, IdleBackendShutdownScheduler, } from '../idle-backend-shutdown.js';
 const SESSION_TAINTED_ERRORS = new WeakSet();
@@ -488,7 +488,7 @@ export class CodexCliClient {
                     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 projectedPromptContext = await this.refreshProjectedPromptContextBestEffort(turn.channelId, turn.preparedTurn.promptContext);
@@ -658,7 +658,7 @@ export class CodexCliClient {
         }
     }
     async resolveSessionCwd(promptContext) {
-        return promptContext?.resolvedWorkspace?.rootPath ?? this.runtime.cwd;
+        return promptContext?.resolvedWorkingFolder?.rootPath ?? this.runtime.cwd;
     }
     async recycleSessionIfInjectionScopeChanged(channelId, state) {
         const session = state.session;
@@ -969,7 +969,9 @@ export class CodexCliClient {
             policyMode: 'enforce',
             params,
             logger: this.logger,
+            agentId: this.resolveSessionStoreAgentId()?.trim() || undefined,
             channelId: state?.channelId,
+            sessionBound: state !== undefined,
             toolPermissionMode: state?.toolPermissionMode ?? 'default',
         });
     }
@@ -1136,6 +1138,7 @@ export class CodexCliClient {
             this.closeSession(session);
         }
         this.channels.delete(channelId);
+        this.idleBackendShutdown.reconcile();
     }
     async shutdownBackend(error) {
         if (this.backendClosed) {
@@ -1194,10 +1197,8 @@ export class CodexCliClient {
         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) {
-                return false;
-            }
+        if (this.channels.size > 0) {
+            return false;
         }
         return true;
     }

package/dist/providers/codex/project-doc.js

@@ -2,12 +2,12 @@ import { buildAttentionSummaryLines } from '../../context/attention.js';
 import { buildCollaborationCapabilityDeclarationSummaryLines, buildMissedCollaborationDiagnosticSummaryLines, } from '../../context/collaboration-capabilities-diagnostics.js';
 import { buildCollaborationOutcomeSummaryLines } from '../../context/collaboration-outcome.js';
 import { MAIN_SESSION_DELEGATION_LINES } from '../../context/main-session-delegation.js';
-import { buildResolvedWorkspaceGuidanceLines } from '../../context/resolved-workspace.js';
+import { buildResolvedWorkingFolderGuidanceLines } from '../../context/resolved-working-folder.js';
 import { buildSkillManualLines, buildSkillManualReadLine } from '../../context/skill-manual.js';
 import { buildTaskThreadCollaborationSummaryLines } from '../../context/task-thread-collaboration.js';
 const PROJECT_DOC_MAX_BYTES = 32 * 1024;
 // Every command the CLI carries needs the gateway credential file, so the capability is only
-// worth naming in a workspace that also names one; otherwise the model is handed an invocation
+// worth naming in a project document that also names one; otherwise the model is handed an invocation
 // template it cannot fill.
 function buildSkillRuntimeLines(context) {
     if (!context?.skillRuntime) {
@@ -29,15 +29,15 @@ function buildGatewayCredentialLines(context) {
 export function buildCodexProjectDocument(context) {
     const sessionDelegationLines = context?.skillRuntime ? [] : MAIN_SESSION_DELEGATION_LINES;
     const lines = [
-        '# Borgee channel workspace',
+        '# Borgee channel session',
         '',
-        'This workspace belongs to one Borgee channel session hosted by agents-host.',
+        'This directory belongs to one Borgee channel session hosted by agents-host.',
         'Keep visible replies concise, do not claim actions you did not perform, and prefer the per-turn prompt when it provides newer turn-local details.',
         '',
         ...sessionDelegationLines,
         ...(() => {
-            const workspaceLines = buildResolvedWorkspaceGuidanceLines(context);
-            return workspaceLines.length > 0 ? ['', ...workspaceLines] : [];
+            const workingFolderLines = buildResolvedWorkingFolderGuidanceLines(context);
+            return workingFolderLines.length > 0 ? ['', ...workingFolderLines] : [];
         })(),
         ...(() => {
             const collaborationOutcomeLines = buildCollaborationOutcomeSummaryLines(context?.collaborationOutcome);

package/dist/providers/copilot/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 { CopilotCliClient } from './cli-client.js';
 export declare const COPILOT_HOSTED_PROVIDER_CAPABILITIES: import("../provider-adapter.js").ProviderCapabilities;
@@ -7,8 +7,12 @@ export declare class CopilotProviderAdapter implements ProviderAdapter {
     private readonly cli;
     private readonly turnPreparer;
     readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
-    constructor(cli: CopilotCliClient, turnPreparer: ProviderTurnPreparer);
+    constructor(cli: CopilotCliClient, turnPreparer: Pick<ProviderTurnPreparer, 'prepare'>);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
+    onAutonomousReply(handler: ((reply: ProviderAutonomousReply) => void) | undefined): void;
     cancelTurn(channelId: string): Promise<boolean>;
+    interruptTurn(channelId: string): Promise<boolean>;
+    cancelSession(channelId: string): Promise<boolean>;
+    cancelBackgroundRun(channelId: string, providerRunId: string): Promise<boolean>;
     dispose(): Promise<void>;
 }

package/dist/providers/copilot/adapter.js

@@ -7,6 +7,13 @@ export const COPILOT_HOSTED_PROVIDER_CAPABILITIES = createHostedProviderCapabili
         reason: 'real-media-delivered',
         delivery: ['blob'],
     },
+    progressUpdates: {
+        support: 'supported',
+    },
+    backgroundRuns: {
+        lifecycle: 'supported',
+        targetedCancellation: 'supported',
+    },
 });
 export class CopilotProviderAdapter {
     cli;
@@ -25,8 +32,27 @@ export class CopilotProviderAdapter {
         // 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);
+        return this.cli.cancelSession(channelId);
+    }
+    async interruptTurn(channelId) {
+        return this.cli.interruptTurn(channelId);
+    }
+    async cancelSession(channelId) {
+        return this.cli.cancelSession(channelId);
+    }
+    async cancelBackgroundRun(channelId, providerRunId) {
+        return this.cli.cancelBackgroundRun(channelId, providerRunId);
     }
     async dispose() {
         await this.cli.dispose();

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

@@ -3,9 +3,12 @@ import { PROTOCOL_VERSION, client, methods, ndJsonStream } from '@agentclientpro
 import { type DebugLogger } from '../../debug.js';
 import type { InternalPolicyMode } from '../../compatibility-gates.js';
 import type { AuthorizationAuditSinkLike } from '../../policy/authorization-audit.js';
-import type { PreparedProviderTurnInput, ProviderGenerateOptions } from '../../types.js';
+import type { PreparedProviderTurnInput, ProviderAutonomousReply, ProviderGenerateOptions } from '../../types.js';
 import type { CopilotChannelSessionStore } from './session-store.js';
-interface CopilotAcpRuntime {
+import { type CopilotSdkClientFactory } from './sdk-session.js';
+interface CopilotRuntime {
+    transport: 'sdk' | 'acp';
+    createSdkClient: CopilotSdkClientFactory;
     spawn: typeof spawn;
     client: typeof client;
     ndJsonStream: typeof ndJsonStream;
@@ -15,6 +18,7 @@ interface CopilotAcpRuntime {
     idleSessionTtlMs: number;
     idleBackendShutdownMs: number;
     idleShutdownGracePeriodMs: number;
+    sessionCloseTimeoutMs: number;
     shutdownGracePeriodMs: number;
     shutdownForceKillWaitMs: number;
     fetch(input: string | URL, init?: RequestInit): Promise<Response>;
@@ -29,12 +33,12 @@ interface CopilotHostedImageInputConfig {
     agentApiKey?: string;
 }
 /**
- * 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 declare class CopilotCliClient {
     private readonly command;
@@ -45,15 +49,21 @@ export declare class CopilotCliClient {
     private readonly imageInputConfig;
     private readonly runtime;
     private readonly channels;
+    private readonly channelWorkerRoutes;
+    private readonly sessionAuthorizationLeases;
     /**
      * 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: string): string | undefined;
+    interruptTurn(channelId: string): Promise<boolean>;
+    cancelSession(channelId: string): Promise<boolean>;
     cancelTurn(channelId: string): Promise<boolean>;
+    cancelBackgroundRun(channelId: string, providerRunId: string): Promise<boolean>;
     private readonly persistedSessions;
     private readonly closingSessions;
+    private readonly orphanedSessions;
     private readonly pendingSessionStarts;
     private readonly pendingSessionCloses;
     private readonly pendingSessionStoreOperations;
@@ -61,6 +71,7 @@ export declare class CopilotCliClient {
     private rejectFatalPromise;
     private child?;
     private connection?;
+    private sdkClient?;
     private startPromise?;
     private shutdownPromise?;
     private childExitPromise?;
@@ -71,6 +82,7 @@ export declare class CopilotCliClient {
      */
     private backendGeneration;
     private idleShutdownPromise?;
+    private backendShutdownInProgress;
     private fatalError;
     private disposing;
     private backendClosed;
@@ -78,19 +90,25 @@ export declare class CopilotCliClient {
     private sessionStoreLoadPromise;
     private sessionStoreWriteQueue;
     private sessionCapabilities;
+    private backendRecycleRequired;
+    private autonomousReplyHandler?;
     private readonly idleBackendShutdown;
-    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>, sessionStore?: CopilotChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger, permissionPolicy?: CopilotPermissionPolicyOptions, imageInputConfig?: CopilotHostedImageInputConfig);
+    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotRuntime>, sessionStore?: CopilotChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger, permissionPolicy?: CopilotPermissionPolicyOptions, imageInputConfig?: CopilotHostedImageInputConfig);
     generateReply(turn: PreparedProviderTurnInput, options?: ProviderGenerateOptions): Promise<string>;
     generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
+    onAutonomousReply(handler: ((reply: ProviderAutonomousReply) => void) | undefined): void;
     dispose(): Promise<void>;
     private ensureStarted;
     private startBackend;
+    private startSdkBackend;
     private getOrCreateChannelState;
+    private resolveChannelState;
     private processChannelQueue;
     private getOrCreateSession;
     private startFreshSession;
     private restoreOrCreateSession;
     private restoreSession;
+    private createSdkSessionAdapter;
     private clearBufferedSessionReplay;
     private resolveSessionCwd;
     private buildPromptInput;
@@ -99,15 +117,21 @@ export declare class CopilotCliClient {
     private runTurn;
     private raceWithFatal;
     private handlePermissionRequest;
+    private handleSdkPermissionRequest;
     private failAll;
     private invalidateSession;
     private closeSession;
+    private markSessionOrphaned;
     private rejectQueuedTurnsAfterSessionTaint;
     private clearIdleTimer;
-    private findChannelStateBySessionId;
+    private bindSessionAuthorization;
+    private promoteWorkerRoute;
+    private releaseWorkerRoute;
+    private releaseInactiveWorkerRoute;
     private reconcileIdleChannelState;
     private ensureSessionStoreLoaded;
     private readPersistedSessionId;
+    private isPersistentRouteOwner;
     private persistSession;
     private persistSessionBestEffort;
     private clearPersistedSession;
@@ -119,14 +143,17 @@ export declare class CopilotCliClient {
     /**
      * 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.
      */
     private shutdownIdleBackend;
     private isBackendIdle;
+    private reconcileBackendLifecycle;
+    private releaseBackendAuthorizationLeases;
     private closeBackendProcess;
     private waitForPendingSessionStarts;
     private waitForPendingSessionCloses;
+    private waitForSessionClose;
     private waitForChildExit;
 }
 export {};