create-ailk 0.23.0 → 0.25.1

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

@@ -1,187 +0,0 @@
-/**
- * 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 `mcpContentRoot()` when the caller passes
- *   none (#8070 D3; the resolver's order is pinned in `content-root.test.ts`);
- * - 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.
- */
-
-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,
-  mcpContentRoot,
-} 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 mcpContentRoot() when none is given (#8070 D3)", () => {
-    getMcpContentAdapter();
-
-    expect(mockResolveContentAdapter).toHaveBeenCalledWith({
-      contentRoot: mcpContentRoot(),
-      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/content-root.test.ts

@@ -1,93 +0,0 @@
-/**
- * `mcpContentRoot()` — the one content-root resolver (#8070 D3, AC-6).
- *
- * The order, against temp directories:
- *   1. AILK_CONTENT_ROOT when set and non-empty (absolute, or resolved
- *      against the working directory);
- *   2. <cwd>/content when it exists (the server started from the repo root);
- *   3. <cwd>/../../content when it exists (the server started from apps/mcp,
- *      a Vercel project whose root directory is apps/mcp);
- *   4. else <cwd>/content — today's value, so a missing root keeps today's
- *      empty result.
- *
- * The working directory is stubbed through `process.cwd`, never changed.
- */
-
-import { mkdirSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { mcpContentRoot } from "../../src/lib/content-adapter.js";
-
-let base: string;
-let savedRoot: string | undefined;
-
-beforeEach(() => {
-  base = realpathSync(mkdtempSync(join(tmpdir(), "mcp-content-root-")));
-  savedRoot = process.env["AILK_CONTENT_ROOT"];
-  delete process.env["AILK_CONTENT_ROOT"];
-});
-
-afterEach(() => {
-  jest.restoreAllMocks();
-  if (savedRoot === undefined) delete process.env["AILK_CONTENT_ROOT"];
-  else process.env["AILK_CONTENT_ROOT"] = savedRoot;
-  rmSync(base, { recursive: true, force: true });
-});
-
-/** Make `dir` (under the temp base) the working directory the resolver sees. */
-function cwdIs(dir: string): string {
-  const abs = join(base, dir);
-  mkdirSync(abs, { recursive: true });
-  jest.spyOn(process, "cwd").mockReturnValue(abs);
-  return abs;
-}
-
-describe("mcpContentRoot", () => {
-  it("AILK_CONTENT_ROOT wins when set — even over an existing <cwd>/content", () => {
-    const cwd = cwdIs("repo");
-    mkdirSync(join(cwd, "content"));
-    const override = join(base, "elsewhere", "content");
-    process.env["AILK_CONTENT_ROOT"] = override;
-
-    expect(mcpContentRoot()).toBe(override);
-  });
-
-  it("a relative AILK_CONTENT_ROOT resolves against the working directory", () => {
-    const cwd = cwdIs("repo/apps/mcp");
-    process.env["AILK_CONTENT_ROOT"] = "../../content";
-
-    expect(mcpContentRoot()).toBe(join(cwd, "..", "..", "content"));
-    expect(mcpContentRoot()).toBe(join(base, "repo", "content"));
-  });
-
-  it("an empty AILK_CONTENT_ROOT is ignored", () => {
-    const cwd = cwdIs("repo");
-    mkdirSync(join(cwd, "content"));
-    process.env["AILK_CONTENT_ROOT"] = "  ";
-
-    expect(mcpContentRoot()).toBe(join(cwd, "content"));
-  });
-
-  it("else <cwd>/content when it exists", () => {
-    const cwd = cwdIs("repo");
-    mkdirSync(join(cwd, "content"));
-    // A repo-level content two levels up must not win over the local one.
-    mkdirSync(join(base, "content"));
-
-    expect(mcpContentRoot()).toBe(join(cwd, "content"));
-  });
-
-  it("else <cwd>/../../content when it exists", () => {
-    cwdIs("repo/apps/mcp");
-    mkdirSync(join(base, "repo", "content"));
-
-    expect(mcpContentRoot()).toBe(join(base, "repo", "content"));
-  });
-
-  it("else <cwd>/content — today's value, when neither exists", () => {
-    const cwd = cwdIs("repo/apps/mcp");
-
-    expect(mcpContentRoot()).toBe(join(cwd, "content"));
-  });
-});

package/templates/apps/mcp/__tests__/lib/errors.test.ts

@@ -1,75 +0,0 @@
-/**
- * Unit tests for the MCP-side canonical error helpers used by D14a content-
- * write tools. Same shape as the apps/api twin minus the status field — MCP
- * surfaces errors as the tool result body itself.
- */
-
-import {
-  conflictError,
-  notFoundError,
-  paymentRequiredError,
-  unauthorizedError,
-  validationError,
-} from "../../src/lib/errors.js";
-
-describe("apps/mcp/lib/errors", () => {
-  it("validationError carries validation_failed code + message", () => {
-    expect(validationError("Invalid input")).toEqual({
-      error: "validation_failed",
-      message: "Invalid input",
-    });
-  });
-
-  it("validationError includes details when provided", () => {
-    expect(
-      validationError("Bad type", { field: "type", received: "Unknown" }),
-    ).toEqual({
-      error: "validation_failed",
-      message: "Bad type",
-      details: { field: "type", received: "Unknown" },
-    });
-  });
-
-  it("validationError omits details key when not provided", () => {
-    const err = validationError("X");
-    expect("details" in err).toBe(false);
-  });
-
-  it("unauthorizedError carries unauthorized code", () => {
-    expect(unauthorizedError("nope")).toEqual({
-      error: "unauthorized",
-      message: "nope",
-    });
-  });
-
-  it("paymentRequiredError carries payment_required code", () => {
-    expect(paymentRequiredError("upgrade")).toEqual({
-      error: "payment_required",
-      message: "upgrade",
-    });
-  });
-
-  it("notFoundError carries not_found code", () => {
-    expect(notFoundError("missing")).toEqual({
-      error: "not_found",
-      message: "missing",
-    });
-  });
-
-  it("conflictError carries conflict code", () => {
-    expect(conflictError("stale")).toEqual({
-      error: "conflict",
-      message: "stale",
-    });
-  });
-
-  it("conflictError includes details (e.g. existing version)", () => {
-    expect(conflictError("Slug exists", { existingVersion: "abc123" })).toEqual(
-      {
-        error: "conflict",
-        message: "Slug exists",
-        details: { existingVersion: "abc123" },
-      },
-    );
-  });
-});

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

@@ -1,165 +0,0 @@
-/**
- * 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/);
-    }
-  });
-});

package/templates/apps/mcp/__tests__/lib/public-workspace.test.ts

@@ -1,124 +0,0 @@
-/**
- * Tests for the MCP server's own workspace resolution (#5876 spec D2/D4/D6/D7).
- *
- * Drives the REAL `initMcpPublicWorkspace()` (not a mock) so its resolution
- * arms are exercised for real, over an injected `WorkspacePredicateClient`
- * stub — no database, no `@working-theory/database` root (client) import,
- * and no internal-module mock of `./prisma.js` either: the `not-required`
- * cases prove the D6 no-op by the RETURN VALUE alone. `resolvedAdapterKind()
- * !== "database"` is this function's first statement and returns before any
- * `await import()` — the source itself, read at `public-workspace.ts:88-91`,
- * is the proof that no lazy import can fire on those two paths; a real
- * unconfigured `PrismaPg({connectionString: undefined})` wouldn't throw
- * synchronously anyway, so mocking the module would prove nothing further.
- */
-
-import {
-  DEFAULT_ORG_ID,
-  DEFAULT_WORKSPACE_ID,
-  type WorkspacePredicateClient,
-} from "@working-theory/database/tenancy";
-
-import {
-  initMcpPublicWorkspace,
-  mcpPublicWorkspace,
-  resetMcpPublicWorkspace,
-} from "../../src/lib/public-workspace.js";
-
-const NON_SENTINEL_ORG_ID = "org_01930000-0000-7bcd-8000-000000000002";
-
-function makeStub(
-  count: number,
-  found: { organizationId: string } | null,
-): WorkspacePredicateClient {
-  return {
-    workspace: {
-      count: jest.fn().mockResolvedValue(count),
-      findUnique: jest.fn().mockResolvedValue(found),
-    },
-  };
-}
-
-describe("initMcpPublicWorkspace", () => {
-  const previous = process.env.CONTENT_ADAPTER;
-
-  beforeEach(() => {
-    resetMcpPublicWorkspace();
-  });
-
-  afterEach(() => {
-    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
-    else process.env.CONTENT_ADAPTER = previous;
-    resetMcpPublicWorkspace();
-  });
-
-  it("resolves not-required on mdx", async () => {
-    process.env.CONTENT_ADAPTER = "mdx";
-
-    const result = await initMcpPublicWorkspace();
-
-    expect(result).toEqual({ kind: "not-required" });
-    expect(mcpPublicWorkspace()).toEqual({ kind: "not-required" });
-  });
-
-  it("resolves not-required on projection", async () => {
-    process.env.CONTENT_ADAPTER = "projection";
-
-    const result = await initMcpPublicWorkspace();
-
-    expect(result).toEqual({ kind: "not-required" });
-  });
-
-  describe("CONTENT_ADAPTER=database", () => {
-    beforeEach(() => {
-      process.env.CONTENT_ADAPTER = "database";
-    });
-
-    it("resolves { kind: resolved } when the sole workspace is the well-known default", async () => {
-      const stub = makeStub(1, { organizationId: DEFAULT_ORG_ID });
-
-      const result = await initMcpPublicWorkspace({ prisma: stub });
-
-      expect(result).toEqual({
-        kind: "resolved",
-        workspaceId: DEFAULT_WORKSPACE_ID,
-        prisma: stub,
-      });
-      expect(mcpPublicWorkspace()).toEqual(result);
-    });
-
-    it("resolves { kind: unresolved } when zero workspaces exist", async () => {
-      const stub = makeStub(0, null);
-
-      const result = await initMcpPublicWorkspace({ prisma: stub });
-
-      expect(result).toEqual({ kind: "unresolved", reason: "ambiguous" });
-    });
-
-    it("resolves { kind: unresolved } when two or more workspaces exist", async () => {
-      const stub = makeStub(2, null);
-
-      const result = await initMcpPublicWorkspace({ prisma: stub });
-
-      expect(result).toEqual({ kind: "unresolved", reason: "ambiguous" });
-    });
-
-    it("resolves { kind: unresolved } when the sole workspace is not the well-known default", async () => {
-      const stub = makeStub(1, { organizationId: NON_SENTINEL_ORG_ID });
-
-      const result = await initMcpPublicWorkspace({ prisma: stub });
-
-      expect(result).toEqual({ kind: "unresolved", reason: "ambiguous" });
-    });
-  });
-});
-
-describe("mcpPublicWorkspace", () => {
-  afterEach(() => {
-    resetMcpPublicWorkspace();
-  });
-
-  it("returns { kind: not-required } before initMcpPublicWorkspace has ever run", () => {
-    expect(mcpPublicWorkspace()).toEqual({ kind: "not-required" });
-  });
-});