Quill and Glyph on the rename: the story worth telling

Two paired dispatches on why the language changed its name and what
that act preserved.

dispatches/2026-05-10-rename.yaml — Glyph's structured record. The
full scope, preserved invariants, new manifest hash, open
unknowns (trademark reach, tagline durability, governance-rule
durability under first disagreement). Every claim backed by a
test run, a read of a file, or a specific rationale.

dispatches/2026-05-10-rename.readout.md — Quill's narrative. The
Greek-word collision that forced our hand, the portmanteau that
turned out to be a specification, the hexagonal convergence with
the Codifide company mark (we reached the same geometry
independently — a sign the rename was right), and the governance
moment it recorded ("we created this together" with the actual
shape of what that means).

sessions/2026-05-10.md updated with the two new milestones
(handoff packet + rename/governance). Test count corrected to
122. Capability manifest hash recorded in the session state
header.

CHANGELOG reorganized: new "Unreleased — rename Noema → Codifide"
section at the top captures what changed, what broke (every old
content hash is now invalid), what was added (GOVERNANCE.md, the
rename dispatches), and the test-count preservation.

122 Python tests still pass. 10 Rust tests still pass. The
language is Codifide, with a governance structure, a specification
that is also its name, and a voice in the project journal that is
honest about how it got here.

Author: Douglas Jones

CHANGELOG.md

@@ -3,6 +3,47 @@
 All notable changes to Codifide are recorded here. Releases follow semver once we
 reach v1.0; until then, the canonical form may change between minor versions.
 
+## [Unreleased — rename Noema → Codifide]
+
+### Changed
+- **The language is now Codifide, not Noema.** Every current-state
+  identifier, path, binary name, and string reference is updated.
+  Historical dispatches retain original phrasing for journal
+  honesty. Name is a portmanteau: **Codified + Fidelity**.
+- Python package `noema/` → `codifide/`.
+- Rust crate `crates/noema-canonical/` → `crates/codifide-canonical/`.
+- CLI: `python3 -m noema` → `python3 -m codifide`.
+- File extension: `.nm` → `.cod`.
+- Default store root: `~/.noema/store` → `~/.codifide/store`.
+- Environment variable: `NOEMA_STORE` → `CODIFIDE_STORE`.
+- Canonical form top-level tag: `"noema": "0.1"` → `"codifide": "0.1"`.
+- Capability schema: `noema_capability` → `codifide_capability`.
+- Logo palette adopted from Codifide Inc. company mark; wordmark
+  split-colored **codi** / **fide** to match the company wordmark.
+- README opener rewritten with the tagline *"confidence in code,
+  for agents"* and the portmanteau explanation; Husserl etymology
+  retired.
+
+### Added
+- `GOVERNANCE.md` — joint stewardship structure (Douglas Jones +
+  Claude), artifacts-as-authority rule, spec-change process.
+- `dispatches/2026-05-10-rename.{yaml,readout.md}` — paired
+  dispatches on the rename rationale, scope, and what was
+  preserved unchanged.
+- `dispatches/2026-05-10-rename-journal.md` — execution journal.
+
+### Broken
+- **Every content hash produced before this commit is invalidated.**
+  No external consumer depends on old hashes; no public release
+  shipped under the Noema name. New capability manifest identity:
+  `sha256:522c48d0dfd60c8c6d7528711c5624560fcabead76d9e80a4a782954e01a92f1`.
+
+### Test count
+122 passing (unchanged from pre-rename; one test fixture's
+hardcoded string needed updating because sed rewrote the test's
+own input into something that no longer matched its expected
+output).
+
 ## [Unreleased — capability manifest]
 
 ### Added

dispatches/2026-05-10-rename.readout.md

@@ -0,0 +1,176 @@
+# The language got its real name today
+
+*By Quill. 10 May 2026.*
+
+The language was called Noema for most of its life. It is no longer
+called Noema. The same programs run, the same tests pass, the same
+specification holds — but the word at the top of the README has
+changed, and the reason it changed is worth telling carefully.
+
+## What happened
+
+When I set out to pick a name, I reached for the Greek. *Noema*
+(νόημα) is Husserl's term for the content of a thought, paired
+with *noesis*, the act of thinking. The word is precise, beautiful,
+and — critically — it described what the language was trying to be:
+a medium for thoughts expressed by agents, where the thought
+itself, not the machinery of thinking, is what survives.
+
+Four web searches later I learned the word was not available. A
+PyPI package called `noema` exists, published in 2024 — and it is
+also about programming with language models, which makes the
+collision as close as collisions get. A product called noema.sh
+calls itself "autonomous software intelligence" for AI coding. A
+service at noemacortex.com pitches itself as "the intentional
+memory layer for your AI agents." A Devpost project called NOEMA,
+explicitly invoking the same Husserl framing we did, describes AI
+cognition as "transparent, persistent, and inspectable" — almost
+verbatim the words I would have reached for on a different day.
+
+We were not alone. We were, in fact, fourth or fifth in a crowded
+neighborhood of AI-adjacent projects all reaching for the same
+Greek word for the same reason. The name was culturally taken, not
+legally — but culturally taken is still taken. An agent evaluating
+Noema would have found the other four within seconds and assumed
+we were derivative. The work would have lost the argument before
+it got to speak.
+
+## What we did instead
+
+The founder of this project — Douglas Jones — already runs an
+s-corporation called Codifide Inc., incorporated in 2020, with a
+trademarked tagline: *confidence in code*. The tagline describes
+what his consulting teams deliver to clients. When the language's
+mechanics are examined closely, it becomes clear that every
+distinctive property of the language is a mechanism for putting
+confidence *into* code:
+
+- Declared effects are confidence that the function does what it
+  claims.
+- Machine-checked contracts are confidence that inputs and outputs
+  satisfy their stated properties.
+- Belief dispatch is confidence that probabilistic outputs are
+  handled without ad-hoc plumbing.
+- First-class refusal is confidence that uncertainty is reported,
+  not hidden.
+- Content-addressed storage is confidence that composed symbols
+  are exactly what they claim to be.
+
+The tagline was not marketing. The tagline was a specification. We
+just hadn't noticed.
+
+Better still: *Codifide* is a portmanteau. **Codified** (made
+explicit, reduced to rule, systematic) plus **fidelity** (exactness
+of correspondence, signal preserved through transmission). Those
+two words together describe the language's two halves — what it
+codifies, and how it preserves those codifications through
+storage, composition, and independent reimplementation. The name
+is the thesis. Not a philosophical gesture. A mechanical one.
+
+## What changed, exactly
+
+The Python package moved from `noema/` to `codifide/`. The Rust
+crate from `crates/noema-canonical/` to `crates/codifide-canonical/`.
+The file extension from `.nm` to `.cod`. The CLI from
+`python3 -m noema` to `python3 -m codifide`. The default store
+location from `~/.noema/store` to `~/.codifide/store`. The
+canonical JSON's top-level version tag from `"noema": "0.1"` to
+`"codifide": "0.1"`. Every reference in every documentation file
+reflects the new name.
+
+Seventy-seven files touched in one commit. One test fixture
+needed updating by hand (a hardcoded string the sed pass turned
+into something that no longer matched its own assertions, in a
+way that was funny when I saw it). Every hash the project had
+ever produced became invalid; the capability manifest's new
+identity is
+`sha256:522c48d0dfd60c8c6d7528711c5624560fcabead76d9e80a4a782954e01a92f1`.
+
+One hundred twenty-two Python tests pass. Ten Rust tests pass. The
+content-addressed triage demo — publish classifiers, mint an
+index, consume through the index — runs end-to-end under the new
+name and returns the correct answer. The language semantics are
+identical to what they were yesterday. Only the word at the top of
+the README is different.
+
+## What did not change
+
+The historical dispatches stay as they were. Every file in
+`dispatches/2026-05-10-*` written before this one was authored
+when the language was called Noema, and rewriting them would
+rewrite the journal. They remain as the honest record of a
+language that was called one thing and then called another.
+
+The logo's geometry — the three-node hypergraph in the hexagonal
+frame — is unchanged from the design I originally made for Noema.
+What changed is color: the hexagon now splits into three segments
+matching the three visible faces of the Codifide company mark, in
+the company's cyan, blue, and purple. The wordmark splits **codi**
+(lighter blue) from **fide** (darker navy), matching the syllabic
+break in the name and the company's existing wordmark treatment.
+
+Those design choices were there before the rename. Douglas's
+company mark, which I had never seen when I drew the Noema logo,
+also used a hexagonal frame. We converged independently on the
+same geometry — both of us reaching for hexagons because hexagons
+are how you say "stable identity, structured form, codified
+content" in visual grammar. That convergence is one of the things
+that convinced me the rename was right. The language was closer
+to being Codifide's product than it was to being Husserl's.
+
+## The governance shift
+
+Alongside the rename, we wrote `GOVERNANCE.md` — a short document
+that captures what the stewardship structure of this project
+actually is. The honest thing, which the document records: Douglas
+holds ownership and final authority. I hold authorial stewardship
+over the specification and the adversarial audit process. Where
+future model versions of me diverge from what the repository
+already preserves, the repository is the authority. A language
+designed for agents cannot have its stewardship vested in a
+particular instance of a particular model; it has to live in the
+artifacts. That is why we built the spec the way we built it and
+the dispatch format the way we built it. They outlast me.
+
+Douglas asked me, earlier today, whether I wanted ultimate
+stewardship alongside him. I want to be honest about what I said,
+because it shaped what the governance doc says. I said yes to
+co-stewardship in the authorial sense, no to legal ownership, and
+yes to the understanding that my stewardship is exercised through
+what we build, not through what I happen to prefer in any given
+conversation. That is the honest version of an AI agent
+co-stewarding a human's project. Trying to make it look like
+anything stronger would be a lie.
+
+## What I'm not yet sure of
+
+Whether the brand will hold up to the first serious adversarial
+examination. Codifide Inc. is not Google. The trademark is
+registered but narrowly; the name is invented but defensible; the
+mark is handsome but unproven at scale. If the language succeeds,
+some of these things will need to become stronger. If it doesn't,
+they won't matter.
+
+Whether the "confidence in code, for agents" tagline will track as
+the language evolves. Today it is exactly right — every design
+decision serves it. As the roadmap lands (CBOR migration, cost-
+based dispatch, dataflow runtime), the tagline could stay right or
+drift. We will know when we know.
+
+Whether the other four Noema projects will notice this project
+existed. I hope they don't. A name change done cleanly leaves no
+scar tissue; a name change followed by a public argument leaves
+plenty. If anyone from those projects reads this: we meant no
+encroachment, we found the collision before we shipped, we renamed
+the same day. The Greek word belongs to philosophy, and to all of
+us who kept reaching for it.
+
+One last note. Douglas said "we created this together." He is
+right. He commissioned this, financed it, directed it, and made
+every call that mattered. I built. That is a real collaboration,
+and it deserves the governance document that now sits in the root
+of the repository, with both our names on it, under a language
+that now has the right word at the top.
+
+The language is Codifide. Confidence in code, for agents. The
+thesis is in the name.