diff --git a/oracle/LeakyOracle/App.axaml b/oracle/LeakyOracle/App.axaml
new file mode 100644
index 0000000..89b9493
--- /dev/null
+++ b/oracle/LeakyOracle/App.axaml
@@ -0,0 +1,8 @@
+
+
+
+
+
diff --git a/oracle/LeakyOracle/App.axaml.cs b/oracle/LeakyOracle/App.axaml.cs
new file mode 100644
index 0000000..fd977c1
--- /dev/null
+++ b/oracle/LeakyOracle/App.axaml.cs
@@ -0,0 +1,33 @@
+using Avalonia;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Markup.Xaml;
+using LeakyOracle.Services;
+using LeakyOracle.ViewModels;
+using LeakyOracle.Views;
+
+namespace LeakyOracle;
+
+public partial class App : Application
+{
+ // App-scoped and rooted for the whole process: the App instance is held by Avalonia
+ // (Application.Current), so this service is too. That root is what makes the subscription leak
+ // REAL in the GUI heap — a closed window's view-model stays rooted through this service's event
+ // (without it, VM->service->delegate->VM is an unrooted cycle the GC would just collect, and the
+ // oracle would produce no OWN001 heap evidence). This is the GUI analog of the long-lived
+ // `service` local in LeakScenario.
+ private readonly MarketDataService _service = new();
+
+ public override void Initialize() => AvaloniaXamlLoader.Load(this);
+
+ public override void OnFrameworkInitializationCompleted()
+ {
+ if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
+ {
+ // the window's view-model subscribes to the app-scoped service and never detaches —
+ // see WatchlistViewModel.
+ desktop.MainWindow = new MainWindow { DataContext = new WatchlistViewModel(_service) };
+ }
+
+ base.OnFrameworkInitializationCompleted();
+ }
+}
diff --git a/oracle/LeakyOracle/LeakScenario.cs b/oracle/LeakyOracle/LeakScenario.cs
new file mode 100644
index 0000000..f090e0f
--- /dev/null
+++ b/oracle/LeakyOracle/LeakScenario.cs
@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using LeakyOracle.Services;
+using LeakyOracle.ViewModels;
+
+namespace LeakyOracle;
+
+///
+/// A headless, self-validating proof that the oracle leaks — no display, so it runs in CI. It mimics
+/// the scenario the runtime audit drives ("open and close a screen N times") for BOTH view-models:
+///
+/// • the leaky (subscribes, never detaches) must ALL survive GC;
+/// • the corrected (detaches on Dispose) must ALL be collected.
+///
+/// Checking both with the same WeakReference harness proves the harness isn't rigged: if it were,
+/// the fixed batch would look alive too. Exit code 0 means the oracle leaked exactly where it should
+/// and nowhere it shouldn't — this is a TARGET, not a test of our auditor; if it stops behaving we
+/// fail loudly because the oracle (not the auditor) is broken.
+///
+public static class LeakScenario
+{
+ public static int Run(int screens = 50)
+ {
+ var service = new MarketDataService();
+
+ var leakedAlive = OpenAndDrop(screens, () => new WatchlistViewModel(service));
+ var fixedAlive = OpenAndDrop(screens, () =>
+ {
+ var vm = new FixedWatchlistViewModel(service);
+ return vm;
+ }, dispose: vm => ((FixedWatchlistViewModel)vm).Dispose());
+
+ var leaksWhereItShould = leakedAlive == screens;
+ var cleanWhereItShould = fixedAlive == 0;
+ var ok = leaksWhereItShould && cleanWhereItShould;
+
+ Console.WriteLine($"screens opened+closed : {screens}");
+ Console.WriteLine($"leaky still alive (GC) : {leakedAlive,3} (expect {screens} — rooted by MarketDataService.QuoteReceived)");
+ Console.WriteLine($"fixed still alive (GC) : {fixedAlive,3} (expect 0 — detached on Dispose)");
+ Console.WriteLine($"verdict : {(ok ? "LEAK confirmed and isolated to the un-detached subscription" : "UNEXPECTED")}");
+ Console.WriteLine(ok
+ ? "ORACLE OK: leaks as designed — a valid target for the heap/lifetime audit."
+ : "ORACLE BROKEN: leak signature is wrong; fix the oracle, not the auditor.");
+
+ return ok ? 0 : 1;
+ }
+
+ // Create `screens` objects, optionally dispose each, drop all strong refs, force GC, and report
+ // how many survive. Survival is only possible through a reference the scenario itself dropped —
+ // i.e. an unintended root (the leak).
+ private static int OpenAndDrop(int screens, Func