tnfr 4.0.0__py3-none-any.whl → 4.3.0__py3-none-any.whl

tnfr/__init__.py

@@ -1,57 +1,61 @@
-
-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.0.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 __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.3.0"
+
+# Re-exports de la API pública
+from .dynamics import step, run, set_delta_nfr_hook, validate_canon
+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,
+    glyph_top, glyph_dwell_stats, export_history,
 )
-from .trace import register_trace
-from .program import play, seq, block, target, wait, THOL, TARGET, WAIT
-from .cli import main as cli_main
-from .scenarios import build_graph
-from .presets import get_preset
-from .types import NodeState
-
-__all__ = [
+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",
+    "step", "run", "set_delta_nfr_hook", "validate_canon",
+
+    "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",
-    "__version__",
-]
-
-__all__ += ["cli_main", "build_graph", "get_preset", "NodeState"]
+    "export_history",
+    "play", "seq", "block", "target", "wait", "THOL", "TARGET", "WAIT",
+    "cli_main", "build_graph", "get_preset", "NodeState",
+    "ejemplo_canonico_basico",
+    "__version__",
+]
+

tnfr/cli.py

@@ -18,10 +18,12 @@ from .metrics import (
     latency_series,
     glifogram_series,
     glyph_top,
+    export_history,
 )
 from .trace import register_trace
 from .program import play, seq, block, wait, target
-from .dynamics import step, _update_history
+from .dynamics import step, _update_history, default_glyph_selector, parametric_glyph_selector, validate_canon
+from .gamma import GAMMA_REGISTRY
 from .scenarios import build_graph
 from .presets import get_preset
 
@@ -31,6 +33,24 @@ def _save_json(path: str, data: Any) -> None:
         json.dump(data, f, ensure_ascii=False, indent=2)
 
 
+def _str2bool(s: str) -> bool:
+    s = s.lower()
+    if s in {"true", "1", "yes", "y"}:
+        return True
+    if s in {"false", "0", "no", "n"}:
+        return False
+    raise argparse.ArgumentTypeError("expected true/false")
+
+
+def _args_to_dict(args: argparse.Namespace, prefix: str) -> Dict[str, Any]:
+    out: Dict[str, Any] = {}
+    pref = prefix.replace(".", "_")
+    for k, v in vars(args).items():
+        if k.startswith(pref) and v is not None:
+            out[k[len(pref):]] = v
+    return out
+
+
 def _load_sequence(path: str) -> List[Any]:
     with open(path, "r", encoding="utf-8") as f:
         text = f.read()
@@ -72,6 +92,20 @@ def _attach_callbacks(G: nx.Graph) -> None:
 def cmd_run(args: argparse.Namespace) -> int:
     G = build_graph(n=args.nodes, topology=args.topology, seed=args.seed)
     _attach_callbacks(G)
+    validate_canon(G)
+    gcanon = dict(DEFAULTS["GRAMMAR_CANON"])
+    gcanon.update(_args_to_dict(args, prefix="grammar."))
+    if hasattr(args, "grammar_canon") and args.grammar_canon is not None:
+        gcanon["enabled"] = bool(args.grammar_canon)
+    G.graph.setdefault("GRAMMAR_CANON", {}).update(gcanon)
+    if args.glyph_hysteresis_window is not None:
+        G.graph["GLYPH_HYSTERESIS_WINDOW"] = int(args.glyph_hysteresis_window)
+    G.graph["glyph_selector"] = default_glyph_selector if args.selector == "basic" else parametric_glyph_selector
+    G.graph["GAMMA"] = {
+        "type": args.gamma_type,
+        "beta": args.gamma_beta,
+        "R0": args.gamma_R0,
+    }
 
     if args.preset:
         program = get_preset(args.preset)
@@ -83,6 +117,8 @@ def cmd_run(args: argparse.Namespace) -> int:
 
     if args.save_history:
         _save_json(args.save_history, G.graph.get("history", {}))
+    if args.export_history_base:
+        export_history(G, args.export_history_base, fmt=args.export_format)
 
     if args.summary:
         tg = Tg_global(G, normalize=True)
@@ -96,6 +132,20 @@ def cmd_run(args: argparse.Namespace) -> int:
 def cmd_sequence(args: argparse.Namespace) -> int:
     G = build_graph(n=args.nodes, topology=args.topology, seed=args.seed)
     _attach_callbacks(G)
+    validate_canon(G)
+    gcanon = dict(DEFAULTS["GRAMMAR_CANON"])
+    gcanon.update(_args_to_dict(args, prefix="grammar."))
+    if hasattr(args, "grammar_canon") and args.grammar_canon is not None:
+        gcanon["enabled"] = bool(args.grammar_canon)
+    G.graph.setdefault("GRAMMAR_CANON", {}).update(gcanon)
+    if args.glyph_hysteresis_window is not None:
+        G.graph["GLYPH_HYSTERESIS_WINDOW"] = int(args.glyph_hysteresis_window)
+    G.graph["glyph_selector"] = default_glyph_selector if args.selector == "basic" else parametric_glyph_selector
+    G.graph["GAMMA"] = {
+        "type": args.gamma_type,
+        "beta": args.gamma_beta,
+        "R0": args.gamma_R0,
+    }
 
     if args.preset:
         program = get_preset(args.preset)
@@ -108,12 +158,22 @@ def cmd_sequence(args: argparse.Namespace) -> int:
 
     if args.save_history:
         _save_json(args.save_history, G.graph.get("history", {}))
+    if args.export_history_base:
+        export_history(G, args.export_history_base, fmt=args.export_format)
     return 0
 
 
 def cmd_metrics(args: argparse.Namespace) -> int:
     G = build_graph(n=args.nodes, topology=args.topology, seed=args.seed)
     _attach_callbacks(G)
+    validate_canon(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_type,
+        "beta": args.gamma_beta,
+        "R0": args.gamma_R0,
+    }
     for _ in range(int(args.steps or 200)):
         step(G)
 
@@ -146,7 +206,22 @@ def main(argv: Optional[List[str]] = None) -> int:
     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("--export-history-base", dest="export_history_base", type=str, default=None)
+    p_run.add_argument("--export-format", dest="export_format", choices=["csv", "json"], default="json")
     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("--grammar.enabled", dest="grammar_enabled", type=_str2bool, default=None)
+    p_run.add_argument("--grammar.zhir_requires_oz_window", dest="grammar_zhir_requires_oz_window", type=int, default=None)
+    p_run.add_argument("--grammar.zhir_dnfr_min", dest="grammar_zhir_dnfr_min", type=float, default=None)
+    p_run.add_argument("--grammar.thol_min_len", dest="grammar_thol_min_len", type=int, default=None)
+    p_run.add_argument("--grammar.thol_max_len", dest="grammar_thol_max_len", type=int, default=None)
+    p_run.add_argument("--grammar.thol_close_dnfr", dest="grammar_thol_close_dnfr", type=float, default=None)
+    p_run.add_argument("--grammar.si_high", dest="grammar_si_high", type=float, default=None)
+    p_run.add_argument("--glyph.hysteresis_window", dest="glyph_hysteresis_window", type=int, default=None)
+    p_run.add_argument("--selector", choices=["basic", "param"], default="basic")
+    p_run.add_argument("--gamma-type", choices=list(GAMMA_REGISTRY.keys()), default="none")
+    p_run.add_argument("--gamma-beta", type=float, default=0.0)
+    p_run.add_argument("--gamma-R0", type=float, default=0.0)
     p_run.set_defaults(func=cmd_run)
 
     p_seq = sub.add_parser("sequence", help="Ejecutar una secuencia (preset o YAML/JSON)")
@@ -156,6 +231,19 @@ def main(argv: Optional[List[str]] = None) -> int:
     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.add_argument("--export-history-base", dest="export_history_base", type=str, default=None)
+    p_seq.add_argument("--export-format", dest="export_format", choices=["csv", "json"], default="json")
+    p_seq.add_argument("--gamma-type", choices=list(GAMMA_REGISTRY.keys()), default="none")
+    p_seq.add_argument("--gamma-beta", type=float, default=0.0)
+    p_seq.add_argument("--gamma-R0", type=float, default=0.0)
+    p_seq.add_argument("--grammar.enabled", dest="grammar_enabled", type=_str2bool, default=None)
+    p_seq.add_argument("--grammar.zhir_requires_oz_window", dest="grammar_zhir_requires_oz_window", type=int, default=None)
+    p_seq.add_argument("--grammar.zhir_dnfr_min", dest="grammar_zhir_dnfr_min", type=float, default=None)
+    p_seq.add_argument("--grammar.thol_min_len", dest="grammar_thol_min_len", type=int, default=None)
+    p_seq.add_argument("--grammar.thol_max_len", dest="grammar_thol_max_len", type=int, default=None)
+    p_seq.add_argument("--grammar.thol_close_dnfr", dest="grammar_thol_close_dnfr", type=float, default=None)
+    p_seq.add_argument("--grammar.si_high", dest="grammar_si_high", type=float, default=None)
+    p_seq.add_argument("--glyph.hysteresis_window", dest="glyph_hysteresis_window", type=int, default=None)
     p_seq.set_defaults(func=cmd_sequence)
 
     p_met = sub.add_parser("metrics", help="Correr breve y volcar métricas clave")
@@ -163,6 +251,11 @@ def main(argv: Optional[List[str]] = None) -> int:
     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-type", choices=list(GAMMA_REGISTRY.keys()), default="none")
+    p_met.add_argument("--gamma-beta", type=float, default=0.0)
+    p_met.add_argument("--gamma-R0", type=float, default=0.0)
     p_met.add_argument("--save", type=str, default=None)
     p_met.set_defaults(func=cmd_metrics)
 

tnfr/constants.py

@@ -72,18 +72,25 @@ 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
-    "REMESH_MIN_PHASE_SYNC": 0.85,     # media mínima de sincronía de fase en ventana
-    "REMESH_MAX_GLYPH_DISR": 0.35,     # media máxima de carga glífica disruptiva en ventana
-    "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_REQUIRE_STABILITY": False, # si True, exige ventana de estabilidad multi-métrica
+    "REMESH_STABILITY_WINDOW": 25,     # tamaño de ventana para evaluar estabilidad
+    "REMESH_MIN_PHASE_SYNC": 0.85,     # media mínima de sincronía de fase en ventana
+    "REMESH_MAX_GLYPH_DISR": 0.35,     # media máxima de carga glífica disruptiva en ventana
+    "REMESH_MIN_SIGMA_MAG": 0.50,      # magnitud mínima de σ en ventana
+    "REMESH_MIN_KURAMOTO_R": 0.80,    # R de Kuramoto mínimo en ventana
+    "REMESH_MIN_SI_HI_FRAC": 0.50,    # fracción mínima de nodos con Si alto
+    "REMESH_LOG_EVENTS": True,         # guarda eventos y metadatos del RE’MESH
+
+    # RE’MESH: memoria τ y mezcla α (global/local)
+    "REMESH_TAU": 8,                  # compatibilidad: tau global por defecto
+    "REMESH_TAU_GLOBAL": 8,           # pasos hacia atrás (escala global)
+    "REMESH_TAU_LOCAL": 4,            # pasos hacia atrás (escala local)
+    "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 +99,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 +114,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
@@ -154,6 +161,7 @@ DEFAULTS: Dict[str, Any] = {
         "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
@@ -174,11 +182,7 @@ DEFAULTS.setdefault("GRAMMAR_CANON", {
 
 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
+    inject_defaults(G, DEFAULTS, override=override)
 
 
 def inject_defaults(G, defaults: Dict[str, Any] = DEFAULTS, override: bool = False) -> None:
@@ -207,7 +211,10 @@ def merge_overrides(G, **overrides) -> None:
 ALIAS_VF     = ("νf", "nu_f", "nu-f", "nu", "freq", "frequency")
 ALIAS_THETA  = ("θ", "theta", "fase", "phi", "phase")
 ALIAS_DNFR   = ("ΔNFR", "delta_nfr", "dnfr")
-ALIAS_EPI    = ("EPI", "psi", "PSI", "value")
-ALIAS_SI     = ("Si", "sense_index", "S_i", "sense", "meaning_index")
-ALIAS_dEPI   = ("dEPI_dt", "dpsi_dt", "dEPI", "velocity")
-ALIAS_D2EPI  = ("d2EPI_dt2", "d2psi_dt2", "d2EPI", "accel")
+ALIAS_EPI    = ("EPI", "psi", "PSI", "value")
+ALIAS_SI     = ("Si", "sense_index", "S_i", "sense", "meaning_index")
+ALIAS_dEPI   = ("dEPI_dt", "dpsi_dt", "dEPI", "velocity")
+ALIAS_D2EPI  = ("d2EPI_dt2", "d2psi_dt2", "d2EPI", "accel")
+ALIAS_dVF    = ("dνf_dt", "dvf_dt", "dnu_dt", "dvf")
+ALIAS_D2VF   = ("d2νf_dt2", "d2vf_dt2", "d2nu_dt2", "B")
+ALIAS_dSI    = ("δSi", "delta_Si", "dSi")

tnfr/dynamics.py

@@ -19,7 +19,11 @@ 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 .constants import (
+    DEFAULTS,
+    ALIAS_VF, ALIAS_THETA, ALIAS_DNFR, ALIAS_EPI, ALIAS_SI,
+    ALIAS_dEPI, ALIAS_D2EPI, ALIAS_dVF, ALIAS_D2VF, ALIAS_dSI,
+)
 from .gamma import eval_gamma
 from .helpers import (
      clamp, clamp01, list_mean, phase_distance,
@@ -187,7 +191,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"]))
@@ -197,6 +201,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"]):
@@ -204,6 +216,17 @@ def aplicar_clamps_canonicos(nd: Dict[str, Any], G=None) -> None:
         _set_attr(nd, ALIAS_THETA, ((th + math.pi) % (2*math.pi) - math.pi))
 
 
+def validate_canon(G) -> None:
+    """Aplica clamps canónicos a todos los nodos de ``G``.
+
+    Envuelve fase y restringe ``EPI`` y ``νf`` a los rangos en ``G.graph``.
+    Si ``VALIDATORS_STRICT`` está activo, registra alertas en ``history``.
+    """
+    for n in G.nodes():
+        aplicar_clamps_canonicos(G.nodes[n], G, n)
+    return G
+
+
 def coordinar_fase_global_vecinal(G, fuerza_global: float | None = None, fuerza_vecinal: float | None = None) -> None:
     """
     Ajusta fase con mezcla GLOBAL+VECINAL.
@@ -212,6 +235,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(
@@ -273,20 +300,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())
@@ -345,6 +367,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:
@@ -403,6 +440,19 @@ def parametric_glyph_selector(G, n) -> str:
             prev = list(hist)[-1]
             if isinstance(prev, str) and prev in ("I’L","O’Z","Z’HIR","T’HOL","NA’V","R’A"):
                 return prev
+
+    # Penalización por falta de avance en σ/Si si se repite glifo
+    prev = None
+    hist_prev = nd.get("hist_glifos")
+    if hist_prev:
+        prev = list(hist_prev)[-1]
+    if prev == cand:
+        delta_si = _get_attr(nd, ALIAS_dSI, 0.0)
+        h = G.graph.get("history", {})
+        sig = h.get("sense_sigma_mag", [])
+        delta_sigma = sig[-1] - sig[-2] if len(sig) >= 2 else 0.0
+        if delta_si <= 0.0 and delta_sigma <= 0.0:
+            score -= 0.05
             
     # Override suave guiado por score (solo si NO cayó la histéresis arriba)
     # Regla: score>=0.66 inclina a I’L; score<=0.33 inclina a O’Z/Z’HIR
@@ -412,22 +462,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
 
 # -------------------------
@@ -470,7 +507,7 @@ def step(G, *, dt: float | None = None, use_Si: bool = True, apply_glyphs: bool
 
     # 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)
@@ -478,7 +515,9 @@ def step(G, *, dt: float | None = None, use_Si: bool = True, apply_glyphs: bool
     # 7) Observadores ligeros
     _update_history(G)
     # dynamics.py — dentro de step(), justo antes del punto 8)
-    tau = int(G.graph.get("REMESH_TAU", DEFAULTS["REMESH_TAU"]))
+    tau_g = int(G.graph.get("REMESH_TAU_GLOBAL", G.graph.get("REMESH_TAU", DEFAULTS["REMESH_TAU_GLOBAL"])))
+    tau_l = int(G.graph.get("REMESH_TAU_LOCAL", G.graph.get("REMESH_TAU", DEFAULTS["REMESH_TAU_LOCAL"])))
+    tau = max(tau_g, tau_l)
     maxlen = max(2 * tau + 5, 64)
     epi_hist = G.graph.get("_epi_hist")
     if not isinstance(epi_hist, deque) or epi_hist.maxlen != maxlen:
@@ -519,11 +558,12 @@ def run(G, steps: int, *, dt: float | None = None, use_Si: bool = True, apply_gl
 # -------------------------
 
 def _update_history(G) -> None:
-    hist = G.graph.setdefault("history", {
-        "C_steps": [], "stable_frac": [],
-        "phase_sync": [], "glyph_load_estab": [], "glyph_load_disr": [],
-        "Si_mean": [], "Si_hi_frac": [], "Si_lo_frac": []
-    })
+    hist = G.graph.setdefault("history", {})
+    for k in (
+        "C_steps", "stable_frac", "phase_sync", "glyph_load_estab", "glyph_load_disr",
+        "Si_mean", "Si_hi_frac", "Si_lo_frac", "delta_Si", "B"
+    ):
+        hist.setdefault(k, [])
 
     # Proxy de coherencia C(t)
     dnfr_mean = list_mean(abs(_get_attr(G.nodes[n], ALIAS_DNFR, 0.0)) for n in G.nodes())
@@ -543,11 +583,37 @@ def _update_history(G) -> None:
     eps_depi = float(G.graph.get("EPS_DEPI_STABLE", DEFAULTS["EPS_DEPI_STABLE"]))
     stables = 0
     total = max(1, G.number_of_nodes())
+    dt = float(G.graph.get("DT", DEFAULTS.get("DT", 1.0))) or 1.0
+    delta_si_acc = []
+    B_acc = []
     for n in G.nodes():
         nd = G.nodes[n]
         if abs(_get_attr(nd, ALIAS_DNFR, 0.0)) <= eps_dnfr and abs(_get_attr(nd, ALIAS_dEPI, 0.0)) <= eps_depi:
             stables += 1
+
+        # δSi por nodo
+        Si_curr = _get_attr(nd, ALIAS_SI, 0.0)
+        Si_prev = nd.get("_prev_Si", Si_curr)
+        dSi = Si_curr - Si_prev
+        nd["_prev_Si"] = Si_curr
+        _set_attr(nd, ALIAS_dSI, dSi)
+        delta_si_acc.append(dSi)
+
+        # Bifurcación B = ∂²νf/∂t²
+        vf_curr = _get_attr(nd, ALIAS_VF, 0.0)
+        vf_prev = nd.get("_prev_vf", vf_curr)
+        dvf_dt = (vf_curr - vf_prev) / dt
+        dvf_prev = nd.get("_prev_dvf", dvf_dt)
+        B = (dvf_dt - dvf_prev) / dt
+        nd["_prev_vf"] = vf_curr
+        nd["_prev_dvf"] = dvf_dt
+        _set_attr(nd, ALIAS_dVF, dvf_dt)
+        _set_attr(nd, ALIAS_D2VF, B)
+        B_acc.append(B)
+
     hist["stable_frac"].append(stables/total)
+    hist["delta_Si"].append(list_mean(delta_si_acc, 0.0))
+    hist["B"].append(list_mean(B_acc, 0.0))
     # --- nuevas series: sincronía de fase y carga glífica ---
     try:
         ps = sincronía_fase(G)                 # [0,1], más alto = más en fase