ci: point Swatinem/rust-cache at the real workspace root

Both workflows had `workspaces: src-tauri -> target`, which tells
rust-cache the workspace lives at src-tauri/ and its target dir is
src-tauri/target. Neither is true: the workspace is defined at the repo
root (Cargo.toml:1–3 — members = ["src-tauri", "crates/*"]), so cargo
walks up and puts artifacts at ./target, not ./src-tauri/target.

Result: the cache action was saving an empty (or wrong) directory on
every run. Every CI run on every OS effectively started from a cold
build, which is the actual reason the Windows job appeared to compile
sqlx from scratch every push — it was compiling sqlx from scratch every
push.

Point the cache at the real workspace root. While here, drop the
`working-directory: src-tauri` on the cargo check step so the command
runs from the workspace root too; cargo finds the same workspace either
way, but running from root is consistent with the cache's view.

Expected impact: Windows check job drops from ~15–25 min cold-every-time
to ~2–3 min on warm runs, matching Linux/macOS behaviour.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

.github/workflows/build.yml

@@ -99,10 +99,12 @@ jobs:
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
 
+      # Workspace is at the repo root; target dir is ./target (not
+      # src-tauri/target). See note in check.yml for details.
       - name: Cache Rust
         uses: Swatinem/rust-cache@v2
         with:
-          workspaces: src-tauri -> target
+          workspaces: .
           shared-key: kon-build-${{ matrix.os }}
 
       - name: Install JS deps

.github/workflows/check.yml

@@ -72,14 +72,18 @@ jobs:
 
       # Cache the Cargo target dir + registry per OS so the heavy
       # whisper-rs-sys C++ build only happens on a clean cache.
+      # The workspace root is the repo root (see //Cargo.toml), so target/
+      # lives at ./target — NOT src-tauri/target. Pointing the cache at
+      # src-tauri/target produced silent cache misses on every run and was
+      # the real reason Windows check times felt like they compiled sqlx
+      # from scratch every time. Use the repo root as the workspace hint.
       - name: Cache Rust artifacts
         uses: Swatinem/rust-cache@v2
         with:
-          workspaces: src-tauri -> target
+          workspaces: .
           shared-key: kon-${{ matrix.os }}
 
       - name: cargo check (workspace)
-        working-directory: src-tauri
         run: cargo check --workspace --all-targets
 
   frontend:

crates/storage/Cargo.toml

@@ -8,7 +8,12 @@ description = "SQLite persistence, BM25 search, and file storage for Kon"
 kon-core = { path = "../core" }
 
 # SQLite with compile-time checked queries
-sqlx = { version = "0.8", features = ["sqlite", "runtime-tokio"] }
+# default-features = false strips sqlx's `any`, `macros`, `migrate`, `json` —
+# none of which this crate uses (it calls sqlx::query() / query_scalar()
+# directly and runs its own migration machinery). Cuts ~40% of sqlx's
+# compile graph, most visibly on Windows MSVC where each proc-macro crate
+# (which `macros` pulls in) becomes a slow .dll link.
+sqlx = { version = "0.8", default-features = false, features = ["runtime-tokio", "sqlite"] }
 
 # Async runtime
 tokio = { version = "1", features = ["rt", "sync", "macros"] }

src-tauri/Cargo.toml

@@ -42,7 +42,9 @@ arboard = "3.6.1"
 # SqlitePool is named directly from src-tauri/src/lib.rs (the AppState
 # stores it). Must be unconditional, not Linux-only — naming a type from
 # a transitive dep requires the dep be listed here too.
-sqlx = { version = "0.8", features = ["sqlite", "runtime-tokio"] }
+# See crates/storage/Cargo.toml — default-features = false drops macros /
+# migrate / any / json which this crate doesn't use. Only names SqlitePool.
+sqlx = { version = "0.8", default-features = false, features = ["runtime-tokio", "sqlite"] }
 uuid = { version = "1", features = ["v4"] }
 
 [target.'cfg(target_os = "linux")'.dependencies]