OpenJarvis 1.0.4.dev1058__tar.gz → 1.0.4.dev1061__tar.gz

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/.github/clone-stats/badge.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "label": "Git Clones",
-  "message": "212,820",
+  "message": "214,122",
   "color": "green",
   "namedLogo": "git"
 }

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/.github/clone-stats/clone-data.json

@@ -1,6 +1,6 @@
 {
-  "total_clones": 212820,
-  "last_updated": "2026-08-24T06:14:27Z",
+  "total_clones": 214122,
+  "last_updated": "2026-08-25T06:09:52Z",
   "daily": {
     "2026-03-27": 2189,
     "2026-03-28": 1874,
@@ -150,6 +150,7 @@
     "2026-08-19": 763,
     "2026-08-20": 10539,
     "2026-08-21": 3692,
-    "2026-08-22": 2346
+    "2026-08-22": 2346,
+    "2026-08-23": 1302
   }
 }

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/CHANGELOG.md

@@ -10,6 +10,50 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ### Added
 
+**Apple Foundation Models (AFM 3)** — a new in-process `afm` engine drives
+Apple's `apple-fm-sdk` directly, with no HTTP hop and no second process whose
+CPU draw would land inside the same energy measurement window. Install with
+`DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer uv sync --extra afm`
+(the SDK compiles Swift bindings, so a full Xcode is required), then
+`jarvis ask --engine afm --model afm-3-core "..."`. Requires an Apple Silicon
+Mac on macOS 26+ with Apple Intelligence enabled.
+
+Token counts are real, via `SystemLanguageModel.token_count` (added in SDK
+0.2.1, hence the floor). Because `token_count` rejects a value and
+instructions together, both ends are measured against the session transcript:
+`prompt_tokens = <transcript before> + <prompt alone>` and
+`completion_tokens = <transcript after> - prompt_tokens`.
+
+Two caveats worth reading before comparing AFM numbers to other backends:
+`stream_response` yields cumulative snapshots batching roughly 8-10 tokens, so
+`ttft` is time-to-first-*chunk* (~450 ms on an M1 Pro) and derived
+inter-token latencies are inter-chunk; and the SDK exposes no variant
+selector, so `afm-3` / `afm-3-core` / `afm-3-core-advanced` are run labels
+only — the framework's dynamic profile chooses what actually executes.
+Bench results record `metadata["engine_info"]` (SDK version, context size,
+host chip) so a run can be attributed after the fact.
+
+**Eval results record which rail did the work.** Result rows and summaries
+previously carried only `energy_joules` and `power_watts`, so nothing in an
+eval artifact distinguished a Neural Engine run from an idle GPU, or a
+hardware measurement from a modelled estimate. Rows now include the per-rail
+breakdown (`cpu`/`gpu`/`dram`/`ane`/`soc`), `energy_basis`, and
+`energy_method`; summaries add `energy_joules_by_rail` alongside both. On a
+ToolCall-15 run against AFM the ANE rail is the largest single component —
+91.7 J of 223.7 J, against 3.0 J on the GPU — which is now visible in the
+file rather than only through live instrumentation.
+
+**ANE and whole-SoC energy** — `EnergySample.ane_energy_joules` existed but
+died at the monitor boundary. Apple Neural Engine and a whole-SoC total now
+flow through `TelemetryRecord`, the SQLite schema (with an `ADD COLUMN`
+migration), the aggregator, `TelemetrySession`, eval `TurnTrace`/`QueryTrace`,
+and bench metadata, alongside an `energy_basis` marker (`"soc"` on Apple
+Silicon, `"gpu"` elsewhere) so downstream repeats the monitor's choice instead
+of guessing. This matters because AFM runs predominantly on the ANE: measured
+on an M1 Pro, one generation drew 0.98 J on the ANE against 0.014 J on the
+GPU rail — 70x — where an MLX matmul on the same machine drew 8.99 J on the
+GPU and nothing on the ANE.
+
 **Vision input for `jarvis ask`** — attach images to a query with
 `-i`/`--image` (repeatable) or capture the current screen with
 `-S`/`--screen`, for vision-capable models such as `gemma3:4b`. Images flow
@@ -21,6 +65,49 @@ stack with `mss`/`Pillow` fallbacks on other platforms. Adds the
 `JARVIS_NUM_CTX` environment variable to tune the Ollama context window
 (default `16384`).
 
+### Fixed
+
+**Apple Silicon energy was never measured, only modelled.**
+`telemetry/energy_apple.py` imported `AppleSiliconMonitor` from
+`zeus.device.soc.apple`; no such class has ever existed there. The import
+raised on every machine, so the CPU-time fallback -- `wall_clock x TDP x 0.60`
+split by four hardcoded ratios -- was the only path that ever ran. It read no
+counters and no utilization, so a ten-second sleep and a ten-second generation
+produced identical joules, and every Apple Silicon figure in the telemetry DB,
+eval traces and `jarvis bench` came from it. Renaming the import would not
+have helped: `zeus.device.soc` landed on zeus master after the last zeus
+release, so no published `zeus-ml` contains it, and `zeus-ml` has no `apple`
+extra either. `energy-apple` now installs `zeus-apple-silicon`, the IOReport
+extension zeus itself wraps, which needs no root. Measured on an M1 Pro:
+8.24 W under load against 3.72 W idle, where the previous code could not tell
+the two windows apart.
+
+`AppleEnergyMonitor.available()` now reports `False` when nothing is
+measurable, instead of `True` on any Apple Silicon host, so the factory falls
+through rather than letting a model masquerade as a measurement. The estimate
+remains reachable through the new `telemetry.allow_energy_estimates` setting
+and still reports `energy_method = "tdp_estimate"`.
+
+`snapshot()` is implemented for the first time, so `TelemetrySession`'s
+background sampler -- the path agentic evals use -- records real readings
+rather than the ABC's empty default. Relatedly, `TelemetrySample` hardcoded
+`cpu_power_w = 0.0`, which zeroed CPU power in every eval trace on every
+platform.
+
+**`apple_fm` shim reported zero token counts.** It hardcoded zeros with a note
+that the SDK did not expose counts; SDK 0.2.1 added `token_count`. Zeroed
+`completion_tokens` zeroes throughput, `energy_per_output_token_joules` and
+`tokens_per_joule` for everything served through the shim. Streaming responses
+now also carry `usage` on the final chunk. The install hint no longer tells
+users to clone from GitHub -- `apple-fm-sdk` is on PyPI. System messages become
+the session's `instructions` rather than being prefixed onto the prompt as
+`[System] ...`, which discarded a distinction the SDK draws and inflated the
+prompt-token count.
+
+**`scripts/setup-energy-monitor.sh` did not exist**, though
+`jarvis bench --setup-energy` built a path to it and offered to run it -- so
+the offer silently did nothing.
+
 ### Security
 
 **WebSocket API keys no longer appear in request URLs.** Browser clients now

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: OpenJarvis
-Version: 1.0.4.dev1058
+Version: 1.0.4.dev1061
 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/
@@ -31,6 +31,8 @@ Requires-Dist: rich>=13
 Requires-Dist: tomli>=2.0; python_version < '3.11'
 Requires-Dist: tomlkit>=0.12
 Requires-Dist: websockets>=15.0.1
+Provides-Extra: afm
+Requires-Dist: apple-fm-sdk>=0.2.1; (sys_platform == 'darwin') and extra == 'afm'
 Provides-Extra: browser
 Requires-Dist: playwright>=1.40; extra == 'browser'
 Provides-Extra: channel-discord
@@ -96,11 +98,11 @@ Requires-Dist: mkdocstrings[python]>=0.25; extra == 'docs'
 Provides-Extra: energy-all
 Requires-Dist: amdsmi>=6.1; extra == 'energy-all'
 Requires-Dist: pynvml>=12.0; extra == 'energy-all'
-Requires-Dist: zeus-ml[apple]; extra == 'energy-all'
+Requires-Dist: zeus-apple-silicon>=1.1.0; (sys_platform == 'darwin') and extra == 'energy-all'
 Provides-Extra: energy-amd
 Requires-Dist: amdsmi>=6.1; extra == 'energy-amd'
 Provides-Extra: energy-apple
-Requires-Dist: zeus-ml[apple]; extra == 'energy-apple'
+Requires-Dist: zeus-apple-silicon>=1.1.0; (sys_platform == 'darwin') and extra == 'energy-apple'
 Provides-Extra: eval-sheets
 Requires-Dist: google-auth>=2.0; extra == 'eval-sheets'
 Requires-Dist: gspread>=6.0; extra == 'eval-sheets'

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/configs/openjarvis/config.toml

@@ -65,7 +65,15 @@ host = "http://localhost:18181"
 host = "http://localhost:8080"
 
 [engine.apple_fm]
-host = "http://localhost:8079"
+host = "http://localhost:8079"                # OpenAI-compatible shim
+
+# In-process Apple Foundation Models (macOS 26+, Apple Intelligence enabled).
+# Install with: uv pip install -e '.[afm]'
+[engine.afm]
+# instructions = ""                           # applied to every session
+# use_case = "general"                        # or "content_tagging"
+# guardrails = "default"                      # or "permissive_content_transformations"
+sampling = "greedy"                           # or "random" (the SDK default)
 
 # ═══════════════════════════════════════════════════════════════
 # PILLAR 5: Learning — Improvement Methodologies

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/deploy/windows/install.ps1

@@ -73,7 +73,10 @@ function Write-Ok    ($msg) { Write-Host "[ok]    $msg" -ForegroundColor Green }
 function Write-Warn2 ($msg) { Write-Host "[warn]  $msg" -ForegroundColor Yellow }
 function Write-Fail  ($msg) {
     Write-Host "[fail]  $msg" -ForegroundColor Red
-    exit 1
+    # A terminating error aborts this installer while returning control to an
+    # existing interactive PowerShell. `exit` would close the entire host when
+    # the documented `irm ... | iex` command is run in a terminal (#868).
+    throw [System.InvalidOperationException]::new([string] $msg)
 }
 
 # ---------------------------------------------------------------------------

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/docs/architecture/engine.md

@@ -118,7 +118,8 @@ All providers produce the same output format consumed by agents:
 | **Nexa** | `nexa` | OpenAI-compatible | 18181 | No (CPU/GPU) | On-device inference with GGUF models |
 | **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 |
+| **Apple FM (shim)** | `apple_fm` | OpenAI-compatible | 8079 | Apple Silicon | Apple Foundation Models over HTTP, for external OpenAI clients |
+| **Apple FM (in-process)** | `afm` | Python SDK (in-process) | — | Apple Silicon | Apple Foundation Models with no HTTP hop — the preferred path |
 | **LiteLLM** | `litellm` | OpenAI-compatible | — | No | Unified proxy to 100+ LLM providers |
 | **Cloud** | `cloud` | Provider SDKs | — | No | OpenAI, Anthropic, Google API access |
 
@@ -218,17 +219,42 @@ The Uzu backend connects to the Uzu inference runtime. Unlike other OpenAI-compa
 - **Health check:** `GET /models`
 - **Best for:** Uzu-optimized inference workloads
 
-### Apple FM
+### Apple Foundation Models (AFM 3)
 
-The Apple FM backend connects to Apple's Foundation Model SDK via a FastAPI shim (`apple_fm_shim.py`). It wraps `python-apple-fm-sdk` as an OpenAI-compatible API. Requires macOS 15+ with Apple Silicon.
+Two backends serve the same on-device model. Both require an Apple Silicon Mac on **macOS 26+** with Apple Intelligence enabled.
 
-!!! note "Token counts"
-    The Apple FM SDK does not expose token counts. The shim returns 0 for all token counts. Benchmark throughput and energy-per-token metrics will reflect this limitation.
+**`afm` — in-process (preferred).** Drives `apple_fm_sdk` directly, with no HTTP hop and no second process. Prefer it for anything energy-measured: a separate uvicorn process burns CPU inside the same measurement window.
 
-- **Default host:** `http://localhost:8079`
-- **Health check:** `GET /v1/models`
-- **Install:** `pip install python-apple-fm-sdk`
-- **Best for:** Running Apple Foundation Models natively on Apple Silicon hardware
+**`apple_fm` — OpenAI-compatible shim.** A FastAPI server (`apple_fm_shim.py`) on port 8079, for pointing external OpenAI clients at AFM.
+
+**Install.** The SDK compiles Swift bindings at install time, so a full Xcode is required — Command Line Tools alone fail:
+
+```bash
+DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer \
+    uv sync --extra afm
+```
+
+`>=0.2.1` is the floor: that release added `SystemLanguageModel.token_count` and `.context_size`, which both backends use for token accounting.
+
+```bash
+jarvis ask --engine afm --model afm-3-core "..."   # in-process
+jarvis host afm-3 --backend apple_fm               # launch the shim
+```
+
+- **Model labels:** `afm-3`, `afm-3-core`, `afm-3-core-advanced`
+- **Context length:** 4096 tokens
+- **Configuration:** `[engine.afm]` — `instructions`, `use_case`, `guardrails`, `sampling`
+
+!!! warning "The model label does not select the model"
+    The SDK exposes no variant selector. The Foundation Models framework's dynamic profile picks AFM 3 Core (dense ~3B) or AFM 3 Core Advanced (20B sparse MoE, 1–4B active per request) based on the host device. The label only tags the run. `AppleFMEngine.describe()` records the SDK version, context size and host chip so a run can be attributed after the fact.
+
+!!! warning "Latency figures are not comparable to other backends"
+    `stream_response` yields cumulative text snapshots batching roughly 8–10 tokens each, not individual tokens. `ttft` is therefore time-to-first-*chunk* — around 450 ms on an M1 Pro, versus a few tens of ms of real first-token latency — and derived inter-token latencies are inter-*chunk* latencies. Token counts, throughput and per-token energy are unaffected.
+
+!!! note "Energy"
+    AFM runs predominantly on the Neural Engine, so its energy is invisible on a GPU-only rail. Install `openjarvis[energy-apple]` to measure CPU/GPU/DRAM/ANE separately; records are then written with `energy_basis = "soc"` and an `ane_energy_joules` column. Without it, no Apple energy is recorded at all.
+
+There is no Private Cloud Compute path in the Python SDK — inference is always on-device, which is what makes the energy measurement meaningful.
 
 ### LiteLLM
 

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/pyproject.toml

@@ -98,10 +98,27 @@ desktop = [
     "soundfile>=0.12",
 ]
 openhands = ["openhands-sdk>=1.0; python_version >= '3.12'"]
+# Apple Foundation Models (on-device AFM 3). Needs an Apple Silicon Mac on
+# macOS 26+ with Apple Intelligence enabled. The SDK compiles Swift bindings
+# at install time, so a full Xcode is required -- Command Line Tools alone
+# fail:
+#   DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer \
+#       uv pip install -e '.[afm]'
+# 0.2.1 is the floor: it added SystemLanguageModel.context_size and
+# token_count, which the engine uses for token accounting.
+afm = ["apple-fm-sdk>=0.2.1; sys_platform == 'darwin'"]
 gpu-metrics = ["pynvml>=12.0"]
 energy-amd = ["amdsmi>=6.1"]
-energy-apple = ["zeus-ml[apple]"]
-energy-all = ["pynvml>=12.0", "amdsmi>=6.1", "zeus-ml[apple]"]
+# `zeus-ml[apple]` was the previous spelling and never worked: zeus-ml has no
+# `apple` extra, and its `zeus.device.soc` package (which wraps this library)
+# landed on master after the last zeus release, so no published zeus-ml
+# contains it. Depend on the underlying IOReport extension directly.
+energy-apple = ["zeus-apple-silicon>=1.1.0; sys_platform == 'darwin'"]
+energy-all = [
+    "pynvml>=12.0",
+    "amdsmi>=6.1",
+    "zeus-apple-silicon>=1.1.0; sys_platform == 'darwin'",
+]
 orchestrator-training = ["torch>=2.0", "transformers>=4.40"]
 learning-dspy = ["dspy>=2.6"]
 learning-gepa = ["gepa>=0.1"]

openjarvis-1.0.4.dev1061/scripts/setup-energy-monitor.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+# Install the energy-measurement backend for this machine.
+#
+# Referenced by `jarvis bench --setup-energy` (see cli/bench_cmd.py), which
+# built a path to this script and offered to run it while the file did not
+# exist -- the offer silently did nothing.
+#
+# Picks the right extra by platform:
+#   Apple Silicon -> energy-apple  (zeus-apple-silicon, IOReport, no root)
+#   Linux + NVIDIA -> gpu-metrics  (pynvml)
+#   Linux + AMD    -> energy-amd   (amdsmi)
+#   Linux, neither -> nothing to install; RAPL is read from sysfs
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+if ! command -v uv >/dev/null 2>&1; then
+    echo "error: uv is required. See https://docs.astral.sh/uv/" >&2
+    exit 1
+fi
+
+os="$(uname -s)"
+arch="$(uname -m)"
+
+case "$os" in
+Darwin)
+    if [ "$arch" != "arm64" ]; then
+        echo "Intel Macs expose no energy counters OpenJarvis can read." >&2
+        exit 1
+    fi
+    extra="energy-apple"
+    ;;
+Linux)
+    if command -v nvidia-smi >/dev/null 2>&1; then
+        extra="gpu-metrics"
+    elif command -v rocm-smi >/dev/null 2>&1; then
+        extra="energy-amd"
+    elif [ -d /sys/class/powercap/intel-rapl ]; then
+        echo "RAPL is readable from sysfs; no extra package needed."
+        echo "If readings come back empty, check permissions on"
+        echo "  /sys/class/powercap/intel-rapl/*/energy_uj"
+        exit 0
+    else
+        echo "No supported energy backend detected on this host." >&2
+        exit 1
+    fi
+    ;;
+*)
+    echo "Energy measurement is not supported on $os." >&2
+    exit 1
+    ;;
+esac
+
+echo "Installing openjarvis[$extra] ..."
+# --inexact: add this extra without pruning extras the user already has.
+# A plain `uv sync --extra` would uninstall e.g. [dev] and [server].
+uv sync --inexact --extra "$extra"
+
+echo
+echo "Verifying ..."
+uv run python - <<'PY'
+from openjarvis.telemetry.energy_monitor import create_energy_monitor
+
+monitor = create_energy_monitor()
+if monitor is None:
+    raise SystemExit(
+        "Energy monitor still unavailable. Run `jarvis doctor` for details."
+    )
+print(f"OK: {monitor.vendor().value} via {monitor.energy_method()}")
+monitor.close()
+PY

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/src/openjarvis/bench/_stubs.py

@@ -29,6 +29,46 @@ class BenchmarkResult:
     energy_method: str = ""
 
 
+def engine_info(engine: Any) -> Optional[Dict[str, Any]]:
+    """Run metadata from an engine that can describe itself, or ``None``.
+
+    Duck-typed the way IPW's runner writes ``client_info`` into
+    ``summary.json``: ``describe`` is not on the ``InferenceEngine`` ABC, so
+    engines opt in by defining it. The AFM engine uses this to record its SDK
+    version, context size and host chip, none of which is recoverable from the
+    benchmark results alone.
+
+    The return value is validated rather than trusted. It lands in a JSONL
+    file, so anything that is not a plain dict of JSON-safe scalars is
+    dropped or stringified -- an engine returning something exotic must not be
+    able to fail the whole benchmark write.
+    """
+    describe = getattr(engine, "describe", None)
+    if not callable(describe):
+        return None
+    try:
+        info = describe()
+    except Exception:
+        return None
+    if not isinstance(info, dict):
+        return None
+
+    safe: Dict[str, Any] = {}
+    for key, value in info.items():
+        if not isinstance(key, str):
+            continue
+        if value is None or isinstance(value, (bool, int, float, str)):
+            safe[key] = value
+        else:
+            try:
+                json.dumps(value)
+            except (TypeError, ValueError):
+                safe[key] = repr(value)
+            else:
+                safe[key] = value
+    return safe or None
+
+
 class BaseBenchmark(ABC):
     """Base class for all benchmark implementations.
 

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/src/openjarvis/bench/energy.py

@@ -7,7 +7,7 @@ import time
 from typing import Any, List, Optional
 
 from openjarvis.bench._stats import compute_stats
-from openjarvis.bench._stubs import BaseBenchmark, BenchmarkResult
+from openjarvis.bench._stubs import BaseBenchmark, BenchmarkResult, engine_info
 from openjarvis.core.registry import BenchmarkRegistry
 from openjarvis.core.types import Message, Role
 from openjarvis.engine._stubs import InferenceEngine
@@ -59,6 +59,15 @@ class EnergyBenchmark(BaseBenchmark):
         per_tokens: List[float] = []
         errors = 0
         energy_method = ""
+        # Per-rail totals, so an ANE-resident backend's energy is attributable
+        # rather than just folded into one number.
+        rail_totals: dict[str, float] = {
+            "cpu": 0.0,
+            "gpu": 0.0,
+            "dram": 0.0,
+            "ane": 0.0,
+        }
+        energy_basis = ""
 
         if energy_monitor is not None:
             from openjarvis.telemetry.steady_state import SteadyStateDetector
@@ -80,6 +89,12 @@ class EnergyBenchmark(BaseBenchmark):
                     tps = tokens / elapsed if elapsed > 0 else 0.0
                     ept = energy_j / tokens if tokens > 0 else 0.0
 
+                    rail_totals["cpu"] += sample.cpu_energy_joules
+                    rail_totals["gpu"] += sample.gpu_energy_joules
+                    rail_totals["dram"] += sample.dram_energy_joules
+                    rail_totals["ane"] += sample.ane_energy_joules
+                    energy_basis = sample.basis or energy_basis
+
                     per_energy_j.append(energy_j)
                     per_power_w.append(power_w)
                     per_tps.append(tps)
@@ -127,10 +142,17 @@ class EnergyBenchmark(BaseBenchmark):
         metrics["total_time_seconds"] = total_time
 
         metadata: dict[str, Any] = {}
-        if engine.engine_id == "apple_fm":
-            metadata["token_estimation"] = (
-                "~4 chars/token (Apple FM SDK does not expose counts)"
-            )
+        info = engine_info(engine)
+        if info:
+            metadata["engine_info"] = info
+        if energy_basis:
+            # Which rail set total_energy_joules and energy_per_token came
+            # from. Figures are only comparable across runs sharing a basis.
+            metadata["energy_basis"] = energy_basis
+        if any(v > 0 for v in rail_totals.values()):
+            metadata["energy_joules_by_rail"] = {
+                rail: round(v, 6) for rail, v in rail_totals.items() if v > 0
+            }
 
         return BenchmarkResult(
             benchmark_name=self.name,

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/src/openjarvis/bench/throughput.py

@@ -7,7 +7,7 @@ import time
 from typing import Any, List
 
 from openjarvis.bench._stats import compute_stats
-from openjarvis.bench._stubs import BaseBenchmark, BenchmarkResult
+from openjarvis.bench._stubs import BaseBenchmark, BenchmarkResult, engine_info
 from openjarvis.core.registry import BenchmarkRegistry
 from openjarvis.core.types import Message, Role
 from openjarvis.engine._stubs import InferenceEngine
@@ -76,10 +76,9 @@ class ThroughputBenchmark(BaseBenchmark):
         metrics["total_time_seconds"] = total_time
 
         metadata: dict[str, Any] = {}
-        if engine.engine_id == "apple_fm":
-            metadata["token_estimation"] = (
-                "~4 chars/token (Apple FM SDK does not expose counts)"
-            )
+        info = engine_info(engine)
+        if info:
+            metadata["engine_info"] = info
 
         return BenchmarkResult(
             benchmark_name=self.name,

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/src/openjarvis/cli/ask.py

@@ -34,6 +34,24 @@ from openjarvis.telemetry.store import TelemetryStore
 
 logger = logging.getLogger(__name__)
 
+# Engines that run inference on this machine. Used by the image privacy guard
+# below: a screenshot is sensitive and OpenJarvis is local-first, so sending
+# one to a non-local engine warrants a warning first. Module-level so it can be
+# asserted against directly -- an engine missing from here produces a false
+# "your image is leaving this machine" warning.
+LOCAL_ENGINES = {
+    "afm",
+    "apple_fm",
+    "exo",
+    "gemma_cpp",
+    "llamacpp",
+    "nexa",
+    "ollama",
+    "sglang",
+    "uzu",
+    "vllm",
+}
+
 
 def _run_research(
     *,
@@ -833,6 +851,7 @@ def ask(
 
             energy_monitor = create_energy_monitor(
                 prefer_vendor=config.telemetry.energy_vendor or None,
+                allow_estimates=config.telemetry.allow_energy_estimates,
             )
         except Exception as exc:
             logger.debug("Failed to create energy monitor: %s", exc)
@@ -943,21 +962,7 @@ def ask(
         return
 
     # Direct-to-engine mode (no agent)
-    # Privacy guard: a screenshot/image is sensitive, and OpenJarvis is
-    # local-first. If the active engine isn't local, warn before the image
-    # leaves the machine rather than silently uploading it to a third party.
-    _LOCAL_ENGINES = {
-        "ollama",
-        "llamacpp",
-        "vllm",
-        "sglang",
-        "exo",
-        "nexa",
-        "uzu",
-        "apple_fm",
-        "gemma_cpp",
-    }
-    if image_b64 and engine_name not in _LOCAL_ENGINES:
+    if image_b64 and engine_name not in LOCAL_ENGINES:
         console.print(
             f"[yellow]Privacy warning:[/yellow] sending {len(image_b64)} "
             f"image(s) to a non-local engine ('{engine_name}'). The image will "

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/src/openjarvis/cli/bench_cmd.py

@@ -260,6 +260,7 @@ def run(
 
             energy_monitor = create_energy_monitor(
                 prefer_vendor=config.telemetry.energy_vendor or None,
+                allow_estimates=config.telemetry.allow_energy_estimates,
             )
         except Exception as exc:
             logger.debug("Energy monitor init skipped: %s", exc)
@@ -298,6 +299,7 @@ def run(
 
                 energy_monitor = create_energy_monitor(
                     prefer_vendor=config.telemetry.energy_vendor or None,
+                    allow_estimates=config.telemetry.allow_energy_estimates,
                 )
                 if energy_monitor is not None:
                     console.print("[green]Energy monitor installed.[/green]")

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/src/openjarvis/cli/doctor_cmd.py

@@ -206,7 +206,12 @@ def _check_optional_deps() -> List[CheckResult]:
         ("pynvml", "openjarvis[gpu-metrics]", "NVIDIA energy monitoring"),
         ("amdsmi", "openjarvis[energy-amd]", "AMD energy monitoring"),
         ("colbert", "openjarvis[memory-colbert]", "ColBERT memory backend"),
-        ("zeus", "openjarvis[energy-apple]", "Apple Silicon energy monitoring"),
+        (
+            "zeus_apple_silicon",
+            "openjarvis[energy-apple]",
+            "Apple Silicon energy monitoring",
+        ),
+        ("apple_fm_sdk", "openjarvis[afm]", "Apple Foundation Models (AFM 3)"),
     ]
     for pkg, install_hint, description in optional_packages:
         try:

{openjarvis-1.0.4.dev1058 → openjarvis-1.0.4.dev1061}/src/openjarvis/cli/host_cmd.py

@@ -72,6 +72,15 @@ _BACKENDS = {
         "default_port": 52415,
         "binary": "exo",
     },
+    "apple_fm": {
+        "display": "Apple Foundation Models (shim)",
+        "package": "apple-fm-sdk",
+        "import_check": "apple_fm_sdk",
+        "pip_spec": "apple-fm-sdk>=0.2.1",
+        "uv_extra": "afm",
+        "platform": "darwin",
+        "default_port": 8079,
+    },
     "uzu": {
         "display": "Uzu",
         "package": "uzu",
@@ -280,6 +289,22 @@ def _build_serve_command(backend: str, model: str, port: int) -> list[str]:
     if backend == "uzu":
         return ["uzu", "serve", "--port", str(port)]
 
+    if backend == "apple_fm":
+        # There is one on-device model, so `model` is a label and is not
+        # passed through -- the shim serves whatever the Foundation Models
+        # dynamic profile selects. For in-process use prefer the `afm`
+        # engine, which needs no server at all.
+        return [
+            sys.executable,
+            "-m",
+            "uvicorn",
+            "openjarvis.engine.apple_fm_shim:app",
+            "--host",
+            "127.0.0.1",
+            "--port",
+            str(port),
+        ]
+
     raise ValueError(f"Unknown backend: {backend}")