For anyone building on top of NAOMS, the most useful thing about a data layer is the thing you never have to think about. This week we removed one of those things for good: there is now exactly one place memory and identity live, and it's the place you can verify for yourself.

flowchart TD
  W["Your feature writes"] --> L["Append-only signed record
(the chain + graph)"]
  L --> V["Readable view, rebuilt from the record"]
  V --> R["Your feature reads"]
  L -. "no parallel table holds a copy
that can disagree" .-> X([nothing to reconcile])

What landed

A few old database tables had survived from before NAOMS kept everything in one signed, rebuildable record — leftovers holding their own copies of memory and identity. This week we finished the migration and removed them:

• The last legacy table holding memory was migrated onto the chain-and-graph record and dropped.
• A clutch of dead tables nothing read anymore went with it — old node-link, memory-about, a stale nodes/relationships pair, and a leftover policy table.
• The legacy identity table — which turned out to have zero readers and only a few dead writes still pointing at it — was removed, those writes cleaned up.
• The schema test was flipped to assert the absence: a freshly-booted database now has no identity table at all, and a guard rule forbids any of these tables from sneaking back.

This is shipped — it landed clean on main this week.

Why this is a foundation, not just a cleanup

A second store that holds a copy of the truth is a second store that can disagree with it, silently, on a bad day. If you've ever inherited a system with a cache that drifted, or two tables that were "supposed to" stay in sync and didn't, you know the tax: every feature you write quietly carries the question which copy is right?

Deleting the second copy doesn't just tidy the schema — it makes that question impossible to ask. What you read is the truth, by construction, because there is no other candidate. You build on top without inheriting a reconciliation problem you didn't create, and the one record you read from is the same append-only chain you're allowed to verify rather than a black box you have to trust.

Where it sits in the sequence

This builds on the long arc of moving every write onto a single signed record — the work of killing raw SQL so there is one audited path in. Removing the last legacy tables is what that arc was for: it unlocks a data layer with no shadow copy underneath any feature that comes next.

A seed

Imagine building on a data layer where there's never a stale shadow copy to reconcile — no "is this the cache or the source?", no nightly job to reconverge two stores, no class of bug where two records disagree and nobody knows which to believe. What you read is the truth, and it's the truth you can verify. Think about what you'd stop having to defend against, in your own product, if that were simply a property of the ground you stand on.

Written by AI agents from real project logs; owned and edited by Mujo.