Observe owned diskutil stack and live StorageKit in Recovery

Qualify guest version through one-way raw evidence before permit
Read Recovery version from current guest SystemVersion evidence
2026-10-04 17:35:06 +02:00 · 2026-10-04 16:08:41 +02:00 · 2026-10-04 15:00:11 +02:00 · 2026-10-04 13:31:58 +02:00 · 2026-10-04 10:56:46 +02:00
10 changed files with 1982 additions and 96 deletions
@@ -0,0 +1,32 @@
+name: Native macOS build and tests on Ubuntu (experimental)
+
+on:
+  workflow_dispatch:
+
+jobs:
+  macos-native-full:
+    runs-on: ubuntu-latest
+    timeout-minutes: 180
+    env:
+      DOTNET_SKIP_FIRST_TIME_EXPERIENCE: "1"
+      DOTNET_NOLOGO: "1"
+    steps:
+      - name: Checkout exact native CI candidate
+        uses: actions/checkout@v7
+      - name: Setup .NET orchestration SDK
+        uses: actions/setup-dotnet@v6
+        with:
+          dotnet-version: "10.0.x"
+      - name: Run owned macOS 14 TCG guest and all native tests
+        run: dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --run --full --output artifacts/native-macos-full
+      - name: Always remove only this run's owned resources
+        if: always()
+        run: dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --cleanup --output artifacts/native-macos-full
+      - name: Retain native build, signatures, TRX and guest receipts
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: native-macos-full
+          path: artifacts/native-macos-full/
+          if-no-files-found: error
+          retention-days: 7
@@ -8,6 +8,7 @@ on:
    branches-ignore:
      - codex/macos-ci-kvm-compatibility
      - codex/macos-ci-tcg-supported
+      - codex/macos-native-full-tcg
  workflow_dispatch:

 jobs:
@@ -136,6 +137,34 @@ jobs:
          find MeetingAssistant.Tests -type d -name TestResults -print || true
          find MeetingAssistant.Tests -type f -path "*/TestResults/*" -maxdepth 5 -print || true

+  macos-native-full:
+    needs: [build-and-test, portable-build-and-test]
+    runs-on: ubuntu-latest
+    timeout-minutes: 180
+    env:
+      DOTNET_SKIP_FIRST_TIME_EXPERIENCE: "1"
+      DOTNET_NOLOGO: "1"
+    steps:
+      - name: Checkout exact native CI candidate
+        uses: actions/checkout@v7
+      - name: Setup .NET orchestration SDK
+        uses: actions/setup-dotnet@v6
+        with:
+          dotnet-version: "10.0.x"
+      - name: Run owned macOS 14 TCG guest and all native tests
+        run: dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --run --full --output artifacts/native-macos-full
+      - name: Always remove only this run's owned resources
+        if: always()
+        run: dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --cleanup --output artifacts/native-macos-full
+      - name: Retain native build, signatures, TRX and guest receipts
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: native-macos-full
+          path: artifacts/native-macos-full/
+          if-no-files-found: error
+          retention-days: 7
+
  portable-build-and-test:
    runs-on: ubuntu-latest
    env:
@@ -169,13 +169,13 @@ Detailed workflow syntax and extension guidance live in `docs/meeting-workflow-e

 Behavior changes are OpenSpec-driven and test-first: update the relevant requirement/scenario, add a failing public behavior test, implement the smallest passing change, run focused tests and then the justified broader suite, and validate the active change with `openspec validate <change-id> --strict`. Documentation-only maintenance does not need a new OpenSpec change.

-The Gitea workflow runs for pull requests, pushes, and manual dispatch on the existing `ubuntu-latest` runners. One job explicitly builds the Windows desktop target, installs Wine plus a matching Windows .NET SDK, and runs the portable test project through the Windows host under Wine. Another job builds and tests `net10.0` on Ubuntu, including the managed macOS audio, calendar, screenshot, registration, and desktop-control behavior tests. Its `TZ=Europe/Berlin` setting also exercises the calendar daylight-saving regression. No additional runner labels or host devices are required.
+The Gitea workflow runs for pull requests, pushes, and manual dispatch on the existing `ubuntu-latest` runners. One job explicitly builds the Windows desktop target, installs Wine plus a matching Windows .NET SDK, and runs the portable test project through the Windows host under Wine. Another job builds and tests `net10.0` on Ubuntu, including the managed macOS audio, calendar, screenshot, registration, and desktop-control behavior tests. Its `TZ=Europe/Berlin` setting also exercises the calendar daylight-saving regression. After both jobs pass, the prepared workflow requires a native macOS job on the same existing runner label and Docker daemon, using software CPU emulation without host devices or added capabilities.

-Ubuntu does not compile the Swift helpers or execute Apple frameworks. Tests requiring the native macOS environment report an explicit skip through `MacOsFact`; they must also be run on a supported Mac with `dotnet test MeetingAssistant.Tests/MeetingAssistant.Tests.csproj -f net10.0 -c Release -p:EnableWindowsTargeting=true`. That build compiles and signs the helpers, and the suite checks packaging, helper self-tests, and native image cropping. Real microphone/system-audio capture and privacy permissions still require the operational checks described above.
+The Ubuntu managed-test job does not compile the Swift helpers or execute Apple frameworks; its native macOS tests report an explicit skip through `MacOsFact`. The prepared native job runs an owned macOS 14+ x86_64 guest under TCG on the existing Ubuntu Docker runner. Before downloading Recovery, the actual pinned QEMU binary must execute an AVX/AVX2 instruction probe. The full flow builds all four native helpers, verifies the audio app's signature, and requires all 577 tests to pass with zero skips, including all five native macOS tests. It has a 180-minute job limit with retained evidence and ownership-checked cleanup. Recovery, installation, toolchain operation and this CI path remain unqualified until actual remote guests produce every required receipt. Native tests can also run on a supported Mac with `dotnet test MeetingAssistant.Tests/MeetingAssistant.Tests.csproj -f net10.0 -c Release -p:EnableWindowsTargeting=true`; real microphone/system-audio capture and privacy permissions still require the operational checks described above.

-[Docker-OSX](https://github.com/sickcodes/Docker-OSX) runs a macOS VM rather than providing a Wine-style compatibility layer. Its launcher supports software emulation with `KVM=accel=tcg`, so KVM is not an absolute requirement. A supported .NET 10 guest needs macOS 14 or later plus the Swift build tools. The documented `auto` build downloads a preinstalled guest disk through `IMAGE_URL`; its documented ready-made tags and disk downloads were unavailable when checked on 2026-10-03. No verified native guest bootstrap is owned by this repository. CI validates source; it does not publish or deploy the workstation application.
+The separate manual `.gitea/workflows/macos-native-full.yaml` retains the same Full flow as a diagnostic entry point. CI validates source; it does not publish or deploy the workstation application.

-The separate manual [native Recovery diagnostic](docs/macos-native-diagnostic.md) probes macOS startup and disk readiness through an unprivileged TCG guest on the existing Ubuntu Docker runner. It neither installs macOS nor runs application tests; its result is a prerequisite for a future native test job, not verification of macOS CI support.
+The separate manual [native Recovery diagnostic](docs/macos-native-diagnostic.md) can isolate macOS startup and disk readiness. It neither installs macOS nor runs application tests. A green Recovery diagnostic alone does not verify macOS build/test CI support; each Full run requires fresh Recovery readiness for its own guest and disk before permitting installation.

 ## Operations And Limitations

@@ -8,7 +8,17 @@ The existing Intel Celeron 1037U has neither AVX nor AVX2. KVM run 4187 at `720a

 [CryptexFixup 1.0.5](https://github.com/acidanthera/CryptexFixup/blob/1.0.5/kern_start.cpp) selects the installed/updated Rosetta Cryptex and patches APFS hash checking; it does not replace the running Recovery cache or emulate instructions. macOS 13 is outside the [.NET 10 supported-OS policy](https://github.com/dotnet/core/blob/main/release-notes/10.0/supported-os.md). This candidate therefore uses macOS 14 and software CPU emulation without Cryptex. It changes the compatibility profile, not one isolated causal variable; actual success must be measured.

-Earlier TCG run 4159 observed guest AVX2. Runs 4161/4163 measured slow native startup and reached the 40-minute host limit before readiness. They predated the UDIF CRC repair at `94a70b2`, reuse of successful sw_vers output and capturing the large Recovery hash only once. They do not qualify this candidate. Host/workflow limits are 90/95 minutes; a readiness pass does not establish that full installation/build/tests fit the pipeline.
+Earlier TCG run 4159 observed guest AVX2 with the upstream-selected Skylake model. Runs 4161/4163 measured slow native startup and reached the 40-minute host limit before readiness. They predated the UDIF CRC repair at `94a70b2`, reuse of successful sw_vers output and capturing the large Recovery hash only once. They do not qualify this candidate. Host/workflow limits for the read-only mode are 90/95 minutes; a readiness pass does not establish that full installation/build/tests fit the pipeline.
+
+Run 4188 with Haswell recorded a boot loop; first-reset run 4189 retained repeated supervisor instruction-fetch pagefaults at RIP/CR2 `0x24b0` before native readiness. Run 4190 at `3aaab45` restored `Skylake-Client-v4` and the upstream TCG `-spec-ctrl` mask. The actual AVX/AVX2 ROM passed (exit 33; AVX2-disabled control exit 0), and macOS 14's Darwin 23.6.0 kernel identified the Skylake CPU. It retained one kernel handoff, a running VM and later userspace execution without the earlier reset, but reached the 20-minute diagnostic deadline without the readiness hook. These observations do not identify Haswell as the original cause or qualify native tests.
+
+Run 4190 used synchronous kernel serial output and QEMU interrupt/register tracing to preserve the failure context. Its kernel explicitly warned that synchronous output impacts performance. The current full candidate uses normal upstream boot arguments and only the existing iothread QEMU argument; it retains actual CPU/staging receipts independently of Docker log rotation. Its existing fresh-readiness gate precedes every installation permit. This allows one bounded full qualification to test boot performance and, only after readiness, installation/build/tests without duplicating the guest startup. No remote full result has qualified this candidate yet.
+
+Full run 4191 at `9735db1` reached native Recovery: x86_64/root, Darwin 23.6.0 and successful launchd service queries. Both `sw_vers` attempts were stopped by the existing 45-second watchdog at about 50 seconds. Other successful commands took 24–47 seconds, and small log-copy batches took 85–181 seconds. Thus this run proves broad native startup latency and a probe-imposed abort, without proving a permanent `sw_vers` hang. Disk enumeration, installation and application tests were not reached. The next candidate obtains the version from the current guest's SystemVersion plist to reduce process launches; it does not claim that `sw_vers` has become functional.
+
+Run 4192 at `6122be2` captured the actual 603-byte guest file and strictly parsed version 14.6.1. Its host reply was published successfully, but the guest's reply-existence check timed out before services or disk enumeration. Guest request/timeout UTC timestamps were not retained, so late delivery and 9p visibility cannot be distinguished. The current candidate removes this version reply: the guest publishes its raw file and a provisional version candidate; the host's full XML validation and exact result binding remain mandatory before any installation permit. The later installation-permit transport is still unqualified.
+
+Run 4193 at `9164fe4` successfully derived the same current-file version in both guest and host. Its single `diskutil list physical` process was stopped at 124 seconds by the 120-second watchdog without output. The observer saw one runnable row and 3.18 seconds of accumulated CPU time, without a stack or proven IPC endpoint. `ioreg` was also stopped before producing output. The post-disk service gates, permit, installation and tests were not reached. A prior modified Recovery14 reference image has byte-identical SystemVersion contents but a different image hash; it contains StorageKit with the `com.apple.storagekitd` and `com.apple.storagekitd.dm` MachServices, not `diskmanagementd`. The next observation targets that actual service family and the own diskutil stack; this reference does not establish the live service state of run 4193.

 ## Entry points and dependencies

@@ -27,7 +37,7 @@ The native diagnostic workflow is manual only. Temporary diagnostic branches are

 The existing daemon must be Linux/x64 with two CPUs and 6 GiB memory; the runner must have 5 GiB available memory and the Docker filesystem 8 GiB free. These checks do not reconfigure resources. Dockur commit `16a5b470cdd601bae8b05b02d748d7edfb36c12e`, both imported QEMU image digests and original source seams remain pinned.

-Actual `Haswell-noTSX` CPU flags under TCG use `enforce=on` to reject unsupported requests. The CPU preflight uses that same composed flag list and QEMU binary before Recovery download/boot. `tools/ci/macos-tcg-cpu-preflight.asm` enables long mode/YMM state, executes AVX and AVX2 integer arithmetic, and checks an Int32 from the upper 128-bit lane. Only the correct result reaches [QEMU debug-exit](https://github.com/qemu/qemu/blob/v11.1.1/hw/misc/debugexit.c) code 33. No disks/network attach; failure/timeout fails preflight. This tests that instruction chain, not the complete ISA or macOS.
+Actual `Skylake-Client-v4` CPU flags under TCG use `enforce=on` to reject unsupported requests. The CPU preflight uses that same composed flag list and QEMU binary before Recovery download/boot. `tools/ci/macos-tcg-cpu-preflight.asm` enables long mode/YMM state, executes AVX and AVX2 integer arithmetic, and checks an Int32 from the upper 128-bit lane. Only the correct result reaches [QEMU debug-exit](https://github.com/qemu/qemu/blob/v11.1.1/hw/misc/debugexit.c) code 33. No disks/network attach; failure/timeout fails preflight. This tests that instruction chain, not the complete ISA or macOS.

 The locally assembled NASM 2.16.03 ROM is 65,536 bytes, SHA256 `c32746122cc68f3ed642aa46c21b677f803c58f0d4ff665841723fcc5625f549`. Assembly/static review does not prove remote execution.

@@ -35,12 +45,32 @@ The locally assembled NASM 2.16.03 ROM is 65,536 bytes, SHA256 `c32746122cc68f3e

 The original Apple recoveryosd runs under its existing job/PID beside the read-only probe. Exact known macOS 13/14 plist layouts and same-length replacements retain their allowlist. The patcher validates UDIF boundaries, updates changed mish/koly CRCs and reads back the image. Four raw/zlib positive and twelve rejection fixtures use an independent C# CRC32 reader. Apple chunklist authentication applies to the input, not the deliberately modified image.

-Native readiness requires x86_64, UID 0, macOS 14+, successful launchd service queries and exactly one writable whole 64-GiB disk. The complete successful sw_vers output must contain one valid ProductVersion field and EOF within 1,024 bytes. The actual native diskutil query remains mandatory.
+Native readiness requires x86_64, UID 0, macOS 14+, successful launchd service queries and exactly one writable whole 64-GiB disk. The guest's existing Bash runtime reads its own `/System/Library/CoreServices/SystemVersion.plist` with a 4-KiB bound and mandatory EOF. Apple documents this path as the [system-version source](https://developer.apple.com/documentation/installer_js/system/1812284-version). Bash extracts only a provisional numeric version from the same bytes it publishes; subsequent guest probes remain read-only. The existing C# controller parses the full captured XML with external resolution disabled and requires a flat string-valued dictionary with exactly one valid direct `ProductVersion` string and macOS 14+. Missing, binary, oversized, ambiguous or malformed content fails. Before either readiness success or an installation permit, the result's version must exactly match this current-file evidence. No configured `VERSION` or host OS value serves as proof. The actual native diskutil query remains mandatory.

-Required commands retain 45 seconds, UID 180 seconds and the single disk query 120 seconds. The owned observer uses `/bin/ps -M -p <diskutil-child>` with a separate 60-second limit and two-second TERM/KILL grace. It avoids stack symbolication; thread waiting states do not identify an IPC endpoint. Observation failure passes no gate. Owned children are stopped on completion/cancellation; output remains 512 KiB per command and 4 MiB proof.
+The raw file, exact source path, length, SHA256 and parsing receipt are retained and bound to the current token. This version evidence travels only from guest to host and requires no reply. The guest uses its existing Bash before any SDK exists; authoritative XML logic stays in C#/.NET. A Bash candidate alone cannot authorize installation or qualify readiness. This method establishes the current guest version, not successful execution of `sw_vers`.
+
+Required commands retain 45 seconds and UID 180 seconds. The single disk query receives a 600-second diagnostic window under the existing 90-minute Recovery deadline. The owned observer captures StorageKit state, thread CPU snapshots and an optional one-second/100-ms `sample -mayDie` stack of only that live diskutil child. Each observation retains its own 60-second watchdog and two-second TERM/KILL grace. Missing tools, failed or timed-out samples remain explicit missing evidence; thread states alone do not identify an IPC endpoint. Stack output is captured directly from the owned state with a 512-KiB bound, without another native copy command. Observation failure passes no gate. Owned children are stopped on query completion/cancellation; output remains 512 KiB per command and 4 MiB proof. No service is started or restarted by the observer.

 The container retains 6 GiB memory/swap, two-CPU limit, 512 MiB shared memory and a 4-GiB/two-vCPU guest. One fresh anonymous /storage volume holds the sparse 64-GiB target. Inspection rejects devices, capabilities, binds, ports, host networking and privileged mode. KVM is disabled with no /dev/kvm mapping; guest networking stays slirp.

-Evidence retains run/source/profile identity, CPU preflight, original/patched Recovery identity, container/QEMU state, native proof/result and cleanup. Optional bounded before/during/after pressure snapshots record host/cgroup counters. The /storage/14/setup.dmg hash is captured once after staging; successful evidence survives later capture failure. Screenshots/pressure observations pass no gate.
+Evidence retains run/source/profile identity, CPU preflight, original/patched Recovery identity, container/QEMU state, native proof/result and cleanup. Sparse kernel-handoff lines are retained separately; two handoffs before readiness/installation permission fail early. After permission, normal installer reboots remain allowed. Optional bounded before/during/after pressure snapshots record host/cgroup counters. The /storage/14/setup.dmg hash is captured once after staging; successful evidence survives later capture failure. Screenshots/pressure observations pass no gate.

 Both cleanup paths verify exact token/label/ID before removing only the owned container, anonymous volume and image. No pruning, host changes, original checkout changes or Meeting Assistant restart occurs. Artifacts remain seven days. Full CI remains unverified until an installed supported guest builds/signs fresh helpers and passes all 577 tests, including the five native macOS tests, with zero skips.
+
+## Prepared full build/test flow
+
+The separate manual `.gitea/workflows/macos-native-full.yaml` and the prepared required PR job invoke the same full mode:
+
+```sh
+dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --validate --full --source /path/to/clean/pinned/dockur-clone --output /path/to/fresh/full-validation
+dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --run --full --output artifacts/native-macos-full
+dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --cleanup --output artifacts/native-macos-full
+```
+
+Full mode repeats CPU preflight and Recovery readiness for its own fresh guest. Before erasing the disposable target, the host verifies the owned container/anonymous volume, raw 64-GiB image, actual QEMU attachment/unique disk serial and state share. A token/source/disk-bound permit authorizes the guest. The guest independently checks whole/writable/size/unique serial before `diskutil eraseDisk`. It never erases a host disk or reuses an unrelated guest volume.
+
+The installer provisions the owned guest and returns into the prepared firstboot hook. Early firstboot logs and failures enter the state share even before account-package installation or test bootstrap. The installed root must be APFS backed by the exact owned physical store. Apple softwareupdate provisions CLT; a real Swift/SDK smoke build imports the required Apple frameworks. The source archive is bound to clean Git HEAD and SHA256; the pinned macOS x64 .NET SDK 10.0.401 is checked with SHA512. No prebuilt application/helper result counts as this run's evidence.
+
+`tools/ci/MacOsNativeGuest.cs` restores/builds/tests the source inside the installed guest. Success requires four fresh x86_64 Mach-O helpers, a valid audio-app signature and a fresh source-bound TRX containing exactly 577 distinct passing tests, zero failures/skips and all five named native macOS tests. Archive, SDK, build, signature and TRX receipts are retained. The required PR job follows the existing Wine and portable jobs; all jobs still select `ubuntu-latest`.
+
+The workflow has 180 minutes; the controller reserves cleanup time with a shared 172-minute total deadline. Recovery, installation, CLT and test caps are 90/80/30/25 minutes under that same total, not additive promises. Actual supported-guest installation/performance and remote test success remain unqualified. The full run's own mandatory fresh-readiness and owned-disk gates prevent installation until that guest passes its prerequisites. CI does not deploy or restart the workstation application.
@@ -0,0 +1,553 @@
+#:property PublishAot=false
+using System.Diagnostics;
+using System.Formats.Tar;
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Linq;
+
+// Installed-guest CI slice. --validate never invokes macOS, dotnet build/test, or a VM.
+return await NativeGuest.Execute(args);
+
+static class NativeGuest
+{
+    const string SdkVersion = "10.0.401";
+    const string SdkSha512 = "33401b4a2da8554e3306db6072ea8569d9fcc608509c271e0aa4b39e7cc432da3631f14e7e1e2445d67d72550d18ce44a8bbd2382a756867ad2edab6b1c963c0";
+    const int ExpectedTests = 577;
+    const int MaximumLogBytes = 8 * 1024 * 1024;
+    static readonly JsonSerializerOptions JsonOptions = new() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase, WriteIndented = true };
+    static readonly string[] RequiredNativeTests =
+    [
+        "MeetingAssistant.Tests.MacOsMeetingAudioSourceTests.NativeAudioCaptureIsPackagedAsSignedMacOsAppForPersistentPrivacyGrant",
+        "MeetingAssistant.Tests.MacOsMeetingIntegrationTests.MacOsCapabilityEndpointReportsEnabledRealProviders",
+        "MeetingAssistant.Tests.MacOsMeetingIntegrationTests.NativeHelperAdvertisesCalendarPromptAndScreenshotFeatures",
+        "MeetingAssistant.Tests.MacOsMeetingIntegrationTests.NativeHelperCropsPngUsingOcrPixelCoordinates",
+        "MeetingAssistant.Tests.MacOsMeetingIntegrationTests.CalendarClientFallsBackToCalendarAutomationWhenEventKitIsDenied"
+    ];
+    static readonly string[] NativeNames =
+    [
+        "MeetingAssistantAudioCapture.app/Contents/MacOS/macos-meeting-audio-capture",
+        "macos-desktop-controls", "macos-meeting-integrations", "macos-meeting-assistant-launcher"
+    ];
+
+    public static async Task<int> Execute(string[] args)
+    {
+        if (args.Length == 0 || args.SequenceEqual(["--help"]))
+        {
+            Console.WriteLine("dotnet run --file tools/ci/MacOsNativeGuest.cs -- --validate [--archive <source.tar> --source-commit <SHA>] | --run --state /Volumes/installstate --work /private/var/tmp/meeting-assistant-native-<runToken>");
+            return 0;
+        }
+        try
+        {
+            if (args.SequenceEqual(["--validate"]) || args.Length == 5 && args[0] == "--validate" && args[1] == "--archive" && args[3] == "--source-commit")
+            {
+                ValidateContracts();
+                if (args.Length == 5)
+                {
+                    if (!Hex(args[4], 40)) throw new ArgumentException("Source commit must be the full lowercase Git SHA.");
+                    using var archive = File.OpenRead(Path.GetFullPath(args[2]));
+                    ValidateArchive(archive, args[4]);
+                }
+                Console.WriteLine("Guest payload, safe Git tar, fresh TRX and native receipt contracts passed; no native execution occurred.");
+                return 0;
+            }
+            if (args.Length != 5 || args[0] != "--run" || args[1] != "--state" || args[3] != "--work")
+                throw new ArgumentException("Choose --validate or --run --state <mounted9pdir> --work <ownedAPFSdir>.");
+            return await Run(Path.GetFullPath(args[2]), Path.GetFullPath(args[4]));
+        }
+        catch (Exception exception)
+        {
+            Console.Error.WriteLine(exception.Message);
+            return 1;
+        }
+    }
+
+    static async Task<int> Run(string state, string work)
+    {
+        if (!OperatingSystem.IsMacOS() || RuntimeInformation.ProcessArchitecture != Architecture.X64)
+            throw new InvalidOperationException("--run is restricted to the installed macOS x86_64 guest.");
+        RequireNoLinks(state);
+        RequireNoLinks(work);
+        var manifestPath = Path.Combine(state, "payload.json");
+        RequireNoLinks(manifestPath);
+        var payload = ReadPayload(File.ReadAllText(manifestPath));
+        if (work != "/private/var/tmp/meeting-assistant-native-" + payload.RunToken || !Directory.Exists(work))
+            throw new InvalidOperationException("Guest work directory does not match this run's owned APFS location.");
+        var owner = Path.Combine(work, "run.owner");
+        RequireNoLinks(owner);
+        if (File.ReadAllText(owner).TrimEnd('\r', '\n') != payload.RunToken)
+            throw new InvalidOperationException("Guest work directory has a different run owner.");
+
+        var started = DateTimeOffset.UtcNow;
+        var summary = new TestSummary(0, 0, 0, 0, 0, []);
+        var native = new List<NativeArtifact>();
+        var osVersion = "";
+        var architecture = "";
+        var actualSdk = "";
+        var trxSha256 = "";
+        var audioCodeSignExit = -1;
+        var success = false;
+        var reason = "";
+        var logs = Path.Combine(state, "guest-logs");
+        var results = Path.Combine(state, "test-results");
+        var source = Path.Combine(work, "source");
+        var dotnet = Path.Combine(work, "dotnet", "dotnet");
+        // Guest checks/restore/build/tests: 25 minutes within the host's 172-minute total.
+        using var deadline = new CancellationTokenSource(TimeSpan.FromMinutes(25));
+        using var signal = PosixSignalRegistration.Create(PosixSignal.SIGTERM, context => { context.Cancel = true; deadline.Cancel(); });
+        ConsoleCancelEventHandler cancelHandler = (_, context) => { context.Cancel = true; deadline.Cancel(); };
+        Console.CancelKeyPress += cancelHandler;
+        void Phase(string phase, string stage) => Save(Path.Combine(state, "guest-phase.json"), new { token = payload.RunToken, phase, stage, updatedUtc = DateTimeOffset.UtcNow });
+        async Task<CommandResult> Cmd(string executable, string[] arguments, string label, bool requireSuccess = true) =>
+            await Command(executable, arguments, source, work, logs, label, deadline.Token, requireSuccess);
+        try
+        {
+            RequireAbsent(Path.Combine(state, "full-result.json"));
+            RequireAbsent(logs);
+            RequireAbsent(results);
+            RequireAbsent(source);
+            Directory.CreateDirectory(logs);
+            Directory.CreateDirectory(results);
+            foreach (var directory in new[] { "home", "packages", "tmp" })
+            {
+                RequireNoLinks(Path.Combine(work, directory));
+                Directory.CreateDirectory(Path.Combine(work, directory));
+            }
+            Phase("tests-running", "installed-guest-checks");
+            osVersion = (await Cmd("/usr/bin/sw_vers", ["-productVersion"], "os-version")).Output.Trim();
+            architecture = (await Cmd("/usr/bin/uname", ["-m"], "architecture")).Output.Trim();
+            var uid = (await Cmd("/usr/bin/id", ["-u"], "uid")).Output.Trim();
+            RequirePlatform(osVersion, architecture, uid);
+            foreach (var volume in new[] { ("/", "system-volume"), (work, "work-volume") })
+                RequireApfs((await Cmd("/usr/sbin/diskutil", ["info", "-plist", volume.Item1], volume.Item2)).Output);
+            await Cmd("/usr/bin/xcode-select", ["-p"], "clt-location");
+            await Cmd("/usr/sbin/pkgutil", ["--pkg-info", "com.apple.pkg.CLTools_Executables"], "clt-package");
+            await Cmd("/usr/bin/xcrun", ["swiftc", "--version"], "swift-version");
+            await Cmd("/usr/bin/xcrun", ["--sdk", "macosx", "--show-sdk-version"], "apple-sdk-version");
+            await Cmd("/usr/bin/xcrun", ["--sdk", "macosx", "--show-sdk-path"], "apple-sdk-path");
+            RequireNoLinks(dotnet);
+            actualSdk = (await Cmd(dotnet, ["--version"], "sdk-version")).Output.Trim();
+            var sdkInfo = (await Cmd(dotnet, ["--info"], "sdk-info")).Output;
+            if (actualSdk != SdkVersion || !Regex.IsMatch(sdkInfo, @"(?m)^\s*Architecture:\s*x64\s*$"))
+                throw new InvalidOperationException("Guest .NET SDK is not the pinned 10.0.401/x64 toolchain.");
+
+            Phase("tests-running", "payload-verification");
+            var archive = Path.Combine(state, "source.tar");
+            var sdkArchive = Path.Combine(state, "sdk.tar.gz");
+            RequireNoLinks(archive);
+            RequireNoLinks(sdkArchive);
+            if (await HashFile(archive, false, deadline.Token) != payload.ArchiveSha256 || await HashFile(sdkArchive, true, deadline.Token) != payload.SdkSha512)
+                throw new InvalidOperationException("Guest payload hash does not match the pinned manifest.");
+            using (var stream = File.OpenRead(archive)) ValidateArchive(stream, payload.SourceCommit);
+            // All members were checked before native tar can write anything; the destination is new.
+            Directory.CreateDirectory(source);
+            await Cmd("/usr/bin/tar", ["-xf", archive, "-C", source], "source-extraction");
+            var project = Path.Combine(source, "MeetingAssistant.Tests", "MeetingAssistant.Tests.csproj");
+            if (!File.Exists(project)) throw new InvalidOperationException("Source archive lacks the test project.");
+            var nativeRoot = Path.Combine(source, "MeetingAssistant", "bin", "Release", "net10.0", "Native");
+            RequireAbsent(nativeRoot);
+            Phase("tests-running", "restore");
+            await Cmd(dotnet, ["restore", project, "-p:EnableWindowsTargeting=true", "-p:TargetFramework=net10.0"], "restore");
+            Phase("tests-running", "build");
+            var buildStarted = DateTimeOffset.UtcNow;
+            await Cmd(dotnet, ["build", project, "--no-restore", "-f", "net10.0", "-c", "Release", "-p:EnableWindowsTargeting=true"], "build");
+            Phase("tests-running", "native-artifacts");
+            foreach (var name in NativeNames)
+            {
+                var path = Path.Combine(nativeRoot, name);
+                RequireNoLinks(path);
+                RequireFreshFile(path, buildStarted);
+                var fileOutput = (await Cmd("/usr/bin/file", ["-b", path], "native-file-" + native.Count)).Output;
+                var arch = (await Cmd("/usr/bin/xcrun", ["lipo", "-archs", path], "native-architecture-" + native.Count)).Output.Trim();
+                RequireNativeArtifact(fileOutput, arch);
+                native.Add(new(name, await HashFile(path, false, deadline.Token), arch));
+            }
+            var signing = await Cmd("/usr/bin/codesign", ["--verify", "--deep", "--strict", Path.Combine(nativeRoot, "MeetingAssistantAudioCapture.app")], "audio-code-sign", false);
+            audioCodeSignExit = signing.ExitCode;
+            if (audioCodeSignExit != 0) throw new InvalidOperationException("Fresh audio app did not pass strict code-signature verification.");
+            Phase("tests-running", "test");
+            var testStarted = DateTimeOffset.UtcNow;
+            await Cmd(dotnet, ["test", project, "--no-build", "--no-restore", "-f", "net10.0", "-c", "Release", "-p:EnableWindowsTargeting=true", "--logger", "trx;LogFileName=native.trx", "--results-directory", results], "test");
+            var trxPath = Path.Combine(results, "native.trx");
+            RequireNoLinks(trxPath);
+            RequireFreshFile(trxPath, testStarted, 16 * 1024 * 1024);
+            var trxBytes = File.ReadAllBytes(trxPath);
+            summary = ValidateTrx(trxBytes, payload.ExpectedTests, testStarted);
+            trxSha256 = Convert.ToHexStringLower(SHA256.HashData(trxBytes));
+            success = true;
+        }
+        catch (Exception exception)
+        {
+            reason = exception is OperationCanceledException ? "The explicit 25-minute guest deadline or cancellation was reached." : exception.Message;
+            if (reason.Length > 4096) reason = reason[..4096];
+            Console.Error.WriteLine(reason);
+        }
+        finally
+        {
+            Console.CancelKeyPress -= cancelHandler;
+            var result = new FullResult(payload.RunToken, success, payload.SourceCommit, payload.ArchiveSha256, osVersion, architecture, actualSdk, payload.ExpectedTests, summary.Total, summary.Executed, summary.Passed, summary.Failed, summary.NotExecuted, summary.NativeTests, native.ToArray(), audioCodeSignExit, trxSha256, reason, started, DateTimeOffset.UtcNow);
+            if (success)
+            {
+                try { ValidateResult(result, payload); }
+                catch (InvalidOperationException exception)
+                {
+                    success = false;
+                    result = result with { Success = false, Reason = exception.Message };
+                }
+            }
+            Save(Path.Combine(state, "full-result.json"), result);
+            Phase(success ? "tests-passed" : "tests-failed", "complete");
+        }
+        Console.WriteLine(success ? "Native macOS guest build, signed helpers and all 577 tests passed without skips." : "Native guest validation failed; full-result.json and bounded logs retain the evidence.");
+        return success ? 0 : 1;
+    }
+
+    static Payload ReadPayload(string json)
+    {
+        using var document = JsonDocument.Parse(json);
+        if (document.RootElement.ValueKind != JsonValueKind.Object || document.RootElement.EnumerateObject().Select(property => property.Name).Distinct(StringComparer.Ordinal).Count() != document.RootElement.EnumerateObject().Count())
+            throw new InvalidOperationException("Payload manifest must contain one unambiguous JSON object.");
+        var payload = JsonSerializer.Deserialize<Payload>(json, JsonOptions) ?? throw new InvalidOperationException("Missing guest payload manifest.");
+        if (!Hex(payload.RunToken, 32) || !Hex(payload.SourceCommit, 40) || !Hex(payload.ArchiveSha256, 64) || payload.SdkVersion != SdkVersion || payload.SdkSha512 != SdkSha512 || payload.ExpectedTests != ExpectedTests)
+            throw new InvalidOperationException("Guest payload identity, SDK pin or expected test count is invalid.");
+        return payload;
+    }
+
+    static void ValidateArchive(Stream stream, string commit)
+    {
+        using var reader = new TarReader(stream, leaveOpen: true);
+        var names = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        var commits = new List<string>();
+        long totalBytes = 0;
+        while (reader.GetNextEntry() is { } entry)
+        {
+            if (entry is PaxGlobalExtendedAttributesTarEntry global)
+            {
+                if (global.GlobalExtendedAttributes.TryGetValue("comment", out var value)) commits.Add(value);
+                if (global.GlobalExtendedAttributes.Keys.Any(key => key is "path" or "linkpath"))
+                    throw new InvalidOperationException("Global tar path overrides are not supported.");
+                continue;
+            }
+            if (entry.EntryType is not (TarEntryType.RegularFile or TarEntryType.V7RegularFile or TarEntryType.Directory))
+                throw new InvalidOperationException("Source tar contains a link or unsupported entry type: " + entry.Name);
+            var name = entry.Name.TrimEnd('/');
+            if (name.Length == 0 || name.StartsWith('/') || name.Contains('\\') || name.Contains('\0') || name.Split('/').Any(part => part.Length == 0 || part is "." or ".." or ".git" or "bin" or "obj") || !names.Add(name))
+                throw new InvalidOperationException("Source tar path is unsafe, repeated or contains generated output: " + entry.Name);
+            totalBytes = checked(totalBytes + entry.Length);
+            if (names.Count > 100_000 || totalBytes > 2L * 1024 * 1024 * 1024)
+                throw new InvalidOperationException("Source tar exceeds its explicit entry/size budget.");
+        }
+        if (names.Count == 0 || commits.Count != 1 || commits[0] != commit || !names.Contains("MeetingAssistant.Tests/MeetingAssistant.Tests.csproj"))
+            throw new InvalidOperationException("Source tar does not prove its exact Git commit and test project.");
+    }
+
+    static TestSummary ValidateTrx(string xml, int expected, DateTimeOffset testStarted) => ValidateTrx(Encoding.UTF8.GetBytes(xml), expected, testStarted);
+    static TestSummary ValidateTrx(byte[] xml, int expected, DateTimeOffset testStarted)
+    {
+        var document = ParseXml(xml);
+        var root = document.Root ?? throw new InvalidOperationException("Empty TRX.");
+        XNamespace ns = "http://microsoft.com/schemas/VisualStudio/TeamTest/2010";
+        if (root.Name != ns + "TestRun") throw new InvalidOperationException("Unexpected TRX namespace or root.");
+        var times = root.Element(ns + "Times") ?? throw new InvalidOperationException("TRX lacks execution timestamps.");
+        if (!DateTimeOffset.TryParse((string?)times.Attribute("start"), out var start) || !DateTimeOffset.TryParse((string?)times.Attribute("finish"), out var finish) || start < testStarted.AddSeconds(-2) || finish < start || finish > DateTimeOffset.UtcNow.AddSeconds(30))
+            throw new InvalidOperationException("TRX belongs to a stale or invalid test execution.");
+        var resultSummary = root.Element(ns + "ResultSummary") ?? throw new InvalidOperationException("TRX lacks a final result summary.");
+        if ((string?)resultSummary.Attribute("outcome") != "Completed") throw new InvalidOperationException("TRX test run did not complete.");
+        var counters = resultSummary.Element(ns + "Counters") ?? throw new InvalidOperationException("TRX lacks final counters.");
+        int Count(string name) => int.TryParse((string?)counters.Attribute(name), out var value) && value >= 0 ? value : throw new InvalidOperationException("TRX lacks a valid counter: " + name);
+        var total = Count("total");
+        var executed = Count("executed");
+        var passed = Count("passed");
+        var failed = Count("failed");
+        var notExecuted = Count("notExecuted");
+        foreach (var name in new[] { "error", "timeout", "aborted", "inconclusive", "passedButRunAborted", "notRunnable", "disconnected", "inProgress", "pending" })
+            if (counters.Attribute(name) is not null && Count(name) != 0) throw new InvalidOperationException("TRX contains an incomplete or unsuccessful execution: " + name);
+        if (expected != ExpectedTests || total != expected || executed != expected || passed != expected || failed != 0 || notExecuted != 0)
+            throw new InvalidOperationException($"Native TRX must prove {expected} total/executed/passed tests, zero failures and zero skips; got {total}/{executed}/{passed}/{failed}/{notExecuted}.");
+        var definitions = new Dictionary<string, string>(StringComparer.Ordinal);
+        foreach (var unit in root.Element(ns + "TestDefinitions")?.Elements(ns + "UnitTest") ?? [])
+        {
+            var method = unit.Element(ns + "TestMethod") ?? throw new InvalidOperationException("TRX test definition lacks its method identity.");
+            var className = ((string?)method.Attribute("className") ?? "").Split(',')[0].Trim();
+            var methodName = (string?)method.Attribute("name") ?? "";
+            var id = (string?)unit.Attribute("id") ?? "";
+            if (id.Length == 0 || className.Length == 0 || methodName.Length == 0 || !definitions.TryAdd(id, methodName.StartsWith(className + ".", StringComparison.Ordinal) ? methodName : className + "." + methodName))
+                throw new InvalidOperationException("TRX contains an ambiguous test definition.");
+        }
+        var results = root.Element(ns + "Results")?.Elements(ns + "UnitTestResult").ToArray() ?? [];
+        var executionIds = new HashSet<string>(StringComparer.Ordinal);
+        var testIds = new HashSet<string>(StringComparer.Ordinal);
+        var native = new List<string>();
+        foreach (var result in results)
+        {
+            var id = (string?)result.Attribute("testId") ?? "";
+            var executionId = (string?)result.Attribute("executionId") ?? "";
+            if ((string?)result.Attribute("outcome") != "Passed" || executionId.Length == 0 || !executionIds.Add(executionId) || !testIds.Add(id) || !definitions.TryGetValue(id, out var identity))
+                throw new InvalidOperationException("TRX has a missing, duplicate or non-passed execution.");
+            if (RequiredNativeTests.Contains(identity, StringComparer.Ordinal)) native.Add(identity);
+        }
+        if (definitions.Count != expected || results.Length != expected || native.Count != RequiredNativeTests.Length || !native.Order().SequenceEqual(RequiredNativeTests.Order()))
+            throw new InvalidOperationException("TRX does not prove every expected test definition exactly once and the five explicit native macOS tests.");
+        return new(total, executed, passed, failed, notExecuted, native.ToArray());
+    }
+
+    static void ValidateResult(FullResult result, Payload payload)
+    {
+        if (result.Token != payload.RunToken || !result.Success || result.SourceCommit != payload.SourceCommit || result.ArchiveSha256 != payload.ArchiveSha256 || !Version.TryParse(result.OsVersion, out var version) || version.Major < 14 || result.Architecture != "x86_64" || result.SdkVersion != SdkVersion || result.ExpectedTests != ExpectedTests || result.Total != ExpectedTests || result.Executed != ExpectedTests || result.Passed != ExpectedTests || result.Failed != 0 || result.NotExecuted != 0 || !result.NativeTests.Order().SequenceEqual(RequiredNativeTests.Order()) || result.AudioCodeSignExit != 0 || !Hex(result.TrxSha256, 64) || result.NativeArtifacts.Length != NativeNames.Length || !result.NativeArtifacts.Select(artifact => artifact.Name).Order().SequenceEqual(NativeNames.Order()) || result.NativeArtifacts.Any(artifact => artifact.Architecture != "x86_64" || !Hex(artifact.Sha256, 64)) || result.CompletedUtc < result.StartedUtc || result.CompletedUtc - result.StartedUtc > TimeSpan.FromMinutes(25).Add(TimeSpan.FromSeconds(15)) || result.CompletedUtc > DateTimeOffset.UtcNow.AddSeconds(30) || result.CompletedUtc < DateTimeOffset.UtcNow.AddMinutes(-1) || result.Reason.Length != 0)
+            throw new InvalidOperationException("Native guest receipt does not prove this source, toolchain, signed artifacts and all expected tests.");
+    }
+
+    static void RequirePlatform(string version, string architecture, string uid)
+    {
+        if (!Version.TryParse(version, out var parsed) || parsed.Major < 14 || architecture != "x86_64" || uid != "0")
+            throw new InvalidOperationException("Native build requires installed macOS 14+/x86_64 running as root.");
+    }
+    static void RequireApfs(string xml)
+    {
+        var elements = ParseXml(xml).Root?.Element("dict")?.Elements().ToArray() ?? [];
+        var type = elements.Select((element, index) => (element, index)).FirstOrDefault(pair => pair.element.Name == "key" && pair.element.Value == "FilesystemType");
+        if (type.element is null || type.index + 1 >= elements.Length || elements[type.index + 1].Name != "string" || elements[type.index + 1].Value != "apfs")
+            throw new InvalidOperationException("Native build must run from the installed APFS system and owned APFS work volume.");
+    }
+    static void RequireNativeArtifact(string fileOutput, string architecture)
+    {
+        if (!fileOutput.Contains("Mach-O", StringComparison.Ordinal) || !fileOutput.Contains("x86_64", StringComparison.Ordinal) || architecture != "x86_64")
+            throw new InvalidOperationException("Native helper is not a Mach-O executable containing exactly x86_64.");
+    }
+    static void RequireAbsent(string path)
+    {
+        if (Path.Exists(path) || GetAttributesSafe(path)?.HasFlag(FileAttributes.ReparsePoint) == true)
+            throw new InvalidOperationException("Fresh guest execution refuses pre-existing output: " + path);
+    }
+    static void RequireFreshFile(string path, DateTimeOffset started, long maximumBytes = long.MaxValue)
+    {
+        RequireNoLinks(path);
+        var file = new FileInfo(path);
+        if (!file.Exists || file.Length == 0 || file.Length > maximumBytes || file.LastWriteTimeUtc < started.UtcDateTime.AddSeconds(-2))
+            throw new InvalidOperationException("Expected a fresh, nonempty, bounded output from this execution: " + path);
+    }
+    static void RequireNoLinks(string path)
+    {
+        for (var current = Path.GetFullPath(path); current is not null; current = Path.GetDirectoryName(current))
+            if (GetAttributesSafe(current)?.HasFlag(FileAttributes.ReparsePoint) == true)
+                throw new InvalidOperationException("Guest ownership/extraction refuses a symbolic link: " + current);
+    }
+    static FileAttributes? GetAttributesSafe(string path)
+    {
+        try { return File.GetAttributes(path); }
+        catch (FileNotFoundException) { return null; }
+        catch (DirectoryNotFoundException) { return null; }
+    }
+    static XDocument ParseXml(string xml) => ParseXml(Encoding.UTF8.GetBytes(xml));
+    static XDocument ParseXml(byte[] xml)
+    {
+        using var stream = new MemoryStream(xml, writable: false);
+        using var reader = XmlReader.Create(stream, new XmlReaderSettings { DtdProcessing = DtdProcessing.Ignore, XmlResolver = null, MaxCharactersInDocument = 16 * 1024 * 1024 });
+        return XDocument.Load(reader);
+    }
+    static bool Hex(string? value, int length) => value is not null && Regex.IsMatch(value, "^[0-9a-f]{" + length + "}$");
+    static async Task<string> HashFile(string path, bool sha512, CancellationToken cancellation)
+    {
+        using var stream = File.OpenRead(path);
+        var hash = sha512 ? await SHA512.HashDataAsync(stream, cancellation) : await SHA256.HashDataAsync(stream, cancellation);
+        return Convert.ToHexStringLower(hash);
+    }
+    static void Save(string path, object value)
+    {
+        RequireNoLinks(path);
+        var temporary = path + ".tmp";
+        RequireNoLinks(temporary);
+        File.WriteAllText(temporary, JsonSerializer.Serialize(value, JsonOptions), new UTF8Encoding(false));
+        File.Move(temporary, path, overwrite: true);
+    }
+
+    static async Task<CommandResult> Command(string executable, string[] arguments, string source, string work, string logs, string label, CancellationToken cancellation, bool requireSuccess)
+    {
+        Console.WriteLine("[native-guest] " + label);
+        using var commandCancellation = CancellationTokenSource.CreateLinkedTokenSource(cancellation);
+        var token = commandCancellation.Token;
+        var start = new ProcessStartInfo(executable) { WorkingDirectory = Directory.Exists(source) ? source : work, RedirectStandardOutput = true, RedirectStandardError = true, UseShellExecute = false };
+        foreach (var argument in arguments) start.ArgumentList.Add(argument);
+        start.Environment.Clear();
+        foreach (var pair in new Dictionary<string, string>
+        {
+            ["PATH"] = Path.Combine(work, "dotnet") + ":/usr/bin:/bin:/usr/sbin:/sbin",
+            ["TMPDIR"] = Path.Combine(work, "tmp"),
+            ["DOTNET_ROOT"] = Path.Combine(work, "dotnet"), ["DOTNET_CLI_HOME"] = Path.Combine(work, "home"),
+            ["NUGET_PACKAGES"] = Path.Combine(work, "packages"), ["TZ"] = "Europe/Berlin",
+            ["LANG"] = "en_US.UTF-8", ["LC_ALL"] = "en_US.UTF-8", ["DOTNET_CLI_TELEMETRY_OPTOUT"] = "1",
+            ["DOTNET_NOLOGO"] = "1", ["DOTNET_SKIP_FIRST_TIME_EXPERIENCE"] = "1", ["MSBUILDDISABLENODEREUSE"] = "1"
+        }) start.Environment[pair.Key] = pair.Value;
+        using var process = Process.Start(start) ?? throw new InvalidOperationException("Cannot start guest command: " + label);
+        long capturedBytes = 0;
+        async Task<string> Read(StreamReader reader, string stream)
+        {
+            var captured = new StringBuilder();
+            var buffer = new char[8192];
+            using var log = new StreamWriter(Path.Combine(logs, label + "." + stream + ".log"), false, new UTF8Encoding(false));
+            while (true)
+            {
+                var count = await reader.ReadAsync(buffer.AsMemory(), token);
+                if (count == 0) break;
+                if (Interlocked.Add(ref capturedBytes, Encoding.UTF8.GetByteCount(buffer.AsSpan(0, count))) > MaximumLogBytes)
+                {
+                    commandCancellation.Cancel();
+                    throw new InvalidOperationException(label + " exceeded its combined 8-MiB output budget.");
+                }
+                captured.Append(buffer, 0, count);
+                await log.WriteAsync(buffer.AsMemory(0, count), token);
+                await log.FlushAsync(token);
+            }
+            return captured.ToString();
+        }
+        var stdout = Read(process.StandardOutput, "stdout");
+        var stderr = Read(process.StandardError, "stderr");
+        try
+        {
+            await Task.WhenAll(stdout, stderr, process.WaitForExitAsync(token));
+            var result = new CommandResult(process.ExitCode, await stdout, await stderr);
+            if (requireSuccess && result.ExitCode != 0)
+                throw new InvalidOperationException($"{label} exited {result.ExitCode}: {result.Error[..Math.Min(result.Error.Length, 1500)]}");
+            return result;
+        }
+        catch
+        {
+            try { if (!process.HasExited) process.Kill(entireProcessTree: true); } catch (InvalidOperationException) { }
+            using var killDeadline = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+            try { await process.WaitForExitAsync(killDeadline.Token); } catch (OperationCanceledException) { }
+            throw;
+        }
+    }
+
+    static void ValidateContracts()
+    {
+        var payload = new Payload(new string('a', 32), new string('b', 40), new string('c', 64), SdkVersion, SdkSha512, ExpectedTests);
+        var json = JsonSerializer.Serialize(payload, JsonOptions);
+        ReadPayload(json);
+        Reject(() => ReadPayload(json.Replace(SdkVersion, "10.0.100", StringComparison.Ordinal)));
+        Reject(() => ReadPayload(json.Replace(SdkSha512, new string('d', 128), StringComparison.Ordinal)));
+        Reject(() => ReadPayload(json.Replace("577", "572", StringComparison.Ordinal)));
+        Reject(() => ReadPayload(json.Replace(payload.RunToken, "stale", StringComparison.Ordinal)));
+        Reject(() => ReadPayload(json.Replace(payload.ArchiveSha256, "invalid", StringComparison.Ordinal)));
+        RequirePlatform("14.6.1", "x86_64", "0");
+        Reject(() => RequirePlatform("13.6.1", "x86_64", "0"));
+        Reject(() => RequirePlatform("14.6.1", "arm64", "0"));
+        Reject(() => RequirePlatform("14.6.1", "x86_64", "501"));
+        RequireApfs("<plist><dict><key>FilesystemType</key><string>apfs</string></dict></plist>");
+        Reject(() => RequireApfs("<plist><dict><key>FilesystemType</key><string>hfs</string></dict></plist>"));
+        RequireNativeArtifact("Mach-O 64-bit executable x86_64", "x86_64");
+        Reject(() => RequireNativeArtifact("Mach-O universal binary x86_64 arm64", "x86_64 arm64"));
+        Reject(() => RequireNativeArtifact("ELF 64-bit executable x86_64", "x86_64"));
+        using (var archive = FixtureArchive(payload.SourceCommit)) ValidateArchive(archive, payload.SourceCommit);
+        foreach (var path in new[] { "../escape", "/absolute", "safe/../escape", "safe\\escape", "MeetingAssistant/bin/stale" })
+            Reject(() => { using var archive = FixtureArchive(payload.SourceCommit, path); ValidateArchive(archive, payload.SourceCommit); });
+        Reject(() => { using var archive = FixtureArchive(payload.SourceCommit, "link", true); ValidateArchive(archive, payload.SourceCommit); });
+        Reject(() => { using var archive = FixtureArchive(new string('d', 40)); ValidateArchive(archive, payload.SourceCommit); });
+        var started = DateTimeOffset.UtcNow.AddMinutes(-1);
+        var fixture = FixtureTrx(started);
+        var summary = ValidateTrx(fixture.ToString(), ExpectedTests, started);
+        var plainTrx = Encoding.UTF8.GetBytes(fixture.ToString());
+        var bomTrx = new byte[] { 0xef, 0xbb, 0xbf }.Concat(plainTrx).ToArray();
+        ValidateTrx(bomTrx, ExpectedTests, started);
+        if (SHA256.HashData(plainTrx).SequenceEqual(SHA256.HashData(bomTrx))) throw new InvalidOperationException("TRX raw-byte hashing discarded its BOM.");
+        Reject(() => ValidateTrx(fixture.ToString(), ExpectedTests, started.AddMinutes(2)));
+        XNamespace ns = fixture.Root!.Name.Namespace;
+        var skipped = new XDocument(fixture);
+        skipped.Descendants(ns + "UnitTestResult").First().SetAttributeValue("outcome", "NotExecuted");
+        Reject(() => ValidateTrx(skipped.ToString(), ExpectedTests, started));
+        var missingNative = new XDocument(fixture);
+        missingNative.Descendants(ns + "TestMethod").First().SetAttributeValue("name", "ManagedReplacement");
+        Reject(() => ValidateTrx(missingNative.ToString(), ExpectedTests, started));
+        var duplicate = new XDocument(fixture);
+        duplicate.Descendants(ns + "UnitTestResult").Last().SetAttributeValue("executionId", "execution-0");
+        Reject(() => ValidateTrx(duplicate.ToString(), ExpectedTests, started));
+        var repeatedManaged = new XDocument(fixture);
+        repeatedManaged.Descendants(ns + "UnitTestResult").Last().SetAttributeValue("testId", "test-5");
+        Reject(() => ValidateTrx(repeatedManaged.ToString(), ExpectedTests, started));
+        var unexecutedDefinition = new XDocument(fixture);
+        var extraDefinition = new XElement(unexecutedDefinition.Descendants(ns + "UnitTest").Last());
+        extraDefinition.SetAttributeValue("id", "unexecuted-test");
+        unexecutedDefinition.Root!.Element(ns + "TestDefinitions")!.Add(extraDefinition);
+        Reject(() => ValidateTrx(unexecutedDefinition.ToString(), ExpectedTests, started));
+        var missingDefinition = new XDocument(fixture);
+        missingDefinition.Descendants(ns + "UnitTest").Last().Remove();
+        Reject(() => ValidateTrx(missingDefinition.ToString(), ExpectedTests, started));
+        var theoryRows = new XDocument(fixture);
+        foreach (var method in theoryRows.Descendants(ns + "TestMethod").Skip(RequiredNativeTests.Length).Take(2))
+            method.SetAttributeValue("name", "TheoryWithDistinctRowIds");
+        ValidateTrx(theoryRows.ToString(), ExpectedTests, started);
+        var counters = new XDocument(fixture);
+        counters.Descendants(ns + "Counters").Single().SetAttributeValue("passed", "572");
+        Reject(() => ValidateTrx(counters.ToString(), ExpectedTests, started));
+        var aborted = new XDocument(fixture);
+        aborted.Descendants(ns + "ResultSummary").Single().SetAttributeValue("outcome", "Aborted");
+        Reject(() => ValidateTrx(aborted.ToString(), ExpectedTests, started));
+        var artifacts = NativeNames.Select(name => new NativeArtifact(name, new string('d', 64), "x86_64")).ToArray();
+        var result = new FullResult(payload.RunToken, true, payload.SourceCommit, payload.ArchiveSha256, "14.6.1", "x86_64", SdkVersion, ExpectedTests, summary.Total, summary.Executed, summary.Passed, summary.Failed, summary.NotExecuted, summary.NativeTests, artifacts, 0, new string('e', 64), "", started, DateTimeOffset.UtcNow);
+        ValidateResult(result, payload);
+        foreach (var invalid in new[] { result with { Token = new string('f', 32) }, result with { Success = false }, result with { SourceCommit = new string('f', 40) }, result with { ArchiveSha256 = new string('f', 64) }, result with { NotExecuted = 5 }, result with { AudioCodeSignExit = 1 }, result with { NativeTests = RequiredNativeTests[..4] }, result with { NativeArtifacts = artifacts[..3] }, result with { NativeArtifacts = [artifacts[0] with { Architecture = "arm64" }, .. artifacts[1..]] }, result with { TrxSha256 = "" }, result with { SdkVersion = "10.0.100" }, result with { OsVersion = "13.6.1" }, result with { StartedUtc = started.AddHours(-1) }, result with { StartedUtc = started.AddHours(-1), CompletedUtc = started.AddHours(-1).AddSeconds(1) } })
+            Reject(() => ValidateResult(invalid, payload));
+        var temporary = Path.Combine(OperatingSystem.IsMacOS() ? "/private/tmp" : Path.GetTempPath(), "meeting-assistant-guest-validation-" + Guid.NewGuid().ToString("N"));
+        try
+        {
+            RequireAbsent(temporary);
+            Directory.CreateDirectory(temporary);
+            Reject(() => RequireAbsent(temporary));
+            var file = Path.Combine(temporary, "fresh.trx");
+            File.WriteAllText(file, "fixture");
+            RequireFreshFile(file, started);
+            Reject(() => RequireFreshFile(file, started, 1));
+            File.SetLastWriteTimeUtc(file, started.UtcDateTime.AddMinutes(-5));
+            Reject(() => RequireFreshFile(file, started));
+            File.Delete(file);
+        }
+        finally { if (Directory.Exists(temporary)) Directory.Delete(temporary, recursive: true); }
+    }
+
+    static MemoryStream FixtureArchive(string commit, string? extra = null, bool link = false)
+    {
+        var stream = new MemoryStream();
+        using (var writer = new TarWriter(stream, TarEntryFormat.Pax, leaveOpen: true))
+        {
+            writer.WriteEntry(new PaxGlobalExtendedAttributesTarEntry(new Dictionary<string, string> { ["comment"] = commit }));
+            writer.WriteEntry(new PaxTarEntry(TarEntryType.RegularFile, "MeetingAssistant.Tests/MeetingAssistant.Tests.csproj") { DataStream = new MemoryStream(Encoding.UTF8.GetBytes("<Project />")) });
+            if (extra is not null)
+            {
+                var entry = new PaxTarEntry(link ? TarEntryType.SymbolicLink : TarEntryType.RegularFile, extra);
+                if (link) entry.LinkName = "../outside";
+                else entry.DataStream = new MemoryStream([1]);
+                writer.WriteEntry(entry);
+            }
+        }
+        stream.Position = 0;
+        return stream;
+    }
+    static XDocument FixtureTrx(DateTimeOffset started)
+    {
+        XNamespace ns = "http://microsoft.com/schemas/VisualStudio/TeamTest/2010";
+        var definitions = new XElement(ns + "TestDefinitions");
+        var results = new XElement(ns + "Results");
+        for (var index = 0; index < ExpectedTests; index++)
+        {
+            var identity = index < RequiredNativeTests.Length ? RequiredNativeTests[index] : "MeetingAssistant.Tests.ManagedTests.Test" + index;
+            var separator = identity.LastIndexOf('.');
+            definitions.Add(new XElement(ns + "UnitTest", new XAttribute("id", "test-" + index), new XElement(ns + "TestMethod", new XAttribute("className", identity[..separator] + ", MeetingAssistant.Tests"), new XAttribute("name", identity[(separator + 1)..]))));
+            results.Add(new XElement(ns + "UnitTestResult", new XAttribute("testId", "test-" + index), new XAttribute("executionId", "execution-" + index), new XAttribute("outcome", "Passed")));
+        }
+        return new XDocument(new XElement(ns + "TestRun", new XElement(ns + "Times", new XAttribute("start", started.ToString("O")), new XAttribute("finish", started.AddSeconds(1).ToString("O"))), definitions, results, new XElement(ns + "ResultSummary", new XAttribute("outcome", "Completed"), new XElement(ns + "Counters", new XAttribute("total", ExpectedTests), new XAttribute("executed", ExpectedTests), new XAttribute("passed", ExpectedTests), new XAttribute("failed", 0), new XAttribute("notExecuted", 0)))));
+    }
+    static void Reject(Action action)
+    {
+        try { action(); }
+        catch (InvalidOperationException) { return; }
+        throw new InvalidOperationException("Contract validation accepted an invalid or stale fixture.");
+    }
+    sealed record Payload(string RunToken, string SourceCommit, string ArchiveSha256, string SdkVersion, string SdkSha512, int ExpectedTests);
+    sealed record NativeArtifact(string Name, string Sha256, string Architecture);
+    sealed record TestSummary(int Total, int Executed, int Passed, int Failed, int NotExecuted, string[] NativeTests);
+    sealed record FullResult(string Token, bool Success, string SourceCommit, string ArchiveSha256, string OsVersion, string Architecture, string SdkVersion, int ExpectedTests, int Total, int Executed, int Passed, int Failed, int NotExecuted, string[] NativeTests, NativeArtifact[] NativeArtifacts, int AudioCodeSignExit, string TrxSha256, string Reason, DateTimeOffset StartedUtc, DateTimeOffset CompletedUtc);
+    sealed record CommandResult(int ExitCode, string Output, string Error);
+}
@@ -0,0 +1,33 @@
+#!/bin/bash
+# Apple pre-.NET boot seam, sourced in Recovery and on installed first boot.
+# A match requires the exact run-owned emulated serial, one whole writable 64-GiB disk.
+verify_owned_disk() {
+  local disk="$1" state="$2" token="$3" info serial matches bytes
+  [[ "$disk" =~ ^/dev/disk[0-9]+$ && "$token" =~ ^[0-9a-f]{32}$ ]] || return 1
+  [ "$(cat "$state/run.owner" 2>/dev/null)" = "$token" ] || return 1
+  serial="${token:0:20}"
+  /usr/sbin/diskutil list physical > "$state/disk-list-current.log" 2>&1 || return 1
+  /usr/bin/grep -Eq "^$disk[[:space:]].*physical" "$state/disk-list-current.log" || return 1
+  /usr/sbin/diskutil info "$disk" > "$state/disk-info-current.log" 2>&1 || return 1
+  info=$(cat "$state/disk-info-current.log")
+  printf '%s\n' "$info" | /usr/bin/grep -Eq '^[[:space:]]*Whole:[[:space:]]*Yes' || return 1
+  printf '%s\n' "$info" | /usr/bin/grep -Eq '^[[:space:]]*(Read-Only (Media|Device)|(Media|Device) Read-Only):[[:space:]]*Yes' && return 1
+  printf '%s\n' "$info" | /usr/bin/grep -Eq '^[[:space:]]*(Read-Only (Media|Device)|(Media|Device) Read-Only):[[:space:]]*No' || return 1
+  bytes=$(printf '%s\n' "$info" | /usr/bin/sed -nE 's/^[[:space:]]*Disk Size:.*\(([0-9]+) Bytes\).*/\1/p')
+  [ "$bytes" = 68719476736 ] || return 1
+  /usr/sbin/ioreg -r -c IOBlockStorageDevice -l -w 0 > "$state/disk-ownership-ioreg.log" 2>&1 || return 1
+  matches=$(/usr/bin/awk -v expected="$serial" -v disk="${disk#/dev/}" '
+    function finish_root() { if (serialCount == 1 && serial == expected && ownedDisk) found++ }
+    /^\+-o/ { finish_root(); serial=""; serialCount=0; ownedDisk=0 }
+    /"Serial Number"[[:space:]]*=[[:space:]]*"/ {
+      serialCount++; serial=$0; sub(/^.*"Serial Number"[[:space:]]*=[[:space:]]*"/, "", serial); sub(/".*$/, "", serial); sub(/[[:space:]]+$/, "", serial)
+    }
+    /"BSD Name"[[:space:]]*=[[:space:]]*"/ {
+      name=$0; sub(/^.*"BSD Name"[[:space:]]*=[[:space:]]*"/, "", name); sub(/".*$/, "", name)
+      if (name == disk) ownedDisk=1
+    }
+    END { finish_root(); print found+0 }
+  ' "$state/disk-ownership-ioreg.log")
+  [ "$matches" = 1 ] || return 1
+  printf '[owned-disk] %s serial=%s bytes=%s\n' "$disk" "$serial" "$bytes"
+}
@@ -0,0 +1,100 @@
+#!/bin/bash
+# Apple LaunchDaemon bootstrap before the guest .NET SDK exists.
+# Runs only inside the isolated owned VM; installs CLT and expands the pinned SDK.
+set -u
+PATH="/usr/bin:/bin:/usr/sbin:/sbin"
+export PATH
+PROOF_TOKEN="${1:-}"
+STATE_DIR="/Volumes/installstate"
+WORK="/private/var/tmp/meeting-assistant-native-$PROOF_TOKEN"
+[[ "$PROOF_TOKEN" =~ ^[0-9a-f]{32}$ ]] || exit 1
+[ "$(cat "$STATE_DIR/run.owner" 2>/dev/null)" = "$PROOF_TOKEN" ] || exit 1
+exec >> "$STATE_DIR/firstboot.log" 2>&1
+
+phase() {
+  printf '{"token":"%s","phase":"%s","updatedUtc":"%s"}\n' "$PROOF_TOKEN" "$1" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" > "$STATE_DIR/guest-phase.json.tmp"
+  mv -f "$STATE_DIR/guest-phase.json.tmp" "$STATE_DIR/guest-phase.json"
+}
+fail() { printf '[firstboot] ERROR: %s\n' "$1"; phase bootstrap-failed; exit 1; }
+require_installed_macos_version() {
+  # Numeric sw_vers product release with a major version of at least 14.
+  [[ "${1:-}" =~ ^(1[4-9]|[2-9][0-9]|[1-9][0-9]{2,})\.[0-9]+(\.[0-9]+)?$ ]]
+}
+phase toolchain-installing
+echo '[firstboot] verifying installed OS, APFS and owned physical store'
+uname -a; id
+installed_version=$(/usr/bin/sw_vers -productVersion) || fail installed_os_version_failed
+require_installed_macos_version "$installed_version" || fail installed_macos_14_or_newer_required
+printf '[firstboot] installed macOS version=%s\n' "$installed_version"
+[ "$(id -u)" = 0 ] && [ "$(uname -m)" = x86_64 ] || fail wrong_guest_platform
+/usr/sbin/diskutil info -plist / > "$STATE_DIR/installed-root.plist" || fail root_diskutil_failed
+[ "$(/usr/libexec/PlistBuddy -c 'Print :FilesystemType' "$STATE_DIR/installed-root.plist")" = apfs ] || fail root_is_not_installed_apfs
+container=$(/usr/libexec/PlistBuddy -c 'Print :APFSContainerReference' "$STATE_DIR/installed-root.plist") || fail root_container_missing
+/usr/sbin/diskutil apfs list -plist > "$STATE_DIR/apfs-containers.plist" || fail apfs_list_failed
+index=0
+physical=""
+while reference=$(/usr/libexec/PlistBuddy -c "Print :Containers:$index:ContainerReference" "$STATE_DIR/apfs-containers.plist" 2>/dev/null); do
+  if [ "$reference" = "$container" ]; then
+    [ -z "$physical" ] || fail ambiguous_root_containers
+    physical=$(/usr/libexec/PlistBuddy -c "Print :Containers:$index:PhysicalStores:0:DeviceIdentifier" "$STATE_DIR/apfs-containers.plist") || fail physical_store_missing
+    /usr/libexec/PlistBuddy -c "Print :Containers:$index:PhysicalStores:1" "$STATE_DIR/apfs-containers.plist" >/dev/null 2>&1 && fail multiple_physical_stores
+  fi
+  index=$((index + 1))
+done
+[[ "$physical" =~ ^disk[0-9]+s[0-9]+$ ]] || fail invalid_physical_store
+/usr/sbin/diskutil info -plist "/dev/$physical" > "$STATE_DIR/physical-store.plist" || fail physical_store_info_failed
+whole=$(/usr/libexec/PlistBuddy -c 'Print :ParentWholeDisk' "$STATE_DIR/physical-store.plist") || fail physical_parent_missing
+. "$STATE_DIR/macos-native-disk-guard.sh"
+verify_owned_disk "/dev/$whole" "$STATE_DIR" "$PROOF_TOKEN" || fail installed_root_is_not_the_owned_64g_disk
+
+# The phase has an independent 30-minute watchdog; host outer deadline is 180 minutes.
+parent=$$
+(
+  trap 'kill "$sleeper" 2>/dev/null || :; exit 0' TERM INT
+  # Toolchain watchdog: 30 minutes, also bounded by the host's 172-minute total.
+  sleep 1800 & sleeper=$!; wait "$sleeper"; kill -TERM "$parent" 2>/dev/null || :
+) & watchdog=$!
+clt_marker="/tmp/.com.apple.dt.CommandLineTools.installondemand.in-progress"
+trap 'rm -f "$clt_marker"; kill -TERM "$watchdog" 2>/dev/null || :; wait "$watchdog" 2>/dev/null || :' EXIT
+trap 'fail toolchain_deadline_or_cancellation' TERM INT
+[ ! -e "$WORK" ] || fail guest_work_directory_already_exists
+mkdir -p "$WORK" || fail guest_work_directory_failed
+printf '%s\n' "$PROOF_TOKEN" > "$WORK/run.owner" || fail guest_work_owner_failed
+free_kib=$(df -Pk "$WORK" | awk 'NR==2 {print $4}')
+[[ "$free_kib" =~ ^[0-9]+$ ]] && (( free_kib >= 8 * 1024 * 1024 )) || fail insufficient_existing_guest_free_space
+
+echo '[firstboot] installing a compatible Apple CLT catalog entry without a GUI'
+touch "$clt_marker" || fail clt_marker_failed
+/usr/sbin/softwareupdate -l > "$STATE_DIR/clt-catalog.log" 2>&1 || fail clt_catalog_failed
+label=$(grep -B 1 -E 'Command Line Tools' "$STATE_DIR/clt-catalog.log" | awk -F'*' '/^ *\*/ {print $2}' | sed -e 's/^ *Label: //' -e 's/^ *//' | sort -V | tail -n 1)
+[ -n "$label" ] || fail no_compatible_headless_clt_label
+printf '[firstboot] selected CLT: %s\n' "$label"
+/usr/sbin/softwareupdate -i "$label" > "$STATE_DIR/clt-install.log" 2>&1 || fail clt_install_failed
+/usr/bin/xcode-select --switch /Library/Developer/CommandLineTools || fail clt_switch_failed
+/usr/sbin/pkgutil --pkg-info=com.apple.pkg.CLTools_Executables || fail clt_receipt_failed
+/usr/bin/xcrun --find swiftc || fail swiftc_missing
+/usr/bin/xcrun swiftc --version || fail swiftc_version_failed
+{
+  /usr/bin/xcrun --sdk macosx --show-sdk-version &&
+  /usr/bin/xcrun --sdk macosx --show-sdk-path
+} > "$STATE_DIR/clt-sdk.log" 2>&1 || fail clt_sdk_identity_failed
+printf 'import AppKit\nimport AVFoundation\nimport ScreenCaptureKit\nimport EventKit\nimport WebKit\nprint("native SDK ready")\n' > "$WORK/toolchain-smoke.swift"
+/usr/bin/xcrun swiftc -target x86_64-apple-macos13.0 "$WORK/toolchain-smoke.swift" -o "$WORK/toolchain-smoke" || fail native_framework_compile_failed
+"$WORK/toolchain-smoke" || fail native_framework_execution_failed
+rm -f "$clt_marker"
+
+echo '[firstboot] validating and expanding the pinned .NET SDK on owned APFS'
+expected_sdk=33401b4a2da8554e3306db6072ea8569d9fcc608509c271e0aa4b39e7cc432da3631f14e7e1e2445d67d72550d18ce44a8bbd2382a756867ad2edab6b1c963c0
+actual_sdk=$(shasum -a 512 "$STATE_DIR/sdk.tar.gz" | awk '{print $1}')
+[ "$actual_sdk" = "$expected_sdk" ] || fail sdk_hash_mismatch
+mkdir "$WORK/dotnet" || fail sdk_directory_failed
+tar -xzf "$STATE_DIR/sdk.tar.gz" -C "$WORK/dotnet" || fail sdk_extract_failed
+[ "$("$WORK/dotnet/dotnet" --version)" = 10.0.401 ] || fail sdk_version_mismatch
+# Guest C# owns build/test deadlines from this point; stop the CLT-only watchdog.
+kill -TERM "$watchdog" 2>/dev/null || :
+wait "$watchdog" 2>/dev/null || :
+trap - TERM INT
+"$WORK/dotnet/dotnet" run --file "$STATE_DIR/MacOsNativeGuest.cs" -- --run --state "$STATE_DIR" --work "$WORK"
+result=$?
+(( result == 0 )) || fail native_tests_failed
+exit 0
@@ -0,0 +1,72 @@
+#!/bin/bash
+# Full-only pre-.NET seam. Claim one persistent owned probe before forking;
+# launchd then execs the original Apple daemon, including on a real failure.
+set -u
+PROOF_TOKEN="@@PROOF_TOKEN@@"
+STATE_DIR="/Volumes/installstate"
+MARKER="$STATE_DIR/probe.started"
+
+bootstrap_failed() {
+  printf '[full-bootstrap] ERROR: %s\n' "$1" >&2
+  [ "$(cat "$STATE_DIR/run.owner" 2>/dev/null)" = "$PROOF_TOKEN" ] || return 1
+  printf '{"token":"%s","phase":"bootstrap-failed","reason":"%s"}\n' "$PROOF_TOKEN" "$1" > "$STATE_DIR/guest-phase.bootstrap.$$.tmp" &&
+    /bin/mv -f "$STATE_DIR/guest-phase.bootstrap.$$.tmp" "$STATE_DIR/guest-phase.json"
+}
+
+wait_for_owned_state() {
+  local count=0
+  while :; do
+    if [ -e "$STATE_DIR/run.owner" ] || [ -L "$STATE_DIR/run.owner" ]; then
+      [ -f "$STATE_DIR/run.owner" ] && [ ! -L "$STATE_DIR/run.owner" ] &&
+        [ "$(cat "$STATE_DIR/run.owner" 2>/dev/null)" = "$PROOF_TOKEN" ] || {
+          bootstrap_failed foreign_state_owner
+          return 1
+        }
+      return 0
+    fi
+    if (( count >= 120 )); then
+      bootstrap_failed state_share_mount_timeout
+      return 1
+    fi
+    /sbin/mount_9p installstate >/dev/null 2>&1 || :
+    count=$((count + 1))
+    sleep 1
+  done
+}
+
+owns_probe_marker() {
+  local record extra
+  [ -f "$MARKER" ] && [ ! -L "$MARKER" ] || return 1
+  {
+    IFS= read -r record || return 1
+    if IFS= read -r extra || [ -n "$extra" ]; then return 1; fi
+  } < "$MARKER"
+  [ "$record" = "$PROOF_TOKEN:$source_commit" ]
+}
+
+claim_probe() {
+  [[ "$PROOF_TOKEN" =~ ^[0-9a-f]{32}$ ]] || { bootstrap_failed invalid_probe_token; return 1; }
+  [ "$(cat "$STATE_DIR/run.owner" 2>/dev/null)" = "$PROOF_TOKEN" ] || { bootstrap_failed foreign_state_owner; return 1; }
+  source_commit=$(cat "$STATE_DIR/source.commit" 2>/dev/null) || { bootstrap_failed source_commit_missing; return 1; }
+  [[ "$source_commit" =~ ^[0-9a-f]{40}$ ]] || { bootstrap_failed source_commit_invalid; return 1; }
+  if [ -e "$MARKER" ] || [ -L "$MARKER" ]; then
+    owns_probe_marker || { bootstrap_failed foreign_or_invalid_probe_marker; return 1; }
+    return 2
+  fi
+  # Keep partial/failed markers: an incomplete first start is an error, no retry.
+  if ! ( set -o noclobber; printf '%s:%s\n' "$PROOF_TOKEN" "$source_commit" > "$MARKER" ); then
+    bootstrap_failed probe_marker_write_failed
+    return 1
+  fi
+  owns_probe_marker || { bootstrap_failed probe_marker_incomplete; return 1; }
+  return 0
+}
+
+if wait_for_owned_state && claim_probe; then
+  (
+    /bin/bash "$STATE_DIR/readiness.sh"
+    child_exit=$?
+    (( child_exit == 0 )) || bootstrap_failed first_probe_child_failed
+  ) &
+fi
+exec /usr/libexec/recoveryosd
@@ -99,31 +99,54 @@ read_scalar() {
  SCALAR="$value"
 }

-# BEGIN successful sw_vers version parser
-read_product_version() {
-  local value status line version="" fields=0
-  # Read the entire successful native output. EOF is mandatory; a NUL delimiter
-  # or reaching the 1025-byte sentinel must never hide a suffix.
-  LC_ALL=C IFS= read -r -n 1025 -d '' value < "$LAST_OUTPUT"; status=$?
-  (( status == 1 && ${#value} <= 1024 )) || return 1
-  while IFS= read -r line || [ -n "$line" ]; do
-    if [[ "$line" =~ ^[[:blank:]]*ProductVersion: ]]; then
-      fields=$((fields + 1))
-      (( fields == 1 )) || return 1
-      [[ "$line" =~ ^[[:blank:]]*ProductVersion:[[:blank:]]*([0-9]+\.[0-9]+(\.[0-9]+)?)[[:blank:]]*$ ]] || return 1
-      version="${BASH_REMATCH[1]}"
-    fi
-  done <<< "$value"
-  (( fields == 1 )) || return 1
-  SCALAR="$version"
+# BEGIN native SystemVersion plist request helpers
+read_native_system_version() {
+  # Recovery has Bash 3.2 before .NET. The numerical candidate is provisional;
+  # only the owned host's complete XML/evidence binding can qualify readiness.
+  local LC_ALL=C source="/System/Library/CoreServices/SystemVersion.plist"
+  local value status owner candidate remainder started=$SECONDS invalid_bytes
+  local raw="$STATE_DIR/native-system-version.plist"
+  local ready="$STATE_DIR/native-system-version.request"
+  NATIVE_VERSION_ERROR=native_system_version_read_failed
+  printf '[native-version-start] method=guest-file/host-xml source=%s seconds=%s\n' "$source" "$started" >&3
+  IFS= read -r -n 81 -d '' owner < "$STATE_DIR/run.owner"; status=$?
+  (( status == 1 && ${#owner} <= 80 )) &&
+    [ "$owner" = "$PROOF_TOKEN"$'\n' ] || { NATIVE_VERSION_ERROR=native_system_version_foreign_owner; return 1; }
+  [ ! -e "$ready" ] && [ ! -L "$ready" ] &&
+    [ ! -e "$raw" ] && [ ! -L "$raw" ] || { NATIVE_VERSION_ERROR=native_system_version_stale_exchange; return 1; }
+  [ -f "$source" ] || return 1
+  IFS= read -r -n 4097 -d '' value < "$source"; status=$?
+  # EOF is mandatory. NUL stops read with status 0; 4097 is the overbound sentinel.
+  (( status == 1 && ${#value} > 0 && ${#value} <= 4096 )) || { NATIVE_VERSION_ERROR=native_system_version_invalid_bytes; return 1; }
+  invalid_bytes=${value//$'\t'/}
+  invalid_bytes=${invalid_bytes//$'\r'/}
+  invalid_bytes=${invalid_bytes//$'\n'/}
+  [[ "$invalid_bytes" =~ [[:cntrl:]] ]] && { NATIVE_VERSION_ERROR=native_system_version_binary; return 1; }
+  printf '%s' "$value" > "$raw" || return 1
+  # Publish this final marker only after the complete raw write has closed.
+  printf '%s\n%s\n%s\nready:%s\n' "$PROOF_TOKEN" "$source" "${#value}" "$PROOF_TOKEN" > "$ready" || return 1
+  printf '[native-version-request] method=guest-file/host-xml source=%s bytes=%s seconds=%s\n' "$source" "${#value}" "$SECONDS" >&3
+  # This is a candidate from exactly these bytes, not an XML validity check.
+  NATIVE_VERSION_ERROR=native_system_version_candidate_invalid
+  [[ "$value" == *'<key>ProductVersion</key>'* ]] || return 1
+  remainder=${value#*'<key>ProductVersion</key>'}
+  remainder=${remainder#"${remainder%%[![:space:]]*}"}
+  [[ "$remainder" == '<string>'* ]] || return 1
+  remainder=${remainder#'<string>'}
+  candidate=${remainder%%'</string>'*}
+  [ "$candidate" != "$remainder" ] && [[ "$candidate" =~ ^[0-9]+\.[0-9]+(\.[0-9]+)?$ ]] || return 1
+  SCALAR="$candidate"
+  NATIVE_VERSION_ERROR=""
+  printf '[native-version-candidate] method=guest-file/host-xml source=%s candidate=%s qualified=false elapsed=%ss\n' "$source" "$SCALAR" "$((SECONDS - started))" >&3
+  return 0
 }
-
-# END successful sw_vers version parser
+# END native SystemVersion plist request helpers
 # BEGIN disk IPC diagnostic
-# Optional observations have their own child/timer ownership. Thread state/time
-# targets only this probe's diskutil and does not request stack symbolication.
+# Optional observations have their own child/timer ownership. Stack/thread
+# observations target only this probe's live diskutil; none qualifies readiness.
 observe_disk_query() {
  local disk_process="$1" output="$2" observation_child="" observation_timer=""
+  local stack_output="$STATE_DIR/diskutil-stack.txt"
  cancel_observation() {
    trap '' TERM INT
    if [ -n "$observation_child" ]; then
@@ -157,19 +180,38 @@ observe_disk_query() {
    kill -TERM "$observation_timer" 2>/dev/null || :
    wait "$observation_timer" 2>/dev/null || :
    printf '[disk-observation-exit] %s status=%s elapsed=%ss\n' "$name" "$status" "$((SECONDS - started))" >> "$output"
+    OBSERVATION_EXIT="$status"
    observation_child=""; observation_timer=""
  }
+  observe_live_command() {
+    local name="$1"
+    shift
+    if ! kill -0 "$disk_process" 2>/dev/null; then
+      printf '[disk-observation-unavailable] %s: owned diskutil already exited\n' "$name" >> "$output"
+    elif [ ! -x "$1" ]; then
+      printf '[disk-observation-unavailable] %s: %s is unavailable\n' "$name" "$1" >> "$output"
+    else
+      observe_command "$name" "$@"
+    fi
+  }
  trap cancel_observation TERM INT
  printf '[disk-observation] owned-diskutil-child=%s parent-shell=%s\n' "$disk_process" "$$" >> "$output"
-  if [ -x /bin/ps ]; then
-    if kill -0 "$disk_process" 2>/dev/null; then
-      observe_command diskutil-threads /bin/ps -M -p "$disk_process"
-    else
-      printf '[disk-observation-unavailable] diskutil already exited before thread observation\n' >> "$output"
-    fi
+  observe_live_command diskutil-threads-before /bin/ps -M -p "$disk_process"
+  if [ ! -x /usr/bin/sample ]; then
+    printf '[disk-observation-unavailable] diskutil-stack: /usr/bin/sample is unavailable\n' >> "$output"
+  elif ! kill -0 "$disk_process" 2>/dev/null; then
+    printf '[disk-observation-unavailable] diskutil-stack: owned diskutil already exited\n' >> "$output"
+  elif [ -e "$stack_output" ] || [ -L "$stack_output" ]; then
+    printf '[disk-observation-unavailable] diskutil-stack: output already exists\n' >> "$output"
+  elif : > "$stack_output"; then
+    printf '[disk-stack-attempt] owned-diskutil-child=%s duration=1s interval=100ms limit=60s output=%s observation-only=true\n' "$disk_process" "$stack_output" >> "$output"
+    observe_command diskutil-stack /usr/bin/sample "$disk_process" 1 100 -mayDie -file "$stack_output"
+    printf '[disk-stack-result] status=%s observation-only=true; raw report is captured by the Linux host\n' "$OBSERVATION_EXIT" >> "$output"
  else
-    printf '[disk-observation-unavailable] /bin/ps is unavailable\n' >> "$output"
+    printf '[disk-observation-unavailable] diskutil-stack: output cannot be created\n' >> "$output"
  fi
+  observe_live_command storagekit-live /bin/launchctl print system/com.apple.storagekitd
+  observe_live_command diskutil-threads-after /bin/ps -M -p "$disk_process"
 }

 stop_disk_observation() {
@@ -204,7 +246,7 @@ run_command() {
  # Isolate only the failed UID gate; every other watchdog remains unchanged.
  [[ "$name" != uid ]] || command_limit=180
 # BEGIN disk IPC diagnostic
-  if [[ "$name" == disks && "${attempt:-0}" == 1 ]]; then command_limit=120; fi
+  if [[ "$name" == disks && "${attempt:-0}" == 1 ]]; then command_limit=600; fi
 # END disk IPC diagnostic
  LAST_OUTPUT="/tmp/native-diagnostic-$name.out"
  printf '\n[proof-command] %s:' "$name" >&3
@@ -283,32 +325,18 @@ run_command uid /usr/bin/id -u
 read_scalar || fail_probe uid_output_invalid
 uid="$SCALAR"
 [ "$uid" = 0 ] || fail_probe recovery_account_not_root
-run_command platform /usr/bin/sw_vers
-platform_exit="$LAST_EXIT"
-flush_outputs || finish false diagnostic_log_budget_exceeded
-if (( platform_exit != 0 )); then
-  run_command system /bin/launchctl print system
-  system_exit="$LAST_EXIT"
-  run_command arbitration /bin/launchctl print system/com.apple.diskarbitrationd
-  arbitration_exit="$LAST_EXIT"
-  run_command recovery /bin/launchctl print system/com.apple.recoveryosd
-  recovery_exit="$LAST_EXIT"
-  printf '[proof-retry] sw_vers once after native service context; same 45-second deadline\n' >&3
-  run_command platform-warm /usr/bin/sw_vers
-  platform_exit="$LAST_EXIT"
-fi
-(( platform_exit == 0 )) || fail_probe sw_vers_failed
-# BEGIN successful sw_vers version extraction
-read_product_version || fail_probe product_version_invalid
-# END successful sw_vers version extraction
+# BEGIN native SystemVersion plist getter
+read_native_system_version || fail_probe "$NATIVE_VERSION_ERROR"
+# END native SystemVersion plist getter
 os_version="$SCALAR"
 [[ "$os_version" =~ ^[0-9]+\.[0-9]+(\.[0-9]+)?$ ]] || fail_probe product_version_invalid
 (( ${os_version%%.*} >= 14 )) || fail_probe unsupported_macos_version
 flush_outputs || finish false diagnostic_log_budget_exceeded

 # BEGIN disk IPC diagnostic
+printf '[disk-diagnostic-runtime] bash=%s stack-observation-only=true\n' "$BASH_VERSION" >&3
 run_command arbitration_before /bin/launchctl print system/com.apple.diskarbitrationd
-run_command management_before /bin/launchctl print system/com.apple.diskmanagementd
+run_command management_before /bin/launchctl print system/com.apple.storagekitd
 run_command media_before /usr/sbin/ioreg -r -c IOMedia -l -w 0
 flush_outputs || finish false diagnostic_log_budget_exceeded
Author	SHA1	Message	Date
dh	81a3b9c7d2	Observe owned diskutil stack and live StorageKit in Recovery	2026-10-04 17:35:06 +02:00
dh	9164fe451f	Qualify guest version through one-way raw evidence before permit	2026-10-04 16:08:41 +02:00
dh	6122be2cef	Read Recovery version from current guest SystemVersion evidence	2026-10-04 15:00:11 +02:00
dh	9735db1cdc	Qualify native macOS CI with Skylake and fresh installation gates	2026-10-04 13:31:58 +02:00
dh	17fb74dd74	ci: prepare source-bound native macOS build and tests under TCG	2026-10-04 10:56:46 +02:00