From 2d83ad07fc10bf04cc2760d34b3d38b1bf4467dc Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Sun, 24 May 2026 17:09:48 +0100 Subject: [PATCH] Add authority policy evaluator --- docs/perfect-machine-module-library.md | 2 + src/Mimir.BufferSmoke/Program.cs | 7 ++ .../MimirAuthorityPolicyEvaluator.cs | 70 +++++++++++++++++++ 3 files changed, 79 insertions(+) create mode 100644 src/Mimir.Runtime/Synchronization/MimirAuthorityPolicyEvaluator.cs diff --git a/docs/perfect-machine-module-library.md b/docs/perfect-machine-module-library.md index a592eb1..1855e0b 100644 --- a/docs/perfect-machine-module-library.md +++ b/docs/perfect-machine-module-library.md @@ -21,6 +21,8 @@ job-interview answer for why it belongs in the body of the machine. | Camera ingest strategies | `Mimir.Runtime` + native workers | Diagnostic metadata, managed native wrapper, native SPSC ring, and shared-GPU-texture ingest shapes. | `src/Mimir.Runtime/Synchronization/MimirCameraIngestConfiguration.cs` | | Reservoir strategies | `Mimir.Runtime` + native reservoir + Fensalir | Managed rolling buffers, native shared-edge rings, and derived GPU temporal field storage. | `src/Mimir.Runtime/Synchronization/MimirReservoirConfiguration.cs` | | Distributed witnesses | `Mimir.Runtime` + CultMesh | Raven, phone, microcontroller, and remote camera rig configurations for compact timing/path state. | `src/Mimir.Runtime/Synchronization/MimirDistributedWitnessConfiguration.cs` | +| Network transports | `Mimir.Runtime` + CultMesh | Typed timing state, debug windows, SRT bridge media, and experimental browser transport policy. | `src/Mimir.Runtime/Synchronization/MimirNetworkTransportConfiguration.cs` | +| Authority policy | `Mimir.Runtime` | Trust decisions for Starfire loopback, Raven evidence, phone candidates, diagnostic media, and unknown nodes. | `src/Mimir.Runtime/Synchronization/MimirAuthorityPolicyConfiguration.cs`, `src/Mimir.Runtime/Synchronization/MimirAuthorityPolicyEvaluator.cs` | | Audio field configurations | `Mimir.Runtime` | Six-mic, source-based, ambisonic, and hybrid evidence field shapes. | `src/Mimir.Runtime/Synchronization/MimirAudioFieldConfiguration.cs` | | Visual fusion configurations | `Mimir.Runtime` + Fensalir | Sensor roles and fusion modes from cadence proof through full hybrid evidence. | `src/Mimir.Runtime/Synchronization/MimirVisualFusionConfiguration.cs` | | Compute offload configurations | `Mimir.Runtime` + CultMesh | Local-heavy, distributed witness, and calibration sweep workload placement. | `src/Mimir.Runtime/Synchronization/MimirComputeOffloadConfiguration.cs` | diff --git a/src/Mimir.BufferSmoke/Program.cs b/src/Mimir.BufferSmoke/Program.cs index d7f1969..d8c8402 100644 --- a/src/Mimir.BufferSmoke/Program.cs +++ b/src/Mimir.BufferSmoke/Program.cs @@ -958,6 +958,10 @@ static int RunPerfectMachineProfileSmoke() [ new MimirPairDelayObservation("mic-left", "mic-right", 0.0, 0.95) ]); + var authority = new MimirAuthorityPolicyEvaluator().Evaluate(new MimirAuthorityEvaluationInput( + "raven-scarlett-witness", + new HashSet(["known-node", "matching-codebook", "clock-fit-confidence", "response-profile"], StringComparer.Ordinal), + new HashSet(StringComparer.Ordinal))); Console.WriteLine( $"perfect-machine-profile-smoke profiles={profiles.Count} calibrationPlans={calibrationPlans.Count} audioFields={audioFields.Count} visualFields={visualFields.Count} computePlans={computePlans.Count} assemblyPlans={assemblyPlans.Count} captureProfiles={captureProfiles.Count} publications={publications.Count} languageProfiles={languageProfiles.Count} pathLearning={pathLearningProfiles.Count} localization={localizationProfiles.Count} benchmarkPanels={benchmarkPanels.Count} actuatorStrategies={actuatorStrategies.Count} cameraIngest={cameraIngestStrategies.Count} reservoirs={reservoirStrategies.Count} distributedWitnesses={distributedWitnesses.Count} networkTransports={networkTransports.Count} authorityPolicies={authorityPolicies.Count} modules={moduleCatalog.Count}"); @@ -971,6 +975,8 @@ static int RunPerfectMachineProfileSmoke() $"perfect-machine-fensalir gpuCameras={gpuFrame.Cameras.Count} gpuTextures={gpuFrame.ExternalTextures.Count} acousticConstraints={acousticFrame.Constraints.Count} timingConfidence={acousticFrame.TimingConfidence:0.000}"); Console.WriteLine( $"perfect-machine-localization candidates={localizationGrid.Count} best=({localization?.PositionMeters.X ?? float.NaN:0.000},{localization?.PositionMeters.Y ?? float.NaN:0.000},{localization?.PositionMeters.Z ?? float.NaN:0.000}) score={localization?.Score ?? 0.0:0.000}"); + Console.WriteLine( + $"perfect-machine-authority appliesTo=raven-scarlett-witness decision={authority.Decision} rule={authority.RuleId}"); return profiles.Count >= 6 && calibrationPlans.Count >= 3 && @@ -997,6 +1003,7 @@ static int RunPerfectMachineProfileSmoke() gpuFrame.HasInput && acousticFrame.HasInput && localization is { Score: > 0.90 } && + authority.Decision == MimirAuthorityDecision.TrustedEvidence && clock is { AnchorCount: >= 4, Confidence: > 0.70 } ? 0 : 1; diff --git a/src/Mimir.Runtime/Synchronization/MimirAuthorityPolicyEvaluator.cs b/src/Mimir.Runtime/Synchronization/MimirAuthorityPolicyEvaluator.cs new file mode 100644 index 0000000..4632332 --- /dev/null +++ b/src/Mimir.Runtime/Synchronization/MimirAuthorityPolicyEvaluator.cs @@ -0,0 +1,70 @@ +namespace Mimir.Runtime.Synchronization; + +public sealed record MimirAuthorityEvaluationInput( + string AppliesTo, + IReadOnlySet Evidence, + IReadOnlySet Conditions); + +public sealed record MimirAuthorityEvaluationResult( + MimirAuthorityDecision Decision, + string RuleId, + string Notes); + +public sealed class MimirAuthorityPolicyEvaluator(MimirAuthorityPolicyConfiguration? policy = null) +{ + private readonly MimirAuthorityPolicyConfiguration policy = policy ?? MimirAuthorityPolicyConfigurations.DefaultTimingPolicy; + + public MimirAuthorityEvaluationResult Evaluate(MimirAuthorityEvaluationInput input) + { + MimirAuthorityRule? wildcard = null; + foreach (var rule in policy.Rules) + { + if (rule.AppliesTo == "*") + { + wildcard ??= rule; + continue; + } + + if (!string.Equals(rule.AppliesTo, input.AppliesTo, StringComparison.Ordinal)) + { + continue; + } + + if (RuleMatches(rule, input)) + { + return new MimirAuthorityEvaluationResult(rule.Decision, rule.Id, rule.Notes); + } + } + + if (wildcard != null && RuleMatches(wildcard, input)) + { + return new MimirAuthorityEvaluationResult(wildcard.Decision, wildcard.Id, wildcard.Notes); + } + + return new MimirAuthorityEvaluationResult( + MimirAuthorityDecision.ObserveOnly, + "default-observe-only", + "No trust rule matched; preserve observation without authority."); + } + + private static bool RuleMatches(MimirAuthorityRule rule, MimirAuthorityEvaluationInput input) + { + foreach (var forbidden in rule.ForbiddenConditions) + { + if (input.Conditions.Contains(forbidden)) + { + return false; + } + } + + foreach (var required in rule.RequiredEvidence) + { + if (!input.Evidence.Contains(required)) + { + return false; + } + } + + return true; + } +}