@stigmer/plugin-package 3.34.0 → 3.36.0

package/src/__tests__/client-prepare.test.ts

@@ -1,163 +0,0 @@
-/**
- * The one preparation, reached three ways, and the small rules beside it.
- *
- * Pins: `preparePluginFromTree` over a lazily-read tree yields the CLI's
- * recorded digest for the thermos fixture (the tripwire constant lives in
- * `client-select-archive.test.ts`); it reads only the ignore files and the
- * selected entries, never an ignored file's bytes; an over-cap selection is
- * refused before any selected byte is read; a reader refusal is returned
- * with the reader's findings. `isReleaseVersion`'s five cases, the two
- * wrong answers the console and the CLI used to give among them.
- * `rerootSingleDirectory` on the shapes a zip takes. The built-in sources'
- * order, their reserved names, and that the official one is first.
- */
-
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-import { describe, expect, it } from "vitest";
-
-import { BUILT_IN_MARKETPLACES, isBuiltInMarketplaceName } from "../client/builtin.js";
-import { type LazyCandidate, preparePluginFromTree } from "../client/prepare.js";
-import { OFFICIAL_MARKETPLACE_NAME } from "../client/refs.js";
-import { isReleaseVersion } from "../client/release.js";
-import { rerootSingleDirectory, stripDirectoryPrefix } from "../client/reroot.js";
-
-const FIXTURES = fileURLToPath(new URL("./fixtures/cursor-plugins/", import.meta.url));
-/** The CLI's digest for the thermos fixture, recorded in client-select-archive.test.ts. */
-const THERMOS_DIGEST = "51bc4e5450e24762bb8515765c76bfe262f65c57f9afeda015c5818038396d5a";
-
-const encoder = new TextEncoder();
-const SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
-
-function manifest(name: string): string {
-  return JSON.stringify({ $schema: SCHEMA, name, version: "1.0.0", description: `the ${name} plugin` });
-}
-
-/** A directory as a lazily-read tree, recording which paths were read. */
-function lazyDirectory(root: string): { candidates: LazyCandidate[]; reads: string[] } {
-  const reads: string[] = [];
-  const candidates: LazyCandidate[] = [];
-  const walk = (dir: string, prefix: string): void => {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const path = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
-      const full = `${dir}/${entry.name}`;
-      if (entry.isDirectory()) walk(full, path);
-      else if (entry.isFile()) {
-        candidates.push({
-          path,
-          size: statSync(full).size,
-          read: async () => {
-            reads.push(path);
-            return new Uint8Array(readFileSync(full));
-          },
-        });
-      }
-    }
-  };
-  walk(root, "");
-  return { candidates, reads };
-}
-
-function lazyMemory(files: Record<string, string>): { candidates: LazyCandidate[]; reads: string[] } {
-  const reads: string[] = [];
-  const candidates = Object.entries(files).map(([path, text]) => {
-    const bytes = encoder.encode(text);
-    return {
-      path,
-      size: bytes.length,
-      read: async () => {
-        reads.push(path);
-        return bytes;
-      },
-    };
-  });
-  return { candidates, reads };
-}
-
-describe("preparePluginFromTree", () => {
-  it("yields the CLI's digest for the thermos fixture from a lazily-read tree", async () => {
-    const { candidates } = lazyDirectory(`${FIXTURES}thermos`);
-    const outcome = await preparePluginFromTree(candidates, { respectGitignore: true });
-    expect(outcome.ok).toBe(true);
-    if (!outcome.ok) return;
-    expect(outcome.prepared.digest).toBe(THERMOS_DIGEST);
-    expect(outcome.prepared.plugin.name).toBe("thermos");
-    expect(outcome.prepared.stats.filesIncluded).toBe(10);
-  });
-
-  it("reads the ignore file and the selected entries only, never an ignored file's bytes", async () => {
-    const tree = lazyMemory({
-      ".gitignore": "secrets.txt\n",
-      "plugin.json": manifest("quiet"),
-      "node_modules/left-pad/index.js": "module.exports = 1;",
-      "secrets.txt": "hunter2",
-      "skills/greet/SKILL.md": "---\nname: greet\ndescription: says hello\n---\nHello.",
-    });
-    const outcome = await preparePluginFromTree(tree.candidates, { respectGitignore: true });
-    expect(outcome.ok).toBe(true);
-    expect(tree.reads.sort()).toEqual([".gitignore", "plugin.json", "skills/greet/SKILL.md"]);
-  });
-
-  it("refuses an over-cap selection before a selected byte is read", async () => {
-    const tree = lazyMemory({
-      "plugin.json": manifest("heavy"),
-      "skills/big/SKILL.md": "x".repeat(2_000),
-    });
-    const outcome = await preparePluginFromTree(tree.candidates, { respectGitignore: true, maxBytes: 1_000 });
-    expect(outcome).toMatchObject({ ok: false, kind: "too-large", maxBytes: 1_000 });
-    if (outcome.ok || outcome.kind !== "too-large") return;
-    expect(outcome.selectedBytes).toBeGreaterThan(1_000);
-    expect(tree.reads).toEqual([]);
-  });
-
-  it("returns the reader's refusal with its findings when the tree is not a plugin", async () => {
-    const tree = lazyMemory({ "README.md": "not a plugin" });
-    const outcome = await preparePluginFromTree(tree.candidates, { respectGitignore: true });
-    expect(outcome.ok).toBe(false);
-    if (outcome.ok || outcome.kind !== "refused") throw new Error("expected the reader's refusal");
-    expect(outcome.errors.length).toBeGreaterThan(0);
-  });
-});
-
-describe("isReleaseVersion", () => {
-  it("accepts a release and a pre-release the lockstep publish covers", () => {
-    expect(isReleaseVersion("3.17.0")).toBe(true);
-    // The console used to call this a development build.
-    expect(isReleaseVersion("3.17.0-rc.1")).toBe(true);
-  });
-
-  it("refuses every shape a source or dev-channel build reports", () => {
-    // The CLI used to accept the bare stamp an unbundled server reports.
-    expect(isReleaseVersion("dev")).toBe(false);
-    expect(isReleaseVersion("0.0.0-dev")).toBe(false);
-    expect(isReleaseVersion("3.17.0-dev.20260918120000")).toBe(false);
-    expect(isReleaseVersion("3.17.0+build.5")).toBe(false);
-    expect(isReleaseVersion("")).toBe(false);
-  });
-});
-
-describe("rerootSingleDirectory", () => {
-  it("names the one directory every path is under", () => {
-    const paths = ["my-plugin/plugin.json", "my-plugin/skills/a/SKILL.md", "my-plugin/.gitignore"];
-    expect(rerootSingleDirectory(paths)).toBe("my-plugin");
-    expect(stripDirectoryPrefix(paths, "my-plugin")).toEqual(["plugin.json", "skills/a/SKILL.md", ".gitignore"]);
-  });
-
-  it("leaves a tree that is already rooted, or has two roots, alone", () => {
-    expect(rerootSingleDirectory(["plugin.json", "skills/a/SKILL.md"])).toBeNull();
-    expect(rerootSingleDirectory(["a/plugin.json", "b/plugin.json"])).toBeNull();
-    expect(rerootSingleDirectory(["a/plugin.json", "README.md"])).toBeNull();
-    expect(rerootSingleDirectory([])).toBeNull();
-  });
-});
-
-describe("BUILT_IN_MARKETPLACES", () => {
-  it("lists the official catalogue alone, a reserved name; a vendor's repository is a source the user adds", () => {
-    expect(BUILT_IN_MARKETPLACES.map((entry) => entry.name)).toEqual([OFFICIAL_MARKETPLACE_NAME]);
-    expect(BUILT_IN_MARKETPLACES[0]?.source).toEqual({ type: "official" });
-    for (const entry of BUILT_IN_MARKETPLACES) expect(isBuiltInMarketplaceName(entry.name)).toBe(true);
-    expect(isBuiltInMarketplaceName("cursor-plugins")).toBe(false);
-    expect(isBuiltInMarketplaceName("acme-plugins")).toBe(false);
-  });
-});

package/src/__tests__/client-refs.test.ts

@@ -1,101 +0,0 @@
-/**
- * The two grammars every client parses: an install ref and a GitHub
- * marketplace source. Pins the splits (`/` then `@`), the path refusal that
- * gets its own kind so a client can name its folder command, the URL forms
- * that normalise to `owner/repo[@ref]`, and that a refusal is returned with
- * a sentence rather than thrown.
- */
-
-import { describe, expect, it } from "vitest";
-
-import {
-  describeGitHubSource,
-  formatInstallRef,
-  isOwnerRepo,
-  looksLikePath,
-  parseGitHubSource,
-  parseInstallRef,
-} from "../client/refs.js";
-
-describe("parseInstallRef", () => {
-  it("a bare name", () => {
-    expect(parseInstallRef("thermos")).toEqual({ ok: true, ref: { name: "thermos" } });
-  });
-
-  it("marketplace/name@version", () => {
-    expect(parseInstallRef("cursor-plugins/thermos@1.0.0")).toEqual({
-      ok: true,
-      ref: { marketplace: "cursor-plugins", name: "thermos", version: "1.0.0" },
-    });
-  });
-
-  it("refuses a path with its own kind", () => {
-    for (const text of ["./thermos", "../x", ".", "..", "/tmp/x", "~/x", "C:\\x", "a\\b"]) {
-      const outcome = parseInstallRef(text);
-      expect(outcome.ok).toBe(false);
-      if (!outcome.ok) expect(outcome.kind).toBe("path");
-    }
-  });
-
-  it("refuses a bad marketplace name, version and plugin name with the shape kind", () => {
-    const bad = ["Upper/thermos", "thermos@", "thermos@1.0!", "Thermos", "a/b/c"];
-    for (const text of bad) {
-      const outcome = parseInstallRef(text);
-      expect(outcome.ok).toBe(false);
-      if (!outcome.ok) expect(outcome.kind).toBe("shape");
-    }
-  });
-
-  it("formatInstallRef is the inverse", () => {
-    const outcome = parseInstallRef("m/n@v");
-    if (!outcome.ok) throw new Error("expected ok");
-    expect(formatInstallRef(outcome.ref)).toBe("m/n@v");
-    expect(formatInstallRef({ name: "n" })).toBe("n");
-  });
-});
-
-describe("parseGitHubSource", () => {
-  it("owner/repo and owner/repo@ref", () => {
-    expect(parseGitHubSource("cursor/plugins")).toEqual({ ok: true, source: { type: "github", repo: "cursor/plugins" } });
-    expect(parseGitHubSource("cursor/plugins@main")).toEqual({
-      ok: true,
-      source: { type: "github", repo: "cursor/plugins", ref: "main" },
-    });
-  });
-
-  it("the browser's URL, with and without /tree/<ref> and .git", () => {
-    for (const text of ["https://github.com/cursor/plugins", "https://www.github.com/cursor/plugins.git", "http://github.com/cursor/plugins/"]) {
-      expect(parseGitHubSource(text)).toEqual({ ok: true, source: { type: "github", repo: "cursor/plugins" } });
-    }
-    expect(parseGitHubSource("https://github.com/cursor/plugins/tree/v1.2")).toEqual({
-      ok: true,
-      source: { type: "github", repo: "cursor/plugins", ref: "v1.2" },
-    });
-  });
-
-  it("refuses what is not a repository", () => {
-    for (const text of ["cursor", "cursor/plugins@", "a/b/c", "https://gitlab.com/a/b", "../x"]) {
-      expect(parseGitHubSource(text).ok).toBe(false);
-    }
-  });
-
-  it("describes a source in one phrase", () => {
-    expect(describeGitHubSource({ type: "github", repo: "a/b" })).toBe("github.com/a/b");
-    expect(describeGitHubSource({ type: "github", repo: "a/b", ref: "r" })).toBe("github.com/a/b@r");
-  });
-});
-
-describe("isOwnerRepo and looksLikePath", () => {
-  it("two segments of GitHub's character set", () => {
-    expect(isOwnerRepo("a/b")).toBe(true);
-    expect(isOwnerRepo("a.b/c-d_e")).toBe(true);
-    expect(isOwnerRepo("./b")).toBe(false);
-    expect(isOwnerRepo("a/../b")).toBe(false);
-    expect(isOwnerRepo("-a/b")).toBe(false);
-  });
-
-  it("a path on any platform", () => {
-    expect(looksLikePath("D:\\plugins")).toBe(true);
-    expect(looksLikePath("thermos")).toBe(false);
-  });
-});

package/src/__tests__/client-select-archive.test.ts

@@ -1,150 +0,0 @@
-/**
- * The client entry's identity discipline: the same tree selected and
- * archived from a directory (the CLI's edge) and from a flat in-memory file
- * list (the console's edge) yields one digest, and that digest is the one
- * the CLI produced before this module existed.
- *
- * The frozen constant below was computed with the unmodified CLI at
- * `d75b0724a` (`preparePluginPush` over the vendored `thermos` fixture,
- * whose bytes never change). If it changes, every installed plugin would
- * look like an upgrade; this test is the tripwire. The catalogue's own
- * `plugins/linear` is read too, but its content is allowed to evolve (a
- * manifest edit is an upgrade by design), so its cases pin the identity
- * discipline (the directory edge and the in-memory edge agree on one
- * digest, and the selection is exactly its files) rather than a constant.
- *
- * The selection cases pin the walk order (component-wise, directories and
- * files interleaved by name), the whole-subtree skip of an ignored
- * directory, the root `.gitignore` and `.stigmerignore`, and that a
- * negation inside a skipped directory cannot pull a file back.
- */
-
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-import { describe, expect, it } from "vitest";
-
-import { archivePlugin, digestArchive } from "../client/archive.js";
-import { type CandidateFile, compareWalkOrder, selectPluginFiles } from "../client/select.js";
-
-const FIXTURES = fileURLToPath(new URL("./fixtures/cursor-plugins/", import.meta.url));
-const REPO_PLUGINS = fileURLToPath(new URL("../../../../../../plugins/", import.meta.url));
-
-const BASELINE = {
-  thermos: "51bc4e5450e24762bb8515765c76bfe262f65c57f9afeda015c5818038396d5a",
-} as const;
-
-const encoder = new TextEncoder();
-
-/** Every file under `root`, unordered, the shape a hosted tree listing has. */
-function listDirectory(root: string): { candidates: CandidateFile[]; read: (path: string) => Uint8Array } {
-  const candidates: CandidateFile[] = [];
-  const walk = (dir: string, prefix: string): void => {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const path = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
-      const full = `${dir}/${entry.name}`;
-      if (entry.isDirectory()) walk(full, path);
-      else if (entry.isFile()) candidates.push({ path, size: statSync(full).size });
-    }
-  };
-  walk(root, "");
-  // Reverse so the test proves selection imposes the order, not the listing.
-  candidates.reverse();
-  return { candidates, read: (path) => new Uint8Array(readFileSync(`${root}/${path}`)) };
-}
-
-function inMemory(files: Record<string, string>): { candidates: CandidateFile[]; read: (path: string) => Uint8Array } {
-  const bytes = new Map(Object.entries(files).map(([path, text]) => [path, encoder.encode(text)]));
-  return {
-    candidates: [...bytes].map(([path, content]) => ({ path, size: content.length })),
-    read: (path) => {
-      const content = bytes.get(path);
-      if (content === undefined) throw new Error(`unlisted ${path}`);
-      return content;
-    },
-  };
-}
-
-const RESPECT = { respectGitignore: true };
-
-describe("parity with the CLI's original walk", () => {
-  it("plugins/linear selects exactly its files, in walk order", () => {
-    const { candidates, read } = listDirectory(`${REPO_PLUGINS}linear`);
-    const selection = selectPluginFiles(candidates, read, RESPECT);
-    expect(selection.files.entries.map((entry) => entry.path)).toEqual(["mcp.json", "plugin.json"]);
-  });
-
-  it("the thermos fixture archives to the CLI's digest", async () => {
-    const { candidates, read } = listDirectory(`${FIXTURES}thermos`);
-    const selection = selectPluginFiles(candidates, read, RESPECT);
-    expect(selection.stats.filesIncluded).toBe(10);
-    expect(await digestArchive(archivePlugin(selection.files))).toBe(BASELINE.thermos);
-  });
-
-  it("the same bytes from a directory and from an in-memory listing yield one digest", async () => {
-    const dir = listDirectory(`${REPO_PLUGINS}linear`);
-    const fromDirectory = await digestArchive(archivePlugin(selectPluginFiles(dir.candidates, dir.read, RESPECT).files));
-    const memory = inMemory(
-      Object.fromEntries(dir.candidates.map((c) => [c.path, new TextDecoder().decode(dir.read(c.path))])),
-    );
-    const fromMemory = await digestArchive(archivePlugin(selectPluginFiles(memory.candidates, memory.read, RESPECT).files));
-    expect(fromMemory).toBe(fromDirectory);
-    expect(fromDirectory).toMatch(/^[0-9a-f]{64}$/);
-  });
-});
-
-describe("compareWalkOrder", () => {
-  it("visits a directory before a file that sorts after it by name", () => {
-    // A code-point sort of full paths would put "b.txt" before "b/x.txt"
-    // ('.' < '/'); the walk visits the directory `b` first.
-    expect(["b.txt", "b/x.txt", "a.txt"].sort(compareWalkOrder)).toEqual(["a.txt", "b/x.txt", "b.txt"]);
-  });
-
-  it("orders siblings by code point, the CLI's comparison", () => {
-    expect(["B.md", "a.md", "_x.md"].sort(compareWalkOrder)).toEqual(["B.md", "_x.md", "a.md"]);
-  });
-});
-
-describe("selectPluginFiles", () => {
-  it("skips an ignored directory whole, and a negation inside it cannot pull a file back", () => {
-    const { candidates, read } = inMemory({
-      "plugin.json": "{}",
-      ".gitignore": "build/\n!build/keep.txt\n",
-      "build/keep.txt": "x",
-      "build/out.js": "y",
-      "src/a.ts": "z",
-    });
-    const selection = selectPluginFiles(candidates, read, RESPECT);
-    expect(selection.files.entries.map((e) => e.path)).toEqual([".gitignore", "plugin.json", "src/a.ts"]);
-    expect(selection.stats).toEqual({ filesIncluded: 3, filesIgnored: 0, dirsSkipped: 1, totalSize: 26 });
-  });
-
-  it("applies the security defaults and lets .env.example through", () => {
-    const { candidates, read } = inMemory({ "plugin.json": "{}", ".env": "S=1", ".env.example": "S=" });
-    const selection = selectPluginFiles(candidates, read, RESPECT);
-    expect(selection.files.entries.map((e) => e.path)).toEqual([".env.example", "plugin.json"]);
-    expect(selection.stats.filesIgnored).toBe(1);
-  });
-
-  it("ignores .gitignore when told to, and always reads .stigmerignore", () => {
-    const files = { "plugin.json": "{}", ".gitignore": "*.draft\n", ".stigmerignore": "*.tmp\n", "a.draft": "", "b.tmp": "" };
-    const loose = selectPluginFiles(inMemory(files).candidates, inMemory(files).read, { respectGitignore: false });
-    expect(loose.files.entries.map((e) => e.path)).toContain("a.draft");
-    expect(loose.files.entries.map((e) => e.path)).not.toContain("b.tmp");
-    const strict = selectPluginFiles(inMemory(files).candidates, inMemory(files).read, RESPECT);
-    expect(strict.files.entries.map((e) => e.path)).not.toContain("a.draft");
-  });
-
-  it("the selected reader refuses a path it did not list", () => {
-    const { candidates, read } = inMemory({ "plugin.json": "{}" });
-    const selection = selectPluginFiles(candidates, read, RESPECT);
-    expect(() => selection.files.read("missing.md")).toThrow("plugin file 'missing.md' is not listed");
-  });
-});
-
-describe("digestArchive", () => {
-  it("is lowercase hex SHA-256", async () => {
-    const digest = await digestArchive(new Uint8Array([1, 2, 3]));
-    expect(digest).toBe("039058c6f2c0cb492c533b0a4d14ef77cc0f78abccced5287d84a1a2011cfb81");
-  });
-});

package/src/__tests__/detect.test.ts

@@ -1,144 +0,0 @@
-/**
- * Pins manifest detection and identity: the root manifest wins, the vendor
- * precedence without one, every present manifest contributes, name rules
- * and conflicts, the open manifest's `$schema` arms, and unknown fields as
- * warnings in every dialect.
- */
-
-import { describe, expect, it } from "vitest";
-
-import { isValidPluginName } from "../detect.js";
-import { claudePlugin, codexPlugin, cursorPlugin, openPlugin, withManifestField } from "../testing.js";
-import { accepted, findingOf, kindsOf, read, refused } from "../__test-utils__/read.js";
-
-describe("identity and precedence", () => {
-  it("takes identity from the root manifest and lists it first", () => {
-    const files = openPlugin({ name: "tools", version: "1.2.0", description: "d", manifest: { license: "MIT", keywords: ["a"] } });
-    const plugin = accepted(read(files));
-    expect(plugin).toMatchObject({ name: "tools", version: "1.2.0", description: "d", license: "MIT", keywords: ["a"], dialect: "agent-plugins" });
-    expect(plugin.manifestsFound).toEqual(["plugin.json"]);
-  });
-
-  it("without a root manifest, Claude precedes Cursor precedes Codex", () => {
-    const both = new Map([...cursorPlugin({ name: "same" }), ...claudePlugin({ name: "same" })]);
-    expect(accepted(read(both))).toMatchObject({ dialect: "claude", manifestsFound: [".claude-plugin/plugin.json", ".cursor-plugin/plugin.json"] });
-    const cursorAndCodex = new Map([...codexPlugin({ name: "same" }), ...cursorPlugin({ name: "same" })]);
-    expect(accepted(read(cursorAndCodex)).dialect).toBe("cursor");
-    expect(accepted(read(codexPlugin({ name: "same" }))).dialect).toBe("codex");
-  });
-
-  it("a root manifest beside a vendor manifest keeps the root identity and reads the vendor's declarations", () => {
-    // With a root manifest present, `mcp.json` is the open format's fixed
-    // location and is read under its rules; the Cursor manifest contributes
-    // what the open format cannot say (the variables declaration).
-    const files = new Map([
-      ...openPlugin({ name: "dual", version: "2.0.0", mcpServers: { s: { type: "streamable-http", url: "https://example.com/mcp", headers: { Authorization: "Bearer ${TOKEN}" } } } }),
-      ...cursorPlugin({ name: "dual", version: "9.9.9", variables: { TOKEN: { type: "string" } } }),
-    ]);
-    const plugin = accepted(read(files));
-    expect(plugin.version).toBe("2.0.0");
-    expect(plugin.dialect).toBe("agent-plugins");
-    expect(plugin.variables.map((v) => v.name)).toEqual(["TOKEN"]);
-    expect(plugin.mcpServers.map((s) => s.name)).toEqual(["s"]);
-  });
-
-  it("a Cursor-shaped mcp.json beside a root manifest is refused under the open format's rules", () => {
-    const files = new Map([
-      ...openPlugin({ name: "dual" }),
-      ...cursorPlugin({ name: "dual", mcpServers: { s: { type: "http", url: "https://example.com/mcp" } } }),
-    ]);
-    expect(kindsOf(read(files)).errors).toEqual(["mcp-config-schema-missing", "mcp-server-type-unknown"]);
-  });
-
-  it("refuses manifests that disagree on the name", () => {
-    const files = new Map([...openPlugin({ name: "one" }), ...cursorPlugin({ name: "two" })]);
-    const finding = findingOf(refused(read(files)), "manifest-name-conflict");
-    expect(finding.message).toBe("manifests disagree on the plugin name: 'one' in 'plugin.json' versus 'two' in '.cursor-plugin/plugin.json'");
-  });
-
-  it("refuses a directory with no manifest and names the four locations", () => {
-    const finding = findingOf(refused(read(new Map([["README.md", "hi"]]))), "no-manifest");
-    expect(finding.message).toContain("'plugin.json', '.claude-plugin/plugin.json', '.cursor-plugin/plugin.json', '.codex-plugin/plugin.json'");
-  });
-});
-
-describe("the plugin name rule", () => {
-  it("accepts the open format's valid names and refuses its invalid ones", () => {
-    for (const name of ["my-plugin", "acme.tools", "lint3r", "a"]) expect(isValidPluginName(name), name).toBe(true);
-    for (const name of ["My-Plugin", "-start", "has--double", "too.many..dots", "", "a".repeat(65), "end-"]) {
-      expect(isValidPluginName(name), name).toBe(false);
-    }
-  });
-
-  it("refuses an invalid name with the rule spelled out", () => {
-    const finding = findingOf(refused(read(cursorPlugin({ name: "Bad Name" }))), "manifest-name-invalid");
-    expect(finding.message).toContain("'Bad Name' in '.cursor-plugin/plugin.json' is invalid");
-  });
-
-  it("refuses a missing name once, naming the manifest", () => {
-    const files = withManifestField(claudePlugin(), ".claude-plugin/plugin.json", "name", undefined);
-    expect(kindsOf(read(files)).errors).toEqual(["manifest-name-missing"]);
-  });
-});
-
-describe("the open manifest's schema", () => {
-  it("refuses a missing and an unsupported $schema, each with its own sentence", () => {
-    expect(kindsOf(read(openPlugin({ schema: null }))).errors).toEqual(["manifest-schema-missing"]);
-    const unsupported = findingOf(refused(read(openPlugin({ schema: "https://agent-plugins.org/schemas/2.0.0/plugin.schema.json" }))), "manifest-schema-unsupported");
-    expect(unsupported.message).toContain("2.0.0");
-  });
-
-  it("reports an unreadable manifest once and does not also blame its missing name", () => {
-    const files = new Map([["plugin.json", "{ not json"]]);
-    expect(kindsOf(read(files)).errors).toEqual(["manifest-unreadable"]);
-  });
-
-  it("decodes a manifest saved with a byte-order mark", () => {
-    const files = openPlugin();
-    const text = files.get("plugin.json") as string;
-    files.set("plugin.json", `\ufeff${text}`);
-    expect(accepted(read(files)).name).toBe("example");
-  });
-});
-
-describe("unknown and mistyped fields", () => {
-  it("warns on an unknown top-level field in every dialect", () => {
-    expect(kindsOf(read(openPlugin({ manifest: { colour: "blue" } }))).warnings).toEqual(["manifest-field-unknown"]);
-    expect(kindsOf(read(claudePlugin({ manifest: { colour: "blue" } }))).warnings).toEqual(["manifest-field-unknown"]);
-    expect(kindsOf(read(cursorPlugin({ manifest: { colour: "blue" } }))).warnings).toEqual(["manifest-field-unknown"]);
-    expect(kindsOf(read(codexPlugin({ manifest: { colour: "blue" } }))).warnings).toEqual(["manifest-field-unknown"]);
-  });
-
-  it("does not warn on a dialect's own metadata fields", () => {
-    const cursor = cursorPlugin({ manifest: { displayName: "X", publisher: "Acme", category: "c", tags: ["t"], author: { name: "a", email: "a@b.c" } } });
-    expect(kindsOf(read(cursor))).toEqual({ errors: [], warnings: [] });
-    const codex = codexPlugin({ manifest: { interface: { displayName: "X" } } });
-    expect(kindsOf(read(codex))).toEqual({ errors: [], warnings: [] });
-  });
-
-  it("refuses a known field of the wrong type, naming the field", () => {
-    const finding = findingOf(refused(read(openPlugin({ manifest: { keywords: "not-an-array" } }))), "manifest-field-type");
-    expect(finding).toMatchObject({ path: "plugin.json", subject: "keywords" });
-  });
-
-  it("records a non-empty extension namespace as ignored and an empty ai.stigmer namespace as nothing", () => {
-    const plugin = accepted(read(openPlugin({ manifest: { extensions: { "com.openai": { apps: "./.app.json" }, "ai.stigmer": {} } } })));
-    expect(plugin.ignored).toEqual([{ kind: "extension", path: "plugin.json#extensions.com.openai" }]);
-  });
-
-  it("reads ai.stigmer's appearance fields the way Cursor's are read: the logo an ignored component, the rest silent", () => {
-    const plugin = accepted(read(openPlugin({ manifest: { extensions: { "ai.stigmer": { displayName: "Linear", logo: "assets/logo.png", category: "integrations" } } } })));
-    expect(plugin.ignored).toEqual([{ kind: "logo", path: "plugin.json#extensions.ai.stigmer.logo" }]);
-    expect(kindsOf(read(openPlugin({ manifest: { extensions: { "ai.stigmer": { displayName: "Linear" } } } })))).toEqual({ errors: [], warnings: [] });
-  });
-
-  it("a field ai.stigmer does not define makes the namespace an ignored extension, so a misspelling stays visible", () => {
-    const plugin = accepted(read(openPlugin({ manifest: { extensions: { "ai.stigmer": { displayname: "Linear" } } } })));
-    expect(plugin.ignored).toEqual([{ kind: "extension", path: "plugin.json#extensions.ai.stigmer" }]);
-  });
-
-  it("warns on a non-object extensions field and keeps reading", () => {
-    const outcome = read(openPlugin({ manifest: { extensions: "nope" } }));
-    expect(kindsOf(outcome)).toEqual({ errors: [], warnings: ["manifest-extensions-invalid"] });
-  });
-});