@@ -72,6 +72,21 @@ integration cases generated with an explicit `--out <dir>/docs` while `verify --
 the config default, and passed only because the two coincided. Sixteen cases failed the moment
 they stopped. They now take the config path, which is what the gate reads.
 
+### Changed — `--limit` is documented as per printed LIST, which is what it always was
+
+Its doc said "per SECTION, never shared across them". The anti-pattern tier prints TWO
+separately-headed lists — the hand-rolling findings and the F52 missing-`baseUrl` findings —
+while being ONE section everywhere else: one structured list keyed by `rule`, one
+`--no-antipatterns` muting both. So `--limit 3` can print six advisory lines from a section
+the payload calls one, and reads like a defect.
+
+It is not. The separate budgets exist for the same reason the caps are per-section at all: a
+shared budget lets the larger list push the smaller one off the end entirely. A project with
+200 money-float sites would never see its `baseUrl` advisory — the one that silently drops
+the API prefix from every generated hook — and starving the small list is the worse failure.
+No behaviour changed; the doc now states the rule the code follows, and a test pins it, so it
+is a decision on the record rather than an accident nobody had measured.
+
 ### Fixed — the Python nudge was blind to the 1.0 cut it exists to catch
 
 `agent_context_staleness` on the Python port dropped the leading MAJOR from both of its
 
@@ -310,11 +310,19 @@ export interface VerifyFlags {
    */
   lax: boolean;
   /**
-   * How many advisory lines TEXT output prints per SECTION before truncating
-   * (`DEFAULT_ADVISORY_LIMIT`, or Infinity for `--limit all`). Per-section, never
-   * shared across them — the reason the two caps were separate in the first place
-   * is that one shared budget lets the authoring lint push every gate warning off
-   * the end. It never applies to a structured payload, which carries everything.
+   * How many advisory lines TEXT output prints per printed LIST before truncating
+   * (`DEFAULT_ADVISORY_LIMIT`, or Infinity for `--limit all`). Never shared across
+   * lists — one shared budget lets the biggest list push every other finding off the
+   * end. It never applies to a structured payload, which carries everything.
+   *
+   * Per LIST, not per section, and the distinction is real rather than pedantic: the
+   * anti-pattern tier prints TWO separately-headed lists (the hand-rolling findings and
+   * the F52 missing-`baseUrl` findings) while being ONE section everywhere else — one
+   * structured list keyed by `rule`, one `--no-antipatterns` muting both. So that
+   * section's text output can reach a MULTIPLE of the cap. Deliberate: a project with 200
+   * money-float sites would otherwise never see its `baseUrl` advisory, which is the one
+   * that silently drops the API prefix from every generated hook, and starving the small
+   * list is the worse failure. Pinned in advisory-structured-output.test.ts.
    */
   limit: number;
 }
 
@@ -58,12 +58,22 @@ const ENTITY_JSON = JSON.stringify({
  * sites — each a money word plus minor-unit math on one line, which is the
  * scanner's high-precision `money-float` rule.
  */
-function project(extraConfig = ""): string {
+function project(extraConfig = "", baseUrlSites = 0): string {
   const dir = mkdtempSync(join(tmpdir(), "mo-advisory-"));
   mkdirSync(join(dir, "metaobjects"), { recursive: true });
   mkdirSync(join(dir, ".metaobjects"), { recursive: true });
   mkdirSync(join(dir, "src"), { recursive: true });
   writeFileSync(join(dir, "metaobjects", "meta.shop.json"), ENTITY_JSON);
+  // F52 sites: an entity-fetcher provider mounted with no baseUrl. A SECOND advisory list
+  // inside the same section as the anti-patterns above — see the two-list cap test.
+  if (baseUrlSites > 0) {
+    for (let i = 0; i < baseUrlSites; i++) {
+      writeFileSync(
+        join(dir, "src", `mount${i}.tsx`),
+        `<EntityFetcherProvider fetcher={fetcher}>\n  <App />\n</EntityFetcherProvider>\n`,
+      );
+    }
+  }
   writeFileSync(join(dir, ".metaobjects", "config.json"), JSON.stringify({ schema_version: 1, sources: [] }));
   writeFileSync(
     join(dir, "src", "checkout.ts"),
@@ -277,6 +287,51 @@ describe("text mode caps, --limit raises it, and every site honors one constant"
     }
   }, TIMEOUT_MS);
 
+  test("the cap is per printed LIST, so a two-list section can print 2x it", async () => {
+    // A DECISION, pinned, because it reads like a defect: `--limit 3` yields up to SIX
+    // advisory lines here. The anti-pattern tier prints two separately-headed lists — the
+    // hand-rolling findings and the F52 missing-baseUrl findings — and they are one SECTION
+    // everywhere else: one structured list keyed by `rule`, and one `--no-antipatterns`
+    // suppressing both.
+    //
+    // They keep separate caps for exactly the reason the caps are per-section at all: a
+    // shared budget lets the larger list push the smaller one off the end entirely. A
+    // project with 200 money-float sites would never see its baseUrl advisory, which is the
+    // one that silently drops the API prefix from every generated hook. Starving the small
+    // list is the worse failure, so each list gets its own budget and the section total can
+    // reach a multiple of the cap.
+    const dir = project(`\n  apiPrefix: "/api",`, 5);
+    try {
+      const { exit, err } = await capture(["verify", "--format", "text", "--limit", "3", "--cwd", dir]);
+      expect(exit).toBe(0);
+      // Both lists are present and each is capped at 3 — neither starved the other.
+      expect(adviceLines(err)).toHaveLength(3);
+      // "src/mount", not "mount" — the section HEADER says "mounted with no baseUrl".
+      const baseUrlLines = err.split("\n").filter((l) => l.includes("src/mount"));
+      expect(baseUrlLines).toHaveLength(3);
+      // ...and each list says how many IT held back, rather than one shared tail.
+      expect(err).toContain(`…and ${FINDINGS - 3} more`);
+      expect(err).toContain("…and 2 more");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }, TIMEOUT_MS);
+
+  test("...and the structured payload still carries both lists in ONE section, uncapped", async () => {
+    const dir = project(`\n  apiPrefix: "/api",`, 5);
+    try {
+      const { exit, out } = await capture(["verify", "--format", "json", "--limit", "1", "--cwd", dir]);
+      expect(exit).toBe(0);
+      const doc = JSON.parse(out) as { antiPatterns?: { total?: number; rows?: FindingRow[] } };
+      const rows = doc.antiPatterns?.rows ?? [];
+      expect(rows.filter((r) => r.rule === "missing-base-url")).toHaveLength(5);
+      expect(rows.filter((r) => r.rule !== "missing-base-url")).toHaveLength(FINDINGS);
+      expect(doc.antiPatterns?.total).toBe(FINDINGS + 5);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }, TIMEOUT_MS);
+
   test("--limit never truncates a structured payload, whatever it is set to", async () => {
     const dir = project();
     try {