Classification: layer=B (names & tokens) + H (weak-reader); mechanism=rule. *The slug names the broader R3-004 aspiration ("closed-vocabulary naming"). The SHIPPED checker enforces one half of it — the name is COMPUTED from the manifest; the closed-vocabulary, one-referent, and no-synonym/shadow halves are named below as unbuilt, not hidden.*

Intent: a cell's canonical type name is not chosen freely but COMPUTED from its manifest — `Pascal(variant)` followed by the seam SPELLED AS WRITTEN — so the type announces which variant of which seam it is, and a rename rides a compiler-checked edit of the manifest, not an author's memory.

Also Known As: computed-cell-name; `cell-name-is-computed`; the `WalFreshnessCheck` house style; R3-004 (composition half); B-038 fork №1.

Applicability / Recognition: an item carries a `cell(seam = "…", variant = "…")` manifest attr — the Rust frontend lowers `#[cell(seam = "…", variant = "…")]` into it VERBATIM, and the Go extract bridge renders `//spec:cell seam=… variant=…` into the SAME `cell(seam = "…", variant = "…")` string (the single place the rust notation is born for Go) — and the declared type name's final path segment is not the composed name. *Detector seed:* for each item with a `cell(…)` attr, read `variant` and `seam`, compose `Pascal(variant)` (split the variant on `_` and `-`, title-case each word, keep the rest as written) concatenated with `seam` verbatim — never re-cased — and compare it to the declared name's last `::` segment (`SatDepSolver`, not `SatDepsolver`). A manifest missing either key composes nothing and is skipped (the vacuity guard — it never reds).

Motivation: a struct named `Sat` behind a `#[cell(seam = "DepSolver", variant = "sat")]` manifest hides which seam-variant it is — a reader must open the manifest to learn it, and the next author renames the type without touching the manifest, so the two drift. Computing the name (`SatDepSolver`) puts the announcement in the type itself, and a rename tracks a manifest edit through the compiler. The `WalFreshnessCheck` family already lived this way before the rule — `variant = "wal-freshness"` + `seam = "Check"` → `WalFreshnessCheck` — so the convention was house style in the largest cell family; the rule makes it machine-checked rather than remembered.

Structure & Participants: the conform fact `Fact::Item { symbol, attrs, … }` — the Rust frontend lowers the `#[cell]` manifest into `attrs` verbatim; the Go bridge renders the `//spec:cell` directive into the same `cell(seam = "…", variant = "…")` string, dropping the extra keys (`replaces`, `flag`) the Go directive carries — → `cell-name-is-computed` extracts `seam` and `variant` through one parser both attr shapes feed, composes `Pascal(variant) + seam`, and compares the declared name's final segment; a divergent name is one finding naming both names. Fingerprints key on `(file, declared_name)`, **never line** — the stop.rs lesson: a line-keyed baseline rots on any edit above the cell.

Collaborations: rides the same conform gate, SARIF output, and ratchet baseline as the other structural rules; **one engine rule serves Rust AND Go** — both drivers mount `CellNameIsComputed`, so the Go convention (practised by hand until now, with no machine check anywhere) is closed in the same move rather than left as an asymmetry; the `rust-ai-native codemod add-cell` scaffolds from the same `pascal`, so the rule and the codemod agree on every name; every finding renders through the one `req_message` renderer (Class-F grammar, R3-011).

Goals / Non-Goals: *Goals:* enforce that a cell's type name IS its manifest composed — `Pascal(variant)` + the seam as written. *Non-Goals (the honest boundary):* **the rule checks COMPOSITION ONLY.** It does NOT check — and the tree contains ZERO of — a closed vocabulary of structural tokens, one-name-one-referent repo-wide, or synonym/shadow detection on contract surfaces. Those are the other halves of R3-004, and **this section is their record** — they are specified and not built, and they are not built because they were **not chosen**: the owner's fork №1 took computed names over the closed-vocabulary variant that would have needed all three. Building them later needs a token vocabulary (none exists in the tree, neither as data nor as a constant) plus a referent/uniqueness checker; both are absent by decision, not by oversight. The rule is also NOT a general naming linter and does NOT touch items without a cell manifest.

Consequences: (+) a cell's name announces its seam-variant at every call site; (+) renames are compiler-checked, riding a manifest edit; (+) one rule reads two languages through one attr string, so a second grammar form never appears. (−) a multi-word seam must already be spelled in the casing the name should carry (`DepSolver`, not `depsolver`) — the rule substitutes it verbatim by design, so a sloppily-cased seam reads oddly in the composed name, which is the price of the seam surviving intact; (−) the rule is near-vacuum where the convention already held (14 of 40 cells were pre-compliant), so its value is holding the line, not red-ing today.

Alternatives: free naming plus a separate vocabulary/uniqueness lint — the closed-vocabulary variant the owner did not take; it needs a token vocabulary that does not exist in the tree. Pascal-both-halves composition (`SatDepsolver`) — mangles a multi-word seam and was explicitly rejected by fork №1. No check at all — the pre-rule state for Go: a convention held by memory, which decays (the failure mode this discipline exists to close).

Risks & Assumptions: assumes the manifest's `seam` is already in the spelling the name should carry, since the rule substitutes it verbatim and never re-cases it; assumes `variant` words compose cleanly under Pascal-case (the `pascal` splits on `_` and `-`). *Sunset:* if cell names become un-representable except through the codemod (the codemod as the sole authoring path makes a divergent name impossible to write), or if the manifest gains a richer naming scheme the composer must follow, the composition check is subsumed and this card retires with its checker (R-050).

Evidence & Transfer-strength: checker shipped (`cell-name-is-computed`, doctested in `core-ai-native-conform/src/rules/naming.rs`, mounted in `rust-ai-native-conform` and `go-ai-native-conform`); R3-004. Exhibited on fixtures — Go clean `FormalGreeting` / dirty `Wrongplanner`, Rust test cells brought to their computed names. Measurement (boss, whole tree, B-038 fork №1): **40** manifest-bearing cells; **14** already compliant (all of `vibe-check` → `WalFreshnessCheck`, so the convention was house style before the rule); **13** production renames in host `crates/` (`vibe-resolver` ×5, `vibe-mcp` ×4, `vibe-registry` ×2, `vibe-index` ×2), the rest test fixtures and regenerated `.vibe/cache/**`; **no name is wire-visible** (MCP tool names are separate string literals), so every rename is compiler-checked and internal. Portability: **Rust + Go** (both mount the rule); **TypeScript carries a recorded reason** — it has no cell manifest, so there is nothing to compute, held by the parity law `spec://org.vibevm.ai-native/core-ai-native/00-MANIFESTO#PARITY-GAP-IS-NEVER-SILENT`, not in silence. Tag: **[E-mid]** — the convention's pre-existence as house style is the strongest part of the evidence, but the comprehension gain is unmeasured (parallel to `rule-position-is-a-resource`).