Merge origin/main; flip the #6562 tripwire (#6810)

#6562 (PR #6811) landed while this branch was in flight and factored the tenant
column into `TENANT_SCOPE_FIELD_DEF`. Conflict resolved onto that shared table:
the definition is now spread VERBATIM, with the `indexed` key gone and the
tenant index declared in `indexes[]`.

`protocol-meta-effective-schema.test.ts` carries the three-line tripwire #6562
pinned in both directions so this fix could not be forgotten. All three flip to
the post-fix truth, annotated with #6810 and with the old expectation quoted in
place so the reversal reads as a record, not a rewrite:

  divergences(...)            ['organization_id.indexed'] → []
  registryBacked._diagnostics valid: false                → { valid: true }
  organization_id.indexed     === multiTenant             → undefined, read
                                                            off `indexes[]`

One residual is recorded rather than left to be rediscovered: the DECLARATION
does not converge the way the field set does — the overlay-backed answer is
rebuilt from the stored body, which declares no indexes. Inert on that surface
(drivers materialize from the REGISTERED schema, never a served document) and
both answers parse green either way.

`metadata-core`'s `injected-system-columns.ts` header described the stamped key
as live; corrected to describe it as closed.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JE8Bbwb8qhau3yNtP3ftLJ

Author: claude

.changeset/meta-object-read-effective-schema.md

@@ -0,0 +1,67 @@
+---
+"@objectstack/metadata-core": minor
+"@objectstack/metadata-protocol": minor
+"@objectstack/objectql": patch
+---
+
+fix(metadata-protocol): a `/meta` object read serves the effective runtime schema, whichever layer answered (#6562)
+
+`GET /api/v1/meta/object/:name` answered a **different set of fields** depending
+on which link of its resolution chain produced the answer, for the same object:
+
+- **registry-backed** → the schema AFTER `applySystemFields`, so it carried the
+  injected system columns — `created_at`, `created_by`, `updated_at`,
+  `updated_by`, `organization_id`, `owner_id`, `owning_business_unit_id` — even
+  when the author declared none of them;
+- **overlay-backed** (a `sys_metadata` customization row, or a MetadataService
+  body) → the stored document VERBATIM, so every one of those columns was simply
+  absent.
+
+Whether an object carries an overlay is invisible to the caller, so the same
+request reported the platform's own columns or not, and nothing in the response
+said which had happened. `/meta` is the machine-readable contract clients and AI
+authors code against: an author reading an overlay-backed object saw no
+`created_at` / `owner_id` / `organization_id` and reasonably concluded the
+columns do not exist — while every one of them is real in the database,
+filterable, orderable, and enforced read-only on write.
+
+**Every `/meta` object read exit now serves the effective schema.** The
+single-item read, the list, the cached/ETag branch, both draft reads and the
+layered read's `effective` layer all report the injected columns, with the same
+`readonly` / `system` markers the engine enforces (`owner_id` stays
+`readonly: false` — ownership is transferable). This is the presence half of the
+seam #4513 closed the value half of.
+
+Three things deliberately did **not** change:
+
+- **`?layers=1`'s `overlay` layer stays byte-verbatim.** Injection happens at the
+  read exits only, so Studio's "what you customised" diff never shows a column
+  nobody wrote. Only `effective` is injected.
+- **A `GET` → `PUT` round-trip still persists a byte-identical body** (#4326).
+  The write path gained the strip counterpart: a field byte-identical to the
+  platform's own definition is removed again on save, so a served document handed
+  straight back stores exactly what it stored before — same checksum, same
+  history diff. A declared `owner_id` carrying the author's own label is *not*
+  the platform's definition and survives untouched.
+- **A declared system column stays the author's.** Injection only ever adds a
+  column nobody declared; it never rewrites one that was.
+
+Which columns an object carries is `resolveInjectedSystemColumns`
+(`@objectstack/spec/data`, #5378) — the same derivation `applySystemFields`
+consumes — so every opt-out (`systemFields: false`, `managedBy: 'better-auth'`,
+`systemFields.audit`/`.tenant`, `tenancy.enabled: false`, the per-tier
+`ownership` table, the `sys_*` namespace) is answered in one place and re-derived
+in none. **What** each column looks like moves to `@objectstack/metadata-core`
+(`AUDIT_FIELD_DEFS` and the three tenancy/ownership anchors, re-exported from
+`@objectstack/objectql` so the symbols still resolve there) — the same relocation,
+for the same dependency cycle, as the audit-governance table in #4513:
+`@objectstack/objectql` depends on `@objectstack/metadata-protocol`, so the read
+path could not import the definitions from the registry that provisions them.
+One table now feeds the injection pass and the read exits, so they cannot drift.
+
+One key is deliberately not carried onto a served document: `organization_id`'s
+`indexed`. It is not a `FieldSchema` key — removed in the 16.x line (#2377,
+ADR-0049) and rejected by name by the strict schema — and its only consumer is
+`driver-mongodb`'s schema builder, which reads the registered schema and never a
+served document. It stays at the injection site; that the registry-backed read
+answers `_diagnostics: { valid: false }` because of it is filed as #6810.

packages/metadata-core/src/index.ts

@@ -36,6 +36,15 @@ export * from './engine-update-dispatch.js';
 // reporting two.
 export * from './audit-field-governance.js';
 
+// [#6562] The injected-system-column DEFINITION table and the served-document
+// injection/strip pair built on it, sunk here by the same criterion and for the
+// same cycle as the governance table above. `resolveInjectedSystemColumns`
+// (spec, #5378) says WHICH columns an object carries; this says WHAT each one
+// looks like — the half that used to exist only inside `applySystemFields`, one
+// import away from every `/meta` read exit and unreachable from all of them.
+// `@objectstack/objectql` now reads this table instead of its own literals.
+export * from './injected-system-columns.js';
+
 // [ADR-0106 / #3682] The metadata-plane FLS projection — one masking function
 // and one fingerprint, shared by every object-schema exit in
 // `@objectstack/rest` and `@objectstack/runtime`. Sunk here by the same