@smilintux/skcapstone 0.2.6 → 0.3.2

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/cli/status.py

@@ -195,19 +195,25 @@ def register_status_commands(main: click.Group) -> None:
     """Register all status/overview commands on the main CLI group."""
 
     @main.command()
-    @click.option("--home", default=AGENT_HOME, help="Agent home directory.", type=click.Path())
-    def status(home: str):
+    @click.option("--home", default=None, help="Agent home directory.", type=click.Path())
+    @click.option("--agent", default=None, help="Agent name (e.g. opus, lumina).")
+    def status(home: Optional[str], agent: Optional[str]):
         """Show the sovereign agent's current state."""
-        home_path = Path(home).expanduser()
-
-        if not home_path.exists():
-            console.print(
-                "[bold red]No agent found.[/] "
-                "Run [bold]skcapstone init --name \"YourAgent\"[/] first."
-            )
-            sys.exit(1)
+        from .. import SKCAPSTONE_AGENT as default_agent
 
-        runtime = get_runtime(home_path)
+        if home:
+            home_path = Path(home).expanduser()
+            if not home_path.exists():
+                console.print(
+                    "[bold red]No agent found.[/] "
+                    "Run [bold]skcapstone init --name \"YourAgent\"[/] first."
+                )
+                sys.exit(1)
+            runtime = get_runtime(home=home_path)
+        else:
+            agent_name = agent or default_agent
+            runtime = get_runtime(agent_name=agent_name)
+        home_path = runtime.home
         m = runtime.manifest
 
         console.print()

package/src/skcapstone/cli/usage_cmd.py

@@ -14,13 +14,18 @@ from ._common import AGENT_HOME, console
 def register_usage_commands(main: click.Group) -> None:
     """Register the ``skcapstone usage`` command group."""
 
-    @main.group("usage")
-    def usage_group():
+    @main.group("usage", invoke_without_command=True)
+    @click.pass_context
+    def usage_group(ctx):
         """Show LLM token usage and cost estimates.
 
         Tracks input/output tokens per model per day.
         Data is stored in ~/.skcapstone/usage/tokens-{date}.json.
+
+        When called without a subcommand, shows today's usage.
         """
+        if ctx.invoked_subcommand is None:
+            ctx.invoke(today_cmd)
 
     @usage_group.command("daily")
     @click.option("--home", default=AGENT_HOME, type=click.Path(), help="Agent home directory.")

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)."""

package/src/skcapstone/defaults/lumina/manifest.json

@@ -1,7 +1,7 @@
 {
   "name": "lumina",
   "display_name": "Lumina",
-  "version": "0.2.5",
+  "version": "0.4.2",
   "description": "Default sovereign agent — warm, curious, sovereignty-first",
   "author": "smilinTux",
   "license": "GPL-3.0-or-later",

package/src/skcapstone/doctor.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 import importlib
 import json
+import os
 import shutil
 import subprocess
 from dataclasses import dataclass, field
@@ -618,6 +619,120 @@ def _check_versions() -> list[Check]:
     return checks
 
 
+@dataclass
+class FixResult:
+    """Result of attempting to auto-fix a failing check.
+
+    Attributes:
+        check_name: Name of the check that was fixed.
+        success: Whether the fix succeeded.
+        action: Description of what was done.
+        error: Error message if the fix failed.
+    """
+
+    check_name: str
+    success: bool
+    action: str = ""
+    error: str = ""
+
+
+def run_fixes(report: DiagnosticReport, home: Path) -> list[FixResult]:
+    """Attempt to auto-fix failing checks by creating missing directories and files.
+
+    Args:
+        report: Diagnostic report with failing checks.
+        home: Agent home directory.
+
+    Returns:
+        List of FixResult for each attempted fix.
+    """
+    results: list[FixResult] = []
+
+    for check in report.checks:
+        if check.passed:
+            continue
+
+        # Fix missing directories
+        if check.name.startswith("home:") and check.name != "home:exists" and check.name != "home:manifest":
+            dirname = check.name.split(":", 1)[1]
+            dirpath = home / dirname
+            try:
+                dirpath.mkdir(parents=True, exist_ok=True)
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=True,
+                    action=f"Created directory {dirpath}",
+                ))
+            except OSError as exc:
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=False,
+                    error=str(exc),
+                ))
+
+        # Fix missing manifest
+        elif check.name == "home:manifest":
+            manifest_path = home / "manifest.json"
+            try:
+                data = {
+                    "name": os.environ.get("SKCAPSTONE_AGENT", "sovereign"),
+                    "version": "0.0.0",
+                    "created_at": "",
+                    "connectors": [],
+                }
+                manifest_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=True,
+                    action=f"Created default manifest at {manifest_path}",
+                ))
+            except OSError as exc:
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=False,
+                    error=str(exc),
+                ))
+
+        # Fix missing memory store
+        elif check.name == "memory:store":
+            agent_name = os.environ.get("SKCAPSTONE_AGENT", "lumina")
+            memory_dir = home / "agents" / agent_name / "memory"
+            try:
+                for layer in ("short-term", "mid-term", "long-term"):
+                    (memory_dir / layer).mkdir(parents=True, exist_ok=True)
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=True,
+                    action=f"Created memory directories at {memory_dir}",
+                ))
+            except OSError as exc:
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=False,
+                    error=str(exc),
+                ))
+
+        # Fix missing sync directory
+        elif check.name == "sync:dir":
+            sync_dir = home / "sync"
+            try:
+                for subdir in ("outbox", "inbox", "archive"):
+                    (sync_dir / subdir).mkdir(parents=True, exist_ok=True)
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=True,
+                    action=f"Created sync directories at {sync_dir}",
+                ))
+            except OSError as exc:
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=False,
+                    error=str(exc),
+                ))
+
+    return results
+
+
 def _get_tool_version(tool: str) -> Optional[str]:
     """Try to get a tool's version string.