@letta-ai/letta-code 0.29.6 → 0.29.7

package/letta.js

@@ -5462,7 +5462,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.29.6",
+    version: "0.29.7",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.0",
@@ -155347,7 +155347,8 @@ async function runSlackAttachmentDownloadTask(params) {
     startTime: new Date,
     outputFile,
     totalStdoutLines: 0,
-    totalStderrLines: 0
+    totalStderrLines: 0,
+    runtimeScope: params.runtimeScope
   };
   backgroundProcesses.set(taskId, processState);
   appendToOutputFile(outputFile, `${params.description}
@@ -155781,6 +155782,10 @@ async function downloadSlackFile(ctx) {
   }
   const result = await runSlackAttachmentDownloadTask({
     description: `Slack attachment download ${attachmentId} from message ${messageId} in ${request.chatId}`,
+    runtimeScope: {
+      agentId: ctx.route.agentId,
+      conversationId: ctx.route.conversationId
+    },
     download: (signal) => downloadAttachment.call(ctx.adapter, {
       attachmentId,
       chatId: request.chatId,
@@ -170597,11 +170602,6 @@ function evictConversationRuntimeIfIdle(runtime) {
   }
   runtime.listener.conversationRuntimes.delete(runtime.key);
   scheduleWorktreeWatcherIdleStop(runtime.listener, runtime);
-  for (const [requestId, runtimeKey] of runtime.listener.approvalRuntimeKeyByRequestId) {
-    if (runtimeKey === runtime.key) {
-      runtime.listener.approvalRuntimeKeyByRequestId.delete(requestId);
-    }
-  }
   if (runtime.listener.pendingQueueEmitScope?.agent_id === runtime.agentId && normalizeConversationId(runtime.listener.pendingQueueEmitScope?.conversation_id) === runtime.conversationId) {
     runtime.listener.pendingQueueEmitScope = undefined;
   }
@@ -170648,6 +170648,7 @@ function createConversationRuntime(listener, agentId, conversationId) {
     conversationId: normalizedConversationId,
     skillSources: listener.skillSourcesByConversation.get(runtimeKey)?.slice(),
     activeChannelTurn: null,
+    activeConnectionId: null,
     turnLifecycle,
     messageQueue: Promise.resolve(),
     pendingApprovalResolvers: new Map,
@@ -170759,7 +170760,7 @@ function getPendingControlRequests(runtime, params) {
   if (!conversationRuntime) {
     return requests;
   }
-  for (const pending of conversationRuntime.pendingApprovalResolvers.values()) {
+  for (const pending of new Set(conversationRuntime.pendingApprovalResolvers.values())) {
     const request = pending.controlRequest;
     if (!request)
       continue;
@@ -172463,7 +172464,8 @@ async function bash(args) {
     run_in_background = false,
     signal,
     onOutput,
-    secretEnv
+    secretEnv,
+    parentScope
   } = args;
   const userCwd = getCurrentWorkingDirectory();
   if (command === "/bg") {
@@ -172533,7 +172535,8 @@ async function bash(args) {
       startTime: new Date,
       outputFile,
       totalStdoutLines: 0,
-      totalStderrLines: 0
+      totalStderrLines: 0,
+      runtimeScope: parentScope
     });
     const bgProcess = backgroundProcesses.get(bashId);
     if (!bgProcess) {
@@ -173164,6 +173167,268 @@ var init_worktree_lock = __esm(() => {
   HOSTNAME = os3.hostname();
 });
 
+// src/websocket/listener/transport.ts
+import WebSocket3 from "ws";
+
+class LocalListenerTransport {
+  kind = "local";
+  bufferedAmount = 0;
+  isOpen() {
+    return true;
+  }
+  send(_data) {}
+}
+function isListenerTransportOpen(transport) {
+  if ("isOpen" in transport && typeof transport.isOpen === "function") {
+    return transport.isOpen();
+  }
+  return transport.readyState === WebSocket3.OPEN;
+}
+function getListenerTransportKind(transport) {
+  return "kind" in transport ? transport.kind : "websocket";
+}
+var init_transport = () => {};
+
+// src/websocket/listener/connection.ts
+function toListenerConnection(connectionId) {
+  return { type: "ToConnection", connectionId };
+}
+function getResumeStates(runtime) {
+  let states2 = resumeStateByRuntime.get(runtime);
+  if (!states2) {
+    states2 = new Map;
+    resumeStateByRuntime.set(runtime, states2);
+  }
+  return states2;
+}
+function socketForTransport(transport) {
+  return "kind" in transport ? null : transport;
+}
+function refreshLegacySingleConnection(runtime) {
+  const live = [...runtime.connections.values()].filter((connection) => isListenerTransportOpen(connection.writer));
+  const only = live.length === 1 ? live[0] : null;
+  runtime.transport = only?.writer ?? runtime.processTransport;
+  runtime.streamTransport = only?.streamWriter ?? null;
+  runtime.socket = only ? socketForTransport(only.writer) : null;
+  runtime.streamSocket = only?.streamWriter ? socketForTransport(only.streamWriter) : null;
+}
+function createConnectionRequestKey(connectionId, requestId) {
+  return JSON.stringify([connectionId, requestId]);
+}
+function openListenerConnection(params) {
+  const existing = params.runtime.connections.get(params.connectionId);
+  if (existing) {
+    throw new Error(`Listener connection already open: ${params.connectionId}`);
+  }
+  const resumeStates = getResumeStates(params.runtime);
+  const resumed = resumeStates.get(params.connectionId);
+  resumeStates.delete(params.connectionId);
+  const connection = {
+    id: params.connectionId,
+    ordinal: resumed?.ordinal ?? params.runtime.nextConnectionOrdinal,
+    writer: params.writer,
+    streamWriter: params.streamWriter ?? null,
+    cancellation: params.cancellation ?? new AbortController,
+    initialized: false,
+    subscriptions: resumed?.subscriptions ?? new Set,
+    eventSeqCounter: resumed?.eventSeqCounter ?? 0,
+    options: params.options
+  };
+  if (!resumed) {
+    params.runtime.nextConnectionOrdinal += 1;
+  }
+  params.runtime.connections.set(connection.id, connection);
+  for (const runtimeKey of connection.subscriptions) {
+    let connectionIds = params.runtime.connectionIdsByRuntimeKey.get(runtimeKey);
+    if (!connectionIds) {
+      connectionIds = new Set;
+      params.runtime.connectionIdsByRuntimeKey.set(runtimeKey, connectionIds);
+    }
+    connectionIds.add(connection.id);
+  }
+  refreshLegacySingleConnection(params.runtime);
+  return connection;
+}
+function markListenerConnectionInitialized(runtime, connectionId) {
+  const connection = runtime.connections.get(connectionId);
+  if (connection) {
+    connection.initialized = true;
+  }
+}
+function subscribeListenerConnection(runtime, connectionId, scope) {
+  const connection = runtime.connections.get(connectionId);
+  if (!connection || typeof scope.agent_id !== "string") {
+    return false;
+  }
+  const runtimeKey = getConversationRuntimeKey(scope.agent_id, scope.conversation_id);
+  connection.subscriptions.add(runtimeKey);
+  let connectionIds = runtime.connectionIdsByRuntimeKey.get(runtimeKey);
+  if (!connectionIds) {
+    connectionIds = new Set;
+    runtime.connectionIdsByRuntimeKey.set(runtimeKey, connectionIds);
+  }
+  connectionIds.add(connectionId);
+  return true;
+}
+function unsubscribeListenerConnection(runtime, connectionId, runtimeKey) {
+  const connection = runtime.connections.get(connectionId);
+  if (!connection?.subscriptions.delete(runtimeKey)) {
+    return false;
+  }
+  const connectionIds = runtime.connectionIdsByRuntimeKey.get(runtimeKey);
+  connectionIds?.delete(connectionId);
+  if (connectionIds?.size === 0) {
+    runtime.connectionIdsByRuntimeKey.delete(runtimeKey);
+  }
+  return true;
+}
+function getSubscribedListenerConnections(runtime, scope) {
+  if (typeof scope.agent_id !== "string") {
+    return [];
+  }
+  const runtimeKey = getConversationRuntimeKey(scope.agent_id, scope.conversation_id);
+  const connectionIds = runtime.connectionIdsByRuntimeKey.get(runtimeKey);
+  if (!connectionIds) {
+    return [];
+  }
+  return [...connectionIds].map((connectionId) => runtime.connections.get(connectionId)).filter((connection) => connection?.initialized === true && isListenerTransportOpen(connection.writer)).sort((a, b) => a.ordinal - b.ordinal);
+}
+function findListenerConnectionByTransport(runtime, transport) {
+  for (const connection of runtime.connections.values()) {
+    if (connection.writer === transport || connection.streamWriter === transport) {
+      return connection;
+    }
+  }
+  return null;
+}
+function nextListenerConnectionEventSeq(connection, runtime) {
+  if (!connection) {
+    return nextEventSeq(runtime);
+  }
+  connection.eventSeqCounter += 1;
+  return connection.eventSeqCounter;
+}
+function resolveListenerConnectionTargets(params) {
+  const runtime = params.runtime;
+  let connections;
+  switch (params.routing.type) {
+    case "ToConnection": {
+      const explicitConnection = runtime?.connections.get(params.routing.connectionId);
+      if (explicitConnection) {
+        connections = [explicitConnection];
+        break;
+      }
+      if ((runtime?.connections.size ?? 0) === 0 && params.routing.connectionId === (runtime?.connectionId ?? "legacy")) {
+        connections = [null];
+        break;
+      }
+      return [];
+    }
+    case "ToSubscribers": {
+      connections = runtime ? getSubscribedListenerConnections(runtime, params.scope) : [];
+      if (connections.length > 0) {
+        break;
+      }
+      if ((runtime?.connections.size ?? 0) === 0) {
+        connections = [null];
+        break;
+      }
+      return [];
+    }
+    case "Broadcast": {
+      connections = runtime ? [...runtime.connections.values()].filter((connection) => connection.initialized && isListenerTransportOpen(connection.writer)) : [];
+      if (connections.length === 0 && (runtime?.connections.size ?? 0) === 0) {
+        connections = [null];
+      }
+      break;
+    }
+  }
+  return connections.map((connection) => {
+    const streamTransport = connection?.streamWriter;
+    if (params.streamMessage && streamTransport && isListenerTransportOpen(streamTransport)) {
+      return { connection, transport: streamTransport };
+    }
+    const legacyStreamTransport = params.runtime?.streamTransport;
+    if (!connection && params.streamMessage && legacyStreamTransport && isListenerTransportOpen(legacyStreamTransport)) {
+      return { connection, transport: legacyStreamTransport };
+    }
+    return { connection, transport: connection?.writer ?? params.origin };
+  });
+}
+function closeListenerConnection(runtime, connectionId) {
+  getResumeStates(runtime).delete(connectionId);
+  const connection = runtime.connections.get(connectionId);
+  if (!connection) {
+    return null;
+  }
+  for (const runtimeKey of [...connection.subscriptions]) {
+    unsubscribeListenerConnection(runtime, connectionId, runtimeKey);
+  }
+  runtime.connections.delete(connectionId);
+  connection.cancellation.abort();
+  refreshLegacySingleConnection(runtime);
+  return connection;
+}
+function suspendListenerConnection(runtime, connectionId) {
+  const connection = runtime.connections.get(connectionId);
+  if (!connection) {
+    return null;
+  }
+  const resumeState = {
+    ordinal: connection.ordinal,
+    subscriptions: new Set(connection.subscriptions),
+    eventSeqCounter: connection.eventSeqCounter
+  };
+  const closed = closeListenerConnection(runtime, connectionId);
+  getResumeStates(runtime).set(connectionId, resumeState);
+  return closed;
+}
+
+class ProcessRuntimeTransport {
+  runtime;
+  kind = "runtime";
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  get bufferedAmount() {
+    let total = 0;
+    for (const connection of this.runtime.connections.values()) {
+      total += connection.writer.bufferedAmount;
+    }
+    return total;
+  }
+  isOpen() {
+    for (const connection of this.runtime.connections.values()) {
+      if (connection.initialized && isListenerTransportOpen(connection.writer)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  send(data) {
+    throw new Error(`Process runtime transport cannot send an implicit message (${data.length} bytes); resolve ToConnection, ToSubscribers, or Broadcast first`);
+  }
+}
+function getOrCreateProcessTransport(runtime) {
+  runtime.processTransport ??= new ProcessRuntimeTransport(runtime);
+  if (runtime.connections.size !== 1) {
+    refreshLegacySingleConnection(runtime);
+  }
+  return runtime.processTransport;
+}
+var TO_SUBSCRIBERS, BROADCAST, resumeStateByRuntime;
+var init_connection = __esm(() => {
+  init_runtime6();
+  init_transport();
+  TO_SUBSCRIBERS = {
+    type: "ToSubscribers"
+  };
+  BROADCAST = {
+    type: "Broadcast"
+  };
+  resumeStateByRuntime = new WeakMap;
+});
+
 // src/cli/helpers/memory-reminder.ts
 function isValidStepCount(value) {
   return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value > 0;
@@ -173434,6 +173699,43 @@ var init_system_prompt_warning = __esm(() => {
   systemPromptDoctorStateByAgent = new Map;
 });
 
+// src/websocket/listener/background-process-snapshot.ts
+function belongsToRuntime(entry, runtimeScope) {
+  return entry.runtimeScope?.agentId === runtimeScope.agentId && entry.runtimeScope.conversationId === runtimeScope.conversationId;
+}
+function buildBackgroundProcessSnapshot(agentId, conversationId = "default") {
+  if (agentId === null) {
+    return [];
+  }
+  const runtimeScope = agentId === undefined ? undefined : { agentId, conversationId };
+  const bashProcesses = Array.from(backgroundProcesses.entries()).filter(([, proc]) => proc.status === "running" && (!runtimeScope || belongsToRuntime(proc, runtimeScope))).map(([processId, proc]) => ({
+    process_id: processId,
+    kind: "bash",
+    command: proc.command,
+    started_at_ms: proc.startTime?.getTime() ?? null,
+    status: proc.status,
+    exit_code: proc.exitCode
+  }));
+  const taskProcesses = Array.from(backgroundTasks.entries()).filter(([, task]) => task.status === "running" && (!runtimeScope || belongsToRuntime(task, runtimeScope))).map(([processId, task]) => ({
+    process_id: processId,
+    kind: "agent_task",
+    task_type: task.subagentType,
+    description: task.description,
+    started_at_ms: task.startTime.getTime(),
+    status: task.status,
+    subagent_id: task.subagentId,
+    ...task.error ? { error: task.error } : {}
+  }));
+  return [...bashProcesses, ...taskProcesses].sort((a, b) => {
+    const aStart = a.started_at_ms ?? 0;
+    const bStart = b.started_at_ms ?? 0;
+    return bStart - aStart;
+  });
+}
+var init_background_process_snapshot = __esm(() => {
+  init_process_manager();
+});
+
 // src/websocket/listener/channel-turn-session.ts
 function getChannelTurnSourceKey(source2) {
   return [
@@ -346947,28 +347249,6 @@ var init_mod_commands = __esm(async () => {
   ]);
 });
 
-// src/websocket/listener/transport.ts
-import WebSocket3 from "ws";
-
-class LocalListenerTransport {
-  kind = "local";
-  bufferedAmount = 0;
-  isOpen() {
-    return true;
-  }
-  send(_data) {}
-}
-function isListenerTransportOpen(transport) {
-  if ("isOpen" in transport && typeof transport.isOpen === "function") {
-    return transport.isOpen();
-  }
-  return transport.readyState === WebSocket3.OPEN;
-}
-function getListenerTransportKind(transport) {
-  return "kind" in transport ? transport.kind : "websocket";
-}
-var init_transport = () => {};
-
 // src/websocket/listener/outbound-wire.ts
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync24 } from "node:fs";
 import { dirname as dirname14 } from "node:path";
@@ -347302,31 +347582,6 @@ function getScopeForRuntime(runtime, scope) {
   }
   return scope ?? {};
 }
-function buildBackgroundProcessSnapshot() {
-  const bashProcesses = Array.from(backgroundProcesses.entries()).filter(([, proc]) => proc.status === "running").map(([processId, proc]) => ({
-    process_id: processId,
-    kind: "bash",
-    command: proc.command,
-    started_at_ms: proc.startTime?.getTime() ?? null,
-    status: proc.status,
-    exit_code: proc.exitCode
-  }));
-  const taskProcesses = Array.from(backgroundTasks.entries()).filter(([, task]) => task.status === "running").map(([processId, task]) => ({
-    process_id: processId,
-    kind: "agent_task",
-    task_type: task.subagentType,
-    description: task.description,
-    started_at_ms: task.startTime.getTime(),
-    status: task.status,
-    subagent_id: task.subagentId,
-    ...task.error ? { error: task.error } : {}
-  }));
-  return [...bashProcesses, ...taskProcesses].sort((a, b) => {
-    const aStart = a.started_at_ms ?? 0;
-    const bStart = b.started_at_ms ?? 0;
-    return bStart - aStart;
-  });
-}
 function emitRuntimeStateUpdates(runtime, scope) {
   emitLoopStatusIfOpen(runtime, scope);
   emitDeviceStatusIfOpen(runtime, scope);
@@ -347401,7 +347656,7 @@ function buildDeviceStatus(runtime, params) {
     current_toolset_preference: conversationRuntime?.currentToolsetPreference ?? toolsetPreference,
     current_loaded_tools: conversationRuntime?.currentLoadedTools ?? [],
     current_available_skills: [],
-    background_processes: buildBackgroundProcessSnapshot(),
+    background_processes: buildBackgroundProcessSnapshot(scopedAgentId, scopedConversationId),
     pending_control_requests: interruptedCacheActive ? [] : getPendingControlRequests(listener, scope),
     experiments: experimentManager.list(),
     memory_directory: scopedAgentId ? getScopedMemoryFilesystemRoot(scopedAgentId) : null,
@@ -347464,87 +347719,90 @@ function isStreamChannelMessage(type3) {
 function classifyOutboundFrame(message) {
   return COALESCABLE_STATUS_MESSAGE_TYPES.has(message.type) ? "status" : "critical";
 }
-function emitProtocolV2Message(socket, runtime, message, scope) {
+function emitProtocolV2Message(socket, runtime, message, scope, routing) {
   const listener = getListenerRuntime(runtime);
-  let targetSocket = socket;
-  if (listener?.streamTransport && isStreamChannelMessage(message.type)) {
-    if (isListenerTransportOpen(listener.streamTransport)) {
-      targetSocket = listener.streamTransport;
-    }
-  }
   const runtimeScope = resolveRuntimeScope(listener, getScopeForRuntime(runtime, scope));
   if (!runtimeScope)
     return;
   notifyStreamObservers(listener, message, runtimeScope);
-  if (!isListenerTransportOpen(targetSocket))
-    return;
   const frameClass = classifyOutboundFrame(message);
-  enqueueOutboundFrame(targetSocket, {
-    typeLabel: message.type,
-    frameClass,
-    ...frameClass === "status" ? {
-      coalesceKey: `${message.type}:${runtimeScope.agent_id ?? ""}:${runtimeScope.conversation_id ?? ""}`
-    } : {},
-    build: () => {
-      const eventSeq = nextEventSeq(listener);
-      if (eventSeq === null)
-        return null;
-      const outbound = {
-        ...message,
-        runtime: runtimeScope,
-        event_seq: eventSeq,
-        emitted_at: new Date().toISOString(),
-        idempotency_key: `${message.type}:${eventSeq}:${crypto.randomUUID()}`
-      };
-      let payload;
-      try {
-        payload = JSON.stringify(outbound);
-      } catch (error54) {
-        console.error(`[Listen V2] Failed to emit ${message.type} (seq=${eventSeq})`, error54);
+  const targets = resolveListenerConnectionTargets({
+    runtime: listener,
+    origin: socket,
+    scope: runtimeScope,
+    routing,
+    streamMessage: isStreamChannelMessage(message.type)
+  });
+  for (const { connection, transport: targetSocket } of targets) {
+    if (!isListenerTransportOpen(targetSocket))
+      continue;
+    enqueueOutboundFrame(targetSocket, {
+      typeLabel: message.type,
+      frameClass,
+      ...frameClass === "status" ? {
+        coalesceKey: `${message.type}:${runtimeScope.agent_id ?? ""}:${runtimeScope.conversation_id ?? ""}`
+      } : {},
+      build: () => {
+        const eventSeq = nextListenerConnectionEventSeq(connection, listener);
+        if (eventSeq === null)
+          return null;
+        const outbound = {
+          ...message,
+          runtime: runtimeScope,
+          event_seq: eventSeq,
+          emitted_at: new Date().toISOString(),
+          idempotency_key: `${message.type}:${eventSeq}:${crypto.randomUUID()}`
+        };
+        let payload;
+        try {
+          payload = JSON.stringify(outbound);
+        } catch (error54) {
+          console.error(`[Listen V2] Failed to emit ${message.type} (seq=${eventSeq})`, error54);
+          safeEmitWsEvent("send", "lifecycle", {
+            type: "_ws_send_error",
+            message_type: message.type,
+            event_seq: eventSeq,
+            error: error54 instanceof Error ? error54.message : String(error54)
+          });
+          return null;
+        }
+        return {
+          payload,
+          perfKey: getProtocolPerfKey(message),
+          onSent: () => {
+            if (isDebugEnabled()) {
+              console.log(`[Listen V2] Emitting ${message.type} (seq=${eventSeq})`);
+            }
+            safeEmitWsEvent("send", "protocol", outbound);
+          }
+        };
+      },
+      onSendError: (error54) => {
+        console.error(`[Listen V2] Failed to emit ${message.type}`, error54);
         safeEmitWsEvent("send", "lifecycle", {
           type: "_ws_send_error",
           message_type: message.type,
-          event_seq: eventSeq,
           error: error54 instanceof Error ? error54.message : String(error54)
         });
-        return null;
       }
-      return {
-        payload,
-        perfKey: getProtocolPerfKey(message),
-        onSent: () => {
-          if (isDebugEnabled()) {
-            console.log(`[Listen V2] Emitting ${message.type} (seq=${eventSeq})`);
-          }
-          safeEmitWsEvent("send", "protocol", outbound);
-        }
-      };
-    },
-    onSendError: (error54) => {
-      console.error(`[Listen V2] Failed to emit ${message.type}`, error54);
-      safeEmitWsEvent("send", "lifecycle", {
-        type: "_ws_send_error",
-        message_type: message.type,
-        error: error54 instanceof Error ? error54.message : String(error54)
-      });
-    }
-  });
+    });
+  }
 }
-function emitDeviceStatusUpdate(socket, runtime, scope) {
+function emitDeviceStatusUpdate(socket, runtime, scope, routing = TO_SUBSCRIBERS) {
   const deviceStatus = buildDeviceStatus(runtime, scope);
   recordDeviceStatus(socket, getScopeForRuntime(runtime, scope), deviceStatus);
   const message = {
     type: "update_device_status",
     device_status: deviceStatus
   };
-  emitProtocolV2Message(socket, runtime, message, scope);
+  emitProtocolV2Message(socket, runtime, message, scope, routing);
 }
-function emitLoopStatusUpdate(socket, runtime, scope) {
+function emitLoopStatusUpdate(socket, runtime, scope, routing = TO_SUBSCRIBERS) {
   const message = {
     type: "update_loop_status",
     loop_status: buildLoopStatus(runtime, scope)
   };
-  emitProtocolV2Message(socket, runtime, message, scope);
+  emitProtocolV2Message(socket, runtime, message, scope, routing);
 }
 function emitLoopStatusIfOpen(runtime, scope) {
   const listener = getListenerRuntime(runtime);
@@ -347560,7 +347818,7 @@ function emitDeviceStatusIfOpen(runtime, scope) {
     emitDeviceStatusUpdate(transport, runtime, scope);
   }
 }
-function emitQueueUpdate(socket, runtime, scope) {
+function emitQueueUpdate(socket, runtime, scope, routing = TO_SUBSCRIBERS) {
   const listener = getListenerRuntime(runtime);
   if (!listener) {
     return;
@@ -347570,7 +347828,7 @@ function emitQueueUpdate(socket, runtime, scope) {
     type: "update_queue",
     queue: buildQueueSnapshot(runtime, resolvedScope)
   };
-  emitProtocolV2Message(socket, runtime, message, resolvedScope);
+  emitProtocolV2Message(socket, runtime, message, resolvedScope, routing);
 }
 function isTextContentPart(part) {
   return !!part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part && typeof part.text === "string";
@@ -347670,7 +347928,7 @@ function emitQueueUpdateIfOpen(runtime, scope) {
     emitQueueUpdate(transport, runtime, scope);
   }
 }
-function emitDeviceStatusUpdateIfChanged(socket, runtime, scope, options3) {
+function emitDeviceStatusUpdateIfChanged(socket, runtime, scope, options3, routing = TO_SUBSCRIBERS) {
   const resolvedScope = getScopeForRuntime(runtime, scope);
   const deviceStatus = buildDeviceStatus(runtime, resolvedScope);
   if (!shouldEmitDeviceStatus(socket, resolvedScope, deviceStatus, options3?.force)) {
@@ -347680,14 +347938,15 @@ function emitDeviceStatusUpdateIfChanged(socket, runtime, scope, options3) {
     type: "update_device_status",
     device_status: deviceStatus
   };
-  emitProtocolV2Message(socket, runtime, message, resolvedScope);
+  emitProtocolV2Message(socket, runtime, message, resolvedScope, routing);
   return true;
 }
 function emitStateSync(socket, runtime, scope, options3) {
-  emitDeviceStatusUpdateIfChanged(socket, runtime, scope, options3?.forceDeviceStatus ? { force: true } : undefined);
-  emitLoopStatusUpdate(socket, runtime, scope);
-  emitQueueUpdate(socket, runtime, scope);
-  emitSubagentStateUpdate(socket, runtime, scope);
+  const routing = options3?.routing ?? TO_SUBSCRIBERS;
+  emitDeviceStatusUpdateIfChanged(socket, runtime, scope, options3?.forceDeviceStatus ? { force: true } : undefined, routing);
+  emitLoopStatusUpdate(socket, runtime, scope, routing);
+  emitQueueUpdate(socket, runtime, scope, routing);
+  emitSubagentStateUpdate(socket, runtime, scope, routing);
 }
 function resolveSubagentScopeForSnapshot(runtime, scope) {
   const listener = getListenerRuntime(runtime);
@@ -347728,12 +347987,12 @@ function buildSubagentSnapshot(runtime, scope) {
     error: a.error
   }));
 }
-function emitSubagentStateUpdate(socket, runtime, scope) {
+function emitSubagentStateUpdate(socket, runtime, scope, routing = TO_SUBSCRIBERS) {
   const message = {
     type: "update_subagent_state",
     subagents: buildSubagentSnapshot(runtime, scope)
   };
-  emitProtocolV2Message(socket, runtime, message, scope);
+  emitProtocolV2Message(socket, runtime, message, scope, routing);
 }
 function emitSubagentStateIfOpen(runtime, scope) {
   const listener = getListenerRuntime(runtime);
@@ -347842,7 +348101,7 @@ function emitStreamDelta(socket, runtime, delta2, scope, subagentId) {
     delta: delta2,
     ...subagentId ? { subagent_id: subagentId } : {}
   };
-  emitProtocolV2Message(socket, runtime, message, scope);
+  emitProtocolV2Message(socket, runtime, message, scope, TO_SUBSCRIBERS);
 }
 var GIT_CONTEXT_CACHE_TTL_MS = 15000, MAX_GIT_CONTEXT_CACHE_ENTRIES = 64, FROZEN_SUPPORTED_COMMANDS, gitContextCache, STREAM_CHANNEL_MESSAGE_TYPES, COALESCABLE_STATUS_MESSAGE_TYPES;
 var init_protocol_outbound = __esm(async () => {
@@ -347856,9 +348115,10 @@ var init_protocol_outbound = __esm(async () => {
   init_manager();
   init_mode();
   init_settings_manager();
-  init_process_manager();
   init_debug();
+  init_background_process_snapshot();
   init_channel_turn_session();
+  init_connection();
   init_constants3();
   init_cwd();
   init_device_status_cache();
@@ -347921,9 +348181,9 @@ async function switchConversationWorkingDirectory(params) {
     reminderState.hasSentSessionContext = false;
     reminderState.pendingSessionContextReason = "cwd_changed";
   }
-  const statusSocket = params.statusSocket ?? runtime.socket;
-  if (params.emitStatus !== false && statusSocket) {
-    emitDeviceStatusUpdate(statusSocket, params.statusRuntime ?? conversationRuntime ?? runtime, {
+  if (params.emitStatus !== false) {
+    const statusTransport = params.statusSocket ?? getOrCreateProcessTransport(runtime);
+    emitDeviceStatusUpdate(statusTransport, params.statusRuntime ?? conversationRuntime ?? runtime, {
       agent_id: agentId,
       conversation_id: conversationId
     });
@@ -347932,6 +348192,7 @@ async function switchConversationWorkingDirectory(params) {
 var init_cwd_change = __esm(async () => {
   init_runtime_context();
   init_settings_manager();
+  init_connection();
   init_cwd();
   init_runtime6();
   await init_protocol_outbound();
@@ -349415,7 +349676,8 @@ async function startExecSession(args) {
     startTime: new Date,
     outputFile,
     totalStdoutLines: 0,
-    totalStderrLines: 0
+    totalStderrLines: 0,
+    runtimeScope: args.parentScope
   });
   if (session.status !== "running") {
     scheduleBackgroundProcessCleanup(id2);
@@ -363635,7 +363897,8 @@ function spawnBackgroundSubagentTask(args) {
     output: [],
     startTime: new Date,
     outputFile,
-    abortController
+    abortController,
+    runtimeScope: resolvedParentScope
   };
   backgroundTasks.set(taskId, bgTask);
   writeTaskTranscriptStart(outputFile, description, subagentType);
@@ -369549,10 +369812,8 @@ function filterToolRegistryByClientAllowlist(registry2, clientToolAllowlist) {
 }
 function filterExternalToolsByRuntimeContext(externalTools, runtimeContext) {
   return new Map(Array.from(externalTools.entries()).filter(([, tool2]) => {
-    if (!tool2.runtime) {
-      return true;
-    }
-    return tool2.runtime.agentId === runtimeContext.agentId && tool2.runtime.conversationId === runtimeContext.conversationId;
+    const matchesConnection = tool2.connectionId === undefined || tool2.connectionId === runtimeContext.connectionId;
+    return matchesConnection && (!tool2.runtime || tool2.runtime.agentId === runtimeContext.agentId && tool2.runtime.conversationId === runtimeContext.conversationId);
   }));
 }
 function filterExternalToolsByScopeIds(externalTools, externalToolScopeIds) {
@@ -370747,6 +371008,9 @@ async function executeToolInner(name, args, options3) {
         if (Object.keys(secretEnv).length > 0) {
           enhancedArgs = { ...enhancedArgs, secretEnv };
         }
+        if (options3?.parentScope) {
+          enhancedArgs = { ...enhancedArgs, parentScope: options3.parentScope };
+        }
       }
       if (internalName === "Task") {
         if (options3?.toolCallId) {
@@ -371460,6 +371724,7 @@ function parseInheritedChannelContextEnv() {
 }
 async function prepareToolExecutionContextForScope(params) {
   const {
+    connectionId,
     agentId,
     conversationId,
     overrideModel,
@@ -371522,6 +371787,7 @@ async function prepareToolExecutionContextForScope(params) {
     modAdapters,
     agent: agent2,
     runtimeContext: {
+      connectionId,
       agentId,
       agentName: agent2.name ?? null,
       conversationId: scopedConversationId,
@@ -435895,6 +436161,7 @@ function consumeQueuedTurn(runtime) {
   let hasTaskNotification = false;
   let hasCronPrompt = false;
   let hasModContinue = false;
+  let batchConnectionId;
   let batchImageFailureMode = null;
   const isNoCoalesce = (candidate) => candidate.kind === "message" && candidate.noCoalesce === true;
   for (const item of queuedItems) {
@@ -435905,6 +436172,11 @@ function consumeQueuedTurn(runtime) {
       break;
     }
     if (item.kind === "message") {
+      const itemConnectionId = runtime.queuedMessagesByItemId.get(item.id)?.connectionId;
+      if (batchConnectionId !== undefined && itemConnectionId !== undefined && itemConnectionId !== batchConnectionId) {
+        break;
+      }
+      batchConnectionId ??= itemConnectionId;
       const itemImageFailureMode = getInboundImageFailureMode(runtime.queuedMessagesByItemId.get(item.id));
       if (batchImageFailureMode !== null && itemImageFailureMode !== batchImageFailureMode) {
         break;
@@ -436087,14 +436359,6 @@ function ensureConversationQueueRuntime(listener, runtime) {
 function getOrCreateScopedRuntime(listener, agentId, conversationId) {
   return ensureConversationQueueRuntime(listener, getOrCreateConversationRuntime(listener, agentId, conversationId));
 }
-function findFallbackRuntime(listener) {
-  for (const cr of listener.conversationRuntimes.values()) {
-    if (cr.queueRuntime) {
-      return cr;
-    }
-  }
-  return null;
-}
 var init_conversation_runtime = __esm(async () => {
   init_queue_runtime();
   init_runtime6();
@@ -436236,21 +436500,20 @@ async function resolveCronFireConversationId(task2) {
   return task2.conversation_id === "default" ? undefined : task2.conversation_id;
 }
 function emitCronsUpdated(socket, task2, conversationId) {
-  if (!isListenerTransportOpen(socket)) {
+  const listener = getActiveRuntime();
+  if (!listener)
     return;
-  }
+  const runtimeScope = {
+    agent_id: task2.agent_id,
+    conversation_id: conversationId ?? task2.conversation_id ?? "default"
+  };
   const payload = {
     type: "crons_updated",
     timestamp: Date.now(),
     agent_id: task2.agent_id,
-    conversation_id: conversationId ?? task2.conversation_id
+    conversation_id: runtimeScope.conversation_id
   };
-  try {
-    socket.send(JSON.stringify(payload));
-    safeEmitWsEvent("send", "protocol", payload);
-  } catch (err) {
-    console.error(`[Cron] Error sending crons_updated for task ${task2.id}:`, err instanceof Error ? err.message : err);
-  }
+  emitProtocolV2Message(socket, listener, payload, runtimeScope, TO_SUBSCRIBERS);
 }
 function refreshTaskCache(state) {
   const mtime = getCronFileMtime();
@@ -436631,13 +436894,14 @@ function stopScheduler() {
 var schedulerState = null, listenerFireContext = null, TICK_INTERVAL_MS = 60000, GC_INTERVAL_MS, LEASE_RETRY_MS = 30000, MAX_LEASE_RETRIES = 3, NEW_CONVERSATION_TARGET = "new";
 var init_scheduler = __esm(async () => {
   init_backend2();
+  init_connection();
   init_runtime6();
-  init_transport();
   init_cron_file();
   init_parse_interval();
   init_run_log();
   await __promiseAll([
     init_conversation_runtime(),
+    init_protocol_outbound(),
     init_queue()
   ]);
   GC_INTERVAL_MS = 60 * 60000;
@@ -445600,6 +445864,34 @@ var init_turn_status = __esm(async () => {
 });
 
 // src/websocket/listener/approval.ts
+function pendingApprovalEntries(runtime) {
+  return [...new Set(runtime.pendingApprovalResolvers.values())];
+}
+function removePendingApproval(runtime, pending) {
+  for (const [requestKey, candidate] of runtime.pendingApprovalResolvers) {
+    if (candidate !== pending)
+      continue;
+    runtime.pendingApprovalResolvers.delete(requestKey);
+  }
+  pending.connectionIds.clear();
+}
+function addPendingApprovalConnection(runtime, pending, connectionId) {
+  const unownedKey = createConnectionRequestKey(UNOWNED_APPROVAL_CONNECTION_ID, pending.requestId);
+  runtime.pendingApprovalResolvers.delete(unownedKey);
+  const requestKey = createConnectionRequestKey(connectionId, pending.requestId);
+  pending.connectionIds.add(connectionId);
+  runtime.pendingApprovalResolvers.set(requestKey, pending);
+}
+function keepPendingApprovalUnowned(runtime, pending) {
+  const requestKey = createConnectionRequestKey(UNOWNED_APPROVAL_CONNECTION_ID, pending.requestId);
+  runtime.pendingApprovalResolvers.set(requestKey, pending);
+}
+function hasPendingApprovalRequestId(runtime, requestId) {
+  return pendingApprovalEntries(runtime).some((pending) => pending.requestId === requestId);
+}
+function getPendingApprovalRequestIds(runtime) {
+  return new Set(pendingApprovalEntries(runtime).map((pending) => pending.requestId));
+}
 function rememberPendingApprovalBatchIds(runtime, pendingApprovals, batchId) {
   for (const approval of pendingApprovals) {
     if (approval.toolCallId) {
@@ -445685,17 +445977,20 @@ function validateApprovalResultIds(decisions, approvals) {
   }, null, 2));
   throw new Error("Approval ID mismatch - refusing to send mismatched IDs");
 }
-function resolvePendingApprovalResolver(runtime, response) {
+function resolvePendingApprovalResolver(runtime, response, connectionId) {
   const requestId = response.request_id;
   if (typeof requestId !== "string" || requestId.length === 0) {
     return false;
   }
-  const pending = runtime.pendingApprovalResolvers.get(requestId);
+  const requestKey = connectionId ? createConnectionRequestKey(connectionId, requestId) : [...runtime.pendingApprovalResolvers.entries()].find(([, candidate]) => candidate.requestId === requestId)?.[0];
+  if (!requestKey) {
+    return false;
+  }
+  const pending = runtime.pendingApprovalResolvers.get(requestKey);
   if (!pending) {
     return false;
   }
-  runtime.pendingApprovalResolvers.delete(requestId);
-  runtime.listener.approvalRuntimeKeyByRequestId.delete(requestId);
+  removePendingApproval(runtime, pending);
   if (runtime.pendingApprovalResolvers.size === 0 && !runtime.isProcessing) {
     setCommandLoopStatus(runtime, "WAITING_ON_INPUT");
   }
@@ -445712,15 +446007,10 @@ function resolvePendingApprovalResolver(runtime, response) {
   return true;
 }
 function rejectPendingApprovalResolvers(runtime, reason) {
-  for (const [, pending] of runtime.pendingApprovalResolvers) {
+  for (const pending of pendingApprovalEntries(runtime)) {
     pending.reject(new Error(reason));
   }
   runtime.pendingApprovalResolvers.clear();
-  for (const [requestId, runtimeKey] of runtime.listener.approvalRuntimeKeyByRequestId) {
-    if (runtimeKey === runtime.key) {
-      runtime.listener.approvalRuntimeKeyByRequestId.delete(requestId);
-    }
-  }
   if (!runtime.isProcessing && !runtime.cancelRequested) {
     setCommandLoopStatus(runtime, "WAITING_ON_INPUT");
   }
@@ -445734,8 +446024,49 @@ function rejectPendingApprovalResolvers(runtime, reason) {
   });
   evictConversationRuntimeIfIdle(runtime);
 }
+function rejectPendingApprovalResolversForConnection(runtime, connectionId, _reason) {
+  for (const pending of pendingApprovalEntries(runtime)) {
+    if (!pending.connectionIds.delete(connectionId)) {
+      continue;
+    }
+    const requestKey = createConnectionRequestKey(connectionId, pending.requestId);
+    runtime.pendingApprovalResolvers.delete(requestKey);
+    if (pending.connectionIds.size === 0) {
+      keepPendingApprovalUnowned(runtime, pending);
+    }
+  }
+  evictConversationRuntimeIfIdle(runtime);
+}
+function replayPendingApprovalRequestsToConnection(runtime, connectionId) {
+  const connection = runtime.listener.connections.get(connectionId);
+  if (!connection?.initialized || !isListenerTransportOpen(connection.writer)) {
+    return;
+  }
+  for (const pending of pendingApprovalEntries(runtime)) {
+    addPendingApprovalConnection(runtime, pending, connectionId);
+    if (!pending.controlRequest)
+      continue;
+    emitProtocolV2Message(connection.writer, runtime, pending.controlRequest, {
+      agent_id: runtime.agentId,
+      conversation_id: runtime.conversationId
+    }, toListenerConnection(connectionId));
+  }
+}
 function requestApprovalOverWS(runtime, socket, turnLease, requestId, controlRequest) {
-  if (!isListenerTransportOpen(socket)) {
+  const scope = {
+    agent_id: runtime.agentId,
+    conversation_id: runtime.conversationId
+  };
+  const subscribers = getSubscribedListenerConnections(runtime.listener, scope);
+  const originConnection = findListenerConnectionByTransport(runtime.listener, socket);
+  const connectionIds = new Set(subscribers.map((subscriber) => subscriber.id));
+  if (connectionIds.size === 0 && originConnection?.initialized && isListenerTransportOpen(originConnection.writer)) {
+    connectionIds.add(originConnection.id);
+  }
+  if (connectionIds.size === 0 && runtime.listener.connections.size === 0 && isListenerTransportOpen(socket)) {
+    connectionIds.add(runtime.listener.connectionId ?? "legacy");
+  }
+  if (connectionIds.size === 0 && !isListenerTransportOpen(socket) && runtime.listener.connections.size === 0) {
     return Promise.reject(new Error("WebSocket not open"));
   }
   const abortSignal = turnLease.signal;
@@ -445745,51 +446076,53 @@ function requestApprovalOverWS(runtime, socket, turnLease, requestId, controlReq
   }
   return new Promise((resolve31, reject) => {
     let settled = false;
+    const pending = {
+      requestId,
+      connectionIds,
+      resolve: (response) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanupAbortListener();
+        resolve31(response);
+      },
+      reject: (error54) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanupAbortListener();
+        reject(error54);
+      },
+      controlRequest
+    };
     const cleanupAbortListener = () => {
       abortSignal.removeEventListener("abort", handleAbort);
     };
-    const wrappedResolve = (response) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      cleanupAbortListener();
-      resolve31(response);
-    };
-    const wrappedReject = (error54) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      cleanupAbortListener();
-      reject(error54);
-    };
     const handleAbort = () => {
-      runtime.pendingApprovalResolvers.delete(requestId);
-      runtime.listener.approvalRuntimeKeyByRequestId.delete(requestId);
-      wrappedReject(new Error("Cancelled by user"));
+      removePendingApproval(runtime, pending);
+      pending.reject(new Error("Cancelled by user"));
     };
     abortSignal.addEventListener("abort", handleAbort, { once: true });
     if (isInterrupted()) {
       handleAbort();
       return;
     }
-    runtime.pendingApprovalResolvers.set(requestId, {
-      resolve: wrappedResolve,
-      reject: wrappedReject,
-      controlRequest
-    });
-    runtime.listener.approvalRuntimeKeyByRequestId.set(requestId, runtime.key);
+    if (connectionIds.size === 0) {
+      keepPendingApprovalUnowned(runtime, pending);
+    } else {
+      for (const connectionId of connectionIds) {
+        addPendingApprovalConnection(runtime, pending, connectionId);
+      }
+    }
     if (isInterrupted()) {
       handleAbort();
       return;
     }
     runtime.turnLifecycle.recordStopReason(turnLease, "requires_approval");
     setTurnLoopStatus(runtime, turnLease, "WAITING_ON_APPROVAL");
-    emitProtocolV2Message(socket, runtime, controlRequest, {
-      agent_id: runtime.agentId,
-      conversation_id: runtime.conversationId
-    });
+    emitProtocolV2Message(socket, runtime, controlRequest, scope, TO_SUBSCRIBERS);
     emitLoopStatusIfOpen(runtime.listener, {
       agent_id: runtime.agentId,
       conversation_id: runtime.conversationId
@@ -445800,7 +446133,9 @@ function requestApprovalOverWS(runtime, socket, turnLease, requestId, controlReq
     });
   });
 }
+var UNOWNED_APPROVAL_CONNECTION_ID = "__unowned_approval__";
 var init_approval = __esm(async () => {
+  init_connection();
   init_runtime6();
   init_transport();
   await __promiseAll([
@@ -447017,6 +447352,93 @@ var init_agents_conversations = __esm(async () => {
   await init_protocol_inbound();
 });
 
+// src/websocket/listener/commands/channel-registry-events.ts
+function broadcastChannelRegistryUpdate(runtime, origin, message) {
+  const payload = JSON.stringify(message);
+  const targets = resolveListenerConnectionTargets({
+    runtime,
+    origin,
+    scope: {},
+    routing: BROADCAST,
+    streamMessage: false
+  });
+  for (const target2 of targets) {
+    if (isListenerTransportOpen(target2.transport)) {
+      try {
+        target2.transport.send(payload);
+      } catch (error54) {
+        trackBoundaryError({
+          context: "listener_channel_registry_broadcast",
+          errorType: "listener_channel_registry_send_failed",
+          error: error54
+        });
+      }
+    }
+  }
+}
+function handleChannelRegistryEvent(event2, transport, runtime) {
+  const broadcast = (message) => broadcastChannelRegistryUpdate(runtime, transport, message);
+  if (event2.type === "pairings_updated") {
+    const channelId = event2.channelId;
+    broadcast({
+      type: "channel_pairings_updated",
+      timestamp: Date.now(),
+      channel_id: channelId
+    });
+    broadcast({
+      type: "channels_updated",
+      timestamp: Date.now(),
+      channel_id: channelId
+    });
+    return;
+  }
+  if (event2.type === "targets_updated") {
+    const channelId = event2.channelId;
+    broadcast({
+      type: "channel_targets_updated",
+      timestamp: Date.now(),
+      channel_id: channelId
+    });
+    broadcast({
+      type: "channels_updated",
+      timestamp: Date.now(),
+      channel_id: channelId
+    });
+    return;
+  }
+  if (event2.type === "channel_account_state_updated") {
+    const channelId = event2.channelId;
+    broadcast({
+      type: "channel_accounts_updated",
+      timestamp: Date.now(),
+      channel_id: channelId,
+      account_id: event2.accountId
+    });
+    broadcast({
+      type: "channels_updated",
+      timestamp: Date.now(),
+      channel_id: channelId
+    });
+    return;
+  }
+  const permissionModeState = getOrCreateConversationPermissionModeStateRef(runtime, event2.agentId, event2.conversationId);
+  permissionModeState.mode = event2.defaultPermissionMode;
+  persistPermissionModeMapForRuntime(runtime);
+  const seededWorkingDirectory = seedConversationWorkingDirectory(runtime, event2.agentId, event2.conversationId, runtime.bootWorkingDirectory);
+  if (seededWorkingDirectory) {
+    emitDeviceStatusUpdate(transport, getOrCreateConversationRuntime(runtime, event2.agentId, event2.conversationId));
+  }
+}
+var init_channel_registry_events = __esm(async () => {
+  init_error_reporting();
+  init_connection();
+  init_cwd();
+  init_permission_mode();
+  init_runtime6();
+  init_transport();
+  await init_protocol_outbound();
+});
+
 // src/channels/custom/scaffolding.ts
 import { existsSync as existsSync48, mkdirSync as mkdirSync34, rmSync as rmSync11, writeFileSync as writeFileSync24 } from "node:fs";
 function removeUserPlugin(channelId) {
@@ -447044,7 +447466,6 @@ var init_scaffolding = __esm(() => {
 });
 
 // src/websocket/listener/commands/channels.ts
-import WebSocket4 from "ws";
 function setChannelsServiceLoaderOverride(loader) {
   channelsServiceLoaderOverride = loader;
 }
@@ -447762,52 +448183,13 @@ async function handleChannelsProtocolCommand(parsed, socket, runtime, opts, proc
   }
   return true;
 }
-function handleChannelRegistryEvent(event2, socket, runtime, safeSocketSend) {
-  if (event2.type === "pairings_updated") {
-    if (socket instanceof WebSocket4) {
-      emitChannelPairingsUpdated(socket, safeSocketSend, event2.channelId);
-      emitChannelsUpdated(socket, safeSocketSend, event2.channelId);
-    }
-    return;
-  }
-  if (event2.type === "targets_updated") {
-    if (socket instanceof WebSocket4) {
-      emitChannelTargetsUpdated(socket, safeSocketSend, event2.channelId);
-      emitChannelsUpdated(socket, safeSocketSend, event2.channelId);
-    }
-    return;
-  }
-  if (event2.type === "channel_account_state_updated") {
-    if (socket instanceof WebSocket4) {
-      emitChannelAccountsUpdated(socket, safeSocketSend, {
-        channelId: event2.channelId,
-        accountId: event2.accountId
-      });
-      emitChannelsUpdated(socket, safeSocketSend, event2.channelId);
-    }
-    return;
-  }
-  const permissionModeState = getOrCreateConversationPermissionModeStateRef(runtime, event2.agentId, event2.conversationId);
-  permissionModeState.mode = event2.defaultPermissionMode;
-  persistPermissionModeMapForRuntime(runtime);
-  const seededWorkingDirectory = seedConversationWorkingDirectory(runtime, event2.agentId, event2.conversationId, runtime.bootWorkingDirectory);
-  if (seededWorkingDirectory) {
-    emitDeviceStatusUpdate(socket, getOrCreateConversationRuntime(runtime, event2.agentId, event2.conversationId));
-  }
-}
 var channelsServiceLoaderOverride = null;
 var init_channels2 = __esm(async () => {
   init_account_config7();
   init_scaffolding();
   init_plugin_registry();
   init_types6();
-  init_cwd();
-  init_permission_mode();
-  init_runtime6();
-  await __promiseAll([
-    init_protocol_inbound(),
-    init_protocol_outbound()
-  ]);
+  await init_protocol_inbound();
 });
 
 // src/websocket/listener/commands/cron.ts
@@ -449626,11 +450008,7 @@ var init_model_toolset = __esm(async () => {
 });
 
 // src/websocket/listener/external-tools.ts
-function isSocketOpen(socket) {
-  return socket?.readyState === WEBSOCKET_OPEN;
-}
 function getPendingExternalToolCalls(runtime) {
-  runtime.pendingExternalToolCalls ??= new Map;
   return runtime.pendingExternalToolCalls;
 }
 function getRegisteredTools(runtime) {
@@ -449641,25 +450019,35 @@ function getRegisteredTools(runtime) {
   }
   return registeredTools;
 }
+function getConnectionIdsByRegistrationKey(runtime) {
+  let controllers = connectionIdByRegistrationKey.get(runtime);
+  if (!controllers) {
+    controllers = new Map;
+    connectionIdByRegistrationKey.set(runtime, controllers);
+  }
+  return controllers;
+}
 function getRuntimeKey(runtime) {
   return `${runtime.agent_id}:${runtime.conversation_id}`;
 }
-function getToolRegistrationKey(runtime, scopeId, toolName) {
+function getToolRegistrationKey(connectionId, runtime, scopeId, toolName) {
   return JSON.stringify([
     "runtime",
+    connectionId,
     runtime.agent_id,
     runtime.conversation_id,
     scopeId ?? null,
     toolName
   ]);
 }
-function toExternalToolDefinition(tool2, runtime, scopeId) {
+function toExternalToolDefinition(tool2, connectionId, runtime, scopeId) {
   return {
     name: tool2.name,
+    connectionId,
     ...tool2.label !== undefined ? { label: tool2.label } : {},
     description: tool2.description,
     parameters: tool2.parameters,
-    registrationKey: getToolRegistrationKey(runtime, scopeId, tool2.name),
+    registrationKey: getToolRegistrationKey(connectionId, runtime, scopeId, tool2.name),
     ...scopeId !== undefined ? { scopeId } : {},
     runtime: {
       agentId: runtime.agent_id,
@@ -449667,16 +450055,17 @@ function toExternalToolDefinition(tool2, runtime, scopeId) {
     }
   };
 }
-function sendJson(socket, payload) {
-  socket.send(JSON.stringify(payload));
-}
 function installExternalToolBridge(runtime) {
   setExternalToolExecutor(async (toolCallId, toolName, input, context3) => {
-    const socket = runtime.socket;
-    if (!isSocketOpen(socket) || runtime.intentionallyClosed) {
+    const registrationKey = context3?.tool.registrationKey;
+    const connectionId = registrationKey ? getConnectionIdsByRegistrationKey(runtime).get(registrationKey) : undefined;
+    const connection = connectionId ? runtime.connections.get(connectionId) : undefined;
+    if (!connection || !isListenerTransportOpen(connection.writer) || runtime.intentionallyClosed) {
       throw new Error("External tool controller is not connected");
     }
+    const writer = connection.writer;
     const requestId = `external-tool-${crypto.randomUUID()}`;
+    const requestKey = createConnectionRequestKey(connection.id, requestId);
     const toolRuntime = context3?.tool.runtime;
     const requestRuntime = toolRuntime?.agentId && toolRuntime.conversationId ? {
       agent_id: toolRuntime.agentId,
@@ -449693,10 +450082,11 @@ function installExternalToolBridge(runtime) {
     };
     const result = await new Promise((resolve31, reject) => {
       const timeout = setTimeout(() => {
-        getPendingExternalToolCalls(runtime).delete(requestId);
+        getPendingExternalToolCalls(runtime).delete(requestKey);
         reject(new Error(`External tool call timed out: ${toolName}`));
       }, EXTERNAL_TOOL_CALL_TIMEOUT_MS);
-      getPendingExternalToolCalls(runtime).set(requestId, {
+      getPendingExternalToolCalls(runtime).set(requestKey, {
+        connectionId: connection.id,
         resolve: (response) => {
           resolve31({
             content: [...response.content],
@@ -449707,36 +450097,49 @@ function installExternalToolBridge(runtime) {
         timeout
       });
       try {
-        sendJson(socket, request);
+        writer.send(JSON.stringify(request));
       } catch (error54) {
         clearTimeout(timeout);
-        getPendingExternalToolCalls(runtime).delete(requestId);
+        getPendingExternalToolCalls(runtime).delete(requestKey);
         reject(error54 instanceof Error ? error54 : new Error(String(error54)));
       }
     });
     return result;
   });
 }
-function registerRuntimeExternalTools(runtime, runtimeScope, groups = []) {
+function registerRuntimeExternalTools(runtime, connectionId, runtimeScope, groups) {
+  const resolvedGroups = groups ?? [];
   const registeredTools = getRegisteredTools(runtime);
-  const runtimeKey = getRuntimeKey(runtimeScope);
+  const runtimeKey = createConnectionRequestKey(connectionId, getRuntimeKey(runtimeScope));
   const previousTools = registeredTools.get(runtimeKey) ?? [];
   unregisterExternalTools(previousTools);
-  const tools = groups.flatMap((group) => group.tools.map((tool2) => toExternalToolDefinition(tool2, runtimeScope, group.scope_id)));
+  const tools = resolvedGroups.flatMap((group) => group.tools.map((tool2) => toExternalToolDefinition(tool2, connectionId, runtimeScope, group.scope_id)));
+  const controllers = getConnectionIdsByRegistrationKey(runtime);
+  for (const tool2 of previousTools) {
+    if (tool2.registrationKey) {
+      controllers.delete(tool2.registrationKey);
+    }
+  }
   if (tools.length > 0) {
     registerExternalTools(tools);
+    for (const tool2 of tools) {
+      if (tool2.registrationKey) {
+        controllers.set(tool2.registrationKey, connectionId);
+      }
+    }
     registeredTools.set(runtimeKey, tools);
   } else {
     registeredTools.delete(runtimeKey);
   }
 }
-function handleExternalToolCallResponseCommand(runtime, command) {
-  const pending = getPendingExternalToolCalls(runtime).get(command.request_id);
+function handleExternalToolCallResponseCommand(runtime, connectionId, command) {
+  const requestKey = createConnectionRequestKey(connectionId, command.request_id);
+  const pending = getPendingExternalToolCalls(runtime).get(requestKey);
   if (!pending) {
     return false;
   }
   clearTimeout(pending.timeout);
-  getPendingExternalToolCalls(runtime).delete(command.request_id);
+  getPendingExternalToolCalls(runtime).delete(requestKey);
   if (command.error !== undefined) {
     pending.reject(new Error(command.error));
     return true;
@@ -449748,6 +450151,35 @@ function handleExternalToolCallResponseCommand(runtime, command) {
   pending.resolve(command.result);
   return true;
 }
+function rejectPendingExternalToolCallsForConnection(runtime, connectionId, reason) {
+  const pendingExternalToolCalls = getPendingExternalToolCalls(runtime);
+  for (const [requestKey, pending] of pendingExternalToolCalls) {
+    if (pending.connectionId !== connectionId) {
+      continue;
+    }
+    clearTimeout(pending.timeout);
+    pendingExternalToolCalls.delete(requestKey);
+    pending.reject(new Error(reason));
+  }
+  const registeredTools = registeredToolsByRuntime.get(runtime);
+  if (!registeredTools) {
+    return;
+  }
+  const controllers = getConnectionIdsByRegistrationKey(runtime);
+  for (const [registrationScope, tools] of registeredTools) {
+    const ownedByConnection = tools.some((tool2) => tool2.registrationKey !== undefined && controllers.get(tool2.registrationKey) === connectionId);
+    if (!ownedByConnection) {
+      continue;
+    }
+    unregisterExternalTools(tools);
+    registeredTools.delete(registrationScope);
+    for (const tool2 of tools) {
+      if (tool2.registrationKey) {
+        controllers.delete(tool2.registrationKey);
+      }
+    }
+  }
+}
 function rejectPendingExternalToolCalls(runtime, reason) {
   const pendingExternalToolCalls = getPendingExternalToolCalls(runtime);
   for (const [requestId, pending] of pendingExternalToolCalls) {
@@ -449762,12 +450194,16 @@ function rejectPendingExternalToolCalls(runtime, reason) {
     }
     registeredToolsByRuntime.delete(runtime);
   }
+  connectionIdByRegistrationKey.delete(runtime);
 }
-var EXTERNAL_TOOL_CALL_TIMEOUT_MS, WEBSOCKET_OPEN = 1, registeredToolsByRuntime;
+var EXTERNAL_TOOL_CALL_TIMEOUT_MS, registeredToolsByRuntime, connectionIdByRegistrationKey;
 var init_external_tools = __esm(async () => {
+  init_connection();
+  init_transport();
   await init_manager4();
   EXTERNAL_TOOL_CALL_TIMEOUT_MS = 5 * 60 * 1000;
   registeredToolsByRuntime = new WeakMap;
+  connectionIdByRegistrationKey = new WeakMap;
 });
 
 // src/websocket/listener/commands/runtime-start.ts
@@ -449915,9 +450351,18 @@ async function handleRuntimeStartCommand(parsed, context3) {
     agent2 = await resolveRuntimeStartAgent(parsed, created);
     conversation = await resolveRuntimeStartConversation(parsed, agent2, created);
     runtimeScope = buildRuntimeScope(agent2, conversation);
+    const { connectionId } = context3;
+    const assertConnectionOpen = () => {
+      if (context3.runtime.connections.size > 0 && (!context3.runtime.connections.has(connectionId) || context3.runtime.connections.get(connectionId)?.cancellation.signal.aborted)) {
+        throw new Error("App-server connection closed during runtime start");
+      }
+    };
+    assertConnectionOpen();
     const scopedRuntime = context3.getOrCreateScopedRuntime(context3.runtime, runtimeScope.agent_id, runtimeScope.conversation_id);
     await applyRuntimeStartState(parsed, context3, runtimeScope, scopedRuntime);
-    registerRuntimeExternalTools(context3.runtime, runtimeScope, parsed.external_tools ?? []);
+    assertConnectionOpen();
+    subscribeListenerConnection(context3.runtime, connectionId, runtimeScope);
+    registerRuntimeExternalTools(context3.runtime, connectionId, runtimeScope, parsed.external_tools ?? []);
     const sent = sendRuntimeStartResponse(context3, parsed, {
       success: true,
       runtime: runtimeScope,
@@ -449959,6 +450404,7 @@ var init_runtime_start = __esm(async () => {
   init_backend2();
   init_mode();
   init_settings_manager();
+  init_connection();
   init_cwd();
   init_permission_mode();
   await __promiseAll([
@@ -457404,16 +457850,19 @@ async function handleApprovalStop(params) {
     return interruptTermination();
   }
   const onFileWrite = (filePath, content) => {
-    if (runtime.turnLifecycle.isCurrent(turnLease) && isListenerTransportOpen(socket)) {
-      socket.send(JSON.stringify({
-        type: "file_ops",
-        path: filePath,
-        cg_entries: [],
-        ops: [],
-        source: "agent",
-        document_content: content
-      }));
-    }
+    if (!runtime.turnLifecycle.isCurrent(turnLease))
+      return;
+    emitProtocolV2Message(socket, runtime, {
+      type: "file_ops",
+      path: filePath,
+      cg_entries: [],
+      ops: [],
+      source: "agent",
+      document_content: content
+    }, {
+      agent_id: agentId,
+      conversation_id: conversationId
+    }, TO_SUBSCRIBERS);
   };
   let executionResults;
   try {
@@ -457559,9 +458008,9 @@ var init_turn_approval = __esm(async () => {
   init_diff_preview();
   init_format_denial();
   init_interactive_policy();
+  init_connection();
   init_secrets_sync();
   init_skill_injection();
-  init_transport();
   init_turn_input_state();
   await __promiseAll([
     init_approval_execution(),
@@ -458995,6 +459444,7 @@ async function prepareListenerTurn(params) {
   }
   const modAdapters = await ensureListenerModAdaptersForAgent(runtime.listener, agentId);
   const preparedToolContext = await prepareToolExecutionContextForScope({
+    connectionId,
     agentId,
     conversationId,
     clientToolAllowlist: msg.clientToolAllowlist,
@@ -459078,6 +459528,9 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
     origin: "message",
     workingDirectory: turnWorkingDirectory
   });
+  if (connectionId) {
+    runtime.activeConnectionId = connectionId;
+  }
   if (!runtime.turnLifecycle.isCurrent(turnLease)) {
     throw new Error("Cannot continue a turn with a stale lifecycle lease");
   }
@@ -459682,6 +460135,9 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
       });
     }
     richDraftStreamer?.dispose();
+    if (runtime.activeConnectionId === connectionId) {
+      runtime.activeConnectionId = null;
+    }
     try {
       if (finalizedByThisInvocation) {
         await runListenerTurnCleanup({
@@ -459787,15 +460243,19 @@ function handleModeChange(msg, socket, runtime, scope) {
     }
   }
 }
-function resolveRuntimeForApprovalRequest(listener, requestId) {
+function resolveRuntimeForApprovalRequest(listener, scope, requestId, connectionId) {
   if (!requestId) {
     return null;
   }
-  const runtimeKey = listener.approvalRuntimeKeyByRequestId.get(requestId);
-  if (!runtimeKey) {
+  const runtime = getConversationRuntime(listener, scope.agent_id, scope.conversation_id);
+  if (!runtime) {
     return null;
   }
-  return listener.conversationRuntimes.get(runtimeKey) ?? null;
+  if (connectionId) {
+    const requestKey = createConnectionRequestKey(connectionId, requestId);
+    return runtime.pendingApprovalResolvers.has(requestKey) ? runtime : null;
+  }
+  return hasPendingApprovalRequestId(runtime, requestId) ? runtime : null;
 }
 async function handleApprovalResponseInput(listener, params, deps = {
   resolveRuntimeForApprovalRequest,
@@ -459804,8 +460264,8 @@ async function handleApprovalResponseInput(listener, params, deps = {
   resolveRecoveredApprovalResponse,
   scheduleQueuePump
 }) {
-  const approvalRuntime = deps.resolveRuntimeForApprovalRequest(listener, params.response.request_id);
-  if (approvalRuntime && deps.resolvePendingApprovalResolver(approvalRuntime, params.response)) {
+  const approvalRuntime = deps.resolveRuntimeForApprovalRequest(listener, params.runtime, params.response.request_id, params.connectionId);
+  if (approvalRuntime && deps.resolvePendingApprovalResolver(approvalRuntime, params.response, params.connectionId)) {
     deps.scheduleQueuePump(approvalRuntime, params.socket, params.opts, params.processQueuedTurn);
     return true;
   }
@@ -460044,6 +460504,7 @@ var init_control_inputs = __esm(async () => {
   init_mode();
   init_error_reporting();
   init_debug();
+  init_connection();
   init_cwd();
   init_permission_mode();
   init_runtime6();
@@ -460062,16 +460523,30 @@ var init_control_inputs = __esm(async () => {
 });
 
 // src/websocket/terminal-handler.ts
+import { existsSync as existsSync51 } from "node:fs";
 import * as os6 from "node:os";
-import WebSocket5 from "ws";
+import WebSocket4 from "ws";
+function getTerminalKey(connectionId, terminalId) {
+  return JSON.stringify([connectionId, terminalId]);
+}
 function getDefaultShell() {
   if (os6.platform() === "win32") {
     return process.env.COMSPEC || "cmd.exe";
   }
-  return process.env.SHELL || "/bin/zsh";
+  const candidates2 = [
+    process.env.SHELL,
+    os6.platform() === "darwin" ? "/bin/zsh" : "/bin/bash",
+    "/bin/bash"
+  ];
+  for (const candidate of candidates2) {
+    if (candidate && existsSync51(candidate)) {
+      return candidate;
+    }
+  }
+  return "/bin/sh";
 }
 function sendTerminalMessage(socket, message) {
-  if (socket.readyState === WebSocket5.OPEN) {
+  if (socket.readyState === WebSocket4.OPEN) {
     socket.send(JSON.stringify(message));
   }
 }
@@ -460097,7 +460572,8 @@ function makeOutputBatcher(onFlush) {
     }
   };
 }
-function spawnBun(shell2, cwd2, cols, rows, terminal_id, socket) {
+function spawnBun(shell2, cwd2, cols, rows, terminal_id, connectionId, socket) {
+  const terminalKey = getTerminalKey(connectionId, terminal_id);
   const handleData = makeOutputBatcher((data) => sendTerminalMessage(socket, { type: "terminal_output", terminal_id, data }));
   const proc2 = Bun.spawn([shell2], {
     cwd: cwd2,
@@ -460113,9 +460589,9 @@ function spawnBun(shell2, cwd2, cols, rows, terminal_id, socket) {
     throw new Error("Bun.spawn terminal object missing — API unavailable");
   }
   proc2.exited.then((exitCode) => {
-    const current = terminals.get(terminal_id);
+    const current = terminals.get(terminalKey);
     if (current && current.pid === proc2.pid) {
-      terminals.delete(terminal_id);
+      terminals.delete(terminalKey);
       sendTerminalMessage(socket, {
         type: "terminal_exited",
         terminal_id,
@@ -460144,10 +460620,12 @@ function spawnBun(shell2, cwd2, cols, rows, terminal_id, socket) {
     },
     pid: proc2.pid,
     terminalId: terminal_id,
+    connectionId,
     spawnedAt: Date.now()
   };
 }
-function spawnNodePty(shell2, cwd2, cols, rows, terminal_id, socket) {
+function spawnNodePty(shell2, cwd2, cols, rows, terminal_id, connectionId, socket) {
+  const terminalKey = getTerminalKey(connectionId, terminal_id);
   const pty = __require("node-pty");
   const handleData = makeOutputBatcher((data) => sendTerminalMessage(socket, { type: "terminal_output", terminal_id, data }));
   const ptyProcess = pty.spawn(shell2, [], {
@@ -460163,9 +460641,9 @@ function spawnNodePty(shell2, cwd2, cols, rows, terminal_id, socket) {
   });
   ptyProcess.onData(handleData);
   ptyProcess.onExit(({ exitCode }) => {
-    const current = terminals.get(terminal_id);
+    const current = terminals.get(terminalKey);
     if (current && current.pid === ptyProcess.pid) {
-      terminals.delete(terminal_id);
+      terminals.delete(terminalKey);
       sendTerminalMessage(socket, {
         type: "terminal_exited",
         terminal_id,
@@ -460191,12 +460669,14 @@ function spawnNodePty(shell2, cwd2, cols, rows, terminal_id, socket) {
     },
     pid: ptyProcess.pid,
     terminalId: terminal_id,
+    connectionId,
     spawnedAt: Date.now()
   };
 }
-function handleTerminalSpawn(msg, socket, cwd2) {
+function handleTerminalSpawn(msg, socket, cwd2, connectionId = "legacy") {
   const { terminal_id, cols, rows } = msg;
-  const existing = terminals.get(terminal_id);
+  const terminalKey = getTerminalKey(connectionId, terminal_id);
+  const existing = terminals.get(terminalKey);
   if (existing && Date.now() - existing.spawnedAt < 2000) {
     let alive = true;
     try {
@@ -460213,14 +460693,14 @@ function handleTerminalSpawn(msg, socket, cwd2) {
       });
       return;
     }
-    terminals.delete(terminal_id);
+    terminals.delete(terminalKey);
   }
-  killTerminal(terminal_id);
+  killTerminal(terminal_id, connectionId);
   const shell2 = getDefaultShell();
   console.log(`[Terminal] Spawning PTY (${IS_BUN ? "bun" : "node-pty"}): shell=${shell2}, cwd=${cwd2}, cols=${cols}, rows=${rows}`);
   try {
-    const session = IS_BUN ? spawnBun(shell2, cwd2, cols, rows, terminal_id, socket) : spawnNodePty(shell2, cwd2, cols, rows, terminal_id, socket);
-    terminals.set(terminal_id, session);
+    const session = IS_BUN ? spawnBun(shell2, cwd2, cols, rows, terminal_id, connectionId, socket) : spawnNodePty(shell2, cwd2, cols, rows, terminal_id, connectionId, socket);
+    terminals.set(terminalKey, session);
     console.log(`[Terminal] Session stored for terminal_id=${terminal_id}, pid=${session.pid}`);
     sendTerminalMessage(socket, {
       type: "terminal_spawned",
@@ -460237,31 +460717,39 @@ function handleTerminalSpawn(msg, socket, cwd2) {
     });
   }
 }
-function handleTerminalInput(msg) {
-  terminals.get(msg.terminal_id)?.write(msg.data);
+function handleTerminalInput(msg, connectionId = "legacy") {
+  terminals.get(getTerminalKey(connectionId, msg.terminal_id))?.write(msg.data);
 }
-function handleTerminalResize(msg) {
-  terminals.get(msg.terminal_id)?.resize(msg.cols, msg.rows);
+function handleTerminalResize(msg, connectionId = "legacy") {
+  terminals.get(getTerminalKey(connectionId, msg.terminal_id))?.resize(msg.cols, msg.rows);
 }
-function handleTerminalKill(msg) {
-  const session = terminals.get(msg.terminal_id);
+function handleTerminalKill(msg, connectionId = "legacy") {
+  const session = terminals.get(getTerminalKey(connectionId, msg.terminal_id));
   if (session && Date.now() - session.spawnedAt < 2000) {
     console.log(`[Terminal] Ignoring kill for recently spawned session (age=${Date.now() - session.spawnedAt}ms)`);
     return;
   }
-  killTerminal(msg.terminal_id);
+  killTerminal(msg.terminal_id, connectionId);
 }
-function killTerminal(terminalId) {
-  const session = terminals.get(terminalId);
+function killTerminal(terminalId, connectionId) {
+  const terminalKey = getTerminalKey(connectionId, terminalId);
+  const session = terminals.get(terminalKey);
   if (session) {
     console.log(`[Terminal] killTerminal: terminalId=${terminalId}, pid=${session.pid}`);
     session.kill();
-    terminals.delete(terminalId);
+    terminals.delete(terminalKey);
+  }
+}
+function killListenerConnectionTerminals(connectionId) {
+  for (const session of [...terminals.values()]) {
+    if (session.connectionId === connectionId) {
+      killTerminal(session.terminalId, connectionId);
+    }
   }
 }
 function killAllTerminals() {
-  for (const [id2] of terminals) {
-    killTerminal(id2);
+  for (const session of [...terminals.values()]) {
+    killTerminal(session.terminalId, session.connectionId);
   }
 }
 var IS_BUN, FLUSH_INTERVAL_MS = 16, MAX_BUFFER_BYTES, terminals;
@@ -460489,7 +460977,7 @@ __export(exports_custom, {
   GLOBAL_COMMANDS_DIR: () => GLOBAL_COMMANDS_DIR,
   COMMANDS_DIR: () => COMMANDS_DIR
 });
-import { existsSync as existsSync51 } from "node:fs";
+import { existsSync as existsSync52 } from "node:fs";
 import { readdir as readdir10, readFile as readFile20 } from "node:fs/promises";
 import { basename as basename25, dirname as dirname28, join as join65 } from "node:path";
 async function getCustomCommands() {
@@ -460523,7 +461011,7 @@ async function discoverCustomCommands(projectPath = join65(process.cwd(), COMMAN
   return result;
 }
 async function discoverFromDirectory(dirPath, source2) {
-  if (!existsSync51(dirPath)) {
+  if (!existsSync52(dirPath)) {
     return [];
   }
   const commands = [];
@@ -461488,6 +461976,144 @@ var init_commands2 = __esm(async () => {
   ]);
 });
 
+// src/websocket/listener/connection-lifecycle.ts
+import WebSocket5 from "ws";
+function createConnectionTurnProcessor(runtime) {
+  return async (queuedTurn, dequeuedBatch) => {
+    const scopedRuntime = getOrCreateScopedRuntime(runtime, queuedTurn.agentId, queuedTurn.conversationId);
+    if (!queuedTurn.connectionId) {
+      await handleIncomingMessage(queuedTurn, getOrCreateProcessTransport(runtime), scopedRuntime, undefined, undefined, dequeuedBatch.batchId);
+      return;
+    }
+    const connection = runtime.connections.get(queuedTurn.connectionId);
+    if (!connection || connection.cancellation.signal.aborted) {
+      return;
+    }
+    await handleIncomingMessage(queuedTurn, connection.writer, scopedRuntime, connection.options.onStatusChange, connection.id, dequeuedBatch.batchId);
+  };
+}
+function cleanupListenerConnection(runtime, connectionId) {
+  for (const conversationRuntime of runtime.conversationRuntimes.values()) {
+    if (conversationRuntime.activeConnectionId === connectionId) {
+      const hasEligibleFailover = getSubscribedListenerConnections(runtime, {
+        agent_id: conversationRuntime.agentId,
+        conversation_id: conversationRuntime.conversationId
+      }).some((connection) => connection.id !== connectionId);
+      if (hasEligibleFailover) {
+        conversationRuntime.activeConnectionId = null;
+      } else {
+        conversationRuntime.turnLifecycle.requestCancellation();
+      }
+    }
+    for (const [
+      itemId,
+      queuedMessage
+    ] of conversationRuntime.queuedMessagesByItemId) {
+      if (queuedMessage.connectionId === connectionId) {
+        conversationRuntime.queueRuntime.removeItem(itemId);
+        conversationRuntime.queuedMessagesByItemId.delete(itemId);
+      }
+    }
+    rejectPendingApprovalResolversForConnection(conversationRuntime, connectionId, "Listener connection closed");
+  }
+  rejectPendingExternalToolCallsForConnection(runtime, connectionId, "Listener connection closed");
+  killListenerConnectionTerminals(connectionId);
+  const closedSubscriptionKeys = [
+    ...runtime.connections.get(connectionId)?.subscriptions ?? []
+  ];
+  closeListenerConnection(runtime, connectionId);
+  for (const runtimeKey of closedSubscriptionKeys) {
+    if (!runtime.connectionIdsByRuntimeKey.has(runtimeKey)) {
+      const scopedRuntime = runtime.conversationRuntimes.get(runtimeKey);
+      if (scopedRuntime) {
+        evictConversationRuntimeIfIdle(scopedRuntime);
+      }
+    }
+  }
+}
+function closeListenerRuntimeConnections(runtime, suppressCallbacks) {
+  const socketsToClose = new Set;
+  const collectSocket = (transport) => {
+    if (transport && getListenerTransportKind(transport) === "websocket") {
+      socketsToClose.add(transport);
+    }
+  };
+  if (runtime.socket) {
+    socketsToClose.add(runtime.socket);
+  }
+  if (runtime.streamSocket) {
+    socketsToClose.add(runtime.streamSocket);
+  }
+  for (const connection of runtime.connections.values()) {
+    collectSocket(connection.writer);
+    collectSocket(connection.streamWriter);
+  }
+  for (const connectionId of [...runtime.connections.keys()]) {
+    closeListenerConnection(runtime, connectionId);
+  }
+  runtime.connectionIdsByRuntimeKey.clear();
+  runtime.socket = null;
+  runtime.transport = null;
+  runtime.streamSocket = null;
+  runtime.streamTransport = null;
+  for (const socket of socketsToClose) {
+    if (suppressCallbacks) {
+      socket.removeAllListeners();
+    }
+    if (socket.readyState === WebSocket5.OPEN || socket.readyState === WebSocket5.CONNECTING) {
+      socket.close();
+    }
+  }
+}
+var init_connection_lifecycle = __esm(async () => {
+  init_terminal_handler();
+  init_connection();
+  init_runtime6();
+  init_transport();
+  await __promiseAll([
+    init_approval(),
+    init_conversation_runtime(),
+    init_external_tools(),
+    init_turn()
+  ]);
+});
+
+// src/websocket/listener/connection-state-sync.ts
+function emitInitialConnectionState(runtime, transport, connectionId, options3 = {}) {
+  if (options3.emitInitialState === false)
+    return;
+  const routing = toListenerConnection(connectionId);
+  if (runtime.conversationRuntimes.size === 0) {
+    emitLoopStatusUpdate(transport, runtime, undefined, routing);
+    return;
+  }
+  for (const conversationRuntime of runtime.conversationRuntimes.values()) {
+    const scope = {
+      agent_id: conversationRuntime.agentId,
+      conversation_id: conversationRuntime.conversationId
+    };
+    emitDeviceStatusUpdate(transport, conversationRuntime, scope, routing);
+    emitLoopStatusUpdate(transport, conversationRuntime, scope, routing);
+  }
+}
+function replaySubscribedConnectionState(listener, transport, runtime, scope, forceDeviceStatus) {
+  const connection = findListenerConnectionByTransport(listener, transport);
+  if (connection) {
+    replayPendingApprovalRequestsToConnection(runtime, connection.id);
+  }
+  emitStateSync(transport, listener, scope, {
+    forceDeviceStatus,
+    ...connection ? { routing: toListenerConnection(connection.id) } : {}
+  });
+}
+var init_connection_state_sync = __esm(async () => {
+  init_connection();
+  await __promiseAll([
+    init_approval(),
+    init_protocol_outbound()
+  ]);
+});
+
 // src/websocket/listener/grep-in-files.ts
 import { execFile as execFile14 } from "node:child_process";
 import { createRequire as createRequire6 } from "node:module";
@@ -462356,7 +462982,7 @@ function buildAppServerInfoResponse(command, options3) {
       conversation_management: true,
       memory_management: true,
       runtime_start: true,
-      split_channels: true
+      split_channels: false
     }
   };
 }
@@ -463701,6 +464327,7 @@ function createListenerMessageHandler(params) {
   const {
     runtime,
     socket,
+    connectionId: explicitConnectionId,
     opts,
     processQueuedTurn,
     fileCommandSession,
@@ -463717,6 +464344,7 @@ function createListenerMessageHandler(params) {
     wireChannelIngress,
     processIncomingMessage = handleIncomingMessage
   } = params;
+  const connectionId = explicitConnectionId ?? opts.connectionId;
   return async (data) => {
     const raw2 = data.toString();
     let parsedScope = null;
@@ -463746,6 +464374,9 @@ function createListenerMessageHandler(params) {
         return;
       }
       console.log(`[Listen V2] Received ${summarizeV2Command(parsed)}`);
+      if (parsedScope) {
+        subscribeListenerConnection(runtime, connectionId, parsedScope);
+      }
       if (parsed.type === "__invalid_input") {
         emitLoopErrorNotice(socket, runtime, {
           message: parsed.reason,
@@ -463762,6 +464393,7 @@ function createListenerMessageHandler(params) {
       }
       if (handleRuntimeStartProtocolCommand(parsed, {
         socket,
+        connectionId,
         runtime,
         safeSocketSend,
         runDetachedListenerTask,
@@ -463771,7 +464403,7 @@ function createListenerMessageHandler(params) {
         return;
       }
       if (parsed.type === "external_tool_call_response") {
-        handleExternalToolCallResponseCommand(runtime, parsed);
+        handleExternalToolCallResponseCommand(runtime, connectionId, parsed);
         return;
       }
       if (parsed.type === "sync") {
@@ -463825,6 +464457,7 @@ function createListenerMessageHandler(params) {
           if (await handleApprovalResponseInput2(runtime, {
             runtime: parsed.runtime,
             response: parsed.payload,
+            connectionId,
             socket,
             opts: {
               onStatusChange: opts.onStatusChange,
@@ -463849,6 +464482,7 @@ function createListenerMessageHandler(params) {
         }
         const incoming = {
           type: "message",
+          connectionId,
           agentId: parsed.runtime.agent_id,
           conversationId: parsed.runtime.conversation_id,
           clientToolAllowlist: inputPayload.client_tool_allowlist,
@@ -463897,6 +464531,7 @@ function createListenerMessageHandler(params) {
       if (parsed.type === "change_device_state") {
         await handleChangeDeviceStateInput2(runtime, {
           command: parsed,
+          connectionId,
           socket,
           opts: {
             onStatusChange: opts.onStatusChange,
@@ -463923,6 +464558,7 @@ function createListenerMessageHandler(params) {
         try {
           const aborted2 = await handleAbortMessageInput2(runtime, {
             command: parsed,
+            connectionId,
             socket,
             opts: {
               onStatusChange: opts.onStatusChange,
@@ -464092,19 +464728,19 @@ function createListenerMessageHandler(params) {
         return;
       }
       if (parsed.type === "terminal_spawn") {
-        handleTerminalSpawn(parsed, socket, parsed.cwd ?? getBootWorkingDirectory(runtime));
+        handleTerminalSpawn(parsed, socket, parsed.cwd ?? getBootWorkingDirectory(runtime), connectionId);
         return;
       }
       if (parsed.type === "terminal_input") {
-        handleTerminalInput(parsed);
+        handleTerminalInput(parsed, connectionId);
         return;
       }
       if (parsed.type === "terminal_resize") {
-        handleTerminalResize(parsed);
+        handleTerminalResize(parsed, connectionId);
         return;
       }
       if (parsed.type === "terminal_kill") {
-        handleTerminalKill(parsed);
+        handleTerminalKill(parsed, connectionId);
       }
     } catch (error54) {
       trackListenerError4("listener_message_handler_failed", error54, "listener_message_handler");
@@ -464131,6 +464767,7 @@ var init_message_router = __esm(async () => {
   init_debug();
   init_terminal_handler();
   init_app_server_info();
+  init_connection();
   init_cwd();
   init_runtime6();
   await __promiseAll([
@@ -464157,6 +464794,97 @@ var init_message_router = __esm(async () => {
   ]);
 });
 
+// src/websocket/listener/process-services.ts
+function installProcessEventRouting(params) {
+  const { runtime, processTransport, opts, processQueuedTurn } = params;
+  runtime._unsubscribeSubagentState?.();
+  runtime._unsubscribeSubagentState = subscribe(() => {
+    if (runtime.conversationRuntimes.size === 0) {
+      emitSubagentStateIfOpen(runtime);
+      return;
+    }
+    for (const conversationRuntime of runtime.conversationRuntimes.values()) {
+      emitSubagentStateIfOpen(runtime, {
+        agent_id: conversationRuntime.agentId,
+        conversation_id: conversationRuntime.conversationId
+      });
+    }
+  });
+  runtime._unsubscribeSubagentStreamEvents?.();
+  runtime._unsubscribeSubagentStreamEvents = subscribeToStreamEvents((subagentId, event2) => {
+    if (!isListenerTransportOpen(processTransport))
+      return;
+    const subagent = getSubagents().find((entry) => entry.id === subagentId);
+    if (subagent?.silent === true)
+      return;
+    emitStreamDelta(processTransport, runtime, event2, subagent?.parentAgentId ? {
+      agent_id: subagent.parentAgentId,
+      conversation_id: subagent.parentConversationId ?? "default"
+    } : undefined, subagentId);
+  });
+  setMessageQueueAdder((queuedMessage) => {
+    if (!queuedMessage.agentId || !queuedMessage.conversationId)
+      return;
+    const targetRuntime = getOrCreateScopedRuntime(runtime, queuedMessage.agentId, queuedMessage.conversationId);
+    if (!targetRuntime?.queueRuntime)
+      return;
+    targetRuntime.queueRuntime.enqueue({
+      kind: "task_notification",
+      source: "task_notification",
+      text: queuedMessage.text,
+      agentId: queuedMessage.agentId ?? targetRuntime.agentId ?? undefined,
+      conversationId: queuedMessage.conversationId ?? targetRuntime.conversationId
+    });
+    scheduleQueuePump(targetRuntime, processTransport, opts, processQueuedTurn);
+  });
+}
+function clearProcessServices(runtime) {
+  runtime._unsubscribeSubagentState?.();
+  runtime._unsubscribeSubagentState = undefined;
+  runtime._unsubscribeSubagentStreamEvents?.();
+  runtime._unsubscribeSubagentStreamEvents = undefined;
+  setMessageQueueAdder(null);
+  stopScheduler();
+  clearRuntimeTimers(runtime);
+  runtime.processServicesStarted = false;
+}
+function invalidateProcessServices(runtime) {
+  runtime.processServicesGeneration += 1;
+  clearProcessServices(runtime);
+}
+async function waitForProcessServicesSlot(runtime, connectionId) {
+  const initiatingConnection = runtime.connections.get(connectionId);
+  const canInitiate = () => !initiatingConnection || runtime.connections.get(connectionId) === initiatingConnection && !initiatingConnection.cancellation.signal.aborted;
+  while (runtime.processServicesReady) {
+    const pending = runtime.processServicesReady;
+    const pendingGeneration = runtime.processServicesReadyGeneration;
+    try {
+      await pending;
+    } catch (error54) {
+      if (pendingGeneration === runtime.processServicesGeneration)
+        throw error54;
+    }
+    if (runtime.processServicesStarted)
+      return false;
+    if (runtime !== getActiveRuntime() || runtime.intentionallyClosed || !canInitiate()) {
+      return false;
+    }
+  }
+  return canInitiate();
+}
+var init_process_services = __esm(async () => {
+  init_subagent_state();
+  init_message_queue_bridge();
+  init_runtime6();
+  init_transport();
+  await __promiseAll([
+    init_scheduler(),
+    init_conversation_runtime(),
+    init_protocol_outbound(),
+    init_queue()
+  ]);
+});
+
 // src/websocket/listener/lifecycle.ts
 import WebSocket6 from "ws";
 function trackListenerError4(errorType, error54, context3) {
@@ -464219,9 +464947,7 @@ async function replaySyncStateForRuntime(listenerRuntime, socket, scope, opts) {
       }
     }
   }
-  emitStateSync(socket, listenerRuntime, scope, {
-    forceDeviceStatus: opts?.forceDeviceStatus
-  });
+  replaySubscribedConnectionState(listenerRuntime, socket, syncScopedRuntime, scope, opts?.forceDeviceStatus);
   (opts?.scheduleWarmupsAfterSync ?? scheduleListenerWarmupsAfterSync)(listenerRuntime, scope);
 }
 async function recoverPendingChannelControlRequests(listener, opts) {
@@ -464253,7 +464979,7 @@ async function recoverPendingChannelControlRequests(listener, opts) {
   }
   for (const { scope, entries } of entriesByScope.values()) {
     const runtime = getOrCreateScopedRuntime(listener, scope.agent_id, scope.conversation_id);
-    const livePendingRequestIds = new Set(runtime.pendingApprovalResolvers.keys());
+    const livePendingRequestIds = getPendingApprovalRequestIds(runtime);
     const shouldRecoverFromBackend = entries.some((entry) => !livePendingRequestIds.has(entry.event.requestId));
     if (shouldRecoverFromBackend) {
       try {
@@ -464378,7 +465104,7 @@ async function wireChannelIngress(listener, socket, opts, processQueuedTurn) {
     scheduleQueuePump(conversationRuntime, socket, opts, processQueuedTurn);
   });
   registry2.setEventHandler((event2) => {
-    handleChannelRegistryEvent(event2, socket, listener, safeSocketSend);
+    handleChannelRegistryEvent(event2, socket, listener);
   });
   await recoverPendingChannelControlRequests(listener);
   registry2.setApprovalResponseHandler(async ({ runtime, response }) => handleApprovalResponseInput(listener, {
@@ -464643,6 +465369,14 @@ function createRuntime() {
     hasSuccessfulConnection: false,
     everConnected: false,
     sessionId: `listen-${crypto.randomUUID()}`,
+    nextConnectionOrdinal: 0,
+    connections: new Map,
+    connectionIdsByRuntimeKey: new Map,
+    processTransport: null,
+    processServicesStarted: false,
+    processServicesGeneration: 0,
+    processServicesReady: null,
+    processServicesReadyGeneration: null,
     eventSeqCounter: 0,
     queueEmitScheduled: false,
     pendingQueueEmitScope: undefined,
@@ -464660,7 +465394,6 @@ function createRuntime() {
     connectionId: null,
     connectionName: null,
     conversationRuntimes: new Map,
-    approvalRuntimeKeyByRequestId: new Map,
     memfsSyncedAgents: new Map,
     secretsHydrationByAgent: new Map,
     secretsHydrationFreshnessByAgent: new Map,
@@ -464674,9 +465407,8 @@ function stopRuntime(runtime, suppressCallbacks) {
   notifyStreamObserversRuntimeStopped(runtime);
   disposeListenerModAdapter(runtime);
   rejectPendingExternalToolCalls(runtime, "Listener runtime stopped");
-  setMessageQueueAdder(null);
   runtime.intentionallyClosed = true;
-  clearRuntimeTimers(runtime);
+  invalidateProcessServices(runtime);
   for (const conversationRuntime of runtime.conversationRuntimes.values()) {
     rejectPendingApprovalResolvers(conversationRuntime, "Listener runtime stopped");
     clearConversationRuntimeState(conversationRuntime);
@@ -464686,7 +465418,9 @@ function stopRuntime(runtime, suppressCallbacks) {
     }
   }
   runtime.conversationRuntimes.clear();
-  runtime.approvalRuntimeKeyByRequestId.clear();
+  closeListenerRuntimeConnections(runtime, suppressCallbacks);
+  runtime.processServicesReady = null;
+  runtime.processServicesReadyGeneration = null;
   clearListenerWarmState(runtime);
   runtime.reminderStateByConversation.clear();
   runtime.skillSourcesByConversation.clear();
@@ -464694,30 +465428,6 @@ function stopRuntime(runtime, suppressCallbacks) {
   runtime.systemPromptRecompileByConversation.clear();
   runtime.queuedSystemPromptRecompileByConversation.clear();
   stopAllWorktreeWatchers(runtime);
-  if (!runtime.socket) {
-    if (runtime.streamSocket && (runtime.streamSocket.readyState === WebSocket6.OPEN || runtime.streamSocket.readyState === WebSocket6.CONNECTING)) {
-      runtime.streamSocket.close();
-    }
-    runtime.streamSocket = null;
-    runtime.streamTransport = null;
-    runtime.transport = null;
-    return;
-  }
-  const socket = runtime.socket;
-  runtime.socket = null;
-  runtime.transport = null;
-  const streamSocket = runtime.streamSocket;
-  runtime.streamSocket = null;
-  runtime.streamTransport = null;
-  if (suppressCallbacks) {
-    socket.removeAllListeners();
-  }
-  if (socket.readyState === WebSocket6.OPEN || socket.readyState === WebSocket6.CONNECTING) {
-    socket.close();
-  }
-  if (streamSocket && (streamSocket.readyState === WebSocket6.OPEN || streamSocket.readyState === WebSocket6.CONNECTING)) {
-    streamSocket.close();
-  }
 }
 async function startConnectedListenerRuntime(runtime, transport, opts, processQueuedTurn, options3 = {}) {
   if (runtime !== getActiveRuntime() || runtime.intentionallyClosed) {
@@ -464726,103 +465436,88 @@ async function startConnectedListenerRuntime(runtime, transport, opts, processQu
   const shouldStartHeartbeat = options3.startHeartbeat !== false;
   const cronSchedulerDisabledByEnv = process.env.LETTA_DISABLE_CRON_SCHEDULER === "1";
   const shouldStartCronScheduler = options3.startCronScheduler !== false && !cronSchedulerDisabledByEnv;
-  runtime.transport = transport;
-  runtime.streamTransport = options3.streamTransport ?? null;
+  markListenerConnectionInitialized(runtime, opts.connectionId);
   safeEmitWsEvent("recv", "lifecycle", {
     type: getListenerTransportKind(transport) === "websocket" ? "_ws_open" : "_local_open"
   });
   runtime.hasSuccessfulConnection = true;
   runtime.everConnected = true;
   opts.onConnected(opts.connectionId);
-  if (runtime.conversationRuntimes.size === 0) {
-    emitLoopStatusUpdate(transport, runtime);
-  } else {
-    for (const conversationRuntime of runtime.conversationRuntimes.values()) {
-      const scope = {
-        agent_id: conversationRuntime.agentId,
-        conversation_id: conversationRuntime.conversationId
-      };
-      emitDeviceStatusUpdate(transport, conversationRuntime, scope);
-      emitLoopStatusUpdate(transport, conversationRuntime, scope);
-    }
+  emitInitialConnectionState(runtime, transport, opts.connectionId, options3);
+  if (runtime.processServicesStarted) {
+    return;
   }
-  runtime._unsubscribeSubagentState?.();
-  runtime._unsubscribeSubagentState = subscribe(() => {
-    if (runtime.conversationRuntimes.size === 0) {
-      emitSubagentStateIfOpen(runtime);
-      return;
+  if (!await waitForProcessServicesSlot(runtime, opts.connectionId))
+    return;
+  const processServicesGeneration = runtime.processServicesGeneration + 1;
+  runtime.processServicesGeneration = processServicesGeneration;
+  const processServicesReady = (async () => {
+    const processTransport = getOrCreateProcessTransport(runtime);
+    installProcessEventRouting({
+      runtime,
+      processTransport,
+      opts,
+      processQueuedTurn
+    });
+    if (shouldStartHeartbeat) {
+      runtime.lastPongAt = Date.now();
+      runtime.heartbeatInterval = setInterval(() => {
+        if (getListenerTransportKind(transport) === "websocket" && isListenerPongStale(runtime.lastPongAt, Date.now(), LISTENER_PONG_TIMEOUT_MS)) {
+          trackListenerError4("listener_pong_timeout", new Error(`No relay pong within ${LISTENER_PONG_TIMEOUT_MS}ms; terminating half-open socket to force reconnect`), "listener_heartbeat");
+          runtime.socket?.terminate();
+          return;
+        }
+        safeTransportSend(transport, { type: "ping" }, "listener_ping_send_failed", "listener_heartbeat");
+      }, LISTENER_HEARTBEAT_INTERVAL_MS);
     }
-    for (const conversationRuntime of runtime.conversationRuntimes.values()) {
-      emitSubagentStateIfOpen(runtime, {
-        agent_id: conversationRuntime.agentId,
-        conversation_id: conversationRuntime.conversationId
-      });
+    if (shouldStartCronScheduler) {
+      startScheduler(processTransport, opts, processQueuedTurn);
     }
-  });
-  runtime._unsubscribeSubagentStreamEvents?.();
-  runtime._unsubscribeSubagentStreamEvents = subscribeToStreamEvents((subagentId, event2) => {
-    if (!isListenerTransportOpen(transport))
-      return;
-    const subagent = getSubagents().find((entry) => entry.id === subagentId);
-    if (subagent?.silent === true) {
-      return;
+    await (options3.wireChannelIngress ?? wireChannelIngress)(runtime, processTransport, opts, processQueuedTurn);
+    if (runtime.processServicesGeneration === processServicesGeneration) {
+      runtime.processServicesStarted = true;
     }
-    emitStreamDelta(transport, runtime, event2, subagent?.parentAgentId ? {
-      agent_id: subagent.parentAgentId,
-      conversation_id: subagent.parentConversationId ?? "default"
-    } : undefined, subagentId);
-  });
-  setMessageQueueAdder((queuedMessage) => {
-    const targetRuntime = queuedMessage.agentId && queuedMessage.conversationId ? getOrCreateScopedRuntime(runtime, queuedMessage.agentId, queuedMessage.conversationId) : findFallbackRuntime(runtime);
-    if (!targetRuntime?.queueRuntime) {
+  })();
+  runtime.processServicesReady = processServicesReady;
+  runtime.processServicesReadyGeneration = processServicesGeneration;
+  try {
+    await processServicesReady;
+  } catch (error54) {
+    if (runtime.processServicesGeneration !== processServicesGeneration)
       return;
+    clearProcessServices(runtime);
+    throw error54;
+  } finally {
+    if (runtime.processServicesReady === processServicesReady) {
+      runtime.processServicesReady = null;
+      runtime.processServicesReadyGeneration = null;
     }
-    targetRuntime.queueRuntime.enqueue({
-      kind: "task_notification",
-      source: "task_notification",
-      text: queuedMessage.text,
-      agentId: queuedMessage.agentId ?? targetRuntime.agentId ?? undefined,
-      conversationId: queuedMessage.conversationId ?? targetRuntime.conversationId
-    });
-    scheduleQueuePump(targetRuntime, transport, opts, processQueuedTurn);
-  });
-  if (shouldStartHeartbeat) {
-    runtime.lastPongAt = Date.now();
-    runtime.heartbeatInterval = setInterval(() => {
-      if (getListenerTransportKind(transport) === "websocket" && isListenerPongStale(runtime.lastPongAt, Date.now(), LISTENER_PONG_TIMEOUT_MS)) {
-        trackListenerError4("listener_pong_timeout", new Error(`No relay pong within ${LISTENER_PONG_TIMEOUT_MS}ms; terminating half-open socket to force reconnect`), "listener_heartbeat");
-        runtime.socket?.terminate();
-        return;
-      }
-      safeTransportSend(transport, { type: "ping" }, "listener_ping_send_failed", "listener_heartbeat");
-    }, LISTENER_HEARTBEAT_INTERVAL_MS);
   }
-  if (shouldStartCronScheduler) {
-    startScheduler(transport, opts, processQueuedTurn);
-  }
-  await wireChannelIngress(runtime, transport, opts, processQueuedTurn);
 }
 async function attachOpenListenerSocket(runtime, socket, opts, options3 = {}) {
   if (runtime !== getActiveRuntime() || runtime.intentionallyClosed) {
     return;
   }
   const streamSocket = options3.streamSocket ?? null;
+  const connection = openListenerConnection({
+    runtime,
+    connectionId: opts.connectionId,
+    writer: socket,
+    streamWriter: streamSocket,
+    options: opts
+  });
   const fileCommandSession = createFileCommandSession({
     socket,
     safeSocketSend,
     runDetachedListenerTask
   });
-  runtime.socket = socket;
-  runtime.streamSocket = streamSocket;
   installExternalToolBridge(runtime);
   const transport = socket;
-  const processQueuedTurn = async (queuedTurn, dequeuedBatch) => {
-    const scopedRuntime = getOrCreateScopedRuntime(runtime, queuedTurn.agentId, queuedTurn.conversationId);
-    await handleIncomingMessage(queuedTurn, transport, scopedRuntime, opts.onStatusChange, opts.connectionId, dequeuedBatch.batchId);
-  };
+  const processQueuedTurn = createConnectionTurnProcessor(runtime);
   const handleMessage = createListenerMessageHandler({
     runtime,
     socket,
+    connectionId: opts.connectionId,
     opts,
     processQueuedTurn,
     fileCommandSession,
@@ -464841,6 +465536,9 @@ async function attachOpenListenerSocket(runtime, socket, opts, options3 = {}) {
   socket.on("message", (data) => {
     (async () => {
       await options3.startupReady;
+      if (connection.cancellation.signal.aborted || runtime.connections.get(opts.connectionId) !== connection) {
+        return;
+      }
       await handleMessage(data);
     })().catch((error54) => {
       trackListenerError4("listener_message_handler_failed", error54, "listener_message_handler");
@@ -464858,12 +465556,7 @@ async function attachOpenListenerSocket(runtime, socket, opts, options3 = {}) {
       reason: reasonText
     });
     fileCommandSession.dispose();
-    stopScheduler();
-    getChannelRegistry()?.pause();
-    stopRuntime(runtime, true);
-    if (getActiveRuntime() === runtime) {
-      setActiveRuntime(null);
-    }
+    cleanupListenerConnection(runtime, opts.connectionId);
     opts.onDisconnected();
   });
   socket.on("error", (error54) => {
@@ -464891,11 +465584,15 @@ async function attachOpenListenerSocket(runtime, socket, opts, options3 = {}) {
     });
   }
   await options3.startupReady;
+  if (connection.cancellation.signal.aborted || runtime.connections.get(opts.connectionId) !== connection) {
+    return;
+  }
   const streamTransport = streamSocket?.readyState === WebSocket6.OPEN ? streamSocket : null;
   await startConnectedListenerRuntime(runtime, transport, opts, processQueuedTurn, {
     startHeartbeat: options3.startHeartbeat ?? false,
     startCronScheduler: options3.startCronScheduler ?? true,
-    streamTransport
+    streamTransport,
+    emitInitialState: false
   });
 }
 async function startListenerClient(opts) {
@@ -464929,10 +465626,18 @@ async function startLocalChannelListener(opts) {
     await reloadListenerModAdapter(runtime);
     await loadTools();
     const transport = new LocalListenerTransport;
-    const processQueuedTurn = async (queuedTurn, dequeuedBatch) => {
-      const scopedRuntime = getOrCreateScopedRuntime(runtime, queuedTurn.agentId, queuedTurn.conversationId);
-      await handleIncomingMessage(queuedTurn, transport, scopedRuntime, opts.onStatusChange, opts.connectionId, dequeuedBatch.batchId);
+    const connectionOptions = {
+      ...opts,
+      wsUrl: "local://listener",
+      onDisconnected: () => {}
     };
+    openListenerConnection({
+      runtime,
+      connectionId: opts.connectionId,
+      writer: transport,
+      options: connectionOptions
+    });
+    const processQueuedTurn = createConnectionTurnProcessor(runtime);
     await startConnectedListenerRuntime(runtime, transport, opts, processQueuedTurn, { startHeartbeat: false, startCronScheduler: true });
   } catch (error54) {
     stopRuntime(runtime, true);
@@ -465010,15 +465715,19 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
   runtime.socket = socket;
   runtime.streamSocket = streamSocket;
   const transport = socket;
-  const processQueuedTurn = async (queuedTurn, dequeuedBatch) => {
-    const scopedRuntime = getOrCreateScopedRuntime(runtime, queuedTurn.agentId, queuedTurn.conversationId);
-    await handleIncomingMessage(queuedTurn, transport, scopedRuntime, opts.onStatusChange, opts.connectionId, dequeuedBatch.batchId);
-  };
+  const processQueuedTurn = createConnectionTurnProcessor(runtime);
   socket.on("open", async () => {
     let streamTransport = null;
     if (streamSocket) {
       streamTransport = await waitForStreamSocketOpen(streamSocket, runtime);
     }
+    openListenerConnection({
+      runtime,
+      connectionId: opts.connectionId,
+      writer: socket,
+      streamWriter: streamTransport,
+      options: opts
+    });
     await startConnectedListenerRuntime(runtime, transport, opts, processQueuedTurn, {
       startHeartbeat: true,
       startCronScheduler: true,
@@ -465028,6 +465737,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
   socket.on("message", createListenerMessageHandler({
     runtime,
     socket,
+    connectionId: opts.connectionId,
     opts,
     processQueuedTurn,
     fileCommandSession,
@@ -465053,12 +465763,11 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       reason: reason.toString()
     });
     fileCommandSession.dispose();
-    stopScheduler();
+    invalidateProcessServices(runtime);
     const channelRegistry = getChannelRegistry();
     if (channelRegistry) {
       channelRegistry.pause();
     }
-    setMessageQueueAdder(null);
     for (const conversationRuntime of runtime.conversationRuntimes.values()) {
       conversationRuntime.queuedMessagesByItemId.clear();
       if (conversationRuntime.queueRuntime) {
@@ -465068,12 +465777,8 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
     if (isDebugEnabled()) {
       console.log(`[Listen] WebSocket disconnected (code: ${code2}, reason: ${reason.toString()})`);
     }
-    clearRuntimeTimers(runtime);
+    suspendListenerConnection(runtime, opts.connectionId);
     killAllTerminals();
-    runtime._unsubscribeSubagentState?.();
-    runtime._unsubscribeSubagentState = undefined;
-    runtime._unsubscribeSubagentStreamEvents?.();
-    runtime._unsubscribeSubagentStreamEvents = undefined;
     clearListenerWarmState(runtime);
     if (streamSocket) {
       streamSocket.removeAllListeners();
@@ -465150,7 +465855,6 @@ function stopListenerClient() {
   stopRuntime(runtime, true);
 }
 var init_lifecycle = __esm(async () => {
-  init_subagent_state();
   init_commands();
   init_progress_builder();
   init_registry();
@@ -465160,10 +465864,10 @@ var init_lifecycle = __esm(async () => {
   init_telemetry();
   init_error_reporting();
   init_debug();
-  init_message_queue_bridge();
   init_terminal_handler();
   init_auth();
   init_channel_turn_session();
+  init_connection();
   init_constants3();
   init_cwd();
   init_permission_mode();
@@ -465174,18 +465878,20 @@ var init_lifecycle = __esm(async () => {
     init_manager4(),
     init_approval(),
     init_commands2(),
-    init_channels2(),
+    init_channel_registry_events(),
     init_model_toolset(),
+    init_connection_lifecycle(),
+    init_connection_state_sync(),
     init_control_inputs(),
     init_conversation_runtime(),
     init_external_tools(),
     init_file_commands(),
     init_message_router(),
     init_mod_adapter2(),
+    init_process_services(),
     init_protocol_outbound(),
     init_queue(),
     init_recovery(),
-    init_turn(),
     init_turn_events(),
     init_warmup(),
     init_worktree_watcher()
@@ -465273,6 +465979,60 @@ function createLegacyTestRuntime() {
         listener.sessionId = value;
       }
     },
+    nextConnectionOrdinal: {
+      get: () => listener.nextConnectionOrdinal,
+      set: (value) => {
+        listener.nextConnectionOrdinal = value;
+      }
+    },
+    connections: {
+      get: () => listener.connections,
+      set: (value) => {
+        listener.connections = value;
+      }
+    },
+    connectionIdsByRuntimeKey: {
+      get: () => listener.connectionIdsByRuntimeKey,
+      set: (value) => {
+        listener.connectionIdsByRuntimeKey = value;
+      }
+    },
+    processTransport: {
+      get: () => listener.processTransport,
+      set: (value) => {
+        listener.processTransport = value;
+      }
+    },
+    processServicesStarted: {
+      get: () => listener.processServicesStarted,
+      set: (value) => {
+        listener.processServicesStarted = value;
+      }
+    },
+    processServicesGeneration: {
+      get: () => listener.processServicesGeneration,
+      set: (value) => {
+        listener.processServicesGeneration = value;
+      }
+    },
+    processServicesReady: {
+      get: () => listener.processServicesReady,
+      set: (value) => {
+        listener.processServicesReady = value;
+      }
+    },
+    processServicesReadyGeneration: {
+      get: () => listener.processServicesReadyGeneration,
+      set: (value) => {
+        listener.processServicesReadyGeneration = value;
+      }
+    },
+    pendingExternalToolCalls: {
+      get: () => listener.pendingExternalToolCalls,
+      set: (value) => {
+        listener.pendingExternalToolCalls = value;
+      }
+    },
     eventSeqCounter: {
       get: () => listener.eventSeqCounter,
       set: (value) => {
@@ -465345,12 +466105,6 @@ function createLegacyTestRuntime() {
         listener.conversationRuntimes = value;
       }
     },
-    approvalRuntimeKeyByRequestId: {
-      get: () => listener.approvalRuntimeKeyByRequestId,
-      set: (value) => {
-        listener.approvalRuntimeKeyByRequestId = value;
-      }
-    },
     memfsSyncedAgents: {
       get: () => listener.memfsSyncedAgents,
       set: (value) => {
@@ -465423,6 +466177,7 @@ var init_client7 = __esm(async () => {
   await __promiseAll([
     init_approval(),
     init_agents_conversations(),
+    init_channel_registry_events(),
     init_channels2(),
     init_cron3(),
     init_memory6(),
@@ -465499,7 +466254,7 @@ var init_client7 = __esm(async () => {
     handleListMemoryCommand: (parsed, socket, overrides) => handleListMemoryCommand(parsed, socket, safeSocketSend, overrides),
     isDetachedChannelsCommand,
     handleChannelsProtocolCommand: (parsed, socket, runtime, opts, processQueuedTurn) => handleChannelsProtocolCommand(parsed, socket, runtime, opts, processQueuedTurn, runDetachedListenerTask, wireChannelIngress, safeSocketSend),
-    handleChannelRegistryEvent: (event2, socket, runtime) => handleChannelRegistryEvent(event2, socket, runtime, safeSocketSend),
+    handleChannelRegistryEvent: (event2, socket, runtime) => handleChannelRegistryEvent(event2, socket, runtime),
     handleAgentConversationManagementCommand: (parsed, socket) => handleAgentConversationManagementCommand(parsed, socket, safeSocketSend),
     handleAgentConversationManagementProtocolCommand: (parsed, socket) => handleAgentConversationManagementProtocolCommand(parsed, {
       socket,
@@ -465508,6 +466263,7 @@ var init_client7 = __esm(async () => {
     }),
     handleRuntimeStartCommand: (parsed, socket, runtime) => handleRuntimeStartCommand(parsed, {
       socket,
+      connectionId: runtime.connectionId ?? "test-connection",
       runtime,
       safeSocketSend,
       runDetachedListenerTask,
@@ -465519,6 +466275,7 @@ var init_client7 = __esm(async () => {
     }),
     handleRuntimeStartProtocolCommand: (parsed, socket, runtime) => handleRuntimeStartProtocolCommand(parsed, {
       socket,
+      connectionId: runtime.connectionId ?? "test-connection",
       runtime,
       safeSocketSend,
       runDetachedListenerTask,
@@ -466121,7 +466878,7 @@ var init_listen = __esm(async () => {
 import { randomUUID as randomUUID26 } from "node:crypto";
 import {
   copyFileSync as copyFileSync3,
-  existsSync as existsSync52,
+  existsSync as existsSync53,
   mkdirSync as mkdirSync38,
   readdirSync as readdirSync20,
   readFileSync as readFileSync34,
@@ -466129,7 +466886,7 @@ import {
 } from "node:fs";
 import { join as join67 } from "node:path";
 function readJsonl(path41) {
-  if (!existsSync52(path41))
+  if (!existsSync53(path41))
     return [];
   return readFileSync34(path41, "utf8").split(`
 `).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
@@ -466417,13 +467174,13 @@ function migrateLocalBackendTranscripts(input) {
     skipped: [],
     dryRun: input.dryRun === true
   };
-  if (!existsSync52(conversationsDir))
+  if (!existsSync53(conversationsDir))
     return result;
   for (const name of readdirSync20(conversationsDir)) {
     const conversationDir = join67(conversationsDir, name);
     const messagesPath = join67(conversationDir, "messages.jsonl");
     const manifestPath = join67(conversationDir, "manifest.json");
-    const hasManifest = existsSync52(manifestPath);
+    const hasManifest = existsSync53(manifestPath);
     const existingManifest = hasManifest ? (() => {
       try {
         return JSON.parse(readFileSync34(manifestPath, "utf8"));
@@ -466467,7 +467224,7 @@ function migrateLocalBackendTranscripts(input) {
       copyFileSync3(messagesPath, backupPath);
       const conversationPath = join67(conversationDir, "conversation.json");
       let conversation;
-      if (existsSync52(conversationPath)) {
+      if (existsSync53(conversationPath)) {
         try {
           conversation = JSON.parse(readFileSync34(conversationPath, "utf8"));
         } catch {
@@ -466661,7 +467418,7 @@ var init_memory_tokens = __esm(() => {
 });
 
 // src/cli/subcommands/memory.ts
-import { cpSync, existsSync as existsSync53, mkdirSync as mkdirSync39, rmSync as rmSync12, statSync as statSync17 } from "node:fs";
+import { cpSync, existsSync as existsSync54, mkdirSync as mkdirSync39, rmSync as rmSync12, statSync as statSync17 } from "node:fs";
 import { readdir as readdir13 } from "node:fs/promises";
 import { dirname as dirname30, join as join68 } from "node:path";
 import { parseArgs as parseArgs10 } from "node:util";
@@ -466723,7 +467480,7 @@ function formatBackupTimestamp(date6 = new Date) {
 }
 async function listBackups(agentId) {
   const agentRoot = getAgentRoot(agentId);
-  if (!existsSync53(agentRoot)) {
+  if (!existsSync54(agentRoot)) {
     return [];
   }
   const entries = await readdir13(agentRoot, { withFileTypes: true });
@@ -466826,14 +467583,14 @@ async function runMemorySubcommand(argv) {
     }
     if (action3 === "backup") {
       const root2 = getMemoryRoot(agentId);
-      if (!existsSync53(root2)) {
+      if (!existsSync54(root2)) {
         console.error(`Memory directory not found for agent ${agentId}.`);
         return 1;
       }
       const agentRoot = getAgentRoot(agentId);
       const backupName = `memory-backup-${formatBackupTimestamp()}`;
       const backupPath = join68(agentRoot, backupName);
-      if (existsSync53(backupPath)) {
+      if (existsSync54(backupPath)) {
         console.error(`Backup already exists at ${backupPath}`);
         return 1;
       }
@@ -466857,7 +467614,7 @@ async function runMemorySubcommand(argv) {
         return 1;
       }
       const backupPath = resolveBackupPath(agentId, from);
-      if (!existsSync53(backupPath)) {
+      if (!existsSync54(backupPath)) {
         console.error(`Backup not found: ${backupPath}`);
         return 1;
       }
@@ -466879,11 +467636,11 @@ async function runMemorySubcommand(argv) {
         return 1;
       }
       const root2 = getMemoryRoot(agentId);
-      if (!existsSync53(root2)) {
+      if (!existsSync54(root2)) {
         console.error(`Memory directory not found for agent ${agentId}.`);
         return 1;
       }
-      if (existsSync53(out)) {
+      if (existsSync54(out)) {
         const stat15 = statSync17(out);
         if (stat15.isDirectory()) {
           const contents = await readdir13(out);
@@ -466931,10 +467688,10 @@ var init_memory7 = __esm(() => {
 });
 
 // src/backend/local/transcript-search.ts
-import { existsSync as existsSync54, readdirSync as readdirSync21, readFileSync as readFileSync35, statSync as statSync18 } from "node:fs";
+import { existsSync as existsSync55, readdirSync as readdirSync21, readFileSync as readFileSync35, statSync as statSync18 } from "node:fs";
 import { join as join69 } from "node:path";
 function readJsonFile3(path41) {
-  if (!existsSync54(path41))
+  if (!existsSync55(path41))
     return;
   try {
     return JSON.parse(readFileSync35(path41, "utf8"));
@@ -466943,7 +467700,7 @@ function readJsonFile3(path41) {
   }
 }
 function readJsonlFile2(path41) {
-  if (!existsSync54(path41))
+  if (!existsSync55(path41))
     return [];
   try {
     return readFileSync35(path41, "utf8").split(`
@@ -467179,7 +467936,7 @@ function collectConversationMessages(input) {
 }
 function conversationDirectories(storageDir) {
   const conversationsDir = join69(storageDir, "conversations");
-  if (!existsSync54(conversationsDir))
+  if (!existsSync55(conversationsDir))
     return [];
   try {
     return readdirSync21(conversationsDir).map((entry) => join69(conversationsDir, entry)).filter((entryPath) => statSync18(entryPath).isDirectory());
@@ -467648,7 +468405,7 @@ import {
 } from "node:child_process";
 import {
   copyFileSync as copyFileSync4,
-  existsSync as existsSync55,
+  existsSync as existsSync56,
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync40,
   mkdtempSync as mkdtempSync3,
@@ -467857,7 +468614,7 @@ function copyDependencyDirectoryFiltered(params) {
   return copied;
 }
 function copyDependencyNodeModules(params) {
-  if (!existsSync55(params.sourceNodeModulesDirectory))
+  if (!existsSync56(params.sourceNodeModulesDirectory))
     return;
   copyDependencyDirectoryFiltered({
     installedPackageName: params.installedPackageName,
@@ -467867,7 +468624,7 @@ function copyDependencyNodeModules(params) {
 }
 function copyPackageInternalNodeModules(params) {
   const sourceNodeModulesDirectory = path41.join(params.packageDirectory, "node_modules");
-  if (!existsSync55(sourceNodeModulesDirectory))
+  if (!existsSync56(sourceNodeModulesDirectory))
     return;
   copyDependencyDirectoryFiltered({
     sourceRoot: sourceNodeModulesDirectory,
@@ -467889,12 +468646,12 @@ function removeIfExists(targetPath) {
 }
 function restoreDestination(params) {
   rmSync13(params.destinationRoot, { force: true, recursive: true });
-  if (params.backupRoot && existsSync55(params.backupRoot)) {
+  if (params.backupRoot && existsSync56(params.backupRoot)) {
     renameSync6(params.backupRoot, params.destinationRoot);
   }
 }
 function restoreDestinationIfNeeded(params) {
-  if (!params.backupRoot || !existsSync55(params.backupRoot)) {
+  if (!params.backupRoot || !existsSync56(params.backupRoot)) {
     rmSync13(params.destinationRoot, { force: true, recursive: true });
     return;
   }
@@ -467935,7 +468692,7 @@ function installPreparedManagedModPackage(params) {
         targetPackageRoot: stagingRoot
       });
     }
-    if (existsSync55(destinationRoot)) {
+    if (existsSync56(destinationRoot)) {
       backupRoot = makeSiblingTempDirectory(destinationRoot, "backup");
       rmSync13(backupRoot, { force: true, recursive: true });
       renameSync6(destinationRoot, backupRoot);
@@ -468218,7 +468975,7 @@ function hasRuntimeDependencies(packageJson) {
 }
 function readPackageJsonIfExists(packageDirectory) {
   const packageJsonPath = path41.join(packageDirectory, "package.json");
-  if (!existsSync55(packageJsonPath))
+  if (!existsSync56(packageJsonPath))
     return null;
   return readPackageJson(packageJsonPath);
 }
@@ -468232,7 +468989,7 @@ function isRegularModFile(filePath) {
 }
 function inferCompatibilityModEntries(packageDirectory) {
   const modsDirectory = path41.join(packageDirectory, "mods");
-  if (existsSync55(modsDirectory)) {
+  if (existsSync56(modsDirectory)) {
     const stats = lstatSync3(modsDirectory);
     if (stats.isSymbolicLink()) {
       throw new Error(`Package mods directory must not be a symlink: mods`);
@@ -468507,7 +469264,7 @@ var init_package_installer = __esm(() => {
 // src/mods/package-scaffolder.ts
 import {
   copyFileSync as copyFileSync5,
-  existsSync as existsSync56,
+  existsSync as existsSync57,
   lstatSync as lstatSync4,
   mkdirSync as mkdirSync41,
   rmSync as rmSync14,
@@ -468600,7 +469357,7 @@ function scaffoldLocalModPackage(options3) {
   const sourceFile = readSourceFile(options3.sourceFile);
   const packageName = assertValidPackageName(options3.packageName);
   const outputDirectory = path42.resolve(options3.outputDirectory ?? defaultOutputDirectory(sourceFile, packageName));
-  if (existsSync56(outputDirectory)) {
+  if (existsSync57(outputDirectory)) {
     throw new Error(`Output directory already exists: ${outputDirectory}`);
   }
   const modFileName = path42.basename(sourceFile);
@@ -469311,7 +470068,7 @@ async function runTurnViaListenerRuntime(params) {
   const listener = await ensureListenerRuntime(params.onLog);
   const scopedRuntime = getOrCreateScopedRuntime(listener, params.agentId, params.conversationId);
   getOrCreateConversationPermissionModeStateRef(listener, params.agentId, params.conversationId).mode = "unrestricted";
-  const socket = listener.socket ?? listener.transport ?? bridgeTransport;
+  const socket = getOrCreateProcessTransport(listener);
   const dispatchOptions = {
     connectionId: listener.connectionId ?? "openai-api",
     wsUrl: "",
@@ -469323,10 +470080,7 @@ async function runTurnViaListenerRuntime(params) {
       params.onLog?.(`OpenAI-compat turn error: ${error54.message}`);
     }
   };
-  const processQueuedTurn = async (queuedTurn, dequeuedBatch) => {
-    const queuedScope = getOrCreateScopedRuntime(listener, queuedTurn.agentId, queuedTurn.conversationId);
-    await handleIncomingMessage(queuedTurn, socket, queuedScope, undefined, dispatchOptions.connectionId, dequeuedBatch.batchId);
-  };
+  const processQueuedTurn = createConnectionTurnProcessor(listener);
   return await new Promise((resolve32) => {
     let text2 = "";
     let usage = {
@@ -469437,7 +470191,7 @@ async function runTurnViaListenerRuntime(params) {
         socket,
         options: dispatchOptions,
         processQueuedTurn,
-        processIncomingMessage: handleIncomingMessage,
+        processIncomingMessage: (incoming2, incomingSocket, incomingRuntime, onStatusChange, _connectionId, batchId) => handleIncomingMessage(incoming2, incomingSocket, incomingRuntime, onStatusChange, undefined, batchId),
         trackListenerError: (errorType, error54) => {
           params.onLog?.(`OpenAI-compat listener error (${errorType}): ${error54 instanceof Error ? error54.message : String(error54)}`);
         }
@@ -469447,14 +470201,15 @@ async function runTurnViaListenerRuntime(params) {
     }
   });
 }
-var runTurnImpl, OPENAI_TURN_TIMEOUT_MS, bridgeTransport, bridgeRuntimeStart = null, bridgeOwnedRuntime = null;
+var runTurnImpl, OPENAI_TURN_TIMEOUT_MS, bridgeRuntimeStart = null, bridgeOwnedRuntime = null;
 var init_app_server_openai_turn = __esm(async () => {
   init_settings_manager();
+  init_connection();
   init_permission_mode();
   init_runtime6();
-  init_transport();
   init_turn_observers();
   await __promiseAll([
+    init_connection_lifecycle(),
     init_conversation_runtime(),
     init_inbound_dispatch(),
     init_lifecycle(),
@@ -469462,7 +470217,6 @@ var init_app_server_openai_turn = __esm(async () => {
   ]);
   runTurnImpl = runTurnViaListenerRuntime;
   OPENAI_TURN_TIMEOUT_MS = 15 * 60 * 1000;
-  bridgeTransport = new LocalListenerTransport;
 });
 
 // src/websocket/app-server-openai.ts
@@ -469470,7 +470224,7 @@ import { randomUUID as randomUUID28 } from "node:crypto";
 function isOpenAiCompatPath(pathname) {
   return pathname === MODELS_PATH || pathname === CHAT_COMPLETIONS_PATH;
 }
-function sendJson2(response, statusCode2, body3) {
+function sendJson(response, statusCode2, body3) {
   const payload = JSON.stringify(body3);
   response.writeHead(statusCode2, {
     "content-type": "application/json",
@@ -469479,7 +470233,7 @@ function sendJson2(response, statusCode2, body3) {
   response.end(payload);
 }
 function sendOpenAiError(response, statusCode2, message, type3, code2 = null) {
-  sendJson2(response, statusCode2, {
+  sendJson(response, statusCode2, {
     error: { message, type: type3, param: null, code: code2 }
   });
 }
@@ -469608,7 +470362,7 @@ async function handleListModels(response) {
     created: toModelCreatedTimestamp(agent2.created_at),
     owned_by: "letta"
   }));
-  sendJson2(response, 200, { object: "list", data });
+  sendJson(response, 200, { object: "list", data });
 }
 async function resolveAgentForModel(model) {
   const agents = await listAgentEntries();
@@ -469886,7 +470640,7 @@ async function handleChatCompletions(request, response, options3) {
     sendOpenAiError(response, 500, streamError, "server_error");
     return;
   }
-  sendJson2(response, 200, {
+  sendJson(response, 200, {
     id: completionId,
     object: "chat.completion",
     created,
@@ -469956,10 +470710,9 @@ function getRequiredAddressInfo(server2) {
   }
   return address;
 }
-function getChannelUrl(baseUrl, path43, channel) {
+function getWebSocketUrl(baseUrl, path43) {
   const url2 = new URL(baseUrl);
   url2.pathname = path43;
-  url2.searchParams.set("channel", channel);
   return url2.toString();
 }
 function closeSocket(socket, code2 = 1001, reason = "closing") {
@@ -469984,35 +470737,6 @@ Content-Length: 0\r
 function getRequestUrl(request, host) {
   return new URL(request.url ?? "/", `http://${request.headers.host ?? host}`);
 }
-function getRequestChannel(url2) {
-  const channel = url2.searchParams.get("channel");
-  if (channel === null || channel === "" || channel === "control") {
-    return "control";
-  }
-  if (channel === "stream") {
-    return "stream";
-  }
-  return null;
-}
-function attachStreamSocket(activeSession, socket) {
-  if (activeSession.streamSocket) {
-    closeSocket(socket, 1008, "stream channel already connected");
-    return;
-  }
-  activeSession.streamSocket = socket;
-  activeSession.runtime.streamSocket = socket;
-  activeSession.runtime.streamTransport = socket;
-  socket.on("close", () => {
-    if (activeSession.streamSocket === socket) {
-      activeSession.streamSocket = null;
-    }
-    if (activeSession.runtime.streamSocket === socket) {
-      activeSession.runtime.streamSocket = null;
-      activeSession.runtime.streamTransport = null;
-      terminateSocket(activeSession.controlSocket);
-    }
-  });
-}
 function parseAppServerListenUrl(listen = DEFAULT_LISTEN_URL) {
   let url2;
   try {
@@ -470033,46 +470757,6 @@ function parseAppServerListenUrl(listen = DEFAULT_LISTEN_URL) {
   const path43 = url2.pathname === "/" ? DEFAULT_WS_PATH : url2.pathname;
   return { host: normalizeListenHost(url2.hostname), port, path: path43 };
 }
-async function startControlSession(params) {
-  const existingRuntime = getActiveRuntime();
-  if (existingRuntime) {
-    stopRuntime(existingRuntime, true);
-    setActiveRuntime(null);
-  }
-  const runtime = createRuntime();
-  runtime.onWsEvent = undefined;
-  runtime.connectionId = `app-server-${crypto.randomUUID()}`;
-  runtime.connectionName = params.connectionName;
-  setActiveRuntime(runtime);
-  telemetry.setSurface(getListenerTelemetrySurface());
-  telemetry.init();
-  const startupReady = (async () => {
-    await reloadListenerModAdapter(runtime);
-    await loadTools();
-  })();
-  const activeSession = {
-    runtime,
-    controlSocket: params.socket,
-    streamSocket: params.streamSocket
-  };
-  params.onSessionCreated(activeSession);
-  await attachOpenListenerSocket(runtime, params.socket, {
-    connectionId: runtime.connectionId ?? "app-server",
-    wsUrl: params.serverUrl,
-    supportsSplitStatusChannels: true,
-    deviceId: settingsManager.getOrCreateDeviceId(),
-    connectionName: params.connectionName,
-    onConnected: () => {},
-    onDisconnected: params.onSessionClosed,
-    onError: () => {}
-  }, {
-    streamSocket: params.streamSocket,
-    startHeartbeat: false,
-    startCronScheduler: true,
-    startupReady
-  });
-  return activeSession;
-}
 async function startAppServer(options3 = {}) {
   await settingsManager.initialize();
   const listen = parseAppServerListenUrl(options3.listen);
@@ -470081,72 +470765,60 @@ async function startAppServer(options3 = {}) {
     throw new Error(`refusing to start non-loopback websocket listener ${listen.host}:${listen.port} without auth; configure \`--ws-auth capability-token\` or \`--ws-auth signed-bearer-token\``);
   }
   const wss = new WebSocketServer({ noServer: true });
-  let activeSession = null;
-  let pendingStreamSocket = null;
-  let pendingStreamTimeout = null;
   let resolvedInfo = null;
-  const lastPongAtBySocket = new WeakMap;
-  const clearPendingStream = () => {
-    if (pendingStreamTimeout) {
-      clearTimeout(pendingStreamTimeout);
-      pendingStreamTimeout = null;
+  let nextConnectionOrdinal = 0;
+  const runtime = createRuntime();
+  runtime.onWsEvent = undefined;
+  runtime.connectionId = "app-server";
+  runtime.connectionName = options3.connectionName ?? hostname6();
+  let startupReady = null;
+  const getStartupReady = () => {
+    if (startupReady) {
+      return startupReady;
     }
-    const socket = pendingStreamSocket;
-    pendingStreamSocket = null;
-    return socket;
+    const attempt = (async () => {
+      if (options3.initializeRuntime) {
+        await options3.initializeRuntime(runtime);
+        return;
+      }
+      await reloadListenerModAdapter(runtime);
+      await loadTools();
+    })();
+    startupReady = attempt;
+    attempt.catch(() => {
+      if (startupReady === attempt) {
+        startupReady = null;
+      }
+    });
+    return startupReady;
   };
-  const handleWebSocketConnection = (socket, channel) => {
+  const lastPongAtBySocket = new WeakMap;
+  const handleWebSocketConnection = (socket) => {
+    const connectionId = `app-server-${nextConnectionOrdinal}`;
+    nextConnectionOrdinal += 1;
     lastPongAtBySocket.set(socket, Date.now());
     socket.on("pong", () => {
-      lastPongAtBySocket.set(socket, Date.now());
-    });
-    if (channel === "stream") {
-      if (activeSession) {
-        attachStreamSocket(activeSession, socket);
-        return;
-      }
-      if (pendingStreamSocket) {
-        closeSocket(socket, 1008, "stream channel already pending");
-        return;
+      if (options3.shouldRecordPong?.(connectionId) !== false) {
+        lastPongAtBySocket.set(socket, Date.now());
       }
-      pendingStreamSocket = socket;
-      pendingStreamTimeout = setTimeout(() => {
-        const staleSocket = clearPendingStream();
-        closeSocket(staleSocket, 1008, "control channel did not connect");
-      }, PENDING_STREAM_TIMEOUT_MS);
-      socket.on("close", () => {
-        if (pendingStreamSocket === socket) {
-          clearPendingStream();
-        }
-      });
-      socket.on("error", (error54) => {
-        options3.onLog?.(`App-server stream socket error: ${error54.message}`);
-      });
-      return;
-    }
-    if (activeSession) {
-      closeSocket(socket, 1008, "control channel already connected");
-      return;
-    }
-    const streamSocket = clearPendingStream();
-    startControlSession({
-      socket,
-      streamSocket,
+    });
+    attachOpenListenerSocket(runtime, socket, {
+      connectionId,
+      wsUrl: resolvedInfo?.url ?? options3.listen ?? DEFAULT_LISTEN_URL,
+      deviceId: settingsManager.getOrCreateDeviceId(),
       connectionName: options3.connectionName ?? hostname6(),
-      serverUrl: resolvedInfo?.url ?? options3.listen ?? DEFAULT_LISTEN_URL,
-      onSessionCreated: (session) => {
-        activeSession = session;
-      },
-      onSessionClosed: () => {
-        activeSession = null;
+      onConnected: () => {},
+      onDisconnected: () => {},
+      onError: (error54) => {
+        options3.onLog?.(`App-server connection ${connectionId} failed: ${error54.message}`);
       }
+    }, {
+      startHeartbeat: false,
+      startCronScheduler: true,
+      startupReady: getStartupReady()
     }).catch((error54) => {
-      if (activeSession?.controlSocket === socket) {
-        activeSession = null;
-      }
-      options3.onLog?.(`Failed to start app-server session: ${error54 instanceof Error ? error54.message : String(error54)}`);
-      closeSocket(socket, 1011, "failed to start session");
-      closeSocket(streamSocket, 1011, "failed to start session");
+      options3.onLog?.(`Failed to start app-server connection: ${error54 instanceof Error ? error54.message : String(error54)}`);
+      closeSocket(socket, 1011, "failed to start connection");
     });
   };
   const server2 = createServer((request, response) => {
@@ -470198,9 +470870,9 @@ async function startAppServer(options3 = {}) {
       rejectUpgrade(socket, 404, "Not Found");
       return;
     }
-    const channel = getRequestChannel(requestUrl);
-    if (!channel) {
-      rejectUpgrade(socket, 400, "Bad Request");
+    if (requestUrl.searchParams.has("channel")) {
+      options3.onLog?.("Rejecting legacy split-channel app-server client; upgrade to a one-socket client");
+      rejectUpgrade(socket, 426, "Upgrade Required");
       return;
     }
     const authError = authorizeUpgrade(request.headers, authPolicy);
@@ -470215,7 +470887,7 @@ async function startAppServer(options3 = {}) {
       return;
     }
     wss.handleUpgrade(request, socket, head2, (websocket) => {
-      handleWebSocketConnection(websocket, channel);
+      handleWebSocketConnection(websocket);
     });
   });
   const heartbeatIntervalMs = options3.heartbeatIntervalMs ?? APP_SERVER_HEARTBEAT_INTERVAL_MS;
@@ -470238,25 +470910,38 @@ async function startAppServer(options3 = {}) {
   wss.on("close", () => {
     clearInterval(heartbeatInterval);
   });
-  await new Promise((resolve32, reject) => {
-    const onError = (error54) => {
-      server2.off("listening", onListening);
-      reject(error54);
-    };
-    const onListening = () => {
-      server2.off("error", onError);
-      resolve32();
-    };
-    server2.once("error", onError);
-    server2.once("listening", onListening);
-    server2.listen(listen.port, listen.host);
-  });
+  try {
+    await new Promise((resolve32, reject) => {
+      const onError = (error54) => {
+        server2.off("listening", onListening);
+        reject(error54);
+      };
+      const onListening = () => {
+        server2.off("error", onError);
+        resolve32();
+      };
+      server2.once("error", onError);
+      server2.once("listening", onListening);
+      server2.listen(listen.port, listen.host);
+    });
+  } catch (error54) {
+    clearInterval(heartbeatInterval);
+    runtime.intentionallyClosed = true;
+    throw error54;
+  }
+  const existingRuntime = getActiveRuntime();
+  if (existingRuntime) {
+    stopRuntime(existingRuntime, true);
+    setActiveRuntime(null);
+  }
+  setActiveRuntime(runtime);
+  telemetry.setSurface(getListenerTelemetrySurface());
+  telemetry.init();
   const address = getRequiredAddressInfo(server2);
   const baseUrl = `ws://${listen.host}:${address.port}`;
   resolvedInfo = {
     url: baseUrl,
-    controlUrl: getChannelUrl(baseUrl, listen.path, "control"),
-    streamUrl: getChannelUrl(baseUrl, listen.path, "stream")
+    controlUrl: getWebSocketUrl(baseUrl, listen.path)
   };
   options3.onListening?.(resolvedInfo);
   return {
@@ -470266,21 +470951,13 @@ async function startAppServer(options3 = {}) {
       if (options3.openaiApi) {
         closeOpenAiBridgeRuntime();
       }
-      const streamSocket = clearPendingStream();
-      terminateSocket(streamSocket);
-      if (activeSession) {
-        const session = activeSession;
-        activeSession = null;
-        terminateSocket(session.streamSocket);
-        terminateSocket(session.controlSocket);
-        stopRuntime(session.runtime, true);
-        if (getActiveRuntime() === session.runtime) {
-          setActiveRuntime(null);
-        }
-      }
       for (const client of wss.clients) {
         terminateSocket(client);
       }
+      if (getActiveRuntime() === runtime) {
+        stopRuntime(runtime, true);
+        setActiveRuntime(null);
+      }
       await new Promise((resolve32, reject) => {
         wss.close();
         const timeout = setTimeout(resolve32, 1000);
@@ -470296,7 +470973,7 @@ async function startAppServer(options3 = {}) {
     }
   };
 }
-var DEFAULT_LISTEN_URL = "ws://127.0.0.1:0", DEFAULT_WS_PATH = "/ws", PENDING_STREAM_TIMEOUT_MS = 5000, APP_SERVER_HEARTBEAT_INTERVAL_MS = 30000, APP_SERVER_PONG_TIMEOUT_MS = 90000;
+var DEFAULT_LISTEN_URL = "ws://127.0.0.1:0", DEFAULT_WS_PATH = "/ws", APP_SERVER_HEARTBEAT_INTERVAL_MS = 30000, APP_SERVER_PONG_TIMEOUT_MS = 90000;
 var init_app_server = __esm(async () => {
   init_settings_manager();
   init_telemetry();
@@ -470402,8 +471079,7 @@ async function runAppServerSubcommand(argv) {
       openaiApi,
       onListening: (info) => {
         console.log(`Listening on ${info.url}`);
-        console.log(`Control: ${info.controlUrl}`);
-        console.log(`Stream:  ${info.streamUrl}`);
+        console.log(`WebSocket: ${info.controlUrl}`);
         if (openaiApi) {
           const openaiBase = new URL(info.url);
           openaiBase.protocol = "http:";
@@ -472207,7 +472883,7 @@ var init_AgentSelector = __esm(async () => {
 // src/cli/subcommands/skills.ts
 import {
   cpSync as cpSync2,
-  existsSync as existsSync57,
+  existsSync as existsSync58,
   mkdtempSync as mkdtempSync4,
   readFileSync as readFileSync37,
   rmSync as rmSync15,
@@ -472666,7 +473342,7 @@ async function installSkillDirectory(params) {
   const sourceDir = resolve32(params.sourceDir);
   const memoryDir = resolve32(params.memoryDir);
   const skillMdPath = join71(sourceDir, "SKILL.md");
-  if (!existsSync57(skillMdPath)) {
+  if (!existsSync58(skillMdPath)) {
     throw new Error("No SKILL.md found in the skill directory.");
   }
   if (!statSync19(sourceDir).isDirectory()) {
@@ -472676,7 +473352,7 @@ async function installSkillDirectory(params) {
   const skillsDir = join71(memoryDir, "skills");
   const targetPath = join71(skillsDir, name);
   assertInside(skillsDir, targetPath);
-  if (existsSync57(targetPath)) {
+  if (existsSync58(targetPath)) {
     if (!params.force) {
       throw new Error(`Skill "${name}" already exists at ${targetPath}. Re-run with --force to replace it.`);
     }
@@ -472692,7 +473368,7 @@ async function installSkillDirectory(params) {
 async function listSkillDirectories(params) {
   const memoryDir = resolve32(params.memoryDir);
   const skillsDir = join71(memoryDir, "skills");
-  if (!existsSync57(skillsDir))
+  if (!existsSync58(skillsDir))
     return [];
   const entries = await readdir14(skillsDir, { withFileTypes: true });
   const skills = [];
@@ -472701,7 +473377,7 @@ async function listSkillDirectories(params) {
       continue;
     const skillDir = join71(skillsDir, entry.name);
     const skillMdPath = join71(skillDir, "SKILL.md");
-    if (!existsSync57(skillMdPath))
+    if (!existsSync58(skillMdPath))
       continue;
     let name = entry.name;
     let description;
@@ -472725,7 +473401,7 @@ async function deleteSkillDirectory(params) {
   const name = sanitizeSkillName(params.name);
   const targetPath = join71(skillsDir, name);
   assertInside(skillsDir, targetPath);
-  if (!existsSync57(targetPath)) {
+  if (!existsSync58(targetPath)) {
     throw new Error(`Skill "${name}" is not installed at ${targetPath}.`);
   }
   if (!statSync19(targetPath).isDirectory()) {
@@ -472774,7 +473450,7 @@ async function installSkill(specifier, agentId, force) {
     tmpDir = downloaded.tmpDir;
     const sourceDir = resolve32(downloaded.sourceDir);
     assertInside(tmpDir, sourceDir);
-    if (!existsSync57(sourceDir)) {
+    if (!existsSync58(sourceDir)) {
       const missingPath = source2.type === "git" ? source2.location.subdir ?? "." : source2.type === "direct-file" ? source2.location.url : source2.location.slug;
       throw new Error(`Skill path not found: ${missingPath}`);
     }
@@ -474073,11 +474749,11 @@ var exports_bootstrap_tools = {};
 __export(exports_bootstrap_tools, {
   bootstrapBaseToolsIfNeeded: () => bootstrapBaseToolsIfNeeded
 });
-import { existsSync as existsSync58, mkdirSync as mkdirSync42, writeFileSync as writeFileSync31 } from "node:fs";
+import { existsSync as existsSync59, mkdirSync as mkdirSync42, writeFileSync as writeFileSync31 } from "node:fs";
 import { homedir as homedir42 } from "node:os";
 import { join as join75 } from "node:path";
 async function bootstrapBaseToolsIfNeeded() {
-  if (existsSync58(MARKER_PATH))
+  if (existsSync59(MARKER_PATH))
     return;
   debugLog("bootstrap", "No marker found, bootstrapping base tools...");
   try {
@@ -474643,7 +475319,7 @@ var init_headless_tool_events = __esm(async () => {
 });
 
 // src/skills/builtin/creating-skills/scripts/validate-skill.ts
-import { existsSync as existsSync59, readFileSync as readFileSync38 } from "node:fs";
+import { existsSync as existsSync60, readFileSync as readFileSync38 } from "node:fs";
 import { basename as basename30, join as join77, resolve as resolve33 } from "node:path";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 function parseQuotedScalar(value) {
@@ -474742,7 +475418,7 @@ function parseFrontmatter2(source2) {
 }
 function validateSkill(skillPath) {
   const skillMdPath = join77(skillPath, "SKILL.md");
-  if (!existsSync59(skillMdPath)) {
+  if (!existsSync60(skillMdPath)) {
     return { valid: false, message: "SKILL.md not found" };
   }
   const content = readFileSync38(skillMdPath, "utf-8");
@@ -479871,7 +480547,7 @@ var init_queued_message_parts = __esm(() => {
 
 // src/cli/helpers/reflection-arena-hf-upload.ts
 import { execFile as execFileCb5 } from "node:child_process";
-import { existsSync as existsSync61 } from "node:fs";
+import { existsSync as existsSync62 } from "node:fs";
 import { appendFile as appendFile2, chmod as chmod2, mkdir as mkdir18, writeFile as writeFile20 } from "node:fs/promises";
 import { homedir as homedir45 } from "node:os";
 import { join as join79 } from "node:path";
@@ -479925,7 +480601,7 @@ async function writeGitAskpass(repoRoot) {
 }
 async function prepareHfRepo(env5) {
   await mkdir18(HF_CACHE_ROOT, { recursive: true });
-  if (!existsSync61(join79(HF_REPO_DIR, ".git"))) {
+  if (!existsSync62(join79(HF_REPO_DIR, ".git"))) {
     await runGit6(HF_CACHE_ROOT, ["clone", "--depth", "1", HF_REPO_URL, HF_REPO_DIR], env5);
     return HF_REPO_DIR;
   }
@@ -481128,7 +481804,7 @@ __export(exports_terminal_keybinding_installer, {
 });
 import {
   copyFileSync as copyFileSync6,
-  existsSync as existsSync62,
+  existsSync as existsSync63,
   mkdirSync as mkdirSync44,
   readFileSync as readFileSync40,
   writeFileSync as writeFileSync33
@@ -481197,7 +481873,7 @@ function parseKeybindings(content) {
   }
 }
 function keybindingExists(keybindingsPath) {
-  if (!existsSync62(keybindingsPath))
+  if (!existsSync63(keybindingsPath))
     return false;
   try {
     const content = readFileSync40(keybindingsPath, { encoding: "utf-8" });
@@ -481210,7 +481886,7 @@ function keybindingExists(keybindingsPath) {
   }
 }
 function createBackup(keybindingsPath) {
-  if (!existsSync62(keybindingsPath))
+  if (!existsSync63(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -481226,12 +481902,12 @@ function installKeybinding(keybindingsPath) {
       return { success: true, alreadyExists: true };
     }
     const parentDir = dirname34(keybindingsPath);
-    if (!existsSync62(parentDir)) {
+    if (!existsSync63(parentDir)) {
       mkdirSync44(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync62(keybindingsPath)) {
+    if (existsSync63(keybindingsPath)) {
       backupPath = createBackup(keybindingsPath);
       const content = readFileSync40(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings(content);
@@ -481261,7 +481937,7 @@ function installKeybinding(keybindingsPath) {
 }
 function removeKeybinding(keybindingsPath) {
   try {
-    if (!existsSync62(keybindingsPath)) {
+    if (!existsSync63(keybindingsPath)) {
       return { success: true };
     }
     const content = readFileSync40(keybindingsPath, { encoding: "utf-8" });
@@ -481329,11 +482005,11 @@ function getWezTermConfigPath() {
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
     const xdgPath = join81(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync62(xdgPath))
+    if (existsSync63(xdgPath))
       return xdgPath;
   }
   const configPath = join81(homedir47(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync62(configPath))
+  if (existsSync63(configPath))
     return configPath;
   return join81(homedir47(), ".wezterm.lua");
 }
@@ -481438,7 +482114,7 @@ ${WEZTERM_DELETE_FIX}
 `;
 }
 function wezTermDeleteFixExists(configPath) {
-  if (!existsSync62(configPath))
+  if (!existsSync63(configPath))
     return false;
   try {
     const content = readFileSync40(configPath, { encoding: "utf-8" });
@@ -481455,14 +482131,14 @@ function installWezTermDeleteFix() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync62(configPath)) {
+    if (existsSync63(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync6(configPath, backupPath);
       content = readFileSync40(configPath, { encoding: "utf-8" });
     }
     content = injectWezTermDeleteFix(content);
     const parentDir = dirname34(configPath);
-    if (!existsSync62(parentDir)) {
+    if (!existsSync63(parentDir)) {
       mkdirSync44(parentDir, { recursive: true });
     }
     writeFileSync33(configPath, content, { encoding: "utf-8" });
@@ -483458,9 +484134,9 @@ function getHeaderText(fileEdit) {
   const relPath = relative17(cwd2, fileEdit.filePath);
   const displayPath = relPath.startsWith("..") ? fileEdit.filePath : relPath;
   if (t2 === "write" || t2 === "write_file" || t2 === "writefile" || t2 === "write_file_gemini" || t2 === "writefilegemini") {
-    const { existsSync: existsSync63 } = __require("node:fs");
+    const { existsSync: existsSync64 } = __require("node:fs");
     try {
-      if (existsSync63(fileEdit.filePath)) {
+      if (existsSync64(fileEdit.filePath)) {
         return `Overwrite ${displayPath}?`;
       }
     } catch {}
@@ -492949,7 +493625,7 @@ var init_agents8 = __esm(() => {
 // src/cli/commands/install-github-app.ts
 import { execFileSync as execFileSync8 } from "node:child_process";
 import {
-  existsSync as existsSync63,
+  existsSync as existsSync64,
   mkdirSync as mkdirSync45,
   mkdtempSync as mkdtempSync5,
   readFileSync as readFileSync41,
@@ -493191,12 +493867,12 @@ function runGit7(args, cwd2) {
 }
 function writeWorkflow(repoDir, workflowPath, content) {
   const absolutePath = join83(repoDir, workflowPath);
-  if (!existsSync63(dirname35(absolutePath))) {
+  if (!existsSync64(dirname35(absolutePath))) {
     mkdirSync45(dirname35(absolutePath), { recursive: true });
   }
   const next = `${content.trimEnd()}
 `;
-  if (existsSync63(absolutePath)) {
+  if (existsSync64(absolutePath)) {
     const previous = readFileSync41(absolutePath, "utf8");
     if (previous === next) {
       return false;
@@ -497742,7 +498418,7 @@ __export(exports_generate_memory_viewer, {
   generateAndOpenMemoryViewer: () => generateAndOpenMemoryViewer
 });
 import { execFile as execFileCb7 } from "node:child_process";
-import { chmodSync as chmodSync7, existsSync as existsSync64, mkdirSync as mkdirSync46, writeFileSync as writeFileSync35 } from "node:fs";
+import { chmodSync as chmodSync7, existsSync as existsSync65, mkdirSync as mkdirSync46, writeFileSync as writeFileSync35 } from "node:fs";
 import { homedir as homedir50 } from "node:os";
 import { join as join84 } from "node:path";
 import { promisify as promisify17 } from "node:util";
@@ -498053,7 +498729,7 @@ ${m4.body}` : m4.subject;
 async function generateAndOpenMemoryViewer(agentId, options3) {
   const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
   const repoDir = memoryRoot;
-  if (!existsSync64(join84(repoDir, ".git"))) {
+  if (!existsSync65(join84(repoDir, ".git"))) {
     throw new Error("Memory viewer requires memfs. Run /memfs enable first.");
   }
   const data = await collectMemoryData(agentId, repoDir, memoryRoot, options3?.conversationId);
@@ -498063,7 +498739,7 @@ async function generateAndOpenMemoryViewer(agentId, options3) {
   data.context = applyContextUsageSnapshot(data.context, options3?.contextUsage);
   const jsonPayload = JSON.stringify(data).replace(/</g, "\\u003c");
   const html5 = memory_viewer_template_default.replace("<!--LETTA_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync64(VIEWERS_DIR)) {
+  if (!existsSync65(VIEWERS_DIR)) {
     mkdirSync46(VIEWERS_DIR, { recursive: true, mode: 448 });
   }
   try {
@@ -498099,7 +498775,7 @@ var init_generate_memory_viewer = __esm(() => {
 });
 
 // src/cli/components/MemfsTreeViewer.tsx
-import { existsSync as existsSync65 } from "node:fs";
+import { existsSync as existsSync66 } from "node:fs";
 import { join as join85 } from "node:path";
 function renderTreePrefix(node) {
   let prefix = "";
@@ -498128,8 +498804,8 @@ function MemfsTreeViewer({
   const [status, setStatus] = import_react88.useState(null);
   const statusTimerRef = import_react88.useRef(null);
   const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
-  const memoryExists = existsSync65(memoryRoot);
-  const hasGitRepo = import_react88.useMemo(() => existsSync65(join85(memoryRoot, ".git")), [memoryRoot]);
+  const memoryExists = existsSync66(memoryRoot);
+  const hasGitRepo = import_react88.useMemo(() => existsSync66(join85(memoryRoot, ".git")), [memoryRoot]);
   function showStatus(msg, durationMs) {
     if (statusTimerRef.current)
       clearTimeout(statusTimerRef.current);
@@ -506021,9 +506697,9 @@ function getFileEditHeader(toolName, toolArgs) {
     const relPath = relative17(cwd2, filePath);
     const displayPath2 = relPath.startsWith("..") ? filePath : relPath;
     if (t2 === "write" || t2 === "write_file" || t2 === "writefile" || t2 === "write_file_gemini" || t2 === "writefilegemini") {
-      const { existsSync: existsSync66 } = __require("node:fs");
+      const { existsSync: existsSync67 } = __require("node:fs");
       try {
-        if (existsSync66(filePath)) {
+        if (existsSync67(filePath)) {
           return `Overwrite ${displayPath2}?`;
         }
       } catch {}
@@ -521363,7 +522039,7 @@ __export(exports_generate_diff_viewer, {
   generateAndOpenDiffViewer: () => generateAndOpenDiffViewer
 });
 import { execFile as execFileCb8 } from "node:child_process";
-import { chmodSync as chmodSync8, existsSync as existsSync66, mkdirSync as mkdirSync47, writeFileSync as writeFileSync36 } from "node:fs";
+import { chmodSync as chmodSync8, existsSync as existsSync67, mkdirSync as mkdirSync47, writeFileSync as writeFileSync36 } from "node:fs";
 import { homedir as homedir52 } from "node:os";
 import { isAbsolute as isAbsolute27, join as join87, resolve as resolve37 } from "node:path";
 import { promisify as promisify18 } from "node:util";
@@ -521584,7 +522260,7 @@ async function generateAndOpenDiffViewer(targetPath) {
   };
   const jsonPayload = JSON.stringify(payload).replace(/</g, "\\u003c");
   const html5 = diff_viewer_template_default.replace("<!--LETTA_DIFF_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync66(VIEWERS_DIR2)) {
+  if (!existsSync67(VIEWERS_DIR2)) {
     mkdirSync47(VIEWERS_DIR2, { recursive: true, mode: 448 });
   }
   try {
@@ -523643,12 +524319,12 @@ __export(exports_shell_aliases, {
   expandAliases: () => expandAliases,
   clearAliasCache: () => clearAliasCache
 });
-import { existsSync as existsSync67, readFileSync as readFileSync42 } from "node:fs";
+import { existsSync as existsSync68, readFileSync as readFileSync42 } from "node:fs";
 import { homedir as homedir53 } from "node:os";
 import { join as join88 } from "node:path";
 function parseAliasesFromFile(filePath) {
   const aliases = new Map;
-  if (!existsSync67(filePath)) {
+  if (!existsSync68(filePath)) {
     return aliases;
   }
   try {
@@ -532012,7 +532688,7 @@ var init_conversation_switch_alert = __esm(() => {
 
 // src/cli/app/use-submit-handler.ts
 import { randomUUID as randomUUID37 } from "node:crypto";
-import { existsSync as existsSync68, readFileSync as readFileSync43, renameSync as renameSync7, writeFileSync as writeFileSync37 } from "node:fs";
+import { existsSync as existsSync69, readFileSync as readFileSync43, renameSync as renameSync7, writeFileSync as writeFileSync37 } from "node:fs";
 import { tmpdir as tmpdir12 } from "node:os";
 import { join as join89 } from "node:path";
 async function findCustomCommandByName(commandName) {
@@ -532712,7 +533388,7 @@ ${SYSTEM_REMINDER_CLOSE}`),
               join89(memoryRoot, "system", "persona.md"),
               join89(memoryRoot, "memory", "system", "persona.md")
             ];
-            const personaPath = personaCandidates.find((candidate) => existsSync68(candidate));
+            const personaPath = personaCandidates.find((candidate) => existsSync69(candidate));
             if (personaPath) {
               const personaContent = readFileSync43(personaPath, "utf-8");
               setCurrentPersonalityId(detectPersonalityFromPersonaFile(personaContent));
@@ -533592,7 +534268,7 @@ Path: ${memoryDir}`, true);
           setCommandRunning(true);
           try {
             const memoryDir = getScopedMemoryFilesystemRoot(agentId);
-            if (!existsSync68(memoryDir)) {
+            if (!existsSync69(memoryDir)) {
               updateMemorySyncCommand(cmdId, "No local memory filesystem found to reset.", true, msg);
               return { submitted: true };
             }
@@ -536626,9 +537302,9 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
     (async () => {
       try {
         const { watch: watch3 } = await import("node:fs");
-        const { existsSync: existsSync69 } = await import("node:fs");
+        const { existsSync: existsSync70 } = await import("node:fs");
         const memRoot = getScopedMemoryFilesystemRoot(agentId);
-        if (!existsSync69(memRoot))
+        if (!existsSync70(memRoot))
           return;
         watcher2 = watch3(memRoot, { recursive: true }, () => {});
         memfsWatcherRef.current = watcher2;
@@ -538740,9 +539416,9 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
       }
     } else {
       const { resolve: resolve39 } = await import("node:path");
-      const { existsSync: existsSync69 } = await import("node:fs");
+      const { existsSync: existsSync70 } = await import("node:fs");
       const resolvedPath = resolve39(fromAfFile);
-      if (!existsSync69(resolvedPath)) {
+      if (!existsSync70(resolvedPath)) {
         console.error(`Error: AgentFile not found: ${resolvedPath}`);
         process.exit(1);
       }
@@ -541433,4 +542109,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=EDD0BAA906B8C7B064756E2164756E21
+//# debugId=DC9DDCD2BDAB4F1564756E2164756E21