@smilintux/skcapstone 0.5.4 → 0.5.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smilintux/skcapstone",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "SKCapstone - The sovereign agent framework. CapAuth identity, Cloud 9 trust, SKMemory persistence.",
   "main": "index.js",
   "types": "index.d.ts",

package/src/skcapstone/consciousness_loop.py

@@ -140,23 +140,14 @@ def _backend_from_model(model_name: str, tier: ModelTier) -> str:
 
     Returns:
         Backend string: ``"ollama"``, ``"anthropic"``, ``"openai"``, ``"grok"``,
-        ``"kimi"``, ``"nvidia"``, ``"passthrough"``, or ``"unknown"``.
+        ``"kimi"``, ``"minimax"``, ``"nvidia"``, ``"passthrough"``, or ``"unknown"``.
     """
     if tier == ModelTier.LOCAL:
         return "ollama"
     name_base = model_name.lower().split(":")[0]
-    if "claude" in name_base:
-        return "anthropic"
-    if any(x in name_base for x in ("gpt", "o1", "o3", "o4")):
-        return "openai"
-    if "grok" in name_base:
-        return "grok"
-    if "kimi" in name_base or "moonshot" in name_base:
-        return "kimi"
-    if "minimax" in name_base:
-        return "minimax"
-    if "nvidia" in name_base:
-        return "nvidia"
+    for patterns, backend in LLMBridge._MODEL_PATTERNS:
+        if any(p in name_base for p in patterns):
+            return backend
     if any(p in name_base for p in _OLLAMA_MODEL_PATTERNS):
         return "ollama"
     return "unknown"
@@ -253,6 +244,7 @@ class LLMBridge:
         adapter: Optional[PromptAdapter] = None,
         cache: Optional[ResponseCache] = None,
     ) -> None:
+        self._config = config
         self._router = ModelRouter(config=router_config)
         self._adapter = adapter or PromptAdapter()
         self._fallback_chain = config.fallback_chain
@@ -263,17 +255,29 @@ class LLMBridge:
         self._ollama_pool = _OllamaPool(os.environ.get("OLLAMA_HOST", config.ollama_host))
         self._probe_available_backends()
 
+    # Maps backend name → env var that activates it.
+    # Backends with None are probed separately (ollama) or always on (passthrough).
+    _BACKEND_ENV_KEYS: dict[str, Optional[str]] = {
+        "ollama": None,
+        "anthropic": "ANTHROPIC_API_KEY",
+        "openai": "OPENAI_API_KEY",
+        "grok": "XAI_API_KEY",
+        "kimi": "MOONSHOT_API_KEY",
+        "minimax": "MINIMAX_API_KEY",
+        "nvidia": "NVIDIA_API_KEY",
+        "passthrough": None,
+    }
+
     def _probe_available_backends(self) -> None:
         """Probe all backends for availability."""
-        self._available = {
-            "ollama": self._probe_ollama(),
-            "anthropic": bool(os.environ.get("ANTHROPIC_API_KEY")),
-            "openai": bool(os.environ.get("OPENAI_API_KEY")),
-            "grok": bool(os.environ.get("XAI_API_KEY")),
-            "kimi": bool(os.environ.get("MOONSHOT_API_KEY")),
-            "nvidia": bool(os.environ.get("NVIDIA_API_KEY")),
-            "passthrough": True,
-        }
+        self._available = {}
+        for name, env_key in self._BACKEND_ENV_KEYS.items():
+            if name == "ollama":
+                self._available[name] = self._probe_ollama()
+            elif name == "passthrough":
+                self._available[name] = True
+            else:
+                self._available[name] = bool(os.environ.get(env_key or ""))
         available = [k for k, v in self._available.items() if v]
         logger.info("LLM backends available: %s", available)
 
@@ -289,9 +293,23 @@ class LLMBridge:
             self._ollama_pool.invalidate()
             return False
 
+    # Maps model-name substring → backend name for pattern matching.
+    _MODEL_PATTERNS: list[tuple[tuple[str, ...], str]] = [
+        (("claude",), "anthropic"),
+        (("gpt", "o1", "o3", "o4"), "openai"),
+        (("grok",), "grok"),
+        (("kimi", "moonshot"), "kimi"),
+        (("minimax",), "minimax"),
+        (("nvidia",), "nvidia"),
+    ]
+
     def _resolve_callback(self, tier: ModelTier, model_name: str):
         """Map tier+model to a skseed callback.
 
+        Uses the configured ollama_model for local inference and
+        resolves cloud backends by model-name pattern matching.
+        Falls back through the configured fallback_chain.
+
         Args:
             tier: The routing tier.
             model_name: The concrete model name.
@@ -299,74 +317,58 @@ class LLMBridge:
         Returns:
             An LLMCallback callable.
         """
-        from skseed.llm import (
-            anthropic_callback,
-            grok_callback,
-            kimi_callback,
-            minimax_callback,
-            nvidia_callback,
-            ollama_callback,
-            openai_callback,
-            passthrough_callback,
-        )
+        from skseed.llm import ollama_callback
 
-        name_lower = model_name.lower()
-        # Strip Ollama :tag suffix for pattern matching (e.g. "deepseek-r1:8b" -> "deepseek-r1")
-        name_base = name_lower.split(":")[0]
+        name_base = model_name.lower().split(":")[0]
 
         # LOCAL tier always goes to Ollama
         if tier == ModelTier.LOCAL:
             return ollama_callback(model=model_name)
 
-        # Pattern matching on model name (use name_base to handle :tag suffixes)
-        if "claude" in name_base:
-            return anthropic_callback(model=model_name)
-        if "gpt" in name_base or "o1" in name_base or "o3" in name_base or "o4" in name_base:
-            return openai_callback(model=model_name)
-        if "grok" in name_base:
-            return grok_callback(model=model_name)
-        if "kimi" in name_base or "moonshot" in name_base:
-            return kimi_callback(model=model_name)
-        if "minimax" in name_base:
-            return minimax_callback(model=model_name)
-        if "nvidia" in name_base:
-            return nvidia_callback(model=model_name)
+        # Pattern matching on model name
+        for patterns, backend in self._MODEL_PATTERNS:
+            if any(p in name_base for p in patterns):
+                return self._callback_for_backend(backend, model=model_name)
 
         # Models that run on Ollama (local inference)
-        ollama_patterns = (
-            "llama",
-            "mistral",
-            "nemotron",
-            "devstral",
-            "deepseek",
-            "qwen",
-            "codestral",
-        )
-        for pattern in ollama_patterns:
-            if pattern in name_base:
-                return ollama_callback(model=model_name)
+        if any(p in name_base for p in _OLLAMA_MODEL_PATTERNS):
+            return ollama_callback(model=model_name)
 
         # Walk fallback chain for first available backend
         for backend in self._fallback_chain:
-            if not self._available.get(backend, False):
-                continue
-            if backend == "ollama":
-                return ollama_callback(model="llama3.2")
-            elif backend == "anthropic":
-                return anthropic_callback()
-            elif backend == "openai":
-                return openai_callback()
-            elif backend == "grok":
-                return grok_callback()
-            elif backend == "kimi":
-                return kimi_callback()
-            elif backend == "nvidia":
-                return nvidia_callback()
-            elif backend == "passthrough":
-                return self._make_passthrough_callback()
+            if self._available.get(backend, False):
+                return self._callback_for_backend(backend)
 
         return self._make_passthrough_callback()
 
+    def _callback_for_backend(self, backend: str, model: Optional[str] = None):
+        """Return the skseed callback for *backend*, importing only what's needed.
+
+        Args:
+            backend: Backend name (e.g. "ollama", "anthropic", "openai").
+            model: Optional model override. When None, uses each provider's default.
+
+        Returns:
+            An LLMCallback callable.
+        """
+        import skseed.llm as _llm
+
+        if backend == "ollama":
+            return _llm.ollama_callback(model=model or self._config.ollama_model)
+        if backend == "passthrough":
+            return self._make_passthrough_callback()
+
+        # All other backends follow the same pattern: <backend>_callback(model=…)
+        factory = getattr(_llm, f"{backend}_callback", None)
+        if factory is None:
+            logger.warning("No skseed callback for backend %r — using passthrough", backend)
+            return self._make_passthrough_callback()
+
+        kwargs: dict[str, Any] = {}
+        if model:
+            kwargs["model"] = model
+        return factory(**kwargs)
+
     @staticmethod
     def _make_passthrough_callback():
         """Return a passthrough callback that always produces a plain str.
@@ -463,16 +465,6 @@ class LLMBridge:
         Returns:
             LLM response text, or a fallback error message.
         """
-        from skseed.llm import (
-            anthropic_callback,
-            grok_callback,
-            kimi_callback,
-            minimax_callback,
-            nvidia_callback,
-            ollama_callback,
-            openai_callback,
-        )
-
         decision = self._router.route(signal)
         logger.info(
             "Routed to tier=%s model=%s: %s",
@@ -612,31 +604,14 @@ class LLMBridge:
                         )
                     )
 
-        # Cross-provider cascade via fallback chain — direct backend mapping,
-        # no _resolve_callback, to avoid infinite regression on unknown names.
+        # Cross-provider cascade via fallback chain — uses _callback_for_backend
+        # so adding a new provider only requires updating the registry, not this loop.
         for backend in self._fallback_chain:
             if not self._available.get(backend, False):
                 continue
             try:
                 logger.info("Fallback cascade: %s", backend)
-                if backend == "ollama":
-                    callback = ollama_callback(model="llama3.2")
-                elif backend == "anthropic":
-                    callback = anthropic_callback()
-                elif backend == "grok":
-                    callback = grok_callback()
-                elif backend == "kimi":
-                    callback = kimi_callback()
-                elif backend == "minimax":
-                    callback = minimax_callback()
-                elif backend == "nvidia":
-                    callback = nvidia_callback()
-                elif backend == "openai":
-                    callback = openai_callback()
-                elif backend == "passthrough":
-                    callback = self._make_passthrough_callback()
-                else:
-                    continue
+                callback = self._callback_for_backend(backend)
                 result = self._timed_call(callback, adapted, ModelTier.FAST)
                 if _out_info is not None:
                     _out_info["backend"] = backend

package/src/skcapstone/onboard.py

@@ -1283,44 +1283,61 @@ def _step_doctor_check(home_path: Path) -> "object":
 
 
 def _step_test_consciousness(home_path: Path) -> bool:
-    """Send a test message through the consciousness loop (optional).
+    """Send a quick test message to the configured LLM backend.
+
+    Reads the consciousness config to determine the default backend
+    (typically the local Ollama model chosen during onboarding) and
+    sends a single prompt to verify the pipeline works end-to-end.
 
     Args:
         home_path: Agent home directory.
 
     Returns:
-        True if the loop responded successfully.
+        True if the LLM responded successfully.
     """
-    if not click.confirm("  Send a test message to verify the consciousness loop?", default=False):
+    if not click.confirm("  Send a test message to verify the LLM backend?", default=False):
         click.echo(
             click.style("  ↷ ", fg="bright_black")
             + "Skipped — test later: skcapstone consciousness test 'hello'"
         )
         return False
 
-    click.echo(click.style("  Sending test message…", fg="bright_black"))
+    # Load config to discover which backend/model was configured
     try:
         from .consciousness_config import load_consciousness_config
-        from .consciousness_loop import LLMBridge, SystemPromptBuilder, _classify_message
-
         config = load_consciousness_config(home_path)
-        bridge = LLMBridge(config)
-        builder = SystemPromptBuilder(home_path, config.max_context_tokens)
-        signal = _classify_message("Onboard wizard test — please confirm you are running.")
-        system_prompt = builder.build()
-        response = bridge.generate(system_prompt, "Onboard wizard test — please confirm you are running.", signal)
+    except Exception:
+        # Fall back to defaults
+        ollama_model = "llama3.2"
+        ollama_host = "http://localhost:11434"
+        config = None
+    else:
+        ollama_model = config.ollama_model
+        ollama_host = config.ollama_host
+
+    click.echo(
+        click.style("  Testing ", fg="bright_black")
+        + click.style(f"{ollama_model}", fg="cyan")
+        + click.style(f" @ {ollama_host}…", fg="bright_black")
+    )
+
+    try:
+        from skseed.llm import ollama_callback
+
+        callback = ollama_callback(model=ollama_model, base_url=ollama_host)
+        response = callback("Respond in one sentence: are you online?")
         if response:
             preview = response[:80].replace("\n", " ")
-            click.echo(click.style("  ✓ ", fg="green") + f"Consciousness loop active")
+            click.echo(click.style("  ✓ ", fg="green") + "LLM backend active")
             click.echo(click.style("    ", fg="bright_black") + f"Response: {preview!r}")
             return True
         else:
-            click.echo(click.style("  ⚠ ", fg="yellow") + "Empty response — loop may not be fully configured")
-            click.echo(click.style("    ", fg="bright_black") + "Start daemon: skcapstone daemon start")
+            click.echo(click.style("  ⚠ ", fg="yellow") + "Empty response — model may still be loading")
+            click.echo(click.style("    ", fg="bright_black") + f"Try: ollama run {ollama_model}")
             return False
     except Exception as exc:
         click.echo(click.style("  ⚠ ", fg="yellow") + f"Test failed: {exc}")
-        click.echo(click.style("    ", fg="bright_black") + "Start daemon: skcapstone daemon start --foreground")
+        click.echo(click.style("    ", fg="bright_black") + f"Check: ollama serve && ollama run {ollama_model}")
         return False
 
 

package/src/skcapstone/pillars/consciousness.py

@@ -80,17 +80,23 @@ def initialize_consciousness(home: Path) -> ConsciousnessState:
         except (json.JSONDecodeError, OSError):
             pass
 
-    # Check if daemon is running (systemd)
+    # Check if consciousness daemon is running (systemd)
+    # Accept either the legacy skwhisper service or the skcapstone service
     try:
         import subprocess
 
-        result = subprocess.run(
-            ["systemctl", "--user", "is-active", "skwhisper"],
-            capture_output=True,
-            text=True,
-            timeout=3,
-        )
-        state.whisper_active = result.stdout.strip() == "active"
+        for service_name in ("skcapstone", "skwhisper"):
+            result = subprocess.run(
+                ["systemctl", "--user", "is-active", service_name],
+                capture_output=True,
+                text=True,
+                timeout=3,
+            )
+            if result.stdout.strip() == "active":
+                state.whisper_active = True
+                break
+        else:
+            state.whisper_active = False
     except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
         state.whisper_active = False
 
@@ -105,6 +111,9 @@ def initialize_consciousness(home: Path) -> ConsciousnessState:
             state.status = PillarStatus.ACTIVE
         else:
             state.status = PillarStatus.DEGRADED
+    elif state.whisper_active:
+        # Daemon is running but no sessions digested yet — consciousness is live
+        state.status = PillarStatus.DEGRADED
     elif state.sessions_digested > 0 or state.whisper_md is not None:
         state.status = PillarStatus.DEGRADED
     else: