mjolnir-cli 0.2.1__tar.gz → 0.4.2__tar.gz

{mjolnir_cli-0.2.1 → mjolnir_cli-0.4.2}/.gitignore

@@ -1,9 +1,13 @@
 __pycache__/
 *.py[cod]
 .venv/
+.playwright-mcp/
 .pytest_cache/
 .ruff_cache/
 .env
+# the configs' env sidecars are plain mjolnir knobs (calibration paths, feature
+# flags) and ride with the configs; real secrets stay out
+!configs/**/.env
 # coverage artifacts (the CI test stage writes these; they regenerate)
 .coverage
 .coverage.*
@@ -24,6 +28,7 @@ benchmarks/raw/*
 !benchmarks/raw/accuracy/
 benchmarks/raw/accuracy/*/*/
 benchmarks/logs/
+benchmarks/staging/
 task/
 
 # autoresearch: the live ledger is untracked (discards are `git reset --hard`);
@@ -32,3 +37,6 @@ research/ledger.jsonl
 research/ledger.tsv
 # …and the exported runs ARE committed (the generic runs/ rule above would hide them)
 !research/runs/
+/cutlass/
+/fa2/
+/llamacpp/

{mjolnir_cli-0.2.1 → mjolnir_cli-0.4.2}/NOTICE

@@ -8,7 +8,7 @@ works listed below; each keeps its own license and copyright notice.
 -------------------------------------------------------------------------------
 1. NVIDIA CUTLASS — CuTe DSL examples                         BSD-3-Clause
 -------------------------------------------------------------------------------
-src/mjolnir/mjolnir/t5_decode.py (the Mjolnir decode-attention kernel) is
+src/mjolnir/mjolnir/arch/thor/decode.py (the Mjolnir decode-attention kernel) is
 derived from
 
   examples/python/CuTeDSL/cute/blackwell/kernel/attention/mixed_input_fmha/

{mjolnir_cli-0.2.1 → mjolnir_cli-0.4.2}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.5
 Name: mjolnir-cli
-Version: 0.2.1
+Version: 0.4.2
 Summary: Serve, benchmark and document LLMs on NVIDIA Jetson AGX Thor: YAML model configs, the Mjolnir vLLM image, KV-cache calibration, kernel / serving / accuracy benchmarks and auto-rendered reports.
-Project-URL: Homepage, https://github.com/thor-arena/mjolnir
-Project-URL: Documentation, https://github.com/thor-arena/mjolnir/tree/main/docs
-Project-URL: Repository, https://github.com/thor-arena/mjolnir.git
-Project-URL: Issues, https://github.com/thor-arena/mjolnir/issues
-Project-URL: Changelog, https://github.com/thor-arena/mjolnir/releases
-Project-URL: CLI reference, https://github.com/thor-arena/mjolnir/blob/main/docs/cli.md
+Project-URL: Homepage, https://github.com/GoBrrr-ai/mjolnir
+Project-URL: Documentation, https://github.com/GoBrrr-ai/mjolnir/tree/main/docs
+Project-URL: Repository, https://github.com/GoBrrr-ai/mjolnir.git
+Project-URL: Issues, https://github.com/GoBrrr-ai/mjolnir/issues
+Project-URL: Changelog, https://github.com/GoBrrr-ai/mjolnir/releases
+Project-URL: CLI reference, https://github.com/GoBrrr-ai/mjolnir/blob/main/docs/cli.md
 Author-email: Mieszko Syty <mieszko@ms1design.pl>
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -34,7 +34,7 @@ Description-Content-Type: text/markdown
 # mjolnir-cli
 
 **Serve, benchmark and document LLMs on the NVIDIA Jetson AGX Thor** with
-[Mjolnir](https://github.com/thor-arena/mjolnir) — a decode-attention kernel
+[Mjolnir](https://github.com/GoBrrr-ai/mjolnir) — a decode-attention kernel
 built for Thor (`sm_110`), a 6-bit KV-cache format for vLLM and a patched vLLM
 image that runs them. This package is the `mjolnir` command that drives all of
 it; the kernel itself ships separately as
@@ -69,17 +69,45 @@ mjolnir serve up                 # serve the default model on the Mjolnir image,
   tests and logs kernel experiments.
 
 Every command, with options and defaults:
-**[the CLI reference](https://github.com/thor-arena/mjolnir/blob/main/docs/cli.md)**
+**[the CLI reference](https://github.com/GoBrrr-ai/mjolnir/blob/main/docs/cli.md)**
 (generated from the commands; `mjolnir <command> --help` prints the same).
 
+## Library use
+
+Two modules are declared a public, stable API — reuse them instead of
+re-implementing the clean-window gate or the bench-history substrate:
+
+- **`mjolnir_cli.gate`** — `wait_for_idle`, `server_load`, `server_counters`,
+  `spec_delta`, the `CleanWindow` context manager, `PreflightError` and the
+  `DEFAULT_*` tuning constants.
+- **`mjolnir_cli.history`** — `append_record`, `load_records` and
+  `SCHEMA_VERSION`; the history-row schema is documented in the module
+  docstring. Rows carry `schema_version` — absence means the legacy (pre-0.3)
+  format — and `load_records` returns rows raw, never normalized.
+  `append_record` files one record per serving key (platform, model, image,
+  config): a re-run merges its cells into the stored record instead of
+  appending a line; records without a serving key are appended verbatim.
+
+Anything else can change without notice; the module docstrings are the API
+reference: [`gate.py`](https://github.com/GoBrrr-ai/mjolnir/blob/main/src/mjolnir-cli/mjolnir_cli/gate.py),
+[`history.py`](https://github.com/GoBrrr-ai/mjolnir/blob/main/src/mjolnir-cli/mjolnir_cli/history.py).
+
+`uv tool install mjolnir-cli` is an isolated CLI install — *not* importable
+from another project. Library use means adding `mjolnir-cli` as a dependency
+of your project (`uv add mjolnir-cli` / `pip install mjolnir-cli`). The
+gate/history import chain is stdlib-only: the CLI dependency stack (typer,
+rich, pyyaml, jinja2) is paid at install time, not import time. Python ≥ 3.12
+is required (pip refuses older interpreters — relevant on JetPack 6-era
+images), and type annotations ship (`py.typed`).
+
 ## Requirements
 
 A Jetson AGX Thor (JetPack 7.x) with Docker and the NVIDIA Container Toolkit
-for anything that touches the GPU; Python ≥ 3.10. Charts need the `plot` extra
+for anything that touches the GPU; Python ≥ 3.12. Charts need the `plot` extra
 (`uv tool install 'mjolnir-cli[plot]'`).
 
 ## Versions
 
 `mjolnir-cli` and `mjolnir-kernel` version independently; the Docker image is
 tagged after the upstream vLLM it is built on (`v0.31.0`). Release notes:
-[GitHub Releases](https://github.com/thor-arena/mjolnir/releases).
+[GitHub Releases](https://github.com/GoBrrr-ai/mjolnir/releases).

{mjolnir_cli-0.2.1 → mjolnir_cli-0.4.2}/README.md

@@ -1,7 +1,7 @@
 # mjolnir-cli
 
 **Serve, benchmark and document LLMs on the NVIDIA Jetson AGX Thor** with
-[Mjolnir](https://github.com/thor-arena/mjolnir) — a decode-attention kernel
+[Mjolnir](https://github.com/GoBrrr-ai/mjolnir) — a decode-attention kernel
 built for Thor (`sm_110`), a 6-bit KV-cache format for vLLM and a patched vLLM
 image that runs them. This package is the `mjolnir` command that drives all of
 it; the kernel itself ships separately as
@@ -36,17 +36,45 @@ mjolnir serve up                 # serve the default model on the Mjolnir image,
   tests and logs kernel experiments.
 
 Every command, with options and defaults:
-**[the CLI reference](https://github.com/thor-arena/mjolnir/blob/main/docs/cli.md)**
+**[the CLI reference](https://github.com/GoBrrr-ai/mjolnir/blob/main/docs/cli.md)**
 (generated from the commands; `mjolnir <command> --help` prints the same).
 
+## Library use
+
+Two modules are declared a public, stable API — reuse them instead of
+re-implementing the clean-window gate or the bench-history substrate:
+
+- **`mjolnir_cli.gate`** — `wait_for_idle`, `server_load`, `server_counters`,
+  `spec_delta`, the `CleanWindow` context manager, `PreflightError` and the
+  `DEFAULT_*` tuning constants.
+- **`mjolnir_cli.history`** — `append_record`, `load_records` and
+  `SCHEMA_VERSION`; the history-row schema is documented in the module
+  docstring. Rows carry `schema_version` — absence means the legacy (pre-0.3)
+  format — and `load_records` returns rows raw, never normalized.
+  `append_record` files one record per serving key (platform, model, image,
+  config): a re-run merges its cells into the stored record instead of
+  appending a line; records without a serving key are appended verbatim.
+
+Anything else can change without notice; the module docstrings are the API
+reference: [`gate.py`](https://github.com/GoBrrr-ai/mjolnir/blob/main/src/mjolnir-cli/mjolnir_cli/gate.py),
+[`history.py`](https://github.com/GoBrrr-ai/mjolnir/blob/main/src/mjolnir-cli/mjolnir_cli/history.py).
+
+`uv tool install mjolnir-cli` is an isolated CLI install — *not* importable
+from another project. Library use means adding `mjolnir-cli` as a dependency
+of your project (`uv add mjolnir-cli` / `pip install mjolnir-cli`). The
+gate/history import chain is stdlib-only: the CLI dependency stack (typer,
+rich, pyyaml, jinja2) is paid at install time, not import time. Python ≥ 3.12
+is required (pip refuses older interpreters — relevant on JetPack 6-era
+images), and type annotations ship (`py.typed`).
+
 ## Requirements
 
 A Jetson AGX Thor (JetPack 7.x) with Docker and the NVIDIA Container Toolkit
-for anything that touches the GPU; Python ≥ 3.10. Charts need the `plot` extra
+for anything that touches the GPU; Python ≥ 3.12. Charts need the `plot` extra
 (`uv tool install 'mjolnir-cli[plot]'`).
 
 ## Versions
 
 `mjolnir-cli` and `mjolnir-kernel` version independently; the Docker image is
 tagged after the upstream vLLM it is built on (`v0.31.0`). Release notes:
-[GitHub Releases](https://github.com/thor-arena/mjolnir/releases).
+[GitHub Releases](https://github.com/GoBrrr-ai/mjolnir/releases).

{mjolnir_cli-0.2.1 → mjolnir_cli-0.4.2}/mjolnir_cli/__init__.py

@@ -5,4 +5,4 @@ kernel against FlashInfer and FlashAttention 2, and render the
 data-driven README charts — one command surface.
 """
 
-__version__ = "0.2.1"
+__version__ = "0.4.2"

mjolnir_cli-0.4.2/mjolnir_cli/__main__.py

@@ -0,0 +1,10 @@
+"""Run the ``mjolnir`` CLI via ``python -m mjolnir_cli`` — the same entry
+point as the console script (``mjolnir_cli.cli:main``), UnknownPlatform
+handler included."""
+
+import sys
+
+from mjolnir_cli.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

{mjolnir_cli-0.2.1 → mjolnir_cli-0.4.2}/mjolnir_cli/accuracy.py

@@ -14,8 +14,9 @@ tool-eval-bench keeps its results in ``./data/benchmarks.sqlite`` and
 under ``benchmarks/raw/accuracy/<run>/<leg>/``, so the database holds exactly
 that leg's runs. :func:`summarize_db` reads it back into the committed
 ``accuracy.json`` (``mjolnir.accuracy/1``): per suite the score, per
-tool-call category the share of points, per scenario the points — what the
-docs table and charts are rendered from.
+tool-call category the share of points, per scenario the points, and the ids
+tool-eval-bench excluded from scoring (``excluded``) — what the docs table
+and charts are rendered from.
 """
 
 from __future__ import annotations
@@ -24,6 +25,7 @@ import json
 import os
 import shlex
 import shutil
+import platform as host_platform  # the record's host field names the machine (platform.node)
 import sqlite3
 import subprocess
 import sys
@@ -32,6 +34,7 @@ from pathlib import Path
 from statistics import mean
 
 from mjolnir_cli.config import by_model, model_of, model_short
+from mjolnir_cli.platforms import platform_of
 
 FORMAT = "mjolnir.accuracy/1"
 TOOL_REPO = "https://github.com/SeraphimSerapis/tool-eval-bench"
@@ -96,7 +99,9 @@ def _pct(earned: float, mx: float) -> float | None:
 def summarize_db(db: Path) -> dict:
     """tool-eval-bench's SQLite → ``{"suites": {suite: {...}}, "categories":
     {...}, "scenarios": {...}}``. Several completed runs of a kind (``--trials``)
-    are averaged; each suite keeps its per-run scores."""
+    are averaged; each suite keeps its per-run scores. A scenario the tool
+    excluded from scoring (an infrastructure failure: the probe failed, a
+    timeout) comes back as ``excluded``."""
     if not db.exists():
         return {"suites": {}, "categories": {}, "scenarios": {}, "runs": []}
     con = sqlite3.connect(f"file:{db}?mode=ro", uri=True)
@@ -110,6 +115,7 @@ def summarize_db(db: Path) -> dict:
     per_suite: dict[str, list[dict]] = {}
     cats: dict[str, dict] = {}
     scen: dict[str, list[float]] = {}
+    excluded: set[str] = set()
     runs = []
     for run_id, created, status, run_type, scores_json, _config_json in rows:
         runs.append({"run_id": run_id, "created_at": created, "status": status, "run_type": run_type})
@@ -117,6 +123,7 @@ def summarize_db(db: Path) -> dict:
             continue
         sc = _loads(scores_json)
         if run_type == "tool_eval":
+            excluded |= set(sc.get("excluded_scenarios") or ())  # upstream lists them only when non-empty
             cs = sc.get("category_scores") or []
             std = [c for c in cs if c.get("category") != HARD_CATEGORY]
             hard = [c for c in cs if c.get("category") == HARD_CATEGORY]
@@ -168,7 +175,7 @@ def summarize_db(db: Path) -> dict:
         if comps:
             last["completion_rate"] = min(comps)  # the worst trial: an exclusion in any trial shows
         suites[name] = {"score": round(mean(scores), 2), "scores": scores, "n": len(scores), **last}
-    return {
+    out = {
         "suites": suites,
         "categories": {
             k: {"label": v["label"], "percent": round(mean(v["percent"]), 2)}
@@ -178,6 +185,9 @@ def summarize_db(db: Path) -> dict:
         "scenarios": {k: round(mean(v), 3) for k, v in sorted(scen.items())},
         "runs": runs,
     }
+    if excluded:  # e.g. TC-45: the tool_choice=required probe failed — scored as zero on the full max
+        out["excluded"] = sorted(excluded)
+    return out
 
 
 # ── the run ─────────────────────────────────────────────────────────────────
@@ -211,9 +221,7 @@ def leg_label(rec: dict) -> str:
     if "MJOLNIR" not in cfg:
         return f"Mjolnir image · {BACKEND_LABELS.get(cfg, cfg)} · {kv}"
     extra = "".join(
-        f" + {name}"
-        for tag, name in (("LMH8", "fp8 lm_head"), ("VT32K", "32K draft vocab"), ("VT64K", "64K draft vocab"))
-        if tag in cfg.split("_")
+        f" + {name}" for tag, name in (("LMH8", "fp8 lm_head"), ("VT64K", "64K draft vocab")) if tag in cfg.split("_")
     )
     return f"Mjolnir · {kv}{extra}"
 
@@ -230,6 +238,7 @@ def run_accuracy(
     tool-eval-bench against it, and write ``accuracy.json``. Returns its path."""
     from mjolnir_cli import dockerctl
     from mjolnir_cli.config import config_field
+    from mjolnir_cli.platforms import detect, gpu_name
 
     tool = find_tool()
     run_id = time.strftime("%Y%m%d-%H%M%S")
@@ -239,6 +248,10 @@ def run_accuracy(
         "format": FORMAT,
         "run_id": run_id,
         "created": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "host": host_platform.node() or "unknown",
+        "gpu": gpu_name(),
+        # the detection-first rule: the record names the *detected* platform
+        "platform": detect().platform,
         "tool": {"repo": TOOL_REPO, "commit": TOOL_COMMIT, "command": tool},
         "args": list(passthrough) or list(DEFAULT_ARGS),
         "legs": [],
@@ -299,23 +312,33 @@ def load_runs(layout) -> list[dict]:
 
 
 def latest_legs(docs: list[dict]) -> list[dict]:
-    """One row per (model, image, config): every suite from the newest run
-    that measured it (an A/B run and a later GSM8K run merge into one row).
-    Order: first appearance."""
+    """One row per (platform, model, image side, config): every suite from the
+    newest run that measured it (an A/B run and a later GSM8K run merge into
+    one row). Order: first appearance. The platform comes from the run doc
+    (platform-less records are the repo's Thor history); a leg measured on
+    two platforms is two rows — its charts are per (platform, model). The
+    side (official image vs Mjolnir) keys the row, not the image tag, so a
+    re-measure on a newer image of the same side supersedes the older scores
+    in place (the row keeps its position and the newest image) instead of
+    duplicating a row the labels cannot tell apart."""
     rows: dict[tuple, dict] = {}
     for d in docs:
+        plat = platform_of(d)
         for leg in d.get("legs", []):
-            key = (model_of(leg), leg.get("image"), leg.get("config"))
+            key = (plat, model_of(leg), _is_mjolnir(str(leg.get("image", ""))), leg.get("config"))
             row = rows.setdefault(
                 key,
                 {k: leg.get(k) for k in ("id", "model", "image", "config", "label", "kv_cache_dtype", "env")}
-                | {"suites": {}, "categories": {}, "scenarios": {}, "runs": {}},
+                | {"platform": plat, "suites": {}, "categories": {}, "scenarios": {}, "runs": {}},
             )
+            row["image"] = leg.get("image") or row.get("image")
             row["kv_cache_dtype"] = leg.get("kv_cache_dtype") or row.get("kv_cache_dtype")
             row["label"] = leg_label(row)  # recomputed: labels improve after a run is stored
             for name, suite in (leg.get("suites") or {}).items():
                 row["suites"][name] = suite
                 row["runs"][name] = {"run_id": d.get("run_id"), "args": d.get("args")}
+            if leg.get("excluded"):  # an exclusion in any run of the leg shows
+                row["excluded"] = sorted({*(row.get("excluded") or ()), *leg["excluded"]})
             if (leg.get("suites") or {}).keys() & {"tools", "hardmode"}:
                 row["categories"] = leg.get("categories") or row["categories"]
                 row["scenarios"] = leg.get("scenarios") or row["scenarios"]

{mjolnir_cli-0.2.1 → mjolnir_cli-0.4.2}/mjolnir_cli/autoresearch.py

@@ -4,10 +4,14 @@ After karpathy/autoresearch: an agent edits ONE file, runs a FIXED,
 time-boxed evaluation, keeps the change if the metric improved and resets it
 otherwise — forever, while every experiment lands on a ledger. Here:
 
-* the editable file  — ``src/mjolnir/mjolnir/t5_decode.py`` (the kernel);
+* the editable files — the kernel family for this board's platform
+  (``mjolnir arch/thor/*.py``: the traced decode kernel and its builder,
+  constants, plan and harness; ``arch/orin/*.py``: the mma kernel plus its
+  runner, plan, combine and harness — resolved from the active platform);
 * the fixed harness  — ``mjolnir autoresearch evaluate``: the quick
-  correctness subset (``mjolnir verify correctness --quick``) + an ncu sweep
-  of FlashInfer vs Mjolnir (harness default) at every L;
+  correctness subset (``mjolnir verify correctness --quick``) + a sweep
+  of FlashInfer vs Mjolnir at every L (ncu-timed on Thor, events-timed
+  on Orin — the platforms' headline sweep either way);
 * the metric         — per L, FlashInfer time / Mjolnir time, both measured
   in the SAME run (drift on the shared Thor cancels out); the score is their
   geomean over L;
@@ -17,7 +21,11 @@ otherwise — forever, while every experiment lands on a ledger. Here:
   single L and no more than one L slower than the noise band; L where the
   FlashInfer reference itself jumped are set aside; ``noisy`` when the
   reference was unstable at too many L (re-evaluate the same commit),
-  ``crash`` if a stage failed to produce data.
+  ``crash`` if a stage failed to produce data. A structured sub-bar gain
+  (over half the bar, same shape) is ``parked``: the commit is tagged
+  ``ar/parked/<sha>`` and survives the reset as stackable material — bricks
+  too small to certify alone clear the bar in batches — but a parked row is
+  never the reference.
 * the ledger         — ``research/ledger.jsonl`` (+ a ``ledger.tsv`` view):
   one row per experiment with the hypothesis, the agents involved, the
   sources (URLs / arXiv ids), the commit, the per-L numbers and the verify
@@ -29,7 +37,8 @@ The loop itself is an OpenCode session (``mjolnir autoresearch run``)
 driving ``.opencode/agent/autoresearch.md`` (the orchestrator; the helpers it delegates to are user-defined OpenCode agents)
 → ``web-researcher`` / ``arxiv-researcher`` (ideas + sources) →
 ``python-engineer`` (the change) → ``debugger`` (crashes, correctness
-failures). The program they follow is ``research/program.md``.
+failures). The program they follow is ``research/program.md`` —
+``research/program-orin.md`` on an Orin (resolved by the active platform).
 """
 
 from __future__ import annotations
@@ -57,7 +66,33 @@ app = typer.Typer(
     context_settings={"help_option_names": ["-h", "--help"]},
 )
 
-KERNEL_FILE = Path("src/mjolnir/mjolnir/t5_decode.py")
+KERNEL_DIR = Path("src/mjolnir/mjolnir/arch/thor")
+ORIN_KERNEL_DIR = Path("src/mjolnir/mjolnir/arch/orin")
+# the kernel family an experiment may change — per family (the loop runs on
+# the board it improves; resolved from the active platform, never a silent
+# default). Thor: the traced decode kernel plus its builder, constants, plan
+# and standalone harness. Orin: the mma kernel plus its runner, plan, combine
+# and standalone harness.
+THOR_FILES = tuple(KERNEL_DIR / f for f in ("decode.py", "call.py", "const.py", "plan.py", "harness.py"))
+ORIN_FILES = tuple(ORIN_KERNEL_DIR / f for f in ("mma.py", "runner.py", "plan.py", "combine.py", "harness.py"))
+# the loop's brief, per platform (what the agent reads; `run` points it there)
+PROGRAM = {"thor": Path("research/program.md"), "orin": Path("research/program-orin.md")}
+
+
+def kernel_files() -> tuple[Path, ...]:
+    """The kernel family this board's loop may change."""
+    from mjolnir_cli.platforms import resolve_platform
+
+    return ORIN_FILES if resolve_platform(None) == "orin" else THOR_FILES
+
+
+def program_file() -> Path:
+    """The program brief for this board's platform."""
+    from mjolnir_cli.platforms import resolve_platform
+
+    return PROGRAM.get(resolve_platform(None), PROGRAM["thor"])
+
+
 LEDGER_DIR = Path("research")
 TSV_COLUMNS = ["id", "ts", "commit", "status", "score", "best_before", "correctness", "agent", "hypothesis", "reason"]
 
@@ -143,6 +178,16 @@ def judge(row: dict, best: dict | None, min_gain: float = 0.02, noise: float = N
     3. at most one L is slower than ``1 - noise`` (one is tolerated: 16K is
        bimodal run to run).
 
+    A *parked* row is a sub-bar gain that still has the shape of a win:
+    geomean over ``1 + min_gain / 2``, leave-one-out over ``1 + min_gain / 4``,
+    at most one L slower than the noise band. ``evaluate`` tags the commit
+    ``ar/parked/<sha>`` so it survives the reset; the orchestrator stacks
+    parked bricks — alone or mixed — and evaluates each batch as one row, and
+    bricks too small to certify alone clear the bar together. A gain resting
+    on one L, or losing at several, is a gating candidate, not a brick: plain
+    ``discard``. A parked row never becomes the reference
+    (:func:`best_kept` ignores it).
+
     An L is *suspect* — set aside — when the FlashInfer reference time moved
     by more than ``REF_JUMP`` against the best row's run (the reference never
     changes between experiments, so a jump there is noise in the measurement,
@@ -170,7 +215,37 @@ def judge(row: dict, best: dict | None, min_gain: float = 0.02, noise: float = N
     note = f" (set aside, reference jumped: {', '.join(_L(L) for L in suspect)})" if suspect else ""
     gain = _gm(trusted.values())
     if gain <= 1 + min_gain:
-        return "discard", f"geomean {_pct(gain)} ≤ +{min_gain * 100:g}%{note}", rel
+        if gain <= 1 + min_gain / 2:
+            return "discard", f"geomean {_pct(gain)} ≤ +{min_gain * 100:g}%{note}", rel
+        # Parked band (half the keep bars): a real-looking small win stays
+        # stackable instead of dying on the reset.
+        top = max(trusted, key=lambda L: trusted[L])
+        loo = _gm(v for L, v in trusted.items() if top != L)
+        slower = sorted((L for L, v in trusted.items() if v < 1 - noise), key=int)
+        if len(slower) > 1:  # a gating candidate, not a brick: name the losses
+            return (
+                "discard",
+                f"geomean {_pct(gain)} under the bar but slower at "
+                + ", ".join(f"{_L(L)} ({_pct(trusted[L])})" for L in slower)
+                + note,
+                rel,
+            )
+        if loo <= 1 + min_gain / 4:
+            return (
+                "discard",
+                f"geomean {_pct(gain)} under the bar and rests on {_L(top)} ({_pct(trusted[top])}): "
+                f"{_pct(loo)} without it{note}",
+                rel,
+            )
+        shape = f", {_pct(loo)} without its best L ({_L(top)})"
+        if slower:
+            shape += ", slower at " + ", ".join(_L(L) for L in slower)
+        return (
+            "parked",
+            f"geomean {_pct(gain)} under the +{min_gain * 100:g}% bar but structured{shape} — "
+            f"parked for stacking{note}",
+            rel,
+        )
     top = max(trusted, key=lambda L: trusted[L])
     loo = _gm(v for L, v in trusted.items() if top != L)
     if loo <= 1 + min_gain / 2:
@@ -211,8 +286,13 @@ def _init(root: Path, tag: str, base: str, evaluate_baseline: bool, image: str |
     if _git(root, "branch", "--list", branch):
         console.print(f"[red]{branch} already exists — pick a fresh tag (a run never reuses a branch)[/red]")
         return 4
-    if _git(root, "status", "--porcelain", "--", str(KERNEL_FILE)):
-        console.print(f"[red]{KERNEL_FILE} has uncommitted changes — commit or stash them first[/red]")
+    kfiles = kernel_files()
+    if _git(root, "status", "--porcelain", "--", *map(str, kfiles)):
+        console.print(
+            "[red]the kernel family has uncommitted changes ("
+            + ", ".join(p.name for p in kfiles)
+            + ") — commit or stash them first[/red]"
+        )
         return 4
     if load_ledger(root):
         console.print(
@@ -255,7 +335,8 @@ def _evaluate(
     rows = load_ledger(root)
     best = best_kept(rows)
     commit = _git(root, "rev-parse", "--short", "HEAD")
-    dirty = bool(_git(root, "status", "--porcelain", "--", str(KERNEL_FILE)))
+    kfiles = kernel_files()
+    dirty = bool(_git(root, "status", "--porcelain", "--", *map(str, kfiles)))
     if dirty:
         console.print(
             "[yellow]the kernel has uncommitted changes — commit the experiment first "
@@ -340,34 +421,52 @@ def _evaluate(
             "  vs best, per L: "
             + "  ".join(f"{_L(L)} {_pct(v)}" for L, v in sorted(rel.items(), key=lambda kv: int(kv[0])))
         )
-    if status in ("discard", "crash"):
+    if status in ("discard", "crash", "parked"):
         console.print(f"[dim]  revert: git reset --hard {best['commit'] if best else 'HEAD~1'}[/dim]")
+    if status == "parked":
+        tag = f"ar/parked/{commit}"
+        try:
+            if not _git(root, "tag", "--list", tag):
+                _git(root, "tag", "-a", tag, "-m", hypothesis, commit)
+            console.print(
+                f"[dim]  parked: the brick survives as tag {tag} — cherry-pick it, alone or mixed with "
+                "other parked tags, onto the best commit and evaluate the batch as one row "
+                "(a parked row is never the reference)[/dim]"
+            )
+        except RuntimeError as exc:
+            console.print(f"[dim]  parked (tagging failed: {exc!r}) — the ledger row carries the commit[/dim]")
     elif status == "noisy":
         console.print("[dim]  the measurement was rejected, not the idea: evaluate the same commit again[/dim]")
-    _render_progress(root)
+    render_progress(root)
     return 0
 
 
-STATUS_COLORS = {"keep": "green", "baseline": "cyan", "discard": "yellow", "crash": "red", "noisy": "magenta"}
+STATUS_COLORS = {
+    "keep": "green",
+    "baseline": "cyan",
+    "parked": "blue",
+    "discard": "yellow",
+    "crash": "red",
+    "noisy": "magenta",
+}
 PROGRESS = LEDGER_DIR / "progress.png"
 
 
-def _render_progress(root: Path, rows: list[dict] | None = None, out: Path | None = None) -> Path | None:
-    """research/progress.png (+ -dark): every experiment on one chart, the
-    kept staircase, and the per-L split vs the baseline. Best effort — a
-    missing matplotlib never fails an evaluation."""
+def render_progress(root: Path, rows: list[dict] | None = None, out: Path | None = None) -> Path | None:
+    """research/progress.png: every experiment on one chart, the kept
+    staircase, and the per-L split vs the baseline. Best effort — a missing
+    matplotlib never fails an evaluation."""
     rows = rows if rows is not None else load_ledger(root)
     try:
         from mjolnir_cli import charts, theme
 
         plt = charts._plt()
         out = out or root / PROGRESS
-        for mode in theme.MODES:
-            fig = charts.chart_autoresearch(rows, mode)
-            if fig is None:
-                return None
-            charts._save(fig, out.with_name(f"{out.stem}{mode.suffix}{out.suffix}"))
-            plt.close(fig)
+        fig = charts.chart_autoresearch(rows, theme.DARK)
+        if fig is None:
+            return None
+        charts._save(fig, out)
+        plt.close(fig)
         return out
     except Exception as e:  # noqa: BLE001 — a chart must never cost a ledger row
         console.print(f"[dim]progress chart skipped: {e!r}[/dim]")
@@ -395,7 +494,7 @@ def evaluate(
     image: str | None = typer.Option(None, "--image"),
 ):
     """Score the committed kernel: quick correctness + FlashInfer vs Mjolnir sweep;
-    append the result and the fixed keep/discard decision to the ledger."""
+    append the result and the fixed keep/park/discard decision to the ledger."""
     raise typer.Exit(_evaluate(_root(), hypothesis, agent, sources, image, min_gain, ls, iters, gate))
 
 
@@ -457,18 +556,21 @@ def status():
 def chart():
     """Re-render research/progress.png from the live ledger (or the newest exported run)."""
     root = _root()
-    p = _render_progress(root, latest_rows(root))
+    p = render_progress(root, latest_rows(root))
     console.print(f"[green]{p}[/green]" if p else "[yellow]no experiments yet[/yellow]")
 
 
 @app.command()
 def run(
     tag: str | None = typer.Option(None, "--tag", help="start a new run first (init <tag>)"),
+    base: str = typer.Option(
+        None, "--base", help="branch to start from (default: main; the Orin's kernel lives on feat/orin)"
+    ),
     model: str | None = typer.Option(None, "--model", help="OpenCode model (provider/model) for the orchestrator"),
     prompt: str = typer.Option(
-        "Read research/program.md and run the loop: setup is done when the ledger has a baseline row. "
-        "Never stop to ask; record every experiment with `mjolnir autoresearch evaluate`.",
+        None,
         "--prompt",
+        help="the orchestrator's brief (default: read this platform's program and run the loop)",
     ),
 ):
     """Launch the loop: an OpenCode session with the `autoresearch` agent."""
@@ -476,8 +578,13 @@ def run(
     if shutil.which("opencode") is None:
         console.print("[red]opencode not found — install it: https://opencode.ai (npm i -g opencode-ai)[/red]")
         raise typer.Exit(2)
+    if prompt is None:
+        prompt = (
+            f"Read {program_file()} and run the loop: setup is done when the ledger has a baseline row. "
+            "Never stop to ask; record every experiment with `mjolnir autoresearch evaluate`."
+        )
     if tag:
-        rc = _init(root, tag, "main", True, None)
+        rc = _init(root, tag, base or ("feat/orin" if program_file() == PROGRAM["orin"] else "main"), True, None)
         if rc != 0:
             raise typer.Exit(rc)
     elif not load_ledger(root):
@@ -522,7 +629,7 @@ def export(
         f"- baseline: {base['score']}× vs FlashInfer at `{base['commit']}`" if base and base.get("score") else "",
         f"- best: **{best['score']}×** at `{best['commit']}` — {best['hypothesis']}" if best else "",
         "",
-        "![progress](progress.png)" if _render_progress(root, rows, out / "progress.png") else "",
+        "![progress](progress.png)" if render_progress(root, rows, out / "progress.png") else "",
         "",
         "| # | commit | status | score | why | agent | hypothesis | sources |",
         "|--:|---|---|--:|---|---|---|---|",