dsh-engineering-ui 0.0.0-stage → 1.5.1

package/engineering/tools/webots_mcp/ledger.py

@@ -0,0 +1,73 @@
+"""Single live owner, durable intent and conservative crash recovery."""
+import hashlib
+import json
+import sqlite3
+from datetime import datetime, timezone
+
+
+def now():
+    return datetime.now(timezone.utc).isoformat()
+
+
+class Ledger:
+    def __init__(self, root):
+        import msvcrt
+        from .evidence import _no_reparse
+        _no_reparse(root)
+        for name in ("webots_instance.lock","webots_jobs.sqlite3","webots_jobs.sqlite3-wal",
+                     "webots_jobs.sqlite3-shm","webots_jobs.sqlite3-journal","webots_state.json"):
+            _no_reparse(root/name)
+        self.lock = (root / "webots_instance.lock").open("a+b")
+        self.lock.seek(0)
+        try:
+            msvcrt.locking(self.lock.fileno(), msvcrt.LK_NBLCK, 1)
+            self.db = sqlite3.connect(root / "webots_jobs.sqlite3", timeout=.2)
+            self.db.row_factory = sqlite3.Row
+            self.db.execute("PRAGMA journal_mode=WAL")
+            self.db.execute("PRAGMA synchronous=FULL")
+            self.db.execute("""CREATE TABLE IF NOT EXISTS actions(
+                op TEXT PRIMARY KEY, digest TEXT NOT NULL, task TEXT NOT NULL, room TEXT NOT NULL,
+                job TEXT UNIQUE NOT NULL, run TEXT NOT NULL, gen INTEGER NOT NULL,
+                phase TEXT NOT NULL, result TEXT NOT NULL, updated TEXT NOT NULL)""")
+            with self.db:
+                for row in self.db.execute("SELECT * FROM actions WHERE phase IN ('accepted','dispatched')").fetchall():
+                    dispatched = row["phase"] == "dispatched"
+                    self.finish(row["op"], "unknown" if dispatched else "rejected",
+                                error_code="OUTCOME_UNKNOWN" if dispatched else "INTERRUPTED_BEFORE_DISPATCH",
+                                execution_state="unknown" if dispatched else "not_started",
+                                ok=False, job_state="UNKNOWN" if dispatched else "FAILED", stale=True)
+        except BaseException:
+            if hasattr(self, "db"):
+                self.db.close()
+            self.lock.close()
+            raise
+
+    def close(self):
+        self.db.close()
+        self.lock.close()
+
+    def lookup(self, key, value):
+        assert key in ("op", "job")
+        return self.db.execute(f"SELECT * FROM actions WHERE {key}=?", (value,)).fetchone()
+
+    @staticmethod
+    def digest(name, args):
+        canonical = json.dumps([name, {k:v for k,v in args.items() if k != "request_id"}],
+                               sort_keys=True, separators=(",", ":"), allow_nan=False)
+        return hashlib.sha256(canonical.encode()).hexdigest()
+
+    def accept(self, args, digest, result):
+        op = args["operation_id"]
+        with self.db:
+            self.db.execute("INSERT INTO actions VALUES(?,?,?,?,?,?,?,?,?,?)",
+                (op,digest,args["task_id"],args["room_id"],result["job_id"],result["run_id"],
+                 result["session_generation"],"accepted",json.dumps(result,allow_nan=False),now()))
+
+    def finish(self, op, phase, **updates):
+        row = self.lookup("op", op)
+        old = json.loads(row["result"])
+        old.update(updates, snapshot_at=now())
+        with self.db:
+            self.db.execute("UPDATE actions SET phase=?,result=?,updated=? WHERE op=?",
+                            (phase,json.dumps(old,allow_nan=False),old["snapshot_at"],op))
+        return old

package/engineering/tools/webots_mcp/owned_job.py

@@ -0,0 +1,70 @@
+"""Keep Windows descendants inside an unnamed kill-on-close Job from birth."""
+import subprocess
+import time
+from uuid import uuid4
+
+import win32api
+import win32con
+import win32job
+import win32process
+
+
+
+class OwnedJob:
+    def __init__(self,max_processes=None):
+        self.handle = win32job.CreateJobObject(None, "A04-" + uuid4().hex)
+        limits = win32job.QueryInformationJobObject(self.handle, win32job.JobObjectExtendedLimitInformation)
+        limits["BasicLimitInformation"]["LimitFlags"] = win32job.JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
+        if max_processes is not None:
+            if type(max_processes) is not int or not 1<=max_processes<=64:
+                self.handle.Close()
+                raise ValueError("Process ceiling must be an integer in 1..64")
+            limits["BasicLimitInformation"]["LimitFlags"] |= win32job.JOB_OBJECT_LIMIT_ACTIVE_PROCESS
+            limits["BasicLimitInformation"]["ActiveProcessLimit"] = max_processes
+        win32job.SetInformationJobObject(self.handle, win32job.JobObjectExtendedLimitInformation, limits)
+
+    def spawn(self, argv, env, cwd):
+        process, thread, pid, _ = win32process.CreateProcess(argv[0], subprocess.list2cmdline(argv),
+            None, None, False, win32con.CREATE_SUSPENDED | win32con.CREATE_NO_WINDOW | win32process.BELOW_NORMAL_PRIORITY_CLASS,
+            env, str(cwd), win32process.STARTUPINFO())
+        try:
+            win32job.AssignProcessToJobObject(self.handle, process)
+            identity = self.identity(pid)
+            win32process.ResumeThread(thread)
+            return identity
+        except BaseException:
+            win32api.TerminateProcess(process, 90)
+            raise
+        finally:
+            thread.Close()
+            process.Close()
+
+    def identity(self, pid):
+        handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION | win32con.PROCESS_VM_READ, False, pid)
+        try:
+            if not win32job.IsProcessInJob(handle, self.handle):
+                raise PermissionError("Peer outside owned Job")
+            return dict(pid=pid, creation_time=str(win32process.GetProcessTimes(handle)["CreationTime"]),
+                        exe=win32process.GetModuleFileNameEx(handle, 0))
+        finally:
+            handle.Close()
+
+    def active(self):
+        return win32job.QueryInformationJobObject(self.handle,
+                win32job.JobObjectBasicAccountingInformation)["ActiveProcesses"]
+
+    def stop(self):
+        # No persisted PID is ever reopened for termination.
+        if self.handle is None:
+            return
+        try:
+            if self.active():
+                win32job.TerminateJobObject(self.handle, 91)
+            until = time.monotonic() + 2
+            while self.active() and time.monotonic() < until:
+                time.sleep(.01)
+            if self.active():
+                raise TimeoutError("Job termination unconfirmed")
+        finally:
+            self.handle.Close()
+            self.handle = None

package/engineering/tools/webots_mcp/physical_gate.py

@@ -0,0 +1,187 @@
+"""Judge a bounded rigid-body pair experiment from two complete observation traces."""
+import math
+import re
+
+
+def number(x):
+    if type(x) not in (float,int) or not math.isfinite(x):
+        raise ValueError("Expected finite measurement")
+    return x
+
+
+def digest(x):
+    if not isinstance(x,str) or not re.fullmatch(r"[a-f0-9]{64}",x):
+        raise ValueError("Missing SHA256 evidence binding")
+    return x
+
+
+CONDITIONS = ("model","scene_except_step","actions","initial_state","materials","thresholds",
+              "coverage","calibration","sensor_binding")
+
+
+def sample_from_observations(store,run,receipts,*,sensor,unit,pairs):
+    """Decode one aligned SI position sample and exact-node contacts from owned snapshots.
+
+    Stability metric in this supported recipe is peak monitored body angular speed (rad/s).
+    Physical calibration/coverage is evaluated separately; empty contacts alone cannot pass.
+    """
+    import hashlib
+    import json
+    if not pairs or len(pairs)>64 or len(receipts)>129:
+        raise ValueError("Bounded explicit collision pairs required")
+    bodies = {}
+    measurement = None
+    scope = None
+    provenance = None
+    for ref in receipts:
+        origin = ref["provenance"]["kind"]
+        if ref["kind"] != "observation" or origin not in ("real-webots","synthetic"):
+            raise ValueError("Wrong observation source")
+        actual = store.file_evidence(run,ref["path"],kind=ref["kind"],provenance=ref["provenance"],
+                                     producer=ref["producer"])
+        if actual != ref or actual["size_bytes"] > 65536:
+            raise ValueError("Observation index mismatch")
+        with store._path(f"webots_runs/{run}/{ref['path']}").open("rb") as file:
+            raw = file.read(65537)
+        if hashlib.sha256(raw).hexdigest()!=ref["sha256"]:
+            raise ValueError("Observation changed")
+        record = json.loads(raw)
+        identity = tuple(record[k] for k in ("run_id","generation","robot","world_sha256","model_sha256",
+                                             "step","sim_time"))
+        if record["run_id"] != run or (scope is not None and (scope!=identity or provenance!=origin)):
+            raise ValueError("Observations from different physics instants")
+        scope,provenance = identity,origin
+        m = record["measurement"]
+        if record["action"]=="sim_sensor" and m["device"]==sensor and m["unit"]==unit and unit in ("m","rad"):
+            if measurement is not None or m["device_type"]!="PositionSensor":
+                raise ValueError("Ambiguous sensor binding")
+            measurement = number(m["value"])
+        elif record["action"]=="sim_contacts" and m["include_descendants"] is False and m["boundingObject"]:
+            if m["node_def"] in bodies:
+                raise ValueError("Duplicate body snapshot")
+            bodies[m["node_def"]]=m
+        else:
+            raise ValueError("Unexpected observation for recipe")
+    if measurement is None or set(bodies)!={body for pair in pairs.values() for body in pair}:
+        raise ValueError("Missing sensor or required body")
+    contacts = {}
+    max_speed = 0.
+    for body in bodies.values():
+        velocity = body["velocity_world"]
+        if len(velocity)!=6:
+            raise ValueError("Missing rigid-body velocity")
+        max_speed = max(max_speed,math.hypot(*(number(v) for v in velocity[3:])))
+    for label,(a,b) in pairs.items():
+        left,right=bodies[a],bodies[b]
+        if left["node_id"]==right["node_id"]:
+            raise ValueError("Pair resolves to the same body")
+        direct = any(p["node_id"]==right["node_id"] for p in left["contacts"])
+        reverse = any(p["node_id"]==left["node_id"] for p in right["contacts"])
+        if direct != reverse:
+            raise ValueError("Contact endpoints disagree")
+        contacts[label]=direct
+    ms=number(scope[-1])*1000
+    if not math.isclose(ms,round(ms),rel_tol=0,abs_tol=1e-6):
+        raise ValueError("Nonintegral simulation clock")
+    return dict(time_ms=round(ms),contacts=contacts,value=measurement,stability_error=max_speed)
+
+
+def evaluate(coarse,fine,policy):
+    """Synthetic traces exercise identical decisions but cannot pass a physical gate."""
+    result = dict(verdict="UNKNOWN",physical_valid=False,provenance="synthetic",reasons=[])
+    try:
+        real = all(trace["provenance"] == "real-webots" for trace in (coarse,fine))
+        if real:
+            result["provenance"] = "real-webots"
+        elif any(trace["provenance"] != "synthetic" for trace in (coarse,fine)):
+            raise ValueError("Mixed or unsupported provenance")
+        if coarse["run_id"] == fine["run_id"] or not coarse["run_id"] or not fine["run_id"]:
+            raise ValueError("Two distinct runs required")
+        if not isinstance(coarse["robot"],str) or not coarse["robot"] or coarse["robot"] != fine["robot"]:
+            raise ValueError("Different or missing robot identity")
+        for trace in (coarse,fine):
+            digest(trace["world_sha256"])
+        for key in CONDITIONS:
+            if digest(coarse["conditions"][key]) != digest(fine["conditions"][key]):
+                raise ValueError("Different condition: "+key)
+        if coarse["seed"] != fine["seed"] or any(type(t["seed"]) is not int for t in (coarse,fine)):
+            raise ValueError("Incomparable seed")
+        dc,df = coarse["step_ms"],fine["step_ms"]
+        if type(dc) is not int or type(df) is not int or not 0 < df <= 1000 or dc != 2*df:
+            raise ValueError("Expected step-halving comparison")
+        if policy["topology"] != "open-rigid":
+            raise ValueError("Closed-loop/flexible/global constraint validity unsupported")
+        pairs = policy["pairs"]
+        if not isinstance(pairs,dict) or not 0 < len(pairs)<=64 or not policy["unit"] or not policy["metric"]:
+            raise ValueError("Explicit pairs, measurement and unit required")
+        tolerance = number(policy["convergence_absolute"])
+        stable_limit = number(policy["stability_limit"])
+        if min(tolerance,stable_limit) < 0:
+            raise ValueError("Negative tolerance")
+        threshold = number(policy["metric_max"])
+        from hashlib import sha256
+        import json
+        policy_hash = sha256(json.dumps(policy,sort_keys=True,separators=(",",":"),allow_nan=False).encode()).hexdigest()
+        if coarse["conditions"]["thresholds"] != policy_hash:
+            raise ValueError("Policy differs from frozen threshold hash")
+        samples = []
+        hits = []
+        contact_times = []
+        for trace in (coarse,fine):
+            digest(trace["raw_evidence_sha256"])
+            if trace["generation"] != 1 or type(trace["generation"]) is not int:
+                raise ValueError("Invalid generation")
+            if trace["calibrated"] is not True or trace["feedback_verified"] is not True:
+                raise ValueError("Unverified model or actuator feedback")
+            if trace["metric"] != policy["metric"] or trace["unit"] != policy["unit"]:
+                raise ValueError("Metric or unit mismatch")
+            if set(trace["coverage"]) != set(pairs):
+                raise ValueError("Missing required collision pair")
+            for pair, expectation in pairs.items():
+                c = trace["coverage"][pair]
+                if (expectation not in ("expected","forbidden") or c["distinct_bodies"] is not True
+                        or c["geometry_calibrated"] is not True or c["collision_enabled"] is not True
+                        or c["detector_verified"] is not True or c["filtered"] is not False
+                        or type(c["self_pair"]) is not bool
+                        or (c["self_pair"] and c["self_collision_enabled"] is not True)):
+                    raise ValueError("Uncovered collision pair: "+pair)
+                digest(c["evidence_sha256"])
+            rows = trace["samples"]
+            if not 1 <= len(rows) <= 10000:
+                raise ValueError("Unsupported trace size")
+            values,h = [],set()
+            events = {k:[] for k in pairs}
+            for i,row in enumerate(rows,1):
+                if type(row["time_ms"]) is not int or row["time_ms"] != i*trace["step_ms"] or set(row["contacts"]) != set(pairs):
+                    raise ValueError("Missing observation or inconsistent sample time")
+                if any(type(v) is not bool for v in row["contacts"].values()):
+                    raise ValueError("Unknown contact sample")
+                h.update(k for k,v in row["contacts"].items() if v)
+                for pair, present in row["contacts"].items():
+                    if present:
+                        events[pair].append(row["time_ms"])
+                values.append(number(row["value"]))
+                if not 0 <= number(row["stability_error"]) <= stable_limit:
+                    raise ValueError("Instability exceeds calibrated bound")
+            samples.append(values)
+            hits.append(h)
+            contact_times.append(events)
+        if len(samples[1]) != 2*len(samples[0]):
+            raise ValueError("Different duration")
+        if hits[0] != hits[1] or any(abs(x-y)>tolerance for x,y in zip(samples[0],samples[1][1::2])):
+            raise ValueError("Contact classification or metric failed convergence")
+        for pair in hits[0]:
+            left,right = (events[pair] for events in contact_times)
+            if set(left) != {((t+dc-1)//dc)*dc for t in right}:
+                raise ValueError("Contact interval occupancy failed convergence: "+pair)
+        if (max(samples[0]) > threshold) != (max(samples[1]) > threshold):
+            raise ValueError("Threshold classification failed convergence")
+        violations = [pair for pair,expected in pairs.items() if (pair in hits[0]) != (expected=="expected")]
+        if max(max(v) for v in samples) > threshold:
+            violations.append("metric_max")
+        decision = "FAIL" if violations else "PASS"
+        result.update(criteria_result=decision,physical_valid=real,verdict=decision if real else "UNKNOWN",
+                      run_ids=[trace["run_id"] for trace in (coarse,fine)], raw_sha256=[trace["raw_evidence_sha256"] for trace in (coarse,fine)], reasons=violations if real else ["Synthetic trace"]+violations)
+    except (KeyError,TypeError,ValueError,OverflowError) as err:
+        result["reasons"] = [str(err)]
+    return result

package/engineering/tools/webots_mcp/physics.py

@@ -0,0 +1,152 @@
+"""SI rigid-body math. No COM, application launch, files, or global state.
+
+Column vectors, p_target = R @ p_source + t. Inertia is a physical tensor
+about the COM, expressed in the named frame (not principal moments).
+"""
+import math
+
+IDENTITY = ((1., 0., 0.), (0., 1., 0.), (0., 0., 1.))
+MASS_FIELDS = ('CenterOfMassX', 'CenterOfMassY', 'CenterOfMassZ', 'Volume',
+               'Area', 'Mass', 'MomXX', 'MomYY', 'MomZZ', 'MomXY', 'MomZX', 'MomYZ')
+
+
+def _numbers(values, count):
+    if not isinstance(values, (list, tuple)) or len(values) != count:
+        raise ValueError(f'expected {count} numbers')
+    if any(isinstance(x, bool) or not isinstance(x, (int, float)) or not math.isfinite(x) for x in values):
+        raise ValueError('finite numeric values required')
+    return [float(x) for x in values]
+
+
+def _matrix(value):
+    if not isinstance(value, (list, tuple)) or len(value) != 3:
+        raise ValueError('expected 3 by 3 matrix')
+    return [_numbers(row, 3) for row in value]
+
+
+def _det(a):
+    return (a[0][0]*(a[1][1]*a[2][2]-a[1][2]*a[2][1])
+            - a[0][1]*(a[1][0]*a[2][2]-a[1][2]*a[2][0])
+            + a[0][2]*(a[1][0]*a[2][1]-a[1][1]*a[2][0]))
+
+
+def _psd(a):
+    # All principal minors, not just leading minors, characterize PSD.
+    return (all(a[i][i] >= -1e-12 for i in range(3))
+            and all(a[i][i]*a[j][j]-a[i][j]**2 >= -1e-12 for i in range(3) for j in range(i))
+            and _det(a) >= -1e-12)
+
+
+def validate_inertia(value):
+    a = _matrix(value)
+    scale = max(abs(x) for row in a for x in row)
+    if scale == 0:
+        raise ValueError('zero inertia unsupported')
+    b = [[x / scale for x in row] for row in a]
+    if any(abs(b[i][j]-b[j][i]) > 1e-12 for i in range(3) for j in range(3)):
+        raise ValueError('inertia must be symmetric')
+    half_trace = sum(b[i][i] for i in range(3)) / 2
+    covariance = [[(half_trace if i == j else 0)-b[i][j] for j in range(3)] for i in range(3)]
+    if not _psd(b) or not _psd(covariance):
+        raise ValueError('inertia is not physically realizable')
+    return a
+
+
+def validate_rotation(value):
+    r = _matrix(value)
+    if (abs(_det(r)-1) > 1e-9 or
+        any(abs(sum(r[k][i]*r[k][j] for k in range(3))-(i == j)) > 1e-9
+            for i in range(3) for j in range(3))):
+        raise ValueError('proper orthonormal rotation required; scale/reflection unsupported')
+    return r
+
+
+def parse_mass_array(method, raw):
+    """Read documented slots verbatim; this does NOT infer cross-term signs."""
+    if method in ('IModelDocExtension.GetMassProperties2', 'IBody2.GetMassProperties'):
+        fields = MASS_FIELDS
+    elif method == 'IModelDocExtension.GetMassProperties':
+        fields = MASS_FIELDS + ('Accuracy',)
+    else:
+        raise ValueError('unverified mass method: ' + str(method))
+    return dict(zip(fields, _numbers(raw, len(fields))))
+
+
+def sw_inertia_tensor(raw):
+    """IMassProperty.GetMomentOfInertia(0) products -> physical tensor.
+
+    Off-diagonal sign follows ROS SW exporter Inertia.SetMomentMatrix.
+    Do not apply to an already converted tensor or unidentified legacy array.
+    """
+    v = _numbers(raw, 9)
+    return validate_inertia([[v[3*i+j] * (1 if i == j else -1)
+                              for j in range(3)] for i in range(3)])
+
+
+def mass_properties(mass, com, inertia, *, length_unit, mass_unit, frame):
+    """One explicit input-unit conversion; downstream APIs accept SI only."""
+    if length_unit not in ('m', 'mm') or mass_unit not in ('kg', 'g'):
+        raise ValueError('unsupported or missing units')
+    if not isinstance(frame, str) or not frame.strip():
+        raise ValueError('frame required')
+    m = _numbers([mass], 1)[0] * (1 if mass_unit == 'kg' else .001)
+    length = 1 if length_unit == 'm' else .001
+    if m <= 0: raise ValueError('positive mass required')
+    factor = (1 if mass_unit == 'kg' else .001) * length**2
+    c = [x*length for x in _numbers(com, 3)]
+    tensor = [[x*factor for x in row] for row in _matrix(inertia)]
+    return {'mass_kg': m, 'com_m': c, 'inertia_kg_m2': validate_inertia(tensor),
+            'frame': frame, 'units': 'SI', 'inertia_about': 'center_of_mass'}
+
+
+def _checked(body, frame):
+    if body.get('units') != 'SI' or body.get('frame') != frame or body.get('inertia_about') != 'center_of_mass':
+        raise ValueError('SI COM tensor and matching source frame required')
+    return mass_properties(body['mass_kg'], body['com_m'], body['inertia_kg_m2'],
+                           length_unit='m', mass_unit='kg', frame=frame)
+
+
+def sw_transform(raw):
+    """IComponent2.Transform2.ArrayData -> column-vector R,t in metres.
+
+    SW stores row-vector axes; transpose its first nine entries exactly once.
+    Component Transform2 is relative to root assembly, even for subassemblies.
+    """
+    v = _numbers(raw, 16)
+    if v[12] != 1:
+        raise ValueError('scaled component transform unsupported')
+    return validate_rotation([[v[j*3+i] for j in range(3)] for i in range(3)]), v[9:12]
+
+
+def transform_mass(body, rotation, translation_m, *, source_frame, target_frame):
+    b = _checked(body, source_frame)
+    r, t = validate_rotation(rotation), _numbers(translation_m, 3)
+    c = [sum(r[i][j]*b['com_m'][j] for j in range(3))+t[i] for i in range(3)]
+    a = b['inertia_kg_m2']
+    tensor = [[sum(r[i][k]*a[k][l]*r[j][l] for k in range(3) for l in range(3))
+               for j in range(3)] for i in range(3)]
+    return mass_properties(b['mass_kg'], c, tensor, length_unit='m', mass_unit='kg', frame=target_frame)
+
+
+def merge_rigid_bodies(components, *, frame):
+    """Merge explicit fixed-group members (id, SI properties in one frame).
+
+    A02 decides membership; this function never infers fixedness from contact.
+    """
+    members = list(components)
+    ids = [item[0] for item in members]
+    if not ids or any(not isinstance(x, str) or not x.strip() for x in ids) or len(set(ids)) != len(ids):
+        raise ValueError('unique nonempty component ids required')
+    bodies = [_checked(b, frame) for _, b in members]
+    mass = math.fsum(b['mass_kg'] for b in bodies)
+    com = [math.fsum(b['mass_kg']*b['com_m'][i] for b in bodies)/mass for i in range(3)]
+    terms = []
+    for b in bodies:
+        d = [b['com_m'][i]-com[i] for i in range(3)]
+        norm2 = sum(x*x for x in d)
+        terms.append([[b['inertia_kg_m2'][i][j] + b['mass_kg']*((norm2 if i == j else 0)-d[i]*d[j])
+                       for j in range(3)] for i in range(3)])
+    tensor = [[math.fsum(a[i][j] for a in terms) for j in range(3)] for i in range(3)]
+    result = mass_properties(mass, com, tensor, length_unit='m', mass_unit='kg', frame=frame)
+    result['component_ids'] = ids
+    return result

package/engineering/tools/webots_mcp/pipeline.py

@@ -0,0 +1,108 @@
+"""Offline A01 single-part preview. Native CAD and physical gates stay closed."""
+import argparse
+import json
+from importlib.metadata import version
+from pathlib import Path
+import re
+import subprocess
+import sys
+
+from .evidence import EvidenceStore, _identifier, _load_json
+from .sw_export import part_bundle
+
+CONVERTER = "2025.0.0"
+PRODUCER = {"name": "webots_mcp.pipeline", "version": "1", "source_revision": None}
+
+
+def native_gate():
+    return {"ok": False, "error_code": "CALIBRATION_REQUIRED", "ready_for_physics": False}
+
+
+def publish_part(store, run, snapshot, *, provenance="static-derived"):
+    if provenance not in {"static-derived", "fixture"} or snapshot["physics"]["frame"] != "part-local":
+        raise ValueError("Only uncalibrated part-local previews are supported")
+    bundle = part_bundle(snapshot)
+    files = [(name, bundle[name].encode("utf-8"), kind) for name, kind in
+             (("robot.urdf", "exported-model"), ("visual.obj", "visual-mesh"))]
+    if any(len(raw) > 4 * 1024**2 for _, raw, _ in files):
+        raise ValueError("Preview exceeds the per-file evidence budget")
+    store._path(f"webots_runs/{_identifier(run)}").mkdir(parents=True)
+    evidence = [store.save_snapshot(run, name, raw, kind=kind, provenance=provenance,
+                                   producer=PRODUCER) for name, raw, kind in files]
+    common = dict(provenance=provenance, source_revision=snapshot["source_revision"],
+                  status="approximate", evidence=evidence,
+                  missing_information=bundle["conversion_data"]["missing_information"])
+    return {kind: store.write_report(store.new_report(kind, run, data=bundle[key], **common))
+            for kind, key in (("model_manifest", "manifest_data"), ("conversion_report", "conversion_data"))}
+
+
+def convert_part(store, run, *, operation_id):
+    operation_id = _identifier(operation_id)
+    manifest = store.read_report(run, "model_manifest")
+    report = store.read_report(run, "conversion_report")
+    provenance = report["provenance"]["kind"]
+    files = {item["path"] for item in report["evidence"] if item["producer"] == PRODUCER}
+    if (provenance not in {"fixture", "static-derived"} or manifest["provenance"]["kind"] != provenance
+            or manifest["source_revision"] != report["source_revision"]
+            or not {"robot.urdf", "visual.obj"} <= files):
+        raise ValueError("An owned part preview is required")
+    if version("urdf2webots") != CONVERTER:
+        raise ValueError(f"Expected urdf2webots {CONVERTER}")
+    root = store._run(run)
+    stage = store._path(f"webots_runs/{run}/preview")
+    stage.mkdir()
+    target = stage / "Preview.proto"
+    with (stage / "converter.log").open("wb") as log:
+        subprocess.run([sys.executable, "-B", "-m", "urdf2webots.importer",
+                        "--input", str(root / "robot.urdf"), "--output", str(target)],
+                       cwd=stage, stdout=log, stderr=subprocess.STDOUT, check=True, timeout=30)
+    text = target.read_text(encoding="utf-8")
+    urls = re.findall(r'^\s*url\s+"([^"]+)"\s*$', text, re.M)
+    if not text.startswith("#VRML_SIM R2025a") or [url.replace("\\", "/") for url in urls] != ["../visual.obj"]:
+        raise ValueError("Unexpected preview format or mesh reference")
+    body, = manifest["data"]["rigid_bodies"]
+    matrix = body["inertia_kg_m2"]
+    expected = {"mass": [body["mass_kg"]], "centerOfMass": body["com_m"],
+                "inertiaMatrix": [matrix[i][j] for i,j in ((0,0),(1,1),(2,2),(0,1),(0,2),(1,2))]}
+    observed = {}
+    for field in expected:
+        pattern = r"([^\n]+)" if field == "mass" else r"\[([^\]]+)\]"
+        match = re.search(r"^\s*" + field + r"\s+" + pattern, text, re.M)
+        observed[field] = [float(value) for value in match[1].split()] if match else None
+    changed = [field for field in expected if expected[field] != observed[field]]
+    precision = dict(preserved=not changed, expected=expected, observed=observed, changed=changed)
+    report["evidence"].extend(store.file_evidence(run, f"preview/{name}", kind=kind,
+        provenance=provenance, producer={"name": "urdf2webots", "version": CONVERTER})
+        for name,kind in (("Preview.proto","preview-proto"),("converter.log","converter-log")))
+    report["data"].update(preview_operation_id=operation_id, converter_version=CONVERTER,
+                          precision=precision, physical_validation="not_run")
+    receipt = store.write_report(report)
+    return {"ready_for_physics": False, "precision": precision, "report": receipt}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("action", choices=("publish-part", "convert-part", "native-status"))
+    parser.add_argument("--state", type=Path)
+    parser.add_argument("--task")
+    parser.add_argument("--room")
+    parser.add_argument("--run")
+    parser.add_argument("--snapshot", type=Path)
+    parser.add_argument("--operation-id")
+    args = parser.parse_args()
+    try:
+        if args.action == "native-status":
+            result = native_gate()
+        else:
+            store = EvidenceStore(args.state, task_id=args.task, room_id=args.room)
+            if args.action == "publish-part":
+                result = publish_part(store, args.run, _load_json(args.snapshot))
+            else:
+                result = convert_part(store, args.run, operation_id=args.operation_id)
+    except (OSError, ValueError, TypeError, KeyError, subprocess.SubprocessError) as error:
+        parser.exit(2, json.dumps({"ok": False, "error": str(error)}) + "\n")
+    print(json.dumps(result, ensure_ascii=False, allow_nan=False))
+
+
+if __name__ == "__main__":
+    main()