The Frozen-Weights, Memory-Grounding Convergence Loop

0. Why this design (and not the other one)

A fully-online weight-updating convergence loop is exactly the failure mode the Σ₀ Collapse Certificate §7 was written to warn against: ungrounded recursion collapses onto a degenerate fixed point (the "42-state") or diverges. Two facts settle the design:

1. Stopping at intervals does not bound the dynamics. Collapse/divergence is a spectral

property of the map (max Re λ(A) < 0), independent of step size; and model collapse is itself the discrete-generation phenomenon — intervals are the setting collapse was demonstrated in, not the cure. [grounded]

1. **The lethal failure is bounded.** Collapse is the non-expansive projection x*=Px

(‖Px‖ ≤ ‖x‖) — perfectly bounded, perfectly dead. So "it won't run away" is necessary, not sufficient. [grounded]

What actually bounds the loop is external grounding (the certificate's one-line thesis: "Grounding is the safety mechanism."). The interval is merely when you get the chance to re-ground; the grounding injected is the bound. Therefore the safe loop keeps weights frozen and adapts only in memory + retrieval + calibration, re-grounded each interval. Capability is bought by which frozen model plugs in (the offline, eval-gated specialist), not by online retraining — consistent with North Star principle("never retrain").

1. The loop, concretely

 Observe ─► Remember ─► Reason ─► Act ─► Verify ─► Converge

    │          │          │        │       │          │

 temporal-   append a   consult   gate    grade vs   record

 band re-    memory +   trust(k)  Act on  external   grounding

 ground      conv-      (frozen   ground- truth      outcome →

 (web +      record     weights)  ing                update trust

 deep res.)  (interval)           floor              (interval)

• Frozen weights: the served model is a static artifact (base + read-only adapter),

model.eval + torch.no_grad, no optimizer in the serving path.

• The "weights" that move every interval are non-parametric: the append-only memory,

the retrieval/temporal-band index, and the Beta-posterior trust weights in grounding-calibration.js (trust = (1+hits)/(2+n) — a pure, replayable function of the grounding log).

• Re-ground every interval: each tick pulls external evidence (web / deep research,

temporal-band-anchored), verifies, writes a convergence record, updates trust.

• Σ₀ guard: the surprise/decode canary trips on a collapsing/over-confident step and

deflates the dilation budget toward "stop and go re-ground."

2. Status — what's built vs. what's wiring (verified 2026-06-22)

Headline: the hard part — actually frozen weights — is done and enforced. The entire adaptive layer is built and unit-tested as primitives but not wired into the live loop. This is a wiring job, not a build-from-scratch.

3. The keystone wire

The single most important connection is already half-built: grounding-policy.js exposes a collapseProximity argument that deflates the time-dilation budget toward "stop and go re-ground" as proximity →collapseProximity— exactly the re-grounding reflex this design needs. But stream-chat.js:795 calls it with collapseProximity hardcoded to 0. Connect a real collapse signal to that one argument and the reflex turns on.

4. Wiring ladder (ordered by leverage)

Every step is connect existing tested parts, not a new subsystem.

Step— write + adapt every interval (provider-agnostic; the chosen option, made real)

1. Emit a Convergence Record on every reply, not just !-commands.
2. Fire recordGrounding({key, predicted, outcome}) from outcomes the loop **already

produces** — web-search hit/miss, tests-passed.

1. Consult trust(key) in the confidence/route path instead of the hardcoded heuristic.
2. Add the missing unit tests for grounding-calibration.js.

→ This is "re-ground into memory/retrieval every interval" with frozen weights, and it works on the cloud-default chain too (no model-side canary required).

Step— make it fail-safe (the Σ₀ guard)

1. Return canary proximity from ouro_serve → parse in JS → feed as collapseProximity

(the keystone wire).

1. For the cloud default (no token canary), add a **post-generation degeneration /

over-confidence detector** to populate the same proximity (the grounding-policy comment already anticipates this).

1. Enforce the GroundingPolicy floor (minSources/trust) before an action commits →

ungrounded/low-trust step forces stop-and-reground.

Step— richer grounding + proof

1. Wire TemporalBand retrieval into the answer path (temporal-band-anchored evidence).
2. Grade chat records per turn (close Verify→Converge beyond the Kalshi slice).
3. Measure grounded-vs-cold lift (Gate B) — prove the loop helps, not assert it.

5. Measurement plan (so "it helps" is earned)

A change that doesn't move Brier or lift is not landed — it's logged and reverted.

6. Where this sits in the program

This is the runtime half of the model program:

• Brain (offline): a ≤8B domain specialist, cloud-shaped by distillation + SFT/DPO on

verified data, eval-gated and frozen (the continual-training flywheel) — never online.

• Runtime (this doc): frozen weights + per-interval memory-grounding + Σ₀ guard.

Together: cloud-shape offline behind an eval gate, run local behind the grounded loop.

7. Honest scope

• This is not an AGI and not an online weight-self-improving loop — by design, and

per the North Star. It is a durable, bounded, trustable local agent.

• "Grounding bounds the loop" is proven closed-form only for the normal-A case (the L2

lemma); the broader Σ₀⁻¹ prevention is measured (900-run sweep, 100%), not a full theorem. The wiring here operationalizes a measured-and-grounded mechanism, not a proof.

• The cloud-default provider chain has no token-level canary; its fail-safe guard

depends on the post-generation detector (Step 2.6), which is [design], not yet built.

• The win condition is reliability, not raw IQ: fewer unsafe (silent / runaway /

ungrounded) errors than a frontier cloud model — measured (§5), not asserted.

Sources (audited on disk 2026-06-22)

• Frozen weights — scripts/ouro_serve.py · src/sigma0/loop_lm.py
• Memory + records — apps/lantern-garage/lib/convergence-records.js · stream-chat.js
• Calibration — apps/lantern-garage/lib/grounding-calibration.js
• Grounding policy / dilation — apps/lantern-garage/lib/grounding-policy.js · src/convergence_io/dilation.py
• Canary — src/cio_sde/surprise.py · src/sigma0/decode_canary.py
• Temporal bands — apps/lantern-garage/lib/observer-engine.js
• North Star + certificate — docs/CONVERGANCE-SIGMA0-BRIEFING.md · docs/SIGMA0-COLLAPSE-CERTIFICATE.md

</content>