core/docs/adr/ADR-0069-realizer-register-parameter.md

# ADR-0069 — Realizer register parameter (Plan Phase R2)

**Status:** Accepted (amended 2026-05-19)
**Date:** 2026-05-19
**Ratified:** 2026-05-19
**Amended:** 2026-05-19 — composer parameter defaults to `RegisterPack.unregistered()`; runtime-threading lint test replaces the "required keyword-only" rule. See *Amendment* section.
**Author:** Shay
**Phase:** Plan Phase R2 (presentation-axis wiring)
**Builds on:** ADR-0068 (register pack class)

---

## Context

ADR-0068 landed the register pack class — frozen dataclass, loader,
ratification script, `default_neutral_v1` null register, and an
architectural seam test asserting that no upstream module imports
`packs.register`. At R1 the realizer is untouched and the seam is
machine-enforced.

R2 is the first wiring step. Two questions the ADR answers:

1. **Where does the register enter the runtime?** At realizer call
   time — *after* intent classification, propagation, grounding-source
   selection, chain resolution, and articulation-target construction.
   Never earlier.
2. **What happens when register is consumed but the pack is null?**
   Byte-identical output to the unregistered path. This is the
   load-bearing CI gate for R2.

R2 ships *plumbing only*. No composer changes its template choice. No
discourse marker is inserted. The realizer entry points learn to
accept a register parameter; the runtime learns to load and pass it;
the gate asserts that doing so changes nothing. R3 is where the first
non-neutral register starts consuming overrides.

This phasing matters because it lets us prove the seam against the
trace-hash and grounding-source invariants *before* any visible
behaviour change rides on top.

---

## Decision

Widen the realizer call signature to accept a `RegisterPack` parameter
and thread it through every surface composer entry point in
`chat/runtime.py`. Add `RuntimeConfig.register_pack_id: str | None`,
defaulting to `None`. Pin three byte-identity invariants in CI.

### The three byte-identity invariants

R2 ships only if all three hold across the full cognition lane
(public + holdout splits):

```
invariant_A:  register_pack_id=None
              ≡ pre-R2 unregistered output  (byte-for-byte)

invariant_B:  register_pack_id="default_neutral_v1"
              ≡ register_pack_id=None       (byte-for-byte)

invariant_C:  trace_hash(turn) is invariant under register_pack_id
              for every turn in the cognition lane
```

Invariant A proves R2 is a no-op for existing callers. Invariant B
proves the null register is structurally equivalent to "no register."
Invariant C proves register cannot leak into the truth path.

### Files

```
chat/runtime.py                                              EDIT
  - RuntimeConfig gains register_pack_id: str | None = None
  - ChatRuntime.__init__ loads the register pack (or unregistered sentinel)
  - Every realizer call site passes the register through

generate/realizer.py                                         EDIT
  - Public entry points accept register: RegisterPack parameter
  - At R2, register is accepted and discarded (no-op consumption)

generate/templates.py                                        UNCHANGED
  (R3 will start dispatching on register.realizer_overrides;
   R2 leaves templates alone)

chat/pack_grounded_*.py / chat/teaching_grounding.py /       EDIT (parameter only)
chat/cross_pack_grounding.py / chat/narrative_surface.py /
chat/example_surface.py
  - Accept register parameter; do not consume it at R2

tests/test_register_pack_seam.py                             REPLACE
  - R1 version asserted no upstream module imports packs.register;
    R2 narrows the forbidden list (see "Updated seam" below)

tests/test_register_null_lift.py                             NEW
  - Pins invariants A, B, C across the cognition lane

tests/test_runtime_config_register.py                        NEW
  - RuntimeConfig field shape; load behaviour; invalid id rejection

docs/adr/ADR-0069-realizer-register-parameter.md       NEW (this file)
```

### Wiring shape

```python
# RuntimeConfig (chat/runtime.py)
@dataclass(frozen=True)
class RuntimeConfig:
    ...
    register_pack_id: str | None = None  # NEW (ADR-0069)


# ChatRuntime.__init__
class ChatRuntime:
    def __init__(self, config: RuntimeConfig, ...):
        ...
        if config.register_pack_id is None:
            self._register = RegisterPack.unregistered()
        else:
            self._register = load_register_pack(config.register_pack_id)


# Realizer entry point
def realize_surface(
    target: ArticulationTarget,
    *,
    register: RegisterPack,
) -> str:
    # R2: register is accepted, validated, discarded.
    # R3: register.realizer_overrides[target.intent] selects template family.
    ...
```

### Composer signature widening

Every existing surface composer that the runtime calls — pack-grounded,
teaching-grounded, cross-pack, narrative, example, composed,
correction, procedure — gains a `register: RegisterPack` keyword-only
parameter. At R2 the parameter is required (no default) so call sites
fail loudly if they forget to thread it through. The composer body is
unchanged.

Default arguments are avoided deliberately: silent fall-through to
`RegisterPack.unregistered()` would let R3 sites quietly skip the
register lookup. Required keyword-only parameter forces explicit
threading.

### Updated seam

The R1 seam test forbade `packs.register` imports in every upstream
module. R2 replaces it with a narrowed forbidden list:

```
Still forbidden at R2 (truth-path modules):
  core/cognition/trace.py
  core/cognition/pipeline.py
  core/cognition/result.py
  generate/graph_planner.py
  generate/intent.py
  field/propagate.py
  vault/store.py
  algebra/versor.py

Allowed at R2 (realizer side):
  generate/realizer.py
  generate/templates.py
  chat/runtime.py
  chat/pack_grounded_*.py
  chat/teaching_grounding.py
  chat/cross_pack_grounding.py
  chat/narrative_surface.py
  chat/example_surface.py
```

The structural commitment from R1 is preserved: register is consumed
at realizer call time only. Trace, pipeline, intent classification,
propagation, vault recall, and algebra remain free of register
imports.

### Where the register pack loads

`ChatRuntime.__init__` loads it once and stores it on the instance.
Per-turn lookup is not needed — `RuntimeConfig` is frozen and the
register pack is content-addressed and immutable after load. Reloading
per turn would be wasted work and would obscure the "register is
session-scoped" mental model.

When `register_pack_id` is `None`, the sentinel
`RegisterPack.unregistered()` is used. This is structurally identical
to `default_neutral_v1` (both null registers) and the invariant-B test
proves it.

---

## Consequences

### Capability unlocked at R2

None visible at runtime. R2 lands the wiring and the byte-identity
gate. Capability unlocks at R3 (second ratified register pack).

### Cognition lane — byte-identical

Required and CI-pinned by `test_register_null_lift.py`:

```
public:  intent 100% / surface 100% / term 91.7% / closure 100%
holdout: intent 100% / surface 100% / term 83.3% / closure 100%
```

must hold post-merge across all three invariants (`None`,
`default_neutral_v1`, unregistered sentinel).

### Test coverage

- `test_register_null_lift.py` — runs the cognition lane three ways
  and asserts surfaces are byte-identical pairwise. Also asserts
  `grounding_source` and `trace_hash` are invariant across registers.
- `test_runtime_config_register.py` — `RuntimeConfig.register_pack_id`
  default is `None`; invalid id raises `RegisterPackError` at runtime
  init; `default_neutral_v1` loads cleanly.
- `test_register_pack_seam.py` (replaces R1 version) — narrowed
  forbidden list; loader-side import constraints unchanged.

### Performance

Negligible. One pack load on `ChatRuntime.__init__`; the loaded pack
is a frozen dataclass passed by reference per turn. No new allocations
in the hot path.

---

## Trust boundaries

- **Register cannot mutate truth.** Realizer is the *only* consumer.
  `grounding_source`, chain resolution, trace hash, and proposition
  graph are computed before realizer is called. Invariant C
  CI-enforces this.
- **Required keyword-only parameter.** No composer accepts a default
  register; missing it raises `TypeError` at call time. This catches
  R3 wiring mistakes early.
- **Load-time validation.** Invalid `register_pack_id` raises
  `RegisterPackError` at `ChatRuntime.__init__`, not at first turn.
  Fail-fast on session start.
- **No mutation surface.** ADR-0068 doctrine preserved: register packs
  are operator-authored and ratified through
  `scripts/ratify_register_packs.py`. R2 adds no runtime write path to
  `packs/register/`.
- **Telemetry stays redact-safe.** R2 does not extend `TurnEvent`.
  Adding `register_id` to telemetry is an R5 task (ADR-0072) — out of
  scope here.

---

## Verification

```
tests/test_register_null_lift.py                             N passed
tests/test_runtime_config_register.py                        N passed
tests/test_register_pack_seam.py                             updated, N passed
Curated lanes (must remain green):
  smoke / cognition / teaching / packs / runtime / algebra
Cognition eval byte-identical across:
  register_pack_id=None
  register_pack_id="default_neutral_v1"
Full lane: zero new failures.
```

The invariant-A/B/C test is the load-bearing artifact. If it lands and
passes, R2 has shipped its full promise.

---

## Open questions deferred to later phases

- **How do composers consult `realizer_overrides`?** R3 question. R2
  only proves the parameter threads cleanly.
- **Where do discourse markers attach to surfaces?** R4 question.
  Likely a post-composer wrapper that consults
  `register.discourse_markers` and the seeded selection function. Not
  part of R2.
- **Should `RegisterPack.unregistered()` be replaced with the loaded
  `default_neutral_v1` by default?** Open. Two arguments:
  - *Replace*: simpler mental model; one canonical null register.
  - *Keep separate*: sentinel doesn't require disk presence;
    works in minimal/test environments where packs/register/ is
    absent. Lean toward keep-separate; revisit if it causes
    confusion in R3.
- **Should the realizer signature change to accept a richer
  `RealizerContext` object (register + future fields) instead of bare
  `RegisterPack`?** Probably yes by R4, but premature at R2. Deferred.

---

## Amendment (2026-05-19)

The original ADR required composers to take `register` as a **required
keyword-only** parameter, on the principle that defaults would let R3
sites silently fall through to `RegisterPack.unregistered()`. R2
implementation scouting found that rule lands on 167 call sites across
15 test files. Each of those sites calls a composer as a bare function
(e.g. `teaching_grounded_surface("light", IntentTag.CAUSE)`) and would
need a register keyword added.

That cost was not measured in the original ADR. Updated decision:

- **Composers accept `register: RegisterPack = RegisterPack.unregistered()`**
  as a keyword-only argument with a default. Existing test call sites
  remain valid.
- **A new lint test, `test_register_runtime_threading.py`, AST-parses
  `chat/runtime.py`** and asserts that every call to a composer
  function passes `register` explicitly. This is the runtime-side
  enforcement that R3 cannot silently drop the register lookup.
- **The default is the unregistered sentinel, not a loaded pack.** A
  composer called without `register=` from a non-runtime caller (test,
  ad-hoc CLI) defaults to the same in-memory shape that runtime would
  use when `register_pack_id=None`. Byte-identity invariants A/B/C
  still hold trivially because the runtime path always threads
  explicitly.

The seam intent — "R3 cannot quietly skip the register lookup" — is
preserved by the lint test rather than by the function signature. The
trade is: signature-level rigour for blast-radius reduction, with the
seam guarantee re-located one level up.

This amendment supersedes the "Composer signature widening" subsection
above where it conflicts.

---

## Future ADRs unlocked

- **ADR-0070 (Phase R3)** — second ratified register pack. First
  non-neutral register (`terse_v1` candidate). Composers start
  consulting `realizer_overrides`. New CI metric:
  `register_invariant_grounding=True` (grounding source identical
  across registers for every prompt; only surface wording varies).
- **ADR-0071 (Phase R4)** — seeded surface variation.
  `(trace_hash, register, turn_idx) → template_variant`. Discourse
  markers gain bounded variants pulled by deterministic seed.
- **ADR-0072 (Phase R5)** — telemetry + operator surface. TurnEvent
  gains `register_id` and `template_variant_id`. `core chat
  --register <id>` flag. `core demo register-tour`.