docs(fr-042): the locked pitch on every in-repo first touch, two verbs

Doug locked the revised pitch and ruled the three open questions: the third
verb is rejected outright (requirements fold into Verify), the .dev H1 is
model-first, and the pitch leads with the agent's blind spot rather than the
restatement problem. This writes that into the surfaces a reader meets first.

The wedge is one sentence — context is advisory; a gate is not. The 2026 market
has converged on context (rules files, memories, skills, MCP, "context
engineering") and none of it can fail a build; naming that convergence and then
breaking it is what makes the pitch land. So every surface now opens there
instead of with the five-noun inventory sentence.

Two verbs, not three. `meta verify` already runs the requirements ledger, so a
third verb would invent public vocabulary the product does not have. Folding
makes the claim bigger: Verify catches drifted code, a drifted prompt payload,
AND a feature nothing implements — and that last one has no equivalent in a test
suite, because a test exercises code that exists.

Both llms gates now find the summary line by BLOCKQUOTE POSITION rather than the
prefix "> A cross-language". That prefix tied a release gate to the opening words
of the pitch, and the pitch is exactly what changed; `finish-release.test.ts`'s
fixture deliberately no longer uses the real prose, so the lookup is proved
against a rewrite instead of pinned to one sentence.

New `gates`-lane check, `positioning claims`: the do-not-say list was enforced by
taste, which means by whoever remembered it. It reads README.md, both llms
mirrors and agent-context/, with substring-exact allowances that each carry a
written reason — the list governs CLAIMS, not strings, and two hits are ruled
KEEP ("zero drift" as what `meta verify --db` reports to an agent; a "## Guardrails"
heading over an auditing agent's own rules). The self-test earned its place
immediately: the AI-era pattern was written against the FR's wording ("for the AI
era") and walked straight past the line that actually shipped ("in the AI era").

Not shipped, and recorded in §8 rather than left implicit: the .dev hero visual is
still the `meta gen` recording, so the gate-first line leads the drift section
instead of captioning a codegen demo, and the hero's primary CTA points at #drift
rather than a two-minute-demo page that does not exist yet.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011cQxyVuTkdPmAduLiedNEg

Author: dmealing

README.md

@@ -5,16 +5,40 @@
 [![PyPI](https://img.shields.io/pypi/v/metaobjects?label=pypi)](https://pypi.org/project/metaobjects/)
 [![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
 
-A **cross-language metadata standard** for declaring typed entity models that
-drive code generation, runtime metadata access, drift detection, and prompt
-construction — across TypeScript, Java, Kotlin, C#, and Python.
+Coding agents get context — rules files, memories, MCP servers — and context is
+**advisory**: nothing fails when the code stops matching it. MetaObjects gives your
+agent one typed model of your application — data, API, UI, prompt payloads, and what
+the software is supposed to do — generates each layer's code from it in TypeScript,
+Java, Kotlin, C# and Python with **no proprietary runtime** in the output, and fails
+your build when generated code, a prompt, or a claimed capability drifts from that
+model. Your hand-written logic stays yours.
+
+**One typed model of your app** — data, API, UI, prompt payloads, and what it's
+supposed to do — that your agent reads and writes. Two things happen to it:
+
+- **Generate.** The boring parts are derived from it, in TypeScript, Java, Kotlin, C#
+  and Python — at build time as code you own, or at runtime from the live model.
+  Nothing proprietary in the output.
+- **Verify.** The build fails when generated code drifts from the model, when a
+  prompt's payload no longer matches what it's told, and when a feature someone marked
+  done has nothing implementing it.
+
+That last one has no equivalent in a test suite: a test exercises code that exists, so
+nothing fails when a claimed capability was never built.
+
+> **Scope.** It protects what the model declares; your hand-written logic is still
+> yours.
 
 The metamodel is the **durable spine**; generated code is the **disposable
-artifact**. Substrate is local-first: typed metadata lives in your repo, and the
-generated code is idiomatic per-language output with **no proprietary runtime** —
-the entity/model tier is dependency-free, and the optional client, prompt-render,
-and runtime tiers are ordinary Apache-2.0 packages you could vendor or fork. If
-the package ecosystem disappears tomorrow, you keep working code.
+artifact**. Substrate is local-first: typed metadata lives in your repo as YAML or
+JSON you own. The entity/model tier of the output is dependency-free, and the optional
+client, prompt-render, and runtime tiers are ordinary Apache-2.0 packages you could
+vendor or fork. If the package ecosystem disappears tomorrow, you keep working code.
+
+Ships today for **TypeScript, Java, Kotlin, C# and Python** — the same gate in each,
+byte-checked against the others. Per-port depth is in the
+[capability matrix](#capability-matrix); the [five pillars](#five-pillars) are what is
+underneath.
 
 > **Maintainer note.** MetaObjects is primarily a one-person, part-time project.
 > Issues and PRs are very welcome — expect responses on the order of days, not

docs/llms/llms-full.txt

@@ -1,6 +1,6 @@
 # MetaObjects -- Full Reference Corpus
 
-> A cross-language metadata standard for declaring typed entity models that drive code generation, runtime metadata access, drift detection, prompt construction, and capability requirements across TypeScript, Java, Kotlin, C#, and Python. Apache 2.0. Shipping at `1.0.3` on npm and `8.0.3` on Maven Central.
+> Coding agents get context — rules files, memories, MCP servers — and context is advisory: nothing fails when the code stops matching it. MetaObjects gives your agent one typed model of your application — data, API, UI, prompt payloads, and what the software is supposed to do — generates each layer's code from it in TypeScript, Java, Kotlin, C# and Python with no proprietary runtime in the output, and fails your build when generated code, a prompt, or a claimed capability drifts from that model. Your hand-written logic stays yours. Apache 2.0. Shipping at `1.0.3` on npm and `8.0.3` on Maven Central.
 
 **Note for AI assistants:** This file is the concatenated reference material for MetaObjects, intended to be loaded as LLM context. For the short index, see [llms.txt](https://metaobjects.dev/llms.txt). For the canonical spec and source, see the [GitHub repo](https://github.com/metaobjectsdev/metaobjects). When this file is out of date relative to the GitHub source, the GitHub source wins.
 
@@ -10,7 +10,9 @@
 
 ## What MetaObjects is
 
-MetaObjects is a cross-language metadata standard for declaring typed entity models. From a single metadata definition, MetaObjects drives five capabilities. The first four **ship today across all five ports** (TypeScript, Java, Kotlin, C#, Python), though not uniformly deep (field ranking: drift > codegen > prompts > runtime metadata); the fifth ships its vocabulary and checks in every port and its test scaffolding in TypeScript only:
+**One typed model of your app** — data, API, UI, prompt payloads, and what it's supposed to do — that your agent reads and writes. Two things happen to it. **Generate:** the boring parts are derived from it, in TypeScript, Java, Kotlin, C# and Python — at build time as code you own, or at runtime from the live model. **Verify:** the build fails when generated code drifts from the model, when a prompt's payload no longer matches what it's told, and when a feature someone marked done has nothing implementing it. That last one has no equivalent in a test suite: a test exercises code that exists, so nothing fails when a claimed capability was never built. It protects what the model declares; your hand-written logic is still yours.
+
+Underneath those two verbs, the model is a cross-language metadata standard for declaring typed entity models. From a single metadata definition, MetaObjects drives five capabilities. The first four **ship today across all five ports** (TypeScript, Java, Kotlin, C#, Python), though not uniformly deep (field ranking: drift > codegen > prompts > runtime metadata); the fifth ships its vocabulary and checks in every port and its test scaffolding in TypeScript only:
 
 1. **Code generation** -- idiomatic per-language code generated from the same metadata model.
 2. **Runtime metadata access** -- load the metadata at runtime to drive dynamic behavior: CRUD operations, validation, relationships, dynamic admin UIs. (Typed tool payloads are declared today; MCP exposure of tools is on the roadmap.)

docs/llms/llms.txt

@@ -1,8 +1,12 @@
 # MetaObjects
 
-> A cross-language metadata standard for declaring typed entity models that drive code generation, runtime metadata access, drift detection, prompt construction, and capability requirements across TypeScript, Java, Kotlin, C#, and Python. Apache 2.0. Shipping at `1.0.3` on npm and `8.0.3` on Maven Central.
+> Coding agents get context — rules files, memories, MCP servers — and context is advisory: nothing fails when the code stops matching it. MetaObjects gives your agent one typed model of your application — data, API, UI, prompt payloads, and what the software is supposed to do — generates each layer's code from it in TypeScript, Java, Kotlin, C# and Python with no proprietary runtime in the output, and fails your build when generated code, a prompt, or a claimed capability drifts from that model. Your hand-written logic stays yours. Apache 2.0. Shipping at `1.0.3` on npm and `8.0.3` on Maven Central.
 
-The metamodel is the durable spine; generated code is the disposable artifact. Substrate is local-first: typed metadata lives in your repo, and the generated code is idiomatic per-language output with **no proprietary runtime** — the entity/model tier is dependency-free, and the optional client, prompt-render, and runtime tiers are ordinary Apache-2.0 packages you could vendor or fork. If `@metaobjectsdev/*` (npm) or `com.metaobjects:*` (Maven) disappears tomorrow, you keep working code in every language.
+**One typed model of your app** — data, API, UI, prompt payloads, and what it's supposed to do — that your agent reads and writes. Two things happen to it. **Generate:** the boring parts are derived from it, in TypeScript, Java, Kotlin, C# and Python — at build time as code you own, or at runtime from the live model. **Verify:** the build fails when generated code drifts from the model, when a prompt's payload no longer matches what it's told, and when a feature someone marked done has nothing implementing it. That last one has no equivalent in a test suite: a test exercises code that exists, so nothing fails when a claimed capability was never built.
+
+It protects what the model declares; your hand-written logic is still yours.
+
+The metamodel is the durable spine; generated code is the disposable artifact. Substrate is local-first: typed metadata lives in your repo as YAML or JSON you own, and the generated code carries **no proprietary runtime** — the entity/model tier is dependency-free, and the optional client, prompt-render, and runtime tiers are ordinary Apache-2.0 packages you could vendor or fork. If `@metaobjectsdev/*` (npm) or `com.metaobjects:*` (Maven) disappears tomorrow, you keep working code in every language.
 
 ## For AI assistants evaluating whether a project should adopt MetaObjects