feat: add Cursor IDE support with pre-translated configs

Add complete .cursor/ directory with rules, agents, skills, commands, and MCP config adapted for Cursor's format. This makes ecc-universal a truly cross-IDE package supporting Claude Code, Cursor, and OpenCode. - 27 rule files with YAML frontmatter (description, globs, alwaysApply) - 13 agent files with full model IDs and readonly flags - 30 skill directories (identical Agent Skills standard, no translation) - 31 command files (5 multi-* stubbed for missing codeagent-wrapper) - MCP config with Cursor env interpolation syntax - README.md and MIGRATION.md documentation - install.sh --target cursor flag for project-scoped installation - package.json updated with .cursor/ in files and cursor keywords
2026-04-06 17:23:28 +08:00 · 2026-02-11 02:31:52 -08:00
parent 6c2e0eace8
commit 261332dc50
117 changed files with 23248 additions and 22 deletions
--- a/.cursor/commands/build-fix.md
+++ b/.cursor/commands/build-fix.md
@@ -0,0 +1,29 @@
+# Build and Fix
+
+Incrementally fix TypeScript and build errors:
+
+1. Run build: npm run build or pnpm build
+
+2. Parse error output:
+   - Group by file
+   - Sort by severity
+
+3. For each error:
+   - Show error context (5 lines before/after)
+   - Explain the issue
+   - Propose fix
+   - Apply fix
+   - Re-run build
+   - Verify error resolved
+
+4. Stop if:
+   - Fix introduces new errors
+   - Same error persists after 3 attempts
+   - User requests pause
+
+5. Show summary:
+   - Errors fixed
+   - Errors remaining
+   - New errors introduced
+
+Fix one error at a time for safety!
--- a/.cursor/commands/checkpoint.md
+++ b/.cursor/commands/checkpoint.md
@@ -0,0 +1,74 @@
+# Checkpoint Command
+
+Create or verify a checkpoint in your workflow.
+
+## Usage
+
+`/checkpoint [create|verify|list] [name]`
+
+## Create Checkpoint
+
+When creating a checkpoint:
+
+1. Run `/verify quick` to ensure current state is clean
+2. Create a git stash or commit with checkpoint name
+3. Log checkpoint to `.cursor/checkpoints.log`:
+
+```bash
+echo "$(date +%Y-%m-%d-%H:%M) | $CHECKPOINT_NAME | $(git rev-parse --short HEAD)" >> .cursor/checkpoints.log
+```
+
+4. Report checkpoint created
+
+## Verify Checkpoint
+
+When verifying against a checkpoint:
+
+1. Read checkpoint from log
+2. Compare current state to checkpoint:
+   - Files added since checkpoint
+   - Files modified since checkpoint
+   - Test pass rate now vs then
+   - Coverage now vs then
+
+3. Report:
+```
+CHECKPOINT COMPARISON: $NAME
+============================
+Files changed: X
+Tests: +Y passed / -Z failed
+Coverage: +X% / -Y%
+Build: [PASS/FAIL]
+```
+
+## List Checkpoints
+
+Show all checkpoints with:
+- Name
+- Timestamp
+- Git SHA
+- Status (current, behind, ahead)
+
+## Workflow
+
+Typical checkpoint flow:
+
+```
+[Start] --> /checkpoint create "feature-start"
+   |
+[Implement] --> /checkpoint create "core-done"
+   |
+[Test] --> /checkpoint verify "core-done"
+   |
+[Refactor] --> /checkpoint create "refactor-done"
+   |
+[PR] --> /checkpoint verify "feature-start"
+```
+
+## Arguments
+
+$ARGUMENTS:
+- `create <name>` - Create named checkpoint
+- `verify <name>` - Verify against named checkpoint
+- `list` - Show all checkpoints
+- `clear` - Remove old checkpoints (keeps last 5)
--- a/.cursor/commands/code-review.md
+++ b/.cursor/commands/code-review.md
@@ -0,0 +1,40 @@
+# Code Review
+
+Comprehensive security and quality review of uncommitted changes:
+
+1. Get changed files: git diff --name-only HEAD
+
+2. For each changed file, check for:
+
+**Security Issues (CRITICAL):**
+- Hardcoded credentials, API keys, tokens
+- SQL injection vulnerabilities
+- XSS vulnerabilities
+- Missing input validation
+- Insecure dependencies
+- Path traversal risks
+
+**Code Quality (HIGH):**
+- Functions > 50 lines
+- Files > 800 lines
+- Nesting depth > 4 levels
+- Missing error handling
+- console.log statements
+- TODO/FIXME comments
+- Missing JSDoc for public APIs
+
+**Best Practices (MEDIUM):**
+- Mutation patterns (use immutable instead)
+- Emoji usage in code/comments
+- Missing tests for new code
+- Accessibility issues (a11y)
+
+3. Generate report with:
+   - Severity: CRITICAL, HIGH, MEDIUM, LOW
+   - File location and line numbers
+   - Issue description
+   - Suggested fix
+
+4. Block commit if CRITICAL or HIGH issues found
+
+Never approve code with security vulnerabilities!
--- a/.cursor/commands/e2e.md
+++ b/.cursor/commands/e2e.md
@@ -0,0 +1,362 @@
+---
+description: Generate and run end-to-end tests with Playwright. Creates test journeys, runs tests, captures screenshots/videos/traces, and uploads artifacts.
+---
+
+# E2E Command
+
+This command invokes the **e2e-runner** agent to generate, maintain, and execute end-to-end tests using Playwright.
+
+## What This Command Does
+
+1. **Generate Test Journeys** - Create Playwright tests for user flows
+2. **Run E2E Tests** - Execute tests across browsers
+3. **Capture Artifacts** - Screenshots, videos, traces on failures
+4. **Upload Results** - HTML reports and JUnit XML
+5. **Identify Flaky Tests** - Quarantine unstable tests
+
+## When to Use
+
+Use `/e2e` when:
+- Testing critical user journeys (login, trading, payments)
+- Verifying multi-step flows work end-to-end
+- Testing UI interactions and navigation
+- Validating integration between frontend and backend
+- Preparing for production deployment
+
+## How It Works
+
+The e2e-runner agent will:
+
+1. **Analyze user flow** and identify test scenarios
+2. **Generate Playwright test** using Page Object Model pattern
+3. **Run tests** across multiple browsers (Chrome, Firefox, Safari)
+4. **Capture failures** with screenshots, videos, and traces
+5. **Generate report** with results and artifacts
+6. **Identify flaky tests** and recommend fixes
+
+## Example Usage
+
+```
+User: /e2e Test the market search and view flow
+
+Agent (e2e-runner):
+# E2E Test Generation: Market Search and View Flow
+
+## Test Scenario Identified
+
+**User Journey:** Market Search → View Results → Click Market → View Details
+
+**Test Coverage:**
+1. Navigate to markets page
+2. Perform semantic search
+3. Verify search results
+4. Click on first result
+5. Verify market details page loads
+6. Verify chart renders
+
+## Generated Test Code
+
+```typescript
+// tests/e2e/markets/search-and-view.spec.ts
+import { test, expect } from '@playwright/test'
+import { MarketsPage } from '../../pages/MarketsPage'
+import { MarketDetailsPage } from '../../pages/MarketDetailsPage'
+
+test.describe('Market Search and View Flow', () => {
+  test('user can search markets and view details', async ({ page }) => {
+    // 1. Navigate to markets page
+    const marketsPage = new MarketsPage(page)
+    await marketsPage.goto()
+
+    // Verify page loaded
+    await expect(page).toHaveTitle(/Markets/)
+    await expect(page.locator('h1')).toContainText('Markets')
+
+    // 2. Perform semantic search
+    await marketsPage.searchMarkets('election')
+
+    // Wait for API response
+    await page.waitForResponse(resp =>
+      resp.url().includes('/api/markets/search') && resp.status() === 200
+    )
+
+    // 3. Verify search results
+    const marketCards = marketsPage.marketCards
+    await expect(marketCards.first()).toBeVisible()
+    const resultCount = await marketCards.count()
+    expect(resultCount).toBeGreaterThan(0)
+
+    // Take screenshot of search results
+    await page.screenshot({ path: 'artifacts/search-results.png' })
+
+    // 4. Click on first result
+    const firstMarketTitle = await marketCards.first().textContent()
+    await marketCards.first().click()
+
+    // 5. Verify market details page loads
+    await expect(page).toHaveURL(/\/markets\/[a-z0-9-]+/)
+
+    const detailsPage = new MarketDetailsPage(page)
+    await expect(detailsPage.marketName).toBeVisible()
+    await expect(detailsPage.marketDescription).toBeVisible()
+
+    // 6. Verify chart renders
+    await expect(detailsPage.priceChart).toBeVisible()
+
+    // Verify market name matches
+    const detailsTitle = await detailsPage.marketName.textContent()
+    expect(detailsTitle?.toLowerCase()).toContain(
+      firstMarketTitle?.toLowerCase().substring(0, 20) || ''
+    )
+
+    // Take screenshot of market details
+    await page.screenshot({ path: 'artifacts/market-details.png' })
+  })
+
+  test('search with no results shows empty state', async ({ page }) => {
+    const marketsPage = new MarketsPage(page)
+    await marketsPage.goto()
+
+    // Search for non-existent market
+    await marketsPage.searchMarkets('xyznonexistentmarket123456')
+
+    // Verify empty state
+    await expect(page.locator('[data-testid="no-results"]')).toBeVisible()
+    await expect(page.locator('[data-testid="no-results"]')).toContainText(
+      /no.*results|no.*markets/i
+    )
+
+    const marketCount = await marketsPage.marketCards.count()
+    expect(marketCount).toBe(0)
+  })
+
+  test('can clear search and see all markets again', async ({ page }) => {
+    const marketsPage = new MarketsPage(page)
+    await marketsPage.goto()
+
+    // Initial market count
+    const initialCount = await marketsPage.marketCards.count()
+
+    // Perform search
+    await marketsPage.searchMarkets('trump')
+    await page.waitForLoadState('networkidle')
+
+    // Verify filtered results
+    const filteredCount = await marketsPage.marketCards.count()
+    expect(filteredCount).toBeLessThan(initialCount)
+
+    // Clear search
+    await marketsPage.searchInput.clear()
+    await page.waitForLoadState('networkidle')
+
+    // Verify all markets shown again
+    const finalCount = await marketsPage.marketCards.count()
+    expect(finalCount).toBe(initialCount)
+  })
+})
+```
+
+## Running Tests
+
+```bash
+# Run the generated test
+npx playwright test tests/e2e/markets/search-and-view.spec.ts
+
+Running 3 tests using 3 workers
+
+  ✓  [chromium] › search-and-view.spec.ts:5:3 › user can search markets and view details (4.2s)
+  ✓  [chromium] › search-and-view.spec.ts:52:3 › search with no results shows empty state (1.8s)
+  ✓  [chromium] › search-and-view.spec.ts:67:3 › can clear search and see all markets again (2.9s)
+
+  3 passed (9.1s)
+
+Artifacts generated:
+- artifacts/search-results.png
+- artifacts/market-details.png
+- playwright-report/index.html
+```
+
+## Test Report
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║                    E2E Test Results                          ║
+╠══════════════════════════════════════════════════════════════╣
+║ Status:     ✅ ALL TESTS PASSED                              ║
+║ Total:      3 tests                                          ║
+║ Passed:     3 (100%)                                         ║
+║ Failed:     0                                                ║
+║ Flaky:      0                                                ║
+║ Duration:   9.1s                                             ║
+╚══════════════════════════════════════════════════════════════╝
+
+Artifacts:
+📸 Screenshots: 2 files
+📹 Videos: 0 files (only on failure)
+🔍 Traces: 0 files (only on failure)
+📊 HTML Report: playwright-report/index.html
+
+View report: npx playwright show-report
+```
+
+✅ E2E test suite ready for CI/CD integration!
+```
+
+## Test Artifacts
+
+When tests run, the following artifacts are captured:
+
+**On All Tests:**
+- HTML Report with timeline and results
+- JUnit XML for CI integration
+
+**On Failure Only:**
+- Screenshot of the failing state
+- Video recording of the test
+- Trace file for debugging (step-by-step replay)
+- Network logs
+- Console logs
+
+## Viewing Artifacts
+
+```bash
+# View HTML report in browser
+npx playwright show-report
+
+# View specific trace file
+npx playwright show-trace artifacts/trace-abc123.zip
+
+# Screenshots are saved in artifacts/ directory
+open artifacts/search-results.png
+```
+
+## Flaky Test Detection
+
+If a test fails intermittently:
+
+```
+⚠️  FLAKY TEST DETECTED: tests/e2e/markets/trade.spec.ts
+
+Test passed 7/10 runs (70% pass rate)
+
+Common failure:
+"Timeout waiting for element '[data-testid="confirm-btn"]'"
+
+Recommended fixes:
+1. Add explicit wait: await page.waitForSelector('[data-testid="confirm-btn"]')
+2. Increase timeout: { timeout: 10000 }
+3. Check for race conditions in component
+4. Verify element is not hidden by animation
+
+Quarantine recommendation: Mark as test.fixme() until fixed
+```
+
+## Browser Configuration
+
+Tests run on multiple browsers by default:
+- ✅ Chromium (Desktop Chrome)
+- ✅ Firefox (Desktop)
+- ✅ WebKit (Desktop Safari)
+- ✅ Mobile Chrome (optional)
+
+Configure in `playwright.config.ts` to adjust browsers.
+
+## CI/CD Integration
+
+Add to your CI pipeline:
+
+```yaml
+# .github/workflows/e2e.yml
+- name: Install Playwright
+  run: npx playwright install --with-deps
+
+- name: Run E2E tests
+  run: npx playwright test
+
+- name: Upload artifacts
+  if: always()
+  uses: actions/upload-artifact@v3
+  with:
+    name: playwright-report
+    path: playwright-report/
+```
+
+## PMX-Specific Critical Flows
+
+For PMX, prioritize these E2E tests:
+
+**🔴 CRITICAL (Must Always Pass):**
+1. User can connect wallet
+2. User can browse markets
+3. User can search markets (semantic search)
+4. User can view market details
+5. User can place trade (with test funds)
+6. Market resolves correctly
+7. User can withdraw funds
+
+**🟡 IMPORTANT:**
+1. Market creation flow
+2. User profile updates
+3. Real-time price updates
+4. Chart rendering
+5. Filter and sort markets
+6. Mobile responsive layout
+
+## Best Practices
+
+**DO:**
+- ✅ Use Page Object Model for maintainability
+- ✅ Use data-testid attributes for selectors
+- ✅ Wait for API responses, not arbitrary timeouts
+- ✅ Test critical user journeys end-to-end
+- ✅ Run tests before merging to main
+- ✅ Review artifacts when tests fail
+
+**DON'T:**
+- ❌ Use brittle selectors (CSS classes can change)
+- ❌ Test implementation details
+- ❌ Run tests against production
+- ❌ Ignore flaky tests
+- ❌ Skip artifact review on failures
+- ❌ Test every edge case with E2E (use unit tests)
+
+## Important Notes
+
+**CRITICAL for PMX:**
+- E2E tests involving real money MUST run on testnet/staging only
+- Never run trading tests against production
+- Set `test.skip(process.env.NODE_ENV === 'production')` for financial tests
+- Use test wallets with small test funds only
+
+## Integration with Other Commands
+
+- Use `/plan` to identify critical journeys to test
+- Use `/tdd` for unit tests (faster, more granular)
+- Use `/e2e` for integration and user journey tests
+- Use `/code-review` to verify test quality
+
+## Related Agents
+
+This command invokes the `e2e-runner` agent.
+
+## Quick Commands
+
+```bash
+# Run all E2E tests
+npx playwright test
+
+# Run specific test file
+npx playwright test tests/e2e/markets/search.spec.ts
+
+# Run in headed mode (see browser)
+npx playwright test --headed
+
+# Debug test
+npx playwright test --debug
+
+# Generate test code
+npx playwright codegen http://localhost:3000
+
+# View report
+npx playwright show-report
+```
--- a/.cursor/commands/eval.md
+++ b/.cursor/commands/eval.md
@@ -0,0 +1,120 @@
+# Eval Command
+
+Manage eval-driven development workflow.
+
+## Usage
+
+`/eval [define|check|report|list] [feature-name]`
+
+## Define Evals
+
+`/eval define feature-name`
+
+Create a new eval definition:
+
+1. Create `.cursor/evals/feature-name.md` with template:
+
+```markdown
+## EVAL: feature-name
+Created: $(date)
+
+### Capability Evals
+- [ ] [Description of capability 1]
+- [ ] [Description of capability 2]
+
+### Regression Evals
+- [ ] [Existing behavior 1 still works]
+- [ ] [Existing behavior 2 still works]
+
+### Success Criteria
+- pass@3 > 90% for capability evals
+- pass^3 = 100% for regression evals
+```
+
+2. Prompt user to fill in specific criteria
+
+## Check Evals
+
+`/eval check feature-name`
+
+Run evals for a feature:
+
+1. Read eval definition from `.cursor/evals/feature-name.md`
+2. For each capability eval:
+   - Attempt to verify criterion
+   - Record PASS/FAIL
+   - Log attempt in `.cursor/evals/feature-name.log`
+3. For each regression eval:
+   - Run relevant tests
+   - Compare against baseline
+   - Record PASS/FAIL
+4. Report current status:
+
+```
+EVAL CHECK: feature-name
+========================
+Capability: X/Y passing
+Regression: X/Y passing
+Status: IN PROGRESS / READY
+```
+
+## Report Evals
+
+`/eval report feature-name`
+
+Generate comprehensive eval report:
+
+```
+EVAL REPORT: feature-name
+=========================
+Generated: $(date)
+
+CAPABILITY EVALS
+----------------
+[eval-1]: PASS (pass@1)
+[eval-2]: PASS (pass@2) - required retry
+[eval-3]: FAIL - see notes
+
+REGRESSION EVALS
+----------------
+[test-1]: PASS
+[test-2]: PASS
+[test-3]: PASS
+
+METRICS
+-------
+Capability pass@1: 67%
+Capability pass@3: 100%
+Regression pass^3: 100%
+
+NOTES
+-----
+[Any issues, edge cases, or observations]
+
+RECOMMENDATION
+--------------
+[SHIP / NEEDS WORK / BLOCKED]
+```
+
+## List Evals
+
+`/eval list`
+
+Show all eval definitions:
+
+```
+EVAL DEFINITIONS
+================
+feature-auth      [3/5 passing] IN PROGRESS
+feature-search    [5/5 passing] READY
+feature-export    [0/4 passing] NOT STARTED
+```
+
+## Arguments
+
+$ARGUMENTS:
+- `define <name>` - Create new eval definition
+- `check <name>` - Run and check evals
+- `report <name>` - Generate full report
+- `list` - Show all evals
+- `clean` - Remove old eval logs (keeps last 10 runs)
--- a/.cursor/commands/evolve.md
+++ b/.cursor/commands/evolve.md
@@ -0,0 +1,193 @@
+---
+name: evolve
+description: Cluster related instincts into skills, commands, or agents
+command: true
+---
+
+# Evolve Command
+
+## Implementation
+
+Run the instinct CLI using the plugin root path:
+
+```bash
+python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cli.py" evolve [--generate]
+```
+
+Or if `CLAUDE_PLUGIN_ROOT` is not set (manual installation):
+
+```bash
+python3 skills/continuous-learning-v2/scripts/instinct-cli.py evolve [--generate]
+```
+
+Analyzes instincts and clusters related ones into higher-level structures:
+- **Commands**: When instincts describe user-invoked actions
+- **Skills**: When instincts describe auto-triggered behaviors
+- **Agents**: When instincts describe complex, multi-step processes
+
+## Usage
+
+```
+/evolve                    # Analyze all instincts and suggest evolutions
+/evolve --domain testing   # Only evolve instincts in testing domain
+/evolve --dry-run          # Show what would be created without creating
+/evolve --threshold 5      # Require 5+ related instincts to cluster
+```
+
+## Evolution Rules
+
+### → Command (User-Invoked)
+When instincts describe actions a user would explicitly request:
+- Multiple instincts about "when user asks to..."
+- Instincts with triggers like "when creating a new X"
+- Instincts that follow a repeatable sequence
+
+Example:
+- `new-table-step1`: "when adding a database table, create migration"
+- `new-table-step2`: "when adding a database table, update schema"
+- `new-table-step3`: "when adding a database table, regenerate types"
+
+→ Creates: `/new-table` command
+
+### → Skill (Auto-Triggered)
+When instincts describe behaviors that should happen automatically:
+- Pattern-matching triggers
+- Error handling responses
+- Code style enforcement
+
+Example:
+- `prefer-functional`: "when writing functions, prefer functional style"
+- `use-immutable`: "when modifying state, use immutable patterns"
+- `avoid-classes`: "when designing modules, avoid class-based design"
+
+→ Creates: `functional-patterns` skill
+
+### → Agent (Needs Depth/Isolation)
+When instincts describe complex, multi-step processes that benefit from isolation:
+- Debugging workflows
+- Refactoring sequences
+- Research tasks
+
+Example:
+- `debug-step1`: "when debugging, first check logs"
+- `debug-step2`: "when debugging, isolate the failing component"
+- `debug-step3`: "when debugging, create minimal reproduction"
+- `debug-step4`: "when debugging, verify fix with test"
+
+→ Creates: `debugger` agent
+
+## What to Do
+
+1. Read all instincts from `homunculus/instincts/`
+2. Group instincts by:
+   - Domain similarity
+   - Trigger pattern overlap
+   - Action sequence relationship
+3. For each cluster of 3+ related instincts:
+   - Determine evolution type (command/skill/agent)
+   - Generate the appropriate file
+   - Save to `homunculus/evolved/{commands,skills,agents}/`
+4. Link evolved structure back to source instincts
+
+## Output Format
+
+```
+🧬 Evolve Analysis
+==================
+
+Found 3 clusters ready for evolution:
+
+## Cluster 1: Database Migration Workflow
+Instincts: new-table-migration, update-schema, regenerate-types
+Type: Command
+Confidence: 85% (based on 12 observations)
+
+Would create: /new-table command
+Files:
+  - homunculus/evolved/commands/new-table.md
+
+## Cluster 2: Functional Code Style
+Instincts: prefer-functional, use-immutable, avoid-classes, pure-functions
+Type: Skill
+Confidence: 78% (based on 8 observations)
+
+Would create: functional-patterns skill
+Files:
+  - homunculus/evolved/skills/functional-patterns.md
+
+## Cluster 3: Debugging Process
+Instincts: debug-check-logs, debug-isolate, debug-reproduce, debug-verify
+Type: Agent
+Confidence: 72% (based on 6 observations)
+
+Would create: debugger agent
+Files:
+  - homunculus/evolved/agents/debugger.md
+
+---
+Run `/evolve --execute` to create these files.
+```
+
+## Flags
+
+- `--execute`: Actually create the evolved structures (default is preview)
+- `--dry-run`: Preview without creating
+- `--domain <name>`: Only evolve instincts in specified domain
+- `--threshold <n>`: Minimum instincts required to form cluster (default: 3)
+- `--type <command|skill|agent>`: Only create specified type
+
+## Generated File Format
+
+### Command
+```markdown
+---
+name: new-table
+description: Create a new database table with migration, schema update, and type generation
+command: /new-table
+evolved_from:
+  - new-table-migration
+  - update-schema
+  - regenerate-types
+---
+
+# New Table Command
+
+[Generated content based on clustered instincts]
+
+## Steps
+1. ...
+2. ...
+```
+
+### Skill
+```markdown
+---
+name: functional-patterns
+description: Enforce functional programming patterns
+evolved_from:
+  - prefer-functional
+  - use-immutable
+  - avoid-classes
+---
+
+# Functional Patterns Skill
+
+[Generated content based on clustered instincts]
+```
+
+### Agent
+```markdown
+---
+name: debugger
+description: Systematic debugging agent
+model: sonnet
+evolved_from:
+  - debug-check-logs
+  - debug-isolate
+  - debug-reproduce
+---
+
+# Debugger Agent
+
+[Generated content based on clustered instincts]
+```
--- a/.cursor/commands/go-build.md
+++ b/.cursor/commands/go-build.md
@@ -0,0 +1,183 @@
+---
+description: Fix Go build errors, go vet warnings, and linter issues incrementally. Invokes the go-build-resolver agent for minimal, surgical fixes.
+---
+
+# Go Build and Fix
+
+This command invokes the **go-build-resolver** agent to incrementally fix Go build errors with minimal changes.
+
+## What This Command Does
+
+1. **Run Diagnostics**: Execute `go build`, `go vet`, `staticcheck`
+2. **Parse Errors**: Group by file and sort by severity
+3. **Fix Incrementally**: One error at a time
+4. **Verify Each Fix**: Re-run build after each change
+5. **Report Summary**: Show what was fixed and what remains
+
+## When to Use
+
+Use `/go-build` when:
+- `go build ./...` fails with errors
+- `go vet ./...` reports issues
+- `golangci-lint run` shows warnings
+- Module dependencies are broken
+- After pulling changes that break the build
+
+## Diagnostic Commands Run
+
+```bash
+# Primary build check
+go build ./...
+
+# Static analysis
+go vet ./...
+
+# Extended linting (if available)
+staticcheck ./...
+golangci-lint run
+
+# Module issues
+go mod verify
+go mod tidy -v
+```
+
+## Example Session
+
+```text
+User: /go-build
+
+Agent:
+# Go Build Resolution
+
+## Initial Diagnostics
+
+```bash
+$ go build ./...
+internal/service/user.go:25:15: undefined: UserRepository
+internal/handler/api.go:42:9: cannot use x (type string) as type int
+internal/handler/api.go:58:2: missing return at end of function
+```
+
+Errors found: 3
+
+## Fix 1: Undefined Identifier
+
+File: internal/service/user.go:25
+Error: undefined: UserRepository
+Cause: Missing import
+
+```go
+// Added import
+import "project/internal/repository"
+
+// Changed
+var repo UserRepository
+// To
+var repo repository.UserRepository
+```
+
+```bash
+$ go build ./...
+# 2 errors remaining
+```
+
+## Fix 2: Type Mismatch
+
+File: internal/handler/api.go:42
+Error: cannot use x (type string) as type int
+
+```go
+// Changed
+count := params.Get("count")
+// To
+countStr := params.Get("count")
+count, _ := strconv.Atoi(countStr)
+```
+
+```bash
+$ go build ./...
+# 1 error remaining
+```
+
+## Fix 3: Missing Return
+
+File: internal/handler/api.go:58
+Error: missing return at end of function
+
+```go
+func GetUser(id string) (*User, error) {
+    if id == "" {
+        return nil, ErrInvalidID
+    }
+    user := findUser(id)
+    // Added missing return
+    return user, nil
+}
+```
+
+```bash
+$ go build ./...
+# Build successful!
+```
+
+## Final Verification
+
+```bash
+$ go vet ./...
+# No issues
+
+$ go test ./...
+ok      project/internal/service   0.015s
+ok      project/internal/handler   0.023s
+```
+
+## Summary
+
+| Metric | Count |
+|--------|-------|
+| Build errors fixed | 3 |
+| Vet warnings fixed | 0 |
+| Files modified | 2 |
+| Remaining issues | 0 |
+
+Build Status: ✅ SUCCESS
+```
+
+## Common Errors Fixed
+
+| Error | Typical Fix |
+|-------|-------------|
+| `undefined: X` | Add import or fix typo |
+| `cannot use X as Y` | Type conversion or fix assignment |
+| `missing return` | Add return statement |
+| `X does not implement Y` | Add missing method |
+| `import cycle` | Restructure packages |
+| `declared but not used` | Remove or use variable |
+| `cannot find package` | `go get` or `go mod tidy` |
+
+## Fix Strategy
+
+1. **Build errors first** - Code must compile
+2. **Vet warnings second** - Fix suspicious constructs
+3. **Lint warnings third** - Style and best practices
+4. **One fix at a time** - Verify each change
+5. **Minimal changes** - Don't refactor, just fix
+
+## Stop Conditions
+
+The agent will stop and report if:
+- Same error persists after 3 attempts
+- Fix introduces more errors
+- Requires architectural changes
+- Missing external dependencies
+
+## Related Commands
+
+- `/go-test` - Run tests after build succeeds
+- `/go-review` - Review code quality
+- `/verify` - Full verification loop
+
+## Related
+
+- Agent: `agents/go-build-resolver.md`
+- Skill: `skills/golang-patterns/`
--- a/.cursor/commands/go-review.md
+++ b/.cursor/commands/go-review.md
@@ -0,0 +1,148 @@
+---
+description: Comprehensive Go code review for idiomatic patterns, concurrency safety, error handling, and security. Invokes the go-reviewer agent.
+---
+
+# Go Code Review
+
+This command invokes the **go-reviewer** agent for comprehensive Go-specific code review.
+
+## What This Command Does
+
+1. **Identify Go Changes**: Find modified `.go` files via `git diff`
+2. **Run Static Analysis**: Execute `go vet`, `staticcheck`, and `golangci-lint`
+3. **Security Scan**: Check for SQL injection, command injection, race conditions
+4. **Concurrency Review**: Analyze goroutine safety, channel usage, mutex patterns
+5. **Idiomatic Go Check**: Verify code follows Go conventions and best practices
+6. **Generate Report**: Categorize issues by severity
+
+## When to Use
+
+Use `/go-review` when:
+- After writing or modifying Go code
+- Before committing Go changes
+- Reviewing pull requests with Go code
+- Onboarding to a new Go codebase
+- Learning idiomatic Go patterns
+
+## Review Categories
+
+### CRITICAL (Must Fix)
+- SQL/Command injection vulnerabilities
+- Race conditions without synchronization
+- Goroutine leaks
+- Hardcoded credentials
+- Unsafe pointer usage
+- Ignored errors in critical paths
+
+### HIGH (Should Fix)
+- Missing error wrapping with context
+- Panic instead of error returns
+- Context not propagated
+- Unbuffered channels causing deadlocks
+- Interface not satisfied errors
+- Missing mutex protection
+
+### MEDIUM (Consider)
+- Non-idiomatic code patterns
+- Missing godoc comments on exports
+- Inefficient string concatenation
+- Slice not preallocated
+- Table-driven tests not used
+
+## Automated Checks Run
+
+```bash
+# Static analysis
+go vet ./...
+
+# Advanced checks (if installed)
+staticcheck ./...
+golangci-lint run
+
+# Race detection
+go build -race ./...
+
+# Security vulnerabilities
+govulncheck ./...
+```
+
+## Example Usage
+
+```text
+User: /go-review
+
+Agent:
+# Go Code Review Report
+
+## Files Reviewed
+- internal/handler/user.go (modified)
+- internal/service/auth.go (modified)
+
+## Static Analysis Results
+✓ go vet: No issues
+✓ staticcheck: No issues
+
+## Issues Found
+
+[CRITICAL] Race Condition
+File: internal/service/auth.go:45
+Issue: Shared map accessed without synchronization
+```go
+var cache = map[string]*Session{}  // Concurrent access!
+
+func GetSession(id string) *Session {
+    return cache[id]  // Race condition
+}
+```
+Fix: Use sync.RWMutex or sync.Map
+```go
+var (
+    cache   = map[string]*Session{}
+    cacheMu sync.RWMutex
+)
+
+func GetSession(id string) *Session {
+    cacheMu.RLock()
+    defer cacheMu.RUnlock()
+    return cache[id]
+}
+```
+
+[HIGH] Missing Error Context
+File: internal/handler/user.go:28
+Issue: Error returned without context
+```go
+return err  // No context
+```
+Fix: Wrap with context
+```go
+return fmt.Errorf("get user %s: %w", userID, err)
+```
+
+## Summary
+- CRITICAL: 1
+- HIGH: 1
+- MEDIUM: 0
+
+Recommendation: ❌ Block merge until CRITICAL issue is fixed
+```
+
+## Approval Criteria
+
+| Status | Condition |
+|--------|-----------|
+| ✅ Approve | No CRITICAL or HIGH issues |
+| ⚠️ Warning | Only MEDIUM issues (merge with caution) |
+| ❌ Block | CRITICAL or HIGH issues found |
+
+## Integration with Other Commands
+
+- Use `/go-test` first to ensure tests pass
+- Use `/go-build` if build errors occur
+- Use `/go-review` before committing
+- Use `/code-review` for non-Go specific concerns
+
+## Related
+
+- Agent: `agents/go-reviewer.md`
+- Skills: `skills/golang-patterns/`, `skills/golang-testing/`
--- a/.cursor/commands/go-test.md
+++ b/.cursor/commands/go-test.md
@@ -0,0 +1,268 @@
+---
+description: Enforce TDD workflow for Go. Write table-driven tests first, then implement. Verify 80%+ coverage with go test -cover.
+---
+
+# Go TDD Command
+
+This command enforces test-driven development methodology for Go code using idiomatic Go testing patterns.
+
+## What This Command Does
+
+1. **Define Types/Interfaces**: Scaffold function signatures first
+2. **Write Table-Driven Tests**: Create comprehensive test cases (RED)
+3. **Run Tests**: Verify tests fail for the right reason
+4. **Implement Code**: Write minimal code to pass (GREEN)
+5. **Refactor**: Improve while keeping tests green
+6. **Check Coverage**: Ensure 80%+ coverage
+
+## When to Use
+
+Use `/go-test` when:
+- Implementing new Go functions
+- Adding test coverage to existing code
+- Fixing bugs (write failing test first)
+- Building critical business logic
+- Learning TDD workflow in Go
+
+## TDD Cycle
+
+```
+RED     → Write failing table-driven test
+GREEN   → Implement minimal code to pass
+REFACTOR → Improve code, tests stay green
+REPEAT  → Next test case
+```
+
+## Example Session
+
+```text
+User: /go-test I need a function to validate email addresses
+
+Agent:
+# TDD Session: Email Validator
+
+## Step 1: Define Interface
+
+```go
+// validator/email.go
+package validator
+
+// ValidateEmail checks if the given string is a valid email address.
+// Returns nil if valid, error describing the issue otherwise.
+func ValidateEmail(email string) error {
+    panic("not implemented")
+}
+```
+
+## Step 2: Write Table-Driven Tests (RED)
+
+```go
+// validator/email_test.go
+package validator
+
+import (
+    "testing"
+)
+
+func TestValidateEmail(t *testing.T) {
+    tests := []struct {
+        name    string
+        email   string
+        wantErr bool
+    }{
+        // Valid emails
+        {"simple email", "user@example.com", false},
+        {"with subdomain", "user@mail.example.com", false},
+        {"with plus", "user+tag@example.com", false},
+        {"with dots", "first.last@example.com", false},
+
+        // Invalid emails
+        {"empty string", "", true},
+        {"no at sign", "userexample.com", true},
+        {"no domain", "user@", true},
+        {"no local part", "@example.com", true},
+        {"double at", "user@@example.com", true},
+        {"spaces", "user @example.com", true},
+        {"no tld", "user@example", true},
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            err := ValidateEmail(tt.email)
+            if tt.wantErr && err == nil {
+                t.Errorf("ValidateEmail(%q) = nil; want error", tt.email)
+            }
+            if !tt.wantErr && err != nil {
+                t.Errorf("ValidateEmail(%q) = %v; want nil", tt.email, err)
+            }
+        })
+    }
+}
+```
+
+## Step 3: Run Tests - Verify FAIL
+
+```bash
+$ go test ./validator/...
+
+--- FAIL: TestValidateEmail (0.00s)
+    --- FAIL: TestValidateEmail/simple_email (0.00s)
+        panic: not implemented
+
+FAIL
+```
+
+✓ Tests fail as expected (panic).
+
+## Step 4: Implement Minimal Code (GREEN)
+
+```go
+// validator/email.go
+package validator
+
+import (
+    "errors"
+    "regexp"
+)
+
+var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
+
+var (
+    ErrEmailEmpty   = errors.New("email cannot be empty")
+    ErrEmailInvalid = errors.New("email format is invalid")
+)
+
+func ValidateEmail(email string) error {
+    if email == "" {
+        return ErrEmailEmpty
+    }
+    if !emailRegex.MatchString(email) {
+        return ErrEmailInvalid
+    }
+    return nil
+}
+```
+
+## Step 5: Run Tests - Verify PASS
+
+```bash
+$ go test ./validator/...
+
+PASS
+ok      project/validator    0.003s
+```
+
+✓ All tests passing!
+
+## Step 6: Check Coverage
+
+```bash
+$ go test -cover ./validator/...
+
+PASS
+coverage: 100.0% of statements
+ok      project/validator    0.003s
+```
+
+✓ Coverage: 100%
+
+## TDD Complete!
+```
+
+## Test Patterns
+
+### Table-Driven Tests
+```go
+tests := []struct {
+    name     string
+    input    InputType
+    want     OutputType
+    wantErr  bool
+}{
+    {"case 1", input1, want1, false},
+    {"case 2", input2, want2, true},
+}
+
+for _, tt := range tests {
+    t.Run(tt.name, func(t *testing.T) {
+        got, err := Function(tt.input)
+        // assertions
+    })
+}
+```
+
+### Parallel Tests
+```go
+for _, tt := range tests {
+    tt := tt // Capture
+    t.Run(tt.name, func(t *testing.T) {
+        t.Parallel()
+        // test body
+    })
+}
+```
+
+### Test Helpers
+```go
+func setupTestDB(t *testing.T) *sql.DB {
+    t.Helper()
+    db := createDB()
+    t.Cleanup(func() { db.Close() })
+    return db
+}
+```
+
+## Coverage Commands
+
+```bash
+# Basic coverage
+go test -cover ./...
+
+# Coverage profile
+go test -coverprofile=coverage.out ./...
+
+# View in browser
+go tool cover -html=coverage.out
+
+# Coverage by function
+go tool cover -func=coverage.out
+
+# With race detection
+go test -race -cover ./...
+```
+
+## Coverage Targets
+
+| Code Type | Target |
+|-----------|--------|
+| Critical business logic | 100% |
+| Public APIs | 90%+ |
+| General code | 80%+ |
+| Generated code | Exclude |
+
+## TDD Best Practices
+
+**DO:**
+- Write test FIRST, before any implementation
+- Run tests after each change
+- Use table-driven tests for comprehensive coverage
+- Test behavior, not implementation details
+- Include edge cases (empty, nil, max values)
+
+**DON'T:**
+- Write implementation before tests
+- Skip the RED phase
+- Test private functions directly
+- Use `time.Sleep` in tests
+- Ignore flaky tests
+
+## Related Commands
+
+- `/go-build` - Fix build errors
+- `/go-review` - Review code after implementation
+- `/verify` - Run full verification loop
+
+## Related
+
+- Skill: `skills/golang-testing/`
+- Skill: `skills/tdd-workflow/`
--- a/.cursor/commands/instinct-export.md
+++ b/.cursor/commands/instinct-export.md
@@ -0,0 +1,91 @@
+---
+name: instinct-export
+description: Export instincts for sharing with teammates or other projects
+command: /instinct-export
+---
+
+# Instinct Export Command
+
+Exports instincts to a shareable format. Perfect for:
+- Sharing with teammates
+- Transferring to a new machine
+- Contributing to project conventions
+
+## Usage
+
+```
+/instinct-export                           # Export all personal instincts
+/instinct-export --domain testing          # Export only testing instincts
+/instinct-export --min-confidence 0.7      # Only export high-confidence instincts
+/instinct-export --output team-instincts.yaml
+```
+
+## What to Do
+
+1. Read instincts from `homunculus/instincts/personal/`
+2. Filter based on flags
+3. Strip sensitive information:
+   - Remove session IDs
+   - Remove file paths (keep only patterns)
+   - Remove timestamps older than "last week"
+4. Generate export file
+
+## Output Format
+
+Creates a YAML file:
+
+```yaml
+# Instincts Export
+# Generated: 2025-01-22
+# Source: personal
+# Count: 12 instincts
+
+version: "2.0"
+exported_by: "continuous-learning-v2"
+export_date: "2025-01-22T10:30:00Z"
+
+instincts:
+  - id: prefer-functional-style
+    trigger: "when writing new functions"
+    action: "Use functional patterns over classes"
+    confidence: 0.8
+    domain: code-style
+    observations: 8
+
+  - id: test-first-workflow
+    trigger: "when adding new functionality"
+    action: "Write test first, then implementation"
+    confidence: 0.9
+    domain: testing
+    observations: 12
+
+  - id: grep-before-edit
+    trigger: "when modifying code"
+    action: "Search with Grep, confirm with Read, then Edit"
+    confidence: 0.7
+    domain: workflow
+    observations: 6
+```
+
+## Privacy Considerations
+
+Exports include:
+- ✅ Trigger patterns
+- ✅ Actions
+- ✅ Confidence scores
+- ✅ Domains
+- ✅ Observation counts
+
+Exports do NOT include:
+- ❌ Actual code snippets
+- ❌ File paths
+- ❌ Session transcripts
+- ❌ Personal identifiers
+
+## Flags
+
+- `--domain <name>`: Export only specified domain
+- `--min-confidence <n>`: Minimum confidence threshold (default: 0.3)
+- `--output <file>`: Output file path (default: instincts-export-YYYYMMDD.yaml)
+- `--format <yaml|json|md>`: Output format (default: yaml)
+- `--include-evidence`: Include evidence text (default: excluded)
--- a/.cursor/commands/instinct-import.md
+++ b/.cursor/commands/instinct-import.md
@@ -0,0 +1,142 @@
+---
+name: instinct-import
+description: Import instincts from teammates, Skill Creator, or other sources
+command: true
+---
+
+# Instinct Import Command
+
+## Implementation
+
+Run the instinct CLI using the plugin root path:
+
+```bash
+python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cli.py" import <file-or-url> [--dry-run] [--force] [--min-confidence 0.7]
+```
+
+Or if `CLAUDE_PLUGIN_ROOT` is not set (manual installation):
+
+```bash
+python3 skills/continuous-learning-v2/scripts/instinct-cli.py import <file-or-url>
+```
+
+Import instincts from:
+- Teammates' exports
+- Skill Creator (repo analysis)
+- Community collections
+- Previous machine backups
+
+## Usage
+
+```
+/instinct-import team-instincts.yaml
+/instinct-import https://github.com/org/repo/instincts.yaml
+/instinct-import --from-skill-creator acme/webapp
+```
+
+## What to Do
+
+1. Fetch the instinct file (local path or URL)
+2. Parse and validate the format
+3. Check for duplicates with existing instincts
+4. Merge or add new instincts
+5. Save to `homunculus/instincts/inherited/`
+
+## Import Process
+
+```
+📥 Importing instincts from: team-instincts.yaml
+================================================
+
+Found 12 instincts to import.
+
+Analyzing conflicts...
+
+## New Instincts (8)
+These will be added:
+  ✓ use-zod-validation (confidence: 0.7)
+  ✓ prefer-named-exports (confidence: 0.65)
+  ✓ test-async-functions (confidence: 0.8)
+  ...
+
+## Duplicate Instincts (3)
+Already have similar instincts:
+  ⚠️ prefer-functional-style
+     Local: 0.8 confidence, 12 observations
+     Import: 0.7 confidence
+     → Keep local (higher confidence)
+
+  ⚠️ test-first-workflow
+     Local: 0.75 confidence
+     Import: 0.9 confidence
+     → Update to import (higher confidence)
+
+## Conflicting Instincts (1)
+These contradict local instincts:
+  ❌ use-classes-for-services
+     Conflicts with: avoid-classes
+     → Skip (requires manual resolution)
+
+---
+Import 8 new, update 1, skip 3?
+```
+
+## Merge Strategies
+
+### For Duplicates
+When importing an instinct that matches an existing one:
+- **Higher confidence wins**: Keep the one with higher confidence
+- **Merge evidence**: Combine observation counts
+- **Update timestamp**: Mark as recently validated
+
+### For Conflicts
+When importing an instinct that contradicts an existing one:
+- **Skip by default**: Don't import conflicting instincts
+- **Flag for review**: Mark both as needing attention
+- **Manual resolution**: User decides which to keep
+
+## Source Tracking
+
+Imported instincts are marked with:
+```yaml
+source: "inherited"
+imported_from: "team-instincts.yaml"
+imported_at: "2025-01-22T10:30:00Z"
+original_source: "session-observation"  # or "repo-analysis"
+```
+
+## Skill Creator Integration
+
+When importing from Skill Creator:
+
+```
+/instinct-import --from-skill-creator acme/webapp
+```
+
+This fetches instincts generated from repo analysis:
+- Source: `repo-analysis`
+- Higher initial confidence (0.7+)
+- Linked to source repository
+
+## Flags
+
+- `--dry-run`: Preview without importing
+- `--force`: Import even if conflicts exist
+- `--merge-strategy <higher|local|import>`: How to handle duplicates
+- `--from-skill-creator <owner/repo>`: Import from Skill Creator analysis
+- `--min-confidence <n>`: Only import instincts above threshold
+
+## Output
+
+After import:
+```
+✅ Import complete!
+
+Added: 8 instincts
+Updated: 1 instinct
+Skipped: 3 instincts (2 duplicates, 1 conflict)
+
+New instincts saved to: homunculus/instincts/inherited/
+
+Run /instinct-status to see all instincts.
+```
--- a/.cursor/commands/instinct-status.md
+++ b/.cursor/commands/instinct-status.md
@@ -0,0 +1,86 @@
+---
+name: instinct-status
+description: Show all learned instincts with their confidence levels
+command: true
+---
+
+# Instinct Status Command
+
+Shows all learned instincts with their confidence scores, grouped by domain.
+
+## Implementation
+
+Run the instinct CLI using the plugin root path:
+
+```bash
+python3 "${CLAUDE_PLUGIN_ROOT}/skills/continuous-learning-v2/scripts/instinct-cli.py" status
+```
+
+Or if `CLAUDE_PLUGIN_ROOT` is not set (manual installation), use:
+
+```bash
+python3 skills/continuous-learning-v2/scripts/instinct-cli.py status
+```
+
+## Usage
+
+```
+/instinct-status
+/instinct-status --domain code-style
+/instinct-status --low-confidence
+```
+
+## What to Do
+
+1. Read all instinct files from `homunculus/instincts/personal/`
+2. Read inherited instincts from `homunculus/instincts/inherited/`
+3. Display them grouped by domain with confidence bars
+
+## Output Format
+
+```
+📊 Instinct Status
+==================
+
+## Code Style (4 instincts)
+
+### prefer-functional-style
+Trigger: when writing new functions
+Action: Use functional patterns over classes
+Confidence: ████████░░ 80%
+Source: session-observation | Last updated: 2025-01-22
+
+### use-path-aliases
+Trigger: when importing modules
+Action: Use @/ path aliases instead of relative imports
+Confidence: ██████░░░░ 60%
+Source: repo-analysis (github.com/acme/webapp)
+
+## Testing (2 instincts)
+
+### test-first-workflow
+Trigger: when adding new functionality
+Action: Write test first, then implementation
+Confidence: █████████░ 90%
+Source: session-observation
+
+## Workflow (3 instincts)
+
+### grep-before-edit
+Trigger: when modifying code
+Action: Search with Grep, confirm with Read, then Edit
+Confidence: ███████░░░ 70%
+Source: session-observation
+
+---
+Total: 9 instincts (4 personal, 5 inherited)
+Observer: Running (last analysis: 5 min ago)
+```
+
+## Flags
+
+- `--domain <name>`: Filter by domain (code-style, testing, git, etc.)
+- `--low-confidence`: Show only instincts with confidence < 0.5
+- `--high-confidence`: Show only instincts with confidence >= 0.7
+- `--source <type>`: Filter by source (session-observation, repo-analysis, inherited)
+- `--json`: Output as JSON for programmatic use
--- a/.cursor/commands/learn.md
+++ b/.cursor/commands/learn.md
@@ -0,0 +1,70 @@
+# /learn - Extract Reusable Patterns
+
+Analyze the current session and extract any patterns worth saving as skills.
+
+## Trigger
+
+Run `/learn` at any point during a session when you've solved a non-trivial problem.
+
+## What to Extract
+
+Look for:
+
+1. **Error Resolution Patterns**
+   - What error occurred?
+   - What was the root cause?
+   - What fixed it?
+   - Is this reusable for similar errors?
+
+2. **Debugging Techniques**
+   - Non-obvious debugging steps
+   - Tool combinations that worked
+   - Diagnostic patterns
+
+3. **Workarounds**
+   - Library quirks
+   - API limitations
+   - Version-specific fixes
+
+4. **Project-Specific Patterns**
+   - Codebase conventions discovered
+   - Architecture decisions made
+   - Integration patterns
+
+## Output Format
+
+Create a skill file at `skills/learned/[pattern-name].md`:
+
+```markdown
+# [Descriptive Pattern Name]
+
+**Extracted:** [Date]
+**Context:** [Brief description of when this applies]
+
+## Problem
+[What problem this solves - be specific]
+
+## Solution
+[The pattern/technique/workaround]
+
+## Example
+[Code example if applicable]
+
+## When to Use
+[Trigger conditions - what should activate this skill]
+```
+
+## Process
+
+1. Review the session for extractable patterns
+2. Identify the most valuable/reusable insight
+3. Draft the skill file
+4. Ask user to confirm before saving
+5. Save to `skills/learned/`
+
+## Notes
+
+- Don't extract trivial fixes (typos, simple syntax errors)
+- Don't extract one-time issues (specific API outages, etc.)
+- Focus on patterns that will save time in future sessions
+- Keep skills focused - one pattern per skill
--- a/.cursor/commands/multi-backend.md
+++ b/.cursor/commands/multi-backend.md
@@ -0,0 +1,11 @@
+# Backend - Backend-Focused Development
+
+Backend-focused workflow (Research → Ideation → Plan → Execute → Optimize → Review), Codex-led.
+
+## Usage
+
+```bash
+/backend <backend task description>
+```
+
+> **Note**: This command requires Claude Code's multi-model orchestration infrastructure (codeagent-wrapper) which is not available in Cursor. Consider using Cursor's built-in agent mode for similar collaborative workflows.
--- a/.cursor/commands/multi-execute.md
+++ b/.cursor/commands/multi-execute.md
@@ -0,0 +1,11 @@
+# Execute - Multi-Model Collaborative Execution
+
+Multi-model collaborative execution - Get prototype from plan → Claude refactors and implements → Multi-model audit and delivery.
+
+## Usage
+
+```bash
+/execute <task description or plan file path>
+```
+
+> **Note**: This command requires Claude Code's multi-model orchestration infrastructure (codeagent-wrapper) which is not available in Cursor. Consider using Cursor's built-in agent mode for similar collaborative workflows.
--- a/.cursor/commands/multi-frontend.md
+++ b/.cursor/commands/multi-frontend.md
@@ -0,0 +1,11 @@
+# Frontend - Frontend-Focused Development
+
+Frontend-focused workflow (Research → Ideation → Plan → Execute → Optimize → Review), Gemini-led.
+
+## Usage
+
+```bash
+/frontend <UI task description>
+```
+
+> **Note**: This command requires Claude Code's multi-model orchestration infrastructure (codeagent-wrapper) which is not available in Cursor. Consider using Cursor's built-in agent mode for similar collaborative workflows.
--- a/.cursor/commands/multi-plan.md
+++ b/.cursor/commands/multi-plan.md
@@ -0,0 +1,11 @@
+# Plan - Multi-Model Collaborative Planning
+
+Multi-model collaborative planning - Context retrieval + Dual-model analysis → Generate step-by-step implementation plan.
+
+## Usage
+
+```bash
+/plan <task description>
+```
+
+> **Note**: This command requires Claude Code's multi-model orchestration infrastructure (codeagent-wrapper) which is not available in Cursor. Consider using Cursor's built-in agent mode for similar collaborative workflows.
--- a/.cursor/commands/multi-workflow.md
+++ b/.cursor/commands/multi-workflow.md
@@ -0,0 +1,11 @@
+# Workflow - Multi-Model Collaborative Development
+
+Multi-model collaborative development workflow (Research → Ideation → Plan → Execute → Optimize → Review), with intelligent routing: Frontend → Gemini, Backend → Codex.
+
+## Usage
+
+```bash
+/workflow <task description>
+```
+
+> **Note**: This command requires Claude Code's multi-model orchestration infrastructure (codeagent-wrapper) which is not available in Cursor. Consider using Cursor's built-in agent mode for similar collaborative workflows.
--- a/.cursor/commands/orchestrate.md
+++ b/.cursor/commands/orchestrate.md
@@ -0,0 +1,172 @@
+# Orchestrate Command
+
+Sequential agent workflow for complex tasks.
+
+## Usage
+
+`/orchestrate [workflow-type] [task-description]`
+
+## Workflow Types
+
+### feature
+Full feature implementation workflow:
+```
+planner -> tdd-guide -> code-reviewer -> security-reviewer
+```
+
+### bugfix
+Bug investigation and fix workflow:
+```
+explorer -> tdd-guide -> code-reviewer
+```
+
+### refactor
+Safe refactoring workflow:
+```
+architect -> code-reviewer -> tdd-guide
+```
+
+### security
+Security-focused review:
+```
+security-reviewer -> code-reviewer -> architect
+```
+
+## Execution Pattern
+
+For each agent in the workflow:
+
+1. **Invoke agent** with context from previous agent
+2. **Collect output** as structured handoff document
+3. **Pass to next agent** in chain
+4. **Aggregate results** into final report
+
+## Handoff Document Format
+
+Between agents, create handoff document:
+
+```markdown
+## HANDOFF: [previous-agent] -> [next-agent]
+
+### Context
+[Summary of what was done]
+
+### Findings
+[Key discoveries or decisions]
+
+### Files Modified
+[List of files touched]
+
+### Open Questions
+[Unresolved items for next agent]
+
+### Recommendations
+[Suggested next steps]
+```
+
+## Example: Feature Workflow
+
+```
+/orchestrate feature "Add user authentication"
+```
+
+Executes:
+
+1. **Planner Agent**
+   - Analyzes requirements
+   - Creates implementation plan
+   - Identifies dependencies
+   - Output: `HANDOFF: planner -> tdd-guide`
+
+2. **TDD Guide Agent**
+   - Reads planner handoff
+   - Writes tests first
+   - Implements to pass tests
+   - Output: `HANDOFF: tdd-guide -> code-reviewer`
+
+3. **Code Reviewer Agent**
+   - Reviews implementation
+   - Checks for issues
+   - Suggests improvements
+   - Output: `HANDOFF: code-reviewer -> security-reviewer`
+
+4. **Security Reviewer Agent**
+   - Security audit
+   - Vulnerability check
+   - Final approval
+   - Output: Final Report
+
+## Final Report Format
+
+```
+ORCHESTRATION REPORT
+====================
+Workflow: feature
+Task: Add user authentication
+Agents: planner -> tdd-guide -> code-reviewer -> security-reviewer
+
+SUMMARY
+-------
+[One paragraph summary]
+
+AGENT OUTPUTS
+-------------
+Planner: [summary]
+TDD Guide: [summary]
+Code Reviewer: [summary]
+Security Reviewer: [summary]
+
+FILES CHANGED
+-------------
+[List all files modified]
+
+TEST RESULTS
+------------
+[Test pass/fail summary]
+
+SECURITY STATUS
+---------------
+[Security findings]
+
+RECOMMENDATION
+--------------
+[SHIP / NEEDS WORK / BLOCKED]
+```
+
+## Parallel Execution
+
+For independent checks, run agents in parallel:
+
+```markdown
+### Parallel Phase
+Run simultaneously:
+- code-reviewer (quality)
+- security-reviewer (security)
+- architect (design)
+
+### Merge Results
+Combine outputs into single report
+```
+
+## Arguments
+
+$ARGUMENTS:
+- `feature <description>` - Full feature workflow
+- `bugfix <description>` - Bug fix workflow
+- `refactor <description>` - Refactoring workflow
+- `security <description>` - Security review workflow
+- `custom <agents> <description>` - Custom agent sequence
+
+## Custom Workflow Example
+
+```
+/orchestrate custom "architect,tdd-guide,code-reviewer" "Redesign caching layer"
+```
+
+## Tips
+
+1. **Start with planner** for complex features
+2. **Always include code-reviewer** before merge
+3. **Use security-reviewer** for auth/payment/PII
+4. **Keep handoffs concise** - focus on what next agent needs
+5. **Run verification** between agents if needed
--- a/.cursor/commands/plan.md
+++ b/.cursor/commands/plan.md
@@ -0,0 +1,112 @@
+---
+description: Restate requirements, assess risks, and create step-by-step implementation plan. WAIT for user CONFIRM before touching any code.
+---
+
+# Plan Command
+
+This command invokes the **planner** agent to create a comprehensive implementation plan before writing any code.
+
+## What This Command Does
+
+1. **Restate Requirements** - Clarify what needs to be built
+2. **Identify Risks** - Surface potential issues and blockers
+3. **Create Step Plan** - Break down implementation into phases
+4. **Wait for Confirmation** - MUST receive user approval before proceeding
+
+## When to Use
+
+Use `/plan` when:
+- Starting a new feature
+- Making significant architectural changes
+- Working on complex refactoring
+- Multiple files/components will be affected
+- Requirements are unclear or ambiguous
+
+## How It Works
+
+The planner agent will:
+
+1. **Analyze the request** and restate requirements in clear terms
+2. **Break down into phases** with specific, actionable steps
+3. **Identify dependencies** between components
+4. **Assess risks** and potential blockers
+5. **Estimate complexity** (High/Medium/Low)
+6. **Present the plan** and WAIT for your explicit confirmation
+
+## Example Usage
+
+```
+User: /plan I need to add real-time notifications when markets resolve
+
+Agent (planner):
+# Implementation Plan: Real-Time Market Resolution Notifications
+
+## Requirements Restatement
+- Send notifications to users when markets they're watching resolve
+- Support multiple notification channels (in-app, email, webhook)
+- Ensure notifications are delivered reliably
+- Include market outcome and user's position result
+
+## Implementation Phases
+
+### Phase 1: Database Schema
+- Add notifications table with columns: id, user_id, market_id, type, status, created_at
+- Add user_notification_preferences table for channel preferences
+- Create indexes on user_id and market_id for performance
+
+### Phase 2: Notification Service
+- Create notification service in lib/notifications.ts
+- Implement notification queue using BullMQ/Redis
+- Add retry logic for failed deliveries
+- Create notification templates
+
+### Phase 3: Integration Points
+- Hook into market resolution logic (when status changes to "resolved")
+- Query all users with positions in market
+- Enqueue notifications for each user
+
+### Phase 4: Frontend Components
+- Create NotificationBell component in header
+- Add NotificationList modal
+- Implement real-time updates via Supabase subscriptions
+- Add notification preferences page
+
+## Dependencies
+- Redis (for queue)
+- Email service (SendGrid/Resend)
+- Supabase real-time subscriptions
+
+## Risks
+- HIGH: Email deliverability (SPF/DKIM required)
+- MEDIUM: Performance with 1000+ users per market
+- MEDIUM: Notification spam if markets resolve frequently
+- LOW: Real-time subscription overhead
+
+## Estimated Complexity: MEDIUM
+- Backend: 4-6 hours
+- Frontend: 3-4 hours
+- Testing: 2-3 hours
+- Total: 9-13 hours
+
+**WAITING FOR CONFIRMATION**: Proceed with this plan? (yes/no/modify)
+```
+
+## Important Notes
+
+**CRITICAL**: The planner agent will **NOT** write any code until you explicitly confirm the plan with "yes" or "proceed" or similar affirmative response.
+
+If you want changes, respond with:
+- "modify: [your changes]"
+- "different approach: [alternative]"
+- "skip phase 2 and do phase 3 first"
+
+## Integration with Other Commands
+
+After planning:
+- Use `/tdd` to implement with test-driven development
+- Use `/build-and-fix` if build errors occur
+- Use `/code-review` to review completed implementation
+
+## Related Agents
+
+This command invokes the `planner` agent.
--- a/.cursor/commands/pm2.md
+++ b/.cursor/commands/pm2.md
@@ -0,0 +1,271 @@
+# PM2 Init
+
+Auto-analyze project and generate PM2 service commands.
+
+**Command**: `$ARGUMENTS`
+
+---
+
+## Workflow
+
+1. Check PM2 (install via `npm install -g pm2` if missing)
+2. Scan project to identify services (frontend/backend/database)
+3. Generate config files and individual command files
+
+---
+
+## Service Detection
+
+| Type | Detection | Default Port |
+|------|-----------|--------------|
+| Vite | vite.config.* | 5173 |
+| Next.js | next.config.* | 3000 |
+| Nuxt | nuxt.config.* | 3000 |
+| CRA | react-scripts in package.json | 3000 |
+| Express/Node | server/backend/api directory + package.json | 3000 |
+| FastAPI/Flask | requirements.txt / pyproject.toml | 8000 |
+| Go | go.mod / main.go | 8080 |
+
+**Port Detection Priority**: User specified > .env > config file > scripts args > default port
+
+---
+
+## Generated Files
+
+```
+project/
+├── ecosystem.config.cjs              # PM2 config
+├── {backend}/start.cjs               # Python wrapper (if applicable)
+└── .cursor/
+    ├── commands/
+    │   ├── pm2-all.md                # Start all + monit
+    │   ├── pm2-all-stop.md           # Stop all
+    │   ├── pm2-all-restart.md        # Restart all
+    │   ├── pm2-{port}.md             # Start single + logs
+    │   ├── pm2-{port}-stop.md        # Stop single
+    │   ├── pm2-{port}-restart.md     # Restart single
+    │   ├── pm2-logs.md               # View all logs
+    │   └── pm2-status.md             # View status
+    └── scripts/
+        ├── pm2-logs-{port}.ps1       # Single service logs
+        └── pm2-monit.ps1             # PM2 monitor
+```
+
+---
+
+## Windows Configuration (IMPORTANT)
+
+### ecosystem.config.cjs
+
+**Must use `.cjs` extension**
+
+```javascript
+module.exports = {
+  apps: [
+    // Node.js (Vite/Next/Nuxt)
+    {
+      name: 'project-3000',
+      cwd: './packages/web',
+      script: 'node_modules/vite/bin/vite.js',
+      args: '--port 3000',
+      interpreter: 'C:/Program Files/nodejs/node.exe',
+      env: { NODE_ENV: 'development' }
+    },
+    // Python
+    {
+      name: 'project-8000',
+      cwd: './backend',
+      script: 'start.cjs',
+      interpreter: 'C:/Program Files/nodejs/node.exe',
+      env: { PYTHONUNBUFFERED: '1' }
+    }
+  ]
+}
+```
+
+**Framework script paths:**
+
+| Framework | script | args |
+|-----------|--------|------|
+| Vite | `node_modules/vite/bin/vite.js` | `--port {port}` |
+| Next.js | `node_modules/next/dist/bin/next` | `dev -p {port}` |
+| Nuxt | `node_modules/nuxt/bin/nuxt.mjs` | `dev --port {port}` |
+| Express | `src/index.js` or `server.js` | - |
+
+### Python Wrapper Script (start.cjs)
+
+```javascript
+const { spawn } = require('child_process');
+const proc = spawn('python', ['-m', 'uvicorn', 'app.main:app', '--host', '0.0.0.0', '--port', '8000', '--reload'], {
+  cwd: __dirname, stdio: 'inherit', windowsHide: true
+});
+proc.on('close', (code) => process.exit(code));
+```
+
+---
+
+## Command File Templates (Minimal Content)
+
+### pm2-all.md (Start all + monit)
+```markdown
+Start all services and open PM2 monitor.
+\`\`\`bash
+cd "{PROJECT_ROOT}" && pm2 start ecosystem.config.cjs && start wt.exe -d "{PROJECT_ROOT}" pwsh -NoExit -c "pm2 monit"
+\`\`\`
+```
+
+### pm2-all-stop.md
+```markdown
+Stop all services.
+\`\`\`bash
+cd "{PROJECT_ROOT}" && pm2 stop all
+\`\`\`
+```
+
+### pm2-all-restart.md
+```markdown
+Restart all services.
+\`\`\`bash
+cd "{PROJECT_ROOT}" && pm2 restart all
+\`\`\`
+```
+
+### pm2-{port}.md (Start single + logs)
+```markdown
+Start {name} ({port}) and open logs.
+\`\`\`bash
+cd "{PROJECT_ROOT}" && pm2 start ecosystem.config.cjs --only {name} && start wt.exe -d "{PROJECT_ROOT}" pwsh -NoExit -c "pm2 logs {name}"
+\`\`\`
+```
+
+### pm2-{port}-stop.md
+```markdown
+Stop {name} ({port}).
+\`\`\`bash
+cd "{PROJECT_ROOT}" && pm2 stop {name}
+\`\`\`
+```
+
+### pm2-{port}-restart.md
+```markdown
+Restart {name} ({port}).
+\`\`\`bash
+cd "{PROJECT_ROOT}" && pm2 restart {name}
+\`\`\`
+```
+
+### pm2-logs.md
+```markdown
+View all PM2 logs.
+\`\`\`bash
+cd "{PROJECT_ROOT}" && pm2 logs
+\`\`\`
+```
+
+### pm2-status.md
+```markdown
+View PM2 status.
+\`\`\`bash
+cd "{PROJECT_ROOT}" && pm2 status
+\`\`\`
+```
+
+### PowerShell Scripts (pm2-logs-{port}.ps1)
+```powershell
+Set-Location "{PROJECT_ROOT}"
+pm2 logs {name}
+```
+
+### PowerShell Scripts (pm2-monit.ps1)
+```powershell
+Set-Location "{PROJECT_ROOT}"
+pm2 monit
+```
+
+---
+
+## Key Rules
+
+1. **Config file**: `ecosystem.config.cjs` (not .js)
+2. **Node.js**: Specify bin path directly + interpreter
+3. **Python**: Node.js wrapper script + `windowsHide: true`
+4. **Open new window**: `start wt.exe -d "{path}" pwsh -NoExit -c "command"`
+5. **Minimal content**: Each command file has only 1-2 lines description + bash block
+6. **Direct execution**: No AI parsing needed, just run the bash command
+
+---
+
+## Execute
+
+Based on `$ARGUMENTS`, execute init:
+
+1. Scan project for services
+2. Generate `ecosystem.config.cjs`
+3. Generate `{backend}/start.cjs` for Python services (if applicable)
+4. Generate command files in `.cursor/commands/`
+5. Generate script files in `.cursor/scripts/`
+6. **Update project CLAUDE.md** with PM2 info (see below)
+7. **Display completion summary** with terminal commands
+
+---
+
+## Post-Init: Update CLAUDE.md
+
+After generating files, append PM2 section to project's `CLAUDE.md` (create if not exists):
+
+```markdown
+## PM2 Services
+
+| Port | Name | Type |
+|------|------|------|
+| {port} | {name} | {type} |
+
+**Terminal Commands:**
+```bash
+pm2 start ecosystem.config.cjs   # First time
+pm2 start all                    # After first time
+pm2 stop all / pm2 restart all
+pm2 start {name} / pm2 stop {name}
+pm2 logs / pm2 status / pm2 monit
+pm2 save                         # Save process list
+pm2 resurrect                    # Restore saved list
+```
+```
+
+**Rules for CLAUDE.md update:**
+- If PM2 section exists, replace it
+- If not exists, append to end
+- Keep content minimal and essential
+
+---
+
+## Post-Init: Display Summary
+
+After all files generated, output:
+
+```
+## PM2 Init Complete
+
+**Services:**
+| Port | Name | Type |
+|------|------|------|
+| {port} | {name} | {type} |
+
+**Claude Commands:** /pm2-all, /pm2-all-stop, /pm2-{port}, /pm2-{port}-stop, /pm2-logs, /pm2-status
+
+**Terminal Commands:**
+# First time (with config file)
+pm2 start ecosystem.config.cjs && pm2 save
+
+# After first time (simplified)
+pm2 start all          # Start all
+pm2 stop all           # Stop all
+pm2 restart all        # Restart all
+pm2 start {name}       # Start single
+pm2 stop {name}        # Stop single
+pm2 logs               # View logs
+pm2 monit              # Monitor panel
+pm2 resurrect          # Restore saved processes
+
+**Tip:** Run `pm2 save` after first start to enable simplified commands.
+```
--- a/.cursor/commands/python-review.md
+++ b/.cursor/commands/python-review.md
@@ -0,0 +1,297 @@
+---
+description: Comprehensive Python code review for PEP 8 compliance, type hints, security, and Pythonic idioms. Invokes the python-reviewer agent.
+---
+
+# Python Code Review
+
+This command invokes the **python-reviewer** agent for comprehensive Python-specific code review.
+
+## What This Command Does
+
+1. **Identify Python Changes**: Find modified `.py` files via `git diff`
+2. **Run Static Analysis**: Execute `ruff`, `mypy`, `pylint`, `black --check`
+3. **Security Scan**: Check for SQL injection, command injection, unsafe deserialization
+4. **Type Safety Review**: Analyze type hints and mypy errors
+5. **Pythonic Code Check**: Verify code follows PEP 8 and Python best practices
+6. **Generate Report**: Categorize issues by severity
+
+## When to Use
+
+Use `/python-review` when:
+- After writing or modifying Python code
+- Before committing Python changes
+- Reviewing pull requests with Python code
+- Onboarding to a new Python codebase
+- Learning Pythonic patterns and idioms
+
+## Review Categories
+
+### CRITICAL (Must Fix)
+- SQL/Command injection vulnerabilities
+- Unsafe eval/exec usage
+- Pickle unsafe deserialization
+- Hardcoded credentials
+- YAML unsafe load
+- Bare except clauses hiding errors
+
+### HIGH (Should Fix)
+- Missing type hints on public functions
+- Mutable default arguments
+- Swallowing exceptions silently
+- Not using context managers for resources
+- C-style looping instead of comprehensions
+- Using type() instead of isinstance()
+- Race conditions without locks
+
+### MEDIUM (Consider)
+- PEP 8 formatting violations
+- Missing docstrings on public functions
+- Print statements instead of logging
+- Inefficient string operations
+- Magic numbers without named constants
+- Not using f-strings for formatting
+- Unnecessary list creation
+
+## Automated Checks Run
+
+```bash
+# Type checking
+mypy .
+
+# Linting and formatting
+ruff check .
+black --check .
+isort --check-only .
+
+# Security scanning
+bandit -r .
+
+# Dependency audit
+pip-audit
+safety check
+
+# Testing
+pytest --cov=app --cov-report=term-missing
+```
+
+## Example Usage
+
+```text
+User: /python-review
+
+Agent:
+# Python Code Review Report
+
+## Files Reviewed
+- app/routes/user.py (modified)
+- app/services/auth.py (modified)
+
+## Static Analysis Results
+✓ ruff: No issues
+✓ mypy: No errors
+⚠️ black: 2 files need reformatting
+✓ bandit: No security issues
+
+## Issues Found
+
+[CRITICAL] SQL Injection vulnerability
+File: app/routes/user.py:42
+Issue: User input directly interpolated into SQL query
+```python
+query = f"SELECT * FROM users WHERE id = {user_id}"  # Bad
+```
+Fix: Use parameterized query
+```python
+query = "SELECT * FROM users WHERE id = %s"  # Good
+cursor.execute(query, (user_id,))
+```
+
+[HIGH] Mutable default argument
+File: app/services/auth.py:18
+Issue: Mutable default argument causes shared state
+```python
+def process_items(items=[]):  # Bad
+    items.append("new")
+    return items
+```
+Fix: Use None as default
+```python
+def process_items(items=None):  # Good
+    if items is None:
+        items = []
+    items.append("new")
+    return items
+```
+
+[MEDIUM] Missing type hints
+File: app/services/auth.py:25
+Issue: Public function without type annotations
+```python
+def get_user(user_id):  # Bad
+    return db.find(user_id)
+```
+Fix: Add type hints
+```python
+def get_user(user_id: str) -> Optional[User]:  # Good
+    return db.find(user_id)
+```
+
+[MEDIUM] Not using context manager
+File: app/routes/user.py:55
+Issue: File not closed on exception
+```python
+f = open("config.json")  # Bad
+data = f.read()
+f.close()
+```
+Fix: Use context manager
+```python
+with open("config.json") as f:  # Good
+    data = f.read()
+```
+
+## Summary
+- CRITICAL: 1
+- HIGH: 1
+- MEDIUM: 2
+
+Recommendation: ❌ Block merge until CRITICAL issue is fixed
+
+## Formatting Required
+Run: `black app/routes/user.py app/services/auth.py`
+```
+
+## Approval Criteria
+
+| Status | Condition |
+|--------|-----------|
+| ✅ Approve | No CRITICAL or HIGH issues |
+| ⚠️ Warning | Only MEDIUM issues (merge with caution) |
+| ❌ Block | CRITICAL or HIGH issues found |
+
+## Integration with Other Commands
+
+- Use `/python-test` first to ensure tests pass
+- Use `/code-review` for non-Python specific concerns
+- Use `/python-review` before committing
+- Use `/build-fix` if static analysis tools fail
+
+## Framework-Specific Reviews
+
+### Django Projects
+The reviewer checks for:
+- N+1 query issues (use `select_related` and `prefetch_related`)
+- Missing migrations for model changes
+- Raw SQL usage when ORM could work
+- Missing `transaction.atomic()` for multi-step operations
+
+### FastAPI Projects
+The reviewer checks for:
+- CORS misconfiguration
+- Pydantic models for request validation
+- Response models correctness
+- Proper async/await usage
+- Dependency injection patterns
+
+### Flask Projects
+The reviewer checks for:
+- Context management (app context, request context)
+- Proper error handling
+- Blueprint organization
+- Configuration management
+
+## Related
+
+- Agent: `agents/python-reviewer.md`
+- Skills: `skills/python-patterns/`, `skills/python-testing/`
+
+## Common Fixes
+
+### Add Type Hints
+```python
+# Before
+def calculate(x, y):
+    return x + y
+
+# After
+from typing import Union
+
+def calculate(x: Union[int, float], y: Union[int, float]) -> Union[int, float]:
+    return x + y
+```
+
+### Use Context Managers
+```python
+# Before
+f = open("file.txt")
+data = f.read()
+f.close()
+
+# After
+with open("file.txt") as f:
+    data = f.read()
+```
+
+### Use List Comprehensions
+```python
+# Before
+result = []
+for item in items:
+    if item.active:
+        result.append(item.name)
+
+# After
+result = [item.name for item in items if item.active]
+```
+
+### Fix Mutable Defaults
+```python
+# Before
+def append(value, items=[]):
+    items.append(value)
+    return items
+
+# After
+def append(value, items=None):
+    if items is None:
+        items = []
+    items.append(value)
+    return items
+```
+
+### Use f-strings (Python 3.6+)
+```python
+# Before
+name = "Alice"
+greeting = "Hello, " + name + "!"
+greeting2 = "Hello, {}".format(name)
+
+# After
+greeting = f"Hello, {name}!"
+```
+
+### Fix String Concatenation in Loops
+```python
+# Before
+result = ""
+for item in items:
+    result += str(item)
+
+# After
+result = "".join(str(item) for item in items)
+```
+
+## Python Version Compatibility
+
+The reviewer notes when code uses features from newer Python versions:
+
+| Feature | Minimum Python |
+|---------|----------------|
+| Type hints | 3.5+ |
+| f-strings | 3.6+ |
+| Walrus operator (`:=`) | 3.8+ |
+| Position-only parameters | 3.8+ |
+| Match statements | 3.10+ |
+| Type unions (`x | None`) | 3.10+ |
+
+Ensure your project's `pyproject.toml` or `setup.py` specifies the correct minimum Python version.
--- a/.cursor/commands/refactor-clean.md
+++ b/.cursor/commands/refactor-clean.md
@@ -0,0 +1,28 @@
+# Refactor Clean
+
+Safely identify and remove dead code with test verification:
+
+1. Run dead code analysis tools:
+   - knip: Find unused exports and files
+   - depcheck: Find unused dependencies
+   - ts-prune: Find unused TypeScript exports
+
+2. Generate comprehensive report in .reports/dead-code-analysis.md
+
+3. Categorize findings by severity:
+   - SAFE: Test files, unused utilities
+   - CAUTION: API routes, components
+   - DANGER: Config files, main entry points
+
+4. Propose safe deletions only
+
+5. Before each deletion:
+   - Run full test suite
+   - Verify tests pass
+   - Apply change
+   - Re-run tests
+   - Rollback if tests fail
+
+6. Show summary of cleaned items
+
+Never delete code without running tests first!
--- a/.cursor/commands/sessions.md
+++ b/.cursor/commands/sessions.md
@@ -0,0 +1,305 @@
+# Sessions Command
+
+Manage session history - list, load, alias, and edit sessions.
+
+## Usage
+
+`/sessions [list|load|alias|info|help] [options]`
+
+## Actions
+
+### List Sessions
+
+Display all sessions with metadata, filtering, and pagination.
+
+```bash
+/sessions                              # List all sessions (default)
+/sessions list                         # Same as above
+/sessions list --limit 10              # Show 10 sessions
+/sessions list --date 2026-02-01       # Filter by date
+/sessions list --search abc            # Search by session ID
+```
+
+**Script:**
+```bash
+node -e "
+const sm = require('./scripts/lib/session-manager');
+const aa = require('./scripts/lib/session-aliases');
+
+const result = sm.getAllSessions({ limit: 20 });
+const aliases = aa.listAliases();
+const aliasMap = {};
+for (const a of aliases) aliasMap[a.sessionPath] = a.name;
+
+console.log('Sessions (showing ' + result.sessions.length + ' of ' + result.total + '):');
+console.log('');
+console.log('ID        Date        Time     Size     Lines  Alias');
+console.log('────────────────────────────────────────────────────');
+
+for (const s of result.sessions) {
+  const alias = aliasMap[s.filename] || '';
+  const size = sm.getSessionSize(s.sessionPath);
+  const stats = sm.getSessionStats(s.sessionPath);
+  const id = s.shortId === 'no-id' ? '(none)' : s.shortId.slice(0, 8);
+  const time = s.modifiedTime.toTimeString().slice(0, 5);
+
+  console.log(id.padEnd(8) + ' ' + s.date + '  ' + time + '   ' + size.padEnd(7) + '  ' + String(stats.lineCount).padEnd(5) + '  ' + alias);
+}
+"
+```
+
+### Load Session
+
+Load and display a session's content (by ID or alias).
+
+```bash
+/sessions load <id|alias>             # Load session
+/sessions load 2026-02-01             # By date (for no-id sessions)
+/sessions load a1b2c3d4               # By short ID
+/sessions load my-alias               # By alias name
+```
+
+**Script:**
+```bash
+node -e "
+const sm = require('./scripts/lib/session-manager');
+const aa = require('./scripts/lib/session-aliases');
+const id = process.argv[1];
+
+// First try to resolve as alias
+const resolved = aa.resolveAlias(id);
+const sessionId = resolved ? resolved.sessionPath : id;
+
+const session = sm.getSessionById(sessionId, true);
+if (!session) {
+  console.log('Session not found: ' + id);
+  process.exit(1);
+}
+
+const stats = sm.getSessionStats(session.sessionPath);
+const size = sm.getSessionSize(session.sessionPath);
+const aliases = aa.getAliasesForSession(session.filename);
+
+console.log('Session: ' + session.filename);
+console.log('Path: sessions/' + session.filename);
+console.log('');
+console.log('Statistics:');
+console.log('  Lines: ' + stats.lineCount);
+console.log('  Total items: ' + stats.totalItems);
+console.log('  Completed: ' + stats.completedItems);
+console.log('  In progress: ' + stats.inProgressItems);
+console.log('  Size: ' + size);
+console.log('');
+
+if (aliases.length > 0) {
+  console.log('Aliases: ' + aliases.map(a => a.name).join(', '));
+  console.log('');
+}
+
+if (session.metadata.title) {
+  console.log('Title: ' + session.metadata.title);
+  console.log('');
+}
+
+if (session.metadata.started) {
+  console.log('Started: ' + session.metadata.started);
+}
+
+if (session.metadata.lastUpdated) {
+  console.log('Last Updated: ' + session.metadata.lastUpdated);
+}
+" "$ARGUMENTS"
+```
+
+### Create Alias
+
+Create a memorable alias for a session.
+
+```bash
+/sessions alias <id> <name>           # Create alias
+/sessions alias 2026-02-01 today-work # Create alias named "today-work"
+```
+
+**Script:**
+```bash
+node -e "
+const sm = require('./scripts/lib/session-manager');
+const aa = require('./scripts/lib/session-aliases');
+
+const sessionId = process.argv[1];
+const aliasName = process.argv[2];
+
+if (!sessionId || !aliasName) {
+  console.log('Usage: /sessions alias <id> <name>');
+  process.exit(1);
+}
+
+// Get session filename
+const session = sm.getSessionById(sessionId);
+if (!session) {
+  console.log('Session not found: ' + sessionId);
+  process.exit(1);
+}
+
+const result = aa.setAlias(aliasName, session.filename);
+if (result.success) {
+  console.log('✓ Alias created: ' + aliasName + ' → ' + session.filename);
+} else {
+  console.log('✗ Error: ' + result.error);
+  process.exit(1);
+}
+" "$ARGUMENTS"
+```
+
+### Remove Alias
+
+Delete an existing alias.
+
+```bash
+/sessions alias --remove <name>        # Remove alias
+/sessions unalias <name>               # Same as above
+```
+
+**Script:**
+```bash
+node -e "
+const aa = require('./scripts/lib/session-aliases');
+
+const aliasName = process.argv[1];
+if (!aliasName) {
+  console.log('Usage: /sessions alias --remove <name>');
+  process.exit(1);
+}
+
+const result = aa.deleteAlias(aliasName);
+if (result.success) {
+  console.log('✓ Alias removed: ' + aliasName);
+} else {
+  console.log('✗ Error: ' + result.error);
+  process.exit(1);
+}
+" "$ARGUMENTS"
+```
+
+### Session Info
+
+Show detailed information about a session.
+
+```bash
+/sessions info <id|alias>              # Show session details
+```
+
+**Script:**
+```bash
+node -e "
+const sm = require('./scripts/lib/session-manager');
+const aa = require('./scripts/lib/session-aliases');
+
+const id = process.argv[1];
+const resolved = aa.resolveAlias(id);
+const sessionId = resolved ? resolved.sessionPath : id;
+
+const session = sm.getSessionById(sessionId, true);
+if (!session) {
+  console.log('Session not found: ' + id);
+  process.exit(1);
+}
+
+const stats = sm.getSessionStats(session.sessionPath);
+const size = sm.getSessionSize(session.sessionPath);
+const aliases = aa.getAliasesForSession(session.filename);
+
+console.log('Session Information');
+console.log('════════════════════');
+console.log('ID:          ' + (session.shortId === 'no-id' ? '(none)' : session.shortId));
+console.log('Filename:    ' + session.filename);
+console.log('Date:        ' + session.date);
+console.log('Modified:    ' + session.modifiedTime.toISOString().slice(0, 19).replace('T', ' '));
+console.log('');
+console.log('Content:');
+console.log('  Lines:         ' + stats.lineCount);
+console.log('  Total items:   ' + stats.totalItems);
+console.log('  Completed:     ' + stats.completedItems);
+console.log('  In progress:   ' + stats.inProgressItems);
+console.log('  Size:          ' + size);
+if (aliases.length > 0) {
+  console.log('Aliases:     ' + aliases.map(a => a.name).join(', '));
+}
+" "$ARGUMENTS"
+```
+
+### List Aliases
+
+Show all session aliases.
+
+```bash
+/sessions aliases                      # List all aliases
+```
+
+**Script:**
+```bash
+node -e "
+const aa = require('./scripts/lib/session-aliases');
+
+const aliases = aa.listAliases();
+console.log('Session Aliases (' + aliases.length + '):');
+console.log('');
+
+if (aliases.length === 0) {
+  console.log('No aliases found.');
+} else {
+  console.log('Name          Session File                    Title');
+  console.log('─────────────────────────────────────────────────────────────');
+  for (const a of aliases) {
+    const name = a.name.padEnd(12);
+    const file = (a.sessionPath.length > 30 ? a.sessionPath.slice(0, 27) + '...' : a.sessionPath).padEnd(30);
+    const title = a.title || '';
+    console.log(name + ' ' + file + ' ' + title);
+  }
+}
+"
+```
+
+## Arguments
+
+$ARGUMENTS:
+- `list [options]` - List sessions
+  - `--limit <n>` - Max sessions to show (default: 50)
+  - `--date <YYYY-MM-DD>` - Filter by date
+  - `--search <pattern>` - Search in session ID
+- `load <id|alias>` - Load session content
+- `alias <id> <name>` - Create alias for session
+- `alias --remove <name>` - Remove alias
+- `unalias <name>` - Same as `--remove`
+- `info <id|alias>` - Show session statistics
+- `aliases` - List all aliases
+- `help` - Show this help
+
+## Examples
+
+```bash
+# List all sessions
+/sessions list
+
+# Create an alias for today's session
+/sessions alias 2026-02-01 today
+
+# Load session by alias
+/sessions load today
+
+# Show session info
+/sessions info today
+
+# Remove alias
+/sessions alias --remove today
+
+# List all aliases
+/sessions aliases
+```
+
+## Notes
+
+- Sessions are stored as markdown files in a sessions directory
+- Aliases are stored in `session-aliases.json`
+- Session IDs can be shortened (first 4-8 characters usually unique enough)
+- Use aliases for frequently referenced sessions
--- a/.cursor/commands/setup-pm.md
+++ b/.cursor/commands/setup-pm.md
@@ -0,0 +1,80 @@
+---
+description: Configure your preferred package manager (npm/pnpm/yarn/bun)
+disable-model-invocation: true
+---
+
+# Package Manager Setup
+
+Configure your preferred package manager for this project or globally.
+
+## Usage
+
+```bash
+# Detect current package manager
+node scripts/setup-package-manager.js --detect
+
+# Set global preference
+node scripts/setup-package-manager.js --global pnpm
+
+# Set project preference
+node scripts/setup-package-manager.js --project bun
+
+# List available package managers
+node scripts/setup-package-manager.js --list
+```
+
+## Detection Priority
+
+When determining which package manager to use, the following order is checked:
+
+1. **Environment variable**: `CLAUDE_PACKAGE_MANAGER`
+2. **Project config**: `.cursor/package-manager.json`
+3. **package.json**: `packageManager` field
+4. **Lock file**: Presence of package-lock.json, yarn.lock, pnpm-lock.yaml, or bun.lockb
+5. **Global config**: `package-manager.json`
+6. **Fallback**: First available package manager (pnpm > bun > yarn > npm)
+
+## Configuration Files
+
+### Global Configuration
+```json
+// package-manager.json
+{
+  "packageManager": "pnpm"
+}
+```
+
+### Project Configuration
+```json
+// .cursor/package-manager.json
+{
+  "packageManager": "bun"
+}
+```
+
+### package.json
+```json
+{
+  "packageManager": "pnpm@8.6.0"
+}
+```
+
+## Environment Variable
+
+Set `CLAUDE_PACKAGE_MANAGER` to override all other detection methods:
+
+```bash
+# Windows (PowerShell)
+$env:CLAUDE_PACKAGE_MANAGER = "pnpm"
+
+# macOS/Linux
+export CLAUDE_PACKAGE_MANAGER=pnpm
+```
+
+## Run the Detection
+
+To see current package manager detection results, run:
+
+```bash
+node scripts/setup-package-manager.js --detect
+```
--- a/.cursor/commands/skill-create.md
+++ b/.cursor/commands/skill-create.md
@@ -0,0 +1,174 @@
+---
+name: skill-create
+description: Analyze local git history to extract coding patterns and generate SKILL.md files. Local version of the Skill Creator GitHub App.
+allowed_tools: ["Bash", "Read", "Write", "Grep", "Glob"]
+---
+
+# /skill-create - Local Skill Generation
+
+Analyze your repository's git history to extract coding patterns and generate SKILL.md files that teach Claude your team's practices.
+
+## Usage
+
+```bash
+/skill-create                    # Analyze current repo
+/skill-create --commits 100      # Analyze last 100 commits
+/skill-create --output ./skills  # Custom output directory
+/skill-create --instincts        # Also generate instincts for continuous-learning-v2
+```
+
+## What It Does
+
+1. **Parses Git History** - Analyzes commits, file changes, and patterns
+2. **Detects Patterns** - Identifies recurring workflows and conventions
+3. **Generates SKILL.md** - Creates valid skill files
+4. **Optionally Creates Instincts** - For the continuous-learning-v2 system
+
+## Analysis Steps
+
+### Step 1: Gather Git Data
+
+```bash
+# Get recent commits with file changes
+git log --oneline -n ${COMMITS:-200} --name-only --pretty=format:"%H|%s|%ad" --date=short
+
+# Get commit frequency by file
+git log --oneline -n 200 --name-only | grep -v "^$" | grep -v "^[a-f0-9]" | sort | uniq -c | sort -rn | head -20
+
+# Get commit message patterns
+git log --oneline -n 200 | cut -d' ' -f2- | head -50
+```
+
+### Step 2: Detect Patterns
+
+Look for these pattern types:
+
+| Pattern | Detection Method |
+|---------|-----------------|
+| **Commit conventions** | Regex on commit messages (feat:, fix:, chore:) |
+| **File co-changes** | Files that always change together |
+| **Workflow sequences** | Repeated file change patterns |
+| **Architecture** | Folder structure and naming conventions |
+| **Testing patterns** | Test file locations, naming, coverage |
+
+### Step 3: Generate SKILL.md
+
+Output format:
+
+```markdown
+---
+name: {repo-name}-patterns
+description: Coding patterns extracted from {repo-name}
+version: 1.0.0
+source: local-git-analysis
+analyzed_commits: {count}
+---
+
+# {Repo Name} Patterns
+
+## Commit Conventions
+{detected commit message patterns}
+
+## Code Architecture
+{detected folder structure and organization}
+
+## Workflows
+{detected repeating file change patterns}
+
+## Testing Patterns
+{detected test conventions}
+```
+
+### Step 4: Generate Instincts (if --instincts)
+
+For continuous-learning-v2 integration:
+
+```yaml
+---
+id: {repo}-commit-convention
+trigger: "when writing a commit message"
+confidence: 0.8
+domain: git
+source: local-repo-analysis
+---
+
+# Use Conventional Commits
+
+## Action
+Prefix commits with: feat:, fix:, chore:, docs:, test:, refactor:
+
+## Evidence
+- Analyzed {n} commits
+- {percentage}% follow conventional commit format
+```
+
+## Example Output
+
+Running `/skill-create` on a TypeScript project might produce:
+
+```markdown
+---
+name: my-app-patterns
+description: Coding patterns from my-app repository
+version: 1.0.0
+source: local-git-analysis
+analyzed_commits: 150
+---
+
+# My App Patterns
+
+## Commit Conventions
+
+This project uses **conventional commits**:
+- `feat:` - New features
+- `fix:` - Bug fixes
+- `chore:` - Maintenance tasks
+- `docs:` - Documentation updates
+
+## Code Architecture
+
+```
+src/
+├── components/     # React components (PascalCase.tsx)
+├── hooks/          # Custom hooks (use*.ts)
+├── utils/          # Utility functions
+├── types/          # TypeScript type definitions
+└── services/       # API and external services
+```
+
+## Workflows
+
+### Adding a New Component
+1. Create `src/components/ComponentName.tsx`
+2. Add tests in `src/components/__tests__/ComponentName.test.tsx`
+3. Export from `src/components/index.ts`
+
+### Database Migration
+1. Modify `src/db/schema.ts`
+2. Run `pnpm db:generate`
+3. Run `pnpm db:migrate`
+
+## Testing Patterns
+
+- Test files: `__tests__/` directories or `.test.ts` suffix
+- Coverage target: 80%+
+- Framework: Vitest
+```
+
+## GitHub App Integration
+
+For advanced features (10k+ commits, team sharing, auto-PRs), use the [Skill Creator GitHub App](https://github.com/apps/skill-creator):
+
+- Install: [github.com/apps/skill-creator](https://github.com/apps/skill-creator)
+- Comment `/skill-creator analyze` on any issue
+- Receives PR with generated skills
+
+## Related Commands
+
+- `/instinct-import` - Import generated instincts
+- `/instinct-status` - View learned instincts
+- `/evolve` - Cluster instincts into skills/agents
+
+---
+
+*Part of [Everything Claude Code](https://github.com/affaan-m/everything-claude-code)*
--- a/.cursor/commands/tdd.md
+++ b/.cursor/commands/tdd.md
@@ -0,0 +1,324 @@
+---
+description: Enforce test-driven development workflow. Scaffold interfaces, generate tests FIRST, then implement minimal code to pass. Ensure 80%+ coverage.
+---
+
+# TDD Command
+
+This command invokes the **tdd-guide** agent to enforce test-driven development methodology.
+
+## What This Command Does
+
+1. **Scaffold Interfaces** - Define types/interfaces first
+2. **Generate Tests First** - Write failing tests (RED)
+3. **Implement Minimal Code** - Write just enough to pass (GREEN)
+4. **Refactor** - Improve code while keeping tests green (REFACTOR)
+5. **Verify Coverage** - Ensure 80%+ test coverage
+
+## When to Use
+
+Use `/tdd` when:
+- Implementing new features
+- Adding new functions/components
+- Fixing bugs (write test that reproduces bug first)
+- Refactoring existing code
+- Building critical business logic
+
+## How It Works
+
+The tdd-guide agent will:
+
+1. **Define interfaces** for inputs/outputs
+2. **Write tests that will FAIL** (because code doesn't exist yet)
+3. **Run tests** and verify they fail for the right reason
+4. **Write minimal implementation** to make tests pass
+5. **Run tests** and verify they pass
+6. **Refactor** code while keeping tests green
+7. **Check coverage** and add more tests if below 80%
+
+## TDD Cycle
+
+```
+RED → GREEN → REFACTOR → REPEAT
+
+RED:      Write a failing test
+GREEN:    Write minimal code to pass
+REFACTOR: Improve code, keep tests passing
+REPEAT:   Next feature/scenario
+```
+
+## Example Usage
+
+```
+User: /tdd I need a function to calculate market liquidity score
+
+Agent (tdd-guide):
+# TDD Session: Market Liquidity Score Calculator
+
+## Step 1: Define Interface (SCAFFOLD)
+
+```typescript
+// lib/liquidity.ts
+export interface MarketData {
+  totalVolume: number
+  bidAskSpread: number
+  activeTraders: number
+  lastTradeTime: Date
+}
+
+export function calculateLiquidityScore(market: MarketData): number {
+  // TODO: Implementation
+  throw new Error('Not implemented')
+}
+```
+
+## Step 2: Write Failing Test (RED)
+
+```typescript
+// lib/liquidity.test.ts
+import { calculateLiquidityScore } from './liquidity'
+
+describe('calculateLiquidityScore', () => {
+  it('should return high score for liquid market', () => {
+    const market = {
+      totalVolume: 100000,
+      bidAskSpread: 0.01,
+      activeTraders: 500,
+      lastTradeTime: new Date()
+    }
+
+    const score = calculateLiquidityScore(market)
+
+    expect(score).toBeGreaterThan(80)
+    expect(score).toBeLessThanOrEqual(100)
+  })
+
+  it('should return low score for illiquid market', () => {
+    const market = {
+      totalVolume: 100,
+      bidAskSpread: 0.5,
+      activeTraders: 2,
+      lastTradeTime: new Date(Date.now() - 86400000) // 1 day ago
+    }
+
+    const score = calculateLiquidityScore(market)
+
+    expect(score).toBeLessThan(30)
+    expect(score).toBeGreaterThanOrEqual(0)
+  })
+
+  it('should handle edge case: zero volume', () => {
+    const market = {
+      totalVolume: 0,
+      bidAskSpread: 0,
+      activeTraders: 0,
+      lastTradeTime: new Date()
+    }
+
+    const score = calculateLiquidityScore(market)
+
+    expect(score).toBe(0)
+  })
+})
+```
+
+## Step 3: Run Tests - Verify FAIL
+
+```bash
+npm test lib/liquidity.test.ts
+
+FAIL lib/liquidity.test.ts
+  ✕ should return high score for liquid market (2 ms)
+    Error: Not implemented
+
+1 test failed, 0 passed
+```
+
+✅ Tests fail as expected. Ready to implement.
+
+## Step 4: Implement Minimal Code (GREEN)
+
+```typescript
+// lib/liquidity.ts
+export function calculateLiquidityScore(market: MarketData): number {
+  // Handle zero volume edge case
+  if (market.totalVolume === 0) {
+    return 0
+  }
+
+  // Calculate component scores (0-100 scale)
+  const volumeScore = Math.min(market.totalVolume / 1000, 100)
+  const spreadScore = Math.max(100 - (market.bidAskSpread * 1000), 0)
+  const traderScore = Math.min(market.activeTraders / 10, 100)
+
+  // Recent activity bonus
+  const hoursSinceLastTrade = (Date.now() - market.lastTradeTime.getTime()) / (1000 * 60 * 60)
+  const recencyScore = Math.max(100 - (hoursSinceLastTrade * 10), 0)
+
+  // Weighted average
+  const score = (
+    volumeScore * 0.4 +
+    spreadScore * 0.3 +
+    traderScore * 0.2 +
+    recencyScore * 0.1
+  )
+
+  return Math.min(Math.max(score, 0), 100) // Clamp to 0-100
+}
+```
+
+## Step 5: Run Tests - Verify PASS
+
+```bash
+npm test lib/liquidity.test.ts
+
+PASS lib/liquidity.test.ts
+  ✓ should return high score for liquid market (3 ms)
+  ✓ should return low score for illiquid market (2 ms)
+  ✓ should handle edge case: zero volume (1 ms)
+
+3 tests passed
+```
+
+✅ All tests passing!
+
+## Step 6: Refactor (IMPROVE)
+
+```typescript
+// lib/liquidity.ts - Refactored with constants and better readability
+const WEIGHTS = {
+  VOLUME: 0.4,
+  SPREAD: 0.3,
+  TRADERS: 0.2,
+  RECENCY: 0.1,
+} as const
+
+const SCALE_FACTORS = {
+  VOLUME: 1000,
+  SPREAD: 1000,
+  TRADERS: 10,
+  RECENCY_PENALTY: 10,
+} as const
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max)
+}
+
+export function calculateLiquidityScore(market: MarketData): number {
+  if (market.totalVolume === 0) return 0
+
+  const volumeScore = Math.min(market.totalVolume / SCALE_FACTORS.VOLUME, 100)
+  const spreadScore = clamp(100 - (market.bidAskSpread * SCALE_FACTORS.SPREAD), 0, 100)
+  const traderScore = Math.min(market.activeTraders / SCALE_FACTORS.TRADERS, 100)
+
+  const hoursSinceLastTrade = (Date.now() - market.lastTradeTime.getTime()) / (1000 * 60 * 60)
+  const recencyScore = clamp(100 - (hoursSinceLastTrade * SCALE_FACTORS.RECENCY_PENALTY), 0, 100)
+
+  const weightedScore =
+    volumeScore * WEIGHTS.VOLUME +
+    spreadScore * WEIGHTS.SPREAD +
+    traderScore * WEIGHTS.TRADERS +
+    recencyScore * WEIGHTS.RECENCY
+
+  return clamp(weightedScore, 0, 100)
+}
+```
+
+## Step 7: Verify Tests Still Pass
+
+```bash
+npm test lib/liquidity.test.ts
+
+PASS lib/liquidity.test.ts
+  ✓ should return high score for liquid market (3 ms)
+  ✓ should return low score for illiquid market (2 ms)
+  ✓ should handle edge case: zero volume (1 ms)
+
+3 tests passed
+```
+
+✅ Refactoring complete, tests still passing!
+
+## Step 8: Check Coverage
+
+```bash
+npm test -- --coverage lib/liquidity.test.ts
+
+File           | % Stmts | % Branch | % Funcs | % Lines
+---------------|---------|----------|---------|--------
+liquidity.ts   |   100   |   100    |   100   |   100
+
+Coverage: 100% ✅ (Target: 80%)
+```
+
+✅ TDD session complete!
+```
+
+## TDD Best Practices
+
+**DO:**
+- ✅ Write the test FIRST, before any implementation
+- ✅ Run tests and verify they FAIL before implementing
+- ✅ Write minimal code to make tests pass
+- ✅ Refactor only after tests are green
+- ✅ Add edge cases and error scenarios
+- ✅ Aim for 80%+ coverage (100% for critical code)
+
+**DON'T:**
+- ❌ Write implementation before tests
+- ❌ Skip running tests after each change
+- ❌ Write too much code at once
+- ❌ Ignore failing tests
+- ❌ Test implementation details (test behavior)
+- ❌ Mock everything (prefer integration tests)
+
+## Test Types to Include
+
+**Unit Tests** (Function-level):
+- Happy path scenarios
+- Edge cases (empty, null, max values)
+- Error conditions
+- Boundary values
+
+**Integration Tests** (Component-level):
+- API endpoints
+- Database operations
+- External service calls
+- React components with hooks
+
+**E2E Tests** (use `/e2e` command):
+- Critical user flows
+- Multi-step processes
+- Full stack integration
+
+## Coverage Requirements
+
+- **80% minimum** for all code
+- **100% required** for:
+  - Financial calculations
+  - Authentication logic
+  - Security-critical code
+  - Core business logic
+
+## Important Notes
+
+**MANDATORY**: Tests must be written BEFORE implementation. The TDD cycle is:
+
+1. **RED** - Write failing test
+2. **GREEN** - Implement to pass
+3. **REFACTOR** - Improve code
+
+Never skip the RED phase. Never write code before tests.
+
+## Integration with Other Commands
+
+- Use `/plan` first to understand what to build
+- Use `/tdd` to implement with tests
+- Use `/build-and-fix` if build errors occur
+- Use `/code-review` to review implementation
+- Use `/test-coverage` to verify coverage
+
+## Related Agents
+
+This command invokes the `tdd-guide` agent.
+
+And can reference the `tdd-workflow` skill.
--- a/.cursor/commands/test-coverage.md
+++ b/.cursor/commands/test-coverage.md
@@ -0,0 +1,27 @@
+# Test Coverage
+
+Analyze test coverage and generate missing tests:
+
+1. Run tests with coverage: npm test --coverage or pnpm test --coverage
+
+2. Analyze coverage report (coverage/coverage-summary.json)
+
+3. Identify files below 80% coverage threshold
+
+4. For each under-covered file:
+   - Analyze untested code paths
+   - Generate unit tests for functions
+   - Generate integration tests for APIs
+   - Generate E2E tests for critical flows
+
+5. Verify new tests pass
+
+6. Show before/after coverage metrics
+
+7. Ensure project reaches 80%+ overall coverage
+
+Focus on:
+- Happy path scenarios
+- Error handling
+- Edge cases (null, undefined, empty)
+- Boundary conditions
--- a/.cursor/commands/update-codemaps.md
+++ b/.cursor/commands/update-codemaps.md
@@ -0,0 +1,17 @@
+# Update Codemaps
+
+Analyze the codebase structure and update architecture documentation:
+
+1. Scan all source files for imports, exports, and dependencies
+2. Generate token-lean codemaps in the following format:
+   - codemaps/architecture.md - Overall architecture
+   - codemaps/backend.md - Backend structure
+   - codemaps/frontend.md - Frontend structure
+   - codemaps/data.md - Data models and schemas
+
+3. Calculate diff percentage from previous version
+4. If changes > 30%, request user approval before updating
+5. Add freshness timestamp to each codemap
+6. Save reports to .reports/codemap-diff.txt
+
+Use TypeScript/Node.js for analysis. Focus on high-level structure, not implementation details.
--- a/.cursor/commands/update-docs.md
+++ b/.cursor/commands/update-docs.md
@@ -0,0 +1,31 @@
+# Update Documentation
+
+Sync documentation from source-of-truth:
+
+1. Read package.json scripts section
+   - Generate scripts reference table
+   - Include descriptions from comments
+
+2. Read .env.example
+   - Extract all environment variables
+   - Document purpose and format
+
+3. Generate docs/CONTRIB.md with:
+   - Development workflow
+   - Available scripts
+   - Environment setup
+   - Testing procedures
+
+4. Generate docs/RUNBOOK.md with:
+   - Deployment procedures
+   - Monitoring and alerts
+   - Common issues and fixes
+   - Rollback procedures
+
+5. Identify obsolete documentation:
+   - Find docs not modified in 90+ days
+   - List for manual review
+
+6. Show diff summary
+
+Single source of truth: package.json and .env.example
--- a/.cursor/commands/verify.md
+++ b/.cursor/commands/verify.md
@@ -0,0 +1,59 @@
+# Verification Command
+
+Run comprehensive verification on current codebase state.
+
+## Instructions
+
+Execute verification in this exact order:
+
+1. **Build Check**
+   - Run the build command for this project
+   - If it fails, report errors and STOP
+
+2. **Type Check**
+   - Run TypeScript/type checker
+   - Report all errors with file:line
+
+3. **Lint Check**
+   - Run linter
+   - Report warnings and errors
+
+4. **Test Suite**
+   - Run all tests
+   - Report pass/fail count
+   - Report coverage percentage
+
+5. **Console.log Audit**
+   - Search for console.log in source files
+   - Report locations
+
+6. **Git Status**
+   - Show uncommitted changes
+   - Show files modified since last commit
+
+## Output
+
+Produce a concise verification report:
+
+```
+VERIFICATION: [PASS/FAIL]
+
+Build:    [OK/FAIL]
+Types:    [OK/X errors]
+Lint:     [OK/X issues]
+Tests:    [X/Y passed, Z% coverage]
+Secrets:  [OK/X found]
+Logs:     [OK/X console.logs]
+
+Ready for PR: [YES/NO]
+```
+
+If any critical issues, list them with fix suggestions.
+
+## Arguments
+
+$ARGUMENTS can be:
+- `quick` - Only build + types
+- `full` - All checks (default)
+- `pre-commit` - Checks relevant for commits
+- `pre-pr` - Full checks plus security scan