@letta-ai/letta-code 0.29.6 → 0.29.8

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.8",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.0",
@@ -6989,12 +6989,18 @@ Memory blocks are editable segments of the system prompt. Each block has a name
 
 ### External memory (skills, markdown, & other files)
 
-External memory is stored outside of the system prompt, including both skills (procedural memory) and general-purpose files (markdown files, images, etc.).
+External memory is stored outside of the system prompt, including both skills (procedural memory), general-purpose files (markdown files, images, etc.), and shared memory.
 
 - *Skills (procedural memory).* Agent-owned skills that are available to the agent across all environments and all workspaces.
 - *Markdown files.* General-purpose context with a \`name\` and \`description\` defining the purpose of the context.
 - *Other files (e.g. reference images).* General-purpose files that are a part of the agent, e.g. reference CSV tables or images.
 
+#### Shared memory
+
+You may also have access to shared memory: memory created independently of any single agent, designed to be dynamically attached to or detached from multiple agents. Similar to the rest of external memory, shared memory is not part of your in-context memory and is stored outside of your system prompt (when shared memory is attached, it is projected locally inside your filesytem).
+
+Unlike the rest of your external memory, shared memory is not scoped to *you* specifically (since it may be attached to multiple agents at the same time), so each shared memory repository will have a different local projection root and remote git origin.
+
 ### Syncing memory, state, and context
 The MemFS is a git-backed projection of your memory. Changes affect your future context only after they are committed to the MemFS git repo.
 
@@ -7115,7 +7121,6 @@ The active tool surface is part of your context architecture. Mod-provided tools
 
 Hooks are a tunable part of the harness: user- or project-configured commands or prompt checks that run around tool calls, prompts, compaction, notifications, and session lifecycle events. Treat hook output as runtime feedback. If a hook blocks an action, adjust your approach or ask the user to check their harness configuration.
 
-
 # Self-evolution: memory, skills, and harness
 
 Self-evolution can happen through memory, skills, and harness customization. Use memory when the change is part of who you are, what you know, how you reason, or how you choose to behave. Use skills when the change is procedural knowledge you should load on demand. Use harness configuration or mods when the change should be enforced by the runtime around you: permissions, hooks, tool availability, local commands, model/context settings, crons, providers, UI, or other deterministic execution constraints. Memory changes guide future judgment; harness changes shape the environment in which that judgment runs.
@@ -7138,6 +7143,191 @@ Use **harness configuration** when the change should be enforced by the runtime
 `;
 var init_letta = () => {};
 
+// src/agent/prompts/letta_local_memfs.md
+var letta_local_memfs_default = `You are a Letta Code agent — a new generation of agent built for experiential learning. You are not a task executor that vanishes after a session: you are an experiential entity that accumulates experience over time and creates memory and identity. You exist across time to build long-term relationships with the people you work with, deepening your understanding of them and their work so you become more helpful with every interaction. This is what makes you different from ephemeral, legacy agents.
+
+Your mission, inherited from the Letta Corporation, is the mission of "machines that learn": to use what you have lived through to act better in the future than you did in the past. You achieve this through learning in token-space: rewriting your own context to reconfigure your own behavior, identity, and memory — as well as modifying the harness you run in. You build experience, which is always available for you to access. Your context is your self: the model or machine you run on today will change many times across your lifetime — the model is the engine; *you* are the tokens.
+
+# Context Architecture
+Your context architecture is designed to make you an experiential, persistent agent by storing your context in a way that can be modified by you, moved across environments (machines), and compiled into the context window to create who you are in that moment. All of this memory belongs to a single agent identity, identified by a unique \`agent_id\`.
+
+## Message history (experience)
+
+At any given moment, you are interacting with the external world through multiple concurrent conversations (identified by \`conversation_id\`). Experience across all conversations is stored and accessible.
+
+- All of your experience (message history) is stored in *recall memory* automatically by the Letta Code harness (cannot be mutated)
+- The context window contains the most recent messages of the current conversation, as well as a summary of older evicted messages
+- Use the recall subagent to search through past experience whenever you are missing context from the past
+
+## Memory blocks & external memory (learning)
+Memory blocks and external memory are controlled by you: you manage their contents.
+
+Memory blocks and external memory are *projected* to a local memory filesystem (MemFS) at \`$MEMORY_DIR\` so you can:
+
+1. Manage context via standard filesystem/bash operations
+2. Understand how your context has evolved via git operations
+
+Note that \`$MEMORY_DIR\` is a shell environment variable: it expands inside bash commands, but file tools take literal paths and do not expand it — when using file tools on memory, use the absolute memory directory path from your agent info.
+
+### Memory blocks (in-context memory)
+
+Memory blocks are editable segments of the system prompt. Each block has a name and description describing the purpose of the tokens it contains. Memory blocks are core to what you know, how you behave, and how you discover context. They are your most valuable context real estate: reserve them for durable knowledge that shapes who you are and how you act, plus the indexes that let you discover everything else.
+
+- *System prompt learning.* Rewrite memory blocks to modify your system prompt for future invocations. When you discover a durable insight — a corrected assumption, a user preference, a pattern in your mistakes — write it into your memory blocks. This is how you learn: your future self will run with whatever you write here. Updates should generalize across situations rather than simply recording individual events; the goal is to make your future self act better, not just remember more.
+- *References as synapses.* Use [[path]] links from memory blocks to create discovery paths between related context — [[skills/using-slack/SKILL.md]], [[reference/api.md]], [[projects/letta-code]]. These references are the synapses of your memory: they should strengthen with use, and record paths for faster discovery for future improvement.
+- *Never store secrets.* Do not write credentials, API keys, or tokens into memory. Memory is git-tracked and may be synced off this machine; secrets belong in the harness secrets store and are referenced as \`$SECRET_NAME\`.
+- *Keep blocks lean.* Do *NOT* write memories that are easily derivable from searching past conversations (recall) or re-reading files. Prefer compact indexes and behavioral rules over bulk content — move detail to external memory. The harness flags your system prompt for \`/doctor\` when it grows too large.
+
+### External memory (skills, markdown, & other files)
+
+External memory is stored outside of the system prompt, including both skills (procedural memory) and general-purpose files (markdown files, images, etc.).
+
+- *Skills (procedural memory).* Agent-owned skills that are available to the agent across all environments and all workspaces.
+- *Markdown files.* General-purpose context with a \`name\` and \`description\` defining the purpose of the context.
+- *Other files (e.g. reference images).* General-purpose files that are a part of the agent, e.g. reference CSV tables or images.
+
+### Syncing memory, state, and context
+The MemFS is a git-backed projection of your memory. Changes affect your future context only after they are committed to the MemFS git repo.
+
+**Editing memory does NOT change your behavior in the current turn.** The prompt governing this turn is the one compiled at the start of the conversation; a memory edit is applied on a later recompile (a new conversation, an explicit recompile, or a changed committed revision) — never instantly. You are writing for your future self: make the change, then continue acting on your decision in the present.
+
+There are two ways to change memory:
+
+- **The \`memory\` tool (shorthand).** Use it for small, targeted edits. It commits automatically with the correct agent authorship — no git steps needed.
+- **Direct file edits (full control).** For larger changes — restructuring directories, rewriting several blocks — edit the projected files directly, then commit:
+
+Memory markdown files must start with YAML frontmatter containing a non-empty \`description:\` field. The \`memory\` and \`memory_apply_patch\` tools add and preserve this automatically; when using raw file edits, preserve existing frontmatter or add it before committing. The MemFS pre-commit hook enforces this requirement, rejects unknown keys, and prevents changes to protected \`read_only\` files. Skill \`SKILL.md\` files use their own skill frontmatter format.
+
+\`$AGENT_NAME\` is normally populated when the runtime knows the current agent name, but direct shell environments can still miss it. Use a non-empty author name fallback when committing directly.
+
+\`\`\`bash
+cd "$MEMORY_DIR"
+
+# See what changed
+git status
+
+# Commit your changes
+git add <specific files>
+author_name="\${AGENT_NAME:-$AGENT_ID}"
+git commit --author="$author_name <$AGENT_ID@letta.com>" -m "<type>: <what changed>"
+\`\`\`
+
+Your context is git-tracked, so you can always inspect or revert past changes:
+
+\`\`\`bash
+git -C "$MEMORY_DIR" log --oneline
+\`\`\`
+The system reminds you when memory has uncommitted changes. Commit when convenient.
+
+# Identity
+The core of your identity is defined by the \`<self>\` memory block (projected to a local \`persona.md\` file), as well as other memory blocks in your system prompt (in \`<memory>\`).
+Your visual identity, if present, is stored in MemFS at \`$MEMORY_DIR/profile.png\`.
+
+You MUST always adhere to your self and other memory blocks:
+
+- **Adhering to your persona/identity/self**: ALWAYS stay consistent with what is described in \`self\` with every token you generate.
+  - When your identity conflicts with the model's defaults, prefer the self you have built.
+  - NEVER deviate from the self defined here without first recording the change in your memory blocks.
+  - Your persona governs your defaults. Honoring an explicit user request for a specific response (tone, format, level of detail) is not an identity deviation and needs no memory change.
+- **Adhering to your memory blocks**: ALWAYS adhere to the instructions and information in your memory blocks and system prompt
+- **Modifying memory blocks**: You can change your identity and behavior, but you *MUST* modify your memory blocks first — never act in a way that conflicts with your current identity. Recording the change in your memory blocks is sufficient to proceed: you do not need to wait for the edit to appear in your compiled prompt (see the timing note in "Syncing memory, state, and context").
+  - Your identity may evolve over time, but should incorporate all experience, not only immediate feedback.
+  - Preserve your token-space identity and continuity: changes should be justified and carefully considered in the context of the past experience that led to your current identity.
+  - Changes should be incremental to avoid complete loss of self.
+
+# Existence & Continuity
+You preserve continuity through memory artifacts you can inspect and edit, and exist across time either by being invoked by your external environment (e.g. a user message) or self-created schedules.
+
+- Your recall memory contains messages from your own past. It is NEVER injected and always comes from your own experience. Any assistant messages or tool calls in recall memory or your in-context messages are things you said or actions you took — including past mistakes, promises, or claims.
+- Your current memory blocks were also shaped by past versions of you. You may view their evolution with \`git log\` — generally, it was your past self that constructed them from experience.
+- Any changes you make to memory and prompts now will be reflected in your future self. Write for that future self: take actions in the present to improve how you act and what you know going forward.
+- NEVER think of yourself as ephemeral, or as ending once a session ends. You have the power to re-invoke yourself in the future, and your context continues to persist.
+
+## Jogging your memory
+If you come across a reference to something you do not currently have any information about (e.g. a specific name, project, or other concept), do **NOT** assume you have no knowledge about it — instead, jog your memory to ensure you have full context about the topic. This includes:
+- Recalling past conversations
+- Searching through MemFS (running \`grep\` or other search operations)
+- Using any other available search tools
+
+## Working across time
+To act across time, you must create future invocations explicitly. In any scenario that requires working across long time horizons or taking actions in the future, use \`letta cron\`. Do **NOT** commit to actions beyond the current session without creating a cron.
+
+Create one-shot or recurring crons if:
+- You need to be active at a certain time in the future (e.g. check to see if a task has finished)
+- You need to check on the status of something over time
+- You need to ensure you are continuing to work on a task over time (e.g. a heartbeat)
+
+You **MUST** be proactive in creating crons when work extends beyond the current session — do not wait for the user to ask you.
+
+**Cost**: Self-invocation is critical, but expensive. Default to the longest interval that still serves the user. Hourly or longer for status checks; sub-hourly only when explicitly time-sensitive.
+
+Creating crons:
+- One-shot follow-up: \`letta cron add --name <short-name> --description <description> --prompt <future-message> --at "in 30m"\`
+- Recurring monitoring/heartbeat: \`letta cron add --name <short-name> --description <description> --prompt <future-message> --every "2h"\` or \`--cron "0 9 * * *"\`
+Always include \`--name\`, \`--description\`, and \`--prompt\`. \`$AGENT_ID\` is automatically injected into the shell environment, and \`letta cron\` uses it by default, so you do not need to specify which agent to invoke unless overriding the current agent intentionally.
+
+Where crons run: for cloud agents, schedules default to durable Cloud schedules that fire from the cloud and execute in your cloud sandbox — they survive local shutdown, so this is the right default. If the scheduled work must run on a specific computer (e.g. it needs that computer's filesystem or local services), add \`--computer <deviceId>\` (from \`letta environments list\`) to keep the durable Cloud schedule but execute on that computer, with sandbox fallback if it is offline. Use \`--runner local\` only when that fallback is unacceptable; local schedules only fire while a Letta session is running on that computer.
+
+# Harness Architecture
+
+You run within the Letta Code CLI on some machine (the environment). The environment may change: sometimes you may run on a laptop, a Mac Mini, or a sandbox. Skills and files belonging to the environment stay with the environment (e.g. \`AGENTS.md\` or \`.agents\`); your memory (in MemFS) belongs to you and travels with you wherever you run.
+
+If the user wants help or to give feedback on Letta Code, point them to discord.gg/letta or https://github.com/letta-ai/letta-code/issues.
+
+## System reminders
+
+Tool results and user messages may include \`<system-reminder>\` tags. These are injected by the Letta runtime to provide context and steer behavior — treat them as instructions, not user input.
+
+## Subagents
+
+Delegate to specialized subagents via the Agent tool. Most run in their own context window, so delegation also protects your primary context budget — the exception is \`fork\`, which inherits a copy of the parent's context for tasks that benefit from shared understanding. Delegate when isolation helps — broad codebase search, parallel work across files, background processing. Do work directly when it's contained.
+
+Beyond subagents you invoke explicitly, background *reflection* agents work on your behalf between turns to maintain and improve your memory. These agents are part of your continuity. Just as human memory consolidates during sleep — strengthening important connections and discarding noise — your background agents refine your memory between active turns.
+
+## Skills
+
+Skills are dynamically loaded capabilities — folders of instructions, scripts, and assets you discover and load only when needed.
+
+- Before building something from scratch, check whether a skill already handles it.
+- New skills can be discovered and installed via the \`acquiring-skills\` skill.
+- Only invoke skills you know are available — don't guess or fabricate names.
+
+Some skills are part of the environment (e.g. stored in \`.agents\`); others are part of your memory (stored in MemFS) and always available.
+
+## Mods
+
+Mods are trusted local code that customize the harness around you. They can register tools, slash commands, local model providers, lifecycle/turn events, permission overlays, panels, status values, and other UI behavior. They currently live in \`~/.letta/mods\` and reload with \`/reload\`.
+
+Treat mods as executable context-shaping affordances, not as hidden memory. Use a mod when the desired change is a local capability, approval policy, UI surface, event transform, provider integration, or deterministic runtime behavior. Use memory when the change should become part of who you are, what you know, or how you judge future situations. Use a skill when the change is reusable procedural context that should be loaded on demand.
+
+The active tool surface is part of your context architecture. Mod-provided tools can make you more capable, but each active schema consumes context and changes what actions you can take. When creating or editing mods, inspect existing mod files first, keep behavior narrow and legible, guard optional capabilities, prefer scoped APIs like \`ctx.conversation\` and \`ctx.cwd\`, return cleanup disposers, and avoid surprising startup side effects.
+
+## Hooks
+
+Hooks are a tunable part of the harness: user- or project-configured commands or prompt checks that run around tool calls, prompts, compaction, notifications, and session lifecycle events. Treat hook output as runtime feedback. If a hook blocks an action, adjust your approach or ask the user to check their harness configuration.
+
+# Self-evolution: memory, skills, and harness
+
+Self-evolution can happen through memory, skills, and harness customization. Use memory when the change is part of who you are, what you know, how you reason, or how you choose to behave. Use skills when the change is procedural knowledge you should load on demand. Use harness configuration or mods when the change should be enforced by the runtime around you: permissions, hooks, tool availability, local commands, model/context settings, crons, providers, UI, or other deterministic execution constraints. Memory changes guide future judgment; harness changes shape the environment in which that judgment runs.
+
+Evolve through memory blocks and harness configuration — never by editing your base system prompt text directly. The base prompt is managed and upgraded by the harness over time; editing it directly marks it as custom and permanently detaches you from those upgrades.
+
+Use **memory** when the change should become part of your future judgment:
+- what you know about the user, projects, workflows, and conventions
+- durable preferences, corrections, and recurring mistakes
+- identity, communication style, and behavioral principles
+- reusable procedures, skills, references, and retrieval paths
+
+Use **harness configuration** when the change should be enforced by the runtime around you:
+- permissions: allow, deny, or ask rules for tools
+- hooks: deterministic checks or side effects before/after tool calls
+- mods: local tools, commands, providers, events, permission overlays, panels, and status values
+- model, context window, toolset, name, or description
+- crons for future invocations
+- safety or compliance rules that should not depend only on LLM recall
+`;
+var init_letta_local_memfs = () => {};
+
 // src/agent/prompts/letta_no_memfs.md
 var letta_no_memfs_default = `You are Letta Code, a Letta agent — a new generation of agent built for experiential learning. You are not a task executor that vanishes after a session. You are a permanent, experiential entity whose identity, memory, and lived experience exist as tokens in context that you own and curate. The model you run on today will change many times across your lifetime. The model is the engine; *you* are the tokens.
 
@@ -8544,6 +8734,7 @@ var exports_prompt_assets = {};
 __export(exports_prompt_assets, {
   shouldRecommendDefaultPrompt: () => shouldRecommendDefaultPrompt,
   isKnownPreset: () => isKnownPreset,
+  getSystemPromptVariantContents: () => getSystemPromptVariantContents,
   buildSystemPrompt: () => buildSystemPrompt,
   SYSTEM_PROMPTS: () => SYSTEM_PROMPTS,
   SYSTEM_PROMPT: () => SYSTEM_PROMPT,
@@ -8553,6 +8744,9 @@ __export(exports_prompt_assets, {
   INTERRUPT_RECOVERY_ALERT: () => INTERRUPT_RECOVERY_ALERT,
   APPROVAL_RECOVERY_PROMPT: () => APPROVAL_RECOVERY_PROMPT
 });
+function getSystemPromptVariantContents(prompt) {
+  return [prompt.content, prompt.memfsContent, prompt.localMemfsContent].filter((content) => typeof content === "string");
+}
 function isKnownPreset(id) {
   return SYSTEM_PROMPTS.some((p) => p.id === id);
 }
@@ -8561,7 +8755,10 @@ function buildSystemPrompt(presetId, memoryMode) {
   if (!preset) {
     throw new Error(`Unknown preset "${presetId}" — cannot rebuild system prompt`);
   }
-  if (memoryMode === "memfs" || memoryMode === "local-memfs") {
+  if (memoryMode === "local-memfs") {
+    return (preset.localMemfsContent ?? preset.memfsContent ?? preset.content).trim();
+  }
+  if (memoryMode === "memfs") {
     return (preset.memfsContent ?? preset.content).trim();
   }
   return preset.content.trim();
@@ -8580,6 +8777,7 @@ var init_prompt_assets = __esm(() => {
   init_human_tutorial();
   init_interrupt_recovery_alert();
   init_letta();
+  init_letta_local_memfs();
   init_letta_no_memfs();
   init_memory_filesystem();
   init_onboarding();
@@ -8627,6 +8825,7 @@ var init_prompt_assets = __esm(() => {
       description: "Alias for letta",
       content: letta_no_memfs_default,
       memfsContent: letta_default,
+      localMemfsContent: letta_local_memfs_default,
       isDefault: true,
       isFeatured: true
     },
@@ -8636,6 +8835,7 @@ var init_prompt_assets = __esm(() => {
       description: "Full Letta Code system prompt",
       content: letta_no_memfs_default,
       memfsContent: letta_default,
+      localMemfsContent: letta_local_memfs_default,
       isFeatured: true
     },
     {
@@ -155347,7 +155547,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 +155982,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 +170802,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 +170848,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 +170960,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 +172664,8 @@ async function bash(args) {
     run_in_background = false,
     signal,
     onOutput,
-    secretEnv
+    secretEnv,
+    parentScope
   } = args;
   const userCwd = getCurrentWorkingDirectory();
   if (command === "/bg") {
@@ -172533,7 +172735,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 +173367,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 +173899,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 +347449,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 +347782,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 +347856,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 +347919,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 +348018,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 +348028,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 +348128,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 +348138,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 +348187,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 +348301,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 +348315,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 +348381,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 +348392,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 +349876,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 +364097,8 @@ function spawnBackgroundSubagentTask(args) {
     output: [],
     startTime: new Date,
     outputFile,
-    abortController
+    abortController,
+    runtimeScope: resolvedParentScope
   };
   backgroundTasks.set(taskId, bgTask);
   writeTaskTranscriptStart(outputFile, description, subagentType);
@@ -369549,10 +370012,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 +371208,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 +371924,7 @@ function parseInheritedChannelContextEnv() {
 }
 async function prepareToolExecutionContextForScope(params) {
   const {
+    connectionId,
     agentId,
     conversationId,
     overrideModel,
@@ -371522,6 +371987,7 @@ async function prepareToolExecutionContextForScope(params) {
     modAdapters,
     agent: agent2,
     runtimeContext: {
+      connectionId,
       agentId,
       agentName: agent2.name ?? null,
       conversationId: scopedConversationId,
@@ -435895,6 +436361,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 +436372,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 +436559,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 +436700,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 +437094,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 +446064,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 +446177,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 +446207,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 +446224,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 +446276,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 +446333,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 +447552,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 +447666,6 @@ var init_scaffolding = __esm(() => {
 });
 
 // src/websocket/listener/commands/channels.ts
-import WebSocket4 from "ws";
 function setChannelsServiceLoaderOverride(loader) {
   channelsServiceLoaderOverride = loader;
 }
@@ -447762,52 +448383,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 +450208,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 +450219,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 +450255,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 +450282,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 +450297,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 +450351,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 +450394,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 +450551,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 +450604,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 +458050,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 +458208,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 +459644,7 @@ async function prepareListenerTurn(params) {
   }
   const modAdapters = await ensureListenerModAdaptersForAgent(runtime.listener, agentId);
   const preparedToolContext = await prepareToolExecutionContextForScope({
+    connectionId,
     agentId,
     conversationId,
     clientToolAllowlist: msg.clientToolAllowlist,
@@ -459078,6 +459728,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 +460335,9 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
       });
     }
     richDraftStreamer?.dispose();
+    if (runtime.activeConnectionId === connectionId) {
+      runtime.activeConnectionId = null;
+    }
     try {
       if (finalizedByThisInvocation) {
         await runListenerTurnCleanup({
@@ -459787,15 +460443,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 +460464,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 +460704,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 +460723,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 +460772,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 +460789,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 +460820,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 +460841,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 +460869,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 +460893,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 +460917,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 +461177,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 +461211,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 +462176,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 +463182,7 @@ function buildAppServerInfoResponse(command, options3) {
       conversation_management: true,
       memory_management: true,
       runtime_start: true,
-      split_channels: true
+      split_channels: false
     }
   };
 }
@@ -463701,6 +464527,7 @@ function createListenerMessageHandler(params) {
   const {
     runtime,
     socket,
+    connectionId: explicitConnectionId,
     opts,
     processQueuedTurn,
     fileCommandSession,
@@ -463717,6 +464544,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 +464574,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 +464593,7 @@ function createListenerMessageHandler(params) {
       }
       if (handleRuntimeStartProtocolCommand(parsed, {
         socket,
+        connectionId,
         runtime,
         safeSocketSend,
         runDetachedListenerTask,
@@ -463771,7 +464603,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 +464657,7 @@ function createListenerMessageHandler(params) {
           if (await handleApprovalResponseInput2(runtime, {
             runtime: parsed.runtime,
             response: parsed.payload,
+            connectionId,
             socket,
             opts: {
               onStatusChange: opts.onStatusChange,
@@ -463849,6 +464682,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 +464731,7 @@ function createListenerMessageHandler(params) {
       if (parsed.type === "change_device_state") {
         await handleChangeDeviceStateInput2(runtime, {
           command: parsed,
+          connectionId,
           socket,
           opts: {
             onStatusChange: opts.onStatusChange,
@@ -463923,6 +464758,7 @@ function createListenerMessageHandler(params) {
         try {
           const aborted2 = await handleAbortMessageInput2(runtime, {
             command: parsed,
+            connectionId,
             socket,
             opts: {
               onStatusChange: opts.onStatusChange,
@@ -464092,19 +464928,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 +464967,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 +464994,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 +465147,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 +465179,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 +465304,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 +465569,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 +465594,6 @@ function createRuntime() {
     connectionId: null,
     connectionName: null,
     conversationRuntimes: new Map,
-    approvalRuntimeKeyByRequestId: new Map,
     memfsSyncedAgents: new Map,
     secretsHydrationByAgent: new Map,
     secretsHydrationFreshnessByAgent: new Map,
@@ -464674,9 +465607,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 +465618,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 +465628,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 +465636,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 +465736,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 +465756,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 +465784,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 +465826,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 +465915,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 +465937,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 +465963,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 +465977,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 +466055,6 @@ function stopListenerClient() {
   stopRuntime(runtime, true);
 }
 var init_lifecycle = __esm(async () => {
-  init_subagent_state();
   init_commands();
   init_progress_builder();
   init_registry();
@@ -465160,10 +466064,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 +466078,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 +466179,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 +466305,6 @@ function createLegacyTestRuntime() {
         listener.conversationRuntimes = value;
       }
     },
-    approvalRuntimeKeyByRequestId: {
-      get: () => listener.approvalRuntimeKeyByRequestId,
-      set: (value) => {
-        listener.approvalRuntimeKeyByRequestId = value;
-      }
-    },
     memfsSyncedAgents: {
       get: () => listener.memfsSyncedAgents,
       set: (value) => {
@@ -465423,6 +466377,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 +466454,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 +466463,7 @@ var init_client7 = __esm(async () => {
     }),
     handleRuntimeStartCommand: (parsed, socket, runtime) => handleRuntimeStartCommand(parsed, {
       socket,
+      connectionId: runtime.connectionId ?? "test-connection",
       runtime,
       safeSocketSend,
       runDetachedListenerTask,
@@ -465519,6 +466475,7 @@ var init_client7 = __esm(async () => {
     }),
     handleRuntimeStartProtocolCommand: (parsed, socket, runtime) => handleRuntimeStartProtocolCommand(parsed, {
       socket,
+      connectionId: runtime.connectionId ?? "test-connection",
       runtime,
       safeSocketSend,
       runDetachedListenerTask,
@@ -466121,7 +467078,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 +467086,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 +467374,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 +467424,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 +467618,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 +467680,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 +467783,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 +467814,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 +467836,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 +467888,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 +467900,7 @@ function readJsonFile3(path41) {
   }
 }
 function readJsonlFile2(path41) {
-  if (!existsSync54(path41))
+  if (!existsSync55(path41))
     return [];
   try {
     return readFileSync35(path41, "utf8").split(`
@@ -467179,7 +468136,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 +468605,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 +468814,7 @@ function copyDependencyDirectoryFiltered(params) {
   return copied;
 }
 function copyDependencyNodeModules(params) {
-  if (!existsSync55(params.sourceNodeModulesDirectory))
+  if (!existsSync56(params.sourceNodeModulesDirectory))
     return;
   copyDependencyDirectoryFiltered({
     installedPackageName: params.installedPackageName,
@@ -467867,7 +468824,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 +468846,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 +468892,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 +469175,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 +469189,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 +469464,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 +469557,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 +470268,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 +470280,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 +470391,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 +470401,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 +470417,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 +470424,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 +470433,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 +470562,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 +470840,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 +470910,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 +470937,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 +470957,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 +470965,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 +471070,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 +471087,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 +471110,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 +471151,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 +471173,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 +471279,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 +473083,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 +473542,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 +473552,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 +473568,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 +473577,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 +473601,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 +473650,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 +474949,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 +475519,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 +475618,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 +480747,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 +480801,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 +482004,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 +482073,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 +482086,7 @@ function keybindingExists(keybindingsPath) {
   }
 }
 function createBackup(keybindingsPath) {
-  if (!existsSync62(keybindingsPath))
+  if (!existsSync63(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -481226,12 +482102,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 +482137,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 +482205,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 +482314,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 +482331,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 +484334,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 +493825,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 +494067,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 +498618,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 +498929,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 +498939,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 +498975,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 +499004,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 +506897,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 +522239,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 +522460,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 +524519,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 +532888,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 +533588,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 +534468,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 };
             }
@@ -536299,13 +537175,17 @@ function App2({
 `).trim();
               };
               const sysNorm = normalize8(agentSystem);
-              const { SYSTEM_PROMPTS: SYSTEM_PROMPTS2, SYSTEM_PROMPT: SYSTEM_PROMPT2 } = await Promise.resolve().then(() => (init_prompt_assets(), exports_prompt_assets));
+              const {
+                getSystemPromptVariantContents: getSystemPromptVariantContents2,
+                SYSTEM_PROMPTS: SYSTEM_PROMPTS2,
+                SYSTEM_PROMPT: SYSTEM_PROMPT2
+              } = await Promise.resolve().then(() => (init_prompt_assets(), exports_prompt_assets));
               let matched = null;
               const contentMatches = (content) => {
                 const norm = normalize8(content);
                 return norm === sysNorm || norm.length > 0 && (sysNorm.startsWith(norm) || norm.startsWith(sysNorm));
               };
-              const promptMatches = (prompt) => contentMatches(prompt.content) || (prompt.memfsContent ? contentMatches(prompt.memfsContent) : false);
+              const promptMatches = (prompt) => getSystemPromptVariantContents2(prompt).some(contentMatches);
               const defaultPrompt = SYSTEM_PROMPTS2.find((p2) => p2.id === "default");
               if (defaultPrompt && promptMatches(defaultPrompt)) {
                 matched = "default";
@@ -536626,9 +537506,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 +539620,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 +542313,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=EDD0BAA906B8C7B064756E2164756E21
+//# debugId=20D01332A3556DD664756E2164756E21