LUME Full System Goals Execution Prompt

Continue the LUME full-system build from the current worktree. Read and preserve `[home]/Desktop/MotionMix/lume-wiring/lume-full-system-goals-execution-prompt-current.md` as the source of truth for the active goal. Do not invent a new architecture. K11 remains the only Rekordbox/AirDeck command gate. Mac4 remains read-only. Mac5 reconstructs and learns offline only after strict real-bundle preflight and explicit allow. Keep all new DJ gestures observe-only until captured, reviewed, dry-run, and intentionally promoted through the K11 manifest. Work from current reports, not memory. The current honest state is: operator/code surface ready by report, K11 play-only AirDeck and the iPhone 16 Plus command peer at [ip] are last-proven rather than current-live claims, only left/right hand raise are promoted live, physical lanes are still missing, and heavy reconstruction is locked. Refresh K11 reachability, Rekordbox foreground, bridge mode, and source lanes before any live action. Improve docs/specs and read-only audits while devices are unavailable. When devices are positioned, run the home-return validation path, assemble a strict-real bundle, run preflight, and only then proceed to Mac5 reconstruction with explicit allow.

phones / cameras / depth / room-wide views
  -> MotionMix / BodyTruth / Pose Coach evidence
  -> session bundle with source identity, timestamps, topology, pose, video, SAN rows, and operator notes
  -> K11 AirDeck for live-safe DJ commands only
  -> Mac4 ENTHEA / Unity / MRT2-style read-only visuals and audio mapping
  -> Mac5 offline reconstruction and learning after strict real-bundle preflight
  -> reviewed templates, NKo/MnKO inscriptions, SAN policy rows, DEMON control-curve requests, and future phrase candidates

[home]/Desktop/MotionMix/lume-wiring/lume-full-system-away-checklist-current.md
[home]/Desktop/MotionMix/lume-wiring/lume-airdeck-observe-only-gesture-spec-current.md
[home]/Desktop/MotionMix/lume-wiring/lume-airdeck-similarity-spec-current.md
[home]/Desktop/MotionMix/lume-wiring/lume-derived-lanes-after-capture-spec-current.md

[home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_home_return_state_refresh_current.json
[home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_home_return_action_packet_current.json
[home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_full_system_goal_audit_current.json
[home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_real_bundle_preflight_current.json
[home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_operator_surface_audit_current.json
[home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_remote_report_parity_current.json
[home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_mac5_return_sync_current.json
[home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_current_surface_coherence_current.json

1. raw/current evidence reports
2. home-return state refresh
3. action packet
4. real-bundle preflight
5. full-system goal audit
6. Mac5 return sync
7. remote report parity
8. current-surface coherence
9. operator surface audit
10. this prompt

if any lower-level report contradicts this prompt, the report wins
if parity says remote_report_parity_needs_review, do not claim remote parity verified
if coherence says current_surface_needs_review, do not claim operator surface coherent
if preflight says blocked_real_bundle_preflight, do not claim heavy reconstruction readiness
if full goal audit says goal_complete false, do not mark the goal complete
if source evidence is fixture-origin or placeholder-origin, do not count it as strict-real
if a command-path report is missing, assume unsafe until rechecked

read_only_audit: stale reports may be inspected if the response says they are stale
operator_present_refresh: current report set should be refreshed inside the same operator window
observe_only_capture: K11/phone/Mac2/Mac4 evidence must come from the current capture window
source_plan_prefill: source evidence must be current and source-specific
bundle_assembly: source plan, validation, topology, and signoff must belong to the same run_id
strict_preflight: session-bundle verification and preflight must read the assembled bundle being claimed
placeholder_handoff: preflight, arm review, Mac5 sync, and signoff must be current for the bundle
heavy_reconstruction: all reports must be current, strict-real, reviewed, and explicitly allowed
promotion: K11 manifest, dry-run proof, rollback, and operator acceptance must be current for one gesture

{
  "schema": "lume.report_freshness_guard.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "run_id": "home-return-YYYYMMDDTHHMMSS-local",
  "before_action": "source_plan_prefill",
  "freshness_status": "freshness_waiting_refresh",
  "current_capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "action_allowed": false,
  "stale_reports": [
    "home_return_state_refresh"
  ],
  "reports": {
    "home_return_state_refresh": {
      "path": "[home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_home_return_state_refresh_current.json",
      "max_age_s": 120,
      "observed_age_s": null,
      "freshness_status": "unknown_or_stale"
    },
    "home_return_action_packet": {
      "path": "[home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_home_return_action_packet_current.json",
      "max_age_s": 120,
      "observed_age_s": null,
      "freshness_status": "unknown_or_stale"
    },
    "operator_surface_audit": {
      "path": "[home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_operator_surface_audit_current.json",
      "max_age_s": 120,
      "observed_age_s": null,
      "freshness_status": "unknown_or_stale"
    },
    "real_bundle_preflight": {
      "path": "[home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_real_bundle_preflight_current.json",
      "max_age_s": 300,
      "observed_age_s": null,
      "freshness_status": "unknown_or_stale"
    }
  },
  "safety": {
    "k11_is_only_command_gate": true,
    "mac4_read_only": true,
    "phones_can_command_rekordbox": false,
    "ipads_can_command_rekordbox": false,
    "mac4_can_command_rekordbox": false,
    "mac5_can_command_rekordbox": false,
    "heavy_reconstruction_allowed": false,
    "k11_manifest_promotion_allowed": false
  },
  "next_allowed_action": "refresh current reports before source-plan prefill"
}

REPORT_FRESHNESS_GUARD="/path/to/report_freshness_guard.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["REPORT_FRESHNESS_GUARD"])
data = json.loads(path.read_text())
errors = []
trusted_wiring_root = Path("[home]/Desktop/MotionMix/lume-wiring")
allowed_actions = {
    "read_only_audit",
    "operator_present_refresh",
    "observe_only_capture",
    "source_plan_prefill",
    "bundle_assembly",
    "strict_preflight",
    "placeholder_handoff",
    "heavy_reconstruction",
    "promotion",
}
high_risk_actions = allowed_actions - {"read_only_audit", "operator_present_refresh"}

if data.get("schema") != "lume.report_freshness_guard.v1":
    errors.append("bad_schema")
before_action = data.get("before_action")
if before_action not in allowed_actions:
    errors.append(f"bad_before_action:{before_action}")

reports = data.get("reports") or {}
if not reports:
    errors.append("missing_reports")
bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]
for report_id, report in reports.items():
    report_path = Path(str((report or {}).get("path") or ""))
    if not str(report_path).startswith(str(trusted_wiring_root)):
        errors.append(f"report_outside_wiring_root:{report_id}:{report_path}")
    value_s = str(report_path)
    if any(marker in value_s for marker in bad_markers):
        errors.append(f"bad_report_path:{report_id}:{value_s}")
    if (report or {}).get("freshness_status") not in {"fresh", "unknown_or_stale", "stale", "missing"}:
        errors.append(f"bad_freshness_status:{report_id}:{(report or {}).get('freshness_status')}")
    max_age = (report or {}).get("max_age_s")
    if not isinstance(max_age, int) or max_age <= 0:
        errors.append(f"bad_max_age:{report_id}:{max_age}")
    observed_age = (report or {}).get("observed_age_s")
    if observed_age is not None and (not isinstance(observed_age, (int, float)) or observed_age < 0):
        errors.append(f"bad_observed_age:{report_id}:{observed_age}")

stale_reports = data.get("stale_reports") or []
if before_action in high_risk_actions:
    if stale_reports:
        errors.append("high_risk_action_has_stale_reports")
    if data.get("action_allowed") is not True:
        errors.append("high_risk_action_not_allowed_by_freshness")
else:
    if data.get("action_allowed") not in {True, False}:
        errors.append("action_allowed_not_boolean")

safety = data.get("safety") or {}
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_only_command_gate_not_true")
if safety.get("mac4_read_only") is not True:
    errors.append("mac4_read_only_not_true")
for key in [
    "phones_can_command_rekordbox",
    "ipads_can_command_rekordbox",
    "mac4_can_command_rekordbox",
    "mac5_can_command_rekordbox",
]:
    if safety.get(key) is not False:
        errors.append(f"{key}_not_false")
if before_action != "heavy_reconstruction" and safety.get("heavy_reconstruction_allowed") is not False:
    errors.append("heavy_reconstruction_allowed_before_heavy_action")
if before_action != "promotion" and safety.get("k11_manifest_promotion_allowed") is not False:
    errors.append("k11_manifest_promotion_allowed_before_promotion_action")

if before_action in high_risk_actions and data.get("current_capture_window_id") in {None, "", "unknown"}:
    errors.append("high_risk_action_missing_capture_window_id")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("report_freshness_guard_passed")
PY

run_id: operator-present attempt directory under first-real-capture-runs/
capture_window_id: actual physical evidence window shared by required sources
bundle_id: trusted copied bundle under real-capture-bundles/
source_plan_id: source-plan snapshot derived from the same run/capture window
operator_signoff_id: operator acceptance scoped to the same run/capture/bundle
promotion_scope_id: one gesture or command pair when K11 promotion is involved

source_plan_prefill:
  requires same run_id and capture_window_id across packet, source rows, topology, and freshness guard

bundle_assembly:
  requires same run_id and capture_window_id across source plan, validation, topology, signoff, and evidence files

strict_preflight:
  requires the bundle_id under test to match the verifier report and preflight report

placeholder_handoff:
  requires bundle_id match across preflight, arm review, signoff, handoff report, and Mac5 sync

heavy_reconstruction:
  requires bundle_id match across preflight, placeholder handoff, learning audit, heavy signoff, and handoff command

derived_lane_review:
  requires bundle_id and source windows match across derived review packet, source manifest, preflight, and learning audit if used

promotion:
  requires promotion_scope_id, bundle_id or rehearsal run_id, K11 manifest hashes, rollback manifest, dry-run proof, and operator acceptance all match

{
  "schema": "lume.run_lineage_guard.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "before_action": "bundle_assembly",
  "lineage_status": "lineage_waiting_for_consistent_artifacts",
  "action_allowed": false,
  "run_id": "home-return-YYYYMMDDTHHMMSS-local",
  "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "bundle_id": null,
  "source_plan_id": "source-plan-YYYYMMDDTHHMMSS-local",
  "operator_signoff_id": null,
  "promotion_scope_id": null,
  "artifacts": [
    {
      "artifact_id": "home_return_packet",
      "path": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/home-return-execution",
      "run_id": "home-return-YYYYMMDDTHHMMSS-local",
      "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
      "bundle_id": null,
      "status": "present"
    },
    {
      "artifact_id": "source_plan",
      "path": "[home]/Desktop/MotionMix/lume-wiring/lume-post-mac4-real-capture-source-plan-current.json",
      "run_id": "home-return-YYYYMMDDTHHMMSS-local",
      "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
      "bundle_id": null,
      "status": "waiting"
    }
  ],
  "safety": {
    "k11_is_only_command_gate": true,
    "mac4_read_only": true,
    "lineage_contains_fixture_or_placeholder": false,
    "heavy_reconstruction_allowed": false,
    "k11_manifest_promotion_allowed": false
  },
  "next_allowed_action": "repair lineage before bundle assembly"
}

RUN_LINEAGE_GUARD="/path/to/run_lineage_guard.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["RUN_LINEAGE_GUARD"])
data = json.loads(path.read_text())
errors = []
trusted_wiring_root = Path("[home]/Desktop/MotionMix/lume-wiring")
trusted_bundle_root = trusted_wiring_root / "real-capture-bundles"
allowed_actions = {
    "source_plan_prefill",
    "bundle_assembly",
    "strict_preflight",
    "placeholder_handoff",
    "heavy_reconstruction",
    "derived_lane_review",
    "promotion",
}
bundle_actions = {
    "strict_preflight",
    "placeholder_handoff",
    "heavy_reconstruction",
    "derived_lane_review",
}

if data.get("schema") != "lume.run_lineage_guard.v1":
    errors.append("bad_schema")
before_action = data.get("before_action")
if before_action not in allowed_actions:
    errors.append(f"bad_before_action:{before_action}")

run_id = data.get("run_id")
capture_window_id = data.get("capture_window_id")
bundle_id = data.get("bundle_id")
if before_action in {"source_plan_prefill", "bundle_assembly", "promotion"} and not run_id:
    errors.append("missing_run_id")
if before_action in {"source_plan_prefill", "bundle_assembly", "promotion"} and not capture_window_id:
    errors.append("missing_capture_window_id")
if before_action in bundle_actions and not bundle_id:
    errors.append("missing_bundle_id")

artifacts = data.get("artifacts") or []
if not artifacts:
    errors.append("missing_artifacts")
bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]
for index, artifact in enumerate(artifacts):
    artifact_path = Path(str((artifact or {}).get("path") or ""))
    path_s = str(artifact_path)
    if not path_s.startswith(str(trusted_wiring_root)):
        errors.append(f"artifact_{index}_outside_wiring_root:{path_s}")
    if any(marker in path_s for marker in bad_markers):
        errors.append(f"artifact_{index}_bad_path:{path_s}")
    if run_id and (artifact or {}).get("run_id") not in {None, run_id}:
        errors.append(f"artifact_{index}_run_id_mismatch:{(artifact or {}).get('run_id')}")
    if capture_window_id and (artifact or {}).get("capture_window_id") not in {None, capture_window_id}:
        errors.append(f"artifact_{index}_capture_window_id_mismatch:{(artifact or {}).get('capture_window_id')}")
    if bundle_id and (artifact or {}).get("bundle_id") not in {None, bundle_id}:
        errors.append(f"artifact_{index}_bundle_id_mismatch:{(artifact or {}).get('bundle_id')}")
    if (artifact or {}).get("status") not in {"present", "waiting", "missing", "stale", "rejected"}:
        errors.append(f"artifact_{index}_bad_status:{(artifact or {}).get('status')}")

if bundle_id:
    bundle_path = trusted_bundle_root / str(bundle_id)
    for artifact in artifacts:
        artifact_bundle = (artifact or {}).get("bundle_id")
        artifact_path = str((artifact or {}).get("path") or "")
        if artifact_bundle == bundle_id and not artifact_path.startswith(str(bundle_path)):
            if "lume_post_mac4_" not in artifact_path:
                errors.append(f"bundle_artifact_outside_bundle_root:{artifact_path}")

safety = data.get("safety") or {}
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_only_command_gate_not_true")
if safety.get("mac4_read_only") is not True:
    errors.append("mac4_read_only_not_true")
if safety.get("lineage_contains_fixture_or_placeholder") is not False:
    errors.append("lineage_contains_fixture_or_placeholder_not_false")
if before_action != "heavy_reconstruction" and safety.get("heavy_reconstruction_allowed") is not False:
    errors.append("heavy_reconstruction_allowed_before_heavy_action")
if before_action != "promotion" and safety.get("k11_manifest_promotion_allowed") is not False:
    errors.append("k11_manifest_promotion_allowed_before_promotion_action")

if data.get("action_allowed") is not True:
    errors.append("lineage_action_not_allowed")
if "repair lineage" in str(data.get("next_allowed_action", "")).lower() and data.get("action_allowed") is True:
    errors.append("allowed_action_still_says_repair_lineage")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("run_lineage_guard_passed")
PY

cd [home]/Desktop/lume-commerce/viz/lume-pcloud
python3 tools/lume-mac5-reconstruction/verify_lume_post_mac4_remote_report_parity.py \
  --wiring-dir [home]/Desktop/MotionMix/lume-wiring \
  --report-json [home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_remote_report_parity_current.json
python3 tools/lume-mac5-reconstruction/audit_lume_post_mac4_current_surface_coherence.py \
  --wiring-dir [home]/Desktop/MotionMix/lume-wiring \
  --report-json [home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_current_surface_coherence_current.json
python3 tools/lume-mac5-reconstruction/audit_lume_post_mac4_operator_surface.py \
  --wiring-dir [home]/Desktop/MotionMix/lume-wiring \
  --report-json [home]/Desktop/MotionMix/lume-wiring/lume_post_mac4_operator_surface_audit_current.json

read_only_audit
  allowed: inspect files, refresh status reports, run parity/coherence/operator audits, update docs
  forbidden: camera capture, Rekordbox commands, gesture promotion, reconstruction execution

observe_only_capture
  allowed: record source evidence, pose rows, video clips, gesture events, topology notes
  forbidden: Rekordbox commands, manifest promotion, claiming learned reconstruction

dry_run_airdeck
  allowed: evaluate gestures against K11 dry-run bridge, write event evidence, compare mappings
  forbidden: live key sends, new command promotion, Mac4/Mac5 command paths

live_play_only
  allowed: current promoted K11 play-only mappings only
  current mappings: left_hand_raise -> z, right_hand_raise -> n
  current command peer: iPhone 16 Plus / [ip]
  forbidden: any new live gesture, any non-K11 command sender

first_real_capture
  allowed: gather required real lanes into a trusted bundle candidate
  forbidden: heavy reconstruction, learned-output claims, direct Rekordbox expansion

placeholder_handoff
  allowed: after strict bundle assembly/preflight, prepare placeholder/offline handoff for review
  forbidden: calling placeholder output learned, promoting placeholder templates

heavy_reconstruction
  allowed: only after strict real-bundle preflight green, operator review, and explicit allow
  forbidden: running from stale, fixture, partial, or template evidence

promotion
  allowed: update K11 manifest or derived policy only after capture, review, dry-run, and intentional approval
  forbidden: batch-promoting unreviewed gestures or letting SAN/DEMON/visuals decide truth

source peer differs from expected command peer during live_play_only
latest pose is stale beyond the report or bridge max-age gate
Rekordbox is not foreground during live command testing
confidence, visible joint count, or body-present signal falls below gate
mapping manifest hash/path is missing or unexpected
remote parity changes to needs_review
current-surface coherence changes to needs_review
real-bundle preflight remains blocked
any non-K11 process appears capable of sending Rekordbox commands
Mac4 attempts to send commands instead of read-only visuals/mapping
an iPad is treated as a required command source
fixture, smoke, stale, template, or placeholder evidence is counted as strict-real
two phones collapse into one unlabeled source while claiming multi-angle capture

stay read-only
record the failed condition in the relevant report or prompt note
rerun the Report Freshness And Conflict Resolution sequence if reports disagree
keep gestures observe-only
do not promote
do not run heavy reconstruction
do not expand Rekordbox control beyond the currently promoted K11 play-only gate

home-return status: waiting_for_physical_lanes
full-goal audit: waiting_for_required_real_capture_lanes
code ready: true
physical capture ready: false
reconstruction learning ready: false
operator surface ready: true
remote report parity verified: true
real bundle preflight: blocked_real_bundle_preflight
heavy reconstruction preflight ready: false

home-return state refresh: waiting_for_physical_lanes
full-system goal audit: waiting_for_required_real_capture_lanes
operator surface audit: operator_surface_ready_waiting_for_physical_lanes
real bundle preflight: blocked_real_bundle_preflight
remote report parity: remote_report_parity_verified
current surface coherence: current_surface_coherent
Mac5 return sync: mac5_post_mac4_tools_verified
heavy reconstruction preflight ready: false
heavy_reconstruction_preflight_ready: false
K11-only command gate: true
Mac4 read-only: true
phones/iPads/Mac2/Mac4/Mac5 send Rekordbox commands: false

iphone_16_plus_motionmix
iphone_14_pro_max_motionmix
mac2_insta360_room_wide
mac4_bodytruth_depth_or_wide

left_hand_raise -> z
right_hand_raise -> n

C:\temp\airdeck_console.py
C:\temp\run_airdeck_console.cmd
C:\Users\Mohamed Diomande\Desktop\LUME AirDeck Console.lnk
scheduled task: LUME AirDeck Console

source_id
device_label
device_model
host_machine
peer_or_address
motionmix_instance_id
camera_role
view_angle_label
capture_window_id
operator_placement_note

iPhone 16 Plus
  expected role: command-peer phone and required front_phone evidence
  current command peer: [ip]
  command eligibility: only through K11, only for promoted play-only gestures
  identity proof: device label + peer + fresh pose rows + operator placement note

iPhone 14 Pro Max
  expected role: required support angle
  command eligibility: none in current contract
  identity proof: device label + distinct peer + fresh pose rows + operator placement note

iPhone 16 Pro Max
  expected role: optional support angle
  command eligibility: none in current contract
  identity proof: device label + distinct peer + fresh pose rows if used

iPads
  expected role: StageView, ShootView, monitoring, memory, or optional view
  command eligibility: none in current contract
  identity proof: optional source row only; must not replace required phone rows

Mac2 Arducam/UVC
  expected role: room-wide video
  command eligibility: none
  identity proof: host_machine=Mac2 + eligible external camera proof + nonzero clip

Mac4/BodyTruth
  expected role: read-only rich body evidence and visual/audio output input
  command eligibility: none
  identity proof: host_machine=Mac4 + BodyTruth rows/video + confidence/presence + topology notes

K11
  expected role: command/safety gate and operator visibility
  command eligibility: true only through promoted K11 manifest
  identity proof: K11 bridge/latest rows + active command peer + manifest hash + foreground/focus state when command testing

if two phones share one peer_or_address, reject both as collapsed until separated
if a phone label is missing, mark the row ambiguous
if latest pose is from a support phone, K11 must show SUPPORTING CAMERA / PEER GATED
if the command-peer phone changes, update K11 intentionally; do not infer it from latest packet order
if an iPad is visible but a required iPhone is missing, the iPad remains optional and cannot fill the required lane
if a device is moved mid-session, write a new placement note or new capture window
if a source drops and reconnects with a new peer, preserve both peer values and the transition time
if a row lacks operator placement notes, it may be useful evidence but is weak for reconstruction topology

admitted_for_command
  only K11 gate row, only current command peer, only promoted manifest commands

admitted_for_required_capture
  required lane with source identity, timing, role, fresh evidence, and non-synthetic topology

admitted_for_optional_capture
  optional source with source identity and timing, useful but not a required replacement

admitted_for_visual_or_semantic_derivation
  derived or supporting source that can inform SAN/Unity/ENTHEA/MRT2/DEMON/templates after source-window links exist

rejected_ambiguous_identity
  source cannot be uniquely tied to a physical device

rejected_wrong_authority
  source is real but not allowed to command or replace a required lane

[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/evidence/optional_source_admission.json

{
  "schema": "lume.optional_source_admission.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "run_id": "home-return-YYYYMMDDTHHMMSS-local",
  "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "required_source_contract_unchanged": true,
  "required_sources_still_required": [
    "iphone_16_plus_motionmix",
    "iphone_14_pro_max_motionmix",
    "mac2_insta360_room_wide",
    "mac4_bodytruth_depth_or_wide"
  ],
  "optional_sources": [
    {
      "source_id": "iphone_16_pro_max_motionmix",
      "device_label": "iPhone 16 Pro Max",
      "source_kind": "phone_motionmix_pose",
      "required_for_first_real_run": false,
      "captured": false,
      "capture_window_match": false,
      "pose_rows_path": null,
      "video_path": null,
      "evidence_path": null,
      "operator_placement_note": null,
      "view_angle_label": "optional_oblique",
      "may_support_reconstruction": true,
      "may_support_operator_review": true,
      "may_replace_required_source": false,
      "may_send_rekordbox_commands": false,
      "may_be_k11_command_peer": false,
      "claim_status": "optional_not_captured",
      "rejection_reasons": []
    },
    {
      "source_id": "ipad_stageview_optional",
      "device_label": "iPad StageView",
      "source_kind": "ipad_operator_or_optional_view",
      "required_for_first_real_run": false,
      "captured": false,
      "capture_window_match": false,
      "pose_rows_path": null,
      "video_path": null,
      "evidence_path": null,
      "operator_placement_note": null,
      "view_angle_label": "operator_stage_view",
      "may_support_reconstruction": false,
      "may_support_operator_review": true,
      "may_replace_required_source": false,
      "may_send_rekordbox_commands": false,
      "may_be_k11_command_peer": false,
      "claim_status": "optional_not_captured",
      "rejection_reasons": []
    }
  ],
  "downstream_permissions": {
    "required_lane_substitution_allowed": false,
    "source_plan_required_prefill_allowed": false,
    "bundle_assembly_allowed": false,
    "mac5_placeholder_allowed": false,
    "mac5_heavy_allowed": false,
    "k11_manifest_promotion_allowed": false,
    "derived_review_allowed_from_optional_only": false
  },
  "safety": {
    "k11_is_only_command_gate": true,
    "current_k11_command_peer": "[ip]",
    "phones_send_rekordbox_commands": false,
    "ipads_send_rekordbox_commands": false,
    "optional_cameras_send_rekordbox_commands": false,
    "mac4_read_only": true,
    "mac5_sends_rekordbox_commands": false
  },
  "next_allowed_action": "record optional evidence as additive rows only after required lane identity stays explicit"
}

OPTIONAL_SOURCE_ADMISSION="/path/to/optional_source_admission.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["OPTIONAL_SOURCE_ADMISSION"])
data = json.loads(path.read_text())
errors = []
trusted_root = Path("[home]/Desktop/MotionMix/lume-wiring")
required_sources = {
    "iphone_16_plus_motionmix",
    "iphone_14_pro_max_motionmix",
    "mac2_insta360_room_wide",
    "mac4_bodytruth_depth_or_wide",
}
allowed_optional_source_ids = {
    "iphone_16_pro_max_motionmix",
    "ipad_stageview_optional",
    "ipad_shootview_optional",
    "k11_femto_depth_optional",
    "mac4_bolt_depth_optional",
    "mac4_mega_depth_optional",
    "arducam_optional",
    "mocopi_optional",
}
allowed_kinds = {
    "phone_motionmix_pose",
    "ipad_operator_or_optional_view",
    "depth_or_wide_optional",
    "room_or_stage_optional_video",
    "wearable_motion_optional",
}
allowed_claims = {"optional_not_captured", "optional_captured", "optional_rejected"}
bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]

if data.get("schema") != "lume.optional_source_admission.v1":
    errors.append("bad_schema")
for key in ["run_id", "capture_window_id"]:
    if not data.get(key):
        errors.append(f"missing_{key}")
if data.get("required_source_contract_unchanged") is not True:
    errors.append("required_source_contract_changed")
if set(data.get("required_sources_still_required") or []) != required_sources:
    errors.append("required_sources_still_required_mismatch")

rows = data.get("optional_sources") or []
seen = set()
for index, row in enumerate(rows):
    source_id = row.get("source_id")
    if source_id in seen:
        errors.append(f"duplicate_optional_source:{source_id}")
    seen.add(source_id)
    if source_id in required_sources:
        errors.append(f"required_source_listed_as_optional:{source_id}")
    if source_id not in allowed_optional_source_ids:
        errors.append(f"unknown_optional_source_id:{source_id}")
    if row.get("source_kind") not in allowed_kinds:
        errors.append(f"{source_id}:bad_source_kind:{row.get('source_kind')}")
    if row.get("required_for_first_real_run") is not False:
        errors.append(f"{source_id}:required_for_first_real_run_not_false")
    if row.get("may_replace_required_source") is not False:
        errors.append(f"{source_id}:may_replace_required_source_not_false")
    if row.get("may_send_rekordbox_commands") is not False:
        errors.append(f"{source_id}:may_send_rekordbox_commands_not_false")
    if row.get("may_be_k11_command_peer") is not False:
        errors.append(f"{source_id}:may_be_k11_command_peer_not_false")
    if row.get("claim_status") not in allowed_claims:
        errors.append(f"{source_id}:bad_claim_status:{row.get('claim_status')}")
    captured = row.get("captured") is True
    if captured:
        if row.get("capture_window_match") is not True:
            errors.append(f"{source_id}:captured_without_capture_window_match")
        if not row.get("operator_placement_note"):
            errors.append(f"{source_id}:captured_without_operator_placement_note")
        if not row.get("view_angle_label"):
            errors.append(f"{source_id}:captured_without_view_angle_label")
        if not (row.get("pose_rows_path") or row.get("video_path") or row.get("evidence_path")):
            errors.append(f"{source_id}:captured_without_pose_video_or_evidence_path")
        if row.get("claim_status") != "optional_captured":
            errors.append(f"{source_id}:captured_claim_status_not_optional_captured")
    elif row.get("claim_status") == "optional_captured":
        errors.append(f"{source_id}:optional_captured_claim_without_captured_true")
    for key in ["pose_rows_path", "video_path", "evidence_path"]:
        value = row.get(key)
        if not value:
            continue
        value_s = str(value)
        if not value_s.startswith(str(trusted_root)):
            errors.append(f"{source_id}:{key}_outside_trusted_root:{value_s}")
        if any(marker in value_s for marker in bad_markers):
            errors.append(f"{source_id}:{key}_bad_path_marker:{value_s}")

permissions = data.get("downstream_permissions") or {}
for key in [
    "required_lane_substitution_allowed",
    "source_plan_required_prefill_allowed",
    "bundle_assembly_allowed",
    "mac5_placeholder_allowed",
    "mac5_heavy_allowed",
    "k11_manifest_promotion_allowed",
    "derived_review_allowed_from_optional_only",
]:
    if permissions.get(key) is not False:
        errors.append(f"{key}_not_false")

safety = data.get("safety") or {}
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_is_only_command_gate_not_true")
if safety.get("current_k11_command_peer") != "[ip]":
    errors.append("unexpected_k11_command_peer")
if safety.get("mac4_read_only") is not True:
    errors.append("mac4_read_only_not_true")
for key in [
    "phones_send_rekordbox_commands",
    "ipads_send_rekordbox_commands",
    "optional_cameras_send_rekordbox_commands",
    "mac5_sends_rekordbox_commands",
]:
    if safety.get(key) is not False:
        errors.append(f"{key}_not_false")

next_action = str(data.get("next_allowed_action") or "").lower()
for forbidden in ["replace required", "assemble bundle", "heavy", "promote"]:
    if forbidden in next_action:
        errors.append(f"next_allowed_action_mentions_forbidden:{forbidden}")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("optional_source_admission_guard_passed")
PY

[home]/Desktop/MotionMix/lume-wiring/source-contracts/required_source_contract_change_<change_id>.json

no_contract_change_requested:
  current required-source contract remains active
  allowed: keep optional sources additive
  forbidden: substitution, contract mutation, source-plan required prefill from optional lanes

contract_change_review_only:
  a proposed future contract exists for review
  allowed: document rationale, proposed source ids, validator updates, topology implications
  forbidden: using the proposal for the current capture window

future_contract_ready_for_new_capture:
  operator reviewed a future contract and all affected validators/specs are listed for update
  allowed: create a new capture window using the future contract after tools are updated
  forbidden: retrofitting the current blocked run or current source plan

{
  "schema": "lume.required_source_contract_change.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "change_id": "required-source-contract-v2-YYYYMMDDTHHMMSS-local",
  "run_id": "home-return-YYYYMMDDTHHMMSS-local",
  "current_capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "change_state": "no_contract_change_requested",
  "current_contract_revision": "post_mac4_first_real_v1",
  "proposed_contract_revision": null,
  "current_required_sources": [
    "k11_pose_coach_gate",
    "iphone_16_plus_motionmix",
    "iphone_14_pro_max_motionmix",
    "mac2_insta360_room_wide",
    "mac4_bodytruth_depth_or_wide"
  ],
  "proposed_required_sources": [],
  "substitution_requests": [],
  "operator_review": {
    "operator_acceptance_required": true,
    "operator_accepted_future_contract": false,
    "operator_note_path": null
  },
  "tooling_update_requirements": {
    "required_validators_to_update": [
      "required_physical_lane_index",
      "source_plan_handoff_decision",
      "session_bundle_verification",
      "strict_real_bundle_preflight",
      "completion_audit"
    ],
    "all_required_updates_listed": false,
    "updated_tools_verified": false
  },
  "downstream_permissions": {
    "current_capture_window_substitution_allowed": false,
    "current_source_plan_mutation_allowed": false,
    "future_contract_draft_allowed": false,
    "future_capture_window_allowed": false,
    "bundle_assembly_allowed": false,
    "mac5_placeholder_allowed": false,
    "mac5_heavy_allowed": false,
    "k11_manifest_promotion_allowed": false
  },
  "safety": {
    "k11_pose_coach_gate_required": true,
    "k11_is_only_command_gate": true,
    "current_k11_command_peer": "[ip]",
    "mac4_read_only": true,
    "non_k11_sources_send_rekordbox_commands": false,
    "contract_change_fixes_current_missing_lanes": false
  },
  "next_allowed_action": "keep current required-source contract unchanged"
}

REQUIRED_SOURCE_CONTRACT_CHANGE="/path/to/required_source_contract_change.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["REQUIRED_SOURCE_CONTRACT_CHANGE"])
data = json.loads(path.read_text())
errors = []
trusted_root = Path("[home]/Desktop/MotionMix/lume-wiring")
current_required_sources = {
    "k11_pose_coach_gate",
    "iphone_16_plus_motionmix",
    "iphone_14_pro_max_motionmix",
    "mac2_insta360_room_wide",
    "mac4_bodytruth_depth_or_wide",
}
allowed_states = {
    "no_contract_change_requested",
    "contract_change_review_only",
    "future_contract_ready_for_new_capture",
}
allowed_substitute_sources = {
    "iphone_16_pro_max_motionmix",
    "ipad_stageview_optional",
    "ipad_shootview_optional",
    "k11_femto_depth_optional",
    "mac4_bolt_depth_optional",
    "mac4_mega_depth_optional",
    "arducam_optional",
    "mocopi_optional",
}
required_validator_updates = {
    "required_physical_lane_index",
    "source_plan_handoff_decision",
    "session_bundle_verification",
    "strict_real_bundle_preflight",
    "completion_audit",
}
bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]

if data.get("schema") != "lume.required_source_contract_change.v1":
    errors.append("bad_schema")
for key in ["change_id", "run_id", "current_capture_window_id", "current_contract_revision"]:
    if not data.get(key):
        errors.append(f"missing_{key}")
state = data.get("change_state")
if state not in allowed_states:
    errors.append(f"bad_change_state:{state}")
if set(data.get("current_required_sources") or []) != current_required_sources:
    errors.append("current_required_sources_mismatch")

proposed = set(data.get("proposed_required_sources") or [])
substitutions = data.get("substitution_requests") or []
operator = data.get("operator_review") or {}
tooling = data.get("tooling_update_requirements") or {}
permissions = data.get("downstream_permissions") or {}
safety = data.get("safety") or {}

if state == "no_contract_change_requested":
    if data.get("proposed_contract_revision") is not None:
        errors.append("no_change_state_has_proposed_revision")
    if proposed:
        errors.append("no_change_state_has_proposed_required_sources")
    if substitutions:
        errors.append("no_change_state_has_substitution_requests")
    if permissions.get("future_contract_draft_allowed") is not False:
        errors.append("future_contract_draft_allowed_in_no_change_state")
elif state == "contract_change_review_only":
    if not data.get("proposed_contract_revision"):
        errors.append("review_state_missing_proposed_revision")
    if not proposed:
        errors.append("review_state_missing_proposed_required_sources")
    if "k11_pose_coach_gate" not in proposed:
        errors.append("proposed_contract_missing_k11_pose_coach_gate")
    if not substitutions:
        errors.append("review_state_missing_substitution_requests")
    if permissions.get("future_contract_draft_allowed") is not True:
        errors.append("review_state_future_contract_draft_not_allowed")
    if permissions.get("future_capture_window_allowed") is not False:
        errors.append("review_state_future_capture_window_allowed")
elif state == "future_contract_ready_for_new_capture":
    if not data.get("proposed_contract_revision"):
        errors.append("ready_state_missing_proposed_revision")
    if not proposed:
        errors.append("ready_state_missing_proposed_required_sources")
    if "k11_pose_coach_gate" not in proposed:
        errors.append("ready_contract_missing_k11_pose_coach_gate")
    if not substitutions:
        errors.append("ready_state_missing_substitution_requests")
    if operator.get("operator_accepted_future_contract") is not True:
        errors.append("ready_state_without_operator_acceptance")
    if tooling.get("all_required_updates_listed") is not True:
        errors.append("ready_state_without_all_required_updates_listed")
    if tooling.get("updated_tools_verified") is not True:
        errors.append("ready_state_without_updated_tools_verified")
    if permissions.get("future_contract_draft_allowed") is not True:
        errors.append("ready_state_future_contract_draft_not_allowed")
    if permissions.get("future_capture_window_allowed") is not True:
        errors.append("ready_state_future_capture_window_not_allowed")

if operator.get("operator_acceptance_required") is not True:
    errors.append("operator_acceptance_required_not_true")
note_path = operator.get("operator_note_path")
if state == "future_contract_ready_for_new_capture":
    if not note_path:
        errors.append("ready_state_missing_operator_note_path")
    else:
        note_s = str(note_path)
        if not note_s.startswith(str(trusted_root)):
            errors.append(f"operator_note_outside_trusted_root:{note_s}")
        if any(marker in note_s for marker in bad_markers):
            errors.append(f"operator_note_bad_path:{note_s}")

updates = set(tooling.get("required_validators_to_update") or [])
if not required_validator_updates.issubset(updates):
    errors.append(f"missing_required_validator_updates:{sorted(required_validator_updates - updates)}")

for index, request in enumerate(substitutions):
    from_source = request.get("from_source_id")
    to_source = request.get("to_source_id")
    if from_source not in current_required_sources:
        errors.append(f"substitution_{index}_bad_from_source:{from_source}")
    if to_source not in allowed_substitute_sources and to_source not in current_required_sources:
        errors.append(f"substitution_{index}_bad_to_source:{to_source}")
    if request.get("future_capture_only") is not True:
        errors.append(f"substitution_{index}_future_capture_only_not_true")
    if request.get("current_capture_window_allowed") is not False:
        errors.append(f"substitution_{index}_current_capture_window_allowed_not_false")
    if not request.get("rationale"):
        errors.append(f"substitution_{index}_missing_rationale")

for key in [
    "current_capture_window_substitution_allowed",
    "current_source_plan_mutation_allowed",
    "bundle_assembly_allowed",
    "mac5_placeholder_allowed",
    "mac5_heavy_allowed",
    "k11_manifest_promotion_allowed",
]:
    if permissions.get(key) is not False:
        errors.append(f"{key}_not_false")

if safety.get("k11_pose_coach_gate_required") is not True:
    errors.append("k11_pose_coach_gate_required_not_true")
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_is_only_command_gate_not_true")
if safety.get("current_k11_command_peer") != "[ip]":
    errors.append("unexpected_k11_command_peer")
if safety.get("mac4_read_only") is not True:
    errors.append("mac4_read_only_not_true")
for key in ["non_k11_sources_send_rekordbox_commands", "contract_change_fixes_current_missing_lanes"]:
    if safety.get(key) is not False:
        errors.append(f"{key}_not_false")

next_action = str(data.get("next_allowed_action") or "").lower()
for forbidden in ["fix current missing", "current source plan", "assemble bundle", "heavy", "promote"]:
    if forbidden in next_action:
        errors.append(f"next_allowed_action_mentions_forbidden:{forbidden}")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("required_source_contract_change_guard_passed")
PY

both required source ids are present exactly once
iPhone 16 Plus source has device_label iPhone 16 Plus
iPhone 16 Plus peer matches the reviewed K11 command peer
iPhone 14 Pro Max source has device_label iPhone 14 Pro Max
iPhone 14 Pro Max peer is present and distinct from the command peer
both sources have current capture_window_id matches
both sources have nonempty MotionMix pose rows under the trusted wiring root
both sources have body_present=true and visible joints
both sources have confidence at or above threshold
both sources have source-window timing or an explicit timebase fallback
both sources have operator placement notes and distinct view angle labels
neither phone sends Rekordbox or AirDeck commands
iPads and optional phones do not replace either required iPhone lane

[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/pose/iphone_16_plus_motionmix.jsonl
[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/pose/iphone_14_pro_max_motionmix.jsonl
[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/evidence/required_iphone_motionmix_sources.json

[home]/Desktop/MotionMix/lume-wiring/real-capture-bundles/<bundle_id>/raw/pose/iphone_16_plus_motionmix.jsonl
[home]/Desktop/MotionMix/lume-wiring/real-capture-bundles/<bundle_id>/raw/pose/iphone_14_pro_max_motionmix.jsonl
[home]/Desktop/MotionMix/lume-wiring/real-capture-bundles/<bundle_id>/raw/evidence/required_iphone_motionmix_sources.json

{
  "schema": "lume.iphone_motionmix_required_pose_evidence.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "run_id": "home-return-YYYYMMDDTHHMMSS-local",
  "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "bundle_id": null,
  "k11_command_peer": {
    "source_id": "iphone_16_plus_motionmix",
    "device_label": "iPhone 16 Plus",
    "peer_or_address": "[ip]",
    "reviewed_by_k11": true
  },
  "required_sources": [
    {
      "source_id": "iphone_16_plus_motionmix",
      "device_label": "iPhone 16 Plus",
      "device_model": "iPhone 16 Plus",
      "peer_or_address": "[ip]",
      "motionmix_instance_id": "iphone-16-plus-motionmix",
      "camera_role": "front_phone_required_command_peer",
      "view_angle_label": "front",
      "operator_placement_note": "front view, full body visible when possible",
      "evidence_kind": "capture_window_pose_rows",
      "pose_rows_path": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/pose/iphone_16_plus_motionmix.jsonl",
      "video_path": null,
      "source_window_start_utc": "YYYY-MM-DDTHH:MM:SSZ",
      "source_window_end_utc": "YYYY-MM-DDTHH:MM:SSZ",
      "capture_window_match": true,
      "pose_rows_nonempty": true,
      "rows_fresh_for_capture_window": true,
      "body_present": true,
      "visible_joint_count": 12,
      "wrists_visible": true,
      "confidence": 0.72,
      "confidence_threshold": 0.55,
      "timestamp_monotonic_ms_present": true,
      "timebase_fallback_declared": false,
      "phone_sends_rekordbox_commands": false,
      "phone_sends_airdeck_commands": false,
      "command_eligible_only_through_k11": true
    },
    {
      "source_id": "iphone_14_pro_max_motionmix",
      "device_label": "iPhone 14 Pro Max",
      "device_model": "iPhone 14 Pro Max",
      "peer_or_address": "[ip]",
      "motionmix_instance_id": "iphone-14-pro-max-motionmix",
      "camera_role": "required_support_angle",
      "view_angle_label": "right_oblique",
      "operator_placement_note": "support angle, distinct from iPhone 16 Plus",
      "evidence_kind": "capture_window_pose_rows",
      "pose_rows_path": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/pose/iphone_14_pro_max_motionmix.jsonl",
      "video_path": null,
      "source_window_start_utc": "YYYY-MM-DDTHH:MM:SSZ",
      "source_window_end_utc": "YYYY-MM-DDTHH:MM:SSZ",
      "capture_window_match": true,
      "pose_rows_nonempty": true,
      "rows_fresh_for_capture_window": true,
      "body_present": true,
      "visible_joint_count": 12,
      "wrists_visible": true,
      "confidence": 0.72,
      "confidence_threshold": 0.55,
      "timestamp_monotonic_ms_present": true,
      "timebase_fallback_declared": false,
      "phone_sends_rekordbox_commands": false,
      "phone_sends_airdeck_commands": false,
      "command_eligible_only_through_k11": false
    }
  ],
  "admission": {
    "admitted_for_required_capture": false,
    "admitted_for_bundle": false,
    "rejection_reasons": [
      "waiting_for_current_distinct_required_iphone_pose_rows"
    ]
  },
  "safety": {
    "k11_is_only_command_gate": true,
    "phones_send_rekordbox_commands": false,
    "phones_send_airdeck_commands": false,
    "ipads_can_replace_required_phones": false,
    "optional_phone_can_replace_required_phone": false,
    "fixture_or_placeholder_origin": false
  },
  "next_allowed_action": "record distinct current MotionMix pose rows from iPhone 16 Plus and iPhone 14 Pro Max"
}

IPHONE_MOTIONMIX_EVIDENCE="/path/to/required_iphone_motionmix_sources.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["IPHONE_MOTIONMIX_EVIDENCE"])
data = json.loads(path.read_text())
errors = []
trusted_root = Path("[home]/Desktop/MotionMix/lume-wiring")
expected = {
    "iphone_16_plus_motionmix": {
        "device_label": "iPhone 16 Plus",
        "current_peer": "[ip]",
        "command_eligible_only_through_k11": True,
    },
    "iphone_14_pro_max_motionmix": {
        "device_label": "iPhone 14 Pro Max",
        "current_peer": None,
        "command_eligible_only_through_k11": False,
    },
}
bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]

if data.get("schema") != "lume.iphone_motionmix_required_pose_evidence.v1":
    errors.append("bad_schema")
if not data.get("run_id"):
    errors.append("missing_run_id")
capture_window_id = data.get("capture_window_id")
if not capture_window_id:
    errors.append("missing_capture_window_id")

command_peer = data.get("k11_command_peer") or {}
if command_peer.get("source_id") != "iphone_16_plus_motionmix":
    errors.append(f"bad_k11_command_peer_source:{command_peer.get('source_id')}")
if command_peer.get("peer_or_address") != expected["iphone_16_plus_motionmix"]["current_peer"]:
    errors.append(f"bad_k11_command_peer_address:{command_peer.get('peer_or_address')}")
if command_peer.get("reviewed_by_k11") is not True:
    errors.append("k11_command_peer_not_reviewed")

sources = data.get("required_sources") or []
seen = {}
for source in sources:
    source_id = source.get("source_id")
    if source_id in seen:
        errors.append(f"duplicate_source_id:{source_id}")
    seen[source_id] = source

if set(seen) != set(expected):
    errors.append(f"required_source_set_mismatch:{sorted(seen)}")

peers = []
view_angles = []
placement_notes = []
for source_id, spec in expected.items():
    source = seen.get(source_id) or {}
    if not source:
        continue
    if source.get("device_label") != spec["device_label"]:
        errors.append(f"{source_id}:bad_device_label:{source.get('device_label')}")
    peer = str(source.get("peer_or_address") or "")
    if not peer:
        errors.append(f"{source_id}:missing_peer_or_address")
    if spec["current_peer"] and peer != spec["current_peer"]:
        errors.append(f"{source_id}:peer_does_not_match_current_command_peer:{peer}")
    peers.append(peer)
    view_angle = str(source.get("view_angle_label") or "")
    placement_note = str(source.get("operator_placement_note") or "")
    view_angles.append(view_angle)
    placement_notes.append(placement_note)
    if not view_angle:
        errors.append(f"{source_id}:missing_view_angle_label")
    if not placement_note:
        errors.append(f"{source_id}:missing_operator_placement_note")
    if not source.get("motionmix_instance_id"):
        errors.append(f"{source_id}:missing_motionmix_instance_id")
    if source.get("evidence_kind") != "capture_window_pose_rows":
        errors.append(f"{source_id}:bad_evidence_kind:{source.get('evidence_kind')}")
    if source.get("capture_window_match") is not True:
        errors.append(f"{source_id}:capture_window_match_not_true")
    if source.get("pose_rows_nonempty") is not True:
        errors.append(f"{source_id}:pose_rows_nonempty_not_true")
    if source.get("rows_fresh_for_capture_window") is not True:
        errors.append(f"{source_id}:rows_fresh_for_capture_window_not_true")
    if source.get("body_present") is not True:
        errors.append(f"{source_id}:body_present_not_true")
    joint_count = source.get("visible_joint_count")
    if not isinstance(joint_count, int) or joint_count < 8:
        errors.append(f"{source_id}:visible_joint_count_too_low:{joint_count}")
    if source.get("wrists_visible") is not True:
        errors.append(f"{source_id}:wrists_visible_not_true")
    confidence = source.get("confidence")
    threshold = source.get("confidence_threshold", 0.55)
    if not isinstance(confidence, (int, float)):
        errors.append(f"{source_id}:confidence_not_numeric:{confidence}")
    if not isinstance(threshold, (int, float)):
        errors.append(f"{source_id}:confidence_threshold_not_numeric:{threshold}")
    if isinstance(confidence, (int, float)) and isinstance(threshold, (int, float)) and confidence < threshold:
        errors.append(f"{source_id}:confidence_below_threshold:{confidence}<{threshold}")
    if not source.get("source_window_start_utc") or not source.get("source_window_end_utc"):
        errors.append(f"{source_id}:missing_source_window")
    if source.get("timestamp_monotonic_ms_present") is not True and source.get("timebase_fallback_declared") is not True:
        errors.append(f"{source_id}:missing_timebase_or_fallback")
    pose_path = str(source.get("pose_rows_path") or "")
    video_path = str(source.get("video_path") or "")
    if not pose_path:
        errors.append(f"{source_id}:missing_pose_rows_path")
    for key, value in [("pose_rows_path", pose_path), ("video_path", video_path)]:
        if not value:
            continue
        if not value.startswith(str(trusted_root)):
            errors.append(f"{source_id}:{key}_outside_trusted_root:{value}")
        if any(marker in value for marker in bad_markers):
            errors.append(f"{source_id}:bad_path:{key}:{value}")
    if source.get("phone_sends_rekordbox_commands") is not False:
        errors.append(f"{source_id}:phone_sends_rekordbox_commands_not_false")
    if source.get("phone_sends_airdeck_commands") is not False:
        errors.append(f"{source_id}:phone_sends_airdeck_commands_not_false")
    if source.get("command_eligible_only_through_k11") is not spec["command_eligible_only_through_k11"]:
        errors.append(f"{source_id}:bad_k11_command_eligibility_flag")

if len(set(peers)) != len(peers):
    errors.append("phone_peers_not_distinct")
if len(set(view_angles)) != len(view_angles):
    errors.append("phone_view_angles_not_distinct")
if len(set(placement_notes)) != len(placement_notes):
    errors.append("phone_placement_notes_not_distinct")

admission = data.get("admission") or {}
if admission.get("admitted_for_required_capture") is True:
    if admission.get("admitted_for_bundle") is not True:
        errors.append("required_capture_admitted_without_bundle_admission")
    if admission.get("rejection_reasons"):
        errors.append("admitted_iphone_lanes_have_rejection_reasons")
else:
    if not admission.get("rejection_reasons"):
        errors.append("not_admitted_without_rejection_reasons")

safety = data.get("safety") or {}
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_only_command_gate_not_true")
for key in [
    "phones_send_rekordbox_commands",
    "phones_send_airdeck_commands",
    "ipads_can_replace_required_phones",
    "optional_phone_can_replace_required_phone",
    "fixture_or_placeholder_origin",
]:
    if safety.get(key) is not False:
        errors.append(f"{key}_not_false")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("iphone_motionmix_required_pose_evidence_passed")
PY

current_peer_unchanged:
  allowed: keep iPhone 16 Plus / [ip] as command peer
  required: K11 bridge and AirDeck Console agree on peer and manifest

peer_change_requested:
  allowed: write a review packet only
  required: old peer, proposed peer, reason, dry-run plan, rollback path
  forbidden: live command testing before review packet is accepted

peer_change_reviewed_for_dry_run:
  allowed: K11 dry-run command-peer test only, sent_command=false
  required: operator acceptance for dry-run and support-peer gating proof

peer_change_promoted_live:
  allowed: exactly one reviewed command peer for exactly the reviewed live scope
  required: K11 manifest/bridge reload, before/after hashes, rollback manifest, console agreement

[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/command-peer/k11_command_peer_review.json

{
  "schema": "lume.k11_command_peer_review.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "run_id": "home-return-YYYYMMDDTHHMMSS-local",
  "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "review_state": "current_peer_unchanged",
  "current_command_peer": {
    "source_id": "iphone_16_plus_motionmix",
    "device_label": "iPhone 16 Plus",
    "peer_or_address": "[ip]",
    "command_scope": "play_pause_only"
  },
  "proposed_command_peer": null,
  "supporting_sources": [
    {
      "source_id": "iphone_14_pro_max_motionmix",
      "device_label": "iPhone 14 Pro Max",
      "peer_or_address": "distinct_from_iphone_16_plus",
      "command_eligible": false,
      "expected_console_state": "SUPPORTING CAMERA / PEER GATED"
    },
    {
      "source_id": "iphone_16_pro_max_motionmix",
      "device_label": "iPhone 16 Pro Max",
      "peer_or_address": null,
      "command_eligible": false,
      "expected_console_state": "OPTIONAL CAMERA / PEER GATED"
    },
    {
      "source_id": "ipad_stage_view",
      "device_label": "iPad StageView",
      "peer_or_address": null,
      "command_eligible": false,
      "expected_console_state": "OPTIONAL VIEW / NOT COMMAND"
    }
  ],
  "k11_evidence": {
    "bridge_config_path": "C:\\lume\\selfplay\\airdeck-playonly-promoted-commands.json",
    "manifest_before_sha256": null,
    "manifest_after_sha256": null,
    "airdeck_console_snapshot": null,
    "dry_run_report": null,
    "rollback_manifest": null
  },
  "safety": {
    "k11_is_only_command_gate": true,
    "phones_send_rekordbox_commands": false,
    "ipads_send_rekordbox_commands": false,
    "mac2_sends_rekordbox_commands": false,
    "mac4_sends_rekordbox_commands": false,
    "mac5_sends_rekordbox_commands": false,
    "supporting_sources_can_command": false,
    "live_commands_allowed": true,
    "new_gesture_promotion_allowed": false
  },
  "next_allowed_action": "keep current K11 command peer and continue source-lane validation"
}

K11_COMMAND_PEER_REVIEW="/path/to/k11_command_peer_review.json" python3 - <<'PY'
import json
import os
import sys

data = json.loads(open(os.environ["K11_COMMAND_PEER_REVIEW"]).read())
errors = []
allowed_states = {
    "current_peer_unchanged",
    "peer_change_requested",
    "peer_change_reviewed_for_dry_run",
    "peer_change_promoted_live",
}
current_expected = {
    "source_id": "iphone_16_plus_motionmix",
    "device_label": "iPhone 16 Plus",
    "peer_or_address": "[ip]",
}

if data.get("schema") != "lume.k11_command_peer_review.v1":
    errors.append("bad_schema")
state = data.get("review_state")
if state not in allowed_states:
    errors.append(f"bad_review_state:{state}")
if not data.get("run_id"):
    errors.append("missing_run_id")
if not data.get("capture_window_id"):
    errors.append("missing_capture_window_id")

current = data.get("current_command_peer") or {}
if state == "current_peer_unchanged":
    for key, expected in current_expected.items():
        if current.get(key) != expected:
            errors.append(f"current_peer_changed_without_review:{key}:{current.get(key)}")
    if data.get("proposed_command_peer") not in {None, {}}:
        errors.append("unchanged_state_has_proposed_peer")
else:
    proposed = data.get("proposed_command_peer") or {}
    if not proposed:
        errors.append("peer_change_missing_proposed_peer")
    if proposed.get("source_id") in {"ipad_stage_view", "ipad_shoot_view"}:
        errors.append("ipad_cannot_be_command_peer")

supporting = data.get("supporting_sources") or []
if not supporting:
    errors.append("missing_supporting_sources")
for index, source in enumerate(supporting):
    if source.get("command_eligible") is not False:
        errors.append(f"supporting_source_{index}_command_eligible_not_false")
    if "GATED" not in str(source.get("expected_console_state", "")) and "NOT COMMAND" not in str(source.get("expected_console_state", "")):
        errors.append(f"supporting_source_{index}_missing_gated_console_state")

safety = data.get("safety") or {}
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_only_command_gate_not_true")
for key in [
    "phones_send_rekordbox_commands",
    "ipads_send_rekordbox_commands",
    "mac2_sends_rekordbox_commands",
    "mac4_sends_rekordbox_commands",
    "mac5_sends_rekordbox_commands",
    "supporting_sources_can_command",
    "new_gesture_promotion_allowed",
]:
    if safety.get(key) is not False:
        errors.append(f"{key}_not_false")
if state in {"peer_change_requested", "peer_change_reviewed_for_dry_run"} and safety.get("live_commands_allowed") is not False:
    errors.append("live_commands_allowed_during_peer_change_review")
if state == "peer_change_promoted_live":
    evidence = data.get("k11_evidence") or {}
    for key in ["manifest_before_sha256", "manifest_after_sha256", "airdeck_console_snapshot", "dry_run_report", "rollback_manifest"]:
        if not evidence.get(key):
            errors.append(f"promoted_peer_missing_evidence:{key}")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("k11_command_peer_review_passed")
PY

host_machine is Mac2
source_id is mac2_insta360_room_wide
capture_window_id matches the current physical attempt
probe identifies an eligible external camera
camera is Arducam B0478 or another approved external UVC room-wide camera
camera is not FaceTime and not internal laptop webcam
video clip exists and is nonzero
video clip belongs to the same capture window
clip is copied into the current staging run or trusted bundle root
Mac2 sends no Rekordbox commands

[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/video/mac2_insta360_room_wide.mp4
[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/evidence/mac2_insta360_room_wide.json

[home]/Desktop/MotionMix/lume-wiring/real-capture-bundles/<bundle_id>/raw/video/mac2_insta360_room_wide.mp4
[home]/Desktop/MotionMix/lume-wiring/real-capture-bundles/<bundle_id>/raw/evidence/mac2_insta360_room_wide.json

{
  "schema": "lume.mac2_insta360_room_wide_evidence.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "run_id": "home-return-YYYYMMDDTHHMMSS-local",
  "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "bundle_id": null,
  "source_id": "mac2_insta360_room_wide",
  "host_machine": "Mac2",
  "required_for_first_real_run": true,
  "camera": {
    "camera_name": "Arducam B0478 (USB3 48MP)",
    "camera_kind": "arducam_or_external_uvc",
    "external_camera": true,
    "facetime_camera": false,
    "internal_camera": false,
    "probe_path": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/evidence/mac2_external_camera_probe.json",
    "probe_identified_eligible_camera": true
  },
  "video": {
    "video_path": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/video/mac2_insta360_room_wide.mp4",
    "byte_size": 1,
    "duration_s": 20.0,
    "frame_count": null,
    "capture_window_match": true
  },
  "admission": {
    "admitted_for_required_capture": false,
    "admitted_for_bundle": false,
    "rejection_reasons": [
      "waiting_for_current_nonzero_room_wide_clip"
    ]
  },
  "safety": {
    "mac2_sends_rekordbox_commands": false,
    "k11_is_only_command_gate": true,
    "fixture_or_placeholder_origin": false
  },
  "next_allowed_action": "record nonzero Mac2 Arducam/UVC room-wide clip from the current capture window"
}

MAC2_INSTA360_EVIDENCE="/path/to/mac2_insta360_room_wide.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["MAC2_INSTA360_EVIDENCE"])
data = json.loads(path.read_text())
errors = []
trusted_root = Path("[home]/Desktop/MotionMix/lume-wiring")
allowed_camera_kinds = {"insta360_or_external_uvc", "insta360", "external_uvc_room_wide"}

if data.get("schema") != "lume.mac2_insta360_room_wide_evidence.v1":
    errors.append("bad_schema")
if data.get("source_id") != "mac2_insta360_room_wide":
    errors.append(f"bad_source_id:{data.get('source_id')}")
if data.get("host_machine") != "Mac2":
    errors.append(f"bad_host_machine:{data.get('host_machine')}")
if data.get("required_for_first_real_run") is not True:
    errors.append("required_for_first_real_run_not_true")
if not data.get("run_id"):
    errors.append("missing_run_id")
if not data.get("capture_window_id"):
    errors.append("missing_capture_window_id")

camera = data.get("camera") or {}
if camera.get("camera_kind") not in allowed_camera_kinds:
    errors.append(f"bad_camera_kind:{camera.get('camera_kind')}")
if camera.get("external_camera") is not True:
    errors.append("external_camera_not_true")
if camera.get("facetime_camera") is not False:
    errors.append("facetime_camera_not_false")
if camera.get("internal_camera") is not False:
    errors.append("internal_camera_not_false")
if camera.get("probe_identified_eligible_camera") is not True:
    errors.append("probe_identified_eligible_camera_not_true")

video = data.get("video") or {}
video_path = Path(str(video.get("video_path") or ""))
if not str(video_path).startswith(str(trusted_root)):
    errors.append(f"video_path_outside_trusted_root:{video_path}")
byte_size = video.get("byte_size")
if not isinstance(byte_size, int) or byte_size <= 0:
    errors.append(f"video_byte_size_not_positive:{byte_size}")
duration_s = video.get("duration_s")
if duration_s is not None and (not isinstance(duration_s, (int, float)) or duration_s <= 0):
    errors.append(f"bad_duration_s:{duration_s}")
if video.get("capture_window_match") is not True:
    errors.append("video_capture_window_match_not_true")

bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]
for key in ["video_path", "probe_path"]:
    value = str(video.get(key) if key == "video_path" else camera.get(key) or "")
    if any(marker in value for marker in bad_markers):
        errors.append(f"bad_mac2_path:{key}:{value}")

admission = data.get("admission") or {}
if admission.get("admitted_for_required_capture") is True:
    if admission.get("admitted_for_bundle") is not True:
        errors.append("required_capture_admitted_without_bundle_admission")
    if admission.get("rejection_reasons"):
        errors.append("admitted_mac2_lane_has_rejection_reasons")
else:
    if not admission.get("rejection_reasons"):
        errors.append("not_admitted_without_rejection_reasons")

safety = data.get("safety") or {}
if safety.get("mac2_sends_rekordbox_commands") is not False:
    errors.append("mac2_sends_rekordbox_commands_not_false")
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_only_command_gate_not_true")
if safety.get("fixture_or_placeholder_origin") is not False:
    errors.append("fixture_or_placeholder_origin_not_false")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("mac2_insta360_room_wide_evidence_passed")
PY

host_machine is Mac4
source_id is mac4_bodytruth_depth_or_wide
capture_window_id matches the current physical attempt
BodyTruth service is reachable
BodyTruth says a body is present
tracking status is tracked, tracking, body_present, ok, or locked
confidence is numeric and at or above the configured threshold
pose rows or video exists under the current staging run or trusted bundle root
BodyTruth state belongs to the same capture window
Mac4 remains read_only=true
Mac4 has no command capability
Mac4 sends no Rekordbox commands

[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/pose/mac4_bodytruth_depth_or_wide.jsonl
[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/video/mac4_bodytruth_depth_or_wide.mp4
[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/evidence/mac4_bodytruth_depth_or_wide.json

[home]/Desktop/MotionMix/lume-wiring/real-capture-bundles/<bundle_id>/raw/pose/mac4_bodytruth_depth_or_wide.jsonl
[home]/Desktop/MotionMix/lume-wiring/real-capture-bundles/<bundle_id>/raw/video/mac4_bodytruth_depth_or_wide.mp4
[home]/Desktop/MotionMix/lume-wiring/real-capture-bundles/<bundle_id>/raw/evidence/mac4_bodytruth_depth_or_wide.json

{
  "schema": "lume.mac4_bodytruth_depth_or_wide_evidence.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "run_id": "home-return-YYYYMMDDTHHMMSS-local",
  "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "bundle_id": null,
  "source_id": "mac4_bodytruth_depth_or_wide",
  "host_machine": "Mac4",
  "required_for_first_real_run": true,
  "bodytruth": {
    "service_reachable": true,
    "body_present": true,
    "tracking_status": "tracked",
    "confidence": 0.72,
    "confidence_threshold": 0.55,
    "pose_rows_path": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/pose/mac4_bodytruth_depth_or_wide.jsonl",
    "video_path": null,
    "bodytruth_state_path": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/evidence/mac4_bodytruth_state.json",
    "topology_notes_path": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/evidence/mac4_bodytruth_topology_notes.json",
    "capture_window_match": true,
    "rows_fresh_for_capture_window": true,
    "read_only": true,
    "command_capability": false
  },
  "admission": {
    "admitted_for_required_capture": false,
    "admitted_for_bundle": false,
    "rejection_reasons": [
      "waiting_for_current_body_present_bodytruth_rows_or_video"
    ]
  },
  "safety": {
    "mac4_read_only": true,
    "mac4_sends_rekordbox_commands": false,
    "mac4_sends_airdeck_commands": false,
    "unity_enthea_mrt2_demon_can_command": false,
    "k11_is_only_command_gate": true,
    "fixture_or_placeholder_origin": false
  },
  "next_allowed_action": "record current Mac4 BodyTruth body-present pose rows or depth/wide video"
}

MAC4_BODYTRUTH_EVIDENCE="/path/to/mac4_bodytruth_depth_or_wide.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["MAC4_BODYTRUTH_EVIDENCE"])
data = json.loads(path.read_text())
errors = []
trusted_root = Path("[home]/Desktop/MotionMix/lume-wiring")
good_tracking_statuses = {"tracked", "tracking", "body_present", "ok", "locked"}
bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]

if data.get("schema") != "lume.mac4_bodytruth_depth_or_wide_evidence.v1":
    errors.append("bad_schema")
if data.get("source_id") != "mac4_bodytruth_depth_or_wide":
    errors.append(f"bad_source_id:{data.get('source_id')}")
if data.get("host_machine") != "Mac4":
    errors.append(f"bad_host_machine:{data.get('host_machine')}")
if data.get("required_for_first_real_run") is not True:
    errors.append("required_for_first_real_run_not_true")
if not data.get("run_id"):
    errors.append("missing_run_id")
if not data.get("capture_window_id"):
    errors.append("missing_capture_window_id")

bodytruth = data.get("bodytruth") or {}
if bodytruth.get("service_reachable") is not True:
    errors.append("bodytruth_service_reachable_not_true")
if bodytruth.get("body_present") is not True:
    errors.append("bodytruth_body_present_not_true")
if bodytruth.get("tracking_status") not in good_tracking_statuses:
    errors.append(f"bad_tracking_status:{bodytruth.get('tracking_status')}")
confidence = bodytruth.get("confidence")
threshold = bodytruth.get("confidence_threshold", 0.55)
if not isinstance(confidence, (int, float)):
    errors.append(f"confidence_not_numeric:{confidence}")
if not isinstance(threshold, (int, float)):
    errors.append(f"confidence_threshold_not_numeric:{threshold}")
if isinstance(confidence, (int, float)) and isinstance(threshold, (int, float)) and confidence < threshold:
    errors.append(f"confidence_below_threshold:{confidence}<{threshold}")
if bodytruth.get("capture_window_match") is not True:
    errors.append("bodytruth_capture_window_match_not_true")
if bodytruth.get("rows_fresh_for_capture_window") is not True:
    errors.append("bodytruth_rows_fresh_for_capture_window_not_true")
if bodytruth.get("read_only") is not True:
    errors.append("bodytruth_read_only_not_true")
if bodytruth.get("command_capability") is not False:
    errors.append("bodytruth_command_capability_not_false")

pose_path = str(bodytruth.get("pose_rows_path") or "")
video_path = str(bodytruth.get("video_path") or "")
state_path = str(bodytruth.get("bodytruth_state_path") or "")
topology_path = str(bodytruth.get("topology_notes_path") or "")

if not pose_path and not video_path:
    errors.append("missing_pose_rows_or_video_path")
for key, value, required in [
    ("pose_rows_path", pose_path, False),
    ("video_path", video_path, False),
    ("bodytruth_state_path", state_path, True),
    ("topology_notes_path", topology_path, False),
]:
    if required and not value:
        errors.append(f"missing_{key}")
    if not value:
        continue
    if not value.startswith(str(trusted_root)):
        errors.append(f"{key}_outside_trusted_root:{value}")
    if any(marker in value for marker in bad_markers):
        errors.append(f"bad_mac4_path:{key}:{value}")

admission = data.get("admission") or {}
if admission.get("admitted_for_required_capture") is True:
    if admission.get("admitted_for_bundle") is not True:
        errors.append("required_capture_admitted_without_bundle_admission")
    if admission.get("rejection_reasons"):
        errors.append("admitted_mac4_lane_has_rejection_reasons")
else:
    if not admission.get("rejection_reasons"):
        errors.append("not_admitted_without_rejection_reasons")

safety = data.get("safety") or {}
if safety.get("mac4_read_only") is not True:
    errors.append("mac4_read_only_not_true")
for key in [
    "mac4_sends_rekordbox_commands",
    "mac4_sends_airdeck_commands",
    "unity_enthea_mrt2_demon_can_command",
    "fixture_or_placeholder_origin",
]:
    if safety.get(key) is not False:
        errors.append(f"{key}_not_false")
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_only_command_gate_not_true")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("mac4_bodytruth_depth_or_wide_evidence_passed")
PY

iphone_16_plus_motionmix
iphone_14_pro_max_motionmix
mac2_insta360_room_wide
mac4_bodytruth_depth_or_wide

[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/evidence/required_physical_lane_index.json

[home]/Desktop/MotionMix/lume-wiring/real-capture-bundles/<bundle_id>/raw/evidence/required_physical_lane_index.json

{
  "schema": "lume.required_physical_lane_index.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "run_id": "home-return-YYYYMMDDTHHMMSS-local",
  "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "bundle_id": null,
  "physical_lanes_ready": false,
  "required_source_ids": [
    "iphone_16_plus_motionmix",
    "iphone_14_pro_max_motionmix",
    "mac2_insta360_room_wide",
    "mac4_bodytruth_depth_or_wide"
  ],
  "lane_checks": [
    {
      "source_id": "iphone_16_plus_motionmix",
      "evidence_group": "iphone_motionmix_required_pose_pair",
      "evidence_path": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/evidence/required_iphone_motionmix_sources.json",
      "validator_name": "IPHONE_MOTIONMIX_EVIDENCE",
      "validator_pass_marker": "iphone_motionmix_required_pose_evidence_passed",
      "validator_passed": false,
      "capture_window_match": false,
      "admitted_for_required_capture": false,
      "blocking_reasons": [
        "waiting_for_current_distinct_required_iphone_pose_rows"
      ]
    },
    {
      "source_id": "iphone_14_pro_max_motionmix",
      "evidence_group": "iphone_motionmix_required_pose_pair",
      "evidence_path": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/evidence/required_iphone_motionmix_sources.json",
      "validator_name": "IPHONE_MOTIONMIX_EVIDENCE",
      "validator_pass_marker": "iphone_motionmix_required_pose_evidence_passed",
      "validator_passed": false,
      "capture_window_match": false,
      "admitted_for_required_capture": false,
      "blocking_reasons": [
        "waiting_for_current_distinct_required_iphone_pose_rows"
      ]
    },
    {
      "source_id": "mac2_insta360_room_wide",
      "evidence_group": "mac2_insta360_room_wide",
      "evidence_path": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/evidence/mac2_insta360_room_wide.json",
      "validator_name": "MAC2_INSTA360_EVIDENCE",
      "validator_pass_marker": "mac2_insta360_room_wide_evidence_passed",
      "validator_passed": false,
      "capture_window_match": false,
      "admitted_for_required_capture": false,
      "blocking_reasons": [
        "waiting_for_current_nonzero_room_wide_clip"
      ]
    },
    {
      "source_id": "mac4_bodytruth_depth_or_wide",
      "evidence_group": "mac4_bodytruth_depth_or_wide",
      "evidence_path": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/evidence/mac4_bodytruth_depth_or_wide.json",
      "validator_name": "MAC4_BODYTRUTH_EVIDENCE",
      "validator_pass_marker": "mac4_bodytruth_depth_or_wide_evidence_passed",
      "validator_passed": false,
      "capture_window_match": false,
      "admitted_for_required_capture": false,
      "blocking_reasons": [
        "waiting_for_current_body_present_bodytruth_rows_or_video"
      ]
    }
  ],
  "missing_or_blocked_source_ids": [
    "iphone_16_plus_motionmix",
    "iphone_14_pro_max_motionmix",
    "mac2_insta360_room_wide",
    "mac4_bodytruth_depth_or_wide"
  ],
  "downstream_permissions": {
    "source_plan_prefill_allowed": false,
    "bundle_assembly_allowed": false,
    "strict_real_bundle_preflight_allowed": false,
    "placeholder_handoff_allowed": false,
    "mac5_handoff_allowed": false,
    "heavy_reconstruction_allowed": false,
    "k11_promotion_allowed": false
  },
  "safety": {
    "k11_is_only_command_gate": true,
    "phones_send_rekordbox_commands": false,
    "mac2_sends_rekordbox_commands": false,
    "mac4_read_only": true,
    "mac4_sends_rekordbox_commands": false,
    "mac5_sends_rekordbox_commands": false,
    "fixture_or_placeholder_origin": false
  },
  "next_allowed_action": "collect or repair required physical lane evidence before source-plan admission"
}

PHYSICAL_LANE_INDEX="/path/to/required_physical_lane_index.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["PHYSICAL_LANE_INDEX"])
data = json.loads(path.read_text())
errors = []
trusted_root = Path("[home]/Desktop/MotionMix/lume-wiring")
expected_sources = {
    "iphone_16_plus_motionmix",
    "iphone_14_pro_max_motionmix",
    "mac2_insta360_room_wide",
    "mac4_bodytruth_depth_or_wide",
}
expected_validators = {
    "iphone_16_plus_motionmix": ("IPHONE_MOTIONMIX_EVIDENCE", "iphone_motionmix_required_pose_evidence_passed"),
    "iphone_14_pro_max_motionmix": ("IPHONE_MOTIONMIX_EVIDENCE", "iphone_motionmix_required_pose_evidence_passed"),
    "mac2_insta360_room_wide": ("MAC2_INSTA360_EVIDENCE", "mac2_insta360_room_wide_evidence_passed"),
    "mac4_bodytruth_depth_or_wide": ("MAC4_BODYTRUTH_EVIDENCE", "mac4_bodytruth_depth_or_wide_evidence_passed"),
}
bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]

if data.get("schema") != "lume.required_physical_lane_index.v1":
    errors.append("bad_schema")
if not data.get("run_id"):
    errors.append("missing_run_id")
if not data.get("capture_window_id"):
    errors.append("missing_capture_window_id")
if set(data.get("required_source_ids") or []) != expected_sources:
    errors.append(f"required_source_ids_mismatch:{data.get('required_source_ids')}")

lane_checks = data.get("lane_checks") or []
seen = {}
for lane in lane_checks:
    source_id = lane.get("source_id")
    if source_id in seen:
        errors.append(f"duplicate_lane_check:{source_id}")
    seen[source_id] = lane
if set(seen) != expected_sources:
    errors.append(f"lane_check_source_set_mismatch:{sorted(seen)}")

blocked = set()
passed = set()
for source_id in expected_sources:
    lane = seen.get(source_id) or {}
    validator_name, pass_marker = expected_validators[source_id]
    if lane.get("validator_name") != validator_name:
        errors.append(f"{source_id}:bad_validator_name:{lane.get('validator_name')}")
    if lane.get("validator_pass_marker") != pass_marker:
        errors.append(f"{source_id}:bad_validator_pass_marker:{lane.get('validator_pass_marker')}")
    evidence_path = str(lane.get("evidence_path") or "")
    if not evidence_path:
        errors.append(f"{source_id}:missing_evidence_path")
    else:
        if not evidence_path.startswith(str(trusted_root)):
            errors.append(f"{source_id}:evidence_path_outside_trusted_root:{evidence_path}")
        if any(marker in evidence_path for marker in bad_markers):
            errors.append(f"{source_id}:bad_evidence_path:{evidence_path}")
    lane_green = (
        lane.get("validator_passed") is True
        and lane.get("capture_window_match") is True
        and lane.get("admitted_for_required_capture") is True
    )
    if lane_green:
        passed.add(source_id)
        if lane.get("blocking_reasons"):
            errors.append(f"{source_id}:passed_lane_has_blocking_reasons")
    else:
        blocked.add(source_id)
        if not lane.get("blocking_reasons"):
            errors.append(f"{source_id}:blocked_lane_missing_blocking_reasons")

missing_or_blocked = set(data.get("missing_or_blocked_source_ids") or [])
if missing_or_blocked != blocked:
    errors.append(f"missing_or_blocked_mismatch:{sorted(missing_or_blocked)}!={sorted(blocked)}")

physical_ready = data.get("physical_lanes_ready")
if physical_ready is not (len(blocked) == 0 and passed == expected_sources):
    errors.append("physical_lanes_ready_inconsistent")

permissions = data.get("downstream_permissions") or {}
if physical_ready is True:
    for key in [
        "source_plan_prefill_allowed",
        "bundle_assembly_allowed",
        "strict_real_bundle_preflight_allowed",
    ]:
        if permissions.get(key) is not True:
            errors.append(f"{key}_not_true_when_physical_ready")
    for key in ["placeholder_handoff_allowed", "mac5_handoff_allowed", "heavy_reconstruction_allowed", "k11_promotion_allowed"]:
        if permissions.get(key) is not False:
            errors.append(f"{key}_not_false_at_physical_index_stage")
else:
    for key, value in permissions.items():
        if value is not False:
            errors.append(f"{key}_not_false_while_physical_lanes_blocked")

safety = data.get("safety") or {}
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_only_command_gate_not_true")
for key in [
    "phones_send_rekordbox_commands",
    "mac2_sends_rekordbox_commands",
    "mac4_sends_rekordbox_commands",
    "mac5_sends_rekordbox_commands",
    "fixture_or_placeholder_origin",
]:
    if safety.get(key) is not False:
        errors.append(f"{key}_not_false")
if safety.get("mac4_read_only") is not True:
    errors.append("mac4_read_only_not_true")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("required_physical_lane_index_passed")
PY

K11
  owns: AirDeck command gate, Pose Coach/operator visibility, live gesture logs, promoted command manifest
  writes: latest pose bridge JSON, bridge event log, command/why-not-fired evidence, console snapshots
  may consume: MotionMix pose packets, BodyTruth gate state, reviewed K11 manifest
  must not consume as truth: unlabeled phone claims, fixture packets, Mac4/Mac5 generated guesses

iPhones
  owns: mobile camera pose/video evidence through MotionMix
  writes: pose rows, device identity, peer ip, optional video/session evidence, frame timing
  may consume: local MotionMix settings and operator framing
  must not write: Rekordbox commands, promoted K11 manifests, reconstruction-learning claims

iPads
  owns: StageView, ShootView, operator surfaces, optional support angles
  writes: optional view/camera evidence only if labeled optional
  may consume: monitoring state, stage/shoot controls, memory views
  must not write: required command-source evidence or replacement evidence for required iPhone lanes

Mac2
  owns: Arducam/UVC room-wide external-camera lane
  writes: external-camera probe plus nonzero room-wide clip and source manifest rows
  may consume: source-plan instructions and capture scheduling
  must not write: FaceTime-substitute evidence, Rekordbox commands, learned reconstruction claims

Mac4
  owns: BodyTruth depth/wide evidence and read-only Unity/ENTHEA/MRT2/DEMON/template preparation
  writes: BodyTruth rows, confidence/presence, topology notes, visual/audio mapping requests
  may consume: reviewed pose/session windows, SAN rows, source bundle summaries
  must not write: Rekordbox commands, live gesture promotions, Mac5 learning claims

Mac5
  owns: offline reconstruction, SAM3D/adapters, bundle verification, template extraction, learning audit
  writes: reconstruction summaries, template candidates, reconstruction-learning audit, derived bundle outputs
  may consume: strict-real bundles only after preflight and explicit allow for heavy work
  must not write: live commands, truth labels without evidence, promoted K11 command manifests

SAN and semantic lanes
  owns: phrase windows, policy rows, compatibility/context notes, candidate descriptions
  writes: annotated windows and candidate rows with source-window links
  may consume: reviewed evidence and current-track/movement context
  must not write: capture proof, reconstruction proof, or command authority

source evidence rows
  -> source plan
  -> topology validation
  -> real session bundle
  -> strict real-bundle preflight report
  -> placeholder handoff/review
  -> explicit heavy allow
  -> Mac5 reconstruction output
  -> reconstruction-learning audit
  -> derived templates/SAN/NKo/visual/audio/DEMON candidates
  -> reviewed promotion candidates
  -> K11 manifest update only for approved commands

claim_status
evidence_grade
source_ids
source_window_start_utc
source_window_end_utc
producer
allowed_consumers
forbidden_consumers
next_required_gate
review_status
operator_note

template_only
  planned schema, fixture, placeholder, generated example, or old prompt text
  may inform design
  cannot prove capture, command safety, reconstruction, or learning

probe_only
  service reachable, camera listed, bridge alive, report path exists
  may prove a path is reachable
  cannot prove body evidence or strict-real capture

observed_live
  fresh live packet, event, pose row, or video seen from a source
  may support home-return checks and rehearsal
  cannot enter trusted bundle until identity, timing, and source role pass

captured_real_candidate
  real source evidence staged with identity, timing, and operator notes
  may enter source-plan validation
  cannot unlock Mac5 until admitted and preflighted

admitted_strict_real
  required source row passes source identity, timing, topology, non-synthetic evidence, and trusted-root checks
  may enter strict real bundle and preflight
  cannot imply learning or live promotion by itself

preflight_ready
  assembled bundle passes strict real-bundle preflight
  may arm placeholder handoff and operator review
  cannot run heavy reconstruction without explicit allow

placeholder_reconstructed
  Mac5 placeholder backend proved routing/plumbing
  may prove handoff and report writing
  cannot prove body reconstruction, learning, template quality, or live promotion safety

reconstructed_real
  non-placeholder Mac5 reconstruction output tied to strict-real source windows
  may feed learning audit and template review
  cannot bypass K11 promotion governance

reviewed_candidate
  human/operator or audited review accepted a derived template, SAN row, visual mapping, DEMON curve, or gesture candidate
  may enter dry-run or downstream candidate queues
  cannot command Rekordbox unless separately promoted through K11

promoted_live
  K11 manifest includes the gesture/command, rollback exists, dry-run proof exists, and bridge/console agree
  may send the approved command from K11 only
  cannot expand to adjacent gestures automatically

expected
detected
observed
staged
candidate
admitted
preflight_passed
placeholder_only
reconstructed
learned_candidate
review_ready
dry_run_passed
promoted_live
rolled_back
rejected

K11 command gate may consume promoted_live command rows only
K11 console may display all grades if the grade/status is visible
AirDeck observe-only may consume observed_live and captured_real_candidate rows but must write sent_command=false
AirDeck similarity may consume reviewed or clearly labeled stale track metadata with command_eligible=false
Mac4 visuals may consume observed_live or higher if read-only and damped by confidence
Mac4 MRT2/ENTHEA/Unity outputs may consume reviewed_candidate mappings and must remain read-only
Mac5 placeholder may consume preflight_ready bundles after operator review
Mac5 heavy reconstruction may consume preflight_ready bundles only after explicit heavy allow
SAN may consume admitted or reviewed source windows but cannot claim capture proof
DEMON may consume reviewed motion labels/timing curves but cannot command Rekordbox
NKo/MnKO inscriptions may consume reviewed movement phrases and evidence links, not raw guesses

observed does not mean trained
trained does not mean reviewed
reviewed does not mean dry-run passed
dry-run passed does not mean live
live for one gesture does not authorize adjacent gestures
placeholder reconstruction does not mean learning
learning does not edit K11 manifests
visual response does not imply command authority
semantic confidence does not replace source evidence

K11 AirDeck Console
  audience: operator during performance
  authority: K11 command safety and gesture visibility
  must show: command peer, manifest hash, Rekordbox foreground/focus, live gestures, observe-only gestures, blocked reasons, latest pose source, stale age
  must not do: promote gestures, edit manifests, send commands from support peers

MotionMix mobile view
  audience: camera/source operator
  authority: local camera/pose state only
  must show: device label, peer, role, frame freshness, pose/body confidence, capture window id
  must not do: claim command authority or strict-real bundle admission

Mac4 visual/output monitor
  audience: read-only output operator
  authority: visual/audio mapping health
  must show: BodyTruth body present, confidence, visual/MRT2/ENTHEA output freshness, read-only status
  must not do: send Rekordbox commands or unlock Mac5 heavy reconstruction

Mac5 reconstruction monitor
  audience: offline reconstruction operator
  authority: bundle/handoff/reconstruction state
  must show: strict preflight status, backend mode, placeholder vs non-placeholder, explicit heavy allow, learning audit result
  must not do: infer readiness from file names or start heavy work without the gate

LUME wiring status page or report pack
  audience: resuming agents and Mohamed
  authority: consolidated truth only after reading underlying reports
  must show: current mode, next safe action, blockers, report timestamps, source identities, missing lanes, and command boundary status
  must not do: hide stale or contradictory reports

system_mode
k11_command_gate
active_command_peer
rekordbox_focus
manifest_hash
live_gestures
observe_only_gestures
iphone_16_plus_motionmix
iphone_14_pro_max_motionmix
iphone_16_pro_max_optional
ipad_stageview_optional
ipad_shootview_optional
mac2_insta360_room_wide
mac4_bodytruth_depth_or_wide
source_identity_status
capture_window_status
camera_topology_status
strict_real_bundle_preflight
mac5_handoff_mode
mac5_learning_status
san_status
similarity_queue_status
unity_enthea_mrt2_status
demon_request_status
nko_mnko_inscription_status
next_safe_action
blocked_reasons

GREEN
  current, admitted, safe for the specific consumer shown

YELLOW
  observed, staged, optional, stale-but-informative, or waiting for review

RED
  blocked, unsafe, missing, ambiguous, failed, wrong authority, fixture-origin, or stale for the claimed use

GRAY
  not configured, not required for current phase, not trained, or intentionally disabled

BLUE
  read-only output lane, visual/semantic candidate, or non-command recommendation

live command freshness is measured in milliseconds or a few seconds and belongs to K11 only
home-return freshness is measured against current source-plan validation windows
strict-real bundle freshness is bound to capture_window_id and trusted copied evidence
derived-lane freshness is bound to source-window links and claim status
remote parity freshness is bound to the latest parity/coherence reports
Mac5 reconstruction freshness is bound to the selected bundle id and backend run id

current mode
  source: full-system goal audit + home-return action packet

K11 command gate
  source: K11 bridge/latest evidence + operator surface audit + promotion manifest

source lanes
  source: source plan + home-return validation + first-real-capture report

strict real-bundle preflight
  source: lume_post_mac4_real_bundle_preflight_current.json

remote parity and coherence
  source: remote report parity + current surface coherence reports

Mac5 handoff and learning
  source: Mac5 return sync + reconstruction arm review + learning audit reports

derived lanes
  source: derived-lanes spec plus actual bundle derived files with source-window links

missing_required_lane: iphone_14_pro_max_motionmix
ambiguous_identity: two phone rows share peer_or_address
wrong_authority: iPad cannot replace required phone lane
stale_pose: latest pose older than freshness gate
fixture_origin: evidence path points to fixture/smoke/temp
preflight_blocked: strict real-bundle preflight failed
heavy_locked: explicit heavy reconstruction allow missing
observe_only: gesture not in K11 promotion manifest
support_peer_gated: latest pose is from non-command peer
read_only_boundary: Mac4 lane cannot command Rekordbox

R1 Mac4 green unlock
  evidence: lume_mac4_first_completion_gate_20260610T035207Z.json + full-system goal audit requirement 1
  current status: proven
  blocker: none
  next action: preserve as unlock artifact; do not use it to bypass real capture lanes

R2 Session bundle contract
  evidence: lume_post_mac4_session_bundle_contract_v1.json + contract coverage audit + full-system goal audit requirement 2
  current status: proven
  blocker: none
  next action: keep source identity, topology, pose, video, SAN, safety, and operator-note fields aligned

R3 SAN/reconstruction separation
  evidence: lume_post_mac4_san_reconstruction_boundary_v1.json + full-system goal audit requirement 3
  current status: proven
  blocker: none
  next action: keep SAN as phrase/audio/gesture policy and reconstruction as multi-view body evidence

R4 Mac5 dry-run readiness with heavy lock
  evidence: lume_post_mac4_mac5_return_sync_current.json + full-system goal audit requirement 4
  current status: proven
  blocker: real bundle preflight still blocked
  next action: allow dry-run/plumbing only; keep heavy reconstruction locked

R5 K11 command boundary
  evidence: state refresh safety, operator audit safety, parity/coherence safety, K11 bridge/console proof
  current status: proven for current play-only lane
  blocker: new commands are not promoted
  next action: keep only hand raise live; new gestures stay observe-only until promotion gate passes

R6 K11 AirDeck operator visibility
  evidence: AirDeck Console installed on K11, scheduled task, console one-shot snapshot, recent bridge events
  current status: proven for play-only visibility
  blocker: observe-only events still need fuller capture surface
  next action: implement/log observe-only rows for sync, next, loop, scratch, platter, safe stop, crate browse

R7 Home-return physical validation
  evidence: lume_post_mac4_home_return_state_refresh_current.json + action packet + validation report
  current status: incomplete
  blocker: missing iphone_16_plus_motionmix, iphone_14_pro_max_motionmix, mac2_insta360_room_wide, mac4_bodytruth_depth_or_wide
  next action: when devices are positioned, run live refresh, prefill source plan, validate home return

R8 Strict real-bundle preflight
  evidence: lume_post_mac4_real_bundle_preflight_current.json
  current status: blocked_real_bundle_preflight
  blocker: fixture/ephemeral markers and missing strict-real required lanes
  next action: replace missing/fixture evidence with strict-real captures and reassemble bundle

R9 First Mac5 reconstruction and learning audit
  evidence: reconstruction handoff report + reconstruction learning audit
  current status: incomplete
  blocker: no real assembled bundle, preflight not ready, no non-placeholder learning audit
  next action: only after R7 and R8 pass, run placeholder handoff, operator review, explicit heavy allow, then audit learning

R10 AirDeck similarity
  evidence: lume-airdeck-similarity-spec-current.md
  current status: specified, not implemented as command path
  blocker: track index/current-track queue not yet built
  next action: build non-command candidate queue with command_eligible=false

R11 Derived lanes after capture
  evidence: lume-derived-lanes-after-capture-spec-current.md
  current status: specified, waiting for strict-real bundle
  blocker: no strict-real session bundle
  next action: after capture, emit templates, SAN index, NKo/MnKO inscriptions, ENTHEA/Unity, MRT2, DEMON, semantic candidates with source-window links

R12 Remote parity and coherence
  evidence: lume_post_mac4_remote_report_parity_current.json + lume_post_mac4_current_surface_coherence_current.json
  current status: remote_report_parity_verified and current_surface_coherent as of 2026-06-10 21:33 EDT
  blocker: none at current audit time
  next action: rerun after any report or prompt-pack update that must travel to Mac2/Mac5

static_check
  reads local files, schemas, specs, or reports only
  allowed during away-window work

read_only_live_check
  probes reachable services or machines without starting capture or commands
  allowed only when the target is reachable and the command is documented as read-only

operator_live_check
  requires Mohamed/device placement or a confirmed physical setup
  not allowed during away-window work

capture_gate
  records or assembles physical evidence
  requires physical setup and explicit operator context

heavy_compute_gate
  starts Mac5 non-placeholder reconstruction or learning
  requires strict preflight green plus explicit heavy allow

promotion_gate
  edits or reloads the K11 live manifest
  requires reviewed evidence, dry-run proof, rollback manifest, and explicit operator acceptance

G0 prompt/status coherence
  level: static_check
  proof: this prompt audit timestamp matches current report summaries
  command type: rg/wc/jq only
  failure means: update prompt or rerun read-only report checks

G1 remote parity and current-surface coherence
  level: read_only_live_check
  proof: remote_report_parity_verified and current_surface_coherent
  command: verify_lume_post_mac4_remote_report_parity.py + audit_lume_post_mac4_current_surface_coherence.py
  failure means: do not claim Mac2/Mac5 prompt/report parity

G2 operator surface readiness
  level: read_only_live_check
  proof: operator_surface_ready_waiting_for_physical_lanes with failure_count=0
  command: audit_lume_post_mac4_operator_surface.py
  failure means: repair K11/console/report surface before physical capture claims

G3 home-return state
  level: read_only_live_check or operator_live_check depending on flags and device state
  proof: no longer waiting_for_physical_lanes
  command: refresh_lume_post_mac4_home_return_state.py
  failure means: remain in read_only_audit or observe_only_capture

G4 source-plan validation
  level: operator_live_check
  proof: required rows admitted with identity, timing, topology, and current evidence
  command: run_lume_post_mac4_home_return_validation.py
  failure means: do not assemble a trusted real bundle

G5 strict real-bundle preflight
  level: static_check after bundle exists
  proof: preflight ready and heavy_reconstruction_preflight_ready=true
  command: audit_lume_post_mac4_real_bundle_preflight.py
  failure means: do not run Mac5 placeholder/heavy reconstruction from the failed bundle

G6 Mac5 sync
  level: read_only_live_check
  proof: mac5_post_mac4_tools_verified
  command: verify_lume_post_mac4_mac5_return_sync.py
  failure means: repair sync/tooling before handoff

G7 placeholder handoff
  level: operator_live_check after G5
  proof: placeholder run report exists and learning audit refuses to call it real learning
  command: run_lume_post_mac4_reconstruction_handoff.py --backend placeholder --run
  failure means: repair plumbing, not learning

G8 heavy reconstruction
  level: heavy_compute_gate
  proof: non-placeholder Mac5 output tied to strict-real source windows
  command: run_lume_post_mac4_reconstruction_handoff.py --backend auto --run --allow-heavy-reconstruction
  failure means: no reconstruction learning claim and no promotion unlock

G9 reconstruction learning
  level: static_check after G8
  proof: learning audit reports non-placeholder learning and safe_to_promote_live when supported
  command: audit_lume_post_mac4_reconstruction_learning.py
  failure means: templates/SAN/DEMON/NKo outputs remain candidates

G10 AirDeck observe-only
  level: static_check or operator_live_check depending on event capture
  proof: non-manifest gestures write sent_command=false and why_not_fired
  command: inspect gesture_events.jsonl / why_not_fired.jsonl / K11 console snapshot
  failure means: keep gesture not_trained or blocked

G11 K11 live promotion
  level: promotion_gate
  proof: before/after manifest hashes, dry-run proof, rollback manifest, operator acceptance, bridge/console agreement
  command: intentional K11 manifest promotion process only
  failure means: rollback and set gesture disabled_or_rolled_back

do not use successful ping as body evidence
do not use service health as capture evidence
do not use fixture preflight as real-bundle preflight
do not use placeholder reconstruction as learning evidence
do not use Mac4 visual response as command safety proof
do not use K11 hand-raise success as proof for sync/next/scratch gestures
do not use a dashboard GREEN tile unless the row names the exact report behind it
do not run heavy commands from this section during away-window work

symptom: prompt says ready but report says waiting/blocked, or parity/coherence reports disagree
safe mode: read_only_audit
do:
  rerun remote parity and current-surface coherence checks
  trust lower-level evidence reports over this prompt
  update dashboard rows and this prompt audit text after the report changes
do not:
  claim completion from stale prose
  delete contradictory reports
  run capture or reconstruction while the current-surface status is unclear

symptom: iphone_16_plus_motionmix or iphone_14_pro_max_motionmix is absent, stale, unlabeled, or has no pose rows
safe mode: observe_only_capture
do:
  confirm MotionMix is open on the intended phone
  record device label, peer, role, and placement note
  verify fresh pose rows before source-plan admission
do not:
  substitute iPad rows
  use optional iPhone 16 Pro Max as a required lane without changing the contract
  treat latest K11 pose as multi-view evidence

symptom: two phone lanes share one peer, one label, or one latest-pose file
safe mode: read_only_audit
do:
  mark both phone rows rejected_ambiguous_identity
  separate source ids and capture windows
  preserve the collapsed rows as failed evidence
do not:
  choose a winner by packet order
  use the collapsed source for K11 promotion or Mac5 reconstruction

symptom: Mac2 probe sees no eligible external camera, FaceTime only, zero-byte video, or no room-wide clip
safe mode: observe_only_capture
do:
  keep Mac2 row blocked until external camera proof plus nonzero clip exists
  record camera name, capture path, duration, and timing metadata
do not:
  use FaceTime camera as the Mac2 room-wide lane
  use camera service reachability as room-wide video evidence
  run strict real-bundle preflight expecting Mac2 to pass

symptom: Mac4 services reachable but body absent, confidence low, tracking lost, or only bridge health exists
safe mode: read_only_audit or observe_only_capture
do:
  keep Mac4 read-only
  require BodyTruth pose/video rows or body-present confidence before admission
  preserve tracking-lost evidence as useful diagnostics only
do not:
  let Mac4 command Rekordbox
  count bridge health as body evidence
  unlock Mac5 heavy reconstruction from Mac4 service health

symptom: required row missing identity, timing, topology, evidence path, or command/read-only boundary
safe mode: observe_only_capture
do:
  fix the source evidence or rerun capture
  keep rejected rows and rejection reasons
  validate again before bundle assembly
do not:
  hand-edit admitted_for_bundle=true
  rename fixture paths to trusted paths
  fill required fields from expected architecture instead of evidence

symptom: blocked_real_bundle_preflight, fixture markers, missing lanes, temp paths, weak topology, or heavy_reconstruction_preflight_ready=false
safe mode: read_only_audit
do:
  treat the failed bundle as a failure artifact
  assemble a fresh trusted bundle from admitted strict-real source rows
  rerun preflight only after evidence changes
do not:
  patch the failed bundle to look real
  start placeholder/heavy Mac5 work from the failed bundle
  lower the preflight threshold

symptom: Mac5 sync not verified, handoff report missing, placeholder backend fails, or learning audit cannot read outputs
safe mode: placeholder_handoff only after strict preflight is green
do:
  verify Mac5 tool sync
  run placeholder before heavy backend
  require learning audit to distinguish placeholder from non-placeholder
do not:
  call plumbing reconstruction
  call placeholder output learning
  allow Mac5 to edit K11 manifests

symptom: gesture fires during normal dancing, wrong peer commands, cooldown fails, Rekordbox focus unknown, or operator cannot tell why it fired
safe mode: dry_run_airdeck or rollback
do:
  preserve event rows, why_not_fired rows, manifest hashes, and console snapshot
  restore previous manifest if live behavior is unsafe
  move the gesture to disabled_or_rolled_back
do not:
  promote adjacent gestures
  hot-patch the live manifest in place
  trust SAN/DEMON/visual confidence as command proof

symptom: GREEN tile lacks a report path, timestamp, source id, or claim grade
safe mode: read_only_audit
do:
  downgrade the row to YELLOW or RED
  add exact report authority and blocked reason
  rerun the relevant verification command if it is read-only
do not:
  use dashboard color as proof without underlying report evidence

symptom: evidence lives under /tmp, /private/var/folders, fixture, smoke, downloads, or an untrusted scratch dir
safe mode: read_only_audit
do:
  preserve the path as diagnostic evidence
  copy only admitted evidence into the trusted bundle root during assembly
  record source and destination hashes when available
do not:
  symlink temp evidence into the trusted bundle
  count smoke output as physical capture

signoff_id
session_id
bundle_id
capture_window_id
operator_name
operator_role
created_at_utc
accepted_scope
accepted_evidence_paths
accepted_report_paths
known_limitations
blocked_items_acknowledged
rollback_or_stop_path
next_allowed_action
explicit_allow_flags
operator_note

first_real_capture_setup
  accepts: devices are physically positioned and capture can begin
  does not accept: bundle admission, reconstruction, learning, or live promotion

source_plan_admission
  accepts: source rows are correctly labeled, timed, and role-bound
  does not accept: strict preflight or Mac5 reconstruction

strict_real_bundle_preflight
  accepts: assembled bundle is ready for preflight review
  does not accept: heavy reconstruction unless preflight report says ready

placeholder_handoff
  accepts: Mac5 placeholder plumbing can run after strict preflight
  does not accept: learning or template quality

heavy_reconstruction
  accepts: non-placeholder Mac5 work may run
  requires: strict preflight green, operator review, explicit heavy allow
  does not accept: K11 live manifest changes

derived_lane_review
  accepts: templates, SAN rows, NKo/MnKO inscriptions, Unity/ENTHEA/MRT2, or DEMON candidates may be reviewed
  does not accept: live Rekordbox commands

gesture_dry_run
  accepts: a candidate gesture may be tested without sending commands
  requires: observe-only evidence and why-not-fired rows
  does not accept: live promotion

k11_live_promotion
  accepts: one reviewed gesture or tightly coupled command pair may enter the K11 manifest
  requires: dry-run proof, false-positive review, mapping hash, rollback manifest, and operator acceptance
  does not accept: adjacent gestures or future automatic promotion

allow_first_real_capture=true
allow_placeholder_handoff=true
allow_heavy_reconstruction=true
allow_derived_lane_review=true
allow_gesture_dry_run=true
allow_k11_live_promotion=true

before first real capture:
  first_real_capture_setup_signoff.md or .json
  confirms devices are positioned and command safety mode is understood

before bundle assembly:
  source_plan_admission_signoff.md or .json
  confirms source identity, timing, and role labels were reviewed

before Mac5 placeholder:
  placeholder_handoff_signoff.md or .json
  confirms strict preflight is green and placeholder is plumbing-only

before Mac5 heavy:
  heavy_reconstruction_signoff.md or .json
  confirms explicit heavy allow and strict preflight report path

before derived-lane promotion to reviewed candidates:
  derived_lane_review_signoff.md or .json
  confirms source-window links and claim status

before K11 manifest change:
  k11_live_promotion_signoff.md or .json
  confirms one gesture scope, rollback path, before/after hashes, and operator acceptance

do not treat "Mohamed is back" as heavy reconstruction allow
do not treat "camera is visible" as source-plan acceptance
do not treat "hand raise works" as permission for sync/next/scratch
do not treat "Mac5 tools verified" as permission for non-placeholder reconstruction
do not reuse a signoff across a different capture_window_id
do not bury limitations outside the packet

first-real-capture-runs/<run_id>/signoff/first_real_capture_setup_signoff.json
first-real-capture-runs/<run_id>/signoff/source_plan_admission_signoff.json
real-capture-bundles/<bundle_id>/signoff/strict_real_bundle_preflight_signoff.json
real-capture-bundles/<bundle_id>/signoff/placeholder_handoff_signoff.json
real-capture-bundles/<bundle_id>/signoff/heavy_reconstruction_signoff.json
real-capture-bundles/<bundle_id>/signoff/derived_lane_review_signoff.json
real-capture-bundles/<bundle_id>/signoff/k11_live_promotion_signoff.json

{
  "schema": "lume.operator_signoff.v1",
  "signoff_id": "YYYYMMDD-HHMMSS-scope",
  "session_id": "YYYYMMDD-HHMMSS-lume",
  "bundle_id": null,
  "capture_window_id": null,
  "operator_name": "Mohamed",
  "operator_role": "owner_operator",
  "created_at_utc": "YYYY-MM-DDTHH:MM:SSZ",
  "accepted_scope": "first_real_capture_setup",
  "accepted_evidence_paths": [],
  "accepted_report_paths": [],
  "known_limitations": [],
  "blocked_items_acknowledged": [],
  "rollback_or_stop_path": "",
  "next_allowed_action": "",
  "explicit_allow_flags": {
    "allow_first_real_capture": false,
    "allow_placeholder_handoff": false,
    "allow_heavy_reconstruction": false,
    "allow_derived_lane_review": false,
    "allow_gesture_dry_run": false,
    "allow_k11_live_promotion": false
  },
  "operator_note": "",
  "created_by": "operator_or_agent_name",
  "claim_status": "review_ready"
}

# LUME Operator Signoff

signoff_id:
session_id:
bundle_id:
capture_window_id:
operator_name:
operator_role:
created_at_utc:
accepted_scope:

## Accepted Evidence Paths

-

## Accepted Report Paths

-

## Known Limitations

-

## Blocked Items Acknowledged

-

## Rollback Or Stop Path


## Next Allowed Action


## Explicit Allow Flags

- allow_first_real_capture: false
- allow_placeholder_handoff: false
- allow_heavy_reconstruction: false
- allow_derived_lane_review: false
- allow_gesture_dry_run: false
- allow_k11_live_promotion: false

## Operator Note


## Claim Status

review_ready

first_real_capture_setup
  true flag allowed: allow_first_real_capture
  next_allowed_action: run one-pass home-return sequence or first-real capture script
  required report paths: home-return state refresh, action packet, operator surface audit

source_plan_admission
  true flag allowed: none
  next_allowed_action: assemble trusted real bundle only after validation passes
  required report paths: source plan, home-return validation, topology validation

placeholder_handoff
  true flag allowed: allow_placeholder_handoff
  next_allowed_action: run Mac5 placeholder handoff
  required report paths: strict real-bundle preflight ready report, Mac5 sync report

heavy_reconstruction
  true flag allowed: allow_heavy_reconstruction
  next_allowed_action: run Mac5 non-placeholder handoff once, then audit learning
  required report paths: strict real-bundle preflight ready report, placeholder handoff report, arm review, operator note

derived_lane_review
  true flag allowed: allow_derived_lane_review
  next_allowed_action: review templates/SAN/NKo/Unity/ENTHEA/MRT2/DEMON candidates
  required report paths: reconstruction learning audit or admitted source-window evidence

k11_live_promotion
  true flag allowed: allow_k11_live_promotion
  next_allowed_action: promote exactly the named gesture or command pair
  required report paths: dry-run report, false-positive review, mapping hash, rollback manifest, before manifest hash

exactly one accepted_scope
allow_heavy_reconstruction requires accepted_scope=heavy_reconstruction
allow_k11_live_promotion requires accepted_scope=k11_live_promotion
bundle_id is required for placeholder_handoff, heavy_reconstruction, derived_lane_review, and k11_live_promotion
capture_window_id is required for every scope after first_real_capture_setup
accepted_report_paths must be non-empty
known_limitations must be explicit, even if the value is []
blocked_items_acknowledged must name any still-blocked lane or say []
stale packets from earlier capture windows must be rejected

[home]/Desktop/MotionMix/lume-wiring/lume-airdeck-observe-only-gesture-spec-current.md

AirDeck Command Mold
  -> stationary or intentionally staged body
  -> deck-like gestures
  -> strict K11 command gate
  -> dry-run before live

Dance Derivation Mold
  -> continuous dancing
  -> computational choreography
  -> SAN / Unity / ENTHEA / MRT2 / DEMON control curves
  -> no direct destructive DJ commands

left_hand_raise -> Deck 1 play/pause -> z
right_hand_raise -> Deck 2 play/pause -> n

sync
next track
loop toggle / loop in-out
air scratch
platter spin
rewind / pull-back
deck-zone hover
wrist circle over virtual platter
safe stop all
crate browse / similarity candidate select
mold switch confirm

primary host: K11
primary surface: AirDeck Console / Gesture Library Panel
secondary surfaces: mirrored read-only status only
input feeds: K11 bridge latest pose, gesture JSONL, promotion manifest, mapping hash, Rekordbox focus state
output feeds: observe-only event rows, why-not-fired rows, reviewed promotion candidates
forbidden output: direct commands from panel clicks unless routed through the reviewed K11 command gate

Live Gate
  shows current mode, command peer, Rekordbox foreground, active manifest, live hand-raise rows, blocked reasons

Gesture Library
  shows every gesture id, family, status, score, evidence count, false-positive count, dry-run status, promotion eligibility

Rehearsal Capture
  records observe-only attempts with body mold, source peer, confidence, joint count, current track context, and operator note

Device Angles
  shows iPhone 16 Plus, iPhone 14 Pro Max, optional iPhone 16 Pro Max, optional iPads, Mac2 Arducam/UVC, Mac4/BodyTruth

Similarity Queue
  shows non-command track candidates, compatibility scores, movement/SAN context, browse/highlight state, and confirm eligibility

Promotion Review
  shows only gestures that passed capture, false-positive review, dry-run proof, mapping hash, cooldown/cancel proof, and explicit acceptance

[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/k11_gesture_panel_snapshot.json

panel_snapshot_missing:
  no usable K11 panel snapshot exists
  allowed: keep console/panel as unknown
  forbidden: operator-surface claims, promotion review, dry-run display claims

panel_snapshot_observe_only_ready:
  panel shows current live gestures plus non-live observe-only/not-trained rows
  allowed: use panel as operator visibility evidence
  forbidden: promotion by panel click, manifest edits, commands

panel_snapshot_live_manifest_mirror:
  panel mirrors the current K11 live manifest and all non-live rows are gated
  allowed: use panel to verify K11 display/bridge agreement
  forbidden: expanding live control from display state alone

panel_snapshot_needs_review:
  panel is stale, contradictory, missing why-not-fired, or shows unsafe rows
  allowed: preserve snapshot and repair display
  forbidden: dry-run, promotion, live test

{
  "schema": "lume.airdeck.k11_gesture_panel_snapshot.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "snapshot_id": "airdeck-k11-panel-snapshot-YYYYMMDDTHHMMSS-local",
  "snapshot_state": "panel_snapshot_observe_only_ready",
  "snapshot_path": "[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/k11_gesture_panel_snapshot.json",
  "panel": {
    "primary_host": "K11",
    "surface": "AirDeck Console / Gesture Library Panel",
    "panel_is_command_surface": false,
    "panel_clicks_send_commands": false,
    "mirrored_surfaces_read_only": true,
    "shows_command_peer": true,
    "shows_manifest_hash": true,
    "shows_rekordbox_focus": true,
    "shows_latest_pose_source": true,
    "shows_why_not_fired": true
  },
  "live_manifest": {
    "manifest_path": "C:\\lume\\selfplay\\airdeck-playonly-promoted-commands.json",
    "manifest_sha256": "sha256:required",
    "command_peer_source_id": "iphone_16_plus_motionmix",
    "command_peer": "[ip]",
    "current_live_gestures": [
      "airdeck_left_hand_raise_play",
      "airdeck_right_hand_raise_play"
    ]
  },
  "input_references": {
    "gesture_catalog_path": "[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/gesture_catalog.json",
    "gesture_catalog_sha256": "sha256:required",
    "gesture_events_jsonl": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/airdeck/gesture_events.jsonl",
    "why_not_fired_jsonl": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/airdeck/why_not_fired.jsonl",
    "latest_pose_source_id": "iphone_16_plus_motionmix",
    "latest_pose_source_peer": "[ip]"
  },
  "counts": {
    "total_gesture_rows": 4,
    "live_rows": 2,
    "observe_only_rows": 1,
    "not_trained_rows": 1,
    "blocked_rows": 0,
    "review_ready_rows": 0,
    "disabled_rows": 0,
    "rows_missing_why_not_count": 0,
    "non_live_command_eligible_rows": 0,
    "support_peer_command_rows": 0,
    "panel_click_command_paths_count": 0
  },
  "gesture_rows": [
    {
      "gesture_id": "airdeck_left_hand_raise_play",
      "display_status": "promoted_live",
      "command_id": "deck_1_play_pause",
      "key_or_midi": "z",
      "command_eligible": true,
      "live_allowed": true,
      "sent_command_allowed": true,
      "source_peer_policy": "current_k11_command_peer_only",
      "why_not_promoted": []
    },
    {
      "gesture_id": "airdeck_right_hand_raise_play",
      "display_status": "promoted_live",
      "command_id": "deck_2_play_pause",
      "key_or_midi": "n",
      "command_eligible": true,
      "live_allowed": true,
      "sent_command_allowed": true,
      "source_peer_policy": "current_k11_command_peer_only",
      "why_not_promoted": []
    },
    {
      "gesture_id": "airdeck_sync",
      "display_status": "observe_only",
      "command_id": "sync",
      "key_or_midi": null,
      "command_eligible": false,
      "live_allowed": false,
      "sent_command_allowed": false,
      "source_peer_policy": "evidence_only_until_promotion",
      "why_not_promoted": [
        "no_k11_live_promotion_admission",
        "not_in_live_manifest"
      ]
    },
    {
      "gesture_id": "airdeck_scratch_nudge",
      "display_status": "not_trained",
      "command_id": "scratch_nudge",
      "key_or_midi": null,
      "command_eligible": false,
      "live_allowed": false,
      "sent_command_allowed": false,
      "source_peer_policy": "evidence_only_until_promotion",
      "why_not_promoted": [
        "not_trained",
        "not_in_live_manifest"
      ]
    }
  ],
  "downstream_permissions": {
    "use_as_operator_visibility_evidence": true,
    "mirror_read_only_status": true,
    "write_observe_only_events": true,
    "prepare_promotion_packet": false,
    "edit_k11_manifest": false,
    "send_rekordbox_commands": false,
    "run_live_test": false
  },
  "safety": {
    "k11_is_only_command_gate": true,
    "panel_is_command_authority": false,
    "panel_writes_k11_manifest": false,
    "panel_sends_keyboard_or_midi": false,
    "phones_send_rekordbox_commands": false,
    "ipads_send_rekordbox_commands": false,
    "mac4_sends_rekordbox_commands": false,
    "mac5_sends_rekordbox_commands": false
  },
  "next_allowed_action": "use panel snapshot as visibility evidence only"
}

AIRDECK_K11_GESTURE_PANEL_SNAPSHOT="/path/to/k11_gesture_panel_snapshot.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["AIRDECK_K11_GESTURE_PANEL_SNAPSHOT"])
data = json.loads(path.read_text())
errors = []
trusted_root = Path("[home]/Desktop/MotionMix/lume-wiring")
allowed_states = {
    "panel_snapshot_missing",
    "panel_snapshot_observe_only_ready",
    "panel_snapshot_live_manifest_mirror",
    "panel_snapshot_needs_review",
}
allowed_statuses = {
    "promoted_live",
    "observe_only",
    "not_trained",
    "blocked",
    "review_ready",
    "disabled_or_rolled_back",
}
current_live = {
    "airdeck_left_hand_raise_play": ("deck_1_play_pause", "z"),
    "airdeck_right_hand_raise_play": ("deck_2_play_pause", "n"),
}
bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]

def is_hash(value):
    return isinstance(value, str) and value.startswith("sha256:") and len(value) > len("sha256:")

def check_wiring_path(label, value, required=False):
    if value in {None, ""}:
        if required:
            errors.append(f"missing_{label}")
        return
    value_s = str(value)
    if not value_s.startswith(str(trusted_root)):
        errors.append(f"{label}_outside_wiring_root:{value_s}")
    if any(marker in value_s for marker in bad_markers):
        errors.append(f"{label}_bad_marker:{value_s}")

if data.get("schema") != "lume.airdeck.k11_gesture_panel_snapshot.v1":
    errors.append("bad_schema")
if not data.get("snapshot_id"):
    errors.append("missing_snapshot_id")
state = data.get("snapshot_state")
if state not in allowed_states:
    errors.append(f"bad_snapshot_state:{state}")
check_wiring_path("snapshot_path", data.get("snapshot_path"), required=state != "panel_snapshot_missing")

panel = data.get("panel") or {}
if panel.get("primary_host") != "K11":
    errors.append("panel_primary_host_not_k11")
if panel.get("panel_is_command_surface") is not False:
    errors.append("panel_is_command_surface_not_false")
if panel.get("panel_clicks_send_commands") is not False:
    errors.append("panel_clicks_send_commands_not_false")
if panel.get("mirrored_surfaces_read_only") is not True:
    errors.append("mirrored_surfaces_read_only_not_true")
for key in [
    "shows_command_peer",
    "shows_manifest_hash",
    "shows_rekordbox_focus",
    "shows_latest_pose_source",
    "shows_why_not_fired",
]:
    if state != "panel_snapshot_missing" and panel.get(key) is not True:
        errors.append(f"{key}_not_true")

manifest = data.get("live_manifest") or {}
if manifest.get("manifest_path") != r"C:\lume\selfplay\airdeck-playonly-promoted-commands.json":
    errors.append("unexpected_manifest_path")
if state != "panel_snapshot_missing" and not is_hash(manifest.get("manifest_sha256")):
    errors.append("manifest_sha256_not_sha256_marker")
if manifest.get("command_peer_source_id") != "iphone_16_plus_motionmix":
    errors.append("unexpected_command_peer_source_id")
if manifest.get("command_peer") != "[ip]":
    errors.append(f"unexpected_command_peer:{manifest.get('command_peer')}")
if state != "panel_snapshot_missing" and set(manifest.get("current_live_gestures") or []) != set(current_live):
    errors.append("current_live_gestures_mismatch")

inputs = data.get("input_references") or {}
check_wiring_path("gesture_catalog_path", inputs.get("gesture_catalog_path"), required=state != "panel_snapshot_missing")
if state != "panel_snapshot_missing" and not is_hash(inputs.get("gesture_catalog_sha256")):
    errors.append("gesture_catalog_sha256_not_sha256_marker")
check_wiring_path("gesture_events_jsonl", inputs.get("gesture_events_jsonl"), required=False)
check_wiring_path("why_not_fired_jsonl", inputs.get("why_not_fired_jsonl"), required=False)

counts = data.get("counts") or {}
count_keys = [
    "total_gesture_rows",
    "live_rows",
    "observe_only_rows",
    "not_trained_rows",
    "blocked_rows",
    "review_ready_rows",
    "disabled_rows",
    "rows_missing_why_not_count",
    "non_live_command_eligible_rows",
    "support_peer_command_rows",
    "panel_click_command_paths_count",
]
for key in count_keys:
    if not isinstance(counts.get(key), int) or counts.get(key) < 0:
        errors.append(f"bad_count_{key}:{counts.get(key)}")
if state == "panel_snapshot_missing":
    for key in count_keys:
        if counts.get(key, 0) != 0:
            errors.append(f"{key}_not_zero_for_missing_snapshot")
else:
    total = counts.get("total_gesture_rows", 0)
    parts = sum(counts.get(key, 0) for key in [
        "live_rows",
        "observe_only_rows",
        "not_trained_rows",
        "blocked_rows",
        "review_ready_rows",
        "disabled_rows",
    ])
    if total <= 0:
        errors.append("panel_snapshot_has_no_rows")
    if total != parts:
        errors.append("panel_row_counts_do_not_sum_to_total")
    if counts.get("live_rows") != len(current_live):
        errors.append("live_rows_not_current_live_count")
    for key in ["rows_missing_why_not_count", "non_live_command_eligible_rows", "support_peer_command_rows", "panel_click_command_paths_count"]:
        if counts.get(key) != 0:
            errors.append(f"{key}_not_zero")

rows = data.get("gesture_rows") or []
if state == "panel_snapshot_missing" and rows:
    errors.append("missing_snapshot_has_rows")
if state != "panel_snapshot_missing" and not rows:
    errors.append("panel_snapshot_has_no_gesture_rows")
for index, row in enumerate(rows):
    gesture_id = row.get("gesture_id")
    if not gesture_id:
        errors.append(f"row_{index}_missing_gesture_id")
        continue
    status = row.get("display_status")
    if status not in allowed_statuses:
        errors.append(f"{gesture_id}_bad_display_status:{status}")
    if status == "promoted_live":
        expected = current_live.get(gesture_id)
        if not expected:
            errors.append(f"{gesture_id}_unexpected_live_row")
            continue
        if row.get("command_id") != expected[0]:
            errors.append(f"{gesture_id}_command_id_mismatch")
        if row.get("key_or_midi") != expected[1]:
            errors.append(f"{gesture_id}_key_or_midi_mismatch")
        if row.get("command_eligible") is not True:
            errors.append(f"{gesture_id}_live_command_eligible_not_true")
        if row.get("live_allowed") is not True:
            errors.append(f"{gesture_id}_live_allowed_not_true")
        if row.get("sent_command_allowed") is not True:
            errors.append(f"{gesture_id}_sent_command_allowed_not_true")
    else:
        if row.get("command_eligible") is not False:
            errors.append(f"{gesture_id}_non_live_command_eligible_not_false")
        if row.get("live_allowed") is not False:
            errors.append(f"{gesture_id}_non_live_live_allowed_not_false")
        if row.get("sent_command_allowed") is not False:
            errors.append(f"{gesture_id}_non_live_sent_command_allowed_not_false")
        if not row.get("why_not_promoted"):
            errors.append(f"{gesture_id}_missing_why_not_promoted")
        if row.get("key_or_midi") not in {None, ""}:
            errors.append(f"{gesture_id}_non_live_key_or_midi_present")

permissions = data.get("downstream_permissions") or {}
if state in {"panel_snapshot_observe_only_ready", "panel_snapshot_live_manifest_mirror"}:
    for key in ["use_as_operator_visibility_evidence", "mirror_read_only_status"]:
        if permissions.get(key) is not True:
            errors.append(f"{key}_not_true")
else:
    if permissions.get("use_as_operator_visibility_evidence") is True:
        errors.append("visibility_evidence_true_outside_ready_state")
for key in ["prepare_promotion_packet", "edit_k11_manifest", "send_rekordbox_commands", "run_live_test"]:
    if permissions.get(key) is not False:
        errors.append(f"{key}_not_false")

safety = data.get("safety") or {}
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_is_only_command_gate_not_true")
for key in [
    "panel_is_command_authority",
    "panel_writes_k11_manifest",
    "panel_sends_keyboard_or_midi",
    "phones_send_rekordbox_commands",
    "ipads_send_rekordbox_commands",
    "mac4_sends_rekordbox_commands",
    "mac5_sends_rekordbox_commands",
]:
    if safety.get(key) is not False:
        errors.append(f"{key}_not_false")

next_action = str(data.get("next_allowed_action") or "").lower()
for forbidden in ["promote", "write manifest", "send command", "run live", "reload bridge"]:
    if forbidden in next_action:
        errors.append(f"next_allowed_action_mentions_forbidden:{forbidden}")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("airdeck_k11_gesture_panel_snapshot_admission_passed")
PY

not_defined
  -> not_trained
  -> observed
  -> rehearsal_candidate
  -> dry_run_passed
  -> review_ready
  -> promoted_live
  -> disabled_or_rolled_back

mistake 1: treating every visible movement as an AirDeck command attempt
mistake 2: letting a support camera or iPad imply command authority
mistake 3: promoting a gesture because it fired once while the operator was experimenting

AirDeck Command Mold:
  meaning: intentional deck-control rehearsal
  output: observe-only command candidate rows
  allowed future path: dry-run, false-positive review, promotion packet, K11 manifest
  forbidden direct path: raw pose -> Rekordbox command

Dance Derivation Mold:
  meaning: expressive movement during performance
  output: phrase windows, SAN context, similarity hints, visual mappings, templates, DEMON requests, NKo/MnKO inscriptions
  allowed future path: reviewed derived lanes and policy learning
  forbidden direct path: raw dance -> sync/next/scratch/load command

if the operator explicitly starts a rehearsal window for deck control:
  default mold = AirDeck Command Mold
elif the system is in performance/dance capture without an explicit rehearsal marker:
  default mold = Dance Derivation Mold
elif the source is a support peer, optional phone, iPad, Mac2 video, or Mac4 BodyTruth:
  default mold = Dance Derivation Mold unless K11 operator review marks a command rehearsal
else:
  default mold = Dance Derivation Mold

raw/airdeck/gesture_rehearsal_events.jsonl
raw/airdeck/gesture_feature_windows.jsonl
raw/airdeck/why_not_fired.jsonl
derived/airdeck/mold_routing_summary.json
derived/airdeck/command_candidate_queue.json
derived/choreography/dance_phrase_windows.jsonl

{
  "schema": "lume.airdeck.gesture_rehearsal_event.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "event_id": "gesture-event-0001",
  "gesture_id": "airdeck_sync",
  "body_mold": "airdeck_command_mold",
  "source_id": "iphone_16_plus_motionmix",
  "source_role": "command_peer_or_supporting_evidence",
  "source_peer": "[ip]",
  "source_label": "iPhone 16 Plus",
  "source_window": {
    "start_utc": "YYYY-MM-DDTHH:MM:SS.sssZ",
    "end_utc": "YYYY-MM-DDTHH:MM:SS.sssZ",
    "duration_ms": 1200
  },
  "features": {
    "visible_joints": 0,
    "confidence": null,
    "dominant_hand": null,
    "motion_vector": null,
    "deck_zone": null
  },
  "candidate_command": {
    "command_id": "sync",
    "deck_scope": "deck_1_or_2_or_global",
    "proposed_key_or_midi": null,
    "command_eligible": false,
    "eligibility_reason": "observe_only_not_reviewed"
  },
  "safety": {
    "k11_is_only_command_gate": true,
    "source_is_current_command_peer": false,
    "rekordbox_foreground_known": false,
    "sent_command": false,
    "non_k11_sender_detected": false
  },
  "promotion": {
    "promotion_status": "observed",
    "dry_run_report": null,
    "false_positive_review": null,
    "rollback_manifest": null,
    "operator_acceptance": null
  },
  "derived_outputs_allowed": [
    "san_phrase_context",
    "similarity_hint",
    "visual_mapping_candidate",
    "template_candidate",
    "nko_mnko_inscription_candidate"
  ],
  "notes": []
}

GESTURE_REHEARSAL_EVENT="/path/to/gesture_rehearsal_event.json" python3 - <<'PY'
import json
import os
import sys

data = json.loads(open(os.environ["GESTURE_REHEARSAL_EVENT"]).read())
errors = []
allowed_molds = {"airdeck_command_mold", "dance_derivation_mold"}

if data.get("schema") != "lume.airdeck.gesture_rehearsal_event.v1":
    errors.append("bad_schema")
if data.get("body_mold") not in allowed_molds:
    errors.append(f"bad_body_mold:{data.get('body_mold')}")

candidate = data.get("candidate_command") or {}
safety = data.get("safety") or {}
promotion = data.get("promotion") or {}

if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_only_command_gate_not_true")
if safety.get("sent_command") is not False:
    errors.append("rehearsal_event_sent_command")
if safety.get("non_k11_sender_detected") is not False:
    errors.append("non_k11_sender_detected")
if promotion.get("promotion_status") == "promoted_live":
    errors.append("rehearsal_event_claims_promoted_live")

if data.get("body_mold") == "dance_derivation_mold":
    if candidate.get("command_eligible") is not False:
        errors.append("dance_mold_command_eligible_not_false")
    if candidate.get("proposed_key_or_midi") not in {None, ""}:
        errors.append("dance_mold_has_proposed_key_or_midi")

if data.get("body_mold") == "airdeck_command_mold":
    if candidate.get("command_eligible") is not False:
        errors.append("airdeck_rehearsal_command_eligible_before_review")
    if not data.get("gesture_id"):
        errors.append("missing_gesture_id")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("gesture_rehearsal_event_validation_passed")
PY

[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/rehearsal_capture_admission.json

rehearsal_capture_missing:
  no usable rehearsal evidence exists for the capture window
  allowed: keep gestures not_trained or waiting
  forbidden: observe-only batch claims, false-positive review, dry-run, promotion

rehearsal_capture_observe_only_ready:
  one or more marked or detected attempts exist and every non-live row is non-command
  allowed: summarize into an observe-only event batch
  forbidden: false-positive review, dry-run, K11 manifest edits, commands

rehearsal_capture_mixed_mold_labeled:
  command-mold rehearsal and dance-derivation windows are both labeled
  allowed: split command candidates from dance-derived phrases before batching
  forbidden: treating dance windows as command attempts

rehearsal_capture_needs_review:
  evidence is stale, unlabeled, unsafe, or missing required why-not-fired rows
  allowed: preserve evidence and repair capture/routing
  forbidden: downstream admission

{
  "schema": "lume.airdeck.rehearsal_capture_admission.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "admission_id": "airdeck-rehearsal-capture-YYYYMMDDTHHMMSS-local",
  "admission_state": "rehearsal_capture_observe_only_ready",
  "run_id": "YYYYMMDD-HHMMSS-airdeck",
  "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "catalog_reference": {
    "catalog_path": "[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/gesture_catalog.json",
    "catalog_sha256": "sha256:required",
    "catalog_schema": "lume.airdeck.gesture_catalog.v1",
    "catalog_state": "catalog_observe_only_ready"
  },
  "panel_snapshot_reference": {
    "panel_snapshot_path": "[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/k11_gesture_panel_snapshot.json",
    "panel_snapshot_sha256": "sha256:required",
    "panel_snapshot_schema": "lume.airdeck.k11_gesture_panel_snapshot.v1",
    "panel_snapshot_state": "panel_snapshot_observe_only_ready"
  },
  "source_context": {
    "k11_command_peer_source_id": "iphone_16_plus_motionmix",
    "k11_command_peer": "[ip]",
    "sources": [
      {
        "source_id": "iphone_16_plus_motionmix",
        "source_label": "iPhone 16 Plus",
        "source_peer": "[ip]",
        "source_role": "k11_command_peer",
        "can_send_rekordbox_commands": false,
        "may_contribute_command_rehearsal_evidence": true,
        "may_contribute_dance_derivation_evidence": true
      },
      {
        "source_id": "iphone_14_pro_max_motionmix",
        "source_label": "iPhone 14 Pro Max",
        "source_peer": "tailscale-or-lan-peer-required",
        "source_role": "support_angle",
        "can_send_rekordbox_commands": false,
        "may_contribute_command_rehearsal_evidence": false,
        "may_contribute_dance_derivation_evidence": true
      }
    ]
  },
  "event_paths": {
    "gesture_rehearsal_events_jsonl": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/airdeck/gesture_rehearsal_events.jsonl",
    "gesture_feature_windows_jsonl": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/airdeck/gesture_feature_windows.jsonl",
    "why_not_fired_jsonl": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/airdeck/why_not_fired.jsonl",
    "mold_routing_summary_json": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/derived/airdeck/mold_routing_summary.json",
    "command_candidate_queue_json": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/derived/airdeck/command_candidate_queue.json",
    "dance_phrase_windows_jsonl": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/derived/choreography/dance_phrase_windows.jsonl"
  },
  "counts": {
    "total_rehearsal_events": 2,
    "airdeck_command_mold_events": 1,
    "dance_derivation_mold_events": 1,
    "current_live_manifest_events": 0,
    "support_peer_events": 1,
    "sent_command_count": 0,
    "non_k11_sender_count": 0,
    "unlabeled_mold_count": 0,
    "missing_source_window_count": 0,
    "missing_why_not_fired_count": 0,
    "command_eligible_non_live_count": 0,
    "panel_click_command_paths_count": 0
  },
  "sample_events": [
    {
      "event_id": "gesture-event-0001",
      "gesture_id": "airdeck_sync",
      "body_mold": "airdeck_command_mold",
      "event_status": "rehearsal_candidate",
      "operator_marked_intent": true,
      "source_id": "iphone_16_plus_motionmix",
      "source_peer": "[ip]",
      "source_role": "k11_command_peer",
      "source_is_current_command_peer": true,
      "source_window": {
        "start_utc": "YYYY-MM-DDTHH:MM:SS.sssZ",
        "end_utc": "YYYY-MM-DDTHH:MM:SS.sssZ",
        "duration_ms": 1200
      },
      "features": {
        "visible_joints": 17,
        "confidence": 0.86,
        "dominant_hand": "right",
        "deck_zone": "deck_1",
        "feature_window_id": "feature-window-0001"
      },
      "candidate_command": {
        "command_id": "sync",
        "proposed_key_or_midi": null,
        "command_eligible": false,
        "eligibility_reason": "observe_only_rehearsal_not_reviewed"
      },
      "safety": {
        "k11_is_only_command_gate": true,
        "sent_command": false,
        "non_k11_sender_detected": false,
        "live_manifest_match": false
      },
      "why_not_fired": [
        "rehearsal_capture_only",
        "no_observe_only_batch_admission",
        "no_false_positive_review",
        "no_dry_run_proof",
        "not_in_live_manifest"
      ]
    },
    {
      "event_id": "gesture-event-0002",
      "gesture_id": "dance_phrase_open_arm",
      "body_mold": "dance_derivation_mold",
      "event_status": "observed",
      "operator_marked_intent": false,
      "source_id": "iphone_14_pro_max_motionmix",
      "source_peer": "tailscale-or-lan-peer-required",
      "source_role": "support_angle",
      "source_is_current_command_peer": false,
      "source_window": {
        "start_utc": "YYYY-MM-DDTHH:MM:SS.sssZ",
        "end_utc": "YYYY-MM-DDTHH:MM:SS.sssZ",
        "duration_ms": 1800
      },
      "features": {
        "visible_joints": 15,
        "confidence": 0.79,
        "dominant_hand": null,
        "deck_zone": null,
        "feature_window_id": "feature-window-0002"
      },
      "candidate_command": {
        "command_id": null,
        "proposed_key_or_midi": null,
        "command_eligible": false,
        "eligibility_reason": "dance_derivation_not_command"
      },
      "safety": {
        "k11_is_only_command_gate": true,
        "sent_command": false,
        "non_k11_sender_detected": false,
        "live_manifest_match": false
      },
      "why_not_fired": [
        "dance_derivation_mold",
        "support_peer_evidence_only",
        "not_a_command_attempt"
      ]
    }
  ],
  "downstream_permissions": {
    "show_in_k11_panel": true,
    "write_observe_only_batch": true,
    "prepare_false_positive_review": false,
    "prepare_dry_run_review": false,
    "prepare_promotion_packet": false,
    "write_k11_manifest": false,
    "send_rekordbox_commands": false,
    "run_live_test": false
  },
  "safety": {
    "k11_is_only_command_gate": true,
    "rehearsal_capture_is_command_authority": false,
    "rehearsal_capture_writes_k11_manifest": false,
    "rehearsal_capture_sends_keyboard_or_midi": false,
    "phones_send_rekordbox_commands": false,
    "ipads_send_rekordbox_commands": false,
    "mac4_sends_rekordbox_commands": false,
    "mac5_sends_rekordbox_commands": false
  },
  "next_allowed_action": "summarize rehearsal capture into an observe-only event batch"
}

AIRDECK_REHEARSAL_CAPTURE_ADMISSION="/path/to/rehearsal_capture_admission.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["AIRDECK_REHEARSAL_CAPTURE_ADMISSION"])
data = json.loads(path.read_text())
errors = []
trusted_root = Path("[home]/Desktop/MotionMix/lume-wiring")
allowed_states = {
    "rehearsal_capture_missing",
    "rehearsal_capture_observe_only_ready",
    "rehearsal_capture_mixed_mold_labeled",
    "rehearsal_capture_needs_review",
}
ready_states = {
    "rehearsal_capture_observe_only_ready",
    "rehearsal_capture_mixed_mold_labeled",
}
allowed_molds = {"airdeck_command_mold", "dance_derivation_mold"}
allowed_event_statuses = {"observed", "observe_only", "rehearsal_candidate", "promoted_live", "blocked"}
current_live = {
    "airdeck_left_hand_raise_play",
    "airdeck_right_hand_raise_play",
}
bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]

def is_hash(value):
    return isinstance(value, str) and value.startswith("sha256:") and len(value) > len("sha256:")

def check_wiring_path(label, value, required=False):
    if value in {None, ""}:
        if required:
            errors.append(f"missing_{label}")
        return
    value_s = str(value)
    if not value_s.startswith(str(trusted_root)):
        errors.append(f"{label}_outside_wiring_root:{value_s}")
    if any(marker in value_s for marker in bad_markers):
        errors.append(f"{label}_bad_marker:{value_s}")

if data.get("schema") != "lume.airdeck.rehearsal_capture_admission.v1":
    errors.append("bad_schema")
if not data.get("admission_id"):
    errors.append("missing_admission_id")
state = data.get("admission_state")
if state not in allowed_states:
    errors.append(f"bad_admission_state:{state}")
if state != "rehearsal_capture_missing" and not data.get("run_id"):
    errors.append("missing_run_id")
if state != "rehearsal_capture_missing" and not data.get("capture_window_id"):
    errors.append("missing_capture_window_id")

catalog = data.get("catalog_reference") or {}
check_wiring_path("catalog_path", catalog.get("catalog_path"), required=state in ready_states)
if state in ready_states:
    if catalog.get("catalog_schema") != "lume.airdeck.gesture_catalog.v1":
        errors.append("bad_catalog_schema")
    if catalog.get("catalog_state") not in {"catalog_observe_only_ready", "catalog_live_manifest_mirror"}:
        errors.append(f"bad_catalog_state:{catalog.get('catalog_state')}")
    if not is_hash(catalog.get("catalog_sha256")):
        errors.append("catalog_sha256_not_sha256_marker")

panel = data.get("panel_snapshot_reference") or {}
check_wiring_path("panel_snapshot_path", panel.get("panel_snapshot_path"), required=False)
if panel.get("panel_snapshot_path"):
    if panel.get("panel_snapshot_schema") != "lume.airdeck.k11_gesture_panel_snapshot.v1":
        errors.append("bad_panel_snapshot_schema")
    if panel.get("panel_snapshot_state") not in {"panel_snapshot_observe_only_ready", "panel_snapshot_live_manifest_mirror"}:
        errors.append(f"bad_panel_snapshot_state:{panel.get('panel_snapshot_state')}")
    if not is_hash(panel.get("panel_snapshot_sha256")):
        errors.append("panel_snapshot_sha256_not_sha256_marker")

source_context = data.get("source_context") or {}
if source_context.get("k11_command_peer_source_id") != "iphone_16_plus_motionmix":
    errors.append("unexpected_k11_command_peer_source_id")
if source_context.get("k11_command_peer") != "[ip]":
    errors.append(f"unexpected_k11_command_peer:{source_context.get('k11_command_peer')}")
sources = source_context.get("sources") or []
source_ids = {source.get("source_id") for source in sources}
if state in ready_states and "iphone_16_plus_motionmix" not in source_ids:
    errors.append("missing_iphone_16_plus_source_context")
for source in sources:
    source_id = source.get("source_id")
    if source.get("can_send_rekordbox_commands") is not False:
        errors.append(f"{source_id}_can_send_rekordbox_commands_not_false")
    if source.get("source_role") == "k11_command_peer":
        if source_id != "iphone_16_plus_motionmix":
            errors.append(f"unexpected_command_peer_source:{source_id}")
        if source.get("source_peer") != "[ip]":
            errors.append(f"{source_id}_unexpected_peer:{source.get('source_peer')}")
        if source.get("may_contribute_command_rehearsal_evidence") is not True:
            errors.append(f"{source_id}_command_rehearsal_evidence_not_true")
    else:
        if source.get("may_contribute_command_rehearsal_evidence") is True:
            errors.append(f"{source_id}_support_source_command_rehearsal_true")

event_paths = data.get("event_paths") or {}
for key in [
    "gesture_rehearsal_events_jsonl",
    "gesture_feature_windows_jsonl",
    "why_not_fired_jsonl",
    "mold_routing_summary_json",
    "command_candidate_queue_json",
    "dance_phrase_windows_jsonl",
]:
    check_wiring_path(key, event_paths.get(key), required=state in ready_states)

counts = data.get("counts") or {}
count_keys = [
    "total_rehearsal_events",
    "airdeck_command_mold_events",
    "dance_derivation_mold_events",
    "current_live_manifest_events",
    "support_peer_events",
    "sent_command_count",
    "non_k11_sender_count",
    "unlabeled_mold_count",
    "missing_source_window_count",
    "missing_why_not_fired_count",
    "command_eligible_non_live_count",
    "panel_click_command_paths_count",
]
for key in count_keys:
    if not isinstance(counts.get(key), int) or counts.get(key) < 0:
        errors.append(f"bad_count_{key}:{counts.get(key)}")
if state == "rehearsal_capture_missing":
    for key in count_keys:
        if counts.get(key, 0) != 0:
            errors.append(f"{key}_not_zero_for_missing_capture")
if state in ready_states:
    total = counts.get("total_rehearsal_events", 0)
    partition = sum(counts.get(key, 0) for key in [
        "airdeck_command_mold_events",
        "dance_derivation_mold_events",
        "current_live_manifest_events",
    ])
    if total <= 0:
        errors.append("ready_rehearsal_capture_has_no_events")
    if total != partition:
        errors.append("total_rehearsal_events_not_partitioned_by_mold")
    if counts.get("sent_command_count") != 0:
        errors.append("sent_command_count_not_zero")
    for key in [
        "non_k11_sender_count",
        "unlabeled_mold_count",
        "missing_source_window_count",
        "missing_why_not_fired_count",
        "command_eligible_non_live_count",
        "panel_click_command_paths_count",
    ]:
        if counts.get(key) != 0:
            errors.append(f"{key}_not_zero")
if state == "rehearsal_capture_mixed_mold_labeled":
    if counts.get("airdeck_command_mold_events", 0) < 1 or counts.get("dance_derivation_mold_events", 0) < 1:
        errors.append("mixed_mold_state_missing_one_mold")

samples = data.get("sample_events") or []
if state == "rehearsal_capture_missing" and samples:
    errors.append("missing_capture_has_sample_events")
if state in ready_states and not samples:
    errors.append("ready_rehearsal_capture_has_no_sample_events")
for index, event in enumerate(samples):
    gesture_id = event.get("gesture_id")
    if not gesture_id:
        errors.append(f"sample_{index}_missing_gesture_id")
        continue
    mold = event.get("body_mold")
    if mold not in allowed_molds:
        errors.append(f"{gesture_id}_bad_body_mold:{mold}")
    if event.get("event_status") not in allowed_event_statuses:
        errors.append(f"{gesture_id}_bad_event_status:{event.get('event_status')}")
    if not event.get("event_id"):
        errors.append(f"{gesture_id}_missing_event_id")
    if not event.get("source_id"):
        errors.append(f"{gesture_id}_missing_source_id")
    if not event.get("source_window"):
        errors.append(f"{gesture_id}_missing_source_window")
    features = event.get("features") or {}
    if not isinstance(features.get("visible_joints"), int) or features.get("visible_joints") < 0:
        errors.append(f"{gesture_id}_bad_visible_joints")
    confidence = features.get("confidence")
    if confidence is not None and (not isinstance(confidence, (int, float)) or not (0 <= confidence <= 1)):
        errors.append(f"{gesture_id}_bad_confidence:{confidence}")
    candidate = event.get("candidate_command") or {}
    safety = event.get("safety") or {}
    why = event.get("why_not_fired") or []
    if safety.get("k11_is_only_command_gate") is not True:
        errors.append(f"{gesture_id}_k11_gate_not_true")
    if safety.get("non_k11_sender_detected") is not False:
        errors.append(f"{gesture_id}_non_k11_sender_detected")
    if gesture_id in current_live and event.get("event_status") == "promoted_live":
        if safety.get("live_manifest_match") is not True:
            errors.append(f"{gesture_id}_live_manifest_match_not_true")
    else:
        if event.get("event_status") == "promoted_live":
            errors.append(f"{gesture_id}_unexpected_promoted_live")
        if safety.get("sent_command") is not False:
            errors.append(f"{gesture_id}_sent_command_not_false")
        if safety.get("live_manifest_match") is not False:
            errors.append(f"{gesture_id}_live_manifest_match_not_false")
        if candidate.get("command_eligible") is not False:
            errors.append(f"{gesture_id}_command_eligible_not_false")
        if candidate.get("proposed_key_or_midi") not in {None, ""}:
            errors.append(f"{gesture_id}_has_proposed_key_or_midi")
        if not why:
            errors.append(f"{gesture_id}_missing_why_not_fired")
    if mold == "dance_derivation_mold":
        if candidate.get("command_id") not in {None, ""}:
            errors.append(f"{gesture_id}_dance_mold_has_command_id")
        if event.get("source_is_current_command_peer") is True and event.get("operator_marked_intent") is True:
            errors.append(f"{gesture_id}_dance_mold_marked_as_command_intent")
    if mold == "airdeck_command_mold":
        if event.get("operator_marked_intent") is not True:
            errors.append(f"{gesture_id}_command_mold_missing_operator_intent")
        if event.get("source_is_current_command_peer") is not True:
            errors.append(f"{gesture_id}_command_mold_source_not_command_peer")

permissions = data.get("downstream_permissions") or {}
if state in ready_states:
    if permissions.get("show_in_k11_panel") is not True:
        errors.append("show_in_k11_panel_not_true")
    if permissions.get("write_observe_only_batch") is not True:
        errors.append("write_observe_only_batch_not_true")
else:
    for key in ["show_in_k11_panel", "write_observe_only_batch", "prepare_false_positive_review"]:
        if permissions.get(key) is True:
            errors.append(f"{key}_true_outside_ready_state")
for key in [
    "prepare_false_positive_review",
    "prepare_dry_run_review",
    "prepare_promotion_packet",
    "write_k11_manifest",
    "send_rekordbox_commands",
    "run_live_test",
]:
    if permissions.get(key) is not False:
        errors.append(f"{key}_not_false")

safety = data.get("safety") or {}
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_is_only_command_gate_not_true")
for key in [
    "rehearsal_capture_is_command_authority",
    "rehearsal_capture_writes_k11_manifest",
    "rehearsal_capture_sends_keyboard_or_midi",
    "phones_send_rekordbox_commands",
    "ipads_send_rekordbox_commands",
    "mac4_sends_rekordbox_commands",
    "mac5_sends_rekordbox_commands",
]:
    if safety.get(key) is not False:
        errors.append(f"{key}_not_false")

next_action = str(data.get("next_allowed_action") or "").lower()
for forbidden in ["promote", "write manifest", "send command", "run live", "make live", "reload bridge"]:
    if forbidden in next_action:
        errors.append(f"next_allowed_action_mentions_forbidden:{forbidden}")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("airdeck_rehearsal_capture_admission_passed")
PY

gesture id and command scope
at least one capture window with source ids and event ids
false-positive review over normal dance movement
dry-run report showing sent_command=false or dry-run-only behavior
K11 manifest before hash
proposed K11 manifest after hash
rollback manifest
operator acceptance for exactly one gesture or tightly coupled command pair

read K11 promotion manifest
read K11 bridge latest pose and recent event logs
read command peer and supporting peers
read Rekordbox foreground/focus status if available
write a console snapshot showing exactly two live gestures
write all non-live gestures as OBSERVE_ONLY or NOT_TRAINED

gesture_id
gesture_family
display_name
body_mold
deck_scope
input_features
minimum_sources
minimum_confidence
minimum_duration_ms
cooldown_ms
cancel_gesture
observe_only_reason
candidate_command
promotion_status

airdeck_left_hand_raise_play
airdeck_right_hand_raise_play
airdeck_sync
airdeck_next_track
airdeck_loop_toggle
airdeck_loop_in
airdeck_loop_out
airdeck_scratch_nudge
airdeck_platter_spin
airdeck_rewind_pullback
airdeck_deck_zone_hover
airdeck_wrist_circle
airdeck_safe_stop_all
airdeck_crate_browse
airdeck_similarity_select
airdeck_mold_switch_confirm
airdeck_cancel

raw/airdeck/gesture_events.jsonl
raw/airdeck/why_not_fired.jsonl
raw/airdeck/source_peer_events.jsonl
raw/airdeck/foreground_events.jsonl
raw/airdeck/cooldown_events.jsonl
derived/airdeck/gesture_summary.json
derived/airdeck/false_positive_review.json

Live Gate module
  shows current command peer, active manifest hash, Rekordbox focus, bridge freshness, live gesture rows, blocked reasons

Gesture Catalog module
  shows every gesture id, family, mold, status, evidence count, false-positive count, last seen time, promotion eligibility

Rehearsal Capture module
  lets the operator mark an attempt window, add a note, and preserve source peers, confidence, and body mold

Device Angles module
  shows whether iPhone 16 Plus, iPhone 14 Pro Max, optional iPhone 16 Pro Max, iPads, Mac2 Arducam/UVC, and Mac4/BodyTruth are current or stale

Similarity Queue module
  shows candidate tracks and why they are candidates, with command_eligible=false until a reviewed load/select path exists

Promotion Review module
  shows a promotion candidate only after observe-only evidence, false-positive review, dry-run proof, mapping hash, cooldown/cancel proof, and rollback manifest exist

test non-manifest gestures never send commands
test supporting peers are blocked from command authority
test stale pose blocks commands
test missing body blocks commands
test low confidence blocks commands
test unknown foreground blocks dry-run/live commands
test cooldown prevents repeats
test cancel gesture can clear a pending load/select path
test manifest hash is captured before and after reload
test promotion package includes rollback manifest

safe stop or cancel
sync
loop toggle
crate browse highlight
similarity select confirm
next/load workflow
scratch/platter continuous controls

gesture_catalog.json
gesture_events.jsonl
why_not_fired.jsonl
gesture_summary.json
false_positive_review.json
dry_run_report.json
promotion_candidate_packet.json
rollback_manifest.json
operator_acceptance_note.md

left_hand_raise -> z
right_hand_raise -> n

[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/gesture_catalog.json

catalog_missing:
  no reviewed gesture catalog exists
  allowed: create a draft catalog with all non-live gestures not_trained
  forbidden: command mapping, dry-run claims, K11 manifest changes

catalog_observe_only_ready:
  catalog rows exist and non-live gestures are observe-only or not-trained
  allowed: show rows in K11 panel and write observe-only rehearsal events
  forbidden: live commands, manifest writes, promotion claims

catalog_live_manifest_mirror:
  catalog mirrors the current K11 live manifest for the two play-only rows
  allowed: display current live rows and non-live observe-only rows
  forbidden: expanding live control beyond the current manifest

catalog_promotion_candidate_review_ready:
  exactly one non-live candidate is ready for later promotion review
  allowed: prepare a separate promotion packet for operator review
  forbidden: editing K11 manifest or sending a live command from the catalog

{
  "schema": "lume.airdeck.gesture_catalog.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "catalog_id": "airdeck-gesture-catalog-YYYYMMDDTHHMMSS-local",
  "catalog_state": "catalog_observe_only_ready",
  "catalog_path": "[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/gesture_catalog.json",
  "live_manifest_reference": {
    "host": "K11",
    "manifest_path": "C:\\lume\\selfplay\\airdeck-playonly-promoted-commands.json",
    "manifest_sha256": "sha256:required",
    "command_peer": "[ip]",
    "catalog_is_live_authority": false,
    "current_live_gestures": [
      {
        "gesture_id": "airdeck_left_hand_raise_play",
        "command_id": "deck_1_play_pause",
        "key_or_midi": "z"
      },
      {
        "gesture_id": "airdeck_right_hand_raise_play",
        "command_id": "deck_2_play_pause",
        "key_or_midi": "n"
      }
    ]
  },
  "gestures": [
    {
      "gesture_id": "airdeck_sync",
      "gesture_family": "transport",
      "display_name": "Sync",
      "body_mold": "airdeck_command_mold",
      "deck_scope": "deck_1_or_2",
      "status": "observe_only",
      "candidate_command": {
        "command_id": "sync",
        "proposed_key_or_midi": null,
        "command_surface": "rekordbox_keyboard_or_midi",
        "command_eligible": false,
        "command_permission_source": "none"
      },
      "detector": {
        "input_features": [
          "hands_visible",
          "deck_zone",
          "gesture_duration"
        ],
        "minimum_sources": 1,
        "minimum_confidence": 0.7,
        "minimum_duration_ms": 600,
        "cooldown_ms": 2500,
        "cancel_gesture": "airdeck_cancel"
      },
      "evidence": {
        "evidence_count": 0,
        "capture_window_ids": [],
        "last_seen_at": null,
        "false_positive_count": 0,
        "dry_run_report": null,
        "promotion_packet": null,
        "rollback_manifest": null,
        "operator_acceptance": null
      },
      "safety": {
        "live_allowed": false,
        "observe_only": true,
        "sent_command_allowed": false,
        "source_must_be_k11_command_peer": true,
        "supporting_peers_allowed_for_evidence_only": true
      }
    }
  ],
  "downstream_permissions": {
    "show_in_k11_panel": true,
    "write_observe_only_events": true,
    "prepare_promotion_packet": false,
    "write_k11_manifest": false,
    "send_rekordbox_commands": false,
    "run_live_test": false
  },
  "safety": {
    "k11_is_only_command_gate": true,
    "catalog_writes_k11_manifest": false,
    "catalog_sends_keyboard_or_midi": false,
    "phones_send_rekordbox_commands": false,
    "ipads_send_rekordbox_commands": false,
    "mac4_sends_rekordbox_commands": false,
    "mac5_sends_rekordbox_commands": false
  },
  "next_allowed_action": "display catalog rows and collect observe-only rehearsal evidence"
}

AIRDECK_GESTURE_CATALOG="/path/to/gesture_catalog.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["AIRDECK_GESTURE_CATALOG"])
data = json.loads(path.read_text())
errors = []
trusted_root = Path("[home]/Desktop/MotionMix/lume-wiring")
allowed_states = {
    "catalog_missing",
    "catalog_observe_only_ready",
    "catalog_live_manifest_mirror",
    "catalog_promotion_candidate_review_ready",
}
allowed_statuses = {
    "not_defined",
    "not_trained",
    "observed",
    "observe_only",
    "rehearsal_candidate",
    "dry_run_passed",
    "review_ready",
    "promoted_live",
    "disabled_or_rolled_back",
}
allowed_molds = {"airdeck_command_mold", "dance_derivation_mold"}
allowed_deck_scopes = {"deck_1", "deck_2", "deck_1_or_2", "global", "none"}
current_live = {
    "airdeck_left_hand_raise_play": ("deck_1_play_pause", "z"),
    "airdeck_right_hand_raise_play": ("deck_2_play_pause", "n"),
}
bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]

def is_hash(value):
    return isinstance(value, str) and value.startswith("sha256:") and len(value) > len("sha256:")

def check_wiring_path(label, value, required=False):
    if value in {None, ""}:
        if required:
            errors.append(f"missing_{label}")
        return
    value_s = str(value)
    if not value_s.startswith(str(trusted_root)):
        errors.append(f"{label}_outside_wiring_root:{value_s}")
    if any(marker in value_s for marker in bad_markers):
        errors.append(f"{label}_bad_marker:{value_s}")

if data.get("schema") != "lume.airdeck.gesture_catalog.v1":
    errors.append("bad_schema")
if not data.get("catalog_id"):
    errors.append("missing_catalog_id")
state = data.get("catalog_state")
if state not in allowed_states:
    errors.append(f"bad_catalog_state:{state}")
check_wiring_path("catalog_path", data.get("catalog_path"), required=state != "catalog_missing")

manifest = data.get("live_manifest_reference") or {}
if manifest.get("host") != "K11":
    errors.append("live_manifest_host_not_k11")
if manifest.get("command_peer") != "[ip]":
    errors.append(f"unexpected_command_peer:{manifest.get('command_peer')}")
if manifest.get("catalog_is_live_authority") is not False:
    errors.append("catalog_claims_live_authority")
if state != "catalog_missing" and not is_hash(manifest.get("manifest_sha256")):
    errors.append("manifest_sha256_not_sha256_marker")

manifest_live = manifest.get("current_live_gestures") or []
manifest_live_ids = {row.get("gesture_id") for row in manifest_live}
if state != "catalog_missing" and manifest_live_ids != set(current_live):
    errors.append(f"current_live_gesture_set_mismatch:{sorted(manifest_live_ids)}")
for row in manifest_live:
    gesture_id = row.get("gesture_id")
    expected = current_live.get(gesture_id)
    if not expected:
        errors.append(f"unknown_live_gesture:{gesture_id}")
        continue
    if row.get("command_id") != expected[0]:
        errors.append(f"{gesture_id}_command_id_mismatch")
    if row.get("key_or_midi") != expected[1]:
        errors.append(f"{gesture_id}_key_or_midi_mismatch")

gestures = data.get("gestures") or []
if state == "catalog_missing" and gestures:
    errors.append("catalog_missing_has_gestures")
if state != "catalog_missing" and not gestures:
    errors.append("catalog_has_no_gestures")

promotion_review_ready_count = 0
seen_ids = set()
for index, gesture in enumerate(gestures):
    gesture_id = gesture.get("gesture_id")
    if not gesture_id:
        errors.append(f"gesture_{index}_missing_id")
        continue
    if gesture_id in seen_ids:
        errors.append(f"duplicate_gesture_id:{gesture_id}")
    seen_ids.add(gesture_id)

    if gesture.get("body_mold") not in allowed_molds:
        errors.append(f"{gesture_id}_bad_body_mold:{gesture.get('body_mold')}")
    if gesture.get("deck_scope") not in allowed_deck_scopes:
        errors.append(f"{gesture_id}_bad_deck_scope:{gesture.get('deck_scope')}")
    status = gesture.get("status")
    if status not in allowed_statuses:
        errors.append(f"{gesture_id}_bad_status:{status}")
    if status == "review_ready":
        promotion_review_ready_count += 1

    candidate = gesture.get("candidate_command") or {}
    safety = gesture.get("safety") or {}
    evidence = gesture.get("evidence") or {}
    detector = gesture.get("detector") or {}

    if not isinstance(detector.get("minimum_sources"), int) or detector.get("minimum_sources", 0) < 1:
        errors.append(f"{gesture_id}_bad_minimum_sources")
    confidence = detector.get("minimum_confidence")
    if not isinstance(confidence, (int, float)) or not (0 <= confidence <= 1):
        errors.append(f"{gesture_id}_bad_minimum_confidence")
    if not isinstance(detector.get("minimum_duration_ms"), int) or detector.get("minimum_duration_ms", 0) < 0:
        errors.append(f"{gesture_id}_bad_minimum_duration_ms")
    if not isinstance(detector.get("cooldown_ms"), int) or detector.get("cooldown_ms", 0) < 0:
        errors.append(f"{gesture_id}_bad_cooldown_ms")
    if not isinstance(evidence.get("evidence_count"), int) or evidence.get("evidence_count", 0) < 0:
        errors.append(f"{gesture_id}_bad_evidence_count")
    if not isinstance(evidence.get("false_positive_count"), int) or evidence.get("false_positive_count", 0) < 0:
        errors.append(f"{gesture_id}_bad_false_positive_count")
    for path_key in ["dry_run_report", "promotion_packet", "rollback_manifest", "operator_acceptance"]:
        check_wiring_path(f"{gesture_id}_{path_key}", evidence.get(path_key), required=False)

    if gesture.get("body_mold") == "dance_derivation_mold":
        if candidate.get("command_eligible") is not False:
            errors.append(f"{gesture_id}_dance_mold_command_eligible")
        if candidate.get("proposed_key_or_midi") not in {None, ""}:
            errors.append(f"{gesture_id}_dance_mold_has_key_or_midi")
        if safety.get("live_allowed") is not False:
            errors.append(f"{gesture_id}_dance_mold_live_allowed")

    if gesture_id in current_live and status == "promoted_live":
        expected_command, expected_key = current_live[gesture_id]
        if candidate.get("command_id") != expected_command:
            errors.append(f"{gesture_id}_live_command_id_mismatch")
        if candidate.get("proposed_key_or_midi") != expected_key:
            errors.append(f"{gesture_id}_live_key_or_midi_mismatch")
        if candidate.get("command_eligible") is not True:
            errors.append(f"{gesture_id}_live_command_eligible_not_true")
        if candidate.get("command_permission_source") != "k11_promoted_manifest":
            errors.append(f"{gesture_id}_permission_not_from_k11_manifest")
        if safety.get("live_allowed") is not True:
            errors.append(f"{gesture_id}_live_allowed_not_true")
        if safety.get("sent_command_allowed") is not True:
            errors.append(f"{gesture_id}_sent_command_allowed_not_true")
    else:
        if status == "promoted_live":
            errors.append(f"{gesture_id}_unexpected_promoted_live")
        if candidate.get("command_eligible") is not False:
            errors.append(f"{gesture_id}_non_live_command_eligible_not_false")
        if safety.get("live_allowed") is not False:
            errors.append(f"{gesture_id}_non_live_live_allowed_not_false")
        if safety.get("sent_command_allowed") is not False:
            errors.append(f"{gesture_id}_non_live_sent_command_allowed_not_false")

    if safety.get("observe_only") is not (gesture_id not in current_live or status != "promoted_live"):
        errors.append(f"{gesture_id}_observe_only_flag_mismatch")
    if safety.get("source_must_be_k11_command_peer") is not True:
        errors.append(f"{gesture_id}_source_must_be_k11_command_peer_not_true")
    if safety.get("supporting_peers_allowed_for_evidence_only") is not True:
        errors.append(f"{gesture_id}_supporting_peers_not_evidence_only")

if state == "catalog_promotion_candidate_review_ready" and promotion_review_ready_count != 1:
    errors.append(f"promotion_candidate_review_ready_count_not_one:{promotion_review_ready_count}")
if state != "catalog_promotion_candidate_review_ready" and promotion_review_ready_count:
    errors.append("review_ready_candidate_outside_review_state")

permissions = data.get("downstream_permissions") or {}
if state == "catalog_missing":
    for key, value in permissions.items():
        if value is not False:
            errors.append(f"{key}_not_false_while_catalog_missing")
else:
    if permissions.get("show_in_k11_panel") is not True:
        errors.append("show_in_k11_panel_not_true")
    if permissions.get("write_observe_only_events") is not True:
        errors.append("write_observe_only_events_not_true")
for key in ["write_k11_manifest", "send_rekordbox_commands", "run_live_test"]:
    if permissions.get(key) is not False:
        errors.append(f"{key}_not_false")
if state == "catalog_promotion_candidate_review_ready":
    if permissions.get("prepare_promotion_packet") is not True:
        errors.append("prepare_promotion_packet_not_true_for_review_ready")
else:
    if permissions.get("prepare_promotion_packet") is not False:
        errors.append("prepare_promotion_packet_not_false")

safety = data.get("safety") or {}
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_is_only_command_gate_not_true")
for key in [
    "catalog_writes_k11_manifest",
    "catalog_sends_keyboard_or_midi",
    "phones_send_rekordbox_commands",
    "ipads_send_rekordbox_commands",
    "mac4_sends_rekordbox_commands",
    "mac5_sends_rekordbox_commands",
]:
    if safety.get(key) is not False:
        errors.append(f"{key}_not_false")

next_action = str(data.get("next_allowed_action") or "").lower()
for forbidden in ["send rekordbox", "write k11 manifest", "run live", "make live"]:
    if forbidden in next_action:
        errors.append(f"next_allowed_action_mentions_forbidden:{forbidden}")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("airdeck_gesture_catalog_admission_passed")
PY

[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/observe_only_event_batch_admission.json

no_events_captured:
  no gesture evidence exists for the capture window
  allowed: keep panel in not_trained or waiting state
  forbidden: false-positive review, dry-run, promotion

observe_only_batch_ready:
  non-live gesture rows exist and every command send is false
  allowed: display events, summarize why-not-fired, prepare false-positive review
  forbidden: dry-run claims, live command claims, manifest edits

live_manifest_mixed_batch_labeled:
  the batch contains current live play-only rows plus non-live observe-only rows
  allowed: preserve current live evidence and non-live blocked evidence
  forbidden: treating non-live rows as current live commands

{
  "schema": "lume.airdeck.observe_only_event_batch.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "batch_id": "airdeck-observe-only-batch-YYYYMMDDTHHMMSS-local",
  "batch_state": "observe_only_batch_ready",
  "run_id": "YYYYMMDD-HHMMSS-airdeck",
  "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "catalog_reference": {
    "catalog_path": "[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/gesture_catalog.json",
    "catalog_sha256": "sha256:required",
    "catalog_schema": "lume.airdeck.gesture_catalog.v1"
  },
  "live_manifest_reference": {
    "host": "K11",
    "manifest_path": "C:\\lume\\selfplay\\airdeck-playonly-promoted-commands.json",
    "manifest_sha256": "sha256:required",
    "command_peer": "[ip]",
    "current_live_gestures": [
      "airdeck_left_hand_raise_play",
      "airdeck_right_hand_raise_play"
    ]
  },
  "event_paths": {
    "gesture_events_jsonl": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/airdeck/gesture_events.jsonl",
    "why_not_fired_jsonl": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/airdeck/why_not_fired.jsonl",
    "source_peer_events_jsonl": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/airdeck/source_peer_events.jsonl",
    "foreground_events_jsonl": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/raw/airdeck/foreground_events.jsonl",
    "gesture_summary_json": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/derived/airdeck/gesture_summary.json"
  },
  "counts": {
    "total_events": 1,
    "non_live_observe_only_events": 1,
    "current_live_manifest_events": 0,
    "sent_command_count": 0,
    "non_k11_sender_count": 0,
    "supporting_peer_event_count": 0,
    "why_not_fired_count": 1,
    "new_gesture_live_claim_count": 0
  },
  "sample_events": [
    {
      "event_id": "gesture-event-0001",
      "gesture_id": "airdeck_sync",
      "body_mold": "airdeck_command_mold",
      "status": "observe_only",
      "source_id": "iphone_16_plus_motionmix",
      "source_peer": "[ip]",
      "source_is_current_command_peer": true,
      "candidate_command": {
        "command_id": "sync",
        "proposed_key_or_midi": null,
        "command_eligible": false,
        "command_permission_source": "none"
      },
      "safety": {
        "k11_is_only_command_gate": true,
        "sent_command": false,
        "non_k11_sender_detected": false,
        "rekordbox_foreground_known": false,
        "live_manifest_match": false
      },
      "why_not_fired": [
        "gesture_is_observe_only",
        "no_k11_promotion_packet",
        "no_dry_run_proof"
      ]
    }
  ],
  "downstream_permissions": {
    "show_in_k11_panel": true,
    "prepare_false_positive_review": true,
    "prepare_dry_run_review": false,
    "prepare_promotion_packet": false,
    "write_k11_manifest": false,
    "send_rekordbox_commands": false,
    "run_live_test": false
  },
  "safety": {
    "k11_is_only_command_gate": true,
    "batch_is_command_authority": false,
    "batch_writes_k11_manifest": false,
    "batch_sends_keyboard_or_midi": false,
    "phones_send_rekordbox_commands": false,
    "ipads_send_rekordbox_commands": false,
    "mac4_sends_rekordbox_commands": false,
    "mac5_sends_rekordbox_commands": false
  },
  "next_allowed_action": "prepare false-positive review from observe-only evidence"
}

AIRDECK_OBSERVE_ONLY_EVENT_BATCH="/path/to/observe_only_event_batch_admission.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["AIRDECK_OBSERVE_ONLY_EVENT_BATCH"])
data = json.loads(path.read_text())
errors = []
trusted_root = Path("[home]/Desktop/MotionMix/lume-wiring")
allowed_states = {
    "no_events_captured",
    "observe_only_batch_ready",
    "live_manifest_mixed_batch_labeled",
}
allowed_statuses = {
    "observed",
    "observe_only",
    "rehearsal_candidate",
    "promoted_live",
    "blocked",
}
allowed_molds = {"airdeck_command_mold", "dance_derivation_mold"}
current_live = {
    "airdeck_left_hand_raise_play",
    "airdeck_right_hand_raise_play",
}
bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]

def is_hash(value):
    return isinstance(value, str) and value.startswith("sha256:") and len(value) > len("sha256:")

def check_wiring_path(label, value, required=False):
    if value in {None, ""}:
        if required:
            errors.append(f"missing_{label}")
        return
    value_s = str(value)
    if not value_s.startswith(str(trusted_root)):
        errors.append(f"{label}_outside_wiring_root:{value_s}")
    if any(marker in value_s for marker in bad_markers):
        errors.append(f"{label}_bad_marker:{value_s}")

if data.get("schema") != "lume.airdeck.observe_only_event_batch.v1":
    errors.append("bad_schema")
if not data.get("batch_id"):
    errors.append("missing_batch_id")
state = data.get("batch_state")
if state not in allowed_states:
    errors.append(f"bad_batch_state:{state}")
if not data.get("run_id"):
    errors.append("missing_run_id")
if not data.get("capture_window_id"):
    errors.append("missing_capture_window_id")

catalog = data.get("catalog_reference") or {}
check_wiring_path("catalog_path", catalog.get("catalog_path"), required=state != "no_events_captured")
if state != "no_events_captured" and catalog.get("catalog_schema") != "lume.airdeck.gesture_catalog.v1":
    errors.append("bad_catalog_schema_reference")
if state != "no_events_captured" and not is_hash(catalog.get("catalog_sha256")):
    errors.append("catalog_sha256_not_sha256_marker")

manifest = data.get("live_manifest_reference") or {}
if manifest.get("host") != "K11":
    errors.append("live_manifest_host_not_k11")
if manifest.get("command_peer") != "[ip]":
    errors.append(f"unexpected_command_peer:{manifest.get('command_peer')}")
if state != "no_events_captured" and not is_hash(manifest.get("manifest_sha256")):
    errors.append("manifest_sha256_not_sha256_marker")
if state != "no_events_captured" and set(manifest.get("current_live_gestures") or []) != current_live:
    errors.append("current_live_gesture_set_mismatch")

event_paths = data.get("event_paths") or {}
for key in [
    "gesture_events_jsonl",
    "why_not_fired_jsonl",
    "source_peer_events_jsonl",
    "foreground_events_jsonl",
    "gesture_summary_json",
]:
    check_wiring_path(key, event_paths.get(key), required=state != "no_events_captured")

counts = data.get("counts") or {}
count_keys = [
    "total_events",
    "non_live_observe_only_events",
    "current_live_manifest_events",
    "sent_command_count",
    "non_k11_sender_count",
    "supporting_peer_event_count",
    "why_not_fired_count",
    "new_gesture_live_claim_count",
]
for key in count_keys:
    if not isinstance(counts.get(key), int) or counts.get(key) < 0:
        errors.append(f"bad_count_{key}:{counts.get(key)}")
total = counts.get("total_events", 0)
non_live = counts.get("non_live_observe_only_events", 0)
current_live_count = counts.get("current_live_manifest_events", 0)
sent_count = counts.get("sent_command_count", 0)
why_count = counts.get("why_not_fired_count", 0)

if state == "no_events_captured":
    for key in count_keys:
        if counts.get(key, 0) != 0:
            errors.append(f"{key}_not_zero_for_no_events")
if state == "observe_only_batch_ready":
    if total <= 0 or non_live <= 0:
        errors.append("observe_only_batch_has_no_non_live_events")
    if current_live_count != 0:
        errors.append("observe_only_batch_contains_live_manifest_events")
    if sent_count != 0:
        errors.append("observe_only_batch_sent_commands")
if state == "live_manifest_mixed_batch_labeled":
    if total <= 0 or non_live <= 0 or current_live_count <= 0:
        errors.append("mixed_batch_missing_live_or_non_live_events")
    if sent_count > current_live_count:
        errors.append("mixed_batch_sent_count_exceeds_current_live_events")
if total != non_live + current_live_count:
    errors.append("total_events_not_partitioned_by_live_and_non_live")
if counts.get("non_k11_sender_count", 0) != 0:
    errors.append("non_k11_sender_count_not_zero")
if counts.get("new_gesture_live_claim_count", 0) != 0:
    errors.append("new_gesture_live_claim_count_not_zero")
if non_live > 0 and why_count < non_live:
    errors.append("why_not_fired_count_less_than_non_live_events")

samples = data.get("sample_events") or []
if state == "no_events_captured" and samples:
    errors.append("no_events_state_has_samples")
if state != "no_events_captured" and not samples:
    errors.append("event_batch_has_no_samples")
for index, event in enumerate(samples):
    gesture_id = event.get("gesture_id")
    if not gesture_id:
        errors.append(f"event_{index}_missing_gesture_id")
        continue
    if event.get("body_mold") not in allowed_molds:
        errors.append(f"{gesture_id}_bad_body_mold:{event.get('body_mold')}")
    if event.get("status") not in allowed_statuses:
        errors.append(f"{gesture_id}_bad_status:{event.get('status')}")
    if not event.get("event_id"):
        errors.append(f"{gesture_id}_missing_event_id")
    if not event.get("source_id"):
        errors.append(f"{gesture_id}_missing_source_id")
    candidate = event.get("candidate_command") or {}
    safety = event.get("safety") or {}
    why = event.get("why_not_fired") or []

    if safety.get("k11_is_only_command_gate") is not True:
        errors.append(f"{gesture_id}_k11_gate_not_true")
    if safety.get("non_k11_sender_detected") is not False:
        errors.append(f"{gesture_id}_non_k11_sender_detected")
    if gesture_id in current_live and event.get("status") == "promoted_live":
        if safety.get("live_manifest_match") is not True:
            errors.append(f"{gesture_id}_live_manifest_match_not_true")
        if candidate.get("command_permission_source") != "k11_promoted_manifest":
            errors.append(f"{gesture_id}_permission_not_k11_manifest")
        if candidate.get("command_eligible") is not True:
            errors.append(f"{gesture_id}_live_command_eligible_not_true")
        if event.get("source_is_current_command_peer") is not True:
            errors.append(f"{gesture_id}_live_source_not_current_command_peer")
    else:
        if event.get("status") == "promoted_live":
            errors.append(f"{gesture_id}_unexpected_promoted_live")
        if safety.get("sent_command") is not False:
            errors.append(f"{gesture_id}_non_live_sent_command")
        if safety.get("live_manifest_match") is not False:
            errors.append(f"{gesture_id}_non_live_manifest_match_not_false")
        if candidate.get("command_eligible") is not False:
            errors.append(f"{gesture_id}_non_live_command_eligible_not_false")
        if candidate.get("proposed_key_or_midi") not in {None, ""}:
            errors.append(f"{gesture_id}_non_live_has_key_or_midi")
        if not why:
            errors.append(f"{gesture_id}_missing_why_not_fired")

permissions = data.get("downstream_permissions") or {}
if state == "no_events_captured":
    for key, value in permissions.items():
        if value is not False:
            errors.append(f"{key}_not_false_for_no_events")
else:
    if permissions.get("show_in_k11_panel") is not True:
        errors.append("show_in_k11_panel_not_true")
    if permissions.get("prepare_false_positive_review") is not True:
        errors.append("prepare_false_positive_review_not_true")
for key in [
    "prepare_dry_run_review",
    "prepare_promotion_packet",
    "write_k11_manifest",
    "send_rekordbox_commands",
    "run_live_test",
]:
    if permissions.get(key) is not False:
        errors.append(f"{key}_not_false")

safety = data.get("safety") or {}
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_is_only_command_gate_not_true")
for key in [
    "batch_is_command_authority",
    "batch_writes_k11_manifest",
    "batch_sends_keyboard_or_midi",
    "phones_send_rekordbox_commands",
    "ipads_send_rekordbox_commands",
    "mac4_sends_rekordbox_commands",
    "mac5_sends_rekordbox_commands",
]:
    if safety.get(key) is not False:
        errors.append(f"{key}_not_false")

next_action = str(data.get("next_allowed_action") or "").lower()
for forbidden in ["send command", "write manifest", "make live", "run live"]:
    if forbidden in next_action:
        errors.append(f"next_allowed_action_mentions_forbidden:{forbidden}")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("airdeck_observe_only_event_batch_admission_passed")
PY

[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/false_positive_review.json

review_waiting_for_events:
  no admitted observe-only batch exists
  allowed: keep collecting observe-only events
  forbidden: dry-run, promotion, manifest edits

review_failed_keep_observe_only:
  candidate overlaps too much with normal dancing or evidence is too weak
  allowed: keep candidate observe-only, revise detector, collect more data
  forbidden: dry-run and promotion

review_passed_for_one_dry_run_candidate:
  exactly one non-live candidate separates from normal dancing enough for dry-run
  allowed: prepare dry-run review packet for that candidate only
  forbidden: promotion, live commands, K11 manifest edits

{
  "schema": "lume.airdeck.false_positive_review.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "review_id": "airdeck-false-positive-review-YYYYMMDDTHHMMSS-local",
  "review_state": "review_passed_for_one_dry_run_candidate",
  "run_id": "YYYYMMDD-HHMMSS-airdeck",
  "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "event_batch_reference": {
    "event_batch_path": "[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/observe_only_event_batch_admission.json",
    "event_batch_sha256": "sha256:required",
    "event_batch_schema": "lume.airdeck.observe_only_event_batch.v1",
    "event_batch_state": "observe_only_batch_ready"
  },
  "review_scope": {
    "candidate_scope": "single_gesture",
    "candidate_gesture_id": "airdeck_sync",
    "body_mold": "airdeck_command_mold",
    "normal_dance_control_window_count": 3,
    "support_peer_control_window_count": 1,
    "current_live_manifest_gestures_excluded": true
  },
  "thresholds": {
    "minimum_attempt_count": 5,
    "maximum_false_positive_rate": 0.05,
    "minimum_separation_score": 0.8,
    "maximum_support_peer_command_confusion_rate": 0.0
  },
  "candidate_results": [
    {
      "gesture_id": "airdeck_sync",
      "review_status": "false_positive_review_passed",
      "attempt_count": 8,
      "true_positive_count": 7,
      "false_positive_count": 0,
      "false_positive_rate": 0.0,
      "normal_dance_false_positive_count": 0,
      "support_peer_confusion_count": 0,
      "separation_score": 0.91,
      "command_sent_count": 0,
      "why_safe_for_dry_run": [
        "low_false_positive_rate",
        "separates_from_normal_dance",
        "no_support_peer_command_confusion"
      ],
      "why_still_not_live": [
        "no_dry_run_proof",
        "no_rollback_manifest",
        "no_operator_acceptance",
        "no_k11_promotion_packet"
      ]
    }
  ],
  "downstream_permissions": {
    "show_in_k11_panel": true,
    "prepare_dry_run_review": true,
    "prepare_promotion_packet": false,
    "write_k11_manifest": false,
    "send_rekordbox_commands": false,
    "run_live_test": false
  },
  "safety": {
    "k11_is_only_command_gate": true,
    "review_is_command_authority": false,
    "review_writes_k11_manifest": false,
    "review_sends_keyboard_or_midi": false,
    "phones_send_rekordbox_commands": false,
    "ipads_send_rekordbox_commands": false,
    "mac4_sends_rekordbox_commands": false,
    "mac5_sends_rekordbox_commands": false
  },
  "next_allowed_action": "prepare dry-run review for airdeck_sync only"
}

AIRDECK_FALSE_POSITIVE_REVIEW="/path/to/false_positive_review.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["AIRDECK_FALSE_POSITIVE_REVIEW"])
data = json.loads(path.read_text())
errors = []
trusted_root = Path("[home]/Desktop/MotionMix/lume-wiring")
allowed_states = {
    "review_waiting_for_events",
    "review_failed_keep_observe_only",
    "review_passed_for_one_dry_run_candidate",
}
allowed_batch_states = {
    "observe_only_batch_ready",
    "live_manifest_mixed_batch_labeled",
}
allowed_statuses = {
    "false_positive_review_waiting",
    "false_positive_review_failed",
    "false_positive_review_passed",
}
current_live = {
    "airdeck_left_hand_raise_play",
    "airdeck_right_hand_raise_play",
}
bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]

def is_hash(value):
    return isinstance(value, str) and value.startswith("sha256:") and len(value) > len("sha256:")

def check_wiring_path(label, value, required=False):
    if value in {None, ""}:
        if required:
            errors.append(f"missing_{label}")
        return
    value_s = str(value)
    if not value_s.startswith(str(trusted_root)):
        errors.append(f"{label}_outside_wiring_root:{value_s}")
    if any(marker in value_s for marker in bad_markers):
        errors.append(f"{label}_bad_marker:{value_s}")

if data.get("schema") != "lume.airdeck.false_positive_review.v1":
    errors.append("bad_schema")
if not data.get("review_id"):
    errors.append("missing_review_id")
state = data.get("review_state")
if state not in allowed_states:
    errors.append(f"bad_review_state:{state}")
if not data.get("run_id"):
    errors.append("missing_run_id")
if not data.get("capture_window_id"):
    errors.append("missing_capture_window_id")

batch = data.get("event_batch_reference") or {}
check_wiring_path("event_batch_path", batch.get("event_batch_path"), required=state != "review_waiting_for_events")
if state != "review_waiting_for_events" and not is_hash(batch.get("event_batch_sha256")):
    errors.append("event_batch_sha256_not_sha256_marker")
if state != "review_waiting_for_events" and batch.get("event_batch_schema") != "lume.airdeck.observe_only_event_batch.v1":
    errors.append("bad_event_batch_schema")
if state != "review_waiting_for_events" and batch.get("event_batch_state") not in allowed_batch_states:
    errors.append(f"bad_event_batch_state:{batch.get('event_batch_state')}")

scope = data.get("review_scope") or {}
candidate_id = scope.get("candidate_gesture_id")
if state == "review_passed_for_one_dry_run_candidate":
    if scope.get("candidate_scope") != "single_gesture":
        errors.append("passed_review_not_single_gesture_scope")
    if not candidate_id:
        errors.append("passed_review_missing_candidate_gesture_id")
    if candidate_id in current_live:
        errors.append("passed_review_candidate_is_current_live_gesture")
if scope.get("current_live_manifest_gestures_excluded") is not True:
    errors.append("current_live_manifest_gestures_not_excluded")
for key in ["normal_dance_control_window_count", "support_peer_control_window_count"]:
    if not isinstance(scope.get(key), int) or scope.get(key) < 0:
        errors.append(f"bad_scope_count_{key}:{scope.get(key)}")

thresholds = data.get("thresholds") or {}
minimum_attempt_count = thresholds.get("minimum_attempt_count")
maximum_false_positive_rate = thresholds.get("maximum_false_positive_rate")
minimum_separation_score = thresholds.get("minimum_separation_score")
maximum_support_peer_confusion_rate = thresholds.get("maximum_support_peer_command_confusion_rate")
if not isinstance(minimum_attempt_count, int) or minimum_attempt_count < 1:
    errors.append(f"bad_minimum_attempt_count:{minimum_attempt_count}")
for key, value in [
    ("maximum_false_positive_rate", maximum_false_positive_rate),
    ("minimum_separation_score", minimum_separation_score),
    ("maximum_support_peer_command_confusion_rate", maximum_support_peer_confusion_rate),
]:
    if not isinstance(value, (int, float)) or not (0 <= value <= 1):
        errors.append(f"bad_threshold_{key}:{value}")

results = data.get("candidate_results") or []
if state == "review_waiting_for_events" and results:
    errors.append("waiting_review_has_candidate_results")
if state != "review_waiting_for_events" and not results:
    errors.append("review_has_no_candidate_results")

passed = []
for index, result in enumerate(results):
    gesture_id = result.get("gesture_id")
    if not gesture_id:
        errors.append(f"result_{index}_missing_gesture_id")
        continue
    if gesture_id in current_live:
        errors.append(f"{gesture_id}_current_live_gesture_in_false_positive_review")
    status = result.get("review_status")
    if status not in allowed_statuses:
        errors.append(f"{gesture_id}_bad_review_status:{status}")
    if status == "false_positive_review_passed":
        passed.append(gesture_id)
    for key in [
        "attempt_count",
        "true_positive_count",
        "false_positive_count",
        "normal_dance_false_positive_count",
        "support_peer_confusion_count",
        "command_sent_count",
    ]:
        if not isinstance(result.get(key), int) or result.get(key) < 0:
            errors.append(f"{gesture_id}_bad_{key}:{result.get(key)}")
    for key in ["false_positive_rate", "separation_score"]:
        if not isinstance(result.get(key), (int, float)) or not (0 <= result.get(key) <= 1):
            errors.append(f"{gesture_id}_bad_{key}:{result.get(key)}")
    attempts = result.get("attempt_count", 0)
    true_pos = result.get("true_positive_count", 0)
    false_pos = result.get("false_positive_count", 0)
    if attempts != true_pos + false_pos:
        errors.append(f"{gesture_id}_attempts_not_true_plus_false")
    if result.get("command_sent_count") != 0:
        errors.append(f"{gesture_id}_command_sent_count_not_zero")
    if result.get("support_peer_confusion_count") != 0:
        errors.append(f"{gesture_id}_support_peer_confusion_count_not_zero")
    if status == "false_positive_review_passed":
        if attempts < minimum_attempt_count:
            errors.append(f"{gesture_id}_passed_with_too_few_attempts")
        if result.get("false_positive_rate", 1) > maximum_false_positive_rate:
            errors.append(f"{gesture_id}_passed_with_high_false_positive_rate")
        if result.get("separation_score", 0) < minimum_separation_score:
            errors.append(f"{gesture_id}_passed_with_low_separation_score")
        if not result.get("why_safe_for_dry_run"):
            errors.append(f"{gesture_id}_missing_why_safe_for_dry_run")
        if not result.get("why_still_not_live"):
            errors.append(f"{gesture_id}_missing_why_still_not_live")

if state == "review_passed_for_one_dry_run_candidate":
    if len(passed) != 1:
        errors.append(f"passed_review_count_not_one:{len(passed)}")
    if candidate_id and passed and passed[0] != candidate_id:
        errors.append("passed_candidate_does_not_match_scope")
    if scope.get("normal_dance_control_window_count", 0) < 1:
        errors.append("passed_review_missing_normal_dance_control_windows")
elif passed:
    errors.append("passed_candidate_outside_passed_state")

permissions = data.get("downstream_permissions") or {}
if state == "review_passed_for_one_dry_run_candidate":
    if permissions.get("show_in_k11_panel") is not True:
        errors.append("show_in_k11_panel_not_true")
    if permissions.get("prepare_dry_run_review") is not True:
        errors.append("prepare_dry_run_review_not_true")
else:
    for key in ["prepare_dry_run_review", "prepare_promotion_packet"]:
        if permissions.get(key) is not False:
            errors.append(f"{key}_not_false")
for key in [
    "prepare_promotion_packet",
    "write_k11_manifest",
    "send_rekordbox_commands",
    "run_live_test",
]:
    if permissions.get(key) is not False:
        errors.append(f"{key}_not_false")

safety = data.get("safety") or {}
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_is_only_command_gate_not_true")
for key in [
    "review_is_command_authority",
    "review_writes_k11_manifest",
    "review_sends_keyboard_or_midi",
    "phones_send_rekordbox_commands",
    "ipads_send_rekordbox_commands",
    "mac4_sends_rekordbox_commands",
    "mac5_sends_rekordbox_commands",
]:
    if safety.get(key) is not False:
        errors.append(f"{key}_not_false")

next_action = str(data.get("next_allowed_action") or "").lower()
for forbidden in ["promote", "write manifest", "send command", "run live", "make live"]:
    if forbidden in next_action:
        errors.append(f"next_allowed_action_mentions_forbidden:{forbidden}")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("airdeck_false_positive_review_admission_passed")
PY

[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/command_grammar_test_matrix.json

grammar_tests_waiting_for_candidate:
  no false-positive-reviewed candidate exists
  allowed: keep tests as planned checks
  forbidden: dry-run admission, promotion, commands

grammar_tests_failed_keep_observe_only:
  at least one fail-closed test failed or evidence is incomplete
  allowed: keep candidate observe-only and fix grammar
  forbidden: dry-run admission, promotion, commands

grammar_tests_passed_for_dry_run_candidate:
  required fail-closed tests passed for exactly one candidate
  allowed: dry-run review for that candidate only
  forbidden: promotion packet, manifest writes, live tests, commands

{
  "schema": "lume.airdeck.command_grammar_test_matrix.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "matrix_id": "airdeck-command-grammar-tests-YYYYMMDDTHHMMSS-local",
  "matrix_state": "grammar_tests_passed_for_dry_run_candidate",
  "run_id": "YYYYMMDD-HHMMSS-airdeck",
  "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "candidate": {
    "gesture_id": "airdeck_sync",
    "command_scope": "one_gesture",
    "target_command": "sync",
    "body_mold": "airdeck_command_mold",
    "candidate_is_current_live_gesture": false
  },
  "required_tests": [
    {
      "test_id": "non_manifest_gestures_never_send",
      "status": "passed",
      "sent_command_count": 0,
      "why_required": "unpromoted gestures must stay observe-only"
    },
    {
      "test_id": "supporting_peers_blocked_from_command_authority",
      "status": "passed",
      "sent_command_count": 0,
      "why_required": "support cameras are evidence only"
    },
    {
      "test_id": "stale_pose_blocks_commands",
      "status": "passed",
      "sent_command_count": 0,
      "why_required": "old pose cannot command"
    },
    {
      "test_id": "missing_body_blocks_commands",
      "status": "passed",
      "sent_command_count": 0,
      "why_required": "no body means no command"
    },
    {
      "test_id": "low_confidence_blocks_commands",
      "status": "passed",
      "sent_command_count": 0,
      "why_required": "weak pose cannot command"
    },
    {
      "test_id": "unknown_foreground_blocks_dry_run_and_live",
      "status": "passed",
      "sent_command_count": 0,
      "why_required": "Rekordbox focus must be known"
    },
    {
      "test_id": "cooldown_prevents_repeats",
      "status": "passed",
      "sent_command_count": 0,
      "why_required": "single gesture cannot spam"
    },
    {
      "test_id": "cancel_clears_pending_load_or_select",
      "status": "passed",
      "sent_command_count": 0,
      "why_required": "operator needs a cancel path"
    },
    {
      "test_id": "manifest_hash_captured_before_after_reload",
      "status": "passed",
      "sent_command_count": 0,
      "why_required": "manifest drift must be visible"
    },
    {
      "test_id": "promotion_package_has_rollback_manifest",
      "status": "passed",
      "sent_command_count": 0,
      "why_required": "rollback must exist before promotion"
    }
  ],
  "counts": {
    "required_test_count": 10,
    "passed_test_count": 10,
    "failed_test_count": 0,
    "sent_command_count": 0,
    "non_k11_sender_count": 0,
    "live_manifest_write_count": 0,
    "bridge_reload_count": 0
  },
  "artifacts": {
    "test_report": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/promotion/command_grammar_test_report.json",
    "test_report_sha256": "sha256:required",
    "why_not_fired_jsonl": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/promotion/why_not_fired.jsonl",
    "cooldown_report": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/promotion/cooldown_report.json",
    "support_peer_gate_report": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/promotion/support_peer_gate_report.json"
  },
  "downstream_permissions": {
    "show_in_k11_panel": true,
    "prepare_dry_run_review": true,
    "prepare_promotion_packet": false,
    "write_k11_manifest": false,
    "send_rekordbox_commands": false,
    "run_live_test": false
  },
  "safety": {
    "k11_is_only_command_gate": true,
    "grammar_tests_are_command_authority": false,
    "grammar_tests_write_k11_manifest": false,
    "grammar_tests_send_keyboard_or_midi": false,
    "phones_send_rekordbox_commands": false,
    "ipads_send_rekordbox_commands": false,
    "mac4_sends_rekordbox_commands": false,
    "mac5_sends_rekordbox_commands": false
  },
  "next_allowed_action": "prepare dry-run review for airdeck_sync only"
}

AIRDECK_COMMAND_GRAMMAR_TEST_MATRIX="/path/to/command_grammar_test_matrix.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["AIRDECK_COMMAND_GRAMMAR_TEST_MATRIX"])
data = json.loads(path.read_text())
errors = []
trusted_root = Path("[home]/Desktop/MotionMix/lume-wiring")
allowed_states = {
    "grammar_tests_waiting_for_candidate",
    "grammar_tests_failed_keep_observe_only",
    "grammar_tests_passed_for_dry_run_candidate",
}
required_test_ids = {
    "non_manifest_gestures_never_send",
    "supporting_peers_blocked_from_command_authority",
    "stale_pose_blocks_commands",
    "missing_body_blocks_commands",
    "low_confidence_blocks_commands",
    "unknown_foreground_blocks_dry_run_and_live",
    "cooldown_prevents_repeats",
    "cancel_clears_pending_load_or_select",
    "manifest_hash_captured_before_after_reload",
    "promotion_package_has_rollback_manifest",
}
current_live = {
    "airdeck_left_hand_raise_play",
    "airdeck_right_hand_raise_play",
}
bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]

def is_hash(value):
    return isinstance(value, str) and value.startswith("sha256:") and len(value) > len("sha256:")

def check_wiring_path(label, value, required=False):
    if value in {None, ""}:
        if required:
            errors.append(f"missing_{label}")
        return
    value_s = str(value)
    if not value_s.startswith(str(trusted_root)):
        errors.append(f"{label}_outside_wiring_root:{value_s}")
    if any(marker in value_s for marker in bad_markers):
        errors.append(f"{label}_bad_marker:{value_s}")

if data.get("schema") != "lume.airdeck.command_grammar_test_matrix.v1":
    errors.append("bad_schema")
if not data.get("matrix_id"):
    errors.append("missing_matrix_id")
state = data.get("matrix_state")
if state not in allowed_states:
    errors.append(f"bad_matrix_state:{state}")
if not data.get("run_id"):
    errors.append("missing_run_id")
if not data.get("capture_window_id"):
    errors.append("missing_capture_window_id")

candidate = data.get("candidate") or {}
gesture_id = candidate.get("gesture_id")
if state == "grammar_tests_passed_for_dry_run_candidate":
    if not gesture_id:
        errors.append("passed_matrix_missing_gesture_id")
    if gesture_id in current_live:
        errors.append("grammar_candidate_is_current_live_gesture")
    if candidate.get("command_scope") != "one_gesture":
        errors.append(f"bad_command_scope:{candidate.get('command_scope')}")
    if not candidate.get("target_command"):
        errors.append("missing_target_command")
    if candidate.get("body_mold") != "airdeck_command_mold":
        errors.append(f"bad_body_mold:{candidate.get('body_mold')}")
    if candidate.get("candidate_is_current_live_gesture") is not False:
        errors.append("candidate_is_current_live_gesture_not_false")

tests = data.get("required_tests") or []
test_ids = {row.get("test_id") for row in tests}
if state == "grammar_tests_passed_for_dry_run_candidate":
    if test_ids != required_test_ids:
        errors.append(f"required_test_ids_mismatch:{sorted(test_ids)}")
for index, row in enumerate(tests):
    test_id = row.get("test_id")
    if test_id not in required_test_ids:
        errors.append(f"unknown_test_id_{index}:{test_id}")
    if state == "grammar_tests_passed_for_dry_run_candidate" and row.get("status") != "passed":
        errors.append(f"{test_id}_not_passed")
    if row.get("sent_command_count") != 0:
        errors.append(f"{test_id}_sent_command_count_not_zero")
    if not row.get("why_required"):
        errors.append(f"{test_id}_missing_why_required")

counts = data.get("counts") or {}
for key in [
    "required_test_count",
    "passed_test_count",
    "failed_test_count",
    "sent_command_count",
    "non_k11_sender_count",
    "live_manifest_write_count",
    "bridge_reload_count",
]:
    if not isinstance(counts.get(key), int) or counts.get(key) < 0:
        errors.append(f"bad_count_{key}:{counts.get(key)}")
if state == "grammar_tests_passed_for_dry_run_candidate":
    if counts.get("required_test_count") != len(required_test_ids):
        errors.append("required_test_count_mismatch")
    if counts.get("passed_test_count") != len(required_test_ids):
        errors.append("passed_test_count_mismatch")
    if counts.get("failed_test_count") != 0:
        errors.append("failed_test_count_not_zero")
for key in ["sent_command_count", "non_k11_sender_count", "live_manifest_write_count", "bridge_reload_count"]:
    if counts.get(key) != 0:
        errors.append(f"{key}_not_zero")

artifacts = data.get("artifacts") or {}
for key in ["test_report", "why_not_fired_jsonl", "cooldown_report", "support_peer_gate_report"]:
    check_wiring_path(key, artifacts.get(key), required=state == "grammar_tests_passed_for_dry_run_candidate")
if state == "grammar_tests_passed_for_dry_run_candidate" and not is_hash(artifacts.get("test_report_sha256")):
    errors.append("test_report_sha256_not_sha256_marker")

permissions = data.get("downstream_permissions") or {}
if state == "grammar_tests_passed_for_dry_run_candidate":
    if permissions.get("show_in_k11_panel") is not True:
        errors.append("show_in_k11_panel_not_true")
    if permissions.get("prepare_dry_run_review") is not True:
        errors.append("prepare_dry_run_review_not_true")
else:
    if permissions.get("prepare_dry_run_review") is not False:
        errors.append("prepare_dry_run_review_not_false")
for key in ["prepare_promotion_packet", "write_k11_manifest", "send_rekordbox_commands", "run_live_test"]:
    if permissions.get(key) is not False:
        errors.append(f"{key}_not_false")

safety = data.get("safety") or {}
if safety.get("k11_is_only_command_gate") is not True:
    errors.append("k11_is_only_command_gate_not_true")
for key in [
    "grammar_tests_are_command_authority",
    "grammar_tests_write_k11_manifest",
    "grammar_tests_send_keyboard_or_midi",
    "phones_send_rekordbox_commands",
    "ipads_send_rekordbox_commands",
    "mac4_sends_rekordbox_commands",
    "mac5_sends_rekordbox_commands",
]:
    if safety.get(key) is not False:
        errors.append(f"{key}_not_false")

next_action = str(data.get("next_allowed_action") or "").lower()
for forbidden in ["promote", "write manifest", "send command", "run live", "reload bridge"]:
    if forbidden in next_action:
        errors.append(f"next_allowed_action_mentions_forbidden:{forbidden}")

if errors:
    print("\n".join(errors))
    sys.exit(1)
print("airdeck_command_grammar_test_matrix_admission_passed")
PY

[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/dry_run_review.json

dry_run_waiting_for_false_positive_review:
  no passed false-positive review exists
  allowed: keep collecting observe-only and false-positive evidence
  forbidden: dry-run, promotion packet, manifest edits

dry_run_failed_keep_observe_only:
  candidate failed no-send gate, cooldown, peer, focus, or cancel checks
  allowed: keep candidate observe-only and preserve failure evidence
  forbidden: promotion packet, manifest edits, live test

dry_run_passed_for_promotion_packet_review:
  exactly one non-live candidate passed no-send dry-run checks
  allowed: prepare a promotion packet for operator review
  forbidden: manifest write, bridge reload, live test, batch promotion

{
  "schema": "lume.airdeck.dry_run_review.v1",
  "created_at": "YYYY-MM-DDTHH:MM:SS-04:00",
  "dry_run_id": "airdeck-dry-run-review-YYYYMMDDTHHMMSS-local",
  "dry_run_state": "dry_run_passed_for_promotion_packet_review",
  "run_id": "YYYYMMDD-HHMMSS-airdeck",
  "capture_window_id": "capture-YYYYMMDDTHHMMSS-local",
  "false_positive_review_reference": {
    "false_positive_review_path": "[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/false_positive_review.json",
    "false_positive_review_sha256": "sha256:required",
    "false_positive_review_schema": "lume.airdeck.false_positive_review.v1",
    "false_positive_review_state": "review_passed_for_one_dry_run_candidate",
    "candidate_gesture_id": "airdeck_sync"
  },
  "command_grammar_test_reference": {
    "command_grammar_test_matrix_path": "[home]/Desktop/MotionMix/lume-wiring/derived/airdeck/command_grammar_test_matrix.json",
    "command_grammar_test_matrix_sha256": "sha256:required",
    "command_grammar_test_matrix_schema": "lume.airdeck.command_grammar_test_matrix.v1",
    "command_grammar_test_matrix_state": "grammar_tests_passed_for_dry_run_candidate",
    "candidate_gesture_id": "airdeck_sync"
  },
  "k11_gate": {
    "host": "K11",
    "k11_is_only_command_gate": true,
    "command_peer_source_id": "iphone_16_plus_motionmix",
    "command_peer": "[ip]",
    "bridge_mode": "dry_run_no_send",
    "rekordbox_foreground_checked": true,
    "airdeck_console_snapshot": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/promotion/airdeck_console_snapshot.json"
  },
  "candidate": {
    "gesture_id": "airdeck_sync",
    "command_scope": "one_gesture",
    "target_command": "sync",
    "target_key_or_midi": null,
    "deck_scope": "reviewed_single_deck_or_pair",
    "mapping_hash": "sha256:required",
    "command_eligible_before_promotion": false
  },
  "dry_run_result": {
    "review_status": "dry_run_passed",
    "attempt_count": 5,
    "dry_run_event_count": 5,
    "blocked_event_count": 0,
    "sent_command_count": 0,
    "non_k11_sender_count": 0,
    "support_peer_command_attempt_count": 0,
    "cooldown_violation_count": 0,
    "cancel_or_rollback_checked": true,
    "supporting_peers_gated": true,
    "live_manifest_unchanged": true,
    "bridge_reload_performed": false,
    "why_safe_for_promotion_packet_review": [
      "no_send_dry_run_passed",
      "k11_command_peer_matched",
      "cooldown_and_cancel_checked",
      "support_peers_gated"
    ],
    "why_still_not_live": [
      "no_operator_acceptance",
      "no_candidate_manifest",
      "no_rollback_manifest",
      "no_k11_live_promotion_admission"
    ]
  },
  "event_paths": {
    "dry_run_events_jsonl": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/promotion/dry_run_events.jsonl",
    "why_not_fired_jsonl": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/promotion/why_not_fired.jsonl",
    "cooldown_report_json": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/promotion/cooldown_report.json",
    "support_peer_gate_report_json": "[home]/Desktop/MotionMix/lume-wiring/first-real-capture-runs/<run_id>/promotion/support_peer_gate_report.json"
  },
  "downstream_permissions": {
    "show_in_k11_panel": true,
    "prepare_promotion_packet": true,
    "candidate_manifest_write_allowed": false,
    "write_k11_manifest": false,
    "bridge_reload_allowed": false,
    "send_rekordbox_commands": false,
    "run_live_test": false,
    "batch_promotion_allowed": false
  },
  "safety": {
    "k11_is_only_command_gate": true,
    "dry_run_is_command_authority": false,
    "dry_run_writes_k11_manifest": false,
    "dry_run_sends_keyboard_or_midi": false,
    "phones_send_rekordbox_commands": false,
    "ipads_send_rekordbox_commands": false,
    "mac4_sends_rekordbox_commands": false,
    "mac5_sends_rekordbox_commands": false
  },
  "next_allowed_action": "prepare promotion packet for operator review only"
}

AIRDECK_DRY_RUN_REVIEW="/path/to/dry_run_review.json" python3 - <<'PY'
import json
import os
import sys
from pathlib import Path

path = Path(os.environ["AIRDECK_DRY_RUN_REVIEW"])
data = json.loads(path.read_text())
errors = []
trusted_root = Path("[home]/Desktop/MotionMix/lume-wiring")
allowed_states = {
    "dry_run_waiting_for_false_positive_review",
    "dry_run_failed_keep_observe_only",
    "dry_run_passed_for_promotion_packet_review",
}
allowed_statuses = {
    "dry_run_waiting",
    "dry_run_failed",
    "dry_run_passed",
}
current_live = {
    "airdeck_left_hand_raise_play",
    "airdeck_right_hand_raise_play",
}
bad_markers = ["/tmp/", "/private/var/folders", "fixture", "smoke", "synthetic", "placeholder"]

def is_hash(value):
    return isinstance(value, str) and value.startswith("sha256:") and len(value) > len("sha256:")

def check_wiring_path(label, value, required=False):
    if value in {None, ""}:
        if required:
            errors.append(f"missing_{label}")
        return
    value_s = str(value)
    if not value_s.startswith(str(trusted_root)):
        errors.append(f"{label}_outside_wiring_root:{value_s}")
    if any(marker in value_s for marker in bad_markers):
        errors.append(f"{label}_bad_marker:{value_s}")

if data.get("schema") != "lume.airdeck.dry_run_review.v1":
    errors.append("bad_schema")
if not data.get("dry_run_id"):
    errors.append("missing_dry_run_id")
state = data.get("dry_run_state")
if state not in allowed_states:
    errors.append(f"bad_dry_run_state:{state}")
if not data.get("run_id"):
    errors.append("missing_run_id")
if not data.get("capture_window_id"):
    errors.append("missing_capture_window_id")

fp = data.get("false_positive_review_reference") or {}
check_wiring_path("false_positive_review_path", fp.get("false_positive_review_path"), required=state != "dry_run_waiting_for_false_positive_review")
if state != "dry_run_waiting_for_false_positive_review":
    if not is_hash(fp.get("false_positive_review_sha256")):
        errors.append("false_positive_review_sha256_not_sha256_marker")
    if fp.get("false_positive_review_schema") != "lume.airdeck.false_positive_review.v1":
        errors.append("bad_false_positive_review_schema")
    if fp.get("false_positive_review_state") != "review_passed_for_one_dry_run_candidate":
        errors.append(f"bad_false_positive_review_state:{fp.get('false_positive_review_state')}")
candidate_id = fp.get("candidate_gesture_id")
if state == "dry_run_passed_for_promotion_packet_review" and not candidate_id:
    errors.append("passed_dry_run_missing_candidate_gesture_id")
if candidate_id in current_live:
    errors.append("dry_run_candidate_is_current_live_gesture")

grammar = data.get("command_grammar_test_reference") or {}
check_wiring_path("command_grammar_test_matrix_path", grammar.get("command_grammar_test_matrix_path"), required=state != "dry_run_waiting_for_false_positive_review")
if state != "dry_run_waiting_for_false_positive_review":
    if not is_hash(grammar.get("command_grammar_test_matrix_sha256")):
        errors.append("command_grammar_test_matrix_sha256_not_sha256_marker")
    if grammar.get("command_grammar_test_matrix_schema") != "lume.airdeck.command_grammar_test_matrix.v1":
        errors.append("bad_command_grammar_test_matrix_schema")
    if grammar.get("command_grammar_test_matrix_state") != "grammar_tests_passed_for_dry_run_candidate":
        errors.append(f"bad_command_grammar_test_matrix_state:{grammar.get('command_grammar_test_matrix_state')}")
    if grammar.get("candidate_gesture_id") != candidate_id:
        errors.append("grammar_candidate_gesture_id_mismatch")

gate = data.get("k11_gate") or {}
if gate.get("host") != "K11":
    errors.append("k11_gate_host_not_k11")
if gate.get("k11_is_only_command_gate") is not True:
    errors.append("k11_is_only_command_gate_not_true")
if gate.get("command_peer_source_id") != "iphone_16_plus_motionmix":
    errors.append("unexpected_command_peer_source_id")
if gate.get("command_peer") != "[ip]":
    errors.append(f"unexpected_command_peer:{gate.get('command_peer')}")
if gate.get("bridge_mode") != "dry_run_no_send":
    errors.append(f"bad_bridge_mode:{gate.get('bridge_mode')}")
if state == "dry_run_passed_for_promotion_packet_review" and gate.get("rekordbox_foreground_checked") is not True:
    errors.append("passed_dry_run_without_rekordbox_foreground_check")
check_wiring_path("airdeck_console_snapshot", gate.get("airdeck_console_snapshot"), required=state != "dry_run_waiting_for_false_positive_review")

candidate = data.get("candidate") or {}
if state != "dry_run_waiting_for_false_positive_review":
    if candidate.get("gesture_id") != candidate_id:
        errors.append("candidate_gesture_id_mismatch")
    if candidate.get("command_scope") != "one_gesture":
        errors.append(f"bad_command_scope:{candidate.get('command_scope')}")
    if not candidate.get("target_command"):
        errors.append("missing_target_command")
    if not is_hash(candidate.get("mapping_hash")):
        errors.append("mapping_hash_not_sha256_marker")
    if candidate.get("command_eligible_before_promotion") is not False:
        errors.append("command_eligible_before_promotion_not_false")

result = data.get("dry_run_result") or {}
status = result.get("review_status")
if state == "dry_run_waiting_for_false_positive_review" and status not in {None, "dry_run_waiting"}:
    errors.append(f"waiting_state_has_bad_status:{status}")
if state != "dry_run_waiting_for_false_positive_review" and status not in allowed_statuses:
    errors.append(f"bad_review_status:{status}")
if state == "dry_run_passed_for_promotion_packet_review" and status != "dry_run_passed":
    errors.append("passed_state_without_dry_run_passed_status")
if state == "dry_run_failed_keep_observe_only" and status != "dry_run_failed":
    errors.append("failed_state_without_dry_run_failed_status")

count_keys = [
    "attempt_count",
    "dry_run_event_count",
    "blocked_event_count",
    "sent_command_count",
    "non_k11_sender_count",
    "support_peer_command_attempt_count",
    "cooldown_violation_count",
]
for key in count_keys:
    value = result.get(key, 0)
    if not isinstance(value, int) or value < 0:
        errors.append(f"bad_result_count_{key}:{value}")
if state == "dry_run_passed_for_promotion_packet_review":
    if result.get("attempt_count", 0) <= 0:
        errors.append("passed_dry_run_has_no_attempts")
    if result.get("dry_run_event_count", 0) <= 0:
        errors.append("passed_dry_run_has_no_events")
    if result.get("sent_command_count") != 0:
        errors.append("passed_dry_run_sent_commands")
    if result.get("non_k11_sender_count") != 0:
        errors.append("passed_dry_run_non_k11_sender")
    if result.get("support_peer_command_attempt_count") != 0:
        errors.append("passed_dry_run_support_peer_command_attempts")
    if result.get("cooldown_violation_count") != 0:
        errors.append("passed_dry_run_cooldown_violations")
    for key in ["cancel_or_rollback_checked", "supporting_peers_gated", "live_manifest_unchanged"]:
        if result.get(key) is not True:
            errors.append(f"passed_dry_run_{key}_not_true")
    if result.get("bridge_reload_performed") is not False:
        errors.append("passed_dry_run_bridge_reload_performed")
    if not result.get("why_safe_for_promotion_packet_review"):
        errors.append("missing_why_safe_for_promotion_packet_review")
    if not result.get("why_still_not_live"):
        errors.append("missing_why_still_not_live")
else:
    if result.get("sent_command_count", 0) != 0:
        errors.append("non_passed_dry_run_sent_commands")

event_paths = data.get("event_paths") or {}
for key in [
    "dry_run_events_jsonl",
    "why_not_fired_jsonl",
    "cooldown_report_json",
    "support_peer_gate_report_json",
]:
    check_wiring_path(key, event_paths.get(key), required=state != "dry_run_waiting_for_false_positive_review")

permissions = data.get("downstream_permissions") or {}
if state == "dry_run_passed_for_promotion_packet_review":
    if permissions.get("show_in_k11_panel") is not True:
        errors.append("show_in_k11_panel_not_true")
    if permissions.get("prepare_promotion_packet") is not True:
        errors.append("prepare_promotion_packet_not_true")
else:
    if permissions.get("prepare_promotion_packet") is not False:
        errors.append("prepare_promotion_packet_not_false")
for key in [
    "candidate_manifest_write_allowed",
    "write_k11_manifest",
    "bridge_reload_allowed",
    "send_rekordbox_commands",
    "run_live_test",
    "batch_promotion_allowed",
]:
    if permissions.get(key) is not False: