@vellumai/assistant 0.8.1 → 0.8.2

package/src/__tests__/{provider-managed-proxy-integration.test.ts → provider-platform-proxy-integration.test.ts}

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { MANAGED_PROVIDER_META } from "../providers/managed-proxy/constants.js";
+import { PLATFORM_PROVIDER_META } from "../providers/platform-proxy/constants.js";
 import { credentialKey } from "../security/credential-key.js";
 
 // ---------------------------------------------------------------------------
@@ -436,7 +436,7 @@ describe("managed proxy integration — ollama exclusion", () => {
   });
 
   test("ollama metadata is marked as non-managed", () => {
-    const meta = MANAGED_PROVIDER_META.ollama;
+    const meta = PLATFORM_PROVIDER_META.ollama;
     expect(meta).toBeDefined();
     expect(meta.managed).toBe(false);
     expect(meta.proxyPath).toBeUndefined();
@@ -478,7 +478,7 @@ describe("config mode flip → provider reinit", () => {
 describe("managed proxy integration — constants integrity", () => {
   test("anthropic, openai, and gemini have metadata with managed=true and a proxyPath", () => {
     for (const provider of ["anthropic", "openai", "gemini"]) {
-      const meta = MANAGED_PROVIDER_META[provider];
+      const meta = PLATFORM_PROVIDER_META[provider];
       expect(meta).toBeDefined();
       expect(meta.managed).toBe(true);
       expect(meta.proxyPath).toBeTruthy();
@@ -487,27 +487,27 @@ describe("managed proxy integration — constants integrity", () => {
   });
 
   test("anthropic routes through anthropic proxy path", () => {
-    expect(MANAGED_PROVIDER_META.anthropic.proxyPath).toBe(
+    expect(PLATFORM_PROVIDER_META.anthropic.proxyPath).toBe(
       "/v1/runtime-proxy/anthropic",
     );
   });
 
   test("gemini routes through gemini proxy path", () => {
-    expect(MANAGED_PROVIDER_META.gemini.proxyPath).toBe(
+    expect(PLATFORM_PROVIDER_META.gemini.proxyPath).toBe(
       "/v1/runtime-proxy/gemini",
     );
   });
 
   test("openai routes through openai proxy path", () => {
-    expect(MANAGED_PROVIDER_META.openai.proxyPath).toBe(
+    expect(PLATFORM_PROVIDER_META.openai.proxyPath).toBe(
       "/v1/runtime-proxy/openai",
     );
   });
 
   test("fireworks and openrouter are not managed proxy capable", () => {
     for (const provider of ["fireworks", "openrouter"]) {
-      expect(MANAGED_PROVIDER_META[provider].managed).toBe(false);
-      expect(MANAGED_PROVIDER_META[provider].proxyPath).toBeUndefined();
+      expect(PLATFORM_PROVIDER_META[provider].managed).toBe(false);
+      expect(PLATFORM_PROVIDER_META[provider].proxyPath).toBeUndefined();
     }
   });
 });

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

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
+const mockRefreshSkillCapabilityMemories = mock(() => {});
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -11,6 +12,11 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+mock.module("../daemon/skill-memory-refresh.js", () => ({
+  refreshSkillCapabilityMemories: mockRefreshSkillCapabilityMemories,
+}));
+
+import { loadSkillCatalog } from "../config/skills.js";
 import { executeScaffoldManagedSkill } from "../tools/skills/scaffold-managed.js";
 import type { ToolContext } from "../tools/types.js";
 
@@ -24,6 +30,7 @@ function makeContext(): ToolContext {
 
 beforeEach(() => {
   mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
+  mockRefreshSkillCapabilityMemories.mockClear();
 });
 
 afterEach(() => {
@@ -31,7 +38,29 @@ afterEach(() => {
 });
 
 describe("scaffold_managed_skill tool", () => {
-  test("creates a valid skill and index entry", async () => {
+  test("keeps legacy index control as a deprecated no-op schema field", () => {
+    const tools = JSON.parse(
+      readFileSync(
+        join(
+          import.meta.dirname,
+          "../config/bundled-skills/skill-management/TOOLS.json",
+        ),
+        "utf-8",
+      ),
+    );
+    const scaffoldTool = tools.tools.find(
+      (tool: { name: string }) => tool.name === "scaffold_managed_skill",
+    );
+
+    expect(scaffoldTool).toBeDefined();
+    expect(scaffoldTool.input_schema.properties.add_to_index).toEqual({
+      type: "boolean",
+      description:
+        "Deprecated no-op compatibility field. Skills are discovered from top-level SKILL.md files.",
+    });
+  });
+
+  test("creates a valid skill discovered from its SKILL.md directory", async () => {
     const result = await executeScaffoldManagedSkill(
       {
         skill_id: "test-skill",
@@ -46,18 +75,40 @@ describe("scaffold_managed_skill tool", () => {
     const parsed = JSON.parse(result.content);
     expect(parsed.created).toBe(true);
     expect(parsed.skill_id).toBe("test-skill");
-    expect(parsed.index_updated).toBe(true);
+    expect(parsed).not.toHaveProperty("index_updated");
 
     const skillFile = join(TEST_DIR, "skills", "test-skill", "SKILL.md");
     expect(existsSync(skillFile)).toBe(true);
     const content = readFileSync(skillFile, "utf-8");
     expect(content).toContain('name: "Test Skill"');
 
-    const indexContent = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
+
+    const catalog = loadSkillCatalog();
+    const skill = catalog.find((s) => s.id === "test-skill");
+    expect(skill).toBeDefined();
+    expect(skill!.name).toBe("Test Skill");
+    expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);
+  });
+
+  test("accepts legacy add_to_index input without returning index metadata", async () => {
+    const result = await executeScaffoldManagedSkill(
+      {
+        skill_id: "legacy-input",
+        name: "Legacy Input",
+        description: "A test skill",
+        body_markdown: "Do the thing.",
+        add_to_index: true,
+      },
+      makeContext(),
     );
-    expect(indexContent).toContain("- test-skill");
+
+    expect(result.isError).toBe(false);
+    const parsed = JSON.parse(result.content);
+    expect(parsed.created).toBe(true);
+    expect(parsed).not.toHaveProperty("index_updated");
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
+    expect(mockRefreshSkillCapabilityMemories).toHaveBeenCalledTimes(1);
   });
 
   test("rejects duplicate unless overwrite=true", async () => {
@@ -258,7 +309,7 @@ describe("scaffold_managed_skill tool", () => {
     expect(result.content).toContain("traversal");
   });
 
-  test("e2e: scaffold child then parent with includes, verify files and index", async () => {
+  test("e2e: scaffold child then parent with includes, verify file discovery", async () => {
     const childResult = await executeScaffoldManagedSkill(
       {
         skill_id: "e2e-child",
@@ -288,11 +339,12 @@ describe("scaffold_managed_skill tool", () => {
     expect(parentContent).toContain("    includes:");
     expect(parentContent).toContain("      - e2e-child");
 
-    const indexContent = readFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "utf-8",
-    );
-    expect(indexContent).toContain("- e2e-child");
-    expect(indexContent).toContain("- e2e-parent");
+    expect(existsSync(join(TEST_DIR, "skills", "SKILLS.md"))).toBe(false);
+
+    const catalog = loadSkillCatalog();
+    expect(catalog.find((s) => s.id === "e2e-child")).toBeDefined();
+    const parent = catalog.find((s) => s.id === "e2e-parent");
+    expect(parent).toBeDefined();
+    expect(parent!.includes).toEqual(["e2e-child"]);
   });
 });

package/src/__tests__/schedule-routes.test.ts

@@ -39,8 +39,11 @@ mock.module("../daemon/conversation-store.js", () => ({
   },
 }));
 
+import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
+import type { AssistantEvent } from "../runtime/assistant-event.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES } from "../runtime/routes/schedule-routes.js";
 import type { RouteDefinition } from "../runtime/routes/types.js";
 import {
@@ -71,6 +74,15 @@ function findRoute(endpoint: string, method: string): RouteDefinition {
   return route;
 }
 
+async function waitFor(predicate: () => boolean): Promise<void> {
+  const deadline = Date.now() + 500;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  throw new Error("Timed out waiting for schedule route event");
+}
+
 describe("schedule run-now trust propagation", () => {
   beforeEach(() => {
     clearTables();
@@ -218,6 +230,41 @@ describe("GET /schedules — default defer exclusion", () => {
     expect(result.schedules).toHaveLength(1);
     expect(result.schedules[0].id).toBe(agent.id);
   });
+
+  test("mutation routes emit schedule sync invalidation", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      const agent = createSchedule({
+        name: "Agent schedule",
+        cronExpression: "* * * * *",
+        message: "hello",
+        syntax: "cron",
+      });
+      await waitFor(() => received.length >= 1);
+      received.length = 0;
+
+      const route = findRoute("schedules/:id/toggle", "POST");
+      route.handler({
+        pathParams: { id: agent.id },
+        body: { enabled: false },
+      });
+
+      await waitFor(() => received.length >= 1);
+      expect(received[0].message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantSchedules],
+      });
+    } finally {
+      subscription.dispose();
+    }
+  });
 });
 
 // ── schedules/:id/runs limit handling ─────────────────────────────────────
@@ -388,9 +435,9 @@ describe("POST /schedules — create", () => {
   });
 
   test("rejects missing required fields", () => {
-    expect(() => postCreate({ expression: "* * * * *", message: "hi" })).toThrow(
-      "name is required",
-    );
+    expect(() =>
+      postCreate({ expression: "* * * * *", message: "hi" }),
+    ).toThrow("name is required");
     expect(() => postCreate({ name: "x", message: "hi" })).toThrow(
       "expression is required",
     );

package/src/__tests__/schedule-store.test.ts

@@ -9,13 +9,19 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string) => value,
 }));
 
+import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
+import type { AssistantEvent } from "../runtime/assistant-event.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import {
   cancelSchedule,
   claimDueSchedules,
   completeOneShot,
+  completeScheduleRun,
   createSchedule,
+  createScheduleRun,
+  deleteSchedule,
   describeCronExpression,
   failOneShot,
   getSchedule,
@@ -31,6 +37,94 @@ function getRawDb(): import("bun:sqlite").Database {
     .$client;
 }
 
+async function waitFor(predicate: () => boolean): Promise<void> {
+  const deadline = Date.now() + 500;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  throw new Error("Timed out waiting for schedule-store event");
+}
+
+async function expectScheduleSyncEvent(
+  received: AssistantEvent[],
+): Promise<void> {
+  await waitFor(() =>
+    received.some(
+      (event) =>
+        event.message.type === "sync_changed" &&
+        event.message.tags.includes(SYNC_TAGS.assistantSchedules),
+    ),
+  );
+  const syncEvent = received.find(
+    (event) =>
+      event.message.type === "sync_changed" &&
+      event.message.tags.includes(SYNC_TAGS.assistantSchedules),
+  );
+  expect(syncEvent?.message).toEqual({
+    type: "sync_changed",
+    tags: [SYNC_TAGS.assistantSchedules],
+  });
+  received.length = 0;
+}
+
+describe("schedule sync invalidation", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+  });
+
+  test("store-level schedule mutations emit schedule sync invalidation", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      const job = createSchedule({
+        name: "Sync test",
+        cronExpression: "* * * * *",
+        message: "sync me",
+        syntax: "cron",
+      });
+      await expectScheduleSyncEvent(received);
+
+      updateSchedule(job.id, { name: "Updated sync test" });
+      await expectScheduleSyncEvent(received);
+
+      getRawDb().run("UPDATE cron_jobs SET next_run_at = ? WHERE id = ?", [
+        Date.now() - 1000,
+        job.id,
+      ]);
+      expect(claimDueSchedules(Date.now())).toHaveLength(1);
+      await expectScheduleSyncEvent(received);
+
+      const runId = createScheduleRun(job.id, "conv-123");
+      completeScheduleRun(runId, { status: "ok" });
+      await expectScheduleSyncEvent(received);
+
+      const oneShot = createSchedule({
+        name: "One-shot sync test",
+        message: "cancel me",
+        nextRunAt: Date.now() + 60_000,
+      });
+      await expectScheduleSyncEvent(received);
+
+      expect(cancelSchedule(oneShot.id)).toBe(true);
+      await expectScheduleSyncEvent(received);
+
+      expect(deleteSchedule(job.id)).toBe(true);
+      await expectScheduleSyncEvent(received);
+    } finally {
+      subscription.dispose();
+    }
+  });
+});
+
 // ── Cron schedules ──────────────────────────────────────────────────
 
 describe("createSchedule (cron)", () => {

package/src/__tests__/scheduler-reuse-conversation.test.ts

@@ -31,6 +31,7 @@ const runBackgroundJobOptions: Array<{
   onConversationCreated?: (id: string) => void;
 }> = [];
 let runBackgroundJobShouldFail = false;
+let runBackgroundJobBootstrapFails = false;
 mock.module("../runtime/background-job-runner.js", () => ({
   runBackgroundJob: async (opts: {
     prompt: string;
@@ -40,6 +41,25 @@ mock.module("../runtime/background-job-runner.js", () => ({
     suppressFailureNotifications?: boolean;
     onConversationCreated?: (id: string) => void;
   }) => {
+    runBackgroundJobOptions.push({
+      conversationType: opts.conversationType,
+      scheduleJobId: opts.scheduleJobId,
+      groupId: opts.groupId,
+      suppressFailureNotifications: opts.suppressFailureNotifications,
+      onConversationCreated: opts.onConversationCreated,
+    });
+    // Bootstrap-failure path: the real runner returns conversationId: ""
+    // when `bootstrapConversation` throws before assignment. Skip the
+    // callback (it was never reached) and surface the empty id to the
+    // scheduler so it can exercise the sentinel guard.
+    if (runBackgroundJobBootstrapFails) {
+      return {
+        conversationId: "",
+        ok: false,
+        error: new Error("Bootstrap failure"),
+        errorKind: "exception" as const,
+      };
+    }
     const { createConversation } =
       await import("../memory/conversation-crud.js");
     const conv = createConversation({
@@ -49,13 +69,6 @@ mock.module("../runtime/background-job-runner.js", () => ({
       ...(opts.groupId ? { groupId: opts.groupId } : {}),
       ...(opts.scheduleJobId ? { scheduleJobId: opts.scheduleJobId } : {}),
     });
-    runBackgroundJobOptions.push({
-      conversationType: opts.conversationType,
-      scheduleJobId: opts.scheduleJobId,
-      groupId: opts.groupId,
-      suppressFailureNotifications: opts.suppressFailureNotifications,
-      onConversationCreated: opts.onConversationCreated,
-    });
     // Mirror the real runner's contract: fire the SSE callback synchronously
     // BEFORE the job's processMessage finishes, with the bootstrap-returned
     // conversation id.
@@ -137,6 +150,7 @@ describe("scheduler conversation reuse", () => {
     processedMessages.length = 0;
     runBackgroundJobOptions.length = 0;
     runBackgroundJobShouldFail = false;
+    runBackgroundJobBootstrapFails = false;
   });
 
   test("recurring schedule with reuseConversation=true reuses conversation across runs", async () => {
@@ -393,6 +407,7 @@ describe("scheduler talk-mode runner option propagation", () => {
     processedMessages.length = 0;
     runBackgroundJobOptions.length = 0;
     runBackgroundJobShouldFail = false;
+    runBackgroundJobBootstrapFails = false;
   });
 
   test("talk-mode propagates conversationType=scheduled, scheduleJobId, and quiet=>suppressFailureNotifications", async () => {
@@ -443,6 +458,38 @@ describe("scheduler talk-mode runner option propagation", () => {
     );
   });
 
+  test("talk-mode bootstrap failure writes sentinel conversationId, not empty string", async () => {
+    /**
+     * Regression: `runBackgroundJob` returns `{ conversationId: "", ok: false }`
+     * when bootstrap throws before the conversation row is assigned. The
+     * scheduler previously stored that empty string in the cron_runs DB row.
+     * Guard ensures we substitute a recognizable sentinel.
+     */
+    const rruleExpr = buildEveryMinuteRrule();
+    const schedule = createSchedule({
+      name: "Bootstrap Failure",
+      cronExpression: rruleExpr,
+      message: "x",
+      syntax: "rrule",
+      expression: rruleExpr,
+    });
+    forceScheduleDue(schedule.id);
+    runBackgroundJobBootstrapFails = true;
+
+    const processMessage = async () => {};
+    const scheduler = startScheduler(processMessage, () => {});
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    scheduler.stop();
+
+    const runs = getScheduleRuns(schedule.id);
+    expect(runs.length).toBe(1);
+    expect(runs[0].status).toBe("error");
+    // Critical: must NOT be empty — the DB column should carry a marker that
+    // identifies this run as a bootstrap-failure case.
+    expect(runs[0].conversationId).not.toBe("");
+    expect(runs[0].conversationId).toBe(`bootstrap-error:${schedule.id}`);
+  });
+
   test("talk-mode fires onScheduleConversationCreated synchronously via runner callback (BEFORE the runner returns)", async () => {
     const rruleExpr = buildEveryMinuteRrule();
     const schedule = createSchedule({

package/src/__tests__/schema-transforms.test.ts

@@ -157,6 +157,26 @@ describe("injectActivityField", () => {
     expect(Object.is(result[0], defs[0])).toBe(true);
   });
 
+  test("passes through undefined/null input_schema unchanged (no crash)", () => {
+    // Repro for the crash where an MCP server returned a tool with missing
+    // inputSchema and `injectActivityField` threw on `schema.type` access.
+    const defs: ToolDefinition[] = [
+      {
+        name: "missing",
+        description: "x",
+        input_schema: undefined as unknown as object,
+      },
+      {
+        name: "nullish",
+        description: "x",
+        input_schema: null as unknown as object,
+      },
+    ];
+    const result = injectActivityField(defs);
+    expect(Object.is(result[0], defs[0])).toBe(true);
+    expect(Object.is(result[1], defs[1])).toBe(true);
+  });
+
   test("does NOT add activity to top-level required when only in oneOf branch", () => {
     const defs = [
       makeDef("my_tool", {

package/src/__tests__/search-skills-unified.test.ts

@@ -124,9 +124,6 @@ mock.module("../providers/provider-send-message.js", () => ({
   getConfiguredProvider: async () => null,
   userMessage: () => ({}),
 }));
-mock.module("../runtime/routes/workspace-utils.js", () => ({
-  isTextMimeType: () => true,
-}));
 mock.module("../skills/catalog-cache.js", () => ({
   getCatalog: async () => [],
 }));
@@ -136,7 +133,6 @@ mock.module("../skills/catalog-install.js", () => ({
 mock.module("../skills/managed-store.js", () => ({
   createManagedSkill: () => ({ created: true }),
   deleteManagedSkill: () => ({ deleted: true }),
-  removeSkillsIndexEntry: () => {},
   validateManagedSkillId: () => null,
 }));
 mock.module("../memory/graph/capability-seed.js", () => ({
@@ -165,7 +161,6 @@ import { searchSkills } from "../daemon/handlers/skills.js";
 // Helpers
 // ---------------------------------------------------------------------------
 
-
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------

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

@@ -91,6 +91,49 @@ describe("renderHistoryContent", () => {
     expect(renderHistoryContent(42).text).toBe("42");
   });
 
+  test("unwraps complete legacy external_content envelopes for plain string content", () => {
+    const output = renderHistoryContent(
+      '<external_content source="slack">\nVisible Slack text\n</external_content>',
+    );
+
+    expect(output.text).toBe("Visible Slack text");
+    expect(output.textSegments).toEqual(["Visible Slack text"]);
+    expect(output.contentOrder).toEqual(["text:0"]);
+  });
+
+  test("unwraps complete legacy external_content envelopes in text blocks", () => {
+    const output = renderHistoryContent([
+      {
+        type: "text",
+        text: '<external_content source="slack">\nVisible block text\n</external_content>',
+      },
+      { type: "text", text: "Plain follow-up." },
+    ]);
+
+    expect(output.text).toBe("Visible block text Plain follow-up.");
+    expect(output.textSegments).toEqual([
+      "Visible block text Plain follow-up.",
+    ]);
+    expect(output.contentOrder).toEqual(["text:0"]);
+  });
+
+  test("leaves malformed or mixed external_content text unchanged", () => {
+    const malformed =
+      '<external_content source="slack">Visible text</external_content>';
+    const mixed =
+      'prefix <external_content source="slack">\nVisible text\n</external_content>';
+
+    const malformedOutput = renderHistoryContent([
+      { type: "text", text: malformed },
+    ]);
+    expect(malformedOutput.text).toBe(malformed);
+    expect(malformedOutput.textSegments).toEqual([malformed]);
+
+    const mixedOutput = renderHistoryContent(mixed);
+    expect(mixedOutput.text).toBe(mixed);
+    expect(mixedOutput.textSegments).toEqual([mixed]);
+  });
+
   test("preserves JSON object content as JSON string", () => {
     expect(renderHistoryContent({ foo: "bar" }).text).toBe('{"foo":"bar"}');
   });

package/src/__tests__/skill-load-feature-flag.test.ts

@@ -103,10 +103,6 @@ describe("skill_load feature flag enforcement", () => {
       "Toggle email channel behavior",
       "Use the feature.",
     );
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      `- ${DECLARED_SKILL_ID}\n`,
-    );
 
     _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
 
@@ -124,10 +120,6 @@ describe("skill_load feature flag enforcement", () => {
       "Toggle email channel behavior",
       "Use the feature.",
     );
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      `- ${DECLARED_SKILL_ID}\n`,
-    );
 
     _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
 
@@ -144,10 +136,6 @@ describe("skill_load feature flag enforcement", () => {
       "Toggle email channel behavior",
       "Use the feature.",
     );
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      `- ${DECLARED_SKILL_ID}\n`,
-    );
 
     // No overrides — uses registry defaults