Bodies registry, fold_clothes (two hands), task x body and skill x body matrices

board.json

@@ -1,16 +1,157 @@
 {
- "format": "pilot-board/1",
- "built": "2026-11-10T17:58:13+00:00",
+ "format": "pilot-board/2",
+ "built": "2026-11-11T08:05:40+00:00",
+ "bodies": [
+  {
+   "body": "cable",
+   "pilot": "MacroSwan/cablepilot",
+   "status": "open",
+   "carrier": "cable-driven parallel robot (4 lines, a gantry, a swinging pole)",
+   "machines": [
+    "Stringman (Neufangled)"
+   ],
+   "rigs": [
+    {
+     "rig": "stringman",
+     "hands": 1,
+     "hand": "Stringman two-finger gripper",
+     "status": "open"
+    },
+    {
+     "rig": "duo_rig",
+     "hands": 2,
+     "hand": "two SO-101 arms on a turntable plate",
+     "status": "private"
+    }
+   ],
+   "predicates": [
+    "see",
+    "pre_grasp",
+    "grasp",
+    "pre_inside",
+    "release",
+    "inside",
+    "avoid"
+   ],
+   "predicates_source": "cablepilot/cardrun.py CABLE_SKILLS",
+   "model": {
+    "params": 28401,
+    "train": "11 min, laptop CPU, task-free sim motion in 12k random rooms"
+   }
+  },
+  {
+   "body": "arm",
+   "pilot": "MacroSwan/armpilot",
+   "status": "coming",
+   "carrier": "desk arm (SO-101, 6 servos)",
+   "machines": [
+    "SO-101 (LeRobot)"
+   ],
+   "rigs": [
+    {
+     "rig": "so101",
+     "hands": 1,
+     "hand": "SO-101 pinch",
+     "status": "private"
+    },
+    {
+     "rig": "so101_duo",
+     "hands": 2,
+     "hand": "two SO-101s facing each other",
+     "status": "private"
+    }
+   ],
+   "predicates": [],
+   "note": "the only pilot with real-robot runs (pen in cup on a real SO-101): the first to release after cable"
+  },
+  {
+   "body": "dog",
+   "pilot": "MacroSwan/dogpilot",
+   "status": "coming",
+   "carrier": "quadruped (Unitree Go2)",
+   "machines": [
+    "Unitree Go2 (sim)"
+   ],
+   "rigs": [
+    {
+     "rig": "go2",
+     "hands": 0,
+     "hand": "none",
+     "status": "private"
+    }
+   ],
+   "predicates": [],
+   "note": "MPPI over a learned motion model: duck under and jump over bars"
+  },
+  {
+   "body": "drone",
+   "pilot": "MacroSwan/dronepilot",
+   "status": "coming",
+   "carrier": "quadrotor (and fixed wing)",
+   "machines": [
+    "quadrotor (sim)"
+   ],
+   "rigs": [
+    {
+     "rig": "quad",
+     "hands": 0,
+     "hand": "none",
+     "status": "private"
+    },
+    {
+     "rig": "quad_pinch",
+     "hands": 1,
+     "hand": "SO-101 pinch under the frame",
+     "status": "private"
+    }
+   ],
+   "predicates": [],
+   "note": "SkyJEPA world model; public precursors on huggingface.co/Ethgar (skyjepa, skyfull datasets)"
+  },
+  {
+   "body": "human",
+   "pilot": "MacroSwan/humanpilot",
+   "status": "coming",
+   "carrier": "humanoid (Unitree G1)",
+   "machines": [
+    "Unitree G1 (sim)"
+   ],
+   "rigs": [
+    {
+     "rig": "g1",
+     "hands": 2,
+     "hand": "G1 hands",
+     "status": "private"
+    }
+   ],
+   "predicates": [],
+   "note": "licence to settle before release: the motion prior is trained on LAFAN1 (CC BY-NC-ND)"
+  }
+ ],
  "tasks": {
   "clean_the_room": {
-   "bodies": [
+   "needs": {
+    "predicates": [
+     "grasp",
+     "inside",
+     "pre_grasp",
+     "pre_inside",
+     "release",
+     "see"
+    ],
+    "hands": 1
+   },
+   "lineage": {
+    "parent": "worldpilot:cards/home/clean_the_room.yaml",
+    "by": "Ethgar",
+    "why": "runnable on today's skills: one box, every stray"
+   },
+   "tunings": [
     "cable"
    ],
    "results": [
     {
      "id": "2026-11-10_2ed39e20ae72_c1511f1b78dd_bedroom_s0",
-     "sim": "3.15.0",
-     "reference_sim": true,
      "body": "cable",
      "world": "sim:bedroom",
      "seed": 0,
@@ -37,14 +178,15 @@
      },
      "by": "Ethgar",
      "date": "2026-11-10T17:57:24+00:00",
+     "sim": "3.15.0",
+     "reference_sim": true,
+     "result": "tasks/clean_the_room/results/2026-11-10_2ed39e20ae72_c1511f1b78dd_bedroom_s0.json",
      "media": "tasks/clean_the_room/media/2026-11-10_2ed39e20ae72_c1511f1b78dd_bedroom_s0.mp4"
     }
    ],
    "best": [
     {
      "id": "2026-11-10_2ed39e20ae72_c1511f1b78dd_bedroom_s0",
-     "sim": "3.15.0",
-     "reference_sim": true,
      "body": "cable",
      "world": "sim:bedroom",
      "seed": 0,
@@ -71,16 +213,192 @@
      },
      "by": "Ethgar",
      "date": "2026-11-10T17:57:24+00:00",
+     "sim": "3.15.0",
+     "reference_sim": true,
+     "result": "tasks/clean_the_room/results/2026-11-10_2ed39e20ae72_c1511f1b78dd_bedroom_s0.json",
      "media": "tasks/clean_the_room/media/2026-11-10_2ed39e20ae72_c1511f1b78dd_bedroom_s0.mp4"
     }
-   ],
-   "card_lines": 32
+   ]
+  },
+  "fold_clothes": {
+   "needs": {
+    "predicates": [
+     "folded",
+     "laid_flat",
+     "on_top",
+     "release",
+     "see",
+     "support_both"
+    ],
+    "hands": 2
+   },
+   "lineage": {
+    "parent": "worldpilot:cards/home/fold_clothes.yaml",
+    "by": "Ethgar",
+    "why": "the first two-hand challenge on the board, unchanged"
+   },
+   "tunings": [],
+   "results": [],
+   "best": []
   },
   "pen_in_cup": {
-   "bodies": [],
+   "needs": {
+    "predicates": [
+     "grasp",
+     "inside",
+     "pre_grasp",
+     "pre_inside",
+     "release",
+     "see"
+    ],
+    "hands": 1
+   },
+   "lineage": null,
+   "tunings": [],
    "results": [],
-   "best": [],
-   "card_lines": 36
+   "best": []
+  }
+ },
+ "matrix": {
+  "clean_the_room": {
+   "cable": {
+    "state": "scored",
+    "done": 29,
+    "of": 36,
+    "world": "sim:bedroom",
+    "result": "tasks/clean_the_room/results/2026-11-10_2ed39e20ae72_c1511f1b78dd_bedroom_s0.json"
+   },
+   "arm": {
+    "state": "coming"
+   },
+   "dog": {
+    "state": "coming"
+   },
+   "drone": {
+    "state": "coming"
+   },
+   "human": {
+    "state": "coming"
+   }
+  },
+  "fold_clothes": {
+   "cable": {
+    "state": "gap",
+    "missing": [
+     "2 hands"
+    ]
+   },
+   "arm": {
+    "state": "coming"
+   },
+   "dog": {
+    "state": "coming"
+   },
+   "drone": {
+    "state": "coming"
+   },
+   "human": {
+    "state": "coming"
+   }
+  },
+  "pen_in_cup": {
+   "cable": {
+    "state": "runs"
+   },
+   "arm": {
+    "state": "coming"
+   },
+   "dog": {
+    "state": "coming"
+   },
+   "drone": {
+    "state": "coming"
+   },
+   "human": {
+    "state": "coming"
+   }
+  }
+ },
+ "skills": {
+  "folded": {
+   "cards": [
+    "fold_clothes"
+   ],
+   "bodies": []
+  },
+  "grasp": {
+   "cards": [
+    "clean_the_room",
+    "pen_in_cup"
+   ],
+   "bodies": [
+    "cable"
+   ]
+  },
+  "inside": {
+   "cards": [
+    "clean_the_room",
+    "pen_in_cup"
+   ],
+   "bodies": [
+    "cable"
+   ]
+  },
+  "laid_flat": {
+   "cards": [
+    "fold_clothes"
+   ],
+   "bodies": []
+  },
+  "on_top": {
+   "cards": [
+    "fold_clothes"
+   ],
+   "bodies": []
+  },
+  "pre_grasp": {
+   "cards": [
+    "clean_the_room",
+    "pen_in_cup"
+   ],
+   "bodies": [
+    "cable"
+   ]
+  },
+  "pre_inside": {
+   "cards": [
+    "clean_the_room",
+    "pen_in_cup"
+   ],
+   "bodies": [
+    "cable"
+   ]
+  },
+  "release": {
+   "cards": [
+    "clean_the_room",
+    "fold_clothes",
+    "pen_in_cup"
+   ],
+   "bodies": [
+    "cable"
+   ]
+  },
+  "see": {
+   "cards": [
+    "clean_the_room",
+    "fold_clothes",
+    "pen_in_cup"
+   ],
+   "bodies": [
+    "cable"
+   ]
+  },
+  "support_both": {
+   "cards": [
+    "fold_clothes"
+   ],
+   "bodies": []
   }
  }
 }

bodies/arm.yaml

@@ -0,0 +1,10 @@
+body: arm
+pilot: MacroSwan/armpilot
+status: coming
+carrier: desk arm (SO-101, 6 servos)
+machines: [SO-101 (LeRobot)]
+rigs:
+  - {rig: so101, hands: 1, hand: SO-101 pinch, status: private}
+  - {rig: so101_duo, hands: 2, hand: two SO-101s facing each other, status: private}
+predicates: []          # filled from armpilot's card runner at release
+note: "the only pilot with real-robot runs (pen in cup on a real SO-101): the first to release after cable"

bodies/cable.yaml

@@ -0,0 +1,13 @@
+# One file per body (carrier). The board reads it to fill the task x body and skill x body matrices.
+# predicates: the goal predicates this body can run today (a card whose goals are all here runs on it).
+body: cable
+pilot: MacroSwan/cablepilot
+status: open
+carrier: cable-driven parallel robot (4 lines, a gantry, a swinging pole)
+machines: [Stringman (Neufangled)]
+rigs:
+  - {rig: stringman, hands: 1, hand: Stringman two-finger gripper, status: open}
+  - {rig: duo_rig, hands: 2, hand: two SO-101 arms on a turntable plate, status: private}
+predicates: [see, pre_grasp, grasp, pre_inside, release, inside, avoid]
+predicates_source: "cablepilot/cardrun.py CABLE_SKILLS"
+model: {params: 28401, train: "11 min, laptop CPU, task-free sim motion in 12k random rooms"}

bodies/dog.yaml

@@ -0,0 +1,9 @@
+body: dog
+pilot: MacroSwan/dogpilot
+status: coming
+carrier: quadruped (Unitree Go2)
+machines: [Unitree Go2 (sim)]
+rigs:
+  - {rig: go2, hands: 0, hand: none, status: private}
+predicates: []
+note: "MPPI over a learned motion model: duck under and jump over bars"

bodies/drone.yaml

@@ -0,0 +1,10 @@
+body: drone
+pilot: MacroSwan/dronepilot
+status: coming
+carrier: quadrotor (and fixed wing)
+machines: [quadrotor (sim)]
+rigs:
+  - {rig: quad, hands: 0, hand: none, status: private}
+  - {rig: quad_pinch, hands: 1, hand: SO-101 pinch under the frame, status: private}
+predicates: []
+note: "SkyJEPA world model; public precursors on huggingface.co/Ethgar (skyjepa, skyfull datasets)"

bodies/human.yaml

@@ -0,0 +1,9 @@
+body: human
+pilot: MacroSwan/humanpilot
+status: coming
+carrier: humanoid (Unitree G1)
+machines: [Unitree G1 (sim)]
+rigs:
+  - {rig: g1, hands: 2, hand: G1 hands, status: private}
+predicates: []
+note: "licence to settle before release: the motion prior is trained on LAFAN1 (CC BY-NC-ND)"

scripts/board.py

@@ -1,12 +1,25 @@
-"""Rebuild board.json from every tasks/*/results/*.json: the best result per (task, body, world), each task's results
-ranked, and its lineage edges. Run after merging a PR:  python scripts/board.py  (stdlib only)."""
+"""Rebuild board.json from the dataset: bodies/*.yaml, tasks/*/card.yaml, tasks/*/results/*.json.
+
+    python scripts/board.py          (needs pyyaml)
+
+board.json holds:
+  bodies        the body registry (carrier, rigs with their hand count, status, the goal predicates it runs)
+  tasks         per task: its results ranked, the best per (body, world) on the reference simulator
+  matrix        task x body: one cell per pair, the best score if any, else whether the body could run it
+                (runs: unscored / missing: the predicates it lacks / needs 2 hands / coming)
+  skills        predicate x body: which body runs which goal predicate, and how many cards use each predicate
+Only results on the reference simulator compete for best (see cablepilot.cardrun.REFERENCE_SIM).
+"""
 from __future__ import annotations
 
 import json
 from datetime import datetime, timezone
 from pathlib import Path
 
+import yaml
+
 ROOT = Path(__file__).resolve().parents[1]
+TWO_HANDS = {"left_hand", "right_hand", "other_hand"}
 
 
 def rank_key(r: dict):
@@ -14,36 +27,86 @@ def rank_key(r: dict):
     return (-s["done_frac"], s.get("furniture_contact_ticks", 0), s.get("s_per_item") or 1e9)
 
 
+def card_needs(card: dict) -> dict:
+    """The goal predicates a card's stages and done test use, and how many hands it needs."""
+    preds = set()
+    for st in card.get("stages") or []:
+        for g in st.get("goals") or []:
+            preds |= set(g) - {"tol"}
+    if card.get("done"):
+        preds |= set(card["done"]) - {"tol"}
+    hands = 2 if TWO_HANDS & set(card.get("roles") or []) else 1
+    return {"predicates": sorted(preds), "hands": hands}
+
+
+def load_results(task_dir: Path) -> list[dict]:
+    out = []
+    for f in sorted((task_dir / "results").glob("*.json")):
+        r = json.loads(f.read_text())
+        if r.get("format") != "pilot-result/1":
+            continue
+        env = r.get("env") or {}
+        out.append({"id": f.stem, "body": r["body"], "world": r["world"], "seed": r["seed"], "episodes": r["episodes"],
+                    "score": r["score"], "compute": r["compute"], "card_sha": r["card_sha"],
+                    "tuning_sha": r.get("tuning_sha"), "lineage": r.get("lineage"), "by": r["by"], "date": r["date"],
+                    "sim": env.get("mujoco"), "reference_sim": bool(env.get("reference_sim")),
+                    "result": f"tasks/{task_dir.name}/results/{f.name}",
+                    "media": f"tasks/{task_dir.name}/media/{f.stem}.mp4"
+                    if (task_dir / "media" / f"{f.stem}.mp4").exists() else None})
+    return sorted(out, key=rank_key)
+
+
+def cell(task: dict, body: dict) -> dict:
+    best = [r for r in task["best"] if r["body"] == body["body"]]
+    if best:
+        b = best[0]
+        return {"state": "scored", "done": b["score"]["done"], "of": b["score"]["of"], "world": b["world"],
+                "result": b["result"]}
+    if body["status"] != "open":
+        return {"state": "coming"}
+    max_hands = max((rg["hands"] for rg in body.get("rigs", []) if rg.get("status") == "open"), default=0)
+    if task["needs"]["hands"] > max_hands:
+        return {"state": "gap", "missing": [f"{task['needs']['hands']} hands"]}
+    missing = [p for p in task["needs"]["predicates"] if p not in set(body.get("predicates") or [])]
+    return {"state": "gap", "missing": missing} if missing else {"state": "runs"}
+
+
 def main():
+    bodies = [yaml.safe_load(p.read_text()) for p in sorted((ROOT / "bodies").glob("*.yaml"))]
+    order = {"open": 0, "coming": 1}
+    bodies.sort(key=lambda b: (order.get(b["status"], 2), b["body"]))
     tasks = {}
     for task_dir in sorted((ROOT / "tasks").iterdir()):
-        if not task_dir.is_dir():
+        if not (task_dir / "card.yaml").exists():
             continue
-        results = []
-        for f in sorted((task_dir / "results").glob("*.json")):
-            r = json.loads(f.read_text())
-            if r.get("format") != "pilot-result/1":
-                continue
-            env = r.get("env") or {}
-            results.append({"id": f.stem, "sim": env.get("mujoco"), "reference_sim": bool(env.get("reference_sim")), "body": r["body"], "world": r["world"], "seed": r["seed"],
-                            "episodes": r["episodes"], "score": r["score"], "compute": r["compute"],
-                            "card_sha": r["card_sha"], "tuning_sha": r.get("tuning_sha"), "lineage": r.get("lineage"),
-                            "by": r["by"], "date": r["date"],
-                            "media": f"tasks/{task_dir.name}/media/{f.stem}.mp4"
-                            if (task_dir / "media" / f"{f.stem}.mp4").exists() else None})
+        card = yaml.safe_load((task_dir / "card.yaml").read_text())
+        results = load_results(task_dir)
         best = {}
-        for r in sorted(results, key=rank_key):
-            if r["reference_sim"]:              # only results on the reference simulator compete for best
+        for r in results:
+            if r["reference_sim"]:
                 best.setdefault(f"{r['body']}|{r['world']}", r)
-        card = (task_dir / "card.yaml").read_text() if (task_dir / "card.yaml").exists() else ""
-        tunings = sorted(p.stem for p in (task_dir / "tuning").glob("*.yaml"))
-        tasks[task_dir.name] = {"bodies": tunings, "results": sorted(results, key=rank_key),
-                                "best": list(best.values()), "card_lines": card.count("\n")}
-    board = {"format": "pilot-board/1", "built": datetime.now(timezone.utc).isoformat(timespec="seconds"), "tasks": tasks}
-    (ROOT / "board.json").write_text(json.dumps(board, indent=1))
+        tasks[task_dir.name] = {"needs": card_needs(card), "lineage": card.get("lineage"),
+                                "tunings": sorted(p.stem for p in (task_dir / "tuning").glob("*.yaml")),
+                                "results": results, "best": list(best.values())}
+    matrix = {t: {b["body"]: cell(v, b) for b in bodies} for t, v in tasks.items()}
+    used = {}
     for t, v in tasks.items():
-        b = ", ".join(f"{r['body']} {r['world']}: {r['score']['done']}/{r['score']['of']}" for r in v["best"]) or "no results"
-        print(f"{t:<20} {b}")
+        for p in v["needs"]["predicates"]:
+            used.setdefault(p, []).append(t)
+    skills = {p: {"cards": sorted(ts), "bodies": [b["body"] for b in bodies if p in set(b.get("predicates") or [])]}
+              for p, ts in sorted(used.items())}
+    board = {"format": "pilot-board/2", "built": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+             "bodies": bodies, "tasks": tasks, "matrix": matrix, "skills": skills}
+    (ROOT / "board.json").write_text(json.dumps(board, indent=1))
+    w = max(len(t) for t in tasks) + 2
+    print(" " * w + "".join(f"{b['body']:<14}" for b in bodies))
+    for t, row in matrix.items():
+        txt = []
+        for b in bodies:
+            c = row[b["body"]]
+            txt.append({"scored": lambda: f"{c['done']}/{c['of']}", "coming": lambda: "coming", "runs": lambda: "runs",
+                        "gap": lambda: "-" + ",".join(c["missing"])}[c["state"]]()[:13])
+        print(f"{t:<{w}}" + "".join(f"{x:<14}" for x in txt))
 
 
 if __name__ == "__main__":

tasks/fold_clothes/card.yaml

@@ -0,0 +1,54 @@
+# Fold clothes: a shirt laid flat on the table, sleeves in, folded in half, set on the folded pile. The common sense of
+# the task and nothing else: no fold line is written, the eyes see the shirt's outline and the folds count. Written
+# 2026-10-20 (lab day, track 5); cloth is outside today's vocabulary (armpilot's cards README says so), this card says
+# what it would take.
+task: fold_clothes
+lineage: {parent: "worldpilot:cards/home/fold_clothes.yaml", by: "Ethgar", why: "the first two-hand challenge on the board, unchanged"}
+vocabulary: home
+source: {dataset: null, episode: null, frames: null, model: null, note: "from the description 'fold the clothes'; no video read. One shirt stands for every piece in the basket (`each`). Missing: parts `corner` / `edge`; laid_flat(thing, part); folded(object) with tol folds_n (holds: the seen footprint shrank by a fold per count and the layers stay put). support_both is a LibraryGap today. Fails at load on the part `corner`"}
+roles: [hand, left_hand, right_hand, head_camera]
+objects:
+  shirt: {kind: shirt, role: held, shape: flat, movable: true}
+  table: {kind: table, role: fixture, shape: block, movable: false}
+  pile: {kind: folded_pile, role: site, shape: flat, movable: false, note: "the clothes already folded; the table's free corner when there are none"}
+parts:
+  shirt.corner: {of: shirt, part: corner, note: "the shoulders when it is spread, the hem's corners when it is folded"}
+  shirt.edge: {of: shirt, part: edge}
+  table.top: {of: table, part: top}
+  pile.top: {of: pile, part: top}
+stages:
+  - name: observe
+    goals: [{see: [head_camera, shirt]}, {see: [head_camera, table]}]
+  - name: take_shoulders                # two hands on two corners, shaken out in the air
+    goals: [{support_both: [left_hand, right_hand, shirt]}]
+  - name: spread                        # laid on the table front down, flat
+    goals: [{laid_flat: [shirt, table.top]}]
+    invariants: [{support_both: [left_hand, right_hand, shirt]}]
+  - name: let_go
+    goals: [{release: [left_hand, shirt]}, {release: [right_hand, shirt]}]
+    invariants: [{laid_flat: [shirt, table.top]}]
+  - name: sides_in                      # each side with its sleeve over the back: two folds
+    goals: [{folded: [shirt], tol: {folds_n: 2}}]
+    invariants: [{on_top: [shirt, table.top]}]
+  - name: in_half                       # hem to collar, both hands on the hem's corners
+    goals: [{folded: [shirt], tol: {folds_n: 3}}]
+    invariants: [{on_top: [shirt, table.top]}]
+  - name: lift_folded
+    goals: [{support_both: [left_hand, right_hand, shirt]}]
+    invariants: [{folded: [shirt], tol: {folds_n: 3}}]
+  - name: onto_pile
+    goals: [{on_top: [shirt, pile.top]}]
+    invariants: [{support_both: [left_hand, right_hand, shirt]}, {folded: [shirt], tol: {folds_n: 3}}]
+  - name: release
+    goals: [{release: [left_hand, shirt]}, {release: [right_hand, shirt]}]
+fallbacks:
+  - {when: {broken: {see: [head_camera, shirt]}}, go: observe}
+  - {when: {broken: {laid_flat: [shirt, table.top]}}, go: take_shoulders}
+  - {when: {broken: {folded: [shirt], tol: {folds_n: 3}}}, go: take_shoulders}    # unfolded on the way: start again
+  - {when: {broken: {support_both: [left_hand, right_hand, shirt]}}, go: take_shoulders}
+done: {folded: [shirt], tol: {folds_n: 3}}
+validation: {sim: null}
+costs:
+  note: "GUESS, 2026-10-21 (track 0): weights multiply each body's own tuned term weights. A person is never touched (10x; 20x for the drone, whose props cut). A drone that grazes furniture loses lift (3x); a balancing base that bumps one can fall (2x); the cable robot's platform hangs over everything and only its arms meet things (1x)."
+  default: {}
+  per_body: {}