chore: absorbe nakui (ERP matemático) en modules/nakui

- crates/modules/nakui/core/: el crate nakui-core (4 bins, tests).
  Deps directas (serde, rhai, surrealdb, petgraph, sha2, uuid, tokio,
  thiserror v1) — no convertidas a workspace = true en esta pasada.
- crates/modules/nakui/modules/{inventory,sales,treasury}/: datos
  declarativos del dominio (nsmc.json, schema.k, morphisms/) que el
  crate consume — no son crates.

cargo check -p nakui-core: 0 errores.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

crates/modules/nakui/core/tests/run.rs

@@ -0,0 +1,286 @@
+//! End-to-end tests for `nakui run` — bind a socket from the main test
+//! thread, drive it from a client thread with line-JSON requests, and
+//! assert behaviour through the wire.
+//!
+//! Why server-on-main / client-on-thread: `Executor` is `!Send` (Rhai
+//! caches AST in a `RefCell`). Moving it across thread boundaries is a
+//! compile-time error, so the test thread runs the server and a worker
+//! thread plays the client. The worker calls `shutdown` last, which lets
+//! the main thread return from `run_server` and join.
+
+use std::io::{BufRead, BufReader, Write};
+use std::os::unix::net::UnixStream;
+use std::path::{Path, PathBuf};
+use std::thread;
+use std::time::Duration;
+
+use nakui_core::event_log::{EventLog, execute_and_log, seed_and_log};
+use nakui_core::executor::Executor;
+use nakui_core::run::run_server;
+use nakui_core::store::MemoryStore;
+use serde_json::{Value, json};
+use uuid::Uuid;
+
+fn workspace_root() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .expect("workspace root above core/")
+        .to_path_buf()
+}
+
+fn treasury_module() -> PathBuf {
+    workspace_root().join("modules/treasury")
+}
+
+fn fresh_log_path() -> PathBuf {
+    std::env::temp_dir().join(format!("nakui_run_log_{}.jsonl", Uuid::new_v4()))
+}
+
+fn fresh_socket_path() -> PathBuf {
+    std::env::temp_dir().join(format!("nakui_run_{}.sock", Uuid::new_v4()))
+}
+
+/// One client connection: keeps a single BufReader alive across
+/// exchanges so buffered bytes from one response don't get dropped
+/// before the next read.
+struct Conn {
+    writer: UnixStream,
+    reader: BufReader<UnixStream>,
+}
+
+impl Conn {
+    fn connect_with_retry(path: &Path) -> Self {
+        for _ in 0..100 {
+            if let Ok(stream) = UnixStream::connect(path) {
+                let reader_stream = stream.try_clone().expect("clone for reader");
+                return Self {
+                    writer: stream,
+                    reader: BufReader::new(reader_stream),
+                };
+            }
+            thread::sleep(Duration::from_millis(20));
+        }
+        panic!("server never started accepting on {}", path.display());
+    }
+
+    fn exchange(&mut self, req: Value) -> Value {
+        let mut s = serde_json::to_vec(&req).expect("serialize request");
+        s.push(b'\n');
+        self.writer.write_all(&s).expect("write request");
+        let mut line = String::new();
+        let n = self.reader.read_line(&mut line).expect("read response");
+        assert!(n > 0, "server closed connection without responding");
+        serde_json::from_str(line.trim()).expect("parse response")
+    }
+}
+
+#[test]
+fn run_server_full_protocol_round_trip() {
+    let log_path = fresh_log_path();
+    let socket_path = fresh_socket_path();
+
+    let caja_id = Uuid::new_v4();
+    {
+        let executor = Executor::load_module(treasury_module()).expect("load module");
+        let mut log = EventLog::open(&log_path).expect("open log");
+        let mut store = MemoryStore::new();
+        seed_and_log(
+            &executor,
+            &mut store,
+            &mut log,
+            "Caja",
+            caja_id,
+            json!({
+                "id": caja_id.to_string(),
+                "name": "A",
+                "saldo": 100_000_i64,
+                "currency": "USD",
+            }),
+        )
+        .expect("seed");
+    }
+
+    let executor = Executor::load_module(treasury_module()).expect("load module");
+    let log = EventLog::open(&log_path).expect("reopen log");
+    let store = MemoryStore::new();
+
+    let socket_for_client = socket_path.clone();
+    let client = thread::spawn(move || -> Result<(), String> {
+        let mut conn = Conn::connect_with_retry(&socket_for_client);
+
+        let resp = conn.exchange(json!({"op": "describe"}));
+        if resp["ok"] != json!(true) {
+            return Err(format!("describe not ok: {}", resp));
+        }
+        if resp["module"] != json!("treasury") {
+            return Err(format!("module mismatch: {}", resp));
+        }
+        if resp["protocol"] != json!(1) {
+            return Err(format!("protocol mismatch: {}", resp));
+        }
+        let morphisms = resp["morphisms"]
+            .as_array()
+            .ok_or("morphisms not array")?;
+        if !morphisms.iter().any(|m| m["name"] == "register_cash_move") {
+            return Err("register_cash_move missing from describe".into());
+        }
+
+        let resp = conn.exchange(json!({
+            "op": "load",
+            "entity": "Caja",
+            "id": caja_id.to_string(),
+        }));
+        if resp["value"]["saldo"].as_i64() != Some(100_000) {
+            return Err(format!("initial saldo wrong: {}", resp));
+        }
+
+        let resp = conn.exchange(json!({
+            "op": "execute",
+            "morphism": "register_cash_move",
+            "inputs": {"caja": caja_id.to_string()},
+            "params": {
+                "monto": 5_000_i64,
+                "tipo": "in",
+                "timestamp": "2026-05-04T10:00:00Z",
+                "memo": "via run",
+                "movimiento_id": Uuid::new_v4().to_string(),
+            },
+        }));
+        if resp["ok"] != json!(true) {
+            return Err(format!("execute failed: {}", resp));
+        }
+        if resp["seq"].as_u64().is_none() {
+            return Err(format!("execute missing seq: {}", resp));
+        }
+        if resp["ops"].as_array().map(|a| a.is_empty()).unwrap_or(true) {
+            return Err(format!("execute missing ops: {}", resp));
+        }
+
+        let resp = conn.exchange(json!({
+            "op": "load",
+            "entity": "Caja",
+            "id": caja_id.to_string(),
+        }));
+        if resp["value"]["saldo"].as_i64() != Some(105_000) {
+            return Err(format!("post-execute saldo wrong: {}", resp));
+        }
+
+        // Kernel rejection: returns ok=false with stage=pre_log.
+        let other = Uuid::new_v4();
+        let resp = conn.exchange(json!({
+            "op": "execute",
+            "morphism": "transfer_between_cajas",
+            "inputs": {"source": caja_id.to_string(), "dest": other.to_string()},
+            "params": {
+                "monto": 999_999_999_i64,
+                "timestamp": "2026-05-04T10:30:00Z",
+                "memo": "overdraw",
+                "transfer_id": Uuid::new_v4().to_string(),
+            },
+        }));
+        if resp["ok"] != json!(false) || resp["stage"] != json!("pre_log") {
+            return Err(format!("expected pre_log rejection: {}", resp));
+        }
+
+        // Bad JSON — connection survives, server keeps serving.
+        conn.writer.write_all(b"not json\n").map_err(|e| e.to_string())?;
+        let mut line = String::new();
+        conn.reader.read_line(&mut line).map_err(|e| e.to_string())?;
+        let parsed: Value = serde_json::from_str(line.trim()).map_err(|e| e.to_string())?;
+        if parsed["ok"] != json!(false) {
+            return Err(format!("bad request didn't get error: {}", parsed));
+        }
+
+        let resp = conn.exchange(json!({"op": "verify"}));
+        if resp["ok"] != json!(true) {
+            return Err(format!("verify failed: {}", resp));
+        }
+        if resp["entries"].as_u64() != Some(2) {
+            return Err(format!("verify entries wrong: {}", resp));
+        }
+
+        let resp = conn.exchange(json!({"op": "shutdown"}));
+        if resp["ok"] != json!(true) || resp["shutdown"] != json!(true) {
+            return Err(format!("shutdown response wrong: {}", resp));
+        }
+        Ok(())
+    });
+
+    run_server(executor, log, store, None, &socket_path).expect("server clean exit");
+    client.join().expect("client thread joined").expect("client assertions");
+
+    assert!(
+        !socket_path.exists(),
+        "shutdown must remove the socket file"
+    );
+    let _ = std::fs::remove_file(&log_path);
+}
+
+#[test]
+fn run_server_reconciles_drifted_store_on_startup() {
+    let log_path = fresh_log_path();
+    let socket_path = fresh_socket_path();
+
+    let caja_id = Uuid::new_v4();
+    {
+        let executor = Executor::load_module(treasury_module()).expect("load");
+        let mut log = EventLog::open(&log_path).expect("open log");
+        let mut store = MemoryStore::new();
+        seed_and_log(
+            &executor,
+            &mut store,
+            &mut log,
+            "Caja",
+            caja_id,
+            json!({
+                "id": caja_id.to_string(),
+                "name": "A",
+                "saldo": 200_000_i64,
+                "currency": "USD",
+            }),
+        )
+        .expect("seed");
+        execute_and_log(
+            &executor,
+            &mut store,
+            &mut log,
+            "register_cash_move",
+            &[("caja", caja_id)],
+            json!({
+                "monto": 1_500_i64,
+                "tipo": "in",
+                "timestamp": "2026-05-04T09:00:00Z",
+                "memo": "pre-run",
+                "movimiento_id": Uuid::new_v4().to_string(),
+            }),
+        )
+        .expect("deposit");
+    }
+
+    let executor = Executor::load_module(treasury_module()).expect("load");
+    let log = EventLog::open(&log_path).expect("reopen");
+    let empty_store = MemoryStore::new();
+
+    let socket_for_client = socket_path.clone();
+    let client = thread::spawn(move || -> Result<(), String> {
+        let mut conn = Conn::connect_with_retry(&socket_for_client);
+        let resp = conn.exchange(json!({
+            "op": "load",
+            "entity": "Caja",
+            "id": caja_id.to_string(),
+        }));
+        if resp["value"]["saldo"].as_i64() != Some(201_500) {
+            return Err(format!(
+                "expected saldo 201_500 (200k seed + 1.5k replayed deposit), got {}",
+                resp
+            ));
+        }
+        conn.exchange(json!({"op": "shutdown"}));
+        Ok(())
+    });
+
+    run_server(executor, log, empty_store, None, &socket_path).expect("clean exit");
+    client.join().unwrap().expect("client assertions");
+
+    let _ = std::fs::remove_file(&log_path);
+}