create-ailk 0.7.0 → 0.8.0

package/templates/apps/api/src/lib/__tests__/lead-capture-store.test.ts

@@ -96,6 +96,36 @@ describe("appendLeadRecord", () => {
     expect(filePath).toMatch(/leads\.jsonl$/);
   });
 
+  // #6730 D3 — the default file is local-only: in production it does not
+  // outlive a serverless instance, so it is skipped unless explicitly pointed
+  // at a durable path.
+  describe("in production (#6730 D3)", () => {
+    const savedNodeEnv = process.env.NODE_ENV;
+    afterEach(() => {
+      process.env.NODE_ENV = savedNodeEnv;
+    });
+
+    it("skips the write when LEAD_CAPTURE_FILE is unset", async () => {
+      process.env.NODE_ENV = "production";
+
+      const result = await appendLeadRecord(record);
+
+      expect(result).toEqual({ ok: true, skipped: true });
+      expect(mockAppendFile).not.toHaveBeenCalled();
+    });
+
+    it("writes when LEAD_CAPTURE_FILE is set explicitly", async () => {
+      process.env.NODE_ENV = "production";
+      process.env.LEAD_CAPTURE_FILE = "/data/leads.jsonl";
+
+      const result = await appendLeadRecord(record);
+
+      expect(result).toEqual({ ok: true });
+      expect(mockAppendFile).toHaveBeenCalledTimes(1);
+      expect(mockAppendFile.mock.calls[0][0]).toBe("/data/leads.jsonl");
+    });
+  });
+
   // AC4 — LEAD_CAPTURE_FILE_DISABLED=true skips the write
   it("short-circuits write when LEAD_CAPTURE_FILE_DISABLED=true", async () => {
     process.env.LEAD_CAPTURE_FILE_DISABLED = "true";

package/templates/apps/api/src/lib/__tests__/lead-delivery.test.ts

@@ -0,0 +1,96 @@
+/**
+ * @file lead-delivery.test.ts
+ * @description The #6730 D1 delivery table, row by row.
+ */
+
+import { acceptsKind, resolveLeadDelivery } from "../lead-delivery";
+
+const EMAIL = {
+  RESEND_API_KEY: "re_test",
+  AILK_LEAD_NOTIFICATION_TO: "owner@example.com",
+  AILK_LEAD_NOTIFICATION_FROM: "noreply@example.com",
+};
+
+describe("resolveLeadDelivery", () => {
+  it("DATABASE_URL alone → inbox", () => {
+    expect(resolveLeadDelivery({ DATABASE_URL: "postgres://x", NODE_ENV: "production" })).toBe(
+      "inbox",
+    );
+  });
+
+  it("DATABASE_URL wins over the email vars", () => {
+    expect(resolveLeadDelivery({ DATABASE_URL: "postgres://x", ...EMAIL })).toBe("inbox");
+  });
+
+  it("the three email vars, no database → email", () => {
+    expect(resolveLeadDelivery({ ...EMAIL, NODE_ENV: "production" })).toBe("email");
+    expect(resolveLeadDelivery({ ...EMAIL, NODE_ENV: "development" })).toBe("email");
+  });
+
+  it("a bare RESEND_API_KEY is not email delivery — local in dev, none in production", () => {
+    expect(resolveLeadDelivery({ RESEND_API_KEY: "re_test", NODE_ENV: "development" })).toBe(
+      "local",
+    );
+    expect(resolveLeadDelivery({ RESEND_API_KEY: "re_test", NODE_ENV: "production" })).toBe(
+      "none",
+    );
+  });
+
+  it("the key and one address only → not email", () => {
+    expect(
+      resolveLeadDelivery({
+        RESEND_API_KEY: "re_test",
+        AILK_LEAD_NOTIFICATION_TO: "owner@example.com",
+        NODE_ENV: "production",
+      }),
+    ).toBe("none");
+  });
+
+  it("nothing configured in production → none", () => {
+    expect(resolveLeadDelivery({ NODE_ENV: "production" })).toBe("none");
+  });
+
+  it("nothing configured outside production → local", () => {
+    expect(resolveLeadDelivery({ NODE_ENV: "test" })).toBe("local");
+    expect(resolveLeadDelivery({})).toBe("local");
+  });
+
+  it("LEAD_CAPTURE_FILE_DISABLED=true removes the local path → none", () => {
+    expect(
+      resolveLeadDelivery({ NODE_ENV: "development", LEAD_CAPTURE_FILE_DISABLED: "true" }),
+    ).toBe("none");
+  });
+
+  it("reads process.env by default", () => {
+    const saved = process.env.DATABASE_URL;
+    process.env.DATABASE_URL = "postgres://x";
+    try {
+      expect(resolveLeadDelivery()).toBe("inbox");
+    } finally {
+      if (saved === undefined) delete process.env.DATABASE_URL;
+      else process.env.DATABASE_URL = saved;
+    }
+  });
+});
+
+describe("acceptsKind", () => {
+  it("none accepts nothing", () => {
+    expect(acceptsKind("none", "submit")).toBe(false);
+    expect(acceptsKind("none", "subscribe")).toBe(false);
+    expect(acceptsKind("none", "callback")).toBe(false);
+  });
+
+  it("email accepts submit and callback, never subscribe", () => {
+    expect(acceptsKind("email", "submit")).toBe(true);
+    expect(acceptsKind("email", "callback")).toBe(true);
+    expect(acceptsKind("email", "subscribe")).toBe(false);
+  });
+
+  it("inbox and local accept every kind", () => {
+    for (const d of ["inbox", "local"] as const) {
+      expect(acceptsKind(d, "submit")).toBe(true);
+      expect(acceptsKind(d, "subscribe")).toBe(true);
+      expect(acceptsKind(d, "callback")).toBe(true);
+    }
+  });
+});

package/templates/apps/api/src/lib/lead-capture-store.ts

@@ -12,6 +12,15 @@
  *
  * Env vars (all read inside function bodies — module is import-side-effect-free):
  *   LEAD_CAPTURE_FILE            — output path (default: apps/api/leads.jsonl relative to cwd)
+ *
+ * The default path is LOCAL-ONLY (#6730 D3). In production
+ * (`NODE_ENV=production`) with `LEAD_CAPTURE_FILE` unset, the write is skipped:
+ * on serverless hosting a file under the process cwd does not outlive the
+ * instance, so it is not a record of anything. An operator with a durable
+ * volume can keep a side copy by setting `LEAD_CAPTURE_FILE` explicitly —
+ * a copy only: in production it never makes a lead count as delivered
+ * (`lib/lead-delivery.ts` needs a database or the email vars).
+ *
  *   LEAD_CAPTURE_FILE_DISABLED   — set to "true" to skip writes (opt-out)
  *   LEAD_CAPTURE_INCLUDE_IP      — set to "true" to include metadata.ip in the record
  *
@@ -47,6 +56,9 @@ export async function appendLeadRecord(
   if (disabled) {
     return { ok: true, skipped: true };
   }
+  if (process.env.NODE_ENV === "production" && !process.env.LEAD_CAPTURE_FILE) {
+    return { ok: true, skipped: true };
+  }
 
   const includeIp = process.env.LEAD_CAPTURE_INCLUDE_IP === "true";
   const outputPath = resolveOutputPath();

package/templates/apps/api/src/lib/lead-delivery.ts

@@ -0,0 +1,52 @@
+/**
+ * @file lead-delivery.ts
+ * @description Where a captured lead goes, resolved from the environment (#6730 D1).
+ *
+ *   inbox — `DATABASE_URL` is set: the database is the destination (the lead
+ *           inbox at `/leads`); the owner email is still sent best-effort.
+ *   email — no database, but `RESEND_API_KEY` plus both notification
+ *           addresses are set: the owner email IS the delivery.
+ *   local — neither, outside production (`pnpm dev`, tests): the local file
+ *           fallback + `leads.jsonl`, so local work needs nothing configured.
+ *   none  — neither, in production: nothing is accepted, so no visitor is
+ *           ever told a message was sent when it reached nobody.
+ *
+ * A key alone delivers nothing (`sendEmail()` also needs both addresses), so
+ * it is not counted as configured. `LEAD_CAPTURE_FILE_DISABLED=true` removes
+ * the local file path, so outside production it resolves to `none` too.
+ *
+ * Import-side-effect-free; the environment is read at call time.
+ */
+
+export type LeadDelivery = "inbox" | "email" | "local" | "none";
+
+export type LeadDeliveryKind = "submit" | "subscribe" | "callback";
+
+export function resolveLeadDelivery(
+  env: NodeJS.ProcessEnv = process.env,
+): LeadDelivery {
+  if (env.DATABASE_URL) return "inbox";
+  if (
+    env.RESEND_API_KEY &&
+    env.AILK_LEAD_NOTIFICATION_TO &&
+    env.AILK_LEAD_NOTIFICATION_FROM
+  ) {
+    return "email";
+  }
+  if (env.NODE_ENV !== "production" && env.LEAD_CAPTURE_FILE_DISABLED !== "true") {
+    return "local";
+  }
+  return "none";
+}
+
+/**
+ * Whether a delivery mode accepts a lead of this kind. A newsletter
+ * subscription is a list entry, not a message — emailing the owner one
+ * address per signup is not a list — so `subscribe` needs somewhere to keep
+ * it (the database, or the local file in development).
+ */
+export function acceptsKind(d: LeadDelivery, kind: LeadDeliveryKind): boolean {
+  if (d === "none") return false;
+  if (kind === "subscribe") return d === "inbox" || d === "local";
+  return true;
+}

package/templates/apps/api/src/openapi/spec.ts

@@ -747,9 +747,11 @@ export function buildOpenApiSpec(
             "form fields — for the given siteId. `source` is a free-form tag the caller " +
             "sets to identify the channel (for example `agent`); it is stored as-is and " +
             "not checked against a fixed vocabulary. A 201 response means the lead " +
-            "landed, in the database or (if the database is unavailable) a file " +
-            "fallback; the response's `email` field reports, best-effort, whether the " +
-            "site operator was notified.",
+            "landed — in the database, a local file fallback (outside production " +
+            "only), or, on a deployment with no database, the site operator's inbox " +
+            "by email (`persisted: \"email\"`); with a database, the response's " +
+            "`email` field reports, best-effort, whether the operator was notified. " +
+            "A lead is never reported captured when nothing stored or delivered it.",
           requestBody: {
             required: true,
             content: {
@@ -777,8 +779,8 @@ export function buildOpenApiSpec(
             },
             "503": {
               description:
-                "Lead capture unavailable — persistence failed, or neither file " +
-                "capture nor a database is configured",
+                "Lead capture unavailable — persistence failed, delivery failed, or " +
+                "this deployment has nowhere to put the lead",
               content: {
                 "application/json": {
                   schema: {
@@ -787,6 +789,7 @@ export function buildOpenApiSpec(
                       {
                         $ref: "#/components/schemas/LeadCaptureNotConfiguredResponse",
                       },
+                      { $ref: "#/components/schemas/DeliveryFailedResponse" },
                     ],
                   },
                 },
@@ -795,6 +798,36 @@ export function buildOpenApiSpec(
           },
         },
       },
+      "/v1/leads/capture": {
+        get: {
+          operationId: "getLeadCaptureStatus",
+          summary: "Whether this site accepts a contact message or a signup",
+          description:
+            "Two booleans: `contact` — a `POST /v1/leads/submit` would be accepted; " +
+            "`newsletter` — a `POST /v1/leads/subscribe` would be. A web page reads " +
+            "it to show the contact form or the site's contact email. It never says " +
+            "how a lead is delivered. No MCP twin (recorded parity exception): the " +
+            "three lead-write tools already answer the same question with a 503.",
+          responses: {
+            "200": {
+              description: "Lead-capture status",
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    required: ["ok", "data"],
+                    properties: {
+                      ok: { type: "boolean", enum: [true] },
+                      data: { $ref: "#/components/schemas/LeadCaptureStatus" },
+                    },
+                  },
+                },
+              },
+            },
+            "429": { $ref: "#/components/responses/RateLimited" },
+          },
+        },
+      },
       "/v1/leads/subscribe": {
         post: {
           operationId: "subscribeLead",
@@ -833,8 +866,8 @@ export function buildOpenApiSpec(
             },
             "503": {
               description:
-                "Lead capture unavailable — persistence failed, or neither file " +
-                "capture nor a database is configured",
+                "Lead capture unavailable — persistence failed, delivery failed, or " +
+                "this deployment has nowhere to put the lead",
               content: {
                 "application/json": {
                   schema: {
@@ -1033,8 +1066,8 @@ export function buildOpenApiSpec(
             },
             "503": {
               description:
-                "Lead capture unavailable — persistence failed, or neither file " +
-                "capture nor a database is configured",
+                "Lead capture unavailable — persistence failed, delivery failed, or " +
+                "this deployment has nowhere to put the lead",
               content: {
                 "application/json": {
                   schema: {
@@ -1043,6 +1076,7 @@ export function buildOpenApiSpec(
                       {
                         $ref: "#/components/schemas/LeadCaptureNotConfiguredResponse",
                       },
+                      { $ref: "#/components/schemas/DeliveryFailedResponse" },
                     ],
                   },
                 },
@@ -1489,10 +1523,11 @@ export function buildOpenApiSpec(
               type: "string",
               description:
                 "Server-assigned record id — a DB-prefixed entity id when " +
-                'persisted is "db", or a `fallback-<ts>-<rand>` file id when ' +
-                'persisted is "file"',
+                'persisted is "db", a `fallback-<ts>-<rand>` file id when ' +
+                'persisted is "file", or an `email-<ts>-<rand>` id when persisted ' +
+                'is "email" (no database; the operator email was the delivery)',
             },
-            persisted: { type: "string", enum: ["db", "file"] },
+            persisted: { type: "string", enum: ["db", "file", "email"] },
             email: { $ref: "#/components/schemas/LeadEmailResult" },
           },
         },
@@ -1511,6 +1546,22 @@ export function buildOpenApiSpec(
             error: { type: "string", enum: ["persist_failed"] },
           },
         },
+        DeliveryFailedResponse: {
+          type: "object",
+          required: ["error", "message"],
+          properties: {
+            error: { type: "string", enum: ["delivery_failed"] },
+            message: { type: "string" },
+          },
+        },
+        LeadCaptureStatus: {
+          type: "object",
+          required: ["contact", "newsletter"],
+          properties: {
+            contact: { type: "boolean" },
+            newsletter: { type: "boolean" },
+          },
+        },
         LeadCaptureNotConfiguredResponse: {
           type: "object",
           required: ["error", "message"],

package/templates/apps/api/src/routes/leads/__tests__/capture.test.ts

@@ -0,0 +1,88 @@
+/**
+ * @file capture.test.ts
+ * `GET /v1/leads/capture` (#6730 D4) — the four D1 environments, and the
+ * body's exact shape: two booleans, never the mode or an env name.
+ */
+
+import type { FastifyInstance } from "fastify";
+
+// The route module also carries the write routes; their dependencies are
+// external boundaries this read never reaches.
+// eslint-disable-next-line no-restricted-syntax -- prisma is a DB boundary; __mocks__/prisma.ts is the repo-standard double
+jest.mock("../../../lib/prisma.js");
+jest.mock("@working-theory/email", () => ({
+  sendLeadNotification: jest.fn(),
+  sendRequestConfirmEmail: jest.fn(),
+  sendRequestPaidLinkEmail: jest.fn(),
+}));
+
+import { leadCaptureStatusRoute } from "../index";
+
+const ENV_KEYS = [
+  "DATABASE_URL",
+  "NODE_ENV",
+  "RESEND_API_KEY",
+  "AILK_LEAD_NOTIFICATION_TO",
+  "AILK_LEAD_NOTIFICATION_FROM",
+  "LEAD_CAPTURE_FILE_DISABLED",
+] as const;
+
+const EMAIL_ENV = {
+  RESEND_API_KEY: "re_test",
+  AILK_LEAD_NOTIFICATION_TO: "owner@example.com",
+  AILK_LEAD_NOTIFICATION_FROM: "noreply@example.com",
+};
+
+describe("GET /v1/leads/capture", () => {
+  let app: FastifyInstance;
+  let saved: Partial<Record<(typeof ENV_KEYS)[number], string | undefined>>;
+
+  beforeEach(async () => {
+    saved = {};
+    for (const k of ENV_KEYS) saved[k] = process.env[k];
+    for (const k of ENV_KEYS) delete process.env[k];
+    const fastify = require("fastify")();
+    await fastify.register(leadCaptureStatusRoute);
+    app = fastify;
+  });
+
+  afterEach(async () => {
+    await app.close();
+    for (const k of ENV_KEYS) {
+      if (saved[k] === undefined) delete process.env[k];
+      else process.env[k] = saved[k];
+    }
+  });
+
+  const get = () => app.inject({ method: "GET", url: "/v1/leads/capture" });
+
+  it.each([
+    ["inbox", { DATABASE_URL: "postgres://x", NODE_ENV: "production" }, true, true],
+    ["email", { ...EMAIL_ENV, NODE_ENV: "production" }, true, false],
+    ["local", { NODE_ENV: "development" }, true, true],
+    ["none", { NODE_ENV: "production" }, false, false],
+  ] as const)("%s → contact=%s newsletter=%s", async (_mode, env, contact, newsletter) => {
+    Object.assign(process.env, env);
+
+    const res = await get();
+
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toEqual({ ok: true, data: { contact, newsletter } });
+  });
+
+  it("the body carries exactly ok + data{contact,newsletter} — no mode, no env names", async () => {
+    Object.assign(process.env, EMAIL_ENV, { NODE_ENV: "production" });
+
+    const res = await get();
+    const body = res.json();
+
+    expect(Object.keys(body).sort()).toEqual(["data", "ok"]);
+    expect(Object.keys(body.data).sort()).toEqual(["contact", "newsletter"]);
+    expect(res.body).not.toMatch(/email|inbox|RESEND|DATABASE|owner@example\.com/);
+  });
+
+  it("is cacheable for a minute", async () => {
+    const res = await get();
+    expect(res.headers["cache-control"]).toBe("public, max-age=60");
+  });
+});

package/templates/apps/api/src/routes/leads/__tests__/index.test.ts

@@ -1236,3 +1236,103 @@ describe("#6335 — the shared prisma mock declares no workspace default", () =>
     });
   });
 });
+
+// ─── #6730 D2/D5 — email delivery and the production refusal, over HTTP ─────
+
+describe("POST /v1/leads/submit — #6730 delivery modes", () => {
+  let app: FastifyInstance;
+  const ENV_KEYS = [
+    "DATABASE_URL",
+    "NODE_ENV",
+    "RESEND_API_KEY",
+    "AILK_LEAD_NOTIFICATION_TO",
+    "AILK_LEAD_NOTIFICATION_FROM",
+    "LEAD_CAPTURE_FILE",
+    "AILK_INBOX_FALLBACK_DIR",
+  ] as const;
+  let saved: Partial<Record<(typeof ENV_KEYS)[number], string | undefined>>;
+  const sendLeadNotification = jest.requireMock("@working-theory/email")
+    .sendLeadNotification as jest.Mock;
+  const writeLeadFallbackSpy = jest.spyOn(
+    jest.requireActual("../../../lib/file-fallback.js"),
+    "writeLeadFallback",
+  );
+
+  const submit = () =>
+    app.inject({
+      method: "POST",
+      url: "/v1/leads/submit",
+      payload: {
+        kind: "submit",
+        source: "contact",
+        email: "visitor@example.com",
+        payload: { message: "hello" },
+      },
+    });
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    saved = {};
+    for (const k of ENV_KEYS) saved[k] = process.env[k];
+    for (const k of ENV_KEYS) delete process.env[k];
+    process.env.NODE_ENV = "production";
+    const fastify = require("fastify")();
+    await fastify.register(leadSubmitRoute);
+    app = fastify;
+  });
+
+  afterEach(async () => {
+    await app.close();
+    for (const k of ENV_KEYS) {
+      if (saved[k] === undefined) delete process.env[k];
+      else process.env[k] = saved[k];
+    }
+  });
+
+  describe("email delivery (no DATABASE_URL, the three email vars)", () => {
+    beforeEach(() => {
+      process.env.RESEND_API_KEY = "re_test";
+      process.env.AILK_LEAD_NOTIFICATION_TO = "owner@example.com";
+      process.env.AILK_LEAD_NOTIFICATION_FROM = "noreply@example.com";
+    });
+
+    it("an accepted email → 201 persisted:email; no Prisma write", async () => {
+      sendLeadNotification.mockResolvedValueOnce({ ok: true, messageId: "msg-e" });
+
+      const res = await submit();
+
+      expect(res.statusCode).toBe(201);
+      expect(res.json()).toMatchObject({ persisted: "email" });
+      expect(res.json().id).toMatch(/^email-/);
+      expect(prisma.lead.create).not.toHaveBeenCalled();
+      expect(sendLeadNotification).toHaveBeenCalledTimes(1);
+      expect(sendLeadNotification.mock.calls[0][0].recipientEmail).toBe("owner@example.com");
+    });
+
+    it("a refused email → 503 delivery_failed, never 201", async () => {
+      sendLeadNotification.mockResolvedValueOnce({
+        ok: false,
+        error: { kind: "provider_error", message: "rejected" },
+      });
+
+      const res = await submit();
+
+      expect(res.statusCode).toBe(503);
+      expect(res.json()).toEqual({
+        error: "delivery_failed",
+        message: "The message could not be delivered.",
+      });
+    });
+  });
+
+  it("production with neither → 503 lead_capture_not_configured; no Prisma, no file, no email", async () => {
+    const res = await submit();
+
+    expect(res.statusCode).toBe(503);
+    expect(res.json().error).toBe("lead_capture_not_configured");
+    expect(prisma.lead.create).not.toHaveBeenCalled();
+    expect(writeLeadFallbackSpy).not.toHaveBeenCalled();
+    expect(sendLeadNotification).not.toHaveBeenCalled();
+    await expect(fs.access(fileEnv.getCaptureFilePath())).rejects.toThrow();
+  });
+});

package/templates/apps/api/src/routes/leads/index.ts

@@ -5,6 +5,16 @@
  *   POST /v1/leads/submit    — lead submission (contact form / inquiry)
  *   POST /v1/leads/subscribe — newsletter subscription
  *   POST /v1/leads/callback  — callback request (phone-back)
+ *   GET  /v1/leads/capture   — whether this deployment accepts a contact
+ *                              message / a newsletter signup (#6730 D4)
+ *
+ * API↔MCP PARITY — `GET /v1/leads/capture` has NO MCP twin, a recorded
+ * exception on the same footing as the anonymous form-lifecycle routes. It
+ * exists so a web page can choose between the form and the contact email
+ * before rendering; an agent never needs that preflight, because the three
+ * write tools (`capture_lead`, `subscribe_newsletter`, `request_callback`)
+ * already return a typed `api_error` carrying the 503 when capture is not
+ * accepted — the same answer, at the moment it matters.
  *
  * TENANT RESOLUTION (#6203, spec §10.4 operator ruling — reverses this
  * file's former byte-unchanged posture). `siteId` used to be taken VERBATIM
@@ -24,6 +34,7 @@
 import { track } from "@working-theory/analytics/server";
 import type { FastifyPluginAsync } from "fastify";
 
+import { acceptsKind, resolveLeadDelivery } from "../../lib/lead-delivery.js";
 import { currentSiteId, resolveSiteWorkspaceId } from "../../lib/site.js";
 import {
   type LeadKind,
@@ -175,7 +186,20 @@ function makeLeadsRoute(kind: LeadKind): FastifyPluginAsync {
           );
           return reply.status(503).send({ error: "persist_failed" });
         }
-        // config_missing — lead capture not configured (file disabled + no DB)
+        if (result.error.kind === "delivery_failed") {
+          // Email was the delivery and the provider did not accept it —
+          // never reported as sent (#6730 D5). Detail stays server-side.
+          // `{ kind, siteId }` only (spec D5): provider error text can echo
+          // an address.
+          request.log.error({ kind, siteId: workspaceId }, "lead delivery_failed");
+          return reply.status(503).send({
+            error: "delivery_failed",
+            message: "The message could not be delivered.",
+          });
+        }
+        // config_missing — this deployment has nowhere to put this kind of
+        // lead (#6730 D1: production with neither a database nor the email
+        // vars, or a newsletter signup with no database).
         return reply.status(503).send({
           error: "lead_capture_not_configured",
           message: "Lead capture is not configured.",
@@ -249,3 +273,24 @@ function makeLeadsRoute(kind: LeadKind): FastifyPluginAsync {
 export const leadSubmitRoute = makeLeadsRoute("submit");
 export const leadSubscribeRoute = makeLeadsRoute("subscribe");
 export const leadCallbackRoute = makeLeadsRoute("callback");
+
+/**
+ * `GET /v1/leads/capture` (#6730 D4) — two booleans and nothing else: never
+ * an address or which env var is missing. (The pair implies as much of the
+ * delivery mode as the rendered page already shows.) Registered at
+ * the top level in `server.ts`, outside `leadsScope`'s strict per-IP limit
+ * (a web server's single egress IP already spends that on form submissions),
+ * so only the server-wide unauthenticated ceiling applies.
+ */
+export const leadCaptureStatusRoute: FastifyPluginAsync = async (fastify) => {
+  fastify.get("/v1/leads/capture", async (_request, reply) => {
+    const delivery = resolveLeadDelivery();
+    return reply.header("Cache-Control", "public, max-age=60").send({
+      ok: true,
+      data: {
+        contact: acceptsKind(delivery, "submit"),
+        newsletter: acceptsKind(delivery, "subscribe"),
+      },
+    });
+  });
+};

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

@@ -58,6 +58,7 @@ import {
 import { searchContentRoute } from "./routes/content/search.js";
 import {
   leadCallbackRoute,
+  leadCaptureStatusRoute,
   leadSubmitRoute,
   leadSubscribeRoute,
 } from "./routes/leads/index.js";
@@ -1145,6 +1146,12 @@ export async function build() {
     await authEmailScope.register(transactionalEmailRoute);
   });
 
+  // Lead-capture status (#6730 D4) — a cheap read the web page makes before
+  // choosing the form or the contact email. Top level, NOT in `leadsScope`:
+  // the web server's single egress IP already spends that scope's strict
+  // 10/min on form submissions. The global unauth ceiling above applies.
+  await server.register(leadCaptureStatusRoute);
+
   // Leads routes — rate-limit middleware scoped to this sub-router. Own
   // default (10/min, pre-#4730) rather than inheriting the wider
   // flows-sized default (#5111, DEF-004 — #4730's shared-default bump was