@@ -19,6 +19,30 @@ here.**
   The always-on agent context links it, and now says a project that deliberately owns its schema
   outside MetaObjects follows its own migration rule.
 
+### Changed
+
+- **`meta verify` warns about whitespace in a node's `name`.** The loader accepts any
+  string as a name, in every port. An adopter's metadata, copied from legacy XML, had a field
+  named `"defaultCurrencyId "` (trailing space) and an identity named
+  `"account_defaultCurrencyId _fk"`, and both loaded with no error. A new advisory section,
+  `names`, reports every object, field, identity, relationship, validator, view, template or
+  other named node whose name contains whitespace (the ECMAScript `\s` class, so a pasted
+  no-break space counts). Leading or trailing whitespace gets `WARN_NAME_SURROUNDING_WHITESPACE`,
+  which says it is almost certainly unintended. Whitespace inside a name gets the plainer
+  `WARN_NAME_INTERNAL_WHITESPACE`. A name inherited through `extends` is reported once, where
+  it is declared. Requirement names are left to the requirement lint, which already reports
+  leading or trailing whitespace and still does not report a short multi-word label such as
+  `"Order Recording"`. Like the other authoring lints it **never fails the build**. It appears
+  in text output and as `names` in `--format json|toon`, and can be muted with
+  `--no-name-lint` or `META_NO_NAME_LINT=1`.
+  **Why a warning and not a load error:** refusing these names does not pass the correction
+  bar in `docs/compatibility-policy.md`. They work on the core path: `meta migrate` quotes the
+  column (`"default_currency_id "`) and the ObjectManager reads and writes the key. Multi-word
+  requirement names are documented to load. So rejecting them would break metadata that does
+  what its author declared. **Upgrading:** nothing stops loading. To clear a finding, rename
+  the node. On a field whose physical column must keep its current name, pin `@column` when
+  you rename it.
+
 ### Fixed
 
 - **The missing-FK-index advisory suggests a name unique to the table.** It suggested
 
@@ -102,6 +102,14 @@ Rules of the contract:
   lacks `overlay: true`. Advisory only, like the anti-pattern pass below — it never
   changes the exit code — and is muted the same way: `--no-overlay-lint` or
   `META_NO_OVERLAY_LINT=1`. See [`metadata-dependencies.md`](metadata-dependencies.md).
+- **The node-name authoring lint also runs on every `meta verify`.** It reports any
+  named node except a requirement whose `name` contains whitespace (the ECMAScript `\s`
+  class). The loader accepts these names on every port. `WARN_NAME_SURROUNDING_WHITESPACE`
+  flags leading or trailing whitespace, which is almost certainly unintended: rename the
+  node, and on a field pin `@column` if the physical column must keep its name.
+  `WARN_NAME_INTERNAL_WHITESPACE` flags whitespace inside a name. Requirement names
+  belong to the requirement lint. This lint is advisory only, appears as `names` in
+  `--format json|toon`, and is muted with `--no-name-lint` or `META_NO_NAME_LINT=1`.
 
 ### The prompt directory: `--prompts` everywhere (F101)
 
 
@@ -39,6 +39,7 @@ import {
 } from "../lib/requirement-check.js";
 import { lintRequirements } from "../lib/requirement-lint.js";
 import { lintOverlays } from "../lib/overlay-lint.js";
+import { lintNodeNames } from "../lib/name-lint.js";
 import { FileSource } from "@metaobjectsdev/metadata/core";
 import { resolveD1Config, resolveMigrateConfig } from "../lib/config.js";
 import {
@@ -350,6 +351,11 @@ export async function verifyCommand(
   // way every other advisory pass does.
   let overlaySection: AdvisorySection<AdvisoryDiagnosticRow> =
     skippedSection("the overlay lint did not run");
+  // The node-name authoring lint — its own section for the same reason: a model
+  // carrying a few hundred legacy names must not push another section's findings
+  // off the end of a capped run.
+  let nameSection: AdvisorySection<AdvisoryDiagnosticRow> =
+    skippedSection("the name lint did not run");
   // The ledger counts `meta verify` prints on every run. Undefined for a project
   // declaring no requirement.* node at all (opt-in by declaration) — the payload
   // then omits the block rather than reporting zeroes that would read as an empty
@@ -386,6 +392,10 @@ export async function verifyCommand(
   // Warnings ONLY — never changes the exit code.
   await runOverlayLintAdvisory();
 
+  // Whitespace in a node's `name` — loads clean on every port, almost never meant.
+  // Runs on every `meta verify`; warnings ONLY, never changes the exit code.
+  runNameLintAdvisory();
+
   // Advisory verify-as-teacher pass: surface hand-rolled work the metadata could
   // model. Warnings ONLY — never changes the exit code (bias to under-flagging).
   // Suppressed with --no-antipatterns or META_NO_ANTIPATTERNS=1 for the rare
@@ -434,6 +444,7 @@ export async function verifyCommand(
         requirementCounts,
         antiPatterns: antiPatternSection,
         overlays: overlaySection,
+        names: nameSection,
       }),
       fmt,
     );
@@ -808,6 +819,29 @@ export async function verifyCommand(
     }
   }
 
+  // -- node-name authoring lint (advisory) -----------------------------------
+  // Reads the LOADED model (see name-lint.ts). Its own section, its own cap, and
+  // a skip that carries its reason rather than looking like a clean scan.
+  function runNameLintAdvisory(): void {
+    if (flags.noNameLint) {
+      nameSection = skippedSection("suppressed by --no-name-lint");
+      return;
+    }
+    if (process.env.META_NO_NAME_LINT === "1") {
+      nameSection = skippedSection("suppressed by META_NO_NAME_LINT=1");
+      return;
+    }
+    const findings = lintNodeNames(root);
+    nameSection = ranSection(findings.map((d) => toDiagnosticRow(d, "lint")));
+    if (findings.length > 0) {
+      log.warn(
+        `meta verify — names: ${findings.length} authoring warning(s) ` +
+          `(advisory — does not fail the build):`,
+      );
+      warnCapped(findings.map(formatDiagnostic), flags.limit, { structured });
+    }
+  }
+
   // -- verify-as-teacher (advisory) ------------------------------------------
   // Records its result EITHER WAY — a skip carries its reason rather than looking
   // like a clean scan. Warnings only; nothing here reaches the exit code (the
@@ -1821,6 +1855,7 @@ function buildVerifyPayload(input: {
   requirementCounts: RequirementCounts | undefined;
   antiPatterns: AdvisorySection<AdvisoryFindingRow>;
   overlays: AdvisorySection<AdvisoryDiagnosticRow>;
+  names: AdvisorySection<AdvisoryDiagnosticRow>;
 }): Record<string, unknown> {
   const ran = input.gates.filter((g) => g.ran);
   const failed = ran.filter((g) => !g.ok);
@@ -1840,6 +1875,9 @@ function buildVerifyPayload(input: {
   if (input.overlays.status === "ran" && input.overlays.total > 0) {
     parts.push(`${input.overlays.total} overlay authoring finding(s)`);
   }
+  if (input.names.status === "ran" && input.names.total > 0) {
+    parts.push(`${input.names.total} name authoring finding(s)`);
+  }
 
   const help: string[] = [];
   if (failed.length > 0) {
@@ -1855,11 +1893,17 @@ function buildVerifyPayload(input: {
       `${input.overlays.total} unflagged cross-file redeclaration(s) — see overlays.rows[]; add overlay: true so a renamed or removed target fails loudly instead of silently becoming a new object`,
     );
   }
+  if (input.names.total > 0) {
+    help.push(
+      `${input.names.total} node name(s) containing whitespace — see names.rows[]; rename each node, and pin @column on a field whose physical column must keep its name`,
+    );
+  }
   if (
     failed.length === 0 &&
     input.antiPatterns.total === 0 &&
     input.requirements.total === 0 &&
-    input.overlays.total === 0
+    input.overlays.total === 0 &&
+    input.names.total === 0
   ) {
     help.push("no drift and nothing advisory to answer — nothing to do");
   }
@@ -1872,6 +1916,7 @@ function buildVerifyPayload(input: {
     antiPatterns: input.antiPatterns,
     requirements: input.requirements,
     overlays: input.overlays,
+    names: input.names,
     ...(input.requirementCounts !== undefined ? { requirementCounts: input.requirementCounts } : {}),
     // The honest boundary. Everything named here is REACHABLE — it is printed as
     // text on stderr — but it is not in this document, and a reader must not have
 
@@ -127,6 +127,8 @@ VERIFY FLAGS (ADR-0021 D2 — explicit subverbs; combine any; exit 1 on ANY drif
   --no-requirement-lint Suppress the advisory requirement AUTHORING lint (not the gate)
   --no-overlay-lint     Suppress the advisory overlay-redeclaration AUTHORING lint
                         (never a gate — this lint can't fail the build)
+  --no-name-lint        Suppress the advisory node-name AUTHORING lint (whitespace
+                        in a name; never a gate — this lint can't fail the build)
   --limit <n|all>       How many advisory lines TEXT output prints per section before
                         it truncates (default 20). Never applies to --format
                         toon/json, which carry every finding and every diagnostic.
@@ -320,6 +322,8 @@ FLAGS:
   --no-requirement-lint Suppress the advisory requirement AUTHORING lint (not the gate)
   --no-overlay-lint     Suppress the advisory overlay-redeclaration AUTHORING lint —
                         never a gate; this lint can't fail the build
+  --no-name-lint        Suppress the advisory node-name AUTHORING lint (whitespace in
+                        a name) — never a gate; this lint can't fail the build
   --limit <n|all>       Advisory lines TEXT output prints PER SECTION before truncating
                         (default 20; per-section so the authoring lint can never push
                         the gate's own warnings off the end)
@@ -350,6 +354,13 @@ redeclaration lacks 'overlay: true' — today's default merge rule reuses it
 silently, but the same unflagged redeclaration silently becomes a NEW object
 the day the target is renamed or removed upstream. Warnings only — it can
 never fail the build. Opt out with --no-overlay-lint or META_NO_OVERLAY_LINT=1.
+
+verify also prints an ADVISORY node-name authoring lint, in its own section: any
+node (object, field, identity, relationship, ...) whose name contains whitespace.
+Leading or trailing whitespace is almost certainly a copy-paste accident — rename
+the node, and pin @column on a field whose physical column must keep its name.
+Requirement names are left to the requirement lint above. Warnings only — it can
+never fail the build. Opt out with --no-name-lint or META_NO_NAME_LINT=1.
 `,
   export: `meta export — flatten loaded metadata to one canonical JSON artifact
 
 
@@ -362,6 +362,13 @@ export interface VerifyFlags {
    * lint has no gate half at all — it can never fail the build).
    */
   noOverlayLint: boolean;
+  /**
+   * Suppress the advisory node-NAME authoring lint — whitespace in a node's
+   * `name` (a trailing space copied from legacy XML loads clean on every port).
+   * Advisory only, like its siblings: it has no gate half and can never fail
+   * the build.
+   */
+  noNameLint: boolean;
   /**
    * ADR-0023 strict-attr load opt-OUT (#96). `verify` is strict-by-default — an
    * undeclared/typo'd own `@attr` fails verify (ERR_UNKNOWN_ATTR). `--lax`
@@ -403,6 +410,7 @@ export const VERIFY_OPTIONS = {
   "no-antipatterns": { type: "boolean", default: false },
   "no-requirement-lint": { type: "boolean", default: false },
   "no-overlay-lint": { type: "boolean", default: false },
+  "no-name-lint": { type: "boolean", default: false },
   lax: { type: "boolean", default: false },
   "d1": { type: "string" },
   "remote": { type: "boolean", default: false },
@@ -487,6 +495,7 @@ export function parseVerifyArgs(argv: string[]): VerifyFlags {
     noAntipatterns: !!values["no-antipatterns"],
     noRequirementLint: !!values["no-requirement-lint"],
     noOverlayLint: !!values["no-overlay-lint"],
+    noNameLint: !!values["no-name-lint"],
     lax: !!values.lax,
     d1: values.d1 as string | undefined,
     remote: !!values.remote,
 
@@ -0,0 +1,106 @@
+// `meta verify` — the node-name AUTHORING lint.
+//
+// The loader accepts any string as a node `name`, on every port. An adopter's metadata
+// carried a field named `"defaultCurrencyId "` (a trailing space, copied from legacy XML)
+// and an identity named `"account_defaultCurrencyId _fk"`; both loaded with no error.
+//
+// WHY THIS IS A WARNING AND NOT A LOAD ERROR. It was weighed against the correction bar
+// in docs/compatibility-policy.md and does not pass it: whitespace names WORK today on
+// the core path — `meta migrate` emits a quoted column (`"default_currency_id "`) and the
+// ObjectManager round-trips the key — and multi-word requirement names are documented to
+// load. Refusing them at load would break metadata that does what its author asked, so
+// the honest instrument is an advisory that names the edit.
+//
+// EVERY FINDING IS A WARNING, BY CONSTRUCTION — the same rule, and the same reasoning,
+// as requirement-lint.ts's header. Nothing here reaches the exit code.
+//
+// REQUIREMENTS ARE NOT LINTED HERE. A requirement's name is its dotted ADDRESS and the
+// requirement lint already owns it (WARN_REQUIREMENT_NAME_NOT_ADDRESSABLE reports
+// leading/trailing whitespace; a short multi-word label such as "Order Recording" is
+// deliberately NOT reported, because renaming one moves its address and its emitted
+// stub file for no gain). Reporting the same name twice under two codes would make
+// one edit look like two problems.
+//
+// IT READS THE LOADED MODEL, NEVER THE FILES — and walks DECLARATIONS (see `walk`).
+
+import { PACKAGE_SEPARATOR, TYPE_FIELD, TYPE_REQUIREMENT, type MetaData } from "@metaobjectsdev/metadata";
+import type { Diagnostic } from "./requirement-check.js";
+
+/** Leading or trailing whitespace — the strong finding. */
+export const WARN_NAME_SURROUNDING_WHITESPACE = "WARN_NAME_SURROUNDING_WHITESPACE";
+/** Whitespace inside an otherwise trimmed name — the plain advisory. */
+export const WARN_NAME_INTERNAL_WHITESPACE = "WARN_NAME_INTERNAL_WHITESPACE";
+
+/**
+ * What counts as whitespace: the ECMAScript `\s` class. That is ASCII space, tab, LF,
+ * CR, VT and FF, plus U+00A0 (no-break space), U+FEFF, U+1680, U+2000–U+200A, U+2028,
+ * U+2029, U+202F, U+205F and U+3000. The non-ASCII members matter for this lint's
+ * actual source of input: a no-break space survives a copy out of a document or a
+ * legacy export and is invisible in every editor.
+ */
+const WHITESPACE = /\s/u;
+
+function warn(path: string, code: string, message: string): Diagnostic {
+  return { severity: "warn", code, path, message };
+}
+
+/** One segment of a node's address. A name with whitespace is quoted so the
+ *  whitespace is visible in the printed path rather than vanishing into it. */
+function segment(name: string): string {
+  return WHITESPACE.test(name) ? JSON.stringify(name) : name;
+}
+
+function check(node: MetaData, path: string, out: Diagnostic[]): void {
+  const name = node.name;
+  if (name === "" || !WHITESPACE.test(name)) return;
+
+  const kind = `${node.type}.${node.subType}`;
+  const quoted = JSON.stringify(name);
+  // @column is a FIELD attribute. Advising an object or identity author to pin it
+  // would send them looking for a slot that does not exist on the node.
+  const pin = node.type === TYPE_FIELD ? ", and pin @column if the physical column must keep its name" : "";
+  const trimmed = name.trim();
+
+  if (trimmed !== name) {
+    const inner = WHITESPACE.test(trimmed) ? " It also contains whitespace inside it." : "";
+    const target = trimmed === "" ? "" : ` (to ${JSON.stringify(trimmed)}, presumably)`;
+    out.push(warn(path, WARN_NAME_SURROUNDING_WHITESPACE,
+      `${kind} name ${quoted} has leading or trailing whitespace, which is almost certainly ` +
+      `unintended — rename it${target}${pin}. The whitespace is carried into every identifier, ` +
+      `column and wire key derived from the name.${inner}`));
+    return;
+  }
+
+  out.push(warn(path, WARN_NAME_INTERNAL_WHITESPACE,
+    `${kind} name ${quoted} contains whitespace. A name is an identifier: derived column names ` +
+    `and wire keys carry the space, and generated code cannot use it as one. Consider ` +
+    `renaming it${pin}.`));
+}
+
+/** A root-level node's address: package-qualified the way `resolutionKey()` is, so the
+ *  path reads like every other reference to the node. */
+function topLevelAddress(node: MetaData): string {
+  const pkg = node.package ?? node.fileDefaultPackage;
+  return pkg !== undefined && pkg !== "" ? `${pkg}${PACKAGE_SEPARATOR}${segment(node.name)}` : segment(node.name);
+}
+
+/**
+ * Lint the name of every named node in the loaded model, requirements excepted.
+ * Returns `[]` for a model with no whitespace in any name.
+ */
+export function lintNodeNames(root: MetaData): Diagnostic[] {
+  const out: Diagnostic[] = [];
+  const walk = (n: MetaData, prefix: string): void => {
+    // OWN-ONLY (ADR-0039 sanctioned case): this reports each DECLARATION once, at the
+    // node that declares it. A field inherited through `extends` is one declaration and
+    // one rename; the resolving `children()` would repeat it on every subtype.
+    for (const c of n.ownChildren()) {
+      if (c.type === TYPE_REQUIREMENT) continue; // owned by requirement-lint.ts — see header
+      const path = prefix === "" ? topLevelAddress(c) : `${prefix}.${segment(c.name)}`;
+      check(c, path, out);
+      walk(c, path);
+    }
+  };
+  walk(root, "");
+  return out;
+}
@@ -107,6 +107,8 @@ VERIFY FLAGS (ADR-0021 D2 — explicit subverbs; combine any; exit 1 on ANY drif
   --no-requirement-lint Suppress the advisory requirement AUTHORING lint (not the gate)
   --no-overlay-lint     Suppress the advisory overlay-redeclaration AUTHORING lint
                         (never a gate — this lint can't fail the build)
+  --no-name-lint        Suppress the advisory node-name AUTHORING lint (whitespace
+                        in a name; never a gate — this lint can't fail the build)
   --limit <n|all>       How many advisory lines TEXT output prints per section before
                         it truncates (default 20). Never applies to --format
                         toon/json, which carry every finding and every diagnostic.