YC (S26) | Open Computer History | Continuously record your company computer work, map your workflows, help you find work worth automating, and power your agents' context
Rust agentsagiaiai-memoryaudio-recordingcomputer-visionhermeshermes-agentllmlocal-ailocal-firstmachine-learningmcpmultimodalopenclawprivacyrewindscreen-recordingspeech-to-textycombinator
ci(windows): move SDE probes to windows-latest job, add ONNX-init + app-binary probes
Louis Beaumont9305f6d453dd
diff --git a/.github/ci/ort-smoke/src/main.rs b/.github/ci/ort-smoke/src/main.rsindex 34f51a5c6..0d61d6f06 100644--- a/.github/ci/ort-smoke/src/main.rs+++ b/.github/ci/ort-smoke/src/main.rs@@ -9,8 +9,10 @@//! deadlocks at 0% CPU on some platforms — Windows x86_64 (#4173) and, by the//! same code path, Windows ARM64 (#4176). A build that merely *compiles* does//! not catch this; the hang is at runtime. This runs the real init path on a-//! worker thread under a 60s deadline and exits with a distinct code so CI can-//! tell a hang apart from a missing-runtime setup error:+//! worker thread under a deadline (60s default; ORT_SMOKE_DEADLINE_SECS+//! overrides — Intel SDE emulation needs a longer budget) and exits with a+//! distinct code so CI can tell a hang apart from a missing-runtime setup+//! error://!//! 0 — ONNX Runtime initialized (good)//! 1 — HANG: init did not return within 60s (the regression)@@ -21,8 +23,18 @@ use std::sync::mpsc;use std::time::{Duration, Instant};fn main() {+ // Default 60s. ORT_SMOKE_DEADLINE_SECS overrides: the non-AVX2 probe in+ // release-cli.yml runs this under Intel SDE emulation (~50x slower than+ // native), where a fixed 60s would misreport slow-but-healthy init as a+ // hang.+ let deadline_secs = std::env::var("ORT_SMOKE_DEADLINE_SECS")+ .ok()+ .and_then(|v| v.parse::<u64>().ok())+ .unwrap_or(60);let t = Instant::now();- eprintln!("ort-smoke: building Session (load onnxruntime + create global env)...");+ eprintln!(+ "ort-smoke: building Session (load onnxruntime + create global env, {deadline_secs}s deadline)..."+ );let (tx, rx) = mpsc::channel();std::thread::spawn(move || {@@ -32,7 +44,7 @@ fn main() {let _ = tx.send(r);});- match rx.recv_timeout(Duration::from_secs(60)) {+ match rx.recv_timeout(Duration::from_secs(deadline_secs)) {Ok(Ok(())) => {eprintln!("OK: ONNX Runtime initialized in {:?}", t.elapsed());std::process::exit(0);@@ -43,7 +55,7 @@ fn main() {std::process::exit(3);}Err(mpsc::RecvTimeoutError::Timeout) => {- eprintln!("HANG: ONNX Runtime init did not return within 60s.");+ eprintln!("HANG: ONNX Runtime init did not return within {deadline_secs}s.");eprintln!("This is the ort load-dynamic regression (see #4173 / #4176).");std::process::exit(1);}diff --git a/.github/workflows/release-app.yml b/.github/workflows/release-app.ymlindex 2ad41f6b7..a9b3dfb27 100644--- a/.github/workflows/release-app.yml+++ b/.github/workflows/release-app.yml@@ -993,6 +993,42 @@ jobs:# ort-sys chokes on them.run: bunx tauri build --verbose ${{ matrix.tauri-args }}+ # The app exe now import-table-links the MS onnxruntime.dll — a+ # missing/incompatible DLL or an AVX2-poisoned static initializer kills+ # the process before main() with no UI and nothing in Sentry (#3125).+ # --cpu-smoke (hidden flag in main.rs) exits 0 right after static init+ # + CPU detection, so this catches that whole class natively. The+ # staged ORT lib dir is already on PATH (Download ONNX Runtime step).+ # Non-AVX2 (Intel SDE) coverage lives in release-cli.yml's+ # smoke-windows job — same workspace crates, same flags; SDE's Pin+ # injector is broken on windows-2022 anyway (pincrt4.dll, run+ # 30653241813). x64 only: the arm64 exe is cross-compiled and cannot+ # run on this x64 runner.+ - name: App launch sanity probe (static init + import table)+ if: matrix.os_type == 'windows' && matrix.target == 'x86_64-pc-windows-msvc'+ shell: pwsh+ timeout-minutes: 5+ run: |+ $targetDir = "apps/screenpipe-app-tauri/src-tauri/target/${{ matrix.target }}/release"+ # tauri v2 renames the built binary to the bundle's mainBinaryName;+ # accept either name so config drift can't silently skip the probe.+ $exe = Get-ChildItem $targetDir -Filter "screenpipe*.exe" |+ Where-Object { $_.Name -in @('screenpipe-app.exe', 'screenpipe.exe', 'screenpipe - Development.exe') } |+ Select-Object -First 1+ if (-not $exe) { throw "app exe not found in $targetDir" }+ Write-Host "=== native — $($exe.Name) --cpu-smoke ==="+ # GUI-subsystem binary: `&` would return immediately without the+ # exit code — Start-Process + .ExitCode is the reliable path. The+ # 4-min wait is belt-and-braces; healthy runs exit in <1s.+ $p = Start-Process -FilePath $exe.FullName -ArgumentList '--cpu-smoke' `+ -NoNewWindow -PassThru -RedirectStandardError cpu-smoke-err.txt+ if (-not $p.WaitForExit(240000)) {+ taskkill /PID $($p.Id) /T /F | Out-Null+ throw "app exe hung on --cpu-smoke (should exit in <1s) — static init or early main is wedged"+ }+ Get-Content cpu-smoke-err.txt -ErrorAction SilentlyContinue+ if ($p.ExitCode -ne 0) { throw "app exe failed --cpu-smoke (exit $($p.ExitCode)) — static init or a load-time DLL import is broken; customers would see a silent launch failure" }+- name: Sign NSIS installer with SSL.com EV (Windows)# Tauri's signCommand handles inner binaries, but the final NSIS# installer is built AFTER signCommand runs - so we sign it herediff --git a/.github/workflows/release-cli.yml b/.github/workflows/release-cli.ymlindex f1e5849ad..f9844204e 100644--- a/.github/workflows/release-cli.yml+++ b/.github/workflows/release-cli.yml@@ -533,94 +533,175 @@ jobs:}7z a "$packageDir.zip" "./$packageDir/*"- - name: Launch smoke test (native CPU + emulated non-AVX2 via Intel SDE)+ # Cheap in-place sanity probe: a native --version from the package dir+ # exercises CRT startup, the import table (onnxruntime.dll →+ # MSVCP/VCRUNTIME), and every static initializer with the exact DLL set+ # customers get. A failure HERE means the package is broken for ALL+ # CPUs (e.g. a DLL missing from the zip) — fail in the build job where+ # the context is. The non-AVX2 (Intel SDE) probes live in the separate+ # smoke-windows job: SDE's Pin injector is broken on windows-2022+ # runners (pincrt4.dll, runs 28806190901 + 30653241813) so they need a+ # windows-latest runner, which downloads this job's artifacts.+ - name: Native launch sanity probeshell: pwsh- # Belt-and-braces against emulator wedges (run 28808593583 sat 80+ min):- # the whole step is bounded even if a phase outside the PS timeout hangs.- timeout-minutes: 20- run: |- # A --version probe exercises process init end-to-end: CRT startup,- # the import table (onnxruntime.dll → MSVCP/VCRUNTIME), and every- # static initializer. Run from the deployment package dir so DLL- # resolution matches exactly what customers get.- #- # Native first: the runner's own modern (AVX2) CPU is what ~99.9% of- # users run — a native failure means the package is broken for- # EVERYONE (e.g. a DLL missing from the zip), independent of any- # AVX2 work. Ordering it first makes failures unambiguous:- # native fails = broken for all; native passes but SDE fails =- # AVX2/baseline regression specifically.+ timeout-minutes: 5+ run: |$packageDir = "screenpipe-${{ env.VERSION }}-x86_64-pc-windows-msvc"$exe = (Resolve-Path "$packageDir/bin/screenpipe.exe").PathWrite-Host "=== native (runner CPU) — screenpipe.exe --version ==="& $exe --versionif ($LASTEXITCODE -ne 0) { throw "screenpipe.exe failed natively (exit $LASTEXITCODE) — the package is broken for ALL CPUs" }- # Intel SDE emulates older CPUs and raises the same illegal-instruction- # fault a real pre-AVX2 chip would. -snb = Sandy Bridge (AVX, no AVX2)- # — exactly the pre-Haswell class from the 2026-07 customer report.- # Guards against regressions of the 0xc000001d launch crash: global- # /arch:AVX2 CFLAGS, AVX2 static onnxruntime, eager ggml init, etc.- # CI runners have AVX2, so without SDE a poisoned build sails through- # CI and dies on customer machines.- #- # Probe design notes (original run validated 2026-07-06 on a real- # Windows machine against this exact build config — ~2s when healthy):- # - SDE 10.8.0 (2026-03-15 kit): Intel removed the 9.44.0 mirror- # (403 as of 2026-07-31, run 30651369680). This is the kit- # google/XNNPACK runs in CI; the 2026-03-15 build's negative- # control was re-verified locally on Windows 11 (stock AVX2- # bun.exe faults instantly under -snb: "vinserti128 ... not valid- # for SANDYBRIDGE"). An earlier 10.8 kit had a broken Pin- # injector on windows-2022 ("Invalid file name and base dir- # combination: pincrt4.dll", run 28806190901) — if that- # resurfaces here, the 8-min hard timeout below fails loud, and- # the fix is a newer kit, not a hang.- # - 7z two-step extraction: the one method proven to work on the- # runner (run 28806190901); a tar -xf variant wedged for 60+ min- # without ever reaching the SDE invocation (run 28808593583).- # - -snb ONLY. Pre-AVX chips (-nhm/-mrm) are a false-negative trap:- # modern hosts' own system DLLs (e.g. Win11 msvcrt.dll strncpy)- # execute AVX, so emulating a pre-AVX chip faults in the OS, not- # in our code. Real pre-AVX machines run OS builds with matching- # DLLs; our no-AVX floor is covered by baseline codegen + the- # runtime AVX2 gates.- # - Hard timeout per invocation + step timeout-minutes: a wedged- # emulator must fail fast and loud, never eat runner-hours.- # If Intel rotates the mirror again, grab a fresh URL from- # https://www.intel.com/content/www/us/en/developer/articles/tool/software-development-emulator.html- # (google/XNNPACK's sde-tests workflow env is another quick source).- $sdeUrl = 'https://downloadmirror.intel.com/915934/sde-external-10.8.0-2026-03-15-win.tar.xz'+ # The launch probe proves process init but never touches ONNX Runtime+ # (ort sessions are created on the audio boot path, not at startup).+ # Build the standalone ort-smoke probe (.github/ci/ort-smoke) against+ # the SAME staged MS DirectML lib this job links (ORT_STRATEGY /+ # ORT_LIB_LOCATION / ORT_PREFER_DYNAMIC_LINK are already in the job env+ # from the "Download ONNX Runtime" step), run it natively here, and+ # ship it to the smoke-windows job for the emulated non-AVX2 run.+ - name: Build + run ort-smoke natively; stage for the SDE job+ shell: pwsh+ timeout-minutes: 15+ run: |+ Write-Host "=== building ort-smoke probe against the packaged onnxruntime.dll ==="+ cargo build --manifest-path .github/ci/ort-smoke/Cargo.toml+ New-Item -ItemType Directory -Force -Path smoke-probes | Out-Null+ Copy-Item ".github/ci/ort-smoke/target/debug/ort-smoke.exe" smoke-probes/+ # exe-adjacent DLLs win Windows search order — stage exactly what+ # the package ships so the probe runs the shipped bits.+ Copy-Item "$env:ORT_LIB_LOCATION/onnxruntime.dll" smoke-probes/+ Copy-Item "$env:ORT_LIB_LOCATION/DirectML.dll" smoke-probes/+ Write-Host "=== native — ort-smoke (DirectML onnxruntime.dll init) ==="+ & "smoke-probes/ort-smoke.exe"+ if ($LASTEXITCODE -ne 0) { throw "ONNX Runtime failed to initialize natively against the shipped DirectML DLL (exit $LASTEXITCODE)" }++ - name: Upload smoke probes for the SDE job+ uses: actions/upload-artifact@v4+ with:+ name: ort-smoke-windows+ path: smoke-probes/++ - name: Calculate SHA256+ shell: pwsh+ run: |+ $hash = Get-FileHash "screenpipe-${{ env.VERSION }}-x86_64-pc-windows-msvc.zip" -Algorithm SHA256+ "WIN_SHA256=$($hash.Hash)" | Out-File -FilePath $env:GITHUB_ENV -Append++ - name: Upload Artifact+ uses: actions/upload-artifact@v4+ with:+ name: screenpipe-windows+ path: screenpipe-*.zip++ # Non-AVX2 launch + ONNX-init smoke against the exact deployment package,+ # under Intel SDE -snb (Sandy Bridge: AVX but NO AVX2 — the pre-Haswell /+ # Atom-line customer class from #3125). CI runners have AVX2, so without+ # SDE an AVX2-poisoned build sails through CI and dies with 0xC000001D on+ # customer machines — this job is the permanent regression guard, and+ # `release`/`publish-npm` require it.+ #+ # Separate job from build-windows on purpose: SDE's Pin injector is broken+ # on windows-2022 runners ("Invalid file name and base dir combination:+ # pincrt4.dll" — runs 28806190901 and 30653241813, both SDE 10.8 kits).+ # windows-latest (Server 2025) is the image google/XNNPACK runs the same+ # kit + -snb probes on. The build stays on windows-2022 for toolchain+ # stability; this job only downloads and runs its artifacts.+ smoke-windows:+ name: Non-AVX2 smoke (Intel SDE)+ needs: [check_commit, build-windows]+ if: needs.check_commit.outputs.should_release == 'true'+ runs-on: windows-latest+ timeout-minutes: 30+ steps:+ - name: Download Windows package+ uses: actions/download-artifact@v4+ with:+ name: screenpipe-windows++ - name: Download smoke probes+ uses: actions/download-artifact@v4+ with:+ name: ort-smoke-windows+ path: smoke-probes++ - name: Launch + ONNX-init probes (native, then emulated non-AVX2)+ shell: pwsh+ # Probe design notes (validated 2026-07-06 on a real Windows machine;+ # SDE 10.8.0 2026-03-15 kit re-verified locally on Windows 11 with the+ # negative control: stock AVX2 bun.exe faults instantly under -snb —+ # "vinserti128 ... not valid for SANDYBRIDGE"):+ # - 7z two-step extraction: proven on runners (run 28806190901); a+ # tar -xf variant wedged 60+ min (run 28808593583).+ # - -snb ONLY. Pre-AVX chips (-nhm/-mrm) are a false-negative trap:+ # modern hosts' system DLLs execute AVX, so emulating pre-AVX+ # faults in the OS, not our code. The no-AVX floor is covered by+ # baseline codegen + the runtime AVX2 gates.+ # - Hard timeout per invocation + job timeout: a wedged emulator must+ # fail fast and loud, never eat runner-hours.+ # - Intel rotates mirrors (9.44.0's died 2026-07-31, run 30651369680).+ # Fresh URLs: intel.com SDE article, or google/XNNPACK's sde-tests+ # workflow env.+ run: |+ Write-Host "=== extracting deployment package ==="+ $zip = (Get-ChildItem "screenpipe-*-x86_64-pc-windows-msvc.zip" | Select-Object -First 1).FullName+ if (-not $zip) { throw "screenpipe Windows zip not found in artifact" }+ $pkg = "pkg"+ 7z x $zip -o"$pkg" -y | Out-Null+ $exe = (Resolve-Path "$pkg/bin/screenpipe.exe").Path++ # Native first, ON THIS IMAGE TOO: a failure here (after build-windows'+ # own native probe passed) isolates runner-image differences from+ # AVX2 regressions.+ Write-Host "=== native — screenpipe.exe --version ==="+ & $exe --version+ if ($LASTEXITCODE -ne 0) { throw "screenpipe.exe failed natively on windows-latest (exit $LASTEXITCODE)" }+ Write-Host "=== native — ort-smoke (DirectML onnxruntime.dll init) ==="+ & "smoke-probes/ort-smoke.exe"+ if ($LASTEXITCODE -ne 0) { throw "ort-smoke failed natively on windows-latest (exit $LASTEXITCODE)" }+Write-Host "=== downloading SDE ==="+ $sdeUrl = 'https://downloadmirror.intel.com/915934/sde-external-10.8.0-2026-03-15-win.tar.xz'curl.exe -fSL -o sde.tar.xz $sdeUrl+ if ($LASTEXITCODE -ne 0) { throw "SDE download failed ($LASTEXITCODE) — Intel rotated the mirror again? See the step comment for fresh-URL sources" }Write-Host "=== extracting SDE (7z two-step) ==="7z x sde.tar.xz -y | Out-Null7z x sde.tar -y | Out-Null$sde = (Get-ChildItem "sde-external-*" -Recurse -Filter sde.exe | Select-Object -First 1).FullNameif (-not $sde) { throw "sde.exe not found after extraction" }- Write-Host "=== SDE -snb — screenpipe.exe --version (8 min timeout; ~2s when healthy) ==="++ # Probe 1: the packaged CLI launches without AVX2 — catches the+ # 0xC000001D static-init crash class (global /arch:AVX2 CFLAGS,+ # AVX2 static onnxruntime, eager ggml init...).+ Write-Host "=== SDE -snb — screenpipe.exe --version (8 min timeout; ~2s native) ==="$p = Start-Process -FilePath $sde -ArgumentList @('-snb','--',$exe,'--version') `-NoNewWindow -PassThru -RedirectStandardOutput sde-out.txt -RedirectStandardError sde-err.txtif (-not $p.WaitForExit(480000)) {taskkill /PID $($p.Id) /T /F | Out-NullGet-Content sde-out.txt, sde-err.txt -ErrorAction SilentlyContinue- throw "SDE -snb probe timed out after 8 minutes (locally it takes ~2s) — emulator wedged on the runner or a startup-path hang on non-AVX2 CPUs"+ throw "SDE -snb launch probe timed out after 8 minutes — emulator wedged or a startup-path hang on non-AVX2 CPUs"}Get-Content sde-out.txt, sde-err.txt -ErrorAction SilentlyContinueif ($p.ExitCode -ne 0) { throw "screenpipe.exe faulted under SDE -snb (exit $($p.ExitCode)) — a non-AVX2 CPU cannot launch this build" }- Write-Host "=== SDE -snb probe passed: the package launches without AVX2 ==="-- - name: Calculate SHA256- shell: pwsh- run: |- $hash = Get-FileHash "screenpipe-${{ env.VERSION }}-x86_64-pc-windows-msvc.zip" -Algorithm SHA256- "WIN_SHA256=$($hash.Hash)" | Out-File -FilePath $env:GITHUB_ENV -Append-- - name: Upload Artifact- uses: actions/upload-artifact@v4- with:- name: screenpipe-windows- path: screenpipe-*.zip+ Write-Host "=== SDE -snb launch probe passed ==="++ # Probe 2: ONNX Runtime (the shipped MS DirectML DLL) actually+ # INITIALIZES without AVX2 — MLAS runtime CPUID dispatch must pick+ # baseline kernels. --version never creates ort sessions (they're+ # created on the audio boot path), so this is the probe that+ # directly covers the pyke-AVX2-static-lib crash class for+ # VAD/diarization/PII.+ Write-Host "=== SDE -snb — ort-smoke (8 min timeout; probe deadline 420s) ==="+ $env:ORT_SMOKE_DEADLINE_SECS = "420"+ $p2 = Start-Process -FilePath $sde -ArgumentList @('-snb','--',(Resolve-Path "smoke-probes/ort-smoke.exe").Path) `+ -NoNewWindow -PassThru -RedirectStandardOutput ort-sde-out.txt -RedirectStandardError ort-sde-err.txt+ if (-not $p2.WaitForExit(480000)) {+ taskkill /PID $($p2.Id) /T /F | Out-Null+ Get-Content ort-sde-out.txt, ort-sde-err.txt -ErrorAction SilentlyContinue+ throw "ort-smoke timed out under SDE -snb after 8 minutes — emulator wedged or ONNX init hangs on non-AVX2 CPUs"+ }+ Get-Content ort-sde-out.txt, ort-sde-err.txt -ErrorAction SilentlyContinue+ if ($p2.ExitCode -ne 0) { throw "ONNX Runtime failed to initialize under SDE -snb (exit $($p2.ExitCode)) — the shipped DLL cannot init on non-AVX2 CPUs" }+ Write-Host "=== SDE -snb ort probe passed: ONNX Runtime initializes without AVX2 ==="build-linux:needs: check_commit@@ -767,7 +848,9 @@ jobs:publish-npm:runs-on: ubuntu-latest- needs: [build-macos, build-windows, build-linux]+ # smoke-windows: nothing ships unless the package launches + inits ONNX+ # on non-AVX2 CPUs (#3125 regression guard).+ needs: [build-macos, build-windows, build-linux, smoke-windows]steps:- name: Checkout codeuses: actions/checkout@v4@@ -922,7 +1005,9 @@ jobs:release:runs-on: ubuntu-latest- needs: [build-macos, build-windows, build-linux]+ # smoke-windows: nothing ships unless the package launches + inits ONNX+ # on non-AVX2 CPUs (#3125 regression guard).+ needs: [build-macos, build-windows, build-linux, smoke-windows]steps:- name: Checkout codeuses: actions/checkout@v4diff --git a/TESTING.md b/TESTING.mdindex ee109b5bc..3770c7d26 100644--- a/TESTING.md+++ b/TESTING.md@@ -484,7 +484,7 @@ commits: `b3628788`, `738178da`commits: `eea0c865`, `fe9060db`, `c99c3967`, `aeaa446b`, `5a219688`, `caae1ebc`, `67caf1d1`, `ff4af7b5`-- [ ] **non-AVX2 CPU launch (compatibility mode)** — (#3125) On x86-64 CPUs without AVX2 (pre-2013 Intel, Atom-line Celeron/Pentium, QEMU `-cpu qemu64`), the app and CLI must LAUNCH and RECORD instead of dying with `0xC000001D STATUS_ILLEGAL_INSTRUCTION`. Local whisper/qwen3 STT is disabled at runtime (AVX2-compiled kernels); parakeet + cloud engines keep working; onboarding shows a "compatibility mode" notice. Guards: never set global `CFLAGS/CXXFLAGS=/arch:AVX2` in Windows release workflows (it poisons every cc/cmake dep incl. bundled SQLite → crash in static initializers before main); ONNX Runtime must stay on the MS DirectML DLL (import-table link, runtime CPUID dispatch) — pyke's `download-binaries` static libs are AVX2-only. CI: `release-cli.yml` runs the packaged exe under Intel SDE `-snb` (Sandy Bridge, no AVX2) on every Windows CLI build; reproduce locally with `sde -snb -- screenpipe.exe --version`, or QEMU `-cpu qemu64` for the app. Pipes/AI chat on such CPUs use bun's official `windows-x64-baseline` build (runtime-downloaded, mandatory SHA-256).+- [ ] **non-AVX2 CPU launch (compatibility mode)** — (#3125) On x86-64 CPUs without AVX2 (pre-2013 Intel, Atom-line Celeron/Pentium, QEMU `-cpu qemu64`), the app and CLI must LAUNCH and RECORD instead of dying with `0xC000001D STATUS_ILLEGAL_INSTRUCTION`. Local whisper/qwen3 STT is disabled at runtime (AVX2-compiled kernels); parakeet + cloud engines keep working; onboarding shows a "compatibility mode" notice. Guards: never set global `CFLAGS/CXXFLAGS=/arch:AVX2` in Windows release workflows (it poisons every cc/cmake dep incl. bundled SQLite → crash in static initializers before main); ONNX Runtime must stay on the MS DirectML DLL (import-table link, runtime CPUID dispatch) — pyke's `download-binaries` static libs are AVX2-only. CI: `release-cli.yml`'s `smoke-windows` job (runs-on windows-latest — SDE's Pin injector is broken on windows-2022) runs the packaged exe AND an ONNX-init probe (`.github/ci/ort-smoke`, real `Session::builder()` against the shipped DirectML DLL) under Intel SDE `-snb` (Sandy Bridge, no AVX2) on every Windows CLI build, and `release`/`publish-npm` require it; `release-app.yml` probes the app exe natively via the hidden `--cpu-smoke` flag (static init + import table). Reproduce locally with `sde -snb -- screenpipe.exe --version`, or QEMU `-cpu qemu64` for the app. Pipes/AI chat on such CPUs use bun's official `windows-x64-baseline` build (runtime-downloaded, mandatory SHA-256; verified 2026-07-31 to run under `sde -snb` while stock bun faults).- [ ] **COM thread conflict** — audio and vision threads don't conflict on COM initialization (`eea0c865`).- [ ] **high-DPI display (150%, 200%)** — OCR captures at correct resolution.- [ ] **multiple monitors** — all detected and recorded.diff --git a/apps/screenpipe-app-tauri/src-tauri/src/main.rs b/apps/screenpipe-app-tauri/src-tauri/src/main.rsindex fb4da7e8c..4d83ea49c 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/main.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/main.rs@@ -396,6 +396,23 @@ async fn main() {);health::set_cpu_compat_mode(true);}++ // Hidden CI probe: `screenpipe-app.exe --cpu-smoke` exits 0 here,+ // after every static initializer and the CPU detection above have+ // run but before any Tauri/WebView/window work. release-app.yml runs+ // this natively post-build so the GUI binary itself — its static+ // init + import table (onnxruntime.dll → MSVCP/VCRUNTIME) — is+ // proven to reach main() (issue #3125: the old /arch:AVX2 builds+ // died in static init with 0xC000001D before any code here could+ // run). Non-AVX2 (Intel SDE) coverage lives in release-cli.yml's+ // smoke-windows job, which compiles the identical workspace crates+ // under the identical flags. A GUI binary can't be probed with+ // --version: it has no console output path, and booting the full+ // app headless in CI is flaky by design.+ if std::env::args().any(|a| a == "--cpu-smoke") {+ eprintln!("cpu-smoke: static init ok; {}", cpu.as_log_string());+ std::process::exit(0);+ }}// Handle --check-arc-automation / --trigger-arc-automation flags early,