@factory/droid-sdk 0.10.0 → 0.11.0

package/dist/node.mjs

@@ -8,6 +8,7 @@ import {
   AddUserMessageRequestSchema,
   AddUserMessageResponseSchema,
   AddUserMessageResultSchema,
+  AnswerSessionElicitationResponseSchema,
   AppendMessagesResponseSchema,
   ApplyPatchToolConfirmationDetailsSchema,
   AskUserCollectedAnswerSchema,
@@ -62,6 +63,7 @@ import {
   ComputerListResponseSchema,
   ComputerMetricSchema,
   ComputerMetricsResponseSchema,
+  ComputerReadSchema,
   ComputerSchema,
   ConcurrentStreamError,
   ConnectionClosedError,
@@ -74,8 +76,10 @@ import {
   ContextStatsSchema,
   CreateMessageNotificationSchema,
   CreateToolConfirmationDetailsSchema,
+  DEFAULT_CONNECTION_CONFIG,
   DEFAULT_LOCAL_DAEMON_WS_URL,
   DEFAULT_REQUEST_TIMEOUT,
+  DROID_RUNNING_STATES,
   DaemonAuthenticationMode,
   DaemonClient,
   DaemonDroidEvent,
@@ -89,6 +93,7 @@ import {
   DocumentSourceSchema,
   DroidClientError,
   DroidClientMethod,
+  DroidConnectionEndedError,
   DroidErrorType,
   DroidEvent,
   DroidHookEventSchema,
@@ -102,6 +107,9 @@ import {
   DroidWorkingStateChangedNotificationSchema,
   EditToolConfirmationDetailsSchema,
   EmptyResultSchema,
+  EnvironmentComputerTimeoutError,
+  EnvironmentListResponseSchema,
+  EnvironmentSchema,
   ErrorDetailSchema,
   ErrorNotificationSchema,
   ExecToolInfoSchema,
@@ -115,7 +123,6 @@ import {
   FACTORY_CLIENT_HEADER,
   FACTORY_CLIENT_VERSION,
   FACTORY_PROTOCOL_VERSION,
-  FACTORY_PROTOCOL_VERSION2,
   FactoryDaemonTransport,
   FactoryDroidMessageRole,
   FactoryDroidMessageSchema,
@@ -131,6 +138,7 @@ import {
   GetContextStatsRequestParamsSchema,
   GetContextStatsRequestSchema,
   GetContextStatsResponseSchema,
+  GetHandoffSummaryResponseSchema,
   GetRewindInfoRequestParamsSchema,
   GetRewindInfoRequestSchema,
   GetRewindInfoResponseSchema,
@@ -162,7 +170,6 @@ import {
   IssueSeverity,
   JSONRPC_VERSION,
   JSONRPC_VERSION2,
-  JSONRPC_VERSION3,
   JsonArraySchema,
   JsonObjectSchema,
   JsonRpcBaseResponseSchema,
@@ -178,6 +185,7 @@ import {
   JsonRpcResponseSchema,
   JsonRpcResponseSuccessSchema,
   JsonValueSchema,
+  KillBackgroundProcessResponseSchema,
   KillWorkerSessionRequestParamsSchema,
   KillWorkerSessionRequestSchema,
   KillWorkerSessionResponseSchema,
@@ -202,6 +210,7 @@ import {
   ListModelsOptionsSchema,
   ListModelsResponseSchema,
   ListModelsResultSchema,
+  ListSessionElicitationsResponseSchema,
   ListSkillsRequestParamsSchema,
   ListSkillsRequestSchema,
   ListSkillsResponseSchema,
@@ -216,6 +225,7 @@ import {
   LoadSessionRequestSchema,
   LoadSessionResponseSchema,
   LoadSessionResultSchema,
+  MACHINE_TYPE_CONFIG,
   MACHINE_TYPE_WEBSOCKET_OVERRIDES,
   MANAGED_COMPUTER_MAX_RETRIES,
   MCP_AUTH_TIMEOUT,
@@ -248,6 +258,7 @@ import {
   MissionFeatureSchema,
   MissionFeaturesChangedNotificationSchema,
   MissionHeartbeatNotificationSchema,
+  MissionMachineTargetKind,
   MissionPausedEntrySchema,
   MissionProgressEntryNotificationSchema,
   MissionResumedEntrySchema,
@@ -295,6 +306,7 @@ import {
   RenameSessionRequestSchema,
   RenameSessionResponseSchema,
   RenameSessionResultSchema,
+  RequestCancelledError,
   RequestPermissionRequestParamsSchema,
   RequestPermissionRequestSchema,
   RequestPermissionResponseSchema,
@@ -303,12 +315,14 @@ import {
   RewindEvictedFileSchema,
   RewindFileCreationSchema,
   RewindFileSnapshotSchema,
+  SDK_CLIENT_METADATA,
   SDK_IDENTITY,
   SDK_REQUEST_ATTRIBUTION,
   SDK_TAG,
   SDK_VERSION,
   SESSION_INIT_TIMEOUT,
   SLACK_DELEGATION_MAX_RETRIES,
+  SandboxEnvironmentSchema,
   ServerRequestHandlerType,
   SessionArtifactAction,
   SessionArtifactKind,
@@ -316,6 +330,7 @@ import {
   SessionArtifactSchema,
   SessionArtifactSource,
   SessionArtifactsSchema,
+  SessionElicitationSchema,
   SessionError,
   SessionMetadataSchema,
   SessionNotFoundError,
@@ -366,6 +381,7 @@ import {
   SubmitMcpAuthCodeResultSchema,
   SubmitMcpAuthErrorResponseSchema,
   SuccessResultSchema,
+  SummarizeForMembersResponseSchema,
   TestCaseSchema,
   TestFileSchema,
   TestsSchema,
@@ -417,6 +433,7 @@ import {
   WorkerSelectedFeatureEntrySchema,
   WorkerStartedEntrySchema,
   WorkerStateInfoSchema,
+  answerRemoteSessionElicitation,
   appendContextSession,
   buildUserMessageContentBlocks,
   configureDaemonCoreDeps,
@@ -424,10 +441,13 @@ import {
   connectToDaemon,
   connectWithRetry,
   convertNotificationToStreamMessage,
+  createApiRequest,
   createComputer,
   createContextDocument,
   createContextFile,
   createContextSpace,
+  createFactoryApi,
+  createOrRecoverComputer,
   createResponseSchema,
   createWebSocketDaemonClient,
   defaultDaemonCoreDeps,
@@ -435,6 +455,7 @@ import {
   deleteContextDocument,
   deleteContextFile,
   emitDroidLog,
+  encodeLegacyStartupLoadOptions,
   escapeJsonLineSeparators,
   extractInnerNotification,
   filterMessagesForUI,
@@ -449,6 +470,8 @@ import {
   getPermissionToolInputForDisplay,
   getQueuedUserMessageDisplayGroup,
   getQueuedUserMessageReviewPriority,
+  getSandboxEnvironmentLaunchRepositories,
+  getSandboxEnvironmentLaunchSource,
   getSubagentCallingMetadata,
   getToolResultBlocks,
   getToolResultToolUseId,
@@ -457,38 +480,51 @@ import {
   injectDroidTraceContext,
   inspectJsonRpcEnvelope,
   isDaemonQueuedMessageKind,
+  isEnvironmentComputerReady,
+  isOfferedPermissionOutcome,
   isPendingToolResultMarker,
   isPersistedHookMessage,
   isProtocolVersionAtLeast,
   isReviewableQueuedMessageKind,
+  isSandboxEnvironmentLaunchable,
   listComputers,
   listContextDocuments,
   listContextSessions,
   listContextSpaces,
+  listEnvironments,
   listMachineTemplates,
+  listRemoteSessionElicitations,
   listRemoteSessions,
   machineTypeToMachineConnectionType,
   mergeSessionSettings,
+  parseResponse,
   readContextFilePart,
   readContextSessionRecords,
   recordComputerConnectSli,
   recordDroidMetric,
   refreshComputer,
   registerContextSession,
+  resolveAskUserHandler,
+  resolvePermissionHandler,
   restartComputer,
   retryInstallDeps,
   retryWithLogger,
+  runWithAbort,
+  sessionTagsUpdateForPeer,
   streamFromClient,
   sumTokenUsage,
   summarizeSessionToolUsage,
   toError,
+  trustedIdentityFromComputerResponse,
   unwrapResponseResult,
   updateComputer,
   updateContextDocument,
   uploadContextFilePart,
+  waitForEnvironmentComputer,
   wireAbortSignal,
   withSdkTag
-} from "./chunk-TWAVPIPS.mjs";
+} from "./chunk-NWFX4MPJ.mjs";
+import "./chunk-7ZD7MMNA.mjs";
 
 // src/exec-core/client.ts
 import EventEmitter from "events";
@@ -497,7 +533,7 @@ import { z } from "zod";
 
 // src/exec-core/constants.ts
 var DEFAULT_REQUEST_TIMEOUT2 = 3e4;
-var SESSION_INIT_TIMEOUT2 = 6e4;
+var SESSION_INIT_TIMEOUT2 = 12e4;
 var COMPACTION_TIMEOUT2 = 24e4;
 var MCP_AUTH_TIMEOUT2 = 3e5;
 var WINDOWS_JOB_OBJECT_ERROR_MARKER = "AssignProcessToJobObject";
@@ -742,16 +778,21 @@ function resolveExecCoreDeps(observability, fallback = defaultExecCoreDeps) {
 }
 
 // src/exec-core/client.ts
-function getResponseId(response) {
-  const parsed = JsonRpcBaseResponseSchema.safeParse(response);
-  return parsed.success ? parsed.data.id : void 0;
+function isDroidConnectionEnded(error) {
+  const failure = error instanceof ProtocolError ? error.cause : error;
+  return failure instanceof DroidConnectionEndedError || failure instanceof ProcessExitError;
 }
 var JsonRpcEnvelopePeekSchema = JsonRpcEnvelopeSchema.partial().extend({
   type: z.nativeEnum(JsonRpcMessageType).optional(),
   method: z.string().optional(),
   id: z.string().nullable().optional()
 }).passthrough();
+function getResponseId(response2) {
+  const parsed = JsonRpcEnvelopePeekSchema.safeParse(response2);
+  return parsed.success ? parsed.data.id : void 0;
+}
 var MCP_OAUTH_OPT_OUT_PROTOCOL_VERSION = "1.78.0";
+var PERMISSION_WITHDRAWN = /* @__PURE__ */ Symbol("permission withdrawn");
 function inspectJsonRpcEnvelope2(message) {
   const result = JsonRpcEnvelopePeekSchema.safeParse(message);
   if (!result.success) {
@@ -778,9 +819,18 @@ var DroidClient = class _DroidClient extends EventEmitter {
   pickOptionsHandlers = /* @__PURE__ */ new Map();
   pendingPermissionRequests = /* @__PURE__ */ new Map();
   pendingAskUserRequests = /* @__PURE__ */ new Map();
+  /**
+   * Queued (non-blocking) AskUser requests that arrived before an AskUser
+   * handler was set, as when a reloaded session asks its pending queued sets
+   * again during the load. Answering one without a handler would record it
+   * as dismissed, and the agent never waits on it, so it waits for the
+   * handler instead.
+   */
+  heldQueuedAskUserRequests = [];
   pendingPickOptionsRequests = /* @__PURE__ */ new Map();
   currentSessionId = null;
   peerProtocolVersion;
+  peerEnforcesQueueOwnership = false;
   /**
    * Sticky error from a transport failure. Once set, all subsequent
    * `sendRequest()` calls throw this error immediately, preventing
@@ -788,6 +838,12 @@ var DroidClient = class _DroidClient extends EventEmitter {
    */
   transportError = null;
   completedTurnObserved = false;
+  /**
+   * Set once the droid sends `droid.disconnect`. It reads no further
+   * requests from then on, so it no longer counts as connected even while its
+   * transport stays open.
+   */
+  disconnected = false;
   logger;
   tracing;
   onRequestSettled;
@@ -815,20 +871,10 @@ var DroidClient = class _DroidClient extends EventEmitter {
     });
     this.transport.onError((error) => {
       const err = error instanceof Error ? error : new Error(String(error));
-      const pendingSessionIds = /* @__PURE__ */ new Set();
-      let hasPendingIdlessSessionStart = false;
-      for (const pendingRequest of this.pendingRequests.values()) {
-        if (pendingRequest.method === "droid.initialize_session" /* INITIALIZE_SESSION */ && pendingRequest.sessionId === void 0) {
-          hasPendingIdlessSessionStart = true;
-        } else if (pendingRequest.sessionId !== void 0) {
-          pendingSessionIds.add(pendingRequest.sessionId);
-        }
-      }
-      const pendingSessionId = pendingSessionIds.size === 1 ? pendingSessionIds.values().next().value : void 0;
-      const sessionId = hasPendingIdlessSessionStart || pendingSessionIds.size > 1 ? void 0 : pendingSessionId ?? this.currentSessionId ?? void 0;
-      const expectedCleanExit = err instanceof ProcessExitError && err.exitCode === 0 && this.completedTurnObserved;
-      if (expectedCleanExit) {
-        this.logger.info("[DroidClient] Process exited after completed turn", {
+      const sessionId = this.addressedSessionId;
+      const expectedExit = err instanceof ProcessExitError && (err.isRequestedStop || err.exitCode === 0 && this.completedTurnObserved);
+      if (expectedExit) {
+        this.logger.info("[DroidClient] Process exited as expected", {
           sessionId,
           exitCode: err.exitCode,
           signal: err.signal
@@ -854,8 +900,48 @@ var DroidClient = class _DroidClient extends EventEmitter {
   get sessionId() {
     return this.currentSessionId;
   }
+  /**
+   * The session that an inbound prompt or transport fault belongs to. A
+   * session start or load in flight owns it, because the CLI replays a loaded
+   * session's pending prompts before it answers the load; otherwise the
+   * current session does. Undefined when that is ambiguous: a start with no
+   * session id yet, or several starts and loads in flight.
+   *
+   * @internal
+   */
+  get addressedSessionId() {
+    const pendingSessionIds = /* @__PURE__ */ new Set();
+    for (const pendingRequest of this.pendingRequests.values()) {
+      if (pendingRequest.method === "droid.initialize_session" /* INITIALIZE_SESSION */ && pendingRequest.sessionId === void 0) {
+        return void 0;
+      }
+      if (pendingRequest.sessionId !== void 0) {
+        pendingSessionIds.add(pendingRequest.sessionId);
+      }
+    }
+    if (pendingSessionIds.size > 1) {
+      return void 0;
+    }
+    const [pendingSessionId] = pendingSessionIds;
+    return pendingSessionId ?? this.currentSessionId ?? void 0;
+  }
   get isConnected() {
-    return this.transport.isConnected;
+    return !this.disconnected && this.transport.isConnected;
+  }
+  /**
+   * Whether the worker runs in a child process. A daemon's shutdown cuts such
+   * a worker off from its owner before closing it, and from then on it reads
+   * no request; a worker hosted in this process still answers.
+   */
+  get runsInChildProcess() {
+    return (this.transport.getManagedProcess?.() ?? null) !== null;
+  }
+  /**
+   * Whether the runner refuses a queue change from someone other than the
+   * prompt's author. Older runners ignore the author on such a change.
+   */
+  get enforcesQueueOwnership() {
+    return this.peerEnforcesQueueOwnership;
   }
   requireMcpOAuthOptOutSupport() {
     if (isProtocolVersionAtLeast(
@@ -882,37 +968,38 @@ var DroidClient = class _DroidClient extends EventEmitter {
   }
   async initializeSession(params) {
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
       id: uuidv4(),
       method: "droid.initialize_session" /* INITIALIZE_SESSION */,
-      params
+      params: encodeLegacyStartupLoadOptions(params)
     };
     const rawResponse = await this.sendRequest(
       request,
       this.sessionInitTimeout,
       params.sessionId
     );
-    const response = InitializeSessionResponseSchema.parse(rawResponse);
-    this.peerProtocolVersion = response.factoryProtocolVersion;
-    if (response.error) {
+    const response2 = InitializeSessionResponseSchema.parse(rawResponse);
+    this.peerProtocolVersion = response2.factoryProtocolVersion;
+    if (response2.error) {
       throw new ProtocolError("Initialize session request failed", {
         requestId: request.id,
-        code: response.error.code,
-        message: response.error.message,
-        data: response.error.data
+        code: response2.error.code,
+        message: response2.error.message,
+        data: response2.error.data
       });
     }
     this.validateMcpServersProtocolSupport(params.mcpServers);
-    const result = InitializeSessionResultSchema.parse(response.result);
+    const result = InitializeSessionResultSchema.parse(response2.result);
+    this.peerEnforcesQueueOwnership = result.enforcesQueueOwnership === true;
     this.currentSessionId = result.sessionId;
-    return response;
+    return response2;
   }
   async loadSession(params) {
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -925,28 +1012,29 @@ var DroidClient = class _DroidClient extends EventEmitter {
       this.sessionInitTimeout,
       params.sessionId
     );
-    const response = LoadSessionResponseSchema.parse(rawResponse);
-    this.peerProtocolVersion = response.factoryProtocolVersion;
-    if (response.error) {
-      const isSessionNotFound = response.error.code === -32004 /* ENTITY_NOT_FOUND */;
+    const response2 = LoadSessionResponseSchema.parse(rawResponse);
+    this.peerProtocolVersion = response2.factoryProtocolVersion;
+    if (response2.error) {
+      const isSessionNotFound = response2.error.code === -32004 /* ENTITY_NOT_FOUND */;
       if (isSessionNotFound) {
         throw new SessionNotFoundError(params.sessionId, {
           requestId: request.id,
-          code: response.error.code,
-          message: response.error.message,
-          data: response.error.data
+          code: response2.error.code,
+          message: response2.error.message,
+          data: response2.error.data
         });
       }
       throw new ProtocolError("Load session request failed", {
         requestId: request.id,
-        code: response.error.code,
-        message: response.error.message,
-        data: response.error.data
+        code: response2.error.code,
+        message: response2.error.message,
+        data: response2.error.data
       });
     }
     this.validateMcpServersProtocolSupport(params.mcpServers);
+    this.peerEnforcesQueueOwnership = response2.result?.enforcesQueueOwnership === true;
     this.currentSessionId = params.sessionId;
-    return response;
+    return response2;
   }
   async addUserMessage(params, requestId) {
     if (!this.currentSessionId) {
@@ -956,7 +1044,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
     }
     this.completedTurnObserved = false;
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -968,16 +1056,16 @@ var DroidClient = class _DroidClient extends EventEmitter {
       }
     };
     const rawResponse = await this.sendRequest(request);
-    const response = AddUserMessageResponseSchema.parse(rawResponse);
-    if (response.error) {
+    const response2 = AddUserMessageResponseSchema.parse(rawResponse);
+    if (response2.error) {
       throw new ProtocolError("Add user message request failed", {
         requestId: request.id,
-        code: response.error.code,
-        message: response.error.message,
-        data: response.error.data
+        code: response2.error.code,
+        message: response2.error.message,
+        data: response2.error.data
       });
     }
-    return response;
+    return response2;
   }
   /**
    * Persists user-only messages without starting an agent turn.
@@ -992,7 +1080,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1001,16 +1089,16 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params
     };
     const rawResponse = await this.sendRequest(request);
-    const response = AppendMessagesResponseSchema.parse(rawResponse);
-    if (response.error) {
+    const response2 = AppendMessagesResponseSchema.parse(rawResponse);
+    if (response2.error) {
       throw new ProtocolError("Append messages request failed", {
         requestId: request.id,
-        code: response.error.code,
-        message: response.error.message,
-        data: response.error.data
+        code: response2.error.code,
+        message: response2.error.message,
+        data: response2.error.data
       });
     }
-    return response;
+    return response2;
   }
   async resolveQueuedUserMessage(params) {
     if (!this.currentSessionId) {
@@ -1019,7 +1107,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1028,16 +1116,16 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = ResolveQueuedUserMessageResponseSchema.parse(rawResponse);
-    if (response.error) {
+    const response2 = ResolveQueuedUserMessageResponseSchema.parse(rawResponse);
+    if (response2.error) {
       throw new ProtocolError("Resolve queued user message request failed", {
         requestId: request.id,
-        code: response.error.code,
-        message: response.error.message,
-        data: response.error.data
+        code: response2.error.code,
+        message: response2.error.message,
+        data: response2.error.data
       });
     }
-    return response;
+    return response2;
   }
   async interruptSession(params = {}) {
     if (!this.currentSessionId) {
@@ -1046,7 +1134,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1055,16 +1143,16 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = InterruptSessionResponseSchema.parse(rawResponse);
-    if (response.error) {
+    const response2 = InterruptSessionResponseSchema.parse(rawResponse);
+    if (response2.error) {
       throw new ProtocolError("Interrupt session request failed", {
         requestId: request.id,
-        code: response.error.code,
-        message: response.error.message,
-        data: response.error.data
+        code: response2.error.code,
+        message: response2.error.message,
+        data: response2.error.data
       });
     }
-    return response;
+    return response2;
   }
   async closeSession(params = {}) {
     if (!this.currentSessionId) {
@@ -1073,7 +1161,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1082,16 +1170,16 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = CloseSessionResponseSchema.parse(rawResponse);
-    if (response.error) {
+    const response2 = CloseSessionResponseSchema.parse(rawResponse);
+    if (response2.error) {
       throw new ProtocolError("Close session request failed", {
         requestId: request.id,
-        code: response.error.code,
-        message: response.error.message,
-        data: response.error.data
+        code: response2.error.code,
+        message: response2.error.message,
+        data: response2.error.data
       });
     }
-    return response;
+    return response2;
   }
   async killWorkerSession(params) {
     if (!this.currentSessionId) {
@@ -1100,7 +1188,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1109,16 +1197,16 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = KillWorkerSessionResponseSchema.parse(rawResponse);
-    if (response.error) {
+    const response2 = KillWorkerSessionResponseSchema.parse(rawResponse);
+    if (response2.error) {
       throw new ProtocolError("Kill worker session request failed", {
         requestId: request.id,
-        code: response.error.code,
-        message: response.error.message,
-        data: response.error.data
+        code: response2.error.code,
+        message: response2.error.message,
+        data: response2.error.data
       });
     }
-    return response;
+    return response2;
   }
   async updateSessionSettings(params, requestId) {
     if (!this.currentSessionId) {
@@ -1127,13 +1215,13 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
       id: requestId ?? uuidv4(),
       method: "droid.update_session_settings" /* UPDATE_SESSION_SETTINGS */,
-      params
+      params: sessionTagsUpdateForPeer(params, this.peerProtocolVersion)
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
     const responseParsed = UpdateSessionSettingsResponseSchema.safeParse(rawResponse);
@@ -1148,16 +1236,16 @@ var DroidClient = class _DroidClient extends EventEmitter {
         }
       );
     }
-    const response = responseParsed.data;
-    if (response.error) {
+    const response2 = responseParsed.data;
+    if (response2.error) {
       throw new ProtocolError("Update session settings request failed", {
         requestId: request.id,
-        code: response.error.code,
-        message: response.error.message,
-        data: response.error.data
+        code: response2.error.code,
+        message: response2.error.message,
+        data: response2.error.data
       });
     }
-    return response;
+    return response2;
   }
   async changeWorkingDirectory(params) {
     if (!this.currentSessionId) {
@@ -1166,7 +1254,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1175,16 +1263,16 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = ChangeWorkingDirectoryResponseSchema.parse(rawResponse);
-    if (response.error) {
+    const response2 = ChangeWorkingDirectoryResponseSchema.parse(rawResponse);
+    if (response2.error) {
       throw new ProtocolError("Change working directory request failed", {
         requestId: request.id,
-        code: response.error.code,
-        message: response.error.message,
-        data: response.error.data
+        code: response2.error.code,
+        message: response2.error.message,
+        data: response2.error.data
       });
     }
-    return response;
+    return response2;
   }
   async toggleMcpServer(params) {
     if (!this.currentSessionId) {
@@ -1193,7 +1281,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1206,8 +1294,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       }
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = ToggleMcpServerResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = ToggleMcpServerResponseSchema.parse(rawResponse);
+    return response2;
   }
   async authenticateMcpServer(params) {
     if (!this.currentSessionId) {
@@ -1216,7 +1304,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1227,8 +1315,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       }
     };
     const rawResponse = await this.sendRequest(request, MCP_AUTH_TIMEOUT2);
-    const response = AuthenticateMcpServerResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = AuthenticateMcpServerResponseSchema.parse(rawResponse);
+    return response2;
   }
   async cancelMcpAuth(params) {
     if (!this.currentSessionId) {
@@ -1237,7 +1325,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1248,8 +1336,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       }
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = CancelMcpAuthResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = CancelMcpAuthResponseSchema.parse(rawResponse);
+    return response2;
   }
   async clearMcpAuth(params) {
     if (!this.currentSessionId) {
@@ -1258,7 +1346,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1269,8 +1357,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       }
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = ClearMcpAuthResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = ClearMcpAuthResponseSchema.parse(rawResponse);
+    return response2;
   }
   async addMcpServer(params) {
     if (!this.currentSessionId) {
@@ -1282,7 +1370,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       this.requireMcpOAuthOptOutSupport();
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1291,8 +1379,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = AddMcpServerResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = AddMcpServerResponseSchema.parse(rawResponse);
+    return response2;
   }
   async removeMcpServer(params) {
     if (!this.currentSessionId) {
@@ -1301,7 +1389,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1310,12 +1398,12 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = RemoveMcpServerResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = RemoveMcpServerResponseSchema.parse(rawResponse);
+    return response2;
   }
   async listModels(params = {}) {
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1333,7 +1421,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1342,8 +1430,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params: {}
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = ListMcpRegistryResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = ListMcpRegistryResponseSchema.parse(rawResponse);
+    return response2;
   }
   async refreshConnectorToolCatalog(params = {}) {
     if (!this.currentSessionId) {
@@ -1352,7 +1440,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1360,8 +1448,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       method: "droid.refresh_connector_tool_catalog" /* REFRESH_CONNECTOR_TOOL_CATALOG */,
       params
     };
-    const response = await this.sendRequest(request, this.requestTimeout);
-    return RefreshConnectorToolCatalogResponseSchema.parse(response);
+    const response2 = await this.sendRequest(request, this.requestTimeout);
+    return RefreshConnectorToolCatalogResponseSchema.parse(response2);
   }
   async listMcpTools() {
     if (!this.currentSessionId) {
@@ -1370,7 +1458,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1379,13 +1467,13 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params: {}
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = ListMcpToolsResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = ListMcpToolsResponseSchema.parse(rawResponse);
+    return response2;
   }
   async listTools(params = {}) {
     const schemasRequested = params.includeSchemas === true;
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1394,17 +1482,17 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = ListToolsResponseSchema.parse(rawResponse);
-    if (!schemasRequested || !("result" in response)) {
-      return response;
+    const response2 = ListToolsResponseSchema.parse(rawResponse);
+    if (!schemasRequested || !("result" in response2)) {
+      return response2;
     }
     const strictResult = ListToolsResultWithSchemasSchema.safeParse(
-      response.result
+      response2.result
     );
     if (strictResult.success) {
-      return response;
+      return response2;
     }
-    const result = ListToolsResultSchema.parse(response.result);
+    const result = ListToolsResultSchema.parse(response2.result);
     const missingSchemaIds = [];
     for (const tool2 of result.tools) {
       if (tool2.schemas === void 0) {
@@ -1425,7 +1513,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1434,8 +1522,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params: {}
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = ListMcpServersResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = ListMcpServersResponseSchema.parse(rawResponse);
+    return response2;
   }
   async toggleMcpTool(serverName, toolName, enabled) {
     if (!this.currentSessionId) {
@@ -1444,7 +1532,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1453,8 +1541,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params: { serverName, toolName, enabled }
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = ToggleMcpToolResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = ToggleMcpToolResponseSchema.parse(rawResponse);
+    return response2;
   }
   async submitMcpAuthCode(params) {
     if (!this.currentSessionId) {
@@ -1463,7 +1551,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1472,8 +1560,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = SubmitMcpAuthCodeResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = SubmitMcpAuthCodeResponseSchema.parse(rawResponse);
+    return response2;
   }
   async submitMcpAuthError(params) {
     if (!this.currentSessionId) {
@@ -1482,7 +1570,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1491,8 +1579,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = SubmitMcpAuthErrorResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = SubmitMcpAuthErrorResponseSchema.parse(rawResponse);
+    return response2;
   }
   async listSkills(params = {}) {
     if (!this.currentSessionId) {
@@ -1501,7 +1589,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1510,8 +1598,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = ListSkillsResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = ListSkillsResponseSchema.parse(rawResponse);
+    return response2;
   }
   async setSkillDisabled(skillName, disabled, settingsLevel) {
     if (!this.currentSessionId) {
@@ -1520,7 +1608,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1538,7 +1626,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1547,8 +1635,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params: {}
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = ListCommandsResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = ListCommandsResponseSchema.parse(rawResponse);
+    return response2;
   }
   async getContextStats() {
     if (!this.currentSessionId) {
@@ -1557,7 +1645,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1566,8 +1654,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params: {}
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = GetContextStatsResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = GetContextStatsResponseSchema.parse(rawResponse);
+    return response2;
   }
   async getContextBreakdown() {
     if (!this.currentSessionId) {
@@ -1576,7 +1664,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1585,27 +1673,45 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params: {}
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = GetContextBreakdownResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = GetContextBreakdownResponseSchema.parse(rawResponse);
+    return response2;
+  }
+  async killBackgroundProcess(processId) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.kill_background_process" /* KILL_BACKGROUND_PROCESS */,
+      params: { processId }
+    };
+    const rawResponse = await this.sendRequest(request, this.requestTimeout);
+    return KillBackgroundProcessResponseSchema.parse(rawResponse);
   }
-  async submitBugReport(userComment, clientLogs, source) {
+  async submitBugReport(userComment, clientLogs, source, tuiLogs) {
     if (!this.currentSessionId) {
       throw new SessionError(
         "No active session. Call initializeSession or loadSession first."
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
       id: uuidv4(),
       method: "droid.submit_bug_report" /* SUBMIT_BUG_REPORT */,
-      params: { userComment, clientLogs, source }
+      params: { userComment, clientLogs, source, tuiLogs }
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = SubmitBugReportResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = SubmitBugReportResponseSchema.parse(rawResponse);
+    return response2;
   }
   async getRewindInfo(params, timeout = this.requestTimeout) {
     if (!this.currentSessionId) {
@@ -1614,7 +1720,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1635,7 +1741,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1662,7 +1768,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1676,6 +1782,44 @@ var DroidClient = class _DroidClient extends EventEmitter {
     const rawResponse = await this.sendRequest(request, COMPACTION_TIMEOUT2);
     return CompactSessionResponseSchema.parse(rawResponse);
   }
+  /** Summarizes the session the way `/handoff` does, without writing anything. */
+  async getHandoffSummary() {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.get_handoff_summary" /* GET_HANDOFF_SUMMARY */,
+      params: {}
+    };
+    const rawResponse = await this.sendRequest(request, COMPACTION_TIMEOUT2);
+    return GetHandoffSummaryResponseSchema.parse(rawResponse);
+  }
+  /** Writes the short summary people joining a shared copy read first. */
+  async summarizeForMembers(params) {
+    if (!this.currentSessionId) {
+      throw new SessionError(
+        "No active session. Call initializeSession or loadSession first."
+      );
+    }
+    const request = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      type: "request",
+      jsonrpc: JSONRPC_VERSION2,
+      id: uuidv4(),
+      method: "droid.summarize_for_members" /* SUMMARIZE_FOR_MEMBERS */,
+      params: { handoffSummary: params.handoffSummary }
+    };
+    const rawResponse = await this.sendRequest(request, COMPACTION_TIMEOUT2);
+    return SummarizeForMembersResponseSchema.parse(rawResponse);
+  }
   async forkSession(params) {
     if (!this.currentSessionId) {
       throw new SessionError(
@@ -1683,7 +1827,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1701,7 +1845,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       );
     }
     const request = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "request",
       jsonrpc: JSONRPC_VERSION2,
@@ -1715,15 +1859,15 @@ var DroidClient = class _DroidClient extends EventEmitter {
     return RenameSessionResponseSchema.parse(rawResponse);
   }
   async warmupCache() {
-    const response = {
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+    const response2 = {
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       type: "response",
       jsonrpc: JSONRPC_VERSION2,
       id: uuidv4(),
       result: {}
     };
-    return WarmupCacheResponseSchema.parse(response);
+    return WarmupCacheResponseSchema.parse(response2);
   }
   onNotification(callback, filter) {
     const handler = (notification) => {
@@ -1754,14 +1898,27 @@ var DroidClient = class _DroidClient extends EventEmitter {
   setPermissionHandler(handler) {
     this.permissionHandlers.set(
       "default",
-      async (event) => await handler(event)
+      async (event, setResponseMetadata) => await handler(event, setResponseMetadata)
     );
   }
   clearPermissionHandler() {
     this.permissionHandlers.delete("default");
   }
   setAskUserHandler(handler) {
-    this.askUserHandlers.set("default", async (event) => await handler(event));
+    this.askUserHandlers.set(
+      "default",
+      async (event, setResponseMetadata) => await handler(event, setResponseMetadata)
+    );
+    const held = this.heldQueuedAskUserRequests;
+    this.heldQueuedAskUserRequests = [];
+    for (const event of held) {
+      void this.answerAskUserRequest(event).catch((error) => {
+        this.reportHandlerFailure(
+          error,
+          "Failed to answer a held queued ask-user request"
+        );
+      });
+    }
   }
   clearAskUserHandler() {
     this.askUserHandlers.delete("default");
@@ -1769,14 +1926,14 @@ var DroidClient = class _DroidClient extends EventEmitter {
   setPickOptionsHandler(handler) {
     this.pickOptionsHandlers.set(
       "default",
-      async (event) => await handler(event)
+      async (event, setResponseMetadata) => await handler(event, setResponseMetadata)
     );
   }
   clearPickOptionsHandler() {
     this.pickOptionsHandlers.delete("default");
   }
   async close(options) {
-    const closeError = new ConnectionError(
+    const closeError = new DroidConnectionEndedError(
       "Droid client closed: pending requests cancelled"
     );
     if (options?.closeTransportFirst) {
@@ -1786,6 +1943,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
         this.rejectAllPending(closeError);
         this.permissionHandlers.clear();
         this.askUserHandlers.clear();
+        this.heldQueuedAskUserRequests = [];
         this.removeAllListeners();
       }
       return;
@@ -1793,6 +1951,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
     this.rejectAllPending(closeError);
     this.permissionHandlers.clear();
     this.askUserHandlers.clear();
+    this.heldQueuedAskUserRequests = [];
     this.pickOptionsHandlers.clear();
     this.removeAllListeners();
     await this.transport.close();
@@ -1829,16 +1988,31 @@ var DroidClient = class _DroidClient extends EventEmitter {
     } catch {
     }
   }
+  /** `_meta` for an answer this client gives itself: its caller and the current trace context. */
+  responseMetadata() {
+    const meta = {};
+    const requestAttribution = this.getRequestAttribution?.();
+    if (requestAttribution) meta.requestAttribution = requestAttribution;
+    this.tracing.injectContext(meta, this.tracing.getCurrentContext());
+    return meta;
+  }
+  async sendResponse(response2, hostMeta) {
+    const meta = hostMeta ?? this.responseMetadata();
+    await this.transport.send(
+      Object.keys(meta).length > 0 ? { ...response2, _meta: meta } : response2
+    );
+  }
   async sendRequest(request, timeout, sessionId) {
     if (this.transportError) {
       throw this.transportError;
     }
-    const requestAttribution = this.getRequestAttribution?.();
-    const _meta = {
-      ...requestAttribution && { requestAttribution }
-    };
+    const requestAttribution = request._meta?.requestAttribution ?? this.getRequestAttribution?.();
+    const _meta = { ...request._meta };
+    delete _meta.requestAttribution;
+    if (requestAttribution) _meta.requestAttribution = requestAttribution;
     this.tracing.injectContext(_meta, this.tracing.getCurrentContext());
-    const requestWithMeta = _meta.traceparent || _meta.requestAttribution ? { ...request, _meta } : request;
+    const { _meta: _originalMeta, ...requestWithoutMeta } = request;
+    const requestWithMeta = Object.keys(_meta).length > 0 ? { ...request, _meta } : requestWithoutMeta;
     const responsePromise = new Promise(
       (resolve2, reject) => {
         const timeoutId = timeout ? setTimeout(() => {
@@ -1862,12 +2036,16 @@ var DroidClient = class _DroidClient extends EventEmitter {
     );
     void responsePromise.catch(() => {
     });
+    void this.writeRequest(requestWithMeta);
+    return responsePromise;
+  }
+  async writeRequest(request) {
     try {
       this.logger.info("[DroidClient] [daemon -> droid] sending request", {
         requestId: request.id,
         method: request.method
       });
-      await this.transport.send(requestWithMeta);
+      await this.transport.send(request);
     } catch (error) {
       const pending = this.pendingRequests.get(request.id);
       if (pending) {
@@ -1883,7 +2061,6 @@ var DroidClient = class _DroidClient extends EventEmitter {
         );
       }
     }
-    return responsePromise;
   }
   async handleMessage(message) {
     try {
@@ -1896,124 +2073,133 @@ var DroidClient = class _DroidClient extends EventEmitter {
       this.logger.warn("[DroidClient] Failed to handle message");
     }
   }
-  handleResponse(response) {
+  handleResponse(response2) {
     try {
-      const responseId = getResponseId(response);
+      const responseId = getResponseId(response2);
       if (responseId !== null && responseId !== void 0) {
         const pending = this.pendingRequests.get(responseId);
         if (pending) {
           let validatedResponse;
           switch (pending.method) {
             case "droid.initialize_session" /* INITIALIZE_SESSION */:
-              validatedResponse = InitializeSessionResponseSchema.parse(response);
+              validatedResponse = InitializeSessionResponseSchema.parse(response2);
               break;
             case "droid.load_session" /* LOAD_SESSION */:
-              validatedResponse = LoadSessionResponseSchema.parse(response);
+              validatedResponse = LoadSessionResponseSchema.parse(response2);
               break;
             case "droid.add_user_message" /* ADD_USER_MESSAGE */:
-              validatedResponse = AddUserMessageResponseSchema.parse(response);
+              validatedResponse = AddUserMessageResponseSchema.parse(response2);
               break;
             case "droid.append_messages" /* APPEND_MESSAGES */:
-              validatedResponse = AppendMessagesResponseSchema.parse(response);
+              validatedResponse = AppendMessagesResponseSchema.parse(response2);
               break;
             case "droid.resolve_queued_user_message" /* RESOLVE_QUEUED_USER_MESSAGE */:
-              validatedResponse = ResolveQueuedUserMessageResponseSchema.parse(response);
+              validatedResponse = ResolveQueuedUserMessageResponseSchema.parse(response2);
               break;
             case "droid.interrupt_session" /* INTERRUPT_SESSION */:
-              validatedResponse = InterruptSessionResponseSchema.parse(response);
+              validatedResponse = InterruptSessionResponseSchema.parse(response2);
               break;
             case "droid.close_session" /* CLOSE_SESSION */:
-              validatedResponse = CloseSessionResponseSchema.parse(response);
+              validatedResponse = CloseSessionResponseSchema.parse(response2);
               break;
             case "droid.update_session_settings" /* UPDATE_SESSION_SETTINGS */:
-              validatedResponse = UpdateSessionSettingsResponseSchema.parse(response);
+              validatedResponse = UpdateSessionSettingsResponseSchema.parse(response2);
               break;
             case "droid.change_working_directory" /* CHANGE_WORKING_DIRECTORY */:
-              validatedResponse = ChangeWorkingDirectoryResponseSchema.parse(response);
+              validatedResponse = ChangeWorkingDirectoryResponseSchema.parse(response2);
               break;
             case "droid.toggle_mcp_server" /* TOGGLE_MCP_SERVER */:
-              validatedResponse = ToggleMcpServerResponseSchema.parse(response);
+              validatedResponse = ToggleMcpServerResponseSchema.parse(response2);
               break;
             case "droid.authenticate_mcp_server" /* AUTHENTICATE_MCP_SERVER */:
-              validatedResponse = AuthenticateMcpServerResponseSchema.parse(response);
+              validatedResponse = AuthenticateMcpServerResponseSchema.parse(response2);
               break;
             case "droid.cancel_mcp_auth" /* CANCEL_MCP_AUTH */:
-              validatedResponse = CancelMcpAuthResponseSchema.parse(response);
+              validatedResponse = CancelMcpAuthResponseSchema.parse(response2);
               break;
             case "droid.clear_mcp_auth" /* CLEAR_MCP_AUTH */:
-              validatedResponse = ClearMcpAuthResponseSchema.parse(response);
+              validatedResponse = ClearMcpAuthResponseSchema.parse(response2);
               break;
             case "droid.add_mcp_server" /* ADD_MCP_SERVER */:
-              validatedResponse = AddMcpServerResponseSchema.parse(response);
+              validatedResponse = AddMcpServerResponseSchema.parse(response2);
               break;
             case "droid.remove_mcp_server" /* REMOVE_MCP_SERVER */:
-              validatedResponse = RemoveMcpServerResponseSchema.parse(response);
+              validatedResponse = RemoveMcpServerResponseSchema.parse(response2);
               break;
             case "droid.list_models" /* LIST_MODELS */:
-              validatedResponse = ListModelsResponseSchema.parse(response);
+              validatedResponse = ListModelsResponseSchema.parse(response2);
               break;
             case "droid.list_mcp_registry" /* LIST_MCP_REGISTRY */:
-              validatedResponse = ListMcpRegistryResponseSchema.parse(response);
+              validatedResponse = ListMcpRegistryResponseSchema.parse(response2);
               break;
             case "droid.list_mcp_tools" /* LIST_MCP_TOOLS */:
-              validatedResponse = ListMcpToolsResponseSchema.parse(response);
+              validatedResponse = ListMcpToolsResponseSchema.parse(response2);
               break;
             case "droid.list_tools" /* LIST_TOOLS */:
-              validatedResponse = ListToolsResponseSchema.parse(response);
+              validatedResponse = ListToolsResponseSchema.parse(response2);
               break;
             case "droid.refresh_connector_tool_catalog" /* REFRESH_CONNECTOR_TOOL_CATALOG */:
-              validatedResponse = RefreshConnectorToolCatalogResponseSchema.parse(response);
+              validatedResponse = RefreshConnectorToolCatalogResponseSchema.parse(response2);
               break;
             case "droid.toggle_mcp_tool" /* TOGGLE_MCP_TOOL */:
-              validatedResponse = ToggleMcpToolResponseSchema.parse(response);
+              validatedResponse = ToggleMcpToolResponseSchema.parse(response2);
               break;
             case "droid.submit_mcp_auth_code" /* SUBMIT_MCP_AUTH_CODE */:
-              validatedResponse = SubmitMcpAuthCodeResponseSchema.parse(response);
+              validatedResponse = SubmitMcpAuthCodeResponseSchema.parse(response2);
               break;
             case "droid.submit_mcp_auth_error" /* SUBMIT_MCP_AUTH_ERROR */:
-              validatedResponse = SubmitMcpAuthErrorResponseSchema.parse(response);
+              validatedResponse = SubmitMcpAuthErrorResponseSchema.parse(response2);
               break;
             case "droid.kill_worker_session" /* KILL_WORKER_SESSION */:
-              validatedResponse = KillWorkerSessionResponseSchema.parse(response);
+              validatedResponse = KillWorkerSessionResponseSchema.parse(response2);
               break;
             case "droid.list_skills" /* LIST_SKILLS */:
-              validatedResponse = ListSkillsResponseSchema.parse(response);
+              validatedResponse = ListSkillsResponseSchema.parse(response2);
               break;
             case "droid.set_skill_disabled" /* SET_SKILL_DISABLED */:
-              validatedResponse = SetSkillDisabledResponseSchema.parse(response);
+              validatedResponse = SetSkillDisabledResponseSchema.parse(response2);
               break;
             case "droid.list_commands" /* LIST_COMMANDS */:
-              validatedResponse = ListCommandsResponseSchema.parse(response);
+              validatedResponse = ListCommandsResponseSchema.parse(response2);
               break;
             case "droid.submit_bug_report" /* SUBMIT_BUG_REPORT */:
-              validatedResponse = SubmitBugReportResponseSchema.parse(response);
+              validatedResponse = SubmitBugReportResponseSchema.parse(response2);
               break;
             case "droid.list_mcp_servers" /* LIST_MCP_SERVERS */:
-              validatedResponse = ListMcpServersResponseSchema.parse(response);
+              validatedResponse = ListMcpServersResponseSchema.parse(response2);
               break;
             case "droid.get_rewind_info" /* GET_REWIND_INFO */:
-              validatedResponse = GetRewindInfoResponseSchema.parse(response);
+              validatedResponse = GetRewindInfoResponseSchema.parse(response2);
               break;
             case "droid.execute_rewind" /* EXECUTE_REWIND */:
-              validatedResponse = ExecuteRewindResponseSchema.parse(response);
+              validatedResponse = ExecuteRewindResponseSchema.parse(response2);
               break;
             case "droid.compact_session" /* COMPACT_SESSION */:
-              validatedResponse = CompactSessionResponseSchema.parse(response);
+              validatedResponse = CompactSessionResponseSchema.parse(response2);
+              break;
+            case "droid.get_handoff_summary" /* GET_HANDOFF_SUMMARY */:
+              validatedResponse = GetHandoffSummaryResponseSchema.parse(response2);
+              break;
+            case "droid.summarize_for_members" /* SUMMARIZE_FOR_MEMBERS */:
+              validatedResponse = SummarizeForMembersResponseSchema.parse(response2);
               break;
             case "droid.fork_session" /* FORK_SESSION */:
-              validatedResponse = ForkSessionResponseSchema.parse(response);
+              validatedResponse = ForkSessionResponseSchema.parse(response2);
               break;
             case "droid.rename_session" /* RENAME_SESSION */:
-              validatedResponse = RenameSessionResponseSchema.parse(response);
+              validatedResponse = RenameSessionResponseSchema.parse(response2);
               break;
             case "droid.get_context_stats" /* GET_CONTEXT_STATS */:
-              validatedResponse = GetContextStatsResponseSchema.parse(response);
+              validatedResponse = GetContextStatsResponseSchema.parse(response2);
               break;
             case "droid.get_context_breakdown" /* GET_CONTEXT_BREAKDOWN */:
-              validatedResponse = GetContextBreakdownResponseSchema.parse(response);
+              validatedResponse = GetContextBreakdownResponseSchema.parse(response2);
               break;
             case "droid.warmup_cache" /* WARMUP_CACHE */:
-              validatedResponse = WarmupCacheResponseSchema.parse(response);
+              validatedResponse = WarmupCacheResponseSchema.parse(response2);
+              break;
+            case "droid.kill_background_process" /* KILL_BACKGROUND_PROCESS */:
+              validatedResponse = KillBackgroundProcessResponseSchema.parse(response2);
               break;
             default: {
               const exhaustiveCheck = pending.method;
@@ -2031,7 +2217,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
           this.settleRequest(responseId);
           pending.resolve(validatedResponse);
         } else {
-          const validatedResponse = JsonRpcBaseResponseSchema.parse(response);
+          const validatedResponse = JsonRpcBaseResponseSchema.parse(response2);
           this.logger.info(
             "[DroidClient] Received response for request not in pending map",
             {
@@ -2041,7 +2227,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
         }
       }
     } catch (error) {
-      const responseId = getResponseId(response);
+      const responseId = getResponseId(response2);
       const pending = responseId !== null && responseId !== void 0 ? this.pendingRequests.get(responseId) : void 0;
       const zodIssues = error instanceof z.ZodError ? error.issues.map((issue) => ({
         path: issue.path,
@@ -2077,7 +2263,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       const syntheticFailure = {
         jsonrpc: JSONRPC_VERSION2,
         type: "response",
-        factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+        factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
         factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
         id: responseId,
         error: {
@@ -2096,8 +2282,10 @@ var DroidClient = class _DroidClient extends EventEmitter {
         const notification = validatedEvent.params.notification;
         if (notification.type === "agent_turn_completed" /* AGENT_TURN_COMPLETED */) {
           this.completedTurnObserved = true;
-        } else if (notification.type === "droid_working_state_changed" /* DROID_WORKING_STATE_CHANGED */ && notification.newState !== "idle" /* Idle */) {
+        } else if (notification.type === "droid_working_state_changed" /* DROID_WORKING_STATE_CHANGED */ && DROID_RUNNING_STATES.has(notification.newState)) {
           this.completedTurnObserved = false;
+        } else if (notification.type === "permission_resolved" /* PERMISSION_RESOLVED */) {
+          this.pendingPermissionRequests.get(notification.requestId)?.withdraw();
         }
         this.emit("session_notification" /* SESSION_NOTIFICATION */, validatedEvent);
       } else if (validatedEvent.method === "droid.request_permission" /* REQUEST_PERMISSION */) {
@@ -2106,6 +2294,8 @@ var DroidClient = class _DroidClient extends EventEmitter {
         await this.handleAskUserRequest(validatedEvent);
       } else if (validatedEvent.method === "droid.pick_options" /* PICK_OPTIONS */) {
         await this.handlePickOptionsRequest(validatedEvent);
+      } else if (validatedEvent.method === "droid.disconnect" /* DISCONNECT */) {
+        this.disconnected = true;
       }
     } catch (error) {
       this.logDroppedEventParseError(error, event);
@@ -2130,7 +2320,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
     const errorResponse = {
       jsonrpc: JSONRPC_VERSION2,
       type: "response",
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       id,
       error: {
@@ -2140,7 +2330,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       }
     };
     try {
-      await this.transport.send(errorResponse);
+      await this.sendResponse(errorResponse, void 0);
     } catch (sendError) {
       this.logger.exception(
         sendError,
@@ -2185,6 +2375,13 @@ var DroidClient = class _DroidClient extends EventEmitter {
       });
     }
   }
+  reportHandlerFailure(error, message) {
+    if (error instanceof RequestCancelledError || isDroidConnectionEnded(error)) {
+      this.logger.info(message, { cause: error });
+    } else {
+      this.logger.exception(error, message);
+    }
+  }
   async handlePermissionRequest(event) {
     if (this.pendingPermissionRequests.has(event.id)) {
       this.logger.info(
@@ -2199,12 +2396,14 @@ var DroidClient = class _DroidClient extends EventEmitter {
       requestId: event.id,
       count: event.params.toolUses.length
     });
+    let hostMeta;
+    const setResponseMetadata = (meta) => {
+      hostMeta = meta;
+    };
     this.emit("request_permission" /* REQUEST_PERMISSION */, event);
-    let selectedOption = "cancel" /* Cancel */;
-    let comment;
-    let editedSpecContent;
-    let clientStartsHandoffSession;
-    let specHandoffId;
+    let result = {
+      selectedOption: "cancel" /* Cancel */
+    };
     const handler = this.permissionHandlers.get("default");
     if (handler) {
       try {
@@ -2214,15 +2413,25 @@ var DroidClient = class _DroidClient extends EventEmitter {
             requestId: event.id
           }
         );
-        const handlerPromise = new Promise(
-          (resolve2, reject) => {
-            this.pendingPermissionRequests.set(event.id, { reject });
-            handler(event).then(resolve2).catch(reject).finally(() => {
+        const handlerPromise = new Promise((resolve2, reject) => {
+          this.pendingPermissionRequests.set(event.id, {
+            reject,
+            withdraw: () => {
               this.pendingPermissionRequests.delete(event.id);
-            });
-          }
-        );
+              resolve2(PERMISSION_WITHDRAWN);
+            }
+          });
+          handler(event, setResponseMetadata).then(resolve2).catch(reject).finally(() => {
+            this.pendingPermissionRequests.delete(event.id);
+          });
+        });
         const handlerResult = await handlerPromise;
+        if (handlerResult === PERMISSION_WITHDRAWN) {
+          this.logger.info("[DroidClient] Permission request withdrawn", {
+            requestId: event.id
+          });
+          return;
+        }
         if (typeof handlerResult === "string" && handlerResult === "proceed_edit" /* ProceedEdit */) {
           throw new DroidClientError(
             "Permission handler returned proceed_edit without editedSpecContent"
@@ -2232,11 +2441,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
           typeof handlerResult === "string" ? { selectedOption: handlerResult } : handlerResult
         );
         if (parsedHandlerResult.success) {
-          selectedOption = parsedHandlerResult.data.selectedOption;
-          comment = parsedHandlerResult.data.comment;
-          editedSpecContent = parsedHandlerResult.data.editedSpecContent;
-          clientStartsHandoffSession = parsedHandlerResult.data.clientStartsHandoffSession;
-          specHandoffId = parsedHandlerResult.data.specHandoffId;
+          result = parsedHandlerResult.data;
         } else {
           throw new DroidClientError(
             "Permission handler returned invalid result",
@@ -2245,19 +2450,20 @@ var DroidClient = class _DroidClient extends EventEmitter {
             }
           );
         }
-        if (!event.params.options.some(
-          (option) => option.value === selectedOption
+        if (!isOfferedPermissionOutcome(
+          event.params.options,
+          result.selectedOption
         )) {
           throw new DroidClientError(
-            `Permission handler selected unavailable option: ${selectedOption}`
+            `Permission handler selected unavailable option: ${result.selectedOption}`
           );
         }
         this.logger.info("[DroidClient] Permission handler resolved", {
           requestId: event.id,
-          result: selectedOption
+          result: result.selectedOption
         });
       } catch (error) {
-        this.logger.exception(
+        this.reportHandlerFailure(
           error,
           "Failed to handle permission request (processing)"
         );
@@ -2272,7 +2478,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
         const cancelResponse = {
           type: "response",
           jsonrpc: JSONRPC_VERSION2,
-          factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+          factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
           factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
           id: event.id,
           result: {
@@ -2280,9 +2486,9 @@ var DroidClient = class _DroidClient extends EventEmitter {
           }
         };
         try {
-          await this.transport.send(cancelResponse);
+          await this.sendResponse(cancelResponse, hostMeta);
         } catch (sendError) {
-          this.logger.exception(
+          this.reportHandlerFailure(
             sendError,
             "Failed to handle permission request (send cancellation)"
           );
@@ -2297,27 +2503,19 @@ var DroidClient = class _DroidClient extends EventEmitter {
         return;
       }
     }
-    const response = {
+    const response2 = {
       type: "response",
       jsonrpc: JSONRPC_VERSION2,
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       id: event.id,
-      result: {
-        selectedOption,
-        ...comment !== void 0 && { comment },
-        ...editedSpecContent !== void 0 && { editedSpecContent },
-        ...clientStartsHandoffSession !== void 0 && {
-          clientStartsHandoffSession
-        },
-        ...specHandoffId !== void 0 && { specHandoffId }
-      }
+      result
     };
     this.logger.info("[DroidClient] Sending permission response back to CLI", {
       requestId: event.id,
-      result: String(selectedOption)
+      result: String(result.selectedOption)
     });
-    await this.transport.send(response);
+    await this.sendResponse(response2, hostMeta);
   }
   async handleAskUserRequest(event) {
     this.logger.info("[DroidClient] Handling ask-user request", {
@@ -2326,6 +2524,21 @@ var DroidClient = class _DroidClient extends EventEmitter {
       count: event.params.questions.length
     });
     this.emit("ask_user" /* ASK_USER */, event);
+    if (event.params.blocking === false && !this.askUserHandlers.has("default")) {
+      this.heldQueuedAskUserRequests.push(event);
+      this.logger.info(
+        "[DroidClient] Holding queued ask-user request until a handler is set",
+        { requestId: event.id }
+      );
+      return;
+    }
+    await this.answerAskUserRequest(event);
+  }
+  async answerAskUserRequest(event) {
+    let hostMeta;
+    const setResponseMetadata = (meta) => {
+      hostMeta = meta;
+    };
     let result = { cancelled: true, answers: [] };
     const handler = this.askUserHandlers.get("default");
     if (handler) {
@@ -2338,7 +2551,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
         );
         const handlerPromise = new Promise((resolve2, reject) => {
           this.pendingAskUserRequests.set(event.id, { reject });
-          handler(event).then(resolve2).catch(reject).finally(() => {
+          handler(event, setResponseMetadata).then(resolve2).catch(reject).finally(() => {
             this.pendingAskUserRequests.delete(event.id);
           });
         });
@@ -2360,7 +2573,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
           count: result.answers.length
         });
       } catch (error) {
-        this.logger.exception(error, "Failed to handle ask-user request");
+        this.reportHandlerFailure(error, "Failed to handle ask-user request");
         const err = error instanceof Error ? error : new Error(String(error));
         this.emit(
           "session_notification" /* SESSION_NOTIFICATION */,
@@ -2369,9 +2582,19 @@ var DroidClient = class _DroidClient extends EventEmitter {
           )
         );
         this.pendingAskUserRequests.delete(event.id);
-        const cancelResponse = {
+        const cancelResponse = event.params.blocking === false ? {
           jsonrpc: JSONRPC_VERSION2,
-          factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+          factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
+          factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+          type: "response",
+          id: event.id,
+          error: {
+            code: -32603 /* INTERNAL_ERROR */,
+            message: "The queued AskUser request could not be answered"
+          }
+        } : {
+          jsonrpc: JSONRPC_VERSION2,
+          factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
           factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
           type: "response",
           id: event.id,
@@ -2381,9 +2604,9 @@ var DroidClient = class _DroidClient extends EventEmitter {
           }
         };
         try {
-          await this.transport.send(cancelResponse);
+          await this.sendResponse(cancelResponse, hostMeta);
         } catch (sendError) {
-          this.logger.exception(
+          this.reportHandlerFailure(
             sendError,
             "Failed to send ask-user cancellation"
           );
@@ -2391,10 +2614,10 @@ var DroidClient = class _DroidClient extends EventEmitter {
         return;
       }
     }
-    const response = {
+    const response2 = {
       type: "response",
       jsonrpc: JSONRPC_VERSION2,
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       id: event.id,
       result
@@ -2403,7 +2626,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       requestId: event.id,
       cancelled: result.cancelled ?? false
     });
-    await this.transport.send(response);
+    await this.sendResponse(response2, hostMeta);
   }
   /**
    * Same shape as the ask-user round trip: the handler (a UI) resolves with
@@ -2418,6 +2641,10 @@ var DroidClient = class _DroidClient extends EventEmitter {
       toolCallId: event.params.toolCallId,
       count: event.params.rows.length
     });
+    let hostMeta;
+    const setResponseMetadata = (meta) => {
+      hostMeta = meta;
+    };
     this.emit("pick_options" /* PICK_OPTIONS */, event);
     let result = { cancelled: true, selectedIds: [] };
     const handler = this.pickOptionsHandlers.get("default");
@@ -2426,7 +2653,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
         const handlerPromise = new Promise(
           (resolve2, reject) => {
             this.pendingPickOptionsRequests.set(event.id, { reject });
-            handler(event).then(resolve2).catch(reject).finally(() => {
+            handler(event, setResponseMetadata).then(resolve2).catch(reject).finally(() => {
               this.pendingPickOptionsRequests.delete(event.id);
             });
           }
@@ -2450,23 +2677,26 @@ var DroidClient = class _DroidClient extends EventEmitter {
           });
           const failure = {
             jsonrpc: JSONRPC_VERSION2,
-            factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+            factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
             factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
             type: "response",
             id: event.id,
             error: error.rpcError
           };
           try {
-            await this.transport.send(failure);
+            await this.sendResponse(failure, hostMeta);
           } catch (sendError) {
-            this.logger.exception(
+            this.reportHandlerFailure(
               sendError,
               "Failed to send pick-options failure"
             );
           }
           return;
         }
-        this.logger.exception(error, "Failed to handle pick-options request");
+        this.reportHandlerFailure(
+          error,
+          "Failed to handle pick-options request"
+        );
         const err = error instanceof Error ? error : new Error(String(error));
         this.emit(
           "session_notification" /* SESSION_NOTIFICATION */,
@@ -2476,16 +2706,16 @@ var DroidClient = class _DroidClient extends EventEmitter {
         );
         const cancelResponse = {
           jsonrpc: JSONRPC_VERSION2,
-          factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+          factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
           factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
           type: "response",
           id: event.id,
           result: { cancelled: true, selectedIds: [] }
         };
         try {
-          await this.transport.send(cancelResponse);
+          await this.sendResponse(cancelResponse, hostMeta);
         } catch (sendError) {
-          this.logger.exception(
+          this.reportHandlerFailure(
             sendError,
             "Failed to send pick-options cancellation"
           );
@@ -2493,19 +2723,20 @@ var DroidClient = class _DroidClient extends EventEmitter {
         return;
       }
     }
-    const response = {
+    const response2 = {
       type: "response",
       jsonrpc: JSONRPC_VERSION2,
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       id: event.id,
       result
     };
-    await this.transport.send(response);
+    await this.sendResponse(response2, hostMeta);
   }
   static getErrorType(error) {
     switch (error.constructor) {
       case ConnectionError:
+      case DroidConnectionEndedError:
         return "ConnectionError" /* CONNECTION_ERROR */;
       case ProtocolError:
         return "ProtocolError" /* PROTOCOL_ERROR */;
@@ -2555,7 +2786,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
     return {
       jsonrpc: JSONRPC_VERSION2,
       type: "notification",
-      factoryApiVersion: LEGACY_FACTORY_API_VERSION,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
       factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
       method: "droid.session_notification" /* SESSION_NOTIFICATION */,
       params: { notification }
@@ -2815,6 +3046,13 @@ function describeSpawnError(error, context) {
   }
   return `Failed to start Droid: ${error.code}`;
 }
+function createSpawnError(error, context) {
+  return new DroidConnectionEndedError(describeSpawnError(error, context), {
+    error,
+    cwd: context?.cwd,
+    execPath: context?.execPath
+  });
+}
 function describeExitError(code, signal) {
   if (signal) {
     return `Droid process was killed (${signal})`;
@@ -2860,13 +3098,29 @@ var ManagedProcessImpl = class {
   logger;
   get childProcess() {
     if (!this._childProcess) {
-      throw new ConnectionError("Process not connected");
+      throw new DroidConnectionEndedError("Process not connected");
     }
     return this._childProcess;
   }
+  /** Wait for the runtime's spawn result without replacing the transport's error handler. */
+  waitForSpawn() {
+    const child = this.childProcess;
+    return new Promise((resolve2, reject) => {
+      const onSpawn = () => {
+        child.off("error", onError);
+        resolve2();
+      };
+      const onError = () => {
+        child.off("spawn", onSpawn);
+        reject(this.processError);
+      };
+      child.once("spawn", onSpawn);
+      child.once("error", onError);
+    });
+  }
   setupHandlers() {
     if (!this.childProcess.stdout) {
-      throw new ConnectionError("Failed to get process stdout");
+      throw new DroidConnectionEndedError("Failed to get process stdout");
     }
     this.childProcess.stdout.setEncoding("utf8");
     this.childProcess.stdout.on("data", this.stdoutDataHandler);
@@ -2874,23 +3128,19 @@ var ManagedProcessImpl = class {
       if (this.processError || this.isClosing || this.exitFinalized) {
         return;
       }
-      this.processError = new ConnectionError(
-        describeSpawnError(error, this.spawnContext),
-        {
-          error,
-          cwd: this.spawnContext?.cwd,
-          execPath: this.spawnContext?.execPath
-        }
-      );
+      this.processError = createSpawnError(error, this.spawnContext);
       this.errorHandler?.(this.processError);
     });
     this.childProcess.stdin?.on("error", (error) => {
       if (this.processError || this.isClosing || this.exitFinalized) {
         return;
       }
-      this.processError = new ConnectionError("Process stdin failed", {
-        error
-      });
+      this.processError = new DroidConnectionEndedError(
+        "Process stdin failed",
+        {
+          error
+        }
+      );
       this.errorHandler?.(this.processError);
     });
     this.childProcess.on("exit", (code, signal) => {
@@ -2965,24 +3215,28 @@ var ManagedProcessImpl = class {
       throw this.processError;
     }
     if (!this._childProcess || !this._childProcess.stdin) {
-      throw new ConnectionError("Process not connected");
+      throw new DroidConnectionEndedError("Process not connected");
     }
     const previousSends = this.queuedSendPromise;
     this.queuedSendPromise = (async () => {
       await previousSends.catch(() => {
       });
       if (!this._childProcess || !this._childProcess.stdin || this._childProcess.killed || this.isClosing) {
-        throw new ConnectionError("Process disconnected before write");
+        throw new DroidConnectionEndedError(
+          "Process disconnected before write"
+        );
       }
       await new Promise((resolve2, reject) => {
         try {
           if (!this._childProcess || !this._childProcess.stdin) {
-            reject(new ConnectionError("Process stdin unavailable"));
+            reject(new DroidConnectionEndedError("Process stdin unavailable"));
             return;
           }
           const stdin = this._childProcess.stdin;
           if ("writable" in stdin && !stdin.writable) {
-            reject(new ConnectionError("Process stdin is not writable"));
+            reject(
+              new DroidConnectionEndedError("Process stdin is not writable")
+            );
             return;
           }
           const childPid = this._childProcess?.pid;
@@ -2998,15 +3252,21 @@ var ManagedProcessImpl = class {
               const errorMessage = error.message || String(error);
               if (errorMessage.includes("EPIPE") || errorMessage.includes("ECONNRESET")) {
                 reject(
-                  new ConnectionError("Process stdin closed during write", {
-                    error
-                  })
+                  new DroidConnectionEndedError(
+                    "Process stdin closed during write",
+                    {
+                      error
+                    }
+                  )
                 );
               } else {
                 reject(
-                  new ConnectionError("Failed to write to process stdin", {
-                    error
-                  })
+                  new DroidConnectionEndedError(
+                    "Failed to write to process stdin",
+                    {
+                      error
+                    }
+                  )
                 );
               }
             } else {
@@ -3028,7 +3288,7 @@ var ManagedProcessImpl = class {
             }
           );
           reject(
-            new ConnectionError("Error writing to process stdin", {
+            new DroidConnectionEndedError("Error writing to process stdin", {
               error: error instanceof Error ? error : new Error(String(error))
             })
           );
@@ -3185,10 +3445,8 @@ async function spawnWithWindowsJobObjectRetry(spawnFactory, options = {}) {
   const sleep = options.sleep ?? defaultSleep;
   const logPrefix = options.logPrefix ?? "[spawnWithWindowsJobObjectRetry]";
   const logger = options.logger ?? noopLogger;
-  let lastChild = null;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+  for (let attempt = 0; ; attempt++) {
     const child = spawnFactory();
-    lastChild = child;
     const observation = await observeEarlySpawnFailure(
       child,
       gracePeriodMs,
@@ -3198,8 +3456,28 @@ async function spawnWithWindowsJobObjectRetry(spawnFactory, options = {}) {
       return child;
     }
     const isRetryableJobObjectFailure = observation.stderr.includes(WINDOWS_JOB_OBJECT_ERROR_MARKER) || observation.exited && observation.code !== 0 && !observation.error;
-    if (attempt === maxRetries || !isRetryableJobObjectFailure) {
-      return child;
+    try {
+      await options.disposeEarlyExited?.(child);
+    } catch (disposeErr) {
+      logWarn(logger, "spawnWithWindowsJobObjectRetry: dispose error", {
+        cause: disposeErr instanceof Error ? disposeErr : new Error(String(disposeErr)),
+        name: logPrefix
+      });
+    }
+    if (attempt >= maxRetries || !isRetryableJobObjectFailure) {
+      if (observation.error) {
+        throw createSpawnError(observation.error, options);
+      }
+      throw new DroidConnectionEndedError(
+        "Droid process exited during startup",
+        {
+          cwd: options.cwd,
+          execPath: options.execPath,
+          exitCode: observation.code,
+          signal: observation.signal,
+          stderrTail: observation.stderr.slice(-256)
+        }
+      );
     }
     logger.warn("spawnWithWindowsJobObjectRetry: retrying on early failure", {
       name: logPrefix,
@@ -3209,21 +3487,8 @@ async function spawnWithWindowsJobObjectRetry(spawnFactory, options = {}) {
       signal: observation.signal,
       stderrTail: observation.stderr.slice(-256)
     });
-    try {
-      await options.disposeEarlyExited?.(child);
-    } catch (disposeErr) {
-      logWarn(logger, "spawnWithWindowsJobObjectRetry: dispose error", {
-        cause: disposeErr instanceof Error ? disposeErr : new Error(String(disposeErr)),
-        name: logPrefix
-      });
-    }
     await sleep(backoff[attempt] ?? backoff[backoff.length - 1] ?? 400);
   }
-  if (lastChild) return lastChild;
-  throw new DroidClientError(
-    "spawnWithWindowsJobObjectRetry: exhausted retries without child",
-    {}
-  );
 }
 
 // src/exec-core/process-manager.ts
@@ -3311,6 +3576,8 @@ var DroidProcessManager = class {
       () => this.invokeNodeSpawn(planned),
       {
         ...retryOptions,
+        cwd: planned.expandedCwd,
+        execPath: planned.execPath,
         logPrefix: "[DroidProcessManager]",
         logger: this.logger,
         disposeEarlyExited: (child) => {
@@ -3341,7 +3608,7 @@ var DroidProcessManager = class {
     );
     if (!childProcess.stdout || !childProcess.stdin) {
       childProcess.kill();
-      throw new ConnectionError("Failed to get process stdio");
+      throw new DroidConnectionEndedError("Failed to get process stdio");
     }
     return new ManagedProcessImpl(
       childProcess,
@@ -3468,7 +3735,7 @@ var DroidProcessManager = class {
     const childProcess = this.invokeNodeSpawn(planned);
     if (!childProcess.stdout || !childProcess.stdin) {
       childProcess.kill();
-      throw new ConnectionError("Failed to get process stdio");
+      throw new DroidConnectionEndedError("Failed to get process stdio");
     }
     return {
       logPrefix: planned.logPrefix,
@@ -3509,7 +3776,7 @@ var ProcessTransport = class {
   }
   async connect() {
     if (this.managedProcess && this.managedProcess.isConnected) {
-      throw new ConnectionError("Transport already connected");
+      throw new DroidClientError("Transport already connected");
     }
     const config = {
       execPath: this.options.droidExecPath,
@@ -3531,8 +3798,22 @@ var ProcessTransport = class {
     let spawnOutcome = "error";
     let managedProcess;
     try {
-      managedProcess = process.platform === "win32" ? await this.processManager.spawnWithWindowsRetry(config) : this.processManager.spawn(config);
+      if (process.platform === "win32") {
+        managedProcess = await this.processManager.spawnWithWindowsRetry(config);
+      } else {
+        const spawned = this.processManager.spawn(config);
+        managedProcess = spawned;
+        if (spawned.childProcess.pid === void 0) {
+          await spawned.waitForSpawn();
+        }
+      }
       spawnOutcome = "success";
+    } catch (error) {
+      await managedProcess?.close();
+      if (error instanceof DroidConnectionEndedError) {
+        this.errorHandler?.(error);
+      }
+      throw error;
     } finally {
       this.metrics.recordDuration(
         CLI_JSONRPC_CHILD_SPAWN_LATENCY_METRIC,
@@ -3556,7 +3837,7 @@ var ProcessTransport = class {
   }
   async send(message) {
     if (!this.managedProcess) {
-      throw new ConnectionError("Transport not connected");
+      throw new DroidConnectionEndedError("Transport not connected");
     }
     return await this.managedProcess.send(JSON.stringify(message));
   }
@@ -3586,6 +3867,180 @@ var ProcessTransport = class {
   }
 };
 
+// src/environment-session.ts
+import { v4 as uuidv43 } from "uuid";
+
+// src/environment-launch/index.ts
+import { v4 as uuidv42 } from "uuid";
+
+// src/environment-launch/errors.ts
+var EnvironmentLaunchError = class extends Error {
+  computerId;
+  computerName;
+  cleanupError;
+  constructor(options) {
+    super(
+      options.cause instanceof Error ? options.cause.message : "Environment session startup failed",
+      { cause: options.cause }
+    );
+    this.name = "EnvironmentLaunchError";
+    this.computerId = options.computerId;
+    this.computerName = options.computerName;
+    this.cleanupError = options.cleanupError;
+  }
+};
+
+// src/environment-launch/index.ts
+async function launchEnvironmentSession(options) {
+  const timeoutMs = options.timeoutMs ?? 18e4;
+  const pollIntervalMs = options.pollIntervalMs ?? 1e3;
+  const controller = new AbortController();
+  const cancel = () => controller.abort(options.signal?.reason);
+  if (options.signal?.aborted) cancel();
+  else options.signal?.addEventListener("abort", cancel, { once: true });
+  const timer = setTimeout(
+    () => controller.abort(new EnvironmentComputerTimeoutError()),
+    timeoutMs
+  );
+  const signal = controller.signal;
+  let createdComputerId;
+  let computerName;
+  function launchError(cause, cleanupError) {
+    return new EnvironmentLaunchError({
+      cause,
+      computerId: createdComputerId,
+      computerName,
+      cleanupError
+    });
+  }
+  try {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || !Number.isFinite(pollIntervalMs) || pollIntervalMs <= 0)
+      throw new Error("Invalid environment launch configuration");
+    const selection = await runWithAbort(
+      signal,
+      async () => await resolveEnvironment({ ...options, signal })
+    );
+    computerName = `environment-${uuidv42()}`;
+    signal.throwIfAborted();
+    const createPromise = createOrRecoverComputer({
+      name: computerName,
+      environmentId: selection.environment.id,
+      keepWhenIdle: options.keepWhenIdle,
+      request: options.request,
+      serviceAccountId: options.serviceAccountId,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    const allocated = await runWithAbort(signal, async () => await createPromise).catch(
+      (cause) => {
+        if (signal.aborted && createdComputerId === void 0)
+          void createPromise.then(
+            (computer2) => createFactoryApi(options.request).deleteComputer({
+              computerId: computer2.id,
+              signal: AbortSignal.timeout(Math.min(timeoutMs, 5e3))
+            })
+          ).catch(() => {
+          });
+        throw cause;
+      }
+    );
+    createdComputerId = allocated.id;
+    await runWithAbort(signal, async () => await options.onComputer?.(allocated));
+    const computer = await waitForEnvironmentComputer({
+      computer: allocated,
+      timeoutMs,
+      pollIntervalMs,
+      now: options.now,
+      sleep: options.sleep,
+      signal,
+      isReady: isEnvironmentComputerReady,
+      onComputer: options.onComputer,
+      request: options.request,
+      serviceAccountId: options.serviceAccountId
+    });
+    const connection = await runWithAbort(
+      signal,
+      async () => await options.connect({ computer, signal })
+    );
+    const session = await runWithAbort(
+      signal,
+      async () => await options.startSession({ connection, computer, selection, signal })
+    );
+    return { session, computer, selection };
+  } catch (cause) {
+    if (createdComputerId !== void 0) {
+      const cleanup = new AbortController();
+      const cleanupTimer = setTimeout(
+        () => cleanup.abort(new EnvironmentComputerTimeoutError()),
+        Math.min(timeoutMs, 5e3)
+      );
+      try {
+        const computerId = createdComputerId;
+        await runWithAbort(
+          cleanup.signal,
+          async () => await createFactoryApi(options.request).deleteComputer({
+            computerId,
+            signal: cleanup.signal
+          })
+        );
+      } catch (failure) {
+        throw launchError(cause, failure);
+      } finally {
+        clearTimeout(cleanupTimer);
+      }
+    }
+    throw launchError(cause);
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", cancel);
+  }
+}
+async function resolveEnvironment(options) {
+  const http2 = createFactoryApi(options.request);
+  const selector = options.environment;
+  if ("id" in selector ? !selector.id.trim() : !selector.name.trim())
+    throw new Error("Invalid environment selector");
+  const context = {
+    serviceAccountId: options.serviceAccountId,
+    signal: options.signal
+  };
+  let environment;
+  if ("id" in selector && context.serviceAccountId === void 0) {
+    environment = SandboxEnvironmentSchema.parse(
+      await http2.getEnvironment({
+        ...context,
+        environmentId: selector.id
+      })
+    );
+    if (environment.id !== selector.id)
+      throw new Error("Environment lookup returned a different ID");
+  } else {
+    const matches = [];
+    options.signal?.throwIfAborted();
+    const page = await http2.listEnvironments(context);
+    if (!page || typeof page !== "object" || !("environments" in page) || !Array.isArray(page.environments))
+      throw new Error("Invalid environment list response");
+    for (const item of page.environments) {
+      const candidate = SandboxEnvironmentSchema.parse(item);
+      if ("id" in selector ? candidate.id === selector.id : candidate.name === selector.name)
+        matches.push(candidate);
+    }
+    if (matches.length !== 1)
+      throw new Error(
+        "id" in selector ? "Environment is not accessible" : "Environment name must match exactly one accessible environment"
+      );
+    environment = matches[0];
+  }
+  if (!environment) throw new Error("Environment is not accessible");
+  if (!isSandboxEnvironmentLaunchable(environment)) {
+    throw new Error("Environment is not ready to launch");
+  }
+  return {
+    environment,
+    source: getSandboxEnvironmentLaunchSource(environment),
+    repositories: getSandboxEnvironmentLaunchRepositories(environment)
+  };
+}
+
 // src/helpers.ts
 function resolveApiKey(apiKey) {
   const resolved = apiKey ?? process.env.FACTORY_API_KEY;
@@ -3608,7 +4063,10 @@ async function createTransport(options) {
       ...options.env,
       FACTORY_API_KEY: resolveApiKey(options.apiKey),
       FACTORY_UPSTREAM_CLIENT_TYPE: "sdk" /* SDK */,
-      FACTORY_UPSTREAM_SDK: SDK_IDENTITY
+      FACTORY_UPSTREAM_SDK: SDK_IDENTITY,
+      // This helper owns the original SDK process, unlike the generic
+      // ProcessTransport also used by daemon workers.
+      FACTORY_EXEC_ORIGINAL_INVOCATION: "1"
     },
     observability: options.observability
   });
@@ -3616,13 +4074,26 @@ async function createTransport(options) {
   return processTransport;
 }
 function setupClientHandlers(client, options) {
+  const sessionId = () => {
+    const addressed = client.addressedSessionId;
+    if (!addressed) {
+      throw new DroidClientError(
+        "Received a prompt that no single session owns"
+      );
+    }
+    return addressed;
+  };
   if (options.permissionHandler) {
     const handler = options.permissionHandler;
-    client.setPermissionHandler((event) => handler(event.params));
+    client.setPermissionHandler(
+      (event) => handler({ ...event.params, sessionId: sessionId() })
+    );
   }
   if (options.askUserHandler) {
     const handler = options.askUserHandler;
-    client.setAskUserHandler((event) => handler(event.params));
+    client.setAskUserHandler(
+      (event) => handler({ ...event.params, sessionId: sessionId() })
+    );
   }
 }
 async function createConfiguredClient(options) {
@@ -3922,6 +4393,313 @@ async function startSdkMcpServers(servers) {
   };
 }
 
+// src/session-operations.ts
+function response(result) {
+  return {
+    type: "response",
+    jsonrpc: JSONRPC_VERSION2,
+    factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
+    factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+    id: "sdk-adapter",
+    result
+  };
+}
+function createDaemonSessionOperations(controller, initialSessionId, handlers) {
+  let sessionId = initialSessionId;
+  const ownedSessionIds = /* @__PURE__ */ new Set([initialSessionId]);
+  const reportError = (error) => controller.emit("error", toError(error));
+  const permission = async (request) => {
+    if (request.sessionId !== sessionId && !request.associatedSessionIds.includes(sessionId))
+      return;
+    const selected = await resolvePermissionHandler(
+      handlers.permissionHandler,
+      request,
+      reportError
+    ) ?? {
+      selectedOption: "cancel" /* Cancel */
+    };
+    try {
+      await controller.respondToPermission({
+        permissionId: request.requestId,
+        sessionId,
+        ...selected
+      });
+    } catch (error) {
+      reportError(error);
+    }
+  };
+  const askUser = async (request) => {
+    if (request.sessionId !== sessionId) return;
+    const result = await resolveAskUserHandler(
+      handlers.askUserHandler,
+      request,
+      reportError
+    );
+    if (!result && request.blocking === false) return;
+    try {
+      await controller.respondToAskUser({
+        requestId: request.requestId,
+        sessionId,
+        result: result ?? { cancelled: true, answers: [] }
+      });
+    } catch (error) {
+      reportError(error);
+    }
+  };
+  controller.on("permissionRequested" /* PermissionRequested */, permission);
+  controller.on("askUserRequested" /* AskUserRequested */, askUser);
+  const operations = {
+    lifecycle: {
+      shutdown: async () => {
+        try {
+          const results = await Promise.allSettled(
+            [...ownedSessionIds].map((id) => controller.closeSession(id))
+          );
+          const failure = results.find(
+            (result) => result.status === "rejected"
+          );
+          if (failure?.status === "rejected") throw toError(failure.reason);
+        } finally {
+          await operations.close();
+        }
+      },
+      abort: (close) => {
+        void close().catch(() => {
+        });
+      }
+    },
+    onNotification(callback, filter) {
+      const listener = (event) => {
+        if (event.sessionId !== sessionId || filter?.type !== void 0 && filter.type !== event.notification.type)
+          return;
+        try {
+          callback({
+            type: "notification",
+            jsonrpc: JSONRPC_VERSION2,
+            factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
+            factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+            method: "droid.session_notification" /* SESSION_NOTIFICATION */,
+            params: { notification: event.notification }
+          });
+        } catch {
+        }
+      };
+      controller.on("sessionNotification" /* SessionNotification */, listener);
+      return () => controller.off("sessionNotification" /* SessionNotification */, listener);
+    },
+    onError(callback) {
+      const disconnected = (code, reason) => callback(new ConnectionClosedError(code, reason));
+      const exited = (event) => {
+        if (event.sessionId === sessionId && event.notification.type === "session_process_exited" /* SESSION_PROCESS_EXITED */)
+          callback(
+            new DroidConnectionEndedError("Remote session process exited.")
+          );
+      };
+      controller.on("error", callback);
+      controller.on("disconnected" /* Disconnected */, disconnected);
+      controller.on("sessionNotification" /* SessionNotification */, exited);
+      return () => {
+        controller.off("error", callback);
+        controller.off("disconnected" /* Disconnected */, disconnected);
+        controller.off("sessionNotification" /* SessionNotification */, exited);
+      };
+    },
+    addUserMessage: async (params) => response(await controller.addUserMessage(sessionId, params)),
+    interruptSession: async () => response(await controller.interruptSession(sessionId)),
+    closeSession: async () => {
+      await controller.closeSession(sessionId);
+      return response({});
+    },
+    close: async () => {
+      controller.off("permissionRequested" /* PermissionRequested */, permission);
+      controller.off("askUserRequested" /* AskUserRequested */, askUser);
+      controller.destroy();
+      controller.getSessionStateManager().clear();
+    },
+    loadSession: async (params) => {
+      ownedSessionIds.add(params.sessionId);
+      const result = await controller.loadSession({
+        ...params,
+        sessionOriginHint: params.sessionOriginHint,
+        sessionSource: params.sessionSource
+      });
+      sessionId = params.sessionId;
+      return response(result);
+    },
+    updateSessionSettings: async (params) => response(await controller.updateSessionSettings(sessionId, params)),
+    addMcpServer: async (params) => response(await controller.addMcpServer({ ...params, sessionId })),
+    removeMcpServer: async (params) => response(await controller.removeMcpServer({ ...params, sessionId })),
+    toggleMcpServer: async (params) => response(await controller.toggleMcpServer({ ...params, sessionId })),
+    listMcpServers: async () => response(await controller.listMcpServers(sessionId)),
+    listMcpTools: async () => response(await controller.listMcpTools(sessionId)),
+    refreshConnectorToolCatalog: async () => response(await controller.refreshConnectorToolCatalog()),
+    authenticateMcpServer: async (params) => response(
+      await controller.authenticateMcpServer({ ...params, sessionId })
+    ),
+    listSkills: async (params) => response(await controller.listSkills(sessionId, params)),
+    setSkillDisabled: async (skillName, disabled, settingsLevel) => response(
+      await controller.setSkillDisabled({
+        sessionId,
+        skillName,
+        disabled,
+        settingsLevel
+      })
+    ),
+    getRewindInfo: async (params) => response(await controller.getRewindInfo(sessionId, params.messageId)),
+    executeRewind: async (params) => response(await controller.executeRewind(sessionId, params)),
+    compactSession: async (params) => response(
+      await controller.compactSession(
+        sessionId,
+        params.customInstructions,
+        params.mode
+      )
+    ),
+    forkSession: async (params) => response(await controller.forkSession(sessionId, params)),
+    renameSession: async (params) => response(await controller.renameSession(sessionId, params.title)),
+    listTools: async () => {
+      throw new DroidClientError(
+        "listTools is not supported by remote sessions."
+      );
+    },
+    getContextStats: async () => {
+      throw new DroidClientError(
+        "getContextStats is not supported by remote sessions."
+      );
+    }
+  };
+  return operations;
+}
+
+// src/environment-session.ts
+async function createEnvironmentSession(options, createHandle) {
+  if (!options.environment)
+    throw new DroidClientError("An environment is required.");
+  for (const key of [
+    "execPath",
+    "execArgs",
+    "env",
+    "transport",
+    "machineId"
+  ]) {
+    if (options[key] !== void 0)
+      throw new DroidClientError(
+        `Option "${key}" is local-only and cannot be used with an environment.`
+      );
+  }
+  const mcpServers = options.mcpServers?.map((server) => {
+    if (server instanceof SdkMcpServer)
+      throw new DroidClientError(
+        "In-process MCP servers cannot be used with an environment."
+      );
+    return server;
+  });
+  const apiKey = resolveApiKey(options.apiKey);
+  const auth = { apiKey, baseUrl: options.baseUrl };
+  const request = createApiRequest(auth);
+  const api = createFactoryApi(request);
+  const sessionId = uuidv43();
+  let startup;
+  try {
+    const launched = await launchEnvironmentSession({
+      environment: options.environment,
+      signal: options.abortSignal,
+      request,
+      connect: async ({ computer, signal }) => {
+        if (!computer.relayClientUrl)
+          throw new DroidClientError("Computer has no relay URL.");
+        const connectionConfig = {
+          ...DEFAULT_CONNECTION_CONFIG,
+          ...MACHINE_TYPE_CONFIG["computer" /* Computer */]
+        };
+        const connected = new DaemonSessionController({
+          sessionStateManager: new MultiSessionStateManager(),
+          config: {
+            machineId: computer.id,
+            machineType: "computer" /* Computer */,
+            providerType: computer.providerType,
+            isManaged: true,
+            ensureRunning: async () => ({ wasRestarted: false }),
+            trustedIdentity: trustedIdentityFromComputerResponse(
+              computer,
+              async () => {
+                const fresh = parseResponse(
+                  await api.getComputer({
+                    computerId: computer.id,
+                    signal: AbortSignal.timeout(5e3)
+                  }),
+                  ComputerReadSchema
+                );
+                if (fresh.id !== computer.id)
+                  throw new DroidClientError(
+                    "Identity refresh returned a different Computer."
+                  );
+                return fresh;
+              }
+            ),
+            url: computer.relayClientUrl,
+            clientType: "sdk" /* SDK */,
+            sdk: SDK_CLIENT_METADATA,
+            getCredential: async () => ({ apiKey }),
+            connectionTimeoutMs: connectionConfig.connectionTimeoutMs,
+            requestTimeout: connectionConfig.requestTimeoutMs,
+            maxPollAttempts: connectionConfig.maxPollAttempts,
+            maxReconnectAttempts: connectionConfig.maxReconnectAttempts,
+            reconnectInterval: connectionConfig.reconnectInitialDelayMs,
+            maxReconnectDelay: connectionConfig.reconnectMaxDelayMs,
+            reconnectBackoffFactor: connectionConfig.reconnectBackoffFactor,
+            supportsTerminalRestoreOnLoad: false
+          }
+        });
+        const operations = createDaemonSessionOperations(
+          connected,
+          sessionId,
+          options
+        );
+        const cancel = () => connected.destroy();
+        signal.addEventListener("abort", cancel, { once: true });
+        startup = {
+          operations,
+          releaseAbort: () => signal.removeEventListener("abort", cancel)
+        };
+        await connected.attemptInitialConnection();
+        signal.throwIfAborted();
+        return { controller: connected, operations };
+      },
+      startSession: async ({ connection, computer, signal }) => {
+        const { controller, operations } = connection;
+        const initParams = buildInitParams({
+          ...options,
+          machineId: computer.id,
+          cwd: options.cwd ?? computer.clonedRepoDirectories?.[0] ?? "~",
+          mcpServers
+        });
+        controller.getSessionStateManager().markSessionLoading(sessionId, computer.id);
+        const result = await controller.initializeSession({
+          ...initParams,
+          sessionId,
+          token: apiKey,
+          sessionSource: initParams.sessionSource,
+          sessionOriginHint: initParams.sessionOriginHint
+        });
+        signal.throwIfAborted();
+        return createHandle({
+          result,
+          operations,
+          computerId: computer.id,
+          cwd: initParams.cwd,
+          mcpServers
+        });
+      }
+    });
+    return launched.session;
+  } catch (error) {
+    await startup?.operations.close();
+    throw error;
+  } finally {
+    startup?.releaseAbort();
+  }
+}
+
 // src/session.ts
 var DroidSession = class _DroidSession {
   /** @internal */
@@ -3932,11 +4710,22 @@ var DroidSession = class _DroidSession {
     this._settings = metadata.settings;
     this._cwd = metadata.cwd;
     this._cleanupCallbacks = cleanupCallbacks;
+    this._lifecycle = _runtime.lifecycle ?? {
+      shutdown: async () => {
+        await client.closeSession({ reason: "other" }).catch(() => {
+        });
+        await client.close();
+      },
+      abort: (close) => {
+        void close();
+      }
+    };
     this._bindMetadataNotifications();
     this._bindAbortSignal();
   }
   _runtime;
   _client;
+  _lifecycle;
   _sessionId;
   _settings;
   _cwd;
@@ -3950,6 +4739,9 @@ var DroidSession = class _DroidSession {
   get id() {
     return this._sessionId;
   }
+  get computerId() {
+    return this._runtime.computerId;
+  }
   get settings() {
     return this._settings;
   }
@@ -3994,9 +4786,7 @@ var DroidSession = class _DroidSession {
       bridge.release();
     }
     try {
-      await this._client.closeSession({ reason: "other" }).catch(() => {
-      });
-      await this._client.close();
+      await this._lifecycle.shutdown();
     } finally {
       const cleanups = this._cleanupCallbacks.splice(0);
       await Promise.all(cleanups.map((cleanup) => cleanup()));
@@ -4259,7 +5049,7 @@ var DroidSession = class _DroidSession {
   _bindAbortSignal() {
     this._cleanupAbortSignal = wireAbortSignal(
       this._runtime.abortSignal,
-      () => void this.close()
+      () => this._lifecycle.abort(() => this.close())
     );
   }
   _bindMetadataNotifications() {
@@ -4304,6 +5094,22 @@ function createReplacementLoadParams(options, mcpServers) {
   };
 }
 async function createSession(options = {}) {
+  if (options.environment) {
+    return await createEnvironmentSession(
+      options,
+      ({ result, operations, computerId, cwd, mcpServers }) => new DroidSession(
+        operations,
+        result.sessionId,
+        { settings: result.settings, cwd },
+        {
+          computerId,
+          abortSignal: options.abortSignal,
+          loadParams: createReplacementLoadParams(options, mcpServers),
+          lifecycle: operations.lifecycle
+        }
+      )
+    );
+  }
   const { client } = await createConfiguredClient(options);
   let cleanupInitAbortSignal = options.abortSignal?.aborted ? () => {
   } : wireAbortSignal(options.abortSignal, () => {
@@ -4393,12 +5199,14 @@ async function run(prompt, options = {}) {
       includePartialMessages: false
     })) {
       if (msg.type === DroidMessageType.Result) {
-        return msg;
+        const computerId = session.computerId;
+        return computerId === void 0 ? msg : { ...msg, computerId };
       }
     }
     throw new Error("Stream completed without a result message");
   } finally {
-    await session.close();
+    await session.close().catch(() => {
+    });
   }
 }
 
@@ -4418,9 +5226,14 @@ var CR = 13;
 var SPACE = 32;
 var TAB = 9;
 var PARSE_OVERSAMPLE = 20;
-function readFileBuffer(filePath) {
+function readFileOrNull(filePath, read) {
   try {
-    return fs3.readFileSync(filePath);
+    const fd = fs3.openSync(filePath, "r");
+    try {
+      return read(fd);
+    } finally {
+      fs3.closeSync(fd);
+    }
   } catch {
     return null;
   }
@@ -4432,37 +5245,83 @@ function parseJsonBuffer(buf) {
     return null;
   }
 }
-function scanBufferForLines(buf) {
+var SCAN_CHUNK_BYTES = 64 * 1024;
+var MAX_SCANNED_FILE_BYTES = 2 ** 31 - 1;
+function scratchChunk(scratch, size) {
+  const want = Math.min(SCAN_CHUNK_BYTES, size === 0 ? 8192 : size);
+  const current = scratch.chunk;
+  if (current && current.length >= want) return current;
+  const grown = Buffer.allocUnsafe(
+    Math.min(SCAN_CHUNK_BYTES, Math.max(want, 2 * (current?.length ?? 0)))
+  );
+  scratch.chunk = grown;
+  return grown;
+}
+function copyFirstLine(parts, chunk, end) {
+  return Buffer.concat([...parts, chunk.subarray(0, end)]);
+}
+function scanSessionFile(fd, scratch) {
+  const stats = fs3.fstatSync(fd);
+  const size = stats.isFile() ? stats.size : 0;
+  if (size > MAX_SCANNED_FILE_BYTES) return null;
+  const chunk = scratchChunk(scratch, size);
   let nonEmptyLineCount = 0;
-  let firstLineEnd = -1;
-  let currentLineHasContent = false;
-  for (let i = 0; i < buf.length; i++) {
-    const ch = buf[i];
-    if (ch === LF) {
-      if (currentLineHasContent) nonEmptyLineCount++;
-      if (firstLineEnd === -1) firstLineEnd = i;
-      currentLineHasContent = false;
-    } else if (ch !== CR && ch !== SPACE && ch !== TAB) {
-      currentLineHasContent = true;
-    }
-  }
-  if (currentLineHasContent) nonEmptyLineCount++;
-  const end = firstLineEnd === -1 ? buf.length : firstLineEnd > 0 && buf[firstLineEnd - 1] === CR ? firstLineEnd - 1 : firstLineEnd;
-  return {
-    firstLine: buf.subarray(0, end),
-    nonEmptyLineCount
-  };
+  let lineHasContent = false;
+  const firstLineParts = [];
+  let firstLine;
+  let pos = 0;
+  for (; ; ) {
+    const length = size === 0 ? chunk.length : Math.min(chunk.length, size - pos);
+    if (length === 0) break;
+    const bytesRead = fs3.readSync(fd, chunk, 0, length, null);
+    if (bytesRead === 0) break;
+    pos += bytesRead;
+    let i = 0;
+    while (i < bytesRead) {
+      let lf;
+      if (lineHasContent) {
+        lf = chunk.indexOf(LF, i);
+        if (lf === -1 || lf >= bytesRead) break;
+        nonEmptyLineCount++;
+        lineHasContent = false;
+      } else {
+        const ch = chunk[i];
+        if (ch === CR || ch === SPACE || ch === TAB) {
+          i++;
+          continue;
+        }
+        if (ch !== LF) {
+          lineHasContent = true;
+          continue;
+        }
+        lf = i;
+      }
+      firstLine ??= copyFirstLine(firstLineParts, chunk, lf);
+      i = lf + 1;
+    }
+    if (firstLine === void 0) {
+      firstLineParts.push(Buffer.from(chunk.subarray(0, bytesRead)));
+    }
+  }
+  if (lineHasContent) nonEmptyLineCount++;
+  const [onlyPart] = firstLineParts;
+  firstLine ??= onlyPart !== void 0 && firstLineParts.length === 1 ? onlyPart : Buffer.concat(firstLineParts);
+  return { firstLine, nonEmptyLineCount };
 }
 function loadFavorites(sessionsDir) {
-  const buf = readFileBuffer(path2.join(sessionsDir, FAVORITES_FILE));
+  const buf = readFileOrNull(
+    path2.join(sessionsDir, FAVORITES_FILE),
+    (fd) => fs3.readFileSync(fd)
+  );
   if (!buf) return /* @__PURE__ */ new Set();
   const parsed = parseJsonBuffer(buf);
   if (!Array.isArray(parsed)) return /* @__PURE__ */ new Set();
   return new Set(parsed.filter((id) => typeof id === "string"));
 }
 function loadSettingsFile(directory, sessionId) {
-  const buf = readFileBuffer(
-    path2.join(directory, `${sessionId}${SETTINGS_SUFFIX}`)
+  const buf = readFileOrNull(
+    path2.join(directory, `${sessionId}${SETTINGS_SUFFIX}`),
+    (fd) => fs3.readFileSync(fd)
   );
   if (!buf) return null;
   const parsed = parseJsonBuffer(buf);
@@ -4484,9 +5343,11 @@ function getMissionMetadataFromTags(settings) {
   };
 }
 function parseSessionFile(candidate, ctx) {
-  const buf = readFileBuffer(candidate.sessionPath);
-  if (!buf) return null;
-  const scanned = scanBufferForLines(buf);
+  const scanned = readFileOrNull(
+    candidate.sessionPath,
+    (fd) => scanSessionFile(fd, ctx.scratch)
+  );
+  if (!scanned) return null;
   const firstParsed = parseJsonBuffer(scanned.firstLine);
   if (firstParsed === null) return null;
   const firstResult = SessionStartEventSchema.safeParse(firstParsed);
@@ -4603,8 +5464,9 @@ async function listSessions(options = {}) {
   projectCandidates.sort(byMtimeDesc);
   legacyCandidates.sort(byMtimeDesc);
   const parseLimit = options.limit !== void 0 && options.limit >= 0 ? options.limit + PARSE_OVERSAMPLE : void 0;
-  const ctx = { favorites };
-  const legacyCtx = requiredCwd !== void 0 ? { favorites, requiredCwd } : ctx;
+  const scratch = { chunk: void 0 };
+  const ctx = { favorites, scratch };
+  const legacyCtx = requiredCwd !== void 0 ? { favorites, scratch, requiredCwd } : ctx;
   const projectSessions = parseUpTo(projectCandidates, ctx, parseLimit);
   const legacySessions = parseUpTo(legacyCandidates, legacyCtx, parseLimit);
   const byId = /* @__PURE__ */ new Map();
@@ -4628,10 +5490,10 @@ async function listModels(options = {}) {
   const { includeDisabled, ...transportOptions } = options;
   const { client } = await createConfiguredClient(transportOptions);
   try {
-    const response = await client.listModels({
+    const response2 = await client.listModels({
       ...includeDisabled !== void 0 && { includeDisabled }
     });
-    return unwrapResponseResult(response).models;
+    return unwrapResponseResult(response2).models;
   } finally {
     await closeQuietly(client);
   }
@@ -4646,6 +5508,7 @@ export {
   AddUserMessageRequestSchema,
   AddUserMessageResponseSchema,
   AddUserMessageResultSchema,
+  AnswerSessionElicitationResponseSchema,
   ApplyPatchToolConfirmationDetailsSchema,
   AskUserCollectedAnswerSchema,
   AskUserConfirmationDetailsSchema,
@@ -4731,6 +5594,7 @@ export {
   DroidClientError,
   DroidClientEvent,
   DroidClientMethod,
+  DroidConnectionEndedError,
   DroidErrorType,
   DroidEvent,
   DroidHookEventSchema,
@@ -4747,6 +5611,8 @@ export {
   DroidWorkingStateChangedNotificationSchema,
   EditToolConfirmationDetailsSchema,
   EmptyResultSchema,
+  EnvironmentListResponseSchema,
+  EnvironmentSchema,
   ErrorDetailSchema,
   ErrorNotificationSchema,
   ExecToolInfoSchema,
@@ -4759,7 +5625,7 @@ export {
   ExitSpecModeConfirmationDetailsSchema,
   FACTORY_CLIENT_HEADER,
   FACTORY_CLIENT_VERSION,
-  FACTORY_PROTOCOL_VERSION2 as FACTORY_PROTOCOL_VERSION,
+  FACTORY_PROTOCOL_VERSION,
   FactoryDaemonTransport,
   FactoryDroidMessageRole,
   FactoryDroidMessageSchema,
@@ -4802,7 +5668,7 @@ export {
   InvalidSessionCwdError,
   IpcDaemonClientTransport,
   IssueSeverity,
-  JSONRPC_VERSION3 as JSONRPC_VERSION,
+  JSONRPC_VERSION,
   JsonArraySchema,
   JsonObjectSchema,
   JsonRpcEnvelopeSchema,
@@ -4821,7 +5687,7 @@ export {
   KillWorkerSessionRequestSchema,
   KillWorkerSessionResponseSchema,
   KillWorkerSessionResultSchema,
-  LEGACY_FACTORY_API_VERSION2 as LEGACY_FACTORY_API_VERSION,
+  LEGACY_FACTORY_API_VERSION,
   LOCAL_MACHINE_ID,
   ListMcpRegistryRequestParamsSchema,
   ListMcpRegistryRequestSchema,
@@ -4837,6 +5703,7 @@ export {
   ListMcpToolsResultSchema,
   ListModelsOptionsSchema,
   ListModelsResultSchema,
+  ListSessionElicitationsResponseSchema,
   ListSkillsRequestParamsSchema,
   ListSkillsRequestSchema,
   ListSkillsResponseSchema,
@@ -4930,6 +5797,7 @@ export {
   RenameSessionRequestSchema,
   RenameSessionResponseSchema,
   RenameSessionResultSchema,
+  RequestCancelledError,
   RequestPermissionRequestParamsSchema,
   RequestPermissionRequestSchema,
   RequestPermissionResponseSchema,
@@ -4949,6 +5817,7 @@ export {
   SessionArtifactSchema,
   SessionArtifactSource,
   SessionArtifactsSchema,
+  SessionElicitationSchema,
   SessionError,
   SessionMetadataSchema,
   SessionNotFoundError,
@@ -5049,7 +5918,9 @@ export {
   WorkerSelectedFeatureEntrySchema,
   WorkerStartedEntrySchema,
   WorkerStateInfoSchema,
+  MissionMachineTargetKind as WorkstreamMachineTargetKind,
   __resetTransportLoggerForTests,
+  answerRemoteSessionElicitation,
   appendContextSession,
   buildUserMessageContentBlocks,
   configureDaemonCoreDeps,
@@ -5088,6 +5959,7 @@ export {
   hasSubagentSessionTag,
   inspectJsonRpcEnvelope,
   isDaemonQueuedMessageKind,
+  isDroidConnectionEnded,
   isPendingToolResultMarker,
   isPersistedHookMessage,
   isReviewableQueuedMessageKind,
@@ -5096,8 +5968,10 @@ export {
   listContextDocuments,
   listContextSessions,
   listContextSpaces,
+  listEnvironments,
   listMachineTemplates,
   listModels,
+  listRemoteSessionElicitations,
   listRemoteSessions,
   listSessions,
   logTransportMessage,