refactor: partition by type (mlx|gguf), drop owner hostname field

Routing by 'owner: <hostname>' coupled the fleet to specific machine
names and broke whenever a machine was renamed or replaced. Routing by
'type: <backend>' instead describes the actual constraint: what
inference path the target needs. Workers detect their own capabilities
at runtime (import mlx_lm + platform check → mlx; explicit opt-in for
gguf until that wrapper lands) or take an explicit LEM_TYPES env
override. Partition falls out of what the hardware can do.

Changes:

targets.yaml
lemer, lemma type: mlx (Apple Silicon workers)
lemmy, lemrd type: gguf (GGUF workers — via Ollama endpoint on charon)

eval.py
- SUPPORTED_TYPES = {'mlx', 'gguf'}
- detect_default_types() probes mlx_lm import + Darwin platform
- --type flag overrides capability detection
- LEM_TYPES env var takes precedence over both
- --my-targets filters by allowed_types (was: by hostname owner)
- gguf targets fail fast with explicit TODO: wrapper not yet implemented

lem-eval.sh
- once() target-list resolution uses type filter via inline python
- log line shows LEM_TYPES for visibility

install.sh
- pre-clone loop filters by type, same logic as eval.py/lem-eval.sh

README.md
- describes capability-based partitioning
- notes gguf wrapper status (not yet implemented, will be
OpenAI-SDK against local Ollama/llama.cpp)

Follow-up needed before gguf targets run: wire gguf_wrapper.py as an
OpenAI-SDK client pointing at a local llama-cpp-server or Ollama
endpoint. The charon cron that's been running since the old pipeline
already has the environment + credentials + Ollama stack, so that
wrapper should drop in cleanly.

Co-Authored-By: Virgil <virgil@lethean.io>

README.md

@@ -14,8 +14,10 @@ The 8-PAC benchmark runner for the Lemma model family.
 A HuggingFace dataset repo used as a tool-shaped "github" — the entire
 scorer lives here, anyone clones it, installs once, and the worker
 machines chug along advancing per-model canons in lockstep. Multiple
-workers farm different targets in parallel (each worker owns its
-targets via the `owner` field in `targets.yaml`).
+workers farm different targets in parallel — each target declares a
+`type` (`mlx` or `gguf`) in `targets.yaml`, and workers filter by the
+backends they can actually run (capability probe or `LEM_TYPES` env).
+Partition falls out of what the hardware can do, not hostnames.
 
 ## What it does
 
@@ -48,7 +50,7 @@ different machines contribute additive rows to the aggregator.
 LEM-Eval/
 ├── eval.py               # target-driven runner (PEP 723 — uv run it)
 ├── mlx_lm_wrapper.py     # lighteval custom model backend
-├── targets.yaml          # declarative fleet spec (base, this, owner)
+├── targets.yaml          # declarative fleet spec (base, this, type)
 ├── install.sh            # bootstrap: clone model repos + lem-benchmarks
 ├── lem-eval.sh           # service script (once | maintain | loop)
 ├── cron/
@@ -73,9 +75,16 @@ cd LEM-Eval
 crontab -l | cat - cron/submit.cron cron/maintain.cron | crontab -
 ```
 
-Add a new machine: edit `targets.yaml` to set `owner: <hostname>` on the
-targets that machine should run, commit, push. Workers on that machine
-pick up the change via the `maintain` cron's hourly `git pull`.
+Add a new machine: install LEM-Eval on it, the worker's backend probe
+decides which targets it can run (mlx on Apple Silicon, gguf where an
+Ollama endpoint is reachable). Override with `LEM_TYPES=mlx,gguf` in
+the cron env if you want explicit control. Workers pick up `targets.yaml`
+edits via the `maintain` cron's hourly `git pull`.
+
+**gguf wrapper status:** not yet implemented. gguf targets (`lemmy`,
+`lemrd`) sit in `targets.yaml` waiting for `gguf_wrapper.py` — will be
+an OpenAI-SDK wrapper pointing at a local Ollama/llama.cpp server.
+Until then, gguf targets list but don't run.
 
 ## Quick start (manual / dev)
 

eval.py

@@ -774,25 +774,50 @@ def _run_once(
     return summary
 
 
-def _print_target_table(targets, my_host=None):
-    print(f"{'name':<18} {'owner':<12} {'base':<42} {'this':<24}")
-    print("-" * 100)
+SUPPORTED_TYPES = {"mlx", "gguf"}
+
+
+def detect_default_types():
+    """Figure out which target types this machine can run by capability probe.
+
+    Apple Silicon + mlx_lm installed → mlx. Anything else (or explicit opt-in)
+    → gguf via an OpenAI-compatible endpoint (Ollama / llama.cpp server).
+    Returns a set. Workers override with --type or the LEM_TYPES env var.
+    """
+    import platform
+    types = set()
+    try:
+        import mlx_lm  # noqa: F401
+        if platform.system() == "Darwin":
+            types.add("mlx")
+    except ImportError:
+        pass
+    # gguf path will be available once gguf_wrapper lands — for now it's
+    # opt-in via explicit --type gguf so workers don't silently skip
+    # mlx-only targets when the wrapper is absent.
+    return types or {"mlx"}
+
+
+def _print_target_table(targets, highlight_types=None):
+    highlight_types = set(highlight_types or [])
+    print(f"{'name':<18} {'type':<6} {'base':<42} {'this':<24}")
+    print("-" * 94)
     for t in targets:
-        mark = " *" if (my_host and t.get("owner") == my_host) else ""
-        print(f"{t['name']:<18} {t.get('owner', '?'):<12} {t['base']:<42} {t['this']:<24}{mark}")
+        mark = " *" if (t.get("type") in highlight_types) else ""
+        print(f"{t['name']:<18} {t.get('type', '?'):<6} {t['base']:<42} {t['this']:<24}{mark}")
 
 
 def main():
-    import socket
-    host = socket.gethostname()
-
     parser = argparse.ArgumentParser(
         description="LEM-Eval 8-PAC benchmark runner — target-driven, multi-writer",
     )
     parser.add_argument("--target", help="Target name from targets.yaml")
     parser.add_argument("--list-targets", action="store_true", help="List all targets and exit")
     parser.add_argument("--my-targets", action="store_true",
-                        help="List targets owned by this hostname and exit")
+                        help="List targets whose type matches this machine's capabilities and exit")
+    parser.add_argument("--type", default=None,
+                        help="Restrict to targets of this type (mlx|gguf). "
+                             "Defaults to capability detection (mlx on Apple Silicon).")
     parser.add_argument("--n-questions", type=int, default=DEFAULT_N_QUESTIONS)
     parser.add_argument("--rounds", type=int, default=DEFAULT_ROUNDS)
     parser.add_argument("--task", default=None,
@@ -817,21 +842,40 @@ def main():
     cfg = load_targets()
     all_targets = cfg.get("targets", [])
 
+    # Resolve the set of types this invocation accepts.
+    if args.type:
+        if args.type not in SUPPORTED_TYPES:
+            parser.error(f"--type must be one of {sorted(SUPPORTED_TYPES)}, got {args.type!r}")
+        allowed_types = {args.type}
+    elif os.environ.get("LEM_TYPES"):
+        allowed_types = set(os.environ["LEM_TYPES"].split(","))
+    else:
+        allowed_types = detect_default_types()
+
     if args.list_targets:
-        _print_target_table(all_targets, my_host=host)
+        _print_target_table(all_targets, highlight_types=allowed_types)
         return 0
     if args.my_targets:
-        mine = [t for t in all_targets if t.get("owner") == host]
+        mine = [t for t in all_targets if t.get("type") in allowed_types]
         if not mine:
-            print(f"No targets owned by '{host}' in targets.yaml")
+            print(f"No targets match this machine's types: {sorted(allowed_types)}")
             return 0
-        _print_target_table(mine)
+        _print_target_table(mine, highlight_types=allowed_types)
         return 0
 
     if not args.target:
         parser.error("--target is required (or use --list-targets / --my-targets)")
 
     target = resolve_target(args.target, cfg)
+    target_type = target.get("type")
+    if target_type not in SUPPORTED_TYPES:
+        parser.error(f"target {args.target!r} has unknown type {target_type!r}")
+    if target_type == "gguf":
+        parser.error(
+            f"target {args.target!r} is type=gguf, but the gguf wrapper is not yet "
+            f"implemented. TODO: wire an OpenAI-SDK-against-Ollama wrapper at "
+            f"gguf_wrapper.py. For now, gguf targets sit in targets.yaml waiting."
+        )
 
     # Populate module globals so the lighteval custom-model loader picks
     # up the right identity when it instantiates MLXLMModel.

install.sh

@@ -51,27 +51,42 @@ fi
 
 # --- clone each owned target's model repo ---------------------------------
 
-log "resolving targets owned by $(hostname)..."
+log "resolving targets this machine can run..."
 uv run --script eval.py --my-targets || true
 
-# Pre-clone each owned target's model repo into workspaces/<target>
-python3 - <<PY
-import os, subprocess, yaml, socket, sys
-host = socket.gethostname()
-with open('targets.yaml') as f:
+# Pre-clone each runnable target's model repo into workspaces/<target>.
+# Type filter mirrors eval.py / lem-eval.sh — respect $LEM_TYPES if set,
+# otherwise capability probe (mlx on Apple Silicon).
+LEM_TYPES="${LEM_TYPES:-}" python3 - <<'PY'
+import os, platform, subprocess, yaml
+
+types_env = os.environ.get("LEM_TYPES", "").strip()
+if types_env:
+    allowed = set(t.strip() for t in types_env.split(","))
+else:
+    allowed = set()
+    try:
+        import mlx_lm  # noqa: F401
+        if platform.system() == "Darwin":
+            allowed.add("mlx")
+    except ImportError:
+        pass
+    if not allowed:
+        allowed = {"mlx"}
+
+with open("targets.yaml") as f:
     cfg = yaml.safe_load(f)
-for t in cfg.get('targets', []):
-    if t.get('owner') != host:
+for t in cfg.get("targets", []):
+    if t.get("type") not in allowed:
         continue
-    name = t['name']
-    repo = t['this']
-    dest = os.path.join('workspaces', name)
-    if os.path.isdir(os.path.join(dest, '.git')):
+    name, repo = t["name"], t["this"]
+    dest = os.path.join("workspaces", name)
+    if os.path.isdir(os.path.join(dest, ".git")):
         print(f"  [{name}] already cloned, pulling")
-        subprocess.run(['git', '-C', dest, 'pull', '--ff-only'], check=False)
+        subprocess.run(["git", "-C", dest, "pull", "--ff-only"], check=False)
     else:
         print(f"  [{name}] cloning https://huggingface.co/{repo} → {dest}")
-        subprocess.run(['git', 'clone', f'https://huggingface.co/{repo}', dest], check=True)
+        subprocess.run(["git", "clone", f"https://huggingface.co/{repo}", dest], check=True)
 PY
 
 # --- warm the uv cache so first eval.py run is fast -----------------------

lem-eval.sh

@@ -81,31 +81,48 @@ run_target() {
     fi
 }
 
-# --- one pass over all targets owned by this host ------------------------
+# --- one pass over all targets this worker can run -----------------------
+#
+# The set of runnable types comes from $LEM_TYPES (comma-separated) or
+# capability detection (mlx on Apple Silicon, otherwise explicit opt-in).
 
 once() {
-    log "host=$HOST mode=once"
+    log "host=$HOST types=${LEM_TYPES:-auto} mode=once"
 
     if [[ ! -d "$LEM_BENCHMARKS_DIR/.git" ]]; then
         log "lem-benchmarks not cloned — run ./install.sh first"
         exit 1
     fi
 
-    # Get list of targets owned by this host via python (avoids yaml-in-shell)
+    # Get list of targets this worker can run, via python (avoids yaml-in-shell)
     local targets
-    targets=$(python3 - <<PY
-import yaml, socket
-host = socket.gethostname()
-with open('targets.yaml') as f:
+    targets=$(LEM_TYPES="${LEM_TYPES:-}" python3 - <<'PY'
+import os, platform, yaml
+
+types_env = os.environ.get("LEM_TYPES", "").strip()
+if types_env:
+    allowed = set(t.strip() for t in types_env.split(","))
+else:
+    allowed = set()
+    try:
+        import mlx_lm  # noqa: F401
+        if platform.system() == "Darwin":
+            allowed.add("mlx")
+    except ImportError:
+        pass
+    if not allowed:
+        allowed = {"mlx"}
+
+with open("targets.yaml") as f:
     cfg = yaml.safe_load(f)
-for t in cfg.get('targets', []):
-    if t.get('owner') == host:
-        print(t['name'])
+for t in cfg.get("targets", []):
+    if t.get("type") in allowed:
+        print(t["name"])
 PY
     )
 
     if [[ -z "$targets" ]]; then
-        log "no targets owned by $HOST in targets.yaml"
+        log "no targets match this worker's types (set LEM_TYPES to override)"
         exit 0
     fi
 

targets.yaml

@@ -1,13 +1,14 @@
 # targets.yaml — declarative fleet spec for LEM-Eval workers.
 #
 # Each target is a (base, this) model pair that gets benchmarked together in
-# a paired A/B run. The `owner` field is the hostname of the worker that
-# should run this target — workers filter by `hostname(3)` so adding or
-# retiring a machine is just editing this file and `git pull`.
+# a paired A/B run. The `type` field says which inference backend the target
+# needs — 'mlx' runs on Apple Silicon via mlx_lm, 'gguf' runs on any machine
+# that can serve GGUF (via Ollama or llama.cpp). Workers filter by type so
+# partitioning across machines falls out of capability, not hostnames.
 #
 # Each target is an independent canon. Workers writing to different targets
 # don't race because each target's .eval_results/ lives in a different model
-# repo (and its results/<model>/ path in LEM-benchmarks is also disjoint).
+# repo (and its results/<target>/ path in LEM-benchmarks is also disjoint).
 #
 # Editing this file is the way to change the fleet. After an edit, commit
 # and push — workers pick up the new config on their next `git pull` cycle
@@ -23,25 +24,25 @@ defaults:
 targets:
 
   - name: lemer
-    owner: studio
+    type: mlx
     base: mlx-community/gemma-4-e2b-it-4bit
     this: lthn/lemer
     notes: Gemma 4 E2B
 
   - name: lemma
-    owner: studio
+    type: mlx
     base: mlx-community/gemma-4-e4b-it-4bit
     this: lthn/lemma
     notes: Gemma 4 E4B
 
   - name: lemmy
-    owner: charon
+    type: gguf
     base: mlx-community/gemma-4-26b-a4b-it-4bit
     this: lthn/lemmy
-    notes: Gemma 4 26B A4B MoE
+    notes: Gemma 4 26B A4B MoE — runs via GGUF on charon (Ollama endpoint)
 
   - name: lemrd
-    owner: charon
+    type: gguf
     base: mlx-community/gemma-4-31b-it-4bit
     this: lthn/lemrd
-    notes: Gemma 4 31B
+    notes: Gemma 4 31B — runs via GGUF on charon (Ollama endpoint)