tnfr 4.3.0__tar.gz → 4.5.1__tar.gz

tnfr-4.5.1/PKG-INFO

@@ -0,0 +1,221 @@
+Metadata-Version: 2.4
+Name: tnfr
+Version: 4.5.1
+Summary: modular structural-based dynamics on networks
+Author: fmg
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/tnfr/
+Project-URL: Repository, https://github.com/fermga/Teoria-de-la-naturaleza-fractal-resonante-TNFR-
+Keywords: TNFR,resonant fractal,resonance,glyphs,networkx,dynamics,coherence,EPI,Kuramoto
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: networkx>=2.6
+Dynamic: license-file
+
+# tnfr · Python package
+
+> Engine for **modeling, simulation, and measurement** of multiscale structural coherence through **structural operators** (emission, reception, coherence, dissonance, coupling, resonance, silence, expansion, contraction, self‑organization, mutation, transition, recursivity).
+
+---
+
+## What is `tnfr`?
+
+`tnfr` is a Python library to **operate with form**: build nodes, couple them into networks, and **modulate their coherence** over time using structural operators. It does not describe “things”; it **activates processes**. Its theoretical basis is the Resonant Fractal Nature Theory (TNFR), which understands reality as **networks of coherence** that persist because they **resonate**.
+
+In practical terms, `tnfr` lets you:
+
+* Model **Resonant Fractal Nodes (NFR)** with parameters for **frequency** (νf), **phase** (θ), and **form** (EPI).
+* Apply **structural operators** to start, stabilize, propagate, or reconfigure coherence.
+* **Simulate** nodal dynamics with discrete/continuous integrators.
+* **Measure** global coherence C(t), nodal gradient ΔNFR, and the **Sense Index** (Si).
+* **Visualize** states and trajectories (coupling matrices, C(t) curves, graphs).
+
+> **Nodal equation (operational core)**
+>
+> $\frac{\partial \mathrm{EPI}}{\partial t} = \nu_f\,\cdot\,\Delta\mathrm{NFR}(t)$
+>
+> A form emerges and persists when **internal reorganization** (ΔNFR) **resonates** with the node’s **frequency** (νf).
+
+---
+
+## Installation
+
+```bash
+pip install tnfr
+```
+
+Requires **Python ≥ 3.9**.
+
+---
+
+## Why TNFR (in 60 seconds)
+
+* **From objects to coherences:** you model **processes** that hold, not fixed entities.
+* **Operators instead of rules:** you compose **structural operators** (e.g., *emission*, *coherence*, *dissonance*) to **build trajectories**.
+* **Operational fractality:** the same pattern works for **ideas, teams, tissues, narratives**; the scales change, **the logic doesn’t**.
+
+---
+
+## Getting started (minimal recipe)
+
+> *The high‑level API centers on three things: nodes, operators, simulation.*
+
+```python
+# 1) Nodes and network
+import tnfr as T
+
+# A minimal set of nodes with initial frequency (νf)
+A = T.Node(label="seed", nu_f=0.8)
+B = T.Node(label="context", nu_f=0.6)
+net = T.Network([A, B], edges=[(A, B, 0.7)])  # coupling 0..1
+
+# 2) Sequence of structural operators
+ops = [
+    T.ops.Emission(strength=0.4),      # start pattern
+    T.ops.Coupling(weight=0.7),        # synchronize nodes
+    T.ops.Coherence(),                 # stabilize form
+]
+
+# 3) Simulation and metrics
+traj = T.sim.run(net, ops, steps=200, dt=0.05)
+print("C(t) =", T.metrics.coherence(traj)[-1])
+print("Si   =", T.metrics.sense_index(traj))
+
+# 4) Quick visualization
+T.viz.plot_coherence(traj)     # C(t) curve
+T.viz.plot_network(net)        # graph/couplings
+```
+
+> **Note:** Specific class/function names may vary across minor versions. Check `help(T.ops)` and `help(T.sim)` for your installed API.
+
+---
+
+## Key concepts (operational summary)
+
+* **Node (NFR):** a unit that persists because it **resonates**. Parameterized by **νf** (frequency), **θ** (phase), and **EPI** (coherent form).
+* **Structural operators:** functions that reorganize the network. We use **functional** names (not phonemes):
+
+  * **Emission** (start), **Reception** (open), **Coherence** (stabilize), **Dissonance** (creative tension), **Coupling** (synchrony), **Resonance** (propagate), **Silence** (latency), **Expansion**, **Contraction**, **Self‑organization**, **Mutation**, **Transition**, **Recursivity**.
+* **Magnitudes:**
+
+  * **C(t):** global coherence.
+  * **ΔNFR:** nodal gradient (need for reorganization).
+  * **νf:** structural frequency (Hz\_str).
+  * **Si:** sense index (ability to generate stable shared coherence).
+
+---
+
+## Typical workflow
+
+1. **Model** your system as a network: nodes (agents, ideas, tissues, modules) and couplings.
+2. **Select** a **trajectory of operators** aligned with your goal (e.g., *start → couple → stabilize*).
+3. **Simulate** the dynamics: number of steps, step size, tolerances.
+4. **Measure**: C(t), ΔNFR, Si; identify bifurcations and collapses.
+5. **Iterate** with controlled **dissonance** to open mutations without losing form.
+
+---
+
+## High‑level API (orientation map)
+
+> The typical module layout in `tnfr` is:
+
+* `tnfr.core`: `Node`, `Network`, `EPI`, `State`
+* `tnfr.ops`: structural operators (Emission, Reception, Coherence, Dissonance, ...)
+* `tnfr.sim`: integrators (`run`, `step`, `integrate`), dt control and thresholds
+* `tnfr.metrics`: `coherence`, `gradient`, `sense_index`, `phase_sync`
+* `tnfr.viz`: plotting utilities (`plot_coherence`, `plot_network`, `plot_phase`)
+
+Usage examples:
+
+```python
+from tnfr import core, ops, sim, metrics
+
+net = core.Network.from_edges([
+    ("n1", "n2", 0.6),
+    ("n2", "n3", 0.8),
+])
+
+sequence = [ops.Emission(0.3), ops.Coupling(0.5), ops.Coherence()]
+traj = sim.run(net, sequence, steps=500)
+
+print(metrics.coherence(traj))
+```
+
+---
+
+## Parametric modeling
+
+```python
+import tnfr as T
+
+net = T.Network.uniform(n=25, nu_f=0.4, coupling=0.3)
+plan = (
+    T.ops.Emission(0.2)
+  >> T.ops.Expansion(0.4)
+  >> T.ops.Coupling(0.6)
+  >> T.ops.Coherence()
+)
+traj = T.sim.run(net, plan, steps=800)
+T.viz.plot_phase(traj)
+```
+
+---
+
+## Main metrics
+
+* `coherence(traj) → C(t)`: global stability; higher values indicate sustained form.
+* `gradient(state) → ΔNFR`: local demand for reorganization (high = risk of collapse/bifurcation).
+* `sense_index(traj) → Si`: proxy for **structural sense** (capacity to generate shared coherence) combining **νf**, phase, and topology.
+
+---
+
+## Best practices
+
+* **Short sequences** and frequent C(t) checks avoid unnecessary collapses.
+* Use **dissonance** as a tool: introduce it to open possibilities, but **seal** with coherence.
+* **Scale first, detail later:** tune coarse couplings before micro‑parameters.
+
+---
+
+## Project status
+
+* **pre‑1.0 API**: signatures may be refined; concepts and magnitudes are stable.
+* **Pure‑Python** core with minimal dependencies (optional: `numpy`, `matplotlib`, `networkx`).
+
+---
+
+## Contributing
+
+Suggestions, issues, and PRs are welcome. Guidelines:
+
+1. Prioritize **operational clarity** (names, docstrings, examples).
+2. Add **tests** and **notebooks** that show the structural effect of each PR.
+3. Keep **semantic neutrality**: operators act on form, not on contents.
+
+---
+
+## License
+
+MIT 
+
+---
+
+## References & notes
+
+* Theoretical foundations: TNFR operational manual.
+* Operational definitions: nodal equation, dimensions (frequency, phase, form), and structural operators.
+
+> If you use `tnfr` in research or projects, please cite the TNFR conceptual framework and link to the PyPI package.

tnfr-4.5.1/README.md

@@ -0,0 +1,194 @@
+# tnfr · Python package
+
+> Engine for **modeling, simulation, and measurement** of multiscale structural coherence through **structural operators** (emission, reception, coherence, dissonance, coupling, resonance, silence, expansion, contraction, self‑organization, mutation, transition, recursivity).
+
+---
+
+## What is `tnfr`?
+
+`tnfr` is a Python library to **operate with form**: build nodes, couple them into networks, and **modulate their coherence** over time using structural operators. It does not describe “things”; it **activates processes**. Its theoretical basis is the Resonant Fractal Nature Theory (TNFR), which understands reality as **networks of coherence** that persist because they **resonate**.
+
+In practical terms, `tnfr` lets you:
+
+* Model **Resonant Fractal Nodes (NFR)** with parameters for **frequency** (νf), **phase** (θ), and **form** (EPI).
+* Apply **structural operators** to start, stabilize, propagate, or reconfigure coherence.
+* **Simulate** nodal dynamics with discrete/continuous integrators.
+* **Measure** global coherence C(t), nodal gradient ΔNFR, and the **Sense Index** (Si).
+* **Visualize** states and trajectories (coupling matrices, C(t) curves, graphs).
+
+> **Nodal equation (operational core)**
+>
+> $\frac{\partial \mathrm{EPI}}{\partial t} = \nu_f\,\cdot\,\Delta\mathrm{NFR}(t)$
+>
+> A form emerges and persists when **internal reorganization** (ΔNFR) **resonates** with the node’s **frequency** (νf).
+
+---
+
+## Installation
+
+```bash
+pip install tnfr
+```
+
+Requires **Python ≥ 3.9**.
+
+---
+
+## Why TNFR (in 60 seconds)
+
+* **From objects to coherences:** you model **processes** that hold, not fixed entities.
+* **Operators instead of rules:** you compose **structural operators** (e.g., *emission*, *coherence*, *dissonance*) to **build trajectories**.
+* **Operational fractality:** the same pattern works for **ideas, teams, tissues, narratives**; the scales change, **the logic doesn’t**.
+
+---
+
+## Getting started (minimal recipe)
+
+> *The high‑level API centers on three things: nodes, operators, simulation.*
+
+```python
+# 1) Nodes and network
+import tnfr as T
+
+# A minimal set of nodes with initial frequency (νf)
+A = T.Node(label="seed", nu_f=0.8)
+B = T.Node(label="context", nu_f=0.6)
+net = T.Network([A, B], edges=[(A, B, 0.7)])  # coupling 0..1
+
+# 2) Sequence of structural operators
+ops = [
+    T.ops.Emission(strength=0.4),      # start pattern
+    T.ops.Coupling(weight=0.7),        # synchronize nodes
+    T.ops.Coherence(),                 # stabilize form
+]
+
+# 3) Simulation and metrics
+traj = T.sim.run(net, ops, steps=200, dt=0.05)
+print("C(t) =", T.metrics.coherence(traj)[-1])
+print("Si   =", T.metrics.sense_index(traj))
+
+# 4) Quick visualization
+T.viz.plot_coherence(traj)     # C(t) curve
+T.viz.plot_network(net)        # graph/couplings
+```
+
+> **Note:** Specific class/function names may vary across minor versions. Check `help(T.ops)` and `help(T.sim)` for your installed API.
+
+---
+
+## Key concepts (operational summary)
+
+* **Node (NFR):** a unit that persists because it **resonates**. Parameterized by **νf** (frequency), **θ** (phase), and **EPI** (coherent form).
+* **Structural operators:** functions that reorganize the network. We use **functional** names (not phonemes):
+
+  * **Emission** (start), **Reception** (open), **Coherence** (stabilize), **Dissonance** (creative tension), **Coupling** (synchrony), **Resonance** (propagate), **Silence** (latency), **Expansion**, **Contraction**, **Self‑organization**, **Mutation**, **Transition**, **Recursivity**.
+* **Magnitudes:**
+
+  * **C(t):** global coherence.
+  * **ΔNFR:** nodal gradient (need for reorganization).
+  * **νf:** structural frequency (Hz\_str).
+  * **Si:** sense index (ability to generate stable shared coherence).
+
+---
+
+## Typical workflow
+
+1. **Model** your system as a network: nodes (agents, ideas, tissues, modules) and couplings.
+2. **Select** a **trajectory of operators** aligned with your goal (e.g., *start → couple → stabilize*).
+3. **Simulate** the dynamics: number of steps, step size, tolerances.
+4. **Measure**: C(t), ΔNFR, Si; identify bifurcations and collapses.
+5. **Iterate** with controlled **dissonance** to open mutations without losing form.
+
+---
+
+## High‑level API (orientation map)
+
+> The typical module layout in `tnfr` is:
+
+* `tnfr.core`: `Node`, `Network`, `EPI`, `State`
+* `tnfr.ops`: structural operators (Emission, Reception, Coherence, Dissonance, ...)
+* `tnfr.sim`: integrators (`run`, `step`, `integrate`), dt control and thresholds
+* `tnfr.metrics`: `coherence`, `gradient`, `sense_index`, `phase_sync`
+* `tnfr.viz`: plotting utilities (`plot_coherence`, `plot_network`, `plot_phase`)
+
+Usage examples:
+
+```python
+from tnfr import core, ops, sim, metrics
+
+net = core.Network.from_edges([
+    ("n1", "n2", 0.6),
+    ("n2", "n3", 0.8),
+])
+
+sequence = [ops.Emission(0.3), ops.Coupling(0.5), ops.Coherence()]
+traj = sim.run(net, sequence, steps=500)
+
+print(metrics.coherence(traj))
+```
+
+---
+
+## Parametric modeling
+
+```python
+import tnfr as T
+
+net = T.Network.uniform(n=25, nu_f=0.4, coupling=0.3)
+plan = (
+    T.ops.Emission(0.2)
+  >> T.ops.Expansion(0.4)
+  >> T.ops.Coupling(0.6)
+  >> T.ops.Coherence()
+)
+traj = T.sim.run(net, plan, steps=800)
+T.viz.plot_phase(traj)
+```
+
+---
+
+## Main metrics
+
+* `coherence(traj) → C(t)`: global stability; higher values indicate sustained form.
+* `gradient(state) → ΔNFR`: local demand for reorganization (high = risk of collapse/bifurcation).
+* `sense_index(traj) → Si`: proxy for **structural sense** (capacity to generate shared coherence) combining **νf**, phase, and topology.
+
+---
+
+## Best practices
+
+* **Short sequences** and frequent C(t) checks avoid unnecessary collapses.
+* Use **dissonance** as a tool: introduce it to open possibilities, but **seal** with coherence.
+* **Scale first, detail later:** tune coarse couplings before micro‑parameters.
+
+---
+
+## Project status
+
+* **pre‑1.0 API**: signatures may be refined; concepts and magnitudes are stable.
+* **Pure‑Python** core with minimal dependencies (optional: `numpy`, `matplotlib`, `networkx`).
+
+---
+
+## Contributing
+
+Suggestions, issues, and PRs are welcome. Guidelines:
+
+1. Prioritize **operational clarity** (names, docstrings, examples).
+2. Add **tests** and **notebooks** that show the structural effect of each PR.
+3. Keep **semantic neutrality**: operators act on form, not on contents.
+
+---
+
+## License
+
+MIT 
+
+---
+
+## References & notes
+
+* Theoretical foundations: TNFR operational manual.
+* Operational definitions: nodal equation, dimensions (frequency, phase, form), and structural operators.
+
+> If you use `tnfr` in research or projects, please cite the TNFR conceptual framework and link to the PyPI package.

{tnfr-4.3.0 → tnfr-4.5.1}/pyproject.toml

@@ -1,14 +1,14 @@
 [project]
 name = "tnfr"
-version = "4.3.0"
-description = "Canonical TNFR: modular glyph-based dynamics on networks."
+version = "4.5.1"
+description = "modular structural-based dynamics on networks"
 readme = "README.md"
 requires-python = ">=3.9"
 license = { text = "MIT" }
 authors = [{ name = "fmg" }]
 keywords = [
-  "TNFR", "resonant fractal", "resonance", "glyphs",
-  "networkx", "dynamics", "coherence", "EPI", "Kuramoto"
+  "TNFR", "resonant fractal", "resonance", "glyphs",
+  "networkx", "dynamics", "coherence", "EPI", "Kuramoto"
 ]
 classifiers = [
   "Programming Language :: Python :: 3",
@@ -39,3 +39,5 @@ requires = ["setuptools>=61", "wheel"]
 build-backend = "setuptools.build_meta"
 
 
+
+

{tnfr-4.3.0 → tnfr-4.5.1}/src/tnfr/__init__.py

@@ -8,10 +8,10 @@ Ecuación nodal:
     ∂EPI/∂t = νf · ΔNFR(t)
 """
 
-__version__ = "4.3.0"
+__version__ = "4.5.1"
 
 # Re-exports de la API pública
-from .dynamics import step, run, set_delta_nfr_hook, validate_canon
+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
@@ -22,23 +22,44 @@ from .sense import (
     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, export_history,
-)
+from .metrics import (
+    register_metrics_callbacks,
+    Tg_global, Tg_by_node,
+    latency_series, glifogram_series,
+    glyph_top, glyph_dwell_stats, export_history,
+)
+from .operators import aplicar_remesh_red_topologico
 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
+from .structural import (
+    create_nfr,
+    Operador,
+    Emision,
+    Recepcion,
+    Coherencia,
+    Disonancia,
+    Acoplamiento,
+    Resonancia,
+    Silencio,
+    Expansion,
+    Contraccion,
+    Autoorganizacion,
+    Mutacion,
+    Transicion,
+    Recursividad,
+    OPERADORES,
+    validate_sequence,
+    run_sequence,
+)
 
 
 __all__ = [
-    "preparar_red",
-    "step", "run", "set_delta_nfr_hook", "validate_canon",
+    "preparar_red",
+    "step", "run", "set_delta_nfr_hook", "validate_canon",
 
     "attach_standard_observer", "coherencia_global", "orden_kuramoto",
     "GAMMA_REGISTRY", "eval_gamma", "kuramoto_R_psi",
@@ -51,11 +72,19 @@ __all__ = [
     "register_trace",
     "Tg_global", "Tg_by_node",
     "latency_series", "glifogram_series",
-    "glyph_top", "glyph_dwell_stats",
-    "export_history",
+    "glyph_top", "glyph_dwell_stats",
+    "export_history",
+    "aplicar_remesh_red_topologico",
     "play", "seq", "block", "target", "wait", "THOL", "TARGET", "WAIT",
     "cli_main", "build_graph", "get_preset", "NodeState",
     "ejemplo_canonico_basico",
+    "create_nfr",
+    "Operador", "Emision", "Recepcion", "Coherencia", "Disonancia",
+    "Acoplamiento", "Resonancia", "Silencio", "Expansion", "Contraccion",
+    "Autoorganizacion", "Mutacion", "Transicion", "Recursividad",
+    "OPERADORES", "validate_sequence", "run_sequence",
     "__version__",
 ]
 
+
+

{tnfr-4.3.0 → tnfr-4.5.1}/src/tnfr/cli.py

@@ -26,6 +26,7 @@ from .dynamics import step, _update_history, default_glyph_selector, parametric_
 from .gamma import GAMMA_REGISTRY
 from .scenarios import build_graph
 from .presets import get_preset
+from .config import apply_config
 
 
 def _save_json(path: str, data: Any) -> None:
@@ -91,8 +92,16 @@ 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)
+    if getattr(args, "config", None):
+        apply_config(G, args.config)
     _attach_callbacks(G)
     validate_canon(G)
+    if args.dt is not None:
+        G.graph["DT"] = float(args.dt)
+    if args.integrator is not None:
+        G.graph["INTEGRATOR_METHOD"] = str(args.integrator)
+    if getattr(args, "remesh_mode", None):
+        G.graph["REMESH_MODE"] = str(args.remesh_mode)
     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:
@@ -120,10 +129,25 @@ def cmd_run(args: argparse.Namespace) -> int:
     if args.export_history_base:
         export_history(G, args.export_history_base, fmt=args.export_format)
 
+    # Resúmenes rápidos (si están activados)
+    if G.graph.get("COHERENCE", DEFAULTS["COHERENCE"]).get("enabled", True):
+        Wstats = G.graph.get("history", {}).get(
+            G.graph.get("COHERENCE", DEFAULTS["COHERENCE"]).get("stats_history_key", "W_stats"), []
+        )
+        if Wstats:
+            print("[COHERENCE] último paso:", Wstats[-1])
+    if G.graph.get("DIAGNOSIS", DEFAULTS["DIAGNOSIS"]).get("enabled", True):
+        last_diag = G.graph.get("history", {}).get(
+            G.graph.get("DIAGNOSIS", DEFAULTS["DIAGNOSIS"]).get("history_key", "nodal_diag"), []
+        )
+        if last_diag:
+            sample = list(last_diag[-1].values())[:3]
+            print("[DIAGNOSIS] ejemplo:", sample)
+
     if args.summary:
         tg = Tg_global(G, normalize=True)
         lat = latency_series(G)
-        print("Top glifos por Tg:", glyph_top(G, k=5))
+        print("Top operadores por Tg:", glyph_top(G, k=5))
         if lat["value"]:
             print("Latencia media:", sum(lat["value"]) / max(1, len(lat["value"])) )
     return 0
@@ -131,8 +155,16 @@ 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)
+    if getattr(args, "config", None):
+        apply_config(G, args.config)
     _attach_callbacks(G)
     validate_canon(G)
+    if args.dt is not None:
+        G.graph["DT"] = float(args.dt)
+    if args.integrator is not None:
+        G.graph["INTEGRATOR_METHOD"] = str(args.integrator)
+    if getattr(args, "remesh_mode", None):
+        G.graph["REMESH_MODE"] = str(args.remesh_mode)
     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:
@@ -165,8 +197,16 @@ def cmd_sequence(args: argparse.Namespace) -> int:
 
 def cmd_metrics(args: argparse.Namespace) -> int:
     G = build_graph(n=args.nodes, topology=args.topology, seed=args.seed)
+    if getattr(args, "config", None):
+        apply_config(G, args.config)
     _attach_callbacks(G)
     validate_canon(G)
+    if args.dt is not None:
+        G.graph["DT"] = float(args.dt)
+    if args.integrator is not None:
+        G.graph["INTEGRATOR_METHOD"] = str(args.integrator)
+    if getattr(args, "remesh_mode", None):
+        G.graph["REMESH_MODE"] = str(args.remesh_mode)
     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"] = {
@@ -205,10 +245,14 @@ def main(argv: Optional[List[str]] = None) -> int:
     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("--config", type=str, default=None)
+    p_run.add_argument("--dt", type=float, default=None)
+    p_run.add_argument("--integrator", choices=["euler", "rk4"], 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("--remesh-mode", choices=["knn", "mst", "community"], default=None)
     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)
@@ -230,9 +274,13 @@ def main(argv: Optional[List[str]] = None) -> int:
     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("--config", type=str, default=None)
+    p_seq.add_argument("--dt", type=float, default=None)
+    p_seq.add_argument("--integrator", choices=["euler", "rk4"], 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("--remesh-mode", choices=["knn", "mst", "community"], default=None)
     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)
@@ -251,12 +299,16 @@ 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("--dt", type=float, default=None)
+    p_met.add_argument("--integrator", choices=["euler", "rk4"], default=None)
     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("--remesh-mode", choices=["knn", "mst", "community"], default=None)
     p_met.add_argument("--save", type=str, default=None)
+    p_met.add_argument("--config", type=str, default=None)
     p_met.set_defaults(func=cmd_metrics)
 
     args = p.parse_args(argv)