@smilintux/skcapstone 0.10.0 → 0.12.5

package/src/skcapstone/pillars/sync.py

@@ -175,7 +175,7 @@ def gpg_encrypt(
         recipient = _detect_gpg_key(agent_home)
 
     if recipient is None:
-        logger.error("No GPG key found for encryption")
+        logger.warning("No GPG key found for encryption — skipping")
         return None
 
     # Build recipient list: own key + all known peers
@@ -208,7 +208,7 @@ def gpg_encrypt(
         )
         return encrypted_path
     except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as exc:
-        logger.error("GPG encryption failed: %s", exc)
+        logger.warning("GPG encryption failed (key may be missing): %s", exc)
         return None
 
 

package/src/skcapstone/preflight.py

@@ -489,15 +489,15 @@ class PreflightChecker:
         )
 
     def check_packages(self) -> CheckResult:
-        """Verify skcapstone, skseed, and skcomm are importable."""
+        """Verify skcapstone, skseed, and skcomms are importable."""
         missing = []
-        for pkg in ("skcapstone", "skseed", "skcomm"):
+        for pkg in ("skcapstone", "skseed", "skcomms"):
             try:
                 __import__(pkg)
             except ImportError:
                 missing.append(pkg)
         if not missing:
-            return CheckResult("packages", "ok", "skcapstone, skseed, skcomm all importable")
+            return CheckResult("packages", "ok", "skcapstone, skseed, skcomms all importable")
         return CheckResult(
             "packages", "fail",
             f"Missing packages: {', '.join(missing)}",

package/src/skcapstone/providers/docker.py

@@ -12,14 +12,14 @@ agent container:
 2. **MCP Server** — host-side skcapstone MCP reachable via env
    (SKCAPSTONE_MCP_HOST / SKCAPSTONE_MCP_SOCKET).  Set one of these so
    containers can call memory_store, coord_claim, etc.
-3. **SKComm Transport** — comms directory bind-mounted at /skcomm so
+3. **SKComms Transport** — comms directory bind-mounted at /skcomms so
    containers share the same file-channel inboxes as local agents.
 
 Prerequisites:
 - Docker daemon running and accessible (DOCKER_HOST or default socket)
 - docker Python SDK: pip install docker
 - Optional: DOCKER_BASE_IMAGE env var to override the default image
-- Optional: SKCOMM_HOME env var for the comms directory
+- Optional: SKCOMMS_HOME env var for the comms directory
 - Optional: SKCAPSTONE_MCP_HOST env var (host:port) or
             SKCAPSTONE_MCP_SOCKET env var (unix socket path)
 """
@@ -83,8 +83,8 @@ class DockerProvider(ProviderBackend):
 
     Sovereign infrastructure wiring
     --------------------------------
-    - **SKComm**: pass ``skcomm_home`` (or set SKCOMM_HOME) to bind-mount
-      the comms directory at ``/skcomm`` inside every container so
+    - **SKComms**: pass ``skcomms_home`` (or set SKCOMMS_HOME) to bind-mount
+      the comms directory at ``/skcomms`` inside every container so
       container agents share the same file-channel inboxes.
     - **MCP server**: pass ``mcp_host`` (host:port) or ``mcp_socket_path``
       to inject the skcapstone MCP endpoint into container env. Containers
@@ -96,8 +96,8 @@ class DockerProvider(ProviderBackend):
         volume_prefix: Prefix for named volumes created per agent.
         docker_host: Docker daemon socket/URL (default: DOCKER_HOST or
             ``unix:///var/run/docker.sock``).
-        skcomm_home: Host-side SKComm comms root directory; bind-mounted at
-            ``/skcomm`` inside containers. Reads SKCOMM_HOME if not set.
+        skcomms_home: Host-side SKComms comms root directory; bind-mounted at
+            ``/skcomms`` inside containers. Reads SKCOMMS_HOME if not set.
         mcp_host: Host:port of the skcapstone MCP server (e.g.
             ``"host-gateway:8765"``). Sets SKCAPSTONE_MCP_HOST inside
             containers. Reads SKCAPSTONE_MCP_HOST env if not set.
@@ -115,7 +115,7 @@ class DockerProvider(ProviderBackend):
         network_name: str = "skcapstone",
         volume_prefix: str = "skcapstone-agent",
         docker_host: Optional[str] = None,
-        skcomm_home: Optional[str] = None,
+        skcomms_home: Optional[str] = None,
         mcp_host: Optional[str] = None,
         mcp_socket_path: Optional[str] = None,
     ) -> None:
@@ -126,7 +126,7 @@ class DockerProvider(ProviderBackend):
         self._network_name = network_name
         self._volume_prefix = volume_prefix
         self._docker_host = docker_host or os.environ.get("DOCKER_HOST", "")
-        self._skcomm_home = skcomm_home or os.environ.get("SKCOMM_HOME", "")
+        self._skcomms_home = skcomms_home or os.environ.get("SKCOMMS_HOME", "")
         self._mcp_host = mcp_host or os.environ.get("SKCAPSTONE_MCP_HOST", "")
         self._mcp_socket_path = (
             mcp_socket_path or os.environ.get("SKCAPSTONE_MCP_SOCKET", "")
@@ -229,7 +229,7 @@ class DockerProvider(ProviderBackend):
     def _build_sovereign_env(self, env_vars: Dict[str, str]) -> None:
         """Inject sovereign infrastructure env vars into the env dict in-place.
 
-        Adds MCP server endpoint and SKComm home when configured so
+        Adds MCP server endpoint and SKComms home when configured so
         container agents can reach the host-side sovereign stack.
 
         Args:
@@ -239,14 +239,14 @@ class DockerProvider(ProviderBackend):
             env_vars["SKCAPSTONE_MCP_HOST"] = self._mcp_host
         if self._mcp_socket_path:
             env_vars["SKCAPSTONE_MCP_SOCKET"] = _MCP_CONTAINER_SOCKET
-        if self._skcomm_home:
-            env_vars["SKCOMM_HOME"] = "/skcomm"
+        if self._skcomms_home:
+            env_vars["SKCOMMS_HOME"] = "/skcomms"
 
     def _build_volumes_config(self, volume_name: str) -> Dict[str, Any]:
         """Build the volumes dict for containers.create().
 
         Always includes the per-agent named volume at /agent.
-        Optionally adds a bind mount for the SKComm comms directory.
+        Optionally adds a bind mount for the SKComms comms directory.
 
         Args:
             volume_name: Named Docker volume for agent state.
@@ -257,8 +257,8 @@ class DockerProvider(ProviderBackend):
         vols: Dict[str, Any] = {
             volume_name: {"bind": "/agent", "mode": "rw"},
         }
-        if self._skcomm_home and Path(self._skcomm_home).exists():
-            vols[self._skcomm_home] = {"bind": "/skcomm", "mode": "rw"}
+        if self._skcomms_home and Path(self._skcomms_home).exists():
+            vols[self._skcomms_home] = {"bind": "/skcomms", "mode": "rw"}
         if self._mcp_socket_path and Path(self._mcp_socket_path).exists():
             vols[self._mcp_socket_path] = {
                 "bind": _MCP_CONTAINER_SOCKET,
@@ -280,7 +280,7 @@ class DockerProvider(ProviderBackend):
 
         The container is created but NOT started here; start() does that.
         Resource limits (CPU, memory) are applied from spec.resources.
-        SKComm and MCP sovereign infrastructure are wired in when
+        SKComms and MCP sovereign infrastructure are wired in when
         configured on this provider.
 
         Args:
@@ -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:
@@ -330,7 +330,7 @@ class DockerProvider(ProviderBackend):
             env_vars["SOUL_BLUEPRINT"] = spec.soul_blueprint
         env_vars.update(spec.env)
 
-        # Wire sovereign infrastructure (MCP + SKComm)
+        # Wire sovereign infrastructure (MCP + SKComms)
         self._build_sovereign_env(env_vars)
 
         volumes_config = self._build_volumes_config(volume_name)
@@ -620,9 +620,9 @@ class DockerProvider(ProviderBackend):
         Resource limits, environment variables, and soul blueprint paths
         are all included.
 
-        When ``skcomm_home`` is configured on the provider the compose
-        output includes a named ``skcomm-data`` volume and mounts it at
-        ``/skcomm`` in every agent service.
+        When ``skcomms_home`` is configured on the provider the compose
+        output includes a named ``skcomms-data`` volume and mounts it at
+        ``/skcomms`` in every agent service.
 
         When ``include_mcp_service=True`` a ``skcapstone-mcp`` sidecar
         service is added; all agent containers receive ``SKCAPSTONE_MCP_HOST``
@@ -663,9 +663,9 @@ class DockerProvider(ProviderBackend):
             }
             volumes["skcapstone-mcp-data"] = {}
 
-        has_skcomm = bool(self._skcomm_home)
-        if has_skcomm:
-            volumes["skcomm-data"] = {}
+        has_skcomms = bool(self._skcomms_home)
+        if has_skcomms:
+            volumes["skcomms-data"] = {}
 
         for agent_key, spec in blueprint.agents.items():
             for idx in range(spec.count):
@@ -690,12 +690,12 @@ class DockerProvider(ProviderBackend):
                 elif self._mcp_host:
                     env["SKCAPSTONE_MCP_HOST"] = self._mcp_host
 
-                if has_skcomm:
-                    env["SKCOMM_HOME"] = "/skcomm"
+                if has_skcomms:
+                    env["SKCOMMS_HOME"] = "/skcomms"
 
                 svc_volumes = [f"{volume_name}:/agent"]
-                if has_skcomm:
-                    svc_volumes.append("skcomm-data:/skcomm")
+                if has_skcomms:
+                    svc_volumes.append("skcomms-data:/skcomms")
 
                 deploy_limits: Dict[str, Any] = {
                     "resources": {

package/src/skcapstone/register.py

@@ -63,11 +63,11 @@ def _build_package_registry(workspace: Optional[Path] = None) -> list[dict]:
             "openclaw_plugin_path": workspace / "skcapstone" / "openclaw-plugin" / "src" / "index.ts",
         },
         {
-            "name": "skcomm",
-            "mcp_cmd": "skcomm-mcp",
+            "name": "skcomms",
+            "mcp_cmd": "skcomms-mcp",
             "mcp_args": [],
             "mcp_env": None,
-            "openclaw_plugin_path": workspace / "pillar-repos" / "skcomm" / "openclaw-plugin" / "src" / "index.ts",
+            "openclaw_plugin_path": workspace / "pillar-repos" / "skcomms" / "openclaw-plugin" / "src" / "index.ts",
         },
         {
             "name": "skchat",
@@ -88,7 +88,7 @@ def _build_package_registry(workspace: Optional[Path] = None) -> list[dict]:
             "mcp_cmd": None,
             "mcp_args": None,
             "mcp_env": None,
-            "openclaw_plugin_path": workspace / "pillar-repos" / "cloud9-python" / "openclaw-plugin" / "src" / "index.ts",
+            "openclaw_plugin_path": workspace / "pillar-repos" / "cloud9" / "openclaw-plugin-python" / "src" / "index.ts",
         },
         {
             "name": "sksecurity",
@@ -121,10 +121,10 @@ def _build_package_registry(workspace: Optional[Path] = None) -> list[dict]:
 _PILLAR_DIR_MAP: dict[str, Optional[str]] = {
     "skmemory": "skmemory",
     "skcapstone": None,  # lives in workspace root, not pillar-repos
-    "skcomm": "skcomm",
+    "skcomms": "skcomms",
     "skchat": "skchat",
     "capauth": "capauth",
-    "cloud9": "cloud9-python",
+    "cloud9": "cloud9",
     "sksecurity": "sksecurity",
     "skseed": "skseed",
     "skgit": None,  # skill dir only, no pillar repo

package/src/skcapstone/registry_client.py

@@ -2,10 +2,10 @@
 
 Wraps the skskills RemoteRegistry client to provide a clean interface for
 skcapstone MCP tools and CLI commands to interact with the remote
-skills-registry at skills.smilintux.org.
+skills-registry at skskills.skworld.io.
 
 This module is the integration point between:
-  - skills-registry/ (FastAPI server at skills.smilintux.org/api)
+  - skills-registry/ (FastAPI server at skskills.skworld.io/api)
   - skskills.remote.RemoteRegistry (HTTP client)
   - skcapstone discovery.py (local skill discovery)
 
@@ -27,7 +27,7 @@ from typing import Any, Optional
 
 logger = logging.getLogger(__name__)
 
-DEFAULT_REGISTRY_URL = "https://skills.smilintux.org/api"
+DEFAULT_REGISTRY_URL = "https://skskills.skworld.io/api"
 
 
 class RegistryClient:
@@ -63,7 +63,8 @@ class RegistryClient:
         try:
             self._remote.fetch_index(force=True)
             return True
-        except Exception:
+        except Exception as e:
+            logger.warning("registry_client.py: %s", e)
             return False
 
     def list_skills(self) -> list[dict[str, Any]]:

package/src/skcapstone/runtime.py

@@ -94,10 +94,14 @@ class AgentRuntime:
         logger.info("Awakening agent from %s (shared: %s)", self.home, self.shared_root)
 
         manifest_file = self.home / "manifest.json"
+        manifest_name_loaded = False
         if manifest_file.exists():
             try:
                 data = json.loads(manifest_file.read_text(encoding="utf-8"))
-                self.manifest.name = data.get("name", self.manifest.name)
+                manifest_name = data.get("name")
+                if manifest_name:
+                    self.manifest.name = manifest_name
+                    manifest_name_loaded = True
                 if data.get("created_at"):
                     self.manifest.created_at = datetime.fromisoformat(data["created_at"])
                 connectors_data = data.get("connectors", [])
@@ -105,17 +109,24 @@ class AgentRuntime:
             except (json.JSONDecodeError, ValueError) as exc:
                 logger.warning("Failed to load manifest: %s", exc)
 
-        self.manifest.name = self.config.agent_name
-
         # Discover pillars from per-agent home
         pillars = discover_all(self.home, shared_root=self.shared_root)
         self.manifest.identity = pillars["identity"]
         self.manifest.memory = pillars["memory"]
         self.manifest.trust = pillars["trust"]
+        self.manifest.consciousness = pillars["consciousness"]
         self.manifest.security = pillars["security"]
         self.manifest.sync = pillars["sync"]
         self.manifest.skills = pillars["skills"]
 
+        if (
+            self.manifest.identity.name
+            and self.manifest.identity.status == PillarStatus.ACTIVE
+        ):
+            self.manifest.name = self.manifest.identity.name
+        elif not manifest_name_loaded and self.config.agent_name:
+            self.manifest.name = self.config.agent_name
+
         self.manifest.last_awakened = datetime.now(timezone.utc)
         self._awakened = True