fix: harden task recovery and DR contract handling

tools/http_concurrency.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Measure fresh-connection task admission bursts against an isolated local API.
+
+The planner is deliberately idle: receipts must not wait for planning. Latency
+is reported as evidence, never asserted as a machine-independent unit-test SLA.
+"""
+import argparse
+from concurrent.futures import ThreadPoolExecutor
+import http.client
+import json
+import math
+from pathlib import Path
+import sys
+import tempfile
+import threading
+import time
+
+ROOT=Path(__file__).resolve().parents[1]
+sys.path.insert(0,str(ROOT/'coordinator'))
+from robot_bt_coordinator.backends import ManualBackend
+from robot_bt_coordinator.http_api import make_server
+from robot_bt_coordinator.service import Coordinator
+
+
+def probe(clients=10,rounds=3):
+    if not 1<=clients<=128 or not 1<=rounds<=100:
+        raise ValueError('clients must be 1..128 and rounds 1..100')
+    with tempfile.TemporaryDirectory(prefix='bt-http-probe-') as folder:
+        coordinator=Coordinator(str(Path(folder)/'tasks.db'),ManualBackend(),{'probe_robot'})
+        server=make_server(coordinator,'127.0.0.1',0,'local-probe-token')
+        thread=threading.Thread(target=server.serve_forever,daemon=True)
+        thread.start()
+        samples=[]
+        try:
+            for iteration in range(rounds):
+                gate=threading.Barrier(clients)
+                def submit(index):
+                    connection=http.client.HTTPConnection('127.0.0.1',server.server_port,timeout=10)
+                    request=dict(client_request_id=f'probe-{iteration}-{index}',robot_id='probe_robot',instruction='local admission probe',known_info={})
+                    gate.wait(timeout=15)
+                    started=time.perf_counter()
+                    try:
+                        connection.request('POST','/v1/tasks',json.dumps(request),{'Authorization':'Bearer local-probe-token','Content-Type':'application/json'})
+                        response=connection.getresponse()
+                        body=json.loads(response.read())
+                        return dict(elapsed_ms=(time.perf_counter()-started)*1000,http_status=response.status,task_id=body.get('task_id'),status=body.get('status'))
+                    finally:connection.close()
+                with ThreadPoolExecutor(max_workers=clients) as pool:
+                    samples.extend(pool.map(submit,range(clients)))
+            successful=all(s['http_status']==202 and s['status']=='QUEUED' for s in samples)
+            successful=successful and len({s['task_id'] for s in samples})==clients*rounds
+            durations=sorted(s['elapsed_ms'] for s in samples)
+            return dict(clients=clients,rounds=rounds,requests=len(samples),all_accepted=successful,
+                        p50_ms=durations[math.ceil(len(durations)*.5)-1],
+                        p95_ms=durations[math.ceil(len(durations)*.95)-1],max_ms=max(durations),
+                        listen_backlog=server.request_queue_size,planner_started=bool(coordinator.backend.plans),samples=samples)
+        finally:
+            server.shutdown();server.server_close();thread.join();coordinator.close()
+
+
+def main():
+    parser=argparse.ArgumentParser()
+    parser.add_argument('--clients',type=int,default=10)
+    parser.add_argument('--rounds',type=int,default=3)
+    args=parser.parse_args()
+    result=probe(args.clients,args.rounds)
+    print(json.dumps(result,indent=2))
+    if not result['all_accepted'] or result['planner_started']:raise SystemExit(1)
+
+
+if __name__=='__main__':main()