@vellumai/assistant 0.4.43 → 0.4.45

package/src/daemon/session-surfaces.ts

@@ -1,9 +1,5 @@
 import { v4 as uuid } from "uuid";
 
-import {
-  findSeededHomeBaseApp,
-  getPrebuiltHomeBasePreview,
-} from "../home-base/prebuilt/seed.js";
 import { getApp, getAppPreview, updateApp } from "../memory/app-store.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
@@ -11,7 +7,6 @@ import { isPlainObject } from "../util/object.js";
 import type {
   CardSurfaceData,
   DynamicPageSurfaceData,
-  FileUploadSurfaceData,
   ListSurfaceData,
   ServerMessage,
   SurfaceData,
@@ -78,14 +73,27 @@ function normalizeCardShowData(
     normalized.templateData = input.templateData;
   }
 
-  // task_progress cards need a title for Swift parsing; fall back when missing.
+  // The LLM sometimes sends `title` or `body` at the top-level tool input
+  // instead of nesting them inside `data`. The Swift client requires `title`
+  // inside the card data dict — without it `parseCardData` returns nil and
+  // the surface is silently dropped. Copy them from input when missing.
+  if (
+    typeof normalized.title !== "string" &&
+    typeof input.title === "string" &&
+    input.title.trim().length > 0
+  ) {
+    normalized.title = input.title;
+  }
+  if (typeof normalized.body !== "string" && typeof input.body === "string") {
+    normalized.body = input.body;
+  }
+
+  // task_progress cards: additional fallbacks for title from templateData.
   if (
     normalized.template === "task_progress" &&
     typeof normalized.title !== "string"
   ) {
-    if (typeof input.title === "string" && input.title.trim().length > 0) {
-      normalized.title = input.title;
-    } else if (
+    if (
       isPlainObject(normalized.templateData) &&
       typeof normalized.templateData.title === "string"
     ) {
@@ -166,7 +174,17 @@ export interface SurfaceSessionContext {
   >;
   surfaceState: Map<
     string,
-    { surfaceType: SurfaceType; data: SurfaceData; title?: string }
+    {
+      surfaceType: SurfaceType;
+      data: SurfaceData;
+      title?: string;
+      actions?: Array<{
+        id: string;
+        label: string;
+        style?: string;
+        data?: Record<string, unknown>;
+      }>;
+    }
   >;
   surfaceUndoStacks: Map<string, string[]>;
   /** Request IDs that originated from surface action button clicks (not regular user messages). */
@@ -176,7 +194,12 @@ export interface SurfaceSessionContext {
     surfaceType: SurfaceType;
     title?: string;
     data: SurfaceData;
-    actions?: Array<{ id: string; label: string; style?: string }>;
+    actions?: Array<{
+      id: string;
+      label: string;
+      style?: string;
+      data?: Record<string, unknown>;
+    }>;
     display?: string;
   }>;
   onEscalateToComputerUse?: (task: string, sourceSessionId: string) => boolean;
@@ -191,7 +214,7 @@ export interface SurfaceSessionContext {
     metadata?: Record<string, unknown>,
     options?: { isInteractive?: boolean },
     displayContent?: string,
-  ): { queued: boolean; rejected?: boolean; requestId: string };
+  ): { queued: boolean; requestId: string; rejected?: boolean };
   getQueueDepth(): number;
   processMessage(
     content: string,
@@ -517,8 +540,82 @@ export function handleSurfaceAction(
   data?: Record<string, unknown>,
 ): void {
   const pending = ctx.pendingSurfaceActions.get(surfaceId);
+
+  // When surfaces are restored from history (e.g. onboarding cards), there is
+  // no in-memory pendingSurfaceActions entry.  For relay_prompt / agent_prompt
+  // actions the client already sends the full payload (including { prompt }),
+  // so we can handle them without stored state.
   if (!pending) {
-    log.warn({ surfaceId, actionId }, "No pending surface action found");
+    const isRelay = actionId === "relay_prompt" || actionId === "agent_prompt";
+    const prompt =
+      isRelay && typeof data?.prompt === "string" ? data.prompt.trim() : "";
+
+    if (!prompt) {
+      log.warn({ surfaceId, actionId }, "No pending surface action found");
+      return;
+    }
+
+    const requestId = uuid();
+    ctx.surfaceActionRequestIds.add(requestId);
+    const onEvent = (msg: ServerMessage) => ctx.sendToClient(msg);
+
+    ctx.traceEmitter.emit("request_received", "Surface action received", {
+      requestId,
+      status: "info",
+      attributes: { source: "surface_action", surfaceId, actionId },
+    });
+
+    const result = ctx.enqueueMessage(
+      prompt,
+      [],
+      onEvent,
+      requestId,
+      surfaceId,
+    );
+
+    if (result.rejected) {
+      ctx.surfaceActionRequestIds.delete(requestId);
+      return;
+    }
+
+    // Echo the prompt to the client so it appears in the chat UI.
+    // Deferred until after rejection check to avoid ghost messages.
+    ctx.sendToClient({
+      type: "user_message_echo",
+      text: prompt,
+      sessionId: ctx.conversationId,
+    });
+
+    if (result.queued) {
+      log.info(
+        { surfaceId, actionId, requestId },
+        "Relay prompt queued (session busy, history-restored)",
+      );
+      return;
+    }
+
+    // Session is idle — process the message immediately.
+    log.info(
+      { surfaceId, actionId, requestId },
+      "Processing relay prompt immediately (history-restored)",
+    );
+    ctx
+      .processMessage(prompt, [], onEvent, requestId, surfaceId)
+      .catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        log.error(
+          { err, surfaceId, actionId },
+          "Failed to process history-restored relay prompt",
+        );
+        onEvent(
+          buildSessionErrorMessage(ctx.conversationId, {
+            code: "SESSION_PROCESSING_FAILED",
+            userMessage: `Something went wrong: ${message}`,
+            retryable: false,
+            debugDetails: `History-restored relay prompt processing failed: ${message}`,
+          }),
+        );
+      });
     return;
   }
   const retainPending = pending.surfaceType === "dynamic_page";
@@ -538,32 +635,39 @@ export function handleSurfaceAction(
     handleDocumentContentChanged(ctx, surfaceId, data);
     return;
   }
-  ctx.lastSurfaceAction.set(surfaceId, { actionId, data });
+  // Merge stored action-level data (from ui_show definition) with client-sent
+  // data. This is critical for relay_prompt buttons: the client only sends the
+  // actionId, but the prompt payload lives in the action definition's data.
+  const stored = ctx.surfaceState.get(surfaceId);
+  const actionDef = stored?.actions?.find((a) => a.id === actionId);
+  const mergedData: Record<string, unknown> | undefined =
+    actionDef?.data || data ? { ...actionDef?.data, ...data } : undefined;
+
+  ctx.lastSurfaceAction.set(surfaceId, { actionId, data: mergedData });
   const shouldRelayPrompt =
     actionId === "relay_prompt" || actionId === "agent_prompt";
   const prompt =
-    shouldRelayPrompt && typeof data?.prompt === "string"
-      ? data.prompt.trim()
+    shouldRelayPrompt && typeof mergedData?.prompt === "string"
+      ? mergedData.prompt.trim()
       : "";
 
   // Build a human-readable summary so the LLM clearly understands the
   // user's decision instead of parsing raw JSON.
-  const stored = ctx.surfaceState.get(surfaceId);
   const surfaceData = stored?.data as Record<string, unknown> | undefined;
   const summary = buildCompletionSummary(
     pending.surfaceType,
     actionId,
-    data,
+    mergedData,
     surfaceData,
   );
   let fallbackContent = `[User action on ${pending.surfaceType} surface: ${summary}]`;
   // Append structured data so the LLM has access to IDs/values it needs
   // to act on (e.g. selectedIds for archiving).
-  if (data && Object.keys(data).length > 0) {
-    fallbackContent += `\n\nAction data: ${JSON.stringify(data)}`;
+  if (mergedData && Object.keys(mergedData).length > 0) {
+    fallbackContent += `\n\nAction data: ${JSON.stringify(mergedData)}`;
   }
   // Append deselection context for table/list surfaces so the LLM knows what the user chose to keep.
-  const selectedIds = data?.selectedIds as string[] | undefined;
+  const selectedIds = mergedData?.selectedIds as string[] | undefined;
   if (
     selectedIds &&
     (pending.surfaceType === "table" || pending.surfaceType === "list")
@@ -574,25 +678,33 @@ export function handleSurfaceAction(
       selectedIds,
     );
   }
-  const content = prompt || fallbackContent;
+  // When a relay_prompt button also carries selection data (e.g. list/table
+  // surface with a canned prompt + user-selected rows), append the selection
+  // context so the LLM sees both the prompt and the user's selections.
+  let content = prompt || fallbackContent;
+  if (prompt && selectedIds && mergedData) {
+    if (pending.surfaceType === "table" || pending.surfaceType === "list") {
+      content += buildDeselectionDescription(
+        pending.surfaceType,
+        stored,
+        selectedIds,
+      );
+    }
+  }
   // Show the user plain-text instead of raw JSON action data.
   const displayContent = prompt
     ? undefined
-    : buildUserFacingLabel(pending.surfaceType, actionId, data, surfaceData);
+    : buildUserFacingLabel(
+        pending.surfaceType,
+        actionId,
+        mergedData,
+        surfaceData,
+      );
 
   const requestId = uuid();
   ctx.surfaceActionRequestIds.add(requestId);
   const onEvent = (msg: ServerMessage) => ctx.sendToClient(msg);
 
-  // Echo the user's prompt to the client so it appears in the chat UI
-  if (shouldRelayPrompt && prompt) {
-    ctx.sendToClient({
-      type: "user_message_echo",
-      text: prompt,
-      sessionId: ctx.conversationId,
-    });
-  }
-
   ctx.traceEmitter.emit("request_received", "Surface action received", {
     requestId,
     status: "info",
@@ -610,6 +722,20 @@ export function handleSurfaceAction(
     undefined,
     displayContent,
   );
+  if (result.rejected) {
+    ctx.surfaceActionRequestIds.delete(requestId);
+    return;
+  }
+
+  // Echo the user's prompt to the client so it appears in the chat UI.
+  // Deferred until after rejection check to avoid ghost messages.
+  if (shouldRelayPrompt && prompt) {
+    ctx.sendToClient({
+      type: "user_message_echo",
+      text: prompt,
+      sessionId: ctx.conversationId,
+    });
+  }
   if (result.queued) {
     const position = ctx.getQueueDepth();
     if (!retainPending) {
@@ -637,29 +763,6 @@ export function handleSurfaceAction(
     return;
   }
 
-  if (result.rejected) {
-    log.error({ surfaceId, actionId }, "Surface action rejected — queue full");
-    ctx.traceEmitter.emit(
-      "request_error",
-      "Surface action rejected — queue full",
-      {
-        requestId,
-        status: "error",
-        attributes: { reason: "queue_full", source: "surface_action" },
-      },
-    );
-    onEvent(
-      buildSessionErrorMessage(ctx.conversationId, {
-        code: "QUEUE_FULL",
-        userMessage:
-          "Message queue is full (max depth: 10). Please wait for current messages to be processed.",
-        retryable: true,
-        debugDetails: "Surface action rejected — session queue is full",
-      }),
-    );
-    return;
-  }
-
   if (!retainPending) {
     ctx.pendingSurfaceActions.delete(surfaceId);
   }
@@ -828,7 +931,7 @@ export function buildUserFacingLabel(
 
 /**
  * Resolve a proxy tool call that targets a UI surface.
- * Handles ui_show, ui_update, ui_dismiss, request_file, computer_use_request_control, and app_open.
+ * Handles ui_show, ui_update, ui_dismiss, computer_use_request_control, and app_open.
  */
 export async function surfaceProxyResolver(
   ctx: SurfaceSessionContext,
@@ -849,56 +952,6 @@ export async function surfaceProxyResolver(
     }
   }
 
-  if (toolName === "request_file") {
-    const surfaceId = uuid();
-    const prompt =
-      typeof input.prompt === "string" ? input.prompt : "Please share a file";
-    const acceptedTypes = Array.isArray(input.accepted_types)
-      ? (input.accepted_types as string[])
-      : undefined;
-    const maxFiles = typeof input.max_files === "number" ? input.max_files : 1;
-
-    const data: FileUploadSurfaceData = {
-      prompt,
-      acceptedTypes,
-      maxFiles,
-    };
-
-    ctx.surfaceState.set(surfaceId, { surfaceType: "file_upload", data });
-
-    ctx.sendToClient({
-      type: "ui_surface_show",
-      sessionId: ctx.conversationId,
-      surfaceId,
-      surfaceType: "file_upload",
-      title: "File Request",
-      data,
-    } as UiSurfaceShow);
-
-    // Track surface for persistence
-    ctx.currentTurnSurfaces.push({
-      surfaceId,
-      surfaceType: "file_upload",
-      title: "File Request",
-      data,
-    });
-
-    // Non-blocking: return immediately, user action arrives as follow-up message
-    ctx.pendingSurfaceActions.set(surfaceId, {
-      surfaceType: "file_upload" as SurfaceType,
-    });
-    return {
-      content: JSON.stringify({
-        surfaceId,
-        status: "awaiting_user_action",
-        message:
-          "File upload dialog displayed and the user can see it. The uploaded file data will arrive as a follow-up message. Do not output any waiting message — just stop here.",
-      }),
-      isError: false,
-      yieldToUser: true,
-    };
-  }
-
   if (toolName === "ui_show") {
     const surfaceId = uuid();
     const surfaceType = input.surface_type as SurfaceType;
@@ -912,7 +965,12 @@ export async function surfaceProxyResolver(
           : rawData
     ) as SurfaceData;
     const actions = input.actions as
-      | Array<{ id: string; label: string; style?: string }>
+      | Array<{
+          id: string;
+          label: string;
+          style?: string;
+          data?: Record<string, unknown>;
+        }>
       | undefined;
     // Interactive surfaces default to awaiting user action.
     const hasActions = Array.isArray(actions) && actions.length > 0;
@@ -942,9 +1000,6 @@ export async function surfaceProxyResolver(
       }
     }
 
-    // Track surface state for ui_update merging
-    ctx.surfaceState.set(surfaceId, { surfaceType, data, title });
-
     const display = (input.display as string) === "panel" ? "panel" : "inline";
 
     const mappedActions = actions?.map((a) => ({
@@ -954,8 +1009,31 @@ export async function surfaceProxyResolver(
         | "primary"
         | "secondary"
         | "destructive",
+      ...(a.data ? { data: a.data } : {}),
     }));
 
+    // Track surface state for ui_update merging (includes actions so we can
+    // look up per-action data payloads when the client sends an action back).
+    ctx.surfaceState.set(surfaceId, {
+      surfaceType,
+      data,
+      title,
+      actions: mappedActions,
+    });
+
+    log.info(
+      {
+        surfaceId,
+        surfaceType,
+        title,
+        dataKeys: Object.keys(data),
+        actionCount: mappedActions?.length ?? 0,
+        display,
+        conversationId: ctx.conversationId,
+      },
+      "Sending ui_surface_show to client",
+    );
+
     ctx.sendToClient({
       type: "ui_surface_show",
       sessionId: ctx.conversationId,
@@ -1106,14 +1184,10 @@ export async function surfaceProxyResolver(
     const openMode = input.open_mode as string | undefined;
     const app = getApp(appId);
     if (!app) return { content: `App not found: ${appId}`, isError: true };
-    const seededHomeBase = findSeededHomeBaseApp();
-    const defaultPreview =
-      seededHomeBase && seededHomeBase.id === app.id
-        ? getPrebuiltHomeBasePreview()
-        : // Generate a minimal fallback preview from app metadata so that the
-          // surface is always rendered as a clickable preview card (not an
-          // un-clickable fallback chip) after session restart.
-          { title: app.name, subtitle: app.description };
+    // Generate a minimal fallback preview from app metadata so that the
+    // surface is always rendered as a clickable preview card (not an
+    // un-clickable fallback chip) after session restart.
+    const defaultPreview = { title: app.name, subtitle: app.description };
 
     const storedPreview = getAppPreview(app.id);
     const surfaceData: DynamicPageSurfaceData = {

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

@@ -27,10 +27,14 @@ import { coreAppProxyTools } from "../tools/apps/definitions.js";
 import { registerSessionSender } from "../tools/browser/browser-screencast.js";
 import { requestComputerControlTool } from "../tools/computer-use/request-computer-control.js";
 import type { ToolExecutor } from "../tools/executor.js";
-import { getAllToolDefinitions } from "../tools/registry.js";
+import {
+  getAllToolDefinitions,
+  getMcpToolDefinitions,
+} from "../tools/registry.js";
 import type {
   ProxyApprovalCallback,
   ProxyApprovalRequest,
+  ToolContext,
   ToolExecutionResult,
   ToolLifecycleEventHandler,
 } from "../tools/types.js";
@@ -87,7 +91,7 @@ export interface ToolSetupContext extends SurfaceSessionContext {
   allowedToolNames?: Set<string>;
   /** Session memory policy — used to propagate scopeId and strictSideEffects into ToolContext. */
   memoryPolicy: { scopeId: string; strictSideEffects: boolean };
-  /** True when the session has no connected IPC client (HTTP-only path). */
+  /** True when the session has no connected client (HTTP-only path). */
   hasNoClient?: boolean;
   /** When true, the session is executing a task run and must not become interactive. */
   headlessLock?: boolean;
@@ -97,6 +101,10 @@ export interface ToolSetupContext extends SurfaceSessionContext {
   trustContext?: TrustContext;
   /** Voice/call session ID, if the session originates from a call. Propagated into ToolContext for scoped grant consumption. */
   callSessionId?: string;
+  /** Optional proxy for delegating host_bash execution to a connected client. */
+  hostBashProxy?: import("./host-bash-proxy.js").HostBashProxy;
+  /** Optional proxy for delegating host_file_read/write/edit execution to a connected client. */
+  hostFileProxy?: import("./host-file-proxy.js").HostFileProxy;
 }
 
 // ── buildToolDefinitions ─────────────────────────────────────────────
@@ -150,7 +158,9 @@ export function createToolExecutor(
       markDoordashStepInProgress(ctx, input);
     }
 
-    const result = await executor.execute(name, input, {
+    // Build the context object shared by both the skill_execute interception
+    // path and the regular executor path.
+    const toolContext: ToolContext = {
       workingDir: ctx.workingDir,
       sessionId: ctx.conversationId,
       conversationId: ctx.conversationId,
@@ -175,6 +185,8 @@ export function createToolExecutor(
       memoryScopeId: ctx.memoryPolicy.scopeId,
       forcePromptSideEffects: ctx.memoryPolicy.strictSideEffects,
       toolUseId,
+      hostBashProxy: ctx.hostBashProxy,
+      hostFileProxy: ctx.hostFileProxy,
       onToolLifecycleEvent: handleToolLifecycleEvent,
       sendToClient: (msg) => {
         // Tool context's sendToClient uses a loose { type: string; [key: string]: unknown }
@@ -315,7 +327,38 @@ export function createToolExecutor(
             : ("deny" as const),
         };
       },
-    });
+    };
+
+    // Intercept skill_execute: extract the real tool name and input, then
+    // route through the full executor pipeline so the underlying tool's
+    // risk level, permission checks, hooks, and lifecycle events all fire
+    // with the real tool name.
+    if (name === "skill_execute") {
+      const toolName = typeof input.tool === "string" ? input.tool : "";
+      const toolInput =
+        input.input != null && typeof input.input === "object"
+          ? (input.input as Record<string, unknown>)
+          : {};
+
+      if (!toolName) {
+        return {
+          content:
+            'Error: skill_execute requires a "tool" parameter with the tool name',
+          isError: true,
+        };
+      }
+
+      const result = await executor.execute(toolName, toolInput, toolContext);
+
+      runPostExecutionSideEffects(toolName, toolInput, result, {
+        ctx,
+        broadcastToAllClients,
+      });
+
+      return result;
+    }
+
+    const result = await executor.execute(name, input, toolContext);
 
     runPostExecutionSideEffects(name, input, result, {
       ctx,
@@ -486,6 +529,63 @@ export interface SkillProjectionContext {
   allowedToolNames?: Set<string>;
   /** When > 0, the resolveTools callback returns no tools at all. */
   toolsDisabledDepth: number;
+  /** Channel capabilities — read lazily per turn for conditional tool filtering. */
+  readonly channelCapabilities?: {
+    channel: string;
+    supportsDynamicUi: boolean;
+  };
+  /** True when no client is connected (HTTP-only). */
+  readonly hasNoClient?: boolean;
+  /** True when the conversation has user-uploaded attachments. */
+  hasAttachments?: boolean;
+}
+
+// ── Conditional tool sets ────────────────────────────────────────────
+
+const UI_SURFACE_TOOL_NAMES = new Set(["ui_show", "ui_update", "ui_dismiss"]);
+const HOST_TOOL_NAMES = new Set([
+  "host_file_read",
+  "host_file_write",
+  "host_file_edit",
+  "host_bash",
+]);
+const ASSET_TOOL_NAMES = new Set(["asset_search", "asset_materialize"]);
+const CLIENT_CAPABILITY_TOOL_NAMES = new Set([
+  "app_open",
+  "computer_use_request_control",
+]);
+const PLATFORM_TOOL_NAMES = new Set(["request_system_permission"]);
+
+/**
+ * Determine whether a tool should be included in the LLM tool definitions
+ * for the current turn based on session context. Tools not active for the
+ * current context are omitted from the definitions sent to the provider,
+ * reducing noise and preventing the model from attempting calls that would
+ * fail.
+ */
+export function isToolActiveForContext(
+  name: string,
+  ctx: SkillProjectionContext,
+): boolean {
+  if (UI_SURFACE_TOOL_NAMES.has(name)) {
+    return ctx.channelCapabilities?.supportsDynamicUi ?? !ctx.hasNoClient;
+  }
+  if (HOST_TOOL_NAMES.has(name)) {
+    // Host tools require a connected client — without one, there is no human
+    // to approve execution and the guardian auto-approve path would allow
+    // unchecked host command execution on the daemon host.
+    return !ctx.hasNoClient;
+  }
+  if (ASSET_TOOL_NAMES.has(name)) {
+    return ctx.hasAttachments ?? false;
+  }
+  if (CLIENT_CAPABILITY_TOOL_NAMES.has(name)) {
+    return !ctx.hasNoClient;
+  }
+  if (PLATFORM_TOOL_NAMES.has(name)) {
+    return process.platform === "darwin" && !ctx.hasNoClient;
+  }
+  return true;
 }
 
 /**
@@ -493,6 +593,12 @@ export interface SkillProjectionContext {
  * dynamically projected skill tools on each agent turn. Also updates
  * allowedToolNames so newly-activated skill tools aren't blocked by
  * the executor's stale gate.
+ *
+ * Core (non-MCP) tool definitions are captured at session creation and
+ * reused on each turn. MCP tool definitions are re-read from the global
+ * registry on each turn so that tools registered after session creation
+ * (e.g. via `vellum mcp reload`) are automatically picked up without
+ * requiring session disposal or app restart.
  */
 export function createResolveToolsCallback(
   toolDefs: ToolDefinition[],
@@ -500,6 +606,20 @@ export function createResolveToolsCallback(
 ): ((history: Message[]) => ToolDefinition[]) | undefined {
   if (toolDefs.length === 0) return undefined;
 
+  // Separate the initial tool defs into core (stable) and MCP (dynamic).
+  // We keep core tools from the snapshot and re-read MCP tools each turn.
+  const initialMcpDefs = getMcpToolDefinitions();
+  const initialMcpNames = new Set(initialMcpDefs.map((d) => d.name));
+  const coreToolDefs = toolDefs.filter((d) => !initialMcpNames.has(d.name));
+  log.debug(
+    {
+      coreCount: coreToolDefs.length,
+      mcpCount: initialMcpDefs.length,
+      mcpTools: initialMcpDefs.map((d) => d.name),
+    },
+    "Session tool resolver initialized",
+  );
+
   return (history: Message[]) => {
     // When tools are explicitly disabled (e.g. during pointer generation),
     // return an empty tool list so the LLM never sees tool definitions and
@@ -509,6 +629,26 @@ export function createResolveToolsCallback(
       return [];
     }
 
+    // Filter core tools based on current session context so that tools
+    // irrelevant to this turn (e.g. UI tools when no client is connected)
+    // are omitted from the definitions sent to the provider.
+    const filteredCoreDefs = coreToolDefs.filter((d) =>
+      isToolActiveForContext(d.name, ctx),
+    );
+
+    // Re-read MCP tool definitions from the registry each turn so sessions
+    // automatically pick up tools added/removed by `vellum mcp reload`.
+    const currentMcpDefs = getMcpToolDefinitions();
+    log.debug(
+      {
+        coreCount: filteredCoreDefs.length,
+        mcpCount: currentMcpDefs.length,
+        mcpTools: currentMcpDefs.map((d) => d.name),
+      },
+      "MCP tools resolved for turn",
+    );
+    const allBaseDefs = [...filteredCoreDefs, ...currentMcpDefs];
+
     const effectivePreactivated = [
       ...DEFAULT_PREACTIVATED_SKILL_IDS,
       ...(ctx.preactivatedSkillIds ?? []),
@@ -518,11 +658,11 @@ export function createResolveToolsCallback(
       previouslyActiveSkillIds: ctx.skillProjectionState,
       cache: ctx.skillProjectionCache,
     });
-    const turnAllowed = new Set(ctx.coreToolNames);
+    const turnAllowed = new Set(allBaseDefs.map((d) => d.name));
     for (const name of projection.allowedToolNames) {
       turnAllowed.add(name);
     }
     ctx.allowedToolNames = turnAllowed;
-    return [...toolDefs, ...projection.toolDefinitions];
+    return allBaseDefs;
   };
 }