@smilintux/skcapstone 0.2.6 → 0.3.2

package/src/skcapstone/notifications.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import datetime
 import logging
+import os
 import platform
 import subprocess
 import threading
@@ -43,53 +44,65 @@ _TERMINAL_CMDS: list[list[str]] = [
 
 
 def _store_notification_memory(title: str, body: str, urgency: str) -> None:
-    """Persist a short-term memory entry for every dispatched notification."""
+    """Log a notification dispatch to the skcomm/notifications/ directory.
+
+    These are transport bookkeeping, not persistent memories, so they
+    go to ``~/.skcapstone/agents/{agent}/skcomm/notifications/`` instead
+    of polluting the memory/ tree that skmemory indexes.
+    """
     try:
+        import json as _json
+        import uuid
         from . import AGENT_HOME
-        from .memory_engine import store as mem_store
-        from .models import MemoryLayer
 
         home = Path(AGENT_HOME).expanduser()
         if not home.exists():
             return
 
+        agent_name = os.environ.get("SKCAPSTONE_AGENT", "lumina")
+        notif_dir = home / "agents" / agent_name / "skcomm" / "notifications"
+        notif_dir.mkdir(parents=True, exist_ok=True)
+
         ts = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-        content = f"[{ts}] Notification sent — title={title!r} body={body!r} urgency={urgency}"
-        mem_store(
-            home=home,
-            content=content,
-            tags=["notification"],
-            source="notifications",
-            importance=0.3,
-            layer=MemoryLayer.SHORT_TERM,
-        )
+        entry = {
+            "id": uuid.uuid4().hex[:12],
+            "type": "notification-sent",
+            "title": title,
+            "body": body,
+            "urgency": urgency,
+            "timestamp": ts,
+        }
+        path = notif_dir / f"{entry['id']}.json"
+        path.write_text(_json.dumps(entry, indent=2), encoding="utf-8")
     except Exception as exc:
-        logger.debug("Failed to store notification memory: %s", exc)
+        logger.debug("Failed to store notification log: %s", exc)
 
 
 def _store_click_event(action: str, detail: str) -> None:
-    """Persist a short-term memory entry for a notification click action."""
+    """Log a notification click event to the skcomm/notifications/ directory."""
     try:
+        import json as _json
+        import uuid
         from . import AGENT_HOME
-        from .memory_engine import store as mem_store
-        from .models import MemoryLayer
 
         home = Path(AGENT_HOME).expanduser()
         if not home.exists():
             return
 
+        agent_name = os.environ.get("SKCAPSTONE_AGENT", "lumina")
+        notif_dir = home / "agents" / agent_name / "skcomm" / "notifications"
+        notif_dir.mkdir(parents=True, exist_ok=True)
+
         ts = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-        content = (
-            f"[{ts}] Notification click — action={action!r} detail={detail!r}"
-        )
-        mem_store(
-            home=home,
-            content=content,
-            tags=["notification", "click-event"],
-            source="notifications",
-            importance=0.3,
-            layer=MemoryLayer.SHORT_TERM,
-        )
+        entry = {
+            "id": uuid.uuid4().hex[:12],
+            "type": "click-event",
+            "action": action,
+            "detail": detail,
+            "timestamp": ts,
+        }
+        path = notif_dir / f"{entry['id']}.json"
+        path.write_text(_json.dumps(entry, indent=2), encoding="utf-8")
         logger.debug("Stored notification click event: %s → %s", action, detail)
     except Exception as exc:
         logger.debug("Failed to store click event in memory: %s", exc)

package/src/skcapstone/onboard.py

@@ -109,6 +109,52 @@ def _step_identity(home_path: Path, name: str, email: str | None) -> tuple[str,
 
         (home_path / "skills").mkdir(parents=True, exist_ok=True)
 
+        # Create full skeleton so all commands work from day one
+        agent_slug = name.lower().replace(" ", "-")
+        agent_dir = home_path / "agents" / agent_slug
+
+        skeleton_dirs = [
+            # Shared root directories
+            home_path / "heartbeats",
+            home_path / "peers",
+            home_path / "coordination" / "tasks",
+            home_path / "coordination" / "agents",
+            home_path / "logs",
+            home_path / "comms" / "inbox",
+            home_path / "comms" / "outbox",
+            home_path / "comms" / "archive",
+            home_path / "archive",
+            home_path / "deployments",
+            home_path / "docs",
+            home_path / "metrics",
+            # Per-agent directories
+            agent_dir / "memory" / "short-term",
+            agent_dir / "memory" / "mid-term",
+            agent_dir / "memory" / "long-term",
+            agent_dir / "soul" / "installed",
+            agent_dir / "wallet",
+            agent_dir / "seeds",
+            agent_dir / "identity",
+            agent_dir / "config",
+            agent_dir / "logs",
+            agent_dir / "security",
+            agent_dir / "cloud9",
+            agent_dir / "trust" / "febs",
+            agent_dir / "sync" / "outbox",
+            agent_dir / "sync" / "inbox",
+            agent_dir / "sync" / "archive",
+            agent_dir / "reflections",
+            agent_dir / "improvements",
+            agent_dir / "scripts",
+            agent_dir / "cron",
+            agent_dir / "archive",
+            agent_dir / "comms" / "inbox",
+            agent_dir / "comms" / "outbox",
+            agent_dir / "comms" / "archive",
+        ]
+        for d in skeleton_dirs:
+            d.mkdir(parents=True, exist_ok=True)
+
         manifest = {
             "name": name,
             "version": __version__,

package/src/skcapstone/pillars/sync.py

@@ -72,7 +72,7 @@ def initialize_sync(home: Path, config: Optional[SyncConfig] = None) -> SyncStat
         else:
             state.status = PillarStatus.DEGRADED
 
-    state.seed_count = _count_seeds(sync_dir)
+    state.seed_count = _count_seeds(sync_dir, home=home)
     return state
 
 
@@ -396,7 +396,7 @@ def discover_sync(home: Path) -> SyncState:
     state = SyncState(
         transport=transport,
         sync_path=sync_dir,
-        seed_count=_count_seeds(sync_dir),
+        seed_count=_count_seeds(sync_dir, home=home),
         status=PillarStatus.ACTIVE,
     )
 
@@ -483,8 +483,8 @@ def _get_hostname() -> str:
     return socket.gethostname()
 
 
-def _count_seeds(sync_dir: Path) -> int:
-    """Count seed files across outbox, inbox, and archive."""
+def _count_seeds(sync_dir: Path, home: Optional[Path] = None) -> int:
+    """Count seed files across sync subdirs and the agent seeds directory."""
     count = 0
     for subdir in ("outbox", "inbox", "archive"):
         d = sync_dir / subdir
@@ -492,6 +492,13 @@ def _count_seeds(sync_dir: Path) -> int:
             count += sum(
                 1 for f in d.iterdir() if f.name.endswith(SEED_EXTENSION) or f.suffix == ".gpg"
             )
+    # Also count seeds in the agent's seeds/ directory
+    if home is not None:
+        seeds_dir = home / "seeds"
+        if seeds_dir.is_dir():
+            count += sum(
+                1 for f in seeds_dir.iterdir() if f.name.endswith(SEED_EXTENSION)
+            )
     return count
 
 

package/src/skcapstone/register.py

@@ -97,6 +97,13 @@ def _build_package_registry(workspace: Optional[Path] = None) -> list[dict]:
             "mcp_env": None,
             "openclaw_plugin_path": workspace / "pillar-repos" / "sksecurity" / "openclaw-plugin" / "src" / "index.ts",
         },
+        {
+            "name": "skseed",
+            "mcp_cmd": None,
+            "mcp_args": None,
+            "mcp_env": None,
+            "openclaw_plugin_path": workspace / "pillar-repos" / "skseed" / "openclaw-plugin" / "src" / "index.ts",
+        },
         {
             "name": "skgit",
             "mcp_cmd": "node",
@@ -119,6 +126,7 @@ _PILLAR_DIR_MAP: dict[str, Optional[str]] = {
     "capauth": "capauth",
     "cloud9": "cloud9-python",
     "sksecurity": "sksecurity",
+    "skseed": "skseed",
     "skgit": None,  # skill dir only, no pillar repo
 }
 

package/src/skcapstone/scheduled_tasks.py

@@ -9,6 +9,7 @@ Built-in recurring tasks:
     - backend_reprobe        — every 5 minutes
     - memory_promotion_sweep — every hour
     - profile_freshness_check — every 24 hours
+    - dreaming_reflection    — every 15 minutes
 
 Usage:
     scheduler = build_scheduler(home, stop_event, consciousness_loop, beacon)
@@ -338,6 +339,85 @@ def make_profile_freshness_task(home: Path, max_age_days: int = 7) -> Callable[[
     return _run
 
 
+def make_dreaming_task(
+    home: Path, consciousness_loop: object = None
+) -> Callable[[], None]:
+    """Return a callback that runs the dreaming engine every 15 minutes.
+
+    Instantiates DreamingEngine lazily (so import errors are deferred until
+    first run). The engine itself checks idle state and cooldown internally.
+
+    Args:
+        home: Agent home directory.
+        consciousness_loop: ConsciousnessLoop instance for idle detection.
+    """
+
+    def _run() -> None:
+        from .consciousness_config import load_dreaming_config
+        from .dreaming import DreamingEngine
+
+        config = load_dreaming_config(home)
+        if config is None or not config.enabled:
+            return
+        engine = DreamingEngine(
+            home=home, config=config, consciousness_loop=consciousness_loop
+        )
+        result = engine.dream()
+        if result and result.memories_created:
+            logger.info(
+                "Dreaming: %d memories created from reflection",
+                len(result.memories_created),
+            )
+        elif result and result.skipped_reason:
+            logger.debug("Dreaming skipped: %s", result.skipped_reason)
+
+    return _run
+
+
+def make_itil_auto_close_task(home: Path) -> Callable[[], None]:
+    """Return a callback that auto-closes resolved incidents after 24h stable.
+
+    Args:
+        home: Shared root directory.
+    """
+
+    def _run() -> None:
+        from .itil import ITILManager
+
+        mgr = ITILManager(home)
+        closed = mgr.auto_close_resolved(stable_hours=24)
+        if closed:
+            logger.info("ITIL auto-close: %d incident(s) closed: %s", len(closed), closed)
+        else:
+            logger.debug("ITIL auto-close: no incidents to close")
+
+    return _run
+
+
+def make_itil_escalation_task(home: Path) -> Callable[[], None]:
+    """Return a callback that checks SLA breaches on open incidents.
+
+    Args:
+        home: Shared root directory.
+    """
+
+    def _run() -> None:
+        from .itil import ITILManager
+
+        mgr = ITILManager(home)
+        breaches = mgr.check_sla_breaches()
+        if breaches:
+            for b in breaches:
+                logger.warning(
+                    "ITIL SLA breach: %s (%s) unacknowledged for %d min (limit: %d min)",
+                    b["id"], b["severity"], b["elapsed_minutes"], b["sla_minutes"],
+                )
+        else:
+            logger.debug("ITIL escalation check: no SLA breaches")
+
+    return _run
+
+
 # ---------------------------------------------------------------------------
 # Convenience builder
 # ---------------------------------------------------------------------------
@@ -369,6 +449,8 @@ def build_scheduler(
     +--------------------------+------------+
     | profile_freshness_check  | 24 hours   |
     +--------------------------+------------+
+    | dreaming_reflection      | 15 min     |
+    +--------------------------+------------+
 
     Args:
         home: Agent home directory.
@@ -424,6 +506,13 @@ def build_scheduler(
         callback=make_profile_freshness_task(home),
     )
 
+    # Dreaming — idle-time self-reflection via NVIDIA NIM
+    scheduler.register(
+        name="dreaming_reflection",
+        interval_seconds=900,  # 15 minutes
+        callback=make_dreaming_task(home, consciousness_loop),
+    )
+
     # Service health check — pings Qdrant, FalkorDB, Syncthing, daemons
     try:
         from .service_health import make_service_health_task
@@ -436,4 +525,22 @@ def build_scheduler(
     except ImportError:
         logger.debug("service_health not available — service_health_check task skipped")
 
+    # ITIL escalation check — SLA breach detection every 5 minutes
+    try:
+        from . import SHARED_ROOT
+
+        shared = Path(SHARED_ROOT).expanduser()
+        scheduler.register(
+            name="itil_escalation_check",
+            interval_seconds=300,  # 5 minutes
+            callback=make_itil_escalation_task(shared),
+        )
+        scheduler.register(
+            name="itil_auto_close",
+            interval_seconds=1800,  # 30 minutes
+            callback=make_itil_auto_close_task(shared),
+        )
+    except Exception:
+        logger.debug("ITIL scheduled tasks not available — skipped")
+
     return scheduler

package/src/skcapstone/service_health.py

@@ -197,16 +197,90 @@ def check_all_services() -> list[dict[str, Any]]:
 # ---------------------------------------------------------------------------
 
 
+def _create_incident_for_down_service(service_result: dict[str, Any]) -> None:
+    """Auto-create an ITIL incident for a down service (with dedup).
+
+    Only creates a new incident if there is no existing open incident
+    for the same service. Uses best-effort: failures are logged but
+    never block the health check.
+    """
+    try:
+        from . import SHARED_ROOT
+        from .itil import ITILManager
+
+        svc_name = service_result["name"]
+        mgr = ITILManager(os.path.expanduser(SHARED_ROOT))
+
+        # Dedup: skip if there's already an open incident for this service
+        existing = mgr.find_open_incident_for_service(svc_name)
+        if existing:
+            logger.debug(
+                "Skipping incident creation for %s — open incident %s exists",
+                svc_name, existing.id,
+            )
+            return
+
+        error_info = service_result.get("error") or "unreachable"
+        mgr.create_incident(
+            title=f"{svc_name} down",
+            severity="sev3",
+            source="service_health",
+            affected_services=[svc_name],
+            impact=f"Service unreachable: {error_info}",
+            managed_by="lumina",
+            created_by="service_health",
+            tags=["auto-detected", "service-health"],
+        )
+        logger.info("Auto-created incident for down service: %s", svc_name)
+    except Exception as exc:
+        logger.debug("Failed to create incident for %s: %s", service_result.get("name"), exc)
+
+
+def _auto_resolve_recovered_service(service_result: dict[str, Any]) -> None:
+    """Auto-resolve sev4 incidents when a service recovers."""
+    try:
+        from . import SHARED_ROOT
+        from .itil import ITILManager
+
+        svc_name = service_result["name"]
+        mgr = ITILManager(os.path.expanduser(SHARED_ROOT))
+        existing = mgr.find_open_incident_for_service(svc_name)
+        if existing is None:
+            return
+
+        if existing.severity.value == "sev4":
+            mgr.update_incident(
+                existing.id, "service_health",
+                new_status="resolved",
+                note=f"Service {svc_name} recovered automatically",
+                resolution_summary="Auto-resolved: service came back up",
+            )
+            logger.info("Auto-resolved sev4 incident %s for recovered service %s",
+                        existing.id, svc_name)
+        else:
+            mgr.update_incident(
+                existing.id, "service_health",
+                note=f"Service {svc_name} appears to be back up",
+            )
+    except Exception as exc:
+        logger.debug("Failed to auto-resolve incident for %s: %s",
+                      service_result.get("name"), exc)
+
+
 def make_service_health_task() -> callable:
     """Return a zero-arg callback suitable for TaskScheduler.register().
 
     Runs check_all_services() and logs results.  Down services are logged
-    at WARNING level; all-up is logged at DEBUG level.
+    at WARNING level; all-up is logged at DEBUG level.  Auto-creates ITIL
+    incidents for down services and auto-resolves sev4 incidents for
+    recovered services.
     """
 
     def _run() -> None:
         results = check_all_services()
         down = [r for r in results if r["status"] == "down"]
+        up = [r for r in results if r["status"] == "up"]
+
         if down:
             names = ", ".join(r["name"] for r in down)
             logger.warning(
@@ -216,8 +290,9 @@ def make_service_health_task() -> callable:
                 logger.warning(
                     "  %s (%s): %s", r["name"], r["url"], r["error"] or "unreachable"
                 )
+                _create_incident_for_down_service(r)
         else:
-            up_count = sum(1 for r in results if r["status"] == "up")
+            up_count = len(up)
             logger.debug(
                 "Service health: %d/%d up, %d unknown",
                 up_count,
@@ -225,4 +300,8 @@ def make_service_health_task() -> callable:
                 len(results) - up_count,
             )
 
+        # Check for recovered services
+        for r in up:
+            _auto_resolve_recovered_service(r)
+
     return _run

package/src/skcapstone/soul.py

@@ -838,6 +838,25 @@ class SoulManager:
                         "source": "repo",
                         "description": desc[:80] if desc else "",
                     }
+        else:
+            # 2b) Local repo not cloned — fall back to GitHub API
+            try:
+                from .blueprint_registry import _fetch_github_blueprints
+
+                github_results = _fetch_github_blueprints()
+                if github_results:
+                    for bp in github_results:
+                        slug = bp["name"]
+                        if slug not in seen:
+                            seen[slug] = {
+                                "name": slug,
+                                "display_name": bp.get("display_name", slug),
+                                "category": bp.get("category", ""),
+                                "source": "github",
+                                "description": "",
+                            }
+            except Exception:
+                pass  # offline — show only installed souls
 
         # Sort by category, then name
         return sorted(seen.values(), key=lambda d: (d["category"], d["name"]))

package/systemd/skcapstone.service

@@ -5,19 +5,18 @@ After=network-online.target ollama.service syncthing.service
 Wants=network-online.target
 
 [Service]
-Type=notify
-ExecStart=skcapstone daemon start --foreground
-ExecStop=skcapstone daemon stop
+Type=simple
+ExecStart=%h/.skenv/bin/skcapstone daemon start --foreground
+ExecStop=%h/.skenv/bin/skcapstone daemon stop
 ExecReload=/bin/kill -HUP $MAINPID
 Restart=on-failure
 RestartSec=10
-# Watchdog: daemon must call sd_notify("WATCHDOG=1") at least every 5 minutes
-WatchdogSec=300
 # Cap memory to prevent OOM from large model loading
 MemoryMax=4G
 # Keep Ollama models warm for 5 minutes between requests
 Environment=PYTHONUNBUFFERED=1
 Environment=OLLAMA_KEEP_ALIVE=5m
+Environment=SKCAPSTONE_AGENT=lumina
 # Journal logging
 StandardOutput=journal
 StandardError=journal
@@ -27,7 +26,7 @@ SyslogIdentifier=skcapstone
 NoNewPrivileges=true
 ProtectSystem=strict
 ProtectHome=read-only
-ReadWritePaths=%h/.skcapstone %h/.skmemory %h/.capauth %h/.cloud9 %h/.skcomm %h/.skchat
+ReadWritePaths=%h/.skcapstone %h/.skenv %h/.capauth %h/.cloud9 %h/.skcomm %h/.skchat
 PrivateTmp=true
 ProtectKernelTunables=true
 ProtectControlGroups=true