@vellumai/assistant 0.11.4-staging.2 → 0.11.4-staging.3

package/src/daemon/conversation-notifiers.ts

@@ -3,8 +3,10 @@
  * the Conversation constructor and dispose/abort methods.
  *
  * Notifier callbacks read from the provided context object at invocation
- * time (not registration time), so they always see the latest sendToClient
- * and messages references even after updateClient().
+ * time (not registration time), so they always see the latest messages
+ * reference. They emit through the conversation, whose sink is fixed for its
+ * life, so an out-of-turn notification reaches every subscribed client
+ * without any per-turn wiring.
  */
 
 import { createAssistantMessage } from "../agent/message-types.js";
@@ -32,7 +34,7 @@ import { restingTrust } from "./trust-context-types.js";
  * invocation time. Properties are read lazily from this reference.
  */
 export interface NotifierConversationContext {
-  sendToClient: (msg: AssistantEvent) => void;
+  emit: (msg: AssistantEvent) => void;
   messages: Message[];
   trustContext?: TrustContext;
 }
@@ -77,12 +79,12 @@ export function registerConversationNotifiers(
 
       ctx.messages.push(createAssistantMessage(questionText));
 
-      ctx.sendToClient({
+      ctx.emit({
         type: "assistant_text_delta",
         text: questionText,
         conversationId: conversationId,
       });
-      ctx.sendToClient({
+      ctx.emit({
         type: "message_complete",
         conversationId: conversationId,
         messageId: msg.id,
@@ -97,12 +99,12 @@ export function registerConversationNotifiers(
       const speakerLabel = speaker === "caller" ? "Caller" : "Assistant";
       const transcriptText = `**Live call transcript**\n${speakerLabel}: ${text}`;
 
-      ctx.sendToClient({
+      ctx.emit({
         type: "assistant_text_delta",
         text: transcriptText,
         conversationId: conversationId,
       });
-      ctx.sendToClient({
+      ctx.emit({
         type: "message_complete",
         conversationId: conversationId,
         source: "aux",
@@ -113,12 +115,12 @@ export function registerConversationNotifiers(
   registerCallCompletionNotifier(conversationId, (callSessionId: string) => {
     const summaryText = buildCallCompletionMessage(callSessionId);
 
-    ctx.sendToClient({
+    ctx.emit({
       type: "assistant_text_delta",
       text: summaryText,
       conversationId: conversationId,
     });
-    ctx.sendToClient({
+    ctx.emit({
       type: "message_complete",
       conversationId: conversationId,
       source: "aux",

package/src/daemon/conversation-process.ts

@@ -60,7 +60,6 @@ import {
 } from "./conversation-slash.js";
 import { getModelInfo } from "./handlers/config-model.js";
 import { preactivateHostProxySkills } from "./host-proxy-preactivation.js";
-import { bindInteractiveTurnSender } from "./interactive-turn-sender.js";
 import type { UserMessageAttachment } from "./message-protocol.js";
 import { buildTransportHints } from "./transport-hints.js";
 import { sameTrustIdentity, type TrustContext } from "./trust-context-types.js";
@@ -1293,26 +1292,11 @@ async function drainSingleMessage(
     drainLoopOptions.isHiddenPrompt = true;
   }
 
-  // By the time the drain runs, the conversation-level sender is usually the
-  // no-op the just-finished interactive turn's restore (or conversation
-  // birth) left behind, and the drain bypasses `processMessage`, so without
-  // a fresh bind the PermissionPrompter's confirmation_request (which reads
-  // the conversation-level sender, not the turn's `onEvent`) would be
-  // emitted into nothing and hang until the permission timeout. Same
-  // bind/restore contract as `processMessage`.
-  const restoreSender =
-    next.isInteractive === true
-      ? bindInteractiveTurnSender(conversation)
-      : undefined;
-
   conversation
     .runAgentLoop(agentLoopContent, userMessageId, {
       ...drainLoopOptions,
       onEvent: next.onEvent,
     })
-    .finally(() => {
-      restoreSender?.();
-    })
     .catch((err) => {
       const message = err instanceof Error ? err.message : String(err);
       log.error(
@@ -1795,14 +1779,6 @@ async function drainBatch(
     drainLoopOptions.isHiddenPrompt = true;
   }
 
-  // Same sender contract as drainSingleMessage: an interactive drained batch
-  // must rebind the conversation-level sender or prompter confirmations
-  // raised during this turn reach no client.
-  const restoreSender =
-    drainLoopOptions.isInteractive === true
-      ? bindInteractiveTurnSender(conversation)
-      : undefined;
-
   // Fire-and-forget: runAgentLoop's finally block recursively calls drainQueue
   // when this run completes. Mirrors drainSingleMessage.
   conversation
@@ -1810,9 +1786,6 @@ async function drainBatch(
       ...drainLoopOptions,
       onEvent: fanOutOnEvent,
     })
-    .finally(() => {
-      restoreSender?.();
-    })
     .catch((err) => {
       const message = err instanceof Error ? err.message : String(err);
       log.error(

package/src/daemon/conversation-store.ts

@@ -27,6 +27,7 @@ import {
 } from "../providers/connection-resolution.js";
 import { RateLimitProvider } from "../providers/ratelimit.js";
 import { listProviders } from "../providers/registry.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { getSandboxWorkingDir } from "../util/platform.js";
 import { Conversation } from "./conversation.js";
@@ -156,7 +157,6 @@ export async function getOrCreateConversation(
   options?: ConversationCreateOptions,
 ): Promise<Conversation> {
   let conversation = findConversation(conversationId);
-  const sendToClient = () => {};
 
   // `taskRunId` and `ephemeral` are per-call scopes, not durable conversation
   // metadata, so they are stripped before the remaining options are merged
@@ -232,7 +232,9 @@ export async function getOrCreateConversation(
         conversationId,
         provider,
         systemPrompt,
-        sendToClient,
+        // Top-level conversations deliver to the SSE hub for their whole life,
+        // so every subscribed client sees every event with no per-turn wiring.
+        broadcastMessage,
         workingDir,
         {
           maxTokens,
@@ -240,8 +242,6 @@ export async function getOrCreateConversation(
           modelOverride: storedOptions?.modelOverride,
         },
       );
-      newConversation.updateClient(sendToClient, true);
-
       // Ensure the conversations row exists before hydrating from DB.
       // `getOrCreateConversation` builds the in-memory Conversation, but
       // the persisted row is what `loadFromDb` reads for conversationType,

package/src/daemon/conversation-surfaces.ts

@@ -138,6 +138,16 @@ const ModelActionSchema = SurfaceActionSchema.extend({
 
 const MAX_UNDO_DEPTH = 10;
 
+/**
+ * Whether a surface-action turn (a user clicked a button or submitted a form on
+ * a UI surface) runs with a human declared present. The handler does not yet
+ * learn the actor's interface, so it cannot declare presence the way the send
+ * route does; the turn runs non-interactive, which is what the state-derived
+ * fallback resolved to between turns. Deriving it from the actor's interface
+ * is a policy change tracked separately.
+ */
+const SURFACE_ACTION_TURN_IS_INTERACTIVE = false;
+
 /**
  * Pending surface types that do not hold the one-interactive-surface-at-a-time
  * lock. Each renders content the user reads (or settles on its own) rather
@@ -1372,7 +1382,7 @@ export function openChannelSetupPanel(
       data: safeParseSurfaceData("channel_setup", data) ?? {},
     });
 
-    ctx.sendToClient({
+    ctx.emit({
       type: "open_panel",
       panelType: "channel_setup",
       data,
@@ -1510,7 +1520,7 @@ function pushUndoState(
 export function handleSurfaceUndo(ctx: Conversation, surfaceId: string): void {
   const stack = ctx.surfaceUndoStacks.get(surfaceId);
   if (!stack || stack.length === 0) {
-    ctx.sendToClient({
+    ctx.emit({
       type: "ui_surface_undo_result",
       conversationId: ctx.conversationId,
       surfaceId,
@@ -1523,7 +1533,7 @@ export function handleSurfaceUndo(ctx: Conversation, surfaceId: string): void {
   const previousHtml = stack.pop()!;
   const stored = ctx.surfaceState.get(surfaceId);
   if (!stored || stored.surfaceType !== "dynamic_page") {
-    ctx.sendToClient({
+    ctx.emit({
       type: "ui_surface_undo_result",
       conversationId: ctx.conversationId,
       surfaceId,
@@ -1557,7 +1567,7 @@ export function handleSurfaceUndo(ctx: Conversation, surfaceId: string): void {
         html: previousHtml,
       };
       s.data = revertedData;
-      ctx.sendToClient({
+      ctx.emit({
         type: "ui_surface_update",
         conversationId: ctx.conversationId,
         surfaceId: sid,
@@ -1594,7 +1604,7 @@ export function handleSurfaceUndo(ctx: Conversation, surfaceId: string): void {
       html: previousHtml,
     };
     stored.data = revertedData;
-    ctx.sendToClient({
+    ctx.emit({
       type: "ui_surface_update",
       conversationId: ctx.conversationId,
       surfaceId,
@@ -1602,7 +1612,7 @@ export function handleSurfaceUndo(ctx: Conversation, surfaceId: string): void {
     });
   }
 
-  ctx.sendToClient({
+  ctx.emit({
     type: "ui_surface_undo_result",
     conversationId: ctx.conversationId,
     surfaceId,
@@ -2212,6 +2222,7 @@ export async function handleSurfaceAction(
       activeSurfaceId: surfaceId,
       displayContent,
       sourceActorPrincipalId,
+      isInteractive: SURFACE_ACTION_TURN_IS_INTERACTIVE,
       // Rides the metadata bag rather than a typed option: the queue
       // round-trips `metadata` but not `PersistMessageOptions`.
       metadata: { scripted: isSyntheticSurfaceActionContent(content) },
@@ -2274,6 +2285,7 @@ export async function handleSurfaceAction(
         activeSurfaceId: surfaceId,
         displayContent,
         sourceActorPrincipalId,
+        isInteractive: SURFACE_ACTION_TURN_IS_INTERACTIVE,
         scripted: isSyntheticSurfaceActionContent(content),
       })
       .catch((err) => {
@@ -2460,6 +2472,7 @@ export async function handleSurfaceAction(
     activeSurfaceId: surfaceId,
     displayContent,
     sourceActorPrincipalId,
+    isInteractive: SURFACE_ACTION_TURN_IS_INTERACTIVE,
     // Rides the metadata bag rather than a typed option: the queue
     // round-trips `metadata` but not `PersistMessageOptions`.
     metadata: { scripted: isSyntheticSurfaceActionContent(content) },
@@ -2532,6 +2545,7 @@ export async function handleSurfaceAction(
       activeSurfaceId: surfaceId,
       displayContent,
       sourceActorPrincipalId,
+      isInteractive: SURFACE_ACTION_TURN_IS_INTERACTIVE,
       scripted: isSyntheticSurfaceActionContent(content),
     })
     .catch((err) => {
@@ -2596,7 +2610,7 @@ export function refreshSurfacesForApp(
     }
 
     // Push the update to the client
-    ctx.sendToClient({
+    ctx.emit({
       type: "ui_surface_update",
       conversationId: ctx.conversationId,
       surfaceId,
@@ -3433,7 +3447,7 @@ export async function surfaceProxyResolver(
       "Sending ui_surface_show to client",
     );
 
-    ctx.sendToClient({
+    ctx.emit({
       type: "ui_surface_show",
       conversationId: ctx.conversationId,
       surfaceId,
@@ -3552,7 +3566,7 @@ export async function surfaceProxyResolver(
       mergedData = patch;
     }
 
-    ctx.sendToClient({
+    ctx.emit({
       type: "ui_surface_update",
       conversationId: ctx.conversationId,
       surfaceId,
@@ -3610,7 +3624,7 @@ export async function surfaceProxyResolver(
           isError: true,
         };
       }
-      ctx.sendToClient({
+      ctx.emit({
         type: "ui_surface_complete",
         conversationId: ctx.conversationId,
         surfaceId,
@@ -3618,7 +3632,7 @@ export async function surfaceProxyResolver(
         submittedData: lastAction.data,
       });
     } else {
-      ctx.sendToClient({
+      ctx.emit({
         type: "ui_surface_dismiss",
         conversationId: ctx.conversationId,
         surfaceId,
@@ -3720,7 +3734,7 @@ export async function surfaceProxyResolver(
       // Inline-only preview card emitted during app_create — do not open a
       // workspace panel and do not register surface state. The client renders
       // this as a tappable inline card that opens the app on demand.
-      ctx.sendToClient({
+      ctx.emit({
         type: "ui_surface_show",
         conversationId: ctx.conversationId,
         surfaceId,
@@ -3750,7 +3764,7 @@ export async function surfaceProxyResolver(
       title: app.name,
     });
 
-    ctx.sendToClient({
+    ctx.emit({
       type: "ui_surface_show",
       conversationId: ctx.conversationId,
       surfaceId,

package/src/daemon/conversation-tool-setup.ts

@@ -245,9 +245,7 @@ export function createToolExecutor(
   toolUseId?: string,
 ) => Promise<ToolExecutionResult> {
   // Register the conversation's sendToClient for browser screencast surface messages
-  registerConversationSender(ctx.conversationId, (msg) =>
-    ctx.sendToClient(msg),
-  );
+  registerConversationSender(ctx.conversationId, (msg) => ctx.emit(msg));
 
   // Execution-layer allowlist gate (`subagentToolGateMode === "execution"`,
   // see {@link SubagentToolGateMode}): rejects non-allowlisted calls BEFORE
@@ -440,7 +438,7 @@ export function createToolExecutor(
       sendToClient: (msg) => {
         // Tool context's sendToClient uses a loose { type: string; [key: string]: unknown }
         // signature, but at runtime these are always AssistantEvent instances.
-        ctx.sendToClient(msg as AssistantEvent);
+        ctx.emit(msg as AssistantEvent);
         if (msg.type === "ui_surface_show") {
           // The tool-context sendToClient signature is loose, so the show
           // message's fields are untyped here; map them through the same

package/src/daemon/conversation.ts

@@ -319,7 +319,21 @@ export class Conversation {
   /** @internal */ prompter: PermissionPrompter;
   /** @internal */ secretPrompter: SecretPrompter;
   private executor: ToolExecutor;
-  /** @internal */ sendToClient: (msg: AssistantEvent) => void;
+  /**
+   * The conversation's event sink, fixed for its whole life. Top-level
+   * conversations deliver to the SSE hub, so every subscribed client sees
+   * every event without any per-turn wiring; a subagent's sink re-envelopes
+   * its events under the parent conversation. Reached only through
+   * {@link emit}, which also notifies {@link addEventObserver} observers.
+   */
+  private readonly sendToClient: (msg: AssistantEvent) => void;
+  /**
+   * Observers notified after every {@link emit}, in registration order. An
+   * observer sees the event after the sink delivered it, so anything it does
+   * in response (e.g. voice auto-resolving a confirmation) lands on the wire
+   * after the event itself.
+   */
+  private readonly eventObservers = new Set<(msg: AssistantEvent) => void>();
   /** @internal */ workingDir: string;
   /** @internal */ allowedToolNames?: Set<string>;
   /**
@@ -435,7 +449,18 @@ export class Conversation {
    * @internal
    */
   currentCallSite?: LLMCallSite;
-  /** @internal */ hasNoClient = false;
+  /**
+   * Whether no human is present to see UI or answer prompts. Derived from the
+   * in-flight turn's interactivity ({@link currentTurnIsNonInteractive}); a
+   * conversation with no turn in flight has no client. Presence is a property
+   * of the turn, never of where events are delivered, so there is no setter:
+   * dispatch paths declare interactivity per turn (`isInteractive` on
+   * `runAgentLoop`, or a wake's pin), and this reads it.
+   * @internal
+   */
+  get hasNoClient(): boolean {
+    return this.currentTurnIsNonInteractive ?? true;
+  }
   /**
    * For subagent conversations, the id of the parent that spawned this one; set
    * once at construction and never reassigned. `undefined` for top-level
@@ -757,10 +782,10 @@ export class Conversation {
     this.workingDir = workingDir;
     this.sendToClient = sendToClient;
     this.graphMemory = new ConversationGraphMemory(conversationId);
-    this.prompter = new PermissionPrompter(sendToClient);
+    // The prompter emits through the conversation so its confirmation_request
+    // reaches the sink and every observer (voice policy) like any other event.
+    this.prompter = new PermissionPrompter((msg) => this.emit(msg));
     this.prompter.setOnStateChanged((requestId, state, source, toolUseId) => {
-      // Route through emitConfirmationStateChanged so the event reaches
-      // the client via sendToClient (wired to the SSE hub for HTTP conversations).
       this.emitConfirmationStateChanged({
         conversationId: this.conversationId,
         requestId,
@@ -1489,31 +1514,55 @@ export class Conversation {
     await this.loadFromDb();
   }
 
-  updateClient(
-    sendToClient: (msg: AssistantEvent) => void,
-    hasNoClient = false,
-  ): void {
-    this.sendToClient = sendToClient;
-    this.hasNoClient = hasNoClient;
-    this.prompter.updateSender(sendToClient);
-
-    // Replay last activity state so a reconnecting client sees the current phase
-    // instead of being stuck on the last state it received before disconnection.
-    if (!hasNoClient && this.lastActivityStateMsg) {
+  /**
+   * Deliver an event through the conversation's sink, then to every observer.
+   * The single emission point for conversation-level events (activity state,
+   * confirmation prompts and state, notifier output, out-of-turn pushes); the
+   * agent loop's own stream rides its per-turn `onEvent`, which defaults to
+   * this when the caller passes none.
+   */
+  readonly emit = (msg: AssistantEvent): void => {
+    try {
+      this.sendToClient(msg);
+    } catch (err) {
+      log.warn(
+        { err, conversationId: this.conversationId, type: msg.type },
+        "conversation sink threw",
+      );
+    }
+    for (const observer of this.eventObservers) {
       try {
-        sendToClient(this.lastActivityStateMsg);
+        observer(msg);
       } catch (err) {
         log.warn(
-          { err, conversationId: this.conversationId },
-          "Failed to replay activity state on client reconnection",
+          { err, conversationId: this.conversationId, type: msg.type },
+          "conversation event observer threw",
         );
       }
     }
+  };
+
+  /**
+   * Observe every event this conversation emits, after the sink delivered it.
+   * For policy layered on delivery (voice auto-resolves approval prompts it
+   * has no UI for), not for delivery itself. Returns the disposer.
+   */
+  addEventObserver(observer: (msg: AssistantEvent) => void): () => void {
+    this.eventObservers.add(observer);
+    return () => {
+      this.eventObservers.delete(observer);
+    };
   }
 
-  /** Returns the current sendToClient reference for identity comparison. */
-  getCurrentSender(): (msg: AssistantEvent) => void {
-    return this.sendToClient;
+  /**
+   * Re-emit the last activity state so a client that reconnected mid-phase
+   * sees the current phase instead of the last one it received before
+   * disconnecting. The send route calls this on every interactive send.
+   */
+  replayActivityState(): void {
+    if (this.lastActivityStateMsg) {
+      this.emit(this.lastActivityStateMsg);
+    }
   }
 
   setSubagentAllowedTools(tools: Set<string> | undefined): void {
@@ -1801,7 +1850,7 @@ export class Conversation {
   } {
     return enqueueMessageImpl(this, {
       ...options,
-      onEvent: options.onEvent ?? this.sendToClient,
+      onEvent: options.onEvent ?? this.emit,
     });
   }
 
@@ -1976,14 +2025,7 @@ export class Conversation {
       type: "confirmation_state_changed",
       ...params,
     } as AssistantEvent;
-    try {
-      this.sendToClient(msg);
-    } catch (err) {
-      log.warn(
-        { err, conversationId: this.conversationId },
-        "sendToClient threw in emitConfirmationStateChanged",
-      );
-    }
+    this.emit(msg);
   }
 
   emitActivityState(
@@ -2008,14 +2050,7 @@ export class Conversation {
       ...(statusText ? { statusText } : {}),
     } as AssistantEvent;
     this.lastActivityStateMsg = msg;
-    try {
-      this.sendToClient(msg);
-    } catch (err) {
-      log.warn(
-        { err, conversationId: this.conversationId },
-        "sendToClient threw in emitActivityState",
-      );
-    }
+    this.emit(msg);
   }
 
   /**
@@ -2069,7 +2104,7 @@ export class Conversation {
     onEvent?: (msg: AssistantEvent) => void,
   ): void {
     try {
-      (onEvent ?? this.sendToClient)({
+      (onEvent ?? this.emit)({
         type: "context_window_usage",
         conversationId: this.conversationId,
         tokens,
@@ -2421,11 +2456,11 @@ export class Conversation {
     ) {
       await this.agentLoop.compactionCircuit.recordOutcome(
         result.summaryFailed,
-        this.sendToClient,
+        this.emit,
       );
     }
     if (result.compacted) {
-      await applyCompactionResult(this, result, this.sendToClient, null, {
+      await applyCompactionResult(this, result, this.emit, null, {
         slackContextCompactionWatermarkTs:
           fixedBoundarySlackWatermarkTs ??
           getSlackCompactionWatermarkForPrefix(
@@ -2681,6 +2716,8 @@ export class Conversation {
       titleText?: string;
       /** See {@link runAgentLoopImpl} — hidden machine-signal turn marker. */
       isHiddenPrompt?: boolean;
+      /** See {@link runAgentLoopImpl}: triggering row's daemon-authored kind. */
+      messageKind?: string;
       /**
        * See {@link runAgentLoopImpl}: the row the end-of-turn reply
        * notification treats as the prompt this turn answers.
@@ -2722,7 +2759,7 @@ export class Conversation {
       this,
       content,
       userMessageId,
-      onEvent ?? this.sendToClient,
+      onEvent ?? this.emit,
       rest,
     );
   }
@@ -2748,7 +2785,7 @@ export class Conversation {
     this.cacheWarmAbort = undefined;
     return processMessageImpl(this, {
       ...options,
-      onEvent: options.onEvent ?? this.sendToClient,
+      onEvent: options.onEvent ?? this.emit,
     });
   }
 

package/src/daemon/doordash-steps.ts

@@ -130,7 +130,7 @@ function pushStepsUpdate(
   };
   const updatedData = { ...card, templateData: updatedTemplateData };
   stored.data = updatedData;
-  ctx.sendToClient({
+  ctx.emit({
     type: "ui_surface_update",
     conversationId: ctx.conversationId,
     surfaceId: SURFACE_ID,
@@ -218,7 +218,7 @@ export function updateDoordashProgress(
       },
     } satisfies CardSurfaceData;
     ctx.surfaceState.set(SURFACE_ID, { surfaceType: "card", data });
-    ctx.sendToClient({
+    ctx.emit({
       type: "ui_surface_show",
       conversationId: ctx.conversationId,
       surfaceId: SURFACE_ID,

package/src/daemon/lifecycle.ts

@@ -4,6 +4,7 @@ import { reconcileCallsOnStartup } from "../calls/call-recovery.js";
 import { TwilioVoiceProvider } from "../calls/twilio-provider.js";
 import { expireInteractionBoundGuardianRequests } from "../channels/gateway-guardian-requests.js";
 import { initFeatureFlagOverrides } from "../config/assistant-feature-flags.js";
+import { getBalancedModelExperimentArm } from "../config/balanced-model-experiment.js";
 import { setIngressPublicBaseUrl, validateEnv } from "../config/env.js";
 import {
   hasPendingDefaultWorkspaceConfig,
@@ -224,9 +225,21 @@ export async function runDaemon(): Promise<void> {
   // a failed fetch leaves the cache unset and resolves `os-beta` to its
   // registry default `false`, which would remove the user's profile and reset
   // their selection.
+  // A balanced-model experiment arm arriving in this same load gets the same
+  // invalidation. HTTP binds before this resolves, so a client that fetched
+  // profiles in that window holds the shipped model; the arm moves nothing on
+  // disk, so the reconcile above would not report a change and the listener's
+  // own comparison sees the arm on both sides of its refresh.
+  const balancedArmBeforeInit = getBalancedModelExperimentArm();
   void initFeatureFlagOverrides()
     .then((loaded) => {
-      if (loaded && reconcileFlagGatedProfiles()) {
+      if (!loaded) {
+        return;
+      }
+      const profilesChanged = reconcileFlagGatedProfiles();
+      const balancedArmChanged =
+        getBalancedModelExperimentArm() !== balancedArmBeforeInit;
+      if (profilesChanged || balancedArmChanged) {
         publishConfigChanged();
       }
     })

package/src/daemon/process-message.ts

@@ -69,7 +69,6 @@ import {
   preactivateHostProxySkills,
   shouldAttachHostProxyForCapability,
 } from "./host-proxy-preactivation.js";
-import { bindInteractiveTurnSender } from "./interactive-turn-sender.js";
 import type { SubagentToolGateMode } from "./tool-setup-types.js";
 import { restingTrust } from "./trust-context-types.js";
 
@@ -709,11 +708,6 @@ export async function processMessage(
     };
   }
 
-  const restoreSender =
-    options?.isInteractive === true
-      ? bindInteractiveTurnSender(conversation)
-      : undefined;
-
   const restoreToolScope = applyTurnToolAllowlist(conversation, options);
   try {
     await conversation.runAgentLoop(resolvedContent, messageId, {
@@ -731,7 +725,6 @@ export async function processMessage(
     });
   } finally {
     restoreToolScope();
-    restoreSender?.();
   }
 
   // Read the just-finished turn's outcome from the stamp `runAgentLoop`'s
@@ -790,11 +783,6 @@ export async function processMessageInBackground(
     return { messageId };
   }
 
-  const restoreSender =
-    options?.isInteractive === true
-      ? bindInteractiveTurnSender(conversation)
-      : undefined;
-
   const restoreToolScope = applyTurnToolAllowlist(conversation, options);
   conversation
     .runAgentLoop(content, messageId, {
@@ -809,7 +797,6 @@ export async function processMessageInBackground(
     })
     .finally(() => {
       restoreToolScope();
-      restoreSender?.();
     })
     .catch((err) => {
       log.error({ err, conversationId }, "Background agent loop failed");

package/src/daemon/windows-compiled-entry.ts

@@ -0,0 +1,4 @@
+import "../windows-compiled-logger.js";
+import "../live-voice/windows-compiled-live-voice.js";
+
+await import("./main.js");