create-ailk 0.1.1 → 0.3.0

package/templates/apps/api/src/services/waitlist-scoring.ts

@@ -1,166 +0,0 @@
-/**
- * @file waitlist-scoring.ts
- * @description The Prisma-touching glue for the rules-layer scoring engine —
- * A2 (#4662 D6).
- *
- * `scoreCompletedSignup` is the ONE `prisma.waitlistScore.upsert` write path
- * in `apps/api` — one row per (lead, EXPERIMENT), re-scoring overwrites,
- * never appends (A1 D3, scoped per experiment by #5036 D6d: a visitor who
- * joins two founders' waitlists is one lead with two scores, and a
- * lead-only key let the second silently erase the first). It loads the owning `WaitlistExperiment`, parses its config,
- * evaluates via the pure `@working-theory/validation` evaluator, and
- * persists the result. Every failure mode (no experiment row, an invalid
- * config, an evaluator throw, a Prisma error) returns a typed outcome — it
- * never throws to its caller (`flow-engine.ts`'s `completeSubmission`, which
- * wraps the call in its own fail-soft try/catch as a residual net).
- *
- * PII boundary: logs carry only `{siteId, experimentKey, leadId, kind}` —
- * never an answer value or the assembled payload (mirrors
- * `waitlist-experiments.ts` / `flow-engine.ts`'s boundary).
- */
-
-import type { Prisma } from "@working-theory/database";
-import { logger } from "@working-theory/observability";
-import {
-  answersFromPayload,
-  evaluateWaitlistScoring,
-  waitlistExperimentConfigSchema,
-  type WaitlistFlags,
-} from "@working-theory/validation";
-
-import { prisma } from "../lib/prisma.js";
-
-import { compileAndStorePlaybook, TARGETING_MATURITY_EXPERIMENT_KEY } from "./playbook-compile.js";
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-export type ScoreCompletedSignupInput = {
-  siteId: string;
-  leadId: string;
-  experimentKey: string;
-  waitlistKey: string;
-  payload: Record<string, unknown>;
-  flags?: WaitlistFlags;
-};
-
-export type ScoreCompletedSignupSkipReason = "no_experiment" | "no_scoring";
-export type ScoreCompletedSignupErrorKind =
-  | "invalid_config"
-  | "evaluation_failed"
-  | "persist_failed";
-
-export type ScoreCompletedSignupResult =
-  | { ok: true; tier: string }
-  | { ok: true; skipped: ScoreCompletedSignupSkipReason }
-  | { ok: false; error: { kind: ScoreCompletedSignupErrorKind } };
-
-function errKindOf(err: unknown): string {
-  return err instanceof Error ? err.constructor.name : typeof err;
-}
-
-// ─── scoreCompletedSignup — the ONE write path (D6) ─────────────────────────
-
-/**
- * Load the `[siteId, experimentKey]` `WaitlistExperiment`, evaluate the
- * signup's answers against its `scoring` register (when declared), and
- * upsert exactly one `WaitlistScore` row on `[leadId]`.
- */
-export async function scoreCompletedSignup(
-  input: ScoreCompletedSignupInput,
-): Promise<ScoreCompletedSignupResult> {
-  const { siteId, leadId, experimentKey, waitlistKey, payload, flags } = input;
-
-  const row = await prisma.waitlistExperiment.findUnique({
-    where: { siteId_key: { siteId, key: experimentKey } },
-  });
-  if (!row) {
-    return { ok: true, skipped: "no_experiment" };
-  }
-
-  const parsed = waitlistExperimentConfigSchema.safeParse(row.config);
-  if (!parsed.success) {
-    logger.error(
-      { siteId, experimentKey, leadId, kind: "invalid_config" },
-      "[waitlist-scoring] experiment config failed validation (defensive — the row was validated on write)",
-    );
-    return { ok: false, error: { kind: "invalid_config" } };
-  }
-  const config = parsed.data;
-  if (!config.scoring) {
-    return { ok: true, skipped: "no_scoring" };
-  }
-
-  const answers = answersFromPayload(config.questionSet, payload);
-  let evaluation;
-  try {
-    evaluation = evaluateWaitlistScoring(config.scoring, answers, flags ?? {});
-  } catch (err) {
-    logger.error(
-      { siteId, experimentKey, leadId, kind: "evaluation_failed", errKind: errKindOf(err) },
-      "[waitlist-scoring] evaluation failed",
-    );
-    return { ok: false, error: { kind: "evaluation_failed" } };
-  }
-
-  let scoreRow;
-  try {
-    scoreRow = await prisma.waitlistScore.upsert({
-      where: { leadId_experimentKey: { leadId, experimentKey } },
-      create: {
-        siteId,
-        leadId,
-        experimentKey,
-        waitlistKey,
-        tier: evaluation.tier,
-        score: evaluation.score,
-        categoryScores: evaluation.categoryScores as unknown as Prisma.InputJsonValue,
-        ruleTrace: evaluation.ruleTrace as unknown as Prisma.InputJsonValue,
-      },
-      update: {
-        tier: evaluation.tier,
-        score: evaluation.score,
-        categoryScores: evaluation.categoryScores as unknown as Prisma.InputJsonValue,
-        ruleTrace: evaluation.ruleTrace as unknown as Prisma.InputJsonValue,
-      },
-    });
-  } catch (err) {
-    logger.error(
-      { siteId, experimentKey, leadId, kind: "persist_failed", errKind: errKindOf(err) },
-      "[waitlist-scoring] persist failed",
-    );
-    return { ok: false, error: { kind: "persist_failed" } };
-  }
-
-  // FEAT-074 U4a (#4715): the compile is the next link in this ONE write
-  // path (D4) — gated on experimentKey, fail-soft internally
-  // (compileAndStorePlaybook never throws by contract). The try/catch here
-  // is the residual safety net (mirrors flow-engine.ts's own "swallowed by
-  // design" fulfillment guard) — the score row above is ALREADY persisted,
-  // so a genuine escape here must never turn this already-successful score
-  // into a thrown failure this function's own header promises it never does.
-  if (experimentKey === TARGETING_MATURITY_EXPERIMENT_KEY) {
-    try {
-      await compileAndStorePlaybook({
-        siteId,
-        leadId,
-        experimentKey,
-        scoreId: scoreRow.id,
-        tier: evaluation.tier,
-        ruleTrace: evaluation.ruleTrace,
-      });
-    } catch (err) {
-      logger.error(
-        {
-          siteId,
-          experimentKey,
-          leadId,
-          kind: "playbook_compile_escaped",
-          errKind: errKindOf(err),
-        },
-        "[waitlist-scoring] compileAndStorePlaybook escaped its own fail-soft catch — the score is unaffected",
-      );
-    }
-  }
-
-  return { ok: true, tier: evaluation.tier };
-}

package/templates/apps/api/src/services/waitlist-signups.ts

@@ -1,165 +0,0 @@
-/**
- * @file waitlist-signups.ts
- * @description The respondent read (#4731 D2/D3/D4) — `readMySignup`, the
- * ONLY read path behind `GET /v1/waitlist-signups/me`: a signed-in,
- * email-verified user reads their OWN newest waitlist signup for one
- * experiment. Nothing here enumerates, nothing accepts an email, nothing
- * reads across sites.
- *
- * Mirrors `lead-promotion.ts` (ADR 0009 D3 service-layer pattern): the same
- * `User {id, email, emailVerified}` read, the same verified-email refusal
- * (D2 there — the consent basis for linking anonymous-lead PII to a user;
- * here a hard 403, evaluated BEFORE any Lead read), and a scalar-only join
- * to the inbox namespace by email — `Lead` carries no `@relation` (ADR 0009
- * invariant #1), so the read is four narrow queries, each scoped to
- * `currentSiteId()` (#4665 D3: the scope is a parameter of every query,
- * never a post-filter).
- *
- * Email normalization (#4731 D3, the contract's open question): the
- * respondent email is persisted AS TYPED — `flow-engine.ts`'s
- * `extractMappedEmail` and `lead-routing.ts`'s `persistToDb` neither trim
- * nor lower-case it (the boundary validator `z.string().email()` already
- * rejects surrounding whitespace). So the match is `lower(trim())` on both
- * sides: `equals` on the trimmed, lower-cased user email with
- * `mode: "insensitive"` for the stored value.
- *
- * PII boundary: logs carry only `{ siteId, experimentKey, leadId, kind }` —
- * never email, payload, or an answer value.
- */
-
-import { logger } from "@working-theory/observability";
-import {
-  aeoScoreResultSchema,
-  type WaitlistSignupMeResponse,
-} from "@working-theory/validation";
-
-import { prisma } from "../lib/prisma.js";
-import { currentSiteId } from "../lib/site.js";
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-export type ReadMySignupResult =
-  | { ok: true; value: WaitlistSignupMeResponse }
-  | {
-      ok: false;
-      error: {
-        kind: "not_found_user" | "email_unverified" | "signup_not_found";
-        message: string;
-      };
-    };
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-/** A string-valued payload key, or undefined when absent / not a string. */
-function readPayloadString(payload: unknown, key: string): string | undefined {
-  if (payload === null || typeof payload !== "object" || Array.isArray(payload)) return undefined;
-  const value = (payload as Record<string, unknown>)[key];
-  return typeof value === "string" ? value : undefined;
-}
-
-/** A schema-defensive read of the stored `FlowSession.aeoScore` JSON value (mirrors flow-engine.ts). */
-function readAeoScore(value: unknown): WaitlistSignupMeResponse["aeoScore"] {
-  if (value === null || value === undefined) return null;
-  const parsed = aeoScoreResultSchema.safeParse(value);
-  return parsed.success ? parsed.data : null;
-}
-
-const SIGNUP_NOT_FOUND: ReadMySignupResult = {
-  ok: false,
-  error: { kind: "signup_not_found", message: "Signup not found" },
-};
-
-// ─── Main export ──────────────────────────────────────────────────────────────
-
-/**
- * Read the calling user's newest signup for `experimentKey` at the current
- * site. `userId` is the auth preHandler's `request.userId` — the ONLY
- * identity input; `experimentKey` is boundary-validated by the route.
- *
- * Result kinds (the route maps them to HTTP):
- *   - `not_found_user`   — no `User` row for `userId` (404 on the wire).
- *   - `email_unverified` — `User.emailVerified !== true`; refused BEFORE any
- *                          Lead read (403).
- *   - `signup_not_found` — no `Lead` at this site with this user's email and
- *                          this `experimentKey` (or a corrupt row missing
- *                          `waitlistKey`) (404).
- */
-export async function readMySignup(
-  userId: string,
-  experimentKey: string,
-): Promise<ReadMySignupResult> {
-  const siteId = currentSiteId();
-
-  // D2 — the exact read lead-promotion.ts performs, mirrored not forked.
-  const user = await prisma.user.findUnique({
-    where: { id: userId },
-    select: { id: true, email: true, emailVerified: true },
-  });
-  if (!user) {
-    return { ok: false, error: { kind: "not_found_user", message: "User not found" } };
-  }
-
-  // D2 — the verified-email gate is a service-level invariant: an unverified
-  // address never reaches a Lead read, whatever the call site.
-  if (user.emailVerified !== true) {
-    return {
-      ok: false,
-      error: { kind: "email_unverified", message: "Verify your email to view your signup" },
-    };
-  }
-
-  // D3 — lower(trim()) on both sides; D4 — scoped, newest wins.
-  const lead = await prisma.lead.findFirst({
-    where: {
-      siteId,
-      email: { equals: user.email.trim().toLowerCase(), mode: "insensitive" },
-      payload: { path: ["experimentKey"], equals: experimentKey },
-    },
-    orderBy: { createdAt: "desc" },
-    select: { id: true, payload: true, createdAt: true },
-  });
-  if (!lead) return SIGNUP_NOT_FOUND;
-
-  // `waitlistKey` is server-written LAST beside `experimentKey` (flow-engine
-  // D4) — a lead carrying one without the other is corrupt data, treated as
-  // not-found rather than emitting an out-of-contract value (the
-  // waitlist-dashboard.ts `getSignup` posture, PR #4687).
-  const waitlistKey = readPayloadString(lead.payload, "waitlistKey");
-  if (!waitlistKey) {
-    logger.warn(
-      { siteId, experimentKey, leadId: lead.id, kind: "missing_waitlist_key" },
-      "[waitlist-signups] signup missing waitlistKey — treating as not_found",
-    );
-    return SIGNUP_NOT_FOUND;
-  }
-
-  // D4 — `@@unique([leadId, experimentKey])` (#5036 D6d); the scope ANDed in,
-  // never a post-filter.
-  const scoreRow = await prisma.waitlistScore.findFirst({
-    where: { leadId: lead.id, siteId, experimentKey },
-    select: { tier: true, score: true },
-  });
-
-  // D4 — the completing session (leadId is stamped in the same completion
-  // call that created the lead). Fallback to Lead.createdAt if absent (D5).
-  const session = await prisma.flowSession.findFirst({
-    where: { leadId: lead.id, siteId, completedAt: { not: null } },
-    orderBy: { completedAt: "desc" },
-    select: { aeoScore: true, completedAt: true },
-  });
-
-  // D5 — seven fields, nothing more. `waitlistKey` and `q3` are the ONLY
-  // payload keys that leave the row.
-  return {
-    ok: true,
-    value: {
-      experimentKey,
-      waitlistKey,
-      completedAt: (session?.completedAt ?? lead.createdAt).toISOString(),
-      tier: scoreRow?.tier ?? null,
-      score: scoreRow?.score ?? null,
-      aeoScore: readAeoScore(session?.aeoScore),
-      answers: { q3: readPayloadString(lead.payload, "q3") ?? null },
-    },
-  };
-}

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

@@ -1,242 +0,0 @@
-// oss: false
-/**
- * Tests for the list_availability + get_event_meta + create_booking MCP
- * tools (#4416, #4633).
- *
- * The claim these tools make is PARITY OF CODE, not just of endpoint: an
- * agent that hits a taken slot must read `slot_unavailable`, the same word
- * the route emitted and the same word the booker section branches on. Most of
- * what follows pins that mapping.
- */
-
-import { ailkCreateBooking } from "../src/tools/create_booking.js";
-import { ailkGetEventMeta } from "../src/tools/get_event_meta.js";
-import {
-  ailkListAvailability,
-  schedulingKindFromStatus,
-} from "../src/tools/list_availability.js";
-
-jest.mock("@working-theory/api-client", () => ({
-  apiClient: {
-    schedule: {
-      availability: jest.fn(),
-      eventMeta: jest.fn(),
-      book: jest.fn(),
-    },
-  },
-}));
-
-const { apiClient } = require("@working-theory/api-client") as {
-  apiClient: {
-    schedule: { availability: jest.Mock; eventMeta: jest.Mock; book: jest.Mock };
-  };
-};
-
-const VALID_RANGE = {
-  calLink: "sam/fit-check",
-  from: "2026-08-26T00:00:00.000Z",
-  to: "2026-09-02T00:00:00.000Z",
-};
-
-const AVAILABILITY = {
-  event: {
-    title: "15-Minute Call with Sam",
-    durationMinutes: 15,
-    meetingType: "Google Meet",
-    timeZone: "America/Denver",
-  },
-  slots: [
-    { start: "2026-08-27T16:00:00.000Z", end: "2026-08-27T16:15:00.000Z" },
-  ],
-};
-
-beforeEach(() => {
-  jest.clearAllMocks();
-});
-
-describe("schedulingKindFromStatus", () => {
-  it.each([
-    [400, "invalid_input"],
-    [404, "event_not_found"],
-    [409, "slot_unavailable"],
-    [503, "not_configured"],
-    [502, "provider_error"],
-    [500, "provider_error"],
-  ])("maps %i to %s", (status, kind) => {
-    expect(schedulingKindFromStatus(status as number)).toBe(kind);
-  });
-});
-
-describe("ailkListAvailability", () => {
-  it("rejects a malformed calLink without calling api-client", async () => {
-    const result = await ailkListAvailability({
-      ...VALID_RANGE,
-      calLink: "https://cal.com/sam/fit-check",
-    });
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.error.kind).toBe("invalid_input");
-    expect(apiClient.schedule.availability).not.toHaveBeenCalled();
-  });
-
-  it("rejects a range wider than the 60-day cap without calling api-client", async () => {
-    const result = await ailkListAvailability({
-      ...VALID_RANGE,
-      to: "2027-08-26T00:00:00.000Z",
-    });
-
-    expect(result.ok).toBe(false);
-    expect(apiClient.schedule.availability).not.toHaveBeenCalled();
-  });
-
-  it("forwards the validated range and returns the derived event meta", async () => {
-    apiClient.schedule.availability.mockResolvedValueOnce({
-      ok: true,
-      body: AVAILABILITY,
-    });
-
-    const result = await ailkListAvailability(VALID_RANGE);
-
-    expect(apiClient.schedule.availability).toHaveBeenCalledWith(VALID_RANGE);
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.data.event.durationMinutes).toBe(15);
-      expect(result.data.slots).toHaveLength(1);
-    }
-  });
-
-  it("surfaces an unconfigured deploy as not_configured, not a bare status", async () => {
-    apiClient.schedule.availability.mockResolvedValueOnce({
-      ok: false,
-      status: 503,
-      body: null,
-    });
-
-    const result = await ailkListAvailability(VALID_RANGE);
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.error.kind).toBe("not_configured");
-  });
-});
-
-describe("ailkGetEventMeta", () => {
-  const EVENTS = {
-    events: [
-      {
-        calLink: "sam/fit-check",
-        event: {
-          title: "15-Minute Call with Sam",
-          durationMinutes: 15,
-          price: { amountMinor: 0, currency: "usd" },
-          timeZone: "America/Denver",
-        },
-      },
-      {
-        calLink: "sam/power-hour",
-        event: {
-          title: "Power Hour",
-          durationMinutes: 60,
-          description: "Sixty focused minutes on your positioning.",
-          price: { amountMinor: 25000, currency: "usd" },
-          timeZone: "America/Denver",
-        },
-      },
-    ],
-  };
-
-  it("rejects a malformed link in the list without calling api-client", async () => {
-    const result = await ailkGetEventMeta({
-      calLinks: "sam/fit-check,https://cal.com/sam/power-hour",
-    });
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.error.kind).toBe("invalid_input");
-    expect(apiClient.schedule.eventMeta).not.toHaveBeenCalled();
-  });
-
-  it("forwards the links and returns meta only — a free and a priced event", async () => {
-    apiClient.schedule.eventMeta.mockResolvedValueOnce({
-      ok: true,
-      body: EVENTS,
-    });
-
-    const result = await ailkGetEventMeta({
-      calLinks: "sam/fit-check,sam/power-hour",
-    });
-
-    expect(apiClient.schedule.eventMeta).toHaveBeenCalledWith({
-      calLinks: "sam/fit-check,sam/power-hour",
-    });
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.data.events).toHaveLength(2);
-      expect(result.data.events[0]?.event.price?.amountMinor).toBe(0);
-      expect(result.data.events[1]?.event.price?.amountMinor).toBe(25000);
-      expect(result.data.events[1]?.event.description).toBe(
-        "Sixty focused minutes on your positioning.",
-      );
-    }
-  });
-
-  it("surfaces an unconfigured deploy as not_configured, not a bare status", async () => {
-    apiClient.schedule.eventMeta.mockResolvedValueOnce({
-      ok: false,
-      status: 503,
-      body: null,
-    });
-
-    const result = await ailkGetEventMeta({ calLinks: "sam/fit-check" });
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.error.kind).toBe("not_configured");
-  });
-});
-
-describe("ailkCreateBooking", () => {
-  const VALID_BOOKING = {
-    calLink: "sam/fit-check",
-    start: "2026-08-27T16:00:00.000Z",
-    attendee: { name: "Sam Rivera", email: "sam@example.com" },
-  };
-
-  it("rejects a malformed attendee email without calling api-client", async () => {
-    const result = await ailkCreateBooking({
-      ...VALID_BOOKING,
-      attendee: { name: "Sam Rivera", email: "sam@" },
-    });
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.error.kind).toBe("invalid_input");
-    expect(apiClient.schedule.book).not.toHaveBeenCalled();
-  });
-
-  it("forwards the booking and returns the provider's identifier", async () => {
-    apiClient.schedule.book.mockResolvedValueOnce({
-      ok: true,
-      body: {
-        bookingId: "bkg_9",
-        start: "2026-08-27T16:00:00.000Z",
-        end: "2026-08-27T16:15:00.000Z",
-      },
-    });
-
-    const result = await ailkCreateBooking(VALID_BOOKING);
-
-    expect(apiClient.schedule.book).toHaveBeenCalledWith(VALID_BOOKING);
-    expect(result.ok).toBe(true);
-    if (result.ok) expect(result.data.bookingId).toBe("bkg_9");
-  });
-
-  it("surfaces a lost race as slot_unavailable so the caller can retry another slot", async () => {
-    apiClient.schedule.book.mockResolvedValueOnce({
-      ok: false,
-      status: 409,
-      body: null,
-    });
-
-    const result = await ailkCreateBooking(VALID_BOOKING);
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.error.kind).toBe("slot_unavailable");
-  });
-});

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

@@ -1,58 +0,0 @@
-// oss: false
-/**
- * create_booking — book one open slot for an attendee (#4416).
- *
- * The MCP twin of `POST /v1/schedule/book` (API↔MCP parity, root CLAUDE.md).
- * Validates input via Zod, forwards through `@working-theory/api-client`, and
- * shapes the response into the MCP output schema. No business logic and no
- * credential — the scheduling key lives in apps/api.
- *
- * MCP-only anonymous write, the posture `subscribe_newsletter` and
- * `request_callback` already established: an agent booking on a prospect's
- * behalf has no session. Listed in `MCP_ONLY_TOOLS` in
- * apps/mcp/__tests__/parity.test.ts.
- *
- * `slot_unavailable` is the interesting failure and is surfaced verbatim: a
- * caller that races another booker should re-read availability and retry with
- * a different slot, exactly as the `booker` section's UI does.
- *
- * Input:  { calLink, start, attendee: { name, email, timeZone?, notes? } }
- * Output: { ok: true, data: { bookingId, start, end, meetingUrl? } }
- *       | { ok: false, error: { kind } }
- * Session/scope: none — anonymous, identity-blind (apps/mcp/CLAUDE.md).
- */
-
-import { apiClient } from "@working-theory/api-client";
-import {
-  createBookingInputSchema,
-  createBookingOutputSchema,
-  type CreateBookingInput,
-  type CreateBookingOutput,
-} from "@working-theory/validation";
-
-import { schedulingKindFromStatus } from "./list_availability.js";
-
-export { createBookingInputSchema, createBookingOutputSchema };
-export type { CreateBookingInput, CreateBookingOutput };
-
-export async function ailkCreateBooking(
-  input: CreateBookingInput,
-): Promise<CreateBookingOutput> {
-  const parsed = createBookingInputSchema.safeParse(input);
-  if (!parsed.success) {
-    return {
-      ok: false,
-      error: {
-        kind: "invalid_input",
-        message: parsed.error.issues[0]?.message ?? "Invalid input.",
-      },
-    };
-  }
-
-  const res = await apiClient.schedule.book(parsed.data);
-  if (!res.ok) {
-    return { ok: false, error: { kind: schedulingKindFromStatus(res.status) } };
-  }
-
-  return createBookingOutputSchema.parse({ ok: true, data: res.body });
-}

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

@@ -1,55 +0,0 @@
-// oss: false
-/**
- * get_event_meta — read one or more events' derived meta, no slots (#4633).
- *
- * The MCP twin of `GET /v1/schedule/event-meta` (API↔MCP parity, root
- * CLAUDE.md). Exists for the same reason the route does: rendering an event's
- * facts (title, duration, description, price) must not cost an availability
- * window per event. Validates input via Zod, forwards through
- * `@working-theory/api-client`, and shapes the response into the MCP output
- * schema. No business logic and no credential — the scheduling key lives in
- * apps/api.
- *
- * MCP-only — no web Server Action twin, same posture as `list_availability`:
- * a tile-rendering page is an RSC calling the HTTP route via api-client, not
- * a form. Listed in `MCP_ONLY_TOOLS` in apps/mcp/__tests__/parity.test.ts.
- *
- * Input:  { calLinks } — comma-separated `"<owner>/<event-slug>"` links
- * Output: { ok: true, data: { events } } | { ok: false, error: { kind } }
- * Session/scope: none — anonymous, identity-blind (apps/mcp/CLAUDE.md).
- */
-
-import { apiClient } from "@working-theory/api-client";
-import {
-  getEventMetaInputSchema,
-  getEventMetaOutputSchema,
-  type GetEventMetaInput,
-  type GetEventMetaOutput,
-} from "@working-theory/validation";
-
-import { schedulingKindFromStatus } from "./list_availability.js";
-
-export { getEventMetaInputSchema, getEventMetaOutputSchema };
-export type { GetEventMetaInput, GetEventMetaOutput };
-
-export async function ailkGetEventMeta(
-  input: GetEventMetaInput,
-): Promise<GetEventMetaOutput> {
-  const parsed = getEventMetaInputSchema.safeParse(input);
-  if (!parsed.success) {
-    return {
-      ok: false,
-      error: {
-        kind: "invalid_input",
-        message: parsed.error.issues[0]?.message ?? "Invalid input.",
-      },
-    };
-  }
-
-  const res = await apiClient.schedule.eventMeta(parsed.data);
-  if (!res.ok) {
-    return { ok: false, error: { kind: schedulingKindFromStatus(res.status) } };
-  }
-
-  return getEventMetaOutputSchema.parse({ ok: true, data: res.body });
-}