bench: orchestrate a multi-card campaign without touching the measurement path

campaign.sh fans a screened operator list across cards, one ab_repeat.sh per
card, serial within a card. It does no measuring: ab_repeat.sh is the path that
produced the four operator verdicts already on record, and it stays byte for
byte as it was.

Each card gets its own AB_ROOT. Eight ab_repeat.sh started in the same second
would otherwise compute the same timestamped directory name and two cards would
write into one.

ZL_ISOLATE_TUNER_CACHE=1 is forced, since eight processes on one sqlite is the
thing to avoid. The cost is that pinned configs differ from a shared-cache
batch, so absolute latencies cannot be quoted across the two; the caliber guard
refuses such comparisons on its own, which is why this is a note and not a
warning someone has to remember.

partition.py's shell output gained the per-card weight, because EXTRA_OPS has
to land on the lightest card and counting operators gets that wrong — one heavy
operator outweighs three light ones. It writes through stdout.buffer: Python
turns "\n" into CRLF on Windows, and the trailing \r then rides into the last
field and breaks the numeric comparison that picks the card.

partition.py

@@ -113,9 +113,15 @@ def main(argv: Optional[List[str]] = None) -> int:
 
     assignment = plan(items, devices)
     if args.format == "shell":
+        # 第三列是该卡的权重秒数，供驱动脚本决定往哪张卡追加算子——按负载选，不是
+        # 按算子个数：一个重算子能顶三个轻的。
+        # 显式写 "\n" 而不用 print：Windows 上 print 会发 CRLF，读的一侧会把 \r
+        # 带进最后一个字段，数值比较就废了。
         for d in devices:
             ops = " ".join(f"{op}:{files[op]}" for op, _ in assignment[d])
-            print(f"{d}\t{ops}")
+            load = sum(w for _, w in assignment[d])
+            sys.stdout.buffer.write(f"{d}\t{ops}\t{load:.0f}\n".encode())
+        sys.stdout.buffer.flush()
         return 0
 
     total = sum(w for _, w in items) * args.rounds