fix(neural): wire LearningScheduler→force_cycle + RBF restore at init (#275)

## Root cause (issue #274, epic #273)

Ground-truth audit found the 8 neural organs were **wired and consumed
but UNFED**: `Hypatia.LearningScheduler` (supervised, 5-min poll)
ingested outcomes but never called
`Hypatia.Neural.Coordinator.force_cycle/0`; `Coordinator.init/1` never
called `Persistence.load_all/0` (zero callers). Networks ran on
init-defaults forever and `pattern_analyzer` defensively ignored their
untrained output — the root cause of the token-cost/scattergun symptom.

## Change

- **`learning_scheduler.ex`** — `run_learning_cycle` now triggers the
Neural Coordinator cycle (N6) *after* ingesting outcomes, so ESN/RBF
train on accumulated trajectories every poll (~5s after boot, then every
5 min). Guarded + non-fatal.
- **`neural/coordinator.ex`** — `init/1` best-effort restores the RBF
network from persisted state (the one cleanly-invertible learned
network; trust rebuilt per cycle, MoE/ESN/LSM train per cycle, ESN/LSM
persistence is summary-only by design). Safe fallback to defaults on any
mismatch — never crashes the supervisor.

## Validation

Training data was already sufficient (`recipe-shell-quote-vars` 166-pt
series ≥60; `registry.json` 9 patterns ≥5) — only the trigger was
missing. Targeted tests green: neural (28), training_pipeline,
cross_repo_learning (11). Compiles cleanly.

## Out of scope / follow-ups

- Pre-existing `--warnings-as-errors` drift (`prover_recommender.ex:123`
unused default arg; `vcl/client.ex:133` ungrouped `handle_call/3`) —
unrelated, not touched.
- Lossless ESN/LSM persistence (currently summary-only, so reservoir not
restored across restarts; retrains on first cycle) — tracked follow-up.

Refs #274

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

lib/learning_scheduler.ex

@@ -117,6 +117,13 @@ defmodule Hypatia.LearningScheduler do
     # echidnabot immediately influence the next prover hint recommendation.
     proof_model_updated = retrain_prover_recommender()
 
+    # N6: Trigger the Neural Coordinator's learning cycle so the organs
+    # (ESN/RBF) actually train on the outcomes just ingested. Without this
+    # the Coordinator's networks run on init-defaults forever and
+    # pattern_analyzer defensively ignores their (untrained) output -- the
+    # root cause of the token-cost/scattergun symptom (issue #274).
+    neural_cycled = trigger_neural_cycle()
+
     now = DateTime.utc_now()
     total = outcomes_count + fleet_outcomes_count
 
@@ -140,6 +147,13 @@ defmodule Hypatia.LearningScheduler do
       Logger.info("LearningScheduler: prover recommender retrained from VeriSimDB proof_attempts")
     end
 
+    if neural_cycled do
+      Logger.info(
+        "LearningScheduler: neural learning cycle triggered " <>
+          "(ESN/RBF train on #{total} new + accumulated outcomes)"
+      )
+    end
+
     %{
       state
       | last_run: now,
@@ -197,6 +211,29 @@ defmodule Hypatia.LearningScheduler do
     end
   end
 
+  # --- N6: Neural Coordinator learning-cycle trigger -------------------
+
+  # Casts :force_cycle to the Neural Coordinator so it trains ESN on the
+  # accumulated confidence trajectories and RBF on the pattern registry,
+  # then persists all neural states. Cast is fire-and-forget (training
+  # runs inside the Coordinator process); we only confirm the process is
+  # alive. Non-fatal: the scheduler must keep running even if the neural
+  # layer is down.
+  defp trigger_neural_cycle do
+    case Process.whereis(Hypatia.Neural.Coordinator) do
+      nil ->
+        false
+
+      _pid ->
+        Hypatia.Neural.Coordinator.force_cycle()
+        true
+    end
+  rescue
+    e ->
+      Logger.warning("LearningScheduler: neural cycle trigger failed: #{inspect(e)}")
+      false
+  end
+
   # --- N4: Strategy-shift detection + re-queueing ----------------------
 
   # Runs StrategyDrift.check_all_shifts/1 on each tick. For each shift

lib/neural/coordinator.ex

@@ -87,22 +87,73 @@ defmodule Hypatia.Neural.Coordinator do
 
   @impl true
   def init(_opts) do
+    persisted = safe_load_persisted()
+    rbf = hydrate_rbf(RadialNeuralNetwork.init(), persisted)
+
     state = %__MODULE__{
       trust_graph: GraphOfTrust.build(),
       moe: MixtureOfExperts.init(),
       lsm: LiquidStateMachine.init(),
       esn: EchoStateNetwork.init(),
-      rbf: RadialNeuralNetwork.init()
+      rbf: rbf
     }
 
     Logger.info(
       "Neural Coordinator initialised: blackboard architecture, " <>
-        "#{@network_count} networks, #{@phase_count} phases"
+        "#{@network_count} networks, #{@phase_count} phases" <>
+        rbf_restore_note(rbf)
     )
 
     {:ok, state}
   end
 
+  # Best-effort load of persisted neural state. Never raises: a missing or
+  # malformed store must not crash the supervisor -- networks fall back to
+  # init-defaults and are retrained by the first LearningScheduler cycle.
+  defp safe_load_persisted do
+    Hypatia.Neural.Persistence.load_all()
+  rescue
+    e ->
+      Logger.warning(
+        "Neural Coordinator: persisted-state load failed (#{inspect(e)}); using defaults"
+      )
+
+      %{}
+  end
+
+  # RBF is the only network restored at init: it is genuinely learned,
+  # plainly serialisable (Persistence.save_rbf/1 is a 1:1 of the struct),
+  # and otherwise unusable until a full training cycle runs. trust is
+  # rebuilt from source every cycle; MoE/ESN/LSM are continuously /
+  # per-cycle trained (ESN/LSM persistence is summary-only by design).
+  defp hydrate_rbf(default_rbf, %{rbf: {:ok, data}}) when is_map(data) do
+    centers = Map.get(data, "centers", [])
+    weights = Map.get(data, "output_weights", [])
+
+    if data["trained"] == true and is_list(centers) and centers != [] and
+         is_list(weights) and weights != [] do
+      %{
+        default_rbf
+        | centers: centers,
+          widths: Map.get(data, "widths", []),
+          output_weights: weights,
+          num_inputs: Map.get(data, "num_inputs", default_rbf.num_inputs),
+          num_centers: Map.get(data, "num_centers", default_rbf.num_centers),
+          trained: true,
+          training_stats: Map.get(data, "training_stats", %{})
+      }
+    else
+      default_rbf
+    end
+  rescue
+    _ -> default_rbf
+  end
+
+  defp hydrate_rbf(default_rbf, _), do: default_rbf
+
+  defp rbf_restore_note(%{trained: true}), do: " (RBF restored from persisted state)"
+  defp rbf_restore_note(_), do: " (RBF cold; trains on first learning cycle)"
+
   # ── Public API ──────────────────────────────────────────
 
   @doc """