Sync from GitHub: 59e52c5e18b5b42c5eed45ee4a7e6f0f76d5fb3f

app.py

@@ -192,6 +192,92 @@ from nuwave.lenia_splat import LeniaSplatEngine, LeniaSplatConfig
 _persist_dir = "/data/nuwave_substrate" if os.path.isdir("/data") else "/tmp/nuwave_substrate"
 organism = NuWaveOrganism(state_path=_persist_dir)
 
+
+def _bootstrap_pinned_clean_slate():
+    """One-time: capture an empty-substrate snapshot to `pinned/clean-slate/` in
+    the HF dataset for easy fresh-start recovery (no benchmark run required).
+
+    Self-no-ops on subsequent boots once `pinned/clean-slate/` exists.
+    Spawns a temporary NuWaveOrganism with NUWAVE_FRESH_START=1 in a temp dir;
+    suppresses hub push by nilling the temp org's _hf_token; uploads the
+    resulting empty-state files directly to `pinned/clean-slate/`. The main
+    `organism` (already initialized above from live root state) is untouched.
+
+    Recovery use: download from `pinned/clean-slate/` in the HF dataset UI,
+    upload to root — substrate resets to empty without firing a FRESH_START
+    benchmark. Folder is OUTSIDE `backups/`, so rotation never touches it.
+    """
+    import tempfile
+    import shutil
+    try:
+        from huggingface_hub import HfApi
+        hf_token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN")
+        if not hf_token:
+            return  # no auth, skip silently
+
+        repo_id = NuWaveOrganism.HUB_REPO
+        api = HfApi()
+
+        # No-op if already pinned
+        try:
+            files = api.list_repo_files(
+                repo_id=repo_id, repo_type="dataset", token=hf_token,
+            )
+            if any(f.startswith("pinned/clean-slate/") for f in files):
+                return
+        except Exception:
+            return  # repo not reachable, defer to next boot
+
+        # Build empty-state files in a throwaway temp dir
+        tmp_dir = tempfile.mkdtemp(prefix="nuwave_clean_slate_")
+        prior_fresh = os.environ.get("NUWAVE_FRESH_START")
+        os.environ["NUWAVE_FRESH_START"] = "1"
+        try:
+            empty_org = NuWaveOrganism(state_path=tmp_dir)
+            # Suppress hub push during the save so live root is untouched
+            saved_token = empty_org._hf_token
+            empty_org._hf_token = None
+            try:
+                empty_org.save()
+            finally:
+                empty_org._hf_token = saved_token
+        finally:
+            # Restore env regardless of save success
+            if prior_fresh is None:
+                os.environ.pop("NUWAVE_FRESH_START", None)
+            else:
+                os.environ["NUWAVE_FRESH_START"] = prior_fresh
+
+        # Upload local empty-state files directly to pinned/clean-slate/
+        for fname in [
+            NuWaveOrganism.HUB_SIDECAR_FILENAME,
+            NuWaveOrganism.HUB_EXP_TRACT_FILENAME,
+            NuWaveOrganism.HUB_OUTCOMES_TRACT_FILENAME,
+            NuWaveOrganism.HUB_ACTIVATIONS_FILENAME,
+        ]:
+            local = os.path.join(tmp_dir, fname)
+            if not os.path.exists(local):
+                continue  # activations may be absent at empty-state
+            try:
+                api.upload_file(
+                    path_or_fileobj=local,
+                    path_in_repo=f"pinned/clean-slate/{fname}",
+                    repo_id=repo_id,
+                    repo_type="dataset",
+                    token=hf_token,
+                    commit_message="Bootstrap clean-slate baseline (one-time)",
+                )
+            except Exception as exc:
+                print(f"[clean-slate bootstrap] upload of {fname} failed: {exc}")
+
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+        print(f"[clean-slate bootstrap] pinned/clean-slate/ created in {repo_id}")
+    except Exception as exc:
+        print(f"[clean-slate bootstrap] skipped (non-fatal): {exc}")
+
+
+_bootstrap_pinned_clean_slate()
+
 # String-level KISS still runs alongside for comparison
 kiss_nw = KISSFilter()
 pith_nw = PithPipeline()

nuwave/organism.py

@@ -16,6 +16,34 @@ communication protocol (Law 1). Raw experience in, classification
 only at extraction (Law 7).
 
 # ---- Changelog ----
+# [2026-06-05] Claude Opus 4.7 (1M ctx) — Persist-hardening: rotation=20, prediction_threshold=1.5
+#   What: Two organism.py changes:
+#         (1) `_snapshot_to_backup` call site bumps `_prune_old_backups(api, keep=5)`
+#             → `keep=20`. Rotation window goes from ~35-min walk-back (eaten by
+#             in-run saves) to ~140-min, covering a full maturation run + change.
+#         (2) Config block adds `prediction_threshold: 1.5` override (canonical
+#             3.0 → 1.5) as Competence-Model regime tune for NuWave's denser,
+#             smaller-substrate signature.
+#   Why:  Run D verification surfaced rotation=5 was too small: NuWave makes
+#         in-run intermediate saves (~7 min cadence), so 5 backups got fully
+#         consumed BY ONE RUN. The pre-Run-D state (Run C's 123-node clean
+#         topology) was rotated out before we could pin it. Increased depth
+#         keeps multiple runs' worth of walk-back available.
+#         Run D also confirmed predictions=0 at 10,252 synapses across 4
+#         maturation runs. Two competing hypotheses for why no synapse has
+#         crossed canonical `prediction_threshold: 3.0`: (a) Syl-calibrated
+#         threshold too high for NuWave's regime, (b) density-spread-too-thin
+#         prevents weight concentration. The 1.5 override is the smallest
+#         reversible test that discriminates: if predictions emerge at 1.5,
+#         (a) is correct; if predictions remain 0, (b) is confirmed and
+#         density intervention (degree_sensitivity bump) becomes next test.
+#   How:  Three surgical edits — one-line keep= change at the call site,
+#         config dict entry with multi-line rationale comment, this changelog
+#         block. Backup method def keeps its default keep=5; callers (just
+#         the one) drive the policy. Pairs with `_bootstrap_pinned_clean_slate`
+#         added to app.py same commit — bootstrap captures empty-substrate
+#         baseline to `pinned/clean-slate/` for easy-reset operations.
+# -------------------
 # [2026-06-02] Claude Opus 4.7 (1M ctx) — Pre-save backup snapshots on HF dataset
 #   What: Two new methods, `_snapshot_to_backup` and `_prune_old_backups`,
 #         called from `save()` immediately before `_push_to_hub`. Snapshot
@@ -813,6 +841,20 @@ class NuWaveOrganism:
                 "decay_rate": 0.97,
                 "prime_strength": 1.0,
                 "learning_rate": 0.08,
+                # prediction_threshold: NuWave-regime override (canonical 3.0 → 1.5).
+                # Competence Model rationale: canonical 3.0 is calibrated for
+                # Syl's long-running, sparse (0.68 syn/node) substrate where
+                # individual pre→post weight concentrates over thousands of
+                # co-firings. NuWave's denser, smaller, benchmark-scale substrate
+                # accumulates many low-weight synapses via STDP-from-spreading-
+                # activation; no individual pre→post pair has crossed 3.0 across
+                # 4 maturation runs (Run B-D, 10,252 synapses, predictions=0).
+                # This override is a diagnostic: if predictions emerge at 1.5,
+                # the binding constraint is threshold calibration; if predictions
+                # remain 0, density-too-thin is confirmed and density-side
+                # intervention (degree_sensitivity bump) becomes the next test.
+                # Per-module Competence Model authority — not a canonical patch.
+                "prediction_threshold": 1.5,
                 # surprise_reward_scaling: canonical default (0.5) inherited.
                 # Previously overridden to 1.5 (3x canonical) — that was a
                 # compensation for the trad-dev external reward field that
@@ -2050,7 +2092,7 @@ class NuWaveOrganism:
                 return  # no live state yet (first save) or all skipped
             logger.info("Snapshotted %d live file(s) to %s", copied, backup_prefix)
 
-            self._prune_old_backups(api, keep=5)
+            self._prune_old_backups(api, keep=20)
         except Exception as exc:
             logger.debug("Snapshot to backup failed (non-fatal): %s", exc)