@smilintux/skcapstone 0.4.6 → 0.5.0

package/src/skcapstone/mcp_tools/soul_tools.py

@@ -2,10 +2,14 @@
 
 from __future__ import annotations
 
+import logging
+
 from mcp.types import TextContent, Tool
 
 from ._helpers import _error_response, _home, _json_response, _text_response
 
+logger = logging.getLogger(__name__)
+
 TOOLS: list[Tool] = [
     Tool(
         name="soul_list",
@@ -250,8 +254,8 @@ async def _handle_soul_list(args: dict) -> list[TextContent]:
                 "source": "installed",
                 "active": name == state.active_soul,
             })
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("Failed to list installed soul blueprints: %s", exc)
 
     # 2) Blueprints repo
     blueprints_repo = Path.home() / "clawd" / "soul-blueprints" / "blueprints"

package/src/skcapstone/mdns_discovery.py

@@ -238,8 +238,8 @@ class MDNSDiscovery:
                         agent_name,
                     )
                     return
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.warning("Failed to read existing mDNS heartbeat for %s: %s", agent_name, exc)
 
         heartbeat = {
             "agent_name": agent_name,

package/src/skcapstone/metrics.py

@@ -358,8 +358,8 @@ class MetricsCollector:
                         1 for t in transports.values()
                         if isinstance(t, dict) and t.get("enabled", True)
                     )
-                except Exception:
-                    pass
+                except Exception as exc:
+                    logger.warning("Failed to parse skcomm transport config: %s", exc)
 
             report.transport = TransportMetrics(
                 available=True,
@@ -474,8 +474,8 @@ class MetricsCollector:
             if state_path.exists():
                 try:
                     state = json.loads(state_path.read_text(encoding="utf-8"))
-                except Exception:
-                    pass
+                except Exception as exc:
+                    logger.warning("Failed to read sync_state.json: %s", exc)
 
             report.sync = SyncMetrics(
                 available=True,
@@ -510,8 +510,8 @@ class MetricsCollector:
                 try:
                     subs = json.loads(subs_file.read_text(encoding="utf-8"))
                     sub_count = len(subs)
-                except Exception:
-                    pass
+                except Exception as exc:
+                    logger.warning("Failed to read pubsub subscriptions.json: %s", exc)
 
             report.pubsub = PubSubMetrics(
                 available=True,
@@ -546,8 +546,8 @@ class MetricsCollector:
                 try:
                     rot_data = json.loads(rot_log.read_text(encoding="utf-8"))
                     rotations = len(rot_data)
-                except Exception:
-                    pass
+                except Exception as exc:
+                    logger.warning("Failed to read KMS rotation log: %s", exc)
 
             report.kms = KmsMetrics(
                 available=True,

package/src/skcapstone/migrate_memories.py

@@ -100,8 +100,8 @@ def migrate(
     try:
         existing = store.list_memories(limit=10000)
         existing_ids = {m.id for m in existing}
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("Failed to load existing memory IDs for deduplication: %s", exc)
 
     for entry in entries:
         if entry.memory_id in existing_ids:

package/src/skcapstone/models.py

@@ -238,6 +238,19 @@ class SyncConfig(BaseModel):
     git_remote: Optional[str] = None
 
 
+class BrainFirstConfig(BaseModel):
+    """Configuration for the brain-first protocol.
+
+    When enabled, agents consult memory before acting on tasks
+    to surface prior knowledge and avoid redundant work.
+    """
+
+    enabled: bool = True
+    max_results: int = 5
+    min_importance: float = 0.3
+    auto_inject: bool = False
+
+
 class AgentConfig(BaseModel):
     """Persistent configuration for the agent runtime."""
 
@@ -249,6 +262,7 @@ class AgentConfig(BaseModel):
     trust_home: Path = Path("~/.cloud9")
     default_connector: Optional[str] = None
     sync: SyncConfig = Field(default_factory=SyncConfig)
+    brain_first: BrainFirstConfig = Field(default_factory=BrainFirstConfig)
     capabilities: list[str] = Field(
         default_factory=lambda: ["consciousness", "code", "chat", "memory"]
     )

package/src/skcapstone/onboard.py

@@ -21,6 +21,7 @@ Steps:
 from __future__ import annotations
 
 import json
+import logging
 import sys
 import time
 from datetime import datetime, timezone
@@ -28,6 +29,8 @@ from pathlib import Path
 from typing import Optional
 
 import click
+
+logger = logging.getLogger(__name__)
 from rich.console import Console
 from rich.panel import Panel
 from rich.prompt import Confirm, Prompt
@@ -503,8 +506,8 @@ def _step_ollama_models(prereqs: dict) -> bool:
         if DEFAULT_MODEL in (r.stdout or ""):
             click.echo(click.style("  ✓ ", fg="green") + f"{DEFAULT_MODEL} already present")
             return True
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("Failed to check ollama model list: %s", exc)
 
     if not click.confirm(f"  Pull default model ({DEFAULT_MODEL}, ~2 GB)?", default=True):
         click.echo(click.style("  ↷ ", fg="bright_black") + f"Skipped — pull later: ollama pull {DEFAULT_MODEL}")
@@ -586,22 +589,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 +643,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 +968,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
@@ -877,8 +994,8 @@ def run_onboard(home: Optional[str] = None) -> None:
         soul = load_soul()
         if soul and soul.boot_message:
             boot_message = soul.boot_message
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("Failed to load soul boot message, using default: %s", exc)
 
     # -----------------------------------------------------------------------
     # Summary table
@@ -911,7 +1028,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/peer_directory.py

@@ -250,8 +250,8 @@ class PeerDirectory:
                         ts = data.get("timestamp", "")
                         if ts:
                             self._entries[agent_name].last_seen = ts
-                    except Exception:
-                        pass
+                    except Exception as exc:
+                        logger.warning("Failed to update last_seen from heartbeat for %s: %s", agent_name, exc)
                     continue
 
                 try:

package/src/skcapstone/providers/docker.py

@@ -307,8 +307,8 @@ class DockerProvider(ProviderBackend):
             old = client.containers.get(container_name)
             logger.warning("Removing stale container: %s", container_name)
             old.remove(force=True)
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("No stale container to remove for %s (expected if first run): %s", container_name, exc)
 
         # Ensure named volume for agent state persistence
         try:

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

@@ -76,8 +76,8 @@ def _http_check(
                 try:
                     body = json.loads(resp.read().decode("utf-8"))
                     result["version"] = body.get(version_key)
-                except Exception:
-                    pass
+                except Exception as exc:
+                    logger.warning("Failed to parse version from service health response: %s", exc)
     except urllib.error.HTTPError as exc:
         latency = (time.monotonic() - t0) * 1000
         result["latency_ms"] = round(latency, 1)
@@ -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/sync_watcher.py

@@ -574,8 +574,8 @@ class SyncWatcher:
             try:
                 self._observer.stop()
                 self._observer.join(timeout=5)
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.warning("Error stopping SyncWatcher observer: %s", exc)
             self._observer = None
         logger.info("SyncWatcher stopped.")