From 625f4f65c7ff8624ac1782c848456a3ffdaca4f4 Mon Sep 17 00:00:00 2001
From: Bernardo Ferrari <bernaferrari2@gmail.com>
Date: Fri, 27 Feb 2026 02:51:42 -0300
Subject: [PATCH 1/5] improve model search matching and highlight hits in
 selectors

---
 .../tests/unit/model-selector-utils.test.ts   |  52 ++++++
 .../agent-manager/MultiModelSelector.tsx      |  56 +++++--
 .../agent-manager/agent-manager.css           |   5 +
 .../src/components/shared/ModelSelector.tsx   |  66 ++++++--
 .../components/shared/model-selector-utils.ts | 148 ++++++++++++++++++
 .../webview-ui/src/styles/chat.css            |   5 +
 6 files changed, 310 insertions(+), 22 deletions(-)

diff --git a/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts b/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts
index dae4533679f..677993fa0af 100644
--- a/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts
+++ b/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts
@@ -3,6 +3,8 @@ import {
   providerSortKey,
   isFree,
   buildTriggerLabel,
+  WordBoundaryFzf,
+  buildMatchSegments,
   KILO_GATEWAY_ID,
   PROVIDER_ORDER,
 } from "../../webview-ui/src/components/shared/model-selector-utils"
@@ -103,3 +105,53 @@ describe("buildTriggerLabel", () => {
     expect(buildTriggerLabel(undefined, raw, false, "", true, labels)).toBe("Select model")
   })
 })
+
+describe("WordBoundaryFzf", () => {
+  const items = ["Claude Sonnet", "gpt-5", "OpenAI o3", "Gemini Flash"]
+  const finder = new WordBoundaryFzf(items, (item) => item)
+
+  it("returns all items with empty positions for empty query", () => {
+    const result = finder.find("")
+    expect(result).toHaveLength(items.length)
+    expect(result.every((entry) => entry.positions.size === 0)).toBe(true)
+  })
+
+  it("matches acronym across words and captures matching positions", () => {
+    const result = finder.find("clso")
+    expect(result).toHaveLength(1)
+    expect(result[0].item).toBe("Claude Sonnet")
+    expect(Array.from(result[0].positions).sort((a, b) => a - b)).toEqual([0, 1, 7, 8])
+  })
+
+  it("supports punctuation in the query by splitting at boundaries", () => {
+    const result = finder.find("gpt-")
+    expect(result).toHaveLength(1)
+    expect(result[0].item).toBe("gpt-5")
+  })
+
+  it("requires matches to start at word boundaries", () => {
+    const result = finder.find("aude")
+    expect(result).toHaveLength(0)
+  })
+
+  it("requires all words in multi-word queries to match", () => {
+    const result = finder.find("claude flash")
+    expect(result).toHaveLength(0)
+  })
+})
+
+describe("buildMatchSegments", () => {
+  it("returns a single non-highlighted segment without matches", () => {
+    expect(buildMatchSegments("Claude Sonnet")).toEqual([{ text: "Claude Sonnet", highlight: false }])
+  })
+
+  it("splits contiguous highlight groups into segments", () => {
+    const segments = buildMatchSegments("Claude Sonnet", new Set([0, 1, 7, 8]))
+    expect(segments).toEqual([
+      { text: "Cl", highlight: true },
+      { text: "aude ", highlight: false },
+      { text: "So", highlight: true },
+      { text: "nnet", highlight: false },
+    ])
+  })
+})
diff --git a/packages/kilo-vscode/webview-ui/agent-manager/MultiModelSelector.tsx b/packages/kilo-vscode/webview-ui/agent-manager/MultiModelSelector.tsx
index e497771b9fd..8b3be9fa5aa 100644
--- a/packages/kilo-vscode/webview-ui/agent-manager/MultiModelSelector.tsx
+++ b/packages/kilo-vscode/webview-ui/agent-manager/MultiModelSelector.tsx
@@ -3,7 +3,12 @@ import { Icon } from "@kilocode/kilo-ui/icon"
 import { useProvider } from "../src/context/provider"
 import type { EnrichedModel } from "../src/context/provider"
 import { useLanguage } from "../src/context/language"
-import { KILO_GATEWAY_ID, providerSortKey } from "../src/components/shared/model-selector-utils"
+import {
+  KILO_GATEWAY_ID,
+  providerSortKey,
+  WordBoundaryFzf,
+  buildMatchSegments,
+} from "../src/components/shared/model-selector-utils"
 import {
   type ModelAllocations,
   MAX_MULTI_VERSIONS,
@@ -19,7 +24,11 @@ export { MAX_MULTI_VERSIONS, totalAllocations, allocationsToArray } from "./mult
 
 interface ModelGroup {
   providerName: string
-  models: EnrichedModel[]
+  models: FilteredModel[]
+}
+
+interface FilteredModel extends EnrichedModel {
+  matchingPositions?: Set<number>
 }
 
 const COUNT_OPTIONS = Array.from({ length: MAX_MULTI_VERSIONS }, (_, i) => i + 1)
@@ -38,13 +47,36 @@ export const MultiModelSelector: Component<{
     return models().filter((m) => m.providerID === KILO_GATEWAY_ID || c.includes(m.providerID))
   })
 
-  const filtered = createMemo(() => {
-    const q = search().toLowerCase()
-    if (!q) return visibleModels()
-    return visibleModels().filter(
-      (m) =>
-        m.name.toLowerCase().includes(q) || m.providerName.toLowerCase().includes(q) || m.id.toLowerCase().includes(q),
+  const filtered = createMemo<FilteredModel[]>(() => {
+    const query = search().trim()
+    if (!query) {
+      return visibleModels().map((model) => ({ ...model, matchingPositions: new Set<number>() }))
+    }
+
+    const finder = new WordBoundaryFzf(visibleModels(), (model) => model.name)
+    const nameMatches = finder.find(query)
+    const nameMatchesByKey = new Map(
+      nameMatches.map(({ item, positions }) => [`${item.providerID}/${item.id}`, positions] as const),
     )
+    const normalized = query.toLowerCase()
+
+    return visibleModels().reduce<FilteredModel[]>((result, model) => {
+      const key = `${model.providerID}/${model.id}`
+      const positions = nameMatchesByKey.get(key)
+
+      if (positions) {
+        result.push({ ...model, matchingPositions: positions })
+        return result
+      }
+
+      const fallbackMatch =
+        model.providerName.toLowerCase().includes(normalized) || model.id.toLowerCase().includes(normalized)
+      if (fallbackMatch) {
+        result.push({ ...model, matchingPositions: new Set<number>() })
+      }
+
+      return result
+    }, [])
   })
 
   const groups = createMemo<ModelGroup[]>(() => {
@@ -106,7 +138,13 @@ export const MultiModelSelector: Component<{
                             props.onChange(toggleModel(props.allocations, model.providerID, model.id, model.name))
                           }
                         />
-                        <span class="am-mm-item-name">{model.name}</span>
+                        <span class="am-mm-item-name">
+                          <For each={buildMatchSegments(model.name, model.matchingPositions)}>
+                            {(segment) => (
+                              <span classList={{ "am-mm-item-name-highlight": segment.highlight }}>{segment.text}</span>
+                            )}
+                          </For>
+                        </span>
                       </label>
                       <Show when={checked()}>
                         <select
diff --git a/packages/kilo-vscode/webview-ui/agent-manager/agent-manager.css b/packages/kilo-vscode/webview-ui/agent-manager/agent-manager.css
index 2dd907aac74..9137d2bae1e 100644
--- a/packages/kilo-vscode/webview-ui/agent-manager/agent-manager.css
+++ b/packages/kilo-vscode/webview-ui/agent-manager/agent-manager.css
@@ -1705,6 +1705,11 @@ button.am-section-toggle:hover .am-section-label {
   white-space: nowrap;
 }
 
+.am-mm-item-name-highlight {
+  font-weight: 700;
+  color: var(--vscode-textLink-foreground, var(--text-link, var(--text-base)));
+}
+
 .am-mm-count-select {
   flex-shrink: 0;
   padding: 2px 4px;
diff --git a/packages/kilo-vscode/webview-ui/src/components/shared/ModelSelector.tsx b/packages/kilo-vscode/webview-ui/src/components/shared/ModelSelector.tsx
index ed1379af9fc..0cf2cae54d8 100644
--- a/packages/kilo-vscode/webview-ui/src/components/shared/ModelSelector.tsx
+++ b/packages/kilo-vscode/webview-ui/src/components/shared/ModelSelector.tsx
@@ -14,11 +14,22 @@ import { useProvider, EnrichedModel } from "../../context/provider"
 import { useSession } from "../../context/session"
 import { useLanguage } from "../../context/language"
 import type { ModelSelection } from "../../types/messages"
-import { KILO_GATEWAY_ID, providerSortKey, isFree, buildTriggerLabel } from "./model-selector-utils"
+import {
+  KILO_GATEWAY_ID,
+  providerSortKey,
+  isFree,
+  buildTriggerLabel,
+  WordBoundaryFzf,
+  buildMatchSegments,
+} from "./model-selector-utils"
 
 interface ModelGroup {
   providerName: string
-  models: EnrichedModel[]
+  models: FilteredModel[]
+}
+
+interface FilteredModel extends EnrichedModel {
+  matchingPositions?: Set<number>
 }
 
 // ---------------------------------------------------------------------------
@@ -59,15 +70,36 @@ export const ModelSelectorBase: Component<ModelSelectorBaseProps> = (props) => {
   const hasProviders = () => visibleModels().length > 0
 
   // Flat filtered list for keyboard navigation
-  const filtered = createMemo(() => {
-    const q = search().toLowerCase()
-    if (!q) {
-      return visibleModels()
+  const filtered = createMemo<FilteredModel[]>(() => {
+    const query = search().trim()
+    if (!query) {
+      return visibleModels().map((model) => ({ ...model, matchingPositions: new Set<number>() }))
     }
-    return visibleModels().filter(
-      (m) =>
-        m.name.toLowerCase().includes(q) || m.providerName.toLowerCase().includes(q) || m.id.toLowerCase().includes(q),
+
+    const finder = new WordBoundaryFzf(visibleModels(), (model) => model.name)
+    const nameMatches = finder.find(query)
+    const nameMatchesByKey = new Map(
+      nameMatches.map(({ item, positions }) => [`${item.providerID}/${item.id}`, positions] as const),
     )
+    const normalized = query.toLowerCase()
+
+    return visibleModels().reduce<FilteredModel[]>((result, model) => {
+      const key = `${model.providerID}/${model.id}`
+      const positions = nameMatchesByKey.get(key)
+
+      if (positions) {
+        result.push({ ...model, matchingPositions: positions })
+        return result
+      }
+
+      const fallbackMatch =
+        model.providerName.toLowerCase().includes(normalized) || model.id.toLowerCase().includes(normalized)
+      if (fallbackMatch) {
+        result.push({ ...model, matchingPositions: new Set<number>() })
+      }
+
+      return result
+    }, [])
   })
 
   // Grouped for rendering
@@ -106,7 +138,7 @@ export const ModelSelectorBase: Component<ModelSelectorBaseProps> = (props) => {
     }
   })
 
-  function pick(model: EnrichedModel) {
+  function pick(model: FilteredModel) {
     props.onSelect(model.providerID, model.id)
     setOpen(false)
   }
@@ -159,13 +191,13 @@ export const ModelSelectorBase: Component<ModelSelectorBaseProps> = (props) => {
     })
   }
 
-  function isSelected(model: EnrichedModel): boolean {
+  function isSelected(model: FilteredModel): boolean {
     const sel = selectedModel()
     return sel !== undefined && sel.providerID === model.providerID && sel.id === model.id
   }
 
   // Track flat index across groups for active highlighting
-  function flatIndex(model: EnrichedModel): number {
+  function flatIndex(model: FilteredModel): number {
     return flatFiltered().indexOf(model) + clearOffset()
   }
 
@@ -249,7 +281,15 @@ export const ModelSelectorBase: Component<ModelSelectorBaseProps> = (props) => {
                       onClick={() => pick(model)}
                       onMouseEnter={() => setActiveIndex(flatIndex(model))}
                     >
-                      <span class="model-selector-item-name">{model.name}</span>
+                      <span class="model-selector-item-name">
+                        <For each={buildMatchSegments(model.name, model.matchingPositions)}>
+                          {(segment) => (
+                            <span classList={{ "model-selector-item-name-highlight": segment.highlight }}>
+                              {segment.text}
+                            </span>
+                          )}
+                        </For>
+                      </span>
                       <Show when={isFree(model)}>
                         <span class="model-selector-tag">{language.t("model.tag.free")}</span>
                       </Show>
diff --git a/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts b/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
index 24d8649bb9a..6e4c0b1170e 100644
--- a/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
+++ b/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
@@ -5,6 +5,23 @@ export const KILO_GATEWAY_ID = "kilo"
 
 export const PROVIDER_ORDER = [KILO_GATEWAY_ID, "anthropic", "openai", "google"]
 
+const WORD_BOUNDARY_REGEX = /(?=[A-Z])|[[\]_.:\s/\\(){}-]+/
+
+interface WordToken {
+  word: string
+  index: number
+}
+
+export interface SearchResult<T> {
+  item: T
+  positions: Set<number>
+}
+
+export interface HighlightSegment {
+  text: string
+  highlight: boolean
+}
+
 export function providerSortKey(providerID: string, order = PROVIDER_ORDER): number {
   const idx = order.indexOf(providerID.toLowerCase())
   return idx >= 0 ? idx : order.length
@@ -14,6 +31,137 @@ export function isFree(model: Pick<EnrichedModel, "inputPrice">): boolean {
   return model.inputPrice === 0
 }
 
+export class WordBoundaryFzf<T> {
+  constructor(
+    private readonly items: T[],
+    private readonly selector: (item: T) => string,
+  ) {}
+
+  find(query: string): SearchResult<T>[] {
+    if (!query || query.trim() === "") {
+      return this.items.map((item) => ({ item, positions: new Set<number>() }))
+    }
+
+    const queryWords = query
+      .toLowerCase()
+      .trim()
+      .split(WORD_BOUNDARY_REGEX)
+      .filter((word) => word.length > 0)
+    if (queryWords.length === 0) {
+      return this.items.map((item) => ({ item, positions: new Set<number>() }))
+    }
+
+    const results: SearchResult<T>[] = []
+
+    for (const item of this.items) {
+      const text = this.selector(item)
+      const tokens = this.tokenize(text)
+
+      if (queryWords.length > 1) {
+        const allPositions = new Set<number>()
+        const allMatch = queryWords.every((word) => {
+          const positions = this.matchAcronym(tokens, word)
+          if (!positions) return false
+          positions.forEach((position) => allPositions.add(position))
+          return true
+        })
+
+        if (allMatch) {
+          results.push({ item, positions: allPositions })
+        }
+      } else {
+        const positions = this.matchAcronym(tokens, queryWords[0])
+        if (positions) {
+          results.push({ item, positions })
+        }
+      }
+    }
+
+    return results
+  }
+
+  private tokenize(text: string): WordToken[] {
+    const tokens: WordToken[] = []
+    let currentIndex = 0
+    const words = text.split(WORD_BOUNDARY_REGEX).filter((word) => word.length > 0)
+
+    for (const word of words) {
+      const index = text.indexOf(word, currentIndex)
+      if (index !== -1) {
+        tokens.push({ word, index })
+        currentIndex = index + word.length
+      }
+    }
+
+    return tokens
+  }
+
+  private matchAcronym(tokens: WordToken[], query: string): Set<number> | null {
+    const lowerWords = tokens.map((token) => token.word.toLowerCase())
+
+    const tryMatch = (wordIndex: number, queryIndex: number, currentPositions: Set<number>): Set<number> | null => {
+      if (queryIndex === query.length) {
+        return currentPositions
+      }
+      if (wordIndex >= lowerWords.length) {
+        return null
+      }
+
+      const word = lowerWords[wordIndex]
+      const token = tokens[wordIndex]
+      const nextPositions = new Set(currentPositions)
+      let matchedInWord = 0
+
+      while (
+        queryIndex + matchedInWord < query.length &&
+        matchedInWord < word.length &&
+        word[matchedInWord] === query[queryIndex + matchedInWord]
+      ) {
+        nextPositions.add(token.index + matchedInWord)
+        matchedInWord++
+      }
+
+      if (matchedInWord > 0) {
+        const continued = tryMatch(wordIndex + 1, queryIndex + matchedInWord, nextPositions)
+        if (continued) {
+          return continued
+        }
+      }
+
+      return tryMatch(wordIndex + 1, queryIndex, currentPositions)
+    }
+
+    return tryMatch(0, 0, new Set<number>())
+  }
+}
+
+export function buildMatchSegments(text: string, matchingPositions?: Set<number>): HighlightSegment[] {
+  if (!matchingPositions || matchingPositions.size === 0) {
+    return [{ text, highlight: false }]
+  }
+
+  const segments: HighlightSegment[] = []
+  let lastIndex = 0
+
+  for (let index = 0; index < text.length; index++) {
+    const isMatch = matchingPositions.has(index)
+    const wasMatch = index > 0 && matchingPositions.has(index - 1)
+
+    if (isMatch !== wasMatch) {
+      if (index > lastIndex) {
+        segments.push({ text: text.slice(lastIndex, index), highlight: wasMatch })
+      }
+      lastIndex = index
+    }
+  }
+
+  if (lastIndex < text.length) {
+    segments.push({ text: text.slice(lastIndex), highlight: matchingPositions.has(text.length - 1) })
+  }
+
+  return segments
+}
+
 export function buildTriggerLabel(
   resolvedName: string | undefined,
   raw: ModelSelection | null,
diff --git a/packages/kilo-vscode/webview-ui/src/styles/chat.css b/packages/kilo-vscode/webview-ui/src/styles/chat.css
index c0485d4ce34..61f94bd2cc5 100644
--- a/packages/kilo-vscode/webview-ui/src/styles/chat.css
+++ b/packages/kilo-vscode/webview-ui/src/styles/chat.css
@@ -578,6 +578,11 @@
   flex: 1;
 }
 
+.model-selector-item-name-highlight {
+  font-weight: 700;
+  color: var(--vscode-textLink-foreground, var(--text-link, var(--text-base)));
+}
+
 .model-selector-tag {
   flex-shrink: 0;
   padding: 1px 5px;

From 1ebb44fcee352fa81066888c3de07c9962413915 Mon Sep 17 00:00:00 2001
From: Bernardo Ferrari <bernaferrari2@gmail.com>
Date: Fri, 27 Feb 2026 19:00:16 -0300
Subject: [PATCH 2/5] refactor model selector filtering and tighten matcher

---
 .../agent-manager/MultiModelSelector.tsx      | 40 ++-------------
 .../src/components/shared/ModelSelector.tsx   | 41 ++-------------
 .../components/shared/model-selector-utils.ts | 50 +++++++++++++++++--
 3 files changed, 52 insertions(+), 79 deletions(-)

diff --git a/packages/kilo-vscode/webview-ui/agent-manager/MultiModelSelector.tsx b/packages/kilo-vscode/webview-ui/agent-manager/MultiModelSelector.tsx
index 8b3be9fa5aa..c1860b8b167 100644
--- a/packages/kilo-vscode/webview-ui/agent-manager/MultiModelSelector.tsx
+++ b/packages/kilo-vscode/webview-ui/agent-manager/MultiModelSelector.tsx
@@ -1,12 +1,12 @@
 import { type Component, createSignal, createMemo, For, Show, onMount } from "solid-js"
 import { Icon } from "@kilocode/kilo-ui/icon"
 import { useProvider } from "../src/context/provider"
-import type { EnrichedModel } from "../src/context/provider"
 import { useLanguage } from "../src/context/language"
 import {
   KILO_GATEWAY_ID,
   providerSortKey,
-  WordBoundaryFzf,
+  filterModels,
+  type FilteredModel,
   buildMatchSegments,
 } from "../src/components/shared/model-selector-utils"
 import {
@@ -27,10 +27,6 @@ interface ModelGroup {
   models: FilteredModel[]
 }
 
-interface FilteredModel extends EnrichedModel {
-  matchingPositions?: Set<number>
-}
-
 const COUNT_OPTIONS = Array.from({ length: MAX_MULTI_VERSIONS }, (_, i) => i + 1)
 
 export const MultiModelSelector: Component<{
@@ -47,37 +43,7 @@ export const MultiModelSelector: Component<{
     return models().filter((m) => m.providerID === KILO_GATEWAY_ID || c.includes(m.providerID))
   })
 
-  const filtered = createMemo<FilteredModel[]>(() => {
-    const query = search().trim()
-    if (!query) {
-      return visibleModels().map((model) => ({ ...model, matchingPositions: new Set<number>() }))
-    }
-
-    const finder = new WordBoundaryFzf(visibleModels(), (model) => model.name)
-    const nameMatches = finder.find(query)
-    const nameMatchesByKey = new Map(
-      nameMatches.map(({ item, positions }) => [`${item.providerID}/${item.id}`, positions] as const),
-    )
-    const normalized = query.toLowerCase()
-
-    return visibleModels().reduce<FilteredModel[]>((result, model) => {
-      const key = `${model.providerID}/${model.id}`
-      const positions = nameMatchesByKey.get(key)
-
-      if (positions) {
-        result.push({ ...model, matchingPositions: positions })
-        return result
-      }
-
-      const fallbackMatch =
-        model.providerName.toLowerCase().includes(normalized) || model.id.toLowerCase().includes(normalized)
-      if (fallbackMatch) {
-        result.push({ ...model, matchingPositions: new Set<number>() })
-      }
-
-      return result
-    }, [])
-  })
+  const filtered = createMemo(() => filterModels(visibleModels(), search()))
 
   const groups = createMemo<ModelGroup[]>(() => {
     const map = new Map<string, ModelGroup>()
diff --git a/packages/kilo-vscode/webview-ui/src/components/shared/ModelSelector.tsx b/packages/kilo-vscode/webview-ui/src/components/shared/ModelSelector.tsx
index 0cf2cae54d8..cb0aa8b6dae 100644
--- a/packages/kilo-vscode/webview-ui/src/components/shared/ModelSelector.tsx
+++ b/packages/kilo-vscode/webview-ui/src/components/shared/ModelSelector.tsx
@@ -10,7 +10,7 @@
 import { Component, createSignal, createMemo, createEffect, For, Show } from "solid-js"
 import { Popover } from "@kilocode/kilo-ui/popover"
 import { Button } from "@kilocode/kilo-ui/button"
-import { useProvider, EnrichedModel } from "../../context/provider"
+import { useProvider } from "../../context/provider"
 import { useSession } from "../../context/session"
 import { useLanguage } from "../../context/language"
 import type { ModelSelection } from "../../types/messages"
@@ -19,7 +19,8 @@ import {
   providerSortKey,
   isFree,
   buildTriggerLabel,
-  WordBoundaryFzf,
+  filterModels,
+  type FilteredModel,
   buildMatchSegments,
 } from "./model-selector-utils"
 
@@ -28,10 +29,6 @@ interface ModelGroup {
   models: FilteredModel[]
 }
 
-interface FilteredModel extends EnrichedModel {
-  matchingPositions?: Set<number>
-}
-
 // ---------------------------------------------------------------------------
 // Reusable base component
 // ---------------------------------------------------------------------------
@@ -70,37 +67,7 @@ export const ModelSelectorBase: Component<ModelSelectorBaseProps> = (props) => {
   const hasProviders = () => visibleModels().length > 0
 
   // Flat filtered list for keyboard navigation
-  const filtered = createMemo<FilteredModel[]>(() => {
-    const query = search().trim()
-    if (!query) {
-      return visibleModels().map((model) => ({ ...model, matchingPositions: new Set<number>() }))
-    }
-
-    const finder = new WordBoundaryFzf(visibleModels(), (model) => model.name)
-    const nameMatches = finder.find(query)
-    const nameMatchesByKey = new Map(
-      nameMatches.map(({ item, positions }) => [`${item.providerID}/${item.id}`, positions] as const),
-    )
-    const normalized = query.toLowerCase()
-
-    return visibleModels().reduce<FilteredModel[]>((result, model) => {
-      const key = `${model.providerID}/${model.id}`
-      const positions = nameMatchesByKey.get(key)
-
-      if (positions) {
-        result.push({ ...model, matchingPositions: positions })
-        return result
-      }
-
-      const fallbackMatch =
-        model.providerName.toLowerCase().includes(normalized) || model.id.toLowerCase().includes(normalized)
-      if (fallbackMatch) {
-        result.push({ ...model, matchingPositions: new Set<number>() })
-      }
-
-      return result
-    }, [])
-  })
+  const filtered = createMemo(() => filterModels(visibleModels(), search()))
 
   // Grouped for rendering
   const groups = createMemo<ModelGroup[]>(() => {
diff --git a/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts b/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
index 6e4c0b1170e..fbeaff0b584 100644
--- a/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
+++ b/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
@@ -22,6 +22,10 @@ export interface HighlightSegment {
   highlight: boolean
 }
 
+export interface FilteredModel extends EnrichedModel {
+  matchingPositions?: Set<number>
+}
+
 export function providerSortKey(providerID: string, order = PROVIDER_ORDER): number {
   const idx = order.indexOf(providerID.toLowerCase())
   return idx >= 0 ? idx : order.length
@@ -31,6 +35,38 @@ export function isFree(model: Pick<EnrichedModel, "inputPrice">): boolean {
   return model.inputPrice === 0
 }
 
+export function filterModels(models: EnrichedModel[], query: string): FilteredModel[] {
+  const text = query.trim()
+  if (!text) {
+    return models as FilteredModel[]
+  }
+
+  const finder = new WordBoundaryFzf(models, (model) => model.name)
+  const nameMatches = finder.find(text)
+  const nameMatchesByKey = new Map(
+    nameMatches.map(({ item, positions }) => [`${item.providerID}/${item.id}`, positions] as const),
+  )
+  const normalized = text.toLowerCase()
+
+  return models.reduce<FilteredModel[]>((result, model) => {
+    const key = `${model.providerID}/${model.id}`
+    const positions = nameMatchesByKey.get(key)
+
+    if (positions) {
+      result.push({ ...model, matchingPositions: positions })
+      return result
+    }
+
+    const fallbackMatch =
+      model.providerName.toLowerCase().includes(normalized) || model.id.toLowerCase().includes(normalized)
+    if (fallbackMatch) {
+      result.push(model)
+    }
+
+    return result
+  }, [])
+}
+
 export class WordBoundaryFzf<T> {
   constructor(
     private readonly items: T[],
@@ -87,10 +123,11 @@ export class WordBoundaryFzf<T> {
 
     for (const word of words) {
       const index = text.indexOf(word, currentIndex)
-      if (index !== -1) {
-        tokens.push({ word, index })
-        currentIndex = index + word.length
+      if (index === -1) {
+        throw new Error(`Failed to tokenize "${text}" at "${word}" from index ${currentIndex}`)
       }
+      tokens.push({ word, index })
+      currentIndex = index + word.length
     }
 
     return tokens
@@ -109,7 +146,7 @@ export class WordBoundaryFzf<T> {
 
       const word = lowerWords[wordIndex]
       const token = tokens[wordIndex]
-      const nextPositions = new Set(currentPositions)
+      let nextPositions: Set<number> | undefined
       let matchedInWord = 0
 
       while (
@@ -117,11 +154,14 @@ export class WordBoundaryFzf<T> {
         matchedInWord < word.length &&
         word[matchedInWord] === query[queryIndex + matchedInWord]
       ) {
+        if (!nextPositions) {
+          nextPositions = new Set(currentPositions)
+        }
         nextPositions.add(token.index + matchedInWord)
         matchedInWord++
       }
 
-      if (matchedInWord > 0) {
+      if (matchedInWord > 0 && nextPositions) {
         const continued = tryMatch(wordIndex + 1, queryIndex + matchedInWord, nextPositions)
         if (continued) {
           return continued

From 36a86ee63821a9081d1254e38b032fc84ff62d36 Mon Sep 17 00:00:00 2001
From: Bernardo Ferrari <bernaferrari2@gmail.com>
Date: Fri, 27 Feb 2026 19:58:38 -0300
Subject: [PATCH 3/5] fix separator-only fuzzy query behavior

---
 packages/kilo-vscode/tests/unit/model-selector-utils.test.ts | 5 +++++
 .../webview-ui/src/components/shared/model-selector-utils.ts | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts b/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts
index 677993fa0af..298a714b52a 100644
--- a/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts
+++ b/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts
@@ -129,6 +129,11 @@ describe("WordBoundaryFzf", () => {
     expect(result[0].item).toBe("gpt-5")
   })
 
+  it("does not treat separator-only queries as empty search", () => {
+    const result = finder.find("-")
+    expect(result).toHaveLength(0)
+  })
+
   it("requires matches to start at word boundaries", () => {
     const result = finder.find("aude")
     expect(result).toHaveLength(0)
diff --git a/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts b/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
index fbeaff0b584..2c3a28f5069 100644
--- a/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
+++ b/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
@@ -84,7 +84,7 @@ export class WordBoundaryFzf<T> {
       .split(WORD_BOUNDARY_REGEX)
       .filter((word) => word.length > 0)
     if (queryWords.length === 0) {
-      return this.items.map((item) => ({ item, positions: new Set<number>() }))
+      return []
     }
 
     const results: SearchResult<T>[] = []

From df248b7d8461edb9725b0b5c3c681cffddae4cb2 Mon Sep 17 00:00:00 2001
From: Bernardo Ferrari <bernaferrari2@gmail.com>
Date: Fri, 27 Feb 2026 20:08:19 -0300
Subject: [PATCH 4/5] fix multi-word fuzzy token reuse

---
 .../tests/unit/model-selector-utils.test.ts   | 12 +++++
 .../components/shared/model-selector-utils.ts | 47 ++++++++++++++-----
 2 files changed, 48 insertions(+), 11 deletions(-)

diff --git a/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts b/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts
index 298a714b52a..fa9917abe4e 100644
--- a/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts
+++ b/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts
@@ -143,6 +143,18 @@ describe("WordBoundaryFzf", () => {
     const result = finder.find("claude flash")
     expect(result).toHaveLength(0)
   })
+
+  it("does not allow multi-word queries to reuse the same token", () => {
+    const result = finder.find("so so")
+    expect(result).toHaveLength(0)
+  })
+
+  it("allows repeated multi-word queries when distinct tokens exist", () => {
+    const repeatedFinder = new WordBoundaryFzf(["So So"], (item) => item)
+    const result = repeatedFinder.find("so so")
+    expect(result).toHaveLength(1)
+    expect(result[0].item).toBe("So So")
+  })
 })
 
 describe("buildMatchSegments", () => {
diff --git a/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts b/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
index 2c3a28f5069..35cd911b958 100644
--- a/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
+++ b/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
@@ -12,6 +12,11 @@ interface WordToken {
   index: number
 }
 
+interface MatchResult {
+  positions: Set<number>
+  nextWordIndex: number
+}
+
 export interface SearchResult<T> {
   item: T
   positions: Set<number>
@@ -94,11 +99,13 @@ export class WordBoundaryFzf<T> {
       const tokens = this.tokenize(text)
 
       if (queryWords.length > 1) {
+        let startWordIndex = 0
         const allPositions = new Set<number>()
         const allMatch = queryWords.every((word) => {
-          const positions = this.matchAcronym(tokens, word)
-          if (!positions) return false
-          positions.forEach((position) => allPositions.add(position))
+          const match = this.matchAcronym(tokens, word, startWordIndex)
+          if (!match) return false
+          startWordIndex = match.nextWordIndex
+          match.positions.forEach((position) => allPositions.add(position))
           return true
         })
 
@@ -106,9 +113,9 @@ export class WordBoundaryFzf<T> {
           results.push({ item, positions: allPositions })
         }
       } else {
-        const positions = this.matchAcronym(tokens, queryWords[0])
-        if (positions) {
-          results.push({ item, positions })
+        const match = this.matchAcronym(tokens, queryWords[0], 0)
+        if (match) {
+          results.push({ item, positions: match.positions })
         }
       }
     }
@@ -133,17 +140,30 @@ export class WordBoundaryFzf<T> {
     return tokens
   }
 
-  private matchAcronym(tokens: WordToken[], query: string): Set<number> | null {
+  private matchAcronym(tokens: WordToken[], query: string, startWordIndex: number): MatchResult | null {
     const lowerWords = tokens.map((token) => token.word.toLowerCase())
+    const failed = new Set<string>()
 
-    const tryMatch = (wordIndex: number, queryIndex: number, currentPositions: Set<number>): Set<number> | null => {
+    const tryMatch = (
+      wordIndex: number,
+      queryIndex: number,
+      currentPositions: Set<number>,
+    ): MatchResult | null => {
       if (queryIndex === query.length) {
-        return currentPositions
+        return {
+          positions: currentPositions,
+          nextWordIndex: wordIndex,
+        }
       }
       if (wordIndex >= lowerWords.length) {
         return null
       }
 
+      const state = `${wordIndex}:${queryIndex}`
+      if (failed.has(state)) {
+        return null
+      }
+
       const word = lowerWords[wordIndex]
       const token = tokens[wordIndex]
       let nextPositions: Set<number> | undefined
@@ -168,10 +188,15 @@ export class WordBoundaryFzf<T> {
         }
       }
 
-      return tryMatch(wordIndex + 1, queryIndex, currentPositions)
+      const skipped = tryMatch(wordIndex + 1, queryIndex, currentPositions)
+      if (skipped) {
+        return skipped
+      }
+      failed.add(state)
+      return null
     }
 
-    return tryMatch(0, 0, new Set<number>())
+    return tryMatch(startWordIndex, 0, new Set<number>())
   }
 }
 

From f819d7b344402d58b7f920415ed7d9fda5dfe3da Mon Sep 17 00:00:00 2001
From: Bernardo Ferrari <bernaferrari2@gmail.com>
Date: Sat, 28 Feb 2026 00:01:53 -0300
Subject: [PATCH 5/5] refactor model selector filtering and preserve identity

---
 .../tests/unit/model-selector-utils.test.ts   | 65 +++++++++++++++++++
 .../agent-manager/MultiModelSelector.tsx      | 14 ++--
 .../src/components/shared/ModelSelector.tsx   | 20 +++---
 .../components/shared/model-selector-utils.ts | 56 +++++++++++-----
 4 files changed, 125 insertions(+), 30 deletions(-)

diff --git a/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts b/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts
index fa9917abe4e..b717dfeedc7 100644
--- a/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts
+++ b/packages/kilo-vscode/tests/unit/model-selector-utils.test.ts
@@ -3,11 +3,13 @@ import {
   providerSortKey,
   isFree,
   buildTriggerLabel,
+  filterModels,
   WordBoundaryFzf,
   buildMatchSegments,
   KILO_GATEWAY_ID,
   PROVIDER_ORDER,
 } from "../../webview-ui/src/components/shared/model-selector-utils"
+import type { EnrichedModel } from "../../webview-ui/src/context/provider"
 
 const labels = { select: "Select model", noProviders: "No providers", notSet: "Not set" }
 
@@ -155,6 +157,69 @@ describe("WordBoundaryFzf", () => {
     expect(result).toHaveLength(1)
     expect(result[0].item).toBe("So So")
   })
+
+  it("requires multi-word query terms to appear in token order (documented behavior)", () => {
+    const result = finder.find("sonnet claude")
+    expect(result).toHaveLength(0)
+  })
+})
+
+describe("filterModels", () => {
+  const model = (value: Partial<EnrichedModel>) =>
+    ({
+      id: "model",
+      name: "Model",
+      providerID: "provider",
+      providerName: "Provider",
+      ...value,
+    }) as EnrichedModel
+
+  const items = [
+    model({ providerID: "openai", providerName: "OpenAI", id: "gpt-5", name: "GPT Five" }),
+    model({ providerID: "anthropic", providerName: "Anthropic", id: "claude-3-5-sonnet", name: "Claude Sonnet" }),
+    model({ providerID: "google", providerName: "Google", id: "gemini-2.5-pro", name: "Gemini Flash" }),
+  ]
+
+  it("returns all models unchanged for empty query", () => {
+    const result = filterModels(items, "")
+    expect(result.models).toBe(items)
+    expect(result.positions.size).toBe(0)
+  })
+
+  it("adds matchingPositions for name matches", () => {
+    const result = filterModels(items, "clso")
+    expect(result.models).toHaveLength(1)
+    expect(result.models[0].id).toBe("claude-3-5-sonnet")
+    expect(Array.from(result.positions.get("anthropic/claude-3-5-sonnet") ?? new Set()).sort((a, b) => a - b)).toEqual([
+      0,
+      1,
+      7,
+      8,
+    ])
+  })
+
+  it("uses fallback providerName and id matches without matchingPositions", () => {
+    const byProvider = filterModels(items, "google")
+    expect(byProvider.models).toHaveLength(1)
+    expect(byProvider.models[0].id).toBe("gemini-2.5-pro")
+    expect(byProvider.positions.has("google/gemini-2.5-pro")).toBe(false)
+
+    const byID = filterModels(items, "3-5")
+    expect(byID.models).toHaveLength(1)
+    expect(byID.models[0].id).toBe("claude-3-5-sonnet")
+    expect(byID.positions.has("anthropic/claude-3-5-sonnet")).toBe(false)
+  })
+
+  it("excludes models that match neither name nor provider nor id", () => {
+    const result = filterModels(items, "zzzz")
+    expect(result.models).toHaveLength(0)
+    expect(result.positions.size).toBe(0)
+  })
+
+  it("preserves input ordering", () => {
+    const result = filterModels(items, "5")
+    expect(result.models.map((item) => item.id)).toEqual(["gpt-5", "claude-3-5-sonnet", "gemini-2.5-pro"])
+  })
 })
 
 describe("buildMatchSegments", () => {
diff --git a/packages/kilo-vscode/webview-ui/agent-manager/MultiModelSelector.tsx b/packages/kilo-vscode/webview-ui/agent-manager/MultiModelSelector.tsx
index c1860b8b167..7b8b39695fc 100644
--- a/packages/kilo-vscode/webview-ui/agent-manager/MultiModelSelector.tsx
+++ b/packages/kilo-vscode/webview-ui/agent-manager/MultiModelSelector.tsx
@@ -1,12 +1,14 @@
 import { type Component, createSignal, createMemo, For, Show, onMount } from "solid-js"
 import { Icon } from "@kilocode/kilo-ui/icon"
 import { useProvider } from "../src/context/provider"
+import type { EnrichedModel } from "../src/context/provider"
 import { useLanguage } from "../src/context/language"
 import {
   KILO_GATEWAY_ID,
   providerSortKey,
   filterModels,
-  type FilteredModel,
+  modelKey,
+  WordBoundaryFzf,
   buildMatchSegments,
 } from "../src/components/shared/model-selector-utils"
 import {
@@ -24,7 +26,7 @@ export { MAX_MULTI_VERSIONS, totalAllocations, allocationsToArray } from "./mult
 
 interface ModelGroup {
   providerName: string
-  models: FilteredModel[]
+  models: EnrichedModel[]
 }
 
 const COUNT_OPTIONS = Array.from({ length: MAX_MULTI_VERSIONS }, (_, i) => i + 1)
@@ -43,11 +45,13 @@ export const MultiModelSelector: Component<{
     return models().filter((m) => m.providerID === KILO_GATEWAY_ID || c.includes(m.providerID))
   })
 
-  const filtered = createMemo(() => filterModels(visibleModels(), search()))
+  const finder = createMemo(() => new WordBoundaryFzf(visibleModels(), (model) => model.name))
+
+  const filtered = createMemo(() => filterModels(visibleModels(), search(), finder()))
 
   const groups = createMemo<ModelGroup[]>(() => {
     const map = new Map<string, ModelGroup>()
-    for (const m of filtered()) {
+    for (const m of filtered().models) {
       let group = map.get(m.providerID)
       if (!group) {
         group = { providerName: m.providerName, models: [] }
@@ -105,7 +109,7 @@ export const MultiModelSelector: Component<{
                           }
                         />
                         <span class="am-mm-item-name">
-                          <For each={buildMatchSegments(model.name, model.matchingPositions)}>
+                          <For each={buildMatchSegments(model.name, filtered().positions.get(modelKey(model)))}>
                             {(segment) => (
                               <span classList={{ "am-mm-item-name-highlight": segment.highlight }}>{segment.text}</span>
                             )}
diff --git a/packages/kilo-vscode/webview-ui/src/components/shared/ModelSelector.tsx b/packages/kilo-vscode/webview-ui/src/components/shared/ModelSelector.tsx
index cb0aa8b6dae..a8c6bf72ca5 100644
--- a/packages/kilo-vscode/webview-ui/src/components/shared/ModelSelector.tsx
+++ b/packages/kilo-vscode/webview-ui/src/components/shared/ModelSelector.tsx
@@ -11,6 +11,7 @@ import { Component, createSignal, createMemo, createEffect, For, Show } from "so
 import { Popover } from "@kilocode/kilo-ui/popover"
 import { Button } from "@kilocode/kilo-ui/button"
 import { useProvider } from "../../context/provider"
+import type { EnrichedModel } from "../../context/provider"
 import { useSession } from "../../context/session"
 import { useLanguage } from "../../context/language"
 import type { ModelSelection } from "../../types/messages"
@@ -20,13 +21,14 @@ import {
   isFree,
   buildTriggerLabel,
   filterModels,
-  type FilteredModel,
+  modelKey,
+  WordBoundaryFzf,
   buildMatchSegments,
 } from "./model-selector-utils"
 
 interface ModelGroup {
   providerName: string
-  models: FilteredModel[]
+  models: EnrichedModel[]
 }
 
 // ---------------------------------------------------------------------------
@@ -66,13 +68,15 @@ export const ModelSelectorBase: Component<ModelSelectorBaseProps> = (props) => {
 
   const hasProviders = () => visibleModels().length > 0
 
+  const finder = createMemo(() => new WordBoundaryFzf(visibleModels(), (model) => model.name))
+
   // Flat filtered list for keyboard navigation
-  const filtered = createMemo(() => filterModels(visibleModels(), search()))
+  const filtered = createMemo(() => filterModels(visibleModels(), search(), finder()))
 
   // Grouped for rendering
   const groups = createMemo<ModelGroup[]>(() => {
     const map = new Map<string, ModelGroup>()
-    for (const m of filtered()) {
+    for (const m of filtered().models) {
       let group = map.get(m.providerID)
       if (!group) {
         group = { providerName: m.providerName, models: [] }
@@ -105,7 +109,7 @@ export const ModelSelectorBase: Component<ModelSelectorBaseProps> = (props) => {
     }
   })
 
-  function pick(model: FilteredModel) {
+  function pick(model: EnrichedModel) {
     props.onSelect(model.providerID, model.id)
     setOpen(false)
   }
@@ -158,13 +162,13 @@ export const ModelSelectorBase: Component<ModelSelectorBaseProps> = (props) => {
     })
   }
 
-  function isSelected(model: FilteredModel): boolean {
+  function isSelected(model: EnrichedModel): boolean {
     const sel = selectedModel()
     return sel !== undefined && sel.providerID === model.providerID && sel.id === model.id
   }
 
   // Track flat index across groups for active highlighting
-  function flatIndex(model: FilteredModel): number {
+  function flatIndex(model: EnrichedModel): number {
     return flatFiltered().indexOf(model) + clearOffset()
   }
 
@@ -249,7 +253,7 @@ export const ModelSelectorBase: Component<ModelSelectorBaseProps> = (props) => {
                       onMouseEnter={() => setActiveIndex(flatIndex(model))}
                     >
                       <span class="model-selector-item-name">
-                        <For each={buildMatchSegments(model.name, model.matchingPositions)}>
+                        <For each={buildMatchSegments(model.name, filtered().positions.get(modelKey(model)))}>
                           {(segment) => (
                             <span classList={{ "model-selector-item-name-highlight": segment.highlight }}>
                               {segment.text}
diff --git a/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts b/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
index 35cd911b958..bfada72b212 100644
--- a/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
+++ b/packages/kilo-vscode/webview-ui/src/components/shared/model-selector-utils.ts
@@ -27,8 +27,13 @@ export interface HighlightSegment {
   highlight: boolean
 }
 
-export interface FilteredModel extends EnrichedModel {
-  matchingPositions?: Set<number>
+export interface FilterResult {
+  models: EnrichedModel[]
+  positions: Map<string, Set<number>>
+}
+
+export function modelKey(model: Pick<EnrichedModel, "providerID" | "id">): string {
+  return `${model.providerID}/${model.id}`
 }
 
 export function providerSortKey(providerID: string, order = PROVIDER_ORDER): number {
@@ -40,25 +45,31 @@ export function isFree(model: Pick<EnrichedModel, "inputPrice">): boolean {
   return model.inputPrice === 0
 }
 
-export function filterModels(models: EnrichedModel[], query: string): FilteredModel[] {
+export function filterModels(
+  models: EnrichedModel[],
+  query: string,
+  finder = new WordBoundaryFzf(models, (model) => model.name),
+): FilterResult {
   const text = query.trim()
   if (!text) {
-    return models as FilteredModel[]
+    return {
+      models,
+      positions: new Map<string, Set<number>>(),
+    }
   }
 
-  const finder = new WordBoundaryFzf(models, (model) => model.name)
   const nameMatches = finder.find(text)
-  const nameMatchesByKey = new Map(
-    nameMatches.map(({ item, positions }) => [`${item.providerID}/${item.id}`, positions] as const),
-  )
+  const nameMatchesByKey = new Map(nameMatches.map(({ item, positions }) => [modelKey(item), positions] as const))
   const normalized = text.toLowerCase()
+  const positions = new Map<string, Set<number>>()
 
-  return models.reduce<FilteredModel[]>((result, model) => {
-    const key = `${model.providerID}/${model.id}`
-    const positions = nameMatchesByKey.get(key)
+  const filtered = models.reduce<EnrichedModel[]>((result, model) => {
+    const key = modelKey(model)
+    const match = nameMatchesByKey.get(key)
 
-    if (positions) {
-      result.push({ ...model, matchingPositions: positions })
+    if (match) {
+      positions.set(key, match)
+      result.push(model)
       return result
     }
 
@@ -70,6 +81,11 @@ export function filterModels(models: EnrichedModel[], query: string): FilteredMo
 
     return result
   }, [])
+
+  return {
+    models: filtered,
+    positions,
+  }
 }
 
 export class WordBoundaryFzf<T> {
@@ -97,12 +113,14 @@ export class WordBoundaryFzf<T> {
     for (const item of this.items) {
       const text = this.selector(item)
       const tokens = this.tokenize(text)
+      const lowerWords = tokens.map((token) => token.word.toLowerCase())
 
       if (queryWords.length > 1) {
+        // Multi-word queries must match in order and consume distinct tokens.
         let startWordIndex = 0
         const allPositions = new Set<number>()
         const allMatch = queryWords.every((word) => {
-          const match = this.matchAcronym(tokens, word, startWordIndex)
+          const match = this.matchAcronym(tokens, lowerWords, word, startWordIndex)
           if (!match) return false
           startWordIndex = match.nextWordIndex
           match.positions.forEach((position) => allPositions.add(position))
@@ -113,7 +131,7 @@ export class WordBoundaryFzf<T> {
           results.push({ item, positions: allPositions })
         }
       } else {
-        const match = this.matchAcronym(tokens, queryWords[0], 0)
+        const match = this.matchAcronym(tokens, lowerWords, queryWords[0], 0)
         if (match) {
           results.push({ item, positions: match.positions })
         }
@@ -140,8 +158,12 @@ export class WordBoundaryFzf<T> {
     return tokens
   }
 
-  private matchAcronym(tokens: WordToken[], query: string, startWordIndex: number): MatchResult | null {
-    const lowerWords = tokens.map((token) => token.word.toLowerCase())
+  private matchAcronym(
+    tokens: WordToken[],
+    lowerWords: string[],
+    query: string,
+    startWordIndex: number,
+  ): MatchResult | null {
     const failed = new Set<string>()
 
     const tryMatch = (