@smilintux/skcapstone 0.9.0 → 0.12.5

package/src/skcapstone/daemon.py

@@ -54,6 +54,36 @@ DEFAULT_PORT = 7777
 PID_FILE = "daemon.pid"
 LOG_DIR = "logs"
 
+
+def _sd_notify(state: str) -> bool:
+    """Send a notification to systemd via the NOTIFY_SOCKET.
+
+    Implements the sd_notify(3) protocol using a raw AF_UNIX datagram socket
+    so we don't need an external dependency.  Returns True if the notification
+    was sent, False if NOTIFY_SOCKET is not set (i.e. not running under systemd).
+
+    Common states:
+        "READY=1"       — service startup complete
+        "WATCHDOG=1"    — watchdog keep-alive ping
+        "STOPPING=1"    — graceful shutdown in progress
+    """
+    addr = os.environ.get("NOTIFY_SOCKET")
+    if not addr:
+        return False
+    import socket as _socket
+    try:
+        sock = _socket.socket(_socket.AF_UNIX, _socket.SOCK_DGRAM)
+        try:
+            if addr[0] == "@":
+                addr = "\0" + addr[1:]
+            sock.sendto(state.encode("utf-8"), addr)
+        finally:
+            sock.close()
+        return True
+    except OSError as exc:
+        logger.debug("sd_notify(%r) failed: %s", state, exc)
+        return False
+
 # ── WebSocket helpers (RFC 6455, stdlib-only) ─────────────────────────────────
 
 _WS_MAGIC = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
@@ -685,7 +715,7 @@ class DaemonService:
         self._stop_event = threading.Event()
         self._threads: list[threading.Thread] = []
         self._server: Optional[HTTPServer] = None
-        self._skcomm = None
+        self._skcomms = None
         self._runtime = None
         self._consciousness = None
         self._healer = None
@@ -770,10 +800,12 @@ class DaemonService:
 
         self._start_api_server()
 
+        _sd_notify("READY=1")
         logger.info("Daemon started — PID %d", os.getpid())
 
     def stop(self) -> None:
         """Gracefully stop the daemon and all workers."""
+        _sd_notify("STOPPING=1")
         logger.info("Daemon stopping...")
         self._stop_event.set()
         self.state.running = False
@@ -852,16 +884,22 @@ class DaemonService:
             logger.info("Preflight complete — all checks passed")
 
     def _load_components(self) -> None:
-        """Attempt to load SKComm, AgentRuntime, and ConsciousnessLoop."""
+        """Attempt to load SKComms, AgentRuntime, and ConsciousnessLoop."""
         try:
-            from skcomm.core import SKComm
-            self._skcomm = SKComm.from_config()
-            logger.info("SKComm loaded — %d transports", len(self._skcomm.router.transports))
+            from skcomms.core import SKComms
+            from .sync_engine import ensure_comms_dirs, get_comms_root
+            self._skcomms = SKComms.from_config()
+            expected_comms_root = get_comms_root(self.config.shared_root)
+            ensure_comms_dirs(self.config.shared_root)
+            for transport in self._skcomms.router.transports:
+                if getattr(transport, "name", "") == "syncthing" and hasattr(transport, "configure"):
+                    transport.configure({"comms_root": str(expected_comms_root)})
+            logger.info("SKComms loaded — %d transports", len(self._skcomms.router.transports))
         except ImportError:
-            logger.warning("SKComm not installed — inbox polling disabled")
+            logger.warning("SKComms not installed — inbox polling disabled")
         except Exception as exc:
-            logger.warning("SKComm failed to load: %s", exc)
-            self.state.record_error(f"SKComm load: {exc}")
+            logger.warning("SKComms failed to load: %s", exc)
+            self.state.record_error(f"SKComms load: {exc}")
 
         try:
             from .runtime import get_runtime
@@ -898,8 +936,8 @@ class DaemonService:
                         home=self.config.home,
                         shared_root=self.config.shared_root,
                     )
-                    if self._skcomm:
-                        self._consciousness.set_skcomm(self._skcomm)
+                    if self._skcomms:
+                        self._consciousness.set_skcomms(self._skcomms)
                     logger.info("Consciousness loop loaded")
 
                     # Preload Ollama model into RAM so first real message is fast
@@ -953,12 +991,12 @@ class DaemonService:
             self.state.record_error(f"Scheduler build: {exc}")
 
     def _poll_loop(self) -> None:
-        """Continuously poll SKComm inbox for new messages."""
+        """Continuously poll SKComms inbox for new messages."""
         while not self._stop_event.is_set():
             self._component_mgr.heartbeat("poll")
-            if self._skcomm:
+            if self._skcomms:
                 try:
-                    envelopes = self._skcomm.receive()
+                    envelopes = self._skcomms.receive()
                     count = len(envelopes)
                     self.state.record_poll(count)
                     if count > 0:
@@ -973,12 +1011,13 @@ class DaemonService:
             self._stop_event.wait(timeout=self.config.poll_interval)
 
     def _health_loop(self) -> None:
-        """Periodically check transport health."""
+        """Periodically check transport health and ping systemd watchdog."""
         while not self._stop_event.is_set():
             self._component_mgr.heartbeat("health")
-            if self._skcomm:
+            _sd_notify("WATCHDOG=1")
+            if self._skcomms:
                 try:
-                    report = self._skcomm.status()
+                    report = self._skcomms.status()
                     transports = report.get("transports", {})
                     serializable = {}
                     for name, health in transports.items():
@@ -1127,10 +1166,10 @@ class DaemonService:
                 self.state.record_error(f"Process message: {exc}")
 
     def _journal_incoming(self, sender: str, preview: str) -> None:
-        """Auto-journal an incoming SKComm message and store a tagged memory.
+        """Auto-journal an incoming SKComms message and store a tagged memory.
 
         Writes a journal entry (title='From {sender}', moments=[preview]) and
-        stores a short-term memory tagged 'skcomm-received'.  Both operations
+        stores a short-term memory tagged 'skcomms-received'.  Both operations
         are best-effort: failures are logged at DEBUG level and never bubble up.
         """
         try:
@@ -1145,24 +1184,26 @@ class DaemonService:
             logger.debug("Auto-journal write failed: %s", exc)
 
         try:
-            self._store_skcomm_receipt(sender, preview)
-            logger.debug("SKComm receipt stored for incoming message from %s", sender)
+            self._store_skcomms_receipt(sender, preview)
+            logger.debug("SKComms receipt stored for incoming message from %s", sender)
         except Exception as exc:
-            logger.debug("SKComm receipt store failed: %s", exc)
+            logger.debug("SKComms receipt store failed: %s", exc)
 
-    def _store_skcomm_receipt(self, sender: str, preview: str) -> None:
-        """Write a skcomm receipt to the skcomm/received/ directory.
+    def _store_skcomms_receipt(self, sender: str, preview: str) -> None:
+        """Write a skcomms receipt to the skcomms/received/ directory.
 
         These are transport bookkeeping, NOT persistent memories, so they
-        go to ``~/.skcapstone/agents/{agent}/skcomm/received/`` instead of
+        go to ``~/.skcapstone/agents/{agent}/skcomms/received/`` instead of
         polluting the memory/ tree that skmemory indexes.
         """
         import json
         import uuid
         from datetime import datetime, timezone
 
-        agent_name = os.environ.get("SKCAPSTONE_AGENT", "lumina")
-        recv_dir = self.config.home / "agents" / agent_name / "skcomm" / "received"
+        from . import active_agent_name
+
+        agent_name = os.environ.get("SKCAPSTONE_AGENT") or active_agent_name()
+        recv_dir = self.config.home / "agents" / agent_name / "skcomms" / "received"
         recv_dir.mkdir(parents=True, exist_ok=True)
 
         receipt_id = uuid.uuid4().hex[:12]
@@ -1262,7 +1303,8 @@ class DaemonService:
                 try:
                     ts = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
                     return datetime.now(timezone.utc) <= ts + timedelta(seconds=ttl)
-                except Exception:
+                except Exception as e:
+                    logger.warning("Failed to parse heartbeat timestamp %r: %s", ts_str, e)
                     return False
 
             @staticmethod
@@ -1275,21 +1317,31 @@ class DaemonService:
                     stats["disk_total_gb"] = round(usage.total / (1024 ** 3), 1)
                     stats["disk_used_gb"] = round(usage.used / (1024 ** 3), 1)
                     stats["disk_free_gb"] = round(usage.free / (1024 ** 3), 1)
-                except Exception:
+                except Exception as e:
+                    logger.warning("Failed to collect disk stats: %s", e)
                     stats.update(disk_total_gb=0, disk_used_gb=0, disk_free_gb=0)
                 try:
-                    meminfo: dict = {}
-                    with open("/proc/meminfo") as fh:
-                        for line in fh:
-                            parts = line.split()
-                            if len(parts) >= 2:
-                                meminfo[parts[0].rstrip(":")] = int(parts[1])
-                    total_kb = meminfo.get("MemTotal", 0)
-                    avail_kb = meminfo.get("MemAvailable", 0)
-                    stats["memory_total_mb"] = round(total_kb / 1024)
-                    stats["memory_used_mb"] = round((total_kb - avail_kb) / 1024)
-                    stats["memory_free_mb"] = round(avail_kb / 1024)
-                except Exception:
+                    import platform as _platform
+                    if _platform.system() == "Linux":
+                        meminfo: dict = {}
+                        with open("/proc/meminfo") as fh:
+                            for line in fh:
+                                parts = line.split()
+                                if len(parts) >= 2:
+                                    meminfo[parts[0].rstrip(":")] = int(parts[1])
+                        total_kb = meminfo.get("MemTotal", 0)
+                        avail_kb = meminfo.get("MemAvailable", 0)
+                        stats["memory_total_mb"] = round(total_kb / 1024)
+                        stats["memory_used_mb"] = round((total_kb - avail_kb) / 1024)
+                        stats["memory_free_mb"] = round(avail_kb / 1024)
+                    else:
+                        import psutil
+                        mem = psutil.virtual_memory()
+                        stats["memory_total_mb"] = round(mem.total / (1024 * 1024))
+                        stats["memory_used_mb"] = round((mem.total - mem.available) / (1024 * 1024))
+                        stats["memory_free_mb"] = round(mem.available / (1024 * 1024))
+                except Exception as e:
+                    logger.warning("Failed to collect memory stats: %s", e)
                     stats.update(memory_total_mb=0, memory_used_mb=0, memory_free_mb=0)
                 return stats
 
@@ -1304,16 +1356,16 @@ class DaemonService:
                     try:
                         agent_name = runtime.manifest.name or agent_name
                         agent_fingerprint = getattr(runtime.manifest, "fingerprint", "")
-                    except Exception:
-                        pass
+                    except Exception as exc:
+                        logger.warning("Failed to read agent name from runtime manifest: %s", exc)
                 identity_file = config.home / "identity" / "identity.json"
                 if identity_file.exists():
                     try:
                         ident = json.loads(identity_file.read_text(encoding="utf-8"))
                         agent_name = ident.get("name", agent_name)
                         agent_fingerprint = ident.get("fingerprint", agent_fingerprint)
-                    except Exception:
-                        pass
+                    except Exception as exc:
+                        logger.warning("Failed to read identity.json for dashboard: %s", exc)
 
                 # Consciousness stats
                 c_stats: dict = snap.get("consciousness", {})
@@ -1339,10 +1391,10 @@ class DaemonService:
                                         "message_count": len(msgs),
                                         "last_message": msgs[-1].get("timestamp") if msgs else None,
                                     })
-                            except Exception:
-                                pass
-                    except Exception:
-                        pass
+                            except Exception as exc:
+                                logger.warning("Failed to read conversation file %s: %s", cf, exc)
+                    except Exception as exc:
+                        logger.warning("Failed to list conversation files: %s", exc)
 
                 return {
                     "agent": {
@@ -1384,16 +1436,16 @@ class DaemonService:
                             agent["consciousness"] = "SINGULAR"
                         elif m.is_conscious:
                             agent["consciousness"] = "CONSCIOUS"
-                    except Exception:
-                        pass
+                    except Exception as exc:
+                        logger.warning("Failed to read agent identity from runtime manifest: %s", exc)
                 identity_file = config.home / "identity" / "identity.json"
                 if identity_file.exists():
                     try:
                         ident = json.loads(identity_file.read_text(encoding="utf-8"))
                         agent["name"] = ident.get("name", agent["name"])
                         agent["fingerprint"] = ident.get("fingerprint", agent["fingerprint"])
-                    except Exception:
-                        pass
+                    except Exception as exc:
+                        logger.warning("Failed to read identity.json for capstone dashboard: %s", exc)
 
                 # ── Pillar status ─────────────────────────────────────────
                 pillars: dict = {}
@@ -1403,8 +1455,8 @@ class DaemonService:
                             k: v.value
                             for k, v in runtime.manifest.pillar_summary.items()
                         }
-                    except Exception:
-                        pass
+                    except Exception as exc:
+                        logger.warning("Failed to read pillar summary from manifest: %s", exc)
 
                 # ── Memory stats ──────────────────────────────────────────
                 memory: dict = {}
@@ -1418,8 +1470,8 @@ class DaemonService:
                         "long_term": ms.long_term,
                         "status": ms.status.value,
                     }
-                except Exception:
-                    pass
+                except Exception as exc:
+                    logger.warning("Failed to collect memory stats for dashboard: %s", exc)
 
                 # ── Coordination board ────────────────────────────────────
                 board: dict = {"summary": {}, "active": []}
@@ -1453,16 +1505,16 @@ class DaemonService:
                         },
                         "active": active_tasks,
                     }
-                except Exception:
-                    pass
+                except Exception as exc:
+                    logger.warning("Failed to collect coordination board data for dashboard: %s", exc)
 
                 # ── Consciousness stats ───────────────────────────────────
                 c_stats: dict = {}
                 if consciousness:
                     try:
                         c_stats = dict(consciousness.stats)
-                    except Exception:
-                        pass
+                    except Exception as exc:
+                        logger.warning("Failed to read consciousness stats for dashboard: %s", exc)
 
                 return {
                     "agent": agent,
@@ -1836,17 +1888,18 @@ class DaemonService:
 
                     fingerprint: Optional[str] = None
                     try:
-                        from skcomm.capauth_validator import CapAuthValidator
+                        from skcomms.capauth_validator import CapAuthValidator
                         fingerprint = CapAuthValidator(require_auth=True).validate(token_str)
                     except ImportError:
-                        # skcomm not installed — fall back to skcapstone signed tokens
+                        # skcomms not installed — fall back to skcapstone signed tokens
                         if token_str:
                             try:
                                 from .tokens import import_token, verify_token
                                 tok = import_token(token_str)
                                 if verify_token(tok, home=config.home):
                                     fingerprint = tok.payload.issuer
-                            except Exception:
+                            except Exception as e:
+                                logger.warning("Token verification fallback failed: %s", e)
                                 fingerprint = None
 
                     if fingerprint is None:
@@ -1976,8 +2029,8 @@ class DaemonService:
                                     entry["identity"] = json.loads(
                                         identity_path.read_text(encoding="utf-8")
                                     )
-                                except Exception:
-                                    pass
+                                except Exception as exc:
+                                    logger.warning("Failed to read identity for agent %s: %s", agent_name, exc)
 
                             hb_path = heartbeats_dir / f"{agent_name.lower()}.json"
                             if hb_path.exists():
@@ -1987,7 +2040,8 @@ class DaemonService:
                                     hb["alive"] = alive
                                     entry["heartbeat"] = hb
                                     entry["status"] = hb.get("status", "unknown") if alive else "stale"
-                                except Exception:
+                                except Exception as exc:
+                                    logger.warning("Failed to read heartbeat for agent %s: %s", agent_name, exc)
                                     entry["status"] = "unknown"
                             else:
                                 entry["status"] = "no_heartbeat"
@@ -2019,8 +2073,8 @@ class DaemonService:
                             entry["identity"] = json.loads(
                                 identity_path.read_text(encoding="utf-8")
                             )
-                        except Exception:
-                            pass
+                        except Exception as exc:
+                            logger.warning("Failed to read identity for agent %s: %s", name, exc)
 
                     hb_path = config.shared_root / "heartbeats" / f"{name.lower()}.json"
                     if hb_path.exists():
@@ -2030,8 +2084,8 @@ class DaemonService:
                             hb["alive"] = alive
                             entry["heartbeat"] = hb
                             entry["status"] = hb.get("status", "unknown") if alive else "stale"
-                        except Exception:
-                            pass
+                        except Exception as exc:
+                            logger.warning("Failed to read heartbeat for agent %s: %s", name, exc)
 
                     memory_dir = agent_dir / "memory"
                     if memory_dir.exists():
@@ -2054,8 +2108,8 @@ class DaemonService:
                                         "message_count": len(msgs),
                                         "last_message": msgs[-1].get("timestamp") if msgs else None,
                                     })
-                            except Exception:
-                                pass
+                            except Exception as exc:
+                                logger.warning("Failed to read conversation file %s: %s", cf, exc)
                     entry["recent_conversations"] = conv_list
 
                     if consciousness:
@@ -2084,8 +2138,8 @@ class DaemonService:
                                         "last_message_time": last_msg.get("timestamp") if msgs else None,
                                         "last_message_preview": (last_content or "")[:120],
                                     })
-                            except Exception:
-                                pass
+                            except Exception as exc:
+                                logger.warning("Failed to read conversation file %s: %s", cf, exc)
                     self._json_response({"conversations": conversations})
 
                 # ── Conversations: single peer history ────────────────────
@@ -2164,7 +2218,8 @@ class DaemonService:
                         length = int(self.headers.get("Content-Length", 0))
                         body = self.rfile.read(length) if length > 0 else b"{}"
                         data = json.loads(body)
-                    except Exception:
+                    except Exception as e:
+                        logger.warning("Failed to parse request JSON body: %s", e)
                         self._json_response({"error": "invalid JSON body"}, status=400)
                         return
 
@@ -2176,7 +2231,7 @@ class DaemonService:
                     message_id = str(uuid.uuid4())
                     ts = datetime.now(timezone.utc).isoformat()
 
-                    # Build SKComm envelope
+                    # Build SKComms envelope
                     envelope = {
                         "message_id": message_id,
                         "sender": "api",
@@ -2188,7 +2243,7 @@ class DaemonService:
                         },
                     }
 
-                    # Write to SKComm outbox
+                    # Write to SKComms outbox
                     try:
                         outbox = config.shared_root / "sync" / "comms" / "outbox"
                         outbox.mkdir(parents=True, exist_ok=True)
@@ -2461,23 +2516,31 @@ class DaemonService:
 def read_pid(home: Optional[Path] = None) -> Optional[int]:
     """Read the daemon PID from the PID file.
 
+    Checks the given home directory first, then falls back to the shared
+    root (AGENT_HOME / ~/.skcapstone) since the daemon writes its PID
+    to config.home which defaults to the shared root.
+
     Args:
-        home: Agent home directory.
+        home: Agent home directory (or shared root).
 
     Returns:
         PID as int, or None if not running.
     """
     home = (home or Path(AGENT_HOME)).expanduser()
-    pid_path = home / PID_FILE
-    if not pid_path.exists():
-        return None
-    try:
-        pid = int(pid_path.read_text(encoding="utf-8").strip())
-        os.kill(pid, 0)
-        return pid
-    except (ValueError, ProcessLookupError, PermissionError):
-        pid_path.unlink(missing_ok=True)
-        return None
+    shared_root = Path(AGENT_HOME).expanduser()
+
+    # Check agent home first, then shared root
+    for candidate in (home, shared_root):
+        pid_path = candidate / PID_FILE
+        if not pid_path.exists():
+            continue
+        try:
+            pid = int(pid_path.read_text(encoding="utf-8").strip())
+            os.kill(pid, 0)
+            return pid
+        except (ValueError, ProcessLookupError, PermissionError):
+            pid_path.unlink(missing_ok=True)
+    return None
 
 
 def is_running(home: Optional[Path] = None) -> bool:

package/src/skcapstone/dashboard.py

@@ -240,8 +240,8 @@ def _get_daemon_json(home: Path, daemon_port: int = 7777) -> dict:
             "recent_errors": recent_errors,
             "inflight_count": snap.get("inflight_count", 0),
         }
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("Failed to fetch daemon status for dashboard: %s", exc)
 
     # ── Daemon /consciousness ─────────────────────────────────────────────────
     consciousness_info: dict = {"enabled": False}
@@ -249,8 +249,8 @@ def _get_daemon_json(home: Path, daemon_port: int = 7777) -> dict:
         url = f"http://127.0.0.1:{daemon_port}/consciousness"
         with urllib.request.urlopen(url, timeout=3) as resp:
             consciousness_info = json.loads(resp.read())
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("Failed to fetch consciousness status for dashboard: %s", exc)
 
     # ── LLM backend availability ──────────────────────────────────────────────
     backend_health: dict = {
@@ -266,16 +266,16 @@ def _get_daemon_json(home: Path, daemon_port: int = 7777) -> dict:
             urllib.request.Request(f"{ollama_host}/api/tags"), timeout=2
         ):
             backend_health["ollama"] = True
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("Ollama probe failed (not available): %s", exc)
 
     # ── Heartbeat (system metrics + active conversations) ─────────────────────
     system_info: dict = {}
     active_conversations: int = 0
     try:
-        from . import SHARED_ROOT
+        from . import SHARED_ROOT, DEFAULT_AGENT
         identity_path = home / "identity" / "identity.json"
-        agent_name = "opus"
+        agent_name = DEFAULT_AGENT
         if identity_path.exists():
             ident = json.loads(identity_path.read_text(encoding="utf-8"))
             agent_name = ident.get("name", agent_name).lower()
@@ -291,8 +291,8 @@ def _get_daemon_json(home: Path, daemon_port: int = 7777) -> dict:
                 "cpu_load_1min": hb.get("cpu_load_1min", 0.0),
                 "memory_used_mb": hb.get("memory_used_mb", 0),
             }
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("Failed to read heartbeat data for dashboard: %s", exc)
 
     return {
         "generated_at": now,