opencode-agent-skills-md 1.0.0 → 1.1.0

package/packages/opencode-agent-skills-md/tests/opencode/plugin.test.ts

@@ -1,551 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, beforeEach, describe, mock, test } from "node:test";
-import type { SkillSummary } from "opencode-agent-skills-md-core";
-import {
-  createFixtureWorkspace,
-  createMockOpencodeClient,
-  createShellRecorder,
-  type FixtureWorkspace,
-} from "../integration/helpers/mock-opencode";
-
-/**
- * Helper functions in `src/opencode/plugin.ts` that were promoted to
- * named exports in PR 2 so they can be tested in isolation. The
- * `as unknown as PluginModule` cast keeps the test file type-safe while
- * the dynamic import path gives the test runner a chance to load the
- * module under test (and lets it throw a clean "is not a function"
- * error in the RED state).
- */
-type PluginModule = {
-  matchSkillsByKeyword: (userMessage: string, availableSkills: SkillSummary[]) => SkillSummary[];
-  formatMatchedSkillsInjection: (matchedSkills: SkillSummary[]) => string;
-};
-
-async function loadPluginModule(): Promise<PluginModule> {
-  return (await import("../../src/plugin")) as unknown as PluginModule;
-}
-
-/**
- * Tests for the OpenCode keyword matcher and the synthetic injection
- * formatter. These were promoted to named exports in PR 2 of
- * `trigger-aware-skill-discovery` so the trigger-aware behaviour can
- * be exercised without standing up a full plugin session.
- *
- * Coverage:
- *   - matchSkillsByKeyword: trigger match (1.5x) outranks description match (1x) for the same query
- *   - matchSkillsByKeyword: trigger match does not outrank name match (2x) for the same query
- *   - matchSkillsByKeyword: skills without a trigger are scored as before (no regression)
- *   - formatMatchedSkillsInjection: trigger text appears in each matched-skill line
- *   - formatMatchedSkillsInjection: skills with no trigger render exactly as before
- */
-describe("matchSkillsByKeyword", () => {
-  test("trigger match (1.5x) outranks description match (1x) at the same query (R4)", async () => {
-    const { matchSkillsByKeyword } = await loadPluginModule();
-    const descSkill: SkillSummary = {
-      name: "skill-x",
-      description: "auth helper for tokens",
-    };
-    const triggerSkill: SkillSummary = {
-      name: "skill-y",
-      description: "unrelated",
-      trigger: "auth login",
-    };
-
-    const result = matchSkillsByKeyword("auth", [descSkill, triggerSkill]);
-
-    assert.equal(result.length, 2);
-    assert.equal(result[0]?.name, "skill-y", "trigger-matched skill ranks first");
-    assert.equal(result[1]?.name, "skill-x", "description-matched skill ranks second");
-  });
-
-  test("name match (2x) still outranks trigger match (1.5x) at the same query", async () => {
-    const { matchSkillsByKeyword } = await loadPluginModule();
-    const nameSkill: SkillSummary = { name: "auth", description: "x" };
-    const triggerSkill: SkillSummary = { name: "skill-y", description: "x", trigger: "auth login" };
-
-    const result = matchSkillsByKeyword("auth", [nameSkill, triggerSkill]);
-
-    assert.equal(result[0]?.name, "auth", "name match wins over trigger match");
-    assert.equal(result[1]?.name, "skill-y");
-  });
-
-  test("skills with no trigger are scored only on name + description (no regression)", async () => {
-    const { matchSkillsByKeyword } = await loadPluginModule();
-    const noTriggerA: SkillSummary = { name: "alpha", description: "auth helper" };
-    const noTriggerB: SkillSummary = { name: "beta", description: "noise" };
-
-    const result = matchSkillsByKeyword("auth", [noTriggerA, noTriggerB]);
-
-    assert.equal(result.length, 1);
-    assert.equal(result[0]?.name, "alpha");
-  });
-});
-
-describe("formatMatchedSkillsInjection", () => {
-  test("renders the trigger text on a sub-line for each matched skill (R5)", async () => {
-    const { formatMatchedSkillsInjection } = await loadPluginModule();
-    const matched: SkillSummary[] = [
-      { name: "skill-y", description: "unrelated", trigger: "auth login" },
-    ];
-
-    const output = formatMatchedSkillsInjection(matched);
-
-    assert.match(output, /skill-y/, "name appears");
-    assert.match(output, /trigger: auth login/, "trigger text is rendered on its own line");
-  });
-
-  test("skills with no trigger render exactly as before (no extra line)", async () => {
-    const { formatMatchedSkillsInjection } = await loadPluginModule();
-    const matched: SkillSummary[] = [
-      { name: "alpha", description: "auth helper" },
-    ];
-
-    const output = formatMatchedSkillsInjection(matched);
-
-    assert.match(output, /- alpha: auth helper/);
-    assert.doesNotMatch(output, /trigger:/, "no trigger line when trigger is undefined");
-  });
-
-  test("multiple matched skills each render their own trigger line", async () => {
-    const { formatMatchedSkillsInjection } = await loadPluginModule();
-    const matched: SkillSummary[] = [
-      { name: "with-trigger", description: "x", trigger: "auth, login" },
-      { name: "no-trigger", description: "y" },
-    ];
-
-    const output = formatMatchedSkillsInjection(matched);
-
-    assert.match(output, /- with-trigger: x\s+trigger: auth, login/);
-    assert.match(output, /- no-trigger: y/);
-  });
-});
-
-/**
- * Regression coverage for the skill-loading callback wiring (PR 1 of
- * `fix-skill-loading-regression`). After the core-decoupling refactor,
- * `createSkillTools()` stopped threading `onSkillLoaded` through to
- * `UseSkill`, so a successful `use_skill` call no longer updated the
- * session's loaded-skill set, and a subsequent keyword-matched
- * `chat.message` re-injected an evaluation prompt for the already-loaded
- * skill.
- *
- * These tests pin both ends of the wiring at the host-adapter boundary:
- *   1. The factory accepts a callback and the tool calls it.
- *   2. The full plugin path (createSkillTools + UseSkill + plugin
- *      bookkeeping) updates `loadedSkillsPerSession` so a second
- *      matching chat.message does NOT re-inject the skill evaluation.
- */
-describe("use_skill callback wiring (PR 1)", () => {
-  let workspace: FixtureWorkspace;
-  const previousSuperpowersMode = process.env.OPENCODE_AGENT_SKILLS_SUPERPOWERS_MODE;
-
-  beforeEach(async () => {
-    workspace = await createFixtureWorkspace();
-    process.env.OPENCODE_AGENT_SKILLS_SUPERPOWERS_MODE = "true";
-  });
-
-  afterEach(async () => {
-    if (workspace) {
-      await workspace.cleanup();
-    }
-    if (previousSuperpowersMode === undefined) {
-      delete process.env.OPENCODE_AGENT_SKILLS_SUPERPOWERS_MODE;
-    } else {
-      process.env.OPENCODE_AGENT_SKILLS_SUPERPOWERS_MODE = previousSuperpowersMode;
-    }
-  });
-
-  /** Drive `chat.message` with a plain text part (the only path the plugin's matcher inspects). */
-  async function sendMessage(
-    plugin: { "chat.message": (input: unknown, output: unknown) => Promise<void> },
-    sessionID: string,
-    text: string,
-  ): Promise<void> {
-    await plugin["chat.message"](
-      {},
-      {
-        message: {
-          sessionID,
-          model: { providerID: "test-provider", modelID: "test-model" },
-          agent: "test-agent",
-        },
-        parts: [{ type: "text", text, synthetic: false }],
-      } as any,
-    );
-  }
-
-  test("createSkillTools forwards onSkillLoaded so UseSkill invokes it (R3)", async () => {
-    const { createSkillTools } = await import("../../src/tools");
-    const { createOpencodeSkillHost } = await import("../../src/host");
-
-    const client = createMockOpencodeClient();
-    const shell = createShellRecorder();
-    const host = createOpencodeSkillHost(client.client as any);
-    const calls: Array<{ sessionID: string; skillName: string }> = [];
-
-    const tools = createSkillTools(
-      host,
-      shell.shell,
-      workspace.projectRoot,
-      (sessionID, skillName) => calls.push({ sessionID, skillName }),
-    );
-
-    const result = await tools.UseSkill.execute(
-      { skill: "scripted-skill" },
-      { sessionID: "callback-test" } as any,
-    );
-
-    assert.match(result, /loaded\./i, "skill load returns the success message");
-    assert.equal(calls.length, 1, "onSkillLoaded should fire exactly once on a successful load");
-    assert.deepEqual(calls[0], { sessionID: "callback-test", skillName: "scripted-skill" });
-  });
-
-  test("plugin updates loadedSkillsPerSession so a repeat chat.message does not re-inject (R3 dedupe)", async () => {
-    const { SkillsPlugin } = await import("../../src");
-
-    const client = createMockOpencodeClient();
-    const shell = createShellRecorder();
-    const plugin = await SkillsPlugin({
-      client: client.client,
-      $: shell.shell,
-      directory: workspace.projectRoot,
-    } as any);
-
-    const SESSION = "session-dedupe-callback";
-
-    // First chat.message: bootstrap the session with the available-skills
-    // block; the keyword matcher is short-circuited on the first message.
-    await sendMessage(plugin, SESSION, "hello");
-    const promptsAfterBootstrap = client.prompts.length;
-    assert.ok(
-      client.prompts.some((p) => /<available-skills>/.test(p.text)),
-      "first message injects the available-skills block",
-    );
-
-    // Load scripted-skill via use_skill. With the regression, no callback
-    // fires and loadedSkillsPerSession is NOT updated.
-    const loadResult = await plugin.tool.use_skill.execute(
-      { skill: "scripted-skill" },
-      { sessionID: SESSION } as any,
-    );
-    assert.match(loadResult, /loaded\./i, "use_skill reports a successful load");
-    assert.ok(
-      client.prompts.slice(promptsAfterBootstrap).some((p) =>
-        /<skill name="scripted-skill">/.test(p.text),
-      ),
-      "use_skill injects the skill content",
-    );
-
-    // Second chat.message with a keyword that also matches scripted-skill.
-    // Other skills may legitimately match too, but scripted-skill MUST be
-    // filtered out by the loaded-skill set after the fix. Before the fix,
-    // scripted-skill appears because loadedSkillsPerSession was never
-    // updated by use_skill (no callback was wired).
-    const promptsBeforeRepeat = client.prompts.length;
-    await sendMessage(plugin, SESSION, "use the script skill");
-    const newPrompts = client.prompts.slice(promptsBeforeRepeat);
-    const evaluationInjections = newPrompts.filter((p) =>
-      /<skill-evaluation-required>/.test(p.text),
-    );
-    for (const prompt of evaluationInjections) {
-      assert.doesNotMatch(
-        prompt.text,
-        /^- scripted-skill:/m,
-        "loaded-skill state must suppress scripted-skill from re-injection",
-      );
-    }
-  });
-
-  test("use_skill still loads when no callback is registered (R3 missing-callback)", async () => {
-    const { SkillsPlugin } = await import("../../src");
-
-    const client = createMockOpencodeClient();
-    const shell = createShellRecorder();
-    const plugin = await SkillsPlugin({
-      client: client.client,
-      $: shell.shell,
-      directory: workspace.projectRoot,
-    } as any);
-
-    const result = await plugin.tool.use_skill.execute(
-      { skill: "scripted-skill" },
-      { sessionID: "session-no-callback" } as any,
-    );
-
-    assert.match(result, /loaded\./i, "skill load returns the success message");
-    assert.ok(
-      client.prompts.some((p) => /<skill name="scripted-skill">/.test(p.text)),
-      "skill content was injected even with no callback registered",
-    );
-  });
-});
-
-/**
- * PR 2 plugin refactor coverage. The closure-scoped refactor must:
- *   1. Keep two plugin instances isolated (no shared session state).
- *   2. Trigger exactly one discovery per chat.message handler call.
- *   3. Preserve first-message bootstrap and subsequent-message matcher
- *      behavior.
- */
-describe("plugin refactor (PR 2)", () => {
-  let workspace: FixtureWorkspace;
-  const previousSuperpowersMode = process.env.OPENCODE_AGENT_SKILLS_SUPERPOWERS_MODE;
-
-  beforeEach(async () => {
-    workspace = await createFixtureWorkspace();
-    process.env.OPENCODE_AGENT_SKILLS_SUPERPOWERS_MODE = "true";
-  });
-
-  afterEach(async () => {
-    if (workspace) await workspace.cleanup();
-    if (previousSuperpowersMode === undefined) {
-      delete process.env.OPENCODE_AGENT_SKILLS_SUPERPOWERS_MODE;
-    } else {
-      process.env.OPENCODE_AGENT_SKILLS_SUPERPOWERS_MODE = previousSuperpowersMode;
-    }
-  });
-
-  async function sendMessage(
-    plugin: { "chat.message": (input: unknown, output: unknown) => Promise<void> },
-    sessionID: string,
-    text: string,
-  ): Promise<void> {
-    await plugin["chat.message"](
-      {},
-      {
-        message: {
-          sessionID,
-          model: { providerID: "test-provider", modelID: "test-model" },
-          agent: "test-agent",
-        },
-        parts: [{ type: "text", text, synthetic: false }],
-      } as any,
-    );
-  }
-
-  test("two plugin instances do not share session state (PR 2 isolation)", async () => {
-    const { SkillsPlugin } = await import("../../src");
-    const clientA = createMockOpencodeClient();
-    const clientB = createMockOpencodeClient();
-    const shell = createShellRecorder();
-    const pluginA = await SkillsPlugin({ client: clientA.client, $: shell.shell, directory: workspace.projectRoot } as any);
-    const pluginB = await SkillsPlugin({ client: clientB.client, $: shell.shell, directory: workspace.projectRoot } as any);
-
-    await sendMessage(pluginA, "shared-session-id", "hello");
-    assert.ok(clientA.prompts.some((p) => /<available-skills>/.test(p.text)), "plugin A bootstraps");
-
-    const promptsBBefore = clientB.prompts.length;
-    await sendMessage(pluginB, "shared-session-id", "hello");
-    assert.ok(
-      clientB.prompts.slice(promptsBBefore).some((p) => /<available-skills>/.test(p.text)),
-      "plugin B independently bootstraps the same session id",
-    );
-
-    await pluginA.tool.use_skill.execute(
-      { skill: "scripted-skill" },
-      { sessionID: "shared-session-id" } as any,
-    );
-    const promptsBBeforeKeyword = clientB.prompts.length;
-    await sendMessage(pluginB, "shared-session-id", "use the script skill");
-    const evaluationB = clientB.prompts
-      .slice(promptsBBeforeKeyword)
-      .filter((p) => /<skill-evaluation-required>/.test(p.text));
-    assert.ok(
-      evaluationB.some((p) => /^- scripted-skill:/m.test(p.text)),
-      "plugin B sees scripted-skill as not-loaded (its own loaded set is independent)",
-    );
-  });
-
-  test("chat.message discovers skills exactly once per handler invocation (PR 2 R3+R4+R5)", async () => {
-    const { SkillsPlugin } = await import("../../src");
-    const client = createMockOpencodeClient();
-    const shell = createShellRecorder();
-    const plugin = await SkillsPlugin({ client: client.client, $: shell.shell, directory: workspace.projectRoot } as any);
-
-    // The fixture has one duplicate (project + user `shared-skill`); each
-    // `discoverAllSkills` triggers exactly one `console.warn` via the
-    // default duplicate callback, so counting warns counts discoveries.
-    const warnSpy = mock.method(console, "warn", () => {});
-    try {
-      const warns = (): number => warnSpy.mock.calls.filter(
-        (c) => typeof c.arguments[0] === "string" && c.arguments[0].startsWith("Skill name conflict:"),
-      ).length;
-
-      await sendMessage(plugin, "spy-session", "use the script skill");
-      assert.equal(warns(), 1, "single chat.message = single discovery");
-
-      const before = warns();
-      await sendMessage(plugin, "spy-session", "use the script skill again");
-      assert.equal(warns() - before, 1, "no cross-request caching");
-    } finally {
-      warnSpy.mock.restore();
-    }
-  });
-
-  test("first-message bootstrap and subsequent keyword match are both preserved (PR 2)", async () => {
-    const { SkillsPlugin } = await import("../../src");
-    const client = createMockOpencodeClient();
-    const shell = createShellRecorder();
-    const plugin = await SkillsPlugin({ client: client.client, $: shell.shell, directory: workspace.projectRoot } as any);
-    const SESSION = "preserved-session";
-
-    await sendMessage(plugin, SESSION, "first message");
-    assert.ok(client.prompts.some((p) => /<available-skills>/.test(p.text)), "first injects available-skills");
-    assert.ok(client.prompts.some((p) => /You have superpowers\./.test(p.text)), "first injects superpowers");
-    assert.ok(
-      !client.prompts.some((p) => /<skill-evaluation-required>/.test(p.text)),
-      "first message does NOT run matcher",
-    );
-
-    await plugin.tool.use_skill.execute({ skill: "scripted-skill" }, { sessionID: SESSION } as any);
-
-    const before = client.prompts.length;
-    await sendMessage(plugin, SESSION, "use the script skill");
-    const newPrompts = client.prompts.slice(before);
-    assert.ok(!newPrompts.some((p) => /<available-skills>/.test(p.text)), "subsequent does NOT re-inject available-skills");
-    const evals = newPrompts.filter((p) => /<skill-evaluation-required>/.test(p.text));
-    for (const p of evals) {
-      assert.doesNotMatch(p.text, /^- scripted-skill:/m, "loaded skills are filtered from match");
-    }
-  });
-});
-
-/**
- * PR 3 diagnostic + SDK-shape hardening coverage. Verifies that:
- *   1. Malformed hook payloads (null / undefined / partial) degrade
- *      gracefully — no throw, no spurious prompts.
- *   2. The `debugLog` helper only emits to stderr when
- *      `OPENCODE_AGENT_SKILLS_DEBUG` is set, and stays silent otherwise.
- *   3. The normal chat.message flow produces zero user-visible noise
- *      (no debug output, no exception).
- */
-describe("PR 3 diagnostics + SDK shapes (R6 + R8)", () => {
-  let workspace: FixtureWorkspace;
-  const previousSuperpowersMode = process.env.OPENCODE_AGENT_SKILLS_SUPERPOWERS_MODE;
-  const previousDebugMode = process.env.OPENCODE_AGENT_SKILLS_DEBUG;
-
-  beforeEach(async () => {
-    workspace = await createFixtureWorkspace();
-    process.env.OPENCODE_AGENT_SKILLS_SUPERPOWERS_MODE = "true";
-    delete process.env.OPENCODE_AGENT_SKILLS_DEBUG;
-  });
-
-  afterEach(async () => {
-    if (workspace) await workspace.cleanup();
-    if (previousSuperpowersMode === undefined) {
-      delete process.env.OPENCODE_AGENT_SKILLS_SUPERPOWERS_MODE;
-    } else {
-      process.env.OPENCODE_AGENT_SKILLS_SUPERPOWERS_MODE = previousSuperpowersMode;
-    }
-    if (previousDebugMode === undefined) {
-      delete process.env.OPENCODE_AGENT_SKILLS_DEBUG;
-    } else {
-      process.env.OPENCODE_AGENT_SKILLS_DEBUG = previousDebugMode;
-    }
-  });
-
-  async function makePlugin() {
-    const { SkillsPlugin } = await import("../../src");
-    const client = createMockOpencodeClient();
-    const shell = createShellRecorder();
-    const plugin = await SkillsPlugin({
-      client: client.client,
-      $: shell.shell,
-      directory: workspace.projectRoot,
-    } as any);
-    return { plugin, client };
-  }
-
-  test("chat.message with undefined output degrades gracefully (no throw, no prompts)", async () => {
-    const { plugin, client } = await makePlugin();
-    await assert.doesNotReject(
-      async () => {
-        await plugin["chat.message"]({}, undefined);
-      },
-      "undefined output must not throw",
-    );
-    assert.equal(client.prompts.length, 0, "no prompts injected on malformed payload");
-  });
-
-  test("chat.message with null output degrades gracefully (no throw, no prompts)", async () => {
-    const { plugin, client } = await makePlugin();
-    await assert.doesNotReject(async () => {
-      await plugin["chat.message"]({}, null);
-    });
-    assert.equal(client.prompts.length, 0);
-  });
-
-  test("chat.message with missing sessionID degrades gracefully", async () => {
-    const { plugin, client } = await makePlugin();
-    await assert.doesNotReject(async () => {
-      await plugin["chat.message"]({}, { message: {}, parts: [] });
-    });
-    assert.equal(client.prompts.length, 0, "partial payload must not inject anything");
-  });
-
-  test("event handler with undefined event degrades gracefully", async () => {
-    const { plugin } = await makePlugin();
-    await assert.doesNotReject(async () => {
-      await plugin.event({ event: undefined });
-    });
-  });
-
-  test("event handler with unknown event type degrades gracefully", async () => {
-    const { plugin } = await makePlugin();
-    await assert.doesNotReject(async () => {
-      await plugin.event({ event: { type: "session.created" } });
-    });
-  });
-
-  test("debugLog emits to stderr when OPENCODE_AGENT_SKILLS_DEBUG is set", async () => {
-    const { debugLog } = await import("opencode-agent-skills-md-core");
-    process.env.OPENCODE_AGENT_SKILLS_DEBUG = "1";
-    const spy = mock.method(console, "error", () => {});
-    try {
-      debugLog("test-context", new Error("boom"));
-      assert.equal(spy.mock.calls.length, 1, "debug output appears when flag is set");
-      const firstCall = spy.mock.calls[0];
-      assert.ok(firstCall, "spy captured a call");
-      const args = firstCall.arguments;
-      assert.match(String(args[0]), /opencode-agent-skills-md/, "debug prefix is present");
-      assert.equal(args[1], "test-context");
-    } finally {
-      spy.mock.restore();
-    }
-  });
-
-  test("debugLog stays silent when OPENCODE_AGENT_SKILLS_DEBUG is unset", async () => {
-    const { debugLog } = await import("opencode-agent-skills-md-core");
-    delete process.env.OPENCODE_AGENT_SKILLS_DEBUG;
-    const spy = mock.method(console, "error", () => {});
-    try {
-      debugLog("test-context", new Error("boom"));
-      assert.equal(spy.mock.calls.length, 0, "no debug output when flag is unset");
-    } finally {
-      spy.mock.restore();
-    }
-  });
-
-  test("normal chat.message flow produces zero user-visible noise", async () => {
-    const { plugin, client } = await makePlugin();
-    const spy = mock.method(console, "error", () => {});
-    try {
-      const SESSION = "noise-test-session";
-      await plugin["chat.message"](
-        {},
-        {
-          message: {
-            sessionID: SESSION,
-            model: { providerID: "test-provider", modelID: "test-model" },
-            agent: "test-agent",
-          },
-          parts: [{ type: "text", text: "hello world", synthetic: false }],
-        } as any,
-      );
-      assert.equal(spy.mock.calls.length, 0, "normal flow is silent when debug flag is off");
-      assert.ok(client.prompts.length > 0, "normal flow still injects bootstrap content");
-    } finally {
-      spy.mock.restore();
-    }
-  });
-});

package/packages/opencode-agent-skills-md/tests/opencode/subpath.test.ts

@@ -1,66 +0,0 @@
-import assert from "node:assert/strict";
-import { createRequire } from "node:module";
-import { describe, test } from "node:test";
-
-const require = createRequire(import.meta.url);
-
-/**
- * Package boundary smoke test for `opencode-agent-skills-md`.
- *
- * The plugin package now lives at `packages/opencode-agent-skills-md/` and is
- * consumed via the workspace link `opencode-agent-skills-md`. Three
- * guarantees pinned by this test:
- *
- *   1. The package's `exports` field resolves `.` to the plugin entry
- *      under the package's own `src/` directory (via the workspace link
- *      into `packages/opencode-agent-skills-md/`).
- *   2. Importing the entry is safe at module-load time — it does not
- *      instantiate anything, it just re-exports the plugin factory.
- *   3. The default export and the `SkillsPlugin` named export are both
- *      the plugin factory function consumed by OpenCode.
- */
-describe("opencode-agent-skills-md package root export", () => {
-  test("resolves . via the workspace link to packages/opencode-agent-skills-md/src/index.ts", () => {
-    const resolved = require.resolve("opencode-agent-skills-md");
-
-    assert.match(
-      resolved,
-      /[\\/]packages[\\/]opencode-agent-skills-md[\\/]src[\\/]index\.ts$/,
-      `expected . to resolve under packages/opencode-agent-skills-md/src, got: ${resolved}`,
-    );
-  });
-
-  test("default export is the SkillsPlugin factory function", async () => {
-    const entryPath = require.resolve("opencode-agent-skills-md");
-    // Dynamic import is intentional: it proves module load is side-effect
-    // safe (the factory itself is not invoked).
-    const mod = await import(entryPath);
-
-    assert.equal(
-      typeof mod.default,
-      "function",
-      "default export should be the SkillsPlugin factory",
-    );
-    assert.equal(
-      typeof mod.SkillsPlugin,
-      "function",
-      "SkillsPlugin named export should be a function",
-    );
-    assert.equal(
-      mod.default,
-      mod.SkillsPlugin,
-      "default export and SkillsPlugin should be the same factory",
-    );
-  });
-
-  test("module load is side-effect safe (does not throw, does not instantiate)", () => {
-    // Reaching this point already exercised module load via the require +
-    // dynamic import above. This test guards against future regressions
-    // where someone might add a top-level `new SomeSDK()` in the entry.
-    assert.doesNotThrow(() => {
-      // Re-resolve without invoking; the spec only requires that the
-      // entry module be importable in isolation.
-      require.resolve("opencode-agent-skills-md");
-    });
-  });
-});