create-ailk 0.1.1 → 0.2.0

package/templates/apps/api/src/routes/project-listings/__tests__/site-key.test.ts

@@ -109,6 +109,17 @@ function installStore(): void {
     },
   );
 
+  // #5275 — the grant write `start` makes after the row. Append-only; it only
+  // needs to resolve here (drafts.test.ts asserts on what it is called with).
+  (prisma.consentGrant.createMany as jest.Mock).mockImplementation(
+    ({ data }: { data: Row[] }) => Promise.resolve({ count: data.length }),
+  );
+
+  // #5275 — `start` writes the row and its grant in one interactive
+  // transaction; the mock hands the same store-backed client through.
+  (prisma.$transaction as jest.Mock).mockImplementation(
+    async (fn: (tx: typeof prisma) => Promise<unknown>) => fn(prisma),
+  );
   (prisma.projectListing.create as jest.Mock).mockImplementation(({ data }: { data: Row }) => {
     const now = new Date();
     const row: Row = {

package/templates/apps/api/src/routes/project-listings/__tests__/structured-address.test.ts

@@ -0,0 +1,467 @@
+/**
+ * @file structured-address.test.ts
+ *
+ * THE ACCEPTANCE GATE for the structured founder address (#5279).
+ *
+ * The application collected a whole business address in ONE free-text box.
+ * It now renders a fieldset, and the payload field `address` became a UNION:
+ * the legacy display STRING or the structured PARTS. The row keeps `address`
+ * as the single-line DISPLAY string and gains six nullable part columns
+ * beside it, which the server writes — and composes the display line from —
+ * in `draftUpdateData`.
+ *
+ * Two properties carry this change, and both look fine when broken, which is
+ * why they each get a test that fails when they are:
+ *
+ *   1. The parts arrive as PARTS. A patch carrying the structured object must
+ *      land six DISTINCT column values, not one concatenated string in
+ *      `address` with the columns left null. A service that quietly stringified
+ *      the object would produce a row that reads correctly on the listing page
+ *      and has silently thrown away the split the fieldset exists to capture.
+ *
+ *   2. A legacy free-text address round-trips CHARACTER-FOR-CHARACTER with its
+ *      parts null. Nothing may ever split an existing `address` into parts:
+ *      address parsing guesses, and a wrong guess silently corrupts the party
+ *      identification the listing's privacy notice points at (#5036 D6), with
+ *      nothing on the row to mark it as invented. A null part is honest; a
+ *      guessed one is not.
+ *
+ * Same harness as `configured-application.test.ts` and `drafts.test.ts`: real
+ * routes, real services, mocked `lib/prisma.js` over a small in-memory row
+ * store, `routeLead` running for real against a per-test temp path.
+ */
+
+// eslint-disable-next-line no-restricted-syntax -- prisma is a DB boundary; __mocks__/prisma.ts activates the auto-mock
+jest.mock("../../../lib/prisma.js");
+
+jest.mock("@working-theory/email", () => ({
+  sendLeadNotification: jest.fn().mockResolvedValue({ ok: true, messageId: "msg-test" }),
+}));
+
+jest.mock("@working-theory/license", () => ({
+  checkLicense: jest.fn().mockResolvedValue({
+    tier: "free",
+    plan: null,
+    features: [],
+    expiresAt: null,
+    revoked: false,
+  }),
+}));
+
+import Fastify from "fastify";
+import type { FastifyInstance } from "fastify";
+
+import { setupLeadFileEnv } from "../../../__tests__/factories/lead-fixture";
+import { prisma } from "../../../lib/prisma.js";
+import { patchProjectListingDraftRoute } from "../patch-draft.js";
+import { startProjectListingRoute } from "../start.js";
+import { submitProjectListingRoute } from "../submit.js";
+
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+
+const SITE_ID = "site-1";
+const SITE_KEY = "pk-site-1";
+
+const opt = (value: string, label: string) => ({ value, label });
+
+const VALID_QUESTIONS = {
+  q2: {
+    prompt: "Why are you here?",
+    options: [opt("scale", "Scaling my team"), opt("just-curious", "Just curious")],
+  },
+  q3: { prompt: "Stage?", options: [opt("a", "A"), opt("b", "B"), opt("c", "C")] },
+  q4: { prompt: "Team size?", options: [opt("a", "A"), opt("b", "B"), opt("c", "C")] },
+  q5: {
+    prompt: "Urgency?",
+    options: [opt("urgent", "Now"), opt("planning", "Soon"), opt("exploring", "Someday")],
+  },
+  q6: {
+    prompt: "Pain?",
+    options: [
+      opt("low", "Low"),
+      opt("medium", "Medium"),
+      opt("high", "High"),
+      opt("critical", "Critical"),
+    ],
+  },
+  q7: { prompt: "Anything else?" },
+  extras: [],
+};
+
+const START_PAYLOAD = {
+  siteKey: SITE_KEY,
+  founderName: "Ada Founder",
+  founderEmail: "ada@example.com",
+  consent: true,
+};
+
+/** Everything the ten steps after step one collect, minus the address. */
+const APPLICATION_WITHOUT_ADDRESS = {
+  name: "My Project",
+  headline: "Ten words or fewer for the tile title here",
+  oneLiner: "A short sentence describing what the project does for its people.",
+  problem: "The problem is real and this describes it.",
+  product: "wireframes",
+  commitment: "part-time",
+  teamComposition: "co-founders",
+  faqs: [
+    { question: "Q one?", answer: "A one." },
+    { question: "Q two?", answer: "A two." },
+    { question: "Q three?", answer: "A three." },
+  ],
+  questions: VALID_QUESTIONS,
+};
+
+/** What `AddressFieldset` posts — six controls under six fixed keys. */
+const ADDRESS_PARTS = {
+  addressLine1: "221B Baker Street",
+  addressLine2: "Flat B",
+  city: "London",
+  region: "Greater London",
+  postalCode: "NW1 6XE",
+  country: "GB",
+};
+
+/**
+ * The display line the SERVER must compose from `ADDRESS_PARTS` — the parts
+ * in reading order, joined with ", ". Written out literally rather than by
+ * calling `composeAddressLine`, so a change to the joiner fails this test
+ * instead of travelling through it.
+ */
+const COMPOSED_ADDRESS_LINE =
+  "221B Baker Street, Flat B, London, Greater London, NW1 6XE, GB";
+
+/**
+ * An address a founder typed into the ONE free-text box, before #5279. It is
+ * not in the composed order, its parts are not separable by any rule, and
+ * nothing may ever try: it is here to be returned unchanged.
+ */
+const LEGACY_ADDRESS_LINE =
+  "221B Baker Street, Marylebone, London NW1 6XE, United Kingdom";
+
+// ─── The in-memory row store the Prisma mock is backed by ───────────────────
+
+type Row = Record<string, unknown>;
+
+let rows: Row[];
+let nextId: number;
+
+function matches(row: Row, where: Record<string, unknown>): boolean {
+  return Object.entries(where).every(([key, value]) => {
+    if (key === "OR") {
+      return (value as Record<string, unknown>[]).some((clause) => matches(row, clause));
+    }
+    if (value !== null && typeof value === "object" && !(value instanceof Date)) {
+      const clause = value as Record<string, unknown>;
+      if ("in" in clause) return (clause["in"] as unknown[]).includes(row[key]);
+      if ("not" in clause) return row[key] !== clause["not"];
+      if ("gt" in clause) return (row[key] as Date) > (clause["gt"] as Date);
+      if ("startsWith" in clause) {
+        return (
+          typeof row[key] === "string" &&
+          (row[key] as string).startsWith(clause["startsWith"] as string)
+        );
+      }
+    }
+    return row[key] === value;
+  });
+}
+
+function installStore(): void {
+  rows = [];
+  nextId = 1;
+
+  (prisma.lead.create as jest.Mock).mockImplementation(() =>
+    Promise.resolve({ id: `lead_00000000-0000-7000-8000-00000000000${nextId}` }),
+  );
+
+  (prisma.siteListingConfig.findUnique as jest.Mock).mockImplementation(
+    ({ where }: { where: { siteId?: string; publicKey?: string } }) => {
+      if (where.publicKey !== undefined) {
+        return Promise.resolve(where.publicKey === SITE_KEY ? { siteId: SITE_ID } : null);
+      }
+      // No config row — the platform defaults, which collect `address`.
+      return Promise.resolve(null);
+    },
+  );
+
+  // #5275 — the grant write `start` makes after the row. Append-only; it only
+  // needs to resolve here (drafts.test.ts asserts on what it is called with).
+  (prisma.consentGrant.createMany as jest.Mock).mockImplementation(
+    ({ data }: { data: Row[] }) => Promise.resolve({ count: data.length }),
+  );
+
+  // #5275 — `start` writes the row and its grant in one interactive
+  // transaction; the mock hands the same store-backed client through.
+  (prisma.$transaction as jest.Mock).mockImplementation(
+    async (fn: (tx: typeof prisma) => Promise<unknown>) => fn(prisma),
+  );
+
+  (prisma.projectListing.create as jest.Mock).mockImplementation(({ data }: { data: Row }) => {
+    const now = new Date();
+    const row: Row = {
+      id: `prjl_00000000-0000-7000-8000-00000000000${nextId++}`,
+      slug: null,
+      name: null,
+      oneLiner: null,
+      problem: null,
+      url: null,
+      product: null,
+      commitment: null,
+      teamComposition: null,
+      faqs: null,
+      anythingElse: null,
+      address: null,
+      // #5279 — a freshly-started draft has no parts, exactly like every row
+      // written before the columns existed.
+      addressLine1: null,
+      addressLine2: null,
+      addressCity: null,
+      addressRegion: null,
+      addressPostalCode: null,
+      addressCountry: null,
+      questions: null,
+      founderCompany: null,
+      leadId: null,
+      headline: null,
+      logoMarkUrl: null,
+      logoWordmarkUrl: null,
+      featured: false,
+      decidedAt: null,
+      decidedBy: null,
+      issueUrl: null,
+      experimentKey: null,
+      windowEndsAt: null,
+      createdAt: now,
+      updatedAt: now,
+      ...data,
+    };
+    rows.push(row);
+    return Promise.resolve(row);
+  });
+
+  (prisma.projectListing.findFirst as jest.Mock).mockImplementation(
+    ({ where }: { where: Record<string, unknown> }) =>
+      Promise.resolve(rows.find((row) => matches(row, where)) ?? null),
+  );
+
+  (prisma.projectListing.findMany as jest.Mock).mockImplementation(
+    ({ where }: { where: Record<string, unknown> }) =>
+      Promise.resolve(rows.filter((row) => matches(row, where))),
+  );
+
+  (prisma.projectListing.update as jest.Mock).mockImplementation(
+    ({ where, data }: { where: Record<string, unknown>; data: Row }) => {
+      const row = rows.find((r) => matches(r, where));
+      Object.assign(row!, data, { updatedAt: new Date() });
+      return Promise.resolve(row);
+    },
+  );
+
+  (prisma.projectListing.updateMany as jest.Mock).mockImplementation(
+    ({ where, data }: { where: Record<string, unknown>; data: Row }) => {
+      const matched = rows.filter((r) => matches(r, where));
+      matched.forEach((r) => Object.assign(r, data, { updatedAt: new Date() }));
+      return Promise.resolve({ count: matched.length });
+    },
+  );
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+const bearer = (token: string) => ({ authorization: `Bearer ${token}` });
+
+async function buildApp(): Promise<FastifyInstance> {
+  const app = Fastify();
+  await app.register(startProjectListingRoute);
+  await app.register(patchProjectListingDraftRoute);
+  await app.register(submitProjectListingRoute);
+  await app.ready();
+  return app;
+}
+
+async function startDraft(
+  app: FastifyInstance,
+): Promise<{ id: string; resumeToken: string }> {
+  const res = await app.inject({
+    method: "POST",
+    url: "/v1/project-listings",
+    payload: START_PAYLOAD,
+  });
+  expect(res.statusCode).toBe(201);
+  return (res.json() as { data: { id: string; resumeToken: string } }).data;
+}
+
+const patch = (
+  app: FastifyInstance,
+  draft: { id: string; resumeToken: string },
+  payload: Record<string, unknown>,
+) =>
+  app.inject({
+    method: "PATCH",
+    url: `/v1/project-listings/drafts/${draft.id}`,
+    headers: bearer(draft.resumeToken),
+    payload,
+  });
+
+const submit = (app: FastifyInstance, draft: { id: string; resumeToken: string }) =>
+  app.inject({
+    method: "POST",
+    url: `/v1/project-listings/drafts/${draft.id}/submit`,
+    headers: bearer(draft.resumeToken),
+  });
+
+const storedRow = (id: string): Row => {
+  const row = rows.find((r) => r["id"] === id);
+  expect(row).toBeDefined();
+  return row!;
+};
+
+const draftBody = (res: { json: () => unknown }) =>
+  (res.json() as { data: Record<string, unknown> }).data;
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe("the structured founder address (#5279)", () => {
+  setupLeadFileEnv("project-listing-structured-address");
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    installStore();
+    app = await buildApp();
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  describe("the parts arrive as PARTS, and the server composes the display line", () => {
+    it("stores six DISTINCT column values, not one concatenated string", async () => {
+      const draft = await startDraft(app);
+
+      const res = await patch(app, draft, { address: ADDRESS_PARTS });
+
+      expect(res.statusCode).toBe(200);
+
+      // The column-level half. Each part is in its OWN column — a service that
+      // stringified the object would leave every one of these null and this
+      // test is the thing that notices.
+      const row = storedRow(draft.id);
+      expect(row["addressLine1"]).toBe("221B Baker Street");
+      expect(row["addressLine2"]).toBe("Flat B");
+      expect(row["addressCity"]).toBe("London");
+      expect(row["addressRegion"]).toBe("Greater London");
+      expect(row["addressPostalCode"]).toBe("NW1 6XE");
+      expect(row["addressCountry"]).toBe("GB");
+
+      // The display half. `address` is DERIVED here and only here — the parts
+      // in reading order, joined with ", ".
+      expect(row["address"]).toBe(COMPOSED_ADDRESS_LINE);
+    });
+
+    it("answers the save with the composed line AND the parts, separably", async () => {
+      const draft = await startDraft(app);
+
+      const body = draftBody(await patch(app, draft, { address: ADDRESS_PARTS }));
+
+      expect(body["address"]).toBe(COMPOSED_ADDRESS_LINE);
+      expect(body["addressParts"]).toEqual(ADDRESS_PARTS);
+    });
+
+    it("omits the blank addressLine2 from both the columns and the composed line", async () => {
+      const draft = await startDraft(app);
+      const { addressLine2: _line2, ...withoutLine2 } = ADDRESS_PARTS;
+
+      const body = draftBody(await patch(app, draft, { address: withoutLine2 }));
+
+      expect(storedRow(draft.id)["addressLine2"]).toBeNull();
+      expect(body["address"]).toBe("221B Baker Street, London, Greater London, NW1 6XE, GB");
+      expect(body["addressParts"]).toEqual(withoutLine2);
+    });
+
+    it("a composed address submits, and reaches the row as the display line", async () => {
+      const draft = await startDraft(app);
+      await patch(app, draft, { ...APPLICATION_WITHOUT_ADDRESS, address: ADDRESS_PARTS });
+
+      const res = await submit(app, draft);
+
+      expect(res.statusCode).toBe(200);
+      expect(storedRow(draft.id)["address"]).toBe(COMPOSED_ADDRESS_LINE);
+      expect(storedRow(draft.id)["addressCountry"]).toBe("GB");
+    });
+
+    it("refuses parts that are not a whole address, rather than storing half of one", async () => {
+      const draft = await startDraft(app);
+      const { city: _city, ...incomplete } = ADDRESS_PARTS;
+
+      const res = await patch(app, draft, { address: incomplete });
+
+      expect(res.statusCode).toBe(400);
+      expect(storedRow(draft.id)["addressLine1"]).toBeNull();
+      expect(storedRow(draft.id)["address"]).toBeNull();
+    });
+  });
+
+  describe("a legacy free-text address round-trips unchanged, with its parts null", () => {
+    // The load-bearing guard. Nothing may split an existing `address` into
+    // parts — a wrong split silently corrupts the party identification the
+    // listing's privacy notice points at, and a null part is honest where a
+    // guessed one is not.
+    it("comes back CHARACTER-FOR-CHARACTER from a save, with addressParts null", async () => {
+      const draft = await startDraft(app);
+
+      const body = draftBody(await patch(app, draft, { address: LEGACY_ADDRESS_LINE }));
+
+      expect(body["address"]).toBe(LEGACY_ADDRESS_LINE);
+      expect(body["addressParts"]).toBeNull();
+    });
+
+    it("leaves EVERY part column untouched — a plain string writes none of them", async () => {
+      const draft = await startDraft(app);
+
+      await patch(app, draft, { address: LEGACY_ADDRESS_LINE });
+
+      const row = storedRow(draft.id);
+      expect(row["address"]).toBe(LEGACY_ADDRESS_LINE);
+      for (const column of [
+        "addressLine1",
+        "addressLine2",
+        "addressCity",
+        "addressRegion",
+        "addressPostalCode",
+        "addressCountry",
+      ]) {
+        expect(row[column]).toBeNull();
+      }
+    });
+
+    it("submits exactly as it did before #5279, and the stored line is unchanged", async () => {
+      const draft = await startDraft(app);
+      await patch(app, draft, {
+        ...APPLICATION_WITHOUT_ADDRESS,
+        address: LEGACY_ADDRESS_LINE,
+      });
+
+      const res = await submit(app, draft);
+
+      expect(res.statusCode).toBe(200);
+      expect(storedRow(draft.id)["address"]).toBe(LEGACY_ADDRESS_LINE);
+      expect(storedRow(draft.id)["addressLine1"]).toBeNull();
+    });
+
+    // A row written before #5279 holds a line and six nulls. Overwriting the
+    // line with a NEW line must not start inventing parts for it either.
+    it("re-patching a legacy line with another legacy line still writes no parts", async () => {
+      const draft = await startDraft(app);
+      await patch(app, draft, { address: LEGACY_ADDRESS_LINE });
+
+      await patch(app, draft, { address: "1 Example Street, Exampleton, EX1 2AM" });
+
+      const row = storedRow(draft.id);
+      expect(row["address"]).toBe("1 Example Street, Exampleton, EX1 2AM");
+      expect(row["addressCity"]).toBeNull();
+      expect(row["addressCountry"]).toBeNull();
+    });
+  });
+});

package/templates/apps/api/src/routes/project-listings/index.ts

@@ -7,6 +7,7 @@
  *   PATCH /v1/project-listings/drafts/:id           — anonymous save-as-you-go, token-gated
  *   POST  /v1/project-listings/drafts/:id/submit    — anonymous submit, token-gated
  *   GET   /v1/project-listings/public               — anonymous page-render read (leadsScope)
+ *   GET   /v1/project-listings/me                   — the founder's OWN listings (authScope)
  *   GET   /v1/project-listings                      — tenant-scoped dashboard list
  *   GET   /v1/project-listings/:id                  — tenant-scoped single read
  *   PATCH /v1/project-listings/:id                  — tenant-scoped decision + featured flag
@@ -19,6 +20,13 @@
  * anonymous token-gated PATCH and the operator's tenant-guarded PATCH apart
  * at the router — they differ in segment count, so neither shadows the other.
  *
+ * `/me` (#5295) sits between the two scopes: `authScope` only, no tenant guard.
+ * A founder is not a workspace member, so the guard's default-deny answers 403
+ * for their own submission — and the fix is this ADDITIVE route, joined on the
+ * owner link, rather than a relaxed `PROJECT_LISTING_ROLES`. Its static `/me`
+ * segment takes router precedence over the parametric `/:id` below, exactly as
+ * the already-shipped static `/public` does.
+ *
  * API<->MCP parity: no MCP twin. The anonymous set mirrors the leads routes'
  * own identity-blind posture (an applying founder has no account, and the
  * resume token is a per-draft capability rather than an identity); the
@@ -27,6 +35,7 @@
  */
 import type { FastifyPluginAsync } from "fastify";
 
+import { projectListingMeRoute as meRoute } from "./me.js";
 import { patchProjectListingDraftRoute } from "./patch-draft.js";
 import { publicProjectListingsRoute } from "./public.js";
 import { startProjectListingRoute } from "./start.js";
@@ -36,6 +45,12 @@ export const projectListingStartRoute = startProjectListingRoute;
 export const projectListingDraftPatchRoute = patchProjectListingDraftRoute;
 export const projectListingSubmitRoute = submitProjectListingRoute;
 export const projectListingPublicRoute = publicProjectListingsRoute;
+/**
+ * The founder's own listings read (#5295). Static, not a slice: it depends on
+ * the owner link alone, so it is registered — and works — on a build with no
+ * multi-tenant module, the same as `flowCheckoutRoutes`.
+ */
+export const projectListingMeRoute = meRoute;
 
 /**
  * Tenant-scoped handlers, as { specifier, exportName }, reached at REGISTRATION

package/templates/apps/api/src/routes/project-listings/me.ts

@@ -0,0 +1,76 @@
+/**
+ * GET /v1/project-listings/me
+ *
+ * The FOUNDER'S OWN listings read (#5295) — the `/v1/flow-checkouts/me` and
+ * `/v1/waitlist-signups/me` posture, for `ProjectListing`.
+ *
+ * Registered INSIDE `server.ts`'s `authScope` (auth only — NOT the inner
+ * `tenantScope`): a founder is not a workspace member, and the tenant guard is
+ * default-deny, so a founder reaching the tenant-scoped list route gets a 403
+ * for their own submission. That is the problem this route exists to solve, and
+ * it is solved by ADDING this route rather than by relaxing
+ * `PROJECT_LISTING_ROLES` — the operator floor on
+ * `GET|PATCH /v1/project-listings[/:id]` is unchanged and still `owner|admin`.
+ *
+ * Identity is `request.userId` ONLY. The route declares no query schema and
+ * reads no query or body key — an `email` parameter is never parsed and never
+ * read — and the service joins on the owner link and nothing else
+ * (`services/project-listings.ts`'s `listMyProjectListings`: `ownerUserId ===
+ * userId`, never a `founderEmail` comparison at read time).
+ *
+ * Route precedence: this static path is registered alongside the parametric
+ * `/v1/project-listings/:id` in the tenant scope. Fastify's router prefers a
+ * static segment over a parametric one, so `/me` reaches this handler, exactly
+ * as the already-shipped static `/v1/project-listings/public` coexists with the
+ * same parametric route.
+ *
+ * Envelope per apps/api/CLAUDE.md: `{ ok: true, data }` /
+ * `{ ok: false, error: { code, message } }`, real HTTP status codes:
+ *   401 unauthorized · 500 internal_error (the 200 body failed its own
+ *   contract schema — a drift is never a leak). A signed-in caller who owns
+ *   NOTHING is a 200 with an empty list, never a 403: they are legitimately
+ *   signed in and simply own no listing yet.
+ *
+ * API↔MCP parity: identity-bound (the session IS the identity; the OSS MCP
+ * surface is identity-blind) — no MCP twin (#3591 exception, the same shape as
+ * `/v1/flow-checkouts/me` and `/v1/waitlist-signups/me`).
+ */
+import { projectListingMeResponseSchema } from "@working-theory/validation";
+import type { FastifyPluginAsync, FastifyReply } from "fastify";
+
+import { listMyProjectListings } from "../../services/project-listings.js";
+
+import { sendValidated } from "./respond.js";
+
+function unauthorized(reply: FastifyReply) {
+  return reply.status(401).send({
+    ok: false,
+    error: { code: "unauthorized", message: "Authentication required" },
+  });
+}
+
+export const projectListingMeRoute: FastifyPluginAsync = async (fastify) => {
+  fastify.get("/v1/project-listings/me", async (request, reply) => {
+    const userId = request.userId;
+    if (!userId) return unauthorized(reply);
+
+    const listings = await listMyProjectListings(userId);
+
+    // The omission is explicit at the send site rather than hidden in a schema
+    // strip, the idiom `patch-draft.ts` uses: `projectListingDraftSchema` is
+    // `.strict()`, so a key that stops being dropped here becomes a 500 instead
+    // of quietly shipping an internal reference to the founder.
+    const data = listings.map(
+      ({
+        siteId: _siteId,
+        leadId: _leadId,
+        decidedBy: _decidedBy,
+        issueUrl: _issueUrl,
+        experimentKey: _experimentKey,
+        ...mine
+      }) => mine,
+    );
+
+    return sendValidated(reply, projectListingMeResponseSchema, data, "me");
+  });
+};

package/templates/apps/api/src/routes/project-listings/start.ts

@@ -83,6 +83,14 @@ export const startProjectListingRoute: FastifyPluginAsync = async (fastify) => {
     }
 
     const result = await startProjectListingDraft(siteId, parsed.data);
+    // #5275 — a `consents` map declining a REQUIRED purpose contradicts the
+    // body's own `consent: true`; no row was created.
+    if (!result.ok) {
+      return reply.status(400).send({
+        ok: false,
+        error: { code: result.error.kind, message: result.error.message },
+      });
+    }
 
     request.log.info(
       { siteId, listingId: result.id, ip: request.ip },

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

@@ -47,6 +47,7 @@ import {
 } from './routes/leads/index.js';
 import {
   projectListingDraftPatchRoute,
+  projectListingMeRoute,
   projectListingPublicRoute,
   projectListingStartRoute,
   projectListingSubmitRoute,
@@ -272,6 +273,19 @@ export async function build() {
     // the only join is the lead-promotion link (never an email match).
     await authScope.register(flowCheckoutRoutes);
 
+    // The founder's OWN listings read (#5295) — the same posture again: auth
+    // only, NOT tenant-guarded, because a founder is not a workspace member
+    // and the tenant guard is default-deny. Identity is request.userId; the
+    // only join is the owner link (ProjectListing.ownerUserId, stamped by
+    // services/listing-promotion.ts), never an email match. The tenant-scoped
+    // listing routes below keep their owner|admin floor untouched — this route
+    // is additive, not a relaxation of that floor. Registered here rather than
+    // inside the multi-tenant scope so a founder can read their own rows on a
+    // build without the module; the static `/me` path takes router precedence
+    // over the tenant scope's parametric `/v1/project-listings/:id`, exactly as
+    // the already-shipped static `/v1/project-listings/public` does.
+    await authScope.register(projectListingMeRoute);
+
     // Tenant-guarded domain routes (multi-tenant module) — the tenant
     // preHandler (default-deny guard, see middleware/tenant.ts) runs after
     // auth for every route in this inner scope. No domain handler executes