@vellumai/assistant 0.8.5 → 0.8.6

package/src/tools/registry.ts

@@ -2,7 +2,6 @@ import type { ToolDefinition } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
 import { coreAppProxyTools } from "./apps/definitions.js";
 import { registerAppTools } from "./apps/registry.js";
-import { allComputerUseTools } from "./computer-use/definitions.js";
 import { hostFileEditTool } from "./host-filesystem/edit.js";
 import { hostFileReadTool } from "./host-filesystem/read.js";
 import { hostFileTransferTool } from "./host-filesystem/transfer.js";
@@ -10,7 +9,7 @@ import { hostFileWriteTool } from "./host-filesystem/write.js";
 import { hostShellTool } from "./host-terminal/host-shell.js";
 import { toProviderSafeToolName } from "./provider-tool-name.js";
 import { registerSystemTools } from "./system/register.js";
-import type { LoadedTool, Tool } from "./types.js";
+import type { LoadedTool, OwnerInfo, Tool } from "./types.js";
 import { allUiSurfaceTools } from "./ui-surface/definitions.js";
 import { registerUiSurfaceTools } from "./ui-surface/registry.js";
 
@@ -18,6 +17,15 @@ const log = getLogger("tool-registry");
 
 const tools = new Map<string, Tool>();
 
+// Authoritative map of tool ownership, keyed by tool name. Populated by the
+// `register*` functions and read by `getToolOwner()`. Lives on the registry
+// (not on the `Tool` object) so callers cannot spoof ownership by writing a
+// field on the manifest — the only way to claim a tool is to go through a
+// `register*` function, which stamps the owner from its arguments. Core
+// tools intentionally have no entry here; `getToolOwner` returns `undefined`
+// for them.
+const ownersByName = new Map<string, OwnerInfo>();
+
 // ── External tool registry ───────────────────────────────────────────
 // Skills register their tools here at initialization time so the tool
 // manifest can include them without importing from `../skills/`.
@@ -28,7 +36,10 @@ const tools = new Map<string, Tool>();
 // feature-flag check until after the daemon has run
 // `mergeDefaultWorkspaceConfig()`, so skills see the merged config
 // instead of forcing an early `loadConfig()` against unmerged defaults.
-const externalToolProviders: Array<() => Tool[]> = [];
+const externalToolProviders: Array<{
+  owner: OwnerInfo;
+  provider: () => Tool[];
+}> = [];
 
 /**
  * Register tools provided by an external skill. Called during skill
@@ -44,20 +55,30 @@ const externalToolProviders: Array<() => Tool[]> = [];
  * dependency: skills/load.ts → … → meet-join/register.ts → tool-manifest.ts
  * → skills/load.ts. Keeping it here lets external skill bootstraps import
  * from registry.ts, which is already a leaf in the dependency graph.
+ *
+ * `owner` records which extension produced these tools — typed
+ * {@link OwnerInfo} so ownership flows through `ownersByName` at
+ * `initializeTools()` time, the same way `register*` registers it for
+ * IPC-loaded tools. Eager (boot-time) skill bootstraps go through this
+ * path rather than `registerSkillTools`, so this is where their owner
+ * lookup gets established.
  */
 export function registerExternalTools(
+  owner: OwnerInfo,
   toolsOrProvider: Tool[] | (() => Tool[]),
 ): void {
   const provider =
     typeof toolsOrProvider === "function"
       ? toolsOrProvider
       : () => toolsOrProvider;
-  externalToolProviders.push(provider);
+  externalToolProviders.push({ owner, provider });
 }
 
-/** Return all externally registered tools. */
-function getExternalTools(): Tool[] {
-  return externalToolProviders.flatMap((provider) => provider());
+/** Return all externally registered tools paired with their owners. */
+function getExternalTools(): Array<{ owner: OwnerInfo; tool: Tool }> {
+  return externalToolProviders.flatMap(({ owner, provider }) =>
+    provider().map((tool) => ({ owner, tool })),
+  );
 }
 
 // Snapshot of core tools captured after initializeTools() completes.
@@ -76,6 +97,27 @@ const skillRefCount = new Map<string, number>();
 // separate and covers the case of two extensions choosing the same tool name.
 const pluginRefCount = new Map<string, number>();
 
+/**
+ * Format an owner for log messages and error strings. Returns a stable
+ * human-readable description (e.g. `skill "deploy"`, `plugin "weather"`,
+ * `MCP server "github"`). When an owner is missing (core tool) or has an
+ * unrecognized kind, returns a fallback string so log/error sites never
+ * produce `undefined` interpolations.
+ */
+function describeOwner(owner: OwnerInfo | undefined): string {
+  if (!owner) return "core tool";
+  switch (owner.kind) {
+    case "skill":
+      return `skill "${owner.id}"`;
+    case "plugin":
+      return `plugin "${owner.id}"`;
+    case "mcp":
+      return `MCP server "${owner.id}"`;
+    default:
+      return `${(owner as OwnerInfo).kind}-origin tool`;
+  }
+}
+
 function withProviderSafeToolName(tool: Tool): Tool {
   const safeName = toProviderSafeToolName(tool.name);
   if (safeName === tool.name) {
@@ -107,83 +149,89 @@ export function getAllTools(): Tool[] {
 }
 
 /**
- * Register multiple skill-origin tools at once.
+ * Return the recorded owner for a tool, or `undefined` if the tool is
+ * core-origin (no owner) or unknown. Consumers that need to gate behavior on
+ * which extension contributed a tool (permissions checker, approval-handler
+ * load hints, conversation-skill-tools projection) call this rather than
+ * reading owner off the `Tool` object — the registry is the single source of
+ * truth for ownership.
+ */
+export function getToolOwner(name: string): OwnerInfo | undefined {
+  return ownersByName.get(name);
+}
+
+/**
+ * Register multiple skill-origin tools owned by `skillId`.
+ *
  * Skips any tool whose name collides with a core tool (logs a warning instead
  * of throwing so the remaining tools in the batch still get registered).
  * Throws if a tool name collides with a skill tool owned by a different skill.
- * Allows replacement when the incoming tool has the same ownerSkillId as the existing one,
- * which supports hot-reloading a skill without tearing down first.
+ * Allows replacement when the incoming tool has the same skill owner id as
+ * the existing one, which supports hot-reloading a skill without tearing
+ * down first.
+ *
+ * Ownership is recorded in {@link ownersByName} keyed by tool name; the
+ * `Tool` object itself carries no owner metadata, so callers cannot spoof
+ * ownership by writing fields on the manifest.
  */
-export function registerSkillTools(newTools: Tool[]): Tool[] {
+export function registerSkillTools(skillId: string, newTools: Tool[]): Tool[] {
   // Filter out tools that collide with core tools, and validate the rest.
   const accepted: Tool[] = [];
   for (const tool of newTools) {
     const existing = tools.get(tool.name);
     if (existing) {
-      const existingIsCore = existing.origin === "core" || !existing.origin;
+      const existingIsCore = !ownersByName.has(tool.name);
       if (existingIsCore) {
         log.warn(
-          { toolName: tool.name, skillId: tool.ownerSkillId },
-          `Skill "${tool.ownerSkillId}" tried to register tool "${tool.name}" which conflicts with a core tool. Skipping.`,
+          { toolName: tool.name, ownerSkillId: skillId },
+          `Skill "${skillId}" tried to register tool "${tool.name}" which conflicts with a core tool. Skipping.`,
         );
         continue;
       }
-      // Existing is from a different origin (plugin/mcp) or a different
+      // Existing is from a different owner (plugin/mcp) or a different
       // skill — skill tools can only replace themselves (hot-reload).
-      if (
-        existing.origin !== "skill" ||
-        existing.ownerSkillId !== tool.ownerSkillId
-      ) {
-        const owner =
-          existing.origin === "skill"
-            ? `skill "${existing.ownerSkillId}"`
-            : existing.origin === "plugin"
-              ? `plugin "${existing.ownerPluginId}"`
-              : existing.origin === "mcp"
-                ? `MCP server "${existing.ownerMcpServerId}"`
-                : `${existing.origin ?? "unknown"}-origin tool`;
+      const existingOwner = ownersByName.get(tool.name);
+      const existingSkillId =
+        existingOwner?.kind === "skill" ? existingOwner.id : undefined;
+      if (existingOwner?.kind !== "skill" || existingSkillId !== skillId) {
         throw new Error(
-          `Skill tool "${tool.name}" is already registered by ${owner}`,
+          `Skill tool "${tool.name}" is already registered by ${describeOwner(existingOwner)}`,
         );
       }
     }
     accepted.push(tool);
   }
 
-  // Collect unique skill IDs from the batch to bump ref counts
-  const skillIds = new Set<string>();
   for (const tool of accepted) {
     tools.set(tool.name, tool);
-    if (tool.ownerSkillId) skillIds.add(tool.ownerSkillId);
+    ownersByName.set(tool.name, { kind: "skill", id: skillId });
     log.info(
-      { name: tool.name, ownerSkillId: tool.ownerSkillId },
+      { name: tool.name, ownerSkillId: skillId },
       "Skill tool registered",
     );
   }
 
-  for (const id of skillIds) {
-    skillRefCount.set(id, (skillRefCount.get(id) ?? 0) + 1);
+  if (accepted.length > 0) {
+    skillRefCount.set(skillId, (skillRefCount.get(skillId) ?? 0) + 1);
   }
 
   return accepted;
 }
 
 /**
- * Register tools contributed by a plugin. Stamps `origin: "plugin"` and
- * `ownerPluginId: pluginName` on every incoming tool so plugin ownership is
- * tracked in a namespace disjoint from skill tools — if a plugin's
- * `manifest.name` happens to match a skill id, the two do not share refcount
- * state or conflict-detection paths.
+ * Register tools contributed by the plugin named `pluginName`. Records the
+ * plugin owner in {@link ownersByName} keyed by tool name — ownership lives
+ * on the registry, never on the `Tool` object itself, so the bootstrap
+ * cannot be spoofed into claiming tools on behalf of an unrelated extension
+ * by forging fields on the manifest. Plugin ownership is tracked in a
+ * namespace disjoint from skill tools: if a plugin's `manifest.name`
+ * happens to match a skill id, the two do not share refcount state or
+ * conflict-detection paths.
  *
  * Conflict handling mirrors {@link registerSkillTools}: collisions with core
  * tools log a warning and skip; collisions with tools owned by a different
  * plugin, skill, or MCP server throw; re-registering the same plugin's own
  * tool (hot reload) is allowed.
- *
- * The stamp is authoritative: any pre-existing `origin` / `ownerPluginId` /
- * `ownerSkillId` / `ownerMcpServerId` fields on the incoming tools are
- * overwritten so the bootstrap cannot be spoofed into claiming tools on
- * behalf of an unrelated extension.
  */
 export function registerPluginTools(
   pluginName: string,
@@ -193,12 +241,6 @@ export function registerPluginTools(
     const tool: Tool = {
       ...pluginTool,
       category: "plugin",
-      origin: "plugin" as const,
-      ownerPluginId: pluginName,
-      ownerSkillId: undefined,
-      ownerMcpServerId: undefined,
-      ownerSkillBundled: undefined,
-      ownerSkillVersionHash: undefined,
     };
     return withProviderSafeToolName(tool);
   });
@@ -207,25 +249,26 @@ export function registerPluginTools(
   for (const tool of stamped) {
     const existing = tools.get(tool.name);
     if (existing) {
-      const existingIsCore = existing.origin === "core" || !existing.origin;
+      const existingIsCore = !ownersByName.has(tool.name);
       if (existingIsCore) {
         log.warn(
-          { toolName: tool.name, pluginName },
+          { toolName: tool.name, ownerPluginId: pluginName },
           `Plugin "${pluginName}" tried to register tool "${tool.name}" which conflicts with a core tool. Skipping.`,
         );
         continue;
       }
-      if (existing.origin === "plugin") {
-        if (existing.ownerPluginId !== pluginName) {
+      const existingOwner = ownersByName.get(tool.name);
+      if (existingOwner?.kind === "plugin") {
+        if (existingOwner.id !== pluginName) {
           throw new Error(
-            `Plugin tool "${tool.name}" is already registered by plugin "${existing.ownerPluginId}"`,
+            `Plugin tool "${tool.name}" is already registered by plugin "${existingOwner.id}"`,
           );
         }
         // Same plugin re-registering its own tool (hot reload) — allow.
       } else {
         // Conflict with a skill or MCP-owned tool.
         throw new Error(
-          `Plugin "${pluginName}" tried to register tool "${tool.name}" which conflicts with a ${existing.origin}-origin tool`,
+          `Plugin "${pluginName}" tried to register tool "${tool.name}" which conflicts with ${describeOwner(existingOwner)}`,
         );
       }
     }
@@ -234,8 +277,9 @@ export function registerPluginTools(
 
   for (const tool of accepted) {
     tools.set(tool.name, tool);
+    ownersByName.set(tool.name, { kind: "plugin", id: pluginName });
     log.info(
-      { name: tool.name, ownerPluginId: tool.ownerPluginId },
+      { name: tool.name, ownerPluginId: pluginName },
       "Plugin tool registered",
     );
   }
@@ -264,10 +308,11 @@ export function unregisterPluginTools(pluginName: string): void {
   }
 
   pluginRefCount.delete(pluginName);
-  for (const [name, tool] of tools) {
-    if (tool.origin === "plugin" && tool.ownerPluginId === pluginName) {
+  for (const [name, owner] of ownersByName) {
+    if (owner.kind === "plugin" && owner.id === pluginName) {
       tools.delete(name);
-      log.info({ name, pluginName }, "Plugin tool unregistered");
+      ownersByName.delete(name);
+      log.info({ name, ownerPluginId: pluginName }, "Plugin tool unregistered");
     }
   }
 }
@@ -296,60 +341,52 @@ export function unregisterSkillTools(skillId: string): void {
 
   // Last reference - actually remove the tools
   skillRefCount.delete(skillId);
-  for (const [name, tool] of tools) {
-    if (tool.origin === "skill" && tool.ownerSkillId === skillId) {
+  for (const [name, owner] of ownersByName) {
+    if (owner.kind === "skill" && owner.id === skillId) {
       tools.delete(name);
-      log.info({ name, skillId }, "Skill tool unregistered");
+      ownersByName.delete(name);
+      log.info({ name, ownerSkillId: skillId }, "Skill tool unregistered");
     }
   }
 }
 
 /**
- * Register multiple MCP-origin tools at once.
+ * Register multiple MCP-origin tools owned by the MCP server `serverId`.
+ *
  * Skips any tool whose name collides with a core tool (logs a warning).
  * Throws if a tool name collides with a tool owned by a different MCP server.
+ *
+ * Ownership is recorded in {@link ownersByName} keyed by tool name; the
+ * `Tool` object itself carries no owner metadata.
  */
-export function registerMcpTools(newTools: Tool[]): Tool[] {
+export function registerMcpTools(serverId: string, newTools: Tool[]): Tool[] {
   const accepted: Tool[] = [];
   for (const tool of newTools) {
     const existing = tools.get(tool.name);
     if (existing) {
-      const existingIsCore = existing.origin === "core" || !existing.origin;
+      const existingIsCore = !ownersByName.has(tool.name);
       if (existingIsCore) {
         log.warn(
-          { toolName: tool.name, serverId: tool.ownerMcpServerId },
-          `MCP server "${tool.ownerMcpServerId}" tried to register tool "${tool.name}" which conflicts with a core tool. Skipping.`,
+          { toolName: tool.name, ownerMcpServerId: serverId },
+          `MCP server "${serverId}" tried to register tool "${tool.name}" which conflicts with a core tool. Skipping.`,
         );
         continue;
       }
-      if (existing.origin === "skill") {
+      const existingOwner = ownersByName.get(tool.name);
+      if (existingOwner?.kind === "skill" || existingOwner?.kind === "plugin") {
         log.warn(
           {
             toolName: tool.name,
-            serverId: tool.ownerMcpServerId,
-            skillId: existing.ownerSkillId,
+            ownerMcpServerId: serverId,
+            existingOwner,
           },
-          `MCP server "${tool.ownerMcpServerId}" tried to register tool "${tool.name}" which conflicts with skill tool from "${existing.ownerSkillId}". Skipping.`,
+          `MCP server "${serverId}" tried to register tool "${tool.name}" which conflicts with ${describeOwner(existingOwner)}. Skipping.`,
         );
         continue;
       }
-      if (existing.origin === "plugin") {
-        log.warn(
-          {
-            toolName: tool.name,
-            serverId: tool.ownerMcpServerId,
-            pluginName: existing.ownerPluginId,
-          },
-          `MCP server "${tool.ownerMcpServerId}" tried to register tool "${tool.name}" which conflicts with plugin tool from "${existing.ownerPluginId}". Skipping.`,
-        );
-        continue;
-      }
-      if (
-        existing.origin === "mcp" &&
-        existing.ownerMcpServerId !== tool.ownerMcpServerId
-      ) {
+      if (existingOwner?.kind === "mcp" && existingOwner.id !== serverId) {
         throw new Error(
-          `MCP tool "${tool.name}" is already registered by MCP server "${existing.ownerMcpServerId}"`,
+          `MCP tool "${tool.name}" is already registered by MCP server "${existingOwner.id}"`,
         );
       }
     }
@@ -358,8 +395,9 @@ export function registerMcpTools(newTools: Tool[]): Tool[] {
 
   for (const tool of accepted) {
     tools.set(tool.name, tool);
+    ownersByName.set(tool.name, { kind: "mcp", id: serverId });
     log.info(
-      { name: tool.name, ownerMcpServerId: tool.ownerMcpServerId },
+      { name: tool.name, ownerMcpServerId: serverId },
       "MCP tool registered",
     );
   }
@@ -371,9 +409,10 @@ export function registerMcpTools(newTools: Tool[]): Tool[] {
  * Unregister all MCP-origin tools from the registry.
  */
 export function unregisterAllMcpTools(): void {
-  for (const [name, tool] of tools) {
-    if (tool.origin === "mcp") {
+  for (const [name, owner] of ownersByName) {
+    if (owner.kind === "mcp") {
       tools.delete(name);
+      ownersByName.delete(name);
       log.info({ name }, "MCP tool unregistered (reload)");
     }
   }
@@ -385,7 +424,9 @@ export function unregisterAllMcpTools(): void {
  * were registered after session creation (e.g. via `vellum mcp reload`).
  */
 export function getMcpToolDefinitions(): ToolDefinition[] {
-  return Array.from(tools.values()).filter((t) => t.origin === "mcp");
+  return Array.from(tools.values()).filter(
+    (t) => ownersByName.get(t.name)?.kind === "mcp",
+  );
 }
 
 /**
@@ -393,7 +434,7 @@ export function getMcpToolDefinitions(): ToolDefinition[] {
  */
 export function getSkillToolNames(): string[] {
   return Array.from(tools.values())
-    .filter((t) => t.origin === "skill")
+    .filter((t) => ownersByName.get(t.name)?.kind === "skill")
     .map((t) => t.name);
 }
 
@@ -405,15 +446,13 @@ export function getSkillRefCount(skillId: string): number {
 }
 
 export function getAllToolDefinitions(): ToolDefinition[] {
-  // Exclude proxy tools (e.g. computer_use_* tools) - they are projected
-  // into sessions by the skill system, not via the global tool list.
   // Exclude skill-origin tools - they are managed by the session-level
   // skill projection system (projectSkillTools) and must not leak into
   // the base tool list, which is shared across sessions via the global
   // registry.  Including them here causes "Tool names must be unique"
   // errors when the projection appends the same tools a second time.
   return getAllTools().filter(
-    (t) => t.executionMode !== "proxy" && t.origin !== "skill",
+    (t) => ownersByName.get(t.name)?.kind !== "skill",
   );
 }
 
@@ -442,10 +481,13 @@ export async function initializeTools(): Promise<void> {
   // External skill tools — registered by skill bootstrap modules via
   // `registerExternalTools()`. Called at init time (not spread into
   // `explicitTools`) so registrations that happen between module-load
-  // and `initializeTools()` are picked up.
-  const extTools = getExternalTools();
-  for (const tool of extTools) {
+  // and `initializeTools()` are picked up. Each provider pairs its tools
+  // with an OwnerInfo so the registry can record ownership in
+  // {@link ownersByName} alongside the bare `registerTool()` install.
+  const extEntries = getExternalTools();
+  for (const { owner, tool } of extEntries) {
     registerTool(tool);
+    ownersByName.set(tool.name, owner);
   }
 
   // Host tools are registered explicitly so host access stays opt-in until
@@ -483,18 +525,17 @@ export async function initializeTools(): Promise<void> {
     const manifestToolNames = new Set<string>([
       ...eagerModuleToolNames,
       ...explicitTools.map((t: Tool) => t.name),
-      ...extTools.map((t: Tool) => t.name),
+      ...extEntries.map(({ tool }) => tool.name),
       ...hostTools.map((t: Tool) => t.name),
       ...cesTools.map((t: Tool) => t.name),
-      ...allComputerUseTools.map((t: Tool) => t.name),
       ...allUiSurfaceTools.map((t: Tool) => t.name),
       ...coreAppProxyTools.map((t: Tool) => t.name),
     ]);
 
     coreToolsSnapshot = new Map<string, Tool>();
     for (const [name, tool] of tools) {
-      if (tool.origin === "skill") continue;
-      if (tool.origin === "plugin") continue;
+      const ownerKind = ownersByName.get(name)?.kind;
+      if (ownerKind === "skill" || ownerKind === "plugin") continue;
       // Exclude pre-existing tools not declared in the manifest
       if (preExisting.has(name) && !manifestToolNames.has(name)) continue;
       coreToolsSnapshot.set(name, tool);
@@ -516,6 +557,7 @@ export async function initializeTools(): Promise<void> {
  */
 export function __resetRegistryForTesting(): void {
   tools.clear();
+  ownersByName.clear();
   skillRefCount.clear();
   pluginRefCount.clear();
 
@@ -533,6 +575,7 @@ export function __resetRegistryForTesting(): void {
  */
 export function __clearRegistryForTesting(): void {
   tools.clear();
+  ownersByName.clear();
   skillRefCount.clear();
   pluginRefCount.clear();
 }

package/src/tools/schedule/create.ts

@@ -43,7 +43,7 @@ export async function executeScheduleCreate(
     | Record<string, unknown>
     | undefined;
   const quiet = (input.quiet as boolean) ?? false;
-  const reuseConversation = (input.reuse_conversation as boolean) ?? false;
+  const reuseConversation = input.reuse_conversation as boolean | undefined;
   const maxRetries = input.max_retries as number | undefined;
   const retryBackoffMs = input.retry_backoff_ms as number | undefined;
 

package/src/tools/skills/skill-tool-factory.ts

@@ -1,5 +1,6 @@
 import type { SkillToolEntry } from "../../config/skills.js";
 import { RiskLevel } from "../../permissions/types.js";
+import { validateInputAgainstSchema } from "../../skills/validate-input.js";
 import type {
   ExecutionTarget,
   Tool,
@@ -14,39 +15,16 @@ const riskMap: Record<SkillToolEntry["risk"], RiskLevel> = {
   high: RiskLevel.High,
 };
 
-/**
- * Validate that all keys in `input` are declared in the tool's input_schema
- * properties. Returns an error result listing unknown parameters, or undefined
- * if validation passes.
- */
-function validateNoUnknownParams(
-  toolName: string,
-  input: Record<string, unknown>,
-  schema: SkillToolEntry["input_schema"],
-): ToolExecutionResult | undefined {
-  const properties = schema?.properties;
-  if (!properties) return undefined;
-
-  const knownKeys = new Set(Object.keys(properties));
-  const unknownKeys = Object.keys(input).filter((k) => !knownKeys.has(k));
-  if (unknownKeys.length === 0) return undefined;
-
-  const listed = unknownKeys.map((k) => `"${k}"`).join(", ");
-  const supported = [...knownKeys].map((k) => `"${k}"`).join(", ");
-  return {
-    content: `Unknown parameter${unknownKeys.length > 1 ? "s" : ""} ${listed} for tool "${toolName}". Supported parameters: ${supported}. Remove unsupported parameters and retry.`,
-    isError: true,
-  };
-}
-
 /**
  * Create a runtime Tool object from a manifest entry.
  * Maps SkillToolEntry metadata to the Tool interface and routes execution
- * through the skill script runner.
+ * through the skill script runner. Ownership (the originating skill id) is
+ * recorded by the tool registry at `registerSkillTools(skillId, tools)`
+ * time, not stamped on the `Tool` object — see
+ * {@link ../../tools/registry.getToolOwner}.
  */
 export function createSkillTool(
   entry: SkillToolEntry,
-  skillId: string,
   skillDir: string,
   versionHash: string,
   bundled?: boolean,
@@ -56,11 +34,7 @@ export function createSkillTool(
     description: entry.description,
     category: entry.category,
     defaultRiskLevel: riskMap[entry.risk],
-    origin: "skill",
-    ownerSkillId: skillId,
     executionTarget: entry.execution_target as ExecutionTarget,
-    ownerSkillVersionHash: versionHash,
-    ownerSkillBundled: bundled,
 
     input_schema: entry.input_schema as object,
 
@@ -68,12 +42,17 @@ export function createSkillTool(
       input: Record<string, unknown>,
       context: ToolContext,
     ): Promise<ToolExecutionResult> {
-      const validationError = validateNoUnknownParams(
+      const validation = validateInputAgainstSchema(
         entry.name,
         input,
-        entry.input_schema,
+        entry.input_schema as Record<string, unknown> | undefined,
       );
-      if (validationError) return validationError;
+      if (!validation.ok) {
+        return {
+          content: `Invalid input for tool "${entry.name}": ${validation.errors.join("; ")}. Fix the arguments and retry.`,
+          isError: true,
+        };
+      }
 
       return runSkillToolScript(skillDir, entry.executor, input, context, {
         target: entry.execution_target,
@@ -86,15 +65,17 @@ export function createSkillTool(
 
 /**
  * Create runtime Tool objects from all entries in a manifest.
+ * The caller is responsible for passing the resulting array to
+ * `registerSkillTools(skillId, tools)`, which is where ownership is
+ * recorded.
  */
 export function createSkillToolsFromManifest(
   entries: SkillToolEntry[],
-  skillId: string,
   skillDir: string,
   versionHash: string,
   bundled?: boolean,
 ): Tool[] {
   return entries.map((entry) =>
-    createSkillTool(entry, skillId, skillDir, versionHash, bundled),
+    createSkillTool(entry, skillDir, versionHash, bundled),
   );
 }

package/src/tools/subagent/spawn.ts

@@ -102,6 +102,9 @@ export async function executeSubagentSpawn(
         ...(inheritedOverrideProfile
           ? { overrideProfile: inheritedOverrideProfile }
           : {}),
+        ...(context.toolUseId
+          ? { parentToolUseId: context.toolUseId }
+          : {}),
         ...forkFields,
       },
       sendToClient as (msg: unknown) => void,

package/src/tools/tool-approval-handler.ts

@@ -10,7 +10,7 @@ import { createOrReuseToolGrantRequest } from "../runtime/tool-grant-request-hel
 import { redactSecrets } from "../security/secret-scanner.js";
 import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
 import { getLogger } from "../util/logger.js";
-import { getAllTools, getTool } from "./registry.js";
+import { getAllTools, getTool, getToolOwner } from "./registry.js";
 import { isSideEffectTool } from "./side-effects.js";
 import { summarizeToolInput } from "./tool-input-summary.js";
 import {
@@ -340,8 +340,12 @@ export class ToolApprovalHandler {
     const tool = getTool(name);
     if (!tool) {
       const allowedToolNames = context.allowedToolNames;
+      // List every registered tool. Tools that need an external resolver
+      // (computer-use, ui-surface, etc.) now return a structured error
+      // from their `execute()` when no resolver is connected, rather than
+      // being filtered out here — listing them surfaces a clearer path
+      // than hiding their names entirely.
       const available = getAllTools()
-        .filter((t) => t.executionMode !== "proxy" || context.proxyToolResolver)
         .map((t) => t.name)
         .filter((n) => !allowedToolNames || allowedToolNames.has(n))
         .sort()
@@ -368,8 +372,10 @@ export class ToolApprovalHandler {
 
     // Gate tools not active for the current turn
     if (context.allowedToolNames && !context.allowedToolNames.has(name)) {
-      const loadHint = tool.ownerSkillId
-        ? `Load the "${tool.ownerSkillId}" skill that provides this tool first.`
+      const owner = getToolOwner(name);
+      const ownerSkillId = owner?.kind === "skill" ? owner.id : undefined;
+      const loadHint = ownerSkillId
+        ? `Load the "${ownerSkillId}" skill that provides this tool first.`
         : `Load the skill that provides this tool first.`;
       const msg = `Tool "${name}" is not currently active. ${loadHint}`;
       const durationMs = Date.now() - startTime;