@smilintux/skcapstone 0.4.5 → 0.4.7

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

@@ -586,22 +586,40 @@ def _step_config_files(home_path: Path) -> tuple:
     return consciousness_ok, profiles_ok
 
 
-def _step_systemd_service() -> bool:
-    """Install systemd user service for auto-start (optional).
+def _step_autostart_service(agent_name: str = "sovereign") -> bool:
+    """Install auto-start service (systemd on Linux, launchd on macOS).
+
+    Prompts the user to choose which services to install and uses
+    the agent name from onboarding for environment variables.
+
+    Args:
+        agent_name: The agent name chosen during onboarding.
 
     Returns:
         True if service was installed.
     """
     import platform
 
-    if platform.system() != "Linux":
-        click.echo(click.style("  ↷ ", fg="bright_black") + "Systemd only available on Linux — skipped")
+    system = platform.system()
+
+    if system == "Linux":
+        return _step_systemd_service_linux()
+    elif system == "Darwin":
+        return _step_launchd_service_macos(agent_name)
+    else:
+        click.echo(
+            click.style("  ↷ ", fg="bright_black")
+            + f"Auto-start not supported on {system} — skipped"
+        )
         return False
 
+
+def _step_systemd_service_linux() -> bool:
+    """Install systemd user service (Linux only)."""
     if not click.confirm("  Install systemd user service for auto-start at login?", default=False):
         click.echo(
             click.style("  ↷ ", fg="bright_black")
-            + "Skipped — run 'skcapstone systemd install' to enable later"
+            + "Skipped — run 'skcapstone daemon install' to enable later"
         )
         return False
 
@@ -622,13 +640,109 @@ def _step_systemd_service() -> bool:
             return True
         else:
             click.echo(click.style("  ✗ ", fg="red") + "Service install failed")
-            click.echo(click.style("    ", fg="bright_black") + "Run manually: skcapstone systemd install")
+            click.echo(click.style("    ", fg="bright_black") + "Run manually: skcapstone daemon install")
             return False
     except Exception as exc:
         click.echo(click.style("  ⚠ ", fg="yellow") + f"Systemd: {exc}")
         return False
 
 
+def _step_launchd_service_macos(agent_name: str) -> bool:
+    """Install launchd user agents (macOS only).
+
+    Shows available services, lets the user choose, and installs
+    plist files to ~/Library/LaunchAgents/.
+
+    Args:
+        agent_name: Agent name for SKCAPSTONE_AGENT env var.
+
+    Returns:
+        True if at least one service was installed.
+    """
+    try:
+        from .launchd import install_service, list_available_services
+    except ImportError as exc:
+        click.echo(click.style("  ⚠ ", fg="yellow") + f"launchd module not available: {exc}")
+        return False
+
+    click.echo(f"  Agent name: [cyan]{agent_name}[/] (used in SKCAPSTONE_AGENT)")
+    click.echo()
+
+    # Show available services
+    available = list_available_services(agent_name)
+    core_services = [s for s in available if s["available"] and not s["suffix"].startswith("sk")]
+    optional_services = [s for s in available if s["available"] and s["suffix"].startswith("sk")]
+
+    click.echo("  Available services:")
+    all_available = [s for s in available if s["available"]]
+    for i, svc in enumerate(all_available, 1):
+        click.echo(f"    {i}. {svc['description']} ({svc['label']})")
+    click.echo()
+
+    if not click.confirm("  Install launchd services for auto-start at login?", default=True):
+        click.echo(
+            click.style("  ↷ ", fg="bright_black")
+            + "Skipped — run 'skcapstone daemon install' to enable later"
+        )
+        return False
+
+    # Ask: all or pick?
+    install_all = click.confirm("  Install all available services?", default=True)
+
+    selected_suffixes: list[str] = []
+    if install_all:
+        selected_suffixes = [s["suffix"] for s in all_available]
+    else:
+        click.echo("  Enter service numbers (comma-separated), or 'none' to skip:")
+        raw = click.prompt("  Services", default="1")
+        if raw.strip().lower() == "none":
+            click.echo(click.style("  ↷ ", fg="bright_black") + "Skipped")
+            return False
+        try:
+            indices = [int(x.strip()) - 1 for x in raw.split(",")]
+            selected_suffixes = [
+                all_available[i]["suffix"]
+                for i in indices
+                if 0 <= i < len(all_available)
+            ]
+        except (ValueError, IndexError):
+            click.echo(click.style("  ⚠ ", fg="yellow") + "Invalid selection — installing core services only")
+            selected_suffixes = [s["suffix"] for s in all_available if not s["suffix"].startswith("sk")]
+
+    if not selected_suffixes:
+        click.echo(click.style("  ↷ ", fg="bright_black") + "No services selected")
+        return False
+
+    # Ask about immediate start
+    start_now = click.confirm("  Start services now?", default=False)
+
+    try:
+        result = install_service(
+            agent_name=agent_name,
+            services=selected_suffixes,
+            start=start_now,
+        )
+
+        if result.get("installed"):
+            for svc in result.get("services", []):
+                status = "[green]loaded[/]" if svc.get("loaded") else "[dim]installed[/]"
+                click.echo(click.style("  ✓ ", fg="green") + f"{svc['label']} — {status}")
+
+            click.echo()
+            click.echo(click.style("    ", fg="bright_black") + "Manage services:")
+            click.echo(click.style("    ", fg="bright_black") + "  launchctl list | grep skcapstone")
+            click.echo(click.style("    ", fg="bright_black") + "  launchctl start com.skcapstone.daemon")
+            click.echo(click.style("    ", fg="bright_black") + "  skcapstone daemon uninstall")
+            return True
+        else:
+            click.echo(click.style("  ✗ ", fg="red") + "No services were installed")
+            return False
+
+    except Exception as exc:
+        click.echo(click.style("  ⚠ ", fg="yellow") + f"launchd install: {exc}")
+        return False
+
+
 def _step_doctor_check(home_path: Path) -> "object":
     """Run doctor diagnostics and print results.
 
@@ -851,10 +965,10 @@ def run_onboard(home: Optional[str] = None) -> None:
     open_task_count = _step_board(home_path, name)
 
     # -----------------------------------------------------------------------
-    # Step 13: Systemd Service (optional)
+    # Step 13: Auto-Start Service (systemd on Linux, launchd on macOS)
     # -----------------------------------------------------------------------
-    _step_header(13, "Systemd Service")
-    systemd_ok = _step_systemd_service()
+    _step_header(13, "Auto-Start Service")
+    service_ok = _step_autostart_service(agent_name=agent_slug)
 
     # -----------------------------------------------------------------------
     # Post-wizard: Doctor Diagnostics
@@ -911,7 +1025,13 @@ def run_onboard(home: Optional[str] = None) -> None:
     summary.add_row("Heartbeat", "[green]ACTIVE[/]" if hb_ok else "[yellow]FAILED[/]", f"{agent_slug}.json" if hb_ok else "see above")
     summary.add_row("Crush AI", "[green]READY[/]" if crush_ok else "[yellow]CONFIG ONLY[/]", "~/.config/crush/crush.json")
     summary.add_row("Board", "[green]ACTIVE[/]", f"{open_task_count} open tasks")
-    summary.add_row("Systemd", "[green]INSTALLED[/]" if systemd_ok else "[dim]OPTIONAL[/]", "skcapstone.service" if systemd_ok else "skcapstone systemd install")
+    import platform as _plat
+    _svc_type = "launchd" if _plat.system() == "Darwin" else "systemd"
+    summary.add_row(
+        "Auto-Start",
+        "[green]INSTALLED[/]" if service_ok else "[dim]OPTIONAL[/]",
+        f"{_svc_type} services" if service_ok else f"skcapstone daemon install",
+    )
     doctor_status = "[green]ALL PASSED[/]" if doctor_report.all_passed else f"[yellow]{doctor_report.failed_count} failed[/]"
     summary.add_row("Doctor", doctor_status, f"{doctor_report.passed_count}/{doctor_report.total_count} checks")
     summary.add_row(

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/src/skcapstone/systemd.py

@@ -16,6 +16,7 @@ Usage:
 from __future__ import annotations
 
 import logging
+import platform
 import shutil
 import subprocess
 from dataclasses import dataclass, field
@@ -24,6 +25,14 @@ from typing import Optional
 
 logger = logging.getLogger("skcapstone.systemd")
 
+
+def _require_linux() -> None:
+    """Raise RuntimeError if not running on Linux."""
+    if platform.system() != "Linux":
+        raise RuntimeError(
+            "systemd is only available on Linux. Use launchd on macOS."
+        )
+
 SERVICE_NAME = "skcapstone.service"
 SOCKET_NAME = "skcapstone-api.socket"
 HEARTBEAT_SERVICE = "skcomm-heartbeat.service"
@@ -93,7 +102,11 @@ def _systemctl(*args: str) -> subprocess.CompletedProcess:
 
     Returns:
         CompletedProcess result.
+
+    Raises:
+        RuntimeError: If not running on Linux.
     """
+    _require_linux()
     return _run(["systemctl", "--user", *args])
 
 
@@ -127,6 +140,7 @@ def install_service(
     Returns:
         dict: Result with 'installed', 'enabled', 'started' bools.
     """
+    _require_linux()
     target = unit_dir or SYSTEMD_USER_DIR
     source = source_dir or BUNDLED_DIR
 
@@ -184,6 +198,7 @@ def uninstall_service(unit_dir: Optional[Path] = None) -> dict:
     Returns:
         dict: Result with 'stopped', 'disabled', 'removed' bools.
     """
+    _require_linux()
     target = unit_dir or SYSTEMD_USER_DIR
     result = {"stopped": False, "disabled": False, "removed": False}
 
@@ -214,6 +229,7 @@ def service_status() -> ServiceStatus:
     Returns:
         ServiceStatus: Detailed status information.
     """
+    _require_linux()
     status = ServiceStatus()
 
     unit_path = SYSTEMD_USER_DIR / SERVICE_NAME
@@ -264,6 +280,7 @@ def service_logs(lines: int = 50, follow: bool = False) -> str:
     Returns:
         str: Log output or the follow command.
     """
+    _require_linux()
     if follow:
         return f"journalctl --user -u {SERVICE_NAME} -f"