@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

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/mcp-reload-service.ts

@@ -6,6 +6,10 @@
  */
 
 import { getConfig, invalidateConfigCache } from "../config/loader.js";
+import {
+  buildEffectiveMcpConfig,
+  pluginMcpServersChangedSinceLastBuild,
+} from "../mcp/effective-config.js";
 import { getMcpServerManager } from "../mcp/manager.js";
 import { migrateLegacyMcpHeaders } from "../mcp/mcp-header-store.js";
 import { createMcpToolsFromServer } from "../tools/mcp/mcp-tool-factory.js";
@@ -52,6 +56,29 @@ export function reloadMcpServers(): Promise<McpReloadResult> {
   return reloadInProgress;
 }
 
+/**
+ * Reload MCP servers if — and only if — the plugin-declared set moved.
+ *
+ * Called by the plugin source reconcile, which every install / uninstall /
+ * upgrade / enable / disable already funnels through, so a plugin's MCP
+ * tools come up and go down with the plugin instead of lingering until an
+ * explicit reload, a config edit, or a restart.
+ *
+ * The guard matters: a reconcile also fires for plugin edits that touch no
+ * `mcp.json` at all, and an unconditional reload would tear down every
+ * healthy workspace connection to re-establish it for nothing.
+ *
+ * Never throws — the reconcile is best-effort and must not fail an install
+ * whose files already landed on disk.
+ */
+export async function reconcilePluginMcpServers(): Promise<void> {
+  if (!pluginMcpServersChangedSinceLastBuild()) {
+    return;
+  }
+  log.info("Plugin-declared MCP servers changed; reloading");
+  await reloadMcpServers();
+}
+
 async function doReload(): Promise<McpReloadResult> {
   try {
     const manager = getMcpServerManager();
@@ -74,17 +101,20 @@ async function doReload(): Promise<McpReloadResult> {
     // 2. Stop existing MCP servers + unregister their tools
     await manager.stop();
     unregisterAllMcpTools();
-    const serverIds = config.mcp?.servers
-      ? Object.keys(config.mcp.servers)
-      : [];
+
+    // Plugins are re-read here too: installing or removing one changes the
+    // server set exactly like editing config.json does, and both arrive
+    // through this same reload.
+    const mcpConfig = buildEffectiveMcpConfig(config.mcp);
+    const serverIds = Object.keys(mcpConfig.servers);
 
     // 3. Restart MCP servers
     let serverCount = 0;
     let toolCount = 0;
     const servers: McpReloadServerResult[] = [];
 
-    if (config.mcp?.servers && Object.keys(config.mcp.servers).length > 0) {
-      const serverToolInfos = await manager.start(config.mcp);
+    if (serverIds.length > 0) {
+      const serverToolInfos = await manager.start(mcpConfig);
       for (const { serverId, serverConfig, tools } of serverToolInfos) {
         const mcpTools = createMcpToolsFromServer(
           tools,
@@ -105,7 +135,7 @@ async function doReload(): Promise<McpReloadResult> {
       // Include servers that were configured but failed to connect or are disabled
       for (const id of serverIds) {
         if (!servers.some((s) => s.id === id)) {
-          const serverConfig = config.mcp!.servers![id];
+          const serverConfig = mcpConfig.servers[id];
           const isDisabled = serverConfig?.enabled === false;
           servers.push({
             id,

package/src/daemon/process-message.ts

@@ -34,7 +34,6 @@ import { updateMetaFile } from "../persistence/conversation-disk-view.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
-import { getSubagentManager } from "../subagent/index.js";
 import {
   readTurnFailure,
   type TurnFailure,
@@ -71,6 +70,7 @@ import {
   shouldAttachHostProxyForCapability,
 } from "./host-proxy-preactivation.js";
 import type { SubagentToolGateMode } from "./tool-setup-types.js";
+import { restingTrust } from "./trust-context-types.js";
 
 const log = getLogger("process-message");
 
@@ -455,7 +455,10 @@ export async function processMessage(
   if (slashResult.kind === "unknown") {
     const serverTurnCtx = conversation.getTurnChannelContext();
     const serverProvenance = provenanceFromTrustContext(
-      conversation.trustContext,
+      // Ingress persists before any per-turn stamp; the slot was just written
+      // by this message's own resolution, and the per-turn field may still
+      // hold the previous turn's actor.
+      restingTrust(conversation),
     );
     const imageSourcePaths: Record<string, string> = {};
     for (let i = 0; i < attachments.length; i++) {
@@ -557,7 +560,10 @@ export async function processMessage(
   if (slashResult.kind === "compact") {
     const serverTurnCtx = conversation.getTurnChannelContext();
     const serverProvenance = provenanceFromTrustContext(
-      conversation.trustContext,
+      // Ingress persists before any per-turn stamp; the slot was just written
+      // by this message's own resolution, and the per-turn field may still
+      // hold the previous turn's actor.
+      restingTrust(conversation),
     );
     const compactChannelMeta = {
       ...serverProvenance,
@@ -612,7 +618,10 @@ export async function processMessage(
   if (slashResult.kind === "clean") {
     const serverTurnCtx = conversation.getTurnChannelContext();
     const serverProvenance = provenanceFromTrustContext(
-      conversation.trustContext,
+      // Ingress persists before any per-turn stamp; the slot was just written
+      // by this message's own resolution, and the per-turn field may still
+      // hold the previous turn's actor.
+      restingTrust(conversation),
     );
     const cleanChannelMeta = {
       ...serverProvenance,
@@ -699,11 +708,6 @@ export async function processMessage(
     };
   }
 
-  if (options?.isInteractive === true) {
-    conversation.updateClient(broadcastMessage, false);
-    getSubagentManager().updateParentSender(conversationId, broadcastMessage);
-  }
-
   const restoreToolScope = applyTurnToolAllowlist(conversation, options);
   try {
     await conversation.runAgentLoop(resolvedContent, messageId, {
@@ -721,12 +725,6 @@ export async function processMessage(
     });
   } finally {
     restoreToolScope();
-    if (
-      options?.isInteractive === true &&
-      conversation.getCurrentSender() === broadcastMessage
-    ) {
-      conversation.updateClient(() => {}, true);
-    }
   }
 
   // Read the just-finished turn's outcome from the stamp `runAgentLoop`'s
@@ -785,11 +783,6 @@ export async function processMessageInBackground(
     return { messageId };
   }
 
-  if (options?.isInteractive === true) {
-    conversation.updateClient(broadcastMessage, false);
-    getSubagentManager().updateParentSender(conversationId, broadcastMessage);
-  }
-
   const restoreToolScope = applyTurnToolAllowlist(conversation, options);
   conversation
     .runAgentLoop(content, messageId, {
@@ -804,12 +797,6 @@ export async function processMessageInBackground(
     })
     .finally(() => {
       restoreToolScope();
-      if (
-        options?.isInteractive === true &&
-        conversation.getCurrentSender() === broadcastMessage
-      ) {
-        conversation.updateClient(() => {}, true);
-      }
     })
     .catch((err) => {
       log.error({ err, conversationId }, "Background agent loop failed");

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 { buildEffectiveMcpConfig } from "../mcp/effective-config.js";
 import { getMcpServerManager } from "../mcp/manager.js";
 import { gmailMessagingProvider } from "../messaging/providers/gmail/adapter.js";
 import { outlookMessagingProvider } from "../messaging/providers/outlook/adapter.js";
@@ -61,11 +62,13 @@ export async function initializeProvidersAndTools(
     );
   }
 
-  // Start MCP servers and register their tools
-  if (config.mcp?.servers && Object.keys(config.mcp.servers).length > 0) {
+  // Start MCP servers — workspace-configured and plugin-declared alike —
+  // and register their tools.
+  const mcpConfig = buildEffectiveMcpConfig(config.mcp);
+  if (Object.keys(mcpConfig.servers).length > 0) {
     const manager = getMcpServerManager();
     try {
-      const serverToolInfos = await manager.start(config.mcp);
+      const serverToolInfos = await manager.start(mcpConfig);
       for (const { serverId, serverConfig, tools } of serverToolInfos) {
         const mcpTools = createMcpToolsFromServer(
           tools,

package/src/daemon/trust-context-types.ts

@@ -106,3 +106,32 @@ export function sameTrustIdentity(
     a.guardianPrincipalId === b.guardianPrincipalId
   );
 }
+
+/** The two trust fields a conversation-shaped value carries. */
+export interface TrustCarrier {
+  currentTurnTrustContext?: TrustContext;
+  trustContext?: TrustContext;
+}
+
+/**
+ * The acting turn's trust, else the owner's. Structural counterpart of
+ * `Conversation.getTurnOrRestingTrust` for call sites handed a
+ * conversation-shaped context rather than the class, so a partial test double
+ * needs only the fields it already has.
+ */
+export function turnOrRestingTrust(
+  carrier: TrustCarrier | undefined,
+): TrustContext | undefined {
+  return carrier?.currentTurnTrustContext ?? carrier?.trustContext;
+}
+
+/**
+ * The owner's trust, independent of any turn. Structural counterpart of
+ * `Conversation.getTrustContext`; see `docs/architecture/turn-actor.md` for
+ * when the owner is the right actor.
+ */
+export function restingTrust(
+  carrier: Pick<TrustCarrier, "trustContext"> | undefined,
+): TrustContext | undefined {
+  return carrier?.trustContext;
+}

package/src/daemon/trust-context.ts

@@ -7,7 +7,7 @@
 import type { ChannelConversationType } from "@vellumai/gateway-client";
 
 import { isHttpAuthDisabled } from "../config/env.js";
-import { shouldExposePersonalMemory } from "../plugins/defaults/memory/substrate/static-context.js";
+import { canSeePersonalMemory } from "../runtime/effective-capabilities.js";
 import type { TrustClass } from "../runtime/trust-class.js";
 import type { TrustContext } from "./trust-context-types.js";
 
@@ -67,21 +67,26 @@ export function resolveTrustClass(
  * Whether personal-memory content may be surfaced for the actor described by
  * `trustContext`: the gate admits guardian-class actors and internal/local
  * flows (including turns with no trust context), and blocks remote untrusted
- * actors — see {@link shouldExposePersonalMemory} for the rationale.
+ * actors.
  *
  * This is THE personal-memory trust gate. Every surface that exposes private
  * user content — the v2 dynamic/static `<memory>` layers, PKB context, NOW.md,
  * memory-v3 cards/spotlight, and the `loadFromDb` rehydration of persisted
  * memory blocks — must call this one helper so the exposure rule cannot drift
- * between copies. It folds in {@link resolveTrustClass} so the dev-bypass
- * (HTTP auth disabled → guardian) applies uniformly at every call site.
+ * between copies.
+ *
+ * The trust-context binding lives here; the policy itself is
+ * {@link canSeePersonalMemory}, alongside the other capability-plus-context
+ * compositions. This adapter folds in {@link resolveTrustClass} so the
+ * dev-bypass (HTTP auth disabled → guardian) applies uniformly at every call
+ * site.
  */
 export function isPersonalMemoryAllowed(
   trustContext: TrustContext | undefined,
 ): boolean {
-  return shouldExposePersonalMemory({
-    sourceChannel: trustContext?.sourceChannel,
-    isTrustedActor: resolveTrustClass(trustContext) === "guardian",
+  return canSeePersonalMemory({
+    trustClass: resolveTrustClass(trustContext),
+    executionChannel: trustContext?.sourceChannel,
   });
 }
 

package/src/daemon/wake-conversation-ops.ts

@@ -32,6 +32,7 @@ import type {
   SubagentToolGateMode,
   WakeToolContextPin,
 } from "./tool-setup-types.js";
+import { restingTrust } from "./trust-context-types.js";
 
 const log = getLogger("wake-conversation-ops");
 
@@ -222,7 +223,7 @@ export async function persistWakeTailMessage(
   const turnChannelCtx = conversation.getTurnChannelContext();
   const turnInterfaceCtx = conversation.getTurnInterfaceContext();
   const metadata: Record<string, unknown> = {
-    ...provenanceFromTrustContext(conversation.trustContext),
+    ...provenanceFromTrustContext(restingTrust(conversation)),
     userMessageChannel: turnChannelCtx?.userMessageChannel ?? "vellum",
     assistantMessageChannel:
       turnChannelCtx?.assistantMessageChannel ?? "vellum",
@@ -301,7 +302,7 @@ export async function persistWakeTriggerMessage(
   const turnChannelCtx = conversation.getTurnChannelContext();
   const turnInterfaceCtx = conversation.getTurnInterfaceContext();
   const metadata: Record<string, unknown> = {
-    ...provenanceFromTrustContext(conversation.trustContext),
+    ...provenanceFromTrustContext(restingTrust(conversation)),
     userMessageChannel: turnChannelCtx?.userMessageChannel ?? "vellum",
     assistantMessageChannel:
       turnChannelCtx?.assistantMessageChannel ?? "vellum",

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");