tnfr 3.5.0__tar.gz → 4.1.0__tar.gz

{tnfr-3.5.0/src/tnfr.egg-info → tnfr-4.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tnfr
-Version: 3.5.0
+Version: 4.1.0
 Summary: TNFR canónica: dinámica glífica modular sobre redes.
 Author: fmg
 License: MIT
@@ -59,6 +59,8 @@ Dynamic: license-file
 
 * **Network re-mesh.** Mixes the current state with a past one (memory `τ`) to stabilize the network, with clear precedence for `α` and conditions based on recent stability and synchrony history.
 
+* **Γ(R) coupling.** Optional network term added to the nodal equation, parameterized by global phase order `R` with gain `β` and threshold `R0` (see `DEFAULTS["GAMMA"]`).
+
 * **Callbacks & observers.** The `Γ(R)` system lets you hook functions before/after each step and after re-mesh, enabling monitoring or external intervention.
 
 ---
@@ -81,6 +83,9 @@ Dynamic: license-file
 
 **Mastering these pieces will let you extend the simulation, build analysis pipelines and connect the theory with computational applications.**
 
+## Optional Node environment
+The repository includes a minimal `package.json` and `netlify.toml` used for an experimental Remix web demo. They are not required for the core Python package; feel free to ignore them unless you plan to build the demo via `npm run build`.
+
 ## Testing
 
 Install the dependencies and project in editable mode before running the test suite with `pytest`:
@@ -89,4 +94,10 @@ Install the dependencies and project in editable mode before running the test su
 pip install networkx
 pip install -e .
 pytest
+
+```
+
+## Installation
+```
+pip install tnfr
 ```

{tnfr-3.5.0 → tnfr-4.1.0}/README.md

@@ -32,6 +32,8 @@
 
 * **Network re-mesh.** Mixes the current state with a past one (memory `τ`) to stabilize the network, with clear precedence for `α` and conditions based on recent stability and synchrony history.
 
+* **Γ(R) coupling.** Optional network term added to the nodal equation, parameterized by global phase order `R` with gain `β` and threshold `R0` (see `DEFAULTS["GAMMA"]`).
+
 * **Callbacks & observers.** The `Γ(R)` system lets you hook functions before/after each step and after re-mesh, enabling monitoring or external intervention.
 
 ---
@@ -54,6 +56,9 @@
 
 **Mastering these pieces will let you extend the simulation, build analysis pipelines and connect the theory with computational applications.**
 
+## Optional Node environment
+The repository includes a minimal `package.json` and `netlify.toml` used for an experimental Remix web demo. They are not required for the core Python package; feel free to ignore them unless you plan to build the demo via `npm run build`.
+
 ## Testing
 
 Install the dependencies and project in editable mode before running the test suite with `pytest`:
@@ -62,4 +67,10 @@ Install the dependencies and project in editable mode before running the test su
 pip install networkx
 pip install -e .
 pytest
+
+```
+
+## Installation
+```
+pip install tnfr
 ```

{tnfr-3.5.0 → tnfr-4.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tnfr"
-version = "3.5.0"
+version = "4.1.0"
 description = "TNFR canónica: dinámica glífica modular sobre redes."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -28,7 +28,7 @@ classifiers = [
 dependencies = ["networkx>=2.6"]
 
 [project.scripts]
-tnfr = "tnfr.main:main"
+tnfr = "tnfr.cli:main"
 
 [project.urls]
 Homepage = "https://pypi.org/project/tnfr/"
@@ -37,3 +37,5 @@ Repository = "https://github.com/fermga/Teoria-de-la-naturaleza-fractal-resonant
 [build-system]
 requires = ["setuptools>=61", "wheel"]
 build-backend = "setuptools.build_meta"
+
+

tnfr-4.1.0/src/tnfr/__init__.py

@@ -0,0 +1,59 @@
+
+from __future__ import annotations
+"""
+TNFR — Teoría de la Naturaleza Fractal Resonante
+API pública del paquete.
+
+Ecuación nodal:
+    ∂EPI/∂t = νf · ΔNFR(t)
+"""
+
+__version__ = "4.1.0"
+
+# Re-exports de la API pública
+from .dynamics import step, run, set_delta_nfr_hook
+from .ontosim import preparar_red
+from .observers import attach_standard_observer, coherencia_global, orden_kuramoto
+from .gamma import GAMMA_REGISTRY, eval_gamma, kuramoto_R_psi
+from .grammar import enforce_canonical_grammar, on_applied_glifo
+from .sense import (
+    GLYPHS_CANONICAL, glyph_angle, glyph_unit,
+    sigma_vector_node, sigma_vector_global,
+    push_sigma_snapshot, sigma_series, sigma_rose,
+    register_sigma_callback,
+)
+from .metrics import (
+    register_metrics_callbacks,
+    Tg_global, Tg_by_node,
+    latency_series, glifogram_series,
+    glyph_top, glyph_dwell_stats,
+)
+from .trace import register_trace
+from .program import play, seq, block, target, wait, THOL, TARGET, WAIT, ejemplo_canonico_basico
+from .cli import main as cli_main
+from .scenarios import build_graph
+from .presets import get_preset
+from .types import NodeState
+
+
+__all__ = [
+    "preparar_red",
+    "step", "run", "set_delta_nfr_hook",
+
+    "attach_standard_observer", "coherencia_global", "orden_kuramoto",
+    "GAMMA_REGISTRY", "eval_gamma", "kuramoto_R_psi",
+    "enforce_canonical_grammar", "on_applied_glifo",
+    "GLYPHS_CANONICAL", "glyph_angle", "glyph_unit",
+    "sigma_vector_node", "sigma_vector_global",
+    "push_sigma_snapshot", "sigma_series", "sigma_rose",
+    "register_sigma_callback",
+    "register_metrics_callbacks",
+    "register_trace",
+    "Tg_global", "Tg_by_node",
+    "latency_series", "glifogram_series",
+    "glyph_top", "glyph_dwell_stats",
+    "play", "seq", "block", "target", "wait", "THOL", "TARGET", "WAIT",
+    "cli_main", "build_graph", "get_preset", "NodeState",
+    "ejemplo_canonico_basico",
+    "__version__",
+]

tnfr-4.1.0/src/tnfr/cli.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+import argparse
+import json
+from typing import Any, Dict, List, Optional
+
+try:  # pragma: no cover - opcional
+    import yaml  # type: ignore
+except Exception:  # pragma: no cover - yaml es opcional
+    yaml = None
+
+import networkx as nx
+
+from .constants import inject_defaults, DEFAULTS
+from .sense import register_sigma_callback, sigma_series, sigma_rose
+from .metrics import (
+    register_metrics_callbacks,
+    Tg_global,
+    latency_series,
+    glifogram_series,
+    glyph_top,
+)
+from .trace import register_trace
+from .program import play, seq, block, wait, target
+from .dynamics import step, _update_history, default_glyph_selector, parametric_glyph_selector
+from .gamma import GAMMA_REGISTRY
+from .scenarios import build_graph
+from .presets import get_preset
+
+
+def _save_json(path: str, data: Any) -> None:
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+
+def _load_sequence(path: str) -> List[Any]:
+    with open(path, "r", encoding="utf-8") as f:
+        text = f.read()
+    if path.endswith(".yaml") or path.endswith(".yml"):
+        if not yaml:
+            raise RuntimeError("pyyaml no está instalado, usa JSON o instala pyyaml")
+        data = yaml.safe_load(text)
+    else:
+        data = json.loads(text)
+
+    def parse_token(tok: Any):
+        if isinstance(tok, str):
+            return tok
+        if isinstance(tok, dict):
+            if "WAIT" in tok:
+                return wait(int(tok["WAIT"]))
+            if "TARGET" in tok:
+                return target(tok["TARGET"])
+            if "THOL" in tok:
+                spec = tok["THOL"] or {}
+                b = [_parse_inner(x) for x in spec.get("body", [])]
+                return block(*b, repeat=int(spec.get("repeat", 1)), close=spec.get("close"))
+        raise ValueError(f"Token inválido: {tok}")
+
+    def _parse_inner(x: Any):
+        return parse_token(x)
+
+    return [parse_token(t) for t in data]
+
+
+def _attach_callbacks(G: nx.Graph) -> None:
+    inject_defaults(G, DEFAULTS)
+    register_sigma_callback(G)
+    register_metrics_callbacks(G)
+    register_trace(G)
+    _update_history(G)
+
+
+def cmd_run(args: argparse.Namespace) -> int:
+    G = build_graph(n=args.nodes, topology=args.topology, seed=args.seed)
+    _attach_callbacks(G)
+    G.graph.setdefault("GRAMMAR_CANON", DEFAULTS["GRAMMAR_CANON"]).update({"enabled": bool(args.grammar_canon)})
+    G.graph["glyph_selector"] = default_glyph_selector if args.selector == "basic" else parametric_glyph_selector
+    G.graph["GAMMA"] = {"type": args.gamma}
+
+    if args.preset:
+        program = get_preset(args.preset)
+        play(G, program)
+    else:
+        steps = int(args.steps or 100)
+        for _ in range(steps):
+            step(G)
+
+    if args.save_history:
+        _save_json(args.save_history, G.graph.get("history", {}))
+
+    if args.summary:
+        tg = Tg_global(G, normalize=True)
+        lat = latency_series(G)
+        print("Top glifos por Tg:", glyph_top(G, k=5))
+        if lat["value"]:
+            print("Latencia media:", sum(lat["value"]) / max(1, len(lat["value"])) )
+    return 0
+
+
+def cmd_sequence(args: argparse.Namespace) -> int:
+    G = build_graph(n=args.nodes, topology=args.topology, seed=args.seed)
+    _attach_callbacks(G)
+    G.graph.setdefault("GRAMMAR_CANON", DEFAULTS["GRAMMAR_CANON"]).update({"enabled": bool(args.grammar_canon)})
+    G.graph["glyph_selector"] = default_glyph_selector if args.selector == "basic" else parametric_glyph_selector
+    G.graph["GAMMA"] = {"type": args.gamma}
+
+    if args.preset:
+        program = get_preset(args.preset)
+    elif args.sequence_file:
+        program = _load_sequence(args.sequence_file)
+    else:
+        program = seq("A’L", "E’N", "I’L", block("O’Z", "Z’HIR", "I’L", repeat=1), "R’A", "SH’A")
+
+    play(G, program)
+
+    if args.save_history:
+        _save_json(args.save_history, G.graph.get("history", {}))
+    return 0
+
+
+def cmd_metrics(args: argparse.Namespace) -> int:
+    G = build_graph(n=args.nodes, topology=args.topology, seed=args.seed)
+    _attach_callbacks(G)
+    G.graph.setdefault("GRAMMAR_CANON", DEFAULTS["GRAMMAR_CANON"]).update({"enabled": bool(args.grammar_canon)})
+    G.graph["glyph_selector"] = default_glyph_selector if args.selector == "basic" else parametric_glyph_selector
+    G.graph["GAMMA"] = {"type": args.gamma}
+    for _ in range(int(args.steps or 200)):
+        step(G)
+
+    tg = Tg_global(G, normalize=True)
+    lat = latency_series(G)
+    rose = sigma_rose(G)
+    glifo = glifogram_series(G)
+
+    out = {
+        "Tg_global": tg,
+        "latency_mean": (sum(lat["value"]) / max(1, len(lat["value"])) ) if lat["value"] else 0.0,
+        "rose": rose,
+        "glifogram": {k: v[:10] for k, v in glifo.items()},
+    }
+    if args.save:
+        _save_json(args.save, out)
+    else:
+        print(json.dumps(out, ensure_ascii=False, indent=2))
+    return 0
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    p = argparse.ArgumentParser(prog="tnfr")
+    sub = p.add_subparsers(dest="cmd")
+
+    p_run = sub.add_parser("run", help="Correr escenario libre o preset y opcionalmente exportar history")
+    p_run.add_argument("--nodes", type=int, default=24)
+    p_run.add_argument("--topology", choices=["ring", "complete", "erdos"], default="ring")
+    p_run.add_argument("--steps", type=int, default=200)
+    p_run.add_argument("--seed", type=int, default=1)
+    p_run.add_argument("--preset", type=str, default=None)
+    p_run.add_argument("--save-history", dest="save_history", type=str, default=None)
+    p_run.add_argument("--summary", action="store_true")
+    p_run.add_argument("--no-canon", dest="grammar_canon", action="store_false", default=True, help="Desactiva gramática canónica")
+    p_run.add_argument("--selector", choices=["basic", "param"], default="basic")
+    p_run.add_argument("--gamma", choices=list(GAMMA_REGISTRY.keys()), default="none")
+    p_run.set_defaults(func=cmd_run)
+
+    p_seq = sub.add_parser("sequence", help="Ejecutar una secuencia (preset o YAML/JSON)")
+    p_seq.add_argument("--nodes", type=int, default=24)
+    p_seq.add_argument("--topology", choices=["ring", "complete", "erdos"], default="ring")
+    p_seq.add_argument("--seed", type=int, default=1)
+    p_seq.add_argument("--preset", type=str, default=None)
+    p_seq.add_argument("--sequence-file", type=str, default=None)
+    p_seq.add_argument("--save-history", dest="save_history", type=str, default=None)
+    p_seq.set_defaults(func=cmd_sequence)
+
+    p_met = sub.add_parser("metrics", help="Correr breve y volcar métricas clave")
+    p_met.add_argument("--nodes", type=int, default=24)
+    p_met.add_argument("--topology", choices=["ring", "complete", "erdos"], default="ring")
+    p_met.add_argument("--steps", type=int, default=300)
+    p_met.add_argument("--seed", type=int, default=1)
+    p_met.add_argument("--no-canon", dest="grammar_canon", action="store_false", default=True, help="Desactiva gramática canónica")
+    p_met.add_argument("--selector", choices=["basic", "param"], default="basic")
+    p_met.add_argument("--gamma", choices=list(GAMMA_REGISTRY.keys()), default="none")
+    p_met.add_argument("--save", type=str, default=None)
+    p_met.set_defaults(func=cmd_metrics)
+
+    args = p.parse_args(argv)
+    if not hasattr(args, "func"):
+        p.print_help()
+        return 1
+    return int(args.func(args))
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

{tnfr-3.5.0 → tnfr-4.1.0}/src/tnfr/constants.py

@@ -10,7 +10,7 @@ from typing import Dict, Any
 # -------------------------
 # Parámetros canónicos
 # -------------------------
-DEFAULTS: Dict[str, Any] = {
+DEFAULTS: Dict[str, Any] = {
     # Discretización
     "DT": 1.0,
 
@@ -72,8 +72,9 @@ DEFAULTS: Dict[str, Any] = {
     # Criterios de estabilidad (para activar RE’MESH de red)
     "EPS_DNFR_STABLE": 1e-3,
     "EPS_DEPI_STABLE": 1e-3,
-    "FRACTION_STABLE_REMESH": 0.80,   # fracción de nodos estables requerida
-    "REMESH_COOLDOWN_VENTANA": 20,    # pasos mínimos entre RE’MESH
+    "FRACTION_STABLE_REMESH": 0.80,   # fracción de nodos estables requerida
+    "REMESH_COOLDOWN_VENTANA": 20,    # pasos mínimos entre RE’MESH
+    "REMESH_COOLDOWN_TS": 0.0,        # cooldown adicional por tiempo simulado
     # Gating adicional basado en observadores (conmutador + ventana)
     "REMESH_REQUIRE_STABILITY": False, # si True, exige ventana de estabilidad multi-métrica
     "REMESH_STABILITY_WINDOW": 25,     # tamaño de ventana para evaluar estabilidad
@@ -82,8 +83,9 @@ DEFAULTS: Dict[str, Any] = {
     "REMESH_LOG_EVENTS": True,         # guarda eventos y metadatos del RE’MESH
 
     # RE’MESH: memoria τ y mezcla α
-    "REMESH_TAU": 8,                  # pasos hacia atrás
-    "REMESH_ALPHA": 0.5,              # mezcla con pasado
+    "REMESH_TAU": 8,                  # pasos hacia atrás
+    "REMESH_ALPHA": 0.5,              # mezcla con pasado
+    "REMESH_ALPHA_HARD": False,       # si True ignora GLYPH_FACTORS['REMESH_alpha']
 
     # Histéresis glífica
     "GLYPH_HYSTERESIS_WINDOW": 7,
@@ -92,13 +94,13 @@ DEFAULTS: Dict[str, Any] = {
     "GLYPH_SELECTOR_MARGIN": 0.05,
 
     # Ventana para estimar la carga glífica en history/plots
-    "GLYPH_LOAD_WINDOW": 50,
+    "GLYPH_LOAD_WINDOW": 50,
 
     # Tamaño de ventana para coherencia promedio W̄
     "WBAR_WINDOW": 25,  
 
     # Factores suaves por glifo (operadores)
-    "GLYPH_FACTORS": {
+    "GLYPH_FACTORS": {
         "AL_boost": 0.05,   # A’L — pequeña emisión
         "EN_mix": 0.25,     # E’N — mezcla con vecindad
         "IL_dnfr_factor": 0.7,  # I’L — reduce ΔNFR
@@ -107,7 +109,7 @@ DEFAULTS: Dict[str, Any] = {
         "RA_epi_diff": 0.15,    # R’A — difusión EPI
         "SHA_vf_factor": 0.85,  # SH’A — baja νf
         "VAL_scale": 1.15,      # VA’L — expande EPI
-        "NUL_scale": 0.85,      # NU’L — contrae EPI
+        "NUL_scale": 0.85,      # NU’L — contrae EPI
         "THOL_accel": 0.10,     # T’HOL — acelera (seg. deriv.) si hay umbral
         "ZHIR_theta_shift": 1.57079632679,  # Z’HIR — desplazamiento ~π/2
         "NAV_jitter": 0.05,     # NA’V — pequeña inestabilidad creativa
@@ -147,22 +149,53 @@ DEFAULTS: Dict[str, Any] = {
         "dnfr_hi": 0.50, "dnfr_lo": 0.10,
         "accel_hi": 0.50, "accel_lo": 0.10
     },
-    # Callbacks Γ(R)
-    "CALLBACKS_STRICT": False,  # si True, un error en callback detiene; si False, se loguea y continúa
-}
+    # Callbacks Γ(R)
+    "GAMMA": {
+        "type": "none",  # 'none' | 'kuramoto_linear' | 'kuramoto_bandpass'
+        "beta": 0.0,
+        "R0": 0.0,
+    },
+    "CALLBACKS_STRICT": False,  # si True, un error en callback detiene; si False, se loguea y continúa
+    "VALIDATORS_STRICT": False, # si True, alerta si se clampa fuera de rango
+}
+
+# Gramática glífica canónica
+DEFAULTS.setdefault("GRAMMAR_CANON", {
+    "enabled": True,                # activar la gramática canónica
+    "zhir_requires_oz_window": 3,   # cuántos pasos atrás buscamos O’Z
+    "zhir_dnfr_min": 0.05,          # si |ΔNFR|_norm < este valor, no permitimos Z’HIR sin O’Z
+    "thol_min_len": 2,
+    "thol_max_len": 6,
+    "thol_close_dnfr": 0.15,        # si el campo calma, cerramos con SH’A/NU’L
+    "si_high": 0.66,                # umbral para elegir NU’L vs SH’A al cerrar
+})
 
 
 # -------------------------
 # Utilidades
 # -------------------------
 
-def attach_defaults(G, override: bool = False) -> None:
-    """Escribe DEFAULTS en G.graph (sin sobreescribir si override=False)."""
-    G.graph.setdefault("_tnfr_defaults_attached", False)
-    for k, v in DEFAULTS.items():
-        if override or k not in G.graph:
-            G.graph[k] = v
-    G.graph["_tnfr_defaults_attached"] = True
+def attach_defaults(G, override: bool = False) -> None:
+    """Escribe DEFAULTS en G.graph (sin sobreescribir si override=False)."""
+    G.graph.setdefault("_tnfr_defaults_attached", False)
+    for k, v in DEFAULTS.items():
+        if override or k not in G.graph:
+            G.graph[k] = v
+    G.graph["_tnfr_defaults_attached"] = True
+
+
+def inject_defaults(G, defaults: Dict[str, Any] = DEFAULTS, override: bool = False) -> None:
+    """Alias de conveniencia para inyectar ``DEFAULTS`` en ``G.graph``.
+
+    Permite pasar un diccionario de *defaults* alternativo y mantiene la
+    semántica de ``attach_defaults`` existente. Si ``override`` es ``True`` se
+    sobreescriben valores ya presentes.
+    """
+    G.graph.setdefault("_tnfr_defaults_attached", False)
+    for k, v in defaults.items():
+        if override or k not in G.graph:
+            G.graph[k] = v
+    G.graph["_tnfr_defaults_attached"] = True
 
 
 def merge_overrides(G, **overrides) -> None:

{tnfr-3.5.0 → tnfr-4.1.0}/src/tnfr/dynamics.py

@@ -18,7 +18,9 @@ import networkx as nx
 
 from .observers import sincronía_fase, carga_glifica, orden_kuramoto, sigma_vector
 from .operators import aplicar_remesh_si_estabilizacion_global
+from .grammar import select_and_apply_with_grammar
 from .constants import DEFAULTS, ALIAS_VF, ALIAS_THETA, ALIAS_DNFR, ALIAS_EPI, ALIAS_SI, ALIAS_dEPI, ALIAS_D2EPI
+from .gamma import eval_gamma
 from .helpers import (
      clamp, clamp01, list_mean, phase_distance,
      _get_attr, _set_attr, media_vecinal, fase_media,
@@ -52,6 +54,7 @@ def _write_dnfr_metadata(G, *, weights: dict, hook_name: str, note: str | None =
 
 
 def default_compute_delta_nfr(G) -> None:
+    """Calcula ΔNFR mezclando gradientes de fase, EPI y νf según pesos."""
     w = G.graph.get("DNFR_WEIGHTS", DEFAULTS["DNFR_WEIGHTS"])  # dict
     w_phase = float(w.get("phase", 0.34))
     w_epi = float(w.get("epi", 0.33))
@@ -121,7 +124,23 @@ def dnfr_epi_vf_mixed(G) -> None:
 # Ecuación nodal
 # -------------------------
 
-def update_epi_via_nodal_equation(G, *, dt: float = None) -> None:
+def update_epi_via_nodal_equation(G, *, dt: float = None, t: float | None = None) -> None:
+    """Ecuación nodal TNFR.
+
+    Implementa la forma extendida de la ecuación nodal:
+        ∂EPI/∂t = νf · ΔNFR(t) + Γi(R)
+
+    Donde:
+      - EPI es la Estructura Primaria de Información del nodo.
+      - νf es la frecuencia estructural del nodo (Hz_str).
+      - ΔNFR(t) es el gradiente nodal (necesidad de reorganización),
+        típicamente una mezcla de componentes (p. ej. fase θ, EPI, νf).
+      - Γi(R) es el acoplamiento de red opcional en función del orden de Kuramoto R
+        (ver gamma.py), usado para modular la integración en red.
+
+    Referencias TNFR: ecuación nodal (manual), glosario νf/ΔNFR/EPI, operador Γ.
+    Efectos secundarios: cachea dEPI y actualiza EPI por integración explícita.
+    """
     if not isinstance(G, (nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph)):
         raise TypeError("G must be a networkx graph instance")
     if dt is None:
@@ -132,16 +151,22 @@ def update_epi_via_nodal_equation(G, *, dt: float = None) -> None:
         if dt < 0:
             raise ValueError("dt must be non-negative")
         dt = float(dt)
+    if t is None:
+        t = float(G.graph.get("_t", 0.0))
+    else:
+        t = float(t)
     for n in G.nodes():
         nd = G.nodes[n]
         vf = _get_attr(nd, ALIAS_VF, 0.0)
         dnfr = _get_attr(nd, ALIAS_DNFR, 0.0)
         dEPI_dt_prev = _get_attr(nd, ALIAS_dEPI, 0.0)
         dEPI_dt = vf * dnfr
+        dEPI_dt += eval_gamma(G, n, t)
         epi = _get_attr(nd, ALIAS_EPI, 0.0) + dt * dEPI_dt
         _set_attr(nd, ALIAS_EPI, epi)
         _set_attr(nd, ALIAS_dEPI, dEPI_dt)
         _set_attr(nd, ALIAS_D2EPI, (dEPI_dt - dEPI_dt_prev) / dt if dt != 0 else 0.0)
+    G.graph["_t"] = t + dt
 
 
 # -------------------------
@@ -162,7 +187,7 @@ def integrar_epi_euler(G, dt: float | None = None) -> None:
     update_epi_via_nodal_equation(G, dt=dt)
 
 
-def aplicar_clamps_canonicos(nd: Dict[str, Any], G=None) -> None:
+def aplicar_clamps_canonicos(nd: Dict[str, Any], G=None, node=None) -> None:
     eps_min = float((G.graph.get("EPI_MIN") if G is not None else DEFAULTS["EPI_MIN"]))
     eps_max = float((G.graph.get("EPI_MAX") if G is not None else DEFAULTS["EPI_MAX"]))
     vf_min = float((G.graph.get("VF_MIN") if G is not None else DEFAULTS["VF_MIN"]))
@@ -172,6 +197,14 @@ def aplicar_clamps_canonicos(nd: Dict[str, Any], G=None) -> None:
     vf = _get_attr(nd, ALIAS_VF, 0.0)
     th = _get_attr(nd, ALIAS_THETA, 0.0)
 
+    strict = bool((G.graph.get("VALIDATORS_STRICT") if G is not None else DEFAULTS.get("VALIDATORS_STRICT", False)))
+    if strict and G is not None:
+        hist = G.graph.setdefault("history", {}).setdefault("clamp_alerts", [])
+        if epi < eps_min or epi > eps_max:
+            hist.append({"node": node, "attr": "EPI", "value": float(epi)})
+        if vf < vf_min or vf > vf_max:
+            hist.append({"node": node, "attr": "VF", "value": float(vf)})
+
     _set_attr(nd, ALIAS_EPI, clamp(epi, eps_min, eps_max))
     _set_attr(nd, ALIAS_VF, clamp(vf, vf_min, vf_max))
     if (G.graph.get("THETA_WRAP") if G is not None else DEFAULTS["THETA_WRAP"]):
@@ -187,6 +220,10 @@ def coordinar_fase_global_vecinal(G, fuerza_global: float | None = None, fuerza_
     """
     g = G.graph
     defaults = DEFAULTS
+    hist = g.setdefault("history", {})
+    hist_state = hist.setdefault("phase_state", [])
+    hist_R = hist.setdefault("phase_R", [])
+    hist_disr = hist.setdefault("phase_disr", [])
     # 0) Si hay fuerzas explícitas, usar y salir del modo adaptativo
     if (fuerza_global is not None) or (fuerza_vecinal is not None):
         kG = float(
@@ -248,20 +285,15 @@ def coordinar_fase_global_vecinal(G, fuerza_global: float | None = None, fuerza_
             kL = _step(kL, kL_t, kL_min, kL_max)
 
             # 5) Persistir en G.graph y log de serie
-            g["PHASE_K_GLOBAL"] = kG
-            g["PHASE_K_LOCAL"] = kL
-            hist = g.setdefault("history", {})
-            hist_kG = hist.setdefault("phase_kG", [])
-            hist_kL = hist.setdefault("phase_kL", [])
-            hist_state = hist.setdefault("phase_state", [])
-            hist_R = hist.setdefault("phase_R", [])
-            hist_disr = hist.setdefault("phase_disr", [])
-            hist_kG.append(float(kG))
-            hist_kL.append(float(kL))
             hist_state.append(state)
             hist_R.append(float(R))
             hist_disr.append(float(disr))
 
+    g["PHASE_K_GLOBAL"] = kG
+    g["PHASE_K_LOCAL"] = kL
+    hist.setdefault("phase_kG", []).append(float(kG))
+    hist.setdefault("phase_kL", []).append(float(kL))
+
     # 6) Fase GLOBAL (centroide) para empuje
     X = list(math.cos(_get_attr(G.nodes[n], ALIAS_THETA, 0.0)) for n in G.nodes())
     Y = list(math.sin(_get_attr(G.nodes[n], ALIAS_THETA, 0.0)) for n in G.nodes())
@@ -320,6 +352,21 @@ def _norms_para_selector(G) -> dict:
     G.graph["_sel_norms"] = norms
     return norms
 
+
+def _soft_grammar_prefilter(G, n, cand, dnfr, accel):
+    """Gramática suave: evita repeticiones antes de la canónica."""
+    gram = G.graph.get("GRAMMAR", DEFAULTS.get("GRAMMAR", {}))
+    gwin = int(gram.get("window", 3))
+    avoid = set(gram.get("avoid_repeats", []))
+    force_dn = float(gram.get("force_dnfr", 0.60))
+    force_ac = float(gram.get("force_accel", 0.60))
+    fallbacks = gram.get("fallbacks", {})
+    nd = G.nodes[n]
+    if cand in avoid and reciente_glifo(nd, cand, gwin):
+        if not (dnfr >= force_dn or accel >= force_ac):
+            cand = fallbacks.get(cand, cand)
+    return cand
+
 def parametric_glyph_selector(G, n) -> str:
     """Multiobjetivo: combina Si, |ΔNFR|_norm y |accel|_norm + histéresis.
     Reglas base:
@@ -387,22 +434,9 @@ def parametric_glyph_selector(G, n) -> str:
         elif score <= 0.33 and cand in ("NA’V","R’A","I’L"):
             cand = "O’Z" if dnfr >= dnfr_lo else "Z’HIR"
     except NameError:
-        # por si 'score' no se definió (robustez), no forzamos nada
         pass
 
-    # --- Gramática glífica suave: evita repeticiones cercanas salvo que el campo lo pida ---
-    gram = G.graph.get("GRAMMAR", DEFAULTS.get("GRAMMAR", {}))
-    gwin = int(gram.get("window", 3))
-    avoid = set(gram.get("avoid_repeats", []))
-    force_dn = float(gram.get("force_dnfr", 0.60))
-    force_ac = float(gram.get("force_accel", 0.60))
-    fallbacks = gram.get("fallbacks", {})
-
-    if cand in avoid and reciente_glifo(nd, cand, gwin):
-        # Solo permitimos repetir si el campo "insiste": dnfr o accel altos (ya normalizados)
-        if not (dnfr >= force_dn or accel >= force_ac):
-            cand = fallbacks.get(cand, "R’A")
-
+    cand = _soft_grammar_prefilter(G, n, cand, dnfr, accel)
     return cand
 
 # -------------------------
@@ -432,16 +466,20 @@ def step(G, *, dt: float | None = None, use_Si: bool = True, apply_glyphs: bool
         selector = G.graph.get("glyph_selector", default_glyph_selector)
         from .operators import aplicar_glifo
         window = int(G.graph.get("GLYPH_HYSTERESIS_WINDOW", DEFAULTS["GLYPH_HYSTERESIS_WINDOW"]))
+        use_canon = bool(G.graph.get("GRAMMAR_CANON", DEFAULTS.get("GRAMMAR_CANON", {})).get("enabled", False))
         for n in G.nodes():
-            g = selector(G, n)
-            aplicar_glifo(G, n, g, window=window)
+            if use_canon:
+                select_and_apply_with_grammar(G, n, selector, window)
+            else:
+                g = selector(G, n)
+                aplicar_glifo(G, n, g, window=window)
 
     # 4) Ecuación nodal
     update_epi_via_nodal_equation(G, dt=dt)
 
     # 5) Clamps
     for n in G.nodes():
-        aplicar_clamps_canonicos(G.nodes[n], G)
+        aplicar_clamps_canonicos(G.nodes[n], G, n)
 
     # 6) Coordinación de fase
     coordinar_fase_global_vecinal(G, None, None)