Added agent skills for selectFromList and performance

Co-Authored-By: GitHub Copilot <noreply@github.com>

Author: elia

.agents/skills/improving-performance/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: improving-performance
+description: Process for systematically finding and fixing performance bottlenecks in code. Use when asked to improve performance, speed up code, or investigate slowness — covers analysis, prioritization, incremental delivery via PRD loop.
+---
+
+# Improving Performance
+
+A systematic process for identifying and fixing performance bottlenecks, delivered as incremental commits.
+
+## Process
+
+### 1. Analyze the Hot Path
+
+Read the full code and trace the critical path end-to-end. Identify what runs on every user action (keystroke, scroll, click). Write findings as comments at the top of the main file:
+
+```
+// BOTTLENECK 1: [description] — [impact] — Fix: [approach]
+// BOTTLENECK 2: ...
+// PRIORITY ORDER: list by biggest impact first
+```
+
+This serves as both documentation and a working checklist.
+
+### 2. Write a PRD
+
+Create `doc/specs/<feature>-performance.md` with checkbox tasks grouped by category:
+
+- **Hot loop optimizations** — algorithmic improvements in the innermost loops
+- **Rendering optimizations** — reduce DOM work, skip unnecessary operations
+- **Structural changes** — virtual scrolling, caching, architecture shifts
+
+Order categories from easiest/safest to most impactful/risky.
+
+### 3. Execute via Ralph Loop
+
+One commit per category using fresh subagent sessions. Each iteration:
+
+1. Launch subagent with specific tasks and coding style rules
+2. Verify changes (lint, read key sections)
+3. Commit with descriptive message
+4. Update PRD checkboxes and progress log
+
+### 4. Archive
+
+Move completed PRD to `doc/specs/completed/`, remove progress file.
+
+## Common Bottleneck Patterns
+
+### Allocation in hot loops
+
+Creating arrays/objects per iteration causes GC pressure. Fix: pre-allocate and reuse.
+
+```js
+// Bad: fresh array per call, called 10k times
+let matrix = Array(n)
+  .fill()
+  .map(() => Array(m).fill(0))
+
+// Good: module-level typed array, grown as needed
+let _matrix = new Float64Array(maxN * maxM)
+```
+
+### Repeated string operations
+
+`toLowerCase()`, `trim()`, regex in inner loops. Fix: pre-compute once, pass through.
+
+```js
+// Bad: lowercased per-character per-item per-keystroke
+if (needle[i].toLowerCase() === hay[j].toLowerCase())
+
+// Good: pre-lowercase at init, compare directly
+item._lower = item.label.toLowerCase()  // once
+if (needle[i] === hayLower[j])           // hot loop
+```
+
+### Full DOM rebuild
+
+`replaceChildren()` with all elements when only a slice is visible. Fix: virtual scrolling.
+
+### Unnecessary work
+
+Sorting when all scores are equal, scanning full list when filter only grew. Fix: conditional skip, incremental narrowing.
+
+### Regex in tight loops
+
+`/pattern/.test(ch)` per character. Fix: charCode comparisons.
+
+```js
+// Bad
+static isAlnum(ch) { return /[a-zA-Z0-9]/.test(ch) }
+
+// Good
+static isAlnum(ch) {
+  let c = ch.charCodeAt(0)
+  return (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122)
+}
+```
+
+## Subagent Prompt Template
+
+When delegating to a subagent, include:
+
+1. **File to edit** — absolute path
+2. **Tasks** — numbered list with before/after code snippets
+3. **Coding style rules** — project conventions (indent, quotes, semicolons, `let` vs `const`)
+4. **Explicit instruction** to make ALL changes and return a summary
+
+Keep task descriptions concrete with code examples, not abstract descriptions.

.agents/skills/refactoring-select-from-list/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: refactoring-select-from-list
+description: Domain knowledge for the selectFromList webview component in vscode-textmate. Use when modifying, debugging, or extending the fuzzy-search selector UI — covers architecture, data flow, key files, and known constraints.
+---
+
+# selectFromList Architecture
+
+A webview-based fuzzy-search selector that replaces VS Code's native QuickPick for richer interaction (multi-select, range select, alternate actions).
+
+## Key Files
+
+| File                            | Role                                                                                                     |
+| ------------------------------- | -------------------------------------------------------------------------------------------------------- |
+| `src/selectFromList.js`         | Extension-side provider — creates/reuses webview, posts items, resolves promises                         |
+| `src/selectFromList/main.js`    | Webview-side — `List` class (virtual scrolling, selection), `FuzzySearch` class (TextMate-style ranking) |
+| `src/selectFromList/index.html` | HTML shell with inline CSS, search input, CSP nonces                                                     |
+| `src/selectFromList.json`       | Manifest fragment (contributes views, commands, configuration)                                           |
+
+## Data Flow
+
+```
+Command invokes showSelectFromList(items, options)
+  → chooseItems() on provider
+    → createWebviewPanel() (reuses if alive) or sidebar path
+    → reveal() panel (so it's visible before init)
+    → await _isReady (resolves when webview posts "ready")
+    → postMessage({ type: "init", items, requestId })
+  → webview receives init
+    → pre-lowercases labels (_lowerLabel, _lowerDescription)
+    → computeVisible() → render() (virtual scrolling)
+    → focus search input
+  → user types → 30ms debounce → computeVisible() → render()
+  → user submits (Enter / double-click)
+    → postMessage({ type: "submit", indexes, requestId })
+  → provider resolves promise with selected items
+```
+
+## FuzzySearch (TextMate port)
+
+- `rank(filter, candidate, candidateLower, out)` — entry point, filter is already lowercase
+- `calculateRank(lhs, rhs, rhsLower, out)` — matrix-based scoring from TextMate's `ranker.cc`
+- `rankFile(filter, filename, directory, filenameLower, directoryLower)` — tries filename first, falls back to full path
+- `isSubset(needle, haystackLower)` — fast pre-check before full ranking
+- Pre-allocated typed arrays (`_matrix`, `_first`, `_last`, `_capitals`) avoid GC pressure
+
+## Performance Characteristics
+
+- **Virtual scrolling** — only ~60 DOM nodes regardless of list size (20-row overscan)
+- **Incremental filtering** — typing more chars narrows from previous matches, not full list
+- **Pre-lowercased labels** — `toLowerCase()` called once at init, not per-char in hot loop
+- **Panel reuse** — `retainContextWhenHidden: true`, panel is reused across opens
+
+## Constraints
+
+- The `FuzzySearch.calculateRank` algorithm is a TextMate port — modify with extreme care
+- `requestId` prevents stale responses from previous invocations
+- `close()` disposes panel (panel path) or hides sidebar — different teardown per render mode
+- The `_isReady` promise pattern: created fresh when panel/sidebar is new, stays resolved when reusing