[NOTICKET] fix(knowledge-domain): a domain entry was being read as a document brief

Found by Rifqi asking the obvious question of the fresh run: the entries are
`document: 1, glossary: 66, rule: 16, formula: 5` - where is the domain?

The answer is that nothing writes one yet, and that is correct: the SCOPE-level
DomainContext is composed at read time, not stored, because a persisted derived
view drifts from what it was derived from - the same reason the review queue is
not stored. What IS missing is the DECLARED half (identity, boundary,
conventions, entities, dimensions), which is expert-authored and therefore must
be an entry to be reviewable, since knowledge_reviews keys on entity_id. That is
what `kind='domain'` is reserved for, and V4-9/V4-10 have not been built.

THE BUG the question surfaced: `compose.py` read `kind='domain'` rows and
treated them as document briefs. That line was transitional, written to handle
v3 rows before the V4-4 split, and after the split it is wrong - the first
declared domain entry ever written would have been silently folded into
`authority.sources[]` as if it were a file, taking its subdomains and title with
it. Briefs are now read as `kind='document'` only.

The declared seam is wired at the same time rather than left for later, because
a reserved kind nothing reads is how the same confusion comes back: a `domain`
entry, once approved, now supplies domain_name, boundary and conventions, and
sets `coverage.declared`. Declared subdomains beat the tags rolled up from
briefs - an expert saying what the domain covers beats an aggregate of per-term
guesses. Nothing writes one yet, so this is normally inert.

The TBox goes through the same review gate as everything else: an unapproved
declaration is ignored in strict mode.

A test caught the semantic change, which is what tests are for: the fixture
still used kind="domain" for a brief and started failing the moment the two
kinds stopped meaning the same thing. Updated, plus 3 new tests - a domain entry
is not a source, the declared half is applied when present, and an unapproved
declaration is ignored.

Live re-check after the fix: 5 measures, sources ['144bb3e9'] (the PDF only),
declared=False, subdomains still rolled up from the brief.

Verification: ruff clean; `import main` OK; suite 638 passed / 7 skipped
(635 + 3).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/knowledge_domain/compose.py

@@ -93,14 +93,23 @@ class DomainComposer:
         rules = await self._store.list_entries(
             scope_id=scope_id, kind="rule", limit=1000
         )
-        # v3 still writes the per-document brief under kind="domain"; v4 splits
-        # it to kind="document" (V4-4). Read both so composition works either
-        # side of that change.
+        # The per-document brief. Since the V4-4 split this is kind="document";
+        # kind="domain" now means something else entirely and must NOT be read
+        # here. Reading both was a transitional line from before the split, and
+        # leaving it would have made the first declared domain entry ever
+        # written get folded into `authority.sources[]` as if it were a file.
         briefs = await self._store.list_entries(
-            scope_id=scope_id, kind="domain", limit=200
-        ) + await self._store.list_entries(
             scope_id=scope_id, kind="document", limit=200
         )
+        # The DECLARED half - identity, boundary, conventions, entities,
+        # dimensions. Expert-authored (the model proposes, the expert approves),
+        # so it must be an entry to be reviewable: `knowledge_reviews` keys on
+        # `entity_id`. Nothing writes one yet (V4-9/V4-10), so this is normally
+        # empty - but the seam is here so that when one lands it is applied
+        # instead of silently ignored.
+        declared_rows = await self._store.list_entries(
+            scope_id=scope_id, kind="domain", limit=5
+        )
 
         reviews = await self._store.latest_reviews(scope_id)
         approved_ids = {
@@ -258,14 +267,40 @@ class DomainComposer:
                 )
             )
 
-        total = len(glossary) + len(formulas) + len(rules) + len(briefs)
+        # Apply the declared half when an expert has ruled on one.
+        declared = next(
+            (_payload(r) for r in declared_rows if include_unapproved
+             or r.entity_id in approved_ids),
+            None,
+        )
+        identity = Identity(subdomains=subdomains)
+        conventions = Conventions(units=units)
+        if declared:
+            identity = Identity(
+                domain_name=declared.get("domain_name"),
+                # Declared subdomains win over the tags rolled up from briefs:
+                # an expert saying what the domain covers beats an aggregate of
+                # per-term guesses.
+                subdomains=list(declared.get("subdomains") or subdomains),
+                boundary=declared.get("boundary"),
+            )
+            conv = declared.get("conventions") or {}
+            conventions = Conventions(
+                time_grain=conv.get("time_grain"),
+                calendar=conv.get("calendar"),
+                units=units or [Unit(**u) for u in (conv.get("units") or [])],
+            )
+
+        total = len(glossary) + len(formulas) + len(rules) + len(briefs) + len(
+            declared_rows
+        )
         context = DomainContext(
             scope_id=scope_id,
-            # Derived only. `domain_name` and `boundary` are declared and stay
-            # empty until an expert rules on them.
-            identity=Identity(subdomains=subdomains),
+            # Derived, overlaid with the declared half when an expert has
+            # approved one. `domain_name` and `boundary` stay empty until then.
+            identity=identity,
             measures=measures,
-            conventions=Conventions(units=units),
+            conventions=conventions,
             policies=policies,
             authority=Authority(
                 sources=sources,
@@ -279,7 +314,7 @@ class DomainComposer:
                     approved_ratio=(
                         (len(approved_ids) / total) if (total and reviews) else None
                     ),
-                    declared=False,
+                    declared=declared is not None,
                 ),
             ),
         )