@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/__tests__/scheduler-wake.test.ts

@@ -23,6 +23,7 @@ import {
 } from "../persistence/conversation-crud.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
+import { resolveDefaultScheduleInferenceProfile } from "../schedule/inference-profile.js";
 import {
   createOwnerDeferredWake,
   createSchedule,
@@ -82,6 +83,9 @@ describe("scheduler wake mode", () => {
       source: "defer",
       persistTriggerAsEvent: true,
       trustContext: INTERNAL_GUARDIAN_TRUST_CONTEXT,
+      // Every schedule is pinned at creation, so the row always carries a
+      // profile for the woken turn to run under.
+      forceOverrideProfile: resolveDefaultScheduleInferenceProfile()!,
     });
 
     // AND processMessage is never called (wake mode doesn't use it)
@@ -113,6 +117,7 @@ describe("scheduler wake mode", () => {
       hint: "Follow up",
       source: "defer",
       persistTriggerAsEvent: true,
+      forceOverrideProfile: resolveDefaultScheduleInferenceProfile()!,
     });
   });
 

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

@@ -108,7 +108,10 @@ import {
   initializeProviders,
   listProviders,
 } from "../providers/registry.js";
-import { ROUTES } from "../runtime/routes/secret-routes.js";
+import {
+  notifyCesOfAssistantApiKeyUpdate,
+  ROUTES,
+} from "../runtime/routes/secret-routes.js";
 
 const addRoute = ROUTES.find(
   (r) => r.method === "POST" && r.endpoint === "secrets",
@@ -176,6 +179,31 @@ describe("secret routes managed proxy registry sync", () => {
     expect(lastGeminiConstructorOpts).toBeDefined();
   });
 
+  test("the CES key-update notification with no CES client logs a warning", async () => {
+    // When getCesClient() is undefined the push is skipped, but the skip must
+    // be logged, not dropped silently. Exercise the extracted helper directly
+    // with an injected logger.
+    const warns: string[] = [];
+    const fakeLogger = {
+      info: () => {},
+      warn: (a: unknown, b?: unknown) => {
+        warns.push(typeof a === "string" ? a : String(b));
+      },
+    };
+
+    await notifyCesOfAssistantApiKeyUpdate(
+      "ast-managed-key",
+      undefined,
+      fakeLogger as unknown as Parameters<
+        typeof notifyCesOfAssistantApiKeyUpdate
+      >[2],
+    );
+
+    expect(warns.some((m) => m.includes("no CES client is connected"))).toBe(
+      true,
+    );
+  });
+
   test("provider API key writes notify live-conversation refresh listeners", async () => {
     await addApiKey("fireworks", "fw-key");
 

package/src/__tests__/secure-keys.test.ts

@@ -19,6 +19,7 @@ import * as encryptedStore from "../security/encrypted-store.js";
 import {
   _resetBackend,
   deleteSecureKeyAsync,
+  getActiveBackendName,
   getSecureKeyAsync,
   getSecureKeyResultAsync,
   listSecureKeysAsync,
@@ -58,6 +59,9 @@ describe("secure-keys", () => {
     _resetBackend();
     delete process.env.VELLUM_DEV;
     delete process.env.VELLUM_DESKTOP_APP;
+    delete process.env.IS_CONTAINERIZED;
+    delete process.env.CES_CREDENTIAL_URL;
+    delete process.env.CES_LOCAL_SOCKET;
   });
 
   afterAll(() => {
@@ -507,4 +511,91 @@ describe("secure-keys", () => {
       ).toBeUndefined();
     });
   });
+
+  // -----------------------------------------------------------------------
+  // Encrypted-store → CES upgrade without a reconnect callback
+  // -----------------------------------------------------------------------
+  //
+  // Worker/CLI processes inject a CES client whose handshake is still in
+  // flight, so the first credential read falls back to the encrypted store.
+  // These processes never register `_cesReconnect`. Once the handshake
+  // completes and the client reports ready, the next read must upgrade to
+  // CES RPC, since the live client already exists and no reconnect is needed.
+  describe("encrypted-store → CES upgrade without a reconnect callback", () => {
+    test("upgrades to CES RPC once the injected client becomes ready", async () => {
+      const client = makeMockCesClient(false);
+      setCesClient(client);
+
+      // Not ready yet → falls back to the encrypted store (local mode).
+      encryptedStore.setKey("openai", "local-value");
+      expect(await getSecureKeyAsync("openai")).toBe("local-value");
+      expect(getActiveBackendName()).toBe("encrypted-store");
+
+      // Handshake completes; no `_cesReconnect` was ever registered.
+      client.setReady(true);
+
+      await getSecureKeyResultAsync("openai");
+      expect(getActiveBackendName()).toBe("ces-rpc");
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Containerized pod with no ready CES backend
+  // -----------------------------------------------------------------------
+  //
+  // On a pod the local encrypted store does not exist. When no CES path is
+  // ready, reads must report the store as unreachable (presence
+  // indeterminate) rather than absent. A provisioned credential is never
+  // reported as "no key". The unreachable result must not be pinned: once a
+  // CES client arrives, the next read routes through it.
+  describe("containerized pod with no ready CES backend", () => {
+    test("reads report unreachable (indeterminate), never absent", async () => {
+      process.env.IS_CONTAINERIZED = "1";
+      delete process.env.CES_CREDENTIAL_URL;
+      delete process.env.CES_LOCAL_SOCKET;
+      _resetBackend();
+
+      const result = await getSecureKeyResultAsync("openai");
+      expect(result.value).toBeUndefined();
+      // unreachable → presence indeterminate, NEVER absent.
+      expect(result.unreachable).toBe(true);
+    });
+
+    test("does not pin the unreachable result: a ready CES client wins the next read", async () => {
+      process.env.IS_CONTAINERIZED = "1";
+      delete process.env.CES_CREDENTIAL_URL;
+      delete process.env.CES_LOCAL_SOCKET;
+      _resetBackend();
+
+      expect((await getSecureKeyResultAsync("openai")).unreachable).toBe(true);
+
+      setCesClient(makeMockCesClient(true));
+
+      const afterAttach = await getSecureKeyResultAsync("openai");
+      expect(afterAttach.unreachable).toBe(false);
+      expect(getActiveBackendName()).toBe("ces-rpc");
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // Encrypted-store read error vs genuinely-absent (local mode)
+  // -----------------------------------------------------------------------
+  describe("encrypted-store read error vs absent", () => {
+    test("genuinely-missing store → absent (unreachable false)", async () => {
+      const result = await getSecureKeyResultAsync("nope");
+      expect(result.value).toBeUndefined();
+      expect(result.unreachable).toBe(false);
+    });
+
+    test("store exists but key material is missing → unreachable", async () => {
+      encryptedStore.setKey("openai", "sk-1");
+      // Remove the store key so the existing entry can no longer be decrypted.
+      rmSync(join(TEST_DIR, "store.key"));
+      _resetBackend();
+
+      const result = await getSecureKeyResultAsync("openai");
+      expect(result.value).toBeUndefined();
+      expect(result.unreachable).toBe(true);
+    });
+  });
 });

package/src/__tests__/server-history-render.test.ts

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
+import type { AnsweredQuestion } from "../api/events/question-answered.js";
 import { renderHistoryContent } from "../daemon/handlers/shared.js";
 import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import {
@@ -298,9 +299,9 @@ describe("renderHistoryContent", () => {
     expect(output.toolCalls[0].errorCode).toBe("acp_claude_oauth_missing");
   });
 
-  test("emits the attachment id for a workspace_ref tool-result image", () => {
+  test("emits the attachment id for a workspace_ref tool-result image", async () => {
     // "aGVsbG8=" = "hello" — a stand-in for screenshot bytes.
-    const stored = uploadAttachment("shot.png", "image/png", "aGVsbG8=");
+    const stored = await uploadAttachment("shot.png", "image/png", "aGVsbG8=");
     const output = renderHistoryContent([
       { type: "tool_use", id: "tu_1", name: "browser_screenshot", input: {} },
       {
@@ -549,6 +550,95 @@ describe("renderHistoryContent", () => {
     expect(output.toolCalls[0].activityMetadata).toEqual(activityMetadata);
   });
 
+  // ── Persisted answered ask_question ────────────────────────────────────────
+
+  test("hydrates a persisted _answeredQuestion onto its tool_use block", () => {
+    // Mirrors what the daemon stamps when an `ask_question` prompt settles, so
+    // the answered card rehydrates on a reopened conversation instead of the
+    // user's decision disappearing with the interactive prompt.
+    const answeredQuestion: AnsweredQuestion = {
+      requestId: "req-1",
+      questions: [
+        {
+          id: "q1",
+          question: "Which Alice?",
+          options: [
+            { id: "alice_work", label: "Alice (work)" },
+            { id: "alice_personal", label: "Alice (personal)" },
+          ],
+        },
+      ],
+      responses: [
+        { questionId: "q1", decision: "option", optionId: "alice_work" },
+      ],
+      overall: "completed",
+    };
+
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_q",
+        name: "ask_question",
+        input: { questions: [{ question: "Which Alice?" }] },
+        _answeredQuestion: answeredQuestion,
+      },
+    ]);
+
+    expect(output.toolCalls[0].answeredQuestion).toEqual(answeredQuestion);
+  });
+
+  test("hydrates a free-text answer verbatim", () => {
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_q",
+        name: "ask_question",
+        input: {},
+        _answeredQuestion: {
+          requestId: "req-2",
+          questions: [{ id: "q1", question: "Which fruit?", options: [] }],
+          responses: [
+            { questionId: "q1", decision: "free_text", text: "Cherry" },
+          ],
+          overall: "completed",
+        },
+      },
+    ]);
+
+    expect(output.toolCalls[0].answeredQuestion?.responses).toEqual([
+      { questionId: "q1", decision: "free_text", text: "Cherry" },
+    ]);
+  });
+
+  test("leaves answeredQuestion absent on rows that predate the annotation", () => {
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_q",
+        name: "ask_question",
+        input: { questions: [{ question: "Which Alice?" }] },
+      },
+    ]);
+
+    expect(output.toolCalls[0].answeredQuestion).toBeUndefined();
+  });
+
+  test("ignores a malformed _answeredQuestion annotation", () => {
+    // The card renders these contents directly, so a rider that does not match
+    // the schema must degrade to no card rather than a crashing render.
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_q",
+        name: "ask_question",
+        input: {},
+        _answeredQuestion: { requestId: "req-3", overall: "sideways" },
+      },
+    ]);
+
+    expect(output.toolCalls[0].answeredQuestion).toBeUndefined();
+  });
+
   test("ignores non-object _activityMetadata annotations", () => {
     const output = renderHistoryContent([
       {
@@ -1084,7 +1174,7 @@ describe("getAttachmentsForMessage", () => {
 
   test("returns attachments linked to a message", async () => {
     const msgId = await createMessage("assistant", "Here is a chart");
-    const stored = uploadAttachment("chart.png", "image/png", "iVBORw==");
+    const stored = await uploadAttachment("chart.png", "image/png", "iVBORw==");
     linkAttachmentToMessage(msgId, stored.id, 0);
 
     const result = getAttachmentsForMessage(msgId);
@@ -1101,8 +1191,8 @@ describe("getAttachmentsForMessage", () => {
 
   test("returns multiple attachments in position order", async () => {
     const msgId = await createMessage("assistant", "Two files");
-    const a1 = uploadAttachment("first.txt", "text/plain", "AAAA");
-    const a2 = uploadAttachment("second.txt", "text/plain", "BBBB");
+    const a1 = await uploadAttachment("first.txt", "text/plain", "AAAA");
+    const a2 = await uploadAttachment("second.txt", "text/plain", "BBBB");
 
     linkAttachmentToMessage(msgId, a2.id, 1);
     linkAttachmentToMessage(msgId, a1.id, 0);
@@ -1115,8 +1205,8 @@ describe("getAttachmentsForMessage", () => {
 
   test("returns all attachments linked to a message", async () => {
     const msgId = await createMessage("assistant", "Mixed");
-    const a1 = uploadAttachment("a.png", "image/png", "AAAA");
-    const a2 = uploadAttachment("b.png", "image/png", "BBBB");
+    const a1 = await uploadAttachment("a.png", "image/png", "AAAA");
+    const a2 = await uploadAttachment("b.png", "image/png", "BBBB");
 
     linkAttachmentToMessage(msgId, a1.id, 0);
     linkAttachmentToMessage(msgId, a2.id, 1);

package/src/__tests__/size-guard.test.ts

@@ -38,41 +38,41 @@ describe("MAX_FILE_SIZE_BYTES", () => {
 // ---------------------------------------------------------------------------
 
 describe("checkFileSizeOnDisk", () => {
-  test("returns undefined for a file within the default limit", () => {
+  test("returns undefined for a file within the default limit", async () => {
     const dir = makeTempDir();
     const filePath = join(dir, "small.txt");
     writeFileSync(filePath, "hello");
 
-    expect(checkFileSizeOnDisk(filePath)).toBeUndefined();
+    expect(await checkFileSizeOnDisk(filePath)).toBeUndefined();
   });
 
-  test("returns error string for a file exceeding a custom limit", () => {
+  test("returns error string for a file exceeding a custom limit", async () => {
     const dir = makeTempDir();
     const filePath = join(dir, "big.txt");
     writeFileSync(filePath, "x".repeat(200));
 
-    const result = checkFileSizeOnDisk(filePath, 100);
+    const result = await checkFileSizeOnDisk(filePath, 100);
     expect(result).toBeDefined();
     expect(result).toContain("exceeds");
     expect(result).toContain("limit");
     expect(result).toContain(filePath);
   });
 
-  test("returns undefined for a file exactly at the custom limit", () => {
+  test("returns undefined for a file exactly at the custom limit", async () => {
     const dir = makeTempDir();
     const filePath = join(dir, "exact.txt");
     writeFileSync(filePath, "x".repeat(100));
 
-    expect(checkFileSizeOnDisk(filePath, 100)).toBeUndefined();
+    expect(await checkFileSizeOnDisk(filePath, 100)).toBeUndefined();
   });
 
-  test("uses default limit when none is provided", () => {
+  test("uses default limit when none is provided", async () => {
     const dir = makeTempDir();
     const filePath = join(dir, "tiny.txt");
     writeFileSync(filePath, "a");
 
     // Should not error since 1 byte is well under 100 MB
-    expect(checkFileSizeOnDisk(filePath)).toBeUndefined();
+    expect(await checkFileSizeOnDisk(filePath)).toBeUndefined();
   });
 });
 

package/src/__tests__/skill-docs-sync-guard.test.ts

@@ -5,8 +5,9 @@ import { describe, expect, test } from "bun:test";
 
 /**
  * Guard for skill ↔ public-docs drift. A bundled skill's SKILL.md is the
- * behavioral source of truth; its public reference page lives in a separate
- * repo (vellum-assistant-platform, https://www.vellum.ai/docs/skills-reference).
+ * behavioral source of truth; its public reference page lives in this repo at
+ * clients/docs/src/app/docs/_components/skills-reference-<slug>-content.tsx
+ * (served at https://www.vellum.ai/docs/skills-reference/<slug>).
  * `scripts/check-skill-docs-sync.ts` fingerprints each documented SKILL.md so a
  * behavior change can't land without the author reconciling the docs page and
  * re-recording the fingerprint.

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

@@ -1,3 +1,4 @@
+import { readFileSync } from "node:fs";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -6,6 +7,9 @@ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import 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";
+import type { SubagentRole } from "../subagent/types.js";
+import { bundledToolInputMisuseKeys } from "../tools/shared/input-misuse.js";
 import {
   createSkillTool,
   createSkillToolsFromManifest,
@@ -490,6 +494,249 @@ describe("createSkillTool — required/type/enum validation", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// createSkillTool: parameter misuse redirects
+// ---------------------------------------------------------------------------
+
+/**
+ * The subagent skill's real `subagent_read` manifest entry. Its redirect keys
+ * are absent from the advertised `properties`, so manifest validation is the
+ * layer that has to surface the redirect: nothing downstream of it runs.
+ */
+function subagentReadEntry(): SkillToolEntry {
+  const manifest = JSON.parse(
+    readFileSync(
+      join(import.meta.dir, "../config/bundled-skills/subagent/TOOLS.json"),
+      "utf-8",
+    ),
+  ) as { tools: SkillToolEntry[] };
+  const entry = manifest.tools.find((t) => t.name === "subagent_read");
+  if (!entry) {
+    throw new Error("subagent_read is missing from the subagent TOOLS.json");
+  }
+  return entry;
+}
+
+function subagentReadTool() {
+  return createSkillTool(
+    subagentReadEntry(),
+    "/skills/subagent",
+    "v1:test",
+    BUNDLED,
+  );
+}
+
+describe("createSkillTool: parameter misuse redirects", () => {
+  for (const key of ["path", "file", "filename"]) {
+    test(`subagent_read sends "${key}" to file_read`, async () => {
+      const result = await subagentReadTool().execute(
+        { [key]: "/tmp/notes.md" },
+        makeContext(),
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toBe(
+        "subagent_read returns a subagent's output, it does not read files. Use file_read for files. Pass subagent_id or label here.",
+      );
+    });
+  }
+
+  for (const key of ["subagentId", "agent_id"]) {
+    test(`subagent_read names "${key}" as a misspelling of subagent_id`, async () => {
+      const result = await subagentReadTool().execute(
+        { [key]: "sa-1" },
+        makeContext(),
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toBe(
+        "Unknown parameter. Use subagent_id (snake_case) or label.",
+      );
+    });
+  }
+
+  test("a key with no redirect keeps the generic validation error", async () => {
+    const result = await subagentReadTool().execute(
+      { subagent_id: "sa-1", nonsense: 1 },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "subagent_read"');
+    expect(result.content).toContain('Unknown parameter "nonsense"');
+  });
+
+  test("redirect keys stay out of the advertised schema", () => {
+    const properties = (
+      subagentReadEntry().input_schema as {
+        properties: Record<string, unknown>;
+      }
+    ).properties;
+
+    for (const key of bundledToolInputMisuseKeys("subagent_read")) {
+      expect(properties[key]).toBeUndefined();
+    }
+  });
+
+  test("a non-bundled skill reusing the name keeps the generic validation error", async () => {
+    // Tool names are not reserved, so a workspace skill can define its own
+    // `subagent_read` where `path` is a declared parameter. Its validation
+    // errors must describe its own manifest, not Vellum's file-reader redirect.
+    const tool = createSkillTool(
+      makeEntry({
+        name: "subagent_read",
+        input_schema: {
+          type: "object",
+          properties: { path: { type: "string" } },
+          required: ["path"],
+        },
+      }),
+      "/workspace/skills/notes",
+      "v1:test",
+      false,
+    );
+
+    const result = await tool.execute(
+      { path: "/tmp/notes.md", nonsense: 1 },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "subagent_read"');
+    expect(result.content).toContain('Unknown parameter "nonsense"');
+  });
+
+  test("an unspecified owner keeps the generic validation error", async () => {
+    const tool = createSkillTool(
+      subagentReadEntry(),
+      "/skills/subagent",
+      "v1:test",
+    );
+
+    const result = await tool.execute({ path: "/tmp/notes.md" }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "subagent_read"');
+    expect(result.content).toContain('Unknown parameter "path"');
+  });
+
+  test("a tool with no rules keeps the generic validation error", async () => {
+    const hash = computeSkillVersionHash(tempDir);
+    const tool = createSkillTool(
+      makeEntry({ executor: "echo.ts" }),
+      tempDir,
+      hash,
+      BUNDLED,
+    );
+
+    const result = await tool.execute(
+      { query: "hello", path: "/tmp/notes.md" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "test_tool"');
+    expect(result.content).toContain('Unknown parameter "path"');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// createSkillTool: subagent_spawn roles survive manifest validation
+// ---------------------------------------------------------------------------
+
+/** The subagent skill's real `subagent_spawn` manifest entry. */
+function subagentSpawnEntry(): SkillToolEntry {
+  const manifest = JSON.parse(
+    readFileSync(
+      join(import.meta.dir, "../config/bundled-skills/subagent/TOOLS.json"),
+      "utf-8",
+    ),
+  ) as { tools: SkillToolEntry[] };
+  const entry = manifest.tools.find((t) => t.name === "subagent_spawn");
+  if (!entry) {
+    throw new Error("subagent_spawn is missing from the subagent TOOLS.json");
+  }
+  return entry;
+}
+
+/**
+ * The real `subagent_spawn` schema wired to a stub executor. Only the schema
+ * is under test here, so the manifest's own executor (which would really spawn)
+ * is swapped for the echo script.
+ */
+function subagentSpawnTool() {
+  return createSkillTool(
+    { ...subagentSpawnEntry(), executor: "echo.ts" },
+    tempDir,
+    computeSkillVersionHash(tempDir),
+    BUNDLED,
+  );
+}
+
+/**
+ * Every `role` string {@link resolveSubagentRole} defines an answer for has to
+ * clear manifest validation first: `createSkillTool` validates against the
+ * manifest BEFORE the executor runs, so a constraint there that is narrower
+ * than the resolver silently deletes the resolver's behavior, and every test
+ * that calls `executeSubagentSpawn` directly still passes.
+ */
+describe("createSkillTool: subagent_spawn role validation", () => {
+  const ROLE_CASES: ReadonlyArray<readonly [string, SubagentRole]> = [
+    ["researcher", "researcher"],
+    ["builder", "builder"],
+    ["advisor", "advisor"],
+    ["planner", "researcher"],
+    ["investigator", "researcher"],
+    ["coder", "builder"],
+    ["general", "builder"],
+    ["a skeptical security reviewer", "researcher"],
+    ["Researcher", "researcher"],
+  ];
+
+  test.each(ROLE_CASES)(
+    'role "%s" passes manifest validation and resolves to %s',
+    async (role, expected) => {
+      const result = await subagentSpawnTool().execute(
+        { label: "Check", objective: "Do the thing", role },
+        makeContext(),
+      );
+
+      // Reached the executor at all, so validation let the role through.
+      expect(result.isError).toBe(false);
+      expect(JSON.parse(result.content).input.role).toBe(role);
+      // And the value the executor receives lands where the tool description
+      // and the docs say it does.
+      expect(resolveSubagentRole(role).role).toBe(expected);
+    },
+  );
+
+  test("role declares no enum, so the resolver stays reachable", () => {
+    const role = (
+      subagentSpawnEntry().input_schema as {
+        properties: Record<string, { type?: string; enum?: unknown }>;
+      }
+    ).properties.role;
+
+    expect(role.type).toBe("string");
+    // An enum here is enforced by `validateInputAgainstSchema` ahead of the
+    // executor, so any list short of "every string" rejects the legacy names
+    // and free-text personas the resolver exists to handle.
+    expect(role.enum).toBeUndefined();
+  });
+
+  test("output_contract keeps its enum, which the resolver has no fallback for", () => {
+    // The counterpart constraint: unlike `role`, an unrecognized contract has
+    // no defined behavior, so rejecting it at the boundary is correct.
+    const contract = (
+      subagentSpawnEntry().input_schema as {
+        properties: Record<string, { enum?: string[] }>;
+      }
+    ).properties.output_contract;
+
+    expect(contract.enum).toEqual(["report", "verdict", "artifact"]);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // createSkillTool — expectedSkillVersionHash plumbing
 // ---------------------------------------------------------------------------