Three qualification-only operators measure RoboDojo motion and scene physics.
None starts a policy model, writes inside a sealed run or is
policy-visible: the motion metrics checker and control replay measure
recorded motion and replay recorded controls exactly, the physics scene
probe measures whether each scene behaves under the selected physics device,
and the scripted motion gate drives a fixed case table through the route
every episode runs.
Card and scene-smoke qualification, keyed on the device, are owned by the
qualification authoring contract and
the runtime lifecycle.
RoboDojo motion metrics and control replay
Layer L0 of the RoboDojo motion v2 design measures v1 motion under fixed definitions and replays recorded controls exactly. It changes no executor, starts no policy and never writes inside a sealed run. Six modules implement it:
| Module | Runs in | Role |
|---|---|---|
ora/orchestrator/backends/robodojo/motion/journal.py |
Harness interpreter, no Isaac | Joins receipts/action-NNNN.json with controller/action-NNNN.json{,l} into immutable tick and per-arm segment records; refuses a trace whose action_id differs from its receipt, a native-action count with a gap, and a truncated or half-written line. |
ora/orchestrator/backends/robodojo/motion/measures.py |
Harness interpreter, no Isaac | The pinned definitions (robodojo-motion-metrics.v2) and their per-run counts. |
ora/orchestrator/backends/robodojo/motion/metrics.py |
Harness interpreter, no Isaac | The report and its CLI. |
ora/orchestrator/backends/robodojo/motion/replay.py |
Harness interpreter | Replay launcher (run scratch, slot lease, worker configuration, worker process group) and the replay report. |
ora/orchestrator/backends/robodojo/replay_kernel.py |
Harness interpreter | Kernel admission: whether this checkout's worker kernel replays the run's physics. |
ora/environment/backends/robodojo/control_replay.py |
RoboDojo interpreter | The replay worker: an in-process RobodojoSession fed the recorded controls. With --scene-trace DIR (the launcher's flag of the same name, one pass only; ora replay RUN --scene) it also writes the scene that replay passes through, reading state only. |
Metric checker
./scripts/ora qualify robodojo motion-metrics RUN [RUN ...] \
[--journal-root DIR] [--upto N] [--planned-waypoints FILE] [--object-poses FILE] [--v-cmd RAD_S] [--output FILE]
RUN is a run directory or its native/ root. The report
(ora.robodojo-motion-metrics-report.v1) carries the definition
version, the definitions, the v_cmd used, one metric object per run, the
runs it could not read (errors, exit code 1; the others are still measured)
and the pooled metrics. Every ratio is a numerator, a denominator and their
share. --output must lie outside every source run; without it the report
goes to stdout. --journal-root reads a control replay's traces against the
original receipts. --planned-waypoints (ora.robodojo-planned-waypoints.v1:
per action and arm, one joint waypoint per native action and optionally
predicted_in_tick_speed_rad_s) and --object-poses apply to one run.
An arm-tick is one native action of an arm whose <arm>_arm_joint_state is
in the recorded control. A speed sample is the change between consecutive
journaled physics steps over 0.004 s; a tick's first step is taken against the
previous tick's last step when the physics clock is contiguous, never across a
round start. A segment is a run of consecutive ticks of one action with one
segment name commanding one arm. The target is that of its first tick; a
segment whose target changes (a planned trajectory or a stall hold) is not a v1
segment. Global segments are move, plan_ref (a probe-planned move),
precontact, retract and every recover*. local is its own
class; gripper, wait and stall_hold are not motion segments. Two cohorts
split the arm-ticks and the jaw episodes: closed_command, where the tick-end
recorded gripper directive is close, and holding_mode, v1's form of the v2
holding rule: after a set_gripper close that ended stalled_before_target,
until the arm's next set_gripper, the round end, or the jaw reaching its
floor. Percentiles are the value at index floor(q·n) of the ascending sort.
| Metric | Denominator | Numerator | Constants and source |
|---|---|---|---|
v1_baseline_diagnostics.saturation_physics_step (v1 only) |
arm-ticks, with closed_command and holding_mode subsets |
a joint speed sample ≥ 4.75 rad/s | 0.95 × the X5 actuator's 5 rad/s (upstream robot_config/x5.py:37-45) |
v1_baseline_diagnostics.saturation_tick_displacement (v1 only) |
moving arm-ticks: largest joint change over the tick ≥ 0.005 rad; a round's first tick has no known start and is excluded | change ≥ 0.19 rad | 0.95 × 5 rad/s × 40 ms |
v1_baseline_diagnostics.out_of_step.spread_above_0.3 / _0.5 (v1 only) |
constant-target global and local segments with a known start and at least two joints whose target is more than 0.05 rad away | normalized progress spread of those joints above the threshold at any physics step; changing_target_segments counts the segments left out |
0.3 from the design, 0.5 from the bottleneck review; not applicable to planned trajectories, whose joint paths are not straight |
commanded_speed_violation |
arm-ticks whose ten steps recorded the arm's applied targets, with cohorts | an applied-target step between two of the tick's own physics steps, over 0.004 s, above v_cmd; the step from the previous tick's last target is not counted |
v_cmd 4.0 rad/s, the design's candidate (--v-cmd overrides); commanded_peak_rad_s gives the distribution |
tracking_error |
arm-ticks (v1) or the ticks of planned (action, arm) pairs |
largest joint |tick-end measured − waypoint| > 0.03 rad | v1 has no waypoint, so the recorded endpoint target stands in (waypoint_source: recorded_control_target); 0.03 is the proposed ARX joint_convergence_tolerance_rad |
peak_ratio |
planned (action, arm) segments |
measured peak joint speed over the planned peak (waypoint steps over 40 ms) above 1.3 | not_applicable to v1; 1.3 is the L2 proposed bound |
impulse_saturation |
planned ticks whose predicted_in_tick_speed_rad_s is below v_cmd |
a measured joint speed sample ≥ 4.75 rad/s | not_applicable to v1 or without a predicted in-tick command |
link6_peak_speed_m_s |
arm-ticks, by cohort | p50, p90 and max of the largest link6 displacement per physics step over 0.004 s | — |
sag.free_space, sag.holding |
move, plan_ref and precontact segments with a known start and a receipt segment record (recovery segments are not transport); unmatched counts those without a record |
link6 z below min(z start, receipt goal z) − 0.02 m | goal z from arms.<arm>.segments[].target_pose_xyz_xyzw; holding when the segment starts in the holding_mode cohort |
held_then_lost.holding_mode, .closed_command |
closes that ended above the jaw floor + 0.03 (closed_command; the stalled ones also holding_mode) | the jaw at floor + 0.03 at a tick end before the arm's next jaw command (jaw_floor), or, with a replay's private object poses, the object nearest the jaw contact centre (link6 +x 0.1501 m) at the close drifting more than 20 mm in the link6 frame (object_displacement); objects lists each selected object, its distance to the jaw centre and its drift |
ARX gripper tolerance; ARX_X5_GRIPPER_GEOMETRY.contact_baseline_link6_x_m; object_frame_check is consistent when the median selected-object distance is at most 0.05 m, and when it is inconsistent the object counts are null and the numerator is the jaw proxy alone (object_evidence: withheld) |
arrival |
every pose command (move_pose, move_free_space); refusals count as not reached |
every targeted arm ends within 0.01 m and 0.1 rad of its final commanded pose (arguments, or the last receipt segment of a plan_ref move); executed gives the same over commands that advanced a native action |
ARX arrival tolerances |
native_actions.per_command |
commands that advanced a native action, by action kind | native actions per command (distribution) | — |
native_actions.per_segment |
arm-independent segments (a synchronized pair counts once): global, local and by_segment |
native actions per segment (distribution) | a mean over global and local together mixes two routes and is not reported |
native_actions.per_round |
rounds × the task's official native-action limit | native actions used | NATIVE_ACTION_LIMITS |
timeout_stillness |
pose commands ending native_action_budget_exhausted |
every targeted arm moved no joint ≥ 0.005 rad in each of its last three ticks | the SDK executor's controller_stalled rule, restated in motion/measures.py since its motion_stall.py was deleted with it |
Changes from the first cut (robodojo-motion-metrics.v1, never used as a
baseline): segments split by name only, not by name and
target; out-of-step counts constant-target segments only; sag takes its goal
height from the receipt and covers pose segments only; arrival's denominator is
every pose command; closed_jaw became the closed_command cohort beside a
new holding_mode cohort; held-then-lost gained the closed-command cohort and
selects its object by the jaw contact centre; commanded-speed violation, v1
tracking error, peak ratio and impulse saturation were added. Commanded speed
counts only the steps inside each tick (an early v2 report also counted the
step from the previous tick), and a stalled close that ended at the
jaw floor opens no holding-mode episode.
Control replay
The replay contract is control: recorded controls in, physics out; no IK,
planner or executor decision is re-run.
- Inputs, read-only from the sealed native root:
source-manifest.jsonandreset.json(source revisions, layout andactual_source_fingerprint),receipts/action-NNNN.json(round index, status),controller/action-NNNN.json(per tick: segment, recordedcontrol, tick-end measured state includinggripper_feedback), the physics journalcontroller/action-NNNN.jsonlfor the host comparison (one line per physics step, written through one line-buffered handle kept open for the action,common.JournalLines, and closed before the receipt hashes it: the same bytes the per-step open, append and close wrote; a line's applied position and velocity targets and measured state come from one device-to-host copy of every arm's articulation buffers,common.arm_readings, which holds the values the SDK's separate joint, finger and link-pose reads return, bit for bit), andplan.json(runtime,budgets.max_sim_steps, source commit). The worker refuses a plant whose source revisions, layout or actual source fingerprint (loaded files, installed packages, resolved configuration; the device binding is not part of it) differ from the run's. - Round 0 starts from
session.start(); every later round fromsession.restart_round(the session-home joint write and upstream reset the run used). Before each tick the session's gripper directives are restored from the tick's recordedgripper_feedback.requested_opening_normalized, because the publishedgripper_command_targetderives from them and not from physics. Each recordedcontroldict then goes, in order, through the unchangednative_tick(session._conformance_tick) with a physics-step recorder in the session'srecord_physicsfields. - The SDK executor of runs recorded on it could rewrite a retained SDK target
outside any tick: a
motion_stallhold with no native action left wroteprev_controldirectly. To reproduce that, before each tick every target-arm dimension the tick does not command (<arm>_arm_joint_state,<arm>_ee_joint_state) is compared with the recorded first physics line's resolvedcommand, which is that dimension's exact tick-start value (_fixed_meta_controlcopies unrequested dimensions unchanged), and seeded from it when they differ. Seeds are listed inheld_target_seeds; support-arm keys are never seeded. The host's first divergence carries acause_hint: a held dimension that differs at a tick start names an unreproduced out-of-tick rewrite, a support-arm key names the support queue. - The replay counts applied targets that differ from the resolved command instead of raising, and omits the original session's second check, that held dimensions kept their pre-action targets. The host compensates: it compares every applied target of every physics step, held dimensions and support arms included, with the original journal line.
- Actions with no native tick (refusals) are skipped and listed. A
plan_refmove replays its recorded controls and is not re-resolved, so the probe that minted it is not needed. Read-only probes (probe_motion,reach_check,align_plan, grasp IK annotations) and observations advance no physics and are not replayed. A round that turns terminal before its recorded end stops and records the unreplayed ticks. - Private object poses are read after every tick through the evaluator's own
CPU adapter, env-relative. Their frame is recorded as
env_relative (assumed = episode_local), unverified; the worker also records the layout's env origin (frame_probe), and the host'sobject_frame_checkconfirms the frame on the first replay that selects held objects. - The launcher refuses a dirty or non-Git checkout and a worker kernel that is
not admitted for the run.
backends.robodojo.replay_kernel.kernel_admissioncompares every file of either commit's worker-kernel manifest. A file in the reviewed executor-only table (sparse_motion.py,recovery.py,motion_adapter.py,wait.py,ik.py,contracts/planning_diagnostics.py, andmotion_stall.py,staged_contact.pyandinter_arm.py, deleted with the SDK executor, each with its reason) may change, or be gone, except for the names the replay reaches (session constants,recovery.configured_route,sparse_motion.gripper_closed_floor); every other file may only add: each top-level name the run's version binds must bind identically (every binding, AST without line numbers),__all__may only grow and new names may appear. In both, module-level statements that bind no name must be unchanged, and a reached name bound at neither commit refuses.session,bridge,round_lifecycle,feedbackandobservationreference the table's modules only through reached names or reviewed callers the replay never runs (execute_sparse_motion_v3,solve_ik,probe_motion,RobodojoMotionBackendAdapter); a test holds the scan to the table. The status isidentical_kernel,executor_drift_admitted(the report then carries akernel_noticethat the kernel is not the run's and was admitted by AST equivalence) orcontrol_path_changed. - Each pass stages its
TMPDIR/TMP/TEMPthroughhost_storage.stage_launchand releases it afterwards, claims its slot lease (a conflict refuses; retry when the slot frees), and runs the worker in its own process group, killed as a group on timeout or interrupt. The worker's pid and process group are written tolaunch.jsonas soon as it starts. In paralleldeterminism, the main thread's SIGINT/SIGTERM handler kills every registered group, so the pool threads blocked inwaitreturn; the serial path is unchanged. - Outputs, per pass under
--output:worker-config.json,worker.log,launch.json(replay id, profile, command, run scratch, and the commit, worker-kernel digest, kernel admission and replay-worker digest at launch; then the exit code and seconds),environment/(the session root, with replayedcontroller/action-NNNN.json{,l}in the original layout),private/object-poses.jsonl(qualification evidence, never policy-visible) andreplay-worker.json; thenrobodojo-motion-replay-report.json(ora.robodojo-motion-replay-report.v1) with the run and Harness identities, the metric-definition version, per-pass physics-step divergence, the metrics of the original and the replay, and the failures.--report-onlyrebuilds it on any machine; outside a Git checkout the Harness identity fields arenull,rebuilt_outside_gitis true and the launched-at-this-commit check is skipped.
| Mode | Passes | Passes when |
|---|---|---|
replay |
one | every selected tick replays without a worker error or applied-target mismatch; arm joints, finger joints, the normalized jaw, link6 position and every applied target equal the original's on every physics step; the pass ran at this commit with an admitted kernel |
metrics-after-replay (default) |
one | as replay, and the replayed journals' metrics equal the original's |
determinism |
two, in parallel with --second-resource-profile |
as metrics-after-replay for each, and the two passes agree on every physics step. Private object poses get their own status (within_bound, exceeds_bound, unmatched or unavailable) against 1 mm and do not decide the result; if they exceed it, drop metrics use the replay-to-replay spread as their noise floor |
Operator command, on the qualified host from the clean committed checkout with
.env sourced for the ROBODOJO_* paths (the runtime's python_env, normally
ROBODOJO_PYTHON, selects the worker interpreter):
export ORA_EXECUTION_HOST=<host-id>
export TMPDIR=<writable scratch on a partition with free space> # the launcher's own TMPDIR
./scripts/ora qualify robodojo motion-replay \
--run outputs/<experiment>/runs/<run_id> \
--output outputs/<experiment>/diagnostics/motion-replay/<run_id>-<stamp> \
--resource-profile robodojo-gpu4-d1 --mode metrics-after-replay [--upto N]
The worker's own TMPDIR is the per-pass run scratch, not the launcher's.
Acceptance replays a few recorded runs in determinism mode; a pass costs the
run's native actions in stepping plus one simulator start of about 90 s. No
replay has run on this implementation yet. The design
places the intent mode in L0 as well; it is not implemented here (it needs a
candidate executor and re-issues the probes that minted consumed plan_refs),
and neither are the ARX control profile and its validator.
Known limits of a control replay:
- The replay turns execution capture off, also for a run recorded with it on. Capture renders after physics steps; that it leaves the plant unchanged is expected but not yet shown.
- Policy observations are not replayed. Runs of imitate_sorting_sequence and
make_kong journal a
support_arm0key; an observation may consume the support-arm queue, and the probe clock guard does not see that. When the first divergence falls on a support key (cause_hint: support_arm_target), check this first.
RoboDojo physics scene probe
The CPU-physics lane (lifecycle)
runs nine scenes on IsaacLab cpu physics. Whether each scene actually
behaves there (the belt moves objects, articulations initialize and hold, the
liquid exists) is a physics question no card or scene smoke answers, so a
bounded qualification-only probe measures it. It is development evidence for
the lane's design: it admits nothing, binds no card or gate and is never
policy-visible.
| Module | Runs in | Role |
|---|---|---|
ora/orchestrator/backends/robodojo/physics_probe.py |
Harness interpreter | Launcher (default runtime of the task on the slot's GPU, slot lease, worker configuration, per-cell scratch, process group), the judge and the report. |
ora/environment/backends/robodojo/physics_scene_probe.py |
RoboDojo interpreter | The worker: an in-process RobodojoSession reset on layout 0, held with session._conformance_tick({}). |
No worker entry point imports the worker module, so it is outside the worker kernel and its edits stale no card or gate. Per cell the worker:
- resets the task (
session.start()) and reads the physics mode back once: IsaacLab's simulation device,use_fabric,/physics/suppressReadback,/physics/fabricEnabled, PhysXget_overwrite_gpu_setting()(upstream forces1, GPU), each physics scene's GPU-dynamics and broadphase attributes, andSimulationManager.get_physics_sim_device(); - reads every
PhysxSurfaceVelocityAPIbelt with its surface velocity and world bounds; - holds
--ticksnative actions (default 100 for a conveyor, 50 otherwise), stopping early only on the official terminal, and every--sample-everyticks (and at 0 and the last tick) records every layout instance's world position, articulation joint positions, and fluid particle counts, finiteness and bounds; - in a scene with a liquid, records at tick 0 and at the end of the hold
(
fluid_evaluator_inputs) the raw inputs of the official fluid predicateis_A_fluid_in_B: each labelled liquid's particle positions as upstream returns them with its layout init pose, and each labelled rigid or geometry instance's env-relative pose and local oriented-bbox vertices. They support a read-only offline replay of the predicate; the judge does not read them; - with
--in-place-restart, also restarts round 1 in place and reads each rigid object'sphysxRigidBody:disableGravityandphysics:collisionEnabledbefore and after (the CPU in-place restart hazard; report only).
The two fluid tasks used --probe-only-native-action-limit (their upstream
step_lim, 400 and 800) until their admission; the probe-only table
is now empty, and the flag is refused for an admitted task.
A cell passes when the worker held every requested tick (or the official terminal ended the hold); the IsaacLab simulation device is the declared one (on CPU without Fabric or suppressed readback); no object fell more than 0.03 m below its reset height, went below the floor, became non-finite or vanished; and, by scene kind, every rigid object resting on a belt stays within 0.03 m of the belt top and advances at least half the belt speed per native action (0.1 m/s x 0.04 s = 4 mm), every articulation's joints stay finite and within 0.05 of reset, and every fluid object has a positive, finite and constant particle count.
# From a clean committed checkout on a registered host; one cell per task x slot, all cells in parallel.
ORA_EXECUTION_HOST=<host-id> ./scripts/ora qualify robodojo physics-probe \
--output <dir> --cell press_by_number:robodojo-gpu4-d1 --cell pick_from_conveyor_by_image:robodojo-gpu5-d1
# rejudge existing cells without a simulator
./scripts/ora qualify robodojo physics-probe --output <dir> --report-only
Each cell writes <dir>/<task>--<profile>/ (launch.json, worker-config.json,
worker.log, probe-worker.json, the worker's environment/), and the run
writes <dir>/robodojo-physics-scene-probe-report.json
(ora.robodojo-physics-scene-probe.v1) with per-cell checks and
failures. --physics-device overrides every cell's device for a comparison and
is recorded per cell.
The CPU lane's other qualification is the usual one, keyed on the device: a
CPU terminal card (run.py card --gpu N --physics-device cpu, measured on a
CPU-physics task and shareable to another GPU with shared_from), one CPU
scene smoke and revalidation per lane (gates/<task>-cpu-gpu<N>.json), and,
before a motion_action_v3 CPU cell can resolve, the scripted sparse-motion
gate run on a CPU runtime with its record cited beside
definitions.SPARSE_MOTION_QUALIFIED_PHYSICS_DEVICES. No CUDA card or gate is
re-measured. That CPU record passed 24/24 cases of the v1 table (swap_blocks),
so CPU cells now resolve. On the same
host and source all nine scenes passed the physics probe (both conveyors carry
objects at the belt's 4 mm per native action), the CPU card passed on
pour_liquid_into_cup, and seven CPU scene smokes passed; fill_egg_holder and
pour_liquid_into_cup failed the smoke's in-place round restart ("official
layout did not settle stably"), the documented CPU restart hazard. Since a CPU
lane runs one round (rule robodojo_cpu_in_place_restart), an unscheduled CPU
smoke no longer restarts in place: it records checks.round_reset = not_applicable_cpu_single_round and restart: null, and revalidation accepts
that for an unscheduled CPU runtime only (coverage drops round_reset from
fresh; the in-place boundary stays under not_established). A
layout-scheduled CPU smoke and every CUDA smoke still require the reset.
For intentional control-path changes, add --allow-kernel-drift to
ora qualify robodojo motion-replay. The default remains strict. This flag
permits control_path_changed at launch and report evaluation; it does not
permit a dirty checkout, an unresolvable kernel identity, or a different commit
between launch and report. Both launch identities and the report retain
kernel_admission.status, differing, and refused_changes; the report adds a
structured warnings entry and kernel_notice. Rebuilding with --report-only
also requires the explicit flag. All tick, target, metric and determinism checks
remain unchanged: a physical difference still fails. This is a diagnostic
validation override, not a claim that the kernels are equivalent.
RoboDojo scripted motion gate
ORA_EXECUTION_HOST=<host-id> ./scripts/ora qualify robodojo motion \
--runtime-config CONFIG --output DIR [--gate FILE]
The host is orchestrator/backends/robodojo/qualification.py; the cases and
their judges are environment/backends/robodojo/motion_checks.py and the runner
motion_qualification.py. It starts one worker through the production
factory/RPC bootstrap with a host-owned execution state, runs no policy, and
writes DIR/robodojo-sparse-motion-qualification.json
(ora.robodojo-sparse-motion-qualification.v2); only a passing record is copied
to --gate. The former python -m host refuses with this command in its error
message.
Route. From v2 every arm motion is the one an episode runs. The host plans
each move with the toolkit lib (MatrixPlanner) over the worker's read-only
kinematics query and binds a follow_joint_trajectory; the worker executes it,
lent native_action_cap native actions as a tool lends them. A move is planned
as move_pose plans a compiled request at its default speed: the fast pace and
its settle, the interaction label choosing the route (lib.motion_plan.route,
with the default surfaces' staged contact approach), the orientation used
exactly (no jaw-twin choice). The home recovery is planned as return_home plans
it and the retrace as recover_pose does. Jaw commands are the rate-limited
set_gripper, holds are wait. No case sends move_pose, move_free_space,
recover_motion or a string set_gripper target; the worker refuses the first
three before any write (unsupported_action_for_backend) since the SDK executor
that ran them was removed.
Planner, timing and motion profile. The runtime binds motion_planner,
motion_timing and motion_profile; a configuration without them gets those of
the default baseline (robodojo_toolkit_v7; motion profile v2 since 2026-11-15),
and session.motion_stack_source records which. Every move is planned at the
bound profile's fast (MatrixPlanner.config) and session.motion_profile names
the profile (profile_id, path, sha256). A
field present but not an object is refused. Before the worker starts, the host
starts the timing worker and writes its passing check to DIR/preflight.json,
which the worker binds (motion_timing.bind_preflight); without it the worker
would time with motion_pace's fallback. A timing worker that does not start
stops the gate before the simulator. session.free_route is global: a
free-space move must take the shared planner's path, so a silent fall back to
the joint line fails its case.
Motion matrix, round 0, each case starting where the previous one ended:
| Case | Request | Passes when |
|---|---|---|
free_space_translation_8cm |
free space, (-8, +6, +4) cm | reached on the free route |
combined_translation_rotation_45deg |
free space, 6 cm and 45 degrees about the approach axis | reached on the free route |
orientation_only_small_12deg |
precision, 12 degrees | reached on line |
orientation_only_90deg |
free space, 90 degrees | reached, stopped, or refused before any action |
orientation_only_near_180deg |
free space, 179 degrees | as the 90-degree case |
precision_small_local_6mm |
precision, +6 mm z | reached on line |
contact_approach_small_8mm |
contact approach, -8 mm z | reached or stopped, on line (with the contact-path check where the planner runs) |
contact_approach_staged_80mm |
contact approach, -80 mm z | reached or stopped, on staged |
planner_refusal_unreachable |
free space to UNREACHABLE_POSITION |
refused before any action with goal_unreachable (paced_path_unreachable on the joint route) |
below_tolerance_noop |
precision, the current pose | reached on line |
dual_arm_synchronized_lift |
free space, both arms +4 cm | both arms reached in one trajectory |
trajectory_step_exceeds_limit |
knots: a hold, then joint 1 by 1.5 x 0.2 rad | plan_rejected, trajectory_step_exceeds_limit, no native action |
trajectory_joint_limit |
knots: joint 1 at 4 pi rad | plan_rejected, trajectory_joint_limit, no native action |
A reached case also needs the joint_trajectory strategy and the
knots_linear_ff executor, and each targeted arm within the ARX arrival
tolerance both of its last knot's forward kinematics (the receipt's
pose_error) and of the requested target. Every executed case needs the
untargeted arm to drift less than 5 mm and a verified command invariant; a
rotation-only case needs link6 to move less than 30 mm, whatever its outcome.
Sequence cases:
| Case | What runs | Passes when |
|---|---|---|
recover_home_after_matrix |
home recovery of both arms | reached, each arm within tolerance of its reset pose |
gripper_close_holds_pose, gripper_open_holds_pose |
rate-limited set_gripper |
reached by the ramp executor within the gripper tolerance, pose targets unchanged |
recover_retrace_after_move |
a 5 cm planned lift, then a retrace | the lift reached; the retrace reached the pre-lift pose |
jaw_flip_variants_probed |
probe_motion with parallel_jaw_equivalents |
two variants |
probe_consistency_unreachable |
a probe of, then a move to, UNREACHABLE_POSITION |
the probe says unreachable and the move is refused for reach; nothing runs |
official_preterminal_boundary |
the verdict before the limit | no verdict, not terminal |
official_terminal_boundary_intact |
20-tick waits to the official limit |
a terminal official Boolean at the limit; a later action refused; the verdict stable on reads |
round_reset_isolation |
restart round 1, then a 4 cm planned lift | reset record, terminal revoked, fresh observation, arm home, round-1 counters restarted |
Removed in v2, because nothing an episode runs can reach them:
probe_then_plan_ref_execution, plan_ref_survives_gripper_only,
plan_ref_expires_after_motion and the stale-reference check of
round_reset_isolation (a probe mints no plan reference since it answers from
the shared planner's IK, and the toolkit refuses plan_ref);
free_space_lift_translate_descend (the SDK executor's lift, translate and
descend segments: a planned path has none); contact_approach_large_refused
(the SDK executor's route refusal: the toolkit chooses the route now, and the
default surfaces stage such a move, contact_approach_staged_80mm). The
2-pi-alias monitor is gone with the SDK IK endpoint: a rotation is a planned
joint path whose wrist turn the timing checks (paced_path_wrist_unwind), and
the 30 mm bound is all that remains of it. recover_backtrack_after_move became
recover_retrace_after_move, the recovery the trajectory surfaces run.
Not measured. The matrix runs in free air, so the tracking and
growing-error stops, the progress guard and the settle failure, the stops
recorded episodes trip most, never fire; no jaw closes on an object. The card
and task probes and the scene smoke still drive ora-action.v3 through the
SDK's IK, so their evidence stays on a route no episode runs. The unit tests
drive the whole gate over the fake plant, which has no shared planner: there
free-space moves take the joint route, and only a run on a card exercises
plan_path, the timing worker and contact_path.