@vellumai/assistant 0.8.0 → 0.8.1

package/src/daemon/conversation-process.ts

@@ -12,6 +12,7 @@ import {
   createUserMessage,
 } from "../agent/message-types.js";
 import {
+  type InterfaceId,
   parseChannelId,
   parseInterfaceId,
   type TurnChannelContext,
@@ -179,7 +180,9 @@ export interface ProcessConversationContext {
     statusText?: string,
   ): void;
   /** Force context compaction regardless of threshold/cooldown. */
-  forceCompact(): Promise<ContextWindowResult>;
+  forceCompact(options?: {
+    targetInputTokensOverride?: number;
+  }): Promise<ContextWindowResult>;
   /** Set transport-derived hints for the conversation. */
   setTransportHints(hints: string[] | undefined): void;
   /** IANA timezone reported by the active client for the current turn. */
@@ -195,6 +198,13 @@ export interface ProcessConversationContext {
   applyClientTimezoneFromTransport(
     transport: ConversationTransportMetadata,
   ): void;
+  /**
+   * Instantiate host proxies for capabilities that have become reachable
+   * mid-queue (e.g. a macOS client connected after a web turn was enqueued
+   * without a proxy). Called from drain paths before preactivation so skills
+   * are only activated when the proxy that services them is present.
+   */
+  ensureHostProxiesForTurn(sourceInterface: InterfaceId | undefined): void;
 }
 
 function resolveQueuedTurnContext(
@@ -432,19 +442,19 @@ async function drainSingleMessage(
     conversation.applyClientTimezoneFromTransport(next.transport);
   }
 
-  // Re-preactivate host-proxy skills for interactive desktop turns. The
-  // dequeue path reset `preactivatedSkillIds` above, so without these
-  // re-adds the relevant skill tools wouldn't be projected to the LLM
-  // for queued messages 2+ even though the underlying proxies (HostCuProxy,
-  // HostAppControlProxy) are still attached. Mirrors the per-message
-  // instantiation block in `conversation-routes.ts` / `process-message.ts`.
+  // Re-attach and re-preactivate host-proxy skills for interactive turns.
+  // The dequeue path reset `preactivatedSkillIds` above; without these
+  // re-adds the relevant skill tools won't be projected to the LLM for
+  // queued messages 2+. Also instantiates proxies that may not have been
+  // present when the message was first enqueued (e.g. a macOS client
+  // connects between enqueue and drain). Mirrors the per-message block in
+  // `conversation-routes.ts` / `process-message.ts`.
   if (next.isInteractive !== false) {
     const interfaceCtx =
       queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
-    preactivateHostProxySkills(
-      conversation,
-      interfaceCtx?.userMessageInterface,
-    );
+    const sourceInterface = interfaceCtx?.userMessageInterface;
+    conversation.ensureHostProxiesForTurn(sourceInterface);
+    preactivateHostProxySkills(conversation, sourceInterface);
   }
 
   // Snapshot persona context at turn start so later tool turns can't pick up
@@ -628,7 +638,9 @@ async function drainSingleMessage(
         "assistant_turn",
         next.requestId,
       );
-      const result = await conversation.forceCompact();
+      const result = await conversation.forceCompact({
+        targetInputTokensOverride: slashResult.targetInputTokensOverride,
+      });
       const responseText = formatCompactResult(result);
 
       const assistantMsg = createAssistantMessage(responseText);
@@ -875,15 +887,14 @@ async function drainBatch(
     conversation.applyClientTimezoneFromTransport(head.transport);
   }
 
-  // Re-preactivate host-proxy skills for interactive desktop turns.
+  // Re-attach and re-preactivate host-proxy skills for interactive turns.
   // Mirrors the single-message path exactly — sourced from `head`.
   if (head.isInteractive !== false) {
     const interfaceCtx =
       queuedInterfaceCtx ?? conversation.getTurnInterfaceContext();
-    preactivateHostProxySkills(
-      conversation,
-      interfaceCtx?.userMessageInterface,
-    );
+    const sourceInterface = interfaceCtx?.userMessageInterface;
+    conversation.ensureHostProxiesForTurn(sourceInterface);
+    preactivateHostProxySkills(conversation, sourceInterface);
   }
 
   // Snapshot persona context at turn start so later tool turns can't pick up
@@ -1314,7 +1325,11 @@ export async function processMessage(
       );
       conversation.messages.push(assistantMsg);
 
-      onEvent({ type: "assistant_text_delta", text: replyText });
+      onEvent({
+        type: "assistant_text_delta",
+        text: replyText,
+        conversationId: conversation.conversationId,
+      });
       onEvent({
         type: "message_complete",
         conversationId: conversation.conversationId,
@@ -1474,7 +1489,9 @@ export async function processMessage(
         "assistant_turn",
         requestId,
       );
-      const result = await conversation.forceCompact();
+      const result = await conversation.forceCompact({
+        targetInputTokensOverride: slashResult.targetInputTokensOverride,
+      });
       const responseText = formatCompactResult(result);
 
       const assistantMsg = createAssistantMessage(responseText);

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

@@ -1641,12 +1641,15 @@ const RUNTIME_INJECTION_PREFIXES = [
   // blocks persist in history so the assistant retains temporal/actor grounding.
   "<memory_context __injected>",
   "<memory_context>", // backward-compat: strip legacy blocks from pre-__injected history
-  // NOTE: `<memory>` blocks (both the dynamic activation block from
-  // `injectTextBlock` and the static `memory-v2-static` injector) are
-  // intentionally NOT stripped — memory injections persist in history so
-  // the assistant retains intra-turn memory state. The activation pipeline
-  // dedupes via `everInjected`, and compaction handles aggregate growth, so
+  // The static `memory-v2-static` block (opens `<memory>\n…`) IS stripped
+  // so each compaction re-injects the freshest essentials/threads/recent/
+  // buffer view, matching the `<knowledge_base>` cadence. The dynamic
+  // activation block (opens `<memory __injected>…`) is intentionally NOT
+  // stripped — `startsWith("<memory>\n")` does not match it — so per-turn
+  // memory activations persist in history. The activation pipeline dedupes
+  // via `everInjected`, and compaction handles aggregate growth, so
   // accumulation does not cause unbounded context growth.
+  "<memory>\n",
   "<voice_call_control>",
   "<workspace_top_level>", // backward-compat: strip legacy workspace blocks
   // NOTE: <workspace> is intentionally NOT stripped — workspace context
@@ -1736,6 +1739,7 @@ export interface RuntimeInjectionBlocks {
   workspaceBlock?: string;
   nowScratchpadBlock?: string;
   pkbContextBlock?: string;
+  memoryV2StaticBlock?: string;
   /**
    * Composed output of every plugin-registered {@link Injector}, concatenated
    * in ascending `order`. Empty string when every injector opted out (returned
@@ -2153,6 +2157,7 @@ export async function applyRuntimeInjections(
   let nowScratchpadCaptured: string | undefined;
   let pkbContextCaptured: string | undefined;
   let pkbSystemReminderCaptured: string | undefined;
+  let memoryV2StaticCaptured: string | undefined;
   const initialTail = runMessages[runMessages.length - 1];
   const initialTailIsUser = !!initialTail && initialTail.role === "user";
   if (initialTailIsUser) {
@@ -2173,6 +2178,9 @@ export async function applyRuntimeInjections(
         case "pkb-reminder":
           pkbSystemReminderCaptured = block.text;
           break;
+        case "memory-v2-static":
+          memoryV2StaticCaptured = block.text;
+          break;
       }
     }
   }
@@ -2354,6 +2362,7 @@ export async function applyRuntimeInjections(
       workspaceBlock: workspaceCaptured,
       nowScratchpadBlock: nowScratchpadCaptured,
       pkbContextBlock: pkbContextCaptured,
+      memoryV2StaticBlock: memoryV2StaticCaptured,
       injectorChainBlock,
     },
   };

package/src/daemon/conversation-slash.ts

@@ -1,6 +1,12 @@
 import type { InterfaceId } from "../channels/types.js";
 import { resolveEffectiveContextWindow } from "../config/llm-context-resolution.js";
-import { getConfig } from "../config/loader.js";
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import {
+  getConfig,
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+} from "../config/loader.js";
 import { getConversationOverrideProfile } from "../memory/conversation-crud.js";
 import { PROVIDER_CATALOG } from "../providers/model-catalog.js";
 import { getConfiguredProviders } from "../providers/provider-availability.js";
@@ -8,7 +14,43 @@ import { getConfiguredProviders } from "../providers/provider-availability.js";
 export type SlashResolution =
   | { kind: "passthrough"; content: string }
   | { kind: "unknown"; message: string }
-  | { kind: "compact" };
+  | { kind: "compact"; targetInputTokensOverride?: number };
+
+const COMPACT_USAGE_HINT =
+  "Usage: `/compact [<tokens>]` (e.g. `/compact 30000`, `/compact 30k`, `/compact 1m`).";
+
+type CompactParse =
+  | { kind: "compact"; targetInputTokensOverride?: number }
+  | { kind: "unknown"; message: string };
+
+const TOKEN_COUNT_PATTERN = /^(\d+(?:\.\d+)?)([km])?$/i;
+const COMPACT_COMMAND_PATTERN = /^\/compact(?:\s+(.+?))?\s*$/i;
+
+function parseTokenCount(input: string): number | null {
+  const match = input.match(TOKEN_COUNT_PATTERN);
+  if (!match) return null;
+  const value = Number.parseFloat(match[1]);
+  if (!Number.isFinite(value) || value <= 0) return null;
+  const suffix = match[2]?.toLowerCase();
+  const multiplier = suffix === "m" ? 1_000_000 : suffix === "k" ? 1_000 : 1;
+  const tokens = Math.floor(value * multiplier);
+  return tokens > 0 ? tokens : null;
+}
+
+function parseCompactCommand(trimmed: string): CompactParse | null {
+  const match = trimmed.match(COMPACT_COMMAND_PATTERN);
+  if (!match) return null;
+  const rest = match[1]?.trim();
+  if (!rest) return { kind: "compact" };
+  const tokens = parseTokenCount(rest);
+  if (tokens == null) {
+    return {
+      kind: "unknown",
+      message: `Unrecognized argument to \`/compact\`: \`${rest}\`. ${COMPACT_USAGE_HINT}`,
+    };
+  }
+  return { kind: "compact", targetInputTokensOverride: tokens };
+}
 
 // ── /context and /status commands ────────────────────────────────────
 
@@ -71,10 +113,125 @@ const DEPRECATED_MODEL_SHORTCUTS = new Set([
   "grok-multi",
 ]);
 
+// ── /model command (inference profile switcher) ──────────────────────
+
+type ModelCommandParse =
+  | { kind: "list" }
+  | { kind: "switch"; profileName: string };
+
+/**
+ * Parse `/model` and `/model <name>` forms. Returns `null` for any input
+ * that isn't a `/model` invocation (so the caller can fall through).
+ */
+function parseModelCommand(trimmed: string): ModelCommandParse | null {
+  if (trimmed === "/model") return { kind: "list" };
+  if (!trimmed.startsWith("/model ")) return null;
+  const rest = trimmed.slice("/model ".length).trim();
+  if (rest.length === 0) return { kind: "list" };
+  return { kind: "switch", profileName: rest };
+}
+
+function orderedProfileNames(
+  profiles: Record<string, { label?: string; description?: string; status?: "active" | "disabled" }>,
+  profileOrder: readonly string[] | undefined,
+): string[] {
+  const order = profileOrder ?? [];
+  const seen = new Set<string>();
+  const ordered: string[] = [];
+  for (const name of order) {
+    if (profiles[name] != null && !seen.has(name)) {
+      ordered.push(name);
+      seen.add(name);
+    }
+  }
+  const tail = Object.keys(profiles)
+    .filter((n) => !seen.has(n))
+    .sort();
+  return [...ordered, ...tail];
+}
+
+async function resolveModelCommand(
+  parse: ModelCommandParse,
+): Promise<SlashResolution> {
+  const config = getConfig();
+  const profiles = (config.llm.profiles ?? {}) as Record<
+    string,
+    { label?: string; description?: string; status?: "active" | "disabled" }
+  >;
+  const profileNames = orderedProfileNames(profiles, config.llm.profileOrder);
+  const activeProfile = config.llm.activeProfile;
+
+  if (parse.kind === "list") {
+    if (profileNames.length === 0) {
+      return {
+        kind: "unknown",
+        message:
+          "No inference profiles are defined. Use **Settings → Models & Services** to create one.",
+      };
+    }
+    const lines = ["Inference profiles:\n"];
+    for (const name of profileNames) {
+      const profile = profiles[name];
+      const label = profile.label ?? name;
+      const isCurrent = name === activeProfile;
+      const isDisabled = profile.status === "disabled";
+      const marker = isCurrent ? " **[current]**" : "";
+      const disabled = isDisabled ? " *(disabled)*" : "";
+      const description = profile.description ? ` — ${profile.description}` : "";
+      lines.push(`  - \`${name}\` (${label})${marker}${disabled}${description}`);
+    }
+    lines.push("\nSwitch with `/model <name>`.");
+    return { kind: "unknown", message: lines.join("\n") };
+  }
+
+  const target = parse.profileName;
+  if (!(target in profiles)) {
+    const available = profileNames.map((n) => `\`${n}\``).join(", ");
+    const hint = available.length > 0 ? ` Available: ${available}.` : "";
+    return {
+      kind: "unknown",
+      message: `Profile \`${target}\` not found.${hint}`,
+    };
+  }
+  if (profiles[target].status === "disabled") {
+    return {
+      kind: "unknown",
+      message: `Profile \`${target}\` is disabled. Enable it in **Settings → Models & Services** first.`,
+    };
+  }
+  if (target === activeProfile) {
+    const label = profiles[target].label ?? target;
+    return {
+      kind: "unknown",
+      message: `Already using profile \`${target}\` (${label}).`,
+    };
+  }
+
+  // Write `llm.activeProfile` directly to the raw config file. We invalidate
+  // the in-process cache so the very next `getConfig()` reflects the switch;
+  // the file watcher will also pick this up but its debounce can lag a tick.
+  const raw = loadRawConfig();
+  const llm: Record<string, unknown> =
+    raw.llm != null && typeof raw.llm === "object" && !Array.isArray(raw.llm)
+      ? (raw.llm as Record<string, unknown>)
+      : {};
+  llm.activeProfile = target;
+  raw.llm = llm;
+  saveRawConfig(raw);
+  invalidateConfigCache();
+
+  const label = profiles[target].label ?? target;
+  return {
+    kind: "unknown",
+    message: `Switched to profile \`${target}\` (${label}).`,
+  };
+}
+
 // ── /models command ──────────────────────────────────────────────────
 
 async function resolveModelList(): Promise<SlashResolution> {
   const config = getConfig();
+  const resolvedMainAgent = resolveCallSiteConfig("mainAgent", config.llm);
   const configuredProviders = new Set<string>(await getConfiguredProviders());
 
   const lines = ["Available models:\n"];
@@ -89,8 +246,8 @@ async function resolveModelList(): Promise<SlashResolution> {
     lines.push(`**${providerName}** ${status}`);
     for (const { id, displayName } of models) {
       const isCurrent =
-        config.llm.default.provider === provider &&
-        config.llm.default.model === id;
+        resolvedMainAgent.provider === provider &&
+        resolvedMainAgent.model === id;
       const current = isCurrent ? " **[current]**" : "";
       lines.push(`  - ${displayName} (\`${id}\`)${current}`);
     }
@@ -146,6 +303,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
   if (context) {
     fallbackLines.push("/context — Show conversation context usage");
   }
+  fallbackLines.push("/model — List or switch inference profile");
   fallbackLines.push("/models — List all available models");
   if (context) {
     fallbackLines.push("/status — Show conversation status and context usage");
@@ -158,6 +316,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
       "/context — Show conversation context usage",
+      "/model — List or switch inference profile",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
@@ -170,6 +329,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
       "/context — Show conversation context usage",
+      "/model — List or switch inference profile",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
@@ -181,6 +341,7 @@ function resolveCommandsList(context?: SlashContext): string[] {
     "/commands — List all available commands",
     "/compact — Force context compaction immediately",
     "/context — Show conversation context usage",
+    "/model — List or switch inference profile",
     "/models — List all available models",
     "/status — Show conversation status and context usage",
     "/btw — Ask a side question while the assistant is working",
@@ -200,10 +361,7 @@ export function classifySlash(
   content: string,
 ): "passthrough" | "compact" | "unknown" {
   const trimmed = content.trim();
-  if (
-    trimmed === "/model" ||
-    (trimmed.startsWith("/model ") && trimmed !== "/models")
-  ) {
+  if (parseModelCommand(trimmed) != null) {
     return "unknown";
   }
   const shortcutMatch = trimmed.match(/^\/([a-z0-9-]+)(\s|$)/i);
@@ -214,7 +372,8 @@ export function classifySlash(
     return "unknown";
   }
   if (trimmed === "/models") return "unknown";
-  if (trimmed === "/compact") return "compact";
+  const compactParse = parseCompactCommand(trimmed);
+  if (compactParse) return compactParse.kind;
   if (trimmed === "/context") return "unknown";
   if (trimmed === "/status") return "unknown";
   if (trimmed === "/commands") return "unknown";
@@ -230,17 +389,11 @@ export async function resolveSlash(
   content: string,
   context?: SlashContext,
 ): Promise<SlashResolution> {
-  // Handle deprecated model-switching commands — direct users to Settings
+  // Handle `/model` — list profiles (no arg) or switch active profile.
   const trimmed = content.trim();
-  if (
-    trimmed === "/model" ||
-    (trimmed.startsWith("/model ") && trimmed !== "/models")
-  ) {
-    return {
-      kind: "unknown",
-      message:
-        "The `/model` command has been removed. Use **Settings → Models & Services** to change your model and provider.",
-    };
+  const modelParse = parseModelCommand(trimmed);
+  if (modelParse != null) {
+    return await resolveModelCommand(modelParse);
   }
 
   // Reject deprecated provider shortcut commands (/opus, /sonnet, /haiku, etc.)
@@ -260,10 +413,9 @@ export async function resolveSlash(
     return await resolveModelList();
   }
 
-  // Handle /compact command
-  if (trimmed === "/compact") {
-    return { kind: "compact" };
-  }
+  // Handle /compact command (with optional `<tokens>` override).
+  const compactParse = parseCompactCommand(trimmed);
+  if (compactParse) return compactParse;
 
   // Handle /context and legacy /status commands
   if (trimmed === "/context" || trimmed === "/status") {

package/src/daemon/conversation-store.ts

@@ -14,12 +14,13 @@
  * shared rate-limit timestamps, broadcast).
  */
 
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { CesClient } from "../credential-execution/client.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
-import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
+import { wrapWithCallSiteRouting } from "../providers/call-site-routing.js";
+import { resolveDefaultProvider } from "../providers/connection-resolution.js";
 import { RateLimitProvider } from "../providers/ratelimit.js";
-import { getProvider } from "../providers/registry.js";
 import { getSubagentManager } from "../subagent/index.js";
 import { getSandboxWorkingDir } from "../util/platform.js";
 import { Conversation } from "./conversation.js";
@@ -222,14 +223,20 @@ export async function getOrCreateConversation(
 
     const createPromise = (async () => {
       const config = getConfig();
-      let provider = getProvider(config.llm.default.provider);
-      provider = new CallSiteRoutingProvider(provider, (name) => {
-        try {
-          return getProvider(name);
-        } catch {
-          return undefined;
-        }
-      });
+      // Connection-aware default-provider resolution. Throws
+      // `ConnectionResolutionError` when the default profile's
+      // `provider_connection` is unset / unknown / mismatched (config
+      // bugs). Returns null on soft credential failures (handled below
+      // as "default provider not registered").
+      const baseProvider = await resolveDefaultProvider(config);
+      if (!baseProvider) {
+        throw new Error(
+          `Conversation: default provider '${resolveCallSiteConfig("mainAgent", config.llm).provider}' is not registered`,
+        );
+      }
+      // Per-call `callSite` routing layered on top, with connection-awareness
+      // for alternate profiles (matches the canonical dispatch path).
+      let provider = wrapWithCallSiteRouting(baseProvider, config);
       const { rateLimit } = config;
       if (rateLimit.maxRequestsPerMinute > 0) {
         provider = new RateLimitProvider(

package/src/daemon/conversation-surfaces.ts

@@ -2023,14 +2023,6 @@ export async function surfaceProxyResolver(
 
   // Route app-control proxy tools (all app_control_* tool variants)
   if (toolName.startsWith("app_control_")) {
-    if (!ctx.hostAppControlProxy || !ctx.hostAppControlProxy.isAvailable()) {
-      return {
-        content:
-          "App control is not available — enable the `app-control` feature flag and connect a macOS client.",
-        isError: true,
-      };
-    }
-
     // `app_control_stop` resolves immediately: tear down the proxy without
     // a client round-trip. Mirrors CU's terminal-tool short-circuit
     // (`computer_use_done` / `computer_use_respond`). Clear the
@@ -2039,15 +2031,85 @@ export async function surfaceProxyResolver(
     // instead of dispatching against a torn-down proxy, and so a sibling
     // conversation can acquire the released singleton lock without the
     // disposed proxy still being addressable.
+    //
+    // Run this BEFORE the isAvailable() gate so a disconnected client
+    // doesn't strand the singleton lock — stop is local-only.
     if (toolName === "app_control_stop") {
-      if (ctx.setHostAppControlProxy) {
-        ctx.setHostAppControlProxy(undefined);
-      } else {
-        ctx.hostAppControlProxy.dispose();
+      if (ctx.hostAppControlProxy) {
+        if (ctx.setHostAppControlProxy) {
+          ctx.setHostAppControlProxy(undefined);
+        } else {
+          ctx.hostAppControlProxy.dispose();
+        }
       }
       return { content: "App control stopped.", isError: false };
     }
 
+    if (!ctx.hostAppControlProxy || !ctx.hostAppControlProxy.isAvailable()) {
+      return {
+        content:
+          "App control is not available — enable the `app-control` feature flag and connect a macOS client.",
+        isError: true,
+      };
+    }
+
+    // Resolve target client. Mirrors the host_cu block above: validate
+    // explicit target_client_id (existence, capability, same-actor), then
+    // multi-client guard when no target is supplied. App-control is
+    // single-client-only at the host (one active session per macOS
+    // machine), so a broadcast across multiple capable clients would fire
+    // the same input on every machine.
+    let targetClientId: string | undefined =
+      typeof input.target_client_id === "string" &&
+      input.target_client_id !== ""
+        ? input.target_client_id
+        : undefined;
+
+    const sourceActorPrincipalId = ctx.trustContext?.guardianPrincipalId;
+    if (targetClientId != null) {
+      const client = assistantEventHub.getClientById(targetClientId);
+      if (!client) {
+        return {
+          content: `No connected client with id '${targetClientId}'. Run \`assistant clients list --capability host_app_control\` to see available clients.`,
+          isError: true,
+        };
+      }
+      if (!client.capabilities.includes("host_app_control")) {
+        return {
+          content: `Client '${targetClientId}' does not support host_app_control. Run \`assistant clients list --capability host_app_control\` to see available clients.`,
+          isError: true,
+        };
+      }
+      const rejection = enforceSameActorOrErrorResult({
+        hub: assistantEventHub,
+        sourceActorPrincipalId,
+        targetClientId,
+        op: "host_app_control",
+      });
+      if (rejection) return rejection;
+    }
+
+    if (targetClientId == null) {
+      const allAcClients =
+        assistantEventHub.listClientsByCapability("host_app_control");
+      const sameUserAcClients = allAcClients.filter(
+        (c) => c.actorPrincipalId === sourceActorPrincipalId,
+      );
+      if (sameUserAcClients.length > 1) {
+        return {
+          content: `Error: multiple clients support host_app_control. Specify which client to target with \`target_client_id\`. Run \`assistant clients list --capability host_app_control\` to see client IDs and labels.`,
+          isError: true,
+        };
+      }
+      // When cross-user host_app_control clients are connected, auto-
+      // resolve to the unique same-user client. Otherwise the proxy would
+      // dispatch untargeted and the action could reach a cross-user
+      // client. Belt-and-suspenders: the proxy re-checks same-user.
+      if (sameUserAcClients.length === 1 && allAcClients.length > 1) {
+        targetClientId = sameUserAcClients[0].clientId;
+      }
+    }
+
     // The TS `HostAppControlInput` (and the Swift mirror) is a discriminated
     // union on `tool` ("start" | "observe" | "press" | …). The agent's raw
     // tool input only carries the action-specific payload (app, x/y, text,
@@ -2066,6 +2128,8 @@ export async function surfaceProxyResolver(
       inputWithTool,
       ctx.conversationId,
       signal ?? new AbortController().signal,
+      sourceActorPrincipalId,
+      targetClientId,
     );
   }