ci: qualify supported macOS emulation before Recovery download

reuse verified native platform version without duplicate query
retain bounded disk stack and resource pressure evidence
2026-10-04 10:30:23 +02:00 · 2026-10-04 09:41:25 +02:00 · 2026-10-04 09:14:39 +02:00 · 2026-10-04 08:41:06 +02:00
9 changed files with 446 additions and 419 deletions
@@ -1,4 +1,4 @@
-name: macOS 13 KVM Cryptex Recovery compatibility diagnostic
+name: macOS 14 TCG Recovery prerequisite diagnostic

 on:
  workflow_dispatch:
@@ -6,7 +6,7 @@ on:
 jobs:
  macos-native-diagnostic:
    runs-on: ubuntu-latest
-    timeout-minutes: 45
+    timeout-minutes: 95
    env:
      DOTNET_SKIP_FIRST_TIME_EXPERIENCE: "1"
      DOTNET_NOLOGO: "1"
@@ -19,7 +19,7 @@ jobs:
        with:
          dotnet-version: "10.0.x"

-      - name: Probe macOS 13 Recovery with existing KVM and host CPU
+      - name: Verify actual AVX2 emulation then probe macOS 14 Recovery
        run: dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --run --output artifacts/native-macos

      - name: Always clean up only this diagnostic's owned resources
@@ -3,6 +3,11 @@ name: PR and Push Build/Test
 on:
  pull_request:
  push:
+    # This temporary branch changes only the native prerequisite diagnostic.
+    # Its manual workflow provides that evidence; the PR branch still runs all jobs.
+    branches-ignore:
+      - codex/macos-ci-kvm-compatibility
+      - codex/macos-ci-tcg-supported
  workflow_dispatch:

 jobs:
@@ -112,15 +117,6 @@ jobs:
            --nologo
          test -s MeetingAssistant/bin/Release/net10.0-windows10.0.19041.0/win-x64/MeetingAssistant.dll

-      - name: Measure transcript reader sharing on the Windows Wine host
-        run: |
-          mkdir -p artifacts/tests
-          transcript_probe_exit=0
-          "${WINE_BIN}" "${WIN_DOTNET_DIR}/dotnet.exe" run \
-            --file tools/ci/TranscriptFileShareProbe.cs > artifacts/tests/transcript-file-sharing.json || transcript_probe_exit=$?
-          cat artifacts/tests/transcript-file-sharing.json
-          exit "${transcript_probe_exit}"
-
      - name: Run tests via Wine (Windows dotnet host)
        run: |
          rm -f artifacts/tests/wine.trx
@@ -191,21 +191,18 @@ public sealed class RecordingCoordinatorTests
            NullLogger<MarkdownMeetingNoteStore>.Instance);
        var artifactStore = new MarkdownMeetingArtifactStore(
            NullLogger<MarkdownMeetingArtifactStore>.Instance);
-        var writeProbe = new TranscriptWriteDiagnostic();
-        var transcriptStore = new DiagnosticTranscriptStore(
-            new VaultTranscriptStore(Options.Create(options), NullLogger<VaultTranscriptStore>.Instance),
-            writeProbe);
        var coordinator = new MeetingRecordingCoordinator(
            audioSource,
            new TestSpeechRecognitionPipelineFactory(
-                new DiagnosticTranscriptionProvider(
-                    new FixedSegmentStreamingTranscriptionProvider(
-                        new TranscriptionSegment(
-                            TimeSpan.FromSeconds(4),
-                            TimeSpan.FromSeconds(5),
-                            "Guest-1",
-                            "Azure returned ***** here.")), writeProbe)),
-            transcriptStore,
+                new FixedSegmentStreamingTranscriptionProvider(
+                    new TranscriptionSegment(
+                        TimeSpan.FromSeconds(4),
+                        TimeSpan.FromSeconds(5),
+                        "Guest-1",
+                        "Azure returned ***** here."))),
+            new VaultTranscriptStore(
+                Options.Create(options),
+                NullLogger<VaultTranscriptStore>.Instance),
            noteStore,
            new CapturingMeetingNoteOpener(),
            artifactStore,
@@ -221,45 +218,9 @@ public sealed class RecordingCoordinatorTests
                NullLogger<MeetingWorkflowEngine>.Instance));

        var started = await coordinator.StartAsync(CancellationToken.None);
-        Exception? waitFailure = null;
-        Exception? stopFailure = null;
-        try
-        {
-            await audioSource.WriteAsync(new AudioChunk([1, 0], 16000, 1), CancellationToken.None);
-            writeProbe.Record("test-audio-enqueued");
-            await WaitUntilAsync(() => FileContainsText(started.TranscriptPath!, "Azure returned"));
-        }
-        catch (Exception exception)
-        {
-            waitFailure = exception;
-            writeProbe.Record("test-wait-failed", exception);
-        }
-        finally
-        {
-            try
-            {
-                await coordinator.StopAsync(CancellationToken.None);
-                writeProbe.Record("test-stop-completed");
-            }
-            catch (Exception exception)
-            {
-                stopFailure = exception;
-                writeProbe.Record("test-stop-failed", exception);
-            }
-        }
-
-        if (waitFailure is TimeoutException)
-        {
-            throw new TimeoutException($"{waitFailure.Message} {writeProbe.Describe()}", waitFailure);
-        }
-        if (waitFailure is not null)
-        {
-            System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(waitFailure).Throw();
-        }
-        if (stopFailure is not null)
-        {
-            System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(stopFailure).Throw();
-        }
+        await audioSource.WriteAsync(new AudioChunk([1, 0], 16000, 1), CancellationToken.None);
+        await WaitUntilAsync(() => FileContainsText(started.TranscriptPath!, "Azure returned"));
+        await coordinator.StopAsync(CancellationToken.None);

        var content = await File.ReadAllTextAsync(started.TranscriptPath!);
        Assert.Contains("[00:00:04] Guest-1: Azure returned [redacted] here.", content);
@@ -5251,94 +5212,6 @@ public sealed class RecordingCoordinatorTests
        }
    }

-    // Temporary diagnosis of Run4174. Observes public provider/store boundaries only.
-    private sealed class TranscriptWriteDiagnostic
-    {
-        private readonly System.Diagnostics.Stopwatch elapsed = System.Diagnostics.Stopwatch.StartNew();
-        private readonly ConcurrentQueue<string> events = new();
-
-        public void Record(string name, Exception? error = null)
-        {
-            events.Enqueue($"{elapsed.ElapsedMilliseconds}ms:{name}" + (error is null ? "" :
-                $":{error.GetType().FullName}:HResult=0x{error.HResult:X8}:{error.Message}"));
-        }
-
-        public string Describe() => "[DEBUG-transcript-write-4174] " + string.Join(" | ", events);
-    }
-
-    private sealed class DiagnosticTranscriptionProvider(
-        IStreamingTranscriptionProvider inner,
-        TranscriptWriteDiagnostic probe) : IStreamingTranscriptionProvider
-    {
-        public async IAsyncEnumerable<TranscriptionSegment> TranscribeAsync(
-            IAsyncEnumerable<AudioChunk> audio,
-            SpeechRecognitionPipelineOptions options,
-            [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
-        {
-            await foreach (var segment in inner.TranscribeAsync(ObserveAudioAsync(audio, cancellationToken), options, cancellationToken))
-            {
-                probe.Record("fake-segment-yielded");
-                yield return segment;
-            }
-        }
-
-        private async IAsyncEnumerable<AudioChunk> ObserveAudioAsync(
-            IAsyncEnumerable<AudioChunk> audio,
-            [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
-        {
-            await foreach (var chunk in audio.WithCancellation(cancellationToken))
-            {
-                probe.Record("fake-audio-consumed");
-                yield return chunk;
-            }
-        }
-    }
-
-    private sealed class DiagnosticTranscriptStore(
-        ITranscriptStore inner,
-        TranscriptWriteDiagnostic probe) : ITranscriptStore
-    {
-        public Task<TranscriptSession> CreateSessionAsync(CancellationToken cancellationToken) =>
-            inner.CreateSessionAsync(cancellationToken);
-        public Task<TranscriptSession> CreateSessionAsync(MeetingAssistantOptions options, DateTimeOffset startedAt, CancellationToken cancellationToken) =>
-            inner.CreateSessionAsync(options, startedAt, cancellationToken);
-        public Task ReplaceLinesAsync(TranscriptSession session, IReadOnlyList<string> replacementLines, CancellationToken cancellationToken) =>
-            inner.ReplaceLinesAsync(session, replacementLines, cancellationToken);
-        public Task UpdateMetadataAsync(TranscriptSession session, MeetingSessionArtifacts artifacts, MeetingNote meetingNote, CancellationToken cancellationToken) =>
-            inner.UpdateMetadataAsync(session, artifacts, meetingNote, cancellationToken);
-
-        public async Task<TranscriptLineReference> AppendLineAsync(TranscriptSession session, string line, CancellationToken cancellationToken)
-        {
-            probe.Record("append-entered");
-            try
-            {
-                var reference = await inner.AppendLineAsync(session, line, cancellationToken);
-                probe.Record("append-completed");
-                return reference;
-            }
-            catch (Exception exception)
-            {
-                probe.Record("append-failed", exception);
-                throw;
-            }
-        }
-
-        public async Task ReplaceLineAsync(TranscriptSession session, TranscriptLineReference lineReference, string replacementLine, CancellationToken cancellationToken)
-        {
-            probe.Record("rewrite-entered");
-            try
-            {
-                await inner.ReplaceLineAsync(session, lineReference, replacementLine, cancellationToken);
-                probe.Record("rewrite-completed");
-            }
-            catch (Exception exception)
-            {
-                probe.Record("rewrite-failed", exception);
-                throw;
-            }
-        }
-    }
-
    private sealed class TestSpeechRecognitionPipelineFactory : ISpeechRecognitionPipelineFactory
    {
        private readonly IStreamingTranscriptionProvider provider;
@@ -1,68 +1,46 @@
-# macOS 13 KVM/Cryptex compatibility diagnostic
+# macOS 14 TCG prerequisite diagnostic

-This separate manual candidate probes Recovery readiness on the existing Ubuntu Docker daemon with KVM, the real Intel host CPU and macOS 13. It does not install macOS, erase a disk, install .NET or Apple CLT, or run Meeting Assistant. Passing proves only a fresh macOS 13+ x86_64 Recovery guest with root identity, a working launchd system domain, DiskArbitration and exactly one writable 64-GiB guest disk.
+This manual candidate uses the existing Ubuntu/x64 Docker runner. Before downloading Apple Recovery it tests actual AVX/AVX2 instruction execution in the pinned QEMU binary, then probes a fresh macOS 14+ Recovery guest. It does not install macOS, erase a disk, provision .NET/CLT or run Meeting Assistant tests. Readiness is only a prerequisite for full native CI.

-Baseline: bootstrap commit `4606de069678e8f95dfe3c7dad1bf5ce5384d30c`; separate branch `codex/macos-ci-kvm-compatibility`. KVM, CPU passthrough, Recovery major version and guest Cryptex staging change together. This is a compatibility experiment, not a causal single-variable A/B test. The TCG/bootstrap experiment remains separate.
+## Profile and evidence

-## Reasons and remaining gaps
+The existing Intel Celeron 1037U has neither AVX nor AVX2. KVM run 4187 at `720a431` reached macOS 13.6/x86_64/root and visible whole writable 64-GiB media. Diskutil timed out after 122 seconds; the sampler produced no report after 61 seconds. The screen remained at the Apple boot progress bar. CPU throttling, memory-limit/OOM events and container swap were zero; memory peaked at 2.67 GB. Host paging occurred. No unsupported-instruction crash or particular IPC wait is proved.

-The existing daemon's Intel Celeron 1037U lacks AVX/AVX2; a separate diagnostic proved KVM enabled/paused state and clean exit. `CPU_MODEL=host` preserves actual instruction availability rather than advertising AVX2 through emulated Skylake. This candidate refuses a TCG or CPU-model fallback.
+[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.

-All four Swift helpers target `x86_64-apple-macos13.0`; the macOS 14 EventKit call has an existing macOS 13 fallback. Inspected native Mach-O files in pinned .NET SDK 10.0.401 x64 declare `minos 12.0`. These source/binary minima are not runtime qualification or vendor support: macOS 13 is outside [Microsoft's current .NET 10 supported-OS policy](https://github.com/dotnet/core/blob/main/release-notes/10.0/supported-os.md). This probe does not install that SDK, compile helpers or test calendar/audio permissions.
+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.

-[Official CryptexFixup 1.0.5](https://github.com/acidanthera/CryptexFixup/blob/1.0.5/CryptexFixup/kern_start.cpp) activates without AVX2 and registers for normal, installer/Recovery and safe-mode boots. It redirects installer/updater ramrod to Apple Silicon's Rosetta Cryptex and bypasses APFS root-hash authentication on Ventura and newer. It does not emulate missing instructions. This kernel patch affects only the owned guest, never a host module.
+## Entry points and dependencies

-**Recovery cache gap:** CryptexFixup does not replace an already running Recovery BaseSystem shared cache. Its installer/update selector targets the installed Cryptex, but this readiness-only run invokes no installer. Staging or loading it therefore proves no Recovery userland compatibility. Actual CPU/kernel behavior, guest injection, all native gates and any later installed-Cryptex/build/test behavior remain unqualified until observed.
+Orchestration remains the .NET 10 file-based app `tools/ci/MacOsNativeDiagnostic.cs`. Existing Bash/Python boot integration is necessary before a guest SDK exists. NASM assembles the CPU probe in the disposable image build, without host/runner installation. No new runner, device, capability, secret or service is used.

-Apple Recovery uses the pinned public InternetRecovery protocol with board ID and session/asset tokens, without Apple ID or workstation credentials. The macOS 13 selection, downloaded hash and actual guest version are retained; the hook downloads no full installer or SDK.
-
-## Entry point and dependencies
-
-Orchestration/validation remain the .NET 10 file-based app `tools/ci/MacOsNativeDiagnostic.cs`. Bash/Python stay only in the existing pinned Linux/macOS boot integration.
-
-~~~sh
-dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --help
+```sh
 dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --validate
-dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --validate --source /path/to/clean/pinned/dockur-clone --cryptex-archive /path/to/CryptexFixup-1.0.5-RELEASE.zip --output /path/to/fresh/validation
-~~~
-
-`--validate` checks result/container contracts without Docker. With `--source` it verifies the actual Cryptex ZIP/bundle, source seams, generated OpenCore configuration and staging/checksum contracts, checks Bash syntax, then exercises four raw/zlib Recovery fixtures and twelve rejection cases with independent C# CRC32 readback. It also checks preservation of a successful resource snapshot after a later failed capture, leaving the supplied source untouched. It does not download/extract the LongQT ISO, verify a complete Apple Recovery image or execute the active-Lilu runtime checks. The ISO checksum is enforced during the later Docker build; active Lilu and EFI-copy checks execute only during container boot. The optional local Cryptex ZIP must match the release size/hash; omitting it downloads only the public 69,703-byte release. Use a fresh output directory. Dependencies are .NET 10, Git, Bash and Python 3 with its standard library; manual execution also requires the existing Linux/x64 Docker daemon and its existing KVM device.
-
-The manual-only workflow keeps these owned run/cleanup entry points; validation invokes neither:
-
-~~~sh
+dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --validate --source /path/to/clean/pinned/dockur-clone --output /path/to/fresh/validation
 dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --run --output artifacts/native-macos
 dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --cleanup --output artifacts/native-macos
-~~~
+```

-## Exact bootasset contract
+The native diagnostic workflow is manual only. Temporary diagnostic branches are excluded from ordinary push jobs to avoid repeating unchanged Wine/portable jobs. Remove this routing when integrating qualified CI into the actual PR.

-Dockur stays pinned to `16a5b470cdd601bae8b05b02d748d7edfb36c12e`. Original Recovery patcher/staging, Dockerfile, OpenCore script and active config hashes are verified before edits. Both existing QEMU image digests remain pinned; other existing upstream downloads are observed through image identity. `source-hashes.json` includes the generated Recovery patcher, both original/replacement daemon variants and `udif_checksums.py`, staged from `tools/ci/macos-native-udif-checksums.py`. This small Python module belongs to the existing Linux UDIF runtime; C# supplies orchestration, validation fixtures and an independent CRC32 implementation.
+## Before Apple downloads

-Run 4173 at `45d7bde71f9f5a1f7121585fe3ee9fc81f7c585f` failed before QEMU started: the full macOS 14 plist pattern was absent from the macOS 13 download. The original image's hash was not retained. An independently downloaded comparison for the same board `Mac-4B682C642B45593E` is macOS 13.6/22G120, Apple product 042-23155, 710,918,897 bytes, SHA256 `c19bd12f5cb1651b87b74d04f02a636da762ea46b81c7ebc9f205fa2a976d599`. Its Apple chunklist signature and chunks verified before any changes. It is comparison evidence, not the missing run-4173 image identity.
+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.

-The HFS+ catalog identifies `/System/Library/LaunchDaemons/com.apple.recoveryosd.plist` as file ID 57231, logical size 465 bytes and one 4,096-byte allocated block. Its exact XML SHA256 is `af9d7f6c1948079bd4384d27b6882678d6fb4e338fcf6a8be8f84fceef174ad6`. This variant has `ProcessType=Interactive`; the previous macOS 14 variant has `App`. The patch accepts only these two exact layouts with exactly one daemon label and original `ProgramArguments=[/usr/libexec/recoveryosd]`. It preserves each variant's fields and process type, removes only the XML doctype to fit the wrapper arguments, and pads to the original file size. Unknown, duplicate, malformed or wrong-argument layouts fail before image writes. The early rc.cdrom hook remains mount-only; the unchanged wrapper runs the Apple daemon.
+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.

-The checksum binding validates the original flattened UDIF boundaries and CRC32 values, stages every recompressed chunk before writing, then updates only the changed mish CRC32 and koly data-fork/master CRC32. [libdmg-hfsplus](https://github.com/planetbeing/libdmg-hfsplus/blob/master/dmg/dmglib.c) provides the checksum semantics; an independent C# reader matched all eight mish checksums on the unchanged comparison. Raw and inflated zlib bytes enter logical CRCs in run order; observed IGNORE runs are omitted. Unobserved ZERO runs, other compression/checksum types, overlaps and invalid boundaries are rejected. Base64 characters are replaced within the same metadata region, preserving its whitespace, length, partition tables and trailer offsets; the entire modified image is read again to verify CRCs. Apple chunklist authentication applies exclusively to the unchanged input, not the deliberately modified guest image. CRC integrity proves no Apple authenticity or native runtime gate.
+The locally assembled NASM 2.16.03 ROM is 65,536 bytes, SHA256 `c32746122cc68f3ed642aa46c21b677f803c58f0d4ff665841723fcc5625f549`. Assembly/static review does not prove remote execution.

-The [original LongQT v0.7 template](https://github.com/LongQT-sea/OpenCore-ISO/releases/download/v0.7/LongQT-OpenCore-v0.7.iso), 15,884,288 bytes, is now Docker-ADD-checksummed to SHA256 `287328995d4198f1b05166f087d85bf7ef66bedafe150d17ad112ac8de60051d`. Runtime copies actual `EFI_RELEASE/EFI/OC/Kexts`, including Lilu 1.7.1, even with official OpenCore DEBUG executables. Active Lilu: executable 526,984 bytes, SHA256 `0c016d93cfe40c7fa3965813175c1b991a76f3d295efd5be66ae712b4a3ffb52`; Info.plist SHA256 `fc885f3319f326e3af60e7965a5216b671772d39d40993ec695758bb43d6ea3a`. Staging checks both hashes and bundle version. Cryptex declares Lilu 1.4.7; [Lilu history](https://github.com/acidanthera/Lilu/blob/master/Changelog.md) includes Ventura/Sonoma installer/Recovery support before 1.7.1. Existing Lilu is kept.
+## Native gates, bounds and cleanup

-[CryptexFixup-1.0.5-RELEASE.zip](https://github.com/acidanthera/CryptexFixup/releases/download/1.0.5/CryptexFixup-1.0.5-RELEASE.zip), 69,703 bytes, SHA256 `25041d94a0fe9a0261caf0ba89b36dfcb21682bf3c697a34bcaddc839576ab30`, is checked in C#. Only expected Info.plist/executable files are accepted; identity/version/dependency and individual hashes are recorded. Runtime checks files before/after copying into fresh guest EFI.
+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.

-Active `/assets/config.plist` receives exactly one enabled Cryptex immediately after enabled Lilu, preserving every other kext's order. Entry: `Arch=x86_64`, `BundlePath=CryptexFixup.kext`, `ExecutablePath=Contents/MacOS/CryptexFixup`, `PlistPath=Contents/Info.plist`, `MinKernel=22.0.0`, empty `MaxKernel`. [OpenCore Kernel.Add](https://github.com/acidanthera/OpenCorePkg/blob/1.0.7/Docs/Configuration.tex) requires dependencies first; bounds are Darwin versions. Runtime rechecks order/enabled/paths/architecture/bounds and rejects unverified `/custom.plist`.
+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.

-No new force/beta argument is needed for actual no-AVX2 CPUs. Baseline arguments remain. Validation rejects disabling arguments, `-crypt_allow_hash_validation` (disables the APFS patch) and unexpected Cryptex force/beta overrides. Manifest/profile enter the boot signature; this candidate always rebuilds `boot.img` and accepts no old cache as evidence.
+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.

-## Gates, privileges and cleanup
+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.

-The Apple wrapper is byte-identical to baseline: background `/Volumes/installstate/readiness.sh` then `exec /usr/libexec/recoveryosd` under the same launchd job/PID. Source evidence does not prove Apple's executable ran.
+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.

-Readiness changes only minimum macOS 14 to 13. Validation normalizes that gate to 14 and requires baseline SHA256 `4d428f594dac14eff64ed87b172c81ecf85ac91da8c5460cd6ec4b1d310800c3`. Architecture, UID, services, disk size/writability/uniqueness, retries, proof bounds, timers and native-wait/cleanup/flush metrics remain identical. Limits stay 45 seconds per native command, 180 seconds for UID, ten minutes disk readiness, 40 minutes host and 45 minutes workflow.
-
-Container profile: `KVM=Y`, `CPU_MODEL=host`, `VERSION=13`, 4-GiB guest, two guest/host CPUs, 6-GiB memory/swap and 512-MiB shared memory. Fresh anonymous `/storage` holds the 64-GiB disk; evidence reads `/storage/13/setup.dmg`. Existing resource budget checks remain.
-
-Only device mapping: exactly `/dev/kvm:/dev/kvm:rw`. Inspection rejects other devices/permissions, added capabilities, device requests/rules, binds, tmpfs overrides, published ports, host networking, privileged mode, wrong limits, unexpected persistent mounts or changed CPU/OS profile. No host modules, infrastructure, secrets, SSH or app lifecycle actions are involved. Guest slirp networking remains.
-
-Evidence retains run/profile identity, source/assets, EFI staging, container/resources, macOS 13 Recovery hash, native proof/result/outcome and cleanup. `[recovery-original]` logs the exact download's size/SHA256 before modifying it, including when patch failure later deletes the source. `guest-container-resources.last-success.stdout.log` and its timestamp/hash receipt preserve the last successful resource snapshot independently of a later failed stopped-container `docker exec`. Optional final Unix HMP capture includes `info kvm`, `info status` and a bounded PPM exported from `/tmp`; capture success passes no native gate.
-
-Both cleanup paths keep exact token/label/ID checks. `docker rm --force --volumes` removes only the owned container and anonymous volume, then its exact image; no unrelated objects or pruning. Evidence stays seven days. Full native CI still needs a subsequent actual installed remote guest to build/sign helpers and pass the full suite, including five native tests without skips.
+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.
@@ -14,8 +14,9 @@ return await NativeDiagnostic.Execute(args);
 static class NativeDiagnostic
 {
    const string DockurCommit = "16a5b470cdd601bae8b05b02d748d7edfb36c12e";
-    const string CryptexUrl = "https://github.com/acidanthera/CryptexFixup/releases/download/1.0.5/CryptexFixup-1.0.5-RELEASE.zip";
-    const string CryptexHash = "25041d94a0fe9a0261caf0ba89b36dfcb21682bf3c697a34bcaddc839576ab30";
+    const string Profile = "tcg-haswell-sonoma";
+    const string CpuModel = "Haswell-noTSX";
+    const string CpuFlags = "Haswell-noTSX,l3-cache=on,+hypervisor,vendor=GenuineIntel,vmx=off,vmware-cpuid-freq=on,-pdpe1gb,-pcid,-invpcid,-tsc-deadline,-xsavec,-xsaves,+ssse3,+sse4.2,+popcnt,+avx,+avx2,+aes,+fma,+bmi1,+bmi2,+smep,+xsave,+xsaveopt,+xgetbv1,+movbe,+rdrand,enforce=on";
    const string OpenCoreTemplateHash = "287328995d4198f1b05166f087d85bf7ef66bedafe150d17ad112ac8de60051d";
    const string UdifChecksumBindingHash = "6109d04619e800c483fdac363d593cd1cd69f34131d2521417334e11d41c8bfa";
    const string OwnerLabel = "org.meeting-assistant.native-diagnostic";
@@ -57,7 +58,7 @@ static class NativeDiagnostic
    {
        if (args.Length == 0 || args.Contains("--help"))
        {
-            Console.WriteLine("dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --run|--cleanup|--validate [--output artifacts/native-macos] [--source existing-dockur-clone] [--cryptex-archive verified-release.zip]");
+            Console.WriteLine("dotnet run --file tools/ci/MacOsNativeDiagnostic.cs -- --run|--cleanup|--validate [--output artifacts/native-macos] [--source existing-dockur-clone]");
            return 0;
        }
        var output = Path.GetFullPath(Option(args, "--output") ?? "artifacts/native-macos");
@@ -66,10 +67,23 @@ static class NativeDiagnostic
            ValidateContracts();
            if (Option(args, "--source") is { } source)
            {
-                await PrepareSource(Path.GetFullPath(source), output, "validation", false, Option(args, "--cryptex-archive"), CancellationToken.None);
+                await PrepareSource(Path.GetFullPath(source), output, "validation", false, CancellationToken.None);
                await ValidateResourceRetention(output);
                await ValidateRecoveryPatch(output);
-                Save(Path.Combine(output, "validation.json"), new { success = true, profile = "kvm-host-ventura-cryptex", helperSha256 = Hash(File.ReadAllBytes(Path.Combine("tools", "ci", "MacOsNativeDiagnostic.cs"))), udifChecksumBindingSha256 = Hash(File.ReadAllBytes(Path.Combine("tools", "ci", "macos-native-udif-checksums.py"))), baselineReadinessNormalized = true, resultNegativeCases = 6, containerNegativeCases = 11, recoveryPositiveCases = 4, recoveryNegativeCases = 12, independentFixtureCrc32Readback = true, resourceSnapshotRetention = true, cryptexArchiveVerified = true, configurationAndStagingContractsVerified = true, templateIsoDownloaded = false, activeLiluRuntimeChecked = false, sourceModified = false, dockerExecuted = false, guestExecuted = false, completedUtc = DateTimeOffset.UtcNow });
+                await ValidateTcgPreflight(output, CancellationToken.None);
+                Save(Path.Combine(output, "validation.json"), new
+                {
+                    success = true, profile = Profile,
+                    helperSha256 = Hash(File.ReadAllBytes(Path.Combine("tools", "ci", "MacOsNativeDiagnostic.cs"))),
+                    udifChecksumBindingSha256 = Hash(File.ReadAllBytes(Path.Combine("tools", "ci", "macos-native-udif-checksums.py"))),
+                    baselineReadinessNormalized = true, readinessDiagnosticBlocksExcluded = 7,
+                    productVersionParserBlockExcluded = true, productVersionSequenceRestored = true, productVersionMaximumBytes = 1024, nativeProductVersionCommandRemoved = true,
+                    diskReadinessAttemptLimit = 1, diskCommandLimitSeconds = 120, diskThreadObservationLimitSeconds = 60, stackSamplingUsed = false,
+                    resultNegativeCases = 6, containerNegativeCases = 11, recoveryPositiveCases = 4, recoveryNegativeCases = 12,
+                    independentFixtureCrc32Readback = true, resourceSnapshotRetention = true, cpuProfileSourceContractsVerified = true,
+                    preflightGateFixtureCases = 8, qemuRuntimePreflightExecuted = false, templateIsoDownloaded = false,
+                    sourceModified = false, dockerExecuted = false, guestExecuted = false, completedUtc = DateTimeOffset.UtcNow
+                });
            }
            Console.WriteLine("Source patch contracts and diagnostic result validation passed; no Docker or guest execution occurred.");
            return 0;
@@ -86,7 +100,7 @@ static class NativeDiagnostic
        Save(statePath, state);
        Directory.CreateDirectory(work);
        File.WriteAllText(Path.Combine(work, "run.owner"), token);
-        using var deadline = new CancellationTokenSource(TimeSpan.FromMinutes(40));
+        using var deadline = new CancellationTokenSource(TimeSpan.FromMinutes(90));
        using var signal = OperatingSystem.IsLinux() ? PosixSignalRegistration.Create(PosixSignal.SIGTERM, context => { context.Cancel = true; deadline.Cancel(); }) : null;
        ConsoleCancelEventHandler cancelHandler = (_, context) => { context.Cancel = true; deadline.Cancel(); };
        Console.CancelKeyPress += cancelHandler;
@@ -98,7 +112,7 @@ static class NativeDiagnostic
                throw new InvalidOperationException("This diagnostic runs on the existing Linux/x64 runner only.");
            ValidateContracts();
            var sourceCommit = (await Command("git", ["rev-parse", "HEAD"], output, "candidate-commit", deadline.Token)).Output.Trim();
-            Save(Path.Combine(output, "run-metadata.json"), new { token, startedUtc = DateTimeOffset.UtcNow, sourceCommit, dockurCommit = DockurCommit, profile = "kvm-host-ventura-cryptex", causalSingleVariableTest = false, kvm = true, cpuModel = "host", recoveryMajor = 13, cryptexVersion = "1.0.5", liluVersion = "1.7.1", runId = Environment.GetEnvironmentVariable("GITHUB_RUN_ID"), server = Environment.GetEnvironmentVariable("GITHUB_SERVER_URL"), architecture = RuntimeInformation.ProcessArchitecture.ToString(), deadlineMinutes = 40 });
+            Save(Path.Combine(output, "run-metadata.json"), new { token, startedUtc = DateTimeOffset.UtcNow, sourceCommit, dockurCommit = DockurCommit, profile = Profile, causalSingleVariableTest = false, kvm = false, cpuModel = CpuModel, recoveryMajor = 14, cpuFlags = CpuFlags, runId = Environment.GetEnvironmentVariable("GITHUB_RUN_ID"), server = Environment.GetEnvironmentVariable("GITHUB_SERVER_URL"), architecture = RuntimeInformation.ProcessArchitecture.ToString(), deadlineMinutes = 90 });
            var info = await Command("docker", ["info", "--format", "{{json .}}"], output, "docker-info", deadline.Token);
            using (var document = JsonDocument.Parse(info.Output))
            {
@@ -117,13 +131,13 @@ static class NativeDiagnostic
            await Command("git", ["-C", source, "checkout", "--detach", DockurCommit], output, "dockur-checkout", deadline.Token);
            var actualCommit = (await Command("git", ["-C", source, "rev-parse", "HEAD"], output, "dockur-commit", deadline.Token)).Output.Trim();
            if (actualCommit != DockurCommit) throw new InvalidOperationException("Dockur source pin mismatch.");
-            await PrepareSource(source, output, token, true, Option(args, "--cryptex-archive"), deadline.Token);
+            await PrepareSource(source, output, token, true, deadline.Token);
            await Command("docker", ["build", "--platform", "linux/amd64", "--label", OwnerLabel + "=" + token, "--tag", state.ImageTag, source], output, "docker-build", deadline.Token, echo: true);
            var imageInspect = await Command("docker", ["image", "inspect", state.ImageTag], output, "image-inspect", deadline.Token);
            using (var image = JsonDocument.Parse(imageInspect.Output))
                state = state with { ImageId = image.RootElement[0].GetProperty("Id").GetString() };
            Save(statePath, state);
-            var create = await Command("docker", ["create", "--name", state.ContainerName, "--label", OwnerLabel + "=" + token, "--memory", "6g", "--memory-swap", "6g", "--cpus", "2", "--shm-size", "512m", "--log-opt", "max-size=8m", "--log-opt", "max-file=1", "--device", "/dev/kvm:/dev/kvm:rw", "--env", "KVM=Y", "--env", "CPU_MODEL=host", "--env", "NETWORK=slirp", "--env", "DISPLAY=web", "--env", "MANUAL=N", "--env", "VERSION=13", "--env", "RAM_SIZE=4G", "--env", "CPU_CORES=2", "--env", "DISK_SIZE=64G", "--env", "DISK_TYPE=sata", "--env", "ARGUMENTS=-object iothread,id=io2", state.ImageTag], output, "docker-create", deadline.Token);
+            var create = await Command("docker", ["create", "--name", state.ContainerName, "--label", OwnerLabel + "=" + token, "--memory", "6g", "--memory-swap", "6g", "--cpus", "2", "--shm-size", "512m", "--log-opt", "max-size=8m", "--log-opt", "max-file=1", "--env", "KVM=N", "--env", "CPU_MODEL=" + CpuModel, "--env", "NETWORK=slirp", "--env", "DISPLAY=web", "--env", "MANUAL=N", "--env", "VERSION=14", "--env", "RAM_SIZE=4G", "--env", "CPU_CORES=2", "--env", "DISK_SIZE=64G", "--env", "DISK_TYPE=sata", "--env", "ARGUMENTS=-object iothread,id=io2", state.ImageTag], output, "docker-create", deadline.Token);
            var id = create.Output.Trim();
            if (!System.Text.RegularExpressions.Regex.IsMatch(id, "^[0-9a-f]{64}$")) throw new InvalidOperationException("Docker did not return a container identity.");
            state = state with { ContainerId = id };
@@ -131,13 +145,21 @@ static class NativeDiagnostic
            await Command("docker", ["inspect", id], output, "container-created", deadline.Token);
            AssertContainer(File.ReadAllText(Path.Combine(output, "container-created.stdout.log")), token);
            await Command("docker", ["start", id], output, "docker-start", deadline.Token);
-            Console.WriteLine("The owned restricted KVM/host-CPU macOS 13 compatibility guest is starting. Success requires native macOS 13+/x86_64 and a writable 64-GiB disk; no installer will run. This is not a single-variable causal test.");
+            await CapturePressure(id, output, "before", deadline.Token);
+            Console.WriteLine("The owned unprivileged TCG/Haswell macOS 14 guest is starting. Success requires native macOS 14+/x86_64 and a writable 64-GiB disk; no installer will run. This is not a single-variable causal test.");
            var recoveryStarted = Stopwatch.StartNew();
            var heartbeat = Stopwatch.StartNew();
+            var diskPressureCaptured = false;
            while (true)
            {
                deadline.Token.ThrowIfCancellationRequested();
                await CaptureGuest(id, output, deadline.Token);
+                var proofPath = Path.Combine(output, "guest-proof.log");
+                if (!diskPressureCaptured && File.Exists(proofPath) && File.ReadAllText(proofPath).Contains("[proof-start] disks", StringComparison.Ordinal))
+                {
+                    diskPressureCaptured = true;
+                    await CapturePressure(id, output, "during", deadline.Token);
+                }
                var resultPath = Path.Combine(output, "guest-result.json");
                if (File.Exists(resultPath))
                {
@@ -159,7 +181,7 @@ static class NativeDiagnostic
        }
        catch (Exception exception)
        {
-            error = exception is OperationCanceledException ? "The explicit 40-minute diagnostic deadline or cancellation was reached." : exception.Message;
+            error = exception is OperationCanceledException ? "The explicit 90-minute diagnostic deadline or cancellation was reached." : exception.Message;
            Console.Error.WriteLine(error);
        }
        finally
@@ -167,6 +189,7 @@ static class NativeDiagnostic
            Console.CancelKeyPress -= cancelHandler;
            using var captureDeadline = new CancellationTokenSource(TimeSpan.FromSeconds(45));
            try { await CaptureGuest(state.ContainerId ?? state.ContainerName, output, captureDeadline.Token, true, state.Token); } catch (Exception exception) { Console.Error.WriteLine("Final evidence capture: " + exception.Message); }
+            await CapturePressure(state.ContainerId ?? state.ContainerName, output, "after", captureDeadline.Token);
            try { PrintGuestProof(output, state.Token); } catch (Exception exception) { Console.Error.WriteLine("Native proof output: " + exception.Message); }
            var clean = await Cleanup(output);
            if (!clean) { outcome = "failed"; error = (error ?? "") + " Owned-resource cleanup failed; inspect cleanup evidence."; }
@@ -184,9 +207,10 @@ static class NativeDiagnostic
    static void ValidateContracts()
    {
        var readiness = File.ReadAllText(Path.Combine("tools", "ci", "macos-native-readiness.sh"));
-        var baseline = ReplaceOnce(readiness, "(( ${os_version%%.*} >= 13 ))", "(( ${os_version%%.*} >= 14 ))");
+        var baseline = NormalizeReadinessDiagnostics(readiness);
+        baseline = ReplaceOnce(baseline, "while (( attempt < 1 && SECONDS - readiness_start < 600 )); do", "while (( SECONDS - readiness_start < 600 )); do");
        if (Hash(Encoding.UTF8.GetBytes(baseline)) != "4d428f594dac14eff64ed87b172c81ecf85ac91da8c5460cd6ec4b1d310800c3")
-            throw new InvalidOperationException("Compatibility readiness may change only the baseline's macOS minimum to 13; identity, services, disk and limits must remain identical.");
+            throw new InvalidOperationException("Outside seven explicit diagnostic blocks, the successful sw_vers version parser/sequence and one-attempt limit, baseline identity/service/disk gates and watchdogs must remain identical.");
        if (Hash(File.ReadAllBytes(Path.Combine("tools", "ci", "macos-native-bootstrap.sh"))) != "94f069e116fdc7685a4d233cab6fa50df9f39274386bb82157674061e74fadb5")
            throw new InvalidOperationException("Compatibility profile must preserve the baseline Apple recoveryosd wrapper.");
        if (Hash(Encoding.UTF8.GetBytes(OriginalDaemon13)) != "af9d7f6c1948079bd4384d27b6882678d6fb4e338fcf6a8be8f84fceef174ad6") throw new InvalidOperationException("macOS 13 allowlist bytes differ from the independently read comparison plist.");
@@ -196,25 +220,57 @@ static class NativeDiagnostic
            ValidateDaemon(variant.Item2, variant.Item3, true);
            if (Encoding.UTF8.GetByteCount(variant.Item2) > Encoding.UTF8.GetByteCount(variant.Item1)) throw new InvalidOperationException("Daemon replacement exceeds original file.");
        }
-        var good = JsonSerializer.Serialize(new { token = "validation", success = true, osVersion = "13.6.1", architecture = "x86_64", uid = 0, disk = "/dev/disk1", diskBytes = GuestDiskBytes, readOnly = false, systemExit = 0, diskArbitrationExit = 0, recoveryExit = 0, diskListExit = 0 });
+        var good = JsonSerializer.Serialize(new { token = "validation", success = true, osVersion = "14.6.1", architecture = "x86_64", uid = 0, disk = "/dev/disk1", diskBytes = GuestDiskBytes, readOnly = false, systemExit = 0, diskArbitrationExit = 0, recoveryExit = 0, diskListExit = 0 });
        ValidateResult(good, "validation");
-        foreach (var invalid in new[] { good.Replace("13.6.1", "12.6.1"), good.Replace("x86_64", "arm64"), good.Replace("\"readOnly\":false", "\"readOnly\":true"), good.Replace("\"success\":true", "\"success\":false"), good.Replace("68719476736", "17179869184"), good.Replace("validation", "stale") })
+        foreach (var invalid in new[] { good.Replace("14.6.1", "13.6.1"), good.Replace("x86_64", "arm64"), good.Replace("\"readOnly\":false", "\"readOnly\":true"), good.Replace("\"success\":true", "\"success\":false"), good.Replace("68719476736", "17179869184"), good.Replace("validation", "stale") })
        {
            try { ValidateResult(invalid, "validation"); } catch (InvalidOperationException) { continue; }
            throw new InvalidOperationException("Diagnostic validator accepted an invalid/stale result.");
        }
        var boundary = """
-            [{"Config":{"Labels":{"org.meeting-assistant.native-diagnostic":"validation"},"Env":["KVM=Y","CPU_MODEL=host","VERSION=13"]},"HostConfig":{"Privileged":false,"NetworkMode":"default","Memory":6442450944,"MemorySwap":6442450944,"NanoCpus":2000000000,"ShmSize":536870912,"CapAdd":null,"DeviceRequests":null,"Binds":null,"PortBindings":{},"DeviceCgroupRules":null,"Tmpfs":null,"Devices":[{"PathOnHost":"/dev/kvm","PathInContainer":"/dev/kvm","CgroupPermissions":"rw"}]},"Mounts":[{"Type":"volume","Destination":"/storage","RW":true}]}]
+            [{"Config":{"Labels":{"org.meeting-assistant.native-diagnostic":"validation"},"Env":["KVM=N","CPU_MODEL=Haswell-noTSX","VERSION=14"]},"HostConfig":{"Privileged":false,"NetworkMode":"default","Memory":6442450944,"MemorySwap":6442450944,"NanoCpus":2000000000,"ShmSize":536870912,"CapAdd":null,"DeviceRequests":null,"Binds":null,"PortBindings":{},"DeviceCgroupRules":null,"Tmpfs":null,"Devices":[]},"Mounts":[{"Type":"volume","Destination":"/storage","RW":true}]}]
            """;
        AssertContainer(boundary, "validation");
-        foreach (var invalid in new[] { boundary.Replace("\"Privileged\":false", "\"Privileged\":true"), boundary.Replace("\"CgroupPermissions\":\"rw\"", "\"CgroupPermissions\":\"rwm\""), boundary.Replace("/dev/kvm", "/dev/other"), boundary.Replace("KVM=Y", "KVM=N"), boundary.Replace("CPU_MODEL=host", "CPU_MODEL=Skylake-Client-v4"), boundary.Replace("VERSION=13", "VERSION=14"), boundary.Replace("6442450944", "8589934592"), boundary.Replace("\"NetworkMode\":\"default\"", "\"NetworkMode\":\"host\""), boundary.Replace("\"CapAdd\":null", "\"CapAdd\":[\"NET_ADMIN\"]"), boundary.Replace("\"Type\":\"volume\"", "\"Type\":\"bind\""), boundary.Replace("/storage", "/host") })
+        foreach (var invalid in new[] { boundary.Replace("\"Privileged\":false", "\"Privileged\":true"), boundary.Replace("\"Devices\":[]", "\"Devices\":[{\"PathOnHost\":\"/dev/kvm\",\"PathInContainer\":\"/dev/kvm\",\"CgroupPermissions\":\"rw\"}]"), boundary.Replace("KVM=N", "KVM=Y"), boundary.Replace("CPU_MODEL=Haswell-noTSX", "CPU_MODEL=host"), boundary.Replace("VERSION=14", "VERSION=13"), boundary.Replace("6442450944", "8589934592"), boundary.Replace("\"NetworkMode\":\"default\"", "\"NetworkMode\":\"host\""), boundary.Replace("\"CapAdd\":null", "\"CapAdd\":[\"NET_ADMIN\"]"), boundary.Replace("\"Type\":\"volume\"", "\"Type\":\"bind\""), boundary.Replace("/storage", "/host"), boundary.Replace("\"NanoCpus\":2000000000", "\"NanoCpus\":4000000000") })
        {
            try { AssertContainer(invalid, "validation"); } catch (InvalidOperationException) { continue; }
            throw new InvalidOperationException("Diagnostic validator accepted an excessive/wrong-profile container boundary.");
        }
    }

-    static async Task PrepareSource(string source, string output, string token, bool writeSource, string? cryptexArchive, CancellationToken cancellation)
+    static string NormalizeReadinessDiagnostics(string source)
+    {
+        const string start = "# BEGIN disk IPC diagnostic\n";
+        const string end = "# END disk IPC diagnostic\n";
+        var blocks = 0;
+        while (source.IndexOf(start, StringComparison.Ordinal) is var from && from >= 0)
+        {
+            var to = source.IndexOf(end, from + start.Length, StringComparison.Ordinal);
+            if (to < 0 || source.IndexOf(start, from + start.Length, to - from - start.Length, StringComparison.Ordinal) >= 0)
+                throw new InvalidOperationException("Readiness diagnostic blocks are unbalanced or nested.");
+            source = source.Remove(from, to + end.Length - from);
+            blocks++;
+        }
+        if (blocks != 7 || source.Contains(end, StringComparison.Ordinal))
+            throw new InvalidOperationException("Readiness must contain exactly seven explicit disk IPC diagnostic blocks.");
+        source = RestoreVersionBlock(source, "successful sw_vers version parser", "");
+        source = RestoreVersionBlock(source, "successful sw_vers version extraction", "run_command version /usr/bin/sw_vers -productVersion\n(( LAST_EXIT == 0 )) || fail_probe product_version_failed\nread_scalar || fail_probe product_version_invalid\n");
+        return source;
+    }
+
+    static string RestoreVersionBlock(string source, string name, string originalSequence)
+    {
+        var start = "# BEGIN " + name + "\n";
+        var end = "# END " + name + "\n";
+        if (source.Split(start, StringSplitOptions.None).Length != 2 || source.Split(end, StringSplitOptions.None).Length != 2)
+            throw new InvalidOperationException("Readiness requires exactly one named version marker pair: " + name);
+        var from = source.IndexOf(start, StringComparison.Ordinal);
+        var to = source.IndexOf(end, StringComparison.Ordinal);
+        if (to < from + start.Length) throw new InvalidOperationException("Readiness version markers are reversed: " + name);
+        return source.Remove(from, to + end.Length - from).Insert(from, originalSequence);
+    }
+
+    static async Task PrepareSource(string source, string output, string token, bool writeSource, CancellationToken cancellation)
    {
        Directory.CreateDirectory(output);
        var patchPath = Path.Combine(source, "src/install/recovery/patch.py");
@@ -232,11 +288,20 @@ static class NativeDiagnostic
        var dockerfile = ReplaceOnce(File.ReadAllText(dockerPath), "FROM scratch AS base\nCOPY --from=qemux/qemu:7.50 --exclude=usr/bin/qemu-system-x86_64 / /\n", "FROM qemux/qemu:7.50@sha256:e7f6fda52503a546fd649670ba46e4bc23dc6dcef275bc3fac48877fbbc430df AS base\n");
        dockerfile = ReplaceAllExact(dockerfile, "--from=qemux/qemu-macos:latest ", "--from=qemux/qemu-macos:latest@sha256:af64297171228f27d5f616249e18f6ad5e2fbc79c1cc517252521e8bcd8eadaa ", 2);
        dockerfile = ReplaceOnce(dockerfile, "ADD $REPO_KVM_OPENCORE/releases/download/v$VERSION_KVM_OPENCORE/LongQT-OpenCore-v$VERSION_KVM_OPENCORE.iso /opencore.iso", "ADD --checksum=sha256:" + OpenCoreTemplateHash + " $REPO_KVM_OPENCORE/releases/download/v$VERSION_KVM_OPENCORE/LongQT-OpenCore-v$VERSION_KVM_OPENCORE.iso /opencore.iso");
-        var compatibility = await PrepareCompatibility(source, output, cryptexArchive, cancellation);
+        dockerfile = ReplaceOnce(dockerfile, "    gzip \\\n", "    gzip \\\n    nasm \\\n");
+        dockerfile = ReplaceOnce(dockerfile, "COPY --chmod=755 ./assets /assets/\n", "COPY --chmod=755 ./assets /assets/\nRUN nasm -f bin /assets/ci-cpu-preflight.asm -o /assets/ci-cpu-preflight.bin && test \"$(stat -c%s /assets/ci-cpu-preflight.bin)\" = 65536\n");
+        var boot = PrepareTcgBoot(source);
+        var cpuPath = Path.Combine(source, "src/cpu.sh");
+        var cpu = File.ReadAllText(cpuPath);
+        if (Hash(Encoding.UTF8.GetBytes(cpu)) != "0f3e4b4e1c3e17743d3a8d27b77a76424ceebb576b269283d612c489bc70993e") throw new InvalidOperationException("Pinned CPU composition script hash mismatch.");
+        cpu = ReplaceOnce(cpu, ",+movbe,+rdrand,check\"", ",+movbe,+rdrand,enforce=on\"");
+        var preflight = File.ReadAllText(Path.Combine("tools", "ci", "macos-tcg-cpu-preflight.asm"));
        var entryPath = Path.Combine(source, "src/entry.sh");
        var entry = ReplaceOnce(File.ReadAllText(entryPath), "set -Eeuo pipefail\n", "set -Eeuo pipefail\n\n# Diagnostic budget: inspect existing Docker storage before Recovery download/boot.\ndf -Pk /storage\nfree_kib=$(df -Pk /storage | awk 'NR==2 {print $4}')\n[[ \"$free_kib\" =~ ^[0-9]+$ ]] && (( free_kib >= 8 * 1024 * 1024 )) || { echo 'Existing Docker storage has less than the 8-GiB diagnostic budget.' >&2; exit 1; }\n");
-        entry = ReplaceOnce(entry, ". init.sh       # Initialize system\n", ". init.sh       # Initialize system\n# Fail before Apple downloads if the existing daemon cannot retain this profile.\nenabled \"$KVM\" && [[ \"$CPU_MODEL\" == host && \"$VERSION\" == 13 ]] && grep -Eq '^vendor_id[[:space:]]*:[[:space:]]*GenuineIntel$' /proc/cpuinfo || { error 'Compatibility probe requires existing Intel KVM and the exact host/13 profile.'; exit 1; }\n");
-        entry = ReplaceOnce(entry, "trap - ERR\n", "[[ \"$KVM_OPTS\" == *'accel=kvm'* || \"$KVM_OPTS\" == *'-accel kvm'* ]] && [[ \"$KVM_OPTS\" != *tcg* && \"$CPU_MODEL\" == host ]] || { error 'Compatibility profile refuses a TCG/CPU fallback.'; exit 1; }\ninfo '[compatibility-profile] accelerator=kvm cpu=host recovery=13; actual guest gates still pending'\n\ntrap - ERR\n");
+        entry = ReplaceOnce(entry, ". cpu.sh        # Configure CPU model\n", "");
+        entry = ReplaceOnce(entry, ". proc.sh       # Initialize processor\n", "");
+        entry = ReplaceOnce(entry, ". init.sh       # Initialize system\n", ". init.sh       # Initialize system\n. cpu.sh        # Compose the exact guest CPU before any Apple download\n. proc.sh       # Compose the actual accelerator/CPU_FLAGS once\n" + TcgPreflight + "\n");
+        entry = ReplaceOnce(entry, "trap - ERR\n", "[[ \"$KVM_OPTS\" == ' -accel tcg,thread=multi' && \"$CPU_FLAGS\" == '" + CpuFlags + "' && \"$CPU_OPTS\" == \"-cpu $CPU_FLAGS -smp $SMP\" ]] || { error 'Supported profile refuses a CPU/accelerator fallback.'; exit 1; }\ninfo '[supported-profile] accelerator=tcg cpu=Haswell-noTSX recovery=14; AVX/AVX2 preflight passed; native guest gates still pending'\n\ntrap - ERR\n");
        var hookPath = Path.Combine("tools", "ci", "macos-native-readiness.sh");
        var hook = ReplaceOnce(File.ReadAllText(hookPath), "@@PROOF_TOKEN@@", token);
        var wrapper = File.ReadAllText(Path.Combine("tools", "ci", "macos-native-bootstrap.sh"));
@@ -246,14 +311,16 @@ static class NativeDiagnostic
        var image = ReplaceOnce(originalImage, "  if ! cp -f \"$IMAGE_TOOLS/recovery/launch.sh\" \"$script\"; then\n", "  if ! cp -f \"$IMAGE_TOOLS/recovery/launch.sh\" \"$script\" ||\n     ! cp -f \"$IMAGE_TOOLS/recovery/readiness.sh\" \"${script%/*}/readiness.sh\"; then\n");
        image = ReplaceOnce(image, "  if ! cmp -s \"$IMAGE_TOOLS/recovery/launch.sh\" \"$script\" ||\n", "  if ! cmp -s \"$IMAGE_TOOLS/recovery/launch.sh\" \"$script\" ||\n     ! cmp -s \"$IMAGE_TOOLS/recovery/readiness.sh\" \"$state/readiness.sh\" ||\n");
        image = ReplaceOnce(image, "  if ! result=$(python3 \"$IMAGE_TOOLS/recovery/patch.py\" \"$image\"); then\n", "  info \"[recovery-original] bytes=$(stat -c%s -- \"$image\") sha256=$(sha256sum \"$image\" | awk '{print $1}')\"\n  if ! result=$(python3 \"$IMAGE_TOOLS/recovery/patch.py\" \"$image\"); then\n");
-        foreach (var pair in new[] { ("recovery-patch.py", patch), ("Dockerfile.patched", dockerfile), ("container-entry.sh", entry), ("guest-launch.sh", wrapper), ("guest-readiness.sh", hook), ("image.sh.patched", image), ("recoveryosd-original.plist", daemon), ("recoveryosd-diagnostic.plist", DiagnosticDaemon), ("recoveryosd-13-original.plist", OriginalDaemon13), ("recoveryosd-13-diagnostic.plist", DiagnosticDaemon13), ("early-bootstrap.sh", MountOnlyBootstrap), ("boot.sh.patched", compatibility.Boot), ("opencore-config.plist", compatibility.Config) })
+        foreach (var pair in new[] { ("recovery-patch.py", patch), ("Dockerfile.patched", dockerfile), ("container-entry.sh", entry), ("guest-launch.sh", wrapper), ("guest-readiness.sh", hook), ("image.sh.patched", image), ("recoveryosd-original.plist", daemon), ("recoveryosd-diagnostic.plist", DiagnosticDaemon), ("recoveryosd-13-original.plist", OriginalDaemon13), ("recoveryosd-13-diagnostic.plist", DiagnosticDaemon13), ("early-bootstrap.sh", MountOnlyBootstrap), ("boot.sh.patched", boot), ("opencore-config.plist", File.ReadAllText(Path.Combine(source, "assets/config.plist"))), ("cpu.sh.patched", cpu), ("ci-cpu-preflight.asm", preflight) })
            File.WriteAllText(Path.Combine(output, pair.Item1), pair.Item2, new UTF8Encoding(false));
-        Save(Path.Combine(output, "source-hashes.json"), Directory.GetFiles(output).Where(path => Path.GetFileName(path) is "recovery-patch.py" or "udif_checksums.py" or "Dockerfile.patched" or "container-entry.sh" or "guest-launch.sh" or "guest-readiness.sh" or "image.sh.patched" or "recoveryosd-original.plist" or "recoveryosd-diagnostic.plist" or "recoveryosd-13-original.plist" or "recoveryosd-13-diagnostic.plist" or "early-bootstrap.sh" or "boot.sh.patched" or "opencore-config.plist" or "compatibility-boot-assets.json").ToDictionary(path => Path.GetFileName(path)!, path => Hash(File.ReadAllBytes(path))));
+        Save(Path.Combine(output, "source-hashes.json"), Directory.GetFiles(output).Where(path => Path.GetFileName(path) is "recovery-patch.py" or "udif_checksums.py" or "Dockerfile.patched" or "container-entry.sh" or "guest-launch.sh" or "guest-readiness.sh" or "image.sh.patched" or "recoveryosd-original.plist" or "recoveryosd-diagnostic.plist" or "recoveryosd-13-original.plist" or "recoveryosd-13-diagnostic.plist" or "early-bootstrap.sh" or "boot.sh.patched" or "opencore-config.plist" or "cpu.sh.patched" or "ci-cpu-preflight.asm").ToDictionary(path => Path.GetFileName(path)!, path => Hash(File.ReadAllBytes(path))));
+        Save(Path.Combine(output, "cpu-preflight-source.json"), new { profile = Profile, cpuModel = CpuModel, cpuFlags = CpuFlags, expectedExitCode = 33, instructionProbeExecuted = false, qemuBinaryExecuted = false, sourceSha256 = Hash(Encoding.UTF8.GetBytes(preflight)) });
        await Command("bash", ["-n", Path.Combine(output, "guest-launch.sh")], output, "guest-hook-syntax", cancellation);
        await Command("bash", ["-n", Path.Combine(output, "guest-readiness.sh")], output, "guest-readiness-syntax", cancellation);
        await Command("bash", ["-n", Path.Combine(output, "image.sh.patched")], output, "guest-staging-syntax", cancellation);
        await Command("bash", ["-n", Path.Combine(output, "container-entry.sh")], output, "entry-syntax", cancellation);
        await Command("bash", ["-n", Path.Combine(output, "boot.sh.patched")], output, "boot-staging-syntax", cancellation);
+        await Command("bash", ["-n", Path.Combine(output, "cpu.sh.patched")], output, "cpu-composition-syntax", cancellation);
        if (!writeSource) return;
        File.WriteAllText(patchPath, patch, new UTF8Encoding(false));
        File.WriteAllText(Path.Combine(source, "src/install/recovery/udif_checksums.py"), checksumBinding, new UTF8Encoding(false));
@@ -262,16 +329,9 @@ static class NativeDiagnostic
        File.WriteAllText(imagePath, image, new UTF8Encoding(false));
        File.WriteAllText(Path.Combine(source, "src/install/recovery/launch.sh"), wrapper, new UTF8Encoding(false));
        File.WriteAllText(Path.Combine(source, "src/install/recovery/readiness.sh"), hook, new UTF8Encoding(false));
-        File.WriteAllText(Path.Combine(source, "src/boot.sh"), compatibility.Boot, new UTF8Encoding(false));
-        File.WriteAllText(Path.Combine(source, "assets/config.plist"), compatibility.Config, new UTF8Encoding(false));
-        var target = Path.Combine(source, "assets", "native-compatibility");
-        if (Directory.Exists(target)) throw new InvalidOperationException("Refusing an existing compatibility asset overlay.");
-        foreach (var file in Directory.GetFiles(compatibility.Assets, "*", SearchOption.AllDirectories))
-        {
-            var destination = Path.Combine(target, Path.GetRelativePath(compatibility.Assets, file));
-            Directory.CreateDirectory(Path.GetDirectoryName(destination)!);
-            File.Copy(file, destination, false);
-        }
+        File.WriteAllText(Path.Combine(source, "src/boot.sh"), boot, new UTF8Encoding(false));
+        File.WriteAllText(cpuPath, cpu, new UTF8Encoding(false));
+        File.WriteAllText(Path.Combine(source, "assets/ci-cpu-preflight.asm"), preflight, new UTF8Encoding(false));
    }

    static void ValidateDaemon(string xml, string processType, bool patched)
@@ -317,53 +377,19 @@ static class NativeDiagnostic
        return string.Join("\n", lines.Select(line => new string(' ', spaces) + (line.Length > 0 ? line[common..] : "")));
    }

-    static async Task<(string Boot, string Config, string Assets)> PrepareCompatibility(string source, string output, string? archivePath, CancellationToken cancellation)
+    static string PrepareTcgBoot(string source)
    {
        var boot = File.ReadAllText(Path.Combine(source, "src", "boot.sh"));
        var config = File.ReadAllText(Path.Combine(source, "assets", "config.plist"));
        if (Hash(Encoding.UTF8.GetBytes(boot)) != "82b56525707a8f586e040f56108b5034c02e7fecfea071f1857e596cba10cbed" || Hash(Encoding.UTF8.GetBytes(config)) != "3b0ec58b693cfa0fadf3e3f952486e87af8c27d504f9545d1e90ae2dc3777096") throw new InvalidOperationException("Pinned OpenCore staging/config hashes mismatch.");
-        byte[] bytes;
-        if (archivePath is not null) bytes = await File.ReadAllBytesAsync(archivePath, cancellation);
-        else
-        {
-            using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(30), MaxResponseContentBufferSize = 2 * 1024 * 1024 };
-            bytes = await client.GetByteArrayAsync(CryptexUrl, cancellation);
-        }
-        if (bytes.Length != 69703 || Hash(bytes) != CryptexHash) throw new InvalidOperationException("Official CryptexFixup release size/hash mismatch.");
-        File.WriteAllBytes(Path.Combine(output, "CryptexFixup-1.0.5-RELEASE.zip"), bytes);
-        var assets = Path.Combine(output, "compatibility-assets");
-        if (Directory.Exists(assets)) throw new InvalidOperationException("Compatibility validation requires a fresh output directory.");
-        Directory.CreateDirectory(assets);
-        using var archive = new ZipArchive(new MemoryStream(bytes), ZipArchiveMode.Read);
-        var required = new[] { "CryptexFixup.kext/Contents/Info.plist", "CryptexFixup.kext/Contents/MacOS/CryptexFixup" };
-        var entries = archive.Entries.Where(entry => entry.FullName.StartsWith("CryptexFixup.kext/", StringComparison.Ordinal) && !entry.FullName.EndsWith('/')).ToArray();
-        if (entries.Length != 2 || required.Any(name => entries.Count(entry => entry.FullName == name) != 1)) throw new InvalidOperationException("Cryptex bundle has an unexpected file layout.");
-        foreach (var entry in entries)
-        {
-            if (entry.Length <= 0 || entry.Length > 1024 * 1024) throw new InvalidOperationException("Cryptex bundle file exceeded the staging bound.");
-            var destination = Path.Combine(assets, entry.FullName);
-            Directory.CreateDirectory(Path.GetDirectoryName(destination)!);
-            entry.ExtractToFile(destination, false);
-        }
-        var info = XDocument.Load(Path.Combine(assets, required[0])).Root!.Element("dict")!;
-        if (PlistValue(info, "CFBundleIdentifier").Value != "com.khronokernel.CryptexFixup" || PlistValue(info, "CFBundleVersion").Value != "1.0.5" || PlistValue(info, "CFBundleExecutable").Value != "CryptexFixup" || PlistValue(PlistValue(info, "OSBundleLibraries"), "as.vit9696.Lilu").Value != "1.4.7") throw new InvalidOperationException("Cryptex bundle identity/version/Lilu dependency mismatch.");
-        var fileHashes = required.ToDictionary(name => name, name => Hash(File.ReadAllBytes(Path.Combine(assets, name))));
-        File.WriteAllText(Path.Combine(assets, "SHA256SUMS"), string.Concat(fileHashes.Select(pair => pair.Value + "  " + pair.Key + "\n")), new UTF8Encoding(false));
-        Save(Path.Combine(output, "compatibility-boot-assets.json"), new { cryptexUrl = CryptexUrl, cryptexSha256 = CryptexHash, cryptexBytes = bytes.Length, cryptexFiles = fileHashes, templateUrl = "https://github.com/LongQT-sea/OpenCore-ISO/releases/download/v0.7/LongQT-OpenCore-v0.7.iso", templateSha256 = OpenCoreTemplateHash, templateBytes = 15884288, liluVersion = "1.7.1", liluBinarySha256 = "0c016d93cfe40c7fa3965813175c1b991a76f3d295efd5be66ae712b4a3ffb52", liluBinaryBytes = 526984, liluInfoSha256 = "fc885f3319f326e3af60e7965a5216b671772d39d40993ec695758bb43d6ea3a", causalSingleVariableTest = false });
        var document = XDocument.Parse(config, LoadOptions.PreserveWhitespace);
        var add = PlistValue(PlistValue(document.Root!.Element("dict")!, "Kernel"), "Add");
        var expected = new[] { "Lilu.kext", "VMHide.kext", "VirtualSMC.kext", "WhateverGreen.kext", "VoodooPS2Controller.kext", "VoodooPS2Controller.kext/Contents/PlugIns/VoodooPS2Keyboard.kext", "AppleMCEReporterDisabler.kext" };
        if (!add.Elements("dict").Select(dict => PlistValue(dict, "BundlePath").Value).SequenceEqual(expected) || add.Elements("dict").Any(dict => PlistValue(dict, "Enabled").Name != "true")) throw new InvalidOperationException("Pinned Kernel.Add order/enabled contract mismatch.");
-        var cryptex = XElement.Parse("<dict><key>Arch</key><string>x86_64</string><key>BundlePath</key><string>CryptexFixup.kext</string><key>Comment</key><string>Official CryptexFixup 1.0.5; owned compatibility guest only</string><key>Enabled</key><true/><key>ExecutablePath</key><string>Contents/MacOS/CryptexFixup</string><key>MaxKernel</key><string></string><key>MinKernel</key><string>22.0.0</string><key>PlistPath</key><string>Contents/Info.plist</string></dict>");
-        add.Elements("dict").First().AddAfterSelf(cryptex);
-        var bootArguments = PlistValue(PlistValue(PlistValue(PlistValue(document.Root.Element("dict")!, "NVRAM"), "Add"), "7C436110-AB2A-4BBB-A880-FE41995C9F82"), "boot-args").Value.Split(' ', StringSplitOptions.RemoveEmptyEntries);
-        if (bootArguments.Intersect(new[] { "-cryptoff", "-liluoff", "-crypt_allow_hash_validation", "-crypt_force_avx", "-cryptbeta", "-lilubetaall" }).Any()) throw new InvalidOperationException("Unexpected Cryptex/Lilu disabling or forcing boot argument.");
-        boot = ReplaceOnce(boot, "  cp -a \"$template/OC/Resources\" \"$EFI_DIR/OC/\"\n", "  cp -a \"$template/OC/Resources\" \"$EFI_DIR/OC/\"\n" + CompatibilityStaging + "\n");
-        boot = ReplaceOnce(boot, "  PLIST=\"/assets/config.plist\"\n", "  [ ! -e /custom.plist ] || { error 'Compatibility profile refuses an unverified custom OpenCore config!'; exit 12; }\n  PLIST=\"/assets/config.plist\"\n");
-        boot = ReplaceOnce(boot, "  checkOpenCoreConfig\n  addVmHideKext\n", "  checkOpenCoreConfig\n" + CompatibilityConfigCheck + "\n  addVmHideKext\n");
+        boot = ReplaceOnce(boot, "  PLIST=\"/assets/config.plist\"\n", "  [ ! -e /custom.plist ] || { error 'Supported profile refuses an unverified custom OpenCore config!'; exit 12; }\n  PLIST=\"/assets/config.plist\"\n");
        boot = ReplaceOnce(boot, "  if [ -s \"$target\" ] && [ \"$previous\" = \"$current\" ]; then\n    IMG=\"$target\"\n    return 0\n  fi\n", "  # This owned compatibility probe always rebuilds; never trust a cached boot.img.\n");
-        boot = ReplaceOnce(boot, "    echo \"VMHIDE=$vmhide\"\n", "    echo \"VMHIDE=$vmhide\"\n    echo \"COMPATIBILITY=kvm-host-ventura-cryptex\"\n    sha256sum /assets/native-compatibility/SHA256SUMS\n");
-        return (boot, document.ToString(), assets);
+        boot = ReplaceOnce(boot, "    echo \"VMHIDE=$vmhide\"\n", "    echo \"VMHIDE=$vmhide\"\n    echo \"PROFILE=tcg-haswell-sonoma\"\n");
+        return boot;
    }

    static XElement PlistValue(XElement dictionary, string key)
@@ -373,32 +399,80 @@ static class NativeDiagnostic
        return value;
    }

-    const string CompatibilityStaging = """
-          # Only the freshly extracted, owned guest EFI is changed; never the host.
-          local lilu="$EFI_DIR/OC/Kexts/Lilu.kext/Contents"
-          printf '%s  %s\n' \
-            fc885f3319f326e3af60e7965a5216b671772d39d40993ec695758bb43d6ea3a "$lilu/Info.plist" \
-            0c016d93cfe40c7fa3965813175c1b991a76f3d295efd5be66ae712b4a3ffb52 "$lilu/MacOS/Lilu" | sha256sum -c - || { error "Pinned active Lilu files mismatch!"; exit 12; }
-          [ "$(xmlstarlet sel -T -t -v '/plist/dict/key[.="CFBundleVersion"]/following-sibling::string[1]' "$lilu/Info.plist")" = 1.7.1 ] || { error "Active Lilu version mismatch!"; exit 12; }
-          [ ! -e "$EFI_DIR/OC/Kexts/CryptexFixup.kext" ] || { error "Unexpected pre-existing Cryptex kext!"; exit 12; }
-          (cd /assets/native-compatibility && sha256sum -c SHA256SUMS) || { error "Pinned Cryptex staging files mismatch!"; exit 12; }
-          cp -a /assets/native-compatibility/CryptexFixup.kext "$EFI_DIR/OC/Kexts/"
-          (cd "$EFI_DIR/OC/Kexts" && sha256sum -c /assets/native-compatibility/SHA256SUMS) || { error "Active Cryptex copy mismatch!"; exit 12; }
-          info "[compatibility-boot] Lilu=1.7.1 CryptexFixup=1.0.5 files=verified; guest injection and Recovery readiness remain unproved"
-        """;
+    static readonly string TcgPreflight = """
+        # Realize this exact TCG model and execute AVX/AVX2 before Apple downloads.
+        disabled "$KVM" && [[ "$ARCH" == amd64 && "$CPU_MODEL" == Haswell-noTSX && "$VERSION" == 14 && "$CPU_FLAGS" == '@@CPU_FLAGS@@' ]] || { error 'Supported probe requires the exact TCG/Haswell/macOS 14 profile.'; exit 1; }
+        [[ "$(qemu-system-x86_64 --version | head -n 1)" == 'QEMU emulator version 11.1.1 (Reims 11.1.3)' ]] || { error 'Pinned QEMU runtime version mismatch.'; exit 1; }
+        printf '%s  %s\n' c32746122cc68f3ed642aa46c21b677f803c58f0d4ff665841723fcc5625f549 /assets/ci-cpu-preflight.bin | sha256sum -c - || { error 'Compiled AVX/AVX2 preflight ROM hash mismatch.'; exit 1; }
+        probeTcgInstructions() {
+          /usr/bin/timeout --signal=TERM --kill-after=2 10 qemu-system-x86_64 \
+            -machine q35 -accel tcg,thread=multi -cpu "$1" -smp 2 -m 64 -bios /assets/ci-cpu-preflight.bin \
+            -nodefaults -display none -serial none -monitor none -nographic -no-reboot \
+            -device isa-debug-exit,iobase=0xf4,iosize=0x04
+        }
+        if probeTcgInstructions "$CPU_FLAGS" > "$QEMU_DIR/cpu-preflight-positive.log" 2>&1; then positive=0; else positive=$?; fi
+        cat "$QEMU_DIR/cpu-preflight-positive.log"
+        (( positive == 33 )) || { error "Actual TCG AVX/AVX2 instruction preflight failed: exit=$positive"; exit 1; }
+        if probeTcgInstructions "$CPU_FLAGS,-avx2" > "$QEMU_DIR/cpu-preflight-negative.log" 2>&1; then negative=0; else negative=$?; fi
+        cat "$QEMU_DIR/cpu-preflight-negative.log"
+        (( negative != 33 )) || { error 'AVX2-disabled negative control unexpectedly passed.'; exit 1; }
+        info "[cpu-preflight] positive=$positive negative=$negative cpu=$CPU_FLAGS; actual AVX/AVX2 executed before Apple download"
+        """.Replace("@@CPU_FLAGS@@", CpuFlags, StringComparison.Ordinal);

-    const string CompatibilityConfigCheck = """
-          local kernel='/plist/dict/key[.="Kernel"]/following-sibling::dict[1]/key[.="Add"]/following-sibling::array[1]'
-          local actual expected
-          actual=$(xmlstarlet sel -T -t -m "$kernel/dict" -v 'key[.="BundlePath"]/following-sibling::string[1]' -n "$CFG") || exit 12
-          expected=$(printf '%s\n' Lilu.kext CryptexFixup.kext VMHide.kext VirtualSMC.kext WhateverGreen.kext VoodooPS2Controller.kext VoodooPS2Controller.kext/Contents/PlugIns/VoodooPS2Keyboard.kext AppleMCEReporterDisabler.kext)
-          [ "$actual" = "$expected" ] || { error "Active Kernel.Add order mismatch!"; exit 12; }
-          [ "$(xmlstarlet sel -T -t -v "name($kernel/dict[1]/key[.='Enabled']/following-sibling::*[1])" -v "name($kernel/dict[2]/key[.='Enabled']/following-sibling::*[1])" "$CFG")" = truetrue ] || { error "Active Lilu/Cryptex must both be enabled!"; exit 12; }
-          actual=$(xmlstarlet sel -T -t -m "$kernel/dict[2]" -v 'key[.="Arch"]/following-sibling::string[1]' -n -v 'key[.="ExecutablePath"]/following-sibling::string[1]' -n -v 'key[.="PlistPath"]/following-sibling::string[1]' -n -v 'key[.="MinKernel"]/following-sibling::string[1]' -n -v 'key[.="MaxKernel"]/following-sibling::string[1]' "$CFG") || exit 12
-          expected=$(printf '%s\n' x86_64 Contents/MacOS/CryptexFixup Contents/Info.plist 22.0.0 '')
-          [ "$actual" = "$expected" ] || { error "Active Cryptex Kernel.Add paths/architecture/Darwin bounds mismatch!"; exit 12; }
-          info "[compatibility-config] Kernel.Add=Lilu,CryptexFixup before remaining baseline kexts; MinKernel=22.0.0 MaxKernel=empty"
-        """;
+    static async Task ValidateTcgPreflight(string output, CancellationToken cancellation)
+    {
+        var fixture = Path.Combine(output, "validation-cpu-preflight-gate");
+        Directory.CreateDirectory(fixture);
+        var entry = File.ReadAllText(Path.Combine(output, "container-entry.sh"));
+        if (entry.IndexOf(TcgPreflight, StringComparison.Ordinal) >= entry.IndexOf(". download.sh", StringComparison.Ordinal)
+            || entry.Split(". cpu.sh", StringSplitOptions.None).Length != 2
+            || entry.Split(". proc.sh", StringSplitOptions.None).Length != 2)
+            throw new InvalidOperationException("Actual composed CPU preflight must execute once before any Apple download.");
+        var cases = new[]
+        {
+            ("positive-negative-exit", 33, 0, "14", CpuFlags, true, true),
+            ("positive-negative-timeout", 33, 124, "14", CpuFlags, true, true),
+            ("positive-normal-exit", 0, 0, "14", CpuFlags, true, false),
+            ("positive-timeout", 124, 0, "14", CpuFlags, true, false),
+            ("negative-passed", 33, 33, "14", CpuFlags, true, false),
+            ("wrong-recovery", 33, 0, "13", CpuFlags, true, false),
+            ("wrong-cpu-flags", 33, 0, "14", CpuFlags.Replace("enforce=on", "check"), true, false),
+            ("wrong-rom-hash", 33, 0, "14", CpuFlags, false, false)
+        };
+        foreach (var item in cases)
+        {
+            var work = Path.Combine(fixture, item.Item1);
+            Directory.CreateDirectory(work);
+            var script = """
+                set -euo pipefail
+                disabled() { [ "$1" = N ]; }
+                error() { printf '%s\n' "$*" >&2; }
+                info() { printf '%s\n' "$*"; }
+                qemu-system-x86_64() { printf '%s\n' 'QEMU emulator version 11.1.1 (Reims 11.1.3)'; }
+                sha256sum() { cat >/dev/null; return "@@HASH_EXIT@@"; }
+                mock_timeout() {
+                  printf '[fixture-command] %s\n' "$*"
+                  case "$*" in *,-avx2*) return @@NEGATIVE@@ ;; *) return @@POSITIVE@@ ;; esac
+                }
+                KVM=N; ARCH=amd64; CPU_MODEL=Haswell-noTSX; VERSION='@@VERSION@@'
+                CPU_FLAGS='@@FLAGS@@'; QEMU_DIR='@@WORK@@'
+                """.Replace("@@HASH_EXIT@@", item.Item6 ? "0" : "1", StringComparison.Ordinal)
+                   .Replace("@@NEGATIVE@@", item.Item3.ToString(), StringComparison.Ordinal)
+                   .Replace("@@POSITIVE@@", item.Item2.ToString(), StringComparison.Ordinal)
+                   .Replace("@@VERSION@@", item.Item4, StringComparison.Ordinal)
+                   .Replace("@@FLAGS@@", item.Item5, StringComparison.Ordinal)
+                   .Replace("@@WORK@@", work.Replace("'", "'\\''", StringComparison.Ordinal), StringComparison.Ordinal)
+                   + "\n" + TcgPreflight.Replace("/usr/bin/timeout", "mock_timeout", StringComparison.Ordinal)
+                   + "\nprintf '[fixture] Apple download reached after gate\\n'\n";
+            var path = Path.Combine(work, "fixture.sh");
+            File.WriteAllText(path, script, new UTF8Encoding(false));
+            var result = await Command("bash", [path], work, "gate", cancellation, requireSuccess: false);
+            var reached = result.Output.Contains("Apple download reached after gate", StringComparison.Ordinal);
+            Save(Path.Combine(work, "receipt.json"), new { success = (result.ExitCode == 0) == item.Item7 && reached == item.Item7, result.ExitCode, reachedAppleDownloadSeam = reached, qemuExecuted = false });
+            if ((result.ExitCode == 0) != item.Item7 || reached != item.Item7)
+                throw new InvalidOperationException("Actual TCG preflight gate fixture failed: " + item.Item1);
+        }
+    }

    static string ReplaceOnce(string text, string oldValue, string newValue) => ReplaceAllExact(text, oldValue, newValue, 1);
    static string ReplaceAllExact(string text, string oldValue, string newValue, int expected)
@@ -412,8 +486,8 @@ static class NativeDiagnostic
    {
        using var document = JsonDocument.Parse(json);
        var result = document.RootElement;
-        if (result.GetProperty("token").GetString() != token || !result.GetProperty("success").GetBoolean() || !Version.TryParse(result.GetProperty("osVersion").GetString(), out var version) || version.Major < 13 || result.GetProperty("architecture").GetString() != "x86_64" || result.GetProperty("uid").GetInt32() != 0 || !System.Text.RegularExpressions.Regex.IsMatch(result.GetProperty("disk").GetString() ?? "", "^/dev/disk[0-9]+$") || result.GetProperty("diskBytes").GetInt64() != GuestDiskBytes || result.GetProperty("readOnly").GetBoolean() || new[] { "systemExit", "diskArbitrationExit", "recoveryExit", "diskListExit" }.Any(key => result.GetProperty(key).GetInt32() != 0))
-            throw new InvalidOperationException("The fresh guest receipt did not prove native macOS 13+/x86_64, service readiness and the writable 64-GiB disk.");
+        if (result.GetProperty("token").GetString() != token || !result.GetProperty("success").GetBoolean() || !Version.TryParse(result.GetProperty("osVersion").GetString(), out var version) || version.Major < 14 || result.GetProperty("architecture").GetString() != "x86_64" || result.GetProperty("uid").GetInt32() != 0 || !System.Text.RegularExpressions.Regex.IsMatch(result.GetProperty("disk").GetString() ?? "", "^/dev/disk[0-9]+$") || result.GetProperty("diskBytes").GetInt64() != GuestDiskBytes || result.GetProperty("readOnly").GetBoolean() || new[] { "systemExit", "diskArbitrationExit", "recoveryExit", "diskListExit" }.Any(key => result.GetProperty(key).GetInt32() != 0))
+            throw new InvalidOperationException("The fresh guest receipt did not prove native macOS 14+/x86_64, service readiness and the writable 64-GiB disk.");
    }

    static void AssertContainer(string json, string token)
@@ -434,18 +508,15 @@ static class NativeDiagnostic
            || new[] { "CapAdd", "DeviceRequests", "Binds", "PortBindings", "DeviceCgroupRules", "Tmpfs" }.Any(key =>
                config.TryGetProperty(key, out var value) && value.ValueKind != JsonValueKind.Null
                && (value.ValueKind == JsonValueKind.Array ? value.GetArrayLength() != 0 : value.EnumerateObject().Any()))
-            || devices.GetArrayLength() != 1
-            || devices[0].GetProperty("PathOnHost").GetString() != "/dev/kvm"
-            || devices[0].GetProperty("PathInContainer").GetString() != "/dev/kvm"
-            || devices[0].GetProperty("CgroupPermissions").GetString() != "rw"
+            || devices.GetArrayLength() != 0
            || mounts.GetArrayLength() != 1
            || mounts[0].GetProperty("Type").GetString() != "volume"
            || mounts[0].GetProperty("Destination").GetString() != "/storage"
            || !mounts[0].GetProperty("RW").GetBoolean()
-            || new[] { "KVM=Y", "CPU_MODEL=host", "VERSION=13" }.Any(expected =>
+            || new[] { "KVM=N", "CPU_MODEL=" + CpuModel, "VERSION=14" }.Any(expected =>
                environment.Count(value => value is not null && value.StartsWith(expected.Split('=')[0] + "=", StringComparison.Ordinal)) != 1
                || !environment.Contains(expected)))
-            throw new InvalidOperationException("Created container exceeds the owned restricted KVM/host-CPU compatibility boundary.");
+            throw new InvalidOperationException("Created container exceeds the owned unprivileged TCG/Haswell/macOS 14 boundary.");
    }

    static async Task CaptureGuest(string id, string output, CancellationToken cancellation, bool final = false, string? token = null)
@@ -457,7 +528,40 @@ static class NativeDiagnostic
            var result = await Command("docker", ["exec", id, "cat", "/dev/shm/installstate/" + file.Item1], output, "capture-" + file.Item1, cancellation, requireSuccess: false);
            if (result.ExitCode == 0 && !string.IsNullOrWhiteSpace(result.Output)) File.WriteAllText(Path.Combine(output, file.Item2), result.Output);
        }
-        await Command("docker", ["exec", id, "sh", "-c", "printf '[qemu]\n'; qemu-system-x86_64 --version | head -n 1; printf '[Recovery hash]\n'; test ! -f /storage/13/setup.dmg || sha256sum /storage/13/setup.dmg; printf '[resources]\n'; df -Pk /storage; cat /sys/fs/cgroup/memory.max /sys/fs/cgroup/cpu.max 2>/dev/null || true"], output, "guest-container-resources", cancellation, requireSuccess: false, retainSuccessful: true);
+        // The immutable Recovery image is complete only after this staging marker.
+        // Hash it once instead of rereading the image on every twenty-second poll.
+        if (logs.Output.Contains("[supported-profile] accelerator=tcg", StringComparison.Ordinal)
+            && !File.Exists(Path.Combine(output, "guest-container-resources.last-success.json")))
+            await Command("docker", ["exec", id, "sh", "-c", "printf '[qemu]\n'; qemu-system-x86_64 --version | head -n 1; printf '[Recovery hash]\n'; test -f /storage/14/setup.dmg && sha256sum /storage/14/setup.dmg || exit 1; printf '[resources]\n'; df -Pk /storage; cat /sys/fs/cgroup/memory.max /sys/fs/cgroup/cpu.max 2>/dev/null || true"], output, "guest-container-resources", cancellation, requireSuccess: false, retainSuccessful: true);
+    }
+
+    static async Task CapturePressure(string id, string output, string phase, CancellationToken cancellation)
+    {
+        using var snapshotDeadline = CancellationTokenSource.CreateLinkedTokenSource(cancellation);
+        snapshotDeadline.CancelAfter(TimeSpan.FromSeconds(20));
+        const string snapshot = """
+            printf '[snapshot UTC]\n'; date -u '+%Y-%m-%dT%H:%M:%SZ'
+            for path in /proc/meminfo /proc/pressure/cpu /proc/pressure/memory /proc/pressure/io \
+                /sys/fs/cgroup/cpu.max /sys/fs/cgroup/cpu.stat /sys/fs/cgroup/cpu.pressure \
+                /sys/fs/cgroup/memory.max /sys/fs/cgroup/memory.current /sys/fs/cgroup/memory.peak \
+                /sys/fs/cgroup/memory.events /sys/fs/cgroup/memory.stat /sys/fs/cgroup/memory.pressure \
+                /sys/fs/cgroup/memory.swap.current; do
+                printf '\n[%s]\n' "$path"
+                if [ -r "$path" ]; then cat "$path"; else printf 'unavailable\n'; fi
+            done
+            printf '\n[host paging counters]\n'
+            awk '/^(pgmajfault|pswpin|pswpout) / {print}' /proc/vmstat
+            """;
+        try
+        {
+            await Command("docker", ["exec", id, "sh", "-c", snapshot], output, "capture-pressure-" + phase, snapshotDeadline.Token, requireSuccess: false, retainSuccessful: true);
+        }
+        catch (Exception exception)
+        {
+            // Optional evidence must not replace the guest outcome or prevent cleanup.
+            try { Save(Path.Combine(output, "capture-pressure-" + phase + ".unavailable.json"), new { phase, error = exception.Message, capturedUtc = DateTimeOffset.UtcNow }); }
+            catch (Exception evidenceError) { Console.Error.WriteLine("Optional pressure evidence: " + evidenceError.Message); }
+        }
    }

    static async Task CaptureMonitor(string id, string output, string token, CancellationToken cancellation)
@@ -1,88 +0,0 @@
-#:property PublishAot=false
-// Local diagnostic only. See TranscriptFileShareProbe.md for the contract and limits.
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Text.Json;
-
-const string original = "---\ntitle: transcript probe\n---\n\n# Meeting Transcript\n";
-const string written = original + "[00:00:04] Guest-1: Azure returned ***** here.\n";
-var root = Path.Combine(Path.GetTempPath(), "meeting-assistant-file-share-probe", Guid.NewGuid().ToString("N"));
-if (Directory.Exists(root))
-    throw new IOException("Probe directory already exists; refusing to reuse it.");
-Directory.CreateDirectory(root);
-var cases = new List<WriteObservation>();
-var cleanupCompleted = false;
-try
-{
-    var path = Path.Combine(root, "original-reader.md");
-    await File.WriteAllTextAsync(path, original);
-    using (var reader = new StreamReader(path, Encoding.UTF8, detectEncodingFromByteOrderMarks: true))
-    {
-        if (reader.ReadToEnd() != original)
-            throw new InvalidDataException("Original reader did not read the initial fixture.");
-        cases.Add(await ObserveWriteAsync("held-original-reader", path, written));
-    }
-    cases[^1] = cases[^1] with { ContentAfterReaderClosed = await File.ReadAllTextAsync(path) };
-    cases.Add(await ObserveWriteAsync("original-reader-released", path, written));
-    cases[^1] = cases[^1] with { ContentAfterReaderClosed = await File.ReadAllTextAsync(path) };
-
-    path = Path.Combine(root, "compatible-reader.md");
-    await File.WriteAllTextAsync(path, original);
-    using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete))
-    using (var reader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true))
-    {
-        if (reader.ReadToEnd() != original)
-            throw new InvalidDataException("Compatible reader did not read the initial fixture.");
-        cases.Add(await ObserveWriteAsync("held-compatible-reader", path, written));
-    }
-    cases[^1] = cases[^1] with { ContentAfterReaderClosed = await File.ReadAllTextAsync(path) };
-}
-finally
-{
-    Directory.Delete(root, recursive: true);
-    cleanupCompleted = !Directory.Exists(root);
-}
-
-var windowsContractMatched = OperatingSystem.IsWindows()
-    ? !cases[0].Completed && cases[0].Error is { Type: "System.IO.IOException", NativeCode: 32 }
-        && cases[0].ContentAfterReaderClosed == original
-    : (bool?)null;
-var compatibleAndReleasedWritesCompleted = cases.Skip(1).All(result =>
-    result.Completed && result.Error is null && result.ContentAfterReaderClosed == written);
-Console.WriteLine(JsonSerializer.Serialize(new
-{
-    Schema = "meeting-assistant-file-share-probe/v1",
-    Runtime = RuntimeInformation.FrameworkDescription,
-    OS = RuntimeInformation.OSDescription,
-    Architecture = RuntimeInformation.ProcessArchitecture.ToString(),
-    ProbeDirectory = root,
-    CleanupCompleted = cleanupCompleted,
-    WindowsContractMatched = windowsContractMatched,
-    CompatibleAndReleasedWritesCompleted = compatibleAndReleasedWritesCompleted,
-    Cases = cases,
-    EvidenceLimit = "Held-reader access-mode probe; it does not reproduce the timing or establish the cause of Run4174."
-}, new JsonSerializerOptions { WriteIndented = true }));
-return cleanupCompleted && compatibleAndReleasedWritesCompleted && windowsContractMatched != false ? 0 : 1;
-
-static async Task<WriteObservation> ObserveWriteAsync(string name, string path, string content)
-{
-    var elapsed = Stopwatch.StartNew();
-    Task? write = null;
-    using var deadline = new CancellationTokenSource(TimeSpan.FromSeconds(5));
-    try
-    {
-        write = File.WriteAllTextAsync(path, content, deadline.Token);
-        await write;
-        return new(name, true, write.Status.ToString(), elapsed.ElapsedMilliseconds, null, null);
-    }
-    catch (Exception exception)
-    {
-        return new(name, false, write?.Status.ToString() ?? "not-returned", elapsed.ElapsedMilliseconds,
-            new(exception.GetType().FullName!, $"0x{exception.HResult:X8}", exception.HResult & 0xffff, exception.Message), null);
-    }
-}
-
-sealed record WriteObservation(string Name, bool Completed, string TaskStatus, long ElapsedMilliseconds,
-    WriteError? Error, string? ContentAfterReaderClosed);
-sealed record WriteError(string Type, string HResult, int NativeCode, string Message);
@@ -1,25 +0,0 @@
-# Transcript file sharing diagnostic
-
-Purpose: distinguish a writer error from a completed write when a reader with the original test's access mode remains open. This temporary diagnostic does not change the app, its tests, or their 577-case count.
-
-Entry point: `tools/ci/TranscriptFileShareProbe.cs`, a .NET 10 file-based app with BCL-only dependencies. From this clone:
-
-```sh
-/Users/dh/.dotnet/dotnet run --file tools/ci/TranscriptFileShareProbe.cs
-```
-
-On another machine use its .NET 10 SDK executable. The file-based app requires an SDK supporting file-based apps; the prepared local run uses SDK 10.0.401. Native AOT is disabled for this diagnostic so its JSON report can use the normal reflection serializer. It prints JSON with runtime/OS, write completion, exception type/HResult/native error code, content after reader disposal, and cleanup status. It creates a unique directory beneath the system temporary directory, writes two small fixture files, and deletes only that directory in `finally`. It starts no Meeting Assistant app, service, network client, container, or VM. The SDK can create its normal file-based build cache. For a fresh CLI profile set `DOTNET_GENERATE_ASPNET_CERTIFICATE=false` and `DOTNET_CLI_TELEMETRY_OPTOUT=1` to disable unrelated certificate/telemetry initialization.
-
-The optional instrumentation in the existing recording-coordinator test observes public provider and transcript-store boundaries: audio consumed, fake segment yielded, append/rewrite entered, completed, or failed. Timeout output uses `[DEBUG-transcript-write-4174]` and includes elapsed milliseconds, exception type, HResult, and message. The reader, 15-second wait and final redaction assertions are unchanged. `StopAsync` always runs in `finally`; a stop failure does not mask the original timeout. Timestamps distinguish events before and after the failed wait. Instrumentation can affect race timing; a passing run alone does not explain the original failure. This temporary instrumentation should be removed after the actual Wine incident is explained.
-
-The original-reader case uses the same path-taking `StreamReader` constructor as `File.ReadAllText`. It deliberately holds the reader after reading the fixture so that the overlap is deterministic. The original test normally disposes that reader immediately after `ReadToEnd`; therefore this probe checks compatible access modes, not the historical race's timing. The second write happens after disposing that reader. The compatible case holds `FileAccess.Read` with `FileShare.ReadWrite | FileShare.Delete`. No reader fix is applied to the actual test.
-
-The existing Wine job runs this probe after its actual Windows SDK build and before the unchanged full test cohort. It writes `artifacts/tests/transcript-file-sharing.json` and prints that report into the CI log. Invocation there uses the already installed Windows SDK through the existing `WINE_BIN`; no runner or infrastructure capability is added. The measured Wine result is pending until this exact workflow executes.
-
-## Primary-source contract
-
-In [.NET runtime v10.0.12 File.cs](https://github.com/dotnet/runtime/blob/v10.0.12/src/libraries/System.Private.CoreLib/src/System/IO/File.cs#L572), `ReadAllText` constructs a path-taking `StreamReader`; [`StreamReader.cs`](https://github.com/dotnet/runtime/blob/v10.0.12/src/libraries/System.Private.CoreLib/src/System/IO/StreamReader.cs#L203) opens read access sharing only further readers. `WriteAllTextAsync` delegates to a create-mode write; [its writer](https://github.com/dotnet/runtime/blob/v10.0.12/src/libraries/System.Private.CoreLib/src/System/IO/File.cs#L1416) opens write access with reader sharing.
-
-[Windows CreateFileW documentation](https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew#parameters) requires existing access and sharing modes to remain compatible until handle closure. A held reader that does not permit writes therefore prevents that writer from opening; the Windows contract expects an `IOException` with sharing-violation native code 32. Allowing read/write sharing removes that incompatibility. Delete sharing is included for the comparison but this probe does not rename or delete an open file.
-
-On Windows the CLI asserts that the original held-reader write fails with code 32 and leaves the original bytes, and that both subsequent writes complete with the expected content. On other platforms it reports the original-reader observation without asserting Windows behavior (`WindowsContractMatched: null`), and still checks completed compatible/released writes and cleanup. The Unix/macOS implementation can differ. A local macOS success is not evidence of Wine behavior or the cause of Run4174's timeout.
@@ -14,6 +14,9 @@ TIMER_FIFO="/tmp/native-diagnostic-$PROOF_TOKEN-$$.fifo"
 PENDING_OUTPUTS=()
 ACTIVE_COMMAND=""
 ACTIVE_TIMER=""
+# BEGIN disk IPC diagnostic
+ACTIVE_OBSERVER=""
+# END disk IPC diagnostic
 os_version=""
 architecture=""
 uid=-1
@@ -96,8 +99,92 @@ 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"
+}
+
+# END successful sw_vers version parser
+# 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.
+observe_disk_query() {
+  local disk_process="$1" output="$2" observation_child="" observation_timer=""
+  cancel_observation() {
+    trap '' TERM INT
+    if [ -n "$observation_child" ]; then
+      kill -TERM "$observation_child" 2>/dev/null || :
+      IFS= read -r -t 2 -u 9 unused || :
+      kill -KILL "$observation_child" 2>/dev/null || :
+      wait "$observation_child" 2>/dev/null || :
+    fi
+    [ -z "$observation_timer" ] || { kill -TERM "$observation_timer" 2>/dev/null || :; wait "$observation_timer" 2>/dev/null || :; }
+    printf '[disk-observation] stopped after the owned disk query\n' >> "$output"
+    exit 143
+  }
+  observe_command() {
+    local name="$1" status started=$SECONDS
+    shift
+    printf '\n[disk-observation-command] %s:' "$name" >> "$output"
+    printf ' %s' "$@" >> "$output"
+    printf '\n' >> "$output"
+    "$@" >> "$output" 2>&1 &
+    observation_child=$!
+    (
+      trap 'exit 0' TERM INT
+      IFS= read -r -t 60 -u 9 unused || :
+      printf '[disk-observation-timeout] %s child=%s limit=60s\n' "$name" "$observation_child" >> "$output"
+      kill -TERM "$observation_child" 2>/dev/null || :
+      IFS= read -r -t 2 -u 9 unused || :
+      kill -KILL "$observation_child" 2>/dev/null || :
+    ) &
+    observation_timer=$!
+    wait "$observation_child"; status=$?
+    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_child=""; observation_timer=""
+  }
+  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
+  else
+    printf '[disk-observation-unavailable] /bin/ps is unavailable\n' >> "$output"
+  fi
+}
+
+stop_disk_observation() {
+  [ -n "$ACTIVE_OBSERVER" ] || return 0
+  kill -TERM "$ACTIVE_OBSERVER" 2>/dev/null || :
+  wait "$ACTIVE_OBSERVER" 2>/dev/null || :
+  ACTIVE_OBSERVER=""
+}
+
+# END disk IPC diagnostic
 cancel_probe() {
  trap '' TERM INT
+# BEGIN disk IPC diagnostic
+  stop_disk_observation
+# END disk IPC diagnostic
  if [ -n "$ACTIVE_COMMAND" ]; then
    kill -TERM "$ACTIVE_COMMAND" 2>/dev/null || :
    IFS= read -r -t 2 -u 9 unused || :
@@ -116,6 +203,9 @@ run_command() {
  # Run 4161: even native uname/ps startup took 34-42s under TCG.
  # 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
+# END disk IPC diagnostic
  LAST_OUTPUT="/tmp/native-diagnostic-$name.out"
  printf '\n[proof-command] %s:' "$name" >&3
  printf ' %s' "$@" >&3
@@ -136,6 +226,16 @@ run_command() {
  ) &
  timer=$!
  ACTIVE_TIMER="$timer"
+# BEGIN disk IPC diagnostic
+  if [[ "$name" == disks && "$attempt" == 1 ]]; then
+    local observation_output="/tmp/native-diagnostic-disk-observation.out"
+    : > "$observation_output"
+    observe_disk_query "$process" "$observation_output" &
+    ACTIVE_OBSERVER=$!
+    printf '[disk-observation-start] observer=%s owned-diskutil-child=%s\n' "$ACTIVE_OBSERVER" "$process" >&3
+    PENDING_OUTPUTS+=("$observation_output")
+  fi
+# END disk IPC diagnostic
  wait "$process"
  exit_code=$?
  waited=$SECONDS
@@ -143,6 +243,9 @@ run_command() {
  printf '[proof-native-wait] %s child=%s elapsed=%ss exit=%s\n' "$name" "$process" "$((waited - started))" "$exit_code" >&3
  kill -TERM "$timer" 2>/dev/null || :
  wait "$timer" 2>/dev/null || :
+# BEGIN disk IPC diagnostic
+  stop_disk_observation
+# END disk IPC diagnostic
  ACTIVE_COMMAND=""; ACTIVE_TIMER=""
  printf '[proof-cleanup] %s child=%s elapsed=%ss total=%ss\n' "$name" "$process" "$((SECONDS - waited))" "$((SECONDS - started))" >&3
  printf '[proof-exit] %s\n' "$exit_code" >&3
@@ -195,18 +298,25 @@ if (( platform_exit != 0 )); then
  platform_exit="$LAST_EXIT"
 fi
 (( platform_exit == 0 )) || fail_probe sw_vers_failed
-run_command version /usr/bin/sw_vers -productVersion
-(( LAST_EXIT == 0 )) || fail_probe product_version_failed
-read_scalar || fail_probe product_version_invalid
+# BEGIN successful sw_vers version extraction
+read_product_version || fail_probe product_version_invalid
+# END successful sw_vers version extraction
 os_version="$SCALAR"
 [[ "$os_version" =~ ^[0-9]+\.[0-9]+(\.[0-9]+)?$ ]] || fail_probe product_version_invalid
-(( ${os_version%%.*} >= 13 )) || fail_probe unsupported_macos_version
+(( ${os_version%%.*} >= 14 )) || fail_probe unsupported_macos_version
 flush_outputs || finish false diagnostic_log_budget_exceeded

+# BEGIN disk IPC diagnostic
+run_command arbitration_before /bin/launchctl print system/com.apple.diskarbitrationd
+run_command management_before /bin/launchctl print system/com.apple.diskmanagementd
+run_command media_before /usr/sbin/ioreg -r -c IOMedia -l -w 0
+flush_outputs || finish false diagnostic_log_budget_exceeded
+
+# END disk IPC diagnostic
 # Bound readiness independently of the host's 40-minute overall deadline.
 readiness_start=$SECONDS
 attempt=0
-while (( SECONDS - readiness_start < 600 )); do
+while (( attempt < 1 && SECONDS - readiness_start < 600 )); do
  attempt=$((attempt + 1))
  printf '\n[readiness-attempt] %s\n' "$attempt" >&3
  run_command disks /usr/sbin/diskutil list physical
@@ -0,0 +1,79 @@
+; Bare 64-KiB BIOS for the existing Linux QEMU binary, not macOS firmware.
+; Assemble: nasm -f bin -o ci-cpu-preflight.bin macos-tcg-cpu-preflight.asm
+; No disks/network. isa-debug-exit returns 33 only after AVX + AVX2 execute
+; and the upper 128-bit lane contains the expected arithmetic result.
+; Unsupported instructions/triple faults cannot produce the success code.
+BITS 16
+ORG 0
+start:
+    cli
+    cld
+    xor ax, ax
+    mov ds, ax
+    mov es, ax
+    mov ss, ax
+    mov sp, 0x8000
+
+    ; QEMU zeroes fresh RAM. Identity-map the first 2 MiB through three tables.
+    mov dword [0x1000], 0x2003
+    mov dword [0x2000], 0x3003
+    mov dword [0x3000], 0x0083
+    lgdt [cs:gdt_descriptor]
+    mov eax, 0x40620             ; PAE, OSFXSR, OSXMMEXCPT, OSXSAVE
+    mov cr4, eax
+    mov eax, 0x1000
+    mov cr3, eax
+    mov ecx, 0xc0000080          ; EFER.LME
+    rdmsr
+    or eax, 0x100
+    wrmsr
+    mov eax, cr0
+    and eax, ~0x0c              ; clear EM and TS before vector instructions
+    or eax, 0x80000003          ; paging, protected mode, monitor coprocessor
+    mov cr0, eax
+    jmp dword 0x08:(0xf0000 + long_mode)
+
+ALIGN 8
+gdt:
+    dq 0
+    dq 0x00af9a000000ffff       ; ring-0 long-mode code, base 0
+    dq 0x00cf92000000ffff       ; ring-0 data, base 0
+gdt_descriptor:
+    dw gdt_descriptor - gdt - 1
+    dd 0xf0000 + gdt
+
+BITS 64
+long_mode:
+    mov ax, 0x10
+    mov ds, ax
+    mov es, ax
+    mov ss, ax
+    mov rsp, 0x8000
+    xor ecx, ecx
+    mov eax, 7                  ; XCR0 enables x87, SSE and AVX state
+    xor edx, edx
+    xsetbv
+    vxorps ymm0, ymm0, ymm0     ; AVX, including the upper YMM lane
+    vpcmpeqd ymm1, ymm1, ymm1   ; AVX2: all eight int32 lanes become -1
+    vpsrld ymm1, ymm1, 31       ; AVX2: all lanes become 1
+    vpaddd ymm2, ymm1, ymm1     ; AVX2: all lanes become 2
+    vextracti128 xmm3, ymm2, 1  ; AVX2: inspect the upper half, not only SSE
+    vmovd eax, xmm3
+    cmp eax, 2
+    jne fail
+    vzeroupper
+    mov eax, 0x10              ; QEMU debugexit computes (value << 1) | 1
+    jmp exit_qemu
+fail:
+    mov eax, 0x11
+exit_qemu:
+    mov dx, 0xf4
+    out dx, eax
+    hlt
+    jmp $
+
+; CPU reset starts at the last 16 bytes; reload the real-mode CS base.
+BITS 16
+TIMES 0xfff0 - ($ - $$) db 0xff
+    jmp 0xf000:start
+TIMES 0x10000 - ($ - $$) db 0xff
Author	SHA1	Message	Date
dh	c01ae13185	ci: qualify supported macOS emulation before Recovery download	2026-10-04 10:30:23 +02:00
dh	720a43158c	reuse verified native platform version without duplicate query	2026-10-04 09:41:25 +02:00
dh	227884723a	retain bounded disk stack and resource pressure evidence	2026-10-04 09:14:39 +02:00
dh	25989cf0eb	diagnose native Recovery disk IPC with bounded observation	2026-10-04 08:41:06 +02:00