sync(neuro_foundation): v0.4.2 hibernation fix from canonical NeuroGraph

Synced from greatnorthernfishguy-hub/NeuroGraph commit f6c576f.
Serializes delay_buffer, recent_spikes, steps_since_last_fire, and
homeostatic_steps_since_scaling so Codemine workers load warm state
rather than cold-starting on every subprocess boundary.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

neuro_foundation.py

@@ -19,6 +19,23 @@ Design principles (PRD §2.1):
     - Persistence-native: all state is serializable
 
 # ---- Changelog ----
+# [2026-04-14] Claude (Sonnet 4.6) — v0.4.2 Hibernation fix: serialize ephemeral process state
+# What: Added 4 previously unserialised fields to _serialize_full()/_deserialize():
+#   _delay_buffer (in-flight spike currents), _recent_spikes (structural plasticity
+#   co-activation history), _steps_since_last_fire (zero-firing circuit breaker),
+#   HomeostaticRule._steps_since_scaling (homeostatic scaling counter).
+#   Version bumped 0.4.1 → 0.4.2.
+# Why: Every ephemeral subprocess (CC hook, Codemine worker) loads the checkpoint
+#   cold — these fields reset to 0. With scaling_interval=25 and a single step() per
+#   call, homeostatic scaling never fired. Silent nodes never got their excitability
+#   boost. In-flight spikes were dropped. Structural plasticity lost co-activation
+#   context between calls. The substrate was effectively starting fresh each call.
+#   This is the canonical "hibernation" fix: the process believes it never stopped.
+# How: _serialize_full() adds delay_buffer (timestep→entries), recent_spikes
+#   (nid→list), steps_since_last_fire (int), homeostatic_steps_since_scaling (int).
+#   _deserialize() restores all four. Delay buffer validates delivery timestep > current
+#   and node existence. Homeostatic counter applied post plasticity-rules re-init.
+#   Migration v0.4.1→v0.4.2 is a no-op (old checkpoints get defaults on next save).
 # [2026-03-25] Claude Code (Opus 4.6) — Dynamic tuning API (SVG Phase 5)
 #   What: Added TUNABLE_PARAMS, update_tunable(), get_tunables() to Graph class.
 #     12 SNN parameters tunable at runtime with validated bounds: learning_rate,
@@ -3632,7 +3649,7 @@ class Graph:
 
     def _serialize_full(self) -> Dict[str, Any]:
         return {
-            "version": "0.4.1",
+            "version": "0.4.2",
             "timestep": self.timestep,
             "config": self.config,
             "nodes": {nid: self._serialize_node(n) for nid, n in self.nodes.items()},
@@ -3703,6 +3720,26 @@ class Graph:
             # Phase 2.5b: Output target learning state
             "he_last_fired_step":  self._he_last_fired_step,
             "he_output_candidates": self._he_output_candidates,
+            # v0.4.2 Hibernation state — ephemeral process counters serialized so
+            # subprocess loads (CC hook, Codemine worker) believe the process never
+            # stopped. Without these, homeostatic scaling never fires, in-flight spikes
+            # are dropped, structural plasticity loses co-activation context, and the
+            # zero-firing circuit breaker loses streak continuity across calls.
+            "delay_buffer": {
+                str(ts): [[nid, curr] for nid, curr in entries]
+                for ts, entries in self._delay_buffer.items()
+            },
+            "recent_spikes": {
+                nid: list(spikes)
+                for nid, spikes in self._recent_spikes.items()
+                if spikes
+            },
+            "steps_since_last_fire": self._steps_since_last_fire,
+            "homeostatic_steps_since_scaling": next(
+                (r._steps_since_scaling for r in self._plasticity_rules
+                 if isinstance(r, HomeostaticRule)),
+                0,
+            ),
         }
 
     def _serialize_incremental(self) -> Dict[str, Any]:
@@ -3829,6 +3866,25 @@ class Graph:
             self._node_hyperedges[nid] = set()
             self._recent_spikes[nid] = deque(maxlen=20)
 
+        # v0.4.2: Restore recent spike history (structural plasticity co-activation)
+        cap = self.config.get("co_activation_window", 5) * 2
+        for nid, spike_list in data.get("recent_spikes", {}).items():
+            if nid in self._recent_spikes and spike_list:
+                self._recent_spikes[nid] = deque(spike_list, maxlen=cap)
+
+        # v0.4.2: Restore in-flight spike buffer (currents scheduled for future delivery)
+        # Keys may be int (msgpack) or str (JSON) — normalise to int.
+        # Drop entries with delivery timestep <= current timestep (already processed).
+        node_ids_set = set(self.nodes.keys())
+        for ts_key, entries in data.get("delay_buffer", {}).items():
+            ts = int(ts_key)
+            if ts <= self.timestep:
+                continue  # stale — would have fired before save
+            valid = [(str(nid), float(curr)) for nid, curr in entries
+                     if str(nid) in node_ids_set]
+            if valid:
+                self._delay_buffer[ts] = valid
+
         # Restore synapses
         for sid, sd in data.get("synapses", {}).items():
             syn = Synapse(
@@ -4075,6 +4131,21 @@ class Graph:
             ),
         ]
 
+        # v0.4.2: Restore zero-firing circuit breaker streak count.
+        # Without this a subprocess always starts at 0, losing continuity
+        # and potentially masking persistent silence across calls.
+        self._steps_since_last_fire = data.get("steps_since_last_fire", 0)
+
+        # v0.4.2: Restore homeostatic scaling counter.
+        # HomeostaticRule.__init__ always sets _steps_since_scaling = 0 above.
+        # Restore the saved value so homeostatic scaling fires at the correct
+        # interval regardless of how many subprocess boundaries have been crossed.
+        homeostatic_steps = data.get("homeostatic_steps_since_scaling", 0)
+        for rule in self._plasticity_rules:
+            if isinstance(rule, HomeostaticRule):
+                rule._steps_since_scaling = homeostatic_steps
+                break
+
         self._dirty_nodes.clear()
         self._dirty_synapses.clear()
         self._dirty_hyperedges.clear()

neurograph_migrate.py

@@ -29,6 +29,9 @@ Schema Version History:
              version bump for tracking)
     0.4.1  — Phase 4.1: Consolidation Lifecycle (ConsolidationState enum,
              synapse salience, hyperedge creation_time, consolidation config)
+    0.4.2  — Hibernation fix: delay_buffer, recent_spikes, steps_since_last_fire,
+             homeostatic_steps_since_scaling serialized (no-op migration — new
+             fields are optional in _deserialize, defaults applied if absent)
 
 Grok Review Changelog (v0.7.1):
     No code changes.  Grok's suggestions for neurograph_migrate.py evaluated:
@@ -64,10 +67,10 @@ except ImportError:
 
 
 # Ordered list of all schema versions
-SCHEMA_VERSIONS = ["0.1.0", "0.2.0", "0.2.5", "0.3.0", "0.3.5", "0.4.0", "0.4.1"]
+SCHEMA_VERSIONS = ["0.1.0", "0.2.0", "0.2.5", "0.3.0", "0.3.5", "0.4.0", "0.4.1", "0.4.2"]
 
 # Current target version
-CURRENT_VERSION = "0.4.1"
+CURRENT_VERSION = "0.4.2"
 
 
 def _version_tuple(v: str) -> Tuple[int, ...]:
@@ -242,6 +245,25 @@ def _migrate_0_4_0_to_0_4_1(data: Dict[str, Any]) -> Dict[str, Any]:
     return data
 
 
+def _migrate_0_4_1_to_0_4_2(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Phase 4.1 → 4.2: Hibernation fix — no-op schema migration.
+
+    The four new fields (delay_buffer, recent_spikes, steps_since_last_fire,
+    homeostatic_steps_since_scaling) are optional in _deserialize() and
+    default to zero/empty when absent. There is no data to backfill — old
+    checkpoints simply won't have in-flight state to restore, which is
+    correct: the buffer was empty at save time in the old code. The version
+    bump ensures that once a checkpoint is saved by v0.4.2 code it carries
+    the hibernation fields and won't be needlessly migrated again.
+    """
+    data.setdefault("delay_buffer", {})
+    data.setdefault("recent_spikes", {})
+    data.setdefault("steps_since_last_fire", 0)
+    data.setdefault("homeostatic_steps_since_scaling", 0)
+    data["version"] = "0.4.2"
+    return data
+
+
 # Migration registry: (from_version, to_version) → migration function
 MIGRATIONS: List[Tuple[str, str, Callable]] = [
     ("0.1.0", "0.2.0", _migrate_0_1_0_to_0_2_0),
@@ -250,6 +272,7 @@ MIGRATIONS: List[Tuple[str, str, Callable]] = [
     ("0.3.0", "0.3.5", _migrate_0_3_0_to_0_3_5),
     ("0.3.5", "0.4.0", _migrate_0_3_5_to_0_4_0),
     ("0.4.0", "0.4.1", _migrate_0_4_0_to_0_4_1),
+    ("0.4.1", "0.4.2", _migrate_0_4_1_to_0_4_2),
 ]