backup phase9 snapshot 20260311_105528

backups/20260311_105528/files/checkpoints.sha256

@@ -0,0 +1,4 @@
+eada09a77af8d0a96ef4a5a9db7c806a357272de079dd36a604a53d80f96cb4b  /tmp/newtie_checkpoint_backup_20260311_105528/files/checkpoints/newtie_v5_p6_step1660.pt
+460c7072fd7c315dc12219a9f4102dce56fa82579ec6c3a2645645a45204be12  /tmp/newtie_checkpoint_backup_20260311_105528/files/checkpoints/newtie_v5_p7_step300.pt
+43ee610b73d80dd90abb55450d4815d4728fb943f8d50c221b40ad4cef5e59da  /tmp/newtie_checkpoint_backup_20260311_105528/files/checkpoints/newtie_v5_p8_step320.pt
+70295e49221e19b15d7099edb53e037724e95fd8253231ef5945bca9aab80f46  /tmp/newtie_checkpoint_backup_20260311_105528/files/checkpoints/newtie_v5_p9_step50.pt

backups/20260311_105528/files/checkpoints/newtie_v5_p6_step1660.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eada09a77af8d0a96ef4a5a9db7c806a357272de079dd36a604a53d80f96cb4b
+size 178344960

backups/20260311_105528/files/checkpoints/newtie_v5_p7_step300.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:460c7072fd7c315dc12219a9f4102dce56fa82579ec6c3a2645645a45204be12
+size 191923200

backups/20260311_105528/files/checkpoints/newtie_v5_p8_step320.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:43ee610b73d80dd90abb55450d4815d4728fb943f8d50c221b40ad4cef5e59da
+size 180172800

backups/20260311_105528/files/checkpoints/newtie_v5_p9_step50.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70295e49221e19b15d7099edb53e037724e95fd8253231ef5945bca9aab80f46
+size 121143296

backups/20260311_105528/files/logs/koyeb_phase9_watchdog.log

@@ -0,0 +1,189 @@
+[watchdog] service=newtie-v5/tt-ssh interval=25 poll=20s ntfy=https://ntfy.sh/newtie-phase9-watchdog
+[watchdog] service=newtie-v5/tt-ssh interval=25 poll=20s ntfy=https://ntfy.sh/newtie-phase9-watchdog
+[watchdog] startup notify: ok=True detail=http_200
+[watchdog] state=training step=170/360 loss=1.612175 best=1.488463
+[watchdog] notify step=170 ok=True detail=http_200
+[watchdog] service=newtie-v5/tt-ssh interval=25 poll=20s ntfy=https://ntfy.sh/newtie-phase9-watchdog
+[watchdog] startup notify: ok=True detail=http_200
+[watchdog] state=training step=170/360 loss=1.612175 best=1.488463
+[watchdog] notify step=170 ok=True detail=http_200
+[watchdog] state=training step=171/360 loss=1.808503 best=1.488463
+[watchdog] state=training step=172/360 loss=1.478135 best=1.478135
+[watchdog] state=training step=173/360 loss=1.998468 best=1.488463
+[watchdog] state=training step=174/360 loss=1.922345 best=1.488463
+[watchdog] state=training step=175/360 loss=1.790282 best=1.488463
+[watchdog] state=training step=176/360 loss=1.652472 best=1.488463
+[watchdog] state=training step=177/360 loss=1.666387 best=1.488463
+[watchdog] state=training step=178/360 loss=1.720078 best=1.488463
+[watchdog] state=training step=179/360 loss=1.67226 best=1.488463
+[watchdog] state=training step=180/360 loss=1.610854 best=1.488463
+[watchdog] state=training step=181/360 loss=1.81897 best=1.488463
+[watchdog] state=training step=182/360 loss=1.689261 best=1.488463
+[watchdog] state=training step=183/360 loss=1.408932 best=1.408932
+[watchdog] state=training step=184/360 loss=1.545652 best=1.488463
+[watchdog] service=newtie-v5/tt-ssh interval=25 poll=20s ntfy=https://ntfy.sh/newtie-phase9-watchdog
+[watchdog] startup notify: ok=True detail=http_200
+[watchdog] state=training step=184/360 loss=1.545652 best=1.488463
+[watchdog] state=training step=185/360 loss=1.589464 best=1.488463
+[watchdog] state=training step=186/360 loss=1.715149 best=1.488463
+[watchdog] state=training step=187/360 loss=1.57981 best=1.488463
+[watchdog] state=training step=188/360 loss=1.942953 best=1.488463
+[watchdog] state=training step=189/360 loss=1.568122 best=1.488463
+[watchdog] state=training step=190/360 loss=1.757539 best=1.488463
+[watchdog] state=training step=191/360 loss=1.537299 best=1.488463
+[watchdog] state=training step=192/360 loss=1.969033 best=1.488463
+[watchdog] state=training step=193/360 loss=1.568621 best=1.488463
+[watchdog] state=training step=194/360 loss=1.607412 best=1.488463
+[watchdog] state=training step=195/360 loss=1.601118 best=1.488463
+[watchdog] state=training step=196/360 loss=1.869775 best=1.488463
+[watchdog] state=training step=197/360 loss=1.650993 best=1.488463
+[watchdog] state=training step=198/360 loss=1.553282 best=1.488463
+[watchdog] state=training step=199/360 loss=1.582979 best=1.488463
+[watchdog] state=training step=200/360 loss=1.712442 best=1.488463
+[watchdog] notify bucket=7 step=184 ok=True detail=http_200
+[watchdog] state=training step=201/360 loss=1.441567 best=1.441567
+[watchdog] state=training step=202/360 loss=1.669093 best=1.488463
+[watchdog] state=training step=203/360 loss=1.723409 best=1.488463
+[watchdog] state=training step=204/360 loss=1.645327 best=1.488463
+[watchdog] state=training step=205/360 loss=1.761128 best=1.488463
+[watchdog] state=training step=206/360 loss=1.586243 best=1.488463
+[watchdog] fetch error: ^D❌ Error listing services to resolve the provided identifier to an object ID: the CLI was unable to query the Koyeb API because of an issue on your machine or in your configuration
+
+🏥 How to solve the issue?
+Fix your configuration and try again
+
+🕦 The original error was:
+Get "https://app.koyeb.com/v1/services?limit=100&offset=0": dial tcp: lookup app.koyeb.com: no such host
+[watchdog] state=training step=207/360 loss=1.601974 best=1.488463
+[watchdog] state=training step=208/360 loss=1.505801 best=1.488463
+[watchdog] state=training step=209/360 loss=1.848183 best=1.488463
+[watchdog] state=training step=210/360 loss=1.633552 best=1.488463
+[watchdog] state=training step=211/360 loss=1.80079 best=1.488463
+[watchdog] state=training step=212/360 loss=1.696399 best=1.488463
+[watchdog] state=training step=213/360 loss=1.765791 best=1.488463
+[watchdog] state=training step=214/360 loss=1.419518 best=1.419518
+[watchdog] state=training step=215/360 loss=1.673599 best=1.488463
+[watchdog] state=training step=216/360 loss=1.971041 best=1.488463
+[watchdog] state=training step=217/360 loss=1.543152 best=1.488463
+[watchdog] state=training step=218/360 loss=1.733779 best=1.488463
+[watchdog] state=training step=219/360 loss=1.642925 best=1.488463
+[watchdog] state=training step=220/360 loss=1.613036 best=1.488463
+[watchdog] state=training step=221/360 loss=1.471104 best=1.471104
+[watchdog] state=training step=222/360 loss=1.748332 best=1.488463
+[watchdog] state=training step=223/360 loss=1.647199 best=1.488463
+[watchdog] state=training step=224/360 loss=1.758446 best=1.488463
+[watchdog] state=training step=225/360 loss=1.560556 best=1.488463
+[watchdog] notify bucket=8 step=214 ok=True detail=http_200
+[watchdog] state=training step=226/360 loss=1.696947 best=1.488463
+[watchdog] state=training step=227/360 loss=1.567105 best=1.488463
+[watchdog] state=training step=228/360 loss=1.715446 best=1.488463
+[watchdog] state=training step=229/360 loss=1.659889 best=1.488463
+[watchdog] state=training step=230/360 loss=1.670879 best=1.488463
+[watchdog] state=training step=231/360 loss=1.545578 best=1.488463
+[watchdog] state=training step=232/360 loss=1.720644 best=1.488463
+[watchdog] state=training step=233/360 loss=2.049204 best=1.488463
+[watchdog] state=training step=234/360 loss=2.144113 best=1.488463
+[watchdog] state=training step=235/360 loss=1.714216 best=1.488463
+[watchdog] state=training step=236/360 loss=2.169509 best=1.488463
+[watchdog] state=training step=237/360 loss=1.610534 best=1.488463
+[watchdog] state=training step=238/360 loss=1.956069 best=1.488463
+[watchdog] state=training step=239/360 loss=1.603848 best=1.488463
+[watchdog] state=training step=240/360 loss=2.006512 best=1.488463
+[watchdog] state=training step=241/360 loss=1.784127 best=1.488463
+[watchdog] state=training step=242/360 loss=1.476042 best=1.476042
+[watchdog] state=training step=243/360 loss=1.563302 best=1.488463
+[watchdog] state=training step=244/360 loss=2.105733 best=1.488463
+[watchdog] state=training step=245/360 loss=1.779902 best=1.488463
+[watchdog] state=training step=246/360 loss=1.558598 best=1.488463
+[watchdog] state=training step=247/360 loss=1.689218 best=1.488463
+[watchdog] state=training step=248/360 loss=1.904245 best=1.488463
+[watchdog] state=training step=249/360 loss=1.505913 best=1.488463
+[watchdog] state=training step=250/360 loss=1.501688 best=1.488463
+[watchdog] state=training step=251/360 loss=1.707498 best=1.488463
+[watchdog] state=training step=252/360 loss=1.421911 best=1.421911
+[watchdog] state=training step=251/2600 loss=10.552023 best=10.552023
+[watchdog] state=training step=252/2600 loss=2.721567 best=2.721567
+[watchdog] state=training step=253/2600 loss=1.967193 best=1.967193
+[watchdog] state=training step=254/2600 loss=2.396918 best=2.396918
+[watchdog] state=training step=255/2600 loss=2.335386 best=2.335386
+[watchdog] state=training step=256/2600 loss=2.278813 best=2.278813
+[watchdog] state=training step=257/2600 loss=2.340992 best=2.340992
+[watchdog] state=training step=258/2600 loss=2.376833 best=2.376833
+[watchdog] state=training step=259/2600 loss=2.342246 best=2.342246
+[watchdog] state=training step=260/2600 loss=2.560757 best=2.560757
+[watchdog] fetch error: ^DGet "https://api.github.com/repos/koyeb/koyeb-cli/releases": dial tcp: lookup api.github.com: no such host
+❌ Error listing services to resolve the provided identifier to an object ID: the CLI was unable to query the Koyeb API because of an issue on your machine or in your configuration
+
+🏥 How to solve the issue?
+Fix your configuration and try again
+
+🕦 The original error was:
+Get "https://app.koyeb.com/v1/services?limit=100&offset=0": dial tcp: lookup app.koyeb.com: no such host
+[watchdog] state=training step=261/2600 loss=2.465716 best=2.465716
+[watchdog] state=training step=262/2600 loss=2.633485 best=2.633485
+[watchdog] service=newtie-v5/tt-ssh interval=25 poll=20s ntfy=https://ntfy.sh/newtie-phase9-watchdog
+[watchdog] startup notify: ok=True detail=http_200
+[watchdog] state=training step=262/2600 loss=2.633485 best=2.633485
+[watchdog] state=training step=263/2600 loss=2.060942 best=2.060942
+[watchdog] service=newtie-v5/tt-ssh interval=25 poll=20s ntfy=https://ntfy.sh/newtie-phase9-watchdog
+[watchdog] startup notify: ok=True detail=http_200
+[watchdog] state=training step=263/2600 loss=2.060942 best=2.060942
+[watchdog] state=training step=264/2600 loss=2.619503 best=2.619503
+[watchdog] state=training step=265/2600 loss=2.185474 best=2.185474
+[watchdog] state=training step=266/2600 loss=2.531834 best=2.531834
+[watchdog] state=training step=267/2600 loss=2.216286 best=2.216286
+[watchdog] state=training step=268/2600 loss=2.10495 best=2.10495
+[watchdog] state=training step=269/2600 loss=2.196869 best=2.196869
+[watchdog] state=training step=270/2600 loss=2.186647 best=2.186647
+[watchdog] state=training step=271/2600 loss=2.058746 best=2.058746
+[watchdog] state=training step=272/2600 loss=2.190154 best=2.190154
+[watchdog] state=training step=273/2600 loss=2.076107 best=2.076107
+[watchdog] state=training step=274/2600 loss=2.463736 best=2.463736
+[watchdog] state=training step=275/2600 loss=2.089918 best=2.089918
+[watchdog] notify bucket=10 step=271 ok=True detail=http_200
+[watchdog] state=training step=276/2600 loss=2.145116 best=2.145116
+[watchdog] state=training step=277/2600 loss=1.952256 best=1.952256
+[watchdog] state=training step=278/2600 loss=2.71554 best=2.71554
+[watchdog] state=training step=279/2600 loss=2.065405 best=2.065405
+[watchdog] state=training step=280/2600 loss=2.197073 best=2.197073
+[watchdog] state=training step=281/2600 loss=2.09925 best=2.09925
+[watchdog] state=training step=282/2600 loss=2.072892 best=2.072892
+[watchdog] state=training step=283/2600 loss=2.102325 best=2.102325
+[watchdog] state=training step=284/2600 loss=2.018738 best=2.018738
+[watchdog] state=training step=285/2600 loss=2.251856 best=2.251856
+[watchdog] state=training step=286/2600 loss=2.177423 best=2.177423
+[watchdog] state=training step=287/2600 loss=2.223401 best=2.223401
+[watchdog] state=training step=288/2600 loss=2.375378 best=2.375378
+[watchdog] state=training step=289/2600 loss=2.143717 best=2.143717
+[watchdog] state=training step=290/2600 loss=2.173659 best=2.173659
+[watchdog] state=training step=291/2600 loss=1.918152 best=1.918152
+[watchdog] state=training step=292/2600 loss=1.970492 best=1.970492
+[watchdog] state=training step=293/2600 loss=1.849398 best=1.849398
+[watchdog] state=training step=294/2600 loss=2.211296 best=2.211296
+[watchdog] state=training step=295/2600 loss=1.990625 best=1.990625
+[watchdog] state=training step=296/2600 loss=2.203358 best=2.203358
+[watchdog] state=training step=297/2600 loss=2.312794 best=2.312794
+[watchdog] state=training step=298/2600 loss=2.094307 best=2.094307
+[watchdog] state=training step=299/2600 loss=1.979491 best=1.979491
+[watchdog] state=training step=300/2600 loss=1.866587 best=1.866587
+[watchdog] notify bucket=11 step=293 ok=True detail=http_200
+[watchdog] state=training step=301/2600 loss=1.840695 best=1.840695
+[watchdog] state=training step=302/2600 loss=1.869256 best=1.866587
+[watchdog] state=training step=303/2600 loss=1.936824 best=1.866587
+[watchdog] state=training step=304/2600 loss=2.16803 best=1.866587
+[watchdog] state=training step=305/2600 loss=2.279149 best=1.866587
+[watchdog] state=training step=306/2600 loss=2.042783 best=1.866587
+[watchdog] state=training step=307/2600 loss=1.950344 best=1.866587
+[watchdog] state=training step=308/2600 loss=2.212778 best=1.866587
+[watchdog] state=training step=309/2600 loss=1.807868 best=1.807868
+[watchdog] state=training step=310/2600 loss=2.098982 best=1.866587
+[watchdog] state=training step=311/2600 loss=1.951648 best=1.866587
+[watchdog] state=training step=312/2600 loss=1.796994 best=1.796994
+[watchdog] state=training step=313/2600 loss=2.138237 best=1.866587
+[watchdog] state=training step=314/2600 loss=1.951604 best=1.866587
+[watchdog] state=training step=315/2600 loss=2.104002 best=1.866587
+[watchdog] state=training step=316/2600 loss=1.914197 best=1.866587
+[watchdog] state=training step=317/2600 loss=2.023874 best=1.866587
+[watchdog] state=training step=318/2600 loss=2.161247 best=1.866587
+[watchdog] state=training step=319/2600 loss=1.779523 best=1.779523
+[watchdog] state=training step=320/2600 loss=2.093385 best=1.866587

backups/20260311_105528/files/train.py

@@ -0,0 +1,1561 @@
+"""
+Newtie V5 — Training Script (4× N300S Pipeline Parallel)
+==========================================================
+
+Phase 1: Cognitive Depth — train on local SFT data (~12.5K entries).
+Focus: deep reasoning, metacognition, identity — NOT memorization.
+
+Pipeline Parallel across 8 Wormhole chips:
+  - 32 layers / 8 chips = 4 layers per chip
+  - 64 micro-batches → 89% pipeline efficiency (1F1B schedule)
+  - MoE experts L1-pinned on Tensix cores (zero DRAM reads)
+  - STDP/Cerebrix as native Tensix compute kernels
+  - tt-topology mesh must be configured first (entrypoint.sh)
+
+Falls back to: single N300 → CUDA → CPU
+
+Data sources (local, Phase 1):
+  - sft_cognitive_depth.jsonl (8K entries — identity, philosophy, reasoning)
+  - deep_synthesis patterns (1.2K — cross-domain reasoning chains)
+  - waveflow2 SFT pairs (2.4K — scientific reasoning)
+  - cognitive scenarios (50 — causal reasoning, chat format)
+  - SALA SFT (37 — tool-use trajectories)
+"""
+
+import os
+import sys
+import json
+import time
+import math
+import glob
+import random
+import argparse
+import signal
+import urllib.error
+import urllib.request
+from pathlib import Path
+from dataclasses import asdict
+from collections import OrderedDict
+from typing import Dict, List, Optional
+
+# ═══════════════════════════════════════════════════════════════
+# CPU THREADING
+#
+# Must be set BEFORE importing torch.
+# Default behavior on N300: run matmuls on Wormhole chips via TTLinear.
+# Set `--cpu-only` or env `NEWTIE_CPU_ONLY=1` to disable chip acceleration.
+# ═══════════════════════════════════════════════════════════════
+_CPU_ONLY = os.environ.get("NEWTIE_CPU_ONLY", "0") == "1"
+_PERF_PROFILE = os.environ.get("NEWTIE_TT_PERF_PROFILE", "balanced").strip().lower()
+_CPU_CAPACITY = os.cpu_count() or 8
+
+
+def _parse_int_env(name: str, default: int, minimum: int = 1, maximum: Optional[int] = None) -> int:
+    raw = os.environ.get(name)
+    if raw is None:
+        val = default
+    else:
+        try:
+            val = int(raw)
+        except (TypeError, ValueError):
+            print(f"[THREADS] invalid {name}={raw!r} -> fallback {default}")
+            val = default
+    if val < minimum:
+        val = minimum
+    if maximum is not None and val > maximum:
+        val = maximum
+    return val
+
+
+def _parse_bool_env(name: str, default: bool = False) -> bool:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    return str(raw).strip().lower() in {"1", "true", "on", "yes", "y"}
+
+
+def _parse_float_env(
+    name: str,
+    default: float,
+    minimum: Optional[float] = None,
+    maximum: Optional[float] = None,
+) -> float:
+    raw = os.environ.get(name)
+    if raw is None:
+        val = default
+    else:
+        try:
+            val = float(raw)
+        except (TypeError, ValueError):
+            print(f"[ENV] invalid {name}={raw!r} -> fallback {default}")
+            val = default
+    if minimum is not None and val < minimum:
+        val = minimum
+    if maximum is not None and val > maximum:
+        val = maximum
+    return val
+
+
+def _get_perf_profile_defaults(cpu_capacity: int) -> Dict[str, int | bool]:
+    tt_profiles = {
+        "safe": {
+            "ncpu": 16,
+            "dataloader_workers": 2,
+            "dataloader_prefetch": 2,
+            "dataloader_persist_workers": True,
+        },
+        "balanced": {
+            "ncpu": 24,
+            "dataloader_workers": 4,
+            "dataloader_prefetch": 3,
+            "dataloader_persist_workers": True,
+        },
+        "throughput": {
+            "ncpu": 28,
+            "dataloader_workers": 6,
+            "dataloader_prefetch": 4,
+            "dataloader_persist_workers": True,
+        },
+    }
+    cpu_profiles = {
+        "safe": {
+            "ncpu": cpu_capacity,
+            "dataloader_workers": 4,
+            "dataloader_prefetch": 2,
+            "dataloader_persist_workers": True,
+        },
+        "balanced": {
+            "ncpu": cpu_capacity,
+            "dataloader_workers": 8,
+            "dataloader_prefetch": 4,
+            "dataloader_persist_workers": True,
+        },
+        "throughput": {
+            "ncpu": cpu_capacity,
+            "dataloader_workers": 12,
+            "dataloader_prefetch": 6,
+            "dataloader_persist_workers": True,
+        },
+    }
+
+    profile = _PERF_PROFILE if _PERF_PROFILE in tt_profiles else "balanced"
+    if _PERF_PROFILE not in tt_profiles:
+        print(f"[PERF] unknown NEWTIE_TT_PERF_PROFILE={_PERF_PROFILE!r}; falling back to balanced")
+        profile = "balanced"
+
+    return cpu_profiles[profile] if _CPU_ONLY else tt_profiles[profile]
+
+
+_perf_defaults = _get_perf_profile_defaults(_CPU_CAPACITY)
+_profile_hint = _PERF_PROFILE if _PERF_PROFILE in ("safe", "balanced", "throughput") else "balanced"
+_default_threads = min(_CPU_CAPACITY, _perf_defaults["ncpu"])
+
+_ncpu = _parse_int_env(
+    "NEWTIE_TT_CPU_THREADS",
+    default=_default_threads,
+    minimum=1,
+    maximum=_CPU_CAPACITY,
+)
+
+os.environ["OMP_NUM_THREADS"] = str(_ncpu)
+os.environ["MKL_NUM_THREADS"] = str(_ncpu)
+os.environ["OPENBLAS_NUM_THREADS"] = str(_ncpu)
+os.environ["VECLIB_MAXIMUM_THREADS"] = str(_ncpu)
+
+_tt_dataloader_workers = _parse_int_env(
+    "NEWTIE_DATALOADER_WORKERS",
+    default=int(_perf_defaults["dataloader_workers"]),
+    minimum=0,
+    maximum=64,
+)
+_tt_dataloader_prefetch = _parse_int_env(
+    "NEWTIE_DATALOADER_PREFETCH",
+    default=int(_perf_defaults["dataloader_prefetch"]),
+    minimum=1,
+    maximum=16,
+)
+_tt_dataloader_persist_workers = _parse_bool_env(
+    "NEWTIE_DATALOADER_PERSIST_WORKERS",
+    default=bool(_perf_defaults["dataloader_persist_workers"]),
+)
+_pretoken_cache_enabled = _parse_bool_env(
+    "NEWTIE_PRETOKENIZE_CACHE",
+    default=(_PERF_PROFILE == "throughput"),
+)
+_pretoken_cache_size = _parse_int_env(
+    "NEWTIE_PRETOKENIZE_CACHE_SIZE",
+    default=4096,
+    minimum=0,
+    maximum=200000,
+)
+
+# Power / benchmark overrides (consumed after phase preset selection)
+_NEWTIE_TT_POWER_MODE = os.environ.get("NEWTIE_TT_POWER_MODE", "").strip()
+_FORCE_BYTE_PATH = os.environ.get("NEWTIE_FORCE_BYTE_PATH", "0") == "1"
+_OVERRIDE_SEQ_LEN = int(os.environ.get("NEWTIE_OVERRIDE_SEQ_LEN", "0") or 0)
+_POWER_EFFECTIVE_MICROBATCH = int(os.environ.get("NEWTIE_POWER_EFFECTIVE_MICROBATCH", "0") or 0)
+_BENCH_RELAX_EVAL = os.environ.get("NEWTIE_BENCH_RELAX_EVAL", "0") == "1"
+_BENCH_RELAX_CHECKPOINT = os.environ.get("NEWTIE_BENCH_RELAX_CHECKPOINT", "0") == "1"
+
+# Watchdog / NTFY notifications
+_WATCHDOG_ENABLED = _parse_bool_env("NEWTIE_WATCHDOG_ENABLED", default=True)
+_WATCHDOG_INTERVAL = _parse_int_env("NEWTIE_WATCHDOG_INTERVAL", default=25, minimum=1, maximum=100000)
+_WATCHDOG_MIN_DELTA = _parse_float_env("NEWTIE_WATCHDOG_MIN_DELTA", default=1e-4, minimum=0.0)
+_NTFY_TOPIC = os.environ.get("NEWTIE_NTFY_TOPIC", "").strip()
+_NTFY_URL = os.environ.get("NEWTIE_NTFY_URL", "").strip()
+_NTFY_TOKEN = os.environ.get("NEWTIE_NTFY_TOKEN", "").strip()
+_NTFY_PRIORITY = os.environ.get("NEWTIE_NTFY_PRIORITY", "3").strip()
+_NTFY_TAGS = os.environ.get("NEWTIE_NTFY_TAGS", "chart_with_upwards_trend").strip()
+_NTFY_CLICK = os.environ.get("NEWTIE_NTFY_CLICK", "").strip()
+_NTFY_TIMEOUT_S = _parse_float_env("NEWTIE_NTFY_TIMEOUT_S", default=10.0, minimum=1.0, maximum=60.0)
+
+import torch
+torch.set_num_threads(_ncpu)
+print(
+    f"[THREADS] OMP={_ncpu}, MKL/OPENBLAS/VECLIB={_ncpu}, "
+    f"torch_threads={torch.get_num_threads()}, cpu_only={_CPU_ONLY}"
+)
+if _profile_hint != _PERF_PROFILE:
+    _resolved_profile_msg = f"[PERF] profile={_profile_hint} (requested={_PERF_PROFILE!r}, fallback={_profile_hint})"
+else:
+    _resolved_profile_msg = f"[PERF] profile={_profile_hint} (requested={_PERF_PROFILE!r})"
+print(
+    _resolved_profile_msg
+)
+print(
+    f"[THREADS] dataloader workers={_tt_dataloader_workers}, "
+    f"prefetch={_tt_dataloader_prefetch}, persist_workers={_tt_dataloader_persist_workers}"
+)
+print(
+    f"[DATA] pretoken cache enabled={_pretoken_cache_enabled}, "
+    f"cache_size={_pretoken_cache_size}"
+)
+print(
+    f"[WATCHDOG] enabled={_WATCHDOG_ENABLED}, interval={_WATCHDOG_INTERVAL}, "
+    f"min_delta={_WATCHDOG_MIN_DELTA}"
+)
+
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader, DistributedSampler
+import torch.distributed as dist
+
+# Add model to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from model.config import (
+    NewtieConfig, TrainingConfig, HardwareConfig,
+    get_phase1_config, get_phase2_config, get_phase3_config, get_phase4_config,
+    get_phase5_config, get_phase6_config, get_phase7_config, get_phase8_config,
+    get_phase9_config,
+)
+from model.newtie_v5 import NewtieV5
+from model.tt_backend import DeviceMesh, PipelineEngine, create_pipeline
+
+# TT ops are optional: only required when chip acceleration is enabled.
+try:
+    from model.tt_ops import (
+        accelerate_model,
+        sync_tt_weights,
+        mark_tt_dirty,
+        begin_tt_runtime_step,
+        report_tt_adaptive_mesh_plan,
+    )
+except Exception:
+    accelerate_model = None
+    sync_tt_weights = None
+    mark_tt_dirty = None
+    begin_tt_runtime_step = None
+    report_tt_adaptive_mesh_plan = None
+
+
+# ═══════════════════════════════════════════════════════════════
+# Hardware Detection (delegates to DeviceMesh for N300)
+# ═══════════════════════════════════════════════════════════════
+
+def detect_hardware():
+    """Detect best available hardware.
+    
+    Returns:
+      (hw_type, compute_device, tt_chip_count)
+        - N300: ("n300", None, chips)
+        - CUDA: ("cuda", cuda_device, 0)
+        - CPU: ("cpu", cpu_device, 0)
+    
+    CRITICAL: Never use torch.device('cuda') or torch.device('cpu') for N300.
+    All tensors go to Wormhole chips via ttnn. The CPU only holds
+    parameter tensors for the optimizer — zero compute on CPU.
+    """
+    # Check for Tenstorrent N300
+    if os.path.exists("/dev/tenstorrent"):
+        try:
+            import ttnn
+            pcie_endpoints = 0
+
+            # Koyeb exposes PCIe endpoints in /dev/tenstorrent. For N300S,
+            # each endpoint corresponds to one card = two Wormhole chips.
+            if os.path.isdir("/dev/tenstorrent"):
+                pcie_endpoints = len([f for f in os.listdir("/dev/tenstorrent")
+                                      if f.isdigit()])
+            chip_count = pcie_endpoints * 2
+            n_cards = pcie_endpoints
+            print(f"[HARDWARE] {n_cards}× N300S detected ({chip_count} Wormhole chips)")
+            print(f"  96 GB VRAM across {chip_count} chips (12 GB each)")
+            print(f"  All matmul compute → Wormhole Tensix cores")
+            print(f"  CPU only holds parameters for optimizer — zero CPU compute")
+            # Return None as device — model params stay on CPU for optimizer,
+            # but ALL forward/backward matmuls dispatch to ttnn devices
+            return "n300", None, chip_count
+        except ImportError:
+            print(f"[HARDWARE] Tenstorrent detected but ttnn not installed")
+            print(f"  FATAL: Cannot run without ttnn on Tenstorrent hardware")
+            raise RuntimeError("ttnn required for Tenstorrent N300")
+
+    if torch.cuda.is_available():
+        name = torch.cuda.get_device_name(0)
+        mem = torch.cuda.get_device_properties(0).total_mem / 1e9
+        print(f"[HARDWARE] CUDA: {name} ({mem:.1f} GB)")
+        return "cuda", torch.device("cuda"), 0
+
+    print("[HARDWARE] CPU mode (no accelerator)")
+    return "cpu", torch.device("cpu"), 0
+
+
+def active_graph_phase_name_for(train_config: TrainingConfig) -> str:
+    """Map training phases to explicit active-graph runtime profiles."""
+    phase = int(getattr(train_config, "phase", 0) or 0)
+    phase_name = str(getattr(train_config, "phase_name", "") or "").strip().lower()
+    if phase == 7 or "grounded_agency" in phase_name:
+        return "phase7"
+    if phase in (8, 9) or "reasoning" in phase_name or "instruction_response" in phase_name:
+        return "phase8"
+    if "byte" in phase_name:
+        return "phase_byte_active"
+    return "phase6"
+
+
+def build_hw_config_for_run(model_config: NewtieConfig,
+                            hw_type: str,
+                            tt_chip_count: int,
+                            num_devices: int) -> HardwareConfig:
+    """Pick a safe pipeline shape for currently visible TT hardware."""
+    hw_config = HardwareConfig()
+    if hw_type != "n300":
+        return hw_config
+
+    requested_chips = max(0, int(num_devices)) * 2 if num_devices else 0
+    available_chips = tt_chip_count if tt_chip_count > 0 else requested_chips
+    if requested_chips > 0 and tt_chip_count > 0:
+        available_chips = min(tt_chip_count, requested_chips)
+    if available_chips <= 0:
+        return hw_config
+
+    if available_chips >= 8:
+        stages = 8
+    elif available_chips >= 4:
+        stages = 4
+    elif available_chips >= 2:
+        stages = 2
+    else:
+        stages = 1
+
+    n_cards = max(1, stages // 2)
+    layers_per_stage = max(1, model_config.n_layers // stages)
+
+    hw_config.n_cards = n_cards
+    hw_config.stages = stages
+    hw_config.layers_per_stage = layers_per_stage
+
+    print(f"[HARDWARE] pipeline profile: cards={hw_config.n_cards}, "
+          f"chips={hw_config.total_chips}, stages={hw_config.stages}, "
+          f"layers_per_stage={hw_config.layers_per_stage}")
+    return hw_config
+
+
+# ═══════════════════════════════════════════════════════════════
+# Cognitive SFT Dataset
+# ═══════════════════════════════════════════════════════════════
+
+class CognitiveSFTDataset(Dataset):
+    """
+    Loads all cognitive SFT data for Phase 1 training.
+    Tokenizes instruction→response pairs into training sequences.
+
+    Format: <|system|>\n{system}\n<|end|>\n<|user|>\n{instruction}\n<|end|>\n<|assistant|>\n{response}\n<|end|>
+    """
+
+    SYSTEM_PROMPT = (
+        "Du är Newtie, en kognitiv AI skapad av InfinityHQ Research Lab. "
+        "Du resonerar djupt, steg för steg. Du är ärlig om vad du vet och inte vet. "
+        "Du tänker över ditt tänkande. Du svarar på samma språk som frågan."
+    )
+
+    def __init__(self, data_paths: List[str], tokenizer, seq_len: int = 2048,
+                 max_samples: int = None,
+                 cache_tokens: bool = _pretoken_cache_enabled,
+                 cache_size: int = _pretoken_cache_size):
+        self.seq_len = seq_len
+        self.tokenizer = tokenizer
+        self.entries = []
+        self._cache_tokens = bool(cache_tokens)
+        self._cache_size = int(max(0, cache_size))
+        self._token_cache: OrderedDict[int, Dict[str, torch.Tensor]] = OrderedDict()
+        self._assistant_prefix_ids = self.tokenizer.encode("<|assistant|>\n")
+        self._end_marker_ids = self.tokenizer.encode("<|end|>")
+
+        # Load all JSONL files
+        for path in data_paths:
+            if not os.path.exists(path):
+                print(f"  [DATA] Skipping {path} (not found)")
+                continue
+            with open(path, 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        entry = json.loads(line)
+                        self.entries.append(entry)
+                    except json.JSONDecodeError:
+                        continue
+            print(f"  [DATA] Loaded {path}: {len(self.entries)} total entries")
+
+        if max_samples and len(self.entries) > max_samples:
+            random.shuffle(self.entries)
+            self.entries = self.entries[:max_samples]
+
+        print(f"  [DATA] Total: {len(self.entries)} training entries")
+
+        if self._cache_tokens and self._cache_size > 0:
+            print(f"  [DATA] LRU token cache active: size={self._cache_size}")
+
+    @staticmethod
+    def _format_cached(item: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
+        """Clone only when necessary for DataLoader worker safety."""
+        return {
+            "input_ids": item["input_ids"],
+            "labels": item["labels"],
+            **({"byte_ids": item["byte_ids"]} if "byte_ids" in item else {})
+        }
+
+    def __len__(self):
+        return len(self.entries)
+
+    @staticmethod
+    def _find_subsequence(haystack: List[int], needle: List[int], start_idx: int = 0) -> int:
+        if not needle:
+            return -1
+        max_start = len(haystack) - len(needle)
+        for idx in range(max(start_idx, 0), max_start + 1):
+            if haystack[idx] == needle[0] and haystack[idx: idx + len(needle)] == needle:
+                return idx
+        return -1
+
+    def _format_entry(self, entry: dict) -> str:
+        """Convert entry to chat format string."""
+        # Handle different data formats
+        if "messages" in entry:
+            # Chat format (cognitive_scenarios.jsonl)
+            parts = []
+            for msg in entry["messages"]:
+                role = msg.get("role", "user")
+                content = msg.get("content", "")
+                parts.append(f"<|{role}|>\n{content}\n<|end|>")
+            return "\n".join(parts)
+
+        elif "instruction" in entry and "response" in entry:
+            # SFT format (sft_cognitive_depth.jsonl, etc.)
+            instruction = entry["instruction"]
+            response = entry["response"]
+            return (
+                f"<|system|>\n{self.SYSTEM_PROMPT}\n<|end|>\n"
+                f"<|user|>\n{instruction}\n<|end|>\n"
+                f"<|assistant|>\n{response}\n<|end|>"
+            )
+
+        elif "query" in entry and "content" in entry:
+            # Pattern format (deep_synthesis patterns)
+            query = entry["query"]
+            content = entry["content"]
+            return (
+                f"<|system|>\n{self.SYSTEM_PROMPT}\n<|end|>\n"
+                f"<|user|>\n{query}\n<|end|>\n"
+                f"<|assistant|>\n{content}\n<|end|>"
+            )
+
+        else:
+            # Fallback: just concatenate all string values
+            text = " ".join(str(v) for v in entry.values() if isinstance(v, str))
+            return text
+
+    def __getitem__(self, idx):
+        if self._cache_tokens and self._cache_size > 0:
+            cached = self._token_cache.get(idx)
+            if cached is not None:
+                self._token_cache.move_to_end(idx)
+                return self._format_cached(cached)
+
+        entry = self.entries[idx]
+        text = self._format_entry(entry)
+
+        # Tokenize
+        token_ids = self.tokenizer.encode(text)
+        content_len = min(len(token_ids), self.seq_len)
+
+        # Truncate or pad to seq_len
+        if len(token_ids) > self.seq_len:
+            token_ids = token_ids[:self.seq_len]
+        else:
+            token_ids = token_ids + [0] * (self.seq_len - len(token_ids))
+
+        input_ids = torch.tensor(token_ids, dtype=torch.long)
+        labels = torch.full_like(input_ids, -100)
+
+        # Train primarily on assistant completion tokens.
+        assistant_start = self._find_subsequence(
+            token_ids[:content_len], self._assistant_prefix_ids, start_idx=0
+        )
+        if assistant_start >= 0:
+            response_start = assistant_start + len(self._assistant_prefix_ids)
+            response_end = self._find_subsequence(
+                token_ids[:content_len], self._end_marker_ids, start_idx=response_start
+            )
+            if response_end < 0:
+                response_end = content_len
+            if response_end > response_start:
+                labels[response_start:response_end] = input_ids[response_start:response_end]
+            else:
+                labels[:content_len] = input_ids[:content_len]
+        else:
+            labels[:content_len] = input_ids[:content_len]
+
+        item = {"input_ids": input_ids, "labels": labels}
+
+        if _FORCE_BYTE_PATH:
+            byte_values = list(text.encode("utf-8"))
+            if len(byte_values) > self.seq_len:
+                byte_values = byte_values[:self.seq_len]
+            else:
+                byte_values = byte_values + [0] * (self.seq_len - len(byte_values))
+            item["byte_ids"] = torch.tensor(byte_values, dtype=torch.long)
+
+        if self._cache_tokens and self._cache_size > 0:
+            if len(self._token_cache) >= self._cache_size:
+                self._token_cache.popitem(last=False)
+            self._token_cache[idx] = {
+                "input_ids": item["input_ids"],
+                "labels": item["labels"],
+                **({"byte_ids": item["byte_ids"]} if "byte_ids" in item else {}),
+            }
+
+        return item
+
+
+def apply_power_mode_overrides(train_config: TrainingConfig) -> TrainingConfig:
+    """Apply env-driven benchmark overrides without changing phase presets on disk."""
+    changed = []
+
+    if _OVERRIDE_SEQ_LEN > 0 and _OVERRIDE_SEQ_LEN != train_config.seq_len:
+        train_config.seq_len = _OVERRIDE_SEQ_LEN
+        changed.append(f"seq_len={train_config.seq_len}")
+
+    if _POWER_EFFECTIVE_MICROBATCH > 0:
+        base_batch = max(1, int(train_config.batch_size))
+        target_effective = max(base_batch, _POWER_EFFECTIVE_MICROBATCH)
+        grad_accum = (target_effective + base_batch - 1) // base_batch
+        if grad_accum != train_config.gradient_accumulation_steps:
+            train_config.gradient_accumulation_steps = grad_accum
+            changed.append(f"effective_batch={train_config.effective_batch_size}")
+
+    if _BENCH_RELAX_EVAL:
+        new_eval = max(int(train_config.eval_interval), int(train_config.total_steps) + 1)
+        if new_eval != train_config.eval_interval:
+            train_config.eval_interval = new_eval
+            changed.append(f"eval_interval={train_config.eval_interval}")
+
+    if _BENCH_RELAX_CHECKPOINT:
+        new_save = max(int(train_config.save_interval), 50)
+        if new_save != train_config.save_interval:
+            train_config.save_interval = new_save
+            changed.append(f"save_interval={train_config.save_interval}")
+
+    if changed:
+        mode_name = _NEWTIE_TT_POWER_MODE or "custom"
+        print(f"[POWER] {mode_name}: {' | '.join(changed)}")
+        if _FORCE_BYTE_PATH:
+            print("[POWER] byte_path=forced")
+
+    return train_config
+
+
+def adapt_resume_state_dict_for_current_model(
+    checkpoint_state: Dict[str, torch.Tensor]
+) -> Dict[str, torch.Tensor]:
+    """Map legacy perception keys into the current SuperByte-Lite layout."""
+    adapted = dict(checkpoint_state)
+
+    key_map = {
+        "perception.superbyte.byte_embed.weight": "perception.superbyte.impl.byte_embed.weight",
+        "perception.superbyte.gate_proj.weight": "perception.superbyte.impl.gate_proj.weight",
+        "perception.superbyte.gate_proj.bias": "perception.superbyte.impl.gate_proj.bias",
+        "perception.superbyte.value_proj.weight": "perception.superbyte.impl.value_proj.weight",
+        "perception.superbyte.value_proj.bias": "perception.superbyte.impl.value_proj.bias",
+        "perception.superbyte.norm.weight": "perception.superbyte.impl.norm.weight",
+        "perception.superbyte.norm.bias": "perception.superbyte.impl.norm.bias",
+        "perception.bridge.W_q.weight": "perception.bridge.impl.q_proj.weight",
+        "perception.bridge.W_k.weight": "perception.bridge.impl.k_proj.weight",
+        "perception.bridge.W_v.weight": "perception.bridge.impl.v_proj.weight",
+        "perception.bridge.W_out.weight": "perception.bridge.impl.out_proj.weight",
+        "perception.bridge.norm_q.weight": "perception.bridge.impl.norm_tokens.weight",
+        "perception.bridge.norm_q.bias": "perception.bridge.impl.norm_tokens.bias",
+        "perception.bridge.norm_kv.weight": "perception.bridge.impl.norm_patches.weight",
+        "perception.bridge.norm_kv.bias": "perception.bridge.impl.norm_patches.bias",
+        "perception.bridge.norm_out.weight": "perception.bridge.impl.norm_out.weight",
+        "perception.bridge.norm_out.bias": "perception.bridge.impl.norm_out.bias",
+    }
+    for old_key, new_key in key_map.items():
+        if old_key in checkpoint_state and new_key not in adapted:
+            adapted[new_key] = checkpoint_state[old_key]
+
+    scale_proj = checkpoint_state.get("perception.superbyte.scale_proj.weight")
+    local_proj_key = "perception.superbyte.impl.local_proj.weight"
+    if scale_proj is not None and local_proj_key not in adapted and scale_proj.ndim == 2:
+        out_dim, in_dim = scale_proj.shape
+        if out_dim > 0 and in_dim % out_dim == 0:
+            n_scales = in_dim // out_dim
+            adapted[local_proj_key] = scale_proj.view(out_dim, n_scales, out_dim).mean(dim=1)
+
+    return adapted
+
+
+def default_phase_data_dir(phase: int) -> Optional[str]:
+    """Prefer structured local phase datasets when present."""
+    candidates = [
+        f"/Volumes/ADi/The Concern/training_data/phase{phase}",
+        f"/data/newtie_v5/training_data/phase{phase}",
+    ]
+    for cand in candidates:
+        if os.path.isdir(cand) and any(name.endswith(".jsonl") for name in os.listdir(cand)):
+            return cand
+    return None
+
+
+# ═══════════════════════════════════════════════════════════════
+# Simple BPE Tokenizer (fallback if sentencepiece not available)
+# ═══════════════════════════════════════════════════════════════
+
+class ByteFallbackTokenizer:
+    """UTF-8 byte-level tokenizer — works without any external dependencies.
+    Each byte (0-255) maps to tokens 0-255. Special tokens 256+."""
+
+    def __init__(self, vocab_size=32000):
+        self.vocab_size = vocab_size
+
+    def encode(self, text: str) -> List[int]:
+        return list(text.encode('utf-8'))
+
+    def decode(self, ids: List[int]) -> str:
+        return bytes(min(b, 255) for b in ids).decode('utf-8', errors='replace')
+
+
+# ═══════════════════════════════════════════════════════════════
+# WSD Learning Rate Schedule
+# ═══════════════════════════════════════════════════════════════
+
+def get_wsd_lr(step: int, config: TrainingConfig) -> float:
+    """Warmup-Stable-Decay schedule (MiniCPM-style)."""
+    total = config.total_steps
+    warmup = config.warmup_steps
+    stable_end = int(total * config.stable_ratio)
+    decay_start = stable_end
+    decay_end = total
+
+    if step < warmup:
+        # Linear warmup
+        return config.lr * step / warmup
+    elif step < stable_end:
+        # Stable phase — full LR
+        return config.lr
+    else:
+        # Cosine decay
+        progress = (step - decay_start) / max(decay_end - decay_start, 1)
+        return config.min_lr + 0.5 * (config.lr - config.min_lr) * (
+            1 + math.cos(math.pi * progress))
+
+
+# ═══════════════════════════════════════════════════════════════
+# Dashboard Integration
+# ═══════════════════════════════════════════════════════════════
+
+def write_status(log_dir: str, status: dict):
+    """Write training status JSON for dashboard to read."""
+    path = os.path.join(log_dir, "training_status.json")
+    try:
+        with open(path, "w") as f:
+            json.dump(status, f, indent=2)
+    except (OSError, IOError):
+        pass  # Non-critical
+
+
+def write_bio_gates(log_dir: str, gate_dict: dict):
+    """Write bio-module gate values + spike dynamics for dashboard."""
+    path = os.path.join(log_dir, "bio_gates.json")
+    try:
+        gates = {}
+        for k, v in gate_dict.items():
+            if isinstance(v, dict):
+                # Spike info dicts — flatten into "spike_hierarchy_info.spike_rate_word" etc.
+                for sk, sv in v.items():
+                    val = sv.item() if hasattr(sv, 'item') else float(sv) if isinstance(sv, (int, float)) else None
+                    if val is not None:
+                        gates[f"{k}.{sk}"] = val
+            elif hasattr(v, 'mean'):
+                gates[k] = float(v.mean().item())
+            elif isinstance(v, (int, float)):
+                gates[k] = float(v)
+        with open(path, "w") as f:
+            json.dump(gates, f, indent=2)
+    except (OSError, IOError):
+        pass
+
+
+def check_pause(log_dir: str) -> bool:
+    """Check if dashboard sent a pause signal."""
+    return os.path.exists(os.path.join(log_dir, "PAUSE"))
+
+
+def resolve_ntfy_url(explicit_url: str, topic: str) -> Optional[str]:
+    if explicit_url:
+        return explicit_url
+    if not topic:
+        return None
+    if topic.startswith("http://") or topic.startswith("https://"):
+        return topic
+    topic_name = topic.lstrip("/")
+    return f"https://ntfy.sh/{topic_name}"
+
+
+def send_ntfy_message(
+    url: str,
+    body: str,
+    title: str,
+    priority: str = "3",
+    tags: str = "",
+    token: str = "",
+    click: str = "",
+    timeout_s: float = 10.0,
+) -> tuple[bool, str]:
+    if not url:
+        return False, "no_ntfy_url"
+
+    headers = {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Title": title[:200],
+        "Priority": str(priority),
+    }
+    if tags:
+        headers["Tags"] = tags
+    if click:
+        headers["Click"] = click
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    req = urllib.request.Request(
+        url=url,
+        data=body.encode("utf-8"),
+        headers=headers,
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout_s) as resp:
+            if 200 <= int(getattr(resp, "status", 200)) < 300:
+                return True, f"http_{int(getattr(resp, 'status', 200))}"
+            return False, f"http_{int(getattr(resp, 'status', 0))}"
+    except urllib.error.HTTPError as exc:
+        return False, f"http_{exc.code}"
+    except Exception as exc:
+        return False, str(exc)
+
+
+# ═══════════════════════════════════════════════════════════════
+# Training Loop
+# ═══════════════════════════════════════════════════════════════
+
+def train(model_config: NewtieConfig = None,
+          train_config: TrainingConfig = None,
+          data_paths: List[str] = None,
+          resume_from: str = None,
+          resume_weights_only: bool = False,
+          num_devices: int = 0,
+          log_dir: str = "/data/newtie_v5/logs",
+          checkpoint_dir: str = "/data/newtie_v5/checkpoints"):
+    """Main training function — 8-chip Pipeline Parallel via TT-Metalium.
+    
+    Pipeline: 8 stages (4 layers/chip), 64 micro-batches, 89% efficiency.
+    Falls back to PyTorch sequential if ttnn unavailable.
+    """
+
+    if model_config is None or train_config is None:
+        model_config, train_config = get_phase1_config()
+
+    train_config = apply_power_mode_overrides(train_config)
+
+    # Override output dirs from CLI
+    train_config.output_dir = checkpoint_dir
+    os.makedirs(log_dir, exist_ok=True)
+    os.makedirs(checkpoint_dir, exist_ok=True)
+
+    # ── Hardware detection ──
+    hw_type, compute_device, tt_chip_count = detect_hardware()
+
+    # ── Default data paths ──
+    if data_paths is None:
+        phase_dir = default_phase_data_dir(train_config.phase)
+        if phase_dir is not None:
+            data_paths = glob.glob(os.path.join(phase_dir, "*.jsonl"))
+            print(f"  [DATA] Using phase data dir: {phase_dir}")
+        # Check Docker data directory first
+        if data_paths is None:
+            docker_data = "/data/newtie_v5/training_data"
+            if os.path.isdir(docker_data) and any(
+                    f.endswith('.jsonl') for f in os.listdir(docker_data)):
+                data_paths = glob.glob(os.path.join(docker_data, "*.jsonl"))
+                print(f"  [DATA] Using Docker data dir: {docker_data}")
+            else:
+                # Local development paths
+                base = "/Volumes/ADi/Ultimate_research"
+                data_paths = [
+                f"{base}/data/training/sft_cognitive_depth.jsonl",
+                f"{base}/data/training/sft_pairs_20260205_125455.jsonl",
+                f"{base}/data/training/sft_pairs_20260205_125230.jsonl",
+                f"{base}/data/training/sft_swedish_personality.jsonl",
+                f"{base}/adi_core_newtie/deep_synthesis/deep_reasoning_chain_patterns.jsonl",
+                f"{base}/adi_core_newtie/deep_synthesis/deep_analogy_patterns.jsonl",
+                f"{base}/adi_core_newtie/deep_synthesis/deep_synthesis_patterns.jsonl",
+                f"{base}/adi_core_newtie/deep_synthesis/deep_meta_patterns.jsonl",
+                f"{base}/adi_core_newtie/deep_synthesis/deep_calibration_patterns.jsonl",
+                f"{base}/data/sala_sft/biomodules.jsonl",
+                f"{base}/data/sala_sft/verified_search.jsonl",
+            ]
+                # Also load waveflow2 SFT data
+                wf2_sft = glob.glob(f"{base}/waveflow2_newton_model/data/training/sft_*.jsonl")
+                data_paths.extend(wf2_sft)
+                # ADi training data
+                data_paths.append("/Volumes/ADi/The Concern/ADi/adi_training/train_data/cognitive_scenarios.jsonl")
+                # include introspective self‑explanations if available
+                introspect_path = "/Volumes/ADi/The Concern/ADi/introspect_sft.jsonl"
+                if os.path.exists(introspect_path):
+                    print(f"  [DATA] including introspection log: {introspect_path}")
+                    data_paths.append(introspect_path)
+
+    # ── Tokenizer ──
+    try:
+        import sentencepiece as spm
+        tokenizer = spm.SentencePieceProcessor()
+        tokenizer.load(train_config.data_dir + "/tokenizer.model")
+        print("[TOKENIZER] SentencePiece loaded")
+    except Exception:
+        tokenizer = ByteFallbackTokenizer(model_config.vocab_size)
+        print("[TOKENIZER] Byte-level fallback (no sentencepiece)")
+
+    # ── Dataset & DataLoader ──
+    dataset = CognitiveSFTDataset(
+        data_paths=data_paths,
+        tokenizer=tokenizer,
+        seq_len=train_config.seq_len,
+        cache_tokens=_pretoken_cache_enabled,
+        cache_size=_pretoken_cache_size,
+    )
+
+    _dataloader_workers = _tt_dataloader_workers
+    if _CPU_ONLY:
+        _dataloader_workers = max(1, _dataloader_workers)
+
+    dataloader = DataLoader(
+        dataset,
+        batch_size=train_config.batch_size,
+        shuffle=True,
+        drop_last=True,
+        num_workers=_dataloader_workers,
+        pin_memory=(hw_type == "cuda"),
+        prefetch_factor=(_tt_dataloader_prefetch if _dataloader_workers > 0 else None),
+        persistent_workers=(_tt_dataloader_persist_workers if _dataloader_workers > 0 else False),
+    )
+
+    print(
+        f"[DL] workers={_dataloader_workers}, "
+        f"prefetch={_tt_dataloader_prefetch}, "
+        f"persist_workers={_tt_dataloader_persist_workers if _dataloader_workers > 0 else False}"
+    )
+
+    # Adaptive mesh planner report (observability only).
+    if report_tt_adaptive_mesh_plan is not None:
+        report_tt_adaptive_mesh_plan(model_config, train_config)
+
+    # Keep TT active-graph runtime aligned with the actual phase unless the
+    # caller explicitly overrides it via environment.
+    os.environ.setdefault(
+        "NEWTIE_TT_ACTIVE_GRAPH_PHASE",
+        active_graph_phase_name_for(train_config),
+    )
+
+    # ── Model ──
+    print(f"\n[MODEL] Initializing Newtie V5...")
+    model = NewtieV5(model_config)
+
+    # Count parameters
+    counts = model.count_parameters()
+    total = counts["TOTAL_unique"]
+    active = model.estimate_active_params()
+    print(f"  Total params:  {total:,} ({total/1e6:.1f}M)")
+    print(f"  Active/token:  {active:,} ({active/1e6:.1f}M, {active/total*100:.1f}%)")
+    print(f"  BF16 size:     {total * 2 / 1e9:.2f} GB")
+
+    # ── Device placement ──
+    if hw_type == "n300":
+        # N300: model params stay on CPU (for optimizer), compute goes to chips
+        # DO NOT call model.to(device) — there is no torch device for TT
+        print(f"[DEVICE] Model params on CPU (for AdamW), compute → Wormhole chips")
+    elif hw_type == "cuda":
+        model = model.to(compute_device)
+        if train_config.mixed_precision == "bf16":
+            model = model.to(torch.bfloat16)
+    else:
+        model = model.to(compute_device)
+
+    # ── Gradient checkpointing (critical for SSM memory) ──
+    if train_config.gradient_checkpointing:
+        model.gradient_checkpointing = True
+        print(f"[MEMORY] Gradient checkpointing ENABLED — saves ~98% activation memory")
+    else:
+        print(f"[MEMORY] WARNING: Gradient checkpointing DISABLED — may OOM!")
+
+    # ── Pipeline Engine (8-chip Metalium) ──
+    hw_config = build_hw_config_for_run(
+        model_config=model_config,
+        hw_type=hw_type,
+        tt_chip_count=tt_chip_count,
+        num_devices=num_devices,
+    )
+    pipeline_engine, device_mesh = create_pipeline(model, model_config, hw_config)
+    n_stages = hw_config.stages if device_mesh.ttnn_available else 1
+
+    # ── Accelerate: replace nn.Linear → TTLinear (matmul on Wormhole chips) ──
+    if _CPU_ONLY:
+        print(f"[MODE] CPU-only enabled — TT acceleration disabled")
+    elif hw_type == "n300" and device_mesh.ttnn_available:
+        if accelerate_model is None:
+            print("[TT-OPS] ERROR: TT ops unavailable (import failed) — cannot use chips")
+        else:
+            n_accelerated = accelerate_model(model, device_mesh, model_config)
+            if n_accelerated == 0:
+                print("[TT-OPS] WARNING: No layers accelerated — check device mesh")
+            else:
+                print(f"[TT-OPS] {n_accelerated} Linear layers now execute on Wormhole chips")
+                print(f"  CPU RAM: ~{total * 2 * 4 / 1e9:.1f} GB (params + optimizer + grads)")
+                print(f"  TT VRAM: 96 GB total across 8 chips")
+
+    # ── Optimizer: dual LR (backbone + bio-modules) ──
+    backbone_params = []
+    bio_params = []
+    for name, param in model.named_parameters():
+        if not param.requires_grad:
+            continue
+        if "bio" in name or "stdp" in name or "synaplexa" in name or \
+           "cerebrix" in name or "dendroplast" in name or "metabolism" in name or \
+           "spike" in name or "lif" in name or "wta" in name:
+            bio_params.append(param)
+        else:
+            backbone_params.append(param)
+
+    optimizer = torch.optim.AdamW([
+        {"params": backbone_params, "lr": train_config.lr},
+        {"params": bio_params, "lr": train_config.bio_lr},
+    ], weight_decay=train_config.weight_decay,
+       betas=(train_config.beta1, train_config.beta2))
+
+    print(f"\n[OPTIMIZER] AdamW (dual LR)")
+    print(f"  Backbone: {len(backbone_params)} tensors, lr={train_config.lr}")
+    print(f"  Bio-modules: {len(bio_params)} tensors, lr={train_config.bio_lr}")
+
+    # ── Resume ──
+    start_step = 0
+    resume_loss_for_watchdog: Optional[float] = None
+    if resume_from and os.path.exists(resume_from):
+        checkpoint = torch.load(resume_from, map_location=compute_device)
+        ckpt_loss = checkpoint.get("loss")
+        if isinstance(ckpt_loss, (int, float)):
+            resume_loss_for_watchdog = float(ckpt_loss)
+        if resume_weights_only:
+            resume_state = adapt_resume_state_dict_for_current_model(checkpoint["model_state_dict"])
+            missing, unexpected = model.load_state_dict(resume_state, strict=False)
+            print(f"[RESUME] Loaded weights only from {resume_from}")
+            print("[RESUME] Optimizer state reset for new phase / fresh step schedule")
+            print(f"[RESUME] Compatible load: missing={len(missing)} unexpected={len(unexpected)}")
+            if missing:
+                print(f"[RESUME] Missing sample: {missing[:6]}")
+            if unexpected:
+                print(f"[RESUME] Unexpected sample: {unexpected[:6]}")
+        else:
+            model.load_state_dict(checkpoint["model_state_dict"])
+            optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
+            start_step = checkpoint.get("step", 0)
+            print(f"[RESUME] From step {start_step}")
+
+    # ── Training ──
+    model.train()
+    grad_accum = train_config.gradient_accumulation_steps
+
+    print(f"\n{'═'*60}")
+    print(f"  TRAINING PHASE {train_config.phase}: {train_config.phase_name}")
+    print(f"  Steps: {train_config.total_steps}")
+    print(f"  Tokens/step: {train_config.tokens_per_step:,}")
+    print(f"  Total tokens: {train_config.total_steps * train_config.tokens_per_step / 1e6:.0f}M")
+    print(f"  Device: {hw_type}")
+    print(f"  Pipeline: {n_stages} stages × {hw_config.layers_per_stage} layers/chip")
+    print(f"  Pipeline efficiency: {hw_config.pipeline_efficiency*100:.1f}%")
+    print(f"  Micro-batch: {train_config.batch_size} × {hw_config.n_micro_batches} = {train_config.batch_size * hw_config.n_micro_batches} effective")
+    print(f"  Dashboard: {log_dir}")
+    print(f"  Checkpoints: {checkpoint_dir}")
+    print(f"{'═'*60}\n")
+
+    global_step = start_step
+    running_loss = 0.0
+    best_loss = float('inf')
+    tokens_processed = 0
+    train_start = time.time()
+    watchdog_enabled = _WATCHDOG_ENABLED and _WATCHDOG_INTERVAL > 0
+    watchdog_ntfy_url = resolve_ntfy_url(_NTFY_URL, _NTFY_TOPIC)
+    watchdog_best_loss = (
+        float(resume_loss_for_watchdog)
+        if resume_loss_for_watchdog is not None
+        else float("inf")
+    )
+    watchdog_last_report_quality: Optional[float] = None
+    watchdog_last_report_loss: Optional[float] = None
+    watchdog_last_report_step = 0
+    watchdog_last_improvement_step = 0
+    watchdog_ntfy_sent = 0
+    watchdog_ntfy_fail = 0
+    watchdog_quality = 0.0
+    if watchdog_enabled:
+        if watchdog_ntfy_url:
+            print(f"[WATCHDOG] interval={_WATCHDOG_INTERVAL} steps, ntfy={watchdog_ntfy_url}")
+        else:
+            print(
+                "[WATCHDOG] interval active but NTFY target missing "
+                "(set NEWTIE_NTFY_TOPIC or NEWTIE_NTFY_URL)"
+            )
+
+    data_iter = iter(dataloader)
+    import sys  # for flush
+    print(f"[DEBUG] Entering training loop at {time.strftime('%H:%M:%S')}", flush=True)
+
+    while global_step < train_config.total_steps:
+        step_t0 = time.time()
+        optimizer.zero_grad()
+        step_loss = 0.0
+        if begin_tt_runtime_step is not None:
+            begin_tt_runtime_step()
+
+        for micro_step in range(grad_accum):
+            try:
+                batch = next(data_iter)
+            except StopIteration:
+                data_iter = iter(dataloader)
+                batch = next(data_iter)
+
+            # For N300: tensors stay on CPU, TTLinear dispatches matmul to chips
+            # For CUDA: tensors move to GPU
+            if compute_device is not None:
+                input_ids = batch["input_ids"].to(compute_device)
+                labels = batch["labels"].to(compute_device)
+                byte_ids = batch.get("byte_ids")
+                if byte_ids is not None:
+                    byte_ids = byte_ids.to(compute_device)
+            else:
+                input_ids = batch["input_ids"]
+                labels = batch["labels"]
+                byte_ids = batch.get("byte_ids")
+
+            # Forward timing
+            fwd_t0 = time.time()
+            if _CPU_ONLY:
+                # CPU bf16 autocast: EPYC 9254 has AVX-512-BF16 for ~2× throughput
+                with torch.autocast(device_type="cpu", dtype=torch.bfloat16):
+                    output = model(input_ids, byte_ids=byte_ids, labels=labels,
+                                   return_gates=(global_step % train_config.log_interval == 0))
+            elif train_config.mixed_precision == "bf16" and hw_type == "cuda":
+                with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+                    output = model(input_ids, byte_ids=byte_ids, labels=labels,
+                                   return_gates=(global_step % train_config.log_interval == 0))
+            else:
+                output = model(input_ids, byte_ids=byte_ids, labels=labels,
+                               return_gates=(global_step % train_config.log_interval == 0))
+            fwd_elapsed = time.time() - fwd_t0
+
+            loss = output.loss / grad_accum
+
+            # NaN detection
+            if torch.isnan(loss) or torch.isinf(loss):
+                print(f"[NaN] step={global_step} micro={micro_step} loss={loss.item()}", flush=True)
+                print(f"[NaN] logits range: {output.logits.min().item():.4f} to {output.logits.max().item():.4f}", flush=True)
+                print(f"[NaN] logits has NaN: {torch.isnan(output.logits).any().item()}", flush=True)
+                print(f"[NaN] logits has Inf: {torch.isinf(output.logits).any().item()}", flush=True)
+                if hasattr(output, 'gate_dict') and output.gate_dict:
+                    for k, v in output.gate_dict.items():
+                        if isinstance(v, torch.Tensor):
+                            if torch.isnan(v).any() or torch.isinf(v).any():
+                                print(f"[NaN] gate {k} has NaN/Inf: min={v.min().item():.4f} max={v.max().item():.4f}", flush=True)
+                # Check input for NaN
+                print(f"[NaN] input range: {input_ids.min().item()} to {input_ids.max().item()}", flush=True)
+                # Check parameters for NaN
+                nan_params = sum(1 for n, p in model.named_parameters() if torch.isnan(p).any())
+                inf_params = sum(1 for n, p in model.named_parameters() if torch.isinf(p).any())
+                print(f"[NaN] params with NaN: {nan_params}, with Inf: {inf_params}", flush=True)
+                if nan_params > 0:
+                    for n, p in model.named_parameters():
+                        if torch.isnan(p).any():
+                            print(f"[NaN]   param {n}: {torch.isnan(p).sum().item()} NaN values", flush=True)
+
+            # Backward timing
+            bwd_t0 = time.time()
+            if torch.isnan(loss) or torch.isinf(loss):
+                print(f"[SKIP-BWD] Skipping backward for NaN/inf loss at step={global_step}", flush=True)
+                # Zero out any partial gradients
+                optimizer.zero_grad()
+                bwd_elapsed = 0.0
+            else:
+                loss.backward()
+                bwd_elapsed = time.time() - bwd_t0
+                
+                # Check gradients for NaN/Inf after backward
+                if global_step < 20:
+                    nan_grads = []
+                    inf_grads = []
+                    max_grad = 0.0
+                    for n, p in model.named_parameters():
+                        if p.grad is not None:
+                            if torch.isnan(p.grad).any():
+                                nan_grads.append(n)
+                            if torch.isinf(p.grad).any():
+                                inf_grads.append(n)
+                            gmax = p.grad.abs().max().item()
+                            if gmax > max_grad:
+                                max_grad = gmax
+                    if nan_grads:
+                        print(f"[GRAD-NaN] {len(nan_grads)} params have NaN grads: {nan_grads[:5]}", flush=True)
+                    if inf_grads:
+                        print(f"[GRAD-Inf] {len(inf_grads)} params have Inf grads: {inf_grads[:5]}", flush=True)
+                    print(f"[GRAD] max_grad_abs={max_grad:.4f}", flush=True)
+
+            step_loss += loss.item()
+            tokens_processed += input_ids.numel()
+
+            # Debug: log EVERY micro-step for first 20 steps
+            if global_step < 20:
+                print(f"[DEBUG] step={global_step} micro={micro_step} "
+                      f"fwd={fwd_elapsed:.1f}s bwd={bwd_elapsed:.1f}s "
+                      f"loss={loss.item()*grad_accum:.4f} "
+                      f"shape={list(input_ids.shape)}", flush=True)
+
+        # Gradient clipping
+        torch.nn.utils.clip_grad_norm_(
+            model.parameters(), train_config.max_grad_norm)
+
+        # LR schedule
+        lr = get_wsd_lr(global_step, train_config)
+        for pg in optimizer.param_groups:
+            if pg is optimizer.param_groups[0]:
+                pg['lr'] = lr
+            else:
+                pg['lr'] = lr * (train_config.bio_lr / train_config.lr)
+
+        optimizer.step()
+
+        # Re-sync TTLinear cached weights to TT devices after optimizer update
+        if (not _CPU_ONLY) and (mark_tt_dirty is not None) and (sync_tt_weights is not None):
+            mark_tt_dirty(model)
+            sync_tt_weights(model)
+
+        global_step += 1
+        running_loss += step_loss
+        step_elapsed = time.time() - step_t0
+        elapsed = time.time() - train_start
+        watchdog_best_loss = min(float(watchdog_best_loss), float(step_loss))
+        watchdog_quality = 0.0
+        if math.isfinite(watchdog_best_loss):
+            # Monotonic quality proxy: lower best loss -> higher score in (0, 1].
+            watchdog_quality = 1.0 / (1.0 + max(watchdog_best_loss, 0.0))
+        best_loss_for_status = min(float(best_loss), float(step_loss))
+        steps_per_sec = global_step / max(elapsed, 1e-6)
+        estimated_remaining_s = int(
+            (train_config.total_steps - global_step) / max(steps_per_sec, 0.01)
+        )
+
+        if watchdog_enabled and global_step % _WATCHDOG_INTERVAL == 0:
+            watchdog_last_report_step = global_step
+            if watchdog_last_report_quality is None:
+                watchdog_last_report_quality = watchdog_quality
+                watchdog_last_report_loss = watchdog_best_loss
+                print(
+                    f"[WATCHDOG] baseline step={global_step} "
+                    f"quality={watchdog_quality:.6f} best_loss={watchdog_best_loss:.6f}"
+                )
+            else:
+                quality_delta = watchdog_quality - watchdog_last_report_quality
+                if quality_delta > _WATCHDOG_MIN_DELTA:
+                    prev_quality = watchdog_last_report_quality
+                    prev_loss = (
+                        watchdog_last_report_loss
+                        if watchdog_last_report_loss is not None
+                        else float("nan")
+                    )
+                    watchdog_last_report_quality = watchdog_quality
+                    watchdog_last_report_loss = watchdog_best_loss
+                    watchdog_last_improvement_step = global_step
+                    print(
+                        f"[WATCHDOG] IMPROVED step={global_step} "
+                        f"quality {prev_quality:.6f} -> {watchdog_quality:.6f} "
+                        f"(delta={quality_delta:.6f}) "
+                        f"best_loss {prev_loss:.6f} -> {watchdog_best_loss:.6f}"
+                    )
+                    if watchdog_ntfy_url:
+                        title = f"Newtie quality improved p{train_config.phase} s{global_step}"
+                        body = (
+                            f"Phase: {train_config.phase} ({train_config.phase_name})\n"
+                            f"Step: {global_step}/{train_config.total_steps}\n"
+                            f"Quality: {prev_quality:.6f} -> {watchdog_quality:.6f} "
+                            f"(+{quality_delta:.6f})\n"
+                            f"Best loss: {prev_loss:.6f} -> {watchdog_best_loss:.6f}\n"
+                            f"LR: {lr:.3e}\n"
+                            f"Elapsed: {int(elapsed)}s"
+                        )
+                        ok, detail = send_ntfy_message(
+                            url=watchdog_ntfy_url,
+                            body=body,
+                            title=title,
+                            priority=_NTFY_PRIORITY,
+                            tags=_NTFY_TAGS,
+                            token=_NTFY_TOKEN,
+                            click=_NTFY_CLICK,
+                            timeout_s=_NTFY_TIMEOUT_S,
+                        )
+                        if ok:
+                            watchdog_ntfy_sent += 1
+                            print(f"[WATCHDOG] NTFY sent ({detail})")
+                        else:
+                            watchdog_ntfy_fail += 1
+                            print(f"[WATCHDOG] NTFY failed ({detail})")
+
+        write_status(log_dir, {
+            "state": "training",
+            "phase": train_config.phase,
+            "phase_name": train_config.phase_name,
+            "step": global_step,
+            "total_steps": train_config.total_steps,
+            "progress_pct": round(global_step / train_config.total_steps * 100, 1),
+            "loss": round(step_loss, 6),
+            "best_loss": round(best_loss_for_status, 6),
+            "lr": lr,
+            "tps": round(tokens_processed / max(elapsed, 1e-6), 1),
+            "tokens_seen": tokens_processed,
+            "elapsed_seconds": int(elapsed),
+            "hw_type": hw_type,
+            "pipeline_stages": n_stages,
+            "pipeline_efficiency": round(hw_config.pipeline_efficiency * 100, 1),
+            "estimated_remaining_s": estimated_remaining_s,
+            "watchdog_enabled": watchdog_enabled,
+            "watchdog_interval": _WATCHDOG_INTERVAL,
+            "watchdog_quality": round(watchdog_quality, 8),
+            "watchdog_best_loss": (
+                round(watchdog_best_loss, 8) if math.isfinite(watchdog_best_loss) else None
+            ),
+            "watchdog_last_report_step": watchdog_last_report_step,
+            "watchdog_last_improvement_step": watchdog_last_improvement_step,
+            "watchdog_ntfy_sent": watchdog_ntfy_sent,
+            "watchdog_ntfy_fail": watchdog_ntfy_fail,
+        })
+
+        # Debug: total step time for first 20 steps
+        if global_step <= 20:
+            # Report TT backward stats
+            try:
+                from model.tt_ops import _bwd_tt_ok, _bwd_tt_fail, _bwd_cpu
+                bwd_stats = f" tt_bwd={_bwd_tt_ok} cpu_bwd={_bwd_cpu} fail={_bwd_tt_fail}"
+            except ImportError:
+                bwd_stats = ""
+            print(f"[DEBUG] Step {global_step} DONE in {step_elapsed:.1f}s "
+                  f"(loss={step_loss:.4f}){bwd_stats}", flush=True)
+
+        # ── Logging ──
+        if global_step % train_config.log_interval == 0:
+            tps = tokens_processed / elapsed
+            avg_loss = running_loss / train_config.log_interval
+            running_loss = 0.0
+
+            # MoE expert usage logging
+            moe_aux_val = 0.0
+            if hasattr(output, 'aux_loss') and output.aux_loss is not None:
+                moe_aux_val = output.aux_loss.item()
+            moe_balance_str = ""
+            if train_config.log_moe_usage:
+                expert_counts_all = []
+                for layer in model.layers:
+                    counts = getattr(layer, '_last_expert_counts', None)
+                    if counts is not None:
+                        expert_counts_all.append(counts)
+                if expert_counts_all:
+                    total_counts = torch.stack(expert_counts_all).sum(0)  # [n_experts]
+                    total_tokens = total_counts.sum().item()
+                    if total_tokens > 0:
+                        usage_pct = (total_counts / total_tokens * 100)
+                        top3 = usage_pct.topk(3)
+                        bot3_vals, bot3_idx = usage_pct.topk(3, largest=False)
+                        balance = 1.0 - (usage_pct.std() / usage_pct.mean()).item()  # 1.0 = perfect
+                        moe_balance_str = f" moe_bal={balance:.3f}"
+
+            print(f"[STEP {global_step:>5d}/{train_config.total_steps}] "
+                  f"loss={avg_loss:.4f} lr={lr:.2e} "
+                  f"tps={tps:.0f} "
+                  f"aux={moe_aux_val:.4f}{moe_balance_str} "
+                  f"elapsed={elapsed:.0f}s", flush=True)
+
+            # Detailed MoE usage every log interval
+            if train_config.log_moe_usage and expert_counts_all:
+                print(f"  [MOE] experts={len(total_counts)} active={int((total_counts > 0).sum())} "
+                      f"top3=[{int(top3.indices[0])}:{top3.values[0]:.1f}% "
+                      f"{int(top3.indices[1])}:{top3.values[1]:.1f}% "
+                      f"{int(top3.indices[2])}:{top3.values[2]:.1f}%] "
+                      f"bot3=[{int(bot3_idx[0])}:{bot3_vals[0]:.1f}% "
+                      f"{int(bot3_idx[1])}:{bot3_vals[1]:.1f}% "
+                      f"{int(bot3_idx[2])}:{bot3_vals[2]:.1f}%]", flush=True)
+
+            # Log bio-gate values
+            if train_config.log_bio_gates and output.gate_dict:
+                skip_keys = {"quality", "confidence_base", "energy",
+                             "spike_stdp_info", "spike_hierarchy_info"}
+                gate_str = " ".join(
+                    f"{k}={v.mean().item():.3f}"
+                    for k, v in output.gate_dict.items()
+                    if isinstance(v, torch.Tensor) and v.shape[-1] == 1
+                    and k not in skip_keys
+                )
+                print(f"  [GATES] {gate_str}", flush=True)
+
+                # Log spike dynamics — this is how you SEE the SHAN working
+                sh_info = output.gate_dict.get("spike_hierarchy_info")
+                if isinstance(sh_info, dict):
+                    rates = {k: (v.item() if isinstance(v, torch.Tensor) else v)
+                             for k, v in sh_info.items()}
+                    print(f"  [SPIKE] word={rates.get('spike_rate_word',0):.4f} "
+                          f"sent={rates.get('spike_rate_sentence',0):.4f} "
+                          f"para={rates.get('spike_rate_paragraph',0):.4f}", flush=True)
+
+                ss_info = output.gate_dict.get("spike_stdp_info")
+                if isinstance(ss_info, dict):
+                    rates = {k: (v.item() if isinstance(v, torch.Tensor) else v)
+                             for k, v in ss_info.items()}
+                    print(f"  [STDP-SPIKE] pre={rates.get('pre_spike_rate',0):.4f} "
+                          f"post={rates.get('post_spike_rate',0):.4f}", flush=True)
+
+                # Write gates for dashboard
+                write_bio_gates(log_dir, output.gate_dict)
+
+            if output.energy is not None:
+                avg_energy = output.energy.mean().item()
+                print(f"  [ENERGY] avg={avg_energy:.3f}", flush=True)
+
+        # ── Pause check (from dashboard) ──
+        if check_pause(log_dir):
+            print(f"  [PAUSE] Dashboard pause signal received. Waiting...")
+            while check_pause(log_dir):
+                time.sleep(5)
+            print(f"  [RESUME] Continuing training.")
+
+        # ── Save checkpoint ──
+        if global_step % train_config.save_interval == 0:
+            save_path = os.path.join(
+                checkpoint_dir,
+                f"newtie_v5_p{train_config.phase}_step{global_step}.pt")
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+
+            torch.save({
+                "step": global_step,
+                "model_state_dict": model.state_dict(),
+                "optimizer_state_dict": optimizer.state_dict(),
+                "config": asdict(model_config) if hasattr(model_config, '__dataclass_fields__') else vars(model_config),
+                "train_config": asdict(train_config) if hasattr(train_config, '__dataclass_fields__') else vars(train_config),
+                "loss": step_loss,
+                "tokens": tokens_processed,
+            }, save_path)
+            print(f"  [SAVE] {save_path}")
+
+            if step_loss < best_loss:
+                best_loss = step_loss
+                best_path = os.path.join(
+                    checkpoint_dir, "newtie_v5_best.pt")
+                torch.save({
+                    "step": global_step,
+                    "model_state_dict": model.state_dict(),
+                    "config": asdict(model_config) if hasattr(model_config, '__dataclass_fields__') else vars(model_config),
+                    "loss": best_loss,
+                }, best_path)
+                print(f"  [BEST] {best_path} (loss={best_loss:.4f})")
+
+    # ── Final save ──
+    total_time = time.time() - train_start
+
+    # Cleanup device mesh
+    if device_mesh:
+        device_mesh.close()
+
+    print(f"\n{'═'*60}")
+    print(f"  TRAINING COMPLETE")
+    print(f"  Phase: {train_config.phase_name}")
+    print(f"  Steps: {global_step}")
+    print(f"  Tokens: {tokens_processed:,}")
+    print(f"  Time: {total_time/3600:.1f}h")
+    print(f"  Final loss: {step_loss:.4f}")
+    print(f"  Best loss: {best_loss:.4f}")
+    print(f"  Pipeline: {n_stages} stages × {hw_config.layers_per_stage} layers/chip")
+    print(f"{'═'*60}")
+
+    # Write final status for dashboard
+    write_status(log_dir, {
+        "state": "completed",
+        "phase": train_config.phase,
+        "phase_name": train_config.phase_name,
+        "step": global_step,
+        "total_steps": train_config.total_steps,
+        "progress_pct": 100.0,
+        "loss": round(step_loss, 6),
+        "best_loss": round(best_loss, 6),
+        "tokens_seen": tokens_processed,
+        "elapsed_seconds": int(total_time),
+        "hw_type": hw_type,
+        "pipeline_stages": n_stages,
+        "pipeline_efficiency": round(hw_config.pipeline_efficiency * 100, 1),
+        "watchdog_enabled": watchdog_enabled,
+        "watchdog_interval": _WATCHDOG_INTERVAL,
+        "watchdog_quality": round(watchdog_quality, 8),
+        "watchdog_best_loss": (
+            round(watchdog_best_loss, 8) if math.isfinite(watchdog_best_loss) else None
+        ),
+        "watchdog_last_report_step": watchdog_last_report_step,
+        "watchdog_last_improvement_step": watchdog_last_improvement_step,
+        "watchdog_ntfy_sent": watchdog_ntfy_sent,
+        "watchdog_ntfy_fail": watchdog_ntfy_fail,
+    })
+
+    return model
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Newtie V5 Training (4× N300S)")
+    parser.add_argument("--max-steps", type=int, default=0,
+                        help="Optional hard cap on steps for smoke/verification runs (0 = full phase)")
+    parser.add_argument("--data-dir", type=str, default="/data/newtie_v5/training_data",
+                        help="Directory containing .jsonl training files")
+    parser.add_argument("--checkpoint-dir", type=str, default="/data/newtie_v5/checkpoints",
+                        help="Directory for saving checkpoints")
+    parser.add_argument("--log-dir", type=str, default="/data/newtie_v5/logs",
+                        help="Directory for dashboard status files")
+    parser.add_argument("--num-devices", type=int, default=0,
+                        help="Number of N300S cards (0 = auto-detect)")
+    parser.add_argument("--resume", type=str, default=None,
+                        help="Path to checkpoint to resume from")
+    parser.add_argument("--resume-weights-only", action="store_true",
+                        help="Load model weights from --resume but reset optimizer and step count")
+    parser.add_argument("--phase", type=int, choices=[1, 2, 3, 4, 5, 6, 7, 8, 9], default=1,
+                        help="Training phase (1=cognitive, 2=tool, 3=self, 4=consciousness, 5=instruct, 6=memory_tool, 7=grounded_agency, 8=reasoning_agency, 9=instruction_response)")
+    parser.add_argument("--cpu-only", action="store_true",
+                        help="Force CPU-only (disable Wormhole TT acceleration)")
+    parser.add_argument("--watchdog-interval", type=int, default=None,
+                        help="Quality watchdog cadence in steps (default: env NEWTIE_WATCHDOG_INTERVAL or 25)")
+    parser.add_argument("--watchdog-min-delta", type=float, default=None,
+                        help="Minimum quality delta to count as improvement (default: env NEWTIE_WATCHDOG_MIN_DELTA)")
+    parser.add_argument("--disable-watchdog", action="store_true",
+                        help="Disable quality watchdog notifications")
+    parser.add_argument("--ntfy-topic", type=str, default=None,
+                        help="NTFY topic name (e.g. my-newtie-topic)")
+    parser.add_argument("--ntfy-url", type=str, default=None,
+                        help="Full NTFY publish URL (overrides --ntfy-topic)")
+    parser.add_argument("--ntfy-token", type=str, default=None,
+                        help="NTFY bearer token (optional)")
+    parser.add_argument("--ntfy-priority", type=str, default=None,
+                        help="NTFY priority header (1-5)")
+    parser.add_argument("--ntfy-tags", type=str, default=None,
+                        help="NTFY tags header (comma-separated)")
+    parser.add_argument("--ntfy-click", type=str, default=None,
+                        help="NTFY click URL")
+    args = parser.parse_args()
+
+    # Apply CPU-only override early (before training starts)
+    if args.cpu_only:
+        os.environ["NEWTIE_CPU_ONLY"] = "1"
+        _CPU_ONLY = True
+
+    # Apply watchdog / NTFY CLI overrides
+    if args.disable_watchdog:
+        _WATCHDOG_ENABLED = False
+    if args.watchdog_interval is not None:
+        _WATCHDOG_INTERVAL = max(1, int(args.watchdog_interval))
+    if args.watchdog_min_delta is not None:
+        _WATCHDOG_MIN_DELTA = max(0.0, float(args.watchdog_min_delta))
+    if args.ntfy_topic is not None:
+        _NTFY_TOPIC = args.ntfy_topic.strip()
+    if args.ntfy_url is not None:
+        _NTFY_URL = args.ntfy_url.strip()
+    if args.ntfy_token is not None:
+        _NTFY_TOKEN = args.ntfy_token.strip()
+    if args.ntfy_priority is not None:
+        _NTFY_PRIORITY = args.ntfy_priority.strip()
+    if args.ntfy_tags is not None:
+        _NTFY_TAGS = args.ntfy_tags.strip()
+    if args.ntfy_click is not None:
+        _NTFY_CLICK = args.ntfy_click.strip()
+
+    # Collect data paths from data-dir
+    data_paths = None
+    if os.path.isdir(args.data_dir):
+        found = glob.glob(os.path.join(args.data_dir, "*.jsonl"))
+        if found:
+            data_paths = found
+            print(f"[DATA] Found {len(found)} JSONL files in {args.data_dir}")
+
+    if args.phase == 1:
+        model_config, train_config = get_phase1_config()
+    elif args.phase == 2:
+        model_config, train_config = get_phase2_config()
+    elif args.phase == 3:
+        model_config, train_config = get_phase3_config()
+    elif args.phase == 4:
+        model_config, train_config = get_phase4_config()
+    elif args.phase == 5:
+        model_config, train_config = get_phase5_config()
+    elif args.phase == 6:
+        model_config, train_config = get_phase6_config()
+    elif args.phase == 7:
+        model_config, train_config = get_phase7_config()
+    elif args.phase == 8:
+        model_config, train_config = get_phase8_config()
+    else:
+        model_config, train_config = get_phase9_config()
+
+    if args.max_steps and args.max_steps > 0:
+        requested_steps = int(args.max_steps)
+        if requested_steps < train_config.total_steps:
+            print(f"[CONFIG] --max-steps applied: {train_config.total_steps} -> {requested_steps}")
+            train_config.total_steps = requested_steps
+
+    train(
+        model_config=model_config,
+        train_config=train_config,
+        data_paths=data_paths,
+        resume_from=args.resume,
+        resume_weights_only=args.resume_weights_only,
+        num_devices=args.num_devices,
+        log_dir=args.log_dir,
+        checkpoint_dir=args.checkpoint_dir,
+    )

backups/20260311_105528/manifest.json

@@ -0,0 +1,15 @@
+{
+  "backup_ts": "2026-03-11T09:55:29Z",
+  "repo": "Eaivee/newtie-tt-checkpoints",
+  "files": {
+    "checkpoints": [
+      "newtie_v5_p9_step50.pt",
+      "newtie_v5_p8_step320.pt",
+      "newtie_v5_p7_step300.pt",
+      "newtie_v5_p6_step1660.pt"
+    ],
+    "config": "train.py",
+    "logs": "logs/koyeb_phase9_watchdog.log"
+  },
+  "note": "Phase 9 watchdog snapshot; latest seen step in logs=320/2600."
+}