diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6fb5bd21..17d142a5 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -76,6 +76,13 @@ jobs:
           echo "total coverage: ${total}%"
           awk -v total="$total" 'BEGIN { if (total + 0 < 85.0) { printf("coverage %.1f%% is below 85.0%%\n", total); exit 1 } }'
 
+      - name: Test portable SIMD and scalar fallback
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        run: |
+          # Release binaries are built with this experiment, so test everything they ship.
+          GOEXPERIMENT=simd go test ./...
+          GOEXPERIMENT=simd GODEBUG=simd=0 go test ./internal/vector ./internal/cli
+
       - name: Build
         run: go build -ldflags "-X github.com/openclaw/gitcrawl/internal/cli.version=${GITHUB_SHA:0:7}" -o bin/gitcrawl ./cmd/gitcrawl
 
diff --git a/.goreleaser.yaml b/.goreleaser.yaml
index 676f374e..c4ed3986 100644
--- a/.goreleaser.yaml
+++ b/.goreleaser.yaml
@@ -11,6 +11,7 @@ builds:
     binary: gitcrawl
     env:
       - CGO_ENABLED=0
+      - GOEXPERIMENT=simd
     ldflags:
       - -s -w -X github.com/openclaw/gitcrawl/internal/cli.version={{ .Version }}
     targets:
@@ -23,6 +24,7 @@ builds:
     binary: gitcrawl
     env:
       - CGO_ENABLED=0
+      - GOEXPERIMENT=simd
     ldflags:
       - -s -w -X github.com/openclaw/gitcrawl/internal/cli.version={{ .Version }}
     targets:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index d4714a60..7a72f533 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- Prepare vectors once for 2.6× faster cluster scoring and 2.0× faster exact neighbors; enable `GOEXPERIMENT=simd` in release builds for a further 2.6×/1.7× on Apple M3 Ultra (1,024 dimensions).
 - Disable automatic Git maintenance during portable-refresh fixture setup so temporary repositories do not launch detached cleanup work.
 
 ## 0.12.0 - 2026-09-24
diff --git a/Dockerfile b/Dockerfile
index 2c30ff53..53f1fce5 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -10,7 +10,7 @@ COPY go.mod go.sum ./
 RUN go mod download
 COPY . .
 ARG VERSION=dev
-RUN CGO_ENABLED=0 GOOS=linux go build -trimpath \
+RUN CGO_ENABLED=0 GOEXPERIMENT=simd GOOS=linux go build -trimpath \
     -ldflags="-s -w -X github.com/openclaw/gitcrawl/internal/cli.version=${VERSION}" \
     -o /out/gitcrawl ./cmd/gitcrawl
 
diff --git a/docs/installation.md b/docs/installation.md
index 6ef6fa5e..c5bf7f04 100644
--- a/docs/installation.md
+++ b/docs/installation.md
@@ -76,6 +76,12 @@ go build \
 
 Symlink or copy `bin/gitcrawl` somewhere on your `PATH` (`~/bin`, `/usr/local/bin`, `~/.local/bin`).
 
+Source builds use scalar vector scoring by default. Set `GOEXPERIMENT=simd` on
+`go build` to enable Go 1.27's experimental portable SIMD kernels for clustering
+and exact neighbors. The API may change in Go 1.28; unsupported hardware and
+`GODEBUG=simd=0` use the scalar kernels. Release archives and Docker builds enable
+this SIMD path.
+
 ## GitHub CLI shim migration
 
 `gitcrawl gh` moved to Octopool:
diff --git a/internal/cli/cluster_graph.go b/internal/cli/cluster_graph.go
index 688ad413..72d59eb6 100644
--- a/internal/cli/cluster_graph.go
+++ b/internal/cli/cluster_graph.go
@@ -81,24 +81,8 @@ func buildDurableClusterInputs(ctx context.Context, st *store.Store, repoID int6
 		}
 		nodes = append(nodes, clusterer.Node{ThreadID: stored.ThreadID, Number: thread.Number, Title: thread.Title})
 	}
-	candidateByPair := map[string]clusterer.Edge{}
-	for left := 0; left < len(nodes); left++ {
-		for right := left + 1; right < len(nodes); right++ {
-			leftID := nodes[left].ThreadID
-			rightID := nodes[right].ThreadID
-			score := vector.Cosine(vectorByThreadID[leftID], vectorByThreadID[rightID])
-			if score < options.Threshold {
-				continue
-			}
-			if score < highConfidenceEdgeScore && titleTokenOverlap(threads[leftID].Title, threads[rightID].Title) < weakEdgeMinTitleOverlap {
-				continue
-			}
-			if threads[leftID].Kind != threads[rightID].Kind && score < options.CrossKindThreshold {
-				continue
-			}
-			upsertClusterEdge(candidateByPair, leftID, rightID, score)
-		}
-	}
+	candidateByPair := scoreClusterEdges(nodes, threads, vectorByThreadID, options)
+
 	repoFullName, err := repositoryFullNameByID(ctx, st, repoID)
 	if err != nil {
 		return nil, 0, err
@@ -155,6 +139,32 @@ func buildDurableClusterInputs(ctx context.Context, st *store.Store, repoID int6
 	return inputs, len(edges), nil
 }
 
+func scoreClusterEdges(nodes []clusterer.Node, threads map[int64]store.Thread, vectorByThreadID map[int64][]float64, options clusterBuildOptions) map[string]clusterer.Edge {
+	prepared := make([]vector.Prepared, len(nodes))
+	for i, node := range nodes {
+		prepared[i] = vector.Prepare(vectorByThreadID[node.ThreadID])
+	}
+	candidateByPair := map[string]clusterer.Edge{}
+	for left := 0; left < len(nodes); left++ {
+		for right := left + 1; right < len(nodes); right++ {
+			leftID := nodes[left].ThreadID
+			rightID := nodes[right].ThreadID
+			score := prepared[left].Cosine(prepared[right])
+			if score < options.Threshold {
+				continue
+			}
+			if score < highConfidenceEdgeScore && titleTokenOverlap(threads[leftID].Title, threads[rightID].Title) < weakEdgeMinTitleOverlap {
+				continue
+			}
+			if threads[leftID].Kind != threads[rightID].Kind && score < options.CrossKindThreshold {
+				continue
+			}
+			upsertClusterEdge(candidateByPair, leftID, rightID, score)
+		}
+	}
+	return candidateByPair
+}
+
 func upsertClusterEdge(edges map[string]clusterer.Edge, leftID, rightID int64, score float64) {
 	if leftID == rightID {
 		return
diff --git a/internal/cli/cluster_graph_bench_test.go b/internal/cli/cluster_graph_bench_test.go
new file mode 100644
index 00000000..b7a6924c
--- /dev/null
+++ b/internal/cli/cluster_graph_bench_test.go
@@ -0,0 +1,133 @@
+package cli
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"math/rand/v2"
+	"path/filepath"
+	"testing"
+	"time"
+
+	clusterer "github.com/openclaw/gitcrawl/internal/cluster"
+	"github.com/openclaw/gitcrawl/internal/config"
+	"github.com/openclaw/gitcrawl/internal/store"
+)
+
+func clusterBenchmarkData(count int) ([]clusterer.Node, map[int64]store.Thread, map[int64][]float64) {
+	rng := rand.New(rand.NewPCG(7, 11))
+	dims := config.Default().OpenAI.EmbedDimensions
+	nodes := make([]clusterer.Node, count)
+	threads := make(map[int64]store.Thread, count)
+	vectors := make(map[int64][]float64, count)
+	var center []float64
+	for i := range nodes {
+		if i%8 == 0 {
+			center = make([]float64, dims)
+			for j := range center {
+				center[j] = rng.NormFloat64()
+			}
+		}
+		values := make([]float64, dims)
+		for j := range values {
+			values[j] = center[j] + 0.15*rng.NormFloat64()
+		}
+		id := int64(i + 1)
+		title := fmt.Sprintf("Synthetic embedding group %d", i/8)
+		nodes[i] = clusterer.Node{ThreadID: id, Number: i + 1, Title: title}
+		kind := "issue"
+		if i%3 == 0 {
+			kind = "pull_request"
+		}
+		threads[id] = store.Thread{Number: i + 1, Kind: kind, State: "open", Title: title}
+		vectors[id] = values
+	}
+	return nodes, threads, vectors
+}
+
+var benchmarkEdges map[string]clusterer.Edge
+
+func BenchmarkClusterEdges2000(b *testing.B) {
+	nodes, threads, vectors := clusterBenchmarkData(2000)
+	opts := clusterBuildOptions{Threshold: 0.90, CrossKindThreshold: defaultCrossKindMinScore}
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		benchmarkEdges = scoreClusterEdges(nodes, threads, vectors, opts)
+	}
+}
+
+func BenchmarkClusterCommand2000(b *testing.B) {
+	ctx := context.Background()
+	b.Setenv("GITCRAWL_NO_UPDATE_CHECK", "1")
+	dir := b.TempDir()
+	configPath, dbPath := filepath.Join(dir, "config.toml"), filepath.Join(dir, "gitcrawl.db")
+	app := New()
+	app.Stdout, app.Stderr = io.Discard, io.Discard
+	if err := app.Run(ctx, []string{"--config", configPath, "init", "--db", dbPath}); err != nil {
+		b.Fatal(err)
+	}
+	st, err := store.Open(ctx, dbPath)
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer st.Close()
+	now := time.Now().UTC().Format(time.RFC3339Nano)
+	repoID, err := st.UpsertRepository(ctx, store.Repository{Owner: "synthetic", Name: "bench", FullName: "synthetic/bench", UpdatedAt: now})
+	if err != nil {
+		b.Fatal(err)
+	}
+	nodes, threads, vectors := clusterBenchmarkData(2000)
+	if err := st.WithTx(ctx, func(st *store.Store) error {
+		for _, node := range nodes {
+			thread := threads[node.ThreadID]
+			thread.RepoID, thread.GitHubID = repoID, fmt.Sprint(node.ThreadID)
+			thread.LabelsJSON, thread.AssigneesJSON, thread.RawJSON = "[]", "[]", "{}"
+			thread.ContentHash, thread.UpdatedAt = fmt.Sprint(node.ThreadID), now
+			if _, err := st.UpsertThread(ctx, thread); err != nil {
+				return err
+			}
+		}
+		return nil
+	}); err != nil {
+		b.Fatal(err)
+	}
+	tasks, err := st.ListEmbeddingTasks(ctx, store.EmbeddingTaskOptions{RepoID: repoID, Basis: "title_original", Model: "text-embedding-3-small", Force: true})
+	if err != nil {
+		b.Fatal(err)
+	}
+	if len(tasks) != len(nodes) {
+		b.Fatalf("tasks: %d want %d", len(tasks), len(nodes))
+	}
+	// Bulk fixture insertion stays outside the timed command and avoids per-row fsync.
+	tx, err := st.DB().BeginTx(ctx, nil)
+	if err != nil {
+		b.Fatal(err)
+	}
+	defer tx.Rollback()
+	for _, task := range tasks {
+		values := vectors[task.ThreadID]
+		data, err := json.Marshal(values)
+		if err != nil {
+			b.Fatal(err)
+		}
+		if _, err := tx.ExecContext(ctx, `insert into thread_vectors(thread_id,basis,model,dimensions,content_hash,vector_json,vector_backend,created_at,updated_at) values(?,?,?,?,?,?,?,?,?)`, task.ThreadID, "title_original", "text-embedding-3-small", len(values), task.ContentHash, string(data), "exact", now, now); err != nil {
+			b.Fatal(err)
+		}
+	}
+	if err := tx.Commit(); err != nil {
+		b.Fatal(err)
+	}
+
+	if err := st.Close(); err != nil {
+		b.Fatal(err)
+	}
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		if err := app.Run(ctx, []string{"--config", configPath, "cluster", "synthetic/bench", "--threshold", "0.90", "--json"}); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
diff --git a/internal/cli/cluster_graph_scoring_test.go b/internal/cli/cluster_graph_scoring_test.go
new file mode 100644
index 00000000..a37030d8
--- /dev/null
+++ b/internal/cli/cluster_graph_scoring_test.go
@@ -0,0 +1,58 @@
+package cli
+
+import (
+	clusterer "github.com/openclaw/gitcrawl/internal/cluster"
+	"github.com/openclaw/gitcrawl/internal/store"
+	"github.com/openclaw/gitcrawl/internal/vector"
+	"math"
+	"testing"
+)
+
+func TestPreparedClusterEdgesMatchOriginal(t *testing.T) {
+	nodes, threads, vectors := clusterBenchmarkData(96)
+	vectors[1] = []float64{math.NaN()}
+	vectors[2] = nil
+	vectors[3] = []float64{0}
+	vectors[4] = []float64{1, 2}
+	vectors[5] = []float64{math.MaxFloat64, math.MaxFloat64}
+	vectors[6] = []float64{math.SmallestNonzeroFloat64, math.SmallestNonzeroFloat64}
+	var maxDeviation float64
+	for _, threshold := range []float64{-1, 0, 0.3, 0.9, 1} {
+		opts := clusterBuildOptions{Threshold: threshold, CrossKindThreshold: defaultCrossKindMinScore}
+		got, want := scoreClusterEdges(nodes, threads, vectors, opts), originalClusterEdges(nodes, threads, vectors, opts)
+		if len(got) != len(want) {
+			t.Fatalf("threshold %g: %d edges want %d", threshold, len(got), len(want))
+		}
+		for pair, expected := range want {
+			actual, ok := got[pair]
+			deviation := math.Abs(actual.Score - expected.Score)
+			maxDeviation = max(maxDeviation, deviation)
+			if !ok || actual.LeftThreadID != expected.LeftThreadID || actual.RightThreadID != expected.RightThreadID || deviation > 1e-12 {
+				t.Fatalf("threshold %g pair %s: %+v want %+v", threshold, pair, actual, expected)
+			}
+		}
+	}
+	t.Logf("max cluster-edge score deviation: %.17g", maxDeviation)
+}
+
+func originalClusterEdges(nodes []clusterer.Node, threads map[int64]store.Thread, vectorByThreadID map[int64][]float64, options clusterBuildOptions) map[string]clusterer.Edge {
+	candidateByPair := map[string]clusterer.Edge{}
+	for left := 0; left < len(nodes); left++ {
+		for right := left + 1; right < len(nodes); right++ {
+			leftID := nodes[left].ThreadID
+			rightID := nodes[right].ThreadID
+			score := vector.Cosine(vectorByThreadID[leftID], vectorByThreadID[rightID])
+			if score < options.Threshold {
+				continue
+			}
+			if score < highConfidenceEdgeScore && titleTokenOverlap(threads[leftID].Title, threads[rightID].Title) < weakEdgeMinTitleOverlap {
+				continue
+			}
+			if threads[leftID].Kind != threads[rightID].Kind && score < options.CrossKindThreshold {
+				continue
+			}
+			upsertClusterEdge(candidateByPair, leftID, rightID, score)
+		}
+	}
+	return candidateByPair
+}
diff --git a/internal/vector/exact.go b/internal/vector/exact.go
index 60f58639..3b236605 100644
--- a/internal/vector/exact.go
+++ b/internal/vector/exact.go
@@ -56,6 +56,8 @@ func queryExact(ctx context.Context, items []Item, query []float64, limit int, e
 	if err := validateExactQuery(query); err != nil {
 		return nil, err
 	}
+	preparedQuery := Prepare(query)
+	scratch := make([]float64, len(query))
 	scored := make([]crawlvector.Scored[Neighbor], 0, len(items))
 	for _, item := range items {
 		if err := ctx.Err(); err != nil {
@@ -64,7 +66,10 @@ func queryExact(ctx context.Context, items []Item, query []float64, limit int, e
 		if item.ThreadID == excludeThreadID {
 			continue
 		}
-		score := Cosine(query, item.Vector)
+		if len(item.Vector) != len(query) {
+			continue
+		}
+		score := preparedQuery.Cosine(prepareInto(scratch, item.Vector))
 		if math.IsNaN(score) || math.IsInf(score, 0) || score <= 0 {
 			continue
 		}
diff --git a/internal/vector/prepared.go b/internal/vector/prepared.go
new file mode 100644
index 00000000..654eb075
--- /dev/null
+++ b/internal/vector/prepared.go
@@ -0,0 +1,52 @@
+package vector
+
+import "math"
+
+// Prepared holds an immutable, validated copy of a vector for repeated scoring.
+// Its zero value scores zero against every vector.
+type Prepared struct {
+	values    []float64
+	magnitude float64
+}
+
+// Prepare scales by max-abs before computing the magnitude, so even very large
+// or subnormal finite inputs are safe. Empty, zero and non-finite inputs are invalid.
+func Prepare(values []float64) Prepared {
+	return prepareInto(make([]float64, len(values)), values)
+}
+
+func prepareScalar(dst, values []float64) Prepared {
+	var maxAbs float64
+	for _, value := range values {
+		if math.IsNaN(value) || math.IsInf(value, 0) {
+			return Prepared{}
+		}
+		maxAbs = max(maxAbs, math.Abs(value))
+	}
+	if maxAbs == 0 {
+		return Prepared{}
+	}
+	var magnitude float64
+	for i, value := range values {
+		scaled := value / maxAbs
+		dst[i] = scaled
+		magnitude += scaled * scaled
+	}
+	return Prepared{values: dst[:len(values)], magnitude: math.Sqrt(magnitude)}
+}
+
+// Cosine returns zero for invalid or mismatched vectors and clamps to [-1, 1].
+func (left Prepared) Cosine(right Prepared) float64 {
+	if len(left.values) == 0 || len(left.values) != len(right.values) {
+		return 0
+	}
+	return max(-1, min(1, preparedDot(left.values, right.values)/(left.magnitude*right.magnitude)))
+}
+
+func dotScalar(left, right []float64) float64 {
+	var dot float64
+	for i, value := range left {
+		dot += value * right[i]
+	}
+	return dot
+}
diff --git a/internal/vector/prepared_nosimd.go b/internal/vector/prepared_nosimd.go
new file mode 100644
index 00000000..6836af00
--- /dev/null
+++ b/internal/vector/prepared_nosimd.go
@@ -0,0 +1,11 @@
+//go:build !goexperiment.simd
+
+package vector
+
+func preparedDot(left, right []float64) float64 {
+	return dotScalar(left, right)
+}
+
+func prepareInto(dst, values []float64) Prepared {
+	return prepareScalar(dst, values)
+}
diff --git a/internal/vector/prepared_simd.go b/internal/vector/prepared_simd.go
new file mode 100644
index 00000000..8816dab5
--- /dev/null
+++ b/internal/vector/prepared_simd.go
@@ -0,0 +1,115 @@
+//go:build goexperiment.simd
+
+package vector
+
+import (
+	"math"
+	"simd"
+)
+
+// Emulation is slower than the scalar kernels.
+var emulatedSIMD = simd.Emulated()
+
+// Lane buffers cover 2048-bit vectors (arm64 SVE is planned for Go 1.28), since
+// release builds enable this experiment and Store panics on a short slice.
+const maxFloat64Lanes = 32
+
+func preparedDot(left, right []float64) float64 {
+	if emulatedSIMD {
+		return dotScalar(left, right)
+	}
+	var a, b, c, d simd.Float64s
+	lanes := a.Len()
+	i := 0
+	for ; i+4*lanes <= len(left); i += 4 * lanes {
+		a = simd.LoadFloat64s(left[i:]).MulAdd(simd.LoadFloat64s(right[i:]), a)
+		b = simd.LoadFloat64s(left[i+lanes:]).MulAdd(simd.LoadFloat64s(right[i+lanes:]), b)
+		c = simd.LoadFloat64s(left[i+2*lanes:]).MulAdd(simd.LoadFloat64s(right[i+2*lanes:]), c)
+		d = simd.LoadFloat64s(left[i+3*lanes:]).MulAdd(simd.LoadFloat64s(right[i+3*lanes:]), d)
+	}
+	for ; i+lanes <= len(left); i += lanes {
+		a = simd.LoadFloat64s(left[i:]).MulAdd(simd.LoadFloat64s(right[i:]), a)
+	}
+	// Reduce once, outside the loop.
+	var sums [maxFloat64Lanes]float64
+	a.Add(b).Add(c.Add(d)).Store(sums[:])
+	var dot float64
+	for _, value := range sums[:lanes] {
+		dot += value
+	}
+	for ; i < len(left); i++ {
+		dot += left[i] * right[i]
+	}
+	return dot
+}
+
+func prepareInto(dst, values []float64) Prepared {
+	if emulatedSIMD {
+		return prepareScalar(dst, values)
+	}
+	var maxima simd.Float64s
+	var invalid simd.Mask64s
+	finiteLimit := simd.BroadcastFloat64s(math.MaxFloat64)
+	lanes := maxima.Len()
+	i := 0
+	for ; i+lanes <= len(values); i += lanes {
+		v := simd.LoadFloat64s(values[i:])
+		abs := v.Abs()
+		invalid = invalid.Or(v.NotEqual(v)).Or(abs.Greater(finiteLimit))
+		maxima = maxima.Max(abs)
+	}
+	var maxValues [maxFloat64Lanes]float64
+	var bad [maxFloat64Lanes]int64
+	maxima.Store(maxValues[:])
+	invalid.ToInt64s().Store(bad[:])
+	var maxAbs float64
+	for lane := 0; lane < lanes; lane++ {
+		if bad[lane] != 0 {
+			return Prepared{}
+		}
+		maxAbs = max(maxAbs, maxValues[lane])
+	}
+	for _, value := range values[i:] {
+		if math.IsNaN(value) || math.IsInf(value, 0) {
+			return Prepared{}
+		}
+		maxAbs = max(maxAbs, math.Abs(value))
+	}
+	if maxAbs == 0 {
+		return Prepared{}
+	}
+	divisor := simd.BroadcastFloat64s(maxAbs)
+	var a, b, c, d simd.Float64s
+	i = 0
+	for ; i+4*lanes <= len(values); i += 4 * lanes {
+		v0 := simd.LoadFloat64s(values[i:]).Div(divisor)
+		v1 := simd.LoadFloat64s(values[i+lanes:]).Div(divisor)
+		v2 := simd.LoadFloat64s(values[i+2*lanes:]).Div(divisor)
+		v3 := simd.LoadFloat64s(values[i+3*lanes:]).Div(divisor)
+		v0.Store(dst[i:])
+		v1.Store(dst[i+lanes:])
+		v2.Store(dst[i+2*lanes:])
+		v3.Store(dst[i+3*lanes:])
+		a = v0.MulAdd(v0, a)
+		b = v1.MulAdd(v1, b)
+		c = v2.MulAdd(v2, c)
+		d = v3.MulAdd(v3, d)
+	}
+	for ; i+lanes <= len(values); i += lanes {
+		v := simd.LoadFloat64s(values[i:]).Div(divisor)
+		v.Store(dst[i:])
+		a = v.MulAdd(v, a)
+	}
+	var sums [maxFloat64Lanes]float64
+	a.Add(b).Add(c.Add(d)).Store(sums[:])
+	var magnitude float64
+	for _, value := range sums[:lanes] {
+		magnitude += value
+	}
+	for ; i < len(values); i++ {
+		scaled := values[i] / maxAbs
+		dst[i] = scaled
+		magnitude += scaled * scaled
+	}
+	return Prepared{values: dst[:len(values)], magnitude: math.Sqrt(magnitude)}
+}
diff --git a/internal/vector/prepared_simd_test.go b/internal/vector/prepared_simd_test.go
new file mode 100644
index 00000000..1cce7355
--- /dev/null
+++ b/internal/vector/prepared_simd_test.go
@@ -0,0 +1,22 @@
+//go:build goexperiment.simd
+
+package vector
+
+import (
+	"simd"
+	"testing"
+)
+
+func TestSIMDMode(t *testing.T) {
+	var lanes simd.Float64s
+	t.Logf("float64 lanes=%d emulated=%t", lanes.Len(), emulatedSIMD)
+	if !emulatedSIMD {
+		return
+	}
+	items := benchmarkItems(2, 1024)
+	left := Prepare(items[0].Vector)
+	right := Prepare(items[1].Vector)
+	if got, want := left.Cosine(right), Cosine(items[0].Vector, items[1].Vector); got != want {
+		t.Fatalf("emulated fallback: got %.17g want scalar %.17g", got, want)
+	}
+}
diff --git a/internal/vector/prepared_test.go b/internal/vector/prepared_test.go
new file mode 100644
index 00000000..3d90bcdf
--- /dev/null
+++ b/internal/vector/prepared_test.go
@@ -0,0 +1,168 @@
+package vector
+
+import (
+	"context"
+	"math"
+	"math/rand/v2"
+	"sort"
+	"testing"
+
+	"github.com/openclaw/gitcrawl/internal/config"
+)
+
+// Lane reduction and FMA change rounding; normalized scores must agree within 1e-12.
+func TestPreparedCosine(t *testing.T) {
+	rng := rand.New(rand.NewPCG(17, 29))
+	lengths := []int{1024, 1536, 3072}
+	// Cover three times the maximum float32 lane count, including odd tails.
+	for n := 0; n <= 3*16+7; n++ {
+		lengths = append(lengths, n)
+	}
+	var maxDeviation, maxDotDeviation float64
+	for _, n := range lengths {
+		left, right := make([]float64, n), make([]float64, n)
+		for trial := 0; trial < 24; trial++ {
+			for i := range left {
+				left[i], right[i] = rng.NormFloat64(), rng.NormFloat64()
+				if trial%3 == 0 {
+					right[i] = left[i] + right[i]*0.01
+				}
+				if trial%3 == 1 {
+					right[i] = -left[i]
+				}
+				if trial%4 == 0 {
+					left[i] *= 1e300
+					right[i] *= 1e-300
+				}
+			}
+			l, r := Prepare(left), Prepare(right)
+			want, got := Cosine(left, right), l.Cosine(r)
+			deviation := math.Abs(want - got)
+			maxDeviation = max(maxDeviation, deviation)
+			if math.IsNaN(got) || deviation > 1e-12 {
+				t.Fatalf("n=%d trial=%d: got %.17g want %.17g", n, trial, got, want)
+			}
+			if n > 0 {
+				scalar := dotScalar(l.values, r.values) / (l.magnitude * r.magnitude)
+				actual := preparedDot(l.values, r.values) / (l.magnitude * r.magnitude)
+				maxDotDeviation = max(maxDotDeviation, math.Abs(scalar-actual))
+				if math.Abs(scalar-actual) > 1e-12 {
+					t.Fatalf("dot n=%d: got %.17g want %.17g", n, actual, scalar)
+				}
+			}
+		}
+	}
+	t.Logf("max cosine deviation from original: %.17g; dispatch-vs-scalar normalized dot: %.17g", maxDeviation, maxDotDeviation)
+}
+
+func TestPreparedSpecialValues(t *testing.T) {
+	cases := [][]float64{nil, {}, {0}, {0, 0}, {1}, {-1}, {1, -1}, {math.MaxFloat64, -math.MaxFloat64}, {math.SmallestNonzeroFloat64, -math.SmallestNonzeroFloat64}, {math.NaN(), 1}, {1, math.Inf(1)}, {math.Inf(-1), 1}}
+	for _, left := range cases {
+		for _, right := range cases {
+			want, got := Cosine(left, right), Prepare(left).Cosine(Prepare(right))
+			if math.IsNaN(got) || math.Abs(want-got) > 1e-12 {
+				t.Fatalf("%v / %v: got %.17g want %.17g", left, right, got, want)
+			}
+		}
+	}
+	for n := 1; n <= 3*16+7; n++ {
+		for i := 0; i < n; i++ {
+			for _, bad := range []float64{math.NaN(), math.Inf(1), math.Inf(-1)} {
+				values := make([]float64, n)
+				values[0], values[i] = 1, bad
+				if got := Prepare(values).Cosine(Prepare(values)); got != 0 {
+					t.Fatalf("n=%d index=%d: %g", n, i, got)
+				}
+			}
+		}
+	}
+	values := []float64{1, 2, 3}
+	prepared := Prepare(values)
+	values[0] = math.NaN()
+	if got := prepared.Cosine(Prepare([]float64{1, 2, 3})); math.Abs(got-1) > 1e-12 {
+		t.Fatalf("Prepare aliases input: %g", got)
+	}
+	if got := preparedDot(nil, nil); got != 0 {
+		t.Fatalf("empty dot = %g", got)
+	}
+	if got := preparedDot(make([]float64, 55), make([]float64, 55)); got != 0 {
+		t.Fatalf("zero dot = %g", got)
+	}
+}
+
+func TestPreparedQueryMatchesOriginal(t *testing.T) {
+	items := benchmarkItems(256, 1024)
+	query := items[0].Vector
+	var want []Neighbor
+	for _, item := range items[1:] {
+		score := Cosine(query, item.Vector)
+		if score > 0 {
+			want = append(want, Neighbor{ThreadID: item.ThreadID, Score: score})
+		}
+	}
+	sort.Slice(want, func(i, j int) bool {
+		if want[i].Score == want[j].Score {
+			return want[i].ThreadID < want[j].ThreadID
+		}
+		return want[i].Score > want[j].Score
+	})
+	want = want[:20]
+	got := Query(items, query, 20, items[0].ThreadID)
+	if len(got) != len(want) {
+		t.Fatalf("neighbors: %d want %d", len(got), len(want))
+	}
+	for i := range want {
+		if got[i].ThreadID != want[i].ThreadID || math.Abs(got[i].Score-want[i].Score) > 1e-12 {
+			t.Fatalf("neighbor %d: %+v want %+v", i, got[i], want[i])
+		}
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	if _, err := queryExact(ctx, items, query, 20, 0); err != context.Canceled {
+		t.Fatalf("cancellation: %v", err)
+	}
+}
+
+func benchmarkItems(count, dims int) []Item {
+	rng := rand.New(rand.NewPCG(7, 11))
+	items := make([]Item, count)
+	for i := range items {
+		values := make([]float64, dims)
+		for j := range values {
+			values[j] = rng.NormFloat64()
+		}
+		items[i] = Item{ThreadID: int64(i + 1), Vector: values}
+	}
+	return items
+}
+
+var benchmarkScore float64
+var benchmarkNeighbors []Neighbor
+
+func BenchmarkCosine(b *testing.B) {
+	items := benchmarkItems(2, config.Default().OpenAI.EmbedDimensions)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		benchmarkScore = Cosine(items[0].Vector, items[1].Vector)
+	}
+}
+
+func BenchmarkPreparedCosine(b *testing.B) {
+	items := benchmarkItems(2, config.Default().OpenAI.EmbedDimensions)
+	left, right := Prepare(items[0].Vector), Prepare(items[1].Vector)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		benchmarkScore = left.Cosine(right)
+	}
+}
+
+func BenchmarkQueryExact20000(b *testing.B) {
+	items := benchmarkItems(20000, config.Default().OpenAI.EmbedDimensions)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		benchmarkNeighbors = Query(items, items[0].Vector, 20, items[0].ThreadID)
+	}
+}