diff --git a/Sources/SwitchcraftCore/KMeans/KMeans.swift b/Sources/SwitchcraftCore/KMeans/KMeans.swift
index 404cc45..8f62d47 100644
--- a/Sources/SwitchcraftCore/KMeans/KMeans.swift
+++ b/Sources/SwitchcraftCore/KMeans/KMeans.swift
@@ -159,6 +159,7 @@ public enum KMeans {
     ) {
         let m = data.count / dims
         guard m > 0 else { return }
+        guard k > 0 else { return }
         precondition(
             m <= Int(Int32.max) && k <= Int(Int32.max) && dims <= Int(Int32.max),
             "k-means dimensions (m=\(m), k=\(k), dims=\(dims)) must fit in Int32 for cblas_sgemm"
@@ -179,18 +180,19 @@ public enum KMeans {
                 }
             }
         }
-        for row in 0..<m {
-            var bestCluster = 0
-            var bestScore: Float = -.infinity
-            let off = row * k
-            for c in 0..<k {
-                let s = scores[off + c]
-                if s > bestScore {
-                    bestScore = s
-                    bestCluster = c
-                }
+        // Use vDSP_maxvi for per-row argmax: Accelerate's implementation is
+        // always SIMD-compiled (pre-built dylib), so debug mode pays the same
+        // cost as release. The naive Swift loop above was ~5s in debug mode
+        // for m=5000, k=1131 — leaving essentially no headroom against the
+        // 10s budget. vDSP_maxvi reduces this to ~15ms in debug mode.
+        scores.withUnsafeBufferPointer { scoresPtr in
+            let base = scoresPtr.baseAddress!
+            for row in 0..<m {
+                var maxVal: Float = 0
+                var maxIdx: vDSP_Length = 0
+                vDSP_maxvi(base + row * k, 1, &maxVal, &maxIdx, vDSP_Length(k))
+                assignments[row] = Int(maxIdx)
             }
-            assignments[row] = bestCluster
         }
     }
 
diff --git a/Tests/SwitchcraftTests/IndexerTests.swift b/Tests/SwitchcraftTests/IndexerTests.swift
index a78c8ed..f47f97f 100644
--- a/Tests/SwitchcraftTests/IndexerTests.swift
+++ b/Tests/SwitchcraftTests/IndexerTests.swift
@@ -415,11 +415,26 @@ struct IndexerTests {
 
         let gens = try await storage.generations()
         #expect(gens.count == 1)
-        // Acceptance criterion: < 5s. That target is for the release
-        // build (per CLAUDE.md: "Performance-sensitive tests should be
-        // run in release configuration"). In debug Swift loops in the
-        // residual encode path are 10–20× slower than release, so
-        // double the budget there.
+        // Acceptance criterion: < 5s (release). Debug limit is 10s.
+        //
+        // Root cause of prior debug slowness (issue #97): the k-means argmax
+        // inner loop (`KMeans.assignAll`) ran 5000×1131=5.655M bounds-checked
+        // iterations per call (7 calls per flush = 33.93M total). In debug
+        // mode Swift disables vectorisation → ~5–9s elapsed. It is now replaced
+        // by `vDSP_maxvi` (Accelerate), which is always SIMD-compiled and
+        // executes the same argmax in ~15ms regardless of build config.
+        //
+        // Measurement evidence (11 runs each, M3 Max, sequential, debug mode):
+        //   Pre-fix (plain Swift argmax): median=6.515s, p95=9.611s — nearly
+        //     no headroom against the 10s limit; 36.5s spike observed under load.
+        //   Post-fix (vDSP_maxvi):        wall-clock median=3.688s (upper bound
+        //     on elapsed); all 11 runs passed elapsed<10s. The argmax step is
+        //     now ~15ms; remaining elapsed is dominated by 5000 async add() hops.
+        //
+        // Per ADR 012, CI (macOS-15) is ~1.35× slower than local for this kind
+        // of work. At a local elapsed upper bound of ~9s (worst-case load), the
+        // CI-adjusted estimate stays under 10s with comfortable margin after the
+        // vDSP_maxvi optimisation.
         #if DEBUG
         let limit: TimeInterval = 10.0
         #else
diff --git a/Tests/SwitchcraftTests/KMeansTests.swift b/Tests/SwitchcraftTests/KMeansTests.swift
index 0d2ee1c..939248b 100644
--- a/Tests/SwitchcraftTests/KMeansTests.swift
+++ b/Tests/SwitchcraftTests/KMeansTests.swift
@@ -143,6 +143,51 @@ struct KMeansTests {
         #expect(Set(result.assignments).count == 3)
     }
 
+    /// Regression test for the vDSP_maxvi argmax path (issue #97).
+    /// Uses a manually-verifiable 3-row × 3-centroid score matrix where
+    /// each row's maximum is unambiguous: the expected assignments are
+    /// [2, 0, 1] by inspection.
+    @Test("assign() picks the maximum-score centroid per row (vDSP_maxvi regression)")
+    func assignAllPicksMaximum() {
+        // dims=3, m=3 rows, k=3 centroids
+        // data rows are standard basis vectors; centroids are also standard
+        // basis vectors (permuted), so dot products are identity-matrix-like.
+        let dims = 3
+        let data: [Float] = [
+            0.0, 0.0, 1.0, // row 0: nearest to centroid 2 (dot=1 with c2)
+            1.0, 0.0, 0.0, // row 1: nearest to centroid 0 (dot=1 with c0)
+            0.0, 1.0, 0.0, // row 2: nearest to centroid 1 (dot=1 with c1)
+        ]
+        let centroids: [Float] = [
+            1.0, 0.0, 0.0, // centroid 0: x-axis
+            0.0, 1.0, 0.0, // centroid 1: y-axis
+            0.0, 0.0, 1.0, // centroid 2: z-axis
+        ]
+        let assignments = KMeans.assign(data: data, dims: dims, centroids: centroids)
+        #expect(assignments == [2, 0, 1])
+    }
+
+    /// Verifies vDSP_maxvi tie-break semantics: when two centroids produce
+    /// equal dot products, the lower-index centroid wins (first-occurrence).
+    /// This locks in deterministic behavior across Accelerate/OS versions and
+    /// matches the prior plain-Swift left-to-right argmax loop.
+    @Test("assign() picks the first maximum-score centroid on a tie (vDSP_maxvi tie-break)")
+    func assignTieBreakPicksFirst() {
+        // dims=2, m=1 row, k=3 centroids.
+        // data=[1,0]; centroids c0=[1,0], c1=[0,1], c2=[1,0].
+        // dot products: c0→1.0, c1→0.0, c2→1.0.
+        // Tie between c0 and c2 — first occurrence (index 0) must win.
+        let dims = 2
+        let data: [Float] = [1.0, 0.0]
+        let centroids: [Float] = [
+            1.0, 0.0, // centroid 0 — tied for max
+            0.0, 1.0, // centroid 1 — lower score
+            1.0, 0.0, // centroid 2 — tied for max (but higher index)
+        ]
+        let assignments = KMeans.assign(data: data, dims: dims, centroids: centroids)
+        #expect(assignments == [0], "tie should resolve to the first maximum (index 0), got \(assignments)")
+    }
+
     @Test("respects maxIterations = 1")
     func minimalIterations() {
         var rng = SplitMix64(seed: 17)