react-manip 0.1.0__py3-none-any.whl

react_manip/instances/runtime.py

@@ -0,0 +1,306 @@
+"""Versioned physical adapters; all runtime sampling is confined to generation.
+
+Initial state uses MuJoCo's version-bound integration vector. Controllers start
+from reset targets at that state; this is an initial-state format, not a generic
+mid-trajectory checkpoint. No simulator state is assigned during env.step().
+"""
+from copy import deepcopy
+import hashlib
+import json
+from pathlib import Path
+import sys
+import warnings
+
+import numpy as np
+
+from .records import VERSION, SUPPORTED_TASKS, digest, seal, validate_pair, validate_record, validate_parameters
+
+ROOT = Path(__file__).resolve().parents[2]
+from react_manip.robots.sensors import policy_camera_ids
+
+_SOURCE_DRIFT_WARNED: set[str] = set()
+
+
+def _check_runtime_identity(actual, expected, task_id):
+    """Validate compiled runtime fields while tolerating evaluator-only drift.
+
+    Saved instances contain a broad source digest. Changes to the viewer or
+    evaluator control flow must not invalidate already-recorded physical
+    scenes, so a source-digest-only difference is reported as a warning. Model,
+    controller, camera, and physics identity changes remain hard failures.
+    """
+
+    mismatches = [key for key in expected if actual.get(key) != expected.get(key)]
+    mismatches.extend(key for key in actual if key not in expected)
+    if not mismatches:
+        return
+    if set(mismatches) == {'source_digest'}:
+        if task_id not in _SOURCE_DRIFT_WARNED:
+            warnings.warn(
+                f'{task_id}: saved source digest differs from the current evaluator; '
+                'continuing because compiled runtime identity matches',
+                RuntimeWarning,
+                stacklevel=3,
+            )
+            _SOURCE_DRIFT_WARNED.add(task_id)
+        return
+    raise ValueError('compiled model/controller/runtime mismatch')
+
+
+def source_digest(task_id):
+    paths = list((ROOT / 'react_manip').rglob('*.py')) + list((ROOT / 'tasks' / task_id).rglob('*.py'))
+    paths += list((ROOT / 'tasks' / task_id).rglob('*.xml'))
+    return digest({str(p.relative_to(ROOT)): hashlib.sha256(p.read_bytes()).hexdigest() for p in sorted(paths)})
+
+
+def _json(value):
+    if isinstance(value, np.ndarray):
+        return value.tolist()
+    if isinstance(value, np.generic):
+        return value.item()
+    if isinstance(value, dict):
+        return {str(k): _json(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_json(v) for v in value]
+    return value
+
+
+def _model_digest(env):
+    # Hash compiled geometry/dynamics/assets, not XML temporary file names.
+    model = env.sim.model._model
+    names = ('qpos0 body_pos body_quat body_mass body_inertia body_ipos body_iquat '
+             'jnt_type jnt_axis jnt_pos jnt_range dof_damping dof_frictionloss dof_armature '
+             'geom_type geom_bodyid geom_pos geom_quat geom_size geom_friction geom_solref geom_solimp '
+             'geom_contype geom_conaffinity geom_condim pair_friction pair_solref pair_solimp '
+             'actuator_gainprm actuator_biasprm actuator_dynprm actuator_ctrlrange actuator_forcerange '
+             'eq_data eq_type eq_obj1id eq_obj2id mesh_vert mesh_face mesh_normal '
+             'cam_bodyid cam_pos cam_quat cam_fovy light_pos light_dir light_diffuse light_specular light_ambient '
+             'geom_rgba geom_matid mat_rgba mat_texid mat_texrepeat mat_emission mat_specular mat_shininess mat_reflectance tex_data').split()
+    h = hashlib.sha256()
+    for name in names:
+        value = getattr(model, name, None)
+        if value is not None:
+            array = np.ascontiguousarray(value)
+            h.update(name.encode()); h.update(str((array.shape, str(array.dtype))).encode()); h.update(array.tobytes())
+    h.update(bytes(model.names))
+    h.update(str((model.nq, model.nv, model.na, model.nu, model.opt.timestep,
+                  model.opt.integrator, model.opt.solver, model.opt.iterations,
+                  model.opt.tolerance, tuple(model.opt.gravity))).encode())
+    return h.hexdigest()
+
+
+def spec_for(task_id):
+    from react_manip.core.specs import load_task_spec
+    if task_id not in SUPPORTED_TASKS:
+        raise ValueError('task has not passed the instance adapter gate')
+    return load_task_spec(ROOT / 'tasks' / task_id / 'task_spec.json')
+
+
+def contract_for(task_id):
+    return json.loads((ROOT / 'tasks' / task_id / 'instance_contract.json').read_text())
+
+
+def _construct(task_id, scenario, robot_id=None, episode=None, *, render=False):
+    from react_manip.builtin import discover_task_definitions
+    definition = next((s, f) for s, f in discover_task_definitions(task_ids=(task_id,)) if s.task_id == task_id)
+    if episode is None:
+        episode = deepcopy(scenario.metadata.get('initial_episode_scene'))
+    extra = {'episode_instance': episode} if task_id in ('phone_lean','leveling_board1','rope_hang','laptop_into_drawer') else {}
+    env = definition[1](**extra, scenario=scenario, robot_id=robot_id, seed=scenario.seed,
+                        initialization_noise=None, has_renderer=render, has_offscreen_renderer=False,
+                        use_camera_obs=False)
+    return env
+
+
+def runtime_identity(env, task_id):
+    import mujoco
+    import robosuite
+    raw = getattr(env, 'env', env)
+    spec = spec_for(task_id)
+    controllers = [r.composite_controller.composite_controller_specific_config
+                   if hasattr(r.composite_controller, 'composite_controller_specific_config') else {}
+                   for r in raw.robots]
+    # Per-arm config is the concrete config supplied to controller construction.
+    controllers += [getattr(r, 'controller_config', {}) for r in raw.robots]
+    for robot in raw.robots:
+        controllers.append({name: {
+            'class': type(part).__module__ + '.' + type(part).__name__,
+            **{key: _json(getattr(part, key)) for key in (
+                'input_min', 'input_max', 'output_min', 'output_max', 'kp', 'kd',
+                'damping_ratio', 'control_dim', 'input_ref_frame', 'input_type', 'impedance_mode')
+               if hasattr(part, key)}} for name, part in robot.composite_controller.part_controllers.items()})
+    return dict(python='.'.join(map(str, sys.version_info[:2])), numpy=np.__version__,
+                mujoco=mujoco.__version__, robosuite=robosuite.__version__,
+                source_digest=source_digest(task_id), control_hz=spec.control_hz,
+                horizon_sec=spec.horizon_sec, physics_timestep=float(raw.sim.model.opt.timestep),
+                model_digest=_model_digest(raw),
+                action_layout=_json(raw.robots[0].composite_controller._action_split_indexes),
+                controller_digest=digest(_json(controllers)), cameras=list(policy_camera_ids(raw.robot_id if hasattr(raw, 'robot_id') else spec.supported_robots[0])))
+
+
+def capture_state(env):
+    import mujoco
+    raw = getattr(env, 'env', env)
+    model, data = raw.sim.model._model, raw.sim.data._data
+    state_spec = int(mujoco.mjtState.mjSTATE_INTEGRATION)
+    vector = np.empty(mujoco.mj_stateSize(model, state_spec))
+    mujoco.mj_getState(model, data, vector, state_spec)
+    return dict(format='mujoco.integration.v1', state_spec=state_spec, integration_state=vector.tolist())
+
+
+
+
+
+
+class ReplayEnv:
+    """Bind explicit episodes to an instance; never forward their files to policy."""
+    def __init__(self, instance, *, cameras=True, native_actions=False):
+        self._native_actions = native_actions
+        validate_record(instance)
+        spec = spec_for(instance['task_id'])
+        if digest(spec.to_dict()) != instance['task_spec_digest'] or digest(contract_for(spec.task_id)) != instance['contract_digest']:
+            raise ValueError('TaskSpec/instance contract version mismatch')
+        validate_parameters(instance['scenario']['parameters'], contract_for(spec.task_id))
+        from react_manip.core.scenarios import Scenario
+        data = instance['scenario']
+        scenario = Scenario(**{k: deepcopy(v) for k, v in data.items() if k != 'digest'})
+        self._instance = deepcopy(instance)
+        self._cameras = cameras
+        self._episode = None
+        self._wrapped = _construct(spec.task_id, scenario, instance['robot_id'])
+        self.env = self._wrapped.env  # policy geometry filter expects the task here
+        try:
+            self._wrapped.reset()
+            _check_runtime_identity(runtime_identity(self._wrapped, spec.task_id),
+                                    instance['runtime'], spec.task_id)
+            if cameras:
+                self._wrapped.set_camera_observations(instance['runtime']['cameras'])
+        except BaseException:
+            self.close()
+            raise
+
+    def __getattr__(self, name):
+        return getattr(self._wrapped, name)
+
+    def bind(self, episode):
+        validate_pair(self._instance, episode)
+        if 'variation' in episode or (self._episode and 'variation' in self._episode):
+            from react_manip.core.scenarios import Scenario
+            from .variation import episode_scenario
+            data = self._instance['scenario']
+            scenario = Scenario(**{k: deepcopy(v) for k,v in data.items() if k != 'digest'})
+            if 'variation' in episode:
+                scenario = episode_scenario(scenario, episode['variation'])
+            candidate = _construct(self._instance['task_id'], scenario,
+                                   self._instance['robot_id'], episode=episode.get('scene'))
+            try:
+                candidate.reset()
+                expected = episode.get('runtime', self._instance['runtime'])
+                _check_runtime_identity(runtime_identity(candidate, self._instance['task_id']),
+                                        expected, self._instance['task_id'])
+                if self._cameras:
+                    candidate.set_camera_observations(expected['cameras'])
+            except BaseException:
+                candidate.close()
+                raise
+            self._wrapped.close()
+            self._wrapped, self.env = candidate, candidate.env
+        if self._instance['task_id'] == 'phone_lean':
+            # Poses reference the explicit Episode scene.
+            self.env.episode_instance = deepcopy(episode['scene'])
+            self.env.episode_seed = episode['scene']['episode_seed']
+            self.env.layout_seed = self.env.episode_seed
+        if self._instance['task_id'] in ('leveling_board1','rope_hang','laptop_into_drawer'):
+            self.env.episode_instance = deepcopy(episode['scene'])
+        self._episode = deepcopy(episode)
+
+    def reset(self, *, seed=None, **kwargs):
+        if seed is not None or kwargs:
+            raise ValueError('explicit episode replay forbids seed/options overrides')
+        if self._episode is None:
+            raise ValueError('bind an Episode Instance before reset')
+        import mujoco
+        self._wrapped.reset()
+        self._wrapped._episode_index = 0
+        raw = self.env
+        saved = self._episode['initial_state']
+        if self._instance['task_id'] in ('rail_ball_to_cup', 'pitch_pot', 'conveyor_grasp', 'turntable_gamble1', 'ring_toss1', 'box_insertion', 'car_drive2', 'rope_hang', 'pan_flip', 'button_indicator_matching', 'laptop_into_drawer', 'find_object_in_drawer2', 'tilte_maze'):
+            # State must match the resolved model's reset, including Episode
+            # parameters; arbitrary resealed robot/object pose edits are forbidden.
+            if saved != capture_state(self._wrapped):
+                raise ValueError(f"{self._instance['task_id']} forbids Episode initial-state variation")
+        model, data = raw.sim.model._model, raw.sim.data._data
+        if saved['state_spec'] != int(mujoco.mjtState.mjSTATE_INTEGRATION):
+            raise ValueError('initial state mask mismatch')
+        vector = np.asarray(saved['integration_state'], dtype=float)
+        if vector.shape != (mujoco.mj_stateSize(model, saved['state_spec']),) or not np.isfinite(vector).all():
+            raise ValueError('initial state shape/value mismatch')
+        # This v1 format supports reset states only, not arbitrary task checkpoints.
+        if vector[0] != 0:
+            raise ValueError('initial state time must be zero')
+        mujoco.mj_setState(model, data, vector, saved['state_spec'])
+        raw.sim.forward()
+        raw.timestep = 0
+        raw.cur_time = 0
+        raw.done = False
+        for robot in raw.robots:
+            robot.composite_controller.update_state()
+            robot.composite_controller.reset()
+            for controller in robot.composite_controller.part_controllers.values():
+                if hasattr(controller, 'reset_goal'):
+                    controller.reset_goal()
+        if self._instance['task_id'] == 'car_drive2':
+            # Native reset restores Python vehicle state; sync moving controller origins.
+            raw._set_car_pose()
+        # Resetting targets may touch controls; restore the exact integration input.
+        mujoco.mj_setState(model, data, vector, saved['state_spec'])
+        raw.sim.forward()
+        if self._instance['task_id'] in ('button_indicator_matching', 'find_object_in_drawer2'):
+            raw.set_episode_targets(self._episode['round_plan']['targets'])
+            raw._episode_index = 0
+        else:
+            raw._attempt = 1
+        raw._update_observables(force=True)
+        obs = raw._get_observations(force_update=True)
+        if self._instance['task_id'] in ('button_indicator_matching', 'conveyor_grasp'):
+            obs = raw._observation(obs)
+        elif self._instance['task_id'] == 'box_insertion':
+            obs = raw._observation()
+        prompt = self._wrapped.get_language_prompt()
+        self._wrapped.language_prompt = prompt
+        # mj_forward refreshes warm-start acceleration by tiny roundoff amounts.
+        # Restore the recorded integration input after all derived observations.
+        obs = self._wrapped._with_camera_observations(obs)
+        mujoco.mj_setState(model, data, vector, saved['state_spec'])
+        return obs, {
+            'success_state': False, 'terminal_success': False, 'events': [],
+            'language_prompt': prompt['text'], 'language_prompt_structured': prompt}
+
+    def step(self, action):
+        action = np.asarray(action, dtype=float)
+        low,high=-np.ones(self._wrapped.action_dim),np.ones(self._wrapped.action_dim)
+        if self._native_actions:
+            robot=self.env.robots[0]
+            for arm in robot.arms:
+                part=robot.part_controllers[arm]
+                if part.name=='JOINT_POSITION' and getattr(part,'input_type',None)=='absolute':
+                    s,e=robot.composite_controller._action_split_indexes[arm]
+                    limits=self.env.sim.model.jnt_range[part.joint_indexes['joints']]
+                    low[s:e],high[s:e]=limits[:,0],limits[:,1]
+        if (action.shape != low.shape or not np.isfinite(action).all()
+                or np.any(action<low-1e-8) or np.any(action>high+1e-8)):
+            raise ValueError('action must be finite and inside the recorded controller bounds')
+        result = self._wrapped.step(action)
+        if not np.isfinite(self.env.sim.data.qpos).all() or not np.isfinite(self.env.sim.data.qvel).all():
+            raise ValueError('non-finite simulation state; evaluation is invalid')
+        # Refresh language after dynamic round transitions; do not send the future plan.
+        prompt = self._wrapped.get_language_prompt()
+        self._wrapped.language_prompt = prompt
+        obs, reward, terminated, truncated, info = result
+        if self._instance['task_id'] == 'rope_hang' and (info.get('failure') or {}).get('reason') in ('physics_instability', 'non_finite_state'):
+            raise ValueError('numerical rope simulation failure; evaluation is invalid')
+        info = dict(info, language_prompt=prompt['text'], language_prompt_structured=prompt)
+        return obs, reward, terminated, truncated, info
+
+    def close(self):
+        self._wrapped.close()

react_manip/instances/suite.py

@@ -0,0 +1,231 @@
+"""Manifest execution. Files stay on the evaluator side of the policy boundary."""
+import json
+import math
+import time
+from pathlib import Path
+
+from .records import VERSION, SUPPORTED_TASKS, load_suite, save_record, seal
+from react_manip.core.timeouts import (
+    DEFAULT_TASK_WALL_TIMEOUT_SEC,
+    USE_DEFAULT_TASK_WALL_TIMEOUT,
+    resolve_task_wall_timeout_sec,
+    validate_timeout,
+)
+
+PROTOCOL = dict(name='practice_exam', practice_episodes=10, exam_episodes=5,
+                exam_adaptation='online', invalid='abort_group',
+                clock='synchronous_simulation', score='mean_exam_task_score', policy_track='public')
+
+
+
+
+
+
+def evaluate(path, policy_factory, *, cameras=True, runner=None, env_factory=None, on_result=None,
+              trace_dir=None, visualize=False, video_dir=None, policy_factory_for_robot=None,
+              close_policy=False, task_wall_timeout_sec=USE_DEFAULT_TASK_WALL_TIMEOUT,
+              episode_wall_timeout_sec=None):
+    if (visualize or video_dir is not None) and not cameras:
+        raise ValueError('visualization and video require policy images')
+    from react_manip.evaluation.viewer import EvaluationViewer
+    with EvaluationViewer(enabled=visualize, video_dir=video_dir) as viewer:
+        return _evaluate(path, policy_factory, cameras=cameras, runner=runner,
+                         env_factory=env_factory, on_result=on_result,
+                         policy_factory_for_robot=policy_factory_for_robot, close_policy=close_policy,
+                         trace_dir=trace_dir, viewer=viewer if viewer.active else None,
+                         task_wall_timeout_sec=task_wall_timeout_sec,
+                         episode_wall_timeout_sec=episode_wall_timeout_sec)
+
+
+def _evaluate(path, policy_factory, *, cameras=True, runner=None, env_factory=None,
+              on_result=None, trace_dir=None, viewer=None, policy_factory_for_robot=None, close_policy=False,
+              task_wall_timeout_sec=USE_DEFAULT_TASK_WALL_TIMEOUT, episode_wall_timeout_sec=None):
+    """Fresh policy per instance; all fifteen episodes retain learned state."""
+    from react_manip.core.runner import BenchmarkRunner
+    from react_manip.evaluation.protocols import _EpisodePolicy
+    from react_manip.evaluation.viewer import SkipEpisode
+    from .runtime import ReplayEnv, spec_for, contract_for
+    manifest, groups = load_suite(path)
+    if trace_dir is not None:
+        trace_dir = Path(trace_dir)
+        trace_dir.mkdir(parents=True, exist_ok=False)
+    runner = runner or BenchmarkRunner()
+    env_factory = env_factory or ReplayEnv
+    explicit_episode_timeout = validate_timeout(episode_wall_timeout_sec, 'episode_wall_timeout_sec')
+    task_started = {}
+    task_timeouts = {}
+    timed_out_tasks = set()
+    rows, outcomes = [], []
+    for instance, episodes in groups:
+        task_id = instance['task_id']
+        task_started.setdefault(task_id, time.perf_counter())
+        task_timeouts.setdefault(task_id, resolve_task_wall_timeout_sec(task_id, task_wall_timeout_sec))
+        task_timeout = task_timeouts[task_id]
+        task_deadline = None if task_timeout is None else task_started[task_id] + task_timeout
+        if task_id in timed_out_tasks or (task_deadline is not None and time.perf_counter() >= task_deadline):
+            timed_out_tasks.add(task_id)
+            outcomes.append({'task_instance_id': instance['task_instance_id'], 'valid': False,
+                             'exam_scores': [], 'error': 'wall_clock_timeout',
+                             'completed_episodes': 0, 'skipped_episodes': len(episodes), 'score': None,
+                             'timeout_scope': 'task'})
+            continue
+        group_rows, error, env, policy = [], None, None, None
+        try:
+            policy = policy_factory_for_robot(instance['robot_id']) if policy_factory_for_robot else policy_factory()
+            for name in ('begin_episode', 'end_episode'):
+                if not callable(getattr(policy, name, None)):
+                    raise TypeError(f'policy requires {name}')
+            if getattr(policy, 'requires_geometry_truth', False):
+                raise ValueError('public track rejects privileged geometry policies')
+            env = env_factory(instance, cameras=cameras)
+            spec = spec_for(instance['task_id'])
+            score_key = contract_for(instance['task_id'])['evaluation']['score_key']
+            for index, episode in enumerate(episodes):
+                if task_deadline is not None and time.perf_counter() >= task_deadline:
+                    timed_out_tasks.add(task_id)
+                    error = 'wall_clock_timeout'
+                    break
+                phase = 'practice' if index < 10 else 'exam'
+                env.bind(episode)
+                # Policy RNG seed is protocol-owned and is not the private environment seed.
+                session = _EpisodePolicy(policy, phase, index if index < 10 else index-10, index)
+                writer = None
+                if viewer:
+                    viewer.begin_episode(instance['task_id'], episode['episode_id'], phase,
+                                         index if index < 10 else index-10, spec.control_hz)
+                callback = None
+                if trace_dir is not None:
+                    from .trajectory import TrajectoryWriter, RecordingPolicy
+                    writer = TrajectoryWriter(trace_dir / episode['episode_id'], {
+                        'manifest_digest': manifest['content_digest'], 'task_instance_digest': instance['content_digest'],
+                        'episode_digest': episode['content_digest'], 'runtime': episode.get('runtime', instance['runtime']),
+                        'phase': phase, 'policy_id': session.policy_id,
+                        'policy_provenance': getattr(policy, 'provenance', None),
+                        'policy_track': 'public', 'cameras_enabled': cameras,
+                        'action_application': 'reject invalid; no clipping',
+                        'control_hz': spec.control_hz})
+                    session = RecordingPolicy(session, writer)
+                    def callback(current_env, step, result):
+                        from react_manip.core.observation import policy_observation
+                        writer.write({'type': 'transition', 'tick': step-1,
+                                      'sim_time_sec': float(current_env.env.sim.data.time),
+                                      'next_observation': policy_observation(result.observation, spec, current_env),
+                                      'reward': result.reward, 'terminated': result.terminated,
+                                      'truncated': result.truncated, 'info': result.info})
+                trace_callback = callback
+                def callback(current_env, step, result):
+                    if trace_callback:
+                        trace_callback(current_env, step, result)
+                    if viewer and (result.done or step >= round(spec.horizon_sec * spec.control_hz)):
+                        from react_manip.core.observation import policy_observation
+                        viewer.observe(current_env, policy_observation(result.observation, spec, current_env), result.info)
+                skipped = False
+                try:
+                    remaining = None if task_deadline is None else max(1e-6, task_deadline - time.perf_counter())
+                    runner_episode_timeout = explicit_episode_timeout
+                    if runner_episode_timeout is None:
+                        runner_episode_timeout = getattr(runner, 'episode_wall_timeout_sec', None)
+                    if remaining is not None:
+                        runner_episode_timeout = remaining if runner_episode_timeout is None else min(runner_episode_timeout, remaining)
+                    result = runner.evaluate(spec, lambda **kwargs: env, session, env=env, seed=None,
+                                             robot_id=instance['robot_id'], camera_observations=cameras, stop_on_done=True, step_callback=callback,
+                                             observation_callback=viewer.observe if viewer else None,
+                                             horizon_sec=instance['runtime']['horizon_sec'],
+                                             control_hz=instance['runtime']['control_hz'], score_key=score_key,
+                                             episode_wall_timeout_sec=runner_episode_timeout)
+                    if writer:
+                        writer.write({'type': 'episode_result', **result.to_dict()})
+                except SkipEpisode:
+                    # A skipped episode is recorded and the next saved
+                    # episode is evaluated. It intentionally makes the group
+                    # invalid for protocol scoring, but must not abort the
+                    # remaining episodes or groups.
+                    skipped = True
+                    if writer:
+                        writer.write({'type': 'skipped', 'reason': 'viewer_skip'})
+                    try:
+                        session.end_episode(skipped=True, passed=False)
+                    except Exception:
+                        # The skip action itself is still honored; policy
+                        # cleanup errors are represented by the invalid row.
+                        pass
+                except Exception as exc:
+                    if writer:
+                        writer.write({'type': 'invalid', 'reason': f'{type(exc).__name__}: {exc}'})
+                    raise
+                finally:
+                    if viewer:
+                        viewer.end_episode()
+                    if writer:
+                        writer.close()
+                if skipped:
+                    row = {'task_id': instance['task_id'], 'task_instance_id': instance['task_instance_id'],
+                           'task_instance_digest': instance['content_digest'],
+                           'episode_id': episode['episode_id'], 'episode_digest': episode['content_digest'],
+                           'phase': phase, 'episode_index': index, 'skipped': True,
+                           'error': 'skipped_by_viewer', 'passed': False, 'episode_score': None}
+                    rows.append(row)
+                    group_rows.append(row)
+                    if on_result:
+                        on_result(row)
+                    continue
+                row = {**result.to_dict(), 'phase': phase, 'episode_index': index,
+                       'task_instance_id': instance['task_instance_id'],
+                       'task_instance_digest': instance['content_digest'],
+                       'episode_id': episode['episode_id'], 'episode_digest': episode['content_digest']}
+                if 'error' not in row:
+                    value = row.get('episode_score')
+                    if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):
+                        row['error'] = 'missing or non-finite episode_score'
+                rows.append(row); group_rows.append(row)
+                if on_result:
+                    on_result(row)
+                if 'error' in row:
+                    if row.get('error') == 'wall_clock_timeout':
+                        timed_out_tasks.add(task_id)
+                    raise ValueError(row['error'])
+        except Exception as exc:
+            error = f'{type(exc).__name__}: {exc}'
+        finally:
+            try:
+                if env is not None:env.close()
+            finally:
+                if close_policy and policy is not None:
+                    try:getattr(policy,'shutdown',policy.close)()
+                    except Exception as exc:error=f'Policy cleanup failed: {type(exc).__name__}: {exc}'
+        valid = (error is None and len(group_rows) == 15 and
+                 not any('error' in row or row.get('skipped') for row in group_rows))
+        exam_scores = [r.get('episode_score') for r in group_rows[10:]]
+        score = sum(exam_scores)/5 if valid else None
+        outcomes.append({'task_instance_id': instance['task_instance_id'], 'valid': valid,
+                         'exam_scores': exam_scores, 'error': error, 'completed_episodes': len(group_rows), 'score': score,
+                         'skipped_episodes': sum(bool(r.get('skipped')) for r in group_rows),
+                         'timeout_scope': 'task' if task_id in timed_out_tasks else None})
+        if viewer and viewer.aborted:
+            break
+    valid = len(outcomes) == len(groups) and all(g['valid'] for g in outcomes)
+    skipped_episodes = sum(len(episodes) for instance, episodes in groups
+                           if instance['task_id'] in timed_out_tasks)
+    task_wall_time_sec = {task_id: time.perf_counter() - started
+                          for task_id, started in task_started.items()}
+    return {'schema_version': VERSION, 'suite_id': manifest['suite_id'], 'manifest_digest': manifest['content_digest'],
+            'protocol': manifest['protocol'], 'valid': valid,
+            'mode': 'public_visual' if cameras else 'state_only_smoke',
+            'protocol_score': sum(g['score'] for g in outcomes)/len(outcomes) if valid and cameras else None,
+            'official_score': None,  # Pilot contracts have not passed publication gates.
+            'groups': outcomes, 'episodes': rows,
+            'limitations': ['in-process policy state isolation relies on adapter contract',
+                            'pilot suite; task solvability and publication gates are separate'],
+            'wall_clock_timeout': bool(timed_out_tasks),
+            'timeout_scope': 'task' if timed_out_tasks else None,
+            'task_wall_timeout_sec': (DEFAULT_TASK_WALL_TIMEOUT_SEC
+                                      if task_wall_timeout_sec is USE_DEFAULT_TASK_WALL_TIMEOUT
+                                      else validate_timeout(task_wall_timeout_sec, 'task_wall_timeout_sec')),
+            'task_wall_timeout_sec_by_task': task_timeouts,
+            'task_wall_time_sec': task_wall_time_sec,
+            'completed_episodes': len(rows),
+            'skipped_episodes': sum(bool(row.get('skipped')) for row in rows) + max(0, skipped_episodes - sum(
+                1 for row in rows if row.get('task_instance_id') in {
+                    instance['task_instance_id'] for instance, episodes in groups
+                    if instance['task_id'] in timed_out_tasks
+                }))}

react_manip/instances/trajectory.py

@@ -0,0 +1,59 @@
+"""Evaluator-owned, optional trajectories with public observations and array files."""
+import json
+from pathlib import Path
+
+import numpy as np
+
+
+class TrajectoryWriter:
+    def __init__(self, directory, metadata):
+        self.directory = Path(directory)
+        self.directory.mkdir(parents=True, exist_ok=False)
+        self.stream = (self.directory / 'trajectory.jsonl').open('x', encoding='utf-8')
+        self.index = 0
+        self.write({'type': 'header', 'schema_version': 'cl-manip.trajectory.v1', **metadata})
+
+    def write(self, record):
+        arrays = {}
+        def encode(value):
+            if isinstance(value, np.ndarray):
+                name = f'a{len(arrays)}'
+                if value.dtype.hasobject:
+                    raise ValueError('trajectory refuses object arrays')
+                arrays[name] = value
+                return {'array_file': f'{self.index:06d}.npz', 'array_key': name,
+                        'dtype': str(value.dtype), 'shape': list(value.shape)}
+            if isinstance(value, np.generic):
+                return value.item()
+            if isinstance(value, dict):
+                return {str(k): encode(v) for k, v in value.items()}
+            if isinstance(value, (tuple, list)):
+                return [encode(v) for v in value]
+            return value
+        encoded = encode(record)
+        line = json.dumps(encoded, ensure_ascii=False, allow_nan=False)
+        if arrays:
+            np.savez_compressed(self.directory / f'{self.index:06d}.npz', **arrays)
+        self.stream.write(line + '\n')
+        self.stream.flush()
+        self.index += 1
+
+    def close(self):
+        self.stream.close()
+
+
+class RecordingPolicy:
+    """Log policy inputs before act; successful ticks are logged by the evaluator."""
+    def __init__(self, policy, writer):
+        self.policy, self.writer, self.tick = policy, writer, 0
+
+    def __getattr__(self, key):
+        return getattr(self.policy, key)
+
+    def act(self, observation, info):
+        self.writer.write({'type': 'policy_input', 'tick': self.tick,
+                           'observation': observation, 'info': info})
+        action = self.policy.act(observation, info)
+        self.writer.write({'type': 'requested_action', 'tick': self.tick, 'action': action})
+        self.tick += 1
+        return action