create-ailk 0.4.0 → 0.6.0

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

@@ -0,0 +1,143 @@
+/**
+ * Tests for `scanSitePages` (apps/mcp/src/lib/audit-single-page.ts), exercised
+ * through `buildSinglePageAuditInput` with a mocked `ContentAdapter` (#6012,
+ * a follow-up from the #6010 review).
+ *
+ * `scanSitePages` treats two conditions differently, and this file is the
+ * test that proves it:
+ *
+ *   - a type the adapter has no pages of resolves NORMALLY to `[]` — never an
+ *     error, never logged. This is the ordinary "site has nothing of this
+ *     type" case every real adapter (MDX, database) takes today.
+ *   - a type whose adapter call THROWS is a genuine failure. It must not take
+ *     down the audit (the other four reads still complete and their pages
+ *     still count), but it must be visible — logged via `console.error`
+ *     (stderr, NOT stdout — the default stdio MCP transport's JSON-RPC
+ *     framing channel, #6012 round 2) — rather than silently collapsing into
+ *     the same vacuous "nothing found" result.
+ *
+ * The call-count assertions below prove that all five reads still ran despite
+ * the throw — the read AFTER the failing one is not skipped, which a
+ * sequential loop that ABORTED on the first throw would fail to show. They
+ * are NOT, on their own, proof of CONCURRENCY: the prior sequential `for`
+ * loop this replaced used `continue` (not a re-throw), so it too issued all
+ * five calls. The `Promise.all` in the source is what delivers the
+ * concurrency AC; these assertions cover the narrower, still load-bearing
+ * property that a throw part-way through never truncates the scan.
+ */
+
+const mockResolveContentAdapter = jest.fn();
+
+jest.mock("@working-theory/content-adapters", () => ({
+  ...jest.requireActual("@working-theory/content-adapters"),
+  resolveContentAdapter: (...args: unknown[]) =>
+    mockResolveContentAdapter(...args),
+}));
+
+import type { ContentPage } from "@working-theory/content-adapters";
+
+import { buildSinglePageAuditInput } from "../../src/lib/audit-single-page.js";
+
+const HOME_PAGE: ContentPage = {
+  type: "HomePage",
+  slug: "home",
+  title: "Home",
+  description: "The home page.",
+};
+
+const PRODUCT_PAGE: ContentPage = {
+  type: "Product",
+  slug: "widget",
+  title: "Widget",
+  description: "A widget for sale.",
+  price: 49,
+  priceCurrency: "USD",
+};
+
+describe("scanSitePages — type-not-registered vs adapter-threw (#6012)", () => {
+  const previous = process.env.CONTENT_ADAPTER;
+  let errorSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    mockResolveContentAdapter.mockReset();
+    process.env.CONTENT_ADAPTER = "mdx";
+    errorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
+    else process.env.CONTENT_ADAPTER = previous;
+    errorSpy.mockRestore();
+  });
+
+  it("a type the adapter legitimately has no pages of resolves silently — nothing logged", async () => {
+    const listPages = jest.fn().mockResolvedValue([]);
+    const listDetail = jest.fn().mockResolvedValue([]);
+    mockResolveContentAdapter.mockReturnValue({
+      getPageBySlug: jest.fn().mockResolvedValue(HOME_PAGE),
+      listPages,
+      listDetail,
+      getDetailBySlug: jest.fn(),
+      searchPages: jest.fn(),
+      extractStructuredData: jest.fn(),
+      createPage: jest.fn(),
+      updatePage: jest.fn(),
+      deletePage: jest.fn(),
+      getPageVersion: jest.fn(),
+    });
+
+    const result = await buildSinglePageAuditInput({
+      slug: "home",
+      type: "HomePage",
+    });
+
+    expect(result.readiness!.sitePages).toEqual([]);
+    expect(errorSpy).not.toHaveBeenCalled();
+    // All five reads still ran — two listDetail (Product, Service), three
+    // listPages (the three policy types).
+    expect(listDetail).toHaveBeenCalledTimes(2);
+    expect(listPages).toHaveBeenCalledTimes(3);
+  });
+
+  it("a type whose adapter call throws is logged to stderr and does not fail the audit", async () => {
+    const listPages = jest.fn().mockResolvedValue([]);
+    const listDetail = jest.fn().mockImplementation((type: string) => {
+      if (type === "Service") {
+        throw new Error("simulated adapter failure");
+      }
+      return Promise.resolve([PRODUCT_PAGE]);
+    });
+    mockResolveContentAdapter.mockReturnValue({
+      getPageBySlug: jest.fn().mockResolvedValue(HOME_PAGE),
+      listPages,
+      listDetail,
+      getDetailBySlug: jest.fn(),
+      searchPages: jest.fn(),
+      extractStructuredData: jest.fn(),
+      createPage: jest.fn(),
+      updatePage: jest.fn(),
+      deletePage: jest.fn(),
+      getPageVersion: jest.fn(),
+    });
+
+    const result = await buildSinglePageAuditInput({
+      slug: "home",
+      type: "HomePage",
+    });
+
+    // The audit as a whole never fails, and the type that threw contributes
+    // nothing — but the type that succeeded (Product) still counts.
+    expect(result.readiness!.sitePages).toEqual([
+      { slug: "widget", type: "Product", price: 49 },
+    ]);
+    // The throwing type is visible, not silently swallowed — and via
+    // console.error (stderr), never console.debug/console.log (stdout,
+    // the stdio transport's JSON-RPC channel).
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+    expect(errorSpy.mock.calls[0]![0]).toMatch(/Service/);
+    // All five reads still ran despite the throw — the read AFTER the
+    // throwing one (ReturnsPolicyPage, et al.) was not skipped.
+    expect(listDetail).toHaveBeenCalledTimes(2);
+    expect(listPages).toHaveBeenCalledTimes(3);
+  });
+});

package/templates/apps/mcp/__tests__/lib/commerce-claim.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Tests for the boot-memoised commerce claim (#5971 spec D2).
+ *
+ * Idiom: `__tests__/lib/require-paid-tier.test.ts` — `checkLicense()` is
+ * injected, never called for real, so no suite reaches a licence server
+ * (NFR-6). Every arm that cannot POSITIVELY establish the claim must resolve
+ * to `"unclaimed"` (NFR-3, fail closed).
+ */
+
+import {
+  initMcpCommerceClaim,
+  mcpCommerceClaim,
+  resetMcpCommerceClaim,
+  __setMcpCommerceClaimForTest,
+} from "../../src/lib/commerce-claim.js";
+
+/**
+ * The injected licence reader. Typed off `initMcpCommerceClaim`'s own option
+ * rather than off `@working-theory/license`, so the stubs below satisfy
+ * exactly what the function under test calls — no double assertion needed.
+ */
+type CheckLicenseSeam = NonNullable<
+  NonNullable<Parameters<typeof initMcpCommerceClaim>[0]>["checkLicense"]
+>;
+
+type LicenseShape = Awaited<ReturnType<CheckLicenseSeam>>;
+
+/** A licence reader that resolves to the given result. */
+function resolving(result: Partial<LicenseShape>): CheckLicenseSeam {
+  return () => Promise.resolve(result as LicenseShape);
+}
+
+/** A licence reader that rejects — the "an exception is a bug" arm. */
+function rejecting(): CheckLicenseSeam {
+  return () => Promise.reject(new Error("boom"));
+}
+
+afterEach(() => {
+  resetMcpCommerceClaim();
+});
+
+describe("initMcpCommerceClaim", () => {
+  it("resolves claimed when features[] carries 'commerce'", async () => {
+    const claim = await initMcpCommerceClaim({
+      checkLicense: resolving({ tier: "pro", features: ["commerce"] }),
+    });
+
+    expect(claim).toBe("claimed");
+    expect(mcpCommerceClaim()).toBe("claimed");
+  });
+
+  it("resolves unclaimed when features[] omits 'commerce'", async () => {
+    await initMcpCommerceClaim({
+      checkLicense: resolving({ tier: "pro", features: ["scheduling"] }),
+    });
+
+    expect(mcpCommerceClaim()).toBe("unclaimed");
+  });
+
+  it("resolves unclaimed on a free tier with no features", async () => {
+    await initMcpCommerceClaim({
+      checkLicense: resolving({ tier: "free", features: [] }),
+    });
+
+    expect(mcpCommerceClaim()).toBe("unclaimed");
+  });
+
+  it("resolves unclaimed when the licence is revoked, even carrying the feature", async () => {
+    await initMcpCommerceClaim({
+      checkLicense: resolving({
+        tier: "pro",
+        features: ["commerce"],
+        revoked: true,
+      }),
+    });
+
+    expect(mcpCommerceClaim()).toBe("unclaimed");
+  });
+
+  it("resolves unclaimed — never throws — when checkLicense() rejects", async () => {
+    const claim = await initMcpCommerceClaim({
+      checkLicense: rejecting(),
+    });
+
+    expect(claim).toBe("unclaimed");
+    expect(mcpCommerceClaim()).toBe("unclaimed");
+  });
+
+  it("re-resolves and re-memoises on a second call", async () => {
+    await initMcpCommerceClaim({
+      checkLicense: resolving({ tier: "pro", features: ["commerce"] }),
+    });
+    expect(mcpCommerceClaim()).toBe("claimed");
+
+    await initMcpCommerceClaim({
+      checkLicense: resolving({ tier: "free", features: [] }),
+    });
+    expect(mcpCommerceClaim()).toBe("unclaimed");
+  });
+});
+
+describe("mcpCommerceClaim — fail-closed initial state", () => {
+  it("is unclaimed before any init", () => {
+    expect(mcpCommerceClaim()).toBe("unclaimed");
+  });
+
+  it("the test injector sets it directly", () => {
+    __setMcpCommerceClaimForTest("claimed");
+    expect(mcpCommerceClaim()).toBe("claimed");
+  });
+});

package/templates/apps/mcp/__tests__/lib/content-adapter-parity.test.ts

@@ -0,0 +1,65 @@
+/**
+ * MCP ↔ API content parity through the one resolver (#5805, Epic #5322 C1).
+ *
+ * `apps/api` resolves its adapter with `resolveContentAdapter()`
+ * (`apps/api/src/lib/content-adapter.ts`); after this change `apps/mcp` does
+ * too, via `getMcpContentAdapter()`. This test proves the two consumers read
+ * the same page for the same slug when pointed at the same content root — the
+ * whole point of one-function resolution.
+ *
+ * It resolves the "API side" by calling `resolveContentAdapter()` directly
+ * with the shape `apps/api` passes, rather than importing `apps/api` — an
+ * app-to-app import is banned by the architecture boundary. The assertion is
+ * deliberately small: this is a proof of one-function resolution, not a second
+ * content-contract suite.
+ */
+
+import { join, resolve } from "node:path";
+
+import {
+  resolveContentAdapter,
+  resetResolvedContentAdapter,
+} from "@working-theory/content-adapters";
+
+import { resolveLocale } from "../../src/lib/resolve-locale.js";
+import { ailkReadContent } from "../../src/tools/read_content.js";
+
+const REPO_ROOT = resolve(__dirname, "../../../..");
+const CONTENT_ROOT = join(REPO_ROOT, "content");
+
+describe("read_content ↔ apps/api adapter parity (CONTENT_ADAPTER=mdx)", () => {
+  const previous = process.env.CONTENT_ADAPTER;
+
+  beforeEach(() => {
+    process.env.CONTENT_ADAPTER = "mdx";
+    resetResolvedContentAdapter();
+  });
+
+  afterEach(() => {
+    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
+    else process.env.CONTENT_ADAPTER = previous;
+    resetResolvedContentAdapter();
+  });
+
+  it("returns the same title and slug the API's adapter returns", async () => {
+    const viaMcp = await ailkReadContent(
+      { type: "HomePage", slug: "home" },
+      CONTENT_ROOT,
+    );
+
+    // The shape apps/api hands the resolver: a content root and the project's
+    // default locale, no workspaceId. Both sides read `project.yaml` for that
+    // locale, so resolving it once here keeps the two calls comparable.
+    const locale = resolveLocale(undefined);
+    const apiAdapter = resolveContentAdapter({
+      contentRoot: CONTENT_ROOT,
+      defaultLocale: locale,
+    });
+    const viaApi = await apiAdapter.getPageBySlug("HomePage", "home", locale);
+
+    expect(viaMcp).not.toBeNull();
+    expect(viaApi).not.toBeNull();
+    expect(viaMcp!.slug).toBe(viaApi!.slug);
+    expect(viaMcp!.frontmatter.title).toBe(viaApi!.title);
+  });
+});

package/templates/apps/mcp/__tests__/lib/content-adapter.test.ts

@@ -0,0 +1,188 @@
+/**
+ * Tests for the shared MCP content-adapter helper (#5805, extended #5876).
+ *
+ * Epic #5322 exit criterion 2: every content consumer resolves its adapter
+ * through one function. These tests pin the delegation contract of
+ * `getMcpContentAdapter()` — the single seam the twelve MCP tools and
+ * `audit-single-page` now go through:
+ *
+ * - it delegates to `resolveContentAdapter()` rather than constructing an
+ *   adapter itself;
+ * - it forwards the caller's `contentRoot` test-override verbatim;
+ * - it forwards the caller's resolved `locale` as `defaultLocale`;
+ * - it defaults `contentRoot` to `<cwd>/content` when the caller passes none;
+ * - its MDX-narrowed twin `getMcpMdxContentAdapter()` (which `read_content`
+ *   needs for `getPageSource()`) resolves the same way and raises a named
+ *   error rather than a TypeError when the selected adapter is not MDX;
+ * - on `CONTENT_ADAPTER=mdx` (the default, unset), it passes NO `workspaceId`;
+ * - on `CONTENT_ADAPTER=database`, it reads `mcpPublicWorkspace()` (#5876
+ *   spec D2/D4/D5/D6): a resolved workspace forwards `workspaceId` + `prisma`
+ *   to `resolveContentAdapter()`; an unresolved one calls the resolver NOT AT
+ *   ALL and returns the fail-closed empty adapter instead.
+ */
+
+import { join } from "node:path";
+
+const mockResolveContentAdapter = jest.fn();
+
+jest.mock("@working-theory/content-adapters", () => ({
+  ...jest.requireActual("@working-theory/content-adapters"),
+  resolveContentAdapter: (...args: unknown[]) =>
+    mockResolveContentAdapter(...args),
+}));
+
+import type { ArtifactPrismaClient } from "@working-theory/content-adapters";
+
+import {
+  getMcpContentAdapter,
+  getMcpMdxContentAdapter,
+} from "../../src/lib/content-adapter.js";
+import {
+  __setMcpPublicWorkspaceForTest,
+  resetMcpPublicWorkspace,
+} from "../../src/lib/public-workspace.js";
+
+describe("getMcpContentAdapter", () => {
+  const previous = process.env.CONTENT_ADAPTER;
+
+  beforeEach(() => {
+    mockResolveContentAdapter.mockReset();
+    mockResolveContentAdapter.mockReturnValue({ marker: "resolved" });
+    process.env.CONTENT_ADAPTER = "mdx";
+  });
+
+  afterEach(() => {
+    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
+    else process.env.CONTENT_ADAPTER = previous;
+  });
+
+  it("delegates to resolveContentAdapter and returns what it builds", () => {
+    const adapter = getMcpContentAdapter({ contentRoot: "/fixtures/content" });
+
+    expect(mockResolveContentAdapter).toHaveBeenCalledTimes(1);
+    expect(adapter).toEqual({ marker: "resolved" });
+  });
+
+  it("forwards contentRoot and locale to the resolver", () => {
+    getMcpContentAdapter({ contentRoot: "/fixtures/content", locale: "fr-CA" });
+
+    expect(mockResolveContentAdapter).toHaveBeenCalledWith({
+      contentRoot: "/fixtures/content",
+      defaultLocale: "fr-CA",
+    });
+  });
+
+  it("defaults contentRoot to <cwd>/content when none is given", () => {
+    getMcpContentAdapter();
+
+    expect(mockResolveContentAdapter).toHaveBeenCalledWith({
+      contentRoot: join(process.cwd(), "content"),
+      defaultLocale: undefined,
+    });
+  });
+
+  it("passes no workspaceId on CONTENT_ADAPTER=mdx — the MDX path stays byte-identical", () => {
+    getMcpContentAdapter({ contentRoot: "/fixtures/content", locale: "en-US" });
+
+    const options = mockResolveContentAdapter.mock.calls[0]![0] as Record<
+      string,
+      unknown
+    >;
+    expect(options).not.toHaveProperty("workspaceId");
+  });
+});
+
+describe("getMcpContentAdapter — CONTENT_ADAPTER=database", () => {
+  const previous = process.env.CONTENT_ADAPTER;
+
+  beforeEach(() => {
+    mockResolveContentAdapter.mockReset();
+    // A full MdxContentAdapter-shaped stub — getMcpContentAdapter()'s database
+    // branch always passes the resolver's return through readOnlyContentAdapter
+    // (content-adapter.ts), which binds every read method.
+    mockResolveContentAdapter.mockReturnValue({
+      getPageBySlug: jest.fn(),
+      listPages: jest.fn(),
+      getDetailBySlug: jest.fn(),
+      listDetail: jest.fn(),
+      searchPages: jest.fn(),
+      extractStructuredData: jest.fn(),
+      getPageSource: jest.fn(),
+      createPage: jest.fn(),
+      updatePage: jest.fn(),
+      deletePage: jest.fn(),
+      getPageVersion: jest.fn(),
+    });
+    process.env.CONTENT_ADAPTER = "database";
+  });
+
+  afterEach(() => {
+    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
+    else process.env.CONTENT_ADAPTER = previous;
+    resetMcpPublicWorkspace();
+  });
+
+  it("forwards workspaceId and prisma to the resolver when the workspace resolved", () => {
+    // This test only asserts the prisma VALUE is forwarded by reference — it
+    // never calls a method on it, so a minimal marker object stands in.
+    // eslint-disable-next-line no-restricted-syntax -- structural test stub, mirrors audit-single-page.test.ts's identical pattern
+    const prismaStub = {
+      marker: "prisma-stub",
+    } as unknown as ArtifactPrismaClient;
+    __setMcpPublicWorkspaceForTest({
+      kind: "resolved",
+      workspaceId: "wksp_00000000-0000-7000-8000-000000000001",
+      prisma: prismaStub,
+    });
+
+    getMcpContentAdapter({ contentRoot: "/fixtures/content", locale: "en-US" });
+
+    expect(mockResolveContentAdapter).toHaveBeenCalledWith({
+      workspaceId: "wksp_00000000-0000-7000-8000-000000000001",
+      prisma: prismaStub,
+      contentRoot: "/fixtures/content",
+      defaultLocale: "en-US",
+    });
+  });
+
+  it("never calls the resolver and returns the fail-closed empty adapter when unresolved", async () => {
+    __setMcpPublicWorkspaceForTest({ kind: "unresolved", reason: "ambiguous" });
+
+    const adapter = getMcpContentAdapter({ contentRoot: "/fixtures/content" });
+
+    expect(mockResolveContentAdapter).not.toHaveBeenCalled();
+    await expect(adapter.getPageBySlug("HomePage", "home")).resolves.toBeNull();
+    await expect(adapter.listPages("HomePage")).resolves.toEqual([]);
+  });
+
+  it("never calls the resolver and returns the fail-closed empty adapter before bootstrap has resolved", async () => {
+    // No __setMcpPublicWorkspaceForTest call — the module's initial
+    // { kind: "not-required" } state, exactly as an MCP tool invoked before
+    // apps/mcp/src/index.ts awaits initMcpPublicWorkspace() would see it (D4).
+    const adapter = getMcpContentAdapter({ contentRoot: "/fixtures/content" });
+
+    expect(mockResolveContentAdapter).not.toHaveBeenCalled();
+    await expect(adapter.getPageBySlug("HomePage", "home")).resolves.toBeNull();
+  });
+});
+
+describe("getMcpMdxContentAdapter", () => {
+  beforeEach(() => {
+    mockResolveContentAdapter.mockReset();
+  });
+
+  it("returns the resolved adapter when it exposes getPageSource", () => {
+    const mdxish = { getPageSource: jest.fn() };
+    mockResolveContentAdapter.mockReturnValue(mdxish);
+
+    expect(getMcpMdxContentAdapter({ contentRoot: "/fixtures/content" })).toBe(
+      mdxish,
+    );
+  });
+
+  it("throws a named error when the resolved adapter is not MDX-capable", () => {
+    mockResolveContentAdapter.mockReturnValue({ getPageBySlug: jest.fn() });
+
+    expect(() => getMcpMdxContentAdapter()).toThrow(/CONTENT_ADAPTER=mdx/);
+  });
+});

package/templates/apps/mcp/__tests__/lib/fail-closed-tools.test.ts

@@ -0,0 +1,165 @@
+/**
+ * AC-2's "every content tool" sweep, demonstrated rather than argued (#5876
+ * spec D5, §4.1). `read_content.test.ts` and `list_pages.test.ts` (`##
+ * Scope`) already cover two of the nine read tools' database-path behaviour;
+ * this table drives all nine plus `buildSinglePageAuditInput` (the `audit`
+ * tool's page reader) through the SAME unresolved arm and asserts each
+ * returns its own not-found/empty shape — never a client-supplied workspace,
+ * never an enumeration signal, never a query.
+ */
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import {
+  resetResolvedContentAdapter,
+  type ArtifactPrismaClient,
+} from "@working-theory/content-adapters";
+
+import { buildSinglePageAuditInput } from "../../src/lib/audit-single-page.js";
+import {
+  __setMcpPublicWorkspaceForTest,
+  resetMcpPublicWorkspace,
+} from "../../src/lib/public-workspace.js";
+import { ailkGetBusinessHours } from "../../src/tools/get_business_hours.js";
+import { ailkGetFaq } from "../../src/tools/get_faq.js";
+import { ailkGetLocations } from "../../src/tools/get_locations.js";
+import { ailkGetOfferings } from "../../src/tools/get_offerings.js";
+import { ailkGetPricing } from "../../src/tools/get_pricing.js";
+import { ailkGetSiteInfo } from "../../src/tools/get_site_info.js";
+import { ailkListPages } from "../../src/tools/list_pages.js";
+import { ailkReadContent } from "../../src/tools/read_content.js";
+import { ailkSearchContent } from "../../src/tools/search_content.js";
+
+/** A structural stub — never resolved into the seam under this arm, so every
+ * one of its methods must remain untouched by every case below. */
+function makeArtifactPrismaClientStub(): ArtifactPrismaClient {
+  return {
+    artifact: {
+      findFirst: jest.fn(),
+      findMany: jest.fn(),
+      create: jest.fn(),
+      updateMany: jest.fn(),
+      deleteMany: jest.fn(),
+    },
+    artifactVersion: {
+      findFirst: jest.fn(),
+      findMany: jest.fn(),
+      create: jest.fn(),
+      updateMany: jest.fn(),
+    },
+    $transaction: jest.fn(),
+  };
+}
+
+describe("every content tool — CONTENT_ADAPTER=database, unresolved workspace", () => {
+  const previous = process.env.CONTENT_ADAPTER;
+  let stub: ArtifactPrismaClient;
+
+  beforeEach(() => {
+    process.env.CONTENT_ADAPTER = "database";
+    resetResolvedContentAdapter();
+    stub = makeArtifactPrismaClientStub();
+    __setMcpPublicWorkspaceForTest({ kind: "unresolved", reason: "ambiguous" });
+  });
+
+  afterEach(() => {
+    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
+    else process.env.CONTENT_ADAPTER = previous;
+    resetMcpPublicWorkspace();
+    resetResolvedContentAdapter();
+  });
+
+  /** Every stub method is asserted untouched — nothing here reaches a query,
+   * not even the stub the deployment never got wired to (NFR-5). */
+  function expectNoQuery(): void {
+    expect(stub.artifact.findFirst).not.toHaveBeenCalled();
+    expect(stub.artifact.findMany).not.toHaveBeenCalled();
+    expect(stub.artifactVersion.findFirst).not.toHaveBeenCalled();
+    expect(stub.artifactVersion.findMany).not.toHaveBeenCalled();
+  }
+
+  it("ailkReadContent returns null", async () => {
+    const result = await ailkReadContent({ type: "HomePage", slug: "home" });
+    expect(result).toBeNull();
+    expectNoQuery();
+  });
+
+  it("ailkListPages returns { pages: [] }", async () => {
+    const result = await ailkListPages({ type: "HomePage" });
+    expect(result).toEqual({ pages: [] });
+    expectNoQuery();
+  });
+
+  it("ailkSearchContent returns { results: [] }", async () => {
+    const result = await ailkSearchContent({ query: "anything" });
+    expect(result).toEqual({ results: [] });
+    expectNoQuery();
+  });
+
+  it("ailkGetFaq returns null", async () => {
+    const result = await ailkGetFaq({});
+    expect(result).toBeNull();
+    expectNoQuery();
+  });
+
+  it("ailkGetOfferings returns { offerings: [] }", async () => {
+    const result = await ailkGetOfferings({});
+    expect(result).toEqual({ offerings: [] });
+    expectNoQuery();
+  });
+
+  it("ailkGetSiteInfo returns null", async () => {
+    const result = await ailkGetSiteInfo({});
+    expect(result).toBeNull();
+    expectNoQuery();
+  });
+
+  it("ailkGetBusinessHours returns null", async () => {
+    const result = await ailkGetBusinessHours({});
+    expect(result).toBeNull();
+    expectNoQuery();
+  });
+
+  it("ailkGetLocations returns { locations: [] }", async () => {
+    const result = await ailkGetLocations({});
+    expect(result).toEqual({ locations: [] });
+    expectNoQuery();
+  });
+
+  it("ailkGetPricing returns null", async () => {
+    const result = await ailkGetPricing({});
+    expect(result).toBeNull();
+    expectNoQuery();
+  });
+
+  it("buildSinglePageAuditInput throws its own not-found error (never a workspace-state error)", async () => {
+    await expect(buildSinglePageAuditInput({ slug: "home" })).rejects.toThrow(
+      /Page not found/,
+    );
+    expectNoQuery();
+  });
+
+  it("no content tool source names workspaceId (structural guard — D8)", () => {
+    // The tools imported above — a caller-supplied workspaceId is never a
+    // valid MCP input, on any tool, at any point (mirrors read_content.test.ts's
+    // existing "no console.*" structural guard idiom).
+    const toolFiles = [
+      "read_content.ts",
+      "list_pages.ts",
+      "search_content.ts",
+      "get_faq.ts",
+      "get_offerings.ts",
+      "get_site_info.ts",
+      "get_business_hours.ts",
+      "get_locations.ts",
+      "get_pricing.ts",
+    ];
+    for (const file of toolFiles) {
+      const src = readFileSync(
+        resolve(__dirname, "../../src/tools", file),
+        "utf-8",
+      );
+      expect(src).not.toMatch(/\bworkspaceId\b/);
+    }
+  });
+});