OpenJarvis 1.0.2.dev667__tar.gz → 1.0.2.dev689__tar.gz

{openjarvis-1.0.2.dev667 → openjarvis-1.0.2.dev689}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenJarvis
-Version: 1.0.2.dev667
+Version: 1.0.2.dev689
 Summary: OpenJarvis — modular AI assistant backend with composable intelligence primitives
 Project-URL: Homepage, https://github.com/open-jarvis/OpenJarvis
 Project-URL: Documentation, https://open-jarvis.github.io/OpenJarvis/

{openjarvis-1.0.2.dev667 → openjarvis-1.0.2.dev689}/docs/architecture/engine.md

@@ -116,7 +116,7 @@ All providers produce the same output format consumed by agents:
 | **LM Studio** | `lmstudio` | OpenAI-compatible | 1234 | No (GPU optional) | Desktop GUI, easy model management |
 | **Exo** | `exo` | OpenAI-compatible | 52415 | No (distributed) | Distributed inference across heterogeneous devices |
 | **Nexa** | `nexa` | OpenAI-compatible | 18181 | No (CPU/GPU) | On-device inference with GGUF models |
-| **Lemonade** | `lemonade` | OpenAI-compatible | 8000 | AMD GPU/NPU | AMD consumer GPUs (RDNA), Ryzen AI NPUs |
+| **Lemonade** | `lemonade` | OpenAI-compatible | 13305 | AMD GPU/NPU | AMD consumer GPUs (RDNA), Ryzen AI NPUs |
 | **Uzu** | `uzu` | OpenAI-compatible | 8000 | Varies | Uzu inference runtime |
 | **Apple FM** | `apple_fm` | OpenAI-compatible | 8079 | Apple Silicon | Apple Foundation Model on-device inference |
 | **LiteLLM** | `litellm` | OpenAI-compatible | — | No | Unified proxy to 100+ LLM providers |
@@ -135,7 +135,7 @@ The Ollama backend communicates via Ollama's native HTTP API at `/api/chat` and
 
 The vLLM backend uses the OpenAI-compatible `/v1/chat/completions` API. It is recommended for datacenter GPUs (NVIDIA A100, H100, L40, A10, A30 and AMD MI300, MI325, MI350, MI355).
 
-- **Default host:** `http://localhost:8000`
+- **Default host:** `http://localhost:13305`
 - **Health check:** `GET /v1/models`
 - **Tool fallback:** If the server returns HTTP 400 when tools are included, the engine automatically retries without tools
 
@@ -204,7 +204,7 @@ The Nexa backend connects to the Nexa SDK on-device inference server via a FastA
 
 The Lemonade backend connects to the [Lemonade](https://lemonade-server.ai/) inference server, which is optimized for AMD consumer GPUs (RDNA architecture) and Ryzen AI Neural Processing Units (NPUs). It uses the OpenAI-compatible `/v1/chat/completions` API.
 
-- **Default host:** `http://localhost:8000`
+- **Default host:** `http://localhost:13305`
 - **Health check:** `GET /v1/models`
 - **Install:** Visit [lemonade-server.ai](https://lemonade-server.ai/) for platform-specific installation instructions
 - **Best for:** Ryzen AI GPUs and NPUs, and AMD-based desktop and laptop systems
@@ -357,7 +357,7 @@ host = "http://localhost:30000"
 # binary_path = ""
 
 # [engine.lemonade]
-# host = "http://localhost:8000"
+# host = "http://localhost:13305"
 ```
 
 The `EngineConfig` dataclass and its per-engine sub-dataclasses map these settings:
@@ -370,7 +370,7 @@ The `EngineConfig` dataclass and its per-engine sub-dataclasses map these settin
 | `SGLangEngineConfig` | `host` | `http://localhost:30000` | SGLang server URL |
 | `LlamaCppEngineConfig` | `host` | `http://localhost:8080` | llama.cpp server URL |
 | `LlamaCppEngineConfig` | `binary_path` | `""` | Path to llama.cpp binary (for managed mode) |
-| `LemonadeEngineConfig` | `host` | `http://localhost:8000` | Lemonade server URL |
+| `LemonadeEngineConfig` | `host` | `http://localhost:13305` | Lemonade server URL |
 
 !!! note "Backward compatibility"
     The old flat field names `ollama_host`, `vllm_host`, `llamacpp_host`, `llamacpp_path`, `sglang_host`, and `lemonade_host` under `[engine]` are still accepted as backward-compatible properties on `EngineConfig`. New configurations should use the nested sub-section format.

{openjarvis-1.0.2.dev667 → openjarvis-1.0.2.dev689}/docs/user-guide/skills.md

@@ -148,6 +148,14 @@ jarvis skill sync openclaw --search "web3|crypto"
 jarvis skill install github:user/repo/path/to/skill --url https://github.com/user/repo
 ```
 
+For example, install the Hermes Tweet skill when you want an agent to search
+Twitter/X, read tweet replies, monitor tweets, export followers, and run
+gated post, reply, or DM workflows:
+
+```bash
+jarvis skill install github:Xquik-dev/hermes-tweet/skills/hermes-tweet --url https://github.com/Xquik-dev/hermes-tweet
+```
+
 ### Config-Driven Auto Import
 
 Add sources to `~/.openjarvis/config.toml` for automatic syncing:

{openjarvis-1.0.2.dev667 → openjarvis-1.0.2.dev689}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "OpenJarvis"
-version = "1.0.2.dev667"
+version = "1.0.2.dev689"
 description = "OpenJarvis — modular AI assistant backend with composable intelligence primitives"
 readme = "README.md"
 requires-python = ">=3.10"

openjarvis-1.0.2.dev689/rust/crates/openjarvis-python/src/skills.rs

@@ -0,0 +1,128 @@
+//! PyO3 bindings for skill manifests and verification.
+
+use pyo3::prelude::*;
+
+#[pyclass(name = "SkillManifest")]
+pub struct PySkillManifest {
+    inner: openjarvis_skills::SkillManifest,
+}
+
+#[pymethods]
+impl PySkillManifest {
+    #[getter]
+    fn name(&self) -> &str {
+        &self.inner.name
+    }
+
+    #[getter]
+    fn version(&self) -> &str {
+        &self.inner.version
+    }
+
+    #[getter]
+    fn description(&self) -> &str {
+        &self.inner.description
+    }
+
+    #[getter]
+    fn author(&self) -> &str {
+        &self.inner.author
+    }
+
+    #[getter]
+    fn steps_count(&self) -> usize {
+        self.inner.steps.len()
+    }
+
+    #[getter]
+    fn required_capabilities(&self) -> Vec<String> {
+        self.inner.required_capabilities.clone()
+    }
+
+    fn to_json(&self) -> String {
+        serde_json::to_string(&self.inner).unwrap_or_default()
+    }
+
+    fn manifest_bytes(&self) -> Vec<u8> {
+        self.inner.manifest_bytes()
+    }
+
+    fn verify_signature(&self, public_key_hex: &str) -> bool {
+        match parse_public_key_hex(public_key_hex) {
+            Some(key_bytes) => openjarvis_skills::verify_signature(&self.inner, &key_bytes),
+            None => false,
+        }
+    }
+}
+
+fn parse_public_key_hex(public_key_hex: &str) -> Option<Vec<u8>> {
+    if !public_key_hex.len().is_multiple_of(2) {
+        return None;
+    }
+    if !public_key_hex.is_ascii() {
+        return None;
+    }
+
+    let mut key_bytes = Vec::with_capacity(public_key_hex.len() / 2);
+    for i in (0..public_key_hex.len()).step_by(2) {
+        match u8::from_str_radix(&public_key_hex[i..i + 2], 16) {
+            Ok(byte) => key_bytes.push(byte),
+            Err(_) => return None,
+        }
+    }
+    Some(key_bytes)
+}
+
+#[pyfunction]
+pub fn load_skill(toml_str: &str) -> PyResult<PySkillManifest> {
+    let manifest = openjarvis_skills::load_skill(toml_str)
+        .map_err(|e| PyErr::new::<pyo3::exceptions::PyValueError, _>(e))?;
+    Ok(PySkillManifest { inner: manifest })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::parse_public_key_hex;
+
+    #[test]
+    fn empty_input_returns_empty_vec() {
+        assert_eq!(parse_public_key_hex(""), Some(Vec::new()));
+    }
+
+    #[test]
+    fn valid_hex_decodes() {
+        assert_eq!(
+            parse_public_key_hex("0a1b2cFF"),
+            Some(vec![0x0a, 0x1b, 0x2c, 0xff])
+        );
+    }
+
+    #[test]
+    fn odd_length_rejected_without_panic() {
+        // Regression: the pre-fix implementation sliced public_key_hex[i..i+2]
+        // on an odd-length string, triggering an out-of-bounds panic and a
+        // DoS vector when the input was attacker-controlled.
+        assert_eq!(parse_public_key_hex("0"), None);
+        assert_eq!(parse_public_key_hex("abc"), None);
+        assert_eq!(parse_public_key_hex("0a1b2"), None);
+    }
+
+    #[test]
+    fn non_hex_chars_rejected() {
+        // Pre-fix `filter_map` silently dropped non-hex chars and produced a
+        // truncated key, which would also have caused verification surprises.
+        assert_eq!(parse_public_key_hex("zz"), None);
+        assert_eq!(parse_public_key_hex("0aZZ"), None);
+        assert_eq!(parse_public_key_hex("gh"), None);
+    }
+
+    #[test]
+    fn multibyte_utf8_rejected_without_panic() {
+        // Pre-fix indexing public_key_hex[i..i+2] on a non-ASCII string could
+        // split a multi-byte UTF-8 codepoint and panic. The ASCII-only check
+        // makes the rejection explicit instead of relying on from_str_radix's
+        // post-slice error path.
+        assert_eq!(parse_public_key_hex("é"), None);
+        assert_eq!(parse_public_key_hex("aaé"), None);
+    }
+}

{openjarvis-1.0.2.dev667 → openjarvis-1.0.2.dev689}/src/openjarvis/agents/executor.py

@@ -317,6 +317,24 @@ class AgentExecutor:
                         tool_instances.append(tool)
                     except Exception:
                         logger.warning("Failed to instantiate tool %s", tname)
+
+            # Pull tools already discovered by SystemBuilder (e.g. external MCP
+            # adapters) that aren't in the static ToolRegistry. Without this,
+            # agents declaring MCP-discovered tools in their template would
+            # silently fall back to natives only.
+            if (
+                self._system is not None
+                and getattr(self._system, "tool_executor", None) is not None
+            ):
+                mcp_pool = getattr(self._system.tool_executor, "_tools", {}) or {}
+                existing = {t.spec.name for t in tool_instances}
+                for tname in tool_names:
+                    if tname in existing:
+                        continue
+                    pooled = mcp_pool.get(tname)
+                    if pooled is not None:
+                        tool_instances.append(pooled)
+
             if tool_instances:
                 logger.info(
                     "Agent %s: resolved %d/%d tools",
@@ -332,6 +350,12 @@ class AgentExecutor:
             agent_kwargs["system_prompt"] = sys_prompt
         if getattr(agent_cls, "accepts_tools", False) and tool_instances:
             agent_kwargs["tools"] = tool_instances
+        # Propagate confirmation policy from the AgentExecutor down to the
+        # agent's own ToolExecutor. Set by CLI paths like `jarvis agents ask`
+        # so non-interactive runs can auto-approve tool execution.
+        if getattr(self, "_confirm_callback", None) is not None:
+            agent_kwargs["interactive"] = True
+            agent_kwargs["confirm_callback"] = self._confirm_callback
         try:
             agent_instance = agent_cls(engine, model, **agent_kwargs)
         except TypeError:

{openjarvis-1.0.2.dev667 → openjarvis-1.0.2.dev689}/src/openjarvis/cli/__init__.py

@@ -140,6 +140,15 @@ except ImportError:
 
 def main() -> None:
     """Entry point registered as ``jarvis`` console script."""
+    import sys
+
+    if sys.platform == "win32":
+        for _stream in (sys.stdout, sys.stderr):
+            if hasattr(_stream, "reconfigure"):
+                try:
+                    _stream.reconfigure(encoding="utf-8", errors="replace")
+                except (AttributeError, OSError):
+                    pass
     cli()
 
 

{openjarvis-1.0.2.dev667 → openjarvis-1.0.2.dev689}/src/openjarvis/cli/agent_cmd.py

@@ -702,16 +702,34 @@ def errors():
 @agent.command("ask")
 @click.argument("agent_id")
 @click.argument("message")
-def ask(agent_id, message):
+@click.option(
+    "--yes/--no-yes",
+    "auto_approve",
+    default=True,
+    help="Auto-approve tool execution that would otherwise need confirmation. "
+    "Default: on (suits non-interactive CLI use). Pass --no-yes to require a "
+    "TTY prompt for tools whose ToolSpec sets requires_confirmation=True.",
+)
+def ask(agent_id, message, auto_approve):
     """Ask an agent a question (immediate response)."""
     manager = _get_manager()
     agent_id = _resolve_agent_id(manager, agent_id)
     manager.send_message(agent_id, message, mode="immediate")
     click.echo("Asking agent...")
-    _, executor, _ = _get_scheduler_and_executor()
+    _, executor, system = _get_scheduler_and_executor()
     if executor is None:
         click.echo("Executor not available", err=True)
         raise SystemExit(1)
+    # Wire a confirmation callback so the agent's own ToolExecutor can actually
+    # run tools whose ToolSpec sets requires_confirmation=True (e.g. shell_exec,
+    # git_*). `executor` is the AgentExecutor; the callback is read in
+    # _invoke_agent and propagated to the constructed agent via agent_kwargs.
+    if auto_approve:
+        executor._confirm_callback = lambda _prompt: True
+    else:
+        executor._confirm_callback = (
+            lambda prompt: click.confirm(f"\n{prompt}", default=False)
+        )
     executor.execute_tick(agent_id)
     msgs = manager.list_messages(agent_id)
     responses = [m for m in msgs if m["direction"] == "agent_to_user"]

{openjarvis-1.0.2.dev667 → openjarvis-1.0.2.dev689}/src/openjarvis/cli/ask.py

@@ -357,6 +357,22 @@ def _run_agent(
     if capability_policy is not None:
         agent_kwargs["capability_policy"] = capability_policy
 
+    # Wire the SystemPromptBuilder so SOUL.md / MEMORY.md / USER.md persona
+    # files actually reach the model. Only passed to agents whose __init__
+    # accepts a `prompt_builder` kwarg (BaseAgent does; agents that override
+    # __init__ without forwarding it, e.g. OrchestratorAgent, opt out
+    # automatically and keep their existing system-prompt machinery).
+    import inspect as _inspect
+
+    if "prompt_builder" in _inspect.signature(agent_cls.__init__).parameters:
+        from openjarvis.prompt.builder import SystemPromptBuilder
+
+        agent_kwargs["prompt_builder"] = SystemPromptBuilder(
+            agent_template=config.agent.default_system_prompt or "",
+            memory_files_config=config.memory_files,
+            system_prompt_config=config.system_prompt,
+        )
+
     agent = agent_cls(engine, model_name, **agent_kwargs)
     ctx = AgentContext()
 
@@ -535,7 +551,11 @@ def _print_profile(
     "--agent",
     "agent_name",
     default=None,
-    help="Agent to use (simple, orchestrator).",
+    help=(
+        "Agent to use (simple, orchestrator, ...). "
+        "When omitted, falls back to ``agent.default_agent`` from config. "
+        "Pass ``--agent ''`` to force direct-to-engine mode (no agent)."
+    ),
 )
 @click.option(
     "--tools",
@@ -591,6 +611,16 @@ def ask(
     # Load config
     config = load_config()
 
+    # Honor `agent.default_agent` from config when --agent was not explicitly
+    # passed. Pass `--agent ""` to opt out and use direct-to-engine mode.
+    # Without this fallback, `[agent].default_system_prompt` and the
+    # SOUL.md / MEMORY.md / USER.md persona system are silently bypassed for
+    # the most common command (`jarvis ask "..."`).
+    if agent_name is None:
+        configured_default = (config.agent.default_agent or "").strip()
+        if configured_default:
+            agent_name = configured_default
+
     # Track whether the user explicitly set --max-tokens
     user_set_max_tokens = max_tokens is not None
 
@@ -715,8 +745,8 @@ def ask(
             model_name,
         )
 
-    # Agent mode
-    if agent_name is not None:
+    # Agent mode (treat empty-string `--agent ""` as explicit opt-out)
+    if agent_name:
         parsed_tools = resolve_tool_names(
             tool_names,
             getattr(config.tools, "enabled", None),

{openjarvis-1.0.2.dev667 → openjarvis-1.0.2.dev689}/src/openjarvis/core/config.py

@@ -188,13 +188,34 @@ def _total_ram_gb() -> float:
         if platform.system() == "Darwin":
             raw = _run_cmd(["sysctl", "-n", "hw.memsize"])
             return round(int(raw) / (1024**3), 1) if raw else 0.0
+        if platform.system() == "Windows":
+            import ctypes
+
+            class _MemoryStatusEx(ctypes.Structure):
+                _fields_ = [
+                    ("dwLength", ctypes.c_ulong),
+                    ("dwMemoryLoad", ctypes.c_ulong),
+                    ("ullTotalPhys", ctypes.c_ulonglong),
+                    ("ullAvailPhys", ctypes.c_ulonglong),
+                    ("ullTotalPageFile", ctypes.c_ulonglong),
+                    ("ullAvailPageFile", ctypes.c_ulonglong),
+                    ("ullTotalVirtual", ctypes.c_ulonglong),
+                    ("ullAvailVirtual", ctypes.c_ulonglong),
+                    ("sullAvailExtendedVirtual", ctypes.c_ulonglong),
+                ]
+
+            stat = _MemoryStatusEx()
+            stat.dwLength = ctypes.sizeof(_MemoryStatusEx)
+            if ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(stat)):
+                return round(stat.ullTotalPhys / (1024**3), 1)
+            return 0.0
         meminfo = Path("/proc/meminfo")
         if meminfo.exists():
             for line in meminfo.read_text().splitlines():
                 if line.startswith("MemTotal"):
                     kb = int(line.split()[1])
                     return round(kb / (1024**2), 1)
-    except (OSError, ValueError):
+    except (OSError, ValueError, AttributeError):
         pass
     return 0.0
 
@@ -259,14 +280,14 @@ _MODEL_TIERS = [
     (64, "qwen3.5:27b"),
 ]
 _MODEL_TIER_FALLBACK = "qwen3.5:27b"
+_LEMONADE_DEFAULT_MODEL = "Qwen3.6-35B-A3B-GGUF"
 
 
 def recommend_model(hw: HardwareInfo, engine: str) -> str:
-    """Suggest the best Qwen3.5 model that fits the detected hardware.
+    """Suggest a default model for the selected engine and hardware.
 
-    Uses an explicit tier table mapping available memory to model size.
-    Falls back to scanning the full catalog if the tiered model is not
-    compatible with the selected engine.
+    For Lemonade, prefer the validated Qwen3.6 35B A3B GGUF default.
+    For other local engines, use the generic Qwen3.5 tier mapping.
     """
     from openjarvis.intelligence.model_catalog import BUILTIN_MODELS
 
@@ -274,6 +295,9 @@ def recommend_model(hw: HardwareInfo, engine: str) -> str:
     if available_gb <= 0:
         return ""
 
+    if engine == "lemonade":
+        return _LEMONADE_DEFAULT_MODEL
+
     # Build a lookup for quick engine-compatibility checks
     catalog = {spec.model_id: spec for spec in BUILTIN_MODELS}
 
@@ -401,7 +425,7 @@ class GemmaCppEngineConfig:
 class LemonadeEngineConfig:
     """Per-engine config for Lemonade."""
 
-    host: str = "http://localhost:8000"
+    host: str = "http://localhost:13305"
 
 
 @dataclass

{openjarvis-1.0.2.dev667 → openjarvis-1.0.2.dev689}/src/openjarvis/engine/openai_compat_engines.py

@@ -13,7 +13,7 @@ _ENGINES = {
     "nexa": ("NexaEngine", "http://localhost:18181", "/v1"),
     "uzu": ("UzuEngine", "http://localhost:8000", ""),
     "apple_fm": ("AppleFmEngine", "http://localhost:8079", "/v1"),
-    "lemonade": ("LemonadeEngine", "http://localhost:8000", "/v1"),
+    "lemonade": ("LemonadeEngine", "http://localhost:13305", "/v1"),
 }
 
 for _key, (_cls_name, _default_host, _api_prefix) in _ENGINES.items():

{openjarvis-1.0.2.dev667 → openjarvis-1.0.2.dev689}/src/openjarvis/mcp/client.py

@@ -84,11 +84,15 @@ class MCPClient:
         """
         response = self._send("tools/list")
         tools = response.result.get("tools", [])
+        # MCP tools often wrap long-running pentest/scan commands. The default
+        # ToolSpec timeout (30s) kills them mid-scan. Bump to 600s — individual
+        # MCP servers can shorten via their own protocol if needed.
         return [
             ToolSpec(
                 name=t["name"],
                 description=t.get("description", ""),
                 parameters=t.get("inputSchema", {}),
+                timeout_seconds=600.0,
             )
             for t in tools
         ]

{openjarvis-1.0.2.dev667 → openjarvis-1.0.2.dev689}/src/openjarvis/mcp/transport.py

@@ -88,6 +88,20 @@ class StdioTransport(MCPTransport):
             raise RuntimeError("No response from subprocess")
         return MCPResponse.from_json(response_line.strip())
 
+    def send_notification(self, request: MCPRequest) -> None:
+        """Send a JSON-RPC notification — write only, never read.
+
+        Overrides the base implementation: stdio servers do not reply
+        to notifications, so the default ``send()`` would block forever
+        on ``proc.stdout.readline()``.
+        """
+        proc = self._process
+        if proc is None or proc.stdin is None:
+            raise RuntimeError("Transport process is not running")
+        line = request.to_json() + "\n"
+        proc.stdin.write(line)
+        proc.stdin.flush()
+
     def close(self) -> None:
         """Terminate the subprocess."""
         if self._process is not None:

{openjarvis-1.0.2.dev667 → openjarvis-1.0.2.dev689}/src/openjarvis/prompt/builder.py

@@ -86,7 +86,10 @@ class SystemPromptBuilder:
         path = Path(path_str).expanduser()
         if not path.exists():
             return ""
-        content = path.read_text()
+        # Always read as UTF-8. On Windows, ``read_text()`` falls back to the
+        # system code page (e.g. cp950 for zh-TW, cp932 for ja) and raises
+        # ``UnicodeDecodeError`` on any non-ASCII persona content.
+        content = path.read_text(encoding="utf-8")
         if len(content) <= max_chars:
             return content
         return self._truncate(content, max_chars)

{openjarvis-1.0.2.dev667 → openjarvis-1.0.2.dev689}/src/openjarvis/telemetry/gpu_monitor.py

@@ -13,7 +13,6 @@ logger = logging.getLogger(__name__)
 
 try:
     import pynvml
-
     _PYNVML_AVAILABLE = True
 except ImportError:
     _PYNVML_AVAILABLE = False
@@ -23,7 +22,6 @@ except ImportError:
 # Hardware spec database
 # ---------------------------------------------------------------------------
 
-
 @dataclass(frozen=True)
 class GpuHardwareSpec:
     """Peak theoretical capabilities for a known GPU model."""
@@ -50,6 +48,26 @@ GPU_SPECS: Dict[str, GpuHardwareSpec] = {
     # Apple Silicon
     "M4 Max": GpuHardwareSpec(tflops_fp16=53, bandwidth_gb_s=546, tdp_watts=40),
     "M2 Ultra": GpuHardwareSpec(tflops_fp16=27, bandwidth_gb_s=800, tdp_watts=60),
+    # Intel Arc
+    "Arc B580": GpuHardwareSpec(tflops_fp16=196, bandwidth_gb_s=456, tdp_watts=190),
+    "Arc B570": GpuHardwareSpec(tflops_fp16=136, bandwidth_gb_s=380, tdp_watts=150),
+    # NVIDIA Jetson
+    "Jetson Orin NX 16GB": GpuHardwareSpec(
+        tflops_fp16=50, bandwidth_gb_s=102, tdp_watts=25
+    ),
+    "Jetson Orin NX 8GB": GpuHardwareSpec(
+        tflops_fp16=25, bandwidth_gb_s=68, tdp_watts=15
+    ),
+    "Jetson AGX Orin": GpuHardwareSpec(
+        tflops_fp16=108, bandwidth_gb_s=204, tdp_watts=60
+    ),
+    # Qualcomm
+    "Snapdragon X Elite": GpuHardwareSpec(
+        tflops_fp16=4.6, bandwidth_gb_s=136, tdp_watts=80
+    ),
+    "Snapdragon X Plus": GpuHardwareSpec(
+        tflops_fp16=3.8, bandwidth_gb_s=136, tdp_watts=80
+    ),
 }
 
 
@@ -70,7 +88,6 @@ def lookup_gpu_spec(name: str) -> Optional[GpuHardwareSpec]:
 # Snapshot & aggregated sample
 # ---------------------------------------------------------------------------
 
-
 @dataclass
 class GpuSnapshot:
     """A single point-in-time reading from one GPU device."""
@@ -103,7 +120,6 @@ class GpuSample:
 # Monitor
 # ---------------------------------------------------------------------------
 
-
 class GpuMonitor:
     """Background GPU poller using pynvml.
 
@@ -219,6 +235,7 @@ class GpuMonitor:
             mean_util = sum(s.utilization_pct for s in tick_snaps) / len(tick_snaps)
             total_mem = sum(s.memory_used_gb for s in tick_snaps)
             mean_temp = sum(s.temperature_c for s in tick_snaps) / len(tick_snaps)
+
             tick_powers.append(total_power)
             tick_utils.append(mean_util)
             tick_mems.append(total_mem)
@@ -256,7 +273,6 @@ class GpuMonitor:
         :class:`GpuSample` without starting a background thread.
         """
         result = GpuSample()
-
         if not self._initialized or self._device_count == 0:
             t_start = time.monotonic()
             yield result
@@ -276,11 +292,13 @@ class GpuMonitor:
 
         t_start = time.monotonic()
         thread.start()
+
         try:
             yield result
         finally:
             stop_event.set()
             thread.join(timeout=2.0)
+
             wall = time.monotonic() - t_start
 
             with lock: