create-ailk 0.4.0 → 0.6.0

package/templates/apps/api/src/services/__tests__/abandon-email.test.ts

@@ -307,6 +307,45 @@ describe("runAbandonEmailSweep", () => {
     expect(call[0].fromAddress).toBe("owner-noreply@example.com");
   });
 
+  // ── #4740 — an empty-string override is an env gap, not a sender ─────────
+
+  it("falls back to AILK_LEAD_NOTIFICATION_FROM when AILK_ABANDON_EMAIL_FROM is set to an empty string", async () => {
+    process.env.AILK_ABANDON_EMAIL_FROM = "";
+    process.env.AILK_LEAD_NOTIFICATION_FROM = "owner-noreply@example.com";
+    (prisma.flowDefinition.findMany as jest.Mock).mockResolvedValue([
+      flowDefRow(),
+    ]);
+    (prisma.flowSession.findMany as jest.Mock).mockResolvedValue([
+      sessionRow(),
+    ]);
+    (prisma.flowSession.update as jest.Mock).mockResolvedValue({});
+
+    await runAbandonEmailSweep({ now: NOW });
+
+    const [call] = mockSendAbandonEmail.mock.calls;
+    expect(call[0].fromAddress).toBe("owner-noreply@example.com");
+  });
+
+  it("leaves an enabled candidate UNSTAMPED when BOTH sender env vars are empty strings", async () => {
+    process.env.AILK_ABANDON_EMAIL_FROM = "";
+    process.env.AILK_LEAD_NOTIFICATION_FROM = "";
+    (prisma.flowDefinition.findMany as jest.Mock).mockResolvedValue([
+      flowDefRow(),
+    ]);
+    (prisma.flowSession.findMany as jest.Mock).mockResolvedValue([
+      sessionRow(),
+    ]);
+
+    const result = await runAbandonEmailSweep({ now: NOW });
+
+    expect(mockSendAbandonEmail).not.toHaveBeenCalled();
+    expect(prisma.flowSession.update).not.toHaveBeenCalled();
+    expect(result).toMatchObject({
+      ok: true,
+      summary: { selected: 1, sent: 0, dark: 0, failed: 0, skipped: 1 },
+    });
+  });
+
   // ── AC3 — locale resolution ──────────────────────────────────────────────
 
   it("resolves copy at the session's persisted locale", async () => {

package/templates/apps/api/src/services/__tests__/aeo-score.test.ts

@@ -5,6 +5,7 @@
  * fixture loading (AC1, AC3-AC7).
  */
 import {
+  AEO_SCORE_EXCLUDED_READINESS_RULES,
   AEO_SCORE_RULES,
   AEO_DIMENSION_SEVERITY,
   AEO_SCORE_DEFAULT_BUDGET_MS,
@@ -14,11 +15,17 @@ import {
   scoreUrl,
   loadExampleScore,
 } from "../aeo-score";
-import { aeoScoreResultSchema } from "@working-theory/validation";
+import {
+  aeoDimensionSchema,
+  aeoScoreResultSchema,
+} from "@working-theory/validation";
 import type { CrawlResult } from "@working-theory/aeo/fetch";
 
 /** Typed as the platform signature so it assigns to `ScoreUrlDeps.fetchImpl` with no cast. */
-type FetchStub = jest.Mock<Promise<Response>, [RequestInfo | URL, RequestInit?]>;
+type FetchStub = jest.Mock<
+  Promise<Response>,
+  [RequestInfo | URL, RequestInit?]
+>;
 
 import expectedResult from "../../../../../packages/aeo/__tests__/fixtures/example-score/result.json";
 
@@ -28,7 +35,13 @@ function page(
   expectedType: string,
   jsonLd: unknown[],
 ): CrawlResult["pages"][number] {
-  return { path, type, expectedType, url: `https://example.com${path}`, jsonLd };
+  return {
+    path,
+    type,
+    expectedType,
+    url: `https://example.com${path}`,
+    jsonLd,
+  };
 }
 
 /**
@@ -59,7 +72,9 @@ describe("AEO_SCORE_RULES", () => {
     ]);
     expect(AEO_SCORE_RULES.map((r) => r.id)).not.toContain("always-passes");
     expect(AEO_SCORE_RULES.map((r) => r.id)).not.toContain("always-fails");
-    expect(AEO_SCORE_RULES.map((r) => r.id)).not.toContain("schema-correctness");
+    expect(AEO_SCORE_RULES.map((r) => r.id)).not.toContain(
+      "schema-correctness",
+    );
   });
 
   it("matches the prospect-audit-site severity table verbatim", () => {
@@ -83,22 +98,32 @@ describe("resolveScoreBudgetMs", () => {
 
   it("falls back to the default and logs when above the 15000ms cap", () => {
     const warn = jest.fn();
-    expect(resolveScoreBudgetMs("20000", { warn })).toBe(AEO_SCORE_DEFAULT_BUDGET_MS);
+    expect(resolveScoreBudgetMs("20000", { warn })).toBe(
+      AEO_SCORE_DEFAULT_BUDGET_MS,
+    );
     expect(warn).toHaveBeenCalledTimes(1);
     expect(warn.mock.calls[0]?.[0]).toContain(String(AEO_SCORE_MAX_BUDGET_MS));
   });
 
   it("falls back silently on an unparseable/non-positive value", () => {
     const warn = jest.fn();
-    expect(resolveScoreBudgetMs("not-a-number", { warn })).toBe(AEO_SCORE_DEFAULT_BUDGET_MS);
-    expect(resolveScoreBudgetMs("-5", { warn })).toBe(AEO_SCORE_DEFAULT_BUDGET_MS);
+    expect(resolveScoreBudgetMs("not-a-number", { warn })).toBe(
+      AEO_SCORE_DEFAULT_BUDGET_MS,
+    );
+    expect(resolveScoreBudgetMs("-5", { warn })).toBe(
+      AEO_SCORE_DEFAULT_BUDGET_MS,
+    );
     expect(warn).not.toHaveBeenCalled();
   });
 });
 
 describe("scoreCrawl", () => {
   it("returns unavailable/no_pages_fetched for an empty crawl", () => {
-    const crawl: CrawlResult = { base: "https://example.com", pages: [], skipped: [] };
+    const crawl: CrawlResult = {
+      base: "https://example.com",
+      pages: [],
+      skipped: [],
+    };
     const result = scoreCrawl(crawl);
     expect(result).toEqual({
       status: "unavailable",
@@ -150,8 +175,18 @@ describe("scoreCrawl", () => {
   it("sets meta.partial true when a page was skipped for budget_exceeded", () => {
     const crawl: CrawlResult = {
       base: "https://example.com",
-      pages: [page("/", "homepage", "HomePage", [{ "@type": "HomePage", name: "Home" }])],
-      skipped: [{ path: "/about", url: "https://example.com/about", reason: "budget_exceeded" }],
+      pages: [
+        page("/", "homepage", "HomePage", [
+          { "@type": "HomePage", name: "Home" },
+        ]),
+      ],
+      skipped: [
+        {
+          path: "/about",
+          url: "https://example.com/about",
+          reason: "budget_exceeded",
+        },
+      ],
     };
     const result = scoreCrawl(crawl);
     if (result.status !== "ready") throw new Error("expected ready");
@@ -162,7 +197,11 @@ describe("scoreCrawl", () => {
   it("result satisfies aeoScoreResultSchema (AC7)", () => {
     const crawl: CrawlResult = {
       base: "https://example.com",
-      pages: [page("/", "homepage", "HomePage", [{ "@type": "HomePage", name: "Home" }])],
+      pages: [
+        page("/", "homepage", "HomePage", [
+          { "@type": "HomePage", name: "Home" },
+        ]),
+      ],
       skipped: [],
     };
     const result = scoreCrawl(crawl);
@@ -187,12 +226,17 @@ describe("scoreCrawl", () => {
     it("redacts a raw assertUrlSafe rejection reason to the ssrf_blocked sentinel", () => {
       const crawl: CrawlResult = {
         base: "https://example.com",
-        pages: [page("/", "homepage", "HomePage", [{ "@type": "HomePage", name: "Home" }])],
+        pages: [
+          page("/", "homepage", "HomePage", [
+            { "@type": "HomePage", name: "Home" },
+          ]),
+        ],
         skipped: [
           {
             path: "/admin",
             url: "http://169.254.169.254/admin",
-            reason: "Host 169.254.169.254 resolves to a blocked address: 169.254.169.254",
+            reason:
+              "Host 169.254.169.254 resolves to a blocked address: 169.254.169.254",
           },
         ],
       };
@@ -201,38 +245,57 @@ describe("scoreCrawl", () => {
       expect(result.meta.skipped).toHaveLength(1);
       expect(result.meta.skipped[0]?.reason).toBe("ssrf_blocked");
       expect(result.meta.skipped[0]?.reason).not.toMatch(/169\.254\.169\.254/);
-      expect(result.meta.skipped[0]?.reason).not.toMatch(/resolves to a blocked address/i);
+      expect(result.meta.skipped[0]?.reason).not.toMatch(
+        /resolves to a blocked address/i,
+      );
     });
 
     it("(AC-2) logs the raw per-path rejection detail server-side before redacting it", () => {
       const crawl: CrawlResult = {
         base: "https://example.com",
-        pages: [page("/", "homepage", "HomePage", [{ "@type": "HomePage", name: "Home" }])],
+        pages: [
+          page("/", "homepage", "HomePage", [
+            { "@type": "HomePage", name: "Home" },
+          ]),
+        ],
         skipped: [
           {
             path: "/admin",
             url: "http://169.254.169.254/admin",
-            reason: "Host 169.254.169.254 resolves to a blocked address: 169.254.169.254",
+            reason:
+              "Host 169.254.169.254 resolves to a blocked address: 169.254.169.254",
           },
         ],
       };
       scoreCrawl(crawl);
       expect(warnSpy).toHaveBeenCalledTimes(1);
-      const [message, meta] = warnSpy.mock.calls[0] as [string, Record<string, unknown>];
+      const [message, meta] = warnSpy.mock.calls[0] as [
+        string,
+        Record<string, unknown>,
+      ];
       expect(message).toMatch(/aeo-score/);
       expect(meta).toMatchObject({
         path: "/admin",
         url: "http://169.254.169.254/admin",
-        reason: "Host 169.254.169.254 resolves to a blocked address: 169.254.169.254",
+        reason:
+          "Host 169.254.169.254 resolves to a blocked address: 169.254.169.254",
       });
     });
 
     it("leaves a non-SSRF skip reason (budget_exceeded, an HTTP failure) unchanged", () => {
       const crawl: CrawlResult = {
         base: "https://example.com",
-        pages: [page("/", "homepage", "HomePage", [{ "@type": "HomePage", name: "Home" }])],
+        pages: [
+          page("/", "homepage", "HomePage", [
+            { "@type": "HomePage", name: "Home" },
+          ]),
+        ],
         skipped: [
-          { path: "/about", url: "https://example.com/about", reason: "budget_exceeded" },
+          {
+            path: "/about",
+            url: "https://example.com/about",
+            reason: "budget_exceeded",
+          },
           {
             path: "/blog",
             url: "https://example.com/blog",
@@ -243,7 +306,11 @@ describe("scoreCrawl", () => {
       const result = scoreCrawl(crawl);
       if (result.status !== "ready") throw new Error("expected ready");
       expect(result.meta.skipped).toEqual([
-        { path: "/about", url: "https://example.com/about", reason: "budget_exceeded" },
+        {
+          path: "/about",
+          url: "https://example.com/about",
+          reason: "budget_exceeded",
+        },
         {
           path: "/blog",
           url: "https://example.com/blog",
@@ -272,7 +339,10 @@ describe("scoreCrawl", () => {
           ),
       );
 
-      const result = await scoreUrl("https://example.com", { fetchImpl, resolver });
+      const result = await scoreUrl("https://example.com", {
+        fetchImpl,
+        resolver,
+      });
 
       if (result.status !== "ready") {
         throw new Error(`expected ready, got ${JSON.stringify(result)}`);
@@ -294,14 +364,68 @@ describe("aeoScoreResultSchema (AC7)", () => {
         status: "ready",
         score: 50,
         dimensions: [
-          { id: "schema-coverage", label: "x", weight: 10, score: 50, severity: "high", finding: null, pagesPassing: 1, pagesTotal: 2 },
-          { id: "jsonld-validity", label: "x", weight: 10, score: 50, severity: "medium", finding: null, pagesPassing: 1, pagesTotal: 2 },
-          { id: "entity-markup", label: "x", weight: 1, score: 50, severity: "high", finding: null, pagesPassing: 1, pagesTotal: 2 },
-          { id: "faq-howto-incentive", label: "x", weight: 0, score: 50, severity: "low", finding: null, pagesPassing: 1, pagesTotal: 2 },
+          {
+            id: "schema-coverage",
+            label: "x",
+            weight: 10,
+            score: 50,
+            severity: "high",
+            finding: null,
+            pagesPassing: 1,
+            pagesTotal: 2,
+          },
+          {
+            id: "jsonld-validity",
+            label: "x",
+            weight: 10,
+            score: 50,
+            severity: "medium",
+            finding: null,
+            pagesPassing: 1,
+            pagesTotal: 2,
+          },
+          {
+            id: "entity-markup",
+            label: "x",
+            weight: 1,
+            score: 50,
+            severity: "high",
+            finding: null,
+            pagesPassing: 1,
+            pagesTotal: 2,
+          },
+          {
+            id: "faq-howto-incentive",
+            label: "x",
+            weight: 0,
+            score: 50,
+            severity: "low",
+            finding: null,
+            pagesPassing: 1,
+            pagesTotal: 2,
+          },
         ],
         lowestTwo: [
-          { id: "schema-coverage", label: "x", weight: 10, score: 50, severity: "high", finding: null, pagesPassing: 1, pagesTotal: 2 },
-          { id: "entity-markup", label: "x", weight: 1, score: 50, severity: "high", finding: null, pagesPassing: 1, pagesTotal: 2 },
+          {
+            id: "schema-coverage",
+            label: "x",
+            weight: 10,
+            score: 50,
+            severity: "high",
+            finding: null,
+            pagesPassing: 1,
+            pagesTotal: 2,
+          },
+          {
+            id: "entity-markup",
+            label: "x",
+            weight: 1,
+            score: 50,
+            severity: "high",
+            finding: null,
+            pagesPassing: 1,
+            pagesTotal: 2,
+          },
         ],
         meta: {
           auditedAt: new Date().toISOString(),
@@ -314,11 +438,21 @@ describe("aeoScoreResultSchema (AC7)", () => {
       }),
     ).not.toThrow();
 
-    expect(() => aeoScoreResultSchema.parse({ status: "computing" })).not.toThrow();
+    expect(() =>
+      aeoScoreResultSchema.parse({ status: "computing" }),
+    ).not.toThrow();
 
-    for (const reason of ["ssrf_blocked", "no_pages_fetched", "crawl_failed"] as const) {
+    for (const reason of [
+      "ssrf_blocked",
+      "no_pages_fetched",
+      "crawl_failed",
+    ] as const) {
       expect(() =>
-        aeoScoreResultSchema.parse({ status: "unavailable", reason, message: "x" }),
+        aeoScoreResultSchema.parse({
+          status: "unavailable",
+          reason,
+          message: "x",
+        }),
       ).not.toThrow();
     }
   });
@@ -348,7 +482,9 @@ describe("scoreUrl", () => {
   it("(AC1) issues the five default paths concurrently — a 2s-delay fetchImpl completes well under 10s", async () => {
     const fetchImpl: FetchStub = jest.fn(async () => {
       await new Promise((resolve) => setTimeout(resolve, 2000));
-      return new Response("<html><script type=\"application/ld+json\">{\"@type\":\"HomePage\",\"name\":\"x\"}</script></html>");
+      return new Response(
+        '<html><script type="application/ld+json">{"@type":"HomePage","name":"x"}</script></html>',
+      );
     });
 
     const t0 = Date.now();
@@ -363,7 +499,9 @@ describe("scoreUrl", () => {
   }, 10_000);
 
   it("(AC1) with budgetMs 500 and a 2s-delay fetchImpl, returns quickly as unavailable/no_pages_fetched", async () => {
-    const fetchImpl: FetchStub = jest.fn(delayedResponse(2000, "<html></html>"));
+    const fetchImpl: FetchStub = jest.fn(
+      delayedResponse(2000, "<html></html>"),
+    );
 
     const t0 = Date.now();
     const result = await scoreUrl("https://example.com", {
@@ -387,13 +525,15 @@ describe("scoreUrl", () => {
   it("(AC1) one fast + four slow pages returns ready with meta.partial true and budget_exceeded skips", async () => {
     const homeResponse = delayedResponse(
       0,
-      "<html><script type=\"application/ld+json\">{\"@type\":\"HomePage\",\"name\":\"x\"}</script></html>",
+      '<html><script type="application/ld+json">{"@type":"HomePage","name":"x"}</script></html>',
     );
     const slowResponse = delayedResponse(5000, "<html></html>");
-    const fetchImpl: FetchStub = jest.fn((input: RequestInfo | URL, init?: RequestInit) => {
-      const isHome = String(input).endsWith("example.com/");
-      return isHome ? homeResponse(input, init) : slowResponse(input, init);
-    });
+    const fetchImpl: FetchStub = jest.fn(
+      (input: RequestInfo | URL, init?: RequestInit) => {
+        const isHome = String(input).endsWith("example.com/");
+        return isHome ? homeResponse(input, init) : slowResponse(input, init);
+      },
+    );
 
     const result = await scoreUrl("https://example.com", {
       fetchImpl,
@@ -401,10 +541,13 @@ describe("scoreUrl", () => {
       budgetMs: 800,
     });
 
-    if (result.status !== "ready") throw new Error(`expected ready, got ${JSON.stringify(result)}`);
+    if (result.status !== "ready")
+      throw new Error(`expected ready, got ${JSON.stringify(result)}`);
     expect(result.meta.partial).toBe(true);
     // Spec AC1: one fast + FOUR slow pages — all four abort at the budget.
-    expect(result.meta.skipped.filter((s) => s.reason === "budget_exceeded").length).toBe(4);
+    expect(
+      result.meta.skipped.filter((s) => s.reason === "budget_exceeded").length,
+    ).toBe(4);
     expect(result.meta.pagesAudited).toBe(1);
   }, 10_000);
 
@@ -473,3 +616,37 @@ describe("loadExampleScore (AC6, D6)", () => {
     }).toEqual(expectedResult);
   });
 });
+
+/**
+ * #5949 D6/FR11 — the readiness rules are deliberately NOT in this service's
+ * rule set. They grade frontmatter and site-set facts, and `buildAuditPayload`
+ * produces no frontmatter, so on a crawl input all three would pass vacuously:
+ * three always-100 dimensions in a closed four-member public enum.
+ *
+ * `/v1/aeo/score` has no MCP twin (apps/api/CLAUDE.md § API ↔ MCP parity), so
+ * the skip is not a parity divergence — and these assertions are the "stated
+ * and tested" half AC-3 asks for, failing loudly if either side drifts.
+ */
+describe("readiness-rule exclusion (#5949 D6)", () => {
+  it("AEO_SCORE_RULES carries none of the excluded readiness rules", () => {
+    const ids = AEO_SCORE_RULES.map((r) => r.id);
+    for (const excluded of AEO_SCORE_EXCLUDED_READINESS_RULES) {
+      expect(ids).not.toContain(excluded);
+    }
+  });
+
+  it("the public dimension enum is still exactly the four content rules", () => {
+    expect([...aeoDimensionSchema.shape.id.options].sort()).toEqual([
+      "entity-markup",
+      "faq-howto-incentive",
+      "jsonld-validity",
+      "schema-coverage",
+    ]);
+  });
+
+  it("AEO_SCORE_RULES' ids are exactly the dimension enum's options", () => {
+    expect(AEO_SCORE_RULES.map((r) => r.id).sort()).toEqual(
+      [...aeoDimensionSchema.shape.id.options].sort(),
+    );
+  });
+});