@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231620.a15f321

package/src/__tests__/provider-platform-proxy-integration.test.ts

@@ -191,6 +191,7 @@ const MANAGED_FALLBACK_PROVIDERS: string[] = [
   "openai",
   "fireworks",
   "together",
+  "typesafe",
 ];
 
 function enableManagedProxy() {
@@ -314,28 +315,57 @@ describe("managed proxy integration — credential precedence", () => {
       },
     );
 
-    test("managed bootstrap registers anthropic, openai, gemini, fireworks, and together", async () => {
+    test("managed bootstrap registers every managed-routable catalog provider", async () => {
       enableManagedProxy();
       mockProviderKeys = {};
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
-      expect(listProviders()).toEqual(
-        expect.arrayContaining([
-          "anthropic",
-          "openai",
-          "gemini",
-          "fireworks",
-          "together",
-        ]),
+      expect([...listProviders()].sort()).toEqual(
+        [...MANAGED_FALLBACK_PROVIDERS].sort(),
       );
-      expect(listProviders()).toHaveLength(5);
-      expect(getProviderRoutingSource("anthropic")).toBe("managed-proxy");
-      expect(getProviderRoutingSource("openai")).toBe("managed-proxy");
-      expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
-      expect(getProviderRoutingSource("fireworks")).toBe("managed-proxy");
-      expect(getProviderRoutingSource("together")).toBe("managed-proxy");
+      for (const provider of MANAGED_FALLBACK_PROVIDERS) {
+        expect(getProviderRoutingSource(provider)).toBe("managed-proxy");
+      }
       expect(getProviderRoutingSource("openrouter")).toBeUndefined();
     });
 
+    test("managed typesafe sends System One through the typesafe proxy path with the assistant key", async () => {
+      enableManagedProxy();
+      mockProviderKeys = {};
+      await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
+
+      const provider = getProvider("typesafe");
+      const originalFetch = globalThis.fetch;
+      let capturedUrl = "";
+      let capturedHeaders: Record<string, string> = {};
+      globalThis.fetch = (async (
+        input: string | URL | Request,
+        init?: RequestInit,
+      ) => {
+        capturedUrl = String(input);
+        capturedHeaders = (init?.headers ?? {}) as Record<string, string>;
+        return new Response(
+          JSON.stringify({
+            model: "jev-latest",
+            answers: {},
+            usage: { input_tokens: 1, output_tokens: 0 },
+          }),
+          { status: 200, headers: { "Content-Type": "application/json" } },
+        );
+      }) as typeof fetch;
+      try {
+        await provider.sendMessage([userMsg("hello")], {
+          config: { model: "jev-latest" },
+        });
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+
+      expect(capturedUrl).toBe(
+        `${PLATFORM_BASE}/v1/runtime-proxy/typesafe/v1/systemone`,
+      );
+      expect(capturedHeaders.Authorization).toBe(`Bearer ${MANAGED_API_KEY}`);
+    });
+
     test("managed anthropic uses anthropic proxy path", async () => {
       enableManagedProxy();
       mockProviderKeys = {};

package/src/__tests__/retry-fallback-escalation.test.ts

@@ -12,7 +12,9 @@ mock.module("../util/retry.js", () => ({
 import {
   recordFallbackServed,
   resetFallbackBreaker,
+  shouldSkipPrimary,
 } from "../providers/fallback-breaker.js";
+import { malformedToolCallError } from "../providers/malformed-tool-call.js";
 import type {
   Message,
   Provider,
@@ -666,6 +668,26 @@ describe("RetryProvider fallback-route escalation", () => {
     expect(backup.calls()).toBe(1);
   });
 
+  test("malformed tool call exhausts retries → backup serves, breaker stays closed", async () => {
+    const primary = failingProvider("openai", () =>
+      malformedToolCallError("openai", "MALFORMED_FUNCTION_CALL"),
+    );
+    const backup = backupProvider();
+    const route = makeRoute(backup.provider);
+    const wrapped = new RetryProvider(primary.provider, {
+      resolveFallbackRoute: route.resolveFallbackRoute,
+    });
+
+    const result = await wrapped.sendMessage(MESSAGES, {
+      config: { callSite: "mainAgent" },
+    });
+
+    expect(primary.calls()).toBe(1 + DEFAULT_MAX_RETRIES);
+    expect(backup.calls()).toBe(1);
+    expect(result.model).toBe("backup-model");
+    expect(shouldSkipPrimary({ upstream: "openai" })).toBe(false);
+  });
+
   test("resolveFallbackRoute unset → behavior unchanged (original error rethrown)", async () => {
     const finalError = new ProviderError("Service Unavailable", "openai", 503);
     const primary = failingProvider("openai", () => finalError);

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -55,8 +55,10 @@ afterAll(() => {
   resetDbForTesting();
 });
 
-const TEST_TOKEN = "test-bearer-token-attach";
-const AUTH_HEADERS = { Authorization: `Bearer ${TEST_TOKEN}` };
+// This suite mocks isHttpAuthDisabled() to true, so a request carrying no
+// bearer authenticates through the dev bypass. A bearer that is present is
+// verified against the signing key, which these tests do not set up.
+const AUTH_HEADERS: Record<string, string> = {};
 
 describe("Runtime attachment metadata", () => {
   let server: RuntimeHttpServer;

package/src/__tests__/scaffold-managed-skill-tool.test.ts

@@ -32,25 +32,24 @@ mock.module("../daemon/skill-memory-refresh.js", () => ({
   refreshSkillCapabilityMemories: mockRefreshSkillCapabilityMemories,
 }));
 
-// Background skill updates route through the notification pipeline; record
-// the signals rather than standing up delivery.
-let emittedSignals: Array<{
-  sourceEventName: string;
-  sourceContextId: string;
-  dedupeKey?: string;
-  contextPayload?: Record<string, unknown>;
-}> = [];
-mock.module("../notifications/emit-signal.js", () => ({
-  emitNotificationSignal: async (params: {
-    sourceEventName: string;
-    sourceContextId: string;
-    dedupeKey?: string;
-    contextPayload?: Record<string, unknown>;
-  }) => {
-    emittedSignals.push(params);
-    return { signalId: "test-signal" };
-  },
-}));
+// Receipt recorder: the executor's one side effect for a background
+// overwrite, captured at the job module's boundary so the tests read what
+// was recorded rather than standing up the memory job queue.
+import type * as ReceiptJob from "../plugins/defaults/memory/skill-update-receipt-job.js";
+
+let recordedUpdates: Parameters<typeof ReceiptJob.recordSkillUpdate>[0][] = [];
+let recordUpdateFails = false;
+mock.module(
+  "../plugins/defaults/memory/skill-update-receipt-job.js",
+  (): Partial<typeof ReceiptJob> => ({
+    recordSkillUpdate: (input) => {
+      recordedUpdates.push(input);
+      if (recordUpdateFails) {
+        throw new Error("memory database unavailable");
+      }
+    },
+  }),
+);
 
 // Skill-card enqueue recorder. Snapshot + override (rather than a full module
 // replacement) because other modules in this import graph (e.g. the managed
@@ -152,7 +151,7 @@ beforeEach(() => {
   skillCardJobUpserts = [];
   skillCardUpsertThrows = false;
   watchdogEvents.length = 0;
-  emittedSignals = [];
+  recordedUpdates = [];
 });
 
 afterEach(() => {
@@ -1771,7 +1770,8 @@ describe("background skill update notification", () => {
     });
     watchdogEvents.length = 0;
     skillCardJobUpserts = [];
-    emittedSignals = [];
+    recordedUpdates = [];
+    recordUpdateFails = false;
   }
 
   const lineage = () => ({
@@ -1781,9 +1781,73 @@ describe("background skill update notification", () => {
         : null,
   });
 
-  test("a background overwrite of an existing skill notifies, keyed to the source conversation", async () => {
+  test("a background overwrite of an existing skill records a receipt entry keyed to the tool call", async () => {
     await seedAssistantSkill("weekly-export", "Old body.");
 
+    const result = await executeScaffoldManagedSkill(
+      {
+        skill_id: "weekly-export",
+        name: "Weekly Report Export",
+        description: "export the weekly usage report",
+        body_markdown: "1. Refined steps.",
+        activation_hints: HINTS,
+        overwrite: true,
+        change_summary: "Refined the steps.",
+      },
+      makeRetrospectiveContext({
+        conversationId: "retro-run-conv",
+        toolUseId: "toolu_1",
+      }),
+      lineage(),
+    );
+
+    expect(result.isError).toBe(false);
+    // Nothing is announced here: the entry joins the pending receipt job,
+    // which announces the burst once it has settled.
+    expect(recordedUpdates).toEqual([
+      {
+        // The producing tool call, so a re-executed call records nothing new.
+        entryId: "retro-run-conv:toolu_1",
+        skillId: "weekly-export",
+        name: "Weekly Report Export",
+        changeSummary: "Refined the steps.",
+        runConversationId: "retro-run-conv",
+        // The receipt's link for this entry resolves through this id, so it
+        // must be the conversation the work came from, not the hidden fork.
+        sourceConversationId: "source-conv",
+      },
+    ]);
+  });
+
+  test("an entry without a tool call id gets a fresh key, so a second rewrite of the same skill is still recorded", async () => {
+    await seedAssistantSkill("weekly-export", "Old body.");
+
+    for (const body of ["1. Refined steps.", "1. Refined again."]) {
+      await executeScaffoldManagedSkill(
+        {
+          skill_id: "weekly-export",
+          name: "Weekly Report Export",
+          description: "export the weekly usage report",
+          body_markdown: body,
+          activation_hints: HINTS,
+          overwrite: true,
+          change_summary: `Refined: ${body}`,
+        },
+        makeRetrospectiveContext({ conversationId: "retro-run-conv" }),
+      );
+    }
+
+    expect(recordedUpdates).toHaveLength(2);
+    const [first, second] = recordedUpdates;
+    expect(first?.entryId.startsWith("retro-run-conv:")).toBe(true);
+    expect(second?.entryId.startsWith("retro-run-conv:")).toBe(true);
+    expect(first?.entryId).not.toBe(second?.entryId);
+  });
+
+  test("a receipt that cannot be recorded is logged and counted, and the skill write stands", async () => {
+    await seedAssistantSkill("weekly-export", "Old body.");
+    recordUpdateFails = true;
+
     const result = await executeScaffoldManagedSkill(
       {
         skill_id: "weekly-export",
@@ -1799,29 +1863,20 @@ describe("background skill update notification", () => {
     );
 
     expect(result.isError).toBe(false);
-    expect(emittedSignals).toHaveLength(1);
-    const signal = emittedSignals[0]!;
-    expect(signal.sourceEventName).toBe("activity.complete");
-    // The feed item's "Go to Convo" target resolves through this id, so it
-    // must be the conversation the work came from, not the hidden fork.
-    expect(signal.sourceContextId).toBe("source-conv");
-    expect(signal.contextPayload?.skillId).toBe("weekly-export");
-    expect(signal.contextPayload?.summary).toBe("Refined the steps.");
-    // The home feed falls back to `title`/`body` when no channel copy was
-    // rendered, which is the intended quiet shape for this signal. Without
-    // them a suppressed delivery would leave the feed item unwritten.
-    // Named so the row is scannable in a feed several entries deep.
-    expect(signal.contextPayload?.title).toBe(
-      "Skill updated: Weekly Report Export",
-    );
-    expect(signal.contextPayload?.body).toBe("Refined the steps.");
-    // Deduped per skill per day so repeated refinements cannot flood the feed.
-    expect(signal.dedupeKey).toBe(
-      `skill-updated:weekly-export:${new Date().toISOString().slice(0, 10)}`,
-    );
-  });
-
-  test("the notice body is the pass's change_summary, so the feed says what changed", async () => {
+    expect(
+      readFileSync(
+        join(TEST_DIR, "skills", "weekly-export", "SKILL.md"),
+        "utf-8",
+      ),
+    ).toContain("Refined steps.");
+    expect(watchdogEvents).toContainEqual(
+      expect.objectContaining({
+        checkName: "skill_update_receipt_record_failed",
+      }),
+    );
+  });
+
+  test("the entry body is the pass's change_summary, so the receipt says what changed", async () => {
     await seedAssistantSkill("weekly-export", "Old body.");
 
     const result = await executeScaffoldManagedSkill(
@@ -1840,14 +1895,9 @@ describe("background skill update notification", () => {
     );
 
     expect(result.isError).toBe(false);
-    expect(emittedSignals).toHaveLength(1);
-    const payload = emittedSignals[0]!.contextPayload;
-    // The title still names the skill; the body is the change itself.
-    expect(payload?.title).toBe("Skill updated: Weekly Report Export");
-    expect(payload?.body).toBe(
+    expect(recordedUpdates[0]?.changeSummary).toBe(
       "Added the retry after an expired session and the export endpoint that held steady.",
     );
-    expect(payload?.summary).toBe(payload?.body);
   });
 
   test("a background overwrite without a change_summary is refused before the write", async () => {
@@ -1881,7 +1931,7 @@ describe("background skill update notification", () => {
         'Error: change_summary is required when updating an existing skill: pass one or two short sentences (under 200 characters) for the person who reads the "Skill updated" notice, naming what you changed and what in the trace prompted it (for example "Added the retry after an expired session and the export endpoint that held steady.").',
       );
       expect(readFileSync(skillFile, "utf-8")).toBe(before);
-      expect(emittedSignals).toHaveLength(0);
+      expect(recordedUpdates).toHaveLength(0);
     }
   });
 
@@ -1905,7 +1955,7 @@ describe("background skill update notification", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain("Set overwrite=true to replace it.");
     expect(result.content).not.toContain("change_summary");
-    expect(emittedSignals).toHaveLength(0);
+    expect(recordedUpdates).toHaveLength(0);
   });
 
   test("the ownership backstop speaks before the change_summary requirement", async () => {
@@ -1937,7 +1987,7 @@ describe("background skill update notification", () => {
     expect(result.content).toContain("not verifiably assistant-authored");
   });
 
-  test("a user-directed overwrite needs no change_summary: it never notifies", async () => {
+  test("a user-directed overwrite needs no change_summary: it records no entry", async () => {
     await executeScaffoldManagedSkill(
       {
         skill_id: "user-skill",
@@ -1964,7 +2014,7 @@ describe("background skill update notification", () => {
     expect(result.isError).toBe(false);
   });
 
-  test("change_summary is sanitized like any other notification body", async () => {
+  test("change_summary is sanitized like any notification body", async () => {
     await seedAssistantSkill("weekly-export", "Old body.");
 
     await executeScaffoldManagedSkill(
@@ -1981,7 +2031,7 @@ describe("background skill update notification", () => {
       lineage(),
     );
 
-    const body = String(emittedSignals[0]!.contextPayload?.body);
+    const body = String(recordedUpdates[0]?.changeSummary);
     // Control characters go, horizontal whitespace collapses, blank-line runs
     // collapse to one paragraph break, and the whole thing is clamped to the
     // shared notification preview budget.
@@ -2012,7 +2062,7 @@ describe("background skill update notification", () => {
 
     expect(result.isError).toBe(true);
     expect(result.content).toBe("Error: change_summary must be a string");
-    expect(emittedSignals).toHaveLength(0);
+    expect(recordedUpdates).toHaveLength(0);
   });
 
   test("the registered tool's schema declares change_summary as an optional string", () => {
@@ -2044,7 +2094,7 @@ describe("background skill update notification", () => {
     expect(result.ok).toBe(true);
   });
 
-  test("it falls back to the run conversation when fork lineage does not resolve", async () => {
+  test("an entry whose fork lineage does not resolve carries no source, never the run", async () => {
     await seedAssistantSkill("weekly-export", "Old body.");
 
     await executeScaffoldManagedSkill(
@@ -2061,10 +2111,10 @@ describe("background skill update notification", () => {
       { getConversation: () => null },
     );
 
-    // Still a real conversation id, so the deep link resolves rather than
-    // falling through to an unrelated target.
-    expect(emittedSignals).toHaveLength(1);
-    expect(emittedSignals[0]!.sourceContextId).toBe("retro-run-conv");
+    // The run is an ephemeral fork; naming it as the source would have the
+    // receipt job drop the entry once the fork is garbage collected.
+    expect(recordedUpdates).toHaveLength(1);
+    expect(recordedUpdates[0]).not.toHaveProperty("sourceConversationId");
   });
 
   test("a background CREATE gets the skill card instead, with no duplicate signal", async () => {
@@ -2082,10 +2132,10 @@ describe("background skill update notification", () => {
 
     expect(result.isError).toBe(false);
     expect(skillCardJobUpserts).toHaveLength(1);
-    expect(emittedSignals).toHaveLength(0);
+    expect(recordedUpdates).toHaveLength(0);
   });
 
-  test("a user-directed overwrite does not notify: it is not unattended work", async () => {
+  test("a user-directed overwrite records no receipt entry: it is not unattended work", async () => {
     await executeScaffoldManagedSkill(
       {
         skill_id: "user-skill",
@@ -2096,7 +2146,7 @@ describe("background skill update notification", () => {
       },
       makeContext(),
     );
-    emittedSignals = [];
+    recordedUpdates = [];
 
     await executeScaffoldManagedSkill(
       {
@@ -2113,6 +2163,6 @@ describe("background skill update notification", () => {
     expect(
       readFileSync(join(TEST_DIR, "skills", "user-skill", "SKILL.md"), "utf-8"),
     ).toContain("V2.");
-    expect(emittedSignals).toHaveLength(0);
+    expect(recordedUpdates).toHaveLength(0);
   });
 });

package/src/__tests__/secret-routes-platform-proxy.test.ts

@@ -25,6 +25,7 @@ const MANAGED_PROVIDERS = [
   "gemini",
   "fireworks",
   "together",
+  "typesafe",
 ] as const;
 
 let platformBaseUrlOverride: string | undefined;

package/src/__tests__/send-endpoint-busy.test.ts

@@ -302,8 +302,10 @@ function makePendingApprovalConversation(
 // Tests
 // ---------------------------------------------------------------------------
 
-const TEST_TOKEN = "test-bearer-token-send";
-const AUTH_HEADERS = { Authorization: `Bearer ${TEST_TOKEN}` };
+// This suite mocks isHttpAuthDisabled() to true, so a request carrying no
+// bearer authenticates through the dev bypass. A bearer that is present is
+// verified against the signing key, which these tests do not set up.
+const AUTH_HEADERS: Record<string, string> = {};
 
 describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
   let server: RuntimeHttpServer;

package/src/__tests__/skill-load-inline-command.test.ts

@@ -109,6 +109,41 @@ async function executeSkillLoad(
 // ── Tests ─────────────────────────────────────────────────────────────────
 
 describe("skill_load inline command expansion", () => {
+  test("read-only preloading returns instructions without running inline commands", async () => {
+    writeSkill(
+      "readonly-example",
+      "readonly-example",
+      "Example skill",
+      "Context: !`echo example`",
+    );
+    const result = await skillLoadTool.execute(
+      { skill: "readonly-example" },
+      {
+        conversationId: "conversation-1",
+        workingDir: TEST_DIR,
+        trustClass: "guardian",
+      },
+      { readOnly: true },
+    );
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("[inline command not executed]");
+    expect(runInlineCommandCalls).toHaveLength(0);
+    expect(mockAutoInstall).not.toHaveBeenCalled();
+  });
+
+  test("read-only preloading does not install missing skills", async () => {
+    const result = await skillLoadTool.execute(
+      { skill: "missing-readonly-skill" },
+      {
+        conversationId: "conversation-1",
+        workingDir: TEST_DIR,
+        trustClass: "guardian",
+      },
+      { readOnly: true },
+    );
+    expect(result.isError).toBe(true);
+    expect(mockAutoInstall).not.toHaveBeenCalled();
+  });
   beforeEach(() => {
     mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
     runInlineCommandCalls.length = 0;

package/src/__tests__/skill-load-tool.test.ts

@@ -1,4 +1,4 @@
-import { mkdirSync, symlinkSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -781,16 +781,48 @@ describe("skill_load tool", () => {
     expect(result.content).toContain("Deploy the application to production");
     expect(result.content).toContain("Rollback to previous version");
 
-    // Should list parameters with types and required/optional markers
-    expect(result.content).toContain(
-      "- environment (string, required): Target environment",
+    const schemas = [
+      ...result.content.matchAll(/```json\n([\s\S]*?)\n```/g),
+    ].map((match) => JSON.parse(match[1]));
+    expect(schemas[0].required).toEqual(["environment"]);
+    expect(schemas[0].properties.environment).toEqual({
+      type: "string",
+      description: "Target environment",
+    });
+    expect(schemas[0].properties.force.type).toBe("boolean");
+    expect(schemas[1].required).toEqual(["version"]);
+  });
+
+  test("discloses the complete annotation mark schema before execution", async () => {
+    const manifest = JSON.parse(
+      readFileSync(
+        join(
+          import.meta.dir,
+          "../config/bundled-skills/screen-annotation/TOOLS.json",
+        ),
+        "utf-8",
+      ),
     );
-    expect(result.content).toContain(
-      "- force (boolean, optional): Force deploy even if checks fail",
+    writeSkill(
+      "annotation-schema",
+      "Annotation Schema",
+      "Point at a control",
+      "Name the control.",
     );
-    expect(result.content).toContain(
-      "- version (string, required): Version to rollback to",
+    writeToolsJson("annotation-schema", manifest.tools);
+
+    const result = await executeSkillLoad(
+      { skill: "annotation-schema" },
+      "macos",
     );
+    expect(result.isError).toBe(false);
+    const schemaMatch = result.content.match(/```json\n([\s\S]*?)\n```/);
+    expect(schemaMatch).not.toBeNull();
+    const schema = JSON.parse(schemaMatch![1]);
+    expect(schema).toEqual(manifest.tools[0].input_schema);
+    expect(schema.properties.marks.items.oneOf).toHaveLength(2);
+    expect(schema.properties.marks.items.properties.target.minLength).toBe(1);
+    expect(schema.properties.marks.items.properties.caption.maxLength).toBe(80);
   });
 
   test("skill without TOOLS.json does not include tool schemas section", async () => {
@@ -862,9 +894,8 @@ describe("skill_load tool", () => {
     // The child skill's tool schemas should appear (#### level under ### Tools from …)
     expect(result.content).toContain("#### child_action");
     expect(result.content).toContain("A child tool action");
-    expect(result.content).toContain(
-      "- target (string, required): Action target",
-    );
+    const schemaMatch = result.content.match(/```json\n([\s\S]*?)\n```/);
+    expect(JSON.parse(schemaMatch![1]).required).toEqual(["target"]);
     expect(result.content).toContain(
       "Use `skill_execute` to call these tools.",
     );

package/src/__tests__/skill-tool-factory.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 
-import type { SkillToolEntry } from "../config/skills.js";
+import { getBundledSkillsDir, type SkillToolEntry } from "../config/skills.js";
 import { RiskLevel } from "../permissions/types.js";
 import { computeSkillVersionHash } from "../skills/version-hash.js";
 import { resolveSubagentRole } from "../subagent/role-resolution.js";
@@ -261,6 +261,54 @@ describe("createSkillTool — unknown parameter validation", () => {
     expect(result.content).toContain('Unknown parameter "bar"');
   });
 
+  test.each([
+    { description: "Filters" },
+    { marks: [{ description: "Filters" }] },
+    { marks: [{}] },
+    { marks: [{ target: 42 }] },
+    { marks: [{ x: 0.1, y: 0.2 }] },
+    { marks: [{ target: "Filters", x: 0.1, y: 0.2, width: 0.3, height: 0.4 }] },
+  ])(
+    "an annotation validation error provides enough schema for one corrected retry: %j",
+    async (invalid) => {
+      const skillDir = join(getBundledSkillsDir(), "screen-annotation");
+      const manifest = JSON.parse(
+        readFileSync(join(skillDir, "TOOLS.json"), "utf-8"),
+      );
+      const entry = manifest.tools.find(
+        (tool: SkillToolEntry) => tool.name === "screen_point_at",
+      );
+      const tool = createSkillTool(
+        entry,
+        skillDir,
+        computeSkillVersionHash(skillDir),
+        BUNDLED,
+      );
+      const calls: unknown[] = [];
+      const context = makeContext({
+        proxyToolResolver: async (name, input) => {
+          calls.push({ name, input });
+          return { content: "Drew 1 mark", isError: false };
+        },
+      });
+
+      const rejected = await tool.execute(invalid, context);
+      expect(rejected.isError).toBe(true);
+      expect(calls).toHaveLength(0);
+      expect(rejected.content).toContain("skill_load");
+      const schemaMatch = rejected.content.match(/```json\n([\s\S]*?)\n```/);
+      expect(schemaMatch).not.toBeNull();
+      expect(JSON.parse(schemaMatch![1])).toEqual(entry.input_schema);
+
+      const input = {
+        marks: [{ target: "Filters", caption: "Click Filters" }],
+      };
+      const corrected = await tool.execute(input, context);
+      expect(corrected.isError).toBe(false);
+      expect(calls).toEqual([{ name: "computer_use_point_at", input }]);
+    },
+  );
+
   test("allows input with only known parameters", async () => {
     const hash = computeSkillVersionHash(tempDir);
     const tool = createSkillTool(
@@ -471,7 +519,7 @@ describe("createSkillTool — required/type/enum validation", () => {
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain(
-      "auto_open must be a boolean — pass true or false as a JSON boolean, not a string",
+      "auto_open must be a boolean: pass true or false as a JSON boolean, not a string",
     );
   });