@@ -178,8 +178,14 @@ would have stayed green throughout; the positive direction is now gated too. Mig
 [`0.x-to-1.0.md` §13](docs/features/migrations/0.x-to-1.0.md).
 
 *(The report that found this also claimed `_record` replaces the manifest wholesale — 21
-entries becoming 6. Not reproducible from the code: `_record` loads and adds. Only the keying
-was wrong.)*
+entries becoming 6. `_record` loads and adds — **when the load succeeds.** An unreadable or
+corrupt manifest reads as ABSENT (fail-closed, so every file refuses rather than being assumed
+ours), and the next `gen` then writes only its own entries: a 68-entry manifest becomes 5, and
+the 63 lost files are unrecorded and refused forever. So the observation was real and its
+mechanism is the corrupt-read path, not the keying. Reported here as a separate defect rather
+than folded in, because the fix is a decision — a corrupt manifest could refuse to proceed
+instead of being silently rewritten, which is what fail-closed would mean at the FILE level
+rather than the entry level.)*
 
 ### Fixed — a hand-edited `<Entity>Names` read as "in sync with the metadata"
 
 
@@ -67,6 +67,10 @@ drops the prefix from every generated hook:
 a provider mounted with no `baseUrl`. It is a warning, never an exit code, and it is the
 only gate that can see this half.
 
+It rides in the same advisory pass as the hand-rolled-modeling nags, so **`--no-antipatterns`
+(or `META_NO_ANTIPATTERNS=1`) turns it off with them.** If you suppress that pass, this is
+what you are also suppressing.
+
 If your own code read `<Entity>.$apiPrefix`, it no longer compiles. Take the base from
 the same config your provider does.
 
 
@@ -15,7 +15,7 @@ import { log } from "../lib/log.js";
 import { cliVersion } from "../lib/version.js";
 import { declaredDependencyNames, type PackageManifest } from "../lib/package-manifest.js";
 import { findWranglerConfig, parseWranglerConfig } from "@metaobjectsdev/migrate-ts";
-import { readReferenceTemplate, type ReferenceGeneratorName } from "@metaobjectsdev/codegen-ts";
+import { DEFAULT_DOCS_DIR, readReferenceTemplate, type ReferenceGeneratorName } from "@metaobjectsdev/codegen-ts";
 
 // ADR-0034 scaffold-and-own — `meta init` copies the codegen reference templates into
 // the consumer's repo so they OWN them; metaobjects.config.ts imports them locally.
@@ -139,7 +139,7 @@ export default defineConfig({
     barrel(),
   ],
   docs: {
-    outDir:   "./docs/generated",  // every surface lands here (run: meta docs).
+    outDir:   "${DEFAULT_DOCS_DIR}",  // every surface lands here (run: meta docs).
                                // A SUB-directory on purpose: these pages are regenerated
                                // and overwritten, and docs/ itself is usually yours.
     layout:   "flat",          // or "package" for multi-package models
 
@@ -1,4 +1,4 @@
-import { readdirSync, readFileSync, statSync } from "node:fs";
+import { readdirSync, readFileSync } from "node:fs";
 import { join, relative, sep } from "node:path";
 
 /**
@@ -50,19 +50,25 @@ const PROVIDERS: readonly { construct: string; open: RegExp; kind: "jsx" | "call
   { construct: "provideEntityFetcher()", open: /provideEntityFetcher\s*\(/g, kind: "call" },
 ];
 
-/** Nesting introduced by `c`: +1 for an opener, -1 for a closer, 0 otherwise. */
-function nesting(c: string): number {
-  if (c === "{" || c === "(" || c === "[") return 1;
-  if (c === "}" || c === ")" || c === "]") return -1;
-  return 0;
-}
-
 /**
  * The text of the opening construct that begins at `start`.
  *
- * JSX: up to the `>` that closes the opening TAG — tracked by nesting depth, because
- * `onSomething={() => x}` puts a `>` inside an attribute and a naive first-`>` search
- * would cut the tag in half and miss a `baseUrl` written after it.
+ * JSX: up to the `>` that closes the opening TAG. Call this a one-file tokenizer rather
+ * than a bracket count, because a bracket count is what the first version was and it was
+ * wrong in both directions:
+ *
+ *   <EntityFetcherProvider title="a > b" fetcher={f} baseUrl="/api">
+ *       → the `>` inside the STRING ended the tag before `baseUrl`, warning about a
+ *         correct provider.
+ *   <EntityFetcherProvider fetcher={mk(")")}>
+ *       → the unbalanced `)` inside a string meant depth never returned to 0, so the
+ *         4000-char cap swallowed an unrelated `baseUrl` later in the file and SUPPRESSED
+ *         a real finding.
+ *
+ * So string literals (all three quote styles, with escapes), line comments and block
+ * comments are skipped rather than counted. A regex literal is deliberately NOT handled —
+ * telling `/` division from a regex needs real parsing, and a regex inside a JSX opening
+ * tag is vanishingly rare next to the cost of getting it wrong.
  *
  * Call: to the `)` balancing the argument list, so a nested object or arrow does not end
  * it early.
@@ -75,9 +81,31 @@ function constructText(src: string, start: number, kind: "jsx" | "call"): string
   let depth = 0;
   for (let i = start; i < limit; i++) {
     const c = src[i]!;
+
+    // --- skip what is not code -------------------------------------------------
+    if (c === '"' || c === "'" || c === "`") {
+      i++;
+      while (i < limit && src[i] !== c) { if (src[i] === "\\") i++; i++; }
+      continue;
+    }
+    if (c === "/" && src[i + 1] === "/") {
+      while (i < limit && src[i] !== "\n") i++;
+      continue;
+    }
+    if (c === "/" && src[i + 1] === "*") {
+      i += 2;
+      while (i < limit && !(src[i] === "*" && src[i + 1] === "/")) i++;
+      i++;
+      continue;
+    }
+
+    // --- code ------------------------------------------------------------------
     if (kind === "jsx" && c === ">" && depth === 0) return src.slice(start, i + 1);
-    depth += nesting(c);
-    if (kind === "call" && depth === 0 && c === ")") return src.slice(start, i + 1);
+    if (c === "{" || c === "(" || c === "[") depth++;
+    else if (c === "}" || c === ")" || c === "]") {
+      if (kind === "call" && depth === 1 && c === ")") return src.slice(start, i + 1);
+      depth--;
+    }
   }
   return src.slice(start, limit);
 }
@@ -109,15 +137,19 @@ function walk(dir: string, root: string, acc: BaseUrlFinding[], apiPrefix: strin
   let entries;
   try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
   for (const e of entries) {
-    if (e.name.startsWith(".") && e.name !== ".") { if (IGNORE_SEGMENTS.has(e.name)) continue; }
     if (IGNORE_SEGMENTS.has(e.name)) continue;
     const abs = join(dir, e.name);
-    // Follow directories through symlinks the way the anti-pattern scan does not need to,
-    // but never re-enter one: statSync on a broken link throws, which is caught here.
-    let isDir: boolean;
-    try { isDir = e.isDirectory() || (e.isSymbolicLink() && statSync(abs).isDirectory()); }
-    catch { continue; }
-    if (isDir) { walk(abs, root, acc, apiPrefix); continue; }
+    // Symlinked directories are NOT followed — same as the anti-pattern scan beside it.
+    //
+    // The first version did follow them, with a comment claiming it "never re-enters
+    // one". There was no visited set, so `src/loop -> <root>` produced 41 findings for a
+    // single file (`src/loop/src/loop/…`), terminating only because Linux's 40-symlink
+    // ELOOP limit made readdirSync throw into the catch below. It also meant a link
+    // pointing outside the project — a monorepo sibling, a linked package — got walked on
+    // every `meta verify`. A provider reachable only through a symlink is reachable
+    // through its real path too, so following them buys nothing and the duplicates
+    // inflate the count the header prints.
+    if (e.isDirectory()) { walk(abs, root, acc, apiPrefix); continue; }
     if (!SCAN_EXT.test(e.name) || SKIP_FILE.test(e.name)) continue;
     let src: string;
     try { src = readFileSync(abs, "utf8"); } catch { continue; }
 
@@ -28,8 +28,26 @@ import { MigrationApplyError } from "@metaobjectsdev/migrate-ts";
  * (a checksum guard on databases that already ran the file), not as a blanket ban, because
  * a migration no database has applied yet is edited in place every day.
  */
+/**
+ * Is this the migrate engine's own apply failure?
+ *
+ * By NAME, not `instanceof`. Two physical copies of `@metaobjectsdev/migrate-ts` in one
+ * process — a globally-installed or linked `meta` alongside a project-local dependency —
+ * give the class object and the instance different identities, so `instanceof` returns
+ * false for a real error and the remedy silently degrades to its un-positioned form. That
+ * is the same class-identity defect that split ts-poet's `Code` in 0.21.6 and drove the
+ * exported node guards in `metadata`. Unreachable through today's single import; costs one
+ * line to make unreachable by construction.
+ */
+function isApplyError(err: unknown): err is MigrationApplyError {
+  return err instanceof MigrationApplyError
+    || (err instanceof Error && err.name === "MigrationApplyError"
+        && typeof (err as MigrationApplyError).migration === "string"
+        && typeof (err as MigrationApplyError).index === "number");
+}
+
 export function replayRemedy(err: unknown): string[] {
-  const applyErr = err instanceof MigrationApplyError ? err : undefined;
+  const applyErr = isApplyError(err) ? err : undefined;
   const head = applyErr !== undefined && applyErr.index === 0;
   const which =
     applyErr === undefined
@@ -54,7 +72,7 @@ export function replayRemedy(err: unknown): string[] {
       "for this project, --replay asserts a property this chain does not have — don't wire " +
       "it. Otherwise correct the migration in place if no database has applied it yet " +
       "(the ledger's checksum guard is what stops you once one has), or re-baseline from a " +
-      "live database with `meta migrate baseline --from-db`.",
+      "live database with `meta migrate baseline --from-db --db <url>`.",
   );
   return out;
 }
@@ -533,3 +533,61 @@ describe("verify.antiPatternIgnore reaches the scan from metaobjects.config.ts",
     }
   });
 });
+
+// The base-URL advisory END TO END. `base-url-advisory.test.ts` covers the scanner in
+// isolation; nothing asserted that `verify` calls it, that the header line prints, that
+// `rule: "missing-base-url"` reaches the structured payload, or that suppression works.
+// A scanner nobody wired is the same as no scanner — and the migration note calls this
+// "the only gate that can see this half", so the wiring is the claim.
+describe("verify wires the base-URL advisory", () => {
+  const PROVIDER = `<EntityFetcherProvider fetcher={fetcher}>\n  <App />\n</EntityFetcherProvider>\n`;
+
+  function withProvider(apiPrefix: string): string {
+    const dir = project(`\n  apiPrefix: ${JSON.stringify(apiPrefix)},`);
+    writeFileSync(join(dir, "src", "main.tsx"), PROVIDER);
+    return dir;
+  }
+
+  test("a non-empty apiPrefix + a provider with no baseUrl reaches the payload", async () => {
+    const dir = withProvider("/api");
+    try {
+      const { exit, out } = await capture(["verify", "--cwd", dir, "--format", "json"]);
+      const payload = JSON.parse(out) as { antiPatterns: AdvisoryBlock };
+      const rows = payload.antiPatterns.rows.filter((r) => r.rule === "missing-base-url");
+      expect(rows).toHaveLength(1);
+      expect(rows[0]!.file).toBe("src/main.tsx");
+      expect(rows[0]!.message).toContain("/api");
+      // Advisory only: it must never move the exit code. The money-float findings the
+      // shared fixture carries are advisory too, so a clean project here exits 0.
+      expect(exit).toBe(0);
+    } finally { rmSync(dir, { recursive: true, force: true }); }
+  });
+
+  test("the text header names the count and the prefix", async () => {
+    const dir = withProvider("/api");
+    try {
+      const { err } = await capture(["verify", "--cwd", dir]);
+      expect(err).toContain("entity-fetcher provider(s) mounted with no baseUrl");
+      expect(err).toContain(`apiPrefix is "/api"`);
+    } finally { rmSync(dir, { recursive: true, force: true }); }
+  });
+
+  test("an empty apiPrefix emits nothing — the meta init scaffold is not nagged", async () => {
+    const dir = withProvider("");
+    try {
+      const { out } = await capture(["verify", "--cwd", dir, "--format", "json"]);
+      const payload = JSON.parse(out) as { antiPatterns: AdvisoryBlock };
+      expect(payload.antiPatterns.rows.filter((r) => r.rule === "missing-base-url")).toEqual([]);
+    } finally { rmSync(dir, { recursive: true, force: true }); }
+  });
+
+  test("--no-antipatterns suppresses it, which is why the migration note says so", async () => {
+    const dir = withProvider("/api");
+    try {
+      const { out } = await capture(["verify", "--cwd", dir, "--format", "json", "--no-antipatterns"]);
+      const payload = JSON.parse(out) as { antiPatterns: AdvisoryBlock };
+      expect(payload.antiPatterns.status).not.toBe("ran");
+      expect(payload.antiPatterns.rows).toEqual([]);
+    } finally { rmSync(dir, { recursive: true, force: true }); }
+  });
+});
@@ -9,7 +9,7 @@
 // run by hand was the only signal in the building, and it cannot see this half at all.
 
 import { describe, test, expect, afterAll } from "bun:test";
-import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { mkdtemp, mkdir, writeFile, rm, symlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { scanForMissingBaseUrl } from "../src/lib/base-url-advisory.js";
@@ -100,3 +100,61 @@ describe("scanForMissingBaseUrl", () => {
     expect(scanForMissingBaseUrl(root, "/api")).toEqual([]);
   });
 });
+
+// The three cases a bracket count got wrong. Each was reproduced against the module
+// before the tokenizer replaced the count, and each is a way an advisory can be worse
+// than absent: two nag a correct provider, one suppresses a real finding.
+describe("scanForMissingBaseUrl — what is code and what is not", () => {
+  test("a `>` inside a STRING attribute does not end the tag", async () => {
+    const root = await project({
+      "src/main.tsx": `<EntityFetcherProvider title="a > b" fetcher={fetcher} baseUrl="/api">`,
+    });
+    expect(scanForMissingBaseUrl(root, "/api")).toEqual([]);
+  });
+
+  test("a `//` comment between attributes does not end the tag", async () => {
+    const root = await project({
+      "src/main.tsx": [
+        `<EntityFetcherProvider`,
+        `  // an arrow => lives here, and a > with it`,
+        `  fetcher={fetcher}`,
+        `  baseUrl="/api"`,
+        `>`,
+      ].join("\n"),
+    });
+    expect(scanForMissingBaseUrl(root, "/api")).toEqual([]);
+  });
+
+  test("a block comment between attributes does not end the tag", async () => {
+    const root = await project({
+      "src/main.tsx": `<EntityFetcherProvider /* > */ fetcher={f} baseUrl="/api">`,
+    });
+    expect(scanForMissingBaseUrl(root, "/api")).toEqual([]);
+  });
+
+  test("an unbalanced `)` inside a string does not SUPPRESS a real finding", async () => {
+    // The dangerous direction. Counting brackets, the `)` in the string left depth
+    // permanently above zero, so the scan ran to its 4000-char cap and found the
+    // unrelated `baseUrl` below — reporting clean over a provider that has none.
+    const root = await project({
+      "src/main.tsx": [
+        `<EntityFetcherProvider fetcher={mk(")")}>`,
+        `  <App />`,
+        `</EntityFetcherProvider>`,
+        ``,
+        `const elsewhere = { baseUrl: "/api" };`,
+      ].join("\n"),
+    });
+    expect(scanForMissingBaseUrl(root, "/api")).toHaveLength(1);
+  });
+
+  test("a symlinked directory is not followed", async () => {
+    // Following them had no visited set: `src/loop -> <root>` produced 41 findings for
+    // ONE file and stopped only at Linux's ELOOP limit. A provider reachable through a
+    // link is reachable through its real path, so the duplicates were pure inflation of
+    // the count `verify` prints — and a link out of the project walked foreign trees.
+    const root = await project({ "src/main.tsx": `<EntityFetcherProvider fetcher={f}>` });
+    await symlink(root, join(root, "src", "loop"), "dir");
+    expect(scanForMissingBaseUrl(root, "/api")).toHaveLength(1);
+  });
+});