Mac5 Reconstruction Worker

Mac5 Reconstruction Worker

Status: verified K11 return lane, review index, and dry-run AirDeck mapping on
2026-06-01.

Latest execution: 2026-06-06 Mac4-first prerequisites passed, local AirDeck
artifact verification passed after repairing the mirrored recording-status link,
and Mac5 completed a fresh non-placeholder one-frame SAM3DBody reconstruction
from an already staged K11 bundle. Live K11 upload/return could not run because
SSH to `[ip]:22` timed out during this pass.

Current wiring update: on 2026-06-10 the Mac4-first live gate turned green
after the Chrome/Web MIDI wrapper was fixed. The wrapper now proves the MRT2
page by clicking the page's own `Connect MIDI` control through CDP DOM/Input,
then validating a fresh `LUME MRT2 Proof Sink` browser proof. The saved unlock
artifact is:

[home]/Desktop/MotionMix/lume-wiring/
  lume_mac4_first_completion_gate_20260610T035207Z.json

It reports `completion_ready=true`, `mac5_heavy_reconstruction_allowed=true`,
`wrapper_status=pass`, `audit_status=pass`, and no failed requirements. Mac5 is
now allowed by the Mac4-first gate, but real heavy reconstruction still needs a
verified real external/multi-angle capture session. K11 remains the only
Rekordbox/AirDeck command gate. Mac4 remains read-only. Mac2 is still staged as
the external-only Insta360 room-wide angle host, but it must enumerate a real
eligible external camera before its lane counts as capture evidence.

This page documents the current K11 -> Mac5 -> K11 offline reconstruction path.
It is an implementation note, not a future architecture sketch.

Role

Mac5 is now an offline body-reconstruction worker for rehearsal bundles.

It does not own live performance control. It does not send Rekordbox commands.
It does not replace K11 as the AirDeck safety gate.

The verified lane is:

K11 rehearsal bundle
  -> derived/sam3d/request.json
  -> Mac1 transfer/orchestration
  -> Mac5 staged bundle
  -> SAM3DBody-cpp frame reconstruction
  -> derived/sam3d/summary.json
  -> derived/sam3d/sam3d_frames.jsonl
  -> derived/sam3d/motion_windows.jsonl
  -> derived/sam3d/template_candidates.json
  -> returned to K11 derived/sam3d

Mac1 is currently the transfer orchestrator because Mac1 has working SSH trust
to both K11 and Mac5. Mac5 does not currently have K11 public-key access; direct
Mac5 -> K11 pull can be added later, but it is not required for the verified
path.

Code Paths

Local source files:

Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/
  mac5_k11_bundle_worker.py
  orchestrate_k11_to_mac5.py
  audit_k11_sam3d_returns.py
  build_k11_sam3d_review_index.py
  package_k11_sam3d_first_capture_bundles.py
  verify_k11_mac4_output_artifacts.py
  smoke_test_mac4_output_contract.py
  audit_lume_mac4_first_code_readiness.py
  smoke_test_mac4_first_code_readiness.py
  audit_lume_mac4_first_objective_completion.py
  smoke_test_mac4_first_objective_completion.py

Mac4-First Output Sidecars

As of 2026-06-06, first-capture bundle packaging emits Mac4-first read-only
output sidecars before Mac5 reconstruction runs:

derived/mac4_first/device_topology.json
derived/templates/gesture_templates.json
derived/enthea/bodytruth_control_map.json
derived/mrt2/control_map.json
derived/demon/request.json
derived/demon/control_curves.json

These are output contracts, not command permissions. They let Mac4 run
ENTHEA/Unity visuals and MRT2-style audio mappings from BodyTruth, and let
DEMON render heavier audio candidates later from CUDA/cloud. They do not send
Rekordbox commands, do not write back to BodyTruth, and do not bypass K11.
`derived/mac4_first/device_topology.json` makes the camera/device assignment
machine-verifiable: K11 owns local pose safety and Rekordbox/AirDeck command
authority, Mac4 owns read-only rich BodyTruth capture/fusion/visual/audio
lanes, and Mac5 waits behind the live Mac4-first gate.
Live Mac4 consumes the visual lane at `/visual` and the MRT2/Web MIDI lane at
`http://[ip]:9415/mrt2`; Mac5 should treat `derived/demon/request.json`
and `derived/demon/control_curves.json` as offline/heavy-render handoff inputs.
Mac4 also runs a receive-only CoreMIDI proof destination named
`LUME MRT2 Proof Sink` through `com.lume.mrt2-proof-sink`. This proves
MRT2-style CC output can land on a non-Rekordbox target before any DAW/MRT2
operator routing. It logs to
`[home-path]` and never sends notes,
keys, or Rekordbox commands.
The browser permission leg is separately proven by
`[home-path]`, written from the Mac4
`/mrt2` page through `/mrt2-proof`. Treat `proof_kind=endpoint_smoke` as
endpoint readiness only; treat `proof_kind=browser_web_midi_runtime` as the real
Chrome Web MIDI output-selection proof. As of 2026-06-10 this proof is generated
by the wrapper through CDP target WebSocket plus DOM/Input activation of the
page's own Connect MIDI control, not by large `Runtime.evaluate` script
injection.
When Mac4 comes back and SSH is reachable, Mac1 can sync the staged Mac4-first
service payload and run the Mac4-local read-only installer:

[home]/Desktop/MotionMix/multicam-server/bootstrap_mac4_first_local_services.sh --host mac4

If the staged Mac4-first files are already present on Mac4, install/start the
same services directly on Mac4 before the Mac1 completion gate:

bash [home-path] --run-probe

The bootstrap and installer stage the BodyTruth control plane, output bridge,
receive-only CoreMIDI proof sink, and local readiness probe, then write
`[home-path]`. It preserves
Mac4 as read-only and keeps K11 as the only Rekordbox/AirDeck command gate.

After a browser proof attempt, rerun the local readiness probe directly:

python3 [home-path]

It writes `[home-path]` and checks
local launchd services, BodyTruth, the output bridge, `/visual`, `/mrt2`, proof
sink status, and the browser proof without giving Mac4 command authority.

Sensor topology:

- K11 Pose Coach does not require a Femto/Bolt class depth camera. A simple UVC
webcam, UVC Arducam, or low-latency Insta360 feed is enough for local
pose/intent gating if it has a clear full-body/control-area view.
- Put richer capture on Mac4: Femto Bolt, Femto Mega, stereo/depth Arducam, or
two cameras at different body angles. Insta360 belongs here when it is used
for wide-angle recording, dewarping, or multi-view BodyTruth evidence. That
gives BodyTruth better depth, occlusion, and multi-view evidence for
visuals/audio mapping without giving Mac4 command authority.
- K11 can consume a distilled BodyTruth/safety signal from Mac4 later, but K11
remains the only Rekordbox/AirDeck command gate.

Verifier:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/verify_k11_mac4_output_artifacts.py \
  --bundle-dir <processed_bundle_dir>

The verifier checks schemas, derived-lane references, device topology,
read-only BodyTruth mode, and recursive safety flags such as `send_keys = false`,
`rekordbox_live_enabled = false`, and `live_control_eligible = false`.

DEMON handoff:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/prepare_demon_control_curve_handoff.py \
  --bundle-dir <processed_bundle_dir> \
  --output <processed_bundle_dir>/derived/demon/handoff_report.json

The handoff report marks bundles as `ready_for_offline_demon_render_handoff`
only after the bundle verifier passes, the DEMON request points at
`derived/demon/control_curves.json`, curve points are present, and all command
safety flags remain false.

Goal audit:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/audit_lume_mac4_first_goal.py

The goal audit now also checks the Mac4 CoreMIDI proof sink over SSH, sends one
test CC to `LUME MRT2 Proof Sink`, confirms the listener status counters, and
requires `[home-path]` to report
`proof_kind=browser_web_midi_runtime` for the receive-only proof sink. Use
`--skip-browser-proof` only for degraded diagnostics; it is not a completion
proof for the Mac4-first MRT2 lane.

Completion gate before Mac5 heavy reconstruction:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/run_lume_mac4_first_completion_gate.py \
  --output /tmp/lume_mac4_first_completion_gate_latest.json

This gate runs the Mac4 MRT2 live browser-proof wrapper first, then runs the
full Mac4-first audit with no skip flags. Mac5 heavy reconstruction is allowed
only when the gate report says `completion_ready=true` and
`mac5_heavy_reconstruction_allowed=true`. A degraded audit or a skipped wrapper
is diagnostic only.

Current green gate artifact:

[home]/Desktop/MotionMix/lume-wiring/lume_mac4_first_completion_gate_20260610T035207Z.json

This unlocks Mac5 dry-runs and prepares the first real reconstruction path. It
does not by itself create multi-view capture evidence. The first meaningful
heavy reconstruction run still needs a session bundle with at least K11 safety
evidence, one phone pose/camera view, and one external room-wide or Mac4 rich
camera view.

The gate now starts with a reachability preflight. It requires Mac4 TCP access
to SSH `:22`, BodyTruth `:9405`, and the output bridge `:9415` before it tries
the wrapper or full audit. If those ports are unavailable, it writes a fast red
report with `audit_status=skipped_by_reachability_preflight`.

Cheap reachability check only:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/run_lume_mac4_first_completion_gate.py \
  --preflight-only \
  --output /tmp/lume_mac4_first_preflight_latest.json

Watcher mode:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/watch_lume_mac4_first_completion_gate.py \
  --max-attempts 1 \
  --output /tmp/lume_mac4_first_completion_gate_latest.json \
  --watch-log /tmp/lume_mac4_first_completion_gate_watch.jsonl

Use `--max-attempts 0` only when intentionally watching until Mac4 is ready.
The watcher runs preflight attempts first; it invokes the full wrapper plus
audit only after SSH, BodyTruth, and output bridge ports are reachable.

Mac1 also has a periodic launchd monitor:

com.lume.mac4-first-completion-watch

Install or refresh it with:

Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/install_lume_mac4_first_completion_watch_launchagent.sh

The installer stages a launchd-safe runnable copy under
`[home-path]` so the background job does not need to open code from
`[home-path]`. It refreshes the watcher/gate/audit files, the local smoke-test
dependencies, the completion-gate/watcher/browser-proof smoke tests, the MRT2
browser-proof wrapper, and the Unity client files that the audit checks. The
LaunchAgent runs every 300 seconds, exits cleanly while the gate is simply
waiting, and writes:

/tmp/lume_mac4_first_completion_gate_latest.json
/tmp/lume_mac4_first_completion_gate_watch.jsonl
/tmp/lume.mac4-first-completion-watch.out
/tmp/lume.mac4-first-completion-watch.err

When Mac4 is offline, the latest JSON report is still useful. Its
`last_attempt.reachability_preflight` field carries the compact readiness
evidence: tailnet ping status, ping output tails, required TCP status for SSH
`:22`, BodyTruth `:9405`, output bridge `:9415`, optional TCP diagnostics, and
the failed-required-port list. This makes
`/tmp/lume_mac4_first_completion_gate_latest.json` the single
operator-readable readiness artifact.

Offline code-readiness audit:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/audit_lume_mac4_first_code_readiness.py \
  --output /tmp/lume_mac4_first_code_readiness_latest.json

Use this when Mac4/K11/Mac5 are offline and the right move is to keep the
system ready for reconnect. The audit checks source and staged tool files,
MRT2 wrapper/JS syntax, Unity BodyTruth client snapshots, LaunchAgent
installation state, latest monitor-report shape, K11-only/read-only safety
markers, source/staged compile, smoke coverage, and non-live goal-audit paths.
It can report `code_ready=true`, but it never claims live completion and never
allows Mac5 heavy reconstruction.

Objective completion audit:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/audit_lume_mac4_first_objective_completion.py \
  --output /tmp/lume_mac4_first_objective_completion_latest.json

This maps the full Mac4-first goal to evidence. It distinguishes three states:
local code readiness, live Mac4 proof, and Mac5 heavy-reconstruction allowance.
While Mac4 is unreachable it should report `waiting_for_live_mac4`, not
`complete`, even when `code_ready=true`.

Latest code-readiness result on 2026-06-07:

status: pass
code_ready: true
failure_count: 0
live_completion_claimed: false
mac5_heavy_reconstruction_allowed: false
report: /tmp/lume_mac4_first_code_readiness_latest.json
timestamp: 2026-06-07T17:43:43Z

Latest objective completion result on 2026-06-07:

status: waiting_for_live_mac4
code_ready: true
live_completion_ready: false
live_blocked: true
failure_count: 0
waiting_count: 2
mac5_heavy_reconstruction_allowed: false
report: /tmp/lume_mac4_first_objective_completion_latest.json
timestamp: 2026-06-07T17:43:57Z

Current gate result on 2026-06-07:

completion_ready: false
mac5_heavy_reconstruction_allowed: false
failed requirements:
  mac4_reachability:ssh
  mac4_reachability:bodytruth
  mac4_reachability:output_bridge

Latest launchd run wrote a fresh waiting report at `2026-06-07T17:34:14Z` and
exited with launchd `last exit code = 0`. The report now embeds the compact
preflight evidence and confirms that Mac4 Tailscale ping failed and required
TCP ports `:22`, `:9405`, and `:9415` are `closed_or_unreachable`. No Mac4
live proof was attempted or posted, and Mac5 heavy reconstruction remains
blocked.

The review-index builder now emits the non-live AirDeck handoff artifacts:

sam3d-review-index.json
sam3d-review-index.md
sam3d-gesture-candidate-library.json
sam3d-mapped-gesture-library.json
sam3d-approved-gesture-library.json
sam3d-dry-run-promotion-manifest.json
sam3d-capture-targets.json
sam3d-capture-session-plan.json
sam3d-capture-session-plan.md
sam3d-capture-session-plan.html
sam3d-recording-queue.json
sam3d-recording-queue.html
sam3d-gesture-training-library.json
sam3d-gesture-training-library.html
sam3d-promotion-readiness.json
sam3d-promotion-readiness.html
sam3d-approval-status.json
sam3d-approval-console.html
sam3d-review-decisions-template.json
sam3d-review.html

The mapped gesture library imports the K11 AirDeck `movement-library.json`
target catalog and maps SAM3D candidates by exact label only. Current returned
SAM3D candidates are all review-only labels, so `mapped_exact_count = 0`,
`review_only_count = 13`, `movement_target_count = 23`, and
`live_enabled_candidate_count = 0`. The dry-run promotion manifest is currently
empty until a human review decision export is provided.

When `sam3d-review-decisions.json` is fed back through
`build_k11_sam3d_review_index.py --decisions`, approved gestures are written
to `sam3d-approved-gesture-library.json`. That file remains non-live and can
hold visual-only approvals, target-selection-required approvals, or dry-run
eligible approvals. The dry-run manifest still sets `send_keys = false` and
requires a later live promotion manifest.

`sam3d-capture-targets.json` is the next-capture queue derived from AirDeck's
movement library. It currently has 23 non-live targets: 11 left deck, 11 right
deck, and one center safe-stop. The two hand-raise targets are existing camera
baselines that still need SAM3D reconstruction evidence; the other 21 targets
need labeled K11 rehearsal capture before promotion can even reach dry-run.

`sam3d-capture-session-plan.*` is the operator-facing expansion of that queue.
It currently writes 23 non-live capture sessions, 69 positive takes, 46 negative
takes, and an estimated 15.3 active capture minutes. The HTML plan is uploaded
to K11 beside `sam3d-review.html`, links back into the review surface, and keeps
the same safety contract: `send_keys = false`, Rekordbox live disabled, K11 as
the command gate.

`sam3d-recording-queue.*` is the take-by-take recording layer derived from the
capture-session plan. It expands the same 23 sessions into 115 rows: 69
positive gesture takes and 46 negative/no-op takes. Each row has a label stub,
operator prompt, gesture window, expected command/key or no-op expectation, and
keeps `send_keys = false` plus `live_enabled = false`. The generated HTML is
uploaded beside the review and capture-plan pages so K11 can use it as a
recording checklist without enabling Rekordbox control.

`sam3d-gesture-training-library.*` is the consolidated gesture vocabulary for
training and review. It turns the 23 capture targets into explicit non-live
gesture specs with deck side, active hand, hand policy, zone kind, motion role,
direction, command intent, expected command/key, positive cues, veto cues,
negative controls, capture queue rows, and SAM3D evidence status. Current
coverage is 11 left-deck specs, 11 right-deck specs, one center safe-stop, and
8 scratch/rewind or scratch/nudge saucer-zone specs. It is a training/review
library only: `send_keys = false`, `rekordbox_live_enabled = false`, and
`live_enabled_candidate_count = 0`.

`sam3d-promotion-readiness.*` is the explicit gate audit. It joins the review
index, approved gesture library, dry-run manifest, capture targets, recording
queue, and gesture training library into one readiness table. Current state:
23 rows, 21 `needs_labeled_capture`, two
`needs_sam3d_reconstruction_for_live_camera_baseline`, zero approvals, zero
dry-run items, and `zero_live_counter_check = true`. The page is linked from
all SAM3D operator surfaces and exists specifically to prove that nothing has
silently crossed the review/training boundary into live control.

The same files now carry the movement-library no-op controls used for training
robustness. K11's movement library contains 27 negative/no-op safety targets;
the builder attaches 92 relevant no-op controls across the 23 positive capture
sessions. Each session also carries a profile and annotation contract: deck
surface, active hand, hand policy, zone kind, motion direction, command intent,
positive cues, veto cues, and annotation tags.

Mac5 runtime location:

[home]/sandbox/lume-body-reconstruction/lume-sam3d-worker/
  process_session.py
  mac5_k11_bundle_worker.py

SAM3DBody backend:

[home]/sandbox/lume-body-reconstruction/SAM3DBody-cpp/
  build-mac-ort120/fast_sam_3dbody_run
  onnx-b1-fp32/pipeline.gguf
  onnx-b1-fp32/yolo.onnx

The existing `process_session.py` remains the per-frame backend runner. The new
Mac5 bundle worker wraps it at the bundle-contract layer and adds K11-compatible
outputs.

Bundle Contract

Input bundle schema:

lume.rehearsal_bundle.v1

Input request:

derived/sam3d/request.json
schema: lume.sam3d_request.v1

Returned outputs:

derived/sam3d/summary.json
derived/sam3d/sam3d_frames.jsonl
derived/sam3d/motion_windows.jsonl
derived/sam3d/template_candidates.json
derived/sam3d/worker.log
derived/sam3d/worker_result.json

`summary.json` is the authority for whether the backend really reconstructed a
frame. The worker never fabricates skeleton or mesh evidence. If a backend or
source video is missing, it writes an explicit placeholder status.

Important statuses:

complete
backend_ran_without_successful_reconstruction
skipped_no_usable_source_video
placeholder_backend_unavailable
backend_exception_explicit_placeholder

Verified Run

Command used from Mac1:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/orchestrate_k11_to_mac5.py \
  --max-frames 1 \
  --clean \
  --run-id codex-real-all-oneframe-20260531 \
  --frame-timeout 240 \
  --batch-timeout 700

Final audit:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/audit_k11_sam3d_returns.py

Full AirDeck artifact verifier:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/verify_k11_sam3d_airdeck_artifacts.py

Use the verifier instead of manually rechecking every JSON/HTML artifact. It
validates local and K11 copies together: schemas, cross-artifact counts, HTML
runtime wiring, approval/dry-run/readiness consistency, and the zero-live /
no-send-keys invariant.

Audit result:

bundle_count: 6
pass_count: 6
fail_count: 0

Latest Mac5 Offline Proof

Command executed from Mac1 on 2026-06-06 after the Mac4-first audit passed:

ssh mac5 'set -e
RUN_ID=codex-mac5-offline-proof-20260606-$(date +%H%M%S)
SRC=[home]/sandbox/lume-body-reconstruction/k11-bundle-stage/codex-real-all-oneframe-20260531/k11-route-smoke-insta360
DEST=[home]/sandbox/lume-body-reconstruction/k11-bundle-stage/$RUN_ID/k11-route-smoke-insta360
mkdir -p "$(dirname "$DEST")"
cp -R "$SRC" "$DEST"
python3 [home]/sandbox/lume-body-reconstruction/lume-sam3d-worker/mac5_k11_bundle_worker.py \
  --bundle-dir "$DEST" \
  --backend auto \
  --regular-sampling \
  --max-frames 1 \
  --timeout 240 \
  --batch-timeout 360 \
  --min-free-gb 5 \
  --clean'

Result:

run_id: codex-mac5-offline-proof-20260606-160638
bundle: k11-route-smoke-insta360
status: complete
placeholder: false
backend: SAM3DBody-cpp
frame_count_requested: 1
frame_count_processed: 1
frame_count_success: 1
sam3d_frames.jsonl rows: 1
motion_windows.jsonl rows: 3
template candidate count: 3
errors: []
command_authority: K11 AirDeck/Rekordbox bridge only
mac5_sends_rekordbox_commands: false
rekordbox_commands_sent: 0

Fresh Mac5 output directory:

[home]/sandbox/lume-body-reconstruction/k11-bundle-stage/codex-mac5-offline-proof-20260606-160638/k11-route-smoke-insta360/derived/sam3d

K11-dependent return/upload remains blocked until K11 SSH is reachable again.
The bounded probe used during this pass returned:

ssh: connect to host [ip] port 22: Operation timed out

Local AirDeck artifact verification also passed after the mirrored local
operator console and recording queue were repaired to link
`sam3d-recording-status.html` and agree with
`sam3d-recording-status.json`:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/verify_k11_sam3d_airdeck_artifacts.py \
  --local-only \
  --local-root [home-path]

Verified summary:

status: pass
failure_count: 0
bundles: 6
candidates: 13
gestures: 23
queue_items: 115
recording_status_missing: 115
live: 0
zero_live: true
operator_next_action: record_first_k11_capture_batch

Per-bundle status:

All six bundles have the expected `derived/sam3d` output files on K11.

Label-Window Fallback

The first Mac5 pass showed that label-window-only processing can starve a
bundle when `labels.jsonl` exists but has no usable `elapsed_sec` values. The
worker now records the requested sampling mode separately from the effective
sampling mode:

{
  "requested_label_windows_only": true,
  "effective_label_windows_only": false,
  "label_window_fallback_used": true,
  "fallback_reason": "no_usable_label_elapsed_times"
}

This does not weaken the evidence contract. It means the worker falls back to
regular video sampling instead of reporting a misleading empty label-window
result. The fallback is visible in `summary.json`, `motion_windows.jsonl`, and
the review index.

Targeted verification command:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/orchestrate_k11_to_mac5.py \
  --bundle tier0-recorder-push-validation \
  --max-frames 3 \
  --clean \
  --run-id codex-label-fallback-tier0-20260531 \
  --frame-timeout 240 \
  --batch-timeout 1000

Verified outcome:

tier0-recorder-push-validation
status: complete
frame_count_requested: 3
frame_count_processed: 3
frame_count_success: 3
template candidate: unlabeled_regular_sample

K11 Review Index

The reconstruction lane now writes a compact review index for Pose Coach,
AirDeck rehearsal, and human inspection:

C:\lume\dance-sessions\sam3d-review-index.json
C:\lume\dance-sessions\sam3d-review-index.md
C:\lume\dance-sessions\sam3d-gesture-candidate-library.json
C:\lume\dance-sessions\sam3d-capture-session-plan.json
C:\lume\dance-sessions\sam3d-capture-session-plan.md
C:\lume\dance-sessions\sam3d-recording-queue.json
C:\lume\dance-sessions\sam3d-gesture-training-library.json
C:\lume\dance-sessions\sam3d-promotion-readiness.json

Local mirrored copy:

[home-path]
[home-path]
[home-path]
[home-path]
[home-path]
[home-path]
[home-path]
[home-path]
[home-path]
[home-path]
[home-path]
[home-path]
[home-path]
[home-path]
[home-path]
[home-path]

Build command:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/build_k11_sam3d_review_index.py

Verified summary:

bundle_count: 6
ready_for_human_review_count: 5
needs_attention_count: 0
live_enabled_candidate_count: 0

Capture-session plan summary:

session_count: 23
target_count: 23
needs_capture_count: 21
live_baseline_needs_sam3d_count: 2
negative_movement_target_count: 27
attached_negative_control_count: 92
total_positive_takes: 69
total_negative_takes: 46
estimated_minutes: 15.3
live_enabled_candidate_count: 0

Recording queue summary:

schema: lume.airdeck.sam3d_recording_queue.v1
session_count: 23
queue_item_count: 115
positive_take_count: 69
negative_take_count: 46
live_enabled_candidate_count: 0

Gesture training library summary:

schema: lume.airdeck.sam3d_gesture_training_library.v1
gesture_count: 23
left_deck_count: 11
right_deck_count: 11
center_mixer_count: 1
scratch_or_rewind_count: 8
positive_take_count: 69
negative_take_count: 46
live_enabled_candidate_count: 0

Promotion readiness summary:

schema: lume.airdeck.sam3d_promotion_readiness.v1
gesture_count: 23
needs_labeled_capture: 21
needs_sam3d_reconstruction_for_live_camera_baseline: 2
approved_count: 0
dry_run_item_count: 0
zero_live_counter_check: true
live_enabled_candidate_count: 0

Approval handoff summary:

schema: lume.airdeck.sam3d_approval_status.v1
decision_count: 0
approved_count: 0
dry_run_item_count: 0
blocked_approved_count: 0
live_enabled_candidate_count: 0

Remote decisions intake is supported for K11-hosted review exports:

python3 Desktop/lume-commerce/viz/lume-pcloud/tools/lume-mac5-reconstruction/build_k11_sam3d_review_index.py \
  --remote-decisions 'C:\lume\airdeck-ui\sam3d-review-decisions.json'

The builder also writes `sam3d-review-decisions-template.json`, which lists the
current candidate IDs and target options for operator review. A synthetic
remote-ingestion smoke approved one current review-only candidate; the approved
gesture library accepted it, the dry-run manifest blocked it because there was
no AirDeck target, and every live counter remained zero.

The review index is evidence only. It does not promote any candidate to live
DJ control.

AirDeck Review UI

The generated AirDeck review surface is:

C:\lume\airdeck-ui\sam3d-review.html

It is linked from:

C:\lume\airdeck-ui\index.html
C:\lume\airdeck-ui\movement-library.html

The page shows:

• bundle readiness;
• candidate gesture labels;
• confidence and reconstruction-window counts;
• label-window fallback notes;
• SAM3D evidence frame rows;
• motion-window support;
• safety state;
• local approve/reject review decisions.
• link to the SAM3D capture-session plan.
• link to the SAM3D recording queue.
• link to the SAM3D gesture training library.
• link to the SAM3D promotion-readiness audit.
• link to the SAM3D approval console.

The generated HTML is no longer static-only. On K11 it first renders the
embedded generation snapshot, then attempts to fetch the sibling JSON artifacts
beside the page and re-render from those files. The review page fetches the
review index, candidate library, mapped library, approved library, dry-run
manifest, and capture targets. The capture plan, recording queue, gesture
training library, and approval console fetch their own JSON artifacts the same
way. Each page exposes a
`data: sibling JSON` / `data: embedded fallback` pill so the operator can see
which source is driving the page.

Review decisions export as:

lume.airdeck.sam3d_review_decisions.v1

Those decisions are still non-live. They are human review evidence, not a
Rekordbox command map.

The separate candidate-library artifact is:

lume.airdeck.sam3d_gesture_candidate_library.v1

It is deliberately non-live:

approved_count: 0
live_enabled_candidate_count: 0
requires_separate_promotion_manifest: true

Safety Invariants

The returned artifacts include explicit safety fields:

mac5_sends_rekordbox_commands: false
rekordbox_commands_sent: 0
command_authority: K11 AirDeck/Rekordbox bridge only
live_enabled_candidate_count: 0

Mac5 output is evidence for training, review, template discovery, and visual
reconstruction. It is not a command source.

Relationship To MAMMA / SMPL-X

The local verified backend is SAM3DBody-cpp. It produces per-frame CSV and BVH
evidence for K11 bundle artifacts.

MAMMA / SMPL-X compatibility remains a target for the same output lane, not a
verified local backend in this snapshot. A future MAMMA worker should write the
same bundle outputs and use `summary.json` to identify the backend honestly.

Do not document Mac5 as running MAMMA or SMPL-X until a local backend path,
model files, and run artifact are identified.

Next Engineering Step

The next step is to turn reviewed evidence into an explicit, still non-live
gesture-library promotion workflow:

map approved candidates onto AirDeck movement-library labels
decide whether BVH/CSV should be copied back to K11 or kept on Mac5 with references
generate a dry-run-only promotion manifest from approved review decisions
only after dry-run proof, generate a separate live-promotion manifest