create-ailk 0.22.0 → 0.24.0

package/templates/apps/mcp/__tests__/tools/purchase.test.ts

@@ -274,13 +274,13 @@ describe("ailkPurchase — valid input", () => {
     );
 
     await ailkPurchase({
-      productCode: "price_test_123",
+      productCode: "growth_monthly",
       quantity: 1,
     });
 
     expect(createSession).toHaveBeenCalledTimes(1);
     const payload = createSession.mock.calls[0]![0];
-    expect(payload.productCode).toBe("price_test_123");
+    expect(payload.productCode).toBe("growth_monthly");
     expect(payload.quantity).toBe(1);
   });
 
@@ -289,7 +289,7 @@ describe("ailkPurchase — valid input", () => {
       sessionCreated("https://checkout.stripe.com/pay/cs_test_promo"),
     );
 
-    await ailkPurchase({ productCode: "price_test_123" });
+    await ailkPurchase({ productCode: "growth_monthly" });
 
     expect(createSession.mock.calls[0]![0]).not.toHaveProperty(
       "allowPromotionCodes",
@@ -302,7 +302,7 @@ describe("ailkPurchase — valid input", () => {
     );
 
     const output = await ailkPurchase({
-      productCode: "price_test_xyz",
+      productCode: "growth_monthly",
     });
 
     expect(output).toEqual({
@@ -315,7 +315,7 @@ describe("ailkPurchase — valid input", () => {
       sessionCreated("https://checkout.stripe.com/pay/cs_test_valid"),
     );
 
-    const output = await ailkPurchase({ productCode: "price_test_valid" });
+    const output = await ailkPurchase({ productCode: "growth_monthly" });
     expect(PurchaseOutputSchema.safeParse(output).success).toBe(true);
   });
 });
@@ -373,10 +373,10 @@ describe("ailkPurchase — always derives redirects from AILK_BASE_URL (#6001 AC
       sessionCreated("https://checkout.stripe.com/pay/cs_test_base"),
     );
 
-    await ailkPurchase({ productCode: "price_test_123" });
+    await ailkPurchase({ productCode: "growth_monthly" });
 
     expect(createSession).toHaveBeenCalledWith({
-      productCode: "price_test_123",
+      productCode: "growth_monthly",
       successUrl:
         "https://example.com/purchase/success?session_id={CHECKOUT_SESSION_ID}",
       cancelUrl: "https://example.com/purchase/cancel",
@@ -390,10 +390,10 @@ describe("ailkPurchase — always derives redirects from AILK_BASE_URL (#6001 AC
       sessionCreated("https://checkout.stripe.com/pay/cs_test_fallback"),
     );
 
-    await ailkPurchase({ productCode: "price_test_123" });
+    await ailkPurchase({ productCode: "growth_monthly" });
 
     expect(createSession).toHaveBeenCalledWith({
-      productCode: "price_test_123",
+      productCode: "growth_monthly",
       successUrl:
         "http://localhost:3000/purchase/success?session_id={CHECKOUT_SESSION_ID}",
       cancelUrl: "http://localhost:3000/purchase/cancel",
@@ -408,7 +408,7 @@ describe("ailkPurchase — always derives redirects from AILK_BASE_URL (#6001 AC
       sessionCreated("https://checkout.stripe.com/pay/cs_test_braces"),
     );
 
-    await ailkPurchase({ productCode: "price_test_123" });
+    await ailkPurchase({ productCode: "growth_monthly" });
 
     const payload = createSession.mock.calls[0]![0] as {
       successUrl: string;
@@ -427,7 +427,7 @@ describe("ailkPurchase — parity shape with purchaseAction", () => {
     );
 
     const output = await ailkPurchase({
-      productCode: "price_parity",
+      productCode: "growth_monthly",
     });
 
     expect(output).toHaveProperty("url");

package/templates/apps/mcp/package.json

@@ -27,6 +27,7 @@
     "@working-theory/license": "workspace:*",
     "@working-theory/metadata": "workspace:*",
     "@working-theory/schema": "workspace:*",
+    "@working-theory/site-config": "workspace:*",
     "@working-theory/validation": "workspace:*",
     "fastify": "^5.12.5",
     "yaml": "^2.9.0",

package/templates/apps/mcp/src/abuse/index.ts

@@ -28,14 +28,18 @@ import { buildDenyList, isUserAgentBlocked } from "./user-agent-deny.js";
 
 /**
  * Tools that require email format validation on their input, each mapped to
- * where the email sits in it: top level for the lead tools, `attendee.email`
- * for create_booking (#8071 D3). submit_flow_step has no fixed email field —
- * its `values` is a free record the hub's flow engine validates.
+ * the paths the email may sit at, read in order — the first string wins: top
+ * level for the lead tools, then `payload.email`, since the route lifts the
+ * address from there when the top level has none (#7171, #7172: `email` is
+ * optional at the top level of both bodies, so an agent could otherwise nest
+ * a malformed one past this check); `attendee.email` for create_booking
+ * (#8071 D3). submit_flow_step has no fixed email field — its `values` is a
+ * free record the hub's flow engine validates.
  */
-const EMAIL_VALIDATED_TOOLS = new Map<string, readonly string[]>([
-  ["capture_lead", ["email"]],
-  ["subscribe_newsletter", ["email"]],
-  ["create_booking", ["attendee", "email"]],
+const EMAIL_VALIDATED_TOOLS = new Map<string, readonly (readonly string[])[]>([
+  ["capture_lead", [["email"], ["payload", "email"]]],
+  ["subscribe_newsletter", [["email"], ["payload", "email"]]],
+  ["create_booking", [["attendee", "email"]]],
 ]);
 
 /**
@@ -274,12 +278,15 @@ export class AbuseGuard {
       };
     }
 
-    // Rule 3: Email format validation, at the tool's own email path. A
+    // Rule 3: Email format validation, at the tool's own email paths — the
+    // first path holding a string is the address the route will read. A
     // missing or non-string email passes — the handler's Zod schema is the
     // authority on required fields.
-    const emailPath = EMAIL_VALIDATED_TOOLS.get(toolName);
-    if (emailPath !== undefined) {
-      const email = valueAt(input, emailPath);
+    const emailPaths = EMAIL_VALIDATED_TOOLS.get(toolName);
+    if (emailPaths !== undefined) {
+      const email = emailPaths
+        .map((path) => valueAt(input, path))
+        .find((value) => typeof value === "string");
       if (typeof email === "string" && !isValidEmail(email)) {
         return {
           allowed: false,

package/templates/apps/mcp/src/http-transport.ts

@@ -201,6 +201,17 @@ function isOriginAllowedForWrite(
   return allowedOrigins.includes(origin);
 }
 
+/**
+ * The "retry in …" wording of the write bucket's refusal, matching what
+ * @fastify/rate-limit's default error says for the same window — `format()`
+ * from `@lukeed/ms` over whole seconds, which for a one-minute window is
+ * "1 minute" or "N second(s)".
+ */
+function retryIn(seconds: number): string {
+  if (seconds >= 60) return "1 minute";
+  return `${seconds} second${seconds === 1 ? "" : "s"}`;
+}
+
 /**
  * An agent key's shape (#3591 D2): `ailk_agt_` plus 32 random bytes in
  * base64url. apps/mcp checks only this; apps/api is where the key is checked.
@@ -322,14 +333,25 @@ export async function registerHttpTransport(
   });
 
   // ── Rate limiting ─────────────────────────────────────────────────────────
-  // Global ceiling — the lower write limit is enforced per-request via the
-  // preHandler by checking the tool name after body parse.
+  // Global ceiling — readPerMin per IP, counted on every request (writes
+  // included) by the plugin's own onRequest hook.
   await app.register(rateLimit, {
     max: config.rateLimits.readPerMin,
     timeWindow: "1 minute",
     keyGenerator: (request: FastifyRequest) => request.ip,
   });
 
+  // The write bucket — writePerMin per IP, charged in the POST preHandler
+  // below once per write-tool call, after the body is parsed and classified
+  // (#9251). `createRateLimit()` gives it its own in-memory store with the
+  // ceiling's key generator and window; it is the plugin's seam for a second
+  // limiter on a request the ceiling has already counted (a hook from
+  // `app.rateLimit()` would skip such a request as already limited).
+  const writeLimit = app.createRateLimit({
+    max: config.rateLimits.writePerMin,
+    timeWindow: "1 minute",
+  });
+
   // ── MCP route ─────────────────────────────────────────────────────────────
 
   // GET — SSE stream for an existing session
@@ -362,13 +384,29 @@ export async function registerHttpTransport(
           return;
         }
 
-        // Write-tool rate limit (stricter than read ceiling)
-        // We re-use the same in-memory store but apply a tighter key.
-        // @fastify/rate-limit tracks by keyGenerator; we check manually here.
-        // Simple approach: use a second rate-limit store baked into the guard.
-        // For now, we rely on the global ceiling for writes (configurable).
-        // TODO: per-tool write rate limit when @fastify/rate-limit v11 lands
-        // a per-route override API compatible with our stateless route design.
+        // Write-tool rate limit (#9251) — writePerMin per IP, tighter than
+        // the ceiling and counting write-tool calls only. Charged once per
+        // call, like the abuse guard below, so a batch of N spends N units.
+        // The refusal is the one the ceiling emits — the plugin's four
+        // headers and Fastify's 429 error body — so a caller sees one
+        // rate-limit shape whichever bucket ran out, never a tool-level
+        // error (see ABUSE_REFUSAL_STATUS on why that distinction matters).
+        for (const _call of writeCalls) {
+          const limit = await writeLimit(request);
+          if (limit.isAllowed || !limit.isExceeded) continue;
+          reply
+            .code(429)
+            .header("x-ratelimit-limit", limit.max)
+            .header("x-ratelimit-remaining", 0)
+            .header("x-ratelimit-reset", limit.ttlInSeconds)
+            .header("retry-after", limit.ttlInSeconds)
+            .send({
+              statusCode: 429,
+              error: "Too Many Requests",
+              message: `Rate limit exceeded, retry in ${retryIn(limit.ttlInSeconds)}`,
+            });
+          return;
+        }
 
         // Abuse heuristics — charged ONCE PER CALL, not once per request, so a
         // batch of N cannot spend one cap unit and execute N times. The whole

package/templates/apps/mcp/src/lib/content-adapter.ts

@@ -114,29 +114,3 @@ export function getMcpContentAdapter(
   // untouched and gate only the four write methods (D13).
   return readOnlyContentAdapter(adapter as MdxContentAdapter);
 }
-
-/**
- * The same resolution, narrowed to the MDX adapter's richer surface.
- *
- * `read_content` returns a page's raw MDX body, which only
- * `MdxContentAdapter.getPageSource()` provides — the base `ContentAdapter`
- * contract returns frontmatter only. Rather than cast, this asserts the
- * capability on the adapter the resolver actually built, so a server pointed
- * at a non-MDX `CONTENT_ADAPTER` gets a named error instead of a
- * `getPageSource is not a function` TypeError. On the default `mdx` path the
- * check always passes and behaviour is unchanged. Under `database`, both the
- * fail-closed empty adapter and the read-only-wrapped database adapter also
- * provide `getPageSource`, so the check passes there too (D5).
- */
-export function getMcpMdxContentAdapter(
-  options: McpContentAdapterOptions = {},
-): MdxContentAdapter {
-  const adapter = getMcpContentAdapter(options);
-  if (typeof (adapter as MdxContentAdapter).getPageSource !== "function") {
-    throw new Error(
-      "This tool needs the MDX adapter's getPageSource(): the adapter selected by " +
-        "CONTENT_ADAPTER does not provide a raw MDX body. Use CONTENT_ADAPTER=mdx (the default).",
-    );
-  }
-  return adapter as MdxContentAdapter;
-}

package/templates/apps/mcp/src/lib/empty-content-adapter.ts

@@ -18,12 +18,13 @@
  *
  *   1. Every content tool's own not-found/empty mapping fires with NO tool
  *      edit — `read_content` and `get_*` already treat `null` as not-found;
- *      `list_pages` and `search_content` already treat `[]` as empty.
+ *      `list_pages` and `search_content` already answer their empty
+ *      `ItemList` over `[]` (#7167: the routes' own envelopes).
  *   2. "Before any content lookup" (NFR-5) is structural, not asserted —
  *      there is nothing here to look anything up in.
- *   3. `getMcpMdxContentAdapter()`'s `typeof getPageSource === "function"`
- *      capability check (`content-adapter.ts`) passes, so `read_content`
- *      never sees THAT named throw on the fail-closed path.
+ *   3. `readContentDocument`'s `typeof getPageSource === "function"`
+ *      capability check (`@working-theory/content-adapters`) passes, so
+ *      `read_content` never sees THAT named throw on the fail-closed path.
  */
 import type {
   ContentPage,

package/templates/apps/mcp/src/lib/shown-offerings.ts

@@ -0,0 +1,105 @@
+/**
+ * The MCP read of the site's Offerings shown set (#8933, spec D6).
+ *
+ * `get_pricing` and `get_offerings` answer a connected site's shown set —
+ * the persisted Stripe snapshot `GET /v1/content/shown-offerings` serves
+ * (#8924) — rather than its page content. apps/mcp reaches Offerings data
+ * only over HTTP (#8876 D9), so this file reads that route through
+ * `@working-theory/api-client` and hands the tools the current set, or
+ * `null` for the content path:
+ *
+ * 1. The deployment's own claim first: unless `mcpCommerceClaim()` reads
+ *    `claimed`, no HTTP call is made at all. The API's claim, read inside
+ *    the route, still decides; this one only spares an unlicensed host the
+ *    call.
+ * 2. One `apiClient.offerings.shown()`, raced against
+ *    `MCP_SHOWN_SET_BUDGET_MS`, so a hung API never holds a tool call.
+ * 3. A refusal, a body `shownOfferingsAnswerSchema` refuses, the budget
+ *    passing or a rejection is `null` and one `console.error` line.
+ * 4. Otherwise `currentShownSet` — a `current` set with offerings, or `null`.
+ *
+ * The workspace is the API's: api-client sends the deployment's own spoke
+ * key, and no tool argument names one (identity-blind). No Stripe package is
+ * imported here or anywhere in apps/mcp (T7).
+ *
+ * T6 — every log line is `{ event, outcome }` plus an HTTP `status` or an
+ * error's class name as `errName`: never a body, a message, the shown set, a
+ * lookup key, an id, a name or a description. The log calls live here
+ * because the tool files may not call `console.*`.
+ */
+
+import { apiClient } from "@working-theory/api-client";
+import { currentShownSet } from "@working-theory/content-adapters";
+import {
+  shownOfferingsAnswerSchema,
+  type WorkspaceShownSetWire,
+} from "@working-theory/validation";
+
+import { mcpCommerceClaim } from "./commerce-claim.js";
+
+/** The longest one tool call waits on the shown set before answering content. */
+export const MCP_SHOWN_SET_BUDGET_MS = 5000;
+
+const OVER_BUDGET = Symbol("over-budget");
+
+/** An error's class name only — never its message, which may carry Stripe text. */
+function errName(err: unknown): string {
+  return err instanceof Error ? err.constructor.name : typeof err;
+}
+
+/** The site's current shown set, or `null` for the content path. */
+export async function mcpCurrentShownSet(): Promise<WorkspaceShownSetWire | null> {
+  if (mcpCommerceClaim() !== "claimed") return null;
+
+  // Caught before the race, so a rejection after the budget is never unhandled.
+  const read = apiClient.offerings.shown().catch((err: unknown) => {
+    console.error({
+      event: "shown-offerings",
+      outcome: "unreachable",
+      errName: errName(err),
+    });
+    return null;
+  });
+  let timer: NodeJS.Timeout | undefined;
+  const budget = new Promise<typeof OVER_BUDGET>((resolve) => {
+    timer = setTimeout(() => resolve(OVER_BUDGET), MCP_SHOWN_SET_BUDGET_MS);
+  });
+  let res: Awaited<typeof read> | typeof OVER_BUDGET;
+  try {
+    res = await Promise.race([read, budget]);
+  } finally {
+    clearTimeout(timer);
+  }
+
+  if (res === OVER_BUDGET) {
+    console.error({ event: "shown-offerings", outcome: "over_budget" });
+    return null;
+  }
+  if (res === null) return null;
+  if (!res.ok) {
+    console.error({
+      event: "shown-offerings",
+      outcome: "refused",
+      status: res.status,
+    });
+    return null;
+  }
+  const parsed = shownOfferingsAnswerSchema.safeParse(res.body);
+  if (!parsed.success) {
+    console.error({ event: "shown-offerings", outcome: "unreadable" });
+    return null;
+  }
+  return currentShownSet(parsed.data);
+}
+
+/**
+ * Logs a shown-set mapping that threw (D12): the tool then answers its
+ * content path, so no `ZodError` message ever reaches the agent.
+ */
+export function reportMappingFailure(err: unknown): void {
+  console.error({
+    event: "shown-offerings",
+    outcome: "mapping_failed",
+    errName: errName(err),
+  });
+}

package/templates/apps/mcp/src/lib/site-config.ts

@@ -0,0 +1,53 @@
+/**
+ * The deployment's `_site.mdx`, read once per content root (#7169).
+ *
+ * `read_content` answers through `readContentDocument` in
+ * `@working-theory/content-adapters`, which takes the parsed site config for
+ * the `HomePage` graph and the `origin` read. That package may not import
+ * `@working-theory/site-config` (`architecture.yaml`), so the read stays with
+ * each app: this is the same reader `apps/api/src/routes/content/get-page.ts`
+ * carries — the one duplication the import rule leaves, kept identical so a
+ * `HomePage` read through the tool is the route's to the byte. The rejected
+ * alternative, `@working-theory/aeo`'s `loadSitewideIdentity`, applies its own
+ * acceptance rules and a parent-directory fallback, which could make the two
+ * differ on an edge site.
+ *
+ * A local read with the client-safe `/schema` entry:
+ * `@working-theory/site-config/server` imports `server-only`, which throws
+ * outside a React Server Components runtime.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  SiteConfigSchema,
+  type SiteConfig,
+} from "@working-theory/site-config/schema";
+import { parse as parseYaml } from "yaml";
+
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+
+/** `_site.mdx` per content root, read once; `null` when it does not load. */
+const siteConfigByRoot = new Map<string, SiteConfig | null>();
+
+/**
+ * The deployment's `_site.mdx`, validated against `SiteConfigSchema`, or
+ * `undefined` on any failure (absent, unreadable, invalid).
+ */
+export function readSiteConfig(contentRoot: string): SiteConfig | undefined {
+  if (!siteConfigByRoot.has(contentRoot)) {
+    let config: SiteConfig | null = null;
+    try {
+      const raw = readFileSync(join(contentRoot, "_site.mdx"), "utf8");
+      const match = FRONTMATTER_RE.exec(raw);
+      if (match) {
+        const parsed = SiteConfigSchema.safeParse(parseYaml(match[1] ?? ""));
+        if (parsed.success) config = parsed.data;
+      }
+    } catch {
+      // Absent or unreadable — no site.
+    }
+    siteConfigByRoot.set(contentRoot, config);
+  }
+  return siteConfigByRoot.get(contentRoot) ?? undefined;
+}

package/templates/apps/mcp/src/server.ts

@@ -119,6 +119,11 @@ const MODULE_TOOL_ENTRIES: Record<
     specifier: "./tools/create_booking.js",
     exportName: "ailkCreateBooking",
   },
+  // #8843 D5 — the twin of GET /v1/schedule/meetings.
+  list_meetings: {
+    specifier: "./tools/list_meetings.js",
+    exportName: "ailkListMeetings",
+  },
   // D-48 signal-collectors — the flow engine's MCP twins of GET
   // /v1/flows/:slug and POST /v1/flows/:slug/steps. Anonymous, identity-blind;
   // free-anonymous status is now module-gated rather than unconditional.

package/templates/apps/mcp/src/tools/capture_lead.ts

@@ -1,9 +1,18 @@
 /**
- * capture_lead — capture a contact-form lead.
+ * capture_lead — capture a lead: the body `POST /v1/leads/submit` takes.
  *
- * Validates input via Zod, forwards to POST /v1/leads/submit via
- * @working-theory/api-client, and shapes the response into the MCP output schema.
- * No business logic — orchestration lives in apps/api B6.
+ * The tool adopted the API, arguments and results (#7171 — the operator's
+ * decision of 2026-10-19). Its input IS the route's `leadSubmitBodySchema`
+ * (the catalog registers the same shape, so the SDK has already parsed the
+ * arguments against it; the `safeParse` here keeps the stdio path and the
+ * `invalid_input` branch honest), the parsed body is posted as the agent
+ * sent it — no `siteId`, no stamped `source`, no wrapping — and the route's
+ * 201 body `{ id, persisted, email }` comes back unchanged. One addition
+ * survives, because it is deployment attribution rather than an argument:
+ * the spoke marker `payload.site` from `AILK_LEAD_SITE` (#7397), spread LAST
+ * over the agent's `payload` as the site's own writer
+ * (`apps/web/src/lib/lead-write.ts`) does; unset or blank, the payload goes
+ * as sent. No business logic — orchestration lives in apps/api.
  *
  * Paired with captureLeadAction Server Action per ADR 0013.
  */
@@ -11,21 +20,21 @@
 import { apiClient } from "@working-theory/api-client";
 import {
   LEAD_SITE_MARKER_KEY,
-  submitLeadInputSchema,
-  submitLeadOutputSchema,
-  type SubmitLeadInput,
-  type SubmitLeadOutput,
+  leadSubmitBodySchema,
+  leadWriteOutputSchema,
+  type LeadSubmitBody,
+  type LeadWriteOutput,
 } from "@working-theory/validation";
 
 import { visitorForwardHeadersForThisCall } from "../request-context.js";
 
-export { submitLeadInputSchema, submitLeadOutputSchema };
-export type { SubmitLeadInput, SubmitLeadOutput };
+export { leadSubmitBodySchema, leadWriteOutputSchema };
+export type { LeadSubmitBody, LeadWriteOutput };
 
 export async function ailkCaptureLead(
-  input: SubmitLeadInput,
-): Promise<SubmitLeadOutput> {
-  const parsed = submitLeadInputSchema.safeParse(input);
+  input: LeadSubmitBody,
+): Promise<LeadWriteOutput> {
+  const parsed = leadSubmitBodySchema.safeParse(input);
   if (!parsed.success) {
     return {
       ok: false,
@@ -33,21 +42,14 @@ export async function ailkCaptureLead(
     };
   }
 
-  const { name, email, message, phone } = parsed.data;
-  const siteId = process.env.AILK_SITE_ID ?? "default";
-  // The spoke marker (#7397) — unset or blank leaves the payload unmarked.
+  // The spoke marker (#7397) — unset or blank leaves the payload as sent.
   const site = process.env.AILK_LEAD_SITE?.trim();
-  const body = {
-    siteId,
-    source: "mcp",
-    email,
-    payload: {
-      name,
-      ...(message !== undefined && { message }),
-      ...(phone !== undefined && { phone }),
-      ...(site && { [LEAD_SITE_MARKER_KEY]: site }),
-    },
-  };
+  const body = site
+    ? {
+        ...parsed.data,
+        payload: { ...parsed.data.payload, [LEAD_SITE_MARKER_KEY]: site },
+      }
+    : parsed.data;
 
   // #8073 — forward the address the transport trusted (never an identity
   // argument on this tool's own schema) so the hub counts the write in that
@@ -60,5 +62,5 @@ export async function ailkCaptureLead(
     return { ok: false, error: { kind: "api_error", status: res.status } };
   }
 
-  return { ok: true, id: res.body.id, persisted: res.body.persisted };
+  return res.body;
 }

package/templates/apps/mcp/src/tools/get_offerings.ts

@@ -2,26 +2,45 @@
  * get_offerings — returns Services and/or Products as a unified offerings array.
  *
  * Pure read: resolves its adapter through `getMcpContentAdapter()` — the one
- * resolver seam (#5805, ADR 0011), MDX by default.
- * Lists pages of type "Service" and/or "Product" and shapes them into a
- * unified offerings array. Optionally filtered by type.
+ * resolver seam (#5805, ADR 0011), MDX by default — and answers through
+ * `listOfferings` (`@working-theory/content-adapters`), which lists pages of
+ * type "Service" and/or "Product" and shapes them into a unified offerings
+ * array. Optionally filtered by type.
+ *
+ * HTTP twin (#7177): `GET /v1/content/offerings` in `apps/api` takes the same
+ * arguments and answers through the same `listOfferings` — the shared seam
+ * the pair proves parity at. The tool still reads content locally, so it
+ * needs no API to answer.
  *
  * Phase 3 S3: optional `locale` parameter (BCP-47). Validated against the
  * project's allowlist; invalid or unknown values silently fall back to the
  * default locale (AC-i18n-07). Lists are locale-scoped.
  *
  * The offering fields (#5838) — `provider`, `categories`, `price` and
- * `priceCurrency` — come off the page's own frontmatter, the same shape the
- * listing card renders from. `price` and `priceCurrency` are `null` (never a
- * fabricated zero) for a listing that declares no price, and `categories` is
- * `[]` for one that is untagged.
+ * `priceCurrency` — come off the page's own frontmatter; `listOfferings`
+ * documents the mapping.
+ *
+ * Offerings (#8933, spec D8): when the site sells through its connected
+ * Stripe catalog and `type` is not `service`, the tool answers the Service
+ * pages followed by the workspace's Offerings shown set, in place of the
+ * Product pages — read over HTTP by `lib/shown-offerings.ts` (D6: only on a
+ * `claimed` host, at most `MCP_SHOWN_SET_BUDGET_MS`) and mapped by
+ * `listOfferingsWithShownSet`, the function the twin route answers through
+ * too, so each shown product also carries `prices` (every price with its
+ * interval and full lookup key). Names, descriptions and prices are
+ * seller-provided data returned as plain JSON values (T5). `type: "service"`,
+ * an unclaimed host, a workspace with no current set, a failed read or a
+ * mapping that throws answers the page content below, unchanged.
  *
  * Input:  { type?: 'service' | 'product', locale?: string }
- * Output: { offerings: Array<{ name, description, category?, image?, provider, categories, price, priceCurrency }> }
+ * Output: { offerings: Array<{ name, description, category?, image?, provider, categories, price, priceCurrency, prices? }> }
  * Session/scope: none — read-only public content.
  */
 
-import { type SchemaOrgType } from "@working-theory/content-adapters";
+import {
+  listOfferings,
+  listOfferingsWithShownSet,
+} from "@working-theory/content-adapters";
 import {
   getOfferingsInputSchema,
   getOfferingsOutputSchema,
@@ -34,6 +53,10 @@ import {
   mcpContentRoot,
 } from "../lib/content-adapter.js";
 import { resolveLocale } from "../lib/resolve-locale.js";
+import {
+  mcpCurrentShownSet,
+  reportMappingFailure,
+} from "../lib/shown-offerings.js";
 
 export { getOfferingsInputSchema, getOfferingsOutputSchema };
 export type { GetOfferingsInput, GetOfferingsOutput };
@@ -54,26 +77,20 @@ export async function ailkGetOfferings(
   const locale = resolveLocale(input.locale);
   const adapter = getMcpContentAdapter({ contentRoot: root, locale });
 
-  const typesToFetch: SchemaOrgType[] = [];
-  if (!input.type || input.type === "service") typesToFetch.push("Service");
-  if (!input.type || input.type === "product") typesToFetch.push("Product");
-
-  const perType = await Promise.all(
-    typesToFetch.map((type) => adapter.listPages(type, locale)),
-  );
-
-  const offerings: GetOfferingsOutput["offerings"] = perType
-    .flat()
-    .map((page) => ({
-      name: page.title,
-      description: page.description,
-      category: page.schema?.["category"] as string | undefined,
-      image: page.image,
-      provider: page.provider ?? null,
-      categories: page.categories ?? [],
-      price: page.price ?? null,
-      priceCurrency: page.priceCurrency ?? null,
-    }));
+  if (input.type !== "service") {
+    const shownSet = await mcpCurrentShownSet();
+    if (shownSet !== null) {
+      try {
+        return await listOfferingsWithShownSet(
+          adapter,
+          { type: input.type, locale },
+          shownSet,
+        );
+      } catch (err) {
+        reportMappingFailure(err);
+      }
+    }
+  }
 
-  return getOfferingsOutputSchema.parse({ offerings });
+  return listOfferings(adapter, { type: input.type, locale });
 }