create-ailk 0.2.0 → 0.4.0

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

@@ -1,61 +0,0 @@
-/**
- * get_flow — serve a validated flow config (#3956 D7).
- *
- * Validates input via Zod, forwards to GET /v1/flows/:slug via
- * @working-theory/api-client, and shapes the response into the MCP output
- * schema. No business logic — orchestration lives in apps/api (flow-engine.ts).
- *
- * Both routes are agent-callable (a chat agent can serve and walk a flow) —
- * the input/output schemas are the SAME `@working-theory/validation` schemas
- * the HTTP route itself validates against (D7 — no simplified MCP-only
- * shape, unlike capture_lead's decoupled input). The `getFlowOutputSchema`
- * export covers the success shape; the error branch below is composed
- * locally (mcp-tool-catalog.ts can only import from `@working-theory/validation`,
- * not from this file, so the catalog's outputShape stays the plain success
- * schema — the same best-effort-documentation shape `read_content`'s
- * `.nullable()` output already carries for its own not-found branch).
- */
-
-import { apiClient } from "@working-theory/api-client";
-import {
-  flowSlugSchema,
-  getFlowOutputSchema,
-  type FlowConfig,
-} from "@working-theory/validation";
-import { z } from "zod";
-
-export const getFlowInputSchema = z.object({
-  slug: flowSlugSchema,
-});
-
-export { getFlowOutputSchema };
-
-export type GetFlowInput = z.infer<typeof getFlowInputSchema>;
-
-export type AilkGetFlowOutput =
-  | { ok: true; data: FlowConfig }
-  | {
-      ok: false;
-      error:
-        | { kind: "invalid_input"; issues: unknown[] }
-        | { kind: "api_error"; status: number };
-    };
-
-export async function ailkGetFlow(
-  input: GetFlowInput,
-): Promise<AilkGetFlowOutput> {
-  const parsed = getFlowInputSchema.safeParse(input);
-  if (!parsed.success) {
-    return {
-      ok: false,
-      error: { kind: "invalid_input", issues: parsed.error.issues },
-    };
-  }
-
-  const res = await apiClient.flows.get(parsed.data.slug);
-  if (!res.ok) {
-    return { ok: false, error: { kind: "api_error", status: res.status } };
-  }
-
-  return { ok: true, data: res.body };
-}

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

@@ -1,67 +0,0 @@
-// oss: false
-/**
- * list_availability — read open booking slots for an event (#4416).
- *
- * The MCP twin of `GET /v1/schedule/availability` (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, so an agent gets the same answer a browser does without ever
- * being near it.
- *
- * MCP-only — there is no web Server Action twin. The `booker` section is a
- * client island that calls the HTTP route directly (the ContactForm /
- * StepFlow pattern), so this tool exists to give agents the same read, not to
- * back a web form. Listed in `MCP_ONLY_TOOLS` in apps/mcp/__tests__/parity.test.ts.
- *
- * Input:  { calLink, from, to, timeZone? }
- * Output: { ok: true, data: { event, slots } } | { ok: false, error: { kind } }
- * Session/scope: none — anonymous, identity-blind (apps/mcp/CLAUDE.md).
- */
-
-import { apiClient } from "@working-theory/api-client";
-import {
-  listAvailabilityInputSchema,
-  listAvailabilityOutputSchema,
-  type ListAvailabilityInput,
-  type ListAvailabilityOutput,
-  type SchedulingErrorKind,
-} from "@working-theory/validation";
-
-export { listAvailabilityInputSchema, listAvailabilityOutputSchema };
-export type { ListAvailabilityInput, ListAvailabilityOutput };
-
-/**
- * Map the route's HTTP status back to the shared error vocabulary, so an
- * agent reads the SAME `kind` the route emitted rather than a bare number.
- * Parity is on the code, not just the endpoint (apps/api/CLAUDE.md).
- */
-export function schedulingKindFromStatus(status: number): SchedulingErrorKind {
-  if (status === 400) return "invalid_input";
-  if (status === 404) return "event_not_found";
-  if (status === 409) return "slot_unavailable";
-  if (status === 503) return "not_configured";
-  return "provider_error";
-}
-
-export async function ailkListAvailability(
-  input: ListAvailabilityInput,
-): Promise<ListAvailabilityOutput> {
-  const parsed = listAvailabilityInputSchema.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.availability(parsed.data);
-  if (!res.ok) {
-    return { ok: false, error: { kind: schedulingKindFromStatus(res.status) } };
-  }
-
-  return listAvailabilityOutputSchema.parse({ ok: true, data: res.body });
-}

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

@@ -1,83 +0,0 @@
-/**
- * submit_flow_step — submit one step's answers (#3956 D7).
- *
- * Validates input via Zod, forwards to POST /v1/flows/:slug/steps via
- * @working-theory/api-client, and shapes the response into the MCP output
- * schema. No business logic — orchestration lives in apps/api (flow-engine.ts).
- *
- * The input shape composes `submitFlowStepInputSchema.shape` (D1's exact
- * field validators — sessionId/stepKey/values/locale) with the `slug` the
- * flat MCP input needs in place of the route's URL path segment. Same D7
- * "reuse the route's own schemas" contract as get_flow — the catalog's
- * outputShape stays the plain success schema for the same layering reason
- * documented there.
- */
-
-import { apiClient } from "@working-theory/api-client";
-import {
-  flowSlugSchema,
-  submitFlowStepInputSchema,
-  submitFlowStepOutputSchema,
-  type AeoScoreResult,
-} from "@working-theory/validation";
-import { z } from "zod";
-
-export const submitFlowStepInputSchemaForTool = z
-  .object({
-    slug: flowSlugSchema,
-    ...submitFlowStepInputSchema.shape,
-  })
-  .strict();
-
-export { submitFlowStepOutputSchema };
-
-export type SubmitFlowStepInput = z.infer<
-  typeof submitFlowStepInputSchemaForTool
->;
-
-export type AilkSubmitFlowStepOutput =
-  | {
-      ok: true;
-      data: {
-        sessionId: string;
-        landed: string;
-        nextStepKey: string | null;
-        completed: boolean;
-        leadId?: string;
-        /** Server-derived segment (#3959 D6) — present from the segmentation-step response onward. */
-        segment?: string;
-        /** D9 (#4663) — present on the aeo_score step's own response AND on the completion response when the flow declares one. */
-        aeoScore?: AeoScoreResult;
-      };
-    }
-  | {
-      ok: false;
-      error:
-        | { kind: "invalid_input"; issues: unknown[] }
-        | { kind: "api_error"; status: number };
-    };
-
-export async function ailkSubmitFlowStep(
-  input: SubmitFlowStepInput,
-): Promise<AilkSubmitFlowStepOutput> {
-  const parsed = submitFlowStepInputSchemaForTool.safeParse(input);
-  if (!parsed.success) {
-    return {
-      ok: false,
-      error: { kind: "invalid_input", issues: parsed.error.issues },
-    };
-  }
-
-  const { slug, sessionId, stepKey, values, locale } = parsed.data;
-  const res = await apiClient.flows.submitStep(slug, {
-    ...(sessionId !== undefined && { sessionId }),
-    stepKey,
-    values,
-    ...(locale !== undefined && { locale }),
-  });
-  if (!res.ok) {
-    return { ok: false, error: { kind: "api_error", status: res.status } };
-  }
-
-  return { ok: true, data: res.body };
-}

package/templates/apps/web/app/[locale]/(authed)/waitlist/[experimentId]/page.tsx

@@ -1,309 +0,0 @@
-/**
- * /[locale]/waitlist/[experimentId] — the operator dashboard's comparison
- * view + paginated signups (#4665 D10, AC2/AC4).
- *
- * RSC: reads `GET /v1/waitlist-experiments/:experimentId` (comparison) and
- * `GET …/signups` (paginated) through `@working-theory/api-client`'s
- * `waitlistExperiments` namespace, forwarding the caller's cookie session.
- * A 404 calls `notFound()`; a 401/403 renders `ForbiddenState`.
- */
-
-import { waitlistExperiments } from "@working-theory/api-client";
-import {
-  DescriptionList,
-  DetailHeader,
-  MetricComparisonTable,
-} from "@working-theory/ui/blocks";
-import { Container } from "@working-theory/ui/primitives";
-import type {
-  WaitlistExperimentComparison,
-  WaitlistMetricRow,
-} from "@working-theory/validation";
-import { resolveLocalizedString } from "@working-theory/validation";
-import type { Metadata } from "next";
-import { notFound } from "next/navigation";
-import { getTranslations } from "next-intl/server";
-import { isValidElement } from "react";
-import type { ReactElement } from "react";
-
-import { ApiError, forwardedCookieInit, unwrapApiResult } from "../../../../../lib/server-api";
-import { ForbiddenState } from "../components/ForbiddenState";
-import { SignupsTable } from "../components/SignupsTable";
-import { ExperimentModeBadge, ExperimentStatusBadge } from "../components/status-badges";
-import type { WaitlistTab } from "../components/WaitlistComparisonTabs";
-import { WaitlistComparisonTabs } from "../components/WaitlistComparisonTabs";
-import { formatCount, formatDateTime, formatRate, targetingMaturityLevel } from "../format";
-
-const DEFAULT_LOCALE = "en";
-
-interface Props {
-  params: Promise<{ locale: string; experimentId: string }>;
-  searchParams: Promise<{ waitlist?: string; cursor?: string }>;
-}
-
-export async function generateMetadata({ params }: Props): Promise<Metadata> {
-  const { locale, experimentId } = await params;
-  const t = await getTranslations({ locale, namespace: "waitlistDashboard.comparison" });
-
-  try {
-    const comparison = await unwrapApiResult(
-      waitlistExperiments.comparison(experimentId, await forwardedCookieInit()),
-    );
-    return { title: comparison.experiment.key };
-  } catch (err) {
-    // A genuine 404 gets the "not found" title; any other failure (a
-    // network error, a 401/403, a 500) gets a neutral fallback rather than
-    // misreporting a real backend error as "this doesn't exist" (#4665
-    // code-review finding).
-    if (err instanceof ApiError && err.status === 404) {
-      return { title: t("notFoundHeadline") };
-    }
-    return { title: t("genericTitle") };
-  }
-}
-
-function metricCell(
-  row: WaitlistMetricRow,
-  kind: "raw" | "qualified" | "rate" | { tier: string },
-  locale: string,
-  unavailable: string,
-): { display: string; value: number | null } {
-  if (kind === "raw") return { display: formatCount(row.raw, locale), value: row.raw };
-  if (kind === "qualified") {
-    return row.qualified === null
-      ? { display: unavailable, value: null }
-      : { display: formatCount(row.qualified, locale), value: row.qualified };
-  }
-  if (kind === "rate") {
-    return { display: formatRate(row.qualificationRate, locale), value: row.qualificationRate };
-  }
-  const found = row.byTier.find((t) => t.tier === kind.tier);
-  const count = found?.count ?? 0;
-  return { display: formatCount(count, locale), value: count };
-}
-
-export default async function WaitlistComparisonPage({
-  params,
-  searchParams,
-}: Props): Promise<ReactElement> {
-  const { locale, experimentId } = await params;
-  const { waitlist: waitlistFilter, cursor } = await searchParams;
-  const t = await getTranslations({ locale, namespace: "waitlistDashboard" });
-  const unavailable = t("common.unavailable");
-
-  const init = await forwardedCookieInit();
-
-  // Shared error mapping for every read on this page — the comparison AND the
-  // signups reads must both degrade the same way (404 -> notFound(), 401/403
-  // -> ForbiddenState) rather than only the first read being guarded (#4665
-  // code-review finding: an unguarded second fetch throws straight to the
-  // route's generic error boundary instead of matching the first read's
-  // handling).
-  async function readOrRespond<T>(
-    result: Promise<T>,
-  ): Promise<T | ReactElement> {
-    try {
-      return await result;
-    } catch (err) {
-      if (err instanceof ApiError) {
-        if (err.status === 404) notFound();
-        if (err.status === 401 || err.status === 403) {
-          return (
-            <ForbiddenState
-              headline={t("common.forbiddenHeadline")}
-              description={t("common.forbiddenDescription")}
-            />
-          );
-        }
-      }
-      throw err;
-    }
-  }
-
-  const comparisonOrResponse = await readOrRespond(
-    unwrapApiResult(waitlistExperiments.comparison(experimentId, init)),
-  );
-  if (isValidElement(comparisonOrResponse)) return comparisonOrResponse;
-  const comparison: WaitlistExperimentComparison = comparisonOrResponse;
-
-  const signupsOrResponse = await readOrRespond(
-    unwrapApiResult(
-      waitlistExperiments.signups(
-        experimentId,
-        {
-          ...(waitlistFilter ? { waitlist: waitlistFilter } : {}),
-          ...(cursor ? { cursor } : {}),
-        },
-        init,
-      ),
-    ),
-  );
-  if (isValidElement(signupsOrResponse)) return signupsOrResponse;
-  const signupsResult = signupsOrResponse;
-
-  // ── Top comparison table (columns = waitlists + total) ────────────────────
-  const columns = [
-    ...comparison.waitlists.map((w) => ({ key: w.key, label: w.key })),
-    { key: "total", label: t("comparison.columnTotal") },
-  ];
-  const allMetricRows = [...comparison.waitlists, comparison.total];
-  const tierKeys = Array.from(
-    new Set(allMetricRows.flatMap((row) => row.byTier.map((tier) => tier.tier))),
-  );
-
-  const cellsFor = (kind: "raw" | "qualified" | "rate" | { tier: string }) => {
-    const cells: Record<string, { display: string; value: number | null }> = {};
-    for (const w of comparison.waitlists) cells[w.key] = metricCell(w, kind, locale, unavailable);
-    cells.total = metricCell(comparison.total, kind, locale, unavailable);
-    return cells;
-  };
-
-  const topRows = [
-    { key: "raw", label: t("comparison.rowRaw"), cells: cellsFor("raw") },
-    { key: "qualified", label: t("comparison.rowQualified"), cells: cellsFor("qualified") },
-    { key: "rate", label: t("comparison.rowRate"), cells: cellsFor("rate") },
-    // AC-5 — the Level distribution: for targeting-maturity, each row's
-    // label is its Level ("Level N" / the Gate label), never the raw
-    // `level_N` tier string; every other experiment renders exactly as
-    // before (targetingMaturityLevel returns null — D5, byte-unchanged floor).
-    ...tierKeys.map((tier) => {
-      const level = targetingMaturityLevel(tier, comparison.experiment.key);
-      const label =
-        level === null
-          ? `${t("comparison.tierRowPrefix")}: ${tier}`
-          : level === 0
-            ? t("level.gate")
-            : t("level.label", { n: level });
-      return { key: `tier-${tier}`, label, cells: cellsFor({ tier }) };
-    }),
-  ];
-
-  // ── Per-waitlist tabs (by-source table + per-question distributions) ──────
-  const tabs: WaitlistTab[] = comparison.waitlists.map((row) => ({
-    key: row.key,
-    label: row.key,
-    bySourceCaption: t("comparison.bySourceCaption"),
-    bySourceRowHeaderLabel: t("comparison.bySourceColumnSource"),
-    bySourceColumns: [
-      { key: "raw", label: t("comparison.bySourceColumnRaw") },
-      { key: "qualified", label: t("comparison.bySourceColumnQualified") },
-      { key: "rate", label: t("comparison.bySourceColumnRate") },
-    ],
-    bySourceRows: row.bySource.map((source) => ({
-      key: source.source,
-      label: source.source,
-      cells: {
-        raw: { display: formatCount(source.raw, locale), value: source.raw },
-        qualified:
-          source.qualified === null
-            ? { display: unavailable, value: null }
-            : { display: formatCount(source.qualified, locale), value: source.qualified },
-        rate: { display: formatRate(source.qualificationRate, locale), value: source.qualificationRate },
-      },
-    })),
-    distributions: row.distributions.map((distribution) => {
-      const question = comparison.questions.find((q) => q.id === distribution.questionId);
-      const prompt = question
-        ? resolveLocalizedString(question.prompt, locale, DEFAULT_LOCALE)
-        : distribution.questionId;
-      return {
-        questionId: distribution.questionId,
-        title: prompt,
-        answered: distribution.answered,
-        answeredLabel: t("comparison.distributionAnswered", { count: distribution.answered }),
-        emptyLabel: t("comparison.distributionNoAnswers"),
-        items: distribution.options.map((option) => {
-          const declared = question?.options?.find((o) => o.value === option.value);
-          const label = declared
-            ? resolveLocalizedString(declared.label, locale, DEFAULT_LOCALE)
-            : option.value;
-          return {
-            label,
-            count: option.count,
-            share: option.share,
-            display: formatRate(option.share, locale),
-          };
-        }),
-      };
-    }),
-  }));
-
-  const signupRows = signupsResult.items.map((signup) => {
-    const level = targetingMaturityLevel(signup.tier, comparison.experiment.key);
-    const tierDisplay =
-      level === null ? signup.tier : level === 0 ? t("level.gate") : t("level.label", { n: level });
-    return {
-      signup,
-      created: formatDateTime(signup.createdAt, locale),
-      score: signup.score === null ? null : formatCount(signup.score, locale),
-      tierDisplay,
-    };
-  });
-
-  return (
-    <main className="min-h-screen bg-surface text-fg" data-testid="waitlist-comparison-page">
-      <DetailHeader
-        breadcrumb={[
-          { label: t("comparison.breadcrumbExperiments"), href: `/${locale}/waitlist` },
-          { label: comparison.experiment.key },
-        ]}
-        title={comparison.experiment.key}
-        typeBadge={
-          <div className="flex gap-2">
-            <ExperimentModeBadge
-              mode={comparison.experiment.mode}
-              label={t(`mode.${comparison.experiment.mode}`)}
-            />
-            <ExperimentStatusBadge
-              status={comparison.experiment.status}
-              label={t(`status.${comparison.experiment.status}`)}
-            />
-          </div>
-        }
-      />
-      <Container className="flex flex-col gap-8 py-section">
-        <DescriptionList
-          items={[
-            { label: t("comparison.site"), value: comparison.experiment.siteId },
-            {
-              label: t("comparison.created"),
-              value: formatDateTime(comparison.experiment.createdAt, locale),
-            },
-            {
-              label: t("comparison.waitlistsCount"),
-              value: String(comparison.experiment.waitlists.length),
-            },
-          ]}
-        />
-
-        <MetricComparisonTable
-          caption={t("comparison.tableCaption")}
-          columns={columns}
-          rows={topRows}
-          emphasisColumnKey="total"
-        />
-
-        <WaitlistComparisonTabs tabs={tabs} />
-
-        <SignupsTable
-          locale={locale}
-          experimentId={experimentId}
-          {...(waitlistFilter ? { waitlist: waitlistFilter } : {})}
-          rows={signupRows}
-          nextCursor={signupsResult.nextCursor}
-          labels={{
-            caption: t("comparison.signupsCaption"),
-            columnEmail: t("comparison.signupsColumnEmail"),
-            columnWaitlist: t("comparison.signupsColumnWaitlist"),
-            columnSource: t("comparison.signupsColumnSource"),
-            columnCreated: t("comparison.signupsColumnCreated"),
-            columnTier: t("comparison.signupsColumnTier"),
-            columnScore: t("comparison.signupsColumnScore"),
-            unavailable,
-            next: t("comparison.signupsNext"),
-          }}
-        />
-      </Container>
-    </main>
-  );
-}

package/templates/apps/web/app/[locale]/(authed)/waitlist/[experimentId]/signups/[leadId]/page.tsx

@@ -1,149 +0,0 @@
-/**
- * /[locale]/waitlist/[experimentId]/signups/[leadId] — the operator
- * dashboard's signup drill-down view (#4665 D10, AC3).
- *
- * RSC: reads `GET …/signups/:leadId` through
- * `@working-theory/api-client`'s `waitlistExperiments.signup`, forwarding
- * the caller's cookie session. A 404 calls `notFound()`; a 401/403 renders
- * `ForbiddenState`.
- */
-
-import { waitlistExperiments } from "@working-theory/api-client";
-import { DescriptionList, DetailHeader } from "@working-theory/ui/blocks";
-import { Container } from "@working-theory/ui/primitives";
-import { resolveLocalizedString } from "@working-theory/validation";
-import type { Metadata } from "next";
-import { notFound } from "next/navigation";
-import { getTranslations } from "next-intl/server";
-import type { ReactElement } from "react";
-
-import { ApiError, forwardedCookieInit, unwrapApiResult } from "../../../../../../../lib/server-api";
-import { ForbiddenState } from "../../../components/ForbiddenState";
-import { ScoreTrace } from "../../../components/ScoreTrace";
-import { decidingDefsFor, formatCount, formatDateTime } from "../../../format";
-
-const DEFAULT_LOCALE = "en";
-
-interface Props {
-  params: Promise<{ locale: string; experimentId: string; leadId: string }>;
-}
-
-export async function generateMetadata({ params }: Props): Promise<Metadata> {
-  const { locale, experimentId, leadId } = await params;
-  const t = await getTranslations({ locale, namespace: "waitlistDashboard.signup" });
-
-  try {
-    const signup = await unwrapApiResult(
-      waitlistExperiments.signup(experimentId, leadId, await forwardedCookieInit()),
-    );
-    return { title: signup.email };
-  } catch (err) {
-    // A genuine 404 gets the "not found" title; any other failure gets a
-    // neutral fallback rather than misreporting a real backend error as
-    // "this doesn't exist" (#4665 code-review finding).
-    if (err instanceof ApiError && err.status === 404) {
-      return { title: t("notFoundHeadline") };
-    }
-    return { title: t("genericTitle") };
-  }
-}
-
-export default async function WaitlistSignupPage({ params }: Props): Promise<ReactElement> {
-  const { locale, experimentId, leadId } = await params;
-  const t = await getTranslations({ locale, namespace: "waitlistDashboard" });
-
-  let signup;
-  try {
-    signup = await unwrapApiResult(
-      waitlistExperiments.signup(experimentId, leadId, await forwardedCookieInit()),
-    );
-  } catch (err) {
-    if (err instanceof ApiError) {
-      if (err.status === 404) notFound();
-      if (err.status === 401 || err.status === 403) {
-        return (
-          <ForbiddenState
-            headline={t("common.forbiddenHeadline")}
-            description={t("common.forbiddenDescription")}
-          />
-        );
-      }
-    }
-    throw err;
-  }
-
-  return (
-    <main className="min-h-screen bg-surface text-fg" data-testid="waitlist-signup-page">
-      <DetailHeader
-        breadcrumb={[
-          { label: t("comparison.breadcrumbExperiments"), href: `/${locale}/waitlist` },
-          {
-            label: t("signup.breadcrumbComparison"),
-            href: `/${locale}/waitlist/${experimentId}`,
-          },
-          { label: signup.email },
-        ]}
-        title={signup.email}
-      />
-      <Container className="flex flex-col gap-8 py-section">
-        <DescriptionList
-          items={[
-            { label: t("signup.email"), value: signup.email },
-            { label: t("signup.waitlist"), value: signup.waitlistKey },
-            { label: t("signup.source"), value: signup.source },
-            { label: t("signup.captured"), value: formatDateTime(signup.createdAt, locale) },
-          ]}
-        />
-
-        <div>
-          <p className="mb-2 text-body-sm font-semibold text-(--color-fg)">
-            {t("signup.answersTitle")}
-          </p>
-          <DescriptionList
-            items={signup.answers.map((answer) => ({
-              label: resolveLocalizedString(answer.prompt, locale, DEFAULT_LOCALE),
-              value:
-                answer.value === null
-                  ? t("common.unavailable")
-                  : Array.isArray(answer.value)
-                    ? answer.value.join(", ")
-                    : answer.value,
-            }))}
-          />
-        </div>
-
-        <ScoreTrace
-          score={signup.score}
-          {...(signup.score !== null
-            ? {
-                scoreDisplay: formatCount(signup.score.score, locale),
-                categoryScores: Object.entries(signup.score.categoryScores).map(
-                  ([category, value]) => ({
-                    label: category,
-                    display: formatCount(value, locale),
-                  }),
-                ),
-                // AC-5 — targeting-maturity only (decidingDefsFor scopes
-                // internally); [] for every other experiment renders no
-                // section, byte-unchanged from before this unit.
-                decidingDefs: decidingDefsFor(
-                  signup.score.tier,
-                  signup.score.ruleTrace,
-                  signup.experimentKey,
-                ),
-              }
-            : {})}
-          labels={{
-            tier: t("signup.tier"),
-            score: t("signup.score"),
-            categoryScoresTitle: t("signup.categoryScoresTitle"),
-            decidingDefsTitle: t("signup.decidingDefsTitle"),
-            ruleTraceTitle: t("signup.ruleTraceTitle"),
-            notScoredHeadline: t("signup.notScoredHeadline"),
-            notScoredDescription: t("signup.notScoredDescription"),
-          }}
-        />
-      </Container>
-    </main>
-  );
-}