Submitted variant R: StackTwoBlocks hybrid_s2b4 (HOLD_T 1, RISE 0.15) + PickBook timing; official run 0.9866

README.md

@@ -20,7 +20,7 @@ datasets:
 # LocalModels / ACT-bimanual
 
 Entry **ACT-bimanual** by team **LocalModels** (Saleh Alsharideh, Independent) to the CoRL 2026 RoboEval Diagnostic
-Bimanual Challenge. **Official score 0.9861**, 399 of 400 episodes successful.
+Bimanual Challenge. **Official score 0.9866**, 399 of 400 episodes successful.
 
 Seven tasks run hand-designed RGB-D controllers (no learned weights); LiftPot runs an Action Chunking Transformer (ACT)
 trained on the demonstrations and fine-tuned in simulation with GRPO. Code, report and explainer videos:
@@ -50,14 +50,14 @@ python -m roboeval.challenge.evaluate --submission submission --workers W --gpus
 | Task | Policy | Successes | Score |
 |---|---|---|---|
 | CubeHandover | controller | 50 | 1.000 |
-| LiftPot | ACT | 50 | 0.999 |
+| LiftPot | ACT | 50 | 0.997 |
 | LiftTray | controller | 50 | 1.000 |
 | PackBox | controller | 49 | 0.954 |
-| PickSingleBookFromTable | controller | 50 | 0.987 |
+| PickSingleBookFromTable | controller | 50 | 0.988 |
 | RotateValve | controller | 50 | 1.000 |
 | StackSingleBookShelf | controller | 50 | 1.000 |
-| StackTwoBlocks | controller | 50 | 0.948 |
-| **Suite** | | **399 / 400** | **0.9861** |
+| StackTwoBlocks | controller | 50 | 0.953 |
+| **Suite** | | **399 / 400** | **0.9866** |
 
 Training data and every use of simulator state: the report, Sec. 3. The files here equal the submitted ones except
 three edits that do not change behaviour (no contact e-mail in `metadata.yaml`, local paths shortened in the LiftPot

SHA1SUMS.txt

@@ -9,10 +9,10 @@ a6dd75ccc8e6a27c80d6991922a7e22115f7495d  submission/checkpoint/LiftPot/policy_p
 cb6034b3f50ca44742f3bf2ac5967d64f605f999  submission/checkpoint/LiftPot/train_config.json
 6b0ae04424367b8f76c82975b28537e5649f2c5c  submission/checkpoint/LiftTray/hybrid.json
 d1ff4f07d748ae3e1fb966861e3226c95360e23e  submission/checkpoint/PackBox/hybrid.json
-45d4627c1f0e46c897edff5e7e625cb2d4457962  submission/checkpoint/PickSingleBookFromTable/hybrid.json
+919a76fb7988ab5d8f66b00e59ff15bb3a049b42  submission/checkpoint/PickSingleBookFromTable/hybrid.json
 dff829d7ba30c5b42bd87ebebe28aa6d26351432  submission/checkpoint/RotateValve/hybrid.json
 2fb4f07db36ad5c35072bf7d0b35dd7a7509300e  submission/checkpoint/StackSingleBookShelf/hybrid.json
-85d64d4e492c33cab63ddc31cfb3fab175ff0362  submission/checkpoint/StackTwoBlocks/hybrid.json
+fcc61e40288e3963c3cdb3ca18b3c803321fda41  submission/checkpoint/StackTwoBlocks/hybrid.json
 93f8e14655c81b4ee0cbd286cb26901dd32ec9e0  submission/metadata.yaml
 2125cc890e4f0935eca511c128ae4e50b671b5b7  submission/policy/hybrid_ch.py
 e79acc904c4d8fb9d4528ad013234fcb5efef526  submission/policy/hybrid_lt.py
@@ -21,13 +21,14 @@ fd0bc2f43f124d001be0a9b3f2653dde971a01ba  submission/policy/hybrid_pk.py
 55ccea8e25b095cad39a955a3b11cda3f3073bd3  submission/policy/hybrid_rv.py
 ddbf36b8fa6d217497e5f5a297cbd93c8cbde4b1  submission/policy/hybrid_s2b.py
 ec9cc4f4c8fdc5ab029800ebda66bfaee08bb15d  submission/policy/hybrid_s2b3.py
+299a9121abcd6b327e69b69022f1e6d44b6c732b  submission/policy/hybrid_s2b4.py
 04a7a59964da57c9f23186468e15007bcd6dd9ed  submission/policy/hybrid_ss.py
 7f7edc19439f493753dc033117fcbe4144a6219d  submission/policy/inference.py
 d502beeb4fef26e486a53f7fc7eb13134f314eac  submission/policy/lt_perc.py
 a9ec953d09433a66fdd96699004fe1e287c99130  submission/policy/modeling_act.py
 659d71814c120324da315907a2dea13dc7f86e68  submission/policy/pk_ik.py
 fc873fe44fe2a4b25eb085f4b633d1190a6f1f62  submission/policy/pk_perception.py
-933ab94fb12525df5a171c682160409f3a0794e0  submission/policy/policy.py
+8f52ff609e77c15abb2809d1c9bdf7cb213a1dab  submission/policy/policy.py
 d80819495655d02d18211a39509f0d51ca982cd1  submission/policy/requirements.txt
 0ebd43e61f2306de911a89156c35d28ef6220d70  submission/policy/rod_perc.py
 42fe921dc58da0eb6b25296bd26dd0f00fe5fee1  submission/policy/rv_perception.py

official_run/results.json

@@ -122,56 +122,56 @@
             "std": 0.0
           },
           "tp": {
-            "mean": 1.0,
-            "std": 0.0
+            "mean": 0.99,
+            "std": 0.06999999999999999
           },
           "bavd": {
-            "mean": 0.2907428134024535,
-            "std": 0.0962944705689577
+            "mean": 0.29281951315243276,
+            "std": 0.09462814601254968
           },
           "bgvd": {
-            "mean": 0.010298816850591686,
-            "std": 0.004452314091633235
+            "mean": 0.010165391094207603,
+            "std": 0.0046259623922256694
           },
           "cpl": {
-            "mean": 0.6699551633231444,
-            "std": 0.0716183064311788
+            "mean": 0.6704045530620671,
+            "std": 0.07377597417639128
           },
           "ct": {
-            "mean": 2.96,
-            "std": 0.1726267650163207
+            "mean": 2.967,
+            "std": 0.1891057904983346
           },
           "ecc": {
             "mean": 0.0,
             "std": 0.0
           },
           "jpl": {
-            "mean": 4.076533994602647,
-            "std": 0.47333641780431596
+            "mean": 4.098847958860526,
+            "std": 0.5163070688299158
           },
           "mcj": {
-            "mean": 9.526656728709378,
-            "std": 1.6592578956263422
+            "mean": 9.31802731270813,
+            "std": 1.8950421588022368
           },
           "mjj": {
-            "mean": 55.416472157492855,
-            "std": 10.668620699254578
+            "mean": 54.52174808567004,
+            "std": 10.309689388763909
           },
           "opl": {
-            "mean": 2.2800774728779505,
-            "std": 0.3668582821919849
+            "mean": 2.3032091026371906,
+            "std": 0.39533000540578506
           },
           "scc": {
-            "mean": 0.02,
-            "std": 0.13999999999999999
+            "mean": 0.0,
+            "std": 0.0
           },
           "sc": {
             "mean": 0.0,
             "std": 0.0
           },
           "tl": {
-            "mean": 59.2,
-            "std": 3.4525353003264136
+            "mean": 59.34,
+            "std": 3.7821158099666907
           }
         },
         "terminations": {
@@ -266,52 +266,52 @@
             "std": 0.0
           },
           "bavd": {
-            "mean": 0.47659149680466034,
-            "std": 0.06612239480233566
+            "mean": 0.4634347306747833,
+            "std": 0.06790829309211645
           },
           "bgvd": {
-            "mean": 0.03871852373226772,
-            "std": 0.010070250904216971
+            "mean": 0.043299860935331065,
+            "std": 0.009997325279898706
           },
           "cpl": {
-            "mean": 1.393348353983685,
-            "std": 0.11070235493408716
+            "mean": 1.3696363340760127,
+            "std": 0.11070404465857603
           },
           "ct": {
-            "mean": 4.7059999999999995,
-            "std": 0.9259935204956891
+            "mean": 4.625,
+            "std": 0.9430402960637472
           },
           "ecc": {
             "mean": 0.0,
             "std": 0.0
           },
           "jpl": {
-            "mean": 5.1804237300377345,
-            "std": 0.49917056182326575
+            "mean": 5.087932775288036,
+            "std": 0.49603342150285495
           },
           "mcj": {
-            "mean": 11.365047787780853,
-            "std": 1.6817120614731258
+            "mean": 11.400662600540763,
+            "std": 1.663938478009395
           },
           "mjj": {
-            "mean": 48.364897931621236,
-            "std": 6.518151965555668
+            "mean": 48.49792000217093,
+            "std": 6.861249973787576
           },
           "opl": {
-            "mean": 1.0293364681009989,
-            "std": 0.36731588405171467
+            "mean": 1.0252549571857066,
+            "std": 0.35946942711610996
           },
           "scc": {
-            "mean": 0.06,
-            "std": 0.23748684174075835
+            "mean": 0.02,
+            "std": 0.13999999999999999
           },
           "sc": {
             "mean": 0.0,
             "std": 0.0
           },
           "tl": {
-            "mean": 94.12,
-            "std": 18.519870409913782
+            "mean": 92.5,
+            "std": 18.860805921274945
           }
         },
         "terminations": {
@@ -546,52 +546,52 @@
             "std": 0.0
           },
           "bavd": {
-            "mean": 0.8746218460586408,
-            "std": 0.18118555529842803
+            "mean": 0.9597556843993951,
+            "std": 0.25022324245165284
           },
           "bgvd": {
-            "mean": 0.2089795572862352,
-            "std": 0.037816234640574944
+            "mean": 0.21264552731291023,
+            "std": 0.03902639572426828
           },
           "cpl": {
-            "mean": 1.1386401663938843,
-            "std": 0.4402695894254054
+            "mean": 1.1374091543412113,
+            "std": 0.44072051299774695
           },
           "ct": {
-            "mean": 6.579,
-            "std": 2.364531454643816
+            "mean": 6.22,
+            "std": 2.3655866080107915
           },
           "ecc": {
             "mean": 0.0,
             "std": 0.0
           },
           "jpl": {
-            "mean": 7.037501694745319,
-            "std": 2.6676240288092647
+            "mean": 7.1145422603480055,
+            "std": 2.5897285047632086
           },
           "mcj": {
-            "mean": 3.090320483869577,
-            "std": 0.6059852680293215
+            "mean": 3.726751704228263,
+            "std": 0.6317925151914751
           },
           "mjj": {
-            "mean": 19.545081228674544,
-            "std": 5.690199966980306
+            "mean": 24.362044697427763,
+            "std": 8.632357968377242
           },
           "opl": {
-            "mean": 2.265703850679821,
-            "std": 0.8937329228062022
+            "mean": 2.344576096088616,
+            "std": 0.8547016352563385
           },
           "scc": {
             "mean": 0.0,
             "std": 0.0
           },
           "sc": {
-            "mean": 0.0,
-            "std": 0.0
+            "mean": 0.02,
+            "std": 0.13999999999999999
           },
           "tl": {
-            "mean": 131.58,
-            "std": 47.290629092876316
+            "mean": 124.4,
+            "std": 47.31173216021582
           }
         },
         "terminations": {
@@ -678,19 +678,19 @@
     "per_family": {
       "LiftPot": {
         "success": 1.0,
-        "tp": 1.0,
-        "bavd": 0.2907428134024535,
-        "bgvd": 0.010298816850591686,
-        "cpl": 0.6699551633231444,
-        "ct": 2.96,
+        "tp": 0.99,
+        "bavd": 0.29281951315243276,
+        "bgvd": 0.010165391094207603,
+        "cpl": 0.6704045530620671,
+        "ct": 2.967,
         "ecc": 0.0,
-        "jpl": 4.076533994602647,
-        "mcj": 9.526656728709378,
-        "mjj": 55.416472157492855,
-        "opl": 2.2800774728779505,
-        "scc": 0.02,
+        "jpl": 4.098847958860526,
+        "mcj": 9.31802731270813,
+        "mjj": 54.52174808567004,
+        "opl": 2.3032091026371906,
+        "scc": 0.0,
         "sc": 0.0,
-        "tl": 59.2
+        "tl": 59.34
       },
       "LiftTray": {
         "success": 1.0,
@@ -711,18 +711,18 @@
       "StackTwoBlocks": {
         "success": 1.0,
         "tp": 1.0,
-        "bavd": 0.47659149680466034,
-        "bgvd": 0.03871852373226772,
-        "cpl": 1.393348353983685,
-        "ct": 4.7059999999999995,
+        "bavd": 0.4634347306747833,
+        "bgvd": 0.043299860935331065,
+        "cpl": 1.3696363340760127,
+        "ct": 4.625,
         "ecc": 0.0,
-        "jpl": 5.1804237300377345,
-        "mcj": 11.365047787780853,
-        "mjj": 48.364897931621236,
-        "opl": 1.0293364681009989,
-        "scc": 0.06,
+        "jpl": 5.087932775288036,
+        "mcj": 11.400662600540763,
+        "mjj": 48.49792000217093,
+        "opl": 1.0252549571857066,
+        "scc": 0.02,
         "sc": 0.0,
-        "tl": 94.12
+        "tl": 92.5
       },
       "StackSingleBookShelf": {
         "success": 1.0,
@@ -775,18 +775,18 @@
       "PickSingleBookFromTable": {
         "success": 1.0,
         "tp": 1.0,
-        "bavd": 0.8746218460586408,
-        "bgvd": 0.2089795572862352,
-        "cpl": 1.1386401663938843,
-        "ct": 6.579,
+        "bavd": 0.9597556843993951,
+        "bgvd": 0.21264552731291023,
+        "cpl": 1.1374091543412113,
+        "ct": 6.22,
         "ecc": 0.0,
-        "jpl": 7.037501694745319,
-        "mcj": 3.090320483869577,
-        "mjj": 19.545081228674544,
-        "opl": 2.265703850679821,
+        "jpl": 7.1145422603480055,
+        "mcj": 3.726751704228263,
+        "mjj": 24.362044697427763,
+        "opl": 2.344576096088616,
         "scc": 0.0,
-        "sc": 0.0,
-        "tl": 131.58
+        "sc": 0.02,
+        "tl": 124.4
       },
       "RotateValve": {
         "success": 1.0,
@@ -807,36 +807,36 @@
     },
     "suite": {
       "success": 0.9975,
-      "tp": 0.9984999999999999,
-      "bavd": 0.385797970625376,
-      "bgvd": 0.05534312049866838,
-      "cpl": 1.1892187237546599,
-      "ct": 5.168875,
+      "tp": 0.99725,
+      "bavd": 0.39505469212048305,
+      "bgvd": 0.056357355682837666,
+      "cpl": 1.186157018476982,
+      "ct": 5.11475,
       "ecc": 0.615,
-      "jpl": 5.621928409623091,
-      "mcj": 6.046500063456854,
-      "mjj": 31.444098766035214,
-      "opl": 1.9007309543642936,
-      "scc": 0.01,
-      "sc": 0.0,
-      "tl": 103.3775
+      "jpl": 5.6227863565119485,
+      "mcj": 6.104427140596522,
+      "mjj": 31.951006449470228,
+      "opl": 1.9129712498958864,
+      "scc": 0.0025,
+      "sc": 0.0025,
+      "tl": 102.295
     }
   },
   "score": {
     "overall": {
-      "score": 0.9860614995491191,
-      "outcome": 0.9978,
-      "safety": 0.9862526043187881,
-      "efficiency": 0.9634561864853971,
-      "coordination": 0.9963121054446111
+      "score": 0.9865902931563009,
+      "outcome": 0.997425,
+      "safety": 0.9871775025799794,
+      "efficiency": 0.9658262433878773,
+      "coordination": 0.9978352329278946
     },
     "tasks": {
       "LiftPot": {
-        "outcome": 1.0,
-        "safety": 0.996078431372549,
+        "outcome": 0.9969999999999999,
+        "safety": 1.0,
         "efficiency": 1.0,
         "coordination": 1.0,
-        "score": 0.9988235294117648
+        "score": 0.9969999999999999
       },
       "LiftTray": {
         "outcome": 1.0,
@@ -847,10 +847,10 @@
       },
       "StackTwoBlocks": {
         "outcome": 1.0,
-        "safety": 0.9886792452830189,
-        "efficiency": 0.7719269711090793,
-        "coordination": 0.9704968435568894,
-        "score": 0.9480388521624105
+        "safety": 0.996078431372549,
+        "efficiency": 0.7805334499711347,
+        "coordination": 0.9826818634231562,
+        "score": 0.9531984057483073
       },
       "StackSingleBookShelf": {
         "outcome": 1.0,
@@ -875,10 +875,10 @@
       },
       "PickSingleBookFromTable": {
         "outcome": 1.0,
-        "safety": 1.0,
-        "efficiency": 0.9374136483938355,
+        "safety": 0.996078431372549,
+        "efficiency": 0.947767624751622,
         "coordination": 1.0,
-        "score": 0.9874827296787672
+        "score": 0.9883770543620891
       },
       "RotateValve": {
         "outcome": 1.0,
@@ -890,7 +890,7 @@
     }
   },
   "provenance": {
-    "created_utc": "2026-10-28T23:00:08+00:00",
+    "created_utc": "2026-11-02T11:29:21+00:00",
     "roboeval_version": "4.1.0",
     "roboeval_metrics_version": "0.1.0",
     "git_commit": "c8b79598c9fb9021652128020517d1847abe4c95",
@@ -915,6 +915,6 @@
         "MKL_CBWR": "COMPATIBLE"
       }
     },
-    "command": "/home/user/roboeval_orch/RoboEval/roboeval/challenge/evaluate.py --submission submission_pick22 --workers 6 --gpus 0"
+    "command": "/home/user/roboeval_orch/RoboEval/roboeval/challenge/evaluate.py --submission submission_pick22r --workers 6 --gpus 0"
   }
 }

submission/checkpoint/PickSingleBookFromTable/hybrid.json

@@ -1 +1 @@
-{"policy": "hybrid_pk", "cfg": {}}
+{"policy": "hybrid_pk", "cfg": {"t_reach": [0.5, 1.6], "t_in": 0.4}}

submission/checkpoint/StackTwoBlocks/hybrid.json

@@ -1 +1 @@
-{"policy": "hybrid_s2b3"}
+{"policy": "hybrid_s2b4", "cfg": {"HOLD_T": 1, "RISE": 0.15}}

submission/policy/hybrid_s2b4.py

@@ -0,0 +1,329 @@
+"""Hybrid StackTwoBlocks policy v4 (Oct 26 15:20) = v3 with its speeds, heights, waits and step-aside distances as constructor
+options (hybrid.json "cfg"); the defaults are v3's values, so v4 with no cfg is v3. For tuning efficiency (path length, time)
+on training seeds. v3 (Oct 24 21:00): both arms act, so the episode reaches the task's stage 2 (both blocks held
+at the same time; the scorer's task progression counts it, 30% of the outcome term) and the arms move together (the
+coordination metrics compare the two arms' velocities). Perception and kinematics as v2 (hybrid_s2b.py).
+
+Plan (from the perceived blocks at the start):
+  Mode A (the stacking arm s reaches both blocks): s picks P and stacks it on B; meanwhile the helper arm b grips B where it
+         stands, holds it until s holds P (both held: stage 2), opens, rises and goes home; s waits above until b is clear
+         and B has been seen again, then stacks.
+  Mode B (no single arm reaches both: blocks far apart on opposite sides): both arms pick their own block; b sets B down at
+         a meeting point M mid-table and goes home; s, holding P at its side meanwhile, then stacks P on B.
+Actions: 14-D end-effector deltas [dp_L dr_L | dp_R dr_R | g_L g_R] (world frame), grippers 0 open / 1 closed."""
+import numpy as np
+
+try:
+    from .hybrid_s2b import fk, locate, wrap, BASE_Y, H_GRASP, H_APPROACH, H_CARRY, VMAX, KP, RMAX, KR, NTOP_MIN, Z_TABLE
+except ImportError:
+    from hybrid_s2b import fk, locate, wrap, BASE_Y, H_GRASP, H_APPROACH, H_CARRY, VMAX, KP, RMAX, KR, NTOP_MIN, Z_TABLE
+
+REACH_A = 0.64  # Mode A if the stacking arm's pick and place both lie within this horizontal distance of its base
+H_GRASP3 = 0.110  # v2's 0.100 put the fingertip pads on the table (an environment collision for the scorer)
+VMAX_FAST = 0.016  # transit speed while > 5 cm from the target (v2: 0.012 everywhere)
+ASIDE = 0.12  # after letting go, arm b moves this far (xy) from B toward its own side
+HOME = (np.array([0.40, 0.32, 1.15]), np.array([0.40, -0.32, 1.15]))
+CLEAR_XY = 0.14  # the stacking arm waits this far (xy) from B while the other arm works there
+DEFAULTS = dict(H_APPROACH=H_APPROACH, H_CARRY=H_CARRY, H_GRASP3=H_GRASP3, VMAX=VMAX, VMAX_FAST=VMAX_FAST, FAST_R=0.05, KP=KP,
+                RMAX=RMAX, KR=KR, ASIDE=ASIDE, CLEAR_XY=CLEAR_XY, GRASP_N=10, RELEASE_N=10, RISE=H_APPROACH, HOLD_T=3)
+
+
+def _reach(arm, xy):
+    return float(np.hypot(xy[0], xy[1] - BASE_Y[arm]))
+
+
+class _Arm:
+    def __init__(self, k):
+        self.k, self.phase, self.count, self.off, self.zhist, self.recov, self.hold_t = k, "idle", 0, None, [], 0, 0
+        self.aside = None
+
+
+class HybridS2B4:
+    carry_queue = False  # the bundle's policy.py resets every episode
+
+    def __init__(self, log=False, **cfg):
+        bad = set(cfg) - set(DEFAULTS)
+        assert not bad, f"unknown options {bad}"
+        self.c = {**DEFAULTS, **cfg}
+        self.log = log
+        self.reset()
+
+    def reset(self, episode=None):
+        self.t, self.mode, self.s, self.b, self.P, self.B, self.M = 0, None, None, None, None, None, None
+        self.blk = [None, None]
+        self.arms = [_Arm(0), _Arm(1)]
+        self.dirtyB = False  # B was gripped or moved by arm b: lower onto it only after a fresh estimate
+        self.b_done_t = None  # step at which arm b reached "done"
+        self.z_rest = Z_TABLE
+        self.trace = []
+
+    # -- helpers --------------------------------------------------------------------------------------------------
+    @property
+    def arm(self):
+        return self.s
+
+    @property
+    def phase(self):
+        return self.arms[self.s].phase if self.s is not None else "start"
+
+    @property
+    def recoveries(self):
+        return sum(a.recov for a in self.arms)
+
+    @property
+    def plan(self):
+        return [self.mode] if self.mode == "A" else [self.mode, self.mode]
+
+    def _holding(self, obs, k):
+        f = float(np.asarray(obs["proprioception_grippers"])[k])
+        return 0.15 < f < 0.8
+
+    def _perceive(self, obs, G, held):
+        est = locate(obs)
+        if not est:
+            return
+        if self.P in held and self.B not in held and self.arms[self.b].phase in ("home", "done"):
+            low = [e for e in est if e["z"] < Z_TABLE + 0.03 and e["ntop"] >= NTOP_MIN
+                   and not any(np.linalg.norm(g[0][:2] - e["xy"]) < 0.10 and g[0][2] < e["z"] + 0.16 for g in G)]
+            if len(low) == 1:
+                self.blk[self.B] = low[0]
+                self.dirtyB = False
+            return
+        for i in (0, 1):
+            if i in held:
+                continue
+            b = self.blk[i]
+            e = min(est, key=lambda e: np.linalg.norm(e["xy"] - b["xy"]))
+            if np.linalg.norm(e["xy"] - b["xy"]) > 0.04 or e["ntop"] < NTOP_MIN:
+                continue
+            if any(np.linalg.norm(g[0][:2] - b["xy"]) < 0.10 and g[0][2] < b["z"] + 0.16 for g in G):
+                continue
+            self.blk[i] = e
+            if i == self.B and self.dirtyB and self.arms[self.b].phase in ("home", "done"):
+                self.dirtyB = False
+
+    def _plan(self, G):
+        best = None
+        for s in (0, 1):
+            for P in (0, 1):
+                B = 1 - P
+                if _reach(s, self.blk[P]["xy"]) > REACH_A or _reach(s, self.blk[B]["xy"]) > REACH_A:
+                    continue
+                cost = np.linalg.norm(G[s][0][:2] - self.blk[P]["xy"]) + np.linalg.norm(self.blk[P]["xy"] - self.blk[B]["xy"]) \
+                    + 0.5 * np.linalg.norm(G[1 - s][0][:2] - self.blk[B]["xy"])
+                if best is None or cost < best[0]:
+                    best = (cost, s, P, B)
+        if best is not None:
+            _, self.s, self.P, self.B = best
+            self.mode = "A"
+        else:
+            own = [int(np.argmin([_reach(k, self.blk[i]["xy"]) for k in (0, 1)])) for i in (0, 1)]
+            if own[0] == own[1]:
+                own[1] = 1 - own[0]
+            # the stacking arm: the one nearer its own block (it waits holding it)
+            P = int(np.argmin([np.linalg.norm(G[own[i]][0][:2] - self.blk[i]["xy"]) for i in (0, 1)]))
+            self.P, self.B, self.s = P, 1 - P, own[P]
+            self.mode = "B"
+            bx = float(np.clip(self.blk[self.B]["xy"][0], 0.45, 0.55))
+            My = BASE_Y[self.s] + np.sign(self.blk[self.B]["xy"][1] - BASE_Y[self.s]) * 0.32
+            self.M = np.array([bx, My])
+        self.b = 1 - self.s
+        if self.mode == "A" and np.linalg.norm(self.blk[self.P]["xy"] - self.blk[self.B]["xy"]) < 0.12:
+            self.arms[self.b].phase = "late"  # blocks close together: grip B only once P is lifted out of the way
+        else:
+            self.arms[self.b].phase = "approach"
+        self.arms[self.s].phase = "approach"
+
+    # -- one arm's step -------------------------------------------------------------------------------------------
+    def _pick(self, A, gp, gy, gR, i, holding, nxt):
+        """approach/descend/grasp block i; returns (target, yaw_ref, grip); on a held grasp sets A.phase = nxt"""
+        X = self.blk[i]
+        pp, py = np.r_[X["xy"], X["z"]], X["yaw"]
+        grip = 0.0
+        if A.phase == "approach":
+            target, yaw_ref = np.r_[pp[:2], pp[2] + self.c["H_APPROACH"]], py
+            if np.linalg.norm(target - gp) < 0.012 and abs(wrap(py - gy, np.pi / 2)) < np.radians(6):
+                A.phase = "descend"
+        elif A.phase == "descend":
+            target, yaw_ref = np.r_[pp[:2], pp[2] + self.c["H_GRASP3"]], py
+            if abs(wrap(py - gy, np.pi / 2)) > np.radians(12) and gp[2] < pp[2] + self.c["H_GRASP3"] + 0.02:
+                A.phase = "approach"
+            elif abs(gp[2] - target[2]) < 0.006 and np.linalg.norm(gp[:2] - pp[:2]) < 0.01:
+                A.phase, A.count = "grasp", 0
+        elif A.phase == "grasp":
+            target, yaw_ref, grip = gp, None, 1.0
+            A.count += 1
+            if A.count >= self.c["GRASP_N"]:
+                if holding:
+                    rel = gR.T @ (pp - gp)
+                    rel[1] = 0.0  # the fingers centre the block along the gripper's y axis
+                    A.off = gR @ rel
+                    A.phase, A.count = nxt, 0
+                else:
+                    A.recov += 1
+                    A.phase, A.count = "reopen", 0
+        else:  # reopen: open, rise, re-approach
+            target, yaw_ref = np.r_[gp[:2], pp[2] + self.c["H_APPROACH"]], None
+            A.count += 1
+            if A.count >= 6 and gp[2] > pp[2] + self.c["H_APPROACH"] - 0.03:
+                A.phase = "approach"
+        return target, yaw_ref, grip
+
+    def _place(self, A, gp, pp, dest_xy, z_place, nxt):
+        """carry the held block over dest_xy at carry height, lower to z_place, open; then A.phase = nxt"""
+        grip = 1.0
+        if A.phase == "carry":
+            target = np.r_[gp[:2] + (dest_xy - pp[:2]), Z_TABLE + self.c["H_CARRY"]]
+            if np.linalg.norm(pp[:2] - dest_xy) < 0.008:
+                A.phase, A.zhist = "lower", []
+        elif A.phase == "lower":
+            target = np.r_[gp[:2] + (dest_xy - pp[:2]), gp[2] - (pp[2] - z_place)]
+            A.zhist.append(gp[2])
+            blocked = len(A.zhist) > 6 and A.zhist[-7] - gp[2] < 0.002 and pp[2] < z_place + 0.03
+            if pp[2] < z_place + 0.004 or blocked:
+                A.phase, A.count = "release", 0
+        else:  # release
+            target, grip = gp, 0.0
+            A.count += 1
+            if A.count >= self.c["RELEASE_N"]:
+                A.phase, A.count = nxt, 0
+        return target, None, grip
+
+    def _go_home(self, A, gp, base_z):
+        """after letting go of B: straight up until the fingers clear it, then step aside toward this arm's side"""
+        Bxy = self.blk[self.B]["xy"]
+        if A.phase == "rise":
+            target = np.r_[gp[:2], base_z + self.c["RISE"]]
+            if gp[2] > base_z + self.c["RISE"] - 0.01:
+                A.phase = "home"
+                A.aside = np.r_[Bxy[0] - 0.03, Bxy[1] + np.sign(BASE_Y[A.k]) * self.c["ASIDE"], base_z + self.c["RISE"]]
+        elif A.phase == "home":
+            target = A.aside
+            if np.linalg.norm(gp[:2] - Bxy) > self.c["ASIDE"] - 0.01:
+                A.phase = "done"
+        else:  # done
+            target = gp
+        return target, None, 0.0
+
+    # -- policy -------------------------------------------------------------------------------------------------------
+    def act(self, obs):
+        self.t += 1
+        a = np.zeros(14, np.float32)
+        G = [fk(np.asarray(obs["proprioception"], np.float64)[9 * k:9 * k + 7], k) for k in (0, 1)]
+        if self.s is None:  # start: no-op; perceive and plan
+            est = locate(obs)
+            if len(est) < 2:
+                est = (est * 2)[:2] if est else [{"xy": np.array([0.5, 0.1]), "z": Z_TABLE, "yaw": 0.0, "ntop": 0, "n": 0},
+                                                 {"xy": np.array([0.5, -0.1]), "z": Z_TABLE, "yaw": 0.0, "ntop": 0, "n": 0}]
+            self.blk = list(est)
+            self._plan(G)
+            return a
+        S, Bm = self.arms[self.s], self.arms[self.b]
+        hold_s, hold_b = self._holding(obs, self.s), self._holding(obs, self.b)
+        held = set()
+        if S.off is not None:
+            held.add(self.P)
+        if Bm.off is not None or Bm.phase in ("grasp", "hold"):
+            held.add(self.B)
+        self._perceive(obs, G, held)
+
+        # ---- arm b: helper (A) or mover (B) ----
+        gp, gy, gR = G[self.b]
+        if Bm.phase == "late":  # wait (still) until the stacking arm has lifted P clear of the table
+            if S.phase in ("wait", "carry") or (S.phase == "lift" and G[self.s][0][2] > Z_TABLE + self.c["H_CARRY"] - 0.06):
+                Bm.phase = "approach"
+            elif self.t > 150:
+                Bm.phase = "done"
+        if Bm.phase == "late":
+            tb = (gp, None, 0.0)
+        elif Bm.phase in ("approach", "descend", "grasp", "reopen"):
+            if Bm.phase == "grasp":
+                self.dirtyB = True
+            nxt = "hold" if self.mode == "A" else "lift"
+            tb = self._pick(Bm, gp, gy, gR, self.B, hold_b, nxt)
+            if self.mode == "A" and Bm.phase == "reopen":  # a helper miss: give up the helper role
+                Bm.phase, Bm.count = "release", 0
+        elif Bm.phase == "hold":  # helper: keep B gripped until the stacking arm holds P (both held)
+            tb = (gp, None, 1.0)
+            Bm.count += 1
+            if (S.off is not None and hold_s and S.phase in ("lift", "wait", "carry")) or Bm.count > 60:
+                Bm.hold_t += 1
+                if Bm.hold_t >= self.c["HOLD_T"] or Bm.count > 60:
+                    Bm.phase, Bm.count = "release", 0
+        elif Bm.phase == "release" and self.mode == "A":
+            tb = (gp, None, 0.0)
+            Bm.count += 1
+            f = float(np.asarray(obs["proprioception_grippers"])[self.b])
+            if (Bm.count >= 5 and f > 0.85) or Bm.count >= 15:
+                Bm.phase, Bm.off = "rise", None
+        elif Bm.phase == "lift":  # mover
+            tb = (np.r_[gp[:2], Z_TABLE + self.c["H_CARRY"]], None, 1.0)
+            if gp[2] > Z_TABLE + self.c["H_CARRY"] - 0.012:
+                Bm.phase = "carry"
+            if not hold_b:
+                Bm.recov += 1; Bm.off = None; Bm.phase, Bm.count = "reopen", 0
+        elif Bm.phase in ("carry", "lower", "release"):  # mover: set B down at M
+            ppb = gp + Bm.off
+            if Bm.phase != "release" and not hold_b:
+                Bm.recov += 1; Bm.off = None; Bm.phase, Bm.count = "reopen", 0
+                tb = (gp, None, 0.0)
+            else:
+                was = Bm.phase
+                tb = self._place(Bm, gp, ppb, self.M, self.z_rest + 0.002, "rise")
+                if was == "release" and Bm.phase == "rise":
+                    self.blk[self.B] = {"xy": ppb[:2].copy(), "z": Z_TABLE, "yaw": 0.0, "ntop": 0, "n": 0}
+                    Bm.off = None
+                    self.dirtyB = True
+        else:  # rise / home / done
+            tb = self._go_home(Bm, gp, Z_TABLE)
+        if Bm.phase == "done" and self.b_done_t is None:
+            self.b_done_t = self.t
+        self._write(a, self.b, gp, gy, *tb)
+
+        # ---- arm s: stack P on B ----
+        gp, gy, gR = G[self.s]
+        Bx = self.blk[self.B]
+        if S.phase in ("approach", "descend", "grasp", "reopen"):
+            ts = self._pick(S, gp, gy, gR, self.P, hold_s, "lift")
+            if S.phase == "lift":
+                self.z_rest = float(self.blk[self.P]["z"])
+        elif S.phase in ("lift", "wait", "carry", "lower") and not hold_s:
+            S.recov += 1; S.off = None; S.phase, S.count = "reopen", 0
+            ts = (gp, None, 0.0)
+        elif S.phase == "lift":
+            ts = (np.r_[gp[:2], Z_TABLE + self.c["H_CARRY"]], None, 1.0)
+            if gp[2] > Z_TABLE + self.c["H_CARRY"] - 0.012:
+                S.phase = "wait"
+        elif S.phase == "wait":  # until arm b is out of the way and B has been seen again
+            pp = gp + S.off
+            if self.mode == "A":  # B stays put: wait CLEAR_XY from it on this side (back off if closer)
+                d = pp[:2] - Bx["xy"]
+                n = np.linalg.norm(d)
+                stop = Bx["xy"] + d / max(n, 1e-6) * self.c["CLEAR_XY"]
+            else:  # B is being moved to M by arm b: hold P on this arm's own side
+                stop = np.array([pp[0], BASE_Y[self.s] * 0.5]) if abs(pp[1] - BASE_Y[self.s]) > 0.15 else pp[:2]
+            ts = (np.r_[gp[:2] + (stop - pp[:2]), Z_TABLE + self.c["H_CARRY"]], None, 1.0)
+            far = np.linalg.norm(G[self.b][0][:2] - Bx["xy"]) > self.c["ASIDE"] - 0.02
+            ready = Bm.phase in ("home", "done") and far and not self.dirtyB
+            if ready or (self.b_done_t is not None and self.t - self.b_done_t > 20):
+                S.phase = "carry"
+        elif S.phase in ("carry", "lower", "release"):
+            pp = gp + S.off
+            ts = self._place(S, gp, pp, Bx["xy"], Bx["z"] + 0.042, "retreat")
+        else:  # retreat
+            ts = (np.r_[gp[:2], Z_TABLE + self.c["H_CARRY"]], None, 0.0)
+        self._write(a, self.s, gp, gy, *ts)
+        if self.log:
+            self.trace.append((self.t, self.mode, S.phase, Bm.phase, G[self.s][0].round(3).tolist(), G[self.b][0].round(3).tolist(),
+                               int(hold_s), int(hold_b)))
+        return a
+
+    def _write(self, a, k, gp, gy, target, yaw_ref, grip):
+        off = 6 * k
+        e = np.asarray(target) - gp
+        c = self.c
+        vmax = c["VMAX_FAST"] if np.linalg.norm(e) > c["FAST_R"] else c["VMAX"]
+        a[off:off + 3] = np.clip(c["KP"] * e, -vmax, vmax)
+        if yaw_ref is not None and np.isfinite(yaw_ref):
+            a[off + 5] = np.clip(c["KR"] * wrap(yaw_ref - gy, np.pi / 2), -c["RMAX"], c["RMAX"])
+        a[12 + k] = grip

submission/policy/policy.py

@@ -23,6 +23,7 @@ except ImportError:
     from inference import ACTInference  # harness context: policy/ is on sys.path
 try:  # hand-designed controllers (classical RGB-D perception + scripted control), selected by checkpoint/<family>/hybrid.json
     from .hybrid_s2b3 import HybridS2B3
+    from .hybrid_s2b4 import HybridS2B4
     from .hybrid_rv import HybridRV
     from .hybrid_pb import HybridPB
     from .hybrid_ch import HybridCH
@@ -31,13 +32,14 @@ try:  # hand-designed controllers (classical RGB-D perception + scripted control
     from .hybrid_ss import HybridSS
 except ImportError:
     from hybrid_s2b3 import HybridS2B3
+    from hybrid_s2b4 import HybridS2B4
     from hybrid_rv import HybridRV
     from hybrid_pb import HybridPB
     from hybrid_ch import HybridCH
     from hybrid_lt import HybridLT
     from hybrid_pk import HybridPK
     from hybrid_ss import HybridSS
-HYBRIDS = {"hybrid_s2b3": HybridS2B3, "hybrid_rv": HybridRV, "hybrid_pb": HybridPB, "hybrid_ch": HybridCH, "hybrid_lt": HybridLT, "hybrid_pk": HybridPK, "hybrid_ss": HybridSS}
+HYBRIDS = {"hybrid_s2b3": HybridS2B3, "hybrid_s2b4": HybridS2B4, "hybrid_rv": HybridRV, "hybrid_pb": HybridPB, "hybrid_ch": HybridCH, "hybrid_lt": HybridLT, "hybrid_pk": HybridPK, "hybrid_ss": HybridSS}
 class _Policy:
     def __init__(self, checkpoint_dir):
         self._checkpoint_dir = Path(checkpoint_dir)