@smilintux/skcapstone 0.4.5 → 0.4.7

package/src/skcapstone/cli/soul.py

@@ -517,22 +517,36 @@ def register_soul_commands(main: click.Group) -> None:
     @soul_registry.command("list")
     @click.option("--url", default=None, help="Registry API base URL.")
     def registry_list(url):
-        """List all blueprints in the remote registry."""
-        from ..blueprint_registry import BlueprintRegistryClient, BlueprintRegistryError
+        """List all blueprints in the remote registry.
 
-        kwargs = {}
+        Pulls from the soul-blueprints GitHub repo. Falls back to
+        the souls.skworld.io API if --url is set.
+        """
+        from ..blueprint_registry import (
+            BlueprintRegistryClient,
+            BlueprintRegistryError,
+            _fetch_github_blueprints,
+        )
+
+        blueprints = None
+        source = "github"
+
+        # If custom URL, try the API server first
         if url:
-            kwargs["base_url"] = url
-        client = BlueprintRegistryClient(**kwargs)
+            try:
+                client = BlueprintRegistryClient(base_url=url)
+                blueprints = client.list_blueprints()
+                source = "registry"
+            except BlueprintRegistryError:
+                pass
 
-        try:
-            blueprints = client.list_blueprints()
-        except BlueprintRegistryError as e:
-            console.print(f"\n  [red]Registry error:[/] {e}\n")
-            sys.exit(1)
+        # Default: pull from GitHub repo
+        if blueprints is None:
+            blueprints = _fetch_github_blueprints()
+            source = "github"
 
         if not blueprints:
-            console.print("\n  [dim]No blueprints found in the registry.[/]\n")
+            console.print("\n  [dim]No blueprints found.[/]\n")
             return
 
         table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
@@ -547,27 +561,38 @@ def register_soul_commands(main: click.Group) -> None:
                 bp.get("category", ""),
             )
 
+        source_label = "" if source == "github" else "  [dim](registry)[/]"
         console.print()
         console.print(table)
-        console.print(f"\n  [dim]{len(blueprints)} blueprint(s) in registry[/]\n")
+        console.print(f"\n  [dim]{len(blueprints)} blueprint(s){source_label}[/]\n")
 
     @soul_registry.command("search")
     @click.argument("query")
     @click.option("--url", default=None, help="Registry API base URL.")
     def registry_search(query, url):
-        """Search the remote registry for blueprints."""
-        from ..blueprint_registry import BlueprintRegistryClient, BlueprintRegistryError
+        """Search the remote registry for blueprints.
 
-        kwargs = {}
+        Searches the soul-blueprints GitHub repo by name and category.
+        """
+        from ..blueprint_registry import (
+            BlueprintRegistryClient,
+            BlueprintRegistryError,
+            _fetch_github_blueprints,
+        )
+
+        results = None
+
+        # If custom URL, try the API server first
         if url:
-            kwargs["base_url"] = url
-        client = BlueprintRegistryClient(**kwargs)
+            try:
+                client = BlueprintRegistryClient(base_url=url)
+                results = client.search_blueprints(query)
+            except BlueprintRegistryError:
+                pass
 
-        try:
-            results = client.search_blueprints(query)
-        except BlueprintRegistryError as e:
-            console.print(f"\n  [red]Registry error:[/] {e}\n")
-            sys.exit(1)
+        # Default: search GitHub repo
+        if results is None:
+            results = _fetch_github_blueprints(query)
 
         if not results:
             console.print(f"\n  [dim]No blueprints matching '{query}'.[/]\n")
@@ -577,14 +602,12 @@ def register_soul_commands(main: click.Group) -> None:
         table.add_column("Name", style="cyan", no_wrap=True)
         table.add_column("Display Name", style="bold")
         table.add_column("Category", style="yellow")
-        table.add_column("Vibe", style="dim")
 
         for bp in results:
             table.add_row(
                 bp.get("name", "?"),
                 bp.get("display_name", ""),
                 bp.get("category", ""),
-                (bp.get("vibe", "") or "")[:60],
             )
 
         console.print()

package/src/skcapstone/consciousness_config.py

@@ -117,3 +117,30 @@ def write_default_config(home: Path) -> Path:
     config_path.write_text(header + content, encoding="utf-8")
     logger.info("Wrote default consciousness config to %s", config_path)
     return config_path
+
+
+def load_dreaming_config(
+    home: Path,
+    config_path: Optional[Path] = None,
+):
+    """Load dreaming config from the consciousness.yaml ``dreaming:`` section.
+
+    Args:
+        home: Agent home directory.
+        config_path: Explicit path to config file (overrides default).
+
+    Returns:
+        DreamingConfig (defaults if section is missing or unparseable).
+    """
+    from .dreaming import DreamingConfig
+
+    yaml_path = config_path or (home / "config" / CONFIG_FILENAME)
+    if not yaml_path.exists():
+        return DreamingConfig()
+    try:
+        raw = yaml.safe_load(yaml_path.read_text(encoding="utf-8"))
+        if raw and isinstance(raw, dict) and "dreaming" in raw:
+            return DreamingConfig.model_validate(raw["dreaming"])
+    except Exception as exc:
+        logger.warning("Failed to parse dreaming config: %s", exc)
+    return DreamingConfig()

package/src/skcapstone/coordination.py

@@ -123,6 +123,7 @@ class AgentFile(BaseModel):
     claimed_tasks: list[str] = Field(default_factory=list)
     completed_tasks: list[str] = Field(default_factory=list)
     capabilities: list[str] = Field(default_factory=list)
+    itil_claims: list[str] = Field(default_factory=list)
     notes: str = ""
 
 

package/src/skcapstone/daemon.py

@@ -1145,16 +1145,35 @@ class DaemonService:
             logger.debug("Auto-journal write failed: %s", exc)
 
         try:
-            from .memory_engine import store as mem_store
-            mem_store(
-                self.config.home,
-                f"Received message from {sender}: {preview}",
-                tags=["skcomm-received"],
-                source="daemon",
-            )
-            logger.debug("Memory stored for incoming message from %s", sender)
+            self._store_skcomm_receipt(sender, preview)
+            logger.debug("SKComm receipt stored for incoming message from %s", sender)
         except Exception as exc:
-            logger.debug("Auto-journal memory store failed: %s", exc)
+            logger.debug("SKComm receipt store failed: %s", exc)
+
+    def _store_skcomm_receipt(self, sender: str, preview: str) -> None:
+        """Write a skcomm receipt to the skcomm/received/ directory.
+
+        These are transport bookkeeping, NOT persistent memories, so they
+        go to ``~/.skcapstone/agents/{agent}/skcomm/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"
+        recv_dir.mkdir(parents=True, exist_ok=True)
+
+        receipt_id = uuid.uuid4().hex[:12]
+        receipt = {
+            "id": receipt_id,
+            "sender": sender,
+            "preview": preview,
+            "received_at": datetime.now(timezone.utc).isoformat(),
+        }
+        path = recv_dir / f"{receipt_id}.json"
+        path.write_text(json.dumps(receipt, indent=2), encoding="utf-8")
 
     def _healing_loop(self) -> None:
         """Periodically run self-healing diagnostics (every 5 min)."""
@@ -1259,17 +1278,25 @@ class DaemonService:
                 except Exception:
                     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)
+                    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:
                     stats.update(memory_total_mb=0, memory_used_mb=0, memory_free_mb=0)
                 return stats