opencode-agent-skills-md 1.0.0 → 1.1.0

package/packages/core/tests/discovery.test.ts

@@ -1,370 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtemp, mkdir, rm, writeFile, chmod } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import * as path from "node:path";
-import { after, before, describe, test } from "node:test";
-
-/**
- * `getSkillSummaries` is the preflight path that builds the list of
- * `SkillSummary` records the plugin feeds into the keyword matcher and
- * the `<available-skills>` injection. PR 2 threads the `trigger`
- * frontmatter key through it so the matcher can rank by trigger and
- * the targeted outputs can render trigger text.
- */
-describe("getSkillSummaries trigger passthrough (PR 2)", () => {
-  let workspace: string;
-
-  before(async () => {
-    workspace = await mkdtemp(path.join(tmpdir(), "opencode-agent-skills-md-summaries-"));
-    const projectRoot = path.join(workspace, ".opencode", "skills");
-    await mkdir(path.join(projectRoot, "with-trigger"), { recursive: true });
-    await mkdir(path.join(projectRoot, "no-trigger"), { recursive: true });
-
-    await writeFile(
-      path.join(projectRoot, "with-trigger", "SKILL.md"),
-      [
-        "---",
-        "name: with-trigger",
-        "description: skill whose frontmatter carries a trigger",
-        "trigger: auth, login",
-        "---",
-        "",
-        "# With Trigger",
-        "",
-      ].join("\n"),
-      "utf8"
-    );
-
-    await writeFile(
-      path.join(projectRoot, "no-trigger", "SKILL.md"),
-      [
-        "---",
-        "name: no-trigger",
-        "description: skill without a trigger",
-        "---",
-        "",
-        "# No Trigger",
-        "",
-      ].join("\n"),
-      "utf8"
-    );
-  });
-
-  after(async () => {
-    if (workspace) {
-      await rm(workspace, { recursive: true, force: true });
-    }
-  });
-
-  test("threads `trigger` through to SkillSummary when present", async () => {
-    const { getSkillSummaries } = await import("../src/index");
-    const summaries = await getSkillSummaries(workspace);
-
-    const withTrigger = summaries.find((s) => s.name === "with-trigger");
-    assert.ok(withTrigger, "with-trigger summary is present");
-    assert.equal(withTrigger!.trigger, "auth, login", "trigger is preserved on the summary");
-  });
-
-  test("leaves `trigger` undefined when the skill has no trigger key", async () => {
-    const { getSkillSummaries } = await import("../src/index");
-    const summaries = await getSkillSummaries(workspace);
-
-    const noTrigger = summaries.find((s) => s.name === "no-trigger");
-    assert.ok(noTrigger, "no-trigger summary is present");
-    assert.equal(
-      noTrigger!.trigger,
-      undefined,
-      "trigger is undefined for skills that omit the frontmatter key"
-    );
-  });
-});
-
-/**
- * `walkDir` (R2 of source-improvements-p1) is the shared directory walker
- * that backs `findSkillsRecursive` and `findScripts`. These tests pin the
- * cross-cutting behavior those callers depend on: hidden / dependency
- * skip rules, depth bounds, per-entry error isolation, and the
- * caller-extensible `skipDirs` option.
- */
-describe("walkDir (R2 shared walker)", () => {
-  let workspace: string;
-
-  before(async () => {
-    workspace = await mkdtemp(path.join(tmpdir(), "opencode-agent-skills-md-walk-"));
-    await mkdir(path.join(workspace, "visible"), { recursive: true });
-    await mkdir(path.join(workspace, ".hidden"), { recursive: true });
-    await mkdir(path.join(workspace, "node_modules", "dep"), { recursive: true });
-    await mkdir(path.join(workspace, ".git", "objects"), { recursive: true });
-    await mkdir(path.join(workspace, "extra", "sub"), { recursive: true });
-    await writeFile(path.join(workspace, "visible", "file.txt"), "ok", "utf8");
-    await writeFile(path.join(workspace, ".hidden", "file.txt"), "skip", "utf8");
-    await writeFile(path.join(workspace, "node_modules", "dep", "file.txt"), "skip", "utf8");
-    await writeFile(path.join(workspace, ".git", "objects", "file.txt"), "skip", "utf8");
-    await writeFile(path.join(workspace, "extra", "sub", "file.txt"), "ok", "utf8");
-  });
-
-  after(async () => {
-    if (workspace) await rm(workspace, { recursive: true, force: true });
-  });
-
-  test("skips hidden directories and the unconditional dependency dirs", async () => {
-    const { walkDir } = await import("../src/walk");
-    const visited: string[] = [];
-    await walkDir(workspace, 3, (entry) => {
-      visited.push(entry.name);
-    });
-    assert.ok(visited.includes("visible"), "visible dir is visited");
-    assert.ok(visited.includes("extra"), "extra dir is visited");
-    assert.ok(!visited.includes(".hidden"), "hidden dir is skipped");
-    assert.ok(!visited.includes("node_modules"), "node_modules is skipped");
-    assert.ok(!visited.includes(".git"), ".git is skipped");
-  });
-
-  test("honors maxDepth and stops recursing beyond it", async () => {
-    const { walkDir } = await import("../src/walk");
-    const visited: string[] = [];
-    await walkDir(path.join(workspace, "extra"), 0, (entry) => {
-      visited.push(entry.name);
-    });
-    assert.deepEqual(visited, ["sub"], "only depth-0 entries are visited at maxDepth=0");
-  });
-
-  test("isolates a throwing visitor so siblings still get visited", async () => {
-    const { walkDir } = await import("../src/walk");
-    const visited: string[] = [];
-    await walkDir(workspace, 1, (entry) => {
-      if (entry.name === "visible") throw new Error("boom");
-      visited.push(entry.name);
-    });
-    assert.ok(visited.includes("extra"), "sibling dirs are visited even when a peer throws");
-    assert.ok(!visited.includes("file.txt"), "the throwing dir's children are still skipped");
-  });
-
-  test("accepts a caller-supplied skipDirs set", async () => {
-    const { walkDir } = await import("../src/walk");
-    const customSkip = new Set(["extra"]);
-    const visited: string[] = [];
-    await walkDir(workspace, 3, (entry) => {
-      visited.push(entry.name);
-    }, { skipDirs: customSkip });
-    assert.ok(visited.includes("visible"), "non-skipped dir is visited");
-    assert.ok(!visited.includes("extra"), "caller-supplied skipDirs is honored");
-  });
-
-  test("is graceful when baseDir does not exist", async () => {
-    const { walkDir } = await import("../src/walk");
-    const ghost = path.join(workspace, "does-not-exist");
-    let called = false;
-    await walkDir(ghost, 3, () => { called = true; });
-    assert.equal(called, false, "visitor is never invoked for a missing baseDir");
-  });
-});
-
-/**
- * `findSkillsRecursive` was refactored onto `walkDir`. These tests pin
- * the behavior the refactor must preserve: root-first check, depth-bounded
- * descent, sorted output, and graceful handling of missing roots.
- */
-describe("findSkillsRecursive on walkDir (R2)", () => {
-  let workspace: string;
-
-  before(async () => {
-    workspace = await mkdtemp(path.join(tmpdir(), "opencode-agent-skills-md-fsr-"));
-    const root = path.join(workspace, "skills");
-    await mkdir(path.join(root, "alpha"), { recursive: true });
-    await mkdir(path.join(root, "beta", "nested"), { recursive: true });
-    await mkdir(path.join(root, ".hidden-skill"), { recursive: true });
-    await mkdir(path.join(root, "node_modules", "skill"), { recursive: true });
-
-    await writeFile(
-      path.join(root, "alpha", "SKILL.md"),
-      "---\nname: alpha\ndescription: top skill\n---\n# alpha\n",
-      "utf8"
-    );
-    await writeFile(
-      path.join(root, "beta", "SKILL.md"),
-      "---\nname: beta\ndescription: mid skill\n---\n# beta\n",
-      "utf8"
-    );
-    await writeFile(
-      path.join(root, "beta", "nested", "SKILL.md"),
-      "---\nname: beta-nested\ndescription: nested skill\n---\n# beta nested\n",
-      "utf8"
-    );
-    await writeFile(
-      path.join(root, ".hidden-skill", "SKILL.md"),
-      "---\nname: hidden\ndescription: must be skipped\n---\n",
-      "utf8"
-    );
-  });
-
-  after(async () => {
-    if (workspace) await rm(workspace, { recursive: true, force: true });
-  });
-
-  test("discovers SKILL.md at every depth the walker reaches", async () => {
-    const { findSkillsRecursive } = await import("../src/discovery");
-    const results = await findSkillsRecursive(
-      path.join(workspace, "skills"),
-      "project",
-      3
-    );
-    const names = results.map((r) => r.relativePath).sort();
-    assert.deepEqual(
-      names,
-      ["alpha", "beta", "beta/nested"],
-      "alpha, beta, and beta/nested are discovered"
-    );
-  });
-
-  test("skips hidden directories and node_modules", async () => {
-    const { findSkillsRecursive } = await import("../src/discovery");
-    const results = await findSkillsRecursive(
-      path.join(workspace, "skills"),
-      "project",
-      3
-    );
-    const rels = results.map((r) => r.relativePath);
-    assert.ok(!rels.some((r) => r.includes(".hidden-skill")), "hidden dir is skipped");
-    assert.ok(!rels.some((r) => r.includes("node_modules")), "node_modules is skipped");
-  });
-
-  test("returns results sorted by relativePath", async () => {
-    const { findSkillsRecursive } = await import("../src/discovery");
-    const results = await findSkillsRecursive(
-      path.join(workspace, "skills"),
-      "project",
-      3
-    );
-    const rels = results.map((r) => r.relativePath);
-    const sorted = [...rels].sort((a, b) => a.localeCompare(b));
-    assert.deepEqual(rels, sorted, "result order is sorted by relativePath");
-  });
-
-  test("returns [] when baseDir is missing", async () => {
-    const { findSkillsRecursive } = await import("../src/discovery");
-    const results = await findSkillsRecursive(
-      path.join(workspace, "does-not-exist"),
-      "project",
-      3
-    );
-    assert.deepEqual(results, [], "missing baseDir yields no results");
-  });
-});
-
-/**
- * `findScripts` was refactored onto `walkDir` with the script-specific
- * `skipDirs` set. These tests pin the executable-bit filter and the
- * `__pycache__` / `.venv` skip semantics the refactor must preserve.
- */
-describe("findScripts on walkDir (R2)", () => {
-  let workspace: string;
-
-  before(async () => {
-    workspace = await mkdtemp(path.join(tmpdir(), "opencode-agent-skills-md-fs-"));
-    await mkdir(path.join(workspace, "scripts", "bin"), { recursive: true });
-    await mkdir(path.join(workspace, "scripts", "__pycache__"), { recursive: true });
-    await mkdir(path.join(workspace, "scripts", ".venv", "bin"), { recursive: true });
-
-    const exec = path.join(workspace, "scripts", "bin", "run.sh");
-    const plain = path.join(workspace, "scripts", "bin", "README.md");
-    const pyCache = path.join(workspace, "scripts", "__pycache__", "mod.pyc");
-    const venvExec = path.join(workspace, "scripts", ".venv", "bin", "python");
-
-    await writeFile(exec, "#!/bin/sh\necho hi\n", "utf8");
-    await writeFile(plain, "not executable", "utf8");
-    await writeFile(pyCache, "fake bytecode", "utf8");
-    await writeFile(venvExec, "fake venv binary", "utf8");
-
-    await chmod(exec, 0o755);
-    await chmod(pyCache, 0o755);
-    await chmod(venvExec, 0o755);
-  });
-
-  after(async () => {
-    if (workspace) await rm(workspace, { recursive: true, force: true });
-  });
-
-  test("returns only files with the executable bit set", async () => {
-    const { findScripts } = await import("../src/scripts");
-    const scripts = await findScripts(path.join(workspace, "scripts"), 3);
-    const rels = scripts.map((s) => s.relativePath);
-    assert.deepEqual(rels, ["bin/run.sh"], "only the executable file is returned");
-  });
-
-  test("skips __pycache__ and .venv via the caller-supplied skipDirs", async () => {
-    const { findScripts } = await import("../src/scripts");
-    const scripts = await findScripts(path.join(workspace, "scripts"), 3);
-    const rels = scripts.map((s) => s.relativePath);
-    assert.ok(!rels.some((r) => r.includes("__pycache__")), "__pycache__ is skipped");
-    assert.ok(!rels.some((r) => r.includes(".venv")), ".venv is skipped");
-  });
-});
-
-describe("listSkillFiles", () => {
-  let workspace: string;
-
-  before(async () => {
-    workspace = await mkdtemp(path.join(tmpdir(), "opencode-agent-skills-md-lsf-"));
-    const root = path.join(workspace, "skill-dir");
-    await mkdir(path.join(root, "docs"), { recursive: true });
-    await mkdir(path.join(root, ".hidden"), { recursive: true });
-    await mkdir(path.join(root, "node_modules", "some-dep"), { recursive: true });
-    await mkdir(path.join(root, ".git", "objects"), { recursive: true });
-    await mkdir(path.join(root, "nested", "deep"), { recursive: true });
-
-    await writeFile(path.join(root, "SKILL.md"), "# skill\n", "utf8");
-    await writeFile(path.join(root, "docs", "guide.md"), "# guide\n", "utf8");
-    await writeFile(path.join(root, ".hidden", "secret.txt"), "skip\n", "utf8");
-    await writeFile(path.join(root, "node_modules", "some-dep", "index.js"), "skip\n", "utf8");
-    await writeFile(path.join(root, ".git", "objects", "pack.idx"), "skip\n", "utf8");
-    await writeFile(path.join(root, "nested", "deep", "file.txt"), "ok\n", "utf8");
-    await writeFile(path.join(root, "nested", "README.md"), "ok\n", "utf8");
-  });
-
-  after(async () => {
-    if (workspace) await rm(workspace, { recursive: true, force: true });
-  });
-
-  test("returns sorted relative paths for visible files, excluding SKILL.md", async () => {
-    const { listSkillFiles } = await import("../src/discovery");
-    const root = path.join(workspace, "skill-dir");
-    const files = await listSkillFiles(root, 3);
-    assert.deepEqual(files, ["docs/guide.md", "nested/README.md", "nested/deep/file.txt"]);
-  });
-
-  test("skips hidden directories", async () => {
-    const { listSkillFiles } = await import("../src/discovery");
-    const root = path.join(workspace, "skill-dir");
-    const files = await listSkillFiles(root, 3);
-    assert.ok(!files.some((f) => f.includes(".hidden")), "no files from hidden dirs");
-  });
-
-  test("skips node_modules", async () => {
-    const { listSkillFiles } = await import("../src/discovery");
-    const root = path.join(workspace, "skill-dir");
-    const files = await listSkillFiles(root, 3);
-    assert.ok(!files.some((f) => f.includes("node_modules")), "node_modules is skipped");
-  });
-
-  test("skips .git", async () => {
-    const { listSkillFiles } = await import("../src/discovery");
-    const root = path.join(workspace, "skill-dir");
-    const files = await listSkillFiles(root, 3);
-    assert.ok(!files.some((f) => f.includes(".git")), ".git is skipped");
-  });
-
-  test("returns empty array when base directory does not exist", async () => {
-    const { listSkillFiles } = await import("../src/discovery");
-    const ghost = path.join(workspace, "does-not-exist");
-    const files = await listSkillFiles(ghost, 3);
-    assert.deepEqual(files, []);
-  });
-
-  test("honors maxDepth", async () => {
-    const { listSkillFiles } = await import("../src/discovery");
-    const root = path.join(workspace, "skill-dir");
-    const files = await listSkillFiles(root, 1);
-    assert.deepEqual(files, ["docs/guide.md", "nested/README.md"]);
-  });
-});

package/packages/core/tests/package-boundary.test.ts

@@ -1,310 +0,0 @@
-/**
- * Package boundary contract for `opencode-agent-skills-md-core`.
- *
- * This is the new home for the agnostic core engine. It encodes the spec
- * scenarios from `sdd/split-core-opencode-packages/spec`:
- *
- *   1. The core package exposes the public API listed in design.md
- *      (`discoverAllSkills`, `parseSkillFile`, `resolveSkill`, plus the
- *      helpers used by the plugin).
- *   2. Zero files under `packages/core/src/` reference the OpenCode host
- *      SDK (`@opencode-ai/plugin`) anywhere in source text.
- *   3. The package manifest declares the runtime entry as a standalone ESM
- *      module so other harnesses can depend on it without pulling the
- *      OpenCode SDK.
- *
- * The test runs from inside `packages/core/tests/`, so the relative paths
- * use `../src/` to resolve against the package's own sources.
- */
-
-import assert from "node:assert/strict";
-import { readdir, readFile, stat } from "node:fs/promises";
-import { createRequire } from "node:module";
-import * as path from "node:path";
-import { describe, test } from "node:test";
-
-const require = createRequire(import.meta.url);
-const SRC_DIR = path.resolve(import.meta.dirname, "..", "src");
-const PKG_DIR = path.resolve(import.meta.dirname, "..");
-const REPO_ROOT = path.resolve(PKG_DIR, "..", "..");
-
-describe("opencode-agent-skills-md-core package boundary", () => {
-  test("manifest declares an ESM package whose runtime excludes @opencode-ai/plugin", async () => {
-    const pkgPath = path.join(PKG_DIR, "package.json");
-    const raw = await readFile(pkgPath, "utf8");
-    const manifest = JSON.parse(raw) as Record<string, unknown>;
-
-    assert.equal(manifest.name, "opencode-agent-skills-md-core", "package name");
-    assert.equal(manifest.type, "module", "package type must be ESM");
-    assert.equal(
-      manifest.private,
-      true,
-      "package must be private until publishing is wired in a later PR"
-    );
-
-    const dependencies = (manifest.dependencies ?? {}) as Record<string, string>;
-    assert.equal(
-      dependencies["@opencode-ai/plugin"],
-      undefined,
-      "runtime dependencies must not include @opencode-ai/plugin"
-    );
-  });
-
-  test("manifest points its root export at the package's own entry file", async () => {
-    const pkgPath = path.join(PKG_DIR, "package.json");
-    const raw = await readFile(pkgPath, "utf8");
-    const manifest = JSON.parse(raw) as Record<string, unknown>;
-    const exports = manifest.exports as Record<string, unknown> | string | undefined;
-
-    assert.ok(exports && typeof exports === "object", "exports must be an object");
-
-    const rootExport = (exports as Record<string, unknown>)["."];
-    assert.ok(rootExport, "exports['.'] must be defined");
-
-    const importField = (rootExport as Record<string, unknown>).import;
-    assert.ok(
-      typeof importField === "string" && importField.includes("src/index"),
-      `exports['.'].import must point at src/index, got: ${String(importField)}`
-    );
-  });
-
-  test("public API surface matches the design contract", async () => {
-    const core = await import("../src/index.ts");
-
-    const expectedFunctions = [
-      "discoverAllSkills",
-      "parseSkillFile",
-      "resolveSkill",
-      "listSkillFiles",
-      "findScripts",
-      "isPathSafe",
-      "findClosestMatch",
-      "levenshtein",
-      "renderAvailableSkillsBlock",
-      "formatSkillListing",
-      "parseYamlFrontmatter",
-      "escapeRegex",
-      "keywordMatch",
-      "scoreSkill",
-      "searchSkills",
-      "tokenize",
-      "getSkillSummaries",
-      "getDefaultOpencodeRoots",
-      "defaultOnDuplicate",
-      "findSkillsRecursive",
-      "findFile",
-    ] as const;
-
-    for (const name of expectedFunctions) {
-      assert.equal(
-        typeof (core as Record<string, unknown>)[name],
-        "function",
-        `${name} must be exported as a function from the package entrypoint`
-      );
-    }
-  });
-
-  test("zero references to @opencode-ai/plugin in packages/core/src/**", async () => {
-    const violations: Array<{ file: string; line: number; text: string }> = [];
-
-    async function walk(dir: string): Promise<void> {
-      const entries = await readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        const stats = await stat(fullPath);
-        if (stats.isDirectory()) {
-          await walk(fullPath);
-        } else if (stats.isFile() && entry.name.endsWith(".ts")) {
-          const text = await readFile(fullPath, "utf8");
-          const lines = text.split("\n");
-          for (let i = 0; i < lines.length; i++) {
-            const line = lines[i] ?? "";
-            if (line.includes("@opencode-ai/plugin")) {
-              violations.push({ file: fullPath, line: i + 1, text: line.trim() });
-            }
-          }
-        }
-      }
-    }
-
-    await walk(SRC_DIR);
-
-    assert.deepEqual(
-      violations,
-      [],
-      `expected zero references to the host SDK under packages/core/src, found: ${JSON.stringify(violations)}`
-    );
-  });
-
-  test("core sources are isolated from the OpenCode adapter (no imports across the boundary)", async () => {
-    const entries = await readdir(SRC_DIR, { withFileTypes: true });
-    const tsFiles = entries.filter(
-      (e) => e.isFile() && e.name.endsWith(".ts")
-    );
-
-    for (const entry of tsFiles) {
-      const text = await readFile(path.join(SRC_DIR, entry.name), "utf8");
-      assert.doesNotMatch(
-        text,
-        /from\s+["']\.\.\/opencode/,
-        `${entry.name} must not import from the OpenCode adapter`
-      );
-    }
-  });
-
-  test("SkillHostClient is declared in packages/core/src/types.ts and re-exported from the package entrypoint", async () => {
-    // Spec R2 (Boundary Interface Location): `SkillHostClient` SHALL be
-    // declared in the core package. The concrete OpenCode implementation
-    // lives in the plugin package only.
-    const typesSource = await readFile(path.join(SRC_DIR, "types.ts"), "utf8");
-
-    assert.match(
-      typesSource,
-      /export\s+interface\s+SkillHostClient\b/,
-      "SkillHostClient interface must be declared in packages/core/src/types.ts",
-    );
-
-    // The interface must NOT be redeclared elsewhere under packages/core/src/
-    // (a single declaration site is the boundary contract).
-    const redeclarationSites: string[] = [];
-    async function walk(dir: string): Promise<void> {
-      const entries = await readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        const stats = await stat(fullPath);
-        if (stats.isDirectory()) {
-          await walk(fullPath);
-        } else if (stats.isFile() && entry.name.endsWith(".ts")) {
-          const text = await readFile(fullPath, "utf8");
-          if (new RegExp(`(?:export\\s+)?interface\\s+SkillHostClient\\b`).test(text) && fullPath !== path.join(SRC_DIR, "types.ts")) {
-            redeclarationSites.push(fullPath);
-          }
-        }
-      }
-    }
-    await walk(SRC_DIR);
-    assert.deepEqual(
-      redeclarationSites,
-      [],
-      `SkillHostClient must be declared only in types.ts, also found at: ${redeclarationSites.join(", ")}`,
-    );
-
-    // The interface must be reachable as a TypeScript type from the core
-    // entrypoint (this is what the plugin package's host.ts will import).
-    // `export type` is erased at runtime, so we verify by reading the
-    // entrypoint's source text — and by dynamically importing it (a
-    // broken index.ts would throw, so this still catches the failure
-    // mode where the re-export line is malformed).
-    const indexSource = await readFile(path.join(SRC_DIR, "index.ts"), "utf8");
-    assert.match(
-      indexSource,
-      /\bSkillHostClient\b/,
-      "SkillHostClient must be re-exported from packages/core/src/index.ts",
-    );
-    const core = (await import("../src/index.ts")) as unknown as Record<string, unknown>;
-    // Type-only export: not a runtime value, but the import must not throw.
-    assert.equal(core.SkillHostClient, undefined, "SkillHostClient is a TypeScript type, not a runtime value");
-  });
-
-  test("SkillHostSession is declared in packages/core/src/types.ts and re-exported from the package entrypoint", async () => {
-    // Spec R2 (Boundary Interface Location): `SkillHostSession` SHALL be
-    // declared in the core package. The plugin package implements the
-    // session factory but does NOT redeclare the interface.
-    const typesSource = await readFile(path.join(SRC_DIR, "types.ts"), "utf8");
-
-    assert.match(
-      typesSource,
-      /export\s+interface\s+SkillHostSession\b/,
-      "SkillHostSession interface must be declared in packages/core/src/types.ts",
-    );
-
-    // And reachable as a TypeScript type from the core entrypoint.
-    const indexSource = await readFile(path.join(SRC_DIR, "index.ts"), "utf8");
-    assert.match(
-      indexSource,
-      /\bSkillHostSession\b/,
-      "SkillHostSession must be re-exported from packages/core/src/index.ts",
-    );
-    const core = (await import("../src/index.ts")) as unknown as Record<string, unknown>;
-    assert.equal(core.SkillHostSession, undefined, "SkillHostSession is a TypeScript type, not a runtime value");
-  });
-
-  test("SkillHostContext is declared in packages/core/src/types.ts and re-exported from the package entrypoint", async () => {
-    // The minimum shared context type needed to express `SkillHostClient`
-    // cleanly in core. Without it, the boundary interface would have to
-    // reach into the plugin package for its parameter type, defeating
-    // the boundary. The spec calls this out implicitly via R2.
-    const typesSource = await readFile(path.join(SRC_DIR, "types.ts"), "utf8");
-
-    assert.match(
-      typesSource,
-      /export\s+interface\s+SkillHostContext\b/,
-      "SkillHostContext interface must be declared in packages/core/src/types.ts",
-    );
-
-    const indexSource = await readFile(path.join(SRC_DIR, "index.ts"), "utf8");
-    assert.match(
-      indexSource,
-      /\bSkillHostContext\b/,
-      "SkillHostContext must be re-exported from packages/core/src/index.ts",
-    );
-    const core = (await import("../src/index.ts")) as unknown as Record<string, unknown>;
-    assert.equal(core.SkillHostContext, undefined, "SkillHostContext is a TypeScript type, not a runtime value");
-  });
-
-  test("SkillHostClient declares the four boundary methods the core expects from any host", async () => {
-    // Triangulation: beyond proving the NAME exists, the structural shape
-    // of the boundary contract matters — the plugin's `createOpencodeSkillHost`
-    // returns an object that must be assignable to this interface. A name
-    // check alone would let an empty interface slip through.
-    const typesSource = await readFile(path.join(SRC_DIR, "types.ts"), "utf8");
-
-    // Slice the `SkillHostClient` interface body so the method-name checks
-    // stay scoped to the interface (avoids false positives from comments or
-    // other interfaces that happen to mention these names).
-    const interfaceBody = typesSource.match(
-      /export\s+interface\s+SkillHostClient\s*\{([\s\S]*?)\n\}/,
-    );
-    assert.ok(
-      interfaceBody,
-      "SkillHostClient must be an `export interface` block in packages/core/src/types.ts",
-    );
-
-    const body = interfaceBody![1]!;
-    for (const methodName of ["injectContent", "getSessionContext", "readFile", "readdir"]) {
-      assert.match(
-        body,
-        new RegExp(`\\b${methodName}\\s*\\(`),
-        `SkillHostClient must declare method ${methodName} (the core relies on it)`,
-      );
-    }
-
-    // The interface must NOT be a type alias (`type X = ...`). Spec R2
-    // calls these "interfaces" and the plugin-side adapter may extend them
-    // structurally; a type alias would still satisfy the name check but
-    // break the design intent.
-    assert.doesNotMatch(
-      typesSource,
-      /export\s+type\s+SkillHostClient\b/,
-      "SkillHostClient must be declared as `interface`, not `type`",
-    );
-  });
-
-  test("package resolves through the workspace link as opencode-agent-skills-md-core", async () => {
-    // The root workspace symlinks packages/core into node_modules so the
-    // package can be resolved by name from the repo root after pnpm install.
-    const resolved = require.resolve("opencode-agent-skills-md-core");
-
-    assert.match(
-      resolved,
-      /[\\/]packages[\\/]core[\\/]src[\\/]index\.ts$/,
-      `expected opencode-agent-skills-md-core to resolve to packages/core/src/index.ts, got: ${resolved}`
-    );
-
-    // Sanity check: the resolved file lives inside the repo (no stale cache).
-    assert.ok(
-      resolved.startsWith(REPO_ROOT),
-      `resolved path must live under the repo root: ${resolved}`
-    );
-  });
-});