@factory/droid-sdk 0.9.1 → 0.11.0

package/dist/node.mjs

@@ -8,6 +8,7 @@ import {
   AddUserMessageRequestSchema,
   AddUserMessageResponseSchema,
   AddUserMessageResultSchema,
+  AnswerSessionElicitationResponseSchema,
   AppendMessagesResponseSchema,
   ApplyPatchToolConfirmationDetailsSchema,
   AskUserCollectedAnswerSchema,
@@ -62,19 +63,23 @@ import {
   ComputerListResponseSchema,
   ComputerMetricSchema,
   ComputerMetricsResponseSchema,
+  ComputerReadSchema,
   ComputerSchema,
   ConcurrentStreamError,
   ConnectionClosedError,
   ConnectionError,
   ConnectionFailureReason,
   ContentBlockSchema,
+  ContextApiError,
   ContextBreakdownCategorySchema,
   ContextStatsAccuracy,
   ContextStatsSchema,
   CreateMessageNotificationSchema,
   CreateToolConfirmationDetailsSchema,
+  DEFAULT_CONNECTION_CONFIG,
   DEFAULT_LOCAL_DAEMON_WS_URL,
   DEFAULT_REQUEST_TIMEOUT,
+  DROID_RUNNING_STATES,
   DaemonAuthenticationMode,
   DaemonClient,
   DaemonDroidEvent,
@@ -88,6 +93,7 @@ import {
   DocumentSourceSchema,
   DroidClientError,
   DroidClientMethod,
+  DroidConnectionEndedError,
   DroidErrorType,
   DroidEvent,
   DroidHookEventSchema,
@@ -101,9 +107,13 @@ import {
   DroidWorkingStateChangedNotificationSchema,
   EditToolConfirmationDetailsSchema,
   EmptyResultSchema,
+  EnvironmentComputerTimeoutError,
+  EnvironmentListResponseSchema,
+  EnvironmentSchema,
   ErrorDetailSchema,
   ErrorNotificationSchema,
   ExecToolInfoSchema,
+  ExecToolInfoWithSchemasSchema,
   ExecuteRewindRequestParamsSchema,
   ExecuteRewindRequestSchema,
   ExecuteRewindResponseSchema,
@@ -113,7 +123,6 @@ import {
   FACTORY_CLIENT_HEADER,
   FACTORY_CLIENT_VERSION,
   FACTORY_PROTOCOL_VERSION,
-  FACTORY_PROTOCOL_VERSION2,
   FactoryDaemonTransport,
   FactoryDroidMessageRole,
   FactoryDroidMessageSchema,
@@ -129,6 +138,7 @@ import {
   GetContextStatsRequestParamsSchema,
   GetContextStatsRequestSchema,
   GetContextStatsResponseSchema,
+  GetHandoffSummaryResponseSchema,
   GetRewindInfoRequestParamsSchema,
   GetRewindInfoRequestSchema,
   GetRewindInfoResponseSchema,
@@ -160,7 +170,6 @@ import {
   IssueSeverity,
   JSONRPC_VERSION,
   JSONRPC_VERSION2,
-  JSONRPC_VERSION3,
   JsonArraySchema,
   JsonObjectSchema,
   JsonRpcBaseResponseSchema,
@@ -176,6 +185,7 @@ import {
   JsonRpcResponseSchema,
   JsonRpcResponseSuccessSchema,
   JsonValueSchema,
+  KillBackgroundProcessResponseSchema,
   KillWorkerSessionRequestParamsSchema,
   KillWorkerSessionRequestSchema,
   KillWorkerSessionResponseSchema,
@@ -183,6 +193,7 @@ import {
   LEGACY_FACTORY_API_VERSION,
   LEGACY_FACTORY_API_VERSION2,
   LOCAL_MACHINE_ID,
+  LfLineDecoder,
   ListCommandsResponseSchema,
   ListMcpRegistryRequestParamsSchema,
   ListMcpRegistryRequestSchema,
@@ -199,6 +210,7 @@ import {
   ListModelsOptionsSchema,
   ListModelsResponseSchema,
   ListModelsResultSchema,
+  ListSessionElicitationsResponseSchema,
   ListSkillsRequestParamsSchema,
   ListSkillsRequestSchema,
   ListSkillsResponseSchema,
@@ -206,11 +218,14 @@ import {
   ListToolsRequestParamsSchema,
   ListToolsRequestSchema,
   ListToolsResponseSchema,
+  ListToolsResponseWithSchemasSchema,
   ListToolsResultSchema,
+  ListToolsResultWithSchemasSchema,
   LoadSessionRequestParamsSchema,
   LoadSessionRequestSchema,
   LoadSessionResponseSchema,
   LoadSessionResultSchema,
+  MACHINE_TYPE_CONFIG,
   MACHINE_TYPE_WEBSOCKET_OVERRIDES,
   MANAGED_COMPUTER_MAX_RETRIES,
   MCP_AUTH_TIMEOUT,
@@ -243,6 +258,7 @@ import {
   MissionFeatureSchema,
   MissionFeaturesChangedNotificationSchema,
   MissionHeartbeatNotificationSchema,
+  MissionMachineTargetKind,
   MissionPausedEntrySchema,
   MissionProgressEntryNotificationSchema,
   MissionResumedEntrySchema,
@@ -261,6 +277,12 @@ import {
   OutputFormatSchema,
   OutputFormatType,
   PermissionResolvedNotificationSchema,
+  PickOptionsRequestParamsSchema,
+  PickOptionsRequestSchema,
+  PickOptionsResponseSchema,
+  PickOptionsResultSchema,
+  PickOptionsRowSchema,
+  PickOptionsUnavailableError,
   ProcessExitError,
   ProgressLogEntrySchema,
   ProgressLogEntryType,
@@ -272,6 +294,7 @@ import {
   ReasoningEffort,
   RedactedThinkingBlockSchema,
   RefreshComputerResponseSchema,
+  RefreshConnectorToolCatalogResponseSchema,
   RelayConnectionError,
   RemoteSessionListResponseSchema,
   RemoteSessionSchema,
@@ -283,6 +306,7 @@ import {
   RenameSessionRequestSchema,
   RenameSessionResponseSchema,
   RenameSessionResultSchema,
+  RequestCancelledError,
   RequestPermissionRequestParamsSchema,
   RequestPermissionRequestSchema,
   RequestPermissionResponseSchema,
@@ -291,13 +315,22 @@ 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,
+  SessionArtifactProvider,
+  SessionArtifactSchema,
+  SessionArtifactSource,
+  SessionArtifactsSchema,
+  SessionElicitationSchema,
   SessionError,
   SessionMetadataSchema,
   SessionNotFoundError,
@@ -348,6 +381,7 @@ import {
   SubmitMcpAuthCodeResultSchema,
   SubmitMcpAuthErrorResponseSchema,
   SuccessResultSchema,
+  SummarizeForMembersResponseSchema,
   TestCaseSchema,
   TestFileSchema,
   TestsSchema,
@@ -371,11 +405,15 @@ import {
   ToolConfirmationListItemSchema,
   ToolConfirmationOutcome,
   ToolConfirmationType,
+  ToolJsonSchemaSchema,
   ToolProgressUpdateNotificationSchema,
   ToolProgressUpdateSchema,
   ToolResultNotificationSchema,
   ToolResultSchema,
+  ToolResultSchemaDescriptorSchema,
+  ToolSchemasSchema,
   ToolSelectionOverridesSchema,
+  ToolSourceSchema,
   ToolUseSchema,
   ToolUseSchema2,
   TraceContextMetaSchema,
@@ -395,57 +433,98 @@ import {
   WorkerSelectedFeatureEntrySchema,
   WorkerStartedEntrySchema,
   WorkerStateInfoSchema,
+  answerRemoteSessionElicitation,
+  appendContextSession,
   buildUserMessageContentBlocks,
   configureDaemonCoreDeps,
   connectAndAuthenticate,
   connectToDaemon,
   connectWithRetry,
   convertNotificationToStreamMessage,
+  createApiRequest,
   createComputer,
+  createContextDocument,
+  createContextFile,
+  createContextSpace,
+  createFactoryApi,
+  createOrRecoverComputer,
   createResponseSchema,
   createWebSocketDaemonClient,
   defaultDaemonCoreDeps,
   deleteComputer,
+  deleteContextDocument,
+  deleteContextFile,
+  emitDroidLog,
+  encodeLegacyStartupLoadOptions,
+  escapeJsonLineSeparators,
   extractInnerNotification,
   filterMessagesForUI,
   getComputer,
   getComputerByName,
   getComputerMetrics,
+  getContextDocument,
+  getContextDocumentByPath,
+  getContextSession,
+  getContextSpace,
   getMachineTemplate,
   getPermissionToolInputForDisplay,
   getQueuedUserMessageDisplayGroup,
   getQueuedUserMessageReviewPriority,
+  getSandboxEnvironmentLaunchRepositories,
+  getSandboxEnvironmentLaunchSource,
   getSubagentCallingMetadata,
   getToolResultBlocks,
   getToolResultToolUseId,
   hasDecoupledInteractionSettings,
   hasSubagentSessionTag,
+  injectDroidTraceContext,
   inspectJsonRpcEnvelope,
   isDaemonQueuedMessageKind,
+  isEnvironmentComputerReady,
+  isOfferedPermissionOutcome,
   isPendingToolResultMarker,
   isPersistedHookMessage,
+  isProtocolVersionAtLeast,
   isReviewableQueuedMessageKind,
+  isSandboxEnvironmentLaunchable,
   listComputers,
+  listContextDocuments,
+  listContextSessions,
+  listContextSpaces,
+  listEnvironments,
   listMachineTemplates,
+  listRemoteSessionElicitations,
   listRemoteSessions,
   machineTypeToMachineConnectionType,
   mergeSessionSettings,
-  orderMessagesByParentChain,
+  parseResponse,
+  readContextFilePart,
+  readContextSessionRecords,
   recordComputerConnectSli,
+  recordDroidMetric,
   refreshComputer,
-  repairParentChainCorruption,
+  registerContextSession,
+  resolveAskUserHandler,
+  resolvePermissionHandler,
   restartComputer,
   retryInstallDeps,
   retryWithLogger,
+  runWithAbort,
+  sessionTagsUpdateForPeer,
   streamFromClient,
   sumTokenUsage,
   summarizeSessionToolUsage,
   toError,
+  trustedIdentityFromComputerResponse,
   unwrapResponseResult,
   updateComputer,
+  updateContextDocument,
+  uploadContextFilePart,
+  waitForEnvironmentComputer,
   wireAbortSignal,
   withSdkTag
-} from "./chunk-TWSTJMV7.mjs";
+} from "./chunk-NWFX4MPJ.mjs";
+import "./chunk-7ZD7MMNA.mjs";
 
 // src/exec-core/client.ts
 import EventEmitter from "events";
@@ -454,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";
@@ -517,6 +596,9 @@ var defaultExecCoreDeps = {
     },
     sanitizeSpawnEnv(env) {
       return env;
+    },
+    buildRuntimeSettingsAuthorityEnv() {
+      return {};
     }
   }
 };
@@ -526,6 +608,7 @@ var DroidClientEvent = /* @__PURE__ */ ((DroidClientEvent2) => {
   DroidClientEvent2["SESSION_NOTIFICATION"] = "session_notification";
   DroidClientEvent2["REQUEST_PERMISSION"] = "request_permission";
   DroidClientEvent2["ASK_USER"] = "ask_user";
+  DroidClientEvent2["PICK_OPTIONS"] = "pick_options";
   DroidClientEvent2["ERROR"] = "error";
   return DroidClientEvent2;
 })(DroidClientEvent || {});
@@ -541,90 +624,6 @@ var TransportDirection = /* @__PURE__ */ ((TransportDirection2) => {
   return TransportDirection2;
 })(TransportDirection || {});
 
-// ../droid-sdk-core/src/observability.ts
-function sanitizeAttributes(attributes) {
-  if (attributes === void 0) {
-    return void 0;
-  }
-  const sanitized = {};
-  for (const [key, value] of Object.entries(attributes)) {
-    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      sanitized[key] = value;
-    }
-  }
-  return Object.keys(sanitized).length > 0 ? sanitized : void 0;
-}
-function serializeError(error) {
-  if (error instanceof Error) {
-    const code = "code" in error && typeof error.code === "string" ? error.code : void 0;
-    return {
-      name: error.name || void 0,
-      message: error.message,
-      ...code !== void 0 && { code }
-    };
-  }
-  return { message: String(error) };
-}
-function handleSinkFailure(error, options) {
-  try {
-    options?.onError?.(error);
-  } catch {
-  }
-}
-function emitDroidLog(observability, event, options) {
-  const sink = observability?.logger;
-  if (!sink) {
-    return false;
-  }
-  try {
-    sink.log({
-      level: event.level,
-      name: event.name,
-      message: event.message,
-      attributes: sanitizeAttributes(event.attributes),
-      ...event.error !== void 0 && {
-        error: serializeError(event.error)
-      }
-    });
-    return true;
-  } catch (error) {
-    handleSinkFailure(error, options);
-    return false;
-  }
-}
-function recordDroidMetric(observability, event, options) {
-  const sink = observability?.metrics;
-  if (!sink) {
-    return false;
-  }
-  try {
-    sink.record({
-      name: event.name,
-      kind: event.kind,
-      value: event.value,
-      unit: event.unit,
-      attributes: sanitizeAttributes(event.attributes)
-    });
-    return true;
-  } catch (error) {
-    handleSinkFailure(error, options);
-    return false;
-  }
-}
-function injectDroidTraceContext(observability, carrier, options) {
-  const sink = observability?.tracing;
-  if (!sink) {
-    return false;
-  }
-  try {
-    sink.inject(carrier);
-    return true;
-  } catch (error) {
-    handleSinkFailure(error, options);
-    return false;
-  }
-}
-
 // src/exec-core/deps.ts
 function logWarn(logger, message, metadata) {
   logger.warn(message, metadata);
@@ -779,15 +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) {
@@ -811,10 +816,21 @@ var DroidClient = class _DroidClient extends EventEmitter {
   pendingRequests = /* @__PURE__ */ new Map();
   permissionHandlers = /* @__PURE__ */ new Map();
   askUserHandlers = /* @__PURE__ */ new Map();
+  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
@@ -822,14 +838,20 @@ 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;
   getRequestAttribution;
   constructor(options, deps = defaultExecCoreDeps) {
     super();
-    this.transport = options.transport;
     const resolved = resolveExecCoreDeps(options.observability, deps);
+    this.transport = options.transport;
     this.logger = resolved.logger;
     this.tracing = resolved.tracing;
     this.requestTimeout = options.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT2;
@@ -849,13 +871,18 @@ var DroidClient = class _DroidClient extends EventEmitter {
     });
     this.transport.onError((error) => {
       const err = error instanceof Error ? error : new Error(String(error));
-      const expectedCleanExit = err instanceof ProcessExitError && err.exitCode === 0 && this.completedTurnObserved;
-      if (expectedCleanExit) {
-        this.logger.info("[DroidClient] Process exited after completed turn", {
-          exitCode: err.exitCode
+      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
         });
       } else {
-        this.logger.exception(err, "Transport error");
+        this.logger.exception(err, "Transport error", {
+          sessionId
+        });
       }
       this.transportError = err;
       this.rejectAllPending(err);
@@ -873,18 +900,62 @@ 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 (this.peerProtocolVersion === FACTORY_PROTOCOL_VERSION) {
+    if (isProtocolVersionAtLeast(
+      this.peerProtocolVersion,
+      MCP_OAUTH_OPT_OUT_PROTOCOL_VERSION
+    )) {
       return;
     }
     throw new ProtocolError(
-      "MCP OAuth opt-out requires a confirmed matching Droid protocol version. The connected Droid reported an incompatible protocol version and cannot disable OAuth for MCP servers.",
+      `MCP OAuth opt-out requires Droid protocol version ${MCP_OAUTH_OPT_OUT_PROTOCOL_VERSION} or newer. The connected Droid reported an older or unknown protocol version and cannot disable OAuth for MCP servers.`,
       {
         value: {
           localFactoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+          minimumFactoryProtocolVersion: MCP_OAUTH_OPT_OUT_PROTOCOL_VERSION,
           peerFactoryProtocolVersion: this.peerProtocolVersion
         }
       }
@@ -897,36 +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
+      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,
@@ -936,30 +1009,32 @@ var DroidClient = class _DroidClient extends EventEmitter {
     };
     const rawResponse = await this.sendRequest(
       request,
-      this.sessionInitTimeout
+      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) {
@@ -969,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,
@@ -981,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.
@@ -1005,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,
@@ -1014,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) {
@@ -1032,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,
@@ -1041,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) {
@@ -1059,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,
@@ -1068,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) {
@@ -1086,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,
@@ -1095,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) {
@@ -1113,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,
@@ -1122,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) {
@@ -1140,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);
@@ -1161,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) {
@@ -1179,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,
@@ -1188,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) {
@@ -1206,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,
@@ -1219,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) {
@@ -1229,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,
@@ -1240,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) {
@@ -1250,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,
@@ -1261,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) {
@@ -1271,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,
@@ -1282,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) {
@@ -1295,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,
@@ -1304,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) {
@@ -1314,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,
@@ -1323,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,
@@ -1346,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,
@@ -1355,8 +1430,26 @@ 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) {
+      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.refresh_connector_tool_catalog" /* REFRESH_CONNECTOR_TOOL_CATALOG */,
+      params
+    };
+    const response2 = await this.sendRequest(request, this.requestTimeout);
+    return RefreshConnectorToolCatalogResponseSchema.parse(response2);
   }
   async listMcpTools() {
     if (!this.currentSessionId) {
@@ -1365,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,
@@ -1374,12 +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,
@@ -1388,8 +1482,29 @@ var DroidClient = class _DroidClient extends EventEmitter {
       params
     };
     const rawResponse = await this.sendRequest(request, this.requestTimeout);
-    const response = ListToolsResponseSchema.parse(rawResponse);
-    return response;
+    const response2 = ListToolsResponseSchema.parse(rawResponse);
+    if (!schemasRequested || !("result" in response2)) {
+      return response2;
+    }
+    const strictResult = ListToolsResultWithSchemasSchema.safeParse(
+      response2.result
+    );
+    if (strictResult.success) {
+      return response2;
+    }
+    const result = ListToolsResultSchema.parse(response2.result);
+    const missingSchemaIds = [];
+    for (const tool2 of result.tools) {
+      if (tool2.schemas === void 0) {
+        missingSchemaIds.push(tool2.llmId);
+      }
+    }
+    if (missingSchemaIds.length > 0) {
+      throw new ProtocolError(
+        `The installed Droid version did not return requested schemas for tool IDs: ${missingSchemaIds.join(", ")}. Update Droid and try again.`
+      );
+    }
+    throw strictResult.error;
   }
   async listMcpServers() {
     if (!this.currentSessionId) {
@@ -1398,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,
@@ -1407,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) {
@@ -1417,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,
@@ -1426,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) {
@@ -1436,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,
@@ -1445,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) {
@@ -1455,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,
@@ -1464,27 +1579,27 @@ 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() {
+  async listSkills(params = {}) {
     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.list_skills" /* LIST_SKILLS */,
-      params: {}
+      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) {
@@ -1493,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,
@@ -1511,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,
@@ -1520,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) {
@@ -1530,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,
@@ -1539,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) {
@@ -1549,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,
@@ -1558,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 submitBugReport(userComment, clientLogs, source) {
+  async killBackgroundProcess(processId) {
     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.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, tuiLogs) {
+    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.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) {
@@ -1587,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,
@@ -1608,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,
@@ -1635,19 +1768,58 @@ 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: uuidv4(),
       method: "droid.compact_session" /* COMPACT_SESSION */,
       params: {
-        customInstructions: params.customInstructions
+        customInstructions: params.customInstructions,
+        mode: params.mode
       }
     };
     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(
@@ -1655,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,
@@ -1673,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,
@@ -1687,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) => {
@@ -1726,25 +1898,61 @@ 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");
   }
-  async close() {
-    const closeError = new ConnectionError(
+  setPickOptionsHandler(handler) {
+    this.pickOptionsHandlers.set(
+      "default",
+      async (event, setResponseMetadata) => await handler(event, setResponseMetadata)
+    );
+  }
+  clearPickOptionsHandler() {
+    this.pickOptionsHandlers.delete("default");
+  }
+  async close(options) {
+    const closeError = new DroidConnectionEndedError(
       "Droid client closed: pending requests cancelled"
     );
+    if (options?.closeTransportFirst) {
+      try {
+        await this.transport.close();
+      } finally {
+        this.rejectAllPending(closeError);
+        this.permissionHandlers.clear();
+        this.askUserHandlers.clear();
+        this.heldQueuedAskUserRequests = [];
+        this.removeAllListeners();
+      }
+      return;
+    }
     this.rejectAllPending(closeError);
     this.permissionHandlers.clear();
     this.askUserHandlers.clear();
+    this.heldQueuedAskUserRequests = [];
+    this.pickOptionsHandlers.clear();
     this.removeAllListeners();
     await this.transport.close();
   }
@@ -1765,6 +1973,10 @@ var DroidClient = class _DroidClient extends EventEmitter {
       reject(error);
     });
     this.pendingAskUserRequests.clear();
+    this.pendingPickOptionsRequests.forEach(({ reject }) => {
+      reject(error);
+    });
+    this.pendingPickOptionsRequests.clear();
   }
   settleRequest(requestId) {
     this.pendingRequests.delete(requestId);
@@ -1776,16 +1988,31 @@ var DroidClient = class _DroidClient extends EventEmitter {
     } catch {
     }
   }
-  async sendRequest(request, timeout) {
+  /** `_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(() => {
@@ -1802,16 +2029,23 @@ var DroidClient = class _DroidClient extends EventEmitter {
           method: request.method,
           resolve: resolve2,
           reject,
-          timeoutId
+          timeoutId,
+          sessionId
         });
       }
     );
+    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(JSON.stringify(requestWithMeta));
+      await this.transport.send(request);
     } catch (error) {
       const pending = this.pendingRequests.get(request.id);
       if (pending) {
@@ -1827,141 +2061,145 @@ var DroidClient = class _DroidClient extends EventEmitter {
         );
       }
     }
-    return responsePromise;
   }
   async handleMessage(message) {
     try {
-      const parsed = JSON.parse(message);
-      if ("result" in parsed || "error" in parsed) {
-        this.handleResponse(parsed);
-      } else if ("method" in parsed) {
-        await this.handleEvent(parsed);
+      if (message.type === "response") {
+        this.handleResponse(message);
       } else {
-        throw new ProtocolError("Invalid message format", {
-          message
-        });
+        await this.handleEvent(message);
       }
     } catch {
-      this.logger.warn("[DroidClient] Failed to handle message", {
-        messageByteLength: new TextEncoder().encode(message).byteLength
-      });
+      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(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;
@@ -1979,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",
             {
@@ -1989,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,
@@ -2025,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: {
@@ -2044,14 +2282,20 @@ 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 */) {
         await this.handlePermissionRequest(validatedEvent);
       } else if (validatedEvent.method === "droid.ask_user" /* ASK_USER */) {
         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);
@@ -2076,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: {
@@ -2086,7 +2330,7 @@ var DroidClient = class _DroidClient extends EventEmitter {
       }
     };
     try {
-      await this.transport.send(JSON.stringify(errorResponse));
+      await this.sendResponse(errorResponse, void 0);
     } catch (sendError) {
       this.logger.exception(
         sendError,
@@ -2131,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(
@@ -2145,10 +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 result = {
+      selectedOption: "cancel" /* Cancel */
+    };
     const handler = this.permissionHandlers.get("default");
     if (handler) {
       try {
@@ -2158,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"
@@ -2176,9 +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;
+          result = parsedHandlerResult.data;
         } else {
           throw new DroidClientError(
             "Permission handler returned invalid result",
@@ -2187,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)"
         );
@@ -2214,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: {
@@ -2222,9 +2486,9 @@ var DroidClient = class _DroidClient extends EventEmitter {
           }
         };
         try {
-          await this.transport.send(JSON.stringify(cancelResponse));
+          await this.sendResponse(cancelResponse, hostMeta);
         } catch (sendError) {
-          this.logger.exception(
+          this.reportHandlerFailure(
             sendError,
             "Failed to handle permission request (send cancellation)"
           );
@@ -2239,23 +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 }
-      }
+      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(JSON.stringify(response));
+    await this.sendResponse(response2, hostMeta);
   }
   async handleAskUserRequest(event) {
     this.logger.info("[DroidClient] Handling ask-user request", {
@@ -2264,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) {
@@ -2276,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);
           });
         });
@@ -2298,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 */,
@@ -2307,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,
@@ -2319,9 +2604,9 @@ var DroidClient = class _DroidClient extends EventEmitter {
           }
         };
         try {
-          await this.transport.send(JSON.stringify(cancelResponse));
+          await this.sendResponse(cancelResponse, hostMeta);
         } catch (sendError) {
-          this.logger.exception(
+          this.reportHandlerFailure(
             sendError,
             "Failed to send ask-user cancellation"
           );
@@ -2329,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
@@ -2341,11 +2626,117 @@ var DroidClient = class _DroidClient extends EventEmitter {
       requestId: event.id,
       cancelled: result.cancelled ?? false
     });
-    await this.transport.send(JSON.stringify(response));
+    await this.sendResponse(response2, hostMeta);
+  }
+  /**
+   * Same shape as the ask-user round trip: the handler (a UI) resolves with
+   * the user's selection, and any failure or missing handler answers the CLI
+   * with a cancellation so its tool call never hangs. A handler that rejects
+   * with {@link PickOptionsUnavailableError} is relayed as that JSON-RPC
+   * error instead, which the CLI does not read as the user's cancel.
+   */
+  async handlePickOptionsRequest(event) {
+    this.logger.info("[DroidClient] Handling pick-options request", {
+      requestId: event.id,
+      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");
+    if (handler) {
+      try {
+        const handlerPromise = new Promise(
+          (resolve2, reject) => {
+            this.pendingPickOptionsRequests.set(event.id, { reject });
+            handler(event, setResponseMetadata).then(resolve2).catch(reject).finally(() => {
+              this.pendingPickOptionsRequests.delete(event.id);
+            });
+          }
+        );
+        const parsedResult = PickOptionsResultSchema.safeParse(
+          await handlerPromise
+        );
+        if (!parsedResult.success) {
+          throw new DroidClientError(
+            "PickOptions handler returned invalid result",
+            { cause: parsedResult.error }
+          );
+        }
+        result = parsedResult.data;
+      } catch (error) {
+        this.pendingPickOptionsRequests.delete(event.id);
+        if (error instanceof PickOptionsUnavailableError) {
+          this.logger.info("[DroidClient] Pick-options request unavailable", {
+            requestId: event.id,
+            code: error.rpcError.code
+          });
+          const failure = {
+            jsonrpc: JSONRPC_VERSION2,
+            factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
+            factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+            type: "response",
+            id: event.id,
+            error: error.rpcError
+          };
+          try {
+            await this.sendResponse(failure, hostMeta);
+          } catch (sendError) {
+            this.reportHandlerFailure(
+              sendError,
+              "Failed to send pick-options failure"
+            );
+          }
+          return;
+        }
+        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 */,
+          _DroidClient.createNotificationEvent(
+            _DroidClient.createErrorNotification(err)
+          )
+        );
+        const cancelResponse = {
+          jsonrpc: JSONRPC_VERSION2,
+          factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
+          factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+          type: "response",
+          id: event.id,
+          result: { cancelled: true, selectedIds: [] }
+        };
+        try {
+          await this.sendResponse(cancelResponse, hostMeta);
+        } catch (sendError) {
+          this.reportHandlerFailure(
+            sendError,
+            "Failed to send pick-options cancellation"
+          );
+        }
+        return;
+      }
+    }
+    const response2 = {
+      type: "response",
+      jsonrpc: JSONRPC_VERSION2,
+      factoryApiVersion: LEGACY_FACTORY_API_VERSION2,
+      factoryProtocolVersion: FACTORY_PROTOCOL_VERSION,
+      id: event.id,
+      result
+    };
+    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 */;
@@ -2395,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 }
@@ -2403,10 +2794,52 @@ var DroidClient = class _DroidClient extends EventEmitter {
   }
 };
 
+// src/exec-core/message-transport.ts
+var JsonRpcCodecTransport = class {
+  transport;
+  logger;
+  constructor(transport, logger) {
+    this.transport = transport;
+    this.logger = logger;
+  }
+  send(message) {
+    return this.transport.send(JSON.stringify(message));
+  }
+  onMessage(handler) {
+    this.transport.onMessage((frame) => {
+      const message = decodeDroidMessage(frame, this.logger);
+      if (message) handler(message);
+    });
+  }
+  onError(handler) {
+    this.transport.onError(handler);
+  }
+  close() {
+    return this.transport.close();
+  }
+  get isConnected() {
+    return this.transport.isConnected;
+  }
+};
+function withJsonRpcCodec(transport, deps = defaultExecCoreDeps) {
+  const { logger } = resolveExecCoreDeps(void 0, deps);
+  return new JsonRpcCodecTransport(transport, logger);
+}
+function decodeDroidMessage(frame, logger) {
+  try {
+    return JsonRpcMessageSchema.parse(JSON.parse(frame));
+  } catch (error) {
+    logWarn(logger, "[DroidClient] Failed to handle message", {
+      errorName: error instanceof Error ? error.name : typeof error,
+      messageByteLength: new TextEncoder().encode(frame).byteLength
+    });
+    return void 0;
+  }
+}
+
 // src/exec-core/managed-process.ts
 import { spawnSync } from "child_process";
 import fs2 from "fs";
-import * as readline from "readline";
 
 // src/exec-core/runtime-utils.ts
 import { homedir } from "os";
@@ -2613,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})`;
@@ -2637,7 +3077,13 @@ var ManagedProcessImpl = class {
   _childProcess;
   messageHandler = null;
   errorHandler = null;
-  readlineInterface = null;
+  stdoutDecoder = new LfLineDecoder();
+  stdoutDataHandler = (chunk) => {
+    const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    for (const line of this.stdoutDecoder.push(text)) {
+      this.handleStdoutLine(line);
+    }
+  };
   isClosing = false;
   /** Latch so exit teardown/classification runs exactly once per process. */
   exitFinalized = false;
@@ -2652,50 +3098,50 @@ 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.readlineInterface = readline.createInterface({
-      input: this.childProcess.stdout,
-      crlfDelay: Infinity
-    });
-    this.readlineInterface.on("line", (line) => {
-      const trimmedLine = line.trim();
-      if (this.messageHandler && trimmedLine) {
-        if (trimmedLine.startsWith("{") || trimmedLine.startsWith("[")) {
-          logTransportMessage(
-            "in" /* In */,
-            trimmedLine,
-            this._childProcess?.pid,
-            this.transportLoggerDeps
-          );
-          this.messageHandler(trimmedLine);
-        } else {
-          const truncated = trimmedLine.length > MAX_NON_JSON_LOG_LENGTH ? trimmedLine.substring(0, MAX_NON_JSON_LOG_LENGTH) : trimmedLine;
-          this.logger.warn("[droid process] non-JSON output", {
-            state: this.logPrefix,
-            output: truncated
-          });
-        }
+    this.childProcess.stdout.setEncoding("utf8");
+    this.childProcess.stdout.on("data", this.stdoutDataHandler);
+    this.childProcess.on("error", (error) => {
+      if (this.processError || this.isClosing || this.exitFinalized) {
+        return;
       }
+      this.processError = createSpawnError(error, this.spawnContext);
+      this.errorHandler?.(this.processError);
     });
-    this.childProcess.on("error", (error) => {
-      this.processError = new ConnectionError(
-        describeSpawnError(error, this.spawnContext),
+    this.childProcess.stdin?.on("error", (error) => {
+      if (this.processError || this.isClosing || this.exitFinalized) {
+        return;
+      }
+      this.processError = new DroidConnectionEndedError(
+        "Process stdin failed",
         {
-          error,
-          cwd: this.spawnContext?.cwd,
-          execPath: this.spawnContext?.execPath
+          error
         }
       );
-      if (!this.isClosing && this.errorHandler) {
-        this.errorHandler(this.processError);
-      }
+      this.errorHandler?.(this.processError);
     });
     this.childProcess.on("exit", (code, signal) => {
       this.exitDrainTimer = setTimeout(() => {
@@ -2704,6 +3150,9 @@ var ManagedProcessImpl = class {
       this.exitDrainTimer.unref?.();
     });
     this.childProcess.on("close", (code, signal) => {
+      for (const line of this.stdoutDecoder.finish()) {
+        this.handleStdoutLine(line);
+      }
       this.finalizeExit(code, signal);
     });
     if (this.childProcess.stderr) {
@@ -2715,6 +3164,27 @@ var ManagedProcessImpl = class {
       });
     }
   }
+  handleStdoutLine(line) {
+    const trimmedLine = line.trim();
+    if (!this.messageHandler || !trimmedLine) {
+      return;
+    }
+    if (trimmedLine.startsWith("{") || trimmedLine.startsWith("[")) {
+      logTransportMessage(
+        "in" /* In */,
+        trimmedLine,
+        this._childProcess?.pid,
+        this.transportLoggerDeps
+      );
+      this.messageHandler(trimmedLine);
+      return;
+    }
+    const truncated = trimmedLine.length > MAX_NON_JSON_LOG_LENGTH ? trimmedLine.substring(0, MAX_NON_JSON_LOG_LENGTH) : trimmedLine;
+    this.logger.warn("[droid process] non-JSON output", {
+      state: this.logPrefix,
+      output: truncated
+    });
+  }
   finalizeExit(code, signal) {
     if (this.exitFinalized) {
       return;
@@ -2724,12 +3194,10 @@ var ManagedProcessImpl = class {
       clearTimeout(this.exitDrainTimer);
       this.exitDrainTimer = null;
     }
+    this._childProcess?.stdout?.off("data", this.stdoutDataHandler);
     this._childProcess = null;
-    if (this.readlineInterface) {
-      this.readlineInterface.close();
-      this.readlineInterface = null;
-    }
-    if (!this.isClosing) {
+    this.stdoutDecoder.reset();
+    if (!this.isClosing && !this.processError) {
       this.processError = new ProcessExitError(
         describeExitError(code, signal),
         {
@@ -2747,28 +3215,32 @@ 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;
-          stdin.write(`${message}
+          stdin.write(`${escapeJsonLineSeparators(message)}
 `, (error) => {
             if (error) {
               logTransportMessage(
@@ -2780,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 {
@@ -2810,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))
             })
           );
@@ -2858,11 +3336,9 @@ var ManagedProcessImpl = class {
           }
         });
       }
+      processToClose.stdout?.off("data", this.stdoutDataHandler);
     }
-    if (this.readlineInterface) {
-      this.readlineInterface.close();
-      this.readlineInterface = null;
-    }
+    this.stdoutDecoder.reset();
     this.exitFinalized = true;
     if (this.exitDrainTimer) {
       clearTimeout(this.exitDrainTimer);
@@ -2969,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,
@@ -2982,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,
@@ -2993,24 +3487,19 @@ 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
+var NATIVE_PROCESS_LIFECYCLE_MESSAGE = "[droid process] native lifecycle";
+var MAX_SPAWN_ERROR_CODE_LENGTH = 64;
+function getSpawnErrorCode(error) {
+  if (typeof error !== "object" || error === null || !("code" in error) || typeof error.code !== "string" && typeof error.code !== "number") {
+    return void 0;
+  }
+  return String(error.code).slice(0, MAX_SPAWN_ERROR_CODE_LENGTH);
+}
 function buildArgs(config) {
   const args = [];
   if (config.mode === "acp" /* Acp */) {
@@ -3029,6 +3518,13 @@ function buildArgs(config) {
   }
   return args;
 }
+function ensureIpcStdio(stdio) {
+  if (Array.isArray(stdio)) {
+    return stdio.includes("ipc") ? stdio : [...stdio, "ipc"];
+  }
+  const standardChannel = stdio ?? "pipe";
+  return [standardChannel, standardChannel, standardChannel, "ipc"];
+}
 var DroidProcessManager = class {
   deps;
   transportLoggerDeps;
@@ -3080,6 +3576,8 @@ var DroidProcessManager = class {
       () => this.invokeNodeSpawn(planned),
       {
         ...retryOptions,
+        cwd: planned.expandedCwd,
+        execPath: planned.execPath,
         logPrefix: "[DroidProcessManager]",
         logger: this.logger,
         disposeEarlyExited: (child) => {
@@ -3109,7 +3607,8 @@ var DroidProcessManager = class {
       }
     );
     if (!childProcess.stdout || !childProcess.stdin) {
-      throw new ConnectionError("Failed to get process stdio");
+      childProcess.kill();
+      throw new DroidConnectionEndedError("Failed to get process stdio");
     }
     return new ManagedProcessImpl(
       childProcess,
@@ -3155,21 +3654,88 @@ var DroidProcessManager = class {
     };
   }
   invokeNodeSpawn(planned) {
+    const stdio = planned.enableIpc ? ensureIpcStdio(planned.stdio) : planned.stdio ?? ["pipe", "pipe", "pipe"];
     const options = {
       cwd: planned.expandedCwd,
       env: planned.env,
-      stdio: planned.stdio ?? (planned.enableIpc ? ["pipe", "pipe", "pipe", "ipc"] : ["pipe", "pipe", "pipe"])
+      stdio
     };
     if (planned.enableIpc) {
       options.serialization = "json";
     }
-    return spawn(planned.execPath, planned.args, options);
+    const spawnedAt = Date.now();
+    let childProcess;
+    try {
+      childProcess = spawn(planned.execPath, planned.args, options);
+    } catch (error) {
+      const failedAt = Date.now();
+      this.logNativeProcessLifecycle({
+        state: "spawn_error",
+        pid: null,
+        createdAt: spawnedAt,
+        eventDate: new Date(failedAt).toISOString(),
+        durationMs: failedAt - spawnedAt,
+        errnoCode: getSpawnErrorCode(error)
+      });
+      throw error;
+    }
+    const pid = childProcess.pid;
+    if (pid === void 0) {
+      childProcess.once("error", (error) => {
+        const failedAt = Date.now();
+        this.logNativeProcessLifecycle({
+          state: "spawn_error",
+          pid: null,
+          createdAt: spawnedAt,
+          eventDate: new Date(failedAt).toISOString(),
+          durationMs: failedAt - spawnedAt,
+          errnoCode: getSpawnErrorCode(error)
+        });
+      });
+    } else {
+      childProcess.once("exit", (exitCode, signal) => {
+        const exitedAt = Date.now();
+        this.logNativeProcessLifecycle({
+          state: "exited",
+          pid,
+          createdAt: spawnedAt,
+          eventDate: new Date(exitedAt).toISOString(),
+          durationMs: exitedAt - spawnedAt,
+          exitCode,
+          signal
+        });
+      });
+      this.logNativeProcessLifecycle({
+        state: "spawned",
+        pid,
+        createdAt: spawnedAt,
+        eventDate: new Date(spawnedAt).toISOString()
+      });
+    }
+    return childProcess;
+  }
+  /**
+   * Emits the content-free native process record consumed by lifecycle
+   * measurement harnesses. `createdAt` is the wall-clock lower bound captured
+   * immediately before spawn; `eventDate` is the wall-clock observation time.
+   */
+  logNativeProcessLifecycle(record) {
+    try {
+      this.logger.info(NATIVE_PROCESS_LIFECYCLE_MESSAGE, record);
+    } catch (loggingError) {
+      void loggingError;
+      logWarn(
+        defaultExecCoreDeps.logger,
+        "[droid process] native lifecycle logger failed"
+      );
+    }
   }
   spawnChildProcess(config) {
     const planned = this.prepareSpawn(config);
     const childProcess = this.invokeNodeSpawn(planned);
     if (!childProcess.stdout || !childProcess.stdin) {
-      throw new ConnectionError("Failed to get process stdio");
+      childProcess.kill();
+      throw new DroidConnectionEndedError("Failed to get process stdio");
     }
     return {
       logPrefix: planned.logPrefix,
@@ -3187,12 +3753,20 @@ var ProcessTransport = class {
   options;
   // Store handlers that may be registered before connect() is called
   messageHandler = null;
+  logger;
+  handleMessage = (frame) => {
+    const message = decodeDroidMessage(frame, this.logger);
+    if (message) this.messageHandler?.(message);
+  };
   errorHandler = null;
   metrics;
+  environmentResolver;
   constructor(options = {}, deps = defaultExecCoreDeps) {
     this.options = options;
     const resolved = resolveExecCoreDeps(options.observability, deps);
+    this.logger = resolved.logger;
     this.metrics = resolved.metrics;
+    this.environmentResolver = resolved.environmentResolver;
     this.processManager = new DroidProcessManager(
       {
         observability: options.observability
@@ -3202,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,
@@ -3210,14 +3784,36 @@ var ProcessTransport = class {
       mode: "stream-jsonrpc" /* StreamJsonRpc */,
       cwd: this.options.cwd,
       env: this.options.env,
+      trustedEnv: {
+        ...this.options.runtimeSettingsAuthority ? this.environmentResolver.buildRuntimeSettingsAuthorityEnv(
+          this.options.runtimeSettingsAuthority
+        ) : {},
+        ...this.options.trustedEnv
+      },
       extraArgs: this.options.droidExecExtraArgs,
-      enableIpc: this.options.enableIpc
+      enableIpc: this.options.enableIpc,
+      stdio: this.options.stdio
     };
     const spawnStart = performance.now();
     let spawnOutcome = "error";
+    let managedProcess;
     try {
-      this.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,
@@ -3225,8 +3821,15 @@ var ProcessTransport = class {
         { outcome: spawnOutcome, source: "process_transport" }
       );
     }
+    try {
+      this.options.onSpawned?.(managedProcess.childProcess);
+    } catch (error) {
+      await managedProcess.close();
+      throw error;
+    }
+    this.managedProcess = managedProcess;
     if (this.messageHandler) {
-      this.managedProcess.onMessage(this.messageHandler);
+      this.managedProcess.onMessage(this.handleMessage);
     }
     if (this.errorHandler) {
       this.managedProcess.onError(this.errorHandler);
@@ -3234,14 +3837,14 @@ var ProcessTransport = class {
   }
   async send(message) {
     if (!this.managedProcess) {
-      throw new ConnectionError("Transport not connected");
+      throw new DroidConnectionEndedError("Transport not connected");
     }
-    return this.managedProcess.send(message);
+    return await this.managedProcess.send(JSON.stringify(message));
   }
   onMessage(handler) {
     this.messageHandler = handler;
     if (this.managedProcess) {
-      this.managedProcess.onMessage(handler);
+      this.managedProcess.onMessage(this.handleMessage);
     }
   }
   onError(handler) {
@@ -3264,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;
@@ -3286,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
   });
@@ -3294,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) {
@@ -3372,15 +4165,21 @@ import http from "http";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { z as z2 } from "zod";
-function tool(name, description, inputSchemaOrHandler, handler) {
+function tool(name, description, inputSchemaOrHandler, handlerOrOptions, maybeOptions) {
+  const options = typeof handlerOrOptions === "function" ? maybeOptions : handlerOrOptions;
+  const annotationFields = options?.annotations && {
+    annotations: options.annotations
+  };
   if (typeof inputSchemaOrHandler === "function") {
     const actualHandler = inputSchemaOrHandler;
     return {
       name,
       description,
-      handler: (input) => actualHandler(input)
+      handler: (input) => actualHandler(input),
+      ...annotationFields
     };
   }
+  const handler = typeof handlerOrOptions === "function" ? handlerOrOptions : void 0;
   if (!handler) {
     throw new Error(`Missing handler for SDK MCP tool "${name}"`);
   }
@@ -3389,7 +4188,8 @@ function tool(name, description, inputSchemaOrHandler, handler) {
     name,
     description,
     inputSchema: inputSchemaOrHandler,
-    handler: (input) => handler(inputObjectSchema.parse(input))
+    handler: (input) => handler(inputObjectSchema.parse(input)),
+    ...annotationFields
   };
 }
 function isSdkMcpServer(server) {
@@ -3515,7 +4315,8 @@ var SdkMcpServer = class {
           description: sdkTool.description,
           ...sdkTool.inputSchema && {
             inputSchema: sdkTool.inputSchema
-          }
+          },
+          ...sdkTool.annotations && { annotations: sdkTool.annotations }
         },
         async (input) => toCallToolResult(await sdkTool.handler(input))
       );
@@ -3592,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 */
@@ -3602,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;
@@ -3620,6 +4739,9 @@ var DroidSession = class _DroidSession {
   get id() {
     return this._sessionId;
   }
+  get computerId() {
+    return this._runtime.computerId;
+  }
   get settings() {
     return this._settings;
   }
@@ -3664,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()));
@@ -3717,6 +4837,11 @@ var DroidSession = class _DroidSession {
     this._ensureNotClosed();
     return unwrapResponseResult(await this._client.listMcpTools()).tools;
   }
+  /** Refresh connector discovery. MCP configuration has its own lifecycle. */
+  async refreshConnectorToolCatalog() {
+    this._ensureNotClosed();
+    unwrapResponseResult(await this._client.refreshConnectorToolCatalog());
+  }
   async listTools(params = {}) {
     this._ensureNotClosed();
     return unwrapResponseResult(await this._client.listTools(params)).tools.map(
@@ -3733,9 +4858,9 @@ var DroidSession = class _DroidSession {
       await this._client.authenticateMcpServer(params)
     );
   }
-  async listSkills() {
+  async listSkills(params) {
     this._ensureNotClosed();
-    return unwrapResponseResult(await this._client.listSkills());
+    return unwrapResponseResult(await this._client.listSkills(params));
   }
   async setSkillDisabled(params) {
     this._ensureNotClosed();
@@ -3760,7 +4885,14 @@ var DroidSession = class _DroidSession {
   }
   async compact(params) {
     const { session, result } = await this._runReplacement(
-      () => this._client.compactSession(params ?? {}).then(unwrapResponseResult)
+      () => this._client.compactSession(params ?? {}).then(unwrapResponseResult),
+      { retainSourceWhenSameId: true }
+    );
+    return { session, removedCount: result.removedCount };
+  }
+  async handoff(params) {
+    const { session, result } = await this._runReplacement(
+      () => this._client.compactSession({ ...params, mode: "handoff" }).then(unwrapResponseResult)
     );
     return { session, removedCount: result.removedCount };
   }
@@ -3808,7 +4940,7 @@ var DroidSession = class _DroidSession {
     }
     this._status = "replacing";
   }
-  async _runReplacement(operation) {
+  async _runReplacement(operation, options) {
     this._beginReplacement();
     let result;
     try {
@@ -3829,6 +4961,10 @@ var DroidSession = class _DroidSession {
         )
       });
     }
+    if (options?.retainSourceWhenSameId && result.newSessionId === this._sessionId) {
+      this._status = "active";
+      return { session: this, result };
+    }
     return {
       session: await this._loadReplacement(result.newSessionId),
       result
@@ -3913,7 +5049,7 @@ var DroidSession = class _DroidSession {
   _bindAbortSignal() {
     this._cleanupAbortSignal = wireAbortSignal(
       this._runtime.abortSignal,
-      () => void this.close()
+      () => this._lifecycle.abort(() => this.close())
     );
   }
   _bindMetadataNotifications() {
@@ -3958,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, () => {
@@ -4047,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(() => {
+    });
   }
 }
 
@@ -4072,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;
   }
@@ -4086,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);
@@ -4138,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);
@@ -4257,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();
@@ -4282,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);
   }
@@ -4300,6 +5508,7 @@ export {
   AddUserMessageRequestSchema,
   AddUserMessageResponseSchema,
   AddUserMessageResultSchema,
+  AnswerSessionElicitationResponseSchema,
   ApplyPatchToolConfirmationDetailsSchema,
   AskUserCollectedAnswerSchema,
   AskUserConfirmationDetailsSchema,
@@ -4360,6 +5569,7 @@ export {
   ConnectionError,
   ConnectionFailureReason,
   ContentBlockSchema,
+  ContextApiError,
   ContextBreakdownCategorySchema,
   GetContextBreakdownResultSchema as ContextBreakdownResultSchema,
   ContextStatsAccuracy,
@@ -4384,6 +5594,7 @@ export {
   DroidClientError,
   DroidClientEvent,
   DroidClientMethod,
+  DroidConnectionEndedError,
   DroidErrorType,
   DroidEvent,
   DroidHookEventSchema,
@@ -4400,9 +5611,12 @@ export {
   DroidWorkingStateChangedNotificationSchema,
   EditToolConfirmationDetailsSchema,
   EmptyResultSchema,
+  EnvironmentListResponseSchema,
+  EnvironmentSchema,
   ErrorDetailSchema,
   ErrorNotificationSchema,
   ExecToolInfoSchema,
+  ExecToolInfoWithSchemasSchema,
   ExecuteRewindRequestParamsSchema,
   ExecuteRewindRequestSchema,
   ExecuteRewindResponseSchema,
@@ -4411,7 +5625,7 @@ export {
   ExitSpecModeConfirmationDetailsSchema,
   FACTORY_CLIENT_HEADER,
   FACTORY_CLIENT_VERSION,
-  FACTORY_PROTOCOL_VERSION2 as FACTORY_PROTOCOL_VERSION,
+  FACTORY_PROTOCOL_VERSION,
   FactoryDaemonTransport,
   FactoryDroidMessageRole,
   FactoryDroidMessageSchema,
@@ -4454,7 +5668,7 @@ export {
   InvalidSessionCwdError,
   IpcDaemonClientTransport,
   IssueSeverity,
-  JSONRPC_VERSION3 as JSONRPC_VERSION,
+  JSONRPC_VERSION,
   JsonArraySchema,
   JsonObjectSchema,
   JsonRpcEnvelopeSchema,
@@ -4473,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,
@@ -4489,6 +5703,7 @@ export {
   ListMcpToolsResultSchema,
   ListModelsOptionsSchema,
   ListModelsResultSchema,
+  ListSessionElicitationsResponseSchema,
   ListSkillsRequestParamsSchema,
   ListSkillsRequestSchema,
   ListSkillsResponseSchema,
@@ -4496,7 +5711,9 @@ export {
   ListToolsRequestParamsSchema,
   ListToolsRequestSchema,
   ListToolsResponseSchema,
+  ListToolsResponseWithSchemasSchema,
   ListToolsResultSchema,
+  ListToolsResultWithSchemasSchema,
   LoadSessionRequestParamsSchema,
   LoadSessionRequestSchema,
   LoadSessionResponseSchema,
@@ -4551,6 +5768,12 @@ export {
   OutputFormatSchema,
   OutputFormatType,
   PermissionResolvedNotificationSchema,
+  PickOptionsRequestParamsSchema,
+  PickOptionsRequestSchema,
+  PickOptionsResponseSchema,
+  PickOptionsResultSchema,
+  PickOptionsRowSchema,
+  PickOptionsUnavailableError,
   ProcessExitError,
   ProcessTransport,
   ProgressLogEntrySchema,
@@ -4574,6 +5797,7 @@ export {
   RenameSessionRequestSchema,
   RenameSessionResponseSchema,
   RenameSessionResultSchema,
+  RequestCancelledError,
   RequestPermissionRequestParamsSchema,
   RequestPermissionRequestSchema,
   RequestPermissionResponseSchema,
@@ -4587,6 +5811,13 @@ export {
   SLACK_DELEGATION_MAX_RETRIES,
   SdkMcpServer,
   ServerRequestHandlerType,
+  SessionArtifactAction,
+  SessionArtifactKind,
+  SessionArtifactProvider,
+  SessionArtifactSchema,
+  SessionArtifactSource,
+  SessionArtifactsSchema,
+  SessionElicitationSchema,
   SessionError,
   SessionMetadataSchema,
   SessionNotFoundError,
@@ -4658,11 +5889,15 @@ export {
   ToolConfirmationListItemSchema,
   ToolConfirmationOutcome,
   ToolConfirmationType,
+  ToolJsonSchemaSchema,
   ToolProgressUpdateNotificationSchema,
   ToolProgressUpdateSchema,
   ToolResultSchema as ToolResultBlockSchema,
   ToolResultNotificationSchema,
+  ToolResultSchemaDescriptorSchema,
+  ToolSchemasSchema,
   ToolSelectionOverridesSchema,
+  ToolSourceSchema,
   ToolUseSchema as ToolUseBlockSchema,
   ToolUseSchema2 as ToolUseSchema,
   TraceContextMetaSchema,
@@ -4683,7 +5918,10 @@ export {
   WorkerSelectedFeatureEntrySchema,
   WorkerStartedEntrySchema,
   WorkerStateInfoSchema,
+  MissionMachineTargetKind as WorkstreamMachineTargetKind,
   __resetTransportLoggerForTests,
+  answerRemoteSessionElicitation,
+  appendContextSession,
   buildUserMessageContentBlocks,
   configureDaemonCoreDeps,
   connectAndAuthenticate,
@@ -4691,16 +5929,25 @@ export {
   connectWithRetry,
   convertNotificationToStreamMessage,
   createComputer,
+  createContextDocument,
+  createContextFile,
+  createContextSpace,
   createResponseSchema,
   createSdkMcpServer,
   createSession,
   createWebSocketDaemonClient,
   defaultDaemonCoreDeps,
   deleteComputer,
+  deleteContextDocument,
+  deleteContextFile,
   filterMessagesForUI,
   getComputer,
   getComputerByName,
   getComputerMetrics,
+  getContextDocument,
+  getContextDocumentByPath,
+  getContextSession,
+  getContextSpace,
   getMachineTemplate,
   getPermissionToolInputForDisplay,
   getQueuedUserMessageDisplayGroup,
@@ -4712,22 +5959,29 @@ export {
   hasSubagentSessionTag,
   inspectJsonRpcEnvelope,
   isDaemonQueuedMessageKind,
+  isDroidConnectionEnded,
   isPendingToolResultMarker,
   isPersistedHookMessage,
   isReviewableQueuedMessageKind,
   isTransportLoggingEnabled,
   listComputers,
+  listContextDocuments,
+  listContextSessions,
+  listContextSpaces,
+  listEnvironments,
   listMachineTemplates,
   listModels,
+  listRemoteSessionElicitations,
   listRemoteSessions,
   listSessions,
   logTransportMessage,
   machineTypeToMachineConnectionType,
   noopLogger,
-  orderMessagesByParentChain,
+  readContextFilePart,
+  readContextSessionRecords,
   recordComputerConnectSli,
   refreshComputer,
-  repairParentChainCorruption,
+  registerContextSession,
   resolveExecCoreDeps,
   restartComputer,
   resumeSession,
@@ -4739,6 +5993,9 @@ export {
   summarizeSessionToolUsage,
   toError,
   tool,
-  updateComputer
+  updateComputer,
+  updateContextDocument,
+  uploadContextFilePart,
+  withJsonRpcCodec
 };
 //# sourceMappingURL=node.mjs.map