Move Quest access ownership to Muninn

This commit is contained in:
Meta Vens 2026-06-12 16:41:15 +01:00
commit c1178512c4
9 changed files with 36 additions and 276 deletions

View file

@ -72,10 +72,9 @@ a named invariant that the native runtime cannot protect yet.
Quest headset/controller pose witnesses, stillness/sweep/validation phases, and
the four derived calibration outputs Mimir must produce before IMU
orientation can become authority.
- `MimirQuestUsbPreflight` publishes the typed USB witness receipt for an
authorized Quest. It proves ADB/device access and records the explicit
boundary that Quest headset/controller poses still require a Quest/OpenXR
witness bridge before they can become calibration evidence.
- Muninn publishes Quest access as `muninn.quest_access.v1` for the USB-attached
Quest. Mimir consumes that access surface and later `muninn.quest_pose_frame.v1`
samples as optional calibration evidence; Mimir does not own ADB/Quest access.
- `scripts/start-nightwing-move-tracking.ps1` is the narrow live Nightwing
bring-up path: it starts the `/eve/periwinkle` receiver/recorder on Starfire,
stages the Nightwing Eye/Move Python worker, keeps a heartbeat for field

View file

@ -42,28 +42,30 @@ lowers to local UDP for OBS compatibility.
7. `validation-pass`: held-out free motion; promote only if triangulated optical
residuals and IMU prediction residuals pass.
## Quest USB Preflight
## Quest Access Preflight
The Quest must be authorized for USB debugging before Starfire can query it.
Check it with:
The Quest must be authorized for USB debugging before Starfire Muninn can query
it. Muninn owns the access surface:
```powershell
adb devices -l
muninn serve --store C:\Meta\Odin\state\muninn.telemetry.cc --host starfire --quest-adb --quest-serial 1WMHHB68PG1515
```
If it reports `unauthorized`, put on the headset and accept the USB debugging
prompt. When it reports an authorized Quest, persist the USB witness receipt:
When the Quest is authorized, Muninn publishes `muninn.quest_access.v1` and
advertises `muninn:<host>:quest-input`, `muninn:<host>:quest-poses`, and
`muninn:<host>:quest-warped-video-input`. Mimir consumes the access/pose
surfaces as calibration evidence; it does not own Quest USB access.
```powershell
dotnet run --project .\src\Mimir.BufferSmoke\Mimir.BufferSmoke.csproj -- --quest-usb-preflight-smoke --output artifacts\move-calibration\quest-usb-preflight.cc
muninn quest-access-status --store C:\Meta\Odin\state\muninn.telemetry.cc
```
That writes `mimir.quest_usb_preflight.v1`. It proves USB access, device
identity, and basic headset state only. It does not expose Quest headset or
controller poses; those still require a Quest/OpenXR witness bridge that
publishes pose samples into Mimir's calibration capture. The current calibration
protocol can still run without Quest, but Quest poses are the preferred external
reference when the headset and both controllers are sitting around the Move.
ADB authorization proves USB access, device identity, and basic headset state
only. It does not expose Quest headset or controller poses; those still require
a Quest/OpenXR witness bridge that publishes pose samples through Muninn. The
current calibration protocol can still run without Quest, but Quest poses are
the preferred external reference when the headset and both controllers are
sitting around the Move.
## Data Products
@ -80,11 +82,9 @@ reference when the headset and both controllers are sitting around the Move.
```powershell
dotnet run --project .\src\Mimir.BufferSmoke\Mimir.BufferSmoke.csproj -- --move-calibration-protocol-smoke --output artifacts\move-calibration\protocol.cc
dotnet run --project .\src\Mimir.BufferSmoke\Mimir.BufferSmoke.csproj -- --quest-usb-preflight-smoke --output artifacts\move-calibration\quest-usb-preflight.cc
```
That writes the typed protocol as `mimir.move_calibration_protocol.v1` into a
CultCache receipt and writes the Quest USB preflight as
`mimir.quest_usb_preflight.v1` when the headset is authorized. The real hardware
runner should consume these documents and append capture receipts instead of
inventing a parallel checklist.
CultCache receipt. The real hardware runner should consume this document plus
Muninn's `muninn.quest_access.v1` when Quest is available, then append capture
receipts instead of inventing a parallel checklist.

View file

@ -14,7 +14,7 @@ job-interview answer for why it belongs in the body of the machine.
| Alignment actuator | `Mimir.Runtime` + Faust | Converts sync state into bounded fractional-delay, gain, and sample-rate-offset controls; Faust moves samples. | `src/Mimir.Runtime/Synchronization/MimirAudioAlignmentActuator.cs` |
| Audio actuator strategies | `Mimir.Runtime` + Faust | Integer baseline, Farrow fractional delay, variable ASRC, and hybrid delay/ASRC strategy profiles. | `src/Mimir.Runtime/Synchronization/MimirAudioActuatorConfiguration.cs` |
| CultMesh contracts | `Mimir.Runtime` | Typed codebook, decoder, acoustic path, actuator, program, Move evidence, and Mimir-fused Move controller pose documents for distributed Mimir nodes. | `src/Mimir.Runtime/Synchronization/MimirCultMeshContracts.cs`, `src/Mimir.Runtime/Synchronization/MimirTrackingObservation.cs` |
| Move controller fusion | `Mimir.Runtime` + native reservoir + Fensalir | Mimir admits Muninn marker candidates plus controller/IMU/button feeds into native `move_evidence` buffers. `MimirMoveCalibrationProtocol` defines the Starfire/Nightwing capture run, `MimirQuestUsbPreflight` records optional Quest USB witness availability without claiming pose capture, `MimirMoveFusion` publishes calibrated `mimir.move_controller_pose.v1` position/button/gyro poses only when camera witnesses are calibrated, and `MimirMovePoseStream` carries those poses over a realtime CultMesh frame. IMU orientation/prediction remains the next earned 6DoF step before Fensalir treats the stream as VR-grade controller input. | `src/Mimir.Runtime/Synchronization/MimirTrackingObservation.cs`, `src/Mimir.Runtime/Synchronization/MimirMuninnMoveEvidence.cs`, `src/Mimir.Runtime/Synchronization/MimirMoveCalibrationProtocol.cs`, `src/Mimir.Runtime/Synchronization/MimirQuestUsbPreflight.cs`, `src/Mimir.Runtime/Synchronization/MimirMoveFusion.cs`, `src/Mimir.Runtime/Synchronization/MimirMovePoseStream.cs`, `src/Mimir.Runtime/Synchronization/MimirNativeReservoirRuntime.cs`, `native/reservoir/src/lib.rs` |
| Move controller fusion | `Mimir.Runtime` + native reservoir + Fensalir | Mimir admits Muninn marker candidates plus controller/IMU/button feeds into native `move_evidence` buffers. `MimirMoveCalibrationProtocol` defines the Starfire/Nightwing capture run, Muninn records optional Quest USB witness availability as `muninn.quest_access.v1`, `MimirMoveFusion` publishes calibrated `mimir.move_controller_pose.v1` position/button/gyro poses only when camera witnesses are calibrated, and `MimirMovePoseStream` carries those poses over a realtime CultMesh frame. IMU orientation/prediction remains the next earned 6DoF step before Fensalir treats the stream as VR-grade controller input. | `src/Mimir.Runtime/Synchronization/MimirTrackingObservation.cs`, `src/Mimir.Runtime/Synchronization/MimirMuninnMoveEvidence.cs`, `src/Mimir.Runtime/Synchronization/MimirMoveCalibrationProtocol.cs`, `src/Mimir.Runtime/Synchronization/MimirMoveFusion.cs`, `src/Mimir.Runtime/Synchronization/MimirMovePoseStream.cs`, `src/Mimir.Runtime/Synchronization/MimirNativeReservoirRuntime.cs`, `native/reservoir/src/lib.rs` |
| Acoustic path learning | `Mimir.Runtime` | Calibration stages for usable bands, confusion, global delay, group delay, and codebook adaptation. | `src/Mimir.Runtime/Synchronization/MimirAcousticPathLearningConfiguration.cs` |
| Acoustic localization | `Mimir.Runtime` + Fensalir | Pairwise TDOA, SRP-PHAT grid, sparse source, and visual-constrained localization profiles plus a small SRP/TDOA scorer. | `src/Mimir.Runtime/Synchronization/MimirAcousticLocalizationConfiguration.cs`, `src/Mimir.Runtime/Synchronization/MimirAcousticLocalizationSolver.cs` |
| Benchmark panels | `Mimir.Runtime` | Decoder golf and meatspace acceptance degradation panels with receipt roots and thresholds. | `src/Mimir.Runtime/Synchronization/MimirBenchmarkPanelConfiguration.cs` |
@ -71,7 +71,6 @@ dotnet run --no-build --project .\src\Mimir.BufferSmoke\Mimir.BufferSmoke.csproj
dotnet run --no-build --project .\src\Mimir.BufferSmoke\Mimir.BufferSmoke.csproj -- --muninn-move-evidence-smoke --native-reservoir .\native\reservoir\target\debug\localcast_reservoir.dll
dotnet run --no-build --project .\src\Mimir.BufferSmoke\Mimir.BufferSmoke.csproj -- --muninn-move-cultmesh-stream-smoke --native-reservoir .\native\reservoir\target\debug\localcast_reservoir.dll
dotnet run --no-build --project .\src\Mimir.BufferSmoke\Mimir.BufferSmoke.csproj -- --move-calibration-protocol-smoke
dotnet run --no-build --project .\src\Mimir.BufferSmoke\Mimir.BufferSmoke.csproj -- --quest-usb-preflight-smoke
dotnet run --no-build --project .\src\Mimir.BufferSmoke\Mimir.BufferSmoke.csproj -- --move-fusion-smoke
dotnet run --no-build --project .\src\Mimir.BufferSmoke\Mimir.BufferSmoke.csproj -- --perfect-machine-manifest
dotnet run --no-build --project .\src\Mimir.BufferSmoke\Mimir.BufferSmoke.csproj -- --bioacoustic-actuator-self-test

View file

@ -147,15 +147,14 @@ Mimir to derive rig calibration, IMU calibration, controller identity mapping,
and a calibration receipt before orientation can stop being
`orientation:imu-unresolved`.
Quest USB preflight proof: `dotnet run --project
.\src\Mimir.BufferSmoke\Mimir.BufferSmoke.csproj --
--quest-usb-preflight-smoke --output
artifacts\move-calibration\quest-usb-preflight.cc` writes
`mimir.quest_usb_preflight.v1`. On 2026-06-12, `adb devices -l` reported
authorized Quest 2 device `1WMHHB68PG1515` with product/device `hollywood`.
This proves Starfire can query the headset over USB; it does not provide
Quest headset/controller poses until a Quest/OpenXR witness bridge publishes
those pose samples.
Quest USB access belongs to Muninn, not Mimir. Starfire Muninn runs with
`--quest-adb --quest-serial 1WMHHB68PG1515` and publishes
`muninn.quest_access.v1`, including stream ids for Quest input, Quest poses, and
warp-corrected video input from Brokkr/Unity. On 2026-06-12, `adb devices -l`
reported authorized Quest 2 device `1WMHHB68PG1515` with product/device
`hollywood`. This proves Starfire can query the headset over USB; it does not
provide Quest headset/controller poses until a Quest/OpenXR witness bridge
publishes those pose samples through Muninn.
Live Nightwing bring-up uses `scripts/start-nightwing-move-tracking.ps1`.
Starfire starts `Mimir.EveSensorReceiver` on `/eve/periwinkle`, stages

View file

@ -127,13 +127,6 @@ if (args.Any(arg => string.Equals(arg, "--move-calibration-protocol-smoke", Stri
.ConfigureAwait(false);
}
if (args.Any(arg => string.Equals(arg, "--quest-usb-preflight-smoke", StringComparison.OrdinalIgnoreCase)))
{
return await RunQuestUsbPreflightSmokeAsync(
ParseStringOption(args, "--output", "artifacts/move-calibration/quest-usb-preflight.cc"))
.ConfigureAwait(false);
}
if (args.Any(arg => string.Equals(arg, "--import-obs-program-scene", StringComparison.OrdinalIgnoreCase)))
{
return await ImportObsProgramSceneAsync(
@ -1918,172 +1911,6 @@ static async Task<int> RunMoveCalibrationProtocolSmokeAsync(string outputPath)
: 1;
}
static async Task<int> RunQuestUsbPreflightSmokeAsync(string outputPath)
{
var devices = await RunProcessCaptureAsync("adb", ["devices", "-l"]).ConfigureAwait(false);
if (devices.ExitCode != 0)
{
Console.Error.WriteLine($"quest-usb-preflight-smoke failed: adb devices exited {devices.ExitCode}: {devices.Stderr.Trim()}");
return 1;
}
var quest = FindAuthorizedQuestDevice(devices.Stdout);
if (quest is null)
{
Console.Error.WriteLine("quest-usb-preflight-smoke failed: no authorized Quest device found in adb devices -l");
Console.Error.WriteLine(devices.Stdout.Trim());
return 1;
}
var serial = quest.Value.Serial;
var fields = quest.Value.Fields;
var product = fields.GetValueOrDefault("product", "");
var model = fields.GetValueOrDefault("model", "");
var device = fields.GetValueOrDefault("device", "");
var transportId = fields.GetValueOrDefault("transport_id", "");
var androidRelease = await GetAdbPropertyAsync(serial, "ro.build.version.release").ConfigureAwait(false);
var androidSdk = await GetAdbPropertyAsync(serial, "ro.build.version.sdk").ConfigureAwait(false);
var buildFingerprint = await GetAdbPropertyAsync(serial, "ro.build.fingerprint").ConfigureAwait(false);
var batterySummary = await GetAdbBatterySummaryAsync(serial).ConfigureAwait(false);
var document = MimirQuestUsbPreflight.Create(
serial,
"device",
product,
model,
device,
transportId,
androidRelease,
androidSdk,
buildFingerprint,
batterySummary);
Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(outputPath)) ?? ".");
using var cache = await CultCacheMessagePack.OpenAsync(outputPath, new CultCacheOpenOptions
{
PullOnOpen = File.Exists(outputPath)
}).ConfigureAwait(false);
await cache.UpsertAsync(
document,
new CultRecordHandle<MimirQuestUsbPreflightDocument>(new CultRecordKey($"mimir-quest-usb-preflight:{document.Serial}")))
.ConfigureAwait(false);
await cache.FlushAsync().ConfigureAwait(false);
Console.WriteLine(
$"quest-usb-preflight-smoke path={outputPath} serial={document.Serial} model={document.Model} product={document.Product} android={document.AndroidRelease} sdk={document.AndroidSdk} pose={document.PoseCaptureStatus}");
return 0;
}
static (string Serial, Dictionary<string, string> Fields)? FindAuthorizedQuestDevice(string adbDevicesOutput)
{
foreach (var rawLine in adbDevicesOutput.Split(['\r', '\n'], StringSplitOptions.RemoveEmptyEntries))
{
var tokens = rawLine.Split(' ', StringSplitOptions.RemoveEmptyEntries);
if (tokens.Length < 2 || tokens[0] == "List" || !string.Equals(tokens[1], "device", StringComparison.Ordinal))
{
continue;
}
var fields = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var token in tokens.Skip(2))
{
var split = token.IndexOf(':');
if (split > 0 && split < token.Length - 1)
{
fields[token[..split]] = token[(split + 1)..];
}
}
var model = fields.GetValueOrDefault("model", "");
var product = fields.GetValueOrDefault("product", "");
if (model.Contains("Quest", StringComparison.OrdinalIgnoreCase) ||
product.Contains("hollywood", StringComparison.OrdinalIgnoreCase))
{
return (tokens[0], fields);
}
}
return null;
}
static async Task<string> GetAdbPropertyAsync(string serial, string property)
{
var result = await RunProcessCaptureAsync("adb", ["-s", serial, "shell", "getprop", property], 5_000).ConfigureAwait(false);
return result.ExitCode == 0 ? result.Stdout.Trim() : "";
}
static async Task<string> GetAdbBatterySummaryAsync(string serial)
{
var result = await RunProcessCaptureAsync("adb", ["-s", serial, "shell", "dumpsys", "battery"], 5_000).ConfigureAwait(false);
if (result.ExitCode != 0)
{
return "";
}
var usefulLines = result.Stdout.Split(['\r', '\n'], StringSplitOptions.RemoveEmptyEntries)
.Select(line => line.Trim())
.Where(line =>
line.StartsWith("AC powered:", StringComparison.OrdinalIgnoreCase) ||
line.StartsWith("USB powered:", StringComparison.OrdinalIgnoreCase) ||
line.StartsWith("Wireless powered:", StringComparison.OrdinalIgnoreCase) ||
line.StartsWith("status:", StringComparison.OrdinalIgnoreCase) ||
line.StartsWith("level:", StringComparison.OrdinalIgnoreCase) ||
line.StartsWith("scale:", StringComparison.OrdinalIgnoreCase) ||
line.StartsWith("voltage:", StringComparison.OrdinalIgnoreCase) ||
line.StartsWith("temperature:", StringComparison.OrdinalIgnoreCase))
.Take(12);
return string.Join(" | ", usefulLines);
}
static async Task<(int ExitCode, string Stdout, string Stderr)> RunProcessCaptureAsync(
string fileName,
IReadOnlyList<string> arguments,
int timeoutMilliseconds = 10_000)
{
using var process = new Process();
process.StartInfo = new ProcessStartInfo(fileName)
{
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false
};
foreach (var argument in arguments)
{
process.StartInfo.ArgumentList.Add(argument);
}
try
{
if (!process.Start())
{
return (-1, "", $"could not start {fileName}");
}
}
catch (Exception ex) when (ex is InvalidOperationException or System.ComponentModel.Win32Exception)
{
return (-1, "", $"could not start {fileName}: {ex.Message}");
}
var stdoutTask = process.StandardOutput.ReadToEndAsync();
var stderrTask = process.StandardError.ReadToEndAsync();
var waitTask = process.WaitForExitAsync();
var completed = await Task.WhenAny(waitTask, Task.Delay(timeoutMilliseconds)).ConfigureAwait(false);
if (completed != waitTask)
{
try
{
process.Kill(entireProcessTree: true);
}
catch (InvalidOperationException)
{
}
return (-1, await stdoutTask.ConfigureAwait(false), $"timed out after {timeoutMilliseconds} ms");
}
return (process.ExitCode, await stdoutTask.ConfigureAwait(false), await stderrTask.ConfigureAwait(false));
}
static MoveTrackingSmokeContext BuildMoveTrackingSmokeHub()
{
var starfireDescriptor = new MimirStreamDescriptor(

View file

@ -57,11 +57,10 @@ public static class MimirModuleLibrary
"move-controller-fusion",
"Mimir.Runtime + Fensalir",
"Mimir fuses Muninn marker candidates, controller IMU/button state, calibration, and timing into resolved wand poses, then publishes them as a realtime CultMesh pose stream for interaction consumers.",
["mimir.move_calibration_protocol.v1", "mimir.quest_usb_preflight.v1", "mimir.move_controller_pose.v1", "mimir.move_controller_pose_stream_frame.v1", "muninn.move_marker_candidate.v1", "muninn.move_controller_state.v1"],
["mimir.move_calibration_protocol.v1", "mimir.move_controller_pose.v1", "mimir.move_controller_pose_stream_frame.v1", "muninn.quest_access.v1", "muninn.quest_pose_frame.v1", "muninn.move_marker_candidate.v1", "muninn.move_controller_state.v1"],
[
"dotnet run --project .\\src\\Mimir.BufferSmoke\\Mimir.BufferSmoke.csproj -- --move-tracking-contract-smoke",
"dotnet run --project .\\src\\Mimir.BufferSmoke\\Mimir.BufferSmoke.csproj -- --move-calibration-protocol-smoke",
"dotnet run --project .\\src\\Mimir.BufferSmoke\\Mimir.BufferSmoke.csproj -- --quest-usb-preflight-smoke",
"dotnet run --project .\\src\\Mimir.BufferSmoke\\Mimir.BufferSmoke.csproj -- --move-fusion-smoke"
]),
new(

View file

@ -1,64 +0,0 @@
using GameCult.Caching;
using MessagePack;
namespace Mimir.Runtime.Synchronization;
[CultDocument("mimir.quest_usb_preflight", "mimir.quest_usb_preflight.v1")]
[MessagePackObject]
public sealed record MimirQuestUsbPreflightDocument(
[property: Key(0)]
[property: CultName]
string PreflightId,
[property: Key(1)] string CapturedAtUtc,
[property: Key(2)] string Serial,
[property: Key(3)] string ConnectionState,
[property: Key(4)] string Product,
[property: Key(5)] string Model,
[property: Key(6)] string Device,
[property: Key(7)] string TransportId,
[property: Key(8)] string AndroidRelease,
[property: Key(9)] string AndroidSdk,
[property: Key(10)] string BuildFingerprint,
[property: Key(11)] string BatterySummary,
[property: Key(12)] string PoseCaptureStatus,
[property: Key(13)] string RequiredNextStep,
[property: Key(14)] string[] OperatorNotes);
public static class MimirQuestUsbPreflight
{
public const string AuthorizedNoPoseBridgeStatus = "usb-authorized-no-pose-bridge-yet";
public static MimirQuestUsbPreflightDocument Create(
string serial,
string connectionState,
string product,
string model,
string device,
string transportId,
string androidRelease,
string androidSdk,
string buildFingerprint,
string batterySummary,
DateTimeOffset? capturedAt = null) =>
new(
PreflightId: $"quest-usb:{serial}",
CapturedAtUtc: (capturedAt ?? DateTimeOffset.UtcNow).ToString("O"),
Serial: serial,
ConnectionState: connectionState,
Product: product,
Model: model,
Device: device,
TransportId: transportId,
AndroidRelease: androidRelease,
AndroidSdk: androidSdk,
BuildFingerprint: buildFingerprint,
BatterySummary: batterySummary,
PoseCaptureStatus: AuthorizedNoPoseBridgeStatus,
RequiredNextStep: "Run or deploy a Quest/OpenXR witness that publishes headset and controller poses into the Mimir calibration capture.",
OperatorNotes:
[
"ADB authorization proves Starfire can query the Quest over USB; it does not expose tracked headset/controller poses by itself.",
"Do not disturb the headset runtime from this preflight. Pose capture belongs to an explicit Quest/OpenXR witness bridge.",
"Mimir may use Quest poses as optional external validation evidence, but Mimir still owns Move calibration and fusion promotion."
]);
}

View file

@ -138,3 +138,4 @@
{"ts": "2026-06-12T14:45:00+01:00", "type": "implementation", "status": "ok", "note": "Added typed Move calibration preflight state as mimir.move_calibration_protocol.v1. BufferSmoke --move-calibration-protocol-smoke writes artifacts/move-calibration/protocol.cc and proves the Starfire/Nightwing protocol requires both Muninn Move evidence streams plus Mimir pose output, includes optional Periwinkle motion/camera witnesses, defines stillness/sweep/validation phases, and names the four required derived outputs before IMU orientation can become authority."}
{"ts": "2026-06-12T15:05:00+01:00", "type": "correction", "status": "ok", "note": "Updated the Move calibration preflight witness from Periwinkle to the USB-connected Quest headset plus left/right controllers. ADB sees serial 1WMHHB68PG1515 but reports unauthorized, so headset-side USB debugging approval is required before Quest pose capture can become live evidence. The protocol treats Quest poses as an optional external VR reference frame around the Move, not as a Mimir fusion owner."}
{"ts":"2026-06-12T15:17:22.2571251+01:00","type":"verification","status":"ok","note":"Quest USB access is now authorized for calibration preflight: adb devices -l reports serial 1WMHHB68PG1515 as Quest_2/hollywood. Added and ran --quest-usb-preflight-smoke, which wrote mimir.quest_usb_preflight.v1 with poseCaptureStatus=usb-authorized-no-pose-bridge-yet. ADB access proves USB/device identity only; headset/controller pose samples still require a Quest/OpenXR witness bridge before Mimir can use Quest as external calibration evidence."}
{"ts":"2026-06-12T16:05:00+01:00","type":"correction","status":"ok","note":"Moved Quest access ownership out of Mimir and under Odin/Muninn. Mimir's local mimir.quest_usb_preflight path was deleted; Mimir now treats muninn.quest_access.v1 and later muninn.quest_pose_frame.v1 as input evidence. Brokkr owns Unity editor routing for Quest input/pose consumption and warp-corrected Unity play-mode video toward Muninn's Quest video input surface."}

View file

@ -118,10 +118,10 @@ accepted_design:
optional Quest headset/controller pose witnesses over USB,
stillness/sweep/validation phases, and the calibration outputs Mimir must
derive before orientation can stop being `orientation:imu-unresolved`.
- `MimirQuestUsbPreflight` defines the typed Quest USB witness receipt. It
proves ADB authorization/device identity for the optional external VR
reference, but it explicitly does not claim Quest headset/controller pose
capture until a Quest/OpenXR witness bridge publishes those samples.
- Muninn owns Quest USB access as `muninn.quest_access.v1`. It proves ADB
authorization/device identity for the optional external VR reference and
advertises Quest input, pose, and warped-video input stream ids. Mimir
consumes those surfaces for calibration; it does not publish Quest access.
- Starfire should have Muninn for source-local Move HID control and local
sensor publication, but some Starfire audio/video paths still enter Mimir
through local Mimir producers or diagnostic process bridges while native