create-ailk 0.1.0

package/templates/apps/mcp/__tests__/abuse/user-agent-deny.test.ts

@@ -0,0 +1,54 @@
+/**
+ * Unit tests for abuse/user-agent-deny.ts
+ *
+ * Verifies built-in bot UA deny list plus env-configured additions.
+ */
+
+import {
+  isUserAgentBlocked,
+  buildDenyList,
+} from "../../src/abuse/user-agent-deny.js";
+
+describe("buildDenyList", () => {
+  it("includes built-in bot user agents", () => {
+    const list = buildDenyList();
+    expect(list.some((r) => r.test("python-requests/2.28"))).toBe(true);
+    expect(list.some((r) => r.test("curl/7.88"))).toBe(true);
+    expect(list.some((r) => r.test("Wget/1.21"))).toBe(true);
+    expect(list.some((r) => r.test("Scrapy/2.8"))).toBe(true);
+  });
+
+  it("merges env-configured additions", () => {
+    const list = buildDenyList("BadBot/1.0,EvilCrawler");
+    expect(list.some((r) => r.test("BadBot/1.0"))).toBe(true);
+    expect(list.some((r) => r.test("EvilCrawler/2"))).toBe(true);
+  });
+});
+
+describe("isUserAgentBlocked", () => {
+  it("blocks a known bot UA", () => {
+    const denyList = buildDenyList();
+    expect(isUserAgentBlocked("python-requests/2.28.1", denyList)).toBe(true);
+  });
+
+  it("allows a real browser UA", () => {
+    const denyList = buildDenyList();
+    expect(
+      isUserAgentBlocked(
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+        denyList,
+      ),
+    ).toBe(false);
+  });
+
+  it("blocks missing UA (empty string)", () => {
+    const denyList = buildDenyList();
+    expect(isUserAgentBlocked("", denyList)).toBe(true);
+  });
+
+  it("blocks undefined/null UA", () => {
+    const denyList = buildDenyList();
+    expect(isUserAgentBlocked(undefined, denyList)).toBe(true);
+    expect(isUserAgentBlocked(null, denyList)).toBe(true);
+  });
+});

package/templates/apps/mcp/__tests__/aeo-cli-parity.test.ts

@@ -0,0 +1,110 @@
+/**
+ * AEO CLI ↔ MCP tool parity test.
+ *
+ * Verifies that `ailkAudit` produces per-page output that matches what
+ * you'd get by calling `runAudit` directly with the same single-page input
+ * that `buildSinglePageAuditInput` produces.
+ *
+ * Both code paths use only the public `@working-theory/aeo` API — no imports from
+ * CLI-internal files (packages/aeo/src/cli/*). The parity claim is:
+ *   buildSinglePageAuditInput → runAudit(input, RULES)
+ *   ≡ ailkAudit internally (same adapter, same RULES)
+ *
+ * Acceptance criteria verified:
+ * - Output of audit for a fixture page equals the result of calling
+ *   runAudit with the same AuditInput (Layer 2 AC: "identical per-page output")
+ * - runAudit invocation uses canonical RULES from packages/aeo/src/rules/index.ts
+ */
+
+import { resolve, join } from "node:path";
+
+import {
+  runAudit,
+  alwaysFails,
+  alwaysPasses,
+  entityMarkup,
+  faqHowtoIncentive,
+  jsonldValidity,
+  schemaCoverage,
+  type Rule,
+} from "@working-theory/aeo";
+
+import { buildSinglePageAuditInput } from "../src/lib/audit-single-page.js";
+import { ailkAudit } from "../src/tools/audit.js";
+
+const REPO_ROOT = resolve(__dirname, "../../..");
+const CONTENT_ROOT = join(REPO_ROOT, "content");
+
+// Canonical rule set — mirrors packages/aeo/src/cli/index.ts RULES array.
+// Must stay in sync with that definition; both are sourced from @working-theory/aeo.
+const RULES: Rule[] = [
+  alwaysPasses,
+  alwaysFails,
+  schemaCoverage,
+  jsonldValidity,
+  faqHowtoIncentive,
+  entityMarkup,
+];
+
+const FIXTURE_SLUG = "home";
+const FIXTURE_TYPE = "HomePage" as const;
+
+describe("audit ↔ runAudit direct parity", () => {
+  it("per-page score matches runAudit(buildSinglePageAuditInput(slug), RULES)", async () => {
+    // --- Direct path (mirrors what the tool does internally) ---
+    const auditInput = await buildSinglePageAuditInput(
+      { slug: FIXTURE_SLUG, type: FIXTURE_TYPE },
+      CONTENT_ROOT,
+    );
+    const directReport = runAudit(auditInput, RULES);
+    const directPage = directReport.perPage.find(
+      (p) => p.slug === FIXTURE_SLUG && p.type === FIXTURE_TYPE,
+    );
+    expect(directPage).toBeDefined();
+
+    // --- MCP tool path ---
+    const mcpResult = await ailkAudit(
+      { slug: FIXTURE_SLUG, type: FIXTURE_TYPE },
+      CONTENT_ROOT,
+    );
+    const mcpPage = mcpResult.perPage.find(
+      (p) => p.slug === FIXTURE_SLUG && p.type === FIXTURE_TYPE,
+    );
+    expect(mcpPage).toBeDefined();
+
+    // Per-page fields must match
+    expect(mcpPage!.score).toBe(directPage!.score);
+    expect(mcpPage!.slug).toBe(directPage!.slug);
+    expect(mcpPage!.type).toBe(directPage!.type);
+  });
+
+  it("overall score matches runAudit called with the same AuditInput", async () => {
+    const auditInput = await buildSinglePageAuditInput(
+      { slug: FIXTURE_SLUG, type: FIXTURE_TYPE },
+      CONTENT_ROOT,
+    );
+    const directReport = runAudit(auditInput, RULES);
+
+    const mcpResult = await ailkAudit(
+      { slug: FIXTURE_SLUG, type: FIXTURE_TYPE },
+      CONTENT_ROOT,
+    );
+
+    expect(mcpResult.score).toBe(directReport.score);
+  });
+
+  it("perRule count matches — tool uses the same RULES array", async () => {
+    const auditInput = await buildSinglePageAuditInput(
+      { slug: FIXTURE_SLUG, type: FIXTURE_TYPE },
+      CONTENT_ROOT,
+    );
+    const directReport = runAudit(auditInput, RULES);
+
+    const mcpResult = await ailkAudit(
+      { slug: FIXTURE_SLUG, type: FIXTURE_TYPE },
+      CONTENT_ROOT,
+    );
+
+    expect(mcpResult.perRule).toHaveLength(directReport.perRule.length);
+  });
+});

package/templates/apps/mcp/__tests__/audit-single-page.test.ts

@@ -0,0 +1,213 @@
+/**
+ * Tests for apps/mcp/src/lib/audit-single-page.ts
+ *
+ * TDD: URL validation cases (security boundary) first, then happy paths.
+ *
+ * Acceptance criteria verified here:
+ * - Rejects URLs not on the AILK installation's own domain (SSRF guard)
+ * - Rejects malformed URLs
+ * - Rejects when both slug and url are provided
+ * - Rejects when neither slug nor url is provided
+ * - Accepts slug-only input and builds AuditInput
+ * - Accepts same-origin url input and builds AuditInput
+ * - Strips query strings + fragments before slug extraction
+ * - Cross-domain error message references ailk audit CLI
+ * - No fetch() call (structural test)
+ */
+
+import { readFileSync } from "node:fs";
+import { resolve, join } from "node:path";
+
+import { buildSinglePageAuditInput } from "../src/lib/audit-single-page.js";
+
+const REPO_ROOT = resolve(__dirname, "../../..");
+const CONTENT_ROOT = join(REPO_ROOT, "content");
+
+// Set env to a known base URL for tests that exercise same-origin logic.
+const TEST_BASE_URL = "https://example.ailk.test";
+
+function withBaseUrl(
+  url: string,
+  fn: () => Promise<unknown>,
+): Promise<unknown> {
+  const prev = process.env.AILK_BASE_URL;
+  process.env.AILK_BASE_URL = url;
+  return fn().finally(() => {
+    if (prev === undefined) delete process.env.AILK_BASE_URL;
+    else process.env.AILK_BASE_URL = prev;
+  });
+}
+
+// ── URL-validation tests (security boundary — RED first) ──────────────────────
+
+describe("buildSinglePageAuditInput — URL validation (security boundary)", () => {
+  it("rejects a cross-domain URL", async () => {
+    await expect(
+      withBaseUrl(TEST_BASE_URL, () =>
+        buildSinglePageAuditInput(
+          { url: "https://evil.example.com/HomePage/some-page" },
+          CONTENT_ROOT,
+        ),
+      ),
+    ).rejects.toThrow(/out of scope|use `ailk audit`/i);
+  });
+
+  it("cross-domain error message references ailk audit CLI", async () => {
+    const err = await withBaseUrl(TEST_BASE_URL, () =>
+      buildSinglePageAuditInput(
+        { url: "https://evil.example.com/HomePage/some-page" },
+        CONTENT_ROOT,
+      ),
+    ).catch((e: Error) => e);
+    expect(err).toBeInstanceOf(Error);
+    expect((err as Error).message).toMatch(/ailk audit/);
+  });
+
+  it("rejects a URL with user-info (credential-stuffed URL bypass attempt)", async () => {
+    // The bypass form: https://trusted-domain@attacker.com/page
+    // WHATWG URL: userinfo="trusted-domain", hostname="attacker.com"
+    // hostname !== base.hostname → rejected.
+    const bypassUrl = `https://${TEST_BASE_URL.replace("https://", "")}@attacker.com/page`;
+    await expect(
+      withBaseUrl(TEST_BASE_URL, () =>
+        buildSinglePageAuditInput({ url: bypassUrl }, CONTENT_ROOT),
+      ),
+    ).rejects.toThrow(/out of scope|use `ailk audit`/i);
+  });
+
+  it("rejects a malformed URL", async () => {
+    await expect(
+      withBaseUrl(TEST_BASE_URL, () =>
+        buildSinglePageAuditInput({ url: "not-a-url" }, CONTENT_ROOT),
+      ),
+    ).rejects.toThrow();
+  });
+
+  it("rejects input with both slug and url provided", async () => {
+    await expect(
+      withBaseUrl(TEST_BASE_URL, () =>
+        buildSinglePageAuditInput(
+          // eslint-disable-next-line no-restricted-syntax -- #506/#507: pre-existing test-hygiene violation
+          {
+            slug: "home",
+            url: `${TEST_BASE_URL}/HomePage/home`,
+          } as unknown as Parameters<typeof buildSinglePageAuditInput>[0],
+          CONTENT_ROOT,
+        ),
+      ),
+    ).rejects.toThrow(/both|exclusive/i);
+  });
+
+  it("rejects input with neither slug nor url", async () => {
+    await expect(
+      withBaseUrl(TEST_BASE_URL, () =>
+        buildSinglePageAuditInput(
+          // eslint-disable-next-line no-restricted-syntax -- #506/#507: pre-existing test-hygiene violation
+          {} as unknown as Parameters<typeof buildSinglePageAuditInput>[0],
+          CONTENT_ROOT,
+        ),
+      ),
+    ).rejects.toThrow(/slug.*url|url.*slug|required/i);
+  });
+
+  it("accepts same-origin URL with matching hostname", async () => {
+    await expect(
+      withBaseUrl(TEST_BASE_URL, () =>
+        buildSinglePageAuditInput(
+          { url: `${TEST_BASE_URL}/HomePage/home` },
+          CONTENT_ROOT,
+        ),
+      ),
+    ).resolves.toBeDefined();
+  });
+
+  it("strips query string from same-origin URL before slug extraction", async () => {
+    const result = await withBaseUrl(TEST_BASE_URL, () =>
+      buildSinglePageAuditInput(
+        { url: `${TEST_BASE_URL}/HomePage/home?utm_source=test` },
+        CONTENT_ROOT,
+      ),
+    );
+    expect(result).toBeDefined();
+  });
+
+  it("strips fragment from same-origin URL before slug extraction", async () => {
+    const result = await withBaseUrl(TEST_BASE_URL, () =>
+      buildSinglePageAuditInput(
+        { url: `${TEST_BASE_URL}/HomePage/home#section` },
+        CONTENT_ROOT,
+      ),
+    );
+    expect(result).toBeDefined();
+  });
+});
+
+// ── Slug happy-path tests ─────────────────────────────────────────────────────
+
+describe("buildSinglePageAuditInput — slug input", () => {
+  it("returns AuditInput with one page for a known HomePage slug", async () => {
+    const result = await buildSinglePageAuditInput(
+      { slug: "home", type: "HomePage" },
+      CONTENT_ROOT,
+    );
+    expect(result.pages).toHaveLength(1);
+    expect(result.pages[0].slug).toBe("home");
+    expect(result.pages[0].type).toBe("HomePage");
+  });
+
+  it("result has locale, identityMode, registry, jsonLdByPage fields", async () => {
+    const result = await buildSinglePageAuditInput(
+      { slug: "home", type: "HomePage" },
+      CONTENT_ROOT,
+    );
+    expect(typeof result.locale).toBe("string");
+    expect(
+      result.identityMode === "person" ||
+        result.identityMode === "organization",
+    ).toBe(true);
+    expect(Array.isArray(result.registry)).toBe(true);
+    expect(typeof result.jsonLdByPage).toBe("object");
+  });
+
+  it("throws for a slug that does not exist in the content directory", async () => {
+    await expect(
+      buildSinglePageAuditInput(
+        { slug: "does-not-exist-at-all", type: "HomePage" },
+        CONTENT_ROOT,
+      ),
+    ).rejects.toThrow(/not found|does not exist/i);
+  });
+});
+
+// ── URL happy-path tests ──────────────────────────────────────────────────────
+
+describe("buildSinglePageAuditInput — url input (same-origin)", () => {
+  it("returns AuditInput for a same-origin URL pointing at a known page", async () => {
+    const result = (await withBaseUrl(TEST_BASE_URL, () =>
+      buildSinglePageAuditInput(
+        { url: `${TEST_BASE_URL}/HomePage/home` },
+        CONTENT_ROOT,
+      ),
+    )) as Awaited<ReturnType<typeof buildSinglePageAuditInput>>;
+    expect(result.pages).toHaveLength(1);
+    expect(result.pages[0].slug).toBe("home");
+    expect(result.pages[0].type).toBe("HomePage");
+  });
+});
+
+// ── Structural guard ──────────────────────────────────────────────────────────
+
+describe("structural guard — no fetch()", () => {
+  it("apps/mcp/src/lib/audit-single-page.ts does not call fetch()", () => {
+    const src = readFileSync(
+      resolve(__dirname, "../src/lib/audit-single-page.ts"),
+      "utf-8",
+    );
+    // Strip block comments (/** ... */ and /* ... */) and line comments (// ...)
+    // before checking — comments may mention fetch() as a negative assertion.
+    const codeOnly = src
+      .replace(/\/\*[\s\S]*?\*\//g, "")
+      .replace(/\/\/[^\n]*/g, "");
+    expect(codeOnly).not.toMatch(/\bfetch\s*\(/);
+  });
+});

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

@@ -0,0 +1,217 @@
+/**
+ * Tests for the audit MCP tool handler.
+ *
+ * Acceptance criteria verified here:
+ * - auditInputSchema validates slug input (with regex enforcement)
+ * - auditInputSchema validates url input
+ * - auditInputSchema rejects invalid slugs (uppercase, slashes, dots)
+ * - ailkAudit returns score + perRule + perPage + meta for a slug input
+ * - ailkAudit returns an error result for a cross-domain URL
+ * - Output validates against auditOutputSchema
+ * - No console.* calls in handler (structural test)
+ * - No fetch() call in tool file (structural test)
+ *
+ * Phase 3 U0 (#294): adds a sanity-check that purchaseInputSchema relocated
+ * to @working-theory/validation (per ADR 0013) is reachable and parses the same input
+ * shape the inline schema parsed pre-relocation.
+ */
+
+import { readFileSync } from "node:fs";
+import { resolve, join } from "node:path";
+
+import {
+  auditInputSchema,
+  auditOutputSchema,
+  purchaseInputSchema,
+} from "@working-theory/validation";
+
+import { ailkAudit } from "../src/tools/audit.js";
+
+const REPO_ROOT = resolve(__dirname, "../../..");
+const CONTENT_ROOT = join(REPO_ROOT, "content");
+const TEST_BASE_URL = "https://example.ailk.test";
+
+function withBaseUrl(
+  url: string,
+  fn: () => Promise<unknown>,
+): Promise<unknown> {
+  const prev = process.env.AILK_BASE_URL;
+  process.env.AILK_BASE_URL = url;
+  return fn().finally(() => {
+    if (prev === undefined) delete process.env.AILK_BASE_URL;
+    else process.env.AILK_BASE_URL = prev;
+  });
+}
+
+// ── Input schema tests ────────────────────────────────────────────────────────
+
+describe("auditInputSchema", () => {
+  it("accepts a valid slug", () => {
+    const result = auditInputSchema.safeParse({
+      slug: "home",
+      type: "HomePage",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts slug without explicit type", () => {
+    const result = auditInputSchema.safeParse({ slug: "home" });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts a url string", () => {
+    const result = auditInputSchema.safeParse({
+      url: "https://example.com/page",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects slug with uppercase letters", () => {
+    const result = auditInputSchema.safeParse({ slug: "LaunchingAilk" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects slug with forward slash (path traversal guard)", () => {
+    const result = auditInputSchema.safeParse({ slug: "some/path" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects slug with dots (path traversal guard)", () => {
+    const result = auditInputSchema.safeParse({ slug: "../etc" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects empty slug", () => {
+    const result = auditInputSchema.safeParse({ slug: "" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects non-url string in url field", () => {
+    const result = auditInputSchema.safeParse({ url: "not-a-url" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects empty object (neither slug nor url)", () => {
+    const result = auditInputSchema.safeParse({});
+    expect(result.success).toBe(false);
+  });
+});
+
+// ── Handler happy-path tests ──────────────────────────────────────────────────
+
+describe("ailkAudit handler — slug input", () => {
+  it("returns score, perRule, perPage, meta for a known HomePage slug", async () => {
+    const result = await ailkAudit(
+      { slug: "home", type: "HomePage" },
+      CONTENT_ROOT,
+    );
+    expect(typeof result.score).toBe("number");
+    expect(result.score).toBeGreaterThanOrEqual(0);
+    expect(result.score).toBeLessThanOrEqual(100);
+    expect(Array.isArray(result.perRule)).toBe(true);
+    expect(Array.isArray(result.perPage)).toBe(true);
+    expect(typeof result.meta).toBe("object");
+    expect(typeof result.meta.auditedAt).toBe("string");
+    expect(typeof result.meta.ruleSet).toBe("string");
+    expect(typeof result.meta.locale).toBe("string");
+  });
+
+  it("perRule entries have ruleId, name, weight, status fields", async () => {
+    const result = await ailkAudit(
+      { slug: "home", type: "HomePage" },
+      CONTENT_ROOT,
+    );
+    for (const rule of result.perRule) {
+      expect(typeof rule.ruleId).toBe("string");
+      expect(typeof rule.name).toBe("string");
+      expect(typeof rule.weight).toBe("number");
+      expect(rule.status === "pass" || rule.status === "fail").toBe(true);
+    }
+  });
+
+  it("perPage entries have slug and type fields", async () => {
+    const result = await ailkAudit(
+      { slug: "home", type: "HomePage" },
+      CONTENT_ROOT,
+    );
+    expect(result.perPage).toHaveLength(1);
+    expect(result.perPage[0].slug).toBe("home");
+    expect(result.perPage[0].type).toBe("HomePage");
+  });
+
+  it("output validates against auditOutputSchema", async () => {
+    const result = await ailkAudit(
+      { slug: "home", type: "HomePage" },
+      CONTENT_ROOT,
+    );
+    const parsed = auditOutputSchema.safeParse(result);
+    expect(parsed.success).toBe(true);
+  });
+});
+
+describe("ailkAudit handler — url input (same-origin)", () => {
+  it("returns audit result for a same-origin URL", async () => {
+    const result = (await withBaseUrl(TEST_BASE_URL, () =>
+      ailkAudit(
+        { url: `${TEST_BASE_URL}/HomePage/home` },
+        CONTENT_ROOT,
+      ),
+    )) as Awaited<ReturnType<typeof ailkAudit>>;
+    expect(typeof result.score).toBe("number");
+    expect(result.perPage[0].slug).toBe("home");
+  });
+});
+
+describe("ailkAudit handler — cross-domain URL", () => {
+  it("throws for a cross-domain URL (no fetch attempted)", async () => {
+    await expect(
+      withBaseUrl(TEST_BASE_URL, () =>
+        ailkAudit(
+          { url: "https://evil.example.com/HomePage/page" },
+          CONTENT_ROOT,
+        ),
+      ),
+    ).rejects.toThrow(/out of scope|use `ailk audit`/i);
+  });
+});
+
+// ── Structural guards ─────────────────────────────────────────────────────────
+
+describe("structural guards", () => {
+  it("apps/mcp/src/tools/audit.ts does not call console.*", () => {
+    const src = readFileSync(
+      resolve(__dirname, "../src/tools/audit.ts"),
+      "utf-8",
+    );
+    expect(src).not.toMatch(/\bconsole\.(log|warn|error|info|debug)\b/);
+  });
+
+  it("apps/mcp/src/tools/audit.ts does not call fetch()", () => {
+    const src = readFileSync(
+      resolve(__dirname, "../src/tools/audit.ts"),
+      "utf-8",
+    );
+    // Strip comments before checking — JSDoc may mention fetch() as a negative assertion.
+    const codeOnly = src
+      .replace(/\/\*[\s\S]*?\*\//g, "")
+      .replace(/\/\/[^\n]*/g, "");
+    expect(codeOnly).not.toMatch(/\bfetch\s*\(/);
+  });
+});
+
+// ── Schema relocation parity (Phase 3 U0 / ADR 0013) ──────────────────────────
+
+describe("purchaseInputSchema relocated to @working-theory/validation", () => {
+  it("parses the same shape the inline schema parsed pre-relocation", () => {
+    const result = purchaseInputSchema.safeParse({
+      priceId: "price_test_123",
+      quantity: 2,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects an empty priceId", () => {
+    const result = purchaseInputSchema.safeParse({ priceId: "" });
+    expect(result.success).toBe(false);
+  });
+});

package/templates/apps/mcp/__tests__/catalog-drift.test.ts

@@ -0,0 +1,52 @@
+/**
+ * Drift-detection test (issue #209): the MCP server's registered tool list
+ * MUST equal the canonical catalog from @working-theory/metadata.
+ *
+ * Without this, two surfaces (apps/web manifest + apps/mcp server) could drift
+ * on tool name or description and only an integration test on a real MCP
+ * client would catch it. This test forces them in lock-step.
+ *
+ * What this asserts:
+ *   - Tool names registered on the McpServer == catalog tool names
+ *   - Tool descriptions registered on the McpServer == catalog descriptions
+ *
+ * What this does NOT assert:
+ *   - inputSchema equality — the server registers Zod schemas; the catalog
+ *     publishes JSON-Schema descriptors. Same source upstream
+ *     (packages/validation), but distinct shapes downstream by design.
+ */
+
+import { getMcpToolCatalog } from "@working-theory/metadata";
+
+import { createMcpServer } from "../src/server.js";
+
+interface RegisteredTool {
+  description?: string;
+}
+
+describe("MCP catalog ↔ server drift", () => {
+  it("registered tool names equal catalog tool names", () => {
+    const server = createMcpServer();
+    const registered = (
+      // eslint-disable-next-line no-restricted-syntax -- #506/#507: pre-existing test-hygiene violation
+      server as unknown as { _registeredTools: Record<string, RegisteredTool> }
+    )._registeredTools;
+    const registeredNames = Object.keys(registered).sort();
+    const catalogNames = getMcpToolCatalog()
+      .map((t) => t.name)
+      .sort();
+    expect(registeredNames).toEqual(catalogNames);
+  });
+
+  it("registered tool descriptions equal catalog descriptions", () => {
+    const server = createMcpServer();
+    const registered = (
+      // eslint-disable-next-line no-restricted-syntax -- #506/#507: pre-existing test-hygiene violation
+      server as unknown as { _registeredTools: Record<string, RegisteredTool> }
+    )._registeredTools;
+    for (const entry of getMcpToolCatalog()) {
+      expect(registered[entry.name]).toBeDefined();
+      expect(registered[entry.name]!.description).toBe(entry.description);
+    }
+  });
+});