Fix differential badge design for mobile search results (rebased)

.claude/hooks/session-start.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+# SessionStart hook for Claude Code on the web.
+# The app is engine-strict on Node 24.x / npm 11.x, but web containers ship an
+# older Node on PATH, so nothing installs or runs until Node 24 is present.
+# Installs Node 24 into $HOME/.node24 (cached with the container), exposes it
+# via $CLAUDE_ENV_FILE, and installs npm dependencies.
+set -euo pipefail
+
+if [ "${CLAUDE_CODE_REMOTE:-}" != "true" ]; then
+  exit 0
+fi
+
+NODE_VERSION="24.13.0"
+NODE_HOME="$HOME/.node24"
+NODE_BIN="$NODE_HOME/node-v${NODE_VERSION}-linux-x64/bin"
+
+current_major="$(node -v 2>/dev/null | sed -E 's/^v([0-9]+).*/\1/' || echo 0)"
+if [ "$current_major" != "24" ] && [ ! -x "$NODE_BIN/node" ]; then
+  echo "[session-start] Installing Node ${NODE_VERSION} (found v${current_major:-none})"
+  mkdir -p "$NODE_HOME"
+  curl -fsSL "https://nodejs.org/dist/v${NODE_VERSION}/node-v${NODE_VERSION}-linux-x64.tar.xz" \
+    | tar -xJ -C "$NODE_HOME"
+fi
+
+if [ -x "$NODE_BIN/node" ]; then
+  export PATH="$NODE_BIN:$PATH"
+  echo "export PATH=\"$NODE_BIN:\$PATH\"" >> "$CLAUDE_ENV_FILE"
+fi
+
+echo "[session-start] Using node $(node -v) / npm $(npm -v)"
+
+cd "$CLAUDE_PROJECT_DIR"
+# npm ci keeps the lockfile untouched (npm install rewrites peer/optional
+# metadata and dirties the worktree); skip entirely when the cached container
+# already has node_modules.
+if [ ! -d node_modules ]; then
+  npm ci --no-audit --no-fund
+  echo "[session-start] Dependencies installed"
+else
+  echo "[session-start] node_modules already present, skipping install"
+fi

.claude/settings.json

@@ -0,0 +1,14 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/session-start.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

.cursor/mcp.json

@@ -0,0 +1,7 @@
+{
+  "mcpServers": {
+    "supabase": {
+      "url": "https://mcp.supabase.com/mcp?project_ref=sjrfecxgysukkwxsowpy&read_only=true"
+    }
+  }
+}

.cursor/skills/cursor-codebase-indexing/SKILL.md

@@ -0,0 +1,234 @@
+---
+name: cursor-codebase-indexing
+description: 'Set up and optimize Cursor codebase indexing for semantic code search
+  and @Codebase queries.
+
+  Triggers on "cursor index", "codebase indexing", "index codebase", "cursor semantic
+  search",
+
+  "@codebase", "cursor embeddings".
+
+  '
+allowed-tools: Read, Write, Edit, Bash(cmd:*)
+version: 1.0.0
+license: MIT
+author: Jeremy Longshore <jeremy@intentsolutions.io>
+tags:
+  - saas
+  - cursor
+  - cursor-codebase
+compatibility: Designed for Claude Code, also compatible with Codex and OpenClaw
+---
+
+# Cursor Codebase Indexing
+
+Set up and optimize Cursor's codebase indexing system. Indexing creates embeddings of your code, enabling `@Codebase` semantic search and improving AI context awareness across Chat, Composer, and Agent mode.
+
+## How Indexing Works
+
+```
+Your Code Files
+      │
+      ▼
+  Syntax Chunking ─── splits files into meaningful code blocks
+      │
+      ▼
+  Embedding Generation ─── converts chunks to vector representations
+      │
+      ▼
+  Vector Storage (Turbopuffer) ─── cloud-hosted nearest-neighbor search
+      │
+      ▼
+  @Codebase Query ─── your question → embedding → similarity search → relevant chunks
+```
+
+### Key Architecture Details
+
+- **Merkle tree** for change detection: only modified files are re-indexed (every 10 minutes)
+- **No plaintext storage**: code is not stored server-side; only embeddings and obfuscated metadata
+- **Privacy Mode compatible**: with Privacy Mode on, embeddings are computed without retaining source code
+- Indexing runs in the background; small projects complete in seconds, large projects (50K+ files) may take hours initially
+
+## Initial Setup
+
+1. Open your project in Cursor
+2. Indexing starts automatically on first open
+3. Check status: look at the bottom status bar for "Indexing..." indicator
+4. View indexed files: `Cursor Settings` > `Features` > `Codebase Indexing` > `View included files`
+
+### Verify Indexing Status
+
+The status bar shows:
+
+- **"Indexing..."** with progress indicator -- initial indexing in progress
+- **"Indexed"** -- indexing complete, `@Codebase` queries are available
+- No indicator -- indexing may be disabled or not started
+
+## Configuration
+
+### .cursorignore
+
+Exclude files from indexing and AI features. Place in project root. Uses `.gitignore` syntax:
+
+```gitignore
+# .cursorignore
+
+# Build artifacts (large, not useful for AI context)
+dist/
+build/
+out/
+.next/
+target/
+
+# Dependencies
+node_modules/
+vendor/
+venv/
+.venv/
+
+# Generated files
+*.min.js
+*.min.css
+*.bundle.js
+*.map
+*.lock
+
+# Large data files
+*.csv
+*.sql
+*.sqlite
+*.parquet
+fixtures/
+seed-data/
+
+# Secrets (defense in depth -- also use .gitignore)
+.env*
+**/secrets/
+**/credentials/
+```
+
+### .cursorindexingignore
+
+Exclude files from indexing only but keep them accessible to AI features when explicitly referenced:
+
+```gitignore
+# .cursorindexingignore
+
+# Large test fixtures -- don't index, but allow @Files reference
+tests/fixtures/
+e2e/recordings/
+
+# Documentation build output
+docs/.vitepress/dist/
+```
+
+**Difference:** `.cursorignore` hides files from both indexing and AI features. `.cursorindexingignore` only excludes from the index; files can still be referenced via `@Files`.
+
+### Default Exclusions
+
+Cursor automatically excludes everything in `.gitignore`. You only need `.cursorignore` for files tracked by git that you want to exclude from AI.
+
+## Using the Index
+
+### @Codebase Queries
+
+Ask semantic questions about your entire codebase:
+
+```
+@Codebase where is user authentication handled?
+
+@Codebase show me all API endpoints that accept file uploads
+
+@Codebase how does the payment processing flow work?
+
+@Codebase find all places where we connect to Redis
+```
+
+`@Codebase` performs a nearest-neighbor search using your question's embedding. It returns the most semantically similar code chunks, even if they do not contain the exact keywords you used.
+
+### @Codebase vs @Files vs Text Search
+
+| Method         | When to Use                             | Context Cost        |
+| -------------- | --------------------------------------- | ------------------- |
+| `@Codebase`    | Discovery -- you don't know which files | High (many chunks)  |
+| `@Files`       | You know exactly which file             | Low (one file)      |
+| `@Folders`     | You know the directory                  | Medium-High         |
+| `Ctrl+Shift+F` | Exact text/regex match                  | N/A (editor search) |
+
+Use `@Codebase` for discovery, then switch to `@Files` once you know where the code lives.
+
+## Optimization for Large Projects
+
+### Monorepo Strategy
+
+For monorepos with many packages, open the specific package directory instead of the root:
+
+```bash
+# Instead of opening the entire monorepo:
+cursor /path/to/monorepo           # Indexes everything -- slow
+
+# Open the specific package:
+cursor /path/to/monorepo/packages/api   # Indexes only this package -- fast
+```
+
+Or use `.cursorignore` at the root to exclude packages you are not actively working on:
+
+```gitignore
+# .cursorignore -- monorepo, focus on api and shared
+packages/web/
+packages/mobile/
+packages/admin/
+# packages/api/    ← not listed, so it IS indexed
+# packages/shared/ ← not listed, so it IS indexed
+```
+
+### Re-Indexing
+
+If search results are stale or indexing appears stuck:
+
+1. `Cmd+Shift+P` > `Cursor: Resync Index`
+2. Wait for status bar to show indexing progress
+3. If that fails, delete the local cache:
+   - macOS: `~/Library/Application Support/Cursor/Cache/`
+   - Linux: `~/.config/Cursor/Cache/`
+   - Windows: `%APPDATA%\Cursor\Cache\`
+4. Restart Cursor and allow full re-index
+
+### File Watcher Limits (Linux)
+
+On Linux, large projects may hit the file watcher limit:
+
+```bash
+# Check current limit
+cat /proc/sys/fs/inotify/max_user_watches
+
+# Increase (temporary)
+sudo sysctl fs.inotify.max_user_watches=524288
+
+# Increase (permanent)
+echo "fs.inotify.max_user_watches=524288" | sudo tee -a /etc/sysctl.conf
+sudo sysctl -p
+```
+
+## Enterprise Considerations
+
+- **Data residency**: Embeddings are stored in Turbopuffer (cloud). Obfuscated filenames and no plaintext code, but metadata exists
+- **Privacy Mode**: With Privacy Mode on, embeddings are computed with zero data retention at the provider
+- **Air-gapped environments**: Indexing requires network access to Cursor's embedding API. Not available offline
+- **Indexing scope**: Only files in the currently open workspace are indexed. Closing a project removes its index from active queries
+
+## Troubleshooting
+
+| Symptom                      | Cause                               | Fix                              |
+| ---------------------------- | ----------------------------------- | -------------------------------- |
+| @Codebase returns no results | Index not built                     | Wait for "Indexed" in status bar |
+| Search misses known files    | File in .gitignore or .cursorignore | Check ignore files               |
+| Indexing stuck at N%         | Large project or network issue      | Resync index via Command Palette |
+| Stale results after refactor | Index not yet updated               | Wait 10 min or manual resync     |
+| High CPU during indexing     | Initial embedding computation       | Normal for first run; subsides   |
+
+## Resources
+
+- [Codebase Indexing Docs](https://docs.cursor.com/context/codebase-indexing)
+- [Ignore Files](https://docs.cursor.com/context/ignore-files)
+- [Secure Codebase Indexing](https://cursor.com/blog/secure-codebase-indexing)

.cursor/skills/supabase-postgres-best-practices/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: supabase-postgres-best-practices
+description: Postgres performance optimization and best practices from Supabase. Use this skill when writing, reviewing, or optimizing Postgres queries, schema designs, or database configurations.
+license: MIT
+metadata:
+  author: supabase
+  version: "1.1.1"
+  organization: Supabase
+  date: January 2026
+  abstract: Comprehensive Postgres performance optimization guide for developers using Supabase and Postgres. Contains performance rules across 8 categories, prioritized by impact from critical (query performance, connection management) to incremental (advanced features). Each rule includes detailed explanations, incorrect vs. correct SQL examples, query plan analysis, and specific performance metrics to guide automated optimization and code generation.
+---
+
+# Supabase Postgres Best Practices
+
+Comprehensive performance optimization guide for Postgres, maintained by Supabase. Contains rules across 8 categories, prioritized by impact to guide automated query optimization and schema design.
+
+## When to Apply
+
+Reference these guidelines when:
+
+- Writing SQL queries or designing schemas
+- Implementing indexes or query optimization
+- Reviewing database performance issues
+- Configuring connection pooling or scaling
+- Optimizing for Postgres-specific features
+- Working with Row-Level Security (RLS)
+
+## Rule Categories by Priority
+
+| Priority | Category                 | Impact      | Prefix      |
+| -------- | ------------------------ | ----------- | ----------- |
+| 1        | Query Performance        | CRITICAL    | `query-`    |
+| 2        | Connection Management    | CRITICAL    | `conn-`     |
+| 3        | Security & RLS           | CRITICAL    | `security-` |
+| 4        | Schema Design            | HIGH        | `schema-`   |
+| 5        | Concurrency & Locking    | MEDIUM-HIGH | `lock-`     |
+| 6        | Data Access Patterns     | MEDIUM      | `data-`     |
+| 7        | Monitoring & Diagnostics | LOW-MEDIUM  | `monitor-`  |
+| 8        | Advanced Features        | LOW         | `advanced-` |
+
+## How to Use
+
+Read individual rule files for detailed explanations and SQL examples:
+
+```
+references/query-missing-indexes.md
+references/query-partial-indexes.md
+references/_sections.md
+```
+
+Each rule file contains:
+
+- Brief explanation of why it matters
+- Incorrect SQL example with explanation
+- Correct SQL example with explanation
+- Optional EXPLAIN output or metrics
+- Additional context and references
+- Supabase-specific notes (when applicable)
+
+## References
+
+- https://www.postgresql.org/docs/current/
+- https://supabase.com/docs
+- https://wiki.postgresql.org/wiki/Performance_Optimization
+- https://supabase.com/docs/guides/database/overview
+- https://supabase.com/docs/guides/auth/row-level-security