Updated dotfiles

24 files changed, 862 insertions, 68 deletions

diff --git a/bash/.bashrc b/bash/.bashrc
index 9ccd0e3..c923972 100755
--- a/bash/.bashrc
+++ b/bash/.bashrc
@@ -104,10 +104,12 @@ fi
 # Set the default editor
 if exists nvim; then
     export EDITOR="nvim"
+    alias vim=nvim
 elif exists vim; then
     export EDITOR="vim"
 elif exists vi; then
     export EDITOR="vi"
+    alias vim=nvim
 fi
 
 # vim() {
diff --git a/iterm2/.iterm2/com.googlecode.iterm2.plist b/iterm2/.iterm2/com.googlecode.iterm2.plist
index f7b56cd..848452e 100644
--- a/iterm2/.iterm2/com.googlecode.iterm2.plist
+++ b/iterm2/.iterm2/com.googlecode.iterm2.plist
@@ -26,6 +26,8 @@
         <string>https://api.openai.com/v1/responses</string>
         <key>CheckTestRelease</key>
         <true/>
+        <key>ClaudeCodeWorkgroupUpsellSuppressed</key>
+        <true/>
         <key>Default Bookmark Guid</key>
         <string>F73BDC14-4F5E-4A25-AE4A-2C6DB0A9BFEF</string>
         <key>DisableFullscreenTransparency</key>
@@ -53,6 +55,8 @@
                         <false/>
                         <key>Ambiguous Double Width</key>
                         <false/>
+                        <key>Animate Movement</key>
+                        <false/>
                         <key>Ansi 0 Color</key>
                         <dict>
                                 <key>Blue Component</key>
@@ -343,7 +347,7 @@
                         <key>Non-ASCII Anti Aliased</key>
                         <true/>
                         <key>Normal Font</key>
-                        <string>Menlo-Regular 11</string>
+                        <string>JetBrainsMonoNLNFM-Regular 11</string>
                         <key>Option Key Sends</key>
                         <integer>0</integer>
                         <key>Prevent Opening in a Tab</key>
@@ -621,6 +625,8 @@
                         <string>xterm-256color</string>
                         <key>Transparency</key>
                         <real>0.0</real>
+                        <key>Unicode Normalization</key>
+                        <integer>0</integer>
                         <key>Unicode Version</key>
                         <integer>9</integer>
                         <key>Unlimited Scrollback</key>
diff --git a/neovim/.config/nvim/README.md b/neovim/.config/nvim/README.md
index 5092af0..0e50788 100644
--- a/neovim/.config/nvim/README.md
+++ b/neovim/.config/nvim/README.md
@@ -15,6 +15,8 @@ lua/config/            Everything that isn't a plugin declaration
   options.lua           vim.opt settings (search, undo, whitespace display, ...)
   keymaps.lua           Global keymaps not owned by a specific plugin
   autocmds.lua          Global autocmds not owned by a specific plugin
+  project_run.lua       Helper for project-local run/debug configs (see below)
+  dap_node.lua           Node/js-debug-adapter wiring for nvim-dap (see below)
   lazy.lua              Bootstraps lazy.nvim and points it at lua/plugins/
 lua/plugins/            One file per plugin (or small plugin group), each
                         returning a lazy.nvim plugin spec (or list of specs)
@@ -34,18 +36,23 @@ such tables) and it's included on next launch.
 | File | Plugin(s) | Purpose |
 |---|---|---|
 | `colorscheme.lua` | vim-janah | Color scheme, falls back to `desert` if it fails to load |
-| `statusline.lua` | vim-airline, vim-airline-themes, tmuxline.vim | Status/tab line |
+| `statusline.lua` | lualine.nvim | Status line |
 | `filetree.lua` | neo-tree.nvim | File explorer sidebar with git-status colors (`<leader>e` to toggle) |
-| `fuzzyfinder.lua` | ctrlp.vim | Fuzzy file finder (ripgrep-backed if `rg` is on PATH) |
-| `editing.lua` | nerdcommenter, quick-scope | Comment toggling, `f`/`F`/`t`/`T` target highlighting |
-| `git.lua` | vim-fugitive, vim-signify | `:Git` commands, git-diff gutter signs |
+| `fuzzyfinder.lua` | telescope.nvim, telescope-ui-select.nvim | Fuzzy file finder (`<C-p>`), live grep (`<leader>fg`), buffers (`<leader>fb`); also overrides `vim.ui.select` globally so overseer's/dap's pickers are Telescope windows |
+| `editing.lua` | quick-scope | `f`/`F`/`t`/`T` target highlighting (comment toggling is Neovim's built-in `gc`/`gcc`) |
+| `git.lua` | vim-fugitive, gitsigns.nvim | `:Git` commands, git-diff gutter signs |
 | `ale.lua` | ALE | Linters/fixers only — `g:ale_disable_lsp = 1` so it doesn't fight the LSP client's diagnostics/hover/go-to-def |
-| `langs.lua` | vim-ansible-yaml, vim-terraform | Only loaded if `ansible`/`terraform` is on PATH (lazy.nvim `cond`) |
 | `claude-code.lua` | claude-code.nvim (+ plenary.nvim) | `:ClaudeCode` and friends |
+| `toggleterm.lua` | toggleterm.nvim | Scratch terminal toggle — `<C-.>`, vertical split on the right matching claude-code.nvim's placement/ratio |
 | `treesitter.lua` | nvim-treesitter (`main` branch) | Parser installs + syntax highlighting |
 | `autopairs.lua` | nvim-autopairs, nvim-ts-autotag | Auto-close brackets/quotes/HTML+JSX tags |
 | `completion.lua` | blink.cmp (+ friendly-snippets) | Completion popup, Tab-to-accept (`super-tab` preset) |
 | `lsp.lua` | nvim-lspconfig, mason.nvim, mason-lspconfig.nvim | Installs & enables language servers, wires blink.cmp's capabilities into them |
+| `dap.lua` | nvim-dap, nvim-dap-ui, nvim-dap-virtual-text, mason-nvim-dap.nvim | Debugger core + UI, installs debug adapters via Mason (`<leader>d*`) |
+| `dap-python.lua` | nvim-dap-python | Python launch configs, wired to Mason's debugpy install |
+| `overseer.lua` | overseer.nvim | Save/run/rerun arbitrary run configurations for any language (`<leader>r*`) |
+| `which-key.lua` | which-key.nvim | Keymap discoverability popup; labels the `<leader>d`/`<leader>r`/etc. groups |
+| `indent-detect.lua` | guess-indent.nvim | Detects each buffer's real indentation and matches shiftwidth/tabstop to it |
 
 ## Language servers
 
@@ -59,6 +66,112 @@ hover) come from Neovim's built-in default LSP keymaps (`:help lsp-defaults`)
 once a server attaches — `grn`, `gra`, `grr`, `gri`, `gO`, `K`, `<C-]>`. No
 extra plugin or keymap needed for these.
 
+## Debugging
+
+Python and Node.js (JavaScript/TypeScript), via `nvim-dap` + `nvim-dap-ui`.
+The `debugpy` and `js-debug-adapter` adapters are installed and kept up to
+date by Mason (via `mason-nvim-dap.nvim`, the DAP equivalent of
+`mason-lspconfig.nvim`), so `:Mason` shows them alongside the language
+servers. Keymaps live under `<leader>d` — `<leader>db` to set a breakpoint,
+`<leader>dc` to start/continue (picks a registered config from any window,
+not just the source buffer; resumes in place if a session is already stopped
+at a breakpoint), `<leader>do`/`di`/`dO` to step over/into/out, `<leader>dt`
+to terminate, `<leader>du` to reopen the UI if you close it manually (it
+opens/closes itself automatically around a session). Press `<leader>d` and
+wait to see the full list via which-key.
+
+Python's adapter/config setup lives in `lua/plugins/dap-python.lua`, wrapping
+the `nvim-dap-python` plugin. Node's lives in `lua/config/dap_node.lua`
+instead — there's no maintained `nvim-dap-python`-style plugin for it (the
+community option, `nvim-dap-vscode-js`, expects an older, manually-built
+vscode-js-debug layout that doesn't match what Mason's `js-debug-adapter`
+package installs), so that file resolves the Mason install path directly and
+registers the `pwa-node` adapter + default `javascript`/`typescript`/
+`javascriptreact`/`typescriptreact` configs itself. It's called eagerly from
+`dap.lua`'s own `config()` rather than being its own `lua/plugins/*` entry,
+since it isn't an installable plugin — same reasoning as
+`lua/config/project_run.lua`.
+
+Adding another language later (e.g. C/C++ via `codelldb`) means adding its
+adapter to `dap.lua`'s `ensure_installed`, and either writing its own
+`dap-<language>.lua` plugin file (if a wrapper plugin exists, following the
+`dap-python.lua` pattern) or a `lua/config/dap_<language>.lua` module called
+from `dap.lua`'s `config()` (if not, following the `dap_node.lua` pattern) —
+including `lazy = false` on `dap.lua` itself either way, so the adapter is
+registered from startup rather than only after a buffer of that filetype is
+opened (the `<leader>dc` picker works from any window, so it can't rely on
+that to lazy-trigger the adapter).
+
+`overseer.lua` sets `dap = true`, which patches `nvim-dap` so a debug
+configuration can set `preLaunchTask`/`postDebugTask` to the name of an
+overseer task (or `"${defaultBuildTask}"` for whichever task is tagged
+`BUILD`) — useful for "build, then debug" workflows once a compiled
+language is added; not needed for plain Python/Node scripts.
+
+## Run configurations
+
+`overseer.nvim` provides PyCharm-style saved/rerunnable run configurations
+for any language or toolchain (shell commands, npm scripts, make, cargo,
+python scripts, ...) — it isn't tied to LSP/DAP language support. Keymaps
+live under `<leader>r` — `<leader>rr` to run a task (prompts for a template
+or a raw command), `<leader>rl` to rerun the last task, `<leader>ro` to
+toggle the task list/output window, `<leader>rq` for quick actions
+(restart/stop/dispose) on a selected task. Press `<leader>r` and wait to see
+the full list via which-key.
+
+`overseer.lua`'s `component_aliases.default` adds the `open_output`
+component (`on_start = "always"`, `focus = false`) on top of overseer's own
+defaults, so starting *any* task — custom, `.nvim.lua`-declared, or
+auto-detected (npm/make/etc.) — docks its output automatically instead of
+running silently until you manually `<leader>ro`.
+
+## Project-local run/debug configs
+
+A project can drop a `.nvim.lua` anywhere in its directory tree and have it
+auto-sourced (after a one-time `:help :trust` prompt — it runs arbitrary
+Lua, so trust it deliberately, not reflexively). This is the PyCharm-style
+"named configuration" mechanism, without adopting any other editor's file
+format.
+
+This is **not** core Vim/Neovim `'exrc'` (deliberately left off in
+options.lua) — `exrc` only checks the literal cwd once at startup, so it
+misses a project's `.nvim.lua` whenever Neovim didn't happen to start with
+cwd exactly there. Instead, an autocmd in `lua/config/autocmds.lua` searches
+*upward* from cwd on `VimEnter`/`DirChanged` (stopping at `$HOME`, same
+nearest-ancestor pattern LSP root-dir detection uses) and reads the file via
+`vim.secure.read` — the same trust mechanism `exrc` itself uses, so `:trust`
+still manages the allowlist unchanged, it's just found reliably regardless
+of how you opened Neovim.
+
+`lua/config/project_run.lua` gives that file one call per config that
+registers both a `<leader>rr` run task and a matching `<leader>dc` debug
+config from the *same* declaration, instead of repeating the command across
+two separate files:
+
+```lua
+-- <project root>/.nvim.lua
+require("config.project_run").python({
+  name = "Run app",
+  program = vim.fn.getcwd() .. "/main.py",
+  args = { "--flag" }, -- optional, shared by both run and debug
+})
+
+require("config.project_run").node({
+  name = "Run app",
+  program = vim.fn.getcwd() .. "/index.js", -- or npmScript = "dev" for `npm run dev`
+  args = { "--flag" }, -- optional, shared by both run and debug
+})
+```
+
+`dap.lua` and `overseer.lua` are both `lazy = false` specifically so this
+works immediately when the autocmd sources the file, rather than needing
+the plugins already triggered by a keymap first.
+
+(`nvim-dap` and `overseer.nvim` also natively read `.vscode/launch.json` and
+`.vscode/tasks.json` respectively, if you'd rather use that ecosystem's
+format for some reason — but `project_run.lua` is the recommended path here
+since it states each command once.)
+
 ## Adding a new plugin
 
 Drop a new file in `lua/plugins/` (or add to an existing group file if it
@@ -74,6 +187,18 @@ return {
 Restart Neovim (or `:Lazy sync`) to install it, then commit the updated
 `lazy-lock.json` alongside your change.
 
+If a plugin backs a keymap or command meant to work from any window — not
+scoped to a particular filetype/buffer, like the run/debug pickers, the
+fuzzy finder, or the file explorer — set `lazy = false` rather than gating
+it behind `ft`/`event`, even though lazy.nvim would otherwise recommend one.
+A trigger tied to "some buffer of type X was opened" silently breaks the
+moment the keymap fires before that's happened (this bit `dap-python.lua`:
+it lazy-loaded on `ft = "python"`, so debugging broke whenever `<leader>dc`
+was pressed before any `.py` buffer had been opened this session). Plain
+per-buffer editing conveniences (`autopairs.lua`'s `InsertEnter`,
+`ale.lua`'s `BufReadPre`, `which-key.lua`'s `VeryLazy`) don't have this
+problem and can stay lazy.
+
 ## Relationship to Vim
 
 Vim and Neovim used to share one `vimrc` (`has('nvim')` branches handled the
diff --git a/neovim/.config/nvim/lazy-lock.json b/neovim/.config/nvim/lazy-lock.json
index 6ac90ec..fd32868 100644
--- a/neovim/.config/nvim/lazy-lock.json
+++ b/neovim/.config/nvim/lazy-lock.json
@@ -2,26 +2,33 @@
   "ale": { "branch": "master", "commit": "e1789bc54483d76ac9ddb40b633d1645c8281914" },
   "blink.cmp": { "branch": "main", "commit": "78336bc89ee5365633bcf754d93df01678b5c08f" },
   "claude-code.nvim": { "branch": "main", "commit": "55c0cb59828fbc3bec744288286a46f5d5750b83" },
-  "ctrlp.vim": { "branch": "master", "commit": "0065942ef13ce28293e2b26cb622d035da050b44" },
   "friendly-snippets": { "branch": "main", "commit": "b4d01b0fdf3c9a549961c2f9ffe8dc09be166219" },
+  "gitsigns.nvim": { "branch": "main", "commit": "f2421c550618d257048afa650413d9e542ddbe67" },
+  "guess-indent.nvim": { "branch": "main", "commit": "84a4987ff36798c2fc1169cbaff67960aed9776f" },
   "lazy.nvim": { "branch": "main", "commit": "306a05526ada86a7b30af95c5cc81ffba93fef97" },
-  "mason-lspconfig.nvim": { "branch": "main", "commit": "b5576cd62899a1a478d0e67ef3d378ee55dba82d" },
+  "lualine.nvim": { "branch": "master", "commit": "221ce6b2d999187044529f49da6554a92f740a96" },
+  "mason-lspconfig.nvim": { "branch": "main", "commit": "77e06f7d2fc127e6ef0a720b59acbc50757cff19" },
+  "mason-nvim-dap.nvim": { "branch": "main", "commit": "9a10e096703966335bd5c46c8c875d5b0690dade" },
   "mason.nvim": { "branch": "main", "commit": "2a6940af80375532e5e9e7c1f2fc6319a1b7a69d" },
   "neo-tree.nvim": { "branch": "v3.x", "commit": "1a14083046d96e88e361d1da00761c40d45012f3" },
-  "nerdcommenter": { "branch": "master", "commit": "a462bbda1e26f44fb3d3eb9d9d1c6a07aa98e665" },
   "nui.nvim": { "branch": "main", "commit": "10fc361835c856ba4233ef5ea135b919bf3dce97" },
   "nvim-autopairs": { "branch": "master", "commit": "430522f95fe4fb7c511ec64f8c1a90cc6a66c05c" },
+  "nvim-dap": { "branch": "master", "commit": "cfa2d58f4537aca6ca83e2de1a0d9f1491121264" },
+  "nvim-dap-python": { "branch": "master", "commit": "1808458eba2b18f178f990e01376941a42c7f93b" },
+  "nvim-dap-ui": { "branch": "master", "commit": "cc9dd33aade7f20bae414d0cba163bc60d4d4b43" },
+  "nvim-dap-virtual-text": { "branch": "master", "commit": "fbdb48c2ed45f4a8293d0d483f7730d24467ccb6" },
   "nvim-lspconfig": { "branch": "master", "commit": "ac9d2f7c4757db6320cab6697fe73e5e8adb2457" },
-  "nvim-treesitter": { "branch": "main", "commit": "d4d59cb369da46b95699bd2200efbcffc6dadb3b" },
+  "nvim-nio": { "branch": "master", "commit": "edcc181a875301dd21840189aa2f2f9ad69fc172" },
+  "nvim-treesitter": { "branch": "main", "commit": "9a168f6357ed21c3a636e1727bc7d382abc451b8" },
   "nvim-ts-autotag": { "branch": "main", "commit": "88c1453db4ba7dd24131086fe51fdf74e587d275" },
   "nvim-web-devicons": { "branch": "master", "commit": "5f032a85be210cd1c6ac98861eb3b187ff3bd5eb" },
+  "overseer.nvim": { "branch": "master", "commit": "a93d9f6d6defdac4bcd6d2c8ba988650e42e0a0e" },
   "plenary.nvim": { "branch": "master", "commit": "74b06c6c75e4eeb3108ec01852001636d85a932b" },
   "quick-scope": { "branch": "master", "commit": "6cee1d9e0b9ac0fbffeb538d4a5ba9f5628fabbc" },
-  "tmuxline.vim": { "branch": "master", "commit": "4119c553923212cc67f4e135e6f946dc3ec0a4d6" },
-  "vim-airline": { "branch": "master", "commit": "ae24f4aca06731d5d7224df1fc5415975331b214" },
-  "vim-airline-themes": { "branch": "master", "commit": "77aab8c6cf7179ddb8a05741da7e358a86b2c3ab" },
-  "vim-ansible-yaml": { "branch": "master", "commit": "a6f92d17ff01b2e63d6c9fdbb7f7e13c7fd41d14" },
+  "telescope-ui-select.nvim": { "branch": "master", "commit": "6e51d7da30bd139a6950adf2a47fda6df9fa06d2" },
+  "telescope.nvim": { "branch": "master", "commit": "40aedd8a68c78a656a10a8d62d80c54af59420fb" },
+  "toggleterm.nvim": { "branch": "main", "commit": "9a88eae817ef395952e08650b3283726786fb5fb" },
   "vim-fugitive": { "branch": "master", "commit": "3b753cf8c6a4dcde6edee8827d464ba9b8c4a6f0" },
   "vim-janah": { "branch": "master", "commit": "3b8ae976987b6ade2abeac25f0208e8bc90d7138" },
-  "vim-signify": { "branch": "master", "commit": "3b5ae37eb2b77c3ae58d60dfdc3fc30258078663" }
+  "which-key.nvim": { "branch": "main", "commit": "3aab2147e74890957785941f0c1ad87d0a44c15a" }
 }
diff --git a/neovim/.config/nvim/lua/config/autocmds.lua b/neovim/.config/nvim/lua/config/autocmds.lua
index 7bc4f6b..e9ebe04 100644
--- a/neovim/.config/nvim/lua/config/autocmds.lua
+++ b/neovim/.config/nvim/lua/config/autocmds.lua
@@ -13,6 +13,49 @@ vim.api.nvim_create_autocmd("BufWritePre", {
   callback = strip_trailing_whitespace,
 })
 
+-- Project-local config: search upward from cwd for a .nvim.lua, the same
+-- nearest-ancestor pattern LSP root-dir detection uses, so it's found
+-- regardless of exactly which subdirectory Neovim's cwd is or how you got
+-- there (:cd, opening a file, session restore, ...) - unlike core 'exrc'
+-- (deliberately left off in options.lua), which only ever checks the
+-- literal cwd once at startup.
+local sourced_project_configs = {}
+
+local function source_project_config()
+  local found = vim.fs.find(".nvim.lua", {
+    upward = true,
+    path = vim.fn.getcwd(),
+    stop = vim.env.HOME,
+  })[1]
+  if not found or sourced_project_configs[found] then
+    return
+  end
+
+  -- vim.secure.read is the same trust mechanism 'exrc' itself uses: prompts
+  -- on first encounter, honors ~/.local/state/nvim/trust, :trust still
+  -- manages the allowlist unchanged. Returns nil (no prompt shown again)
+  -- for a file previously denied.
+  local content = vim.secure.read(found)
+  if not content then
+    return
+  end
+  sourced_project_configs[found] = true
+
+  local chunk, load_err = load(content, "@" .. found)
+  if not chunk then
+    vim.notify("Error loading " .. found .. ":\n" .. load_err, vim.log.levels.ERROR)
+    return
+  end
+  local ok, run_err = pcall(chunk)
+  if not ok then
+    vim.notify("Error running " .. found .. ":\n" .. run_err, vim.log.levels.ERROR)
+  end
+end
+
+vim.api.nvim_create_autocmd({ "VimEnter", "DirChanged" }, {
+  callback = source_project_config,
+})
+
 -- Note: the colorscheme (with its "desert" fallback) is applied from
 -- lua/plugins/colorscheme.lua's own `config` function, not here — under
 -- lazy.nvim that's the natural place to react to "the plugin is now loaded".
diff --git a/neovim/.config/nvim/lua/config/dap_node.lua b/neovim/.config/nvim/lua/config/dap_node.lua
new file mode 100644
index 0000000..0fb6890
--- /dev/null
+++ b/neovim/.config/nvim/lua/config/dap_node.lua
@@ -0,0 +1,88 @@
+-- JavaScript/TypeScript launch configs, wired to the js-debug-adapter
+-- (Microsoft's vscode-js-debug, bundled by Mason as a standalone
+-- multi-session DAP server) that dap.lua's mason-nvim-dap ensure_installed
+-- installs.
+--
+-- There's no nvim-dap-python equivalent for this: the one community plugin
+-- for it (mxsdev/nvim-dap-vscode-js) hardcodes the older
+-- `out/src/vsDebugServer.js` vscode-js-debug build layout, which doesn't
+-- match what Mason's js-debug-adapter package actually installs
+-- (`js-debug/src/dapDebugServer.js`) - so this resolves the Mason path
+-- directly instead, same approach as dap-python.lua's debugpy_path.
+--
+-- Lives under lua/config/ rather than lua/plugins/ (and is required
+-- eagerly from dap.lua's config()) because it isn't an installable plugin
+-- itself, just adapter/config wiring - same reason project_run.lua lives
+-- here instead of there.
+--
+-- js-debug-adapter is a multi-session server: debugging a script that
+-- spawns a worker thread arrives as a `startDebugging` reverse request
+-- rather than a second top-level session. nvim-dap's core (dap/session.lua)
+-- already handles that natively, so no extra plugin is needed for it either.
+local M = {}
+
+local function configurations()
+  return {
+    {
+      type = "pwa-node",
+      request = "launch",
+      name = "Launch file",
+      program = "${file}",
+      cwd = "${workspaceFolder}",
+    },
+    {
+      type = "pwa-node",
+      request = "attach",
+      name = "Attach to process",
+      processId = require("dap.utils").pick_process,
+      cwd = "${workspaceFolder}",
+    },
+  }
+end
+
+function M.setup()
+  local registry = require("mason-registry")
+  local pkg = registry.get_package("js-debug-adapter")
+
+  local function register()
+    local entrypoint = pkg:get_install_path() .. "/js-debug/src/dapDebugServer.js"
+
+    require("dap").adapters["pwa-node"] = {
+      type = "server",
+      host = "localhost",
+      port = "${port}",
+      executable = {
+        command = "node",
+        args = { entrypoint, "${port}" },
+      },
+    }
+
+    local dap = require("dap")
+    for _, filetype in ipairs({ "javascript", "typescript", "javascriptreact", "typescriptreact" }) do
+      dap.configurations[filetype] = configurations()
+    end
+  end
+
+  if pkg:is_installed() then
+    register()
+  else
+    -- Same reasoning as dap-python.lua: dap.lua's mason-nvim-dap
+    -- ensure_installed triggers the install, but that's async - on a fresh
+    -- machine (or before it finishes) the entrypoint doesn't exist on disk
+    -- yet, so wire up the adapter once the install actually completes
+    -- instead of pointing it at a path that isn't there yet.
+    vim.notify(
+      "js-debug-adapter not installed yet - dap.lua's ensure_installed should be"
+        .. " installing it now (check :Mason); run :MasonInstall js-debug-adapter"
+        .. " if it doesn't show up there. Debugging will work once it's done.",
+      vim.log.levels.WARN
+    )
+    registry:on("package:install:success", function(installed_pkg)
+      if installed_pkg.name == "js-debug-adapter" then
+        register()
+      end
+    end)
+  end
+end
+
+return M
diff --git a/neovim/.config/nvim/lua/config/keymaps.lua b/neovim/.config/nvim/lua/config/keymaps.lua
index 66e97a0..65e3236 100644
--- a/neovim/.config/nvim/lua/config/keymaps.lua
+++ b/neovim/.config/nvim/lua/config/keymaps.lua
@@ -14,6 +14,18 @@ map("t", "<C-k>", [[<C-\><C-n><C-w>k]])
 map("t", "<C-h>", [[<C-\><C-n><C-w>h]])
 map("t", "<C-l>", [[<C-\><C-n><C-w>l]])
 
+-- Copy to clipboard
+map("v", "<leader>y", '"+y')
+map("n", "<leader>Y", '"+yg_')
+map("n", "<leader>y", '"+y')
+map("n", "<leader>yy", '"+yy')
+
+-- Paste from clipboard
+map("n", "<leader>p", '"+p')
+map("n", "<leader>P", '"+P')
+map("v", "<leader>p", '"+p')
+map("v", "<leader>P", '"+P')
+
 -- Never use the arrow keys
 for _, key in ipairs({ "<Up>", "<Down>", "<Left>", "<Right>" }) do
   map({ "n", "i" }, key, "<Nop>")
diff --git a/neovim/.config/nvim/lua/config/options.lua b/neovim/.config/nvim/lua/config/options.lua
index be614e1..1282850 100644
--- a/neovim/.config/nvim/lua/config/options.lua
+++ b/neovim/.config/nvim/lua/config/options.lua
@@ -34,3 +34,9 @@ opt.hlsearch = true
 opt.incsearch = true
 opt.ignorecase = true
 opt.smartcase = true
+
+-- Project-local config (.nvim.lua) is handled by a custom autocmd in
+-- autocmds.lua instead of the core 'exrc' option: 'exrc' only checks the
+-- literal cwd at startup, once, so it misses a project's .nvim.lua whenever
+-- Neovim didn't start with cwd exactly there. Leave 'exrc' off to avoid
+-- double-sourcing the same file via both mechanisms.
diff --git a/neovim/.config/nvim/lua/config/project_run.lua b/neovim/.config/nvim/lua/config/project_run.lua
new file mode 100644
index 0000000..40c1795
--- /dev/null
+++ b/neovim/.config/nvim/lua/config/project_run.lua
@@ -0,0 +1,151 @@
+-- Single-source-of-truth helper for project-local run/debug configs, meant
+-- to be called once per config from a project's `.nvim.lua` (requires
+-- `opt.exrc` - see options.lua - and trusting the file once via
+-- `:help :trust`). One call registers both an overseer run task and a
+-- matching nvim-dap debug config, so a project states its command once
+-- instead of repeating it across a separate run-file and debug-file.
+--
+-- Example .nvim.lua (script invocation):
+--   require("config.project_run").python({
+--     name = "Run app",
+--     program = vim.fn.getcwd() .. "/main.py",
+--     args = { "--flag" }, -- optional, shared by both run and debug
+--   })
+--
+-- Example .nvim.lua (module invocation, `python -m <module>`):
+--   require("config.project_run").python({
+--     name = "Run app",
+--     module = "fastapi",
+--     args = { "dev", "app" },
+--   })
+--
+-- This shows "Run app" in the <leader>rr picker (plain execution) and in
+-- the <leader>dc picker (same script/module, under debugpy, breakpoints
+-- included). If <cwd>/.venv exists, both get VIRTUAL_ENV/PATH pointed at
+-- it, same as `uv run` (or `source .venv/bin/activate`) would - and the
+-- debug config additionally gets pythonPath set to that venv's interpreter,
+-- since debugpy runs the script with the literal interpreter it's told
+-- rather than resolving `python3` via PATH.
+--
+-- Example .nvim.lua (Node, script invocation):
+--   require("config.project_run").node({
+--     name = "Run app",
+--     program = vim.fn.getcwd() .. "/index.js",
+--     args = { "--flag" }, -- optional, shared by both run and debug
+--   })
+--
+-- Example .nvim.lua (Node, `npm run <script>` invocation):
+--   require("config.project_run").node({
+--     name = "Run app",
+--     npmScript = "dev",
+--   })
+
+local M = {}
+
+local function venv_dir()
+  local venv = vim.fn.getcwd() .. "/.venv"
+  if vim.fn.isdirectory(venv) == 0 then
+    return nil
+  end
+  return venv
+end
+
+local function venv_env(venv)
+  return {
+    VIRTUAL_ENV = venv,
+    PATH = venv .. "/bin:" .. vim.env.PATH,
+  }
+end
+
+function M.python(opts)
+  assert(opts.name, "project_run.python: opts.name is required")
+  assert(opts.program or opts.module, "project_run.python: opts.program or opts.module is required")
+
+  local venv = venv_dir()
+  local env = venv and venv_env(venv) or nil
+  local cmd = opts.module and { "python3", "-m", opts.module } or { "python3", opts.program }
+
+  require("overseer").register_template({
+    name = opts.name,
+    builder = function()
+      return {
+        cmd = cmd,
+        args = opts.args,
+        name = opts.name,
+        env = env,
+      }
+    end,
+  })
+
+  local dap = require("dap")
+  dap.configurations.python = dap.configurations.python or {}
+  table.insert(dap.configurations.python, {
+    type = "python",
+    request = "launch",
+    name = opts.name,
+    program = opts.program,
+    module = opts.module,
+    args = opts.args,
+    env = env,
+    -- nvim-dap-python only auto-detects an interpreter (VIRTUAL_ENV env var,
+    -- then a venv/.venv/env/.env folder search) when pythonPath/python isn't
+    -- already set - and debugpy needs the literal interpreter path here
+    -- regardless (it spawns it directly, not through a shell that'd resolve
+    -- `python3` via PATH the way env.PATH above does for the overseer task).
+    -- Set it explicitly from the same .venv we already found, so debugging
+    -- doesn't depend on that separate heuristic agreeing with us - without
+    -- this, a missed/wrong guess falls back to debugpy's own adapter venv,
+    -- which can't see the project's installed packages.
+    pythonPath = venv and (venv .. "/bin/python") or nil,
+  })
+end
+
+-- Node has no venv-style interpreter juggling to do - node_modules
+-- resolution is automatic - so this is a straight translation of opts into
+-- an overseer task plus a pwa-node dap config, into all four JS/TS
+-- filetypes (dap_node.lua registers the same four for its own defaults).
+function M.node(opts)
+  assert(opts.name, "project_run.node: opts.name is required")
+  assert(opts.program or opts.npmScript, "project_run.node: opts.program or opts.npmScript is required")
+
+  local cmd = opts.npmScript and { "npm", "run", opts.npmScript } or { "node", opts.program }
+
+  require("overseer").register_template({
+    name = opts.name,
+    builder = function()
+      return {
+        cmd = cmd,
+        args = opts.args,
+        name = opts.name,
+      }
+    end,
+  })
+
+  -- A fresh table per filetype - nvim-dap's session setup can stash
+  -- bookkeeping fields onto a running config, so the four filetypes
+  -- shouldn't share one table instance.
+  local function config()
+    local c = {
+      type = "pwa-node",
+      request = "launch",
+      name = opts.name,
+      args = opts.args,
+      cwd = vim.fn.getcwd(),
+    }
+    if opts.npmScript then
+      c.runtimeExecutable = "npm"
+      c.runtimeArgs = { "run", opts.npmScript }
+    else
+      c.program = opts.program
+    end
+    return c
+  end
+
+  local dap = require("dap")
+  for _, filetype in ipairs({ "javascript", "typescript", "javascriptreact", "typescriptreact" }) do
+    dap.configurations[filetype] = dap.configurations[filetype] or {}
+    table.insert(dap.configurations[filetype], config())
+  end
+end
+
+return M
diff --git a/neovim/.config/nvim/lua/plugins/claude-code.lua b/neovim/.config/nvim/lua/plugins/claude-code.lua
index 0390852..b2e881f 100644
--- a/neovim/.config/nvim/lua/plugins/claude-code.lua
+++ b/neovim/.config/nvim/lua/plugins/claude-code.lua
@@ -1,5 +1,6 @@
 return {
   "greggh/claude-code.nvim",
+  lazy = false,
   dependencies = { "nvim-lua/plenary.nvim" },
   cmd = { "ClaudeCode", "ClaudeCodeContinue", "ClaudeCodeResume", "ClaudeCodeVerbose" },
   config = function()
diff --git a/neovim/.config/nvim/lua/plugins/colorscheme.lua b/neovim/.config/nvim/lua/plugins/colorscheme.lua
index 457dc71..0349cf9 100644
--- a/neovim/.config/nvim/lua/plugins/colorscheme.lua
+++ b/neovim/.config/nvim/lua/plugins/colorscheme.lua
@@ -6,6 +6,14 @@ return {
     local ok = pcall(vim.cmd.colorscheme, "janah")
     if not ok then
       vim.cmd.colorscheme("desert")
+      return
     end
+
+    -- vim-janah predates floating windows and never defines NormalFloat/
+    -- FloatBorder, so they fall back to Neovim's near-black default and any
+    -- floating UI (:Mason, :Lazy, which-key's popup, ...) renders as a
+    -- mismatched black box. Match them to janah's own Normal/Comment colors.
+    vim.api.nvim_set_hl(0, "NormalFloat", { bg = "#262626", fg = "#dadada" })
+    vim.api.nvim_set_hl(0, "FloatBorder", { bg = "#262626", fg = "#585858" })
   end,
 }
diff --git a/neovim/.config/nvim/lua/plugins/dap-python.lua b/neovim/.config/nvim/lua/plugins/dap-python.lua
new file mode 100644
index 0000000..b61e0f4
--- /dev/null
+++ b/neovim/.config/nvim/lua/plugins/dap-python.lua
@@ -0,0 +1,71 @@
+-- Python launch configs (nvim-dap-python), wired to the debugpy adapter
+-- that mason-nvim-dap.nvim installs (dap.lua). Kept in its own file since
+-- this is the "per-language" half of debugging, parallel to how
+-- ftplugin/python.lua holds Python-only settings.
+return {
+  "mfussenegger/nvim-dap-python",
+  -- Not left to lazy-load off `ft = "python"`: dap.lua's <leader>dc picker
+  -- works from any window (not just a Python buffer) and needs
+  -- dap.adapters.python already registered by the time a config is picked,
+  -- even if no .py buffer has been opened yet this session.
+  lazy = false,
+  -- mason.nvim is listed directly (not just transitively via dap.lua)
+  -- because config() below needs require("mason-registry") to be loadable
+  -- from startup, same reasoning as lazy = false above.
+  dependencies = { "mfussenegger/nvim-dap", "mason-org/mason.nvim" },
+  config = function()
+    local registry = require("mason-registry")
+    local pkg = registry.get_package("debugpy")
+
+    -- debugpy_path is the interpreter that runs the debug *adapter* itself
+    -- (Mason's isolated venv) - it does not control which Python runs your
+    -- script. dap-python defaults that to the active venv/system python3;
+    -- project-specific venvs may need a manual `pythonPath` override in a
+    -- generated launch config later.
+    local debugpy_path = pkg:get_install_path() .. "/venv/bin/python"
+
+    local function setup()
+      require("dap-python").setup(debugpy_path)
+
+      -- nvim-dap-python doesn't expose adapter.options for tuning, and
+      -- nvim-dap's default terminate-request timeout (3s) is tight enough
+      -- that debugpy's real response can arrive just after nvim-dap already
+      -- gave up and moved on ("No callback found" in dap.log) - <leader>dt
+      -- still works, but dap.session() doesn't clear for a few extra
+      -- seconds, so <leader>dc right after can catch it still "active".
+      -- Wrap the adapter dap-python just registered to give it more room.
+      local dap = require("dap")
+      local base_adapter = dap.adapters.python
+      dap.adapters.python = function(cb, config)
+        base_adapter(function(adapter)
+          adapter.options = adapter.options or {}
+          adapter.options.disconnect_timeout_sec = 8
+          cb(adapter)
+        end, config)
+      end
+    end
+
+    if pkg:is_installed() then
+      setup()
+    else
+      -- dap.lua's mason-nvim-dap ensure_installed triggers debugpy's
+      -- install, but that's async - on a fresh machine (or before it
+      -- finishes) debugpy_path doesn't exist on disk yet, and <leader>dc
+      -- would fail with a raw ENOENT from debugpy itself instead of a clear
+      -- message. Wire up the adapter once the install actually completes
+      -- instead of pointing it at a path that isn't there yet.
+      vim.notify(
+        "debugpy not installed yet - dap.lua's ensure_installed should be"
+          .. " installing it now (check :Mason); run :MasonInstall debugpy"
+          .. " if it doesn't show up there. Debugging will work once it's"
+          .. " done.",
+        vim.log.levels.WARN
+      )
+      registry:on("package:install:success", function(installed_pkg)
+        if installed_pkg.name == "debugpy" then
+          setup()
+        end
+      end)
+    end
+  end,
+}
diff --git a/neovim/.config/nvim/lua/plugins/dap.lua b/neovim/.config/nvim/lua/plugins/dap.lua
new file mode 100644
index 0000000..975eaea
--- /dev/null
+++ b/neovim/.config/nvim/lua/plugins/dap.lua
@@ -0,0 +1,181 @@
+-- Debugging via nvim-dap. Adapter installs are bridged through Mason
+-- (mason-nvim-dap.nvim), the same pattern lsp.lua uses for language servers,
+-- so adding a debug adapter for another language later is just adding it to
+-- ensure_installed here - Python specifics live in dap-python.lua, Node
+-- specifics in lua/config/dap_node.lua.
+return {
+  "mfussenegger/nvim-dap",
+  -- Not left to lazy-load off `keys`: a project's .nvim.lua (see
+  -- lua/config/project_run.lua) needs `require("dap")` to work immediately
+  -- when exrc sources it, which requires the plugin already being on
+  -- runtimepath rather than deferred until a <leader>d keymap fires.
+  lazy = false,
+  dependencies = {
+    {
+      "rcarriga/nvim-dap-ui",
+      dependencies = { "nvim-neotest/nvim-nio" },
+    },
+    "theHamsta/nvim-dap-virtual-text",
+    {
+      "jay-babu/mason-nvim-dap.nvim",
+      dependencies = { "mason-org/mason.nvim" },
+    },
+  },
+  keys = {
+    { "<leader>db", function() require("dap").toggle_breakpoint() end, desc = "Toggle breakpoint" },
+    {
+      "<leader>dB",
+      function() require("dap").set_breakpoint(vim.fn.input("Breakpoint condition: ")) end,
+      desc = "Conditional breakpoint",
+    },
+    {
+      "<leader>dc",
+      function()
+        local dap = require("dap")
+
+        if dap.session() then
+          -- Existing session: resume past a breakpoint, or nvim-dap's
+          -- terminate/pause/restart prompt if active but not stopped.
+          -- This branch doesn't consult buffer filetype, so it's fine to
+          -- call from any window.
+          dap.continue()
+          return
+        end
+
+        -- No active session: pick a config to start. dap.continue()'s own
+        -- path for this (select_config_and_run) only offers
+        -- dap.configurations[<current buffer's filetype>], so calling it
+        -- from the task-output dock or some other non-source window finds
+        -- nothing. Flatten across every filetype instead - same as
+        -- <leader>rr does for run tasks - so this works from anywhere and
+        -- you just pick the config you want from the list.
+        local entries = {}
+        for filetype, configs in pairs(dap.configurations) do
+          for _, config in ipairs(configs) do
+            table.insert(entries, { config = config, filetype = filetype })
+          end
+        end
+
+        -- .vscode/launch.json (if present in cwd) is read on-demand by
+        -- nvim-dap's own "dap.launch.json" provider - dap.ext.vscode's
+        -- load_launchjs() is deprecated now that this exists. That provider
+        -- is normally consulted inside dap.continue()'s own
+        -- select_config_and_run, which we're bypassing above, so call it
+        -- directly here to fold its configs into the same picker - the
+        -- debug-side counterpart to overseer's tasks.json support (README's
+        -- Run configurations section). Pair a launch.json entry with a
+        -- same-named tasks.json entry for PyCharm-style "run or debug the
+        -- same thing".
+        local ok, launchjson_configs = pcall(dap.providers.configs["dap.launch.json"])
+        if ok then
+          for _, config in ipairs(launchjson_configs) do
+            table.insert(entries, { config = config, filetype = config.type })
+          end
+        end
+
+        if vim.tbl_isempty(entries) then
+          vim.notify("No debug configurations registered (see project_run.lua)", vim.log.levels.WARN)
+          return
+        end
+
+        vim.ui.select(entries, {
+          prompt = "Configuration: ",
+          format_item = function(e) return e.config.name end,
+        }, function(entry)
+          if entry then
+            -- Pass along the filetype the config was registered under (not
+            -- necessarily the invoking buffer's) so breakpoint-hit window
+            -- jumping still picks a sensible window.
+            dap.run(entry.config, { filetype = entry.filetype })
+          end
+        end)
+      end,
+      desc = "Continue / start debugging",
+    },
+    { "<leader>do", function() require("dap").step_over() end, desc = "Step over" },
+    { "<leader>di", function() require("dap").step_into() end, desc = "Step into" },
+    { "<leader>dO", function() require("dap").step_out() end, desc = "Step out" },
+    { "<leader>dt", function() require("dap").terminate() end, desc = "Terminate session" },
+    { "<leader>dr", function() require("dap").repl.toggle() end, desc = "Toggle REPL" },
+    { "<leader>du", function() require("dapui").toggle() end, desc = "Toggle debug UI" },
+  },
+  config = function()
+    require("dapui").setup()
+    require("nvim-dap-virtual-text").setup()
+
+    -- nvim-dap doesn't define these signs itself - it just places them
+    -- (breakpoints.lua, session.lua's DapStopped placement) and expects the
+    -- config to have already called sign_define, so without this nothing
+    -- renders: no breakpoint marker in the sign column, and no indication
+    -- of the current line when a session stops (the stop itself still
+    -- works, sign_place just errors silently into a pcall).
+    vim.fn.sign_define("DapBreakpoint", { text = "●", texthl = "DiagnosticError" })
+    vim.fn.sign_define("DapBreakpointCondition", { text = "◆", texthl = "DiagnosticWarn" })
+    vim.fn.sign_define("DapBreakpointRejected", { text = "✗", texthl = "DiagnosticError" })
+    vim.fn.sign_define("DapLogPoint", { text = "📝", texthl = "DiagnosticInfo" })
+    vim.fn.sign_define("DapStopped", { text = "▶", texthl = "DiagnosticWarn", linehl = "DapStoppedLine" })
+    -- default = true so a colorscheme (or later config) can override this
+    -- without a load-order fight; Visual is just a visible fallback.
+    vim.api.nvim_set_hl(0, "DapStoppedLine", { default = true, link = "Visual" })
+
+    -- handlers = {} opts out of mason-nvim-dap's automatic adapter
+    -- registration: nvim-dap-python (dap-python.lua) registers its own
+    -- "python" adapter/config, so we don't want a second one clobbering it.
+    -- Adding a language without its own dap-<lang>.lua later should drop
+    -- this override so its adapter gets auto-registered instead.
+    require("mason-nvim-dap").setup({
+      -- ensure_installed wants nvim-dap *adapter/source* names, not Mason
+      -- *package* names - mason-nvim-dap looks each entry up in its own
+      -- name -> package mapping (source.lua: python -> debugpy) and just
+      -- silently skips anything it doesn't recognize, no error/log. Passing
+      -- "debugpy" here (the package name) matched nothing, so it never
+      -- triggered an install at all.
+      ensure_installed = { "python", "js" },
+      automatic_installation = true,
+      handlers = {},
+    })
+
+    -- Node/JS/TS adapter + default configs - not left to mason-nvim-dap's
+    -- own handler since "js" has no default adapter mapping there (only the
+    -- deprecated node2 does), see lua/config/dap_node.lua for why.
+    require("config.dap_node").setup()
+
+    local dap, dapui = require("dap"), require("dapui")
+
+    -- nvim-dap jumps to the stopped line using Neovim's 'switchbuf' option,
+    -- which defaults to "uselast": reuse the current window if it's already
+    -- a plain/source buffer, else fall back to the alternate window - and
+    -- if neither applies (e.g. <leader>dc was started from the task-output
+    -- dock or some other non-source window, which the picker now allows),
+    -- it silently does nothing. No error, no jump - the session *is*
+    -- stopped (stepping/continuing still works), it just never shows where.
+    -- Append "vsplit" so there's always a guaranteed-successful last resort
+    -- that opens the source file if nothing else matched.
+    dap.defaults.fallback.switchbuf = "usevisible,useopen,uselast,vsplit"
+
+    -- Open/close dap-ui automatically around a debug session, so <leader>du
+    -- is only needed to bring it back after manually closing it mid-session.
+    dap.listeners.after.event_initialized["dapui_config"] = function()
+      dapui.open()
+    end
+    dap.listeners.before.event_terminated["dapui_config"] = function()
+      dapui.close()
+    end
+    dap.listeners.before.event_exited["dapui_config"] = function()
+      dapui.close()
+    end
+
+    -- These events arrive asynchronously over debugpy's socket (a libuv
+    -- callback, not a keypress), and nvim-dap updates its state - cursor
+    -- position, signs, dapui panels - without that alone forcing Neovim to
+    -- repaint. So hitting a breakpoint, continuing past one, or a session
+    -- ending can all silently not *look* like anything happened until the
+    -- next keystroke forces a redraw that reveals the already-current
+    -- state (e.g. <leader>dc appearing to need pressing twice to resume).
+    for _, event in ipairs({ "event_stopped", "event_continued", "event_terminated", "event_exited" }) do
+      dap.listeners.after[event]["dap_redraw"] = function()
+        vim.cmd("redraw")
+      end
+    end
+  end,
+}
diff --git a/neovim/.config/nvim/lua/plugins/editing.lua b/neovim/.config/nvim/lua/plugins/editing.lua
index c1d5567..62b1dbf 100644
--- a/neovim/.config/nvim/lua/plugins/editing.lua
+++ b/neovim/.config/nvim/lua/plugins/editing.lua
@@ -1,13 +1,3 @@
 return {
-  {
-    "preservim/nerdcommenter",
-    init = function()
-      vim.g.NERDSpaceDelims = 1
-      vim.g.NERDCompactSexyComs = 1
-      vim.g.NERDDefaultAlign = "left"
-      vim.g.NERDCommentEmptyLines = 1
-      vim.g.NERDTrimTrailingWhitespace = 1
-    end,
-  },
   "unblevable/quick-scope",
 }
diff --git a/neovim/.config/nvim/lua/plugins/fuzzyfinder.lua b/neovim/.config/nvim/lua/plugins/fuzzyfinder.lua
index 444d9ff..2ed9970 100644
--- a/neovim/.config/nvim/lua/plugins/fuzzyfinder.lua
+++ b/neovim/.config/nvim/lua/plugins/fuzzyfinder.lua
@@ -1,10 +1,32 @@
 return {
-  "ctrlpvim/ctrlp.vim",
-  init = function()
-    -- Use ripgrep for listing files (fast, respects .gitignore)
-    if vim.fn.executable("rg") == 1 then
-      vim.g.ctrlp_user_command = 'rg %s --files --color=never --glob ""'
-      vim.g.ctrlp_use_caching = 0
-    end
+  "nvim-telescope/telescope.nvim",
+  -- Not left to lazy-load off `keys`: telescope-ui-select's vim.ui.select()
+  -- override (below) needs to be installed from startup, otherwise
+  -- overseer's <leader>rr / nvim-dap-python's <leader>dc pickers fall back
+  -- to Neovim's default list until something (e.g. <C-p>) happens to
+  -- trigger telescope's own lazy-load first.
+  lazy = false,
+  dependencies = {
+    "nvim-lua/plenary.nvim",
+    "nvim-telescope/telescope-ui-select.nvim",
+  },
+  keys = {
+    { "<C-p>", "<cmd>Telescope find_files<cr>" },
+    { "<leader>fg", "<cmd>Telescope live_grep<cr>" },
+    { "<leader>fb", "<cmd>Telescope buffers<cr>" },
+  },
+  config = function()
+    -- telescope-ui-select makes vim.ui.select() - overseer's <leader>rr
+    -- template picker, nvim-dap-python's launch-config picker, LSP code
+    -- actions, etc. - a scrollable/fuzzy-searchable Telescope window
+    -- instead of Neovim's default numbered-list-in-the-cmdline prompt.
+    require("telescope").setup({
+      extensions = {
+        ["ui-select"] = {
+          require("telescope.themes").get_dropdown({}),
+        },
+      },
+    })
+    require("telescope").load_extension("ui-select")
   end,
 }
diff --git a/neovim/.config/nvim/lua/plugins/git.lua b/neovim/.config/nvim/lua/plugins/git.lua
index 8402905..ef07442 100644
--- a/neovim/.config/nvim/lua/plugins/git.lua
+++ b/neovim/.config/nvim/lua/plugins/git.lua
@@ -1,4 +1,7 @@
 return {
   "tpope/vim-fugitive",
-  "mhinz/vim-signify",
+  {
+    "lewis6991/gitsigns.nvim",
+    opts = {},
+  },
 }
diff --git a/neovim/.config/nvim/lua/plugins/indent-detect.lua b/neovim/.config/nvim/lua/plugins/indent-detect.lua
new file mode 100644
index 0000000..945769c
--- /dev/null
+++ b/neovim/.config/nvim/lua/plugins/indent-detect.lua
@@ -0,0 +1,8 @@
+-- Detects each buffer's actual indentation/spacing on open and sets
+-- shiftwidth/tabstop/expandtab to match, rather than relying solely on
+-- ftplugin defaults (e.g. ftplugin/python.lua) or global options.opt.
+return {
+  "nmac427/guess-indent.nvim",
+  event = { "BufReadPost", "BufNewFile" },
+  opts = {},
+}
diff --git a/neovim/.config/nvim/lua/plugins/langs.lua b/neovim/.config/nvim/lua/plugins/langs.lua
deleted file mode 100644
index 7bf22d4..0000000
--- a/neovim/.config/nvim/lua/plugins/langs.lua
+++ /dev/null
@@ -1,14 +0,0 @@
-return {
-  {
-    "chase/vim-ansible-yaml",
-    cond = function()
-      return vim.fn.executable("ansible") == 1
-    end,
-  },
-  {
-    "hashivim/vim-terraform",
-    cond = function()
-      return vim.fn.executable("terraform") == 1
-    end,
-  },
-}
diff --git a/neovim/.config/nvim/lua/plugins/overseer.lua b/neovim/.config/nvim/lua/plugins/overseer.lua
new file mode 100644
index 0000000..99d0f5f
--- /dev/null
+++ b/neovim/.config/nvim/lua/plugins/overseer.lua
@@ -0,0 +1,57 @@
+-- Run configurations (PyCharm-style "run this again"), language-agnostic:
+-- works for npm scripts, make, cargo, arbitrary shell commands, python
+-- scripts, etc, unlike DAP which is Python-only for now.
+return {
+  "stevearc/overseer.nvim",
+  -- Not left to lazy-load off `cmd`/`keys`: a project's .nvim.lua (see
+  -- lua/config/project_run.lua) needs `require("overseer")` to work
+  -- immediately when exrc sources it, which requires the plugin already
+  -- being on runtimepath rather than deferred until first use.
+  lazy = false,
+  keys = {
+    { "<leader>rr", "<cmd>OverseerRun<cr>", desc = "Run task" },
+    {
+      "<leader>rl",
+      function()
+        -- :OverseerRestartLast exists in current overseer.nvim versions; the
+        -- run_action fallback covers older/newer versions that lack it
+        -- rather than hard-failing the keymap.
+        if vim.fn.exists(":OverseerRestartLast") == 2 then
+          vim.cmd("OverseerRestartLast")
+          return
+        end
+        local overseer = require("overseer")
+        local tasks = overseer.list_tasks({ recent_first = true })
+        if vim.tbl_isempty(tasks) then
+          vim.notify("No previous task to rerun", vim.log.levels.WARN)
+        else
+          overseer.run_action(tasks[1], "restart")
+        end
+      end,
+      desc = "Rerun last task",
+    },
+    { "<leader>ro", "<cmd>OverseerToggle<cr>", desc = "Toggle task list/output" },
+    { "<leader>rq", "<cmd>OverseerQuickAction<cr>", desc = "Quick action on task" },
+  },
+  opts = {
+    -- Patches nvim-dap so a debug config can set preLaunchTask/postDebugTask
+    -- to an overseer task name (or "${defaultBuildTask}" for whatever task
+    -- is tagged BUILD) - lets a dap.configurations entry build before it
+    -- launches the debugger. See README's Debugging section.
+    dap = true,
+    -- overseer's actual default components (on_exit_set_status,
+    -- on_complete_notify, on_complete_dispose) don't open the output panel
+    -- on their own - without open_output added here, starting any task
+    -- (whether from a template, .nvim.lua/project_run.lua, or auto-detected
+    -- npm/make scripts) runs silently until you manually <leader>ro to look.
+    -- Adding it here applies to every task, not just custom ones.
+    component_aliases = {
+      default = {
+        "on_exit_set_status",
+        "on_complete_notify",
+        { "on_complete_dispose", require_view = { "SUCCESS", "FAILURE" } },
+        { "open_output", direction = "dock", focus = false, on_start = "always" },
+      },
+    },
+  },
+}
diff --git a/neovim/.config/nvim/lua/plugins/statusline.lua b/neovim/.config/nvim/lua/plugins/statusline.lua
index b93b34c..17741a6 100644
--- a/neovim/.config/nvim/lua/plugins/statusline.lua
+++ b/neovim/.config/nvim/lua/plugins/statusline.lua
@@ -1,23 +1,5 @@
 return {
-  "bling/vim-airline",
-  lazy = false,
-  dependencies = {
-    "vim-airline/vim-airline-themes",
-    "edkolev/tmuxline.vim",
-  },
-  init = function()
-    -- On arch linux install the following:
-    -- otf-powerline-symbols-git
-    -- powerline-fonts-git
-    vim.g.airline_powerline_fonts = 1
-    vim.g["airline#extensions#tabline#enabled"] = 1
-
-    -- vim.g dict reads return a copy, not a live reference, so the nested
-    -- field has to be set via a local table and reassigned.
-    local symbols = vim.g.airline_symbols or {}
-    symbols.space = "\u{a0}"
-    vim.g.airline_symbols = symbols
-
-    vim.opt.laststatus = 2
-  end,
+  "nvim-lualine/lualine.nvim",
+  dependencies = { "nvim-tree/nvim-web-devicons" },
+  opts = {},
 }
diff --git a/neovim/.config/nvim/lua/plugins/toggleterm.lua b/neovim/.config/nvim/lua/plugins/toggleterm.lua
new file mode 100644
index 0000000..b8067a3
--- /dev/null
+++ b/neovim/.config/nvim/lua/plugins/toggleterm.lua
@@ -0,0 +1,18 @@
+-- Scratch terminal for running arbitrary shell commands, toggled like
+-- claude-code.nvim's own <C-,> - open/close (not kill) a persistent split.
+return {
+  "akinsho/toggleterm.nvim",
+  lazy = false, -- global <C-.> toggle must work from any window, not just after some trigger event
+  opts = {
+    open_mapping = [[<C-.>]], -- registers n, t (terminal_mappings) and i (insert_mappings) mode maps automatically
+    direction = "vertical",
+    -- toggleterm's vertical direction always opens via "botright vsplit" internally,
+    -- so this already matches claude-code.nvim's right-side placement without
+    -- touching 'splitright'.
+    size = function(term)
+      if term.direction == "vertical" then
+        return math.floor(vim.o.columns * 0.3) -- matches claude-code.nvim's window.position ratio
+      end
+    end,
+  },
+}
diff --git a/neovim/.config/nvim/lua/plugins/which-key.lua b/neovim/.config/nvim/lua/plugins/which-key.lua
new file mode 100644
index 0000000..190d651
--- /dev/null
+++ b/neovim/.config/nvim/lua/plugins/which-key.lua
@@ -0,0 +1,17 @@
+-- Popup showing available keymaps/groups as you type a prefix like
+-- <leader>d or <leader>r, so the debug/run namespaces stay discoverable
+-- without memorizing every letter. Auto-discovers each keymap's own `desc`
+-- field from dap.lua/overseer.lua/etc - only the group headers need
+-- registering here.
+return {
+  "folke/which-key.nvim",
+  event = "VeryLazy",
+  opts = {
+    spec = {
+      { "<leader>d", group = "Debug", icon = "🐞" },
+      { "<leader>r", group = "Run", icon = "▶" },
+      { "<leader>f", group = "Find" },
+      { "<leader>e", group = "Explorer" },
+    },
+  },
+}
diff --git a/neovim/.config/nvim/nvim.log b/neovim/.config/nvim/nvim.log
new file mode 100644
index 0000000..7158332
--- /dev/null
+++ b/neovim/.config/nvim/nvim.log
@@ -0,0 +1,6 @@
+WRN 2026-09-14T16:30:21.846 ?.4836     server_start:197: Failed to start server: operation not permitted: /tmp/claude-501/nvim.tom/StQYRj/nvim.4836.0
+WRN 2026-09-14T16:30:26.261 ?.4845     server_start:197: Failed to start server: operation not permitted: /tmp/claude-501/nvim.tom/K4I50n/nvim.4845.0
+WRN 2026-09-14T16:31:13.471 ?.4921     server_start:197: Failed to start server: operation not permitted: /tmp/claude-501/nvim.tom/OkXebD/nvim.4921.0
+WRN 2026-09-14T16:33:09.911 ?.5030     server_start:197: Failed to start server: operation not permitted: /tmp/claude-501/nvim.tom/e73IV2/nvim.5030.0
+WRN 2026-09-15T10:45:56.983 ?.34498    server_start:197: Failed to start server: operation not permitted: /tmp/claude-501/nvim.tom/R2azoM/nvim.34498.0
+WRN 2026-09-15T11:05:45.401 c/nvim.35169.0 server_start:197: Failed to start server: operation not permitted: /tmp/claude-501/nvim.tom/8xMtRC/nvim.38701.0
diff --git a/nvim.log b/nvim.log
new file mode 100644
index 0000000..54cac1c
--- /dev/null
+++ b/nvim.log
@@ -0,0 +1,4 @@
+WRN 2026-09-15T10:52:53.198 c/nvim.35169.0 server_start:197: Failed to start server: operation not permitted: /tmp/claude-501/nvim.tom/70FEV5/nvim.35600.0
+ERR 2026-09-15T10:52:53.200 c/nvim.35169.0 pty_proc_spawn:190: forkpty failed: Operation not permitted
+WRN 2026-09-15T10:53:00.647 c/nvim.35169.0 server_start:197: Failed to start server: operation not permitted: /tmp/claude-501/nvim.tom/NuetHc/nvim.35627.0
+ERR 2026-09-15T10:53:00.650 c/nvim.35169.0 pty_proc_spawn:190: forkpty failed: Operation not permitted