create-ailk 0.24.0 → 0.25.1

package/templates/apps/mcp/__tests__/list_pages.test.ts

@@ -1,268 +0,0 @@
-/**
- * Tests for the list_pages MCP tool handler.
- *
- * Acceptance criteria verified here:
- * - contentListParamsSchema requires `type` and rejects unknown type values
- * - contentListQuerySchema takes an optional `page` / `pageSize` window
- * - ailkListPages returns the route's paginated ItemList for a type
- * - ailkListPages defaults the window to page 1 / pageSize 20 and clamps
- *   pageSize to 100, as the route does
- * - Output validates against contentListResultSchema
- * - No console.* calls in handler (structural test)
- *
- * #7168 (the operator's decision of 2026-10-19): the tool adopted its route's
- * arguments (`type` required, `page`/`pageSize`) and result (the paginated
- * `ItemList`, not `{ pages }`); the all-types fan-out is gone with the
- * optional `type`.
- */
-
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { resolve, join } from "node:path";
-
-import {
-  resetResolvedContentAdapter,
-  type ArtifactPrismaClient,
-} from "@working-theory/content-adapters";
-
-import {
-  ailkListPages,
-  contentListParamsSchema,
-  contentListQuerySchema,
-  contentListResultSchema,
-} from "../src/tools/list_pages.js";
-import {
-  __setMcpPublicWorkspaceForTest,
-  resetMcpPublicWorkspace,
-} from "../src/lib/public-workspace.js";
-
-// Content root for real-filesystem tests — repo-relative
-const REPO_ROOT = resolve(__dirname, "../../..");
-const CONTENT_ROOT = join(REPO_ROOT, "content");
-const WORKSPACE_ID = "wksp_00000000-0000-7000-8000-000000000001";
-
-/**
- * A structural `ArtifactPrismaClient` stub (#5876 spec D11) — a published
- * HomePage plus a draft-only HomePage that must never surface (AC-1's
- * published-only half is a reach test — the invariant is the adapter's).
- */
-function makeArtifactPrismaClientStub(): ArtifactPrismaClient {
-  return {
-    artifact: {
-      findFirst: jest.fn(),
-      findMany: jest.fn().mockResolvedValue([
-        {
-          id: "artifact_published",
-          workspaceId: WORKSPACE_ID,
-          contentType: "text/page",
-          locale: "en",
-          slug: "home",
-          title: "Home",
-          publishedVersionId: "version_published",
-        },
-        {
-          id: "artifact_draft",
-          workspaceId: WORKSPACE_ID,
-          contentType: "text/page",
-          locale: "en",
-          slug: "draft-page",
-          title: "Draft Page",
-          publishedVersionId: null,
-        },
-      ]),
-      create: jest.fn(),
-      updateMany: jest.fn(),
-      deleteMany: jest.fn(),
-    },
-    artifactVersion: {
-      findFirst: jest.fn(),
-      // Only the PUBLISHED version's row is ever returned — the adapter
-      // filters publishedIds to non-null before this query, so a draft-only
-      // artifact's version id never appears in the `id: { in: [...] }` set.
-      findMany: jest.fn().mockResolvedValue([
-        {
-          id: "version_published",
-          artifactId: "artifact_published",
-          workspaceId: WORKSPACE_ID,
-          content: {
-            type: "HomePage",
-            slug: "home",
-            title: "Home",
-            description: "The homepage.",
-            body: "# Hello",
-          },
-          isCurrent: false,
-        },
-      ]),
-      create: jest.fn(),
-      updateMany: jest.fn(),
-    },
-    $transaction: jest.fn(),
-  };
-}
-
-describe("contentListParamsSchema", () => {
-  it("requires type (#7168 — the route's required param)", () => {
-    const result = contentListParamsSchema.safeParse({});
-    expect(result.success).toBe(false);
-  });
-
-  it("accepts a valid SchemaOrgType", () => {
-    const result = contentListParamsSchema.safeParse({ type: "HomePage" });
-    expect(result.success).toBe(true);
-  });
-
-  it("accepts HomePage", () => {
-    const result = contentListParamsSchema.safeParse({ type: "HomePage" });
-    expect(result.success).toBe(true);
-  });
-
-  it("rejects an unknown type string", () => {
-    const result = contentListParamsSchema.safeParse({ type: "NotAType" });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects a numeric type", () => {
-    const result = contentListParamsSchema.safeParse({ type: 42 });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe("contentListQuerySchema", () => {
-  it("accepts an empty window (page and pageSize are optional)", () => {
-    const result = contentListQuerySchema.safeParse({});
-    expect(result.success).toBe(true);
-  });
-
-  it("coerces a string page and pageSize, as the route's query string parses", () => {
-    const result = contentListQuerySchema.safeParse({ page: "2", pageSize: "5" });
-    expect(result.success).toBe(true);
-    expect(result.data).toEqual({ page: 2, pageSize: 5 });
-  });
-
-  it("rejects page 0 and pageSize 0", () => {
-    expect(contentListQuerySchema.safeParse({ page: 0 }).success).toBe(false);
-    expect(contentListQuerySchema.safeParse({ pageSize: 0 }).success).toBe(false);
-  });
-
-  it("admits pageSize 500 — the clamp to 100 is the builder's, not a 400 (AC-13)", () => {
-    expect(contentListQuerySchema.safeParse({ pageSize: 500 }).success).toBe(true);
-  });
-});
-
-describe("ailkListPages handler", () => {
-  it("returns the route's paginated ItemList for a specific type", async () => {
-    const result = await ailkListPages({ type: "HomePage" }, CONTENT_ROOT);
-
-    expect(result["@context"]).toBe("https://schema.org");
-    expect(result["@type"]).toBe("ItemList");
-    expect(result.type).toBe("HomePage");
-    expect(Array.isArray(result.items)).toBe(true);
-    // The real content/ tree has at least one HomePage
-    expect(result.items.length).toBeGreaterThan(0);
-    for (const page of result.items) {
-      expect(page.type).toBe("HomePage");
-      expect(typeof page.slug).toBe("string");
-      expect(typeof page.title).toBe("string");
-    }
-  });
-
-  it("defaults the window to page 1 / pageSize 20, as the route does", async () => {
-    const result = await ailkListPages({ type: "HomePage" }, CONTENT_ROOT);
-    expect(result.pagination).toEqual({
-      page: 1,
-      pageSize: 20,
-      totalItems: result.items.length,
-      totalPages: 1,
-    });
-  });
-
-  it("returns an empty ItemList for a type with no content", async () => {
-    // An empty content root of its own (#9422): a scaffold's content/ seeds
-    // TeamMember placeholders (#8850), so the repo's tree cannot stand in.
-    const emptyRoot = mkdtempSync(join(tmpdir(), "list-pages-empty-"));
-    const result = await ailkListPages({ type: "TeamMember" }, emptyRoot);
-    rmSync(emptyRoot, { recursive: true, force: true });
-    expect(result.items).toEqual([]);
-    expect(result.pagination.totalItems).toBe(0);
-    expect(result.pagination.totalPages).toBe(1);
-  });
-
-  it("clamps pageSize 500 to 100 in pagination.pageSize (AC-13)", async () => {
-    const result = await ailkListPages(
-      { type: "HomePage", pageSize: 500 },
-      CONTENT_ROOT,
-    );
-    expect(result.pagination.pageSize).toBe(100);
-  });
-
-  it("output validates against contentListResultSchema", async () => {
-    const result = await ailkListPages({ type: "HomePage" }, CONTENT_ROOT);
-    const parsed = contentListResultSchema.safeParse(result);
-    expect(parsed.success).toBe(true);
-  });
-});
-
-describe("contentListParamsSchema — Zod boundary security", () => {
-  it("rejects input with path traversal characters in type", () => {
-    const result = contentListParamsSchema.safeParse({ type: "../etc/passwd" });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe("ailkListPages — CONTENT_ADAPTER=database (#5876)", () => {
-  const previous = process.env.CONTENT_ADAPTER;
-
-  beforeEach(() => {
-    process.env.CONTENT_ADAPTER = "database";
-    resetResolvedContentAdapter();
-  });
-
-  afterEach(() => {
-    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
-    else process.env.CONTENT_ADAPTER = previous;
-    resetMcpPublicWorkspace();
-    resetResolvedContentAdapter();
-  });
-
-  it("AC-1: lists only published pages", async () => {
-    const stub = makeArtifactPrismaClientStub();
-    __setMcpPublicWorkspaceForTest({
-      kind: "resolved",
-      workspaceId: WORKSPACE_ID,
-      prisma: stub,
-    });
-
-    const result = await ailkListPages({ type: "HomePage" });
-
-    expect(result.items).toEqual([
-      expect.objectContaining({ slug: "home", type: "HomePage" }),
-    ]);
-    expect(stub.artifact.findMany).toHaveBeenCalledWith(
-      expect.objectContaining({
-        where: expect.objectContaining({ workspaceId: WORKSPACE_ID }),
-      }),
-    );
-  });
-
-  it("AC-2: returns the empty ItemList when the workspace is unresolved, with no query", async () => {
-    const stub = makeArtifactPrismaClientStub();
-    __setMcpPublicWorkspaceForTest({ kind: "unresolved", reason: "ambiguous" });
-
-    const result = await ailkListPages({ type: "HomePage" });
-
-    expect(result.items).toEqual([]);
-    expect(result.pagination.totalItems).toBe(0);
-    expect(stub.artifact.findMany).not.toHaveBeenCalled();
-  });
-});
-
-describe("architectural guard — no console calls", () => {
-  it("apps/mcp/src/tools/list_pages.ts does not call console.*", () => {
-    const src = readFileSync(
-      resolve(__dirname, "../src/tools/list_pages.ts"),
-      "utf-8",
-    );
-    expect(src).not.toMatch(/\bconsole\.(log|warn|error|info|debug)\b/);
-  });
-});

package/templates/apps/mcp/__tests__/locale.test.ts

@@ -1,120 +0,0 @@
-/**
- * Tests for the locale parameter on content read MCP tools (Phase 3 S3).
- *
- * Acceptance criteria verified here:
- * - read_content accepts an optional `locale` parameter
- * - list_pages accepts an optional `locale` parameter
- * - search_content accepts an optional `locale` parameter
- * - Tool schemas accept any string `locale`, as the routes' do — the
- *   allowlist is the handler's `resolveLocale`, never the schema (#7167 DD1,
- *   the operator's decision of 2026-10-19: the tool adopted the API's
- *   arguments, so a malformed tag falls back silently instead of being
- *   refused)
- * - Tool handlers return data when valid locale is passed (back-compat)
- * - Invalid/unknown locales silently fall back to default (AC-i18n-07)
- */
-
-import { resolve, join } from "node:path";
-
-import {
-  contentListParamsSchema,
-  contentListQuerySchema,
-  contentPageParamsSchema,
-  contentPageQuerySchema,
-  contentSearchQuerySchema,
-} from "@working-theory/validation";
-
-import { ailkListPages } from "../src/tools/list_pages.js";
-import { ailkReadContent } from "../src/tools/read_content.js";
-import { ailkSearchContent } from "../src/tools/search_content.js";
-
-const REPO_ROOT = resolve(__dirname, "../../..");
-const CONTENT_ROOT = join(REPO_ROOT, "content");
-
-describe("locale parameter — input schemas", () => {
-  it("contentPageParamsSchema + contentPageQuerySchema accept a valid BCP-47 tag", () => {
-    expect(
-      contentPageParamsSchema.safeParse({ type: "HomePage", slug: "home" }).success,
-    ).toBe(true);
-    expect(contentPageQuerySchema.safeParse({ locale: "en" }).success).toBe(true);
-  });
-
-  it("contentPageQuerySchema accepts region-tagged BCP-47 (zh-CN)", () => {
-    expect(contentPageQuerySchema.safeParse({ locale: "zh-CN" }).success).toBe(true);
-  });
-
-  // #7167 DD1 — the route's `locale` is a bare optional string, and the tool
-  // parses the same export: a malformed tag is admitted here and falls back
-  // silently in the handler (`resolveLocale`), as it does on the route.
-  it("contentPageQuerySchema admits a malformed locale (uppercase) — the handler falls back", () => {
-    expect(contentPageQuerySchema.safeParse({ locale: "EN" }).success).toBe(true);
-  });
-
-  it("contentPageQuerySchema admits a path-traversal-shaped locale — the handler falls back, never the filesystem", () => {
-    expect(
-      contentPageQuerySchema.safeParse({ locale: "../../etc/passwd" }).success,
-    ).toBe(true);
-  });
-
-  it("contentPageQuerySchema accepts absent locale (optional)", () => {
-    expect(contentPageQuerySchema.safeParse({}).success).toBe(true);
-  });
-
-  it("contentListParamsSchema + contentListQuerySchema accept a valid locale", () => {
-    expect(contentListParamsSchema.safeParse({ type: "HomePage" }).success).toBe(true);
-    expect(contentListQuerySchema.safeParse({ locale: "en" }).success).toBe(true);
-  });
-
-  it("contentSearchQuerySchema accepts a valid locale", () => {
-    const r = contentSearchQuerySchema.safeParse({
-      q: "foo",
-      locale: "en",
-    });
-    expect(r.success).toBe(true);
-  });
-});
-
-describe("locale parameter — handler behavior (real adapter)", () => {
-  it("ailkReadContent returns the page when locale=en", async () => {
-    const result = await ailkReadContent(
-      { type: "HomePage", slug: "home", locale: "en" },
-      CONTENT_ROOT,
-    );
-    expect(result).toHaveProperty("page", expect.objectContaining({ slug: "home" }));
-  });
-
-  it("ailkReadContent silently falls back when locale=zz (unknown)", async () => {
-    const result = await ailkReadContent(
-      { type: "HomePage", slug: "home", locale: "zz" },
-      CONTENT_ROOT,
-    );
-    // AC-i18n-07: silent fallback to default locale's content.
-    expect(result).toHaveProperty("page", expect.objectContaining({ slug: "home" }));
-  });
-
-  it("ailkListPages returns pages when locale=en", async () => {
-    const result = await ailkListPages(
-      { type: "HomePage", locale: "en" },
-      CONTENT_ROOT,
-    );
-    expect(Array.isArray(result.items)).toBe(true);
-    expect(result.items.length).toBeGreaterThan(0);
-  });
-
-  it("ailkListPages silently falls back when locale=zz", async () => {
-    const result = await ailkListPages(
-      { type: "HomePage", locale: "zz" },
-      CONTENT_ROOT,
-    );
-    // Falls back to default-locale list.
-    expect(Array.isArray(result.items)).toBe(true);
-  });
-
-  it("ailkSearchContent returns results when locale=en", async () => {
-    const result = await ailkSearchContent(
-      { q: "AI", locale: "en" },
-      CONTENT_ROOT,
-    );
-    expect(Array.isArray(result.items)).toBe(true);
-  });
-});

package/templates/apps/mcp/__tests__/module-exclusion.test.ts

@@ -1,175 +0,0 @@
-/**
- * Module-exclusion regression test (S1, #5088).
- *
- * Proves the mechanical claim card S1 exists to make true: when a paid
- * module is excluded (`AILK_ENABLED_MODULES` omits it), none of the MCP
- * tools that module contributes survive registration — the runtime half of
- * "a tool and its apps/api route appear or vanish together" (API↔MCP
- * parity). `packages/metadata/src/mcp-tool-catalog.ts`'s `module` field on
- * each `TOOLS` entry is the map this test walks; it is not a second,
- * hand-maintained list.
- *
- * Reverting the `shouldRegister` module filter in `../src/server.ts` (while
- * leaving the `OSS_DISABLED_TOOLS` check alone) makes this test fail RED —
- * see #5088 S1 verification notes.
- *
- * #7136: the module filter stays independent of the licence-feature gate —
- * the matrix below also runs in refuse mode with every feature held. The
- * catalog enumerations pin `featureGate: "warn"`, so they list every
- * module-tagged tool whichever way `MCP_FEATURE_GATE_MODE` is set and can
- * never iterate nothing.
- */
-
-import { getMcpToolRegistrations } from "@working-theory/metadata";
-
-import {
-  __setMcpFeatureGateForTest,
-  __setMcpHeldFeaturesForTest,
-  resetMcpCommerceClaim,
-} from "../src/lib/commerce-claim.js";
-import { createMcpServer, listRegisteredTools } from "../src/server.js";
-
-// `content-write` left this list in #5853: its three tools (create_page /
-// update_page / delete_page) were deleted with the untenanted HTTP routes they
-// twinned, so the module now owns NO catalog tool at all and the
-// "owns at least one" fixture check below would fail for it. The flag itself
-// is unchanged — it still gates the tenant-guarded editor routes in apps/api
-// (D8), which this MCP-side matrix has never covered.
-const PAID_MODULES = ["scheduling", "signal-collectors"] as const;
-
-/** Every module-tagged tool in the catalog, whatever the gate mode. */
-function catalogRegistrations() {
-  return getMcpToolRegistrations({ featureGate: "warn" });
-}
-
-function withEnabledModules<T>(enabled: string, fn: () => T): T {
-  const prior = process.env.AILK_ENABLED_MODULES;
-  process.env.AILK_ENABLED_MODULES = enabled;
-  try {
-    return fn();
-  } finally {
-    if (prior === undefined) {
-      delete process.env.AILK_ENABLED_MODULES;
-    } else {
-      process.env.AILK_ENABLED_MODULES = prior;
-    }
-  }
-}
-
-describe("MCP tool registration — module exclusion (S1, #5088)", () => {
-  afterEach(() => {
-    delete process.env.AILK_ENABLED_MODULES;
-  });
-
-  it("every module-tagged tool in the catalog names one of the modules this test covers", () => {
-    // Guards the test itself against drift: a future module tag added to
-    // the catalog without a matching entry here would silently go
-    // unverified.
-    const taggedModules = new Set(
-      catalogRegistrations()
-        .map((reg) => reg.module)
-        .filter((m): m is string => Boolean(m)),
-    );
-    expect(taggedModules.size).toBeGreaterThan(0);
-    for (const m of taggedModules) {
-      expect(PAID_MODULES).toContain(m);
-    }
-  });
-
-  it.each(PAID_MODULES)(
-    "excluding '%s' registers none of its tools",
-    (excluded) => {
-      const enabledModules = PAID_MODULES.filter((m) => m !== excluded).join(
-        ",",
-      );
-      const excludedToolNames = catalogRegistrations()
-        .filter((reg) => reg.module === excluded)
-        .map((reg) => reg.name);
-      // Sanity check the fixture: every module this test parametrizes over
-      // actually owns at least one catalog tool, or the assertion below
-      // would vacuously pass.
-      expect(excludedToolNames.length).toBeGreaterThan(0);
-
-      const registeredNames = withEnabledModules(enabledModules, () =>
-        listRegisteredTools().map((t) => t.name),
-      );
-      for (const name of excludedToolNames) {
-        expect(registeredNames).not.toContain(name);
-      }
-
-      const server = withEnabledModules(enabledModules, () =>
-        createMcpServer(),
-      );
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- mirrors apps/mcp/__tests__/catalog-drift.test.ts
-      const registered = (server as any)._registeredTools as Record<
-        string,
-        unknown
-      >;
-      for (const name of excludedToolNames) {
-        expect(name in registered).toBe(false);
-      }
-    },
-  );
-
-  it("with every module enabled, all module-tagged tools register (no over-exclusion)", () => {
-    const enabledModules = PAID_MODULES.join(",");
-    const registeredNames = new Set(
-      withEnabledModules(enabledModules, () =>
-        listRegisteredTools().map((t) => t.name),
-      ),
-    );
-    const taggedNames = catalogRegistrations()
-      .filter((reg) => reg.module)
-      .map((reg) => reg.name);
-    expect(taggedNames.length).toBeGreaterThan(0);
-    for (const name of taggedNames) {
-      expect(registeredNames).toContain(name);
-    }
-  });
-});
-
-describe("module exclusion is independent of the licence-feature gate (#7136)", () => {
-  beforeEach(() => {
-    __setMcpFeatureGateForTest("refuse");
-    __setMcpHeldFeaturesForTest(["scheduling", "flows-deliverables"]);
-  });
-
-  afterEach(() => {
-    resetMcpCommerceClaim();
-    delete process.env.AILK_ENABLED_MODULES;
-  });
-
-  it.each(PAID_MODULES)(
-    "refuse mode, every feature held: excluding '%s' still registers none of its tools",
-    (excluded) => {
-      const enabledModules = PAID_MODULES.filter((m) => m !== excluded).join(
-        ",",
-      );
-      const excludedToolNames = catalogRegistrations()
-        .filter((reg) => reg.module === excluded)
-        .map((reg) => reg.name);
-      expect(excludedToolNames.length).toBeGreaterThan(0);
-
-      const registeredNames = withEnabledModules(enabledModules, () =>
-        listRegisteredTools().map((t) => t.name),
-      );
-      for (const name of excludedToolNames) {
-        expect(registeredNames).not.toContain(name);
-      }
-    },
-  );
-
-  it("refuse mode, every feature held, both modules enabled: all six register", () => {
-    const featureTools = catalogRegistrations()
-      .filter((reg) => reg.feature)
-      .map((reg) => reg.name);
-    expect(featureTools).toHaveLength(6);
-
-    const registeredNames = withEnabledModules(PAID_MODULES.join(","), () =>
-      listRegisteredTools().map((t) => t.name),
-    );
-    for (const name of featureTools) {
-      expect(registeredNames).toContain(name);
-    }
-  });
-});

package/templates/apps/mcp/__tests__/purchase-disabled.test.ts

@@ -1,101 +0,0 @@
-/**
- * `start_purchase` visibility — the commerce add-on claim matrix (#5971).
- *
- * Supersedes S15a (#610), which asserted blanket absence while
- * `OSS_DISABLED_TOOLS` carried the name. The gate is now the deployment's
- * `commerce` licence claim, so the assertion is a MATRIX, not an absence:
- *
- *   keyless (no claim) → absent from `listRegisteredTools()` and from
- *     `createMcpServer()._registeredTools`, and calling `ailkPurchase` BY
- *     NAME returns the module-disabled body with no `checkout.createSession`
- *     call;
- *   keyed (claim held)  → present in both surfaces.
- *
- * Both halves are driven through `__setMcpCommerceClaimForTest()`, the same
- * injector idiom `lib/public-workspace.ts` established (#5876). No test
- * reaches a licence server.
- */
-
-import { checkout } from "@working-theory/api-client";
-
-import {
-  __setMcpCommerceClaimForTest,
-  resetMcpCommerceClaim,
-} from "../src/lib/commerce-claim.js";
-import { createMcpServer, listRegisteredTools } from "../src/server.js";
-import { ailkPurchase } from "../src/tools/purchase.js";
-
-jest.mock("@working-theory/api-client", () => ({
-  checkout: { createSession: jest.fn() },
-}));
-
-const createSession = checkout.createSession as jest.MockedFunction<
-  typeof checkout.createSession
->;
-
-function registeredNames(): string[] {
-  const server = createMcpServer();
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- #506/#507: pre-existing test-hygiene violation
-  const tools = (server as any)._registeredTools as Record<string, unknown>;
-  return Object.keys(tools);
-}
-
-afterEach(() => {
-  jest.clearAllMocks();
-  resetMcpCommerceClaim();
-});
-
-describe("start_purchase — keyless site (no commerce claim)", () => {
-  beforeEach(() => {
-    __setMcpCommerceClaimForTest("unclaimed");
-  });
-
-  it("is NOT in listRegisteredTools()", () => {
-    expect(listRegisteredTools().map((t) => t.name)).not.toContain(
-      "start_purchase",
-    );
-  });
-
-  it("is NOT in createMcpServer()._registeredTools", () => {
-    expect(registeredNames()).not.toContain("start_purchase");
-  });
-
-  it("calling it by name returns the module-disabled body and creates no session", async () => {
-    const result = await ailkPurchase({ productCode: "pro-plan" });
-
-    expect(result).toEqual({ error: "not_found", message: "Not found" });
-    expect(createSession).not.toHaveBeenCalled();
-  });
-
-  it("the module-disabled body does not hint that a licence gate exists", async () => {
-    const result = await ailkPurchase({ productCode: "pro-plan" });
-
-    expect(JSON.stringify(result)).not.toMatch(/commerce|licen[cs]e|claim/i);
-  });
-});
-
-describe("start_purchase — keyed site (commerce claim held)", () => {
-  beforeEach(() => {
-    __setMcpCommerceClaimForTest("claimed");
-  });
-
-  it("IS in listRegisteredTools()", () => {
-    expect(listRegisteredTools().map((t) => t.name)).toContain(
-      "start_purchase",
-    );
-  });
-
-  it("IS in createMcpServer()._registeredTools", () => {
-    expect(registeredNames()).toContain("start_purchase");
-  });
-});
-
-describe("fail-closed default", () => {
-  it("the un-initialised module state is unclaimed", () => {
-    // No injector call — this is the state a boot that never resolved the
-    // licence (or resolved it to a rejection) leaves behind.
-    expect(listRegisteredTools().map((t) => t.name)).not.toContain(
-      "start_purchase",
-    );
-  });
-});