Skip to content

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

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.rs
index 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.yml
index 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 here
diff --git a/.github/workflows/release-cli.yml b/.github/workflows/release-cli.yml
index 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 probe
shell: 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").Path
Write-Host "=== native (runner CPU) — screenpipe.exe --version ==="
& $exe --version
if ($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-Null
7z x sde.tar -y | Out-Null
$sde = (Get-ChildItem "sde-external-*" -Recurse -Filter sde.exe | Select-Object -First 1).FullName
if (-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.txt
if (-not $p.WaitForExit(480000)) {
taskkill /PID $($p.Id) /T /F | Out-Null
Get-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 SilentlyContinue
if ($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 code
uses: 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 code
uses: actions/checkout@v4
diff --git a/TESTING.md b/TESTING.md
index 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.rs
index 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,