Add Fensalir daemon Eve surface

This commit is contained in:
Meta Vens 2026-06-02 17:43:30 +01:00
commit 85459184f5
9 changed files with 1096 additions and 0 deletions

View file

@ -6,6 +6,7 @@
<Project Path="src/Mimir.EveDialogue/Mimir.EveDialogue.csproj" />
<Project Path="src/Mimir.EveDashboard/Mimir.EveDashboard.csproj" />
<Project Path="src/Mimir.EveSensorReceiver/Mimir.EveSensorReceiver.csproj" />
<Project Path="src/Mimir.FensalirDaemon/Mimir.FensalirDaemon.csproj" />
<Project Path="src/Mimir.Well/Mimir.Well.csproj" />
<Project Path="src/Mimir.WellObsDaemon/Mimir.WellObsDaemon.csproj" />
<Project Path="src/Mimir.VerseRecorder/Mimir.VerseRecorder.csproj" />

View file

@ -50,3 +50,36 @@ The remaining gap is real: Fensalir still lacks a flat program-layer video
backend that draws Fensalir-owned camera texture leases as 2D synced layers.
That backend is separate from the reservoir daemon. Build it as the editor's
presentation path; do not smuggle it through field diagnostics.
## Current Daemon Cut
`src/Mimir.FensalirDaemon` is the first owner-shaped daemon:
- eats CultCache through `state/fensalir-daemon.ccmp`, using the canonical
MessagePack CultCache backing store;
- drinks Well JSONL logs containing `mimir.well_snapshot.v1`,
`mimir.well_capture_page.v1`, and `mimir.well_stream_pressure.v1`;
- publishes typed `mimir.fensalir_daemon_state.v1` state;
- speaks a CultNet-shaped WebSocket Eve provider at `/eve/deck`;
- speaks binary CultMesh dashboard documents at `/eve/deck/cultmesh`;
- exposes `/health` and `/eve/deck/manifest`;
- presents a retained `cultmesh.eve_surface.v0` surface with compact text and
metrics that Eve GUI and Odin/Nightwing TUI can lower.
Start it with:
```powershell
powershell -ExecutionPolicy Bypass -File .\scripts\start-fensalir-daemon.ps1
```
The launcher writes a supervisor manifest under
`artifacts/runtime/fensalir-daemon-*` with provider specs:
```text
mimir-fensalir-daemon|Mimir Fensalir Daemon|ws://127.0.0.1:8799/eve/deck
mimir-fensalir-daemon|Mimir Fensalir Daemon|ws://127.0.0.1:8799/eve/deck/cultmesh
```
The current worker mode is `surface-owner-installed`: kernel scheduling,
GPU-resident reservoir compute, and actual fused program-surface publication
belong behind this daemon next. Do not move those back into the editor.

View file

@ -36,6 +36,13 @@ video compositor/control surface and must stay responsive even while the
reservoir worker is absent, paused, or saturated. Field diagnostics, Leap
surface splats, spectrum tubes, and reservoir proof visuals are opt-in
diagnostics or daemon outputs, not default editor presentation.
`Mimir.FensalirDaemon` is now the first daemon-shaped owner for that path: it
tails Well documents, persists `mimir.fensalir_daemon_state.v1` into
CultCache, exposes `/health`, and serves JSON plus binary CultMesh
`mimir.eve_dashboard_state.v1` Eve surfaces at `/eve/deck` and
`/eve/deck/cultmesh`. The current worker mode is deliberately
`surface-owner-installed`; dense GPU kernels and fused program output belong
behind this daemon next.
Any path that only paints pixels is not the spatiotemporal machine, but the
editor still needs a real flat video compositor backend. The current

View file

@ -0,0 +1,83 @@
param(
[string]$WellLog = "",
[string]$CultCache = "",
[int]$Port = 8799,
[int]$PollMs = 100,
[double]$GpuBudget = 0.50,
[double]$CpuBudget = 0.25,
[switch]$NoBuild,
[switch]$FromStart
)
$ErrorActionPreference = "Stop"
$repo = Resolve-Path (Join-Path $PSScriptRoot "..")
$project = Join-Path $repo "src\Mimir.FensalirDaemon\Mimir.FensalirDaemon.csproj"
if (-not $NoBuild) {
dotnet build $project | Out-Host
}
if ([string]::IsNullOrWhiteSpace($CultCache)) {
$CultCache = Join-Path $repo "state\fensalir-daemon.ccmp"
}
if ([string]::IsNullOrWhiteSpace($WellLog)) {
$runtimeRoot = Join-Path $repo "artifacts\runtime"
if (Test-Path $runtimeRoot) {
$WellLog = Get-ChildItem -Path $runtimeRoot -Recurse -File -Include *.log,*.jsonl |
Where-Object { $_.Length -gt 0 } |
Sort-Object LastWriteTimeUtc -Descending |
Where-Object {
try {
Select-String -Path $_.FullName -Pattern 'mimir\.well_' -Quiet -ErrorAction Stop
} catch {
$false
}
} |
Select-Object -First 1 -ExpandProperty FullName
}
}
$runId = Get-Date -Format "yyyyMMdd-HHmmss"
$runDir = Join-Path $repo "artifacts\runtime\fensalir-daemon-$runId"
New-Item -ItemType Directory -Force -Path $runDir | Out-Null
$stdout = Join-Path $runDir "fensalir-daemon.out.log"
$stderr = Join-Path $runDir "fensalir-daemon.err.log"
$manifest = Join-Path $runDir "supervisor.json"
$dll = Join-Path $repo "src\Mimir.FensalirDaemon\bin\Debug\net10.0\Mimir.FensalirDaemon.dll"
$arguments = @(
$dll,
"--port", $Port,
"--cultcache", $CultCache,
"--poll-ms", $PollMs,
"--gpu-budget", $GpuBudget.ToString([Globalization.CultureInfo]::InvariantCulture),
"--cpu-budget", $CpuBudget.ToString([Globalization.CultureInfo]::InvariantCulture)
)
if (-not [string]::IsNullOrWhiteSpace($WellLog)) {
$arguments += @("--well-log", $WellLog)
}
if ($FromStart) {
$arguments += "--from-start"
}
$process = Start-Process -FilePath "dotnet" -ArgumentList $arguments -WorkingDirectory $repo -RedirectStandardOutput $stdout -RedirectStandardError $stderr -PassThru -WindowStyle Hidden
[pscustomobject]@{
daemon = "Mimir.FensalirDaemon"
pid = $process.Id
port = $Port
wellLog = $WellLog
cultCache = $CultCache
providerSpec = "mimir-fensalir-daemon|Mimir Fensalir Daemon|ws://127.0.0.1:$Port/eve/deck"
cultMeshProviderSpec = "mimir-fensalir-daemon|Mimir Fensalir Daemon|ws://127.0.0.1:$Port/eve/deck/cultmesh"
stdout = $stdout
stderr = $stderr
started = (Get-Date).ToString("o")
} | ConvertTo-Json | Set-Content -Path $manifest -Encoding UTF8
Write-Host "Started Mimir.FensalirDaemon PID $($process.Id)"
Write-Host "Health: http://127.0.0.1:$Port/health"
Write-Host "Eve provider: mimir-fensalir-daemon|Mimir Fensalir Daemon|ws://127.0.0.1:$Port/eve/deck"
Write-Host "Manifest: $manifest"

View file

@ -0,0 +1,17 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net10.0</TargetFramework>
<AssemblyName>Mimir.FensalirDaemon</AssemblyName>
<RootNamespace>Mimir.FensalirDaemon</RootNamespace>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\Mimir.Runtime\Mimir.Runtime.csproj" />
<ProjectReference Include="..\..\..\CultLib\src\GameCult.Caching.MessagePack\GameCult.Caching.MessagePack.csproj" />
</ItemGroup>
</Project>

View file

@ -0,0 +1,923 @@
using System.Globalization;
using System.Net;
using System.Net.Sockets;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using GameCult.Caching;
using GameCult.Caching.MessagePack;
using MessagePack;
using Mimir.Runtime.Synchronization;
var options = FensalirDaemonOptions.Parse(args);
Directory.CreateDirectory(Path.GetDirectoryName(options.CultCachePath) ?? ".");
await using var state = await FensalirDaemonState.OpenAsync(options).ConfigureAwait(false);
using var server = new FensalirDaemonEveServer(options, state);
using var stopping = new CancellationTokenSource();
Console.CancelKeyPress += (_, eventArgs) =>
{
eventArgs.Cancel = true;
stopping.Cancel();
};
Console.Error.WriteLine($"Mimir Fensalir daemon drinking Well from {options.WellLogPath}");
Console.Error.WriteLine($"Mimir Fensalir daemon state cache {options.CultCachePath}");
Console.Error.WriteLine($"Mimir Fensalir daemon speaking Eve/CultMesh on ws://0.0.0.0:{options.Port}/eve/deck");
var serveTask = server.RunAsync(stopping.Token);
await state.RunAsync(stopping.Token).ConfigureAwait(false);
await serveTask.ConfigureAwait(false);
return 0;
internal sealed record FensalirDaemonOptions(
string DaemonId,
string VerseId,
string WellLogPath,
string CultCachePath,
int Port,
int PollMs,
int StatusSeconds,
double GpuBudget,
double CpuBudget,
bool FromStart,
bool Once)
{
public static FensalirDaemonOptions Parse(IReadOnlyList<string> args)
{
var runtimeRoot = Path.Combine(RepoRoot(), "artifacts", "runtime");
var defaultCache = Path.Combine(RepoRoot(), "state", "fensalir-daemon.ccmp");
return new FensalirDaemonOptions(
ParseString(args, "--daemon-id", "mimir-fensalir-daemon"),
ParseString(args, "--verse-id", "mimir.local"),
ParseString(args, "--well-log", FindLatestWellLog(runtimeRoot)),
ParseString(args, "--cultcache", defaultCache),
Math.Clamp(ParseInt(args, "--port", 8799), 1024, 65535),
Math.Max(10, ParseInt(args, "--poll-ms", 100)),
Math.Max(1, ParseInt(args, "--status-seconds", 5)),
Math.Clamp(ParseDouble(args, "--gpu-budget", 0.50), 0.0, 1.0),
Math.Clamp(ParseDouble(args, "--cpu-budget", 0.25), 0.0, 1.0),
ParseBool(args, "--from-start", false),
ParseBool(args, "--once", false));
}
private static string RepoRoot()
{
var current = new DirectoryInfo(AppContext.BaseDirectory);
for (var i = 0; i < 8; i++)
{
if (File.Exists(Path.Combine(current.FullName, "Mimir.slnx")))
{
return current.FullName;
}
if (current.Parent == null)
{
break;
}
current = current.Parent;
}
return Directory.GetCurrentDirectory();
}
private static string FindLatestWellLog(string runtimeRoot)
{
if (!Directory.Exists(runtimeRoot))
{
return "";
}
return Directory.EnumerateFiles(runtimeRoot, "*.log", SearchOption.AllDirectories)
.Concat(Directory.EnumerateFiles(runtimeRoot, "*.jsonl", SearchOption.AllDirectories))
.Select(static path => new FileInfo(path))
.Where(static info => info.Length > 0)
.OrderByDescending(static info => info.LastWriteTimeUtc)
.Take(128)
.Select(static info => info.FullName)
.FirstOrDefault(ContainsWellDocument) ?? "";
}
private static bool ContainsWellDocument(string path)
{
try
{
return DaemonUtil.TailTextFile(path, 128 * 1024).Contains("mimir.well_", StringComparison.Ordinal);
}
catch
{
return false;
}
}
private static string ParseString(IReadOnlyList<string> args, string name, string fallback)
{
for (var index = 0; index < args.Count; index++)
{
if (string.Equals(args[index], name, StringComparison.OrdinalIgnoreCase) && index + 1 < args.Count)
{
return args[index + 1];
}
if (args[index].StartsWith(name + "=", StringComparison.OrdinalIgnoreCase))
{
return args[index][(name.Length + 1)..];
}
}
return fallback;
}
private static int ParseInt(IReadOnlyList<string> args, string name, int fallback) =>
int.TryParse(ParseString(args, name, ""), NumberStyles.Integer, CultureInfo.InvariantCulture, out var value) ? value : fallback;
private static double ParseDouble(IReadOnlyList<string> args, string name, double fallback) =>
double.TryParse(ParseString(args, name, ""), NumberStyles.Float, CultureInfo.InvariantCulture, out var value) ? value : fallback;
private static bool ParseBool(IReadOnlyList<string> args, string name, bool fallback)
{
for (var index = 0; index < args.Count; index++)
{
if (!string.Equals(args[index], name, StringComparison.OrdinalIgnoreCase))
{
continue;
}
if (index + 1 >= args.Count || args[index + 1].StartsWith("--", StringComparison.Ordinal))
{
return true;
}
return bool.TryParse(args[index + 1], out var value) ? value : fallback;
}
return fallback;
}
}
internal sealed class FensalirDaemonState : IAsyncDisposable
{
private readonly FensalirDaemonOptions options;
private readonly CultCache cache;
private readonly CultRecordHandle<MimirFensalirDaemonStateDocument> handle;
private readonly WellLogTailState tail;
private readonly object gate = new();
private MimirFensalirDaemonStateDocument document;
private DateTimeOffset lastStatus = DateTimeOffset.MinValue;
private FensalirDaemonState(
FensalirDaemonOptions options,
CultCache cache,
CultRecordHandle<MimirFensalirDaemonStateDocument> handle,
MimirFensalirDaemonStateDocument document)
{
this.options = options;
this.cache = cache;
this.handle = handle;
this.document = document;
tail = new WellLogTailState(options.WellLogPath, options.FromStart);
}
public MimirFensalirDaemonStateDocument Document
{
get
{
lock (gate)
{
return document;
}
}
}
public static async Task<FensalirDaemonState> OpenAsync(FensalirDaemonOptions options)
{
var cache = await CultCacheMessagePack.OpenAsync(options.CultCachePath, new CultCacheOpenOptions
{
UseDirectoryStore = true,
FlushOnDispose = true,
StoreFlushOnDispose = true,
}).ConfigureAwait(false);
var key = new CultRecordKey(options.DaemonId);
var existing = cache.Get<MimirFensalirDaemonStateDocument>(key);
var document = existing ?? BuildInitialDocument(options);
var handle = await cache.UpsertAsync(document, new CultRecordHandle<MimirFensalirDaemonStateDocument>(key)).ConfigureAwait(false);
await cache.FlushAsync().ConfigureAwait(false);
return new FensalirDaemonState(options, cache, handle, document);
}
public async Task RunAsync(CancellationToken stopping)
{
while (!stopping.IsCancellationRequested)
{
var touched = false;
foreach (var json in tail.ReadNewDocuments())
{
using var _ = json;
if (TryDrink(json.RootElement, out var next))
{
lock (gate)
{
document = next;
}
touched = true;
}
}
if (touched)
{
await cache.UpsertAsync(document, handle).ConfigureAwait(false);
await cache.FlushAsync(soft: true).ConfigureAwait(false);
if (options.Once)
{
return;
}
}
if (DateTimeOffset.UtcNow - lastStatus >= TimeSpan.FromSeconds(options.StatusSeconds))
{
lastStatus = DateTimeOffset.UtcNow;
var state = Document;
Console.Error.WriteLine(
$"mimir-fensalir-daemon status={state.Status} wellSeq={state.LastWellSequence} captureSeq={state.LastCaptureSequence} slices={state.ReadySlices}/{state.TotalSlices} offset={tail.Position}");
}
try
{
await Task.Delay(options.PollMs, stopping).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
break;
}
}
}
public ValueTask DisposeAsync()
{
cache.Dispose();
return ValueTask.CompletedTask;
}
private bool TryDrink(JsonElement root, out MimirFensalirDaemonStateDocument next)
{
var kind = DaemonUtil.JsonText(root, "document") ?? "";
var current = Document;
next = current;
if (kind == "mimir.well_snapshot.v1")
{
var buffers = DaemonUtil.JsonArray(DaemonUtil.JsonGet(root, "buffers")).ToArray();
var frame = DaemonUtil.JsonGet(root, "synchronizedFrame");
var slices = DaemonUtil.JsonArray(DaemonUtil.JsonGet(frame, "slices")).ToArray();
var streamPressure = DaemonUtil.JsonGet(root, "streamPressure");
var poll = DaemonUtil.JsonGet(streamPressure, "poll");
var publish = DaemonUtil.JsonGet(streamPressure, "publish");
var capture = DaemonUtil.JsonGet(root, "capture");
var storage = DaemonUtil.JsonGet(capture, "storage");
next = current with
{
UpdatedAtUtc = DateTimeOffset.UtcNow.ToString("O"),
Status = "drinking-well",
WellSource = string.IsNullOrWhiteSpace(options.WellLogPath) ? "missing" : options.WellLogPath,
LastWellSequence = (long)DaemonUtil.JsonNumber(root, "sequence"),
AudioSources = buffers.Count(static item => string.Equals(DaemonUtil.JsonText(item, "kind", "Kind"), "Audio", StringComparison.OrdinalIgnoreCase)),
VideoSources = buffers.Count(static item => string.Equals(DaemonUtil.JsonText(item, "kind", "Kind"), "Video", StringComparison.OrdinalIgnoreCase)),
ReadySlices = slices.Count(static slice => string.Equals(DaemonUtil.JsonText(slice, "status", "Status"), "Ready", StringComparison.OrdinalIgnoreCase)),
TotalSlices = slices.Length,
PresentationDelayMs = DaemonUtil.JsonNumber(frame, "presentationDelayMs", "PresentationDelayMs"),
PollAverageMs = DaemonUtil.JsonNumber(poll, "averageMilliseconds"),
PublishAverageMs = DaemonUtil.JsonNumber(publish, "averageMilliseconds"),
Notes = [
$"capture-body-transport={DaemonUtil.JsonText(storage, "bodyTransport") ?? "unknown"}",
$"inline-bodies={DaemonUtil.JsonText(storage, "inlineBodies") ?? "unknown"}",
"reservoir-kernels=pending-owner-installed"
],
};
return true;
}
if (kind == "mimir.well_capture_page.v1")
{
next = current with
{
UpdatedAtUtc = DateTimeOffset.UtcNow.ToString("O"),
Status = "drinking-capture-pages",
WellSource = string.IsNullOrWhiteSpace(options.WellLogPath) ? "missing" : options.WellLogPath,
LastCaptureSequence = (long)DaemonUtil.JsonNumber(root, "captureSequence"),
};
return true;
}
if (kind == "mimir.well_stream_pressure.v1")
{
var poll = DaemonUtil.JsonGet(root, "poll");
var publish = DaemonUtil.JsonGet(root, "publish");
next = current with
{
UpdatedAtUtc = DateTimeOffset.UtcNow.ToString("O"),
Status = "observing-stream-pressure",
PollAverageMs = DaemonUtil.JsonNumber(poll, "averageMilliseconds"),
PublishAverageMs = DaemonUtil.JsonNumber(publish, "averageMilliseconds"),
};
return true;
}
return false;
}
private static MimirFensalirDaemonStateDocument BuildInitialDocument(FensalirDaemonOptions options) =>
new(
options.DaemonId,
DateTimeOffset.UtcNow.ToString("O"),
options.VerseId,
string.IsNullOrWhiteSpace(options.WellLogPath) ? "waiting-for-well" : "booting",
string.IsNullOrWhiteSpace(options.WellLogPath) ? "missing" : options.WellLogPath,
-1,
-1,
0,
0,
0,
0,
0.0,
0.0,
0.0,
options.GpuBudget,
options.CpuBudget,
"surface-owner-installed",
["cultcache-state", "cultnet-websocket", "cultmesh-eve-dashboard", "well-tail"],
["reservoir kernels pending"]);
}
internal sealed class FensalirDaemonEveServer(FensalirDaemonOptions options, FensalirDaemonState state) : IDisposable
{
private static readonly JsonSerializerOptions JsonOptions = new()
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
};
private readonly TcpListener listener = new(IPAddress.Any, options.Port);
private readonly CancellationTokenSource stopping = new();
public async Task RunAsync(CancellationToken outerStopping)
{
using var linked = CancellationTokenSource.CreateLinkedTokenSource(outerStopping, stopping.Token);
listener.Start();
while (!linked.IsCancellationRequested)
{
try
{
var client = await listener.AcceptTcpClientAsync(linked.Token).ConfigureAwait(false);
_ = Task.Run(() => HandleAsync(client, linked.Token), linked.Token);
}
catch (OperationCanceledException)
{
break;
}
}
}
private async Task HandleAsync(TcpClient client, CancellationToken token)
{
await using var stream = client.GetStream();
var request = await DaemonUtil.ReadHttpRequestAsync(stream).ConfigureAwait(false);
if (request.Path == "/health")
{
var health = JsonSerializer.Serialize(new
{
ok = true,
providerId = options.DaemonId,
verse = options.VerseId,
status = state.Document.Status,
cultCache = options.CultCachePath,
cultMeshDocument = "mimir.fensalir_daemon_state",
}, JsonOptions);
await DaemonUtil.WriteHttpResponseAsync(stream, "200 OK", "application/json", Encoding.UTF8.GetBytes(health)).ConfigureAwait(false);
return;
}
if (request.Path == "/eve/deck/manifest")
{
await DaemonUtil.WriteHttpResponseAsync(stream, "200 OK", "application/json", Encoding.UTF8.GetBytes(JsonSerializer.Serialize(Manifest(), JsonOptions))).ConfigureAwait(false);
return;
}
if (!IsDashboardPath(request.Path, out var binary) || !request.Headers.TryGetValue("Sec-WebSocket-Key", out var key))
{
await DaemonUtil.WriteHttpResponseAsync(stream, "404 Not Found", "text/plain", Encoding.UTF8.GetBytes("not found")).ConfigureAwait(false);
return;
}
await DaemonUtil.WriteWebSocketHandshakeAsync(stream, key).ConfigureAwait(false);
while (!token.IsCancellationRequested)
{
await SendStateAsync(stream, binary).ConfigureAwait(false);
await Task.Delay(1000, token).ConfigureAwait(false);
}
}
private async Task SendStateAsync(NetworkStream stream, bool binary)
{
var document = state.Document;
var dashboard = BuildDashboard(document);
if (binary)
{
var cultMesh = ToCultMesh(dashboard);
await DaemonUtil.SendBinaryFrameAsync(stream, MessagePackSerializer.Serialize(cultMesh)).ConfigureAwait(false);
return;
}
await DaemonUtil.SendTextFrameAsync(stream, JsonSerializer.Serialize(dashboard, JsonOptions)).ConfigureAwait(false);
}
private DashboardState BuildDashboard(MimirFensalirDaemonStateDocument doc)
{
var readiness = doc.TotalSlices <= 0 ? 0.0 : doc.ReadySlices / (double)doc.TotalSlices;
var pressure = Math.Clamp(Math.Max(doc.PollAverageMs / 16.0, doc.PublishAverageMs / 16.0), 0.0, 1.0);
var nodes = new List<DashboardNode>
{
new("daemon", $"Fensalir Daemon\n{doc.Status}", "daemon", 0.0, -0.42, 0.70, 0.18, doc.Status),
new("well", $"Well Drink\nseq {doc.LastWellSequence}", "well", -0.38, -0.08, 0.32, 0.18, doc.LastWellSequence >= 0 ? "live" : "waiting"),
new("capture", $"Capture Pages\nseq {doc.LastCaptureSequence}", "cultcache", 0.0, -0.08, 0.32, 0.18, doc.LastCaptureSequence >= 0 ? "paged" : "waiting"),
new("budget", $"Budget\nGPU {doc.GpuBudget:0.00} CPU {doc.CpuBudget:0.00}", "budget", 0.38, -0.08, 0.32, 0.18, "configured"),
};
return new DashboardState
{
ProviderId = options.DaemonId,
Title = "Mimir Fensalir Daemon",
Version = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
UpdatedAt = DateTimeOffset.UtcNow,
SelectedNodeId = "daemon",
LutPreset = "terminal",
Nodes = nodes,
Surface = new DashboardSurface
{
Id = "mimir.fensalir-daemon.surface",
Title = "Fensalir Daemon",
Root = Ui.Container("daemon-root", "dashboard", new UiLayout { Direction = "vertical", Gap = 6, Padding = 6, Overflow = "scroll", MinWidth = 96, MinHeight = 40, PreferredWidth = 150, PreferredHeight = 92, Density = "continuous" },
[
Ui.Row("daemon-row-top",
[
Ui.Pane("daemon-pane", "Daemon",
[
Ui.Text("daemon-status", $"{DaemonUtil.Pulse()} {doc.Status}", "strong", Bind("/status")),
Ui.Text("daemon-owner", $"verse {doc.VerseId}\nstate {options.CultCachePath}", "caption", Bind("/verseId")),
Ui.Bar("daemon-readiness", "ready slices", readiness, DaemonUtil.Tone(readiness), $"{doc.ReadySlices}/{doc.TotalSlices}"),
]),
Ui.Pane("well-pane", "Well",
[
Ui.Text("well-source", doc.WellSource, "caption", Bind("/wellSource")),
Ui.Text("well-seq", $"well seq {doc.LastWellSequence} capture seq {doc.LastCaptureSequence}", "mono", Bind("/lastWellSequence")),
Ui.Text("well-counts", $"audio {doc.AudioSources} video {doc.VideoSources} delay {doc.PresentationDelayMs:0.0}ms", "caption", Bind("/presentationDelayMs")),
]),
]),
Ui.Row("daemon-row-bottom",
[
Ui.Pane("budget-pane", "Budgets",
[
Ui.Bar("gpu-budget", "GPU share", doc.GpuBudget, "cool", $"{doc.GpuBudget:0.00}"),
Ui.Bar("cpu-budget", "CPU share", doc.CpuBudget, "warm", $"{doc.CpuBudget:0.00}"),
Ui.Text("worker-mode", doc.WorkerMode, "caption", Bind("/workerMode")),
]),
Ui.Pane("pressure-pane", "Pressure",
[
Ui.Bar("pressure-bar", "publish/poll pressure", pressure, DaemonUtil.Tone(1.0 - pressure), $"{Math.Max(doc.PollAverageMs, doc.PublishAverageMs):0.000}ms"),
Ui.Text("pressure-detail", $"poll {doc.PollAverageMs:0.000}ms publish {doc.PublishAverageMs:0.000}ms", "caption", Bind("/pollAverageMs")),
Ui.Text("notes", string.Join("\n", doc.Notes.Take(4)), "caption", Bind("/notes")),
]),
]),
]),
},
};
}
private UiBinding Bind(string path) => new()
{
DocumentSchema = "mimir.fensalir_daemon_state.v1",
DocumentId = options.DaemonId,
Path = path,
ValueKind = "state",
Access = "read",
Authority = "Mimir.FensalirDaemon",
};
private static MimirEveDashboardStateDocument ToCultMesh(DashboardState state) =>
new(
state.ProviderId,
state.Title,
state.Version,
state.UpdatedAt.ToString("O"),
state.SelectedNodeId,
state.LutPreset,
state.Nodes.Select(static node => new MimirEveDashboardNodeSnapshot(
node.Id,
node.Label,
node.Kind,
node.Visible,
node.X,
node.Y,
node.Z,
node.Rotation,
node.Scale,
node.Width,
node.Height,
node.Health,
null,
null,
null)).ToArray(),
ToCultMeshSurface(state.Surface));
private static MimirEveDashboardSurfaceSnapshot ToCultMeshSurface(DashboardSurface surface) =>
new(
surface.Schema,
surface.Id,
surface.Title,
ToCultMeshElement(surface.Root),
[]);
private static MimirEveDashboardUiElementSnapshot ToCultMeshElement(UiElement element) =>
new(
element.Id,
element.Kind,
element.Role,
element.Text,
null,
null,
null,
element.CommandId,
element.Layout == null ? null : new MimirEveDashboardUiLayoutSnapshot(
element.Layout.Direction,
element.Layout.Width,
element.Layout.Height,
element.Layout.Grow,
element.Layout.Gap,
element.Layout.Padding,
element.Layout.Overflow,
element.Layout.MinWidth,
element.Layout.MinHeight,
element.Layout.PreferredWidth,
element.Layout.PreferredHeight,
element.Layout.Priority,
element.Layout.Density,
element.Layout.ViewportMode),
null,
element.Metric == null ? null : new MimirEveDashboardUiMetricSnapshot(element.Metric.Label, element.Metric.Value, element.Metric.Tone),
element.Children.Select(ToCultMeshElement).ToArray(),
element.Binding == null ? null : new MimirEveDashboardUiBindingSnapshot(
element.Binding.DocumentSchema,
element.Binding.DocumentId,
element.Binding.Path,
element.Binding.ValueKind,
element.Binding.Access,
element.Binding.Authority,
element.Binding.CommandId));
private DashboardProviderManifest Manifest() =>
new(
options.DaemonId,
"Mimir Fensalir Daemon",
"Well-drinking Fensalir reservoir owner: CultCache state, CultNet/WebSocket transport, CultMesh/Eve surface.",
"1",
$"/eve/deck/{options.DaemonId}",
["cultcache-state", "cultnet-websocket", "cultmesh-eve-dashboard", "well-tail", "reservoir-owner"],
UsesCultMesh: true,
Transport: "CultCache .ccmp + Eve/CultMesh MessagePack WebSocket provider");
private static bool IsDashboardPath(string path, out bool binary)
{
binary = path == "/eve/deck/cultmesh";
return path is "/eve/deck" or "/eve/dashboard" or "/eve/deck/cultmesh";
}
public void Dispose()
{
stopping.Cancel();
listener.Dispose();
stopping.Dispose();
}
}
internal sealed class WellLogTailState
{
private readonly string path;
private long position;
public WellLogTailState(string path, bool fromStart)
{
this.path = path;
position = !fromStart && File.Exists(path) ? Math.Max(0, new FileInfo(path).Length - 1024 * 1024) : 0;
}
public long Position => position;
public IEnumerable<JsonDocument> ReadNewDocuments()
{
if (string.IsNullOrWhiteSpace(path) || !File.Exists(path))
{
yield break;
}
using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
if (position > stream.Length)
{
position = 0;
}
stream.Seek(position, SeekOrigin.Begin);
using var reader = new StreamReader(stream, Encoding.UTF8);
string? line;
while ((line = reader.ReadLine()) != null)
{
if (string.IsNullOrWhiteSpace(line))
{
continue;
}
JsonDocument? parsed = null;
try
{
parsed = JsonDocument.Parse(line);
}
catch (JsonException)
{
}
if (parsed != null)
{
yield return parsed;
}
}
position = stream.Position;
}
}
internal sealed record HttpRequest(string Path, Dictionary<string, string> Headers);
internal static class Ui
{
public static UiElement Container(string id, string kind, UiLayout layout, IReadOnlyList<UiElement> children) =>
new() { Id = id, Kind = kind, Layout = layout, Children = children };
public static UiElement Row(string id, IReadOnlyList<UiElement> children) =>
Container(id, "row", new UiLayout { Direction = "horizontal", Gap = 8 }, children);
public static UiElement Pane(string id, string title, IReadOnlyList<UiElement> children) =>
new()
{
Id = id,
Kind = "pane",
Text = title,
Layout = new UiLayout { Direction = "vertical", Gap = 8, Padding = 10, Grow = 1 },
Children = children,
};
public static UiElement Text(string id, string text, string role, UiBinding? binding = null) =>
new() { Id = id, Kind = "text", Role = role, Text = text, Binding = binding };
public static UiElement Bar(string id, string label, double value, string tone, string display) =>
new()
{
Id = id,
Kind = "metric",
Text = display,
Metric = new UiMetric(label, Math.Clamp(value, 0.0, 1.0), tone),
};
}
internal sealed class DashboardState
{
public string Type { get; set; } = "dashboard-state";
public string Schema { get; set; } = "mimir.eve_dashboard_state.v1";
public string ProviderId { get; set; } = "";
public string Title { get; set; } = "";
public long Version { get; set; }
public DateTimeOffset UpdatedAt { get; set; } = DateTimeOffset.UtcNow;
public string SelectedNodeId { get; set; } = "";
public string LutPreset { get; set; } = "terminal";
public List<DashboardNode> Nodes { get; set; } = [];
public DashboardSurface Surface { get; set; } = new();
}
internal sealed class DashboardSurface
{
public string Schema { get; set; } = "cultmesh.eve_surface.v0";
public string Id { get; set; } = "";
public string Title { get; set; } = "";
public UiElement Root { get; set; } = new();
}
internal sealed class DashboardNode(
string id,
string label,
string kind,
double x,
double y,
double width,
double height,
string health)
{
public string Id { get; set; } = id;
public string Label { get; set; } = label;
public string Kind { get; set; } = kind;
public bool Visible { get; set; } = true;
public double X { get; set; } = x;
public double Y { get; set; } = y;
public double Z { get; set; }
public double Rotation { get; set; }
public double Scale { get; set; } = 1.0;
public double Width { get; set; } = width;
public double Height { get; set; } = height;
public string Health { get; set; } = health;
}
internal sealed class UiElement
{
public string Id { get; set; } = "";
public string Kind { get; set; } = "";
public string? Role { get; set; }
public string? Text { get; set; }
public string? CommandId { get; set; }
public UiBinding? Binding { get; set; }
public UiLayout? Layout { get; set; }
public UiMetric? Metric { get; set; }
public IReadOnlyList<UiElement> Children { get; set; } = [];
}
internal sealed class UiLayout
{
public string Direction { get; set; } = "vertical";
public double? Width { get; set; }
public double? Height { get; set; }
public double? Grow { get; set; }
public double? Gap { get; set; }
public double? Padding { get; set; }
public string? Overflow { get; set; }
public double? MinWidth { get; set; }
public double? MinHeight { get; set; }
public double? PreferredWidth { get; set; }
public double? PreferredHeight { get; set; }
public double? Priority { get; set; }
public string? Density { get; set; }
public string? ViewportMode { get; set; }
}
internal sealed class UiBinding
{
public string DocumentSchema { get; set; } = "";
public string DocumentId { get; set; } = "";
public string Path { get; set; } = "";
public string ValueKind { get; set; } = "";
public string Access { get; set; } = "read";
public string Authority { get; set; } = "";
public string? CommandId { get; set; }
}
internal sealed record UiMetric(string Label, double Value, string Tone);
internal sealed record DashboardProviderManifest(
string Id,
string Title,
string Description,
string Version,
string Endpoint,
string[] Capabilities,
bool UsesCultMesh,
string Transport);
internal static class DaemonUtil
{
public static string Tone(double value) =>
value >= 0.70 ? "cool" : value >= 0.25 ? "warm" : "danger";
public static string Pulse() =>
(DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() / 250 % 4) switch
{
0 => "|",
1 => "/",
2 => "-",
_ => "\\",
};
public static JsonElement JsonGet(JsonElement element, params string[] names)
{
if (element.ValueKind != JsonValueKind.Object)
{
return default;
}
foreach (var name in names)
{
if (element.TryGetProperty(name, out var value))
{
return value;
}
}
return default;
}
public static IReadOnlyList<JsonElement> JsonArray(JsonElement element) =>
element.ValueKind == JsonValueKind.Array ? element.EnumerateArray().ToArray() : [];
public static string? JsonText(JsonElement element, params string[] names)
{
var value = names.Length == 0 ? element : JsonGet(element, names);
return value.ValueKind == JsonValueKind.String ? value.GetString() : null;
}
public static double JsonNumber(JsonElement element, params string[] names)
{
var value = names.Length == 0 ? element : JsonGet(element, names);
return value.ValueKind == JsonValueKind.Number && value.TryGetDouble(out var number) ? number : 0.0;
}
public static string TailTextFile(string path, int maxBytes)
{
using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
var length = stream.Length;
var start = Math.Max(0, length - maxBytes);
stream.Seek(start, SeekOrigin.Begin);
using var reader = new StreamReader(stream, Encoding.UTF8);
return reader.ReadToEnd();
}
public static async Task<HttpRequest> ReadHttpRequestAsync(NetworkStream stream)
{
var buffer = new byte[8192];
var count = await stream.ReadAsync(buffer).ConfigureAwait(false);
var text = Encoding.UTF8.GetString(buffer, 0, count);
var lines = text.Split("\r\n", StringSplitOptions.None);
var path = "/";
var first = lines.FirstOrDefault();
if (!string.IsNullOrWhiteSpace(first))
{
var parts = first.Split(' ', StringSplitOptions.RemoveEmptyEntries);
if (parts.Length >= 2)
{
path = parts[1];
}
}
var headers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var line in lines.Skip(1))
{
var separator = line.IndexOf(':');
if (separator > 0)
{
headers[line[..separator].Trim()] = line[(separator + 1)..].Trim();
}
}
return new HttpRequest(path, headers);
}
public static async Task WriteHttpResponseAsync(NetworkStream stream, string status, string contentType, byte[] body)
{
var header = Encoding.UTF8.GetBytes($"HTTP/1.1 {status}\r\nContent-Type: {contentType}\r\nContent-Length: {body.Length}\r\nConnection: close\r\n\r\n");
await stream.WriteAsync(header).ConfigureAwait(false);
await stream.WriteAsync(body).ConfigureAwait(false);
}
public static async Task WriteWebSocketHandshakeAsync(NetworkStream stream, string key)
{
var hash = SHA1.HashData(Encoding.ASCII.GetBytes(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"));
var accept = Convert.ToBase64String(hash);
var response = Encoding.ASCII.GetBytes($"HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: {accept}\r\n\r\n");
await stream.WriteAsync(response).ConfigureAwait(false);
}
public static async Task SendTextFrameAsync(NetworkStream stream, string text) =>
await SendFrameAsync(stream, 0x1, Encoding.UTF8.GetBytes(text)).ConfigureAwait(false);
public static async Task SendBinaryFrameAsync(NetworkStream stream, byte[] payload) =>
await SendFrameAsync(stream, 0x2, payload).ConfigureAwait(false);
private static async Task SendFrameAsync(NetworkStream stream, int opcode, byte[] payload)
{
var header = new List<byte> { (byte)(0x80 | opcode) };
if (payload.Length < 126)
{
header.Add((byte)payload.Length);
}
else if (payload.Length <= ushort.MaxValue)
{
header.Add(126);
header.Add((byte)(payload.Length >> 8));
header.Add((byte)(payload.Length & 0xff));
}
else
{
header.Add(127);
for (var shift = 56; shift >= 0; shift -= 8)
{
header.Add((byte)((ulong)payload.Length >> shift));
}
}
await stream.WriteAsync(header.ToArray()).ConfigureAwait(false);
await stream.WriteAsync(payload).ConfigureAwait(false);
}
}

View file

@ -104,6 +104,31 @@ public sealed record MimirFaustControlSnapshot(
[property: Key(0)] string Path,
[property: Key(1)] float Value);
[CultDocument("mimir.fensalir_daemon_state", "mimir.fensalir_daemon_state.v1")]
[MessagePackObject]
public sealed record MimirFensalirDaemonStateDocument(
[property: Key(0)]
[property: CultName]
string DaemonId,
[property: Key(1)] string UpdatedAtUtc,
[property: Key(2)] string VerseId,
[property: Key(3)] string Status,
[property: Key(4)] string WellSource,
[property: Key(5)] long LastWellSequence,
[property: Key(6)] long LastCaptureSequence,
[property: Key(7)] int AudioSources,
[property: Key(8)] int VideoSources,
[property: Key(9)] int ReadySlices,
[property: Key(10)] int TotalSlices,
[property: Key(11)] double PresentationDelayMs,
[property: Key(12)] double PollAverageMs,
[property: Key(13)] double PublishAverageMs,
[property: Key(14)] double GpuBudget,
[property: Key(15)] double CpuBudget,
[property: Key(16)] string WorkerMode,
[property: Key(17)] string[] Capabilities,
[property: Key(18)] string[] Notes);
[CultDocument("mimir.eve_dashboard_manifest", "mimir.eve_dashboard_manifest.v1")]
[MessagePackObject]
public sealed record MimirEveDashboardManifestDocument(

View file

@ -359,3 +359,4 @@
{"ts": "2026-06-02T15:18:04+01:00", "type": "verification", "status": "ok", "note": "Fixed EveDashboard Move Score sparsity regression: fallback trace discovery now scans the tail of the newest move online-sync.jsonl for the latest parseable live_score/score_gesture frame instead of trusting the last line. Nightwing TUI then rendered Move Score with bpm 119, F# major/F# chord, source score summaries, and active voices from the saved move-sync trace."}
{"ts": "2026-06-02T16:14:03+01:00", "type": "implementation", "status": "ok", "note": "Added Mimir.WellObsDaemon and scripts/start-well-obs-daemon.ps1. The daemon tails Well capture pages with inline audio bodies, applies configuredComposite audio mute/solo/gain selection, publishes well_composite plus per-source well_<source> stems into the existing Local\\\\MimirObsStemBus OBS plugin ABI, and refuses metadata-only bodies. Smoke fixture published well_composite/well_asio_ch0/well_asio_ch1 into a test map with expected Float32 samples; launcher smoke recorded real daemon PID and supervisor manifest."}
{"ts": "2026-06-02T17:22:39+01:00", "type": "implementation", "status": "ok", "note": "2026-06-02: Mimir editor responsiveness scar/fix. Fensalir reservoir history is now gated by source-derived reservoir-producing inputs instead of running on every scene presentation. Live video-only editor run artifacts/runtime/program-texture-video-only-fast-20260602-172059 showed reservoir-update n/a and CPU frame about 8-9 ms. Remaining gap is architectural: FieldEvidenceFrame camera Texture2D declarations are not a flat video compositor backend, so live synced camera feeds need an explicit Fensalir 2D program-layer draw path or a separate Fensalir reservoir daemon output surface."}
{"ts": "2026-06-02T17:38:35+01:00", "type": "implementation", "status": "ok", "note": "2026-06-02: Added Mimir.FensalirDaemon as the first Well-drinking Fensalir reservoir owner surface. It tails Well JSONL documents, persists mimir.fensalir_daemon_state.v1 in state/fensalir-daemon.ccmp via CultCache MessagePack, serves /health and /eve/deck/manifest, and publishes Eve dashboard state over JSON WebSocket plus binary CultMesh mimir.eve_dashboard_state.v1 at /eve/deck/cultmesh. Smoke run fensalir-daemon-20260602-173556 reported health status=drinking-capture-pages and binary provider=mimir-fensalir-daemon nodes=4 surface=mimir.fensalir-daemon.surface. Current workerMode is surface-owner-installed; dense GPU kernels and fused program output still belong behind this daemon."}

View file

@ -56,6 +56,12 @@ invariants:
Well pages/configured composites, owns reservoir budgets, job scheduling,
GPU residency, and CPU/GPU worker share, then publishes typed
reservoir/program surfaces. The Mimir editor is not this daemon.
`src/Mimir.FensalirDaemon` is the first live owner surface: it tails Well
documents, persists `mimir.fensalir_daemon_state.v1` into
`state/fensalir-daemon.ccmp`, serves `/health`, and publishes JSON plus
binary CultMesh Eve dashboard state on port 8799. Its current
`workerMode=surface-owner-installed` means dense kernels and fused program
output are still pending behind the daemon, not silently owned elsewhere.
- `FieldEvidenceFrame` is not a flat video compositor. Camera Texture2D
resources and claims are typed evidence declarations; they do not draw live
Fensalir-owned texture leases as 2D program layers until Fensalir has an