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

package/src/config/feature-flag-registry.json

@@ -540,8 +540,8 @@
       "id": "assistant-desktop",
       "scope": "assistant",
       "key": "assistant-desktop",
-      "label": "Assistant Desktop",
-      "description": "Streams an interactive desktop from a containerized assistant pod to the web client over /v1/desktop/stream. Off: no desktop affordance is rendered. On: the chat header offers a desktop panel that views and controls the pod's display.",
+      "label": "Virtual desktop",
+      "description": "Streams an interactive virtual desktop from a platform-hosted, containerized assistant over /v1/desktop/stream. Requires platform hosting; self-hosted assistants are excluded. Off: the virtual desktop is hidden. On: the chat header offers its viewer and controls.",
       "defaultEnabled": false
     }
   ]

package/src/config/schemas/__tests__/voice.test.ts

@@ -9,7 +9,7 @@ const PROGRESS_DEFAULTS = {
   maxSilenceMs: 35_000,
   longOpMs: 15_000,
   minGapMs: 6_000,
-  generationTimeoutMs: 1_500,
+  generationTimeoutMs: 5_000,
 };
 
 const FRONT_MODEL_DEFAULTS = {
@@ -75,7 +75,7 @@ describe("VoiceFrontModelConfigSchema", () => {
     expect(parsed.progress.maxSilenceMs).toBe(35_000);
     expect(parsed.progress.longOpMs).toBe(15_000);
     expect(parsed.progress.minGapMs).toBe(6_000);
-    expect(parsed.progress.generationTimeoutMs).toBe(1_500);
+    expect(parsed.progress.generationTimeoutMs).toBe(5_000);
   });
 
   test("a stale maxPerTurn key is stripped, not rejected", () => {

package/src/config/schemas/mcp.ts

@@ -55,9 +55,7 @@ const McpSseTransportSchema = z
       .optional()
       .describe("Custom HTTP headers sent with SSE requests"),
   })
-  .describe(
-    "SSE transport: connects to an MCP server over Server-Sent Events",
-  );
+  .describe("SSE transport: connects to an MCP server over Server-Sent Events");
 
 const McpStreamableHttpTransportSchema = z
   .object({
@@ -114,10 +112,14 @@ export type McpConfig = z.infer<typeof McpConfigSchema>;
  */
 export type McpServerSource = "workspace" | "plugin";
 
-/** A server config with its origin resolved. */
-export interface ResolvedMcpServerConfig extends McpServerConfig {
-  readonly source: McpServerSource;
-}
+/** A server config with its runtime-only origin and credential identity. */
+export type ResolvedMcpServerConfig =
+  | (McpServerConfig & { readonly source: "workspace" })
+  | (McpServerConfig & {
+      readonly source: "plugin";
+      readonly pluginName: string;
+      readonly serverKey: string;
+    });
 
 /** The MCP config the daemon runs: both origins, every server attributed. */
 export interface ResolvedMcpConfig {

package/src/config/schemas/monitoring.ts

@@ -75,6 +75,15 @@ export const MonitoringConfigSchema = z
       .describe(
         "Minimum interval between file-descriptor warnings while usage stays over the threshold, in milliseconds. Crossing the threshold always warns immediately; this only throttles the repeats.",
       ),
+    mountWatchIntervalMs: z
+      .number({ error: "monitoring.mountWatchIntervalMs must be a number" })
+      .int("monitoring.mountWatchIntervalMs must be an integer")
+      .min(1_000, "monitoring.mountWatchIntervalMs must be at least 1000ms")
+      .max(60_000, "monitoring.mountWatchIntervalMs must be <= 60000ms")
+      .default(10_000)
+      .describe(
+        "How often the monitor diffs the assistant container's mount table (/proc/self/mountinfo plus statfs of /workspace and /data), in milliseconds. Logs only when the watched mounts change. Default 10 seconds so a virtiofs bind drop is timestamped without a line per poll.",
+      ),
     pluginSourceScanIntervalMs: z
       .number({
         error: "monitoring.pluginSourceScanIntervalMs must be a number",

package/src/config/schemas/voice.ts

@@ -74,9 +74,9 @@ export const VoiceProgressConfigSchema = z
       .positive(
         "voice.frontModel.progress.generationTimeoutMs must be a positive integer",
       )
-      .default(1_500)
+      .default(5_000)
       .describe(
-        "Budget (ms) for LLM-generated progress text. Not latency-critical: it speaks into dead air",
+        "Budget (ms) for LLM-generated progress text. Not latency-critical: it speaks into dead air, so the budget is set to cover the narrator's real roundtrip rather than to be tight. A budget that only sometimes covers that roundtrip thins narration out rather than speeding it up, and it thins out exactly where the updates matter most, since the slow beats are the ones with the longest silence behind them (see endpointDecisionTimeoutMs for the same failure mode). Kept under progress.minGapMs so an update that spends the whole budget still lands before the next one is due",
       ),
   })
   // The heartbeat is checked when the idle tick finds the turn silent, so a

package/src/config/skills.ts

@@ -39,6 +39,10 @@ import {
   getWorkspacePluginsDir,
   getWorkspaceSkillsDir,
 } from "../util/platform.js";
+import {
+  hasPluginManifest,
+  readPluginManifest,
+} from "../util/plugin-manifest.js";
 import { stripCommentLines } from "../util/strip-comment-lines.js";
 import { isAssistantFeatureFlagEnabled } from "./assistant-feature-flags.js";
 import { getConfig } from "./loader.js";
@@ -734,8 +738,7 @@ function discoverSkillDirectories(skillsDir: string): string[] {
 }
 
 /**
- * Whether `pluginDir` carries a plugin manifest the runtime can load: a
- * parseable `package.json` with a non-empty string `name`. This mirrors the
+ * Whether `pluginDir` carries a plugin manifest the runtime can load. This mirrors the
  * external plugin loader (`buildPluginFromDir`), which builds a plugin from
  * any such directory and derives the plugin's identity from `package.json`
  * `name` — it imposes no match between that `name` and the directory name.
@@ -745,31 +748,20 @@ function discoverSkillDirectories(skillsDir: string): string[] {
  * requiring the two to match would silently drop the resident skills of every
  * such plugin even though the runtime loads its hooks and tools fine.
  *
- * The caller is responsible for the missing-`package.json` case (it emits a
+ * The caller is responsible for the missing-manifest case (it emits a
  * diagnostic warning); this function only judges a manifest that is present.
  */
 function hasLoadablePluginManifest(pluginDir: string): boolean {
-  const manifestPath = join(pluginDir, "package.json");
-  if (!existsSync(manifestPath)) {
-    return false;
-  }
-  let parsed: unknown;
   try {
-    parsed = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    readPluginManifest(pluginDir);
+    return true;
   } catch (err) {
     log.warn(
-      { err, manifestPath },
-      "Skipping plugin dir with unparseable package.json for resident skills",
+      { err, pluginDir },
+      "Skipping plugin dir with an invalid manifest for resident skills",
     );
     return false;
   }
-  return (
-    typeof parsed === "object" &&
-    parsed !== null &&
-    "name" in parsed &&
-    typeof (parsed as { name: unknown }).name === "string" &&
-    (parsed as { name: string }).name.length > 0
-  );
 }
 
 /**
@@ -885,15 +877,15 @@ function discoverInstalledPluginResidentSkills(): SkillSummary[] {
     }
     const pluginDir = join(pluginsDir, entry.name);
 
-    // A directory under `plugins/` with no `package.json` is not a plugin the
+    // A directory under `plugins/` with no supported manifest is not a plugin the
     // runtime can load, so its skills are never surfaced. This is an easy
     // footgun — a plugin dropped in without its manifest looks installed but
     // silently contributes nothing — so warn loudly with the path rather than
     // skipping in silence, to make the misconfiguration diagnosable.
-    if (!existsSync(join(pluginDir, "package.json"))) {
+    if (!hasPluginManifest(pluginDir)) {
       log.warn(
         { pluginDir },
-        "Plugin directory is missing package.json — skipping; its skills will not be available. Add a package.json with a `name`.",
+        "Plugin directory is missing package.json and plugin.json; its skills will not be available.",
       );
       continue;
     }

package/src/daemon/__tests__/conversation-tool-setup-exclude.test.ts

@@ -6,6 +6,7 @@
 
 import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 
+import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
 import * as configLoader from "../../config/loader.js";
 import type { AssistantConfig } from "../../config/schema.js";
 import * as disabledState from "../../plugins/disabled-state.js";
@@ -245,3 +246,49 @@ describe("createResolveToolsCallback — config.tools.exclude", () => {
     expect(ctx.allowedToolNames?.has("bash")).toBe(false);
   });
 });
+
+test("managed browser guidance follows each turn without changing native or shared tool definitions", () => {
+  const platform = process.env.IS_PLATFORM;
+  const containerized = process.env.IS_CONTAINERIZED;
+  process.env.IS_PLATFORM = "true";
+  process.env.IS_CONTAINERIZED = "true";
+  setOverridesForTesting({ "assistant-desktop": true });
+  const bash = def("bash");
+  const ctx = makeCtx({
+    conversationId: "conv-browser-guidance",
+    transportInterface: "web",
+    currentTurnClientOs: "web",
+    trustContext: { trustClass: "guardian" } as Conversation["trustContext"],
+    getTurnActorPrincipalId: () => "user-123",
+  });
+  const resolve = createResolveToolsCallback([bash], ctx)!;
+  try {
+    expect(
+      resolve([]).find((tool) => tool.name === "bash")?.description,
+    ).toContain("assistant browser navigate");
+    expect(bash.description).toBe("bash");
+    for (const clientOs of ["macos", "windows", "linux"] as const) {
+      ctx.currentTurnClientOs = clientOs;
+      expect(
+        resolve([]).find((tool) => tool.name === "bash")?.description,
+      ).toBe("bash");
+    }
+    ctx.currentTurnClientOs = "web";
+    setOverridesForTesting({ "assistant-desktop": false });
+    expect(resolve([]).find((tool) => tool.name === "bash")?.description).toBe(
+      "bash",
+    );
+  } finally {
+    setOverridesForTesting({});
+    if (platform === undefined) {
+      delete process.env.IS_PLATFORM;
+    } else {
+      process.env.IS_PLATFORM = platform;
+    }
+    if (containerized === undefined) {
+      delete process.env.IS_CONTAINERIZED;
+    } else {
+      process.env.IS_CONTAINERIZED = containerized;
+    }
+  }
+});

package/src/daemon/__tests__/plugin-mcp-reconcile.test.ts

@@ -41,6 +41,7 @@ mock.module("../../mcp/mcp-header-store.js", () => ({
 }));
 
 mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({}),
   invalidateConfigCache: () => {},
 }));
 

package/src/daemon/conversation-client-surface.ts

@@ -0,0 +1,26 @@
+import { type ClientOs, parseClientOs } from "../channels/types.js";
+import type { Conversation } from "./conversation.js";
+
+/**
+ * Host OS of the client driving this turn. The Electron renderer reports
+ * `interface: "web"` and carries the real OS in `clientOs`, so this prefers
+ * the frozen per-turn value and only falls back to a desktop transport.
+ */
+export function resolveTurnClientOs(ctx: Conversation): {
+  clientOs: ClientOs | undefined;
+  transportInterface: Conversation["transportInterface"];
+} {
+  const pin = ctx.toolContextPin;
+  const transportInterface = pin
+    ? pin.transportInterface
+    : ctx.transportInterface;
+  const clientOs = pin
+    ? pin.clientOs
+    : (parseClientOs(ctx.currentTurnClientOs ?? ctx.clientOs) ??
+      (transportInterface === "macos" ||
+      transportInterface === "windows" ||
+      transportInterface === "linux"
+        ? transportInterface
+        : undefined));
+  return { clientOs, transportInterface };
+}

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

@@ -854,7 +854,7 @@ export function buildChannelCapabilityBlock(
   if (clientOs === "macos") {
     lines.push("");
     lines.push(
-      "On macOS, prefer osascript/CLI via `host_bash` over computer use tools, which take over the user's cursor. Use foreground computer use only when no scripting alternative exists or the user explicitly asks.",
+      "On macOS, drive apps with the computer-use skill; `host_bash` is for shell commands.",
     );
   }
 

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

@@ -7,10 +7,9 @@
  */
 
 import type { AssistantEvent } from "../api/index.js";
+import { shouldUseVirtualDesktopBrowser } from "../browser/virtual-desktop-target.js";
 import {
-  type ClientOs,
   type HostProxyCapability,
-  parseClientOs,
   supportsHostProxy,
 } from "../channels/types.js";
 import { getIsPlatform } from "../config/env-registry.js";
@@ -74,6 +73,7 @@ import {
   conversationSupportsGuardianQuestionCards,
 } from "./channel-ui-capability.js";
 import type { Conversation } from "./conversation.js";
+import { resolveTurnClientOs } from "./conversation-client-surface.js";
 import { projectSkillTools } from "./conversation-skill-tools.js";
 import {
   restoreSurfaceStateEntry,
@@ -742,30 +742,6 @@ export const ALLOWLIST_ONLY_TOOL_NAMES = new Set<string>([
   "delete_memory_page",
 ]);
 
-/**
- * Host OS of the client driving this turn. The Electron renderer reports
- * `interface: "web"` and carries the real OS in `clientOs`, so this prefers
- * the frozen per-turn value and only falls back to a desktop transport.
- */
-function resolveTurnClientOs(ctx: Conversation): {
-  clientOs: ClientOs | undefined;
-  transportInterface: Conversation["transportInterface"];
-} {
-  const pin = ctx.toolContextPin;
-  const transportInterface = pin
-    ? pin.transportInterface
-    : ctx.transportInterface;
-  const clientOs = pin
-    ? pin.clientOs
-    : (parseClientOs(ctx.currentTurnClientOs ?? ctx.clientOs) ??
-      (transportInterface === "macos" ||
-      transportInterface === "windows" ||
-      transportInterface === "linux"
-        ? transportInterface
-        : undefined));
-  return { clientOs, transportInterface };
-}
-
 /**
  * Windows parity gate: skill tools may declare `supported_client_os`; drop
  * them when the turn's client OS (or pinned OS for wakes) is not listed.
@@ -1149,9 +1125,35 @@ export function createResolveToolsCallback(
     // while background calls persist the full surface content for the next
     // capable client that opens the conversation. Skill tools stay off this
     // list (`skill_execute` dispatch) and are a separate disclosure path.
-    let allBaseDefs = [...scopedCoreDefs, ...scopedWorkspaceDefs, ...scopedMcpDefs].filter(
-      (d) => !excluded.has(d.name),
-    );
+    let allBaseDefs = [
+      ...scopedCoreDefs,
+      ...scopedWorkspaceDefs,
+      ...scopedMcpDefs,
+    ].filter((d) => !excluded.has(d.name));
+    if (
+      ctx.transportInterface === "web" &&
+      shouldUseVirtualDesktopBrowser(
+        undefined,
+        {},
+        {
+          workingDir: ctx.workingDir,
+          conversationId: ctx.conversationId,
+          trustClass: ctx.trustContext?.trustClass ?? "unknown",
+          transportInterface: ctx.transportInterface,
+          clientOs: resolveTurnClientOs(ctx).clientOs,
+          sourceActorPrincipalId: ctx.getTurnActorPrincipalId?.(),
+        },
+      )
+    ) {
+      allBaseDefs = allBaseDefs.map((definition) =>
+        definition.name === "bash"
+          ? {
+              ...definition,
+              description: `${definition.description} For browser tasks, use assistant browser navigate --url <url> directly. It installs the virtual desktop if needed, starts Chrome, and completes the action in one call. Use timeout_seconds: ${getConfig().timeouts.shellMaxTimeoutSec} for first use; setup progress is visible in the Virtual desktop panel. Use assistant browser --help for other browser actions. Use this managed path even if saved notes describe manual setup. Do not install packages or launch Chrome, X servers, or screenshot scripts yourself.`,
+            }
+          : definition,
+      );
+    }
     // Activation-rail conversations carry the optional `activation_moment`
     // telemetry param on ui_show. The marker is written before the first
     // tool resolution (see `applyBootstrapTemplate` in system-prompt.ts), so

package/src/daemon/host-cu-proxy.ts

@@ -48,8 +48,8 @@ const SCREENSHOT_OMITTED_MESSAGE =
   "Screenshot omitted: the accessibility tree above is current. Pass include_screenshot: true on computer_use_observe to see the screen.";
 
 // computer_use_key combos that change only selection/cursor/clipboard state.
-// The AX tree models none of these, so they always produce an empty diff —
-// exempt them from the "NO VISIBLE EFFECT" signal (mirrors computer_use_wait).
+// The AX tree models none of these, so they always produce an empty diff and
+// are exempt from the unchanged-tree signal.
 // Stored in canonical form (see canonicalizeKeyCombo): modifier aliases
 // normalized and ordered, so `cmd + a`, `command+a`, `alt+tab`, `tab+shift`
 // all match.
@@ -129,12 +129,28 @@ export interface ActionRecord {
   reasoning?: string;
 }
 
+// Steps whose empty diff says nothing about whether they worked: waiting and
+// observing change nothing by design, and an AppleScript reports its own
+// outcome in the execution result, often for an app whose content the tree
+// cannot see. They neither warn nor move the unchanged streak.
+const NO_AX_DIFF_TOOLS = new Set([
+  "computer_use_wait",
+  "computer_use_observe",
+  "computer_use_run_applescript",
+]);
+
+type ActionIdentity = Pick<ActionRecord, "toolName" | "input">;
+
+function isNoDiffTool(action: ActionIdentity | undefined): boolean {
+  return action !== undefined && NO_AX_DIFF_TOOLS.has(action.toolName);
+}
+
 /**
  * True when `action` is a computer_use_key press whose key only mutates
- * selection/cursor/clipboard state — changes the AX tree cannot represent, so
+ * selection/cursor/clipboard state: changes the AX tree cannot represent, so
  * an empty diff is expected rather than a sign the action did nothing.
  */
-function isNoDiffKeyAction(action: ActionRecord | undefined): boolean {
+function isNoDiffKeyAction(action: ActionIdentity | undefined): boolean {
   if (action?.toolName !== "computer_use_key") {
     return false;
   }
@@ -245,6 +261,7 @@ export class HostCuProxy {
       resetGeneration: number;
       dispatchedAt: number;
       toolName: string;
+      input: Record<string, unknown>;
       step: number;
     }
   >();
@@ -455,6 +472,7 @@ export class HostCuProxy {
         resetGeneration: this._resetGeneration,
         dispatchedAt: Date.now(),
         toolName,
+        input,
         step: stepNumber,
       });
 
@@ -538,7 +556,7 @@ export class HostCuProxy {
     }
 
     // A targeted snapshot has no comparable action/diff baseline; neither it
-    // nor the first desktop observation after it can imply "no visible effect".
+    // nor the first desktop observation after it can imply an unchanged tree.
     // A response dispatched before the last reset belongs to a finished run,
     // so it must not change any state the new run has started building.
     const fromCurrentRun =
@@ -548,6 +566,11 @@ export class HostCuProxy {
       this._consecutiveUnchangedSteps = 0;
     }
     const prevAXTree = this._previousAXTree;
+    // Judge the empty diff against the action this request carried, for the
+    // same reason the timings line does.
+    const action: ActionIdentity | undefined = owned
+      ? { toolName: owned.toolName, input: owned.input }
+      : this.lastRecordedAction();
     const comparableObservation = scopedObservation
       ? { ...observation, axDiff: undefined, secondaryWindows: undefined }
       : observation;
@@ -557,7 +580,7 @@ export class HostCuProxy {
       !scopedObservation &&
       owned?.toolName !== POINT_AT_PROXY_TOOL
     ) {
-      this.updateStateFromObservation(comparableObservation);
+      this.updateStateFromObservation(comparableObservation, action);
       // A desktop has had its first look only once pixels from it arrived,
       // so a failed capture leaves the next request asking again.
       if (owned && observation.screenshot) {
@@ -568,6 +591,7 @@ export class HostCuProxy {
       comparableObservation,
       prevAXTree,
       owned?.screenshotSkipped ?? false,
+      action,
     );
     interaction.rpcResolve(result);
     return result;
@@ -672,6 +696,7 @@ export class HostCuProxy {
     obs: CuObservationResult,
     previousAXTree?: string,
     screenshotSkipped = false,
+    action: ActionIdentity | undefined = this.lastRecordedAction(),
   ): ToolExecutionResult {
     const prevTree = previousAXTree;
     const parts: string[] = [];
@@ -690,24 +715,17 @@ export class HostCuProxy {
       parts.push(obs.axDiff);
       parts.push("");
     } else if (prevTree != null && obs.axTree != null) {
-      const lastAction =
-        this._actionHistory.length > 0
-          ? this._actionHistory[this._actionHistory.length - 1]
-          : undefined;
-      const isWaitAction = lastAction?.toolName === "computer_use_wait";
-      const isNoDiffKey = isNoDiffKeyAction(lastAction);
-
-      if (!isWaitAction && !isNoDiffKey) {
+      if (!isNoDiffTool(action) && !isNoDiffKeyAction(action)) {
         if (
           this._consecutiveUnchangedSteps >=
           CONSECUTIVE_UNCHANGED_WARNING_THRESHOLD
         ) {
           parts.push(
-            `WARNING: ${this._consecutiveUnchangedSteps} consecutive actions had NO VISIBLE EFFECT on the UI. You MUST try a completely different approach.`,
+            `WARNING: the accessibility tree did not change across ${this._consecutiveUnchangedSteps} consecutive actions. If the screenshot does not show them working either, try a different approach.`,
           );
         } else {
           parts.push(
-            "Your last action had NO VISIBLE EFFECT on the UI. Try something different.",
+            "The accessibility tree did not change after your last action. Apps that draw their own content (timelines, canvases, spreadsheet grids) change without it, so check the screenshot before deciding the action did nothing.",
           );
         }
         parts.push("");
@@ -822,19 +840,26 @@ export class HostCuProxy {
   // Private helpers
   // ---------------------------------------------------------------------------
 
-  private updateStateFromObservation(obs: CuObservationResult): void {
+  private lastRecordedAction(): ActionRecord | undefined {
+    return this._actionHistory.at(-1);
+  }
+
+  private updateStateFromObservation(
+    obs: CuObservationResult,
+    action: ActionIdentity | undefined,
+  ): void {
     if (this._stepCount > 0) {
-      const lastAction =
-        this._actionHistory.length > 0
-          ? this._actionHistory[this._actionHistory.length - 1]
-          : undefined;
-      if (obs.axDiff != null || isNoDiffKeyAction(lastAction)) {
+      if (obs.axDiff != null || isNoDiffKeyAction(action)) {
         // A real diff, or an exempt key whose effect is invisible by design,
-        // breaks the no-effect streak — clear it rather than preserving a
-        // stale count so an intervening cmd+a can't bridge two no-op actions
-        // into a false "consecutive" escalation.
+        // breaks the no-effect streak. Clearing it rather than preserving a
+        // stale count keeps an intervening cmd+a from bridging two no-op
+        // actions into a false "consecutive" escalation.
         this._consecutiveUnchangedSteps = 0;
-      } else if (this._previousAXTree != null && obs.axTree != null) {
+      } else if (
+        !isNoDiffTool(action) &&
+        this._previousAXTree != null &&
+        obs.axTree != null
+      ) {
         this._consecutiveUnchangedSteps++;
       }
     }

package/src/daemon/host-proxy-preactivation.ts

@@ -9,6 +9,8 @@
  *   - `daemon/process-message.ts` (create path, prepareConversationForMessage)
  *   - `daemon/conversation-process.ts` `drainSingleMessage` (re-add after dequeue)
  *   - `daemon/conversation-process.ts` `drainBatch` (re-add after dequeue)
+ *   - `calls/voice-session-bridge.ts` (tool-capable legs of a live-voice
+ *     session opened from the macOS desktop client)
  *
  * The create paths additionally instantiate the proxy itself; that
  * instantiation logic is per-proxy-class and stays inline at each create

package/src/daemon/mcp-reload-service.ts

@@ -14,6 +14,7 @@ import { getMcpServerManager } from "../mcp/manager.js";
 import { migrateLegacyMcpHeaders } from "../mcp/mcp-header-store.js";
 import { signalMcpReloaded } from "../mcp/reload-signal.js";
 import { loadWorkspaceMcpConfig } from "../mcp/workspace-mcp-config.js";
+import { publishMcpChanged } from "../runtime/sync/resource-sync-events.js";
 import { createMcpToolsFromServer } from "../tools/mcp/mcp-tool-factory.js";
 import { registerMcpTools, unregisterAllMcpTools } from "../tools/registry.js";
 import { getLogger } from "../util/logger.js";
@@ -80,6 +81,7 @@ export async function reconcilePluginMcpServers(): Promise<void> {
 }
 
 async function doReload(): Promise<McpReloadResult> {
+  let teardownStarted = false;
   try {
     const manager = getMcpServerManager();
 
@@ -98,6 +100,7 @@ async function doReload(): Promise<McpReloadResult> {
     invalidateConfigCache();
 
     // 2. Stop existing MCP servers + unregister their tools
+    teardownStarted = true;
     await manager.stop();
     unregisterAllMcpTools();
 
@@ -160,5 +163,9 @@ async function doReload(): Promise<McpReloadResult> {
     const error = err instanceof Error ? err.message : String(err);
     log.error({ err }, "MCP reload failed");
     return { success: false, error };
+  } finally {
+    if (teardownStarted) {
+      publishMcpChanged();
+    }
   }
 }

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

@@ -18,6 +18,7 @@ export const SYNC_TAGS = {
   appsList: "apps:list",
   documentsList: "documents:list",
   pluginsList: "plugins:list",
+  mcpList: "mcp:list",
   conversationsList: "conversations:list",
   /** Activation-checklist progress: task launches, step counts, completions. */
   activationProgress: "activation:progress",

package/src/daemon/providers-setup.ts

@@ -1,6 +1,7 @@
 import { maybeDefaultSpeechToManaged } from "../config/managed-speech-defaults.js";
 import { rehydratePlatformCredentials } from "../config/platform-rehydration.js";
 import type { AssistantConfig } from "../config/types.js";
+import { getMcpServerManager } from "../mcp/manager.js";
 import { startConfiguredMcpServers } from "../mcp/startup.js";
 import { gmailMessagingProvider } from "../messaging/providers/gmail/adapter.js";
 import { outlookMessagingProvider } from "../messaging/providers/outlook/adapter.js";
@@ -9,6 +10,7 @@ import { telegramBotMessagingProvider } from "../messaging/providers/telegram-bo
 import { whatsappMessagingProvider } from "../messaging/providers/whatsapp/adapter.js";
 import { registerMessagingProvider } from "../messaging/registry.js";
 import { initializeProviders } from "../providers/registry.js";
+import { publishMcpChanged } from "../runtime/sync/resource-sync-events.js";
 import { validateSubagentRoleAllowlists } from "../subagent/validate-allowlists.js";
 import { initializeTools } from "../tools/registry.js";
 import { getLogger } from "../util/logger.js";
@@ -63,7 +65,9 @@ export async function initializeProvidersAndTools(
   // Start MCP servers — workspace-configured and plugin-declared alike —
   // and register their tools. Shared with the schedule worker, which hosts
   // agent turns in its own process and so needs its own connections.
+  getMcpServerManager().setUnexpectedCloseHandler(() => publishMcpChanged());
   await startConfiguredMcpServers();
+  publishMcpChanged();
 
   log.info("Daemon startup: providers and tools initialized");
 }

package/src/desktop/__tests__/fake-desktop.ts

@@ -58,6 +58,7 @@ export function newFakeDesktop(options: FakeDesktopOptions) {
   let vncReady = true;
   let chromiumPath: () => Promise<string> = async () => "/fake/chromium";
   const manager = new DesktopSessionManager({
+    allocateDebugPort: async () => 9222,
     spawn: (role, request) => {
       if (options.failSpawn?.includes(role)) {
         throw new Error(`spawn ${role} failed`);