diff --git a/lua/modules/navigation.lua b/lua/modules/navigation.lua
index e291a6f..66d5d28 100644
--- a/lua/modules/navigation.lua
+++ b/lua/modules/navigation.lua
@@ -1,2 +1,13 @@
-require('plugins.finder')
 require('plugins.filetree')
+require('plugins.finder').setup({
+  exclude_patterns = { 'node_modules', 'dist', 'build', '.git', '.cache', '.turbo', '*-lock.json' },
+  use_disk_cache = true, -- optional
+})
+
+vim.keymap.set('n', '<leader>f', function()
+  require('plugins.finder').files()
+end)
+
+vim.keymap.set('n', '<leader>g', function()
+  require('plugins.finder').grep()
+end)
diff --git a/lua/plugins/finder.lua b/lua/plugins/finder.lua
index 1c12870..6fdb487 100644
--- a/lua/plugins/finder.lua
+++ b/lua/plugins/finder.lua
@@ -1,323 +1,947 @@
--- Minimal fuzzy finder + content search for Neovim 0.11+
--- Optional: `fdfind` or `fd` for file listing, and `rg` (ripgrep) for text search.
+-- finder.lua — Minimal, hardened async fuzzy finder + grep for Neovim ≥ 0.11
 
-local Fuzzy = {}
+local M = {}
 
---------------------------------------------------------------------
--- 🧩 Helpers
---------------------------------------------------------------------
+---------------------------------------------------------------------
+-- Config
+---------------------------------------------------------------------
+M.config = {
+  file_cmd = nil, -- "fd" | "fdfind" | nil (auto)
+  grep_cmd = 'rg', -- ripgrep binary
+  page_size = 60, -- soft cap; real viewport height is measured
+  debounce_ms = 80,
+  instant_items = 1500, -- <= this count + cached => 0 ms debounce
+  fast_items = 4000, -- <= this count => debounce_ms/2
+  cache_ttl_sec = 20,
+  max_items = 5000, -- safety cap for massive outputs
+  debug = false,
 
--- Collect all files (try fdfind/fd first, then globpath)
-local function get_file_list()
-  local handle = io.popen('fdfind --type f 2>/dev/null || fd --type f 2>/dev/null')
-  if handle then
-    local result = handle:read('*a')
-    handle:close()
-    if result and result ~= '' then
-      return vim.split(result, '\n', { trimempty = true })
-    end
-  end
-  return vim.fn.globpath('.', '**/*', false, true)
-end
+  -- Exclusion controls (added to tool flags and used in glob fallback)
+  exclude_patterns = { 'node_modules', 'dist', 'build', '.git' },
 
--- Create floating input + result windows
-local function open_float(prompt)
-  local input_buf = vim.api.nvim_create_buf(false, true)
-  local result_buf = vim.api.nvim_create_buf(false, true)
+  -- Optional on-disk filelist cache at $ROOT/.devflow/finder_cache.json
+  use_disk_cache = false,
+}
 
-  -- mark both buffers as scratch/unlisted
-  for _, b in ipairs({ input_buf, result_buf }) do
-    vim.bo[b].bufhidden = 'wipe'
-    vim.bo[b].buflisted = false
-    vim.bo[b].swapfile = false
-  end
-  vim.bo[input_buf].buftype = 'prompt'
-  vim.bo[result_buf].buftype = 'nofile'
+---------------------------------------------------------------------
+-- State
+---------------------------------------------------------------------
+local S = {
+  active = false,
+  mode = nil, -- "files" | "grep"
+  root = nil,
 
-  local width = math.floor(vim.o.columns * 0.7)
-  local height = 20
-  local row = math.floor((vim.o.lines - height) / 2)
-  local col = math.floor((vim.o.columns - width) / 2)
+  cache = {},
+  timer = nil,
+  ns = vim.api.nvim_create_namespace('finder_ns'),
+  aug = nil,
+  gen = 0, -- session generation id
 
-  local input_win = vim.api.nvim_open_win(input_buf, true, {
-    relative = 'editor',
-    row = row,
-    col = col,
-    width = width,
-    height = 1,
-    style = 'minimal',
-    border = 'rounded',
-  })
-  vim.fn.prompt_setprompt(input_buf, prompt)
+  -- async jobs
+  job_files = nil,
+  job_rg = nil,
 
-  local result_win = vim.api.nvim_open_win(result_buf, false, {
-    relative = 'editor',
-    row = row + 2,
-    col = col,
-    width = width,
-    height = height - 2,
-    style = 'minimal',
-    border = 'single',
-  })
+  -- UI
+  win_inp = nil,
+  buf_inp = nil,
+  win_res = nil,
+  buf_res = nil,
 
-  return input_buf, result_buf, input_win, result_win
-end
+  -- Data
+  query = '',
+  items = {}, -- full set (files or grep lines)
+  filtered = {}, -- current view
+  positions = {}, -- positions[i] = { {scol, ecol}, ... } for filtered[i]
+  select = 1, -- absolute index in filtered (1-based)
+  scroll = 0, -- top index (0-based)
+  user_moved = false, -- has user navigated during this session?
 
---------------------------------------------------------------------
--- 🔵 Highlight current selection
---------------------------------------------------------------------
-function Fuzzy:highlight_selection()
-  if not self.result_buf then
+  -- meta
+  files_cached = false,
+}
+
+---------------------------------------------------------------------
+-- Utils
+---------------------------------------------------------------------
+local function L(msg, data)
+  if not M.config.debug then
     return
   end
-  if not self.ns_id then
-    self.ns_id = vim.api.nvim_create_namespace('FuzzyHighlight')
-  end
-  vim.api.nvim_buf_clear_namespace(self.result_buf, self.ns_id, 0, -1)
-  if self.matches and self.matches[self.cursor] then
-    local rel_cursor = self.cursor - (self.scroll or 0)
-    if rel_cursor >= 1 and rel_cursor <= self.page_size then
-      vim.api.nvim_buf_set_extmark(self.result_buf, self.ns_id, rel_cursor - 1, 0, {
-        end_line = rel_cursor,
-        hl_group = 'Visual',
-        hl_eol = true,
-      })
-    end
+  local s = '[finder] ' .. msg
+  if data ~= nil then
+    s = s .. ' ' .. vim.inspect(data)
   end
+  vim.schedule(function()
+    pcall(vim.notify, s)
+  end)
 end
 
---------------------------------------------------------------------
--- 🔴 Close all floating windows
---------------------------------------------------------------------
-function Fuzzy.close()
-  local wins = { Fuzzy.input_win, Fuzzy.result_win }
-  for _, win in ipairs(wins) do
-    if win and vim.api.nvim_win_is_valid(win) then
-      vim.api.nvim_win_close(win, true)
-    end
-  end
-  Fuzzy.active = false
+local function now_sec()
+  return vim.loop.now() / 1000
+end
+local function clamp(v, lo, hi)
+  return (v < lo) and lo or ((v > hi) and hi or v)
+end
+local function cmd_exists(bin)
+  return vim.fn.executable(bin) == 1
 end
 
---------------------------------------------------------------------
--- 🟢 File finder
---------------------------------------------------------------------
-function Fuzzy.open()
-  if Fuzzy.active then
-    Fuzzy.close()
+-- single reusable timer to avoid churn; caller controls ms
+local function debounce(fn, ms)
+  if not S.timer then
+    S.timer = vim.loop.new_timer()
   end
-  Fuzzy.active = true
+  S.timer:stop()
+  S.timer:start(ms, 0, function()
+    S.timer:stop()
+    vim.schedule(fn)
+  end)
+end
 
-  Fuzzy.files = get_file_list()
-  Fuzzy.matches = Fuzzy.files
-  Fuzzy.cursor = 1
-  Fuzzy.scroll = 0
-  Fuzzy.page_size = 50
-
-  Fuzzy.input_buf, Fuzzy.result_buf, Fuzzy.input_win, Fuzzy.result_win = open_float('Search: ')
-
-  local function render_results()
-    local total = #Fuzzy.matches
-    if total == 0 then
-      vim.api.nvim_buf_set_lines(Fuzzy.result_buf, 0, -1, false, { '-- no matches --' })
-      return
+local function read_gitignore(root)
+  local p = root .. '/.gitignore'
+  local f = io.open(p, 'r')
+  if not f then
+    return {}
+  end
+  local lines = {}
+  for line in f:lines() do
+    local l = vim.trim(line)
+    if #l > 0 and not l:match('^#') and not l:match('^!') then
+      l = l:gsub('/+$', '')
+      table.insert(lines, l)
     end
-    local start_idx = Fuzzy.scroll + 1
-    local end_idx = math.min(start_idx + Fuzzy.page_size - 1, total)
-    local display = {}
+  end
+  f:close()
+  return lines
+end
+
+local function ensure_cache_dir(root)
+  local dir = root .. '/.devflow'
+  local ok = vim.loop.fs_stat(dir)
+  if not ok then
+    pcall(vim.loop.fs_mkdir, dir, 448)
+  end -- 0700
+  return dir
+end
+
+local function load_cache(root)
+  if not M.config.use_disk_cache then
+    return nil
+  end
+  local file = ensure_cache_dir(root) .. '/finder_cache.json'
+  local f = io.open(file, 'r')
+  if not f then
+    return nil
+  end
+  local content = f:read('*a')
+  f:close()
+  local ok, data = pcall(vim.json.decode, content)
+  if not ok or type(data) ~= 'table' or type(data.files) ~= 'table' then
+    return nil
+  end
+  if now_sec() - (data.timestamp or 0) > M.config.cache_ttl_sec then
+    pcall(os.remove, file) -- proactively clear stale
+    return nil
+  end
+  return data.files
+end
+
+local function save_cache(root, files)
+  if not M.config.use_disk_cache then
+    return
+  end
+  local file = ensure_cache_dir(root) .. '/finder_cache.json'
+  local payload = { timestamp = now_sec(), files = files }
+  local ok, json = pcall(vim.json.encode, payload)
+  if not ok then
+    return
+  end
+  local f = io.open(file, 'w')
+  if not f then
+    return
+  end
+  f:write(json)
+  f:close()
+end
+
+local function project_root()
+  local obj = vim.system({ 'git', 'rev-parse', '--show-toplevel' }, { text = true }):wait()
+  if obj.code == 0 and obj.stdout and obj.stdout ~= '' then
+    return vim.trim(obj.stdout)
+  end
+  return vim.fn.getcwd(0, 0)
+end
+
+-- Robust relative-to-root
+local function normalize_rel(root, p)
+  if not p or p == '' then
+    return ''
+  end
+  local abs = vim.fs.normalize(vim.fn.fnamemodify(p, ':p'))
+  local root_norm = vim.fs.normalize(root)
+  if abs == root_norm then
+    return ''
+  end
+  if abs:find(root_norm, 1, true) == 1 then
+    local ch = abs:sub(#root_norm + 1, #root_norm + 1)
+    if ch == '/' or ch == '\\' then
+      return abs:sub(#root_norm + 2)
+    end
+  end
+  -- strip leading ./ as last resort
+  return (p:gsub('^%./', ''))
+end
+
+local function to_abs_path(root, rel)
+  if not rel or rel == '' then
+    return root
+  end
+  return vim.fs.normalize(root .. '/' .. rel)
+end
+
+local function to_display_path(abs)
+  -- relative to current working dir if possible, else absolute
+  return vim.fn.fnamemodify(abs, ':.')
+end
+
+local function page_rows()
+  if S.win_res and vim.api.nvim_win_is_valid(S.win_res) then
+    return math.max(1, vim.api.nvim_win_get_height(S.win_res))
+  end
+  return math.max(1, math.min(M.config.page_size, vim.o.lines))
+end
+
+local function effective_debounce_ms()
+  if S.mode == 'files' then
+    local n = #S.items
+    if S.files_cached and n > 0 and n <= (M.config.instant_items or 1500) then
+      return 0
+    elseif n > 0 and n <= (M.config.fast_items or 4000) then
+      return math.max(0, math.floor((M.config.debounce_ms or 80) / 2))
+    end
+  end
+  return M.config.debounce_ms or 80
+end
+
+---------------------------------------------------------------------
+-- Render helpers
+---------------------------------------------------------------------
+local function ensure_visible()
+  local page = page_rows()
+  local sel = clamp(S.select, 1, #S.filtered)
+  local top = S.scroll + 1
+  local bot = S.scroll + page
+  if sel < top then
+    S.scroll = sel - 1
+  elseif sel > bot then
+    S.scroll = sel - page
+  end
+  S.scroll = clamp(S.scroll, 0, math.max(#S.filtered - page, 0))
+end
+
+---------------------------------------------------------------------
+-- Render
+---------------------------------------------------------------------
+local function render()
+  if not (S.buf_res and vim.api.nvim_buf_is_valid(S.buf_res)) then
+    return
+  end
+
+  ensure_visible()
+
+  local total = #S.filtered
+  local view = {}
+  if total == 0 then
+    view = { '-- no matches --' }
+  else
+    local start_idx = S.scroll + 1
+    local end_idx = math.min(start_idx + page_rows() - 1, total)
     for i = start_idx, end_idx do
-      display[#display + 1] = Fuzzy.matches[i]
+      local line = S.filtered[i]
+      view[#view + 1] = tostring(line or '')
     end
-    vim.api.nvim_buf_set_lines(Fuzzy.result_buf, 0, -1, false, display)
-    Fuzzy:highlight_selection()
   end
 
-  local function update_results(text)
-    if text == '' then
-      Fuzzy.matches = Fuzzy.files
-    else
-      Fuzzy.matches = vim.fn.matchfuzzy(Fuzzy.files, text)
-    end
-    Fuzzy.cursor, Fuzzy.scroll = 1, 0
-    render_results()
-  end
+  vim.bo[S.buf_res].modifiable = true
+  vim.bo[S.buf_res].readonly = false
+  vim.api.nvim_buf_set_lines(S.buf_res, 0, -1, false, view)
+  vim.api.nvim_buf_clear_namespace(S.buf_res, S.ns, 0, -1)
 
-  vim.api.nvim_create_autocmd({ 'TextChangedI', 'TextChangedP' }, {
-    buffer = Fuzzy.input_buf,
-    callback = function()
-      local text = vim.fn.getline('.'):gsub('^Search:%s*', '')
-      update_results(text)
-    end,
-  })
-
-  vim.keymap.set('i', '<C-n>', function()
-    if Fuzzy.cursor < #Fuzzy.matches then
-      Fuzzy.cursor = Fuzzy.cursor + 1
-      if Fuzzy.cursor > Fuzzy.scroll + Fuzzy.page_size then
-        Fuzzy.scroll = Fuzzy.scroll + 1
-      end
-      render_results()
-    end
-  end, { buffer = Fuzzy.input_buf })
-
-  vim.keymap.set('i', '<C-p>', function()
-    if Fuzzy.cursor > 1 then
-      Fuzzy.cursor = Fuzzy.cursor - 1
-      if Fuzzy.cursor <= Fuzzy.scroll then
-        Fuzzy.scroll = math.max(Fuzzy.scroll - 1, 0)
-      end
-      render_results()
-    end
-  end, { buffer = Fuzzy.input_buf })
-
-  vim.keymap.set('i', '<CR>', function()
-    local choice = Fuzzy.matches[Fuzzy.cursor]
-    if choice then
-      Fuzzy.close()
-      vim.cmd.edit(vim.fn.fnameescape(choice))
-    end
-  end, { buffer = Fuzzy.input_buf })
-
-  vim.keymap.set('i', '<Esc>', Fuzzy.close, { buffer = Fuzzy.input_buf })
-  vim.keymap.set('i', '<C-c>', Fuzzy.close, { buffer = Fuzzy.input_buf })
-  vim.keymap.set('n', '<Esc>', Fuzzy.close, { buffer = Fuzzy.input_buf })
-  vim.keymap.set('n', 'q', Fuzzy.close, { buffer = Fuzzy.input_buf })
-
-  vim.cmd.startinsert()
-end
-
---------------------------------------------------------------------
--- 🟣 Ripgrep-based content search (scrolling + match highlighting)
---------------------------------------------------------------------
-function Fuzzy.open_grep()
-  if Fuzzy.active then
-    Fuzzy.close()
-  end
-  Fuzzy.active = true
-
-  Fuzzy.input_buf, Fuzzy.result_buf, Fuzzy.input_win, Fuzzy.result_win = open_float('Grep: ')
-  Fuzzy.matches, Fuzzy.cursor, Fuzzy.scroll = {}, 1, 0
-  Fuzzy.page_size = 50
-  Fuzzy.ns_id = vim.api.nvim_create_namespace('FuzzyHighlight')
-
-  local function render_results(query)
-    local total = #Fuzzy.matches
-    if total == 0 then
-      vim.api.nvim_buf_set_lines(Fuzzy.result_buf, 0, -1, false, { '-- no matches --' })
-      return
-    end
-
-    local start_idx = Fuzzy.scroll + 1
-    local end_idx = math.min(start_idx + Fuzzy.page_size - 1, total)
-    local display = {}
-    for i = start_idx, end_idx do
-      display[#display + 1] = Fuzzy.matches[i]
-    end
-
-    vim.api.nvim_buf_set_lines(Fuzzy.result_buf, 0, -1, false, display)
-    vim.api.nvim_buf_clear_namespace(Fuzzy.result_buf, Fuzzy.ns_id, 0, -1)
-
-    -- highlight selection
-    local rel_cursor = math.min(Fuzzy.cursor - Fuzzy.scroll, #display)
-    vim.api.nvim_buf_set_extmark(Fuzzy.result_buf, Fuzzy.ns_id, rel_cursor - 1, 0, {
-      end_line = rel_cursor,
-      hl_group = 'Visual',
-      hl_eol = true,
-    })
-
-    -- highlight query matches
-    if query and query ~= '' then
-      local pattern = vim.pesc(query)
-      for i, line in ipairs(display) do
-        for s, e in line:gmatch('()' .. pattern .. '()') do
-          vim.api.nvim_buf_set_extmark(Fuzzy.result_buf, Fuzzy.ns_id, i - 1, s - 1, {
-            end_col = e - 1,
-            hl_group = 'Search',
+  -- match highlights (visible window only)
+  vim.api.nvim_set_hl(0, 'FinderMatch', { link = 'Search', default = true })
+  for i = 1, #view do
+    local idx = S.scroll + i
+    local spans = S.positions[idx]
+    if spans then
+      for _, se in ipairs(spans) do
+        local scol, ecol = se[1], se[2]
+        if ecol > scol then
+          vim.api.nvim_buf_set_extmark(S.buf_res, S.ns, i - 1, scol, {
+            end_col = ecol,
+            hl_group = 'FinderMatch',
           })
         end
       end
     end
   end
 
-  local function run_grep(query)
-    if query == '' then
-      vim.api.nvim_buf_set_lines(Fuzzy.result_buf, 0, -1, false, { '-- type to search --' })
-      return
-    end
-    local handle = io.popen('rg --vimgrep --hidden --smart-case ' .. vim.fn.shellescape(query))
-    if not handle then
-      return
-    end
-    local result = handle:read('*a')
-    handle:close()
-    Fuzzy.matches = vim.split(result, '\n', { trimempty = true })
-    Fuzzy.cursor, Fuzzy.scroll = 1, 0
-    render_results(query)
+  -- selection highlight
+  if total > 0 and #view > 0 then
+    vim.api.nvim_set_hl(0, 'FinderSelection', { link = 'CursorLine', default = true })
+    local rel = clamp(S.select - S.scroll, 1, #view)
+    vim.api.nvim_buf_set_extmark(S.buf_res, S.ns, rel - 1, 0, {
+      end_line = rel,
+      hl_group = 'FinderSelection',
+      hl_eol = true,
+    })
   end
 
-  vim.api.nvim_create_autocmd({ 'TextChangedI', 'TextChangedP' }, {
-    buffer = Fuzzy.input_buf,
+  vim.bo[S.buf_res].modifiable = false
+  L('render', { select = S.select, scroll = S.scroll, total = total, lines = #view })
+end
+
+---------------------------------------------------------------------
+-- Querying / Filtering
+---------------------------------------------------------------------
+local function compute_positions_files(items, q)
+  local ok, res = pcall(vim.fn.matchfuzzypos, items, q)
+  if not ok or type(res) ~= 'table' then
+    return {}, {}
+  end
+  local out_items = res[1] or {}
+  local pos = res[2] or {}
+
+  local filtered, positions = {}, {}
+  for i, v in ipairs(out_items) do
+    filtered[i] = tostring(v or '')
+    local cols = pos[i] or {}
+    table.sort(cols)
+    local spans = {}
+    local start_col, last_col = nil, nil
+    for _, c in ipairs(cols) do
+      local c0 = c
+      if not start_col then
+        start_col, last_col = c0, c0
+      elseif c0 == last_col + 1 then
+        last_col = c0
+      else
+        table.insert(spans, { start_col, last_col + 1 }) -- end exclusive
+        start_col, last_col = c0, c0
+      end
+    end
+    if start_col then
+      table.insert(spans, { start_col, last_col + 1 })
+    end
+    positions[i] = (#spans > 0) and spans or nil
+  end
+  return filtered, positions
+end
+
+local function compute_positions_grep(lines, q)
+  if q == '' then
+    return lines, {}
+  end
+  local qlow = q:lower()
+  local positions = {}
+  for i, line in ipairs(lines) do
+    local llow = tostring(line or ''):lower()
+    local spans = {}
+    local sidx = 1
+    while true do
+      local s, e = llow:find(qlow, sidx, true)
+      if not s then
+        break
+      end
+      table.insert(spans, { s - 1, e })
+      sidx = e + 1
+      if #spans > 64 then
+        break
+      end
+    end
+    positions[i] = (#spans > 0) and spans or nil
+  end
+  return lines, positions
+end
+
+---------------------------------------------------------------------
+-- set_items
+---------------------------------------------------------------------
+local function set_items(list)
+  list = list or {}
+  if #list > M.config.max_items then
+    local tmp = {}
+    for i = 1, M.config.max_items do
+      tmp[i] = list[i]
+    end
+    list = tmp
+  end
+
+  -- sanitize to strings
+  for i, v in ipairs(list) do
+    list[i] = tostring(v or '')
+  end
+
+  S.items = list
+  S.filtered = list
+  S.positions = {}
+  S.select = 1
+  S.scroll = 0
+  render()
+end
+
+---------------------------------------------------------------------
+-- set_query
+---------------------------------------------------------------------
+local function set_query(q)
+  local prev_val = S.filtered[S.select]
+  S.query = q
+
+  if S.mode == 'grep' then
+    local filtered, pos = compute_positions_grep(S.items, q)
+    S.filtered, S.positions = filtered, pos
+  else
+    if q == '' then
+      S.filtered = S.items
+      S.positions = {}
+    else
+      local filtered, pos = compute_positions_files(S.items, q)
+      S.filtered, S.positions = filtered, pos
+    end
+  end
+
+  -- selection policy:
+  if not S.user_moved then
+    S.select = 1
+  else
+    local idx = nil
+    if prev_val then
+      for i, v in ipairs(S.filtered) do
+        if v == prev_val then
+          idx = i
+          break
+        end
+      end
+    end
+    S.select = idx or 1
+  end
+
+  ensure_visible()
+  render()
+  L('set_query', { query = q, filtered = #S.filtered, user_moved = S.user_moved })
+end
+
+---------------------------------------------------------------------
+-- Move / Accept
+---------------------------------------------------------------------
+local function move_down()
+  if #S.filtered == 0 then
+    return
+  end
+  S.user_moved = true
+  S.select = clamp(S.select + 1, 1, #S.filtered)
+  ensure_visible()
+  render()
+end
+
+local function move_up()
+  if #S.filtered == 0 then
+    return
+  end
+  S.user_moved = true
+  S.select = clamp(S.select - 1, 1, #S.filtered)
+  ensure_visible()
+  render()
+end
+
+-- Correct parser for rg --vimgrep (file:line:col:match)
+local function parse_vimgrep(line)
+  if type(line) ~= 'string' then
+    return nil
+  end
+  local file, lnum = line:match('^(.-):(%d+):%d+:')
+  if not file then
+    return nil
+  end
+  return file, tonumber(lnum) or 1
+end
+
+local function accept_selection_files()
+  local pick = S.filtered[S.select]
+  if type(pick) ~= 'string' or pick == '' then
+    return
+  end
+  local abs = to_abs_path(S.root, pick)
+  local path = to_display_path(abs)
+  M.close()
+  vim.schedule(function()
+    vim.cmd.edit(vim.fn.fnameescape(path))
+  end)
+end
+
+local function accept_selection_grep()
+  local pick = S.filtered[S.select]
+  if type(pick) ~= 'string' or pick == '' then
+    return
+  end
+  local file, lnum = parse_vimgrep(pick)
+  if not file then
+    return
+  end
+  local abs = to_abs_path(S.root, file)
+  local path = to_display_path(abs)
+  local ln = tonumber(lnum) or 1
+  M.close()
+  vim.schedule(function()
+    vim.cmd.edit(vim.fn.fnameescape(path))
+    pcall(vim.api.nvim_win_set_cursor, 0, { ln, 0 })
+  end)
+end
+
+---------------------------------------------------------------------
+-- Backends
+---------------------------------------------------------------------
+local function cancel_job(job)
+  if not job then
+    return
+  end
+  pcall(function()
+    job:kill(15)
+  end) -- SIGTERM if available
+end
+
+local function collect_files_async(cb)
+  local root = S.root
+  local gen = S.gen
+
+  local disk = load_cache(root)
+  if disk and type(disk) == 'table' then
+    S.files_cached = true
+    cb(disk)
+    return
+  end
+  S.files_cached = false
+
+  local file_cmd = M.config.file_cmd
+  if not file_cmd then
+    if cmd_exists('fd') then
+      file_cmd = 'fd'
+    elseif cmd_exists('fdfind') then
+      file_cmd = 'fdfind'
+    end
+  end
+
+  local excludes = {}
+  for _, p in ipairs(M.config.exclude_patterns or {}) do
+    table.insert(excludes, p)
+  end
+  local gi = read_gitignore(root)
+  for _, p in ipairs(gi) do
+    table.insert(excludes, p)
+  end
+
+  if file_cmd then
+    local args = { file_cmd, '--type', 'f', '--hidden', '--color', 'never' }
+    if file_cmd == 'fd' or file_cmd == 'fdfind' then
+      table.insert(args, '--strip-cwd-prefix')
+    end
+    for _, ex in ipairs(excludes) do
+      table.insert(args, '--exclude')
+      table.insert(args, ex)
+    end
+    cancel_job(S.job_files)
+    S.job_files = vim.system(args, { text = true, cwd = root }, function(obj)
+      if not (S.active and gen == S.gen) then
+        return
+      end
+      local list = {}
+      if obj.stdout then
+        local raw = vim.split(obj.stdout, '\n', { trimempty = true })
+        for _, p in ipairs(raw) do
+          list[#list + 1] = normalize_rel(root, p)
+        end
+      end
+      if #list > M.config.max_items then
+        local tmp = {}
+        for i = 1, M.config.max_items do
+          tmp[i] = list[i]
+        end
+        list = tmp
+      end
+      save_cache(root, list)
+      vim.schedule(function()
+        if S.active and gen == S.gen then
+          cb(list)
+        end
+      end)
+    end)
+    return
+  end
+
+  -- Try git ls-files as async fallback
+  if cmd_exists('git') then
+    cancel_job(S.job_files)
+    S.job_files = vim.system(
+      { 'git', 'ls-files', '-co', '--exclude-standard', '-z' },
+      { text = true, cwd = root },
+      function(o2)
+        if not (S.active and gen == S.gen) then
+          return
+        end
+        local list = {}
+        if o2.stdout then
+          for p in o2.stdout:gmatch('([^%z]+)') do
+            list[#list + 1] = normalize_rel(root, p)
+          end
+        end
+        if #list > M.config.max_items then
+          local tmp = {}
+          for i = 1, M.config.max_items do
+            tmp[i] = list[i]
+          end
+          list = tmp
+        end
+        save_cache(root, list)
+        vim.schedule(function()
+          if S.active and gen == S.gen then
+            cb(list)
+          end
+        end)
+      end
+    )
+    return
+  end
+
+  -- Last resort omitted: blocking glob removed to keep async-only behavior
+  cb({})
+end
+
+local function grep_async(query, cb)
+  if query == '' then
+    cb({})
+    return
+  end
+  local gen = S.gen
+  local rg = M.config.grep_cmd
+  if not cmd_exists(rg) then
+    cb({})
+    return
+  end
+
+  local root = S.root
+  local args = {
+    rg,
+    '--vimgrep',
+    '--hidden',
+    '--smart-case',
+    '--no-heading',
+    '--no-config',
+    '--color',
+    'never',
+    '--path-separator',
+    '/',
+    '--',
+    query,
+  }
+  -- Apply excludes as negative globs
+  for _, p in ipairs(M.config.exclude_patterns or {}) do
+    table.insert(args, 2, '--glob')
+    table.insert(args, 3, '!' .. p)
+  end
+  for _, p in ipairs(read_gitignore(root)) do
+    table.insert(args, 2, '--glob')
+    table.insert(args, 3, '!' .. p)
+  end
+
+  cancel_job(S.job_rg)
+  S.job_rg = vim.system(args, { text = true, cwd = root }, function(obj)
+    if not (S.active and gen == S.gen) then
+      return
+    end
+    local list = {}
+    -- Accept output even if exit code != 0 (no matches or partial errors)
+    if obj.stdout and #obj.stdout > 0 then
+      list = vim.split(obj.stdout, '\n', { trimempty = true })
+    end
+    if #list > M.config.max_items then
+      local tmp = {}
+      for i = 1, M.config.max_items do
+        tmp[i] = list[i]
+      end
+      list = tmp
+    end
+    vim.schedule(function()
+      if S.active and gen == S.gen then
+        cb(list)
+      end
+    end)
+  end)
+end
+
+---------------------------------------------------------------------
+-- Layout
+---------------------------------------------------------------------
+local function open_layout(prompt)
+  S.buf_inp = vim.api.nvim_create_buf(false, true)
+  S.buf_res = vim.api.nvim_create_buf(false, true)
+
+  for _, b in ipairs({ S.buf_inp, S.buf_res }) do
+    if b and vim.api.nvim_buf_is_valid(b) then
+      vim.bo[b].buflisted = false
+      vim.bo[b].bufhidden = 'wipe'
+      vim.bo[b].swapfile = false
+    end
+  end
+  if S.buf_inp and vim.api.nvim_buf_is_valid(S.buf_inp) then
+    vim.bo[S.buf_inp].buftype = 'prompt'
+  end
+  if S.buf_res and vim.api.nvim_buf_is_valid(S.buf_res) then
+    vim.bo[S.buf_res].buftype = 'nofile'
+    vim.bo[S.buf_res].modifiable = false
+    vim.bo[S.buf_res].readonly = false
+  end
+
+  local width = math.floor(vim.o.columns * 0.8)
+  local height = math.min(math.floor(vim.o.lines * 0.5), M.config.page_size + 2)
+  local col = math.floor((vim.o.columns - width) / 2)
+  local row = math.floor((vim.o.lines - height) * 0.7)
+
+  S.win_inp = vim.api.nvim_open_win(S.buf_inp, true, {
+    relative = 'editor',
+    style = 'minimal',
+    border = 'rounded',
+    width = width,
+    height = 1,
+    col = col,
+    row = row,
+    focusable = true,
+    zindex = 200,
+  })
+  if S.buf_inp and vim.api.nvim_buf_is_valid(S.buf_inp) then
+    vim.fn.prompt_setprompt(S.buf_inp, prompt or '')
+  end
+
+  S.win_res = vim.api.nvim_open_win(S.buf_res, false, {
+    relative = 'editor',
+    style = 'minimal',
+    border = 'single',
+    width = width,
+    height = math.max(1, height - 2),
+    col = col,
+    row = row + 2,
+    focusable = false,
+    zindex = 199,
+  })
+  if S.win_res and vim.api.nvim_win_is_valid(S.win_res) then
+    vim.wo[S.win_res].cursorline = false
+    vim.wo[S.win_res].cursorlineopt = 'line'
+  end
+
+  if S.aug then
+    pcall(vim.api.nvim_del_augroup_by_id, S.aug)
+  end
+  S.aug = vim.api.nvim_create_augroup('finder_session', { clear = true })
+
+  -- Close if focus enters a non-floating window that isn't ours
+  vim.api.nvim_create_autocmd('WinEnter', {
+    group = S.aug,
     callback = function()
-      local text = vim.fn.getline('.'):gsub('^Grep:%s*', '')
-      run_grep(text)
+      if not S.active then
+        return
+      end
+      local w = vim.api.nvim_get_current_win()
+      if w == S.win_inp or w == S.win_res then
+        return
+      end
+      local cfg = vim.api.nvim_win_get_config(w)
+      if cfg and cfg.relative == '' then
+        M.close()
+      end
     end,
   })
 
-  vim.keymap.set('i', '<C-n>', function()
-    if Fuzzy.cursor < #Fuzzy.matches then
-      Fuzzy.cursor = Fuzzy.cursor + 1
-      if Fuzzy.cursor > Fuzzy.scroll + Fuzzy.page_size then
-        Fuzzy.scroll = Fuzzy.scroll + 1
+  -- Close if prompt buffer hides or leaves
+  if S.buf_inp and vim.api.nvim_buf_is_valid(S.buf_inp) then
+    vim.api.nvim_create_autocmd({ 'BufHidden', 'BufLeave' }, {
+      group = S.aug,
+      buffer = S.buf_inp,
+      callback = function()
+        if S.active then
+          M.close()
+        end
+      end,
+    })
+  end
+
+  -- Re-render on resize to respect new viewport height
+  vim.api.nvim_create_autocmd('VimResized', {
+    group = S.aug,
+    callback = function()
+      if S.active then
+        render()
       end
-      local query = vim.fn.getline('.'):gsub('^Grep:%s*', '')
-      render_results(query)
-    end
-  end, { buffer = Fuzzy.input_buf })
-
-  vim.keymap.set('i', '<C-p>', function()
-    if Fuzzy.cursor > 1 then
-      Fuzzy.cursor = Fuzzy.cursor - 1
-      if Fuzzy.cursor <= Fuzzy.scroll then
-        Fuzzy.scroll = math.max(Fuzzy.scroll - 1, 0)
-      end
-      local query = vim.fn.getline('.'):gsub('^Grep:%s*', '')
-      render_results(query)
-    end
-  end, { buffer = Fuzzy.input_buf })
-
-  vim.keymap.set('i', '<CR>', function()
-    local line = Fuzzy.matches[Fuzzy.cursor]
-    if line then
-      local parts = vim.split(line, ':')
-      local file, lnum = parts[1], tonumber(parts[2]) or 1
-      Fuzzy.close()
-      vim.cmd.edit(vim.fn.fnameescape(file))
-      vim.api.nvim_win_set_cursor(0, { lnum, 0 })
-    end
-  end, { buffer = Fuzzy.input_buf })
-
-  vim.keymap.set('i', '<Esc>', function()
-    Fuzzy.close()
-  end, { buffer = Fuzzy.input_buf })
+    end,
+  })
 
   vim.cmd.startinsert()
+  L('open_layout', { win_inp = S.win_inp, win_res = S.win_res })
 end
 
---------------------------------------------------------------------
--- 🧩 Commands & Keymaps
---------------------------------------------------------------------
-vim.api.nvim_create_user_command('FuzzyLive', function()
-  Fuzzy.open()
-end, {})
-vim.api.nvim_create_user_command('FuzzyGrep', function()
-  Fuzzy.open_grep()
-end, {})
+local function close_layout()
+  for _, win in ipairs({ S.win_inp, S.win_res }) do
+    if win and vim.api.nvim_win_is_valid(win) then
+      pcall(vim.api.nvim_win_close, win, true)
+    end
+  end
+  for _, buf in ipairs({ S.buf_inp, S.buf_res }) do
+    if buf and vim.api.nvim_buf_is_valid(buf) then
+      pcall(vim.api.nvim_buf_delete, buf, { force = true })
+    end
+  end
+  if S.aug then
+    pcall(vim.api.nvim_del_augroup_by_id, S.aug)
+    S.aug = nil
+  end
+  L('close_layout')
+end
 
-vim.keymap.set('n', '<leader>f', function()
-  vim.cmd.FuzzyLive()
-end, { desc = 'Open fuzzy file finder' })
-vim.keymap.set('n', '<leader>g', function()
-  vim.cmd.FuzzyGrep()
-end, { desc = 'Search file contents with ripgrep' })
+---------------------------------------------------------------------
+-- Input handlers
+---------------------------------------------------------------------
+local function attach_handlers()
+  local opts = { buffer = S.buf_inp, nowait = true, silent = true, noremap = true }
+  vim.keymap.set('i', '<C-n>', move_down, opts)
+  vim.keymap.set('i', '<C-p>', move_up, opts)
+  vim.keymap.set('i', '<Down>', move_down, opts)
+  vim.keymap.set('i', '<Up>', move_up, opts)
+  vim.keymap.set('i', '<CR>', function()
+    if S.mode == 'grep' then
+      accept_selection_grep()
+    else
+      accept_selection_files()
+    end
+  end, opts)
+  vim.keymap.set('i', '<Esc>', function()
+    M.close()
+  end, opts)
+  vim.keymap.set('i', '<C-c>', function()
+    M.close()
+  end, opts)
 
-return Fuzzy
+  if S.buf_inp and vim.api.nvim_buf_is_valid(S.buf_inp) then
+    vim.api.nvim_create_autocmd({ 'TextChangedI', 'TextChangedP' }, {
+      group = S.aug,
+      buffer = S.buf_inp,
+      callback = function()
+        local delay = effective_debounce_ms()
+        debounce(function()
+          if not (S.active and S.buf_inp and vim.api.nvim_buf_is_valid(S.buf_inp)) then
+            return
+          end
+          local raw = vim.fn.getline('.')
+          raw = type(raw) == 'string' and raw or ''
+          local prompt_pat = (S.mode == 'files') and '^Search:%s*' or '^Grep:%s*'
+          local q = raw:gsub(prompt_pat, '')
+          if S.mode == 'grep' then
+            grep_async(q, function(list)
+              if not S.active then
+                return
+              end
+              S.items = list or {}
+              set_query(q)
+            end)
+          else
+            set_query(q)
+          end
+        end, delay)
+      end,
+    })
+  end
+
+  L('keymaps attached', opts)
+end
+
+---------------------------------------------------------------------
+-- Public
+---------------------------------------------------------------------
+function M.files()
+  if S.active then
+    M.close()
+  end
+  S.active = true
+  S.gen = S.gen + 1
+  S.user_moved = false
+  S.mode = 'files'
+  S.root = project_root()
+  open_layout('Search: ')
+  attach_handlers()
+  collect_files_async(function(list)
+    if not S.active then
+      return
+    end
+    set_items(list) -- render initial list (relative to root)
+  end)
+end
+
+function M.grep()
+  if S.active then
+    M.close()
+  end
+  S.active = true
+  S.gen = S.gen + 1
+  S.user_moved = false
+  S.mode = 'grep'
+  S.root = project_root()
+  open_layout('Grep: ')
+  attach_handlers()
+  S.items = {}
+  set_query('')
+end
+
+function M.close()
+  if not S.active then
+    return
+  end
+  -- stop timers and jobs first
+  if S.timer then
+    pcall(function()
+      S.timer:stop()
+      S.timer:close()
+    end)
+    S.timer = nil
+  end
+  cancel_job(S.job_rg)
+  S.job_rg = nil
+  cancel_job(S.job_files)
+  S.job_files = nil
+
+  close_layout()
+  S.active = false
+  S.mode, S.root = nil, nil
+  S.items, S.filtered, S.positions = {}, {}, {}
+  S.query, S.select, S.scroll = '', 1, 0
+  S.user_moved = false
+  S.files_cached = false
+  L('session closed')
+end
+
+function M.setup(opts)
+  M.config = vim.tbl_deep_extend('force', M.config, opts or {})
+  if M.config.file_cmd and not cmd_exists(M.config.file_cmd) then
+    pcall(
+      vim.notify,
+      ("finder: file_cmd '%s' not found"):format(M.config.file_cmd),
+      vim.log.levels.WARN
+    )
+  end
+  if M.config.grep_cmd and not cmd_exists(M.config.grep_cmd) then
+    pcall(
+      vim.notify,
+      ("finder: grep_cmd '%s' not found, will try 'rg'"):format(M.config.grep_cmd),
+      vim.log.levels.WARN
+    )
+  end
+  L('setup', M.config)
+end
+
+return M