@vellumai/assistant 0.6.1 → 0.6.2

package/src/daemon/conversation-messaging.ts

@@ -41,6 +41,7 @@ import type {
   ServerMessage,
   UserMessageAttachment,
 } from "./message-protocol.js";
+import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 
 const log = getLogger("conversation-messaging");
 
@@ -222,6 +223,7 @@ export function enqueueMessage(
   metadata?: Record<string, unknown>,
   options?: { isInteractive?: boolean },
   displayContent?: string,
+  transport?: ConversationTransportMetadata,
 ): { queued: boolean; requestId: string; rejected?: boolean } {
   if (!ctx.processing) {
     return { queued: false, requestId };
@@ -246,6 +248,7 @@ export function enqueueMessage(
     turnChannelContext,
     turnInterfaceContext,
     isInteractive: options?.isInteractive,
+    transport,
     displayContent,
     sentAt: Date.now(),
   });

package/src/daemon/conversation-process.ts

@@ -15,7 +15,11 @@ import type {
   TurnChannelContext,
   TurnInterfaceContext,
 } from "../channels/types.js";
-import { parseChannelId, parseInterfaceId } from "../channels/types.js";
+import {
+  parseChannelId,
+  parseInterfaceId,
+  supportsHostProxy,
+} from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
 import type { ContextWindowResult } from "../context/window-manager.js";
 import { listPendingRequestsByConversationScope } from "../memory/canonical-guardian-store.js";
@@ -44,6 +48,7 @@ import type {
   UserMessageAttachment,
 } from "./message-protocol.js";
 import type { TraceEmitter } from "./trace-emitter.js";
+import { buildTransportHints } from "./transport-hints.js";
 import { resolveVerificationSessionIntent } from "./verification-session-intent.js";
 
 const log = getLogger("conversation-process");
@@ -157,6 +162,8 @@ export interface ProcessConversationContext {
   ): void;
   /** Force context compaction regardless of threshold/cooldown. */
   forceCompact(): Promise<ContextWindowResult>;
+  /** Set transport-derived hints for the conversation. */
+  setTransportHints(hints: string[] | undefined): void;
 }
 
 function resolveQueuedTurnContext(
@@ -290,6 +297,15 @@ export async function drainQueue(
     conversation.setTurnInterfaceContext(queuedInterfaceCtx);
   }
 
+  // Apply transport hints from the queued message so each turn uses the
+  // transport metadata that arrived with its message. Messages without
+  // transport (subagent notifications, surface actions, etc.) inherit the
+  // conversation's existing hints — clearing them would erase the user's
+  // environment context for internal turns.
+  if (next.transport) {
+    conversation.setTransportHints(buildTransportHints(next.transport));
+  }
+
   // Non-interactive queued messages (channel requests) must not execute tools
   // via the desktop host proxy. Clear proxy availability so isAvailable()
   // returns false and tool execution falls back to local.
@@ -302,7 +318,7 @@ export async function drainQueue(
     const interfaceCtx =
       queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
     const sourceInterface = interfaceCtx?.userMessageInterface;
-    if (sourceInterface === "macos") {
+    if (sourceInterface && supportsHostProxy(sourceInterface)) {
       conversation.restoreProxyAvailability();
       conversation.addPreactivatedSkillId("computer-use");
     }

package/src/daemon/conversation-queue-manager.ts

@@ -14,6 +14,7 @@ import type {
   ServerMessage,
   UserMessageAttachment,
 } from "./message-protocol.js";
+import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 
 const log = getLogger("conversation-queue");
 
@@ -29,6 +30,8 @@ export interface QueuedMessage {
   turnInterfaceContext?: TurnInterfaceContext;
   /** When false, the turn has no interactive user and should skip clarification prompts. */
   isInteractive?: boolean;
+  /** Transport metadata snapshot captured at enqueue time, applied when this message becomes active. */
+  transport?: ConversationTransportMetadata;
   /** Original user message text to persist to DB when recording intent stripping produced a different `content`. */
   displayContent?: string;
   /** Wall-clock time (ms since epoch) when the message was enqueued, used as the display timestamp. */
@@ -155,6 +158,11 @@ function estimateItemBytes(item: QueuedMessage): number {
     bytes += a.data.length * 2;
     if (a.extractedText) bytes += a.extractedText.length * 2;
   }
+  // Include transport metadata in the estimate so large transport
+  // payloads (e.g. hostHomeDir, hostUsername) count against the budget.
+  if (item.transport) {
+    bytes += JSON.stringify(item.transport).length * 2;
+  }
   // Small fixed overhead for metadata, pointers, etc. (not worth
   // measuring precisely — the content/attachment data dominates).
   bytes += 512;

package/src/daemon/conversation-runtime-assembly.ts

@@ -6,7 +6,7 @@
  */
 
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 
 import { type ChannelId, parseInterfaceId } from "../channels/types.js";
 import { getAppDirPath, listAppFiles } from "../memory/app-store.js";
@@ -533,7 +533,9 @@ export function stripNowScratchpad(messages: Message[]): Message[] {
 // PKB (Personal Knowledge Base) injection
 // ---------------------------------------------------------------------------
 
-const PKB_FILES = ["INDEX.md", "essentials.md", "threads.md", "buffer.md"];
+const PKB_DEFAULT_FILES = ["INDEX.md", "essentials.md", "threads.md", "buffer.md"];
+
+const AUTOINJECT_FILENAME = "_autoinject.md";
 
 /** Max buffer.md lines injected into prompts — keeps context bounded even when filing is off. */
 const MAX_BUFFER_LINES = 50;
@@ -547,9 +549,35 @@ const PKB_NUDGE =
   "Use `remember` for every new fact you learn, immediately, no batching.";
 
 /**
- * Read the always-loaded PKB files (INDEX, essentials, threads, buffer)
- * and append a nudge encouraging the assistant to proactively read topic
- * files and use `remember` aggressively.
+ * Read `_autoinject.md` from the PKB directory and return the list of
+ * filenames to inject.
+ *
+ * - Returns `null` when the file is missing or unreadable — callers
+ *   should fall back to the hardcoded defaults.
+ * - Returns `[]` when the file exists but has no entries (empty or
+ *   comments only) — an explicit opt-out meaning "inject nothing."
+ */
+export function readAutoinjectList(pkbDir: string): string[] | null {
+  const filePath = join(pkbDir, AUTOINJECT_FILENAME);
+  if (!existsSync(filePath)) return null;
+  try {
+    const raw = stripCommentLines(readFileSync(filePath, "utf-8"));
+    const files = raw
+      .split("\n")
+      .map((l) => l.trim())
+      .filter((l) => l.length > 0);
+    return files.length > 0 ? files : [];
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read the always-loaded PKB files and append a nudge encouraging the
+ * assistant to proactively read topic files and use `remember` aggressively.
+ *
+ * Which files are loaded is determined by `pkb/_autoinject.md` (one filename
+ * per line). Falls back to the built-in defaults when that file is absent.
  *
  * Returns the concatenated content ready for injection, or `null` if all
  * files are missing or empty.
@@ -558,9 +586,14 @@ export function readPkbContext(): string | null {
   const pkbDir = join(getWorkspaceDir(), "pkb");
   if (!existsSync(pkbDir)) return null;
 
+  const filesToInject = readAutoinjectList(pkbDir) ?? PKB_DEFAULT_FILES;
+
   const parts: string[] = [];
-  for (const file of PKB_FILES) {
-    const filePath = join(pkbDir, file);
+  for (const file of filesToInject) {
+    // Path traversal guard: reject entries that escape the pkb directory
+    const filePath = resolve(pkbDir, file);
+    if (!filePath.startsWith(pkbDir + "/")) continue;
+
     if (!existsSync(filePath)) continue;
     try {
       let content = stripCommentLines(readFileSync(filePath, "utf-8")).trim();
@@ -599,6 +632,7 @@ export function injectPkbContext(message: Message, content: string): Message {
     if (
       block.type === "text" &&
       (block.text.startsWith("<memory") ||
+        block.text.startsWith("</memory_image>") ||
         block.text.startsWith("<memory_context"))
     ) {
       insertIdx = i + 1;
@@ -1051,6 +1085,7 @@ const RUNTIME_INJECTION_PREFIXES = [
   "<now_scratchpad>", // backward-compat: strip legacy blocks from pre-rename history
   "<pkb>",
   "<transport_hints>",
+  "<system_notice>One or more tool calls returned an error.",
 ];
 
 /**
@@ -1085,6 +1120,28 @@ export function findLastInjectedNowContent(messages: Message[]): string | null {
   return null;
 }
 
+/**
+ * Extract the most recently injected PKB content from the message history.
+ * Returns null if no PKB injection is found.
+ */
+export function findLastInjectedPkbContent(
+  messages: Message[],
+): string | null {
+  const prefix = "<pkb>\n";
+  const suffix = "\n</pkb>";
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role !== "user") continue;
+    for (const block of msg.content) {
+      if (block.type === "text" && block.text.startsWith(prefix)) {
+        const end = block.text.lastIndexOf(suffix);
+        if (end > prefix.length) return block.text.slice(prefix.length, end);
+      }
+    }
+  }
+  return null;
+}
+
 /**
  * Controls which runtime injections are applied.
  *

package/src/daemon/conversation-surfaces.ts

@@ -9,6 +9,10 @@ import {
   resolveAppDir,
   updateApp,
 } from "../memory/app-store.js";
+import {
+  getMessages,
+  updateMessageContent,
+} from "../memory/conversation-crud.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
 import { isPlainObject } from "../util/object.js";
@@ -26,11 +30,69 @@ import type {
   UiSurfaceShow,
 } from "./message-protocol.js";
 import { INTERACTIVE_SURFACE_TYPES } from "./message-protocol.js";
+import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 import type { UserMessageAttachment } from "./message-types/shared.js";
 
 const log = getLogger("conversation-surfaces");
 
 const MAX_UNDO_DEPTH = 10;
+
+/**
+ * Mark a `ui_surface` content block as completed in the database so that
+ * history reconstruction preserves the completion state.  Also updates
+ * in-memory messages when available.
+ */
+export function markSurfaceCompleted(
+  ctx: { conversationId: string; messages?: Array<{ content: unknown }> },
+  surfaceId: string,
+  summary: string,
+): void {
+  // Update in-memory messages when available so subsequent reads within
+  // this session see the change without waiting for DB.
+  if (ctx.messages) {
+    for (let i = ctx.messages.length - 1; i >= 0; i--) {
+      const msg = ctx.messages[i];
+      if (!Array.isArray(msg.content)) continue;
+      for (const block of msg.content) {
+        const b = block as Record<string, unknown>;
+        if (b.type === "ui_surface" && b.surfaceId === surfaceId) {
+          b.completed = true;
+          b.completionSummary = summary;
+          break;
+        }
+      }
+    }
+  }
+
+  // Persist to DB.
+  const rows = getMessages(ctx.conversationId);
+  for (let r = rows.length - 1; r >= 0; r--) {
+    let parsed: unknown[];
+    try {
+      const result = JSON.parse(rows[r].content);
+      if (!Array.isArray(result)) continue;
+      parsed = result;
+    } catch {
+      // Some rows store plain text content (e.g. notification seeding) —
+      // skip them and keep scanning.
+      continue;
+    }
+    let found = false;
+    for (const pb of parsed) {
+      const rb = pb as Record<string, unknown>;
+      if (rb.type === "ui_surface" && rb.surfaceId === surfaceId) {
+        rb.completed = true;
+        rb.completionSummary = summary;
+        found = true;
+        break;
+      }
+    }
+    if (found) {
+      updateMessageContent(rows[r].id, JSON.stringify(parsed));
+      return;
+    }
+  }
+}
 const TASK_PROGRESS_TEMPLATE_FIELDS = ["title", "status", "steps"] as const;
 
 /**
@@ -226,6 +288,7 @@ export interface SurfaceConversationContext {
     metadata?: Record<string, unknown>,
     options?: { isInteractive?: boolean },
     displayContent?: string,
+    transport?: ConversationTransportMetadata,
   ): { queued: boolean; requestId: string; rejected?: boolean };
   getQueueDepth(): number;
   processMessage(
@@ -857,6 +920,7 @@ export function handleSurfaceAction(
       summary,
       submittedData: mergedData,
     });
+    markSurfaceCompleted(ctx, surfaceId, summary);
   }
 
   // Extract file attachments from action data so they are sent as proper
@@ -1442,6 +1506,7 @@ export async function surfaceProxyResolver(
         summary,
         submittedData: lastAction.data,
       });
+      markSurfaceCompleted(ctx, surfaceId, summary);
     } else {
       ctx.sendToClient({
         type: "ui_surface_dismiss",

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

@@ -89,7 +89,6 @@ export interface ToolSetupContext extends SurfaceConversationContext {
   assistantId?: string;
   currentRequestId?: string;
   workingDir: string;
-  sandboxOverride?: boolean;
   abortController: AbortController | null;
   /** When set, only tools in this set may execute during the current turn. */
   allowedToolNames?: Set<string>;
@@ -186,7 +185,6 @@ export function createToolExecutor(
           : undefined,
       onOutput,
       signal: ctx.abortController?.signal,
-      sandboxOverride: ctx.sandboxOverride,
       allowedToolNames: ctx.allowedToolNames,
       memoryScopeId: ctx.memoryPolicy.scopeId,
       forcePromptSideEffects: ctx.memoryPolicy.strictSideEffects,
@@ -371,7 +369,6 @@ export function createProxyApprovalCallback(
       allowlistOptions,
       scopeOptions,
       undefined,
-      undefined,
       ctx.conversationId,
     );
 

package/src/daemon/conversation.ts

@@ -114,6 +114,7 @@ import type {
   UsageStats,
   UserMessageAttachment,
 } from "./message-protocol.js";
+import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 import type {
   AssistantActivityState,
   ConfirmationStateChanged,
@@ -156,7 +157,6 @@ export class Conversation {
   /** @internal */ sendToClient: (msg: ServerMessage) => void;
   /** @internal */ eventBus = new EventBus<AssistantDomainEvents>();
   /** @internal */ workingDir: string;
-  /** @internal */ sandboxOverride?: boolean;
   /** @internal */ allowedToolNames?: Set<string>;
   /** @internal */ toolsDisabledDepth = 0;
   /** @internal */ preactivatedSkillIds?: string[];
@@ -540,10 +540,6 @@ export class Conversation {
     }
   }
 
-  setSandboxOverride(enabled: boolean | undefined): void {
-    this.sandboxOverride = enabled;
-  }
-
   setSubagentAllowedTools(tools: Set<string> | undefined): void {
     this.subagentAllowedTools = tools;
   }
@@ -609,6 +605,7 @@ export class Conversation {
     metadata?: Record<string, unknown>,
     options?: { isInteractive?: boolean },
     displayContent?: string,
+    transport?: ConversationTransportMetadata,
   ): { queued: boolean; requestId: string; rejected?: boolean } {
     return enqueueMessageImpl(
       this,
@@ -621,6 +618,7 @@ export class Conversation {
       metadata,
       options,
       displayContent,
+      transport,
     );
   }
 

package/src/daemon/handlers/conversations.ts

@@ -4,6 +4,7 @@ import {
   type InterfaceId,
   parseChannelId,
   parseInterfaceId,
+  supportsHostProxy,
 } from "../../channels/types.js";
 import { getConfig } from "../../config/loader.js";
 import {
@@ -301,7 +302,7 @@ export async function handleConversationCreate(
     // Only create the host bash proxy for desktop client interfaces that can
     // execute commands on the user's machine. Set before updateClient so
     // updateClient's call to hostBashProxy.updateSender targets the new proxy.
-    if (transportInterface === "macos") {
+    if (supportsHostProxy(transportInterface)) {
       const proxy = new HostBashProxy(sendEvent, (requestId) => {
         pendingInteractions.resolve(requestId);
       });

package/src/daemon/handlers/shared.ts

@@ -81,6 +81,8 @@ export interface HistorySurface {
   data: Record<string, unknown>;
   actions?: Array<{ id: string; label: string; style?: string }>;
   display?: string;
+  completed?: boolean;
+  completionSummary?: string;
 }
 
 export interface RenderedHistoryContent {
@@ -281,6 +283,11 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
           : {},
         actions: Array.isArray(block.actions) ? block.actions : undefined,
         display: typeof block.display === "string" ? block.display : undefined,
+        completed: block.completed === true ? true : undefined,
+        completionSummary:
+          typeof block.completionSummary === "string"
+            ? block.completionSummary
+            : undefined,
       };
       surfaces.push(surface);
       contentOrder.push(`surface:${surfaces.length - 1}`);

package/src/daemon/lifecycle.ts

@@ -5,6 +5,7 @@ import { reconcileCallsOnStartup } from "../calls/call-recovery.js";
 import { setRelayBroadcast } from "../calls/relay-server.js";
 import { TwilioConversationRelayProvider } from "../calls/twilio-provider.js";
 import { setVoiceBridgeDeps } from "../calls/voice-session-bridge.js";
+import { initFeatureFlagOverrides } from "../config/assistant-feature-flags.js";
 import {
   getPlatformAssistantId,
   getQdrantHttpPortEnv,
@@ -269,6 +270,15 @@ export async function runDaemon(): Promise<void> {
     const signingKey = resolveSigningKey();
     initAuthSigningKey(signingKey);
 
+    // Pre-populate the feature flag cache from the gateway so all
+    // subsequent sync isAssistantFeatureFlagEnabled() calls have data.
+    // Fired non-blocking so a slow or unreachable gateway doesn't delay
+    // daemon startup (the fetch has a 10s timeout that would otherwise
+    // stall the critical path).
+    void initFeatureFlagOverrides().catch((err) =>
+      log.warn({ err }, "Background feature flag init failed"),
+    );
+
     seedInterfaceFiles();
 
     log.info("Daemon startup: installing templates and initializing DB");
@@ -690,7 +700,7 @@ export async function runDaemon(): Promise<void> {
           seedUninstalledCatalogSkillMemories,
         } = await import("../memory/graph/capability-seed.js");
         seedSkillGraphNodes();
-        seedCliGraphNodes();
+        await seedCliGraphNodes();
         void seedUninstalledCatalogSkillMemories().catch((err) =>
           log.warn(
             { err },
@@ -763,6 +773,11 @@ export async function runDaemon(): Promise<void> {
           },
           routingIntent: schedule.routingIntent,
           routingHints: schedule.routingHints,
+          conversationMetadata: {
+            groupId: "system:scheduled",
+            scheduleJobId: schedule.id,
+            source: "schedule",
+          },
           dedupeKey: `schedule:notify:${schedule.id}:${Date.now()}`,
           throwOnError: true,
         });
@@ -782,6 +797,11 @@ export async function runDaemon(): Promise<void> {
             scheduleId: schedule.id,
             name: schedule.name,
           },
+          conversationMetadata: {
+            groupId: "system:scheduled",
+            scheduleJobId: schedule.id,
+            source: "schedule",
+          },
           dedupeKey: `schedule:complete:${schedule.id}:${Date.now()}`,
         });
       },

package/src/daemon/message-types/conversations.ts

@@ -309,6 +309,10 @@ export interface HistoryResponseSurface {
     data?: Record<string, unknown>;
   }>;
   display?: string;
+  /** True when the surface was completed (e.g. form submitted, action taken). */
+  completed?: boolean;
+  /** Human-readable summary shown in the completion chip. */
+  completionSummary?: string;
 }
 
 export interface HistoryResponse {

package/src/daemon/message-types/messages.ts

@@ -151,7 +151,6 @@ export interface ConfirmationRequest {
     newContent: string;
     isNewFile: boolean;
   };
-  sandboxed?: boolean;
   conversationId?: string;
   /** When false, the client should hide "always allow" / trust-rule persistence affordances. */
   persistentDecisionsAllowed?: boolean;

package/src/daemon/message-types/notifications.ts

@@ -27,6 +27,18 @@ export interface NotificationConversationCreated {
    * and should only be surfaced by clients bound to this guardian identity.
    */
   targetGuardianPrincipalId?: string;
+  /**
+   * Conversation group identifier propagated from the signal producer.
+   * Clients use this to place the conversation in the correct sidebar folder
+   * (e.g. "system:scheduled" for schedule completion threads).
+   */
+  groupId?: string;
+  /**
+   * Semantic source of the conversation (e.g. "schedule", "reminder").
+   * Allows clients to override the default "notification" source so the
+   * conversation is attributed correctly.
+   */
+  source?: string;
 }
 
 /** Client ack sent after UNUserNotificationCenter.add() completes (or fails). */

package/src/daemon/message-types/settings.ts

@@ -34,11 +34,21 @@ export interface AvatarUpdated {
   avatarPath: string;
 }
 
+/** Sent by the daemon when workspace config.json changes on disk. */
+export interface ConfigChanged {
+  type: "config_changed";
+}
+
 /** Sent by the daemon when sounds config or sound files change on disk. */
 export interface SoundsConfigUpdated {
   type: "sounds_config_updated";
 }
 
+/** Sent by the daemon when feature flag files change on disk. */
+export interface FeatureFlagsChanged {
+  type: "feature_flags_changed";
+}
+
 /** Response to a generate_avatar request indicating success or failure. */
 export interface GenerateAvatarResponse {
   type: "generate_avatar_response";
@@ -56,5 +66,7 @@ export type _SettingsClientMessages =
 export type _SettingsServerMessages =
   | ClientSettingsUpdate
   | AvatarUpdated
+  | ConfigChanged
   | SoundsConfigUpdated
+  | FeatureFlagsChanged
   | GenerateAvatarResponse;

package/src/daemon/server.ts

@@ -17,6 +17,7 @@ import {
   type InterfaceId,
   parseChannelId,
   parseInterfaceId,
+  supportsHostProxy,
 } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
 import { onContactChange } from "../contacts/contact-events.js";
@@ -91,6 +92,7 @@ import type {
   ServerMessage,
   UserMessageAttachment,
 } from "./message-protocol.js";
+import { buildTransportHints } from "./transport-hints.js";
 
 const log = getLogger("server");
 
@@ -373,28 +375,7 @@ export class DaemonServer {
       { channelId: transport.channelId },
       "Transport metadata received",
     );
-
-    // Build enriched hints: interface ID first, then host environment (macOS
-    // only), then any client-provided hints.
-    const enrichedHints: string[] = [];
-
-    const interfaceLabel = parseInterfaceId(transport.interfaceId) ?? "vellum";
-    enrichedHints.push(`User is messaging from interface: ${interfaceLabel}`);
-
-    if (transport.interfaceId === "macos") {
-      if (transport.hostHomeDir) {
-        enrichedHints.push(`Host home directory: ${transport.hostHomeDir}`);
-      }
-      if (transport.hostUsername) {
-        enrichedHints.push(`Host username: ${transport.hostUsername}`);
-      }
-    }
-
-    if (transport.hints) {
-      enrichedHints.push(...transport.hints);
-    }
-
-    conversation.setTransportHints(enrichedHints);
+    conversation.setTransportHints(buildTransportHints(transport));
   }
 
   constructor() {
@@ -548,10 +529,18 @@ export class DaemonServer {
     }
   }
 
+  private broadcastConfigChanged(): void {
+    this.broadcast({ type: "config_changed" });
+  }
+
   private broadcastSoundsConfigUpdated(): void {
     this.broadcast({ type: "sounds_config_updated" });
   }
 
+  private broadcastFeatureFlagsChanged(): void {
+    this.broadcast({ type: "feature_flags_changed" });
+  }
+
   private broadcastAvatarUpdated(): void {
     this.broadcast({
       type: "avatar_updated",
@@ -748,6 +737,8 @@ export class DaemonServer {
       () => this.broadcastIdentityChanged(),
       () => this.broadcastSoundsConfigUpdated(),
       () => this.broadcastAvatarUpdated(),
+      () => this.broadcastConfigChanged(),
+      () => this.broadcastFeatureFlagsChanged(),
     );
 
     this.appSourceWatcher.start((appId) => this.handleAppSourceChange(appId));
@@ -978,7 +969,13 @@ export class DaemonServer {
       }
       this.evictor.touch(conversationId);
     } else {
-      this.applyTransportMetadata(conversation, options);
+      // Only apply transport metadata when the conversation is idle.
+      // When processing, the hints are stored on the queued message and
+      // will be applied at dequeue time — applying them here would
+      // overwrite the in-flight conversation's transportHints.
+      if (!conversation.isProcessing()) {
+        this.applyTransportMetadata(conversation, options);
+      }
       this.evictor.touch(conversationId);
     }
     return conversation;
@@ -1091,7 +1088,7 @@ export class DaemonServer {
     // Guard: don't replace an active proxy during concurrent turn races —
     // another request may have started processing between the isProcessing()
     // check above and the await on ensureActorScopedHistory().
-    if (resolvedInterface === "macos") {
+    if (supportsHostProxy(resolvedInterface)) {
       if (!conversation.isProcessing() || !conversation.hostBashProxy) {
         conversation.setHostBashProxy(
           new HostBashProxy(conversation.getCurrentSender(), (requestId) => {