From d40302f2dd73f56ed50f115e2a61746ba30c97d3 Mon Sep 17 00:00:00 2001 From: "neo.webmaster.2@gmail.com" Date: Sat, 3 Jan 2026 16:28:44 +0100 Subject: [PATCH] "Auto-commit via make git" --- ChatGPT.md | 59 +----- Makefile.am | 4 +- src/_nfdos/kernel/neurotron/neurotron.in | 24 ++- .../neurotron/src/neurotron/__main__.py | 1 + .../kernel/neurotron/src/neurotron/cortex.py | 63 +++++- .../src/neurotron/dashboard/panes/chat.py | 11 +- .../src/neurotron/dashboard/panes/kernel.py | 18 +- .../src/neurotron/dashboard/panes/memory.py | 15 +- .../src/neurotron/dashboard/panes/trm.py | 28 ++- .../neurotron/src/neurotron/hippocampus.py | 22 +- .../kernel/neurotron/src/neurotron/logbus.py | 55 +++-- .../neurotron/src/neurotron/trm/engine.py | 4 + .../src/neurotron/trm/thought_agent.py | 3 + src/_nfdos/rootfs/init | 24 ++- .../neurotron/src/neurotron/__main__.py | 1 + .../kernel/neurotron/src/neurotron/cortex.py | 63 +++++- .../src/neurotron/dashboard/panes/chat.py | 11 +- .../src/neurotron/dashboard/panes/kernel.py | 18 +- .../src/neurotron/dashboard/panes/memory.py | 15 +- .../src/neurotron/dashboard/panes/trm.py | 28 ++- .../neurotron/src/neurotron/hippocampus.py | 22 +- .../kernel/neurotron/src/neurotron/logbus.py | 55 +++-- .../neurotron/src/neurotron/trm/engine.py | 4 + .../src/neurotron/trm/thought_agent.py | 3 + src/docs/jornada.md | 192 +++++++++++++++++ src/docs/tese.md | 196 ++++++++++++++++++ src/docs/wiki/Architecture.md | 22 ++ src/tui/menu_kernel.py | 36 ++-- 28 files changed, 826 insertions(+), 171 deletions(-) create mode 100644 src/docs/jornada.md diff --git a/ChatGPT.md b/ChatGPT.md index d533b3b..c7e7383 100644 --- a/ChatGPT.md +++ b/ChatGPT.md @@ -44,58 +44,9 @@ GRUB_GFXPAYLOAD_LINUX=keep └──────────────────────────────────────────────────────────────────────────────────────────────┘ ``` ``` -ok a forma geral funcionou. temos um dashboard fixo com o pane status a funcionar: -``` -MODE: PERSISTENT TRM: ACTIVE -CogState: STABLE Depth: 1 Valence: -2.40 Energy: 7.300 +temos neurotron no qemu em modo VGA 😍: print em anexo (modo diagnostico) +agora sim a aventura ganhou forma 😍. +temos o que fazer que, quando entra em modo persistente: : print em anexo (modo persistente) +com a mensagem do kernel "desconfigura" o "design" do dashboard, alem de nem ter linhas que chegue para o dashboard completo (falta o painel do chat). +mas por hoje checkpoint garantido 😍 -──────────────────────────────────────────────────────────────────────────────── -KERNEL MESSAGES (placeholder) - - - - - - - -──────────────────────────────────────────────────────────────────────────────── -MEMORY MESSAGES (placeholder) - - - - - - - -──────────────────────────────────────────────────────────────────────────────── -TRM MESSAGES (placeholder) - - - - - - - -──────────────────────────────────────────────────────────────────────────────── -CHAT MESSAGES (placeholder)[00:48:18] [debug] telemetry state=stable temp=3.7 cpu=16.7% mem=10.6% load=0.14 jitter=0.744s.60 is too large: -[00:48:18] [debug] [trm.explorer] cpu tendência ↑ (+16.7) → energia -0.5ad=0.07 jitter=0.756s3.40 is too large: -[00:48:18] [debug] [trm.thought] Δcpu elevado (+16.7) — reduzir complexidadeepth=1 valence=-2.400. Quota mode: disabled.f -[00:48:18] [debug] [trm.thought] mem estável — tendência favorável.6% load=0.14 jitter=0.764s2.60. Quota mode: disabled.f -[00:48:18] [debug] [trm.thought] sistema frio — margem para explorargy=19.6 depth=1 valence=-2.60mask: ffffffffffffffff -[00:48:18] [debug] [trm.engine] step ok: mode=active cog=stable energy=7.3 depth=1 valence=-2.400mask: ffffffffffffffff -[00:48:18] [heart] cpu=0.0% mem=10.6% tick=0.50stive cog=stable energy=9.3 depth=1 valence=-2.400refined-jiffies' interval of 480030000 ns (480 ms) -[00:47:55] [heart] cpu=0.0% mem=10.6% tick=0.50stive cog=stable energy=40.6 depth=1 valence=-3.60refined-jiffies' interval of 480030000 ns (480 ms) -[00:47:44] [debug] [trm.engine] step ok: mode=active cog=stable energy=43.4 depth=1 valence=-3.60 -clocksource: 'tsc' is current clocksource. -tsc: Marking TSC unstable due to clocksource watchdog -tsc: Marking TSC unstable due to clocksource watchdog -TSC found unstable after boot, most likely due to broken BIOS. Use 'tsc=unstable'. -TSC found unstable after boot, most likely due to broken BIOS. Use 'tsc=unstable'. -sched_clock: Marking unstable (3566043715, 47405219)<-(3626634341, -13185437) -sched_clock: Marking unstable (3566043715, 47405219)<-(3626634341, -13185437) -clocksource: Not enough CPUs to check clocksource 'tsc'. -clocksource: Not enough CPUs to check clocksource 'tsc'. -clocksource: Switched to clocksource refined-jiffies -clocksource: Switched to clocksource refined-jiffies -``` -agora temos de ajustar onde as mensagens aparecem nos outros panes, ou como falaste e bem ... definir a API mínima de cada pane \ No newline at end of file diff --git a/Makefile.am b/Makefile.am index 37b4122..a183590 100644 --- a/Makefile.am +++ b/Makefile.am @@ -47,7 +47,7 @@ $(ISO_FILE): cp $(INITRAMFS) $(DIST_DIR)/iso/boot/ @echo "[ISO] Gerando grub.cfg..." - @printf "set timeout=3\nset default=0\n\nmenuentry 'NFDOS Linux' {\n\tlinux /boot/bzImage console=ttyS0 root=/dev/ram0 loglevel=8\n\tinitrd /boot/initramfs.cpio.gz\n}\n" > $(ISO_DIR)/grub.cfg + @printf "set timeout=3\nset default=0\n\nmenuentry 'NFDOS Linux' {\n\tlinux /boot/bzImage console=tty0 console=ttyS0 root=/dev/ram0 loglevel=8\n\tinitrd /boot/initramfs.cpio.gz\n}\n" > $(ISO_DIR)/grub.cfg @echo "[ISO] Gerando imagem ISO..." grub-mkrescue -o $(ISO_FILE) $(DIST_DIR)/iso --compress=xz -V NFDOS @@ -58,7 +58,7 @@ $(ISO_FILE): # =========================== qemu: $(ISO_FILE) @echo "[QEMU] Iniciando NFDOS ISO..." - qemu-system-x86_64 -cdrom $(ISO_FILE) -m 1024 -nographic -serial mon:stdio -no-reboot + qemu-system-x86_64 -cdrom $(ISO_FILE) -m 1024 -serial mon:stdio -no-reboot # =========================== # Empacotamento do código-fonte diff --git a/src/_nfdos/kernel/neurotron/neurotron.in b/src/_nfdos/kernel/neurotron/neurotron.in index 35d9002..2eed79c 100644 --- a/src/_nfdos/kernel/neurotron/neurotron.in +++ b/src/_nfdos/kernel/neurotron/neurotron.in @@ -4,18 +4,28 @@ PYTHON="/usr/bin/python3" NEUROTRON_HOME="/opt/kernel/neurotron" SRC="$NEUROTRON_HOME/src" -# Garante diretórios básicos +# --- Filesystems base --- mkdir -p /proc /sys /dev - -# Montar proc, sysfs e devtmpfs (idempotente, falha silenciosa se já montado) mount -t proc proc /proc 2>/dev/null || true mount -t sysfs sys /sys 2>/dev/null || true mount -t devtmpfs devtmpfs /dev 2>/dev/null || true -# Ambiente Python minimalista +# --- Ambiente --- +export HOME=/ +export TERM=linux export PYTHONHOME="/usr" export PYTHONPATH="$SRC:/usr/lib/python3.13:/usr/lib/python3.13/site-packages" -export PATH="/sbin:/bin:/usr/sbin:/usr/bin:$PATH" +export PATH="/sbin:/bin:/usr/sbin:/usr/bin" -# Arrancar o cérebro principal como módulo do package -exec "$PYTHON" -m neurotron "$@" +# --- Garante VT --- +mkdir -p /dev/pts +mount -t devpts devpts /dev/pts 2>/dev/null || true + +# --- Mudar para tty1 (VGA) --- +chvt 1 + +# --- Criar sessão e ligar ao VGA --- +exec setsid sh -c ' + exec /dev/tty1 2>&1 + exec '"$PYTHON"' -m neurotron +' diff --git a/src/_nfdos/kernel/neurotron/src/neurotron/__main__.py b/src/_nfdos/kernel/neurotron/src/neurotron/__main__.py index 85b9c73..b9cdf55 100644 --- a/src/_nfdos/kernel/neurotron/src/neurotron/__main__.py +++ b/src/_nfdos/kernel/neurotron/src/neurotron/__main__.py @@ -73,6 +73,7 @@ def main(): Path(log_dir).mkdir(parents=True, exist_ok=True) ctx = Cortex(runtime_dir=runtime_dir, log_dir=log_dir) + logbus.subscribe(ctx._on_log_event) # threads t_dash = threading.Thread(target=dashboard_loop, args=(ctx,), daemon=True) diff --git a/src/_nfdos/kernel/neurotron/src/neurotron/cortex.py b/src/_nfdos/kernel/neurotron/src/neurotron/cortex.py index d3b8199..d1ce27a 100644 --- a/src/_nfdos/kernel/neurotron/src/neurotron/cortex.py +++ b/src/_nfdos/kernel/neurotron/src/neurotron/cortex.py @@ -72,6 +72,16 @@ class Cortex: self.telemetry_path = Path(NEUROTRON_DATASET_PATH) / "telemetry.json" self.telemetry_path.parent.mkdir(parents=True, exist_ok=True) + # ---- Dashboard ---- + self.memory = Hippocampus( + log_dir=self.log_dir, + on_remember=self._on_memory_event, + ) + self.ui_bus = defaultdict(lambda: deque(maxlen=200)) + self.ui_publish("kernel", "[Placeholder (No futuro /dev/kmsg, dmesg reader ou ring buffer próprio)] ACPI: Core revision 20240415") + self.ui_publish("kernel", "[Placeholder (No futuro /dev/kmsg, dmesg reader ou ring buffer próprio)] EXT4-fs mounted filesystem") + + def _init_paths(self): """ Inicializa todos os paths canónicos do runtime Neurotron. @@ -192,6 +202,16 @@ class Cortex: return float(x) except: return fallback + + def ui_publish(self, pane: str, msg: str): + self.ui_bus[pane].append(msg) + + def ui_tail(self, pane: str, n: int): + q = self.ui_bus.get(pane) + if not q: + return [] + return list(q)[-n:] + # ---------------------------------------- # heartbeat — apenas visual, não cognitivo @@ -286,4 +306,45 @@ class Cortex: except Exception: pass - return snap \ No newline at end of file + return snap + + def _on_memory_event(self, kind: str, data: dict): + """ + Observador de eventos lembrados (UI / TRM / futuro). + """ + summary = self._summarize_memory(kind, data) + if summary: + self.ui_publish("memory", summary) + + + def _summarize_memory(self, kind: str, data: dict) -> str: + """ + Converte eventos ricos em linhas humanas (dashboard). + """ + try: + if kind == "boot": + return f"[boot] mode={data.get('mode')} tick={data.get('tick')}" + if kind.startswith("telemetry.event"): + return f"[tele] {kind.split('.')[-1]}" + if kind == "trm.snapshot": + st = data.get("state", {}) + return ( + f"[trm] cog={st.get('cog_state')} " + f"val={st.get('valence', 0):+.2f} " + f"depth={st.get('depth')}" + ) + return f"[{kind}] {str(data)[:60]}" + except Exception: + return None + + def _on_log_event(self, ev): + # sempre disponível para UI + self.ui_publish("log", ev) + + # opcional: persistência + if ev.level in ("error", "warn"): + self.memory.remember("log", { + "level": ev.level, + "msg": ev.msg + }) + diff --git a/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/chat.py b/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/chat.py index e6b2dbf..1d61969 100644 --- a/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/chat.py +++ b/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/chat.py @@ -2,4 +2,13 @@ import sys class ChatPane: def render(self, ctx, x, y, w, h): - sys.stdout.write(f"\033[{y};{x}HCHAT MESSAGES (placeholder)") \ No newline at end of file + # título + sys.stdout.write(f"\033[{y};{x}HCHAT MESSAGES:") + sys.stdout.write("\033[K") + + # consumir linhas já publicadas + lines = ctx.ui_tail("log", h-1) + for i, ev in enumerate(lines): + sys.stdout.write( + f"\033[{y+1+i};{x}H{ev.format()[:w]}" + ) \ No newline at end of file diff --git a/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/kernel.py b/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/kernel.py index fcbc201..9e917ee 100644 --- a/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/kernel.py +++ b/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/kernel.py @@ -1,6 +1,20 @@ -# panes/kernel.py +# neurotron/dashboard/panes/kernel.py import sys class KernelPane: def render(self, ctx, x, y, w, h): - sys.stdout.write(f"\033[{y};{x}HKERNEL MESSAGES (placeholder)") + # título + sys.stdout.write(f"\033[{y};{x}HKERNEL MESSAGES:") + sys.stdout.write("\033[K") + + # consumir linhas já publicadas + lines = ctx.ui_tail("kernel", h - 1) + + row = y + 1 + for line in lines: + truncated = line[:w] + sys.stdout.write(f"\033[{row};{x}H{truncated}") + sys.stdout.write("\033[K") + row += 1 + + diff --git a/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/memory.py b/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/memory.py index 18b1440..c716ca2 100644 --- a/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/memory.py +++ b/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/memory.py @@ -1,5 +1,18 @@ +# neurotron/dashboard/panes/memory.py import sys class MemoryPane: def render(self, ctx, x, y, w, h): - sys.stdout.write(f"\033[{y};{x}HMEMORY MESSAGES (placeholder)") \ No newline at end of file + # título + sys.stdout.write(f"\033[{y};{x}HMEMORY MESSAGES:") + sys.stdout.write("\033[K") + + # consumir memória recente (já filtrada!) + lines = ctx.ui_tail("memory", h - 1) + + row = y + 1 + for line in lines: + truncated = line[:w] + sys.stdout.write(f"\033[{row};{x}H{truncated}") + sys.stdout.write("\033[K") + row += 1 diff --git a/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/trm.py b/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/trm.py index 20f7970..cff7c56 100644 --- a/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/trm.py +++ b/src/_nfdos/kernel/neurotron/src/neurotron/dashboard/panes/trm.py @@ -2,4 +2,30 @@ import sys class TRMPane: def render(self, ctx, x, y, w, h): - sys.stdout.write(f"\033[{y};{x}HTRM MESSAGES (placeholder)") \ No newline at end of file + snap = ctx.cognitive_snapshot() + + sys.stdout.write( + f"\033[{y};{x}HTRM STATE:" + ) + + line1 = ( + f"State:{snap['cog_state']} " + f"Depth:{snap['depth']} " + f"Val:{snap['valence']:+.2f} " + f"Energy:{snap['energy']}" + ) + + sys.stdout.write(f"\033[{y+1};{x}H{line1[:w]}\033[K") + + # Separador + sys.stdout.write(f"\033[{y+2};{x}H" + "─" * w) + + # Pensamentos recentes + thoughts = ctx.ui_tail("trm", h - 3) + row = y + 3 + + for t in thoughts: + sys.stdout.write( + f"\033[{row};{x}H• {t[:w-2]}\033[K" + ) + row += 1 diff --git a/src/_nfdos/kernel/neurotron/src/neurotron/hippocampus.py b/src/_nfdos/kernel/neurotron/src/neurotron/hippocampus.py index a62f30a..84bbc3e 100644 --- a/src/_nfdos/kernel/neurotron/src/neurotron/hippocampus.py +++ b/src/_nfdos/kernel/neurotron/src/neurotron/hippocampus.py @@ -1,18 +1,24 @@ +# neurotron/hippocampus.py from pathlib import Path from datetime import datetime import json +from typing import Optional, Callable + class Hippocampus: """ Memória contextual simples (JSON Lines): append-only. - Guarda perceções, decisões e ações para replays futuros. - Apenas stdlib JSON — 100% compatível com Python estático. """ - def __init__(self, log_dir: Path): + def __init__( + self, + log_dir: Path, + on_remember: Optional[Callable[[str, dict], None]] = None, + ): self.log_dir = log_dir self.log_dir.mkdir(parents=True, exist_ok=True) self.events_file = self.log_dir / "events.jsonl" + self.on_remember = on_remember def remember(self, kind: str, data: dict) -> None: rec = { @@ -22,11 +28,15 @@ class Hippocampus: } try: - # stdlib json → sempre string - blob = json.dumps(rec, separators=(",", ":")) # compacto + blob = json.dumps(rec, separators=(",", ":")) with self.events_file.open("a", encoding="utf-8") as f: f.write(blob + "\n") except Exception: - # nunca crashar o Neurotron por logs pass + # 🔔 notificação opcional (não quebra nunca) + if self.on_remember: + try: + self.on_remember(kind, data) + except Exception: + pass diff --git a/src/_nfdos/kernel/neurotron/src/neurotron/logbus.py b/src/_nfdos/kernel/neurotron/src/neurotron/logbus.py index e2a2fea..a33330d 100644 --- a/src/_nfdos/kernel/neurotron/src/neurotron/logbus.py +++ b/src/_nfdos/kernel/neurotron/src/neurotron/logbus.py @@ -1,33 +1,39 @@ # neurotron/logbus.py -from collections import deque +from dataclasses import dataclass from datetime import datetime -import sys +@dataclass +class LogEvent: + ts: str + level: str + msg: str + + def format(self) -> str: + return f"[{self.ts}] [{self.level}] {self.msg}" class LogBus: - """ - Canal central de logs do Neurotron. - - escreve tudo em stdout (texto simples, sem Rich) - - mantém um buffer em memória para o dashboard (tail) - """ + def __init__(self): + self._subscribers = [] - def __init__(self, maxlen: int = 1000): - self._buffer = deque(maxlen=maxlen) + def subscribe(self, fn): + self._subscribers.append(fn) # ------------------------- # núcleo # ------------------------- + def _emit(self, level: str, msg: str): - ts = datetime.utcnow().strftime("%H:%M:%S") - line = f"[{ts}] [{level}] {msg}" - - # guarda em memória para o dashboard - self._buffer.append(line) - - # escreve em stdout (uma linha) - sys.stdout.write(line + "\n") - sys.stdout.flush() + ev = LogEvent( + ts=datetime.utcnow().strftime("%H:%M:%S"), + level=level, + msg=msg, + ) + for fn in self._subscribers: + try: + fn(ev) + except Exception: + pass # ------------------------- # API pública de logs @@ -61,16 +67,5 @@ class LogBus: # fallback para chamadas antigas tipo logbus.emit("...") self.info(msg) - # ------------------------- - # Para o dashboard - # ------------------------- - def tail(self, n: int = 150): - """Devolve as últimas n linhas de log como lista de strings.""" - if n <= 0: - return [] - buf = list(self._buffer) - return buf[-n:] - - # instância global -logbus = LogBus() +logbus: "LogBus" = LogBus() diff --git a/src/_nfdos/kernel/neurotron/src/neurotron/trm/engine.py b/src/_nfdos/kernel/neurotron/src/neurotron/trm/engine.py index 04daece..1684fef 100644 --- a/src/_nfdos/kernel/neurotron/src/neurotron/trm/engine.py +++ b/src/_nfdos/kernel/neurotron/src/neurotron/trm/engine.py @@ -171,6 +171,10 @@ class TRMEngine: if len(self._history) % 10 == 0 and hasattr(self.ctx, "memory"): payload = make_trm_snapshot_payload(st9, telemetry) self.ctx.memory.remember("trm.snapshot", payload) + self.ctx.ui_publish( + "memory", + f"[trm] cog={st9.cog_state} val={st9.valence:+.2f} depth={st9.depth}" + ) except Exception as e: self._dbg(f"erro ao gravar snapshot no Hippocampus: {e}") diff --git a/src/_nfdos/kernel/neurotron/src/neurotron/trm/thought_agent.py b/src/_nfdos/kernel/neurotron/src/neurotron/trm/thought_agent.py index 9b376a0..2d18f36 100644 --- a/src/_nfdos/kernel/neurotron/src/neurotron/trm/thought_agent.py +++ b/src/_nfdos/kernel/neurotron/src/neurotron/trm/thought_agent.py @@ -136,6 +136,9 @@ class ThoughtAgent: payload = {"thought": t} try: self.ctx.memory.remember("trm.thought", payload) + if hasattr(self.ctx, "ui_publish"): + self.ctx.ui_publish("trm", t) + except Exception: pass diff --git a/src/_nfdos/rootfs/init b/src/_nfdos/rootfs/init index 35d9002..2eed79c 100755 --- a/src/_nfdos/rootfs/init +++ b/src/_nfdos/rootfs/init @@ -4,18 +4,28 @@ PYTHON="/usr/bin/python3" NEUROTRON_HOME="/opt/kernel/neurotron" SRC="$NEUROTRON_HOME/src" -# Garante diretórios básicos +# --- Filesystems base --- mkdir -p /proc /sys /dev - -# Montar proc, sysfs e devtmpfs (idempotente, falha silenciosa se já montado) mount -t proc proc /proc 2>/dev/null || true mount -t sysfs sys /sys 2>/dev/null || true mount -t devtmpfs devtmpfs /dev 2>/dev/null || true -# Ambiente Python minimalista +# --- Ambiente --- +export HOME=/ +export TERM=linux export PYTHONHOME="/usr" export PYTHONPATH="$SRC:/usr/lib/python3.13:/usr/lib/python3.13/site-packages" -export PATH="/sbin:/bin:/usr/sbin:/usr/bin:$PATH" +export PATH="/sbin:/bin:/usr/sbin:/usr/bin" -# Arrancar o cérebro principal como módulo do package -exec "$PYTHON" -m neurotron "$@" +# --- Garante VT --- +mkdir -p /dev/pts +mount -t devpts devpts /dev/pts 2>/dev/null || true + +# --- Mudar para tty1 (VGA) --- +chvt 1 + +# --- Criar sessão e ligar ao VGA --- +exec setsid sh -c ' + exec /dev/tty1 2>&1 + exec '"$PYTHON"' -m neurotron +' diff --git a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/__main__.py b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/__main__.py index 85b9c73..b9cdf55 100644 --- a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/__main__.py +++ b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/__main__.py @@ -73,6 +73,7 @@ def main(): Path(log_dir).mkdir(parents=True, exist_ok=True) ctx = Cortex(runtime_dir=runtime_dir, log_dir=log_dir) + logbus.subscribe(ctx._on_log_event) # threads t_dash = threading.Thread(target=dashboard_loop, args=(ctx,), daemon=True) diff --git a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/cortex.py b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/cortex.py index d3b8199..d1ce27a 100644 --- a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/cortex.py +++ b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/cortex.py @@ -72,6 +72,16 @@ class Cortex: self.telemetry_path = Path(NEUROTRON_DATASET_PATH) / "telemetry.json" self.telemetry_path.parent.mkdir(parents=True, exist_ok=True) + # ---- Dashboard ---- + self.memory = Hippocampus( + log_dir=self.log_dir, + on_remember=self._on_memory_event, + ) + self.ui_bus = defaultdict(lambda: deque(maxlen=200)) + self.ui_publish("kernel", "[Placeholder (No futuro /dev/kmsg, dmesg reader ou ring buffer próprio)] ACPI: Core revision 20240415") + self.ui_publish("kernel", "[Placeholder (No futuro /dev/kmsg, dmesg reader ou ring buffer próprio)] EXT4-fs mounted filesystem") + + def _init_paths(self): """ Inicializa todos os paths canónicos do runtime Neurotron. @@ -192,6 +202,16 @@ class Cortex: return float(x) except: return fallback + + def ui_publish(self, pane: str, msg: str): + self.ui_bus[pane].append(msg) + + def ui_tail(self, pane: str, n: int): + q = self.ui_bus.get(pane) + if not q: + return [] + return list(q)[-n:] + # ---------------------------------------- # heartbeat — apenas visual, não cognitivo @@ -286,4 +306,45 @@ class Cortex: except Exception: pass - return snap \ No newline at end of file + return snap + + def _on_memory_event(self, kind: str, data: dict): + """ + Observador de eventos lembrados (UI / TRM / futuro). + """ + summary = self._summarize_memory(kind, data) + if summary: + self.ui_publish("memory", summary) + + + def _summarize_memory(self, kind: str, data: dict) -> str: + """ + Converte eventos ricos em linhas humanas (dashboard). + """ + try: + if kind == "boot": + return f"[boot] mode={data.get('mode')} tick={data.get('tick')}" + if kind.startswith("telemetry.event"): + return f"[tele] {kind.split('.')[-1]}" + if kind == "trm.snapshot": + st = data.get("state", {}) + return ( + f"[trm] cog={st.get('cog_state')} " + f"val={st.get('valence', 0):+.2f} " + f"depth={st.get('depth')}" + ) + return f"[{kind}] {str(data)[:60]}" + except Exception: + return None + + def _on_log_event(self, ev): + # sempre disponível para UI + self.ui_publish("log", ev) + + # opcional: persistência + if ev.level in ("error", "warn"): + self.memory.remember("log", { + "level": ev.level, + "msg": ev.msg + }) + diff --git a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/chat.py b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/chat.py index e6b2dbf..1d61969 100644 --- a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/chat.py +++ b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/chat.py @@ -2,4 +2,13 @@ import sys class ChatPane: def render(self, ctx, x, y, w, h): - sys.stdout.write(f"\033[{y};{x}HCHAT MESSAGES (placeholder)") \ No newline at end of file + # título + sys.stdout.write(f"\033[{y};{x}HCHAT MESSAGES:") + sys.stdout.write("\033[K") + + # consumir linhas já publicadas + lines = ctx.ui_tail("log", h-1) + for i, ev in enumerate(lines): + sys.stdout.write( + f"\033[{y+1+i};{x}H{ev.format()[:w]}" + ) \ No newline at end of file diff --git a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/kernel.py b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/kernel.py index fcbc201..9e917ee 100644 --- a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/kernel.py +++ b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/kernel.py @@ -1,6 +1,20 @@ -# panes/kernel.py +# neurotron/dashboard/panes/kernel.py import sys class KernelPane: def render(self, ctx, x, y, w, h): - sys.stdout.write(f"\033[{y};{x}HKERNEL MESSAGES (placeholder)") + # título + sys.stdout.write(f"\033[{y};{x}HKERNEL MESSAGES:") + sys.stdout.write("\033[K") + + # consumir linhas já publicadas + lines = ctx.ui_tail("kernel", h - 1) + + row = y + 1 + for line in lines: + truncated = line[:w] + sys.stdout.write(f"\033[{row};{x}H{truncated}") + sys.stdout.write("\033[K") + row += 1 + + diff --git a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/memory.py b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/memory.py index 18b1440..c716ca2 100644 --- a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/memory.py +++ b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/memory.py @@ -1,5 +1,18 @@ +# neurotron/dashboard/panes/memory.py import sys class MemoryPane: def render(self, ctx, x, y, w, h): - sys.stdout.write(f"\033[{y};{x}HMEMORY MESSAGES (placeholder)") \ No newline at end of file + # título + sys.stdout.write(f"\033[{y};{x}HMEMORY MESSAGES:") + sys.stdout.write("\033[K") + + # consumir memória recente (já filtrada!) + lines = ctx.ui_tail("memory", h - 1) + + row = y + 1 + for line in lines: + truncated = line[:w] + sys.stdout.write(f"\033[{row};{x}H{truncated}") + sys.stdout.write("\033[K") + row += 1 diff --git a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/trm.py b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/trm.py index 20f7970..cff7c56 100644 --- a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/trm.py +++ b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/dashboard/panes/trm.py @@ -2,4 +2,30 @@ import sys class TRMPane: def render(self, ctx, x, y, w, h): - sys.stdout.write(f"\033[{y};{x}HTRM MESSAGES (placeholder)") \ No newline at end of file + snap = ctx.cognitive_snapshot() + + sys.stdout.write( + f"\033[{y};{x}HTRM STATE:" + ) + + line1 = ( + f"State:{snap['cog_state']} " + f"Depth:{snap['depth']} " + f"Val:{snap['valence']:+.2f} " + f"Energy:{snap['energy']}" + ) + + sys.stdout.write(f"\033[{y+1};{x}H{line1[:w]}\033[K") + + # Separador + sys.stdout.write(f"\033[{y+2};{x}H" + "─" * w) + + # Pensamentos recentes + thoughts = ctx.ui_tail("trm", h - 3) + row = y + 3 + + for t in thoughts: + sys.stdout.write( + f"\033[{row};{x}H• {t[:w-2]}\033[K" + ) + row += 1 diff --git a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/hippocampus.py b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/hippocampus.py index a62f30a..84bbc3e 100644 --- a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/hippocampus.py +++ b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/hippocampus.py @@ -1,18 +1,24 @@ +# neurotron/hippocampus.py from pathlib import Path from datetime import datetime import json +from typing import Optional, Callable + class Hippocampus: """ Memória contextual simples (JSON Lines): append-only. - Guarda perceções, decisões e ações para replays futuros. - Apenas stdlib JSON — 100% compatível com Python estático. """ - def __init__(self, log_dir: Path): + def __init__( + self, + log_dir: Path, + on_remember: Optional[Callable[[str, dict], None]] = None, + ): self.log_dir = log_dir self.log_dir.mkdir(parents=True, exist_ok=True) self.events_file = self.log_dir / "events.jsonl" + self.on_remember = on_remember def remember(self, kind: str, data: dict) -> None: rec = { @@ -22,11 +28,15 @@ class Hippocampus: } try: - # stdlib json → sempre string - blob = json.dumps(rec, separators=(",", ":")) # compacto + blob = json.dumps(rec, separators=(",", ":")) with self.events_file.open("a", encoding="utf-8") as f: f.write(blob + "\n") except Exception: - # nunca crashar o Neurotron por logs pass + # 🔔 notificação opcional (não quebra nunca) + if self.on_remember: + try: + self.on_remember(kind, data) + except Exception: + pass diff --git a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/logbus.py b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/logbus.py index e2a2fea..a33330d 100644 --- a/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/logbus.py +++ b/src/_nfdos/rootfs/opt/kernel/neurotron/src/neurotron/logbus.py @@ -1,33 +1,39 @@ # neurotron/logbus.py -from collections import deque +from dataclasses import dataclass from datetime import datetime -import sys +@dataclass +class LogEvent: + ts: str + level: str + msg: str + + def format(self) -> str: + return f"[{self.ts}] [{self.level}] {self.msg}" class LogBus: - """ - Canal central de logs do Neurotron. - - escreve tudo em stdout (texto simples, sem Rich) - - mantém um buffer em memória para o dashboard (tail) - """ + def __init__(self): + self._subscribers = [] - def __init__(self, maxlen: int = 1000): - self._buffer = deque(maxlen=maxlen) + def subscribe(self, fn): + self._subscribers.append(fn) # ------------------------- # núcleo # ------------------------- + def _emit(self, level: str, msg: str): - ts = datetime.utcnow().strftime("%H:%M:%S") - line = f"[{ts}] [{level}] {msg}" - - # guarda em memória para o dashboard - self._buffer.append(line) - - # escreve em stdout (uma linha) - sys.stdout.write(line + "\n") - sys.stdout.flush() + ev = LogEvent( + ts=datetime.utcnow().strftime("%H:%M:%S"), + level=level, + msg=msg, + ) + for fn in self._subscribers: + try: + fn(ev) + except Exception: + pass # ------------------------- # API pública de logs @@ -61,16 +67,5 @@ class LogBus: # fallback para chamadas antigas tipo logbus.emit("...") self.info(msg) - # ------------------------- - # Para o dashboard - # ------------------------- - def tail(self, n: int = 150): - """Devolve as últimas n linhas de log como lista de strings.""" - if n <= 0: - return [] - buf = list(self._buffer) - return buf[-n:] - - # instância global -logbus = LogBus() +logbus: "LogBus" = LogBus() 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 04daece..1684fef 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 @@ -171,6 +171,10 @@ class TRMEngine: if len(self._history) % 10 == 0 and hasattr(self.ctx, "memory"): payload = make_trm_snapshot_payload(st9, telemetry) self.ctx.memory.remember("trm.snapshot", payload) + self.ctx.ui_publish( + "memory", + f"[trm] cog={st9.cog_state} val={st9.valence:+.2f} depth={st9.depth}" + ) except Exception as e: self._dbg(f"erro ao gravar snapshot no Hippocampus: {e}") 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 index 9b376a0..2d18f36 100644 --- 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 @@ -136,6 +136,9 @@ class ThoughtAgent: payload = {"thought": t} try: self.ctx.memory.remember("trm.thought", payload) + if hasattr(self.ctx, "ui_publish"): + self.ctx.ui_publish("trm", t) + except Exception: pass diff --git a/src/docs/jornada.md b/src/docs/jornada.md new file mode 100644 index 0000000..85d595e --- /dev/null +++ b/src/docs/jornada.md @@ -0,0 +1,192 @@ +# Neurotron — Jornada Resumida + +## 1. Origem + +Este projeto nasce de uma motivação humana simples e persistente: +compreender, preservar e continuar. + +A jornada começa ainda na infância, num contexto sem acesso a computador ou internet. +O código era escrito em papel. +A execução existia apenas na imaginação. + +Décadas depois, essa intuição inicial transforma-se num sistema operativo experimental (NFDOS) e num sistema cognitivo mínimo (Neurotron). +Este documento resume essa jornada — não como autobiografia, mas como **processo técnico e humano contínuo**. + +--- + +## 2. O Problema Central + +A maioria dos sistemas computacionais modernos otimiza: +- performance +- previsão estatística +- eficiência de execução +- escala + +Poucos sistemas são projetados para: +- viabilidade contínua +- autorregulação +- preservação de identidade +- degradação graciosa sob stress + +O Neurotron parte de uma pergunta diferente: + +> O que é o mínimo necessário para um sistema **continuar a existir**? + +--- + +## 3. Hipótese Fundamental + +A inteligência não precede a estabilidade. +Ela emerge **depois** dela. + +Antes de raciocinar, aprender ou explorar, um sistema precisa: +- não colapsar +- não entrar em loops destrutivos +- não consumir energia além da sua capacidade +- manter coerência interna mínima + +Este princípio é tratado operacionalmente como **homeostase**. + +--- + +## 4. Homeostase — Definição Operacional + +No contexto do Neurotron, homeostase não é um conceito abstrato. +É uma propriedade mensurável e regulável. + +Homeostase é a capacidade do sistema de: +- observar o próprio estado +- detectar desvios críticos +- ajustar o próprio comportamento +- regressar a uma zona viável de operação + +A cognição surge **apenas após** essa condição ser satisfeita. + +--- + +## 5. Atuadores Centrais (v0) + +A homeostase do Neurotron é implementada através de três atuadores — apenas três. + +### `tick` — Ritmo temporal +Controla a velocidade do ciclo cognitivo. +Sob stress, o sistema desacelera. +Sob estabilidade, retoma ritmo normal. + +### `depth` — Profundidade cognitiva +Controla o nível de complexidade interna permitido. +Quando os recursos diminuem, o sistema pensa menos — mas melhor. + +### `mode` — Modo global +Define o estado operacional macro: +- diagnóstico +- operação normal +- sobrevivência mínima + +Não existem outros atuadores nesta fase. +Essa limitação é intencional. + +--- + +## 6. Abordagem Técnica (Resumo) + +O Neurotron opera sobre: +- um sistema operativo minimalista (NFDOS) +- Python estático +- módulos cognitivos simples +- memória episódica +- telemetria contínua + +O ciclo básico do sistema é: + +``` + +observe → think → act → rest + +``` + +A cada iteração, os atuadores são ajustados com base no estado interno. + +Não há aprendizagem estatística neste estágio. +Não há otimização de desempenho. +Há apenas **regulação para viabilidade**. + +--- + +## 7. O Que o Sistema Já Demonstra + +Mesmo na sua forma inicial, o Neurotron já apresenta comportamento coerente de autorregulação: + +- reduz atividade sob stress +- diminui profundidade cognitiva quando instável +- entra em modos seguros automaticamente +- preserva identidade operacional + +Isto **não é inteligência**. +É a **condição de possibilidade da inteligência**. + +--- + +## 8. Dimensão Humana + +Este projeto não é apenas técnico. + +Ele nasce de uma preocupação humana concreta: +legado, continuidade e comunicação para além dos limites biológicos. + +Uma das hipóteses exploradas é a existência de um +**“eu elétrico”** — padrões funcionais de atividade que podem persistir enquanto houver sinal, estrutura e interpretação. + +Essa dimensão orienta decisões éticas e arquiteturais, +mas **não substitui o rigor técnico**. + +--- + +## 9. O Que Este Projeto Não É + +Este projeto: +- não é um manifesto +- não é ficção científica disfarçada +- não promete consciência artificial +- não é um produto comercial + +É um **experimento técnico-filosófico honesto**, +documentado em tempo real, +com falhas visíveis e decisões rastreáveis. + +--- + +## 10. Estado Atual + +- Sistema funcional +- Homeostase mínima implementada +- Observabilidade ativa +- Memória episódica integrada +- Documentação extensa disponível + +O projeto encontra-se em fase exploratória, +com foco em **compreensão antes de expansão**. + +--- + +## 11. Continuidade + +Os documentos completos, logs experimentais, narrativas paralelas e variações técnicas permanecem disponíveis como material de apoio. + +Este resumo existe para permitir: +- leitura clara +- análise crítica +- diálogo interdisciplinar + +Nada mais. +Nada menos. + +--- + +## 12. Nota Final + +Nós não estamos a otimizar resultados. +Nós estamos a aprender **o que mantém um sistema vivo**. + +Isso é engenharia de sistemas viáveis. +Não hype. \ No newline at end of file diff --git a/src/docs/tese.md b/src/docs/tese.md index f23d273..5763fa5 100644 --- a/src/docs/tese.md +++ b/src/docs/tese.md @@ -262,3 +262,199 @@ As lacunas identificadas ao longo deste capítulo fundamentam a motivação do t - Onde termina regulação técnica e começa cognição? Estas questões orientam o desenvolvimento contínuo do NFDOS. + +# Capítulo 3 — Visão Geral do NFDOS + +## 3.1 Motivação e Origem do Projeto + +O NFDOS emerge de uma motivação central que atravessa tanto a engenharia de sistemas como a investigação em cognição artificial: compreender quais são as condições mínimas necessárias para a **continuidade operacional viável** de um sistema complexo. + +Embora o desenvolvimento do NFDOS seja informado por uma trajetória longa de experimentação prática e reflexão conceptual, este trabalho não se propõe como um relato autobiográfico. Em vez disso, a origem do projeto é aqui apresentada como um **processo técnico contínuo**, no qual questões humanas fundamentais — preservação, continuidade e interpretação — são traduzidas em decisões arquiteturais concretas. + +O NFDOS resulta da convergência entre: +- sistemas operativos minimalistas, +- princípios de cibernética e autorregulação, +- arquiteturas cognitivas simbólicas, +- e modelos de vida artificial sob restrições reais de execução. + +--- + +## 3.2 O Problema Estrutural Abordado + +A maioria dos sistemas computacionais contemporâneos é projetada para otimizar métricas específicas, tais como: +- desempenho, +- eficiência computacional, +- previsibilidade estatística, +- escalabilidade. + +No entanto, estes sistemas raramente são concebidos para lidar explicitamente com: +- viabilidade contínua, +- autorregulação interna, +- preservação de identidade operacional, +- degradação graciosa sob condições adversas. + +O NFDOS parte de uma questão distinta das abordagens tradicionais: + +> Qual é o conjunto mínimo de mecanismos necessários para que um sistema computacional **continue a existir de forma coerente ao longo do tempo**, mesmo sob stress, falha parcial ou restrição de recursos? + +Esta questão desloca o foco da otimização para a **viabilidade sistémica**. + +--- + +## 3.3 Hipótese Fundamental + +A hipótese central que orienta o NFDOS é a seguinte: + +> A cognição não precede a estabilidade; ela emerge **a partir** da estabilidade. + +Antes de qualquer forma de aprendizagem, exploração ou deliberação complexa, um sistema precisa ser capaz de: +- evitar colapso funcional, +- prevenir loops destrutivos, +- operar dentro dos seus limites energéticos, +- manter coerência interna mínima. + +Esta condição é tratada, no NFDOS, através do conceito operacional de **homeostase**. + +--- + +## 3.4 Homeostase como Princípio Operacional + +No contexto do NFDOS e do Neurotron, homeostase não é utilizada como metáfora biológica, mas como uma **propriedade mensurável, observável e regulável**. + +Define-se homeostase como a capacidade do sistema de: +- observar continuamente o seu próprio estado interno, +- detectar desvios críticos relativamente a zonas viáveis, +- ajustar o seu comportamento de forma autónoma, +- regressar a uma região operacional estável. + +A cognição simbólica só é ativada plenamente quando esta condição de viabilidade é satisfeita. + +--- + +## 3.5 Atuadores Homeostáticos Fundamentais + +A implementação da homeostase no Neurotron baseia-se deliberadamente num conjunto reduzido de atuadores. Na versão atual (v0), existem apenas três: + +### 3.5.1 `tick` — Ritmo Temporal + +O atuador `tick` controla o intervalo temporal entre ciclos cognitivos. +Quando o sistema deteta condições adversas, o ritmo é desacelerado; em estados estáveis, o ritmo é gradualmente normalizado. + +Este mecanismo reduz carga, jitter e risco de instabilidade acumulada. + +### 3.5.2 `depth` — Profundidade Cognitiva + +O atuador `depth` limita a complexidade interna permitida ao modelo de raciocínio (TRM). +Sob restrição de recursos ou stress elevado, a profundidade cognitiva é reduzida automaticamente. + +Este mecanismo impede thrashing cognitivo e preserva energia computacional. + +### 3.5.3 `mode` — Modo Operacional Global + +O atuador `mode` define o estado macro de operação do sistema, distinguindo entre: +- modos de diagnóstico, +- operação normal, +- sobrevivência mínima. + +A transição entre modos é automática e baseada no estado interno observado. + +A limitação a apenas três atuadores é uma escolha arquitetural intencional, visando interpretabilidade, robustez e controlo explícito. + +--- + +## 3.6 Abordagem Técnica Geral + +O Neurotron opera integrado num sistema operativo minimalista (NFDOS), recorrendo a: +- Python estático, +- módulos cognitivos simples, +- memória episódica persistente, +- telemetria contínua de baixo nível. + +O ciclo cognitivo fundamental do sistema é definido como: + +``` + +observe → think → act → rest + +``` + +A cada iteração, os atuadores homeostáticos são ajustados com base no estado interno atual. + +Nesta fase do projeto: +- não é utilizada aprendizagem estatística, +- não há otimização de desempenho, +- não existem modelos de linguagem de grande escala (LLMs). + +O foco exclusivo é a **regulação para viabilidade contínua**. + +--- + +## 3.7 Comportamentos Observados + +Mesmo numa fase inicial, o sistema já demonstra propriedades coerentes de autorregulação: + +- redução automática de atividade sob stress, +- diminuição da profundidade cognitiva em estados instáveis, +- entrada precoce em modos seguros, +- preservação de identidade operacional ao longo do tempo. + +Estes comportamentos não constituem inteligência no sentido forte, mas representam a **condição necessária para a sua eventual emergência**. + +--- + +## 3.8 Dimensão Conceptual e Humana + +Embora este trabalho mantenha rigor técnico, ele é informado por uma preocupação conceptual mais ampla: a continuidade funcional de padrões de atividade significativos ao longo do tempo. + +Uma das hipóteses exploradas é a noção de um **“eu elétrico”**, entendido como padrões funcionais persistentes que podem ser observados, interpretados e mantidos enquanto existirem estrutura, sinal e regulação. + +Esta dimensão influencia decisões arquiteturais e éticas, mas não substitui nem enfraquece o método científico adotado. + +--- + +## 3.9 Delimitação do Escopo + +É importante clarificar o que o NFDOS **não** pretende ser: + +- não é um manifesto filosófico, +- não é ficção científica, +- não promete consciência artificial, +- não é um produto comercial. + +Trata-se de um **experimento técnico-científico exploratório**, documentado de forma transparente, com falhas, limitações e decisões explicitamente registadas. + +--- + +## 3.10 Estado Atual do Sistema + +No estado atual, o NFDOS apresenta: + +- sistema funcional e executável, +- mecanismos homeostáticos mínimos implementados, +- observabilidade ativa, +- memória episódica integrada, +- documentação extensiva. + +O desenvolvimento encontra-se numa fase exploratória, privilegiando **compreensão estrutural antes de expansão funcional**. + +--- + +## 3.11 Continuidade do Trabalho + +Os documentos complementares, logs experimentais, variações arquiteturais e narrativas técnicas permanecem disponíveis como material de apoio. + +Este capítulo fornece uma visão consolidada necessária para: +- análise crítica, +- reprodução conceptual, +- diálogo interdisciplinar. + +--- + +## 3.12 Síntese + +Nós não estamos a otimizar resultados isolados. +Nós estamos a investigar **quais são as condições que permitem a um sistema permanecer viável ao longo do tempo**. + +Este trabalho posiciona-se, assim, no domínio da **engenharia de sistemas viáveis**, distinguindo-se de abordagens orientadas a desempenho ou previsão. + +Não se trata de hype, mas de exploração fundamentada. diff --git a/src/docs/wiki/Architecture.md b/src/docs/wiki/Architecture.md index e69de29..e3d01aa 100644 --- a/src/docs/wiki/Architecture.md +++ b/src/docs/wiki/Architecture.md @@ -0,0 +1,22 @@ +``` +┌───────────────┐ +│ Kernel │ +│ │ +│ console=tty0 │─── VGA (mensagens kernel) +│ console=ttyS0 │─── Serial (debug) +└───────┬───────┘ + │ +┌───────▼───────┐ +│ init (PID 1) │ +│ │ +│ chvt 1 │ +│ setsid │ +│ exec tty1 │ +└───────┬───────┘ + │ +┌───────▼───────┐ +│ Neurotron │ +│ Dashboard v2 │ +│ Corpo visual │ +└───────────────┘ +``` \ No newline at end of file diff --git a/src/tui/menu_kernel.py b/src/tui/menu_kernel.py index b36a8c3..e327e47 100644 --- a/src/tui/menu_kernel.py +++ b/src/tui/menu_kernel.py @@ -146,17 +146,19 @@ def corrigir_kernel_overrides(cross_compile): "CONFIG_EXT4_USE_FOR_EXT2", "CONFIG_CMDLINE_PARTITION", "CONFIG_MCORE2", + # estes estao sendo testados #"CONFIG_EXT4_FS_POSIX_ACL", #"CONFIG_EXT4_FS_SECURITY", - # Console VGA (comentado para modo serial-only) - # "CONFIG_VT", - # "CONFIG_VT_CONSOLE", - # "CONFIG_VGA_CONSOLE", + # Console VGA (comentar para modo serial-only) + "CONFIG_VT", + "CONFIG_VT_CONSOLE", + "CONFIG_VGA_CONSOLE", + "CONFIG_FRAMEBUFFER_CONSOLE", + "CONFIG_FONT_8x16", + "CONFIG_FONT_8x8", + "CONFIG_FB_VESA", + # estes estao sendo testados # "CONFIG_FB", - # "CONFIG_FB_VESA", - # "CONFIG_FRAMEBUFFER_CONSOLE", - # "CONFIG_FONT_8x16", - # "CONFIG_FONT_8x8", # # "CONFIG_X86_MCE", # # "CONFIG_X86_MCE_INTEL", # "CONFIG_X86_LOCAL_APIC", @@ -210,12 +212,12 @@ def corrigir_kernel_overrides(cross_compile): # "CONFIG_X86_PAT", # "CONFIG_X86_PSE", # modo serial-only - "CONFIG_VT", - "CONFIG_VT_CONSOLE", - "CONFIG_VGA_CONSOLE", - "CONFIG_FRAMEBUFFER_CONSOLE", + # "CONFIG_VT", + # "CONFIG_VT_CONSOLE", + # "CONFIG_VGA_CONSOLE", + # "CONFIG_FRAMEBUFFER_CONSOLE", + # "CONFIG_FB", "CONFIG_DUMMY_CONSOLE", - "CONFIG_FB", "CONFIG_DRM", "CONFIG_DRM_I915", "CONFIG_LOGO", @@ -905,7 +907,7 @@ def run(): # 🧠 Monta a linha base do QEMU kernel_params = ( - "console=ttyS0 earlyprintk=serial,ttyS0,115200 " + "console=tty0 console=ttyS0 earlyprintk=serial,ttyS0,115200 " "keep_bootcon loglevel=8" ) @@ -918,10 +920,10 @@ def run(): f"-append '{kernel_params}' " f"-drive file={data_disk},if=virtio,format=raw " f"-m 1024 " - # f"-vga std " - # f"-display default " + f"-vga std " + f"-display default " f"-serial mon:stdio " - f"-nographic " + # f"-nographic " f"-no-reboot" )