diff --git a/CHANGELOG.md b/CHANGELOG.md index 92e538e..28fbd0e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,80 +9,172 @@ cat -A configure.ac | grep '\^I' nl -ba Makefile | sed -n '770,790p' grep -n "^[ ]" Makefile | head -o resultado: +ate que esta a ficar bonito 😍: ``` -UP: 00:00:08 TICK: 0.88s MODO: DIAGNOSTIC +UP: 00:01:14 TICK: 0.50s MODO: PERSISTENT ──────────────────────────────────────────────────────────────────────────────── -[05:42:44] [info] Neurotron boot() — mode=diagnostic -[05:42:44] [info] Ciclo cognitivo iniciado (observe → think → act → rest) -[05:42:44] [disk] Disco detectado: /dev/vda (sem partições visíveis, usando disco inteiro) -[05:42:44] [debug] Vitals CPU=0.0% MEM=11.0% load1=0.0 -[05:42:44] [info] [echo] CPU=0.0% MEM=11.0% -[05:42:44] [debug] telemetry state=stable temp=0.1 cpu=0.0% mem=11.0% load=0.00 jitter=0.000s -[05:42:44] [debug] [trm.engine] step ok: mode=active cog=stable energy=99.3 depth=1 valence=+0.00 -[05:42:44] [heart] cpu=16.7% mem=11.0% tick=1.00s -[05:42:45] [debug] telemetry state=stable temp=0.2 cpu=0.0% mem=11.0% load=0.00 jitter=1.224s -[05:42:45] [debug] [trm.archaeologist] encontrou 1 eventos perigosos recentes → valence -0.10 -[05:42:45] [debug] [trm.engine] step ok: mode=active cog=stable energy=98.5 depth=1 valence=-0.10 -[05:42:45] [heart] cpu=0.0% mem=11.0% tick=1.00s -[05:42:46] [debug] Vitals CPU=0.0% MEM=11.0% load1=0.08 -[05:42:46] [debug] telemetry state=stable temp=0.3 cpu=0.0% mem=11.0% load=0.08 jitter=1.280s -[05:42:46] [debug] [trm.archaeologist] encontrou 2 eventos perigosos recentes → valence -0.20 -[05:42:46] [debug] [trm.engine] step ok: mode=active cog=stable energy=97.8 depth=1 valence=-0.30 -[05:42:47] [heart] cpu=0.0% mem=11.0% tick=1.00s -[05:42:48] [debug] telemetry state=stable temp=0.4 cpu=0.0% mem=11.0% load=0.08 jitter=1.232s -[05:42:48] [debug] [trm.archaeologist] encontrou 3 eventos perigosos recentes → valence -0.30 -[05:42:48] [debug] [trm.engine] step ok: mode=active cog=stable energy=97.0 depth=1 valence=-0.60 -[05:42:48] [heart] cpu=0.0% mem=11.0% tick=1.00s -[05:42:49] [debug] telemetry state=stable temp=0.5 cpu=0.0% mem=11.0% load=0.08 jitter=1.268s -[05:42:49] [debug] [trm.archaeologist] encontrou 3 eventos perigosos recentes → valence -0.30 -[05:42:49] [debug] [trm.engine] step ok: mode=active cog=stable energy=96.3 depth=1 valence=-0.90 -[05:42:49] [heart] cpu=0.0% mem=11.0% tick=1.00s -[05:42:50] [debug] [diag] estado=STABLE cpu=0.0 mem=11.0 load1=0.08 -[05:42:50] [diag] estado=STABLE cpu=0.0 mem=11.0 load1=0.08 -[05:42:50] [info] tick ajustado 1.00s → 0.88s -[05:42:50] [debug] telemetry state=stable temp=0.5 cpu=0.0% mem=11.0% load=0.08 jitter=1.392s -[05:42:50] [debug] [trm.archaeologist] encontrou 3 eventos perigosos recentes → valence -0.30 +[06:23:38] [debug] [diag] estado=STABLE cpu=0.0 mem=10.6 load1=0.44 +[06:23:38] [diag] estado=STABLE cpu=0.0 mem=10.6 load1=0.44 +[06:23:38] [debug] telemetry state=stable temp=1.2 cpu=0.0% mem=10.6% load=0.44 jitter=0.904s +[06:23:38] [debug] [trm.thought] mem estável — tendência favorável +[06:23:38] [debug] [trm.thought] sistema frio — margem para explorar +[06:23:38] [debug] [trm.thought] valência baixa — evitar exploração +[06:23:38] [debug] [trm.engine] step ok: mode=active cog=stable energy=43.1 depth=1 valence=-5.00 +[06:23:38] [heart] cpu=0.0% mem=10.6% tick=0.50s +[06:23:39] [debug] telemetry state=stable temp=1.2 cpu=0.0% mem=10.6% load=0.44 jitter=0.748s +[06:23:39] [debug] [trm.thought] mem estável — tendência favorável +[06:23:39] [debug] [trm.thought] sistema frio — margem para explorar +[06:23:39] [debug] [trm.thought] valência baixa — evitar exploração +[06:23:39] [debug] [trm.engine] step ok: mode=active cog=stable energy=42.4 depth=1 valence=-5.00 +[06:23:39] [heart] cpu=0.0% mem=10.6% tick=0.50s +[06:23:39] [debug] telemetry state=stable temp=1.2 cpu=0.0% mem=10.6% load=0.44 jitter=0.784s +[06:23:40] [debug] [trm.thought] mem estável — tendência favorável +[06:23:40] [debug] [trm.thought] sistema frio — margem para explorar +[06:23:40] [debug] [trm.thought] valência baixa — evitar exploração +[06:23:40] [debug] [trm.engine] step ok: mode=active cog=stable energy=41.7 depth=1 valence=-5.00 +[06:23:40] [heart] cpu=0.0% mem=10.6% tick=0.50s +[06:23:40] [debug] Vitals CPU=0.0% MEM=10.6% load1=0.4 +[06:23:40] [debug] telemetry state=stable temp=1.2 cpu=0.0% mem=10.6% load=0.40 jitter=0.820s +[06:23:40] [debug] [trm.thought] mem estável — tendência favorável +[06:23:40] [debug] [trm.thought] sistema frio — margem para explorar +[06:23:40] [debug] [trm.thought] valência baixa — evitar exploração +[06:23:40] [debug] [trm.engine] step ok: mode=active cog=stable energy=41.0 depth=1 valence=-5.00 +[06:23:40] [heart] cpu=0.0% mem=10.6% tick=0.50s +[06:23:41] [debug] telemetry state=stable temp=1.2 cpu=0.0% mem=10.6% load=0.40 jitter=0.736s +[06:23:41] [debug] [trm.thought] mem estável — tendência favorável +[06:23:41] [debug] [trm.thought] sistema frio — margem para explorar +[06:23:41] [debug] [trm.thought] valência baixa — evitar exploração +[06:23:41] [debug] [trm.engine] step ok: mode=active cog=stable energy=40.3 depth=1 valence=-5.00 +[06:23:41] [heart] cpu=0.0% mem=10.6% tick=0.50s +[06:23:42] [debug] [diag] estado=STABLE cpu=0.0 mem=10.6 load1=0.4 +[06:23:42] [diag] estado=STABLE cpu=0.0 mem=10.6 load1=0.4 +[06:23:42] [debug] telemetry state=stable temp=1.2 cpu=0.0% mem=10.6% load=0.40 ``` -apos ter estabilizado +podemos adicionar "o pensador" ao roadmap: ``` -UP: 00:01:08 TICK: 0.50s MODO: PERSISTENT -──────────────────────────────────────────────────────────────────────────────── -[05:43:45] [heart] cpu=0.0% mem=11.0% tick=0.50s -[05:43:46] [debug] [diag] estado=STABLE cpu=0.0 mem=11.0 load1=0.27 -[05:43:46] [diag] estado=STABLE cpu=0.0 mem=11.0 load1=0.27 -[05:43:46] [debug] Vitals CPU=0.0% MEM=11.0% load1=0.27 -[05:43:46] [debug] telemetry state=stable temp=1.2 cpu=0.0% mem=11.0% load=0.27 jitter=0.912s -[05:43:46] [debug] [trm.archaeologist] encontrou 3 eventos perigosos recentes → valence -0.30 -[05:43:46] [debug] [trm.engine] step ok: mode=active cog=stable energy=50.1 depth=1 valence=-5.30 -[05:43:46] [heart] cpu=0.0% mem=11.0% tick=0.50s -[05:43:47] [debug] telemetry state=stable temp=1.2 cpu=0.0% mem=11.0% load=0.27 jitter=0.724s -[05:43:47] [debug] [trm.archaeologist] encontrou 3 eventos perigosos recentes → valence -0.30 -[05:43:47] [debug] [trm.engine] step ok: mode=active cog=stable energy=49.4 depth=1 valence=-5.30 -[05:43:47] [heart] cpu=0.0% mem=11.0% tick=0.50s -[05:43:48] [debug] telemetry state=stable temp=1.2 cpu=0.0% mem=11.0% load=0.27 jitter=0.780s -[05:43:48] [debug] [trm.archaeologist] encontrou 3 eventos perigosos recentes → valence -0.30 -[05:43:48] [debug] [trm.engine] step ok: mode=active cog=stable energy=48.7 depth=1 valence=-5.30 -[05:43:48] [heart] cpu=0.0% mem=11.0% tick=0.50s -[05:43:48] [debug] telemetry state=stable temp=1.2 cpu=0.0% mem=11.0% load=0.27 jitter=0.780s -[05:43:49] [debug] [trm.archaeologist] encontrou 3 eventos perigosos recentes → valence -0.30 -[05:43:49] [debug] [trm.engine] step ok: mode=active cog=stable energy=48.0 depth=1 valence=-5.30 -[05:43:49] [heart] cpu=0.0% mem=11.0% tick=0.50s -[05:43:49] [debug] telemetry state=stable temp=1.2 cpu=0.0% mem=11.0% load=0.27 jitter=0.780s -[05:43:49] [debug] [trm.archaeologist] encontrou 3 eventos perigosos recentes → valence -0.30 -[05:43:49] [debug] [trm.engine] step ok: mode=active cog=stable energy=47.3 depth=1 valence=-5.30 -[05:43:49] [heart] cpu=0.0% mem=11.0% tick=0.50s -[05:43:50] [debug] [diag] estado=STABLE cpu=0.0 mem=11.0 load1=0.27 -[05:43:50] [diag] estado=STABLE cpu=0.0 mem=11.0 load1=0.27 -[05:43:50] [debug] telemetry state=stable temp=1.2 cpu=0.0% mem=11.0% load=0.27 jitter=0.884s -[05:43:50] [debug] [trm.archaeologist] encontrou 3 eventos perigosos recentes → valence -0.30 -[05:43:50] [debug] [trm.engine] step ok: mode=active cog=stable energy=46.6 depth=1 valence=-5.30 -[05:43:50] [heart] cpu=0.0% mem=11.0% tick=0.50s -[05:43:51] [debug] Vitals CPU=0.0% MEM=11.0% load1=0.25 -[05:43:51] [debug] telemetry state=stable temp=1.2 cpu=0.0% mem=11.0% load=0.25 jitter=0.780s -[05:43:51] [debug] [trm.archaeologist] encontrou 3 eventos perigosos recentes → valence -0.30 -[05:43:51] [debug] [trm.engine] step ok: mode=active cog=stable energy=45.9 depth=1 valence=-5.30 -[05:43:51] [heart] cpu=0.0% mem=11.0% tick=0.50s -[05:43:52] [debug] telemetry state=stable temp=1.2 cpu=0.0% mem=11.0% load=0.25 jitter=0.7 -``` -para o Thought Generator uma mistura Minimalista com Técnico-analítico. algo assim: "detetei stress: Δcpu alto → redução de depth aplicada" \ No newline at end of file +### ✔ TRM — Tiny Recursive Model — Base simbólica definida + +O TRM é o primeiro módulo de **raciocínio interno** do Neurotron. +Ele não é uma rede neural, não aprende por SGD e não precisa de GPU. + +O TRM é: + +> um **micro-modelo simbólico**, iterativo, recorrente, energeticamente limitado, +> capaz de gerar *pensamentos internos*, previsões, julgamentos e estados mentais. + +Ele usa: + +* [x] telemetria v5 +* [x] memória de eventos (Hippocampus) +* [x] sinais fisiológicos +* [-] micro-regras +* [x] micro-agentes internos + +para criar uma **mente mínima**, mas viva. + +#### 🟦 **TRM v1 — (implementação imediata)** + +> Objetivo: gerar *vida interna mínima* e um estado cognitivo coerente. + +##### 🔹 1. Micro-agentes internos + +Três agentes simples, independentes, mas acoplados: + +##### **🛡️ Guardião** + +Responsável por proteção e homeostase. + +* [-] monitora delta, aceleração, temperatura e FS +* [-] ajustes preventivos +* [x] ativa markers (`enter_stress_zone`, `fs_warning`) +* [-] reduz carga quando há risco + +##### **🧭 Explorador** + +Responsável por “pensamento” TRM. + +* [-] gera micro previsões de tendência +* [-] avalia estabilidade +* [-] modifica tick cognitivo +* [ ] inicia refinamento simbólico + +##### **📜 Arqueólogo** + +Responsável por memória e histórico. + +* [x] lê eventos telemétricos recentes +* [-] correlaciona com estados antigos +* [x] ativa markers (`loop_suspect`, `recovering`) +* [x] influencia valência interna + +#### 🔹 2. Energia / Custo Cognitivo + +Cada passo TRM consome energia. + +* [x] cada passo TRM consome energia +* [-] mais telemetria = mais custo +* [ ] previsões mais profundas = custo quadrático +* [-] estado “quente” aumenta custo +* [-] estado “frio” diminui custo + +* [x] Quando a energia baixa demais → TRM reduz profundidade, entra em modo “mínimo”. + +#### 🔹 3. Valência Interna + +Uma métrica de “bem-estar”. + +* [x] estabilidade aumenta valência +* [-] picos rápidos diminuem +* [x] recovery aumenta +* [x] FS warning diminui +* [-] jitter alto diminui + +Valência influencia: + +* [x] intensidade TRM +* [-] prioridades +* [-] ritmo cognitivo + +#### 🔹 4. Ritmos Internos (Osciladores) + +Quatro ritmos independentes: + +* [-] `think_rate` +* [-] `memory_sync_rate` +* [-] `telemetry_rate` +* [-] `selfcheck_rate` + +Alguns podem oscilar lentamente ao longo do tempo (sinusóide leve), criando: + +* [-] ciclos +* [-] fases +* [-] padrões internos + +Estes ritmos ajudam a criar **estabilidade dinâmica**, essencial para emergência. + +#### 🔹 5. Espaço de Estados & Atratores + +##### Estados principais: + +* [x] `stable` +* [x] `warm` +* [x] `hot` +* [x] `critical` +* [x] `recovery` + +##### Atratores cognitivos (dinâmica de V1): + +* [-] estável +* [-] quasi-estável +* [-] recuperativo +* [-] oscilatório +* [ ] pré-caótico (quando delta+aceleração divergem) + +O estado atual do TRM influencia: + +* [x] profundidade TRM +* [x] valência +* [-] custo cognitivo +* [-] ajustes no tick +* [x] markers enviados ao Hippocampus +``` \ No newline at end of file diff --git a/src/_nfdos/kernel/neurotron/src/neurotron/trm/engine.py b/src/_nfdos/kernel/neurotron/src/neurotron/trm/engine.py index cba6e14..77c6543 100644 --- a/src/_nfdos/kernel/neurotron/src/neurotron/trm/engine.py +++ b/src/_nfdos/kernel/neurotron/src/neurotron/trm/engine.py @@ -18,6 +18,7 @@ from pathlib import Path from neurotron.logbus import logbus from .state import TRMState from .agents import GuardianAgent, ExplorerAgent, ArchaeologistAgent +from .thought_agent import ThoughtAgent from .events import make_trm_snapshot_payload @@ -43,6 +44,7 @@ class TRMEngine: self.guardian = GuardianAgent() self.explorer = ExplorerAgent() self.archaeologist = ArchaeologistAgent(self.ctx) + self.thought_agent = ThoughtAgent(self.ctx) # histórico curto de estados do TRM (para futuro TRM v2) @@ -134,6 +136,13 @@ class TRMEngine: st2 = self.explorer.step(st1, telemetry) st3 = self.archaeologist.step(st2, telemetry) + # pensamentos simbólicos + try: + self.thought_agent.step(st3, telemetry) + except Exception as e: + self._dbg(f"thought_agent erro: {e}") + + # ---------------------------------------------------------- # Custo energético + modo de operação # ---------------------------------------------------------- diff --git a/src/_nfdos/kernel/neurotron/src/neurotron/trm/thought_agent.py b/src/_nfdos/kernel/neurotron/src/neurotron/trm/thought_agent.py new file mode 100644 index 0000000..9b376a0 --- /dev/null +++ b/src/_nfdos/kernel/neurotron/src/neurotron/trm/thought_agent.py @@ -0,0 +1,144 @@ +""" +thought_agent.py — TRM v1 Thought Generator +------------------------------------------- + +Gera pensamentos minimalistas, analíticos e contextuais com base na +telemetria e no estado interno do TRM. + +Estilo: + - curto + - técnico + - orientado a deltas + - simbólico, mas não emocional + +Exemplos: + "Δcpu alto — reduzir profundidade" + "mem estável — tendência favorável" + "jitter elevado — cautela sugerida" + "stress detectado — foco conservador" +""" + +from __future__ import annotations +from typing import Dict, Any +from neurotron.logbus import logbus + + +class ThoughtAgent: + name = "trm.thought" + + def __init__(self, cortex): + self.ctx = cortex + + # ----------------------------------------------------------- + # helper seguro + # ----------------------------------------------------------- + def _safe(self, x, default=0.0): + try: + return float(x) + except: + return default + + # ----------------------------------------------------------- + # função principal + # ----------------------------------------------------------- + def step(self, state, tele: Dict[str, Any]) -> None: + """ + Recebe TRMState + telemetria e gera 0..N pensamentos. + Cada pensamento é um dict com: + { "thought": "...", "ts": ... } + gravado via Hippocampus como "trm.thought". + """ + thoughts = [] + + raw = tele.get("raw", {}) or {} + delta = tele.get("delta", {}) or {} + accel = tele.get("accel", {}) or {} + temp = self._safe(tele.get("temp")) + jitter = self._safe(tele.get("jitter")) + events = tele.get("events", []) or [] + + cpu = self._safe(raw.get("cpu")) + mem = self._safe(raw.get("mem")) + load = self._safe(raw.get("load")) + d_cpu = self._safe(delta.get("cpu")) + d_mem = self._safe(delta.get("mem")) + d_load = self._safe(delta.get("load")) + + # ------------------------------------------------------- + # CPU + # ------------------------------------------------------- + if d_cpu > 10: + thoughts.append(f"Δcpu elevado ({d_cpu:+.1f}) — reduzir complexidade") + elif d_cpu > 3: + thoughts.append(f"cpu a subir ({d_cpu:+.1f}) — monitorizar") + + if accel.get("cpu", 0) > 10: + thoughts.append("aceleração cpu brusca — possível stress interno") + + # ------------------------------------------------------- + # MEM + # ------------------------------------------------------- + if mem > 80: + thoughts.append("memória alta — foco conservador") + elif d_mem > 5: + thoughts.append(f"Δmem {d_mem:+.1f} — carga crescente") + elif abs(d_mem) < 1: + thoughts.append("mem estável — tendência favorável") + + # ------------------------------------------------------- + # LOAD + # ------------------------------------------------------- + if load > 2.0: + thoughts.append(f"load {load:.2f} — sistema pesado") + elif d_load > 0.5: + thoughts.append(f"Δload {d_load:+.2f} — possível transição") + + # ------------------------------------------------------- + # Temperatura + # ------------------------------------------------------- + if temp > 60: + thoughts.append("temperatura alta — priorizar eficiência") + elif temp > 40: + thoughts.append("temperatura moderada — ajuste recomendado") + elif temp < 10: + thoughts.append("sistema frio — margem para explorar") + + # ------------------------------------------------------- + # Jitter + # ------------------------------------------------------- + if jitter > 1.5: + thoughts.append(f"jitter elevado ({jitter:.2f}s) — cautela sugerida") + + # ------------------------------------------------------- + # Eventos diretos + # ------------------------------------------------------- + if "enter_stress_zone" in events: + thoughts.append("stress detectado — reduzir profundidade") + + if "fs_warning" in events: + thoughts.append("FS warning — evitar operações pesadas") + + if "loop_suspect" in events: + thoughts.append("padrão repetitivo — vigiar loop") + + # ------------------------------------------------------- + # Valência + # ------------------------------------------------------- + if state.valence < -3: + thoughts.append("valência baixa — evitar exploração") + elif state.valence > 2: + thoughts.append("valência positiva — aprofundar análise") + + # ------------------------------------------------------- + # Gravar pensamentos no Hippocampus + # ------------------------------------------------------- + for t in thoughts: + payload = {"thought": t} + try: + self.ctx.memory.remember("trm.thought", payload) + except Exception: + pass + + logbus.debug(f"[trm.thought] {t}") + + return None diff --git a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/trm/engine.py b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/trm/engine.py index cba6e14..77c6543 100644 --- a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/trm/engine.py +++ b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/trm/engine.py @@ -18,6 +18,7 @@ from pathlib import Path from neurotron.logbus import logbus from .state import TRMState from .agents import GuardianAgent, ExplorerAgent, ArchaeologistAgent +from .thought_agent import ThoughtAgent from .events import make_trm_snapshot_payload @@ -43,6 +44,7 @@ class TRMEngine: self.guardian = GuardianAgent() self.explorer = ExplorerAgent() self.archaeologist = ArchaeologistAgent(self.ctx) + self.thought_agent = ThoughtAgent(self.ctx) # histórico curto de estados do TRM (para futuro TRM v2) @@ -134,6 +136,13 @@ class TRMEngine: st2 = self.explorer.step(st1, telemetry) st3 = self.archaeologist.step(st2, telemetry) + # pensamentos simbólicos + try: + self.thought_agent.step(st3, telemetry) + except Exception as e: + self._dbg(f"thought_agent erro: {e}") + + # ---------------------------------------------------------- # Custo energético + modo de operação # ---------------------------------------------------------- diff --git a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/trm/thought_agent.py b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/trm/thought_agent.py new file mode 100644 index 0000000..9b376a0 --- /dev/null +++ b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/trm/thought_agent.py @@ -0,0 +1,144 @@ +""" +thought_agent.py — TRM v1 Thought Generator +------------------------------------------- + +Gera pensamentos minimalistas, analíticos e contextuais com base na +telemetria e no estado interno do TRM. + +Estilo: + - curto + - técnico + - orientado a deltas + - simbólico, mas não emocional + +Exemplos: + "Δcpu alto — reduzir profundidade" + "mem estável — tendência favorável" + "jitter elevado — cautela sugerida" + "stress detectado — foco conservador" +""" + +from __future__ import annotations +from typing import Dict, Any +from neurotron.logbus import logbus + + +class ThoughtAgent: + name = "trm.thought" + + def __init__(self, cortex): + self.ctx = cortex + + # ----------------------------------------------------------- + # helper seguro + # ----------------------------------------------------------- + def _safe(self, x, default=0.0): + try: + return float(x) + except: + return default + + # ----------------------------------------------------------- + # função principal + # ----------------------------------------------------------- + def step(self, state, tele: Dict[str, Any]) -> None: + """ + Recebe TRMState + telemetria e gera 0..N pensamentos. + Cada pensamento é um dict com: + { "thought": "...", "ts": ... } + gravado via Hippocampus como "trm.thought". + """ + thoughts = [] + + raw = tele.get("raw", {}) or {} + delta = tele.get("delta", {}) or {} + accel = tele.get("accel", {}) or {} + temp = self._safe(tele.get("temp")) + jitter = self._safe(tele.get("jitter")) + events = tele.get("events", []) or [] + + cpu = self._safe(raw.get("cpu")) + mem = self._safe(raw.get("mem")) + load = self._safe(raw.get("load")) + d_cpu = self._safe(delta.get("cpu")) + d_mem = self._safe(delta.get("mem")) + d_load = self._safe(delta.get("load")) + + # ------------------------------------------------------- + # CPU + # ------------------------------------------------------- + if d_cpu > 10: + thoughts.append(f"Δcpu elevado ({d_cpu:+.1f}) — reduzir complexidade") + elif d_cpu > 3: + thoughts.append(f"cpu a subir ({d_cpu:+.1f}) — monitorizar") + + if accel.get("cpu", 0) > 10: + thoughts.append("aceleração cpu brusca — possível stress interno") + + # ------------------------------------------------------- + # MEM + # ------------------------------------------------------- + if mem > 80: + thoughts.append("memória alta — foco conservador") + elif d_mem > 5: + thoughts.append(f"Δmem {d_mem:+.1f} — carga crescente") + elif abs(d_mem) < 1: + thoughts.append("mem estável — tendência favorável") + + # ------------------------------------------------------- + # LOAD + # ------------------------------------------------------- + if load > 2.0: + thoughts.append(f"load {load:.2f} — sistema pesado") + elif d_load > 0.5: + thoughts.append(f"Δload {d_load:+.2f} — possível transição") + + # ------------------------------------------------------- + # Temperatura + # ------------------------------------------------------- + if temp > 60: + thoughts.append("temperatura alta — priorizar eficiência") + elif temp > 40: + thoughts.append("temperatura moderada — ajuste recomendado") + elif temp < 10: + thoughts.append("sistema frio — margem para explorar") + + # ------------------------------------------------------- + # Jitter + # ------------------------------------------------------- + if jitter > 1.5: + thoughts.append(f"jitter elevado ({jitter:.2f}s) — cautela sugerida") + + # ------------------------------------------------------- + # Eventos diretos + # ------------------------------------------------------- + if "enter_stress_zone" in events: + thoughts.append("stress detectado — reduzir profundidade") + + if "fs_warning" in events: + thoughts.append("FS warning — evitar operações pesadas") + + if "loop_suspect" in events: + thoughts.append("padrão repetitivo — vigiar loop") + + # ------------------------------------------------------- + # Valência + # ------------------------------------------------------- + if state.valence < -3: + thoughts.append("valência baixa — evitar exploração") + elif state.valence > 2: + thoughts.append("valência positiva — aprofundar análise") + + # ------------------------------------------------------- + # Gravar pensamentos no Hippocampus + # ------------------------------------------------------- + for t in thoughts: + payload = {"thought": t} + try: + self.ctx.memory.remember("trm.thought", payload) + except Exception: + pass + + logbus.debug(f"[trm.thought] {t}") + + return None diff --git a/src/docs/wiki/Roadmap.md b/src/docs/wiki/Roadmap.md index 50532d0..19ff25d 100644 --- a/src/docs/wiki/Roadmap.md +++ b/src/docs/wiki/Roadmap.md @@ -29,7 +29,7 @@ Próximo ponto imediato: **Auto-Diagnóstico V5 + Telemetria V5**. - Servidor Gitea + Caddy Proxy (TLS ativo) - Canal SSH ativo via porta `2222` - WireGuard preparado (rede privada 10.13.13.0/24) -configure.ac + - [x] **Ambiente de Desenvolvimento** - Toolchain customizada (`crosstool-ng`) - Integração autotools (`configure.ac`, `Makefile.am`) @@ -129,6 +129,47 @@ Nesta fase o Neurotron deixa de apenas medir, e passa a **interpretar**, **preve - [-] `critical` - [-] `recovery` +### 📊 Telemetria Interna (Infra da fase) +- [x] Leitura `/proc` e telemetria básica (via Python estático) +- [ ] Coleta contínua estruturada +- [ ] Histórico temporal completo +- [ ] JSON logs evolutivos + +### 🖥️ TUI V2 (Telemetria) +- [ ] Painel vivo CPU/MEM/LOAD +- [ ] Indicador de stress +- [ ] Gráfico (“sparkline”) interno +- [ ] Últimos eventos telemétricos +- [ ] Estado cognitivo atual + +### 🧪 Auto-Diagnóstico v5 +- [ ] Curvas de estabilidade +- [ ] Regressão cognitiva (análise temporal) +- [ ] Tendências dinâmicas (JSON) +- [ ] Comparação evolutiva inteligente +- [ ] Alertas preditivos + +--- + +### 🔁 Heartbeat 1 Hz +- [ ] Ritmo vital constante +- [ ] Log simbólico periódico +- [ ] Commit automático quando estável +- [ ] “🩵 O sistema sente-se bem hoje.” + +Heartbeat virou apenas UI log, não telemetria. +A telemetria verdadeira está no V5. + +--- + +### 💸 Integração com Fun Money (microeconomia cognitiva) +- [ ] Energia interna como recurso +- [ ] Latência e tempo como custo +- [ ] Tarefas como investimento +- [ ] Economia simbólica de decisões + +--- + ### ✔ TRM — Tiny Recursive Model — Base simbólica definida O TRM é o primeiro módulo de **raciocínio interno** do Neurotron. @@ -141,15 +182,16 @@ O TRM é: Ele usa: -* [x] telemetria v5 -* [x] memória de eventos (Hippocampus) -* [x] sinais fisiológicos -* [-] micro-regras -* [x] micro-agentes internos +- [x] Telemetria V6 +- [x] Hippocampus (eventos) +- [x] Sinais internos +- [x] Micro-regras +- [x] Micro-agentes internos +- [x] Pensador (ThoughtAgent v1) para criar uma **mente mínima**, mas viva. -#### 🟦 **TRM v1 — (implementação imediata)** +#### 🟦 **TRM v1 — (já operacional)** > Objetivo: gerar *vida interna mínima* e um estado cognitivo coerente. @@ -161,6 +203,9 @@ Três agentes simples, independentes, mas acoplados: Responsável por proteção e homeostase. +- [x] homeostase +- [x] avaliação de stress +- [x] ajuste de profundidade * [-] monitora delta, aceleração, temperatura e FS * [-] ajustes preventivos * [x] ativa markers (`enter_stress_zone`, `fs_warning`) @@ -168,8 +213,11 @@ Responsável por proteção e homeostase. ##### **🧭 Explorador** -Responsável por “pensamento” TRM. +Responsável por pesquisa interna. +- [x] previsões simples +- [x] deteção de tendências +- [x] ajuste simbólico TRM * [-] gera micro previsões de tendência * [-] avalia estabilidade * [-] modifica tick cognitivo @@ -179,16 +227,31 @@ Responsável por “pensamento” TRM. Responsável por memória e histórico. +- [x] memória recente +- [x] inferências de perigo / recuperação * [x] lê eventos telemétricos recentes * [-] correlaciona com estados antigos * [x] ativa markers (`loop_suspect`, `recovering`) * [x] influencia valência interna +##### **🧠 O Pensador (novo!)** + +Responsável por pensamentos internos + +- [x] geração de pensamentos internos +- [x] narrativa técnica mínima +- [x] integração direta no Hippocampus +- [x] influência parcial na valência + #### 🔹 2. Energia / Custo Cognitivo Cada passo TRM consome energia. -* [x] cada passo TRM consome energia +- [x] custo por passo +- [x] custo por eventos +- [-] custo por profundidade +- [-] custo ajustado por temperatura + * [-] mais telemetria = mais custo * [ ] previsões mais profundas = custo quadrático * [-] estado “quente” aumenta custo @@ -200,6 +263,8 @@ Cada passo TRM consome energia. Uma métrica de “bem-estar”. +- [x] valência é modulada por risco/recovery + * [x] estabilidade aumenta valência * [-] picos rápidos diminuem * [x] recovery aumenta @@ -211,6 +276,8 @@ Valência influencia: * [x] intensidade TRM * [-] prioridades * [-] ritmo cognitivo +- [x] profundidade +- [x] TRM mode #### 🔹 4. Ritmos Internos (Osciladores) @@ -241,12 +308,20 @@ Estes ritmos ajudam a criar **estabilidade dinâmica**, essencial para emergênc ##### Atratores cognitivos (dinâmica de V1): +Atratores (v1): * [-] estável * [-] quasi-estável * [-] recuperativo * [-] oscilatório * [ ] pré-caótico (quando delta+aceleração divergem) +Atratores (v2): +- [-] estável +- [-] quasi-estável +- [-] recuperativo +- [-] oscilatório +- [-] pré-caótico + O estado atual do TRM influencia: * [x] profundidade TRM @@ -272,10 +347,11 @@ O TRM começa a preferir estados e caminhos: Representações simples como: +``` thought: "tendência alta" thought: "risco: subida rápida" thought: "estado bom, manter" - +``` Exportados ao Hippocampus. @@ -307,10 +383,11 @@ O TRM v2 reconhece: Os três agentes votam dentro do TRM: +``` guardião: reduzir carga -explorador: aprofundar pensamento +explorador: aprofundar pesquisa arqueólogo: isto parece perigoso - +``` * [ ] mecanismo de votação interna entre agentes @@ -350,51 +427,6 @@ Pequenos desequilíbrios internos criam: --- -### 📊 Telemetria Interna (Infra da fase) -- [x] Leitura `/proc` e telemetria básica (via Python estático) -- [ ] Coleta contínua estruturada -- [ ] Histórico temporal completo -- [ ] JSON logs evolutivos - ---- - -### 🖥️ TUI V2 (Telemetria) -- [ ] Painel vivo CPU/MEM/LOAD -- [ ] Indicador de stress -- [ ] Gráfico (“sparkline”) interno -- [ ] Últimos eventos telemétricos -- [ ] Estado cognitivo atual - ---- - -### 🔁 Heartbeat 1 Hz -- [ ] Ritmo vital constante -- [ ] Log simbólico periódico -- [ ] Commit automático quando estável -- [ ] “🩵 O sistema sente-se bem hoje.” - -Heartbeat virou apenas UI log, não telemetria. -A telemetria verdadeira está no V5. - ---- - -### 🧪 Auto-Diagnóstico v5 -- [ ] Curvas de estabilidade -- [ ] Regressão cognitiva (análise temporal) -- [ ] Tendências dinâmicas (JSON) -- [ ] Comparação evolutiva inteligente -- [ ] Alertas preditivos - ---- - -### 💸 Integração com Fun Money (microeconomia cognitiva) -- [ ] Energia interna como recurso -- [ ] Latência e tempo como custo -- [ ] Tarefas como investimento -- [ ] Economia simbólica de decisões - ---- - ## 🧩 Fase IV — Expansão Cognitiva do Neurotron (TRM + Módulos Dinâmicos) - [ ] **Telemetria Externa / Observabilidade**