fix(workers): capability probe + (name,type,quant) triple iteration

Two bugs install.sh and lem-eval.sh both had:

1. Stale capability probe fallback — when mlx_lm import failed (linux),
the code fell back to {'mlx'} as the allowed type set. Charon then
tried to clone/run the mlx targets anyway, picking up lthn/lemer-mlx
into workspaces/lemer instead of the intended lthn/lemer gguf repo.
Now probes gguf independently via 'openai' import and errors out
with no fallback if neither backend is detected.

2. Runner keyed off target NAME only. With the composite (name, type,
quant) key we introduced earlier, multiple entries share 'lemer'
— the old code would race them into the same workspace dir and
eval.py would refuse to pick one (multiple matches). Python block
now emits pipe-separated 'name|type|quant|repo' tuples; run_target
takes all four and passes --type and --quant explicitly to eval.py.

install.sh pre-clone loop now:
- dedupes by repo id (multiple gguf quants share lthn/lemer — one clone)
- uses derive_repo_id() to strip the Ollama 'hf.co/<repo>:<tag>' form
into a bare clone-able repo id
- clones into workspaces/<repo-path> (e.g. workspaces/lthn/lemer,
workspaces/lthn/lemer-mlx) so siblings don't collide

lem-eval.sh run_target now:
- takes (name, type, quant, repo) explicitly
- workspace dir matches repo id, not target name
- commits carry 'name/type/quant' in the message for traceability
- passes --type and --quant to eval.py so resolve_target disambiguates

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

install.sh

@@ -54,9 +54,11 @@ fi
 log "resolving targets this machine can run..."
 uv run --script eval.py --my-targets || true
 
-# 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).
+# Pre-clone each runnable target's backing model repo into
+# workspaces/<repo-id>. Capability probe matches eval.py: mlx on
+# Apple Silicon with mlx_lm importable, gguf wherever openai is
+# importable. Multiple targets sharing the same backing repo (e.g.
+# the three gguf quants that all live in lthn/lemer) share one clone.
 LEM_TYPES="${LEM_TYPES:-}" python3 - <<'PY'
 import os, platform, subprocess, yaml
 
@@ -71,21 +73,44 @@ else:
             allowed.add("mlx")
     except ImportError:
         pass
+    try:
+        import openai  # noqa: F401
+        allowed.add("gguf")
+    except ImportError:
+        pass
     if not allowed:
-        allowed = {"mlx"}
+        print("  no target types detected (need mlx_lm or openai); set LEM_TYPES=gguf to override")
+
+def derive_repo_id(this_ref):
+    """Strip Ollama hf.co/ prefix and :<tag> suffix to get a clone-able repo id."""
+    if this_ref.startswith("hf.co/"):
+        base = this_ref[len("hf.co/"):]
+        if ":" in base:
+            base = base.split(":", 1)[0]
+        return base
+    return this_ref
 
 with open("targets.yaml") as f:
     cfg = yaml.safe_load(f)
+
+# Dedupe by repo id so multi-quant families clone once.
+seen_repos = set()
 for t in cfg.get("targets", []):
     if t.get("type") not in allowed:
         continue
-    name, repo = t["name"], t["this"]
-    dest = os.path.join("workspaces", name)
+    repo = derive_repo_id(t["this"])
+    if repo in seen_repos:
+        continue
+    seen_repos.add(repo)
+    # workspace dir matches the repo path so 'lthn/lemer' and
+    # 'lthn/lemer-mlx' end up in distinct folders.
+    dest = os.path.join("workspaces", repo)
+    os.makedirs(os.path.dirname(dest), exist_ok=True)
     if os.path.isdir(os.path.join(dest, ".git")):
-        print(f"  [{name}] already cloned, pulling")
+        print(f"  [{repo}] already cloned, pulling")
         subprocess.run(["git", "-C", dest, "pull", "--ff-only"], check=False)
     else:
-        print(f"  [{name}] cloning https://huggingface.co/{repo} → {dest}")
+        print(f"  [{repo}] cloning https://huggingface.co/{repo} → {dest}")
         subprocess.run(["git", "clone", f"https://huggingface.co/{repo}", dest], check=True)
 PY
 

lem-eval.sh

@@ -37,54 +37,59 @@ maintain() {
     fi
 }
 
-# --- run one slice for a single target ------------------------------------
+# --- run one slice for a single (name, type, quant) triple --------------
 
 run_target() {
-    local target="$1"
-    local workspace="$WORKSPACES/$target"
+    local name="$1" ttype="$2" quant="$3" repo="$4"
+    local workspace="$WORKSPACES/$repo"
+    local label="$name/$ttype/$quant"
 
     if [[ ! -d "$workspace/.git" ]]; then
-        log "[$target] workspace not cloned, skipping (run install.sh first)"
+        log "[$label] workspace $repo not cloned, skipping (run install.sh first)"
         return 0
     fi
 
-    log "[$target] git pull (model repo)"
+    log "[$label] git pull $repo"
     (cd "$workspace" && git pull --ff-only) || {
-        log "[$target] pull failed, skipping"
+        log "[$label] pull failed, skipping"
         return 0
     }
 
-    log "[$target] running eval.py..."
+    log "[$label] running eval.py..."
     uv run --script eval.py \
-        --target "$target" \
+        --target "$name" \
+        --type "$ttype" \
+        --quant "$quant" \
         --eval-results-dir "$workspace/.eval_results" \
         --lem-benchmarks-dir "$LEM_BENCHMARKS_DIR" \
         --n-questions 1 \
         --rounds 8
 
-    # Commit + push to target model repo
+    # Commit + push to target model repo (canon advance for this quant)
     if (cd "$workspace" && git status --short | grep -q .); then
-        log "[$target] committing canon update to model repo"
+        log "[$label] committing canon update to $repo"
         (cd "$workspace" \
             && git add .eval_results/ \
-            && git commit -m "eval: advance canon ($(date -u +%Y-%m-%dT%H:%M:%SZ))" \
-            && git push) || log "[$target] model repo push failed (non-fatal)"
+            && git commit -m "eval: ${name}/${ttype}/${quant} advance ($(date -u +%Y-%m-%dT%H:%M:%SZ))" \
+            && git push) || log "[$label] model repo push failed (non-fatal)"
     fi
 
     # Commit + push to lem-benchmarks for the aggregator row
     if (cd "$LEM_BENCHMARKS_DIR" && git status --short | grep -q .); then
-        log "[$target] committing canon update to lem-benchmarks"
+        log "[$label] committing canon update to lem-benchmarks"
         (cd "$LEM_BENCHMARKS_DIR" \
-            && git add "results/$target/" \
-            && git commit -m "eval: $target canon advance ($(date -u +%Y-%m-%dT%H:%M:%SZ))" \
-            && git push) || log "[$target] lem-benchmarks push failed (non-fatal)"
+            && git add "results/$name/" \
+            && git commit -m "eval: ${name}/${ttype}/${quant} advance ($(date -u +%Y-%m-%dT%H:%M:%SZ))" \
+            && git push) || log "[$label] lem-benchmarks push failed (non-fatal)"
     fi
 }
 
 # --- 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).
+# Iterates every (name, type, quant) triple whose type matches this
+# worker's capability set — $LEM_TYPES env var overrides, otherwise
+# capability probe (mlx on Apple Silicon with mlx_lm importable, gguf
+# everywhere the openai client is importable).
 
 once() {
     log "host=$HOST types=${LEM_TYPES:-auto} mode=once"
@@ -94,9 +99,9 @@ once() {
         exit 1
     fi
 
-    # Get list of targets this worker can run, via python (avoids yaml-in-shell)
-    local targets
-    targets=$(LEM_TYPES="${LEM_TYPES:-}" python3 - <<'PY'
+    # Emit one pipe-separated line per runnable target: name|type|quant|repo
+    local triples
+    triples=$(LEM_TYPES="${LEM_TYPES:-}" python3 - <<'PY'
 import os, platform, yaml
 
 types_env = os.environ.get("LEM_TYPES", "").strip()
@@ -110,26 +115,42 @@ else:
             allowed.add("mlx")
     except ImportError:
         pass
-    if not allowed:
-        allowed = {"mlx"}
+    try:
+        import openai  # noqa: F401
+        allowed.add("gguf")
+    except ImportError:
+        pass
+
+def derive_repo_id(this_ref):
+    if this_ref.startswith("hf.co/"):
+        base = this_ref[len("hf.co/"):]
+        if ":" in base:
+            base = base.split(":", 1)[0]
+        return base
+    return this_ref
 
 with open("targets.yaml") as f:
     cfg = yaml.safe_load(f)
 for t in cfg.get("targets", []):
-    if t.get("type") in allowed:
-        print(t["name"])
+    if t.get("type") not in allowed:
+        continue
+    name = t["name"]
+    ttype = t["type"]
+    quant = t.get("quant", "")
+    repo = derive_repo_id(t["this"])
+    print(f"{name}|{ttype}|{quant}|{repo}")
 PY
     )
 
-    if [[ -z "$targets" ]]; then
+    if [[ -z "$triples" ]]; then
         log "no targets match this worker's types (set LEM_TYPES to override)"
         exit 0
     fi
 
-    while IFS= read -r target; do
-        [[ -z "$target" ]] && continue
-        run_target "$target"
-    done <<< "$targets"
+    while IFS='|' read -r name ttype quant repo; do
+        [[ -z "$name" ]] && continue
+        run_target "$name" "$ttype" "$quant" "$repo"
+    done <<< "$triples"
 
     log "pass complete"
 }