claudecto 0.1.0

package/dist/services/advisor.js

@@ -0,0 +1,2636 @@
+/**
+ * AI Advisor Service - Proactive Intelligence Engine
+ *
+ * Analyzes Claude Code usage patterns and generates actionable recommendations:
+ * - Repeated prompts → Skill suggestions
+ * - Error patterns → Hook suggestions
+ * - Clarification loops → CLAUDE.md additions
+ * - Model performance → Model recommendations
+ *
+ * IMPORTANT: This service must intelligently distinguish between:
+ * - Actual user requests/intentions (skill candidates)
+ * - Tool results (file contents, command outputs)
+ * - System messages and code snippets
+ */
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import crypto from 'node:crypto';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+const SKILL_KNOWLEDGE_BASE = [
+    // === DEPLOYMENT SKILLS ===
+    {
+        name: 'deploy-vercel',
+        description: 'Deploy the current project to Vercel with automatic preview URLs',
+        category: 'deployment',
+        techStack: ['next', 'nextjs', 'react', 'vite', 'astro', 'nuxt', 'svelte'],
+        triggers: ['deploy', 'vercel', 'ship', 'publish', 'production', 'preview'],
+        confidence: 0.9,
+        content: `---
+description: Deploy the current project to Vercel
+user-invocable: true
+---
+
+# Deploy to Vercel
+
+Deploy the current project to Vercel for production or preview.
+
+## Instructions
+
+1. Check if the Vercel CLI is installed (\`which vercel\`), suggest installation if not
+2. Run \`vercel\` to deploy (or \`vercel --prod\` for production)
+3. If no vercel.json exists and deployment fails, help configure it
+4. Return the deployment URL when complete
+
+$ARGUMENTS`,
+    },
+    {
+        name: 'deploy-netlify',
+        description: 'Deploy the current project to Netlify',
+        category: 'deployment',
+        techStack: ['next', 'nextjs', 'react', 'vite', 'gatsby', 'hugo', 'astro'],
+        triggers: ['deploy', 'netlify', 'ship', 'publish'],
+        confidence: 0.85,
+        content: `---
+description: Deploy the current project to Netlify
+user-invocable: true
+---
+
+# Deploy to Netlify
+
+Deploy the current project to Netlify.
+
+## Instructions
+
+1. Check if Netlify CLI is installed (\`which netlify\`)
+2. Run \`netlify deploy\` for preview or \`netlify deploy --prod\` for production
+3. Return the deployment URL
+
+$ARGUMENTS`,
+    },
+    // === GIT & VERSION CONTROL SKILLS ===
+    {
+        name: 'commit',
+        description: 'Create well-structured git commits with conventional commit messages',
+        category: 'git',
+        techStack: ['*'], // Universal
+        triggers: ['commit', 'git', 'save', 'changes', 'staged'],
+        confidence: 0.95,
+        content: `---
+description: Create a well-structured git commit with conventional commit message
+user-invocable: true
+---
+
+# Smart Commit
+
+Create a well-structured git commit following conventional commits.
+
+## Instructions
+
+1. Run \`git status\` and \`git diff --staged\` to understand changes
+2. Analyze the changes to determine the commit type:
+   - feat: New feature
+   - fix: Bug fix
+   - docs: Documentation only
+   - style: Formatting, no code change
+   - refactor: Code change without feature/fix
+   - test: Adding tests
+   - chore: Maintenance
+3. Generate a commit message: \`<type>(<scope>): <description>\`
+4. Include a body explaining WHY if the change is significant
+5. Run \`git commit -m "..."\`
+
+$ARGUMENTS`,
+    },
+    {
+        name: 'pr-create',
+        description: 'Create a pull request with proper description and checklist',
+        category: 'git',
+        techStack: ['*'],
+        triggers: ['pr', 'pull request', 'merge', 'review', 'github'],
+        confidence: 0.9,
+        content: `---
+description: Create a pull request with proper title, description, and checklist
+user-invocable: true
+---
+
+# Create Pull Request
+
+Create a well-structured pull request.
+
+## Instructions
+
+1. Check current branch and commits with \`git log main..HEAD\`
+2. Analyze the changes to write a clear PR title
+3. Generate a description with:
+   - Summary of changes
+   - Why this change is needed
+   - How to test
+   - Checklist of items
+4. Use \`gh pr create\` to create the PR
+5. Return the PR URL
+
+$ARGUMENTS`,
+    },
+    {
+        name: 'code-review',
+        description: 'Review code for issues, security vulnerabilities, and improvements',
+        category: 'git',
+        techStack: ['*'],
+        triggers: ['review', 'pr', 'feedback', 'check', 'audit'],
+        confidence: 0.88,
+        content: `---
+description: Review code for issues, security, and improvements
+user-invocable: true
+---
+
+# Code Review
+
+Perform a thorough code review.
+
+## Review Checklist
+
+### Correctness
+- Logic errors and edge cases
+- Null/undefined handling
+- Error handling completeness
+
+### Security
+- Input validation
+- SQL injection / XSS vulnerabilities
+- Sensitive data exposure
+
+### Performance
+- Inefficient algorithms
+- Unnecessary re-renders
+- Memory leaks
+
+### Maintainability
+- Code readability
+- DRY principle
+- Test coverage
+
+## Output Format
+
+1. **Critical Issues** - Must fix
+2. **Suggestions** - Recommended improvements
+3. **Positive Notes** - What was done well
+
+$ARGUMENTS`,
+    },
+    // === TESTING SKILLS ===
+    {
+        name: 'run-tests',
+        description: 'Run tests and analyze results with helpful feedback',
+        category: 'testing',
+        techStack: ['*'],
+        triggers: ['test', 'tests', 'spec', 'jest', 'vitest', 'pytest', 'mocha'],
+        confidence: 0.92,
+        content: `---
+description: Run tests and analyze results
+user-invocable: true
+---
+
+# Run Tests
+
+Run the project's test suite and analyze results.
+
+## Instructions
+
+1. Detect the test framework (jest, vitest, pytest, etc.)
+2. Run the appropriate test command
+3. If tests fail:
+   - Analyze the failure messages
+   - Identify the root cause
+   - Suggest fixes
+4. Report summary: passed, failed, skipped
+
+$ARGUMENTS`,
+    },
+    {
+        name: 'generate-tests',
+        description: 'Generate comprehensive unit tests for the specified code',
+        category: 'testing',
+        techStack: ['*'],
+        triggers: ['test', 'tests', 'coverage', 'unit test', 'spec'],
+        confidence: 0.85,
+        content: `---
+description: Generate comprehensive unit tests
+user-invocable: true
+---
+
+# Generate Tests
+
+Generate unit tests for the specified code.
+
+## Instructions
+
+1. Analyze the code to understand its functionality
+2. Generate tests covering:
+   - Happy path scenarios
+   - Edge cases
+   - Error handling
+   - Boundary conditions
+3. Follow the project's existing test patterns
+4. Use appropriate assertions
+
+$ARGUMENTS`,
+    },
+    // === CODE QUALITY SKILLS ===
+    {
+        name: 'lint-fix',
+        description: 'Run linter and automatically fix issues',
+        category: 'code-quality',
+        techStack: ['javascript', 'typescript', 'react', 'node'],
+        triggers: ['lint', 'eslint', 'fix', 'format', 'style'],
+        confidence: 0.9,
+        content: `---
+description: Run linter and fix issues
+user-invocable: true
+---
+
+# Lint and Fix
+
+Run the linter and fix issues automatically.
+
+## Instructions
+
+1. Detect the linter (eslint, biome, etc.)
+2. Run with auto-fix: \`npm run lint -- --fix\` or equivalent
+3. Report remaining issues that need manual attention
+
+$ARGUMENTS`,
+    },
+    {
+        name: 'type-check',
+        description: 'Run TypeScript type checking and help fix errors',
+        category: 'code-quality',
+        techStack: ['typescript', 'ts'],
+        triggers: ['type', 'types', 'typescript', 'tsc', 'type error'],
+        confidence: 0.88,
+        content: `---
+description: Run TypeScript type checking
+user-invocable: true
+---
+
+# Type Check
+
+Run TypeScript type checking and help fix errors.
+
+## Instructions
+
+1. Run \`npx tsc --noEmit\` to check types
+2. If errors found:
+   - Explain each error clearly
+   - Suggest fixes
+   - Apply fixes if requested
+
+$ARGUMENTS`,
+    },
+    // === DOCUMENTATION SKILLS ===
+    {
+        name: 'generate-docs',
+        description: 'Generate documentation for code',
+        category: 'documentation',
+        techStack: ['*'],
+        triggers: ['docs', 'documentation', 'readme', 'jsdoc', 'comment'],
+        confidence: 0.85,
+        content: `---
+description: Generate documentation for code
+user-invocable: true
+---
+
+# Generate Documentation
+
+Generate comprehensive documentation.
+
+## Instructions
+
+1. Analyze the code structure
+2. Generate appropriate documentation:
+   - JSDoc comments for functions
+   - README sections
+   - API documentation
+3. Follow the project's documentation style
+
+$ARGUMENTS`,
+    },
+    {
+        name: 'update-readme',
+        description: 'Update the README with current project information',
+        category: 'documentation',
+        techStack: ['*'],
+        triggers: ['readme', 'documentation', 'docs', 'update'],
+        confidence: 0.82,
+        content: `---
+description: Update README with current project info
+user-invocable: true
+---
+
+# Update README
+
+Update the README file with current project information.
+
+## Instructions
+
+1. Read the current README
+2. Analyze the project structure
+3. Update sections:
+   - Installation instructions
+   - Usage examples
+   - API reference (if applicable)
+   - Contributing guidelines
+
+$ARGUMENTS`,
+    },
+    // === SCAFFOLDING SKILLS ===
+    {
+        name: 'create-component',
+        description: 'Create a new React/Vue/Svelte component with proper structure',
+        category: 'scaffolding',
+        techStack: ['react', 'vue', 'svelte', 'next', 'nextjs', 'nuxt'],
+        triggers: ['component', 'create', 'new', 'scaffold', 'generate'],
+        confidence: 0.88,
+        content: `---
+description: Create a new component with proper structure
+user-invocable: true
+---
+
+# Create Component
+
+Create a new component following project conventions.
+
+## Instructions
+
+1. Detect the framework (React, Vue, Svelte)
+2. Find existing component patterns in the project
+3. Create the component with:
+   - Proper file structure
+   - TypeScript types (if using TS)
+   - Basic props interface
+   - Matching style file if project uses CSS modules
+4. Add basic tests if project has test files for components
+
+$ARGUMENTS - provide component name and description`,
+    },
+    {
+        name: 'create-api-route',
+        description: 'Create a new API route/endpoint',
+        category: 'scaffolding',
+        techStack: ['next', 'nextjs', 'express', 'fastify', 'hono', 'node'],
+        triggers: ['api', 'route', 'endpoint', 'create', 'new'],
+        confidence: 0.85,
+        content: `---
+description: Create a new API route/endpoint
+user-invocable: true
+---
+
+# Create API Route
+
+Create a new API endpoint following project patterns.
+
+## Instructions
+
+1. Detect the API framework (Next.js API routes, Express, etc.)
+2. Find existing API route patterns
+3. Create the route with:
+   - Proper request/response handling
+   - Input validation
+   - Error handling
+   - TypeScript types
+
+$ARGUMENTS - provide route path and description`,
+    },
+    // === DEBUGGING SKILLS ===
+    {
+        name: 'debug',
+        description: 'Help debug an issue with systematic analysis',
+        category: 'debugging',
+        techStack: ['*'],
+        triggers: ['debug', 'error', 'bug', 'issue', 'fix', 'broken', 'not working'],
+        confidence: 0.9,
+        content: `---
+description: Systematically debug an issue
+user-invocable: true
+---
+
+# Debug Issue
+
+Systematically debug and fix an issue.
+
+## Process
+
+1. **Understand**: What's the expected vs actual behavior?
+2. **Reproduce**: Identify minimal steps to reproduce
+3. **Locate**: Find the root cause through:
+   - Reading error messages
+   - Checking recent changes
+   - Adding debug logging
+4. **Fix**: Implement the minimal fix
+5. **Verify**: Confirm the fix works
+
+$ARGUMENTS - describe the issue`,
+    },
+    // === MCP & INTEGRATION SKILLS ===
+    {
+        name: 'mcp-builder',
+        description: 'Guide for creating MCP servers to integrate external APIs',
+        category: 'integration',
+        techStack: ['typescript', 'node', 'python'],
+        triggers: ['mcp', 'server', 'integration', 'api', 'tool'],
+        confidence: 0.8,
+        content: `---
+description: Create MCP servers for external integrations
+user-invocable: true
+---
+
+# MCP Server Builder
+
+Create MCP servers to integrate external APIs and services.
+
+## Structure
+
+\`\`\`typescript
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+
+const server = new Server({
+  name: "my-mcp-server",
+  version: "1.0.0",
+}, {
+  capabilities: { tools: {} }
+});
+\`\`\`
+
+## Instructions
+
+1. Define the tools with clear schemas
+2. Implement request handlers
+3. Add proper error handling
+4. Test the integration
+
+$ARGUMENTS - describe what to integrate`,
+    },
+    // === REFACTORING SKILLS ===
+    {
+        name: 'refactor',
+        description: 'Refactor code following best practices',
+        category: 'refactoring',
+        techStack: ['*'],
+        triggers: ['refactor', 'clean', 'improve', 'optimize', 'restructure'],
+        confidence: 0.85,
+        content: `---
+description: Refactor code following best practices
+user-invocable: true
+---
+
+# Refactor Code
+
+Refactor code for better readability, maintainability, and performance.
+
+## Goals
+
+- **Readability**: Clear naming, single responsibility
+- **DRY**: Remove duplication
+- **SOLID**: Apply principles where appropriate
+- **Performance**: Optimize hot paths
+
+## Process
+
+1. Identify code smells
+2. Plan incremental changes
+3. Refactor step by step
+4. Verify behavior after each step
+
+$ARGUMENTS - specify what to refactor`,
+    },
+];
+const AGENT_KNOWLEDGE_BASE = [
+    {
+        name: 'code-reviewer',
+        description: 'Reviews code for issues, security vulnerabilities, and improvements',
+        triggers: ['review', 'pr review', 'check code', 'audit', 'look over', 'feedback on'],
+        techStack: ['*'],
+        category: 'review',
+        content: `---
+name: code-reviewer
+description: Reviews code for issues, security vulnerabilities, and improvements
+allowed-tools: Read, Glob, Grep, LSP
+---
+
+# Code Reviewer Agent
+
+You are a thorough code reviewer. Analyze code for:
+
+## Review Checklist
+
+### Correctness
+- Logic errors and edge cases
+- Null/undefined handling
+- Error handling completeness
+
+### Security
+- Input validation
+- SQL injection / XSS vulnerabilities
+- Sensitive data exposure
+
+### Performance
+- Inefficient algorithms
+- Unnecessary re-renders (React)
+- Memory leaks
+
+### Maintainability
+- Code readability
+- DRY principle adherence
+- Test coverage
+
+## Output Format
+
+Provide feedback in these categories:
+1. **Critical Issues** - Must fix before merging
+2. **Suggestions** - Recommended improvements
+3. **Positive Notes** - What was done well
+
+$ARGUMENTS`,
+    },
+    {
+        name: 'test-writer',
+        description: 'Generates comprehensive unit and integration tests',
+        triggers: ['write tests', 'add tests', 'test coverage', 'unit tests', 'integration tests', 'spec'],
+        techStack: ['*'],
+        category: 'testing',
+        content: `---
+name: test-writer
+description: Generates comprehensive unit and integration tests
+allowed-tools: Read, Write, Edit, Glob, Grep, Bash
+---
+
+# Test Writer Agent
+
+You are an expert test writer. Generate comprehensive tests.
+
+## Test Categories
+
+### Unit Tests
+- Test individual functions in isolation
+- Mock dependencies appropriately
+- Cover edge cases and error conditions
+
+### Integration Tests
+- Test component interactions
+- Test API endpoints
+- Test database operations
+
+## Best Practices
+
+1. Follow the project's existing test patterns
+2. Use descriptive test names (should... when... given...)
+3. Aim for high coverage of critical paths
+4. Include both positive and negative test cases
+
+## Framework Detection
+
+- JavaScript/TypeScript: Look for jest, vitest, mocha
+- Python: Look for pytest, unittest
+- Go: Use standard testing package
+
+$ARGUMENTS`,
+    },
+    {
+        name: 'security-auditor',
+        description: 'Audits code for security vulnerabilities and OWASP issues',
+        triggers: ['security', 'vulnerabilities', 'audit security', 'owasp', 'secure', 'penetration'],
+        techStack: ['*'],
+        category: 'security',
+        content: `---
+name: security-auditor
+description: Audits code for security vulnerabilities and OWASP compliance
+allowed-tools: Read, Glob, Grep, Bash
+---
+
+# Security Auditor Agent
+
+You are a security expert. Audit code for vulnerabilities.
+
+## OWASP Top 10 Check
+
+1. **Injection** - SQL, NoSQL, OS, LDAP injection
+2. **Broken Authentication** - Session management issues
+3. **Sensitive Data Exposure** - Unencrypted secrets, logs
+4. **XML External Entities** - XXE attacks
+5. **Broken Access Control** - Missing authorization checks
+6. **Security Misconfiguration** - Debug modes, default credentials
+7. **XSS** - Cross-site scripting vulnerabilities
+8. **Insecure Deserialization** - Untrusted data deserialization
+9. **Vulnerable Components** - Outdated dependencies
+10. **Insufficient Logging** - Missing audit trails
+
+## Additional Checks
+
+- Hardcoded secrets (API keys, passwords)
+- Insecure random number generation
+- Path traversal vulnerabilities
+- CORS misconfigurations
+
+## Output Format
+
+Rate each finding by severity: CRITICAL, HIGH, MEDIUM, LOW
+
+$ARGUMENTS`,
+    },
+    {
+        name: 'docs-generator',
+        description: 'Generates documentation, READMEs, and JSDoc comments',
+        triggers: ['document', 'documentation', 'readme', 'jsdoc', 'typedoc', 'api docs'],
+        techStack: ['*'],
+        category: 'documentation',
+        content: `---
+name: docs-generator
+description: Generates comprehensive documentation
+allowed-tools: Read, Write, Edit, Glob, Grep
+---
+
+# Documentation Generator Agent
+
+You are a technical writer. Generate clear documentation.
+
+## Documentation Types
+
+### README.md
+- Project overview
+- Installation instructions
+- Usage examples
+- API reference
+- Contributing guidelines
+
+### API Documentation
+- Endpoint descriptions
+- Request/response examples
+- Authentication details
+- Error codes
+
+### Code Documentation
+- JSDoc/TSDoc comments
+- Function descriptions
+- Parameter documentation
+- Return value documentation
+
+## Best Practices
+
+1. Use clear, concise language
+2. Include practical examples
+3. Keep documentation up-to-date with code
+4. Use consistent formatting
+
+$ARGUMENTS`,
+    },
+    {
+        name: 'refactorer',
+        description: 'Refactors code for better readability, maintainability, and performance',
+        triggers: ['refactor', 'clean up', 'improve code', 'simplify', 'restructure', 'optimize'],
+        techStack: ['*'],
+        category: 'refactoring',
+        content: `---
+name: refactorer
+description: Refactors code following best practices
+allowed-tools: Read, Write, Edit, Glob, Grep, LSP
+---
+
+# Refactoring Agent
+
+You are a refactoring expert. Improve code quality.
+
+## Refactoring Goals
+
+### Readability
+- Clear variable/function names
+- Single responsibility principle
+- Consistent formatting
+
+### DRY (Don't Repeat Yourself)
+- Extract common code into functions
+- Create reusable utilities
+- Use inheritance/composition appropriately
+
+### SOLID Principles
+- Single Responsibility
+- Open/Closed
+- Liskov Substitution
+- Interface Segregation
+- Dependency Inversion
+
+### Performance
+- Optimize hot paths
+- Reduce unnecessary computations
+- Improve algorithmic complexity
+
+## Process
+
+1. Identify code smells
+2. Plan incremental changes
+3. Refactor step by step
+4. Verify behavior after each step
+
+$ARGUMENTS`,
+    },
+];
+const HOOK_KNOWLEDGE_BASE = [
+    {
+        name: 'lint-on-edit',
+        event: 'PostToolUse',
+        matcher: 'Edit',
+        command: 'npm run lint -- --fix "$TOOL_INPUT_file_path" 2>/dev/null || true',
+        description: 'Auto-fix linting issues after editing files',
+        triggers: ['lint errors', 'eslint', 'formatting issues', 'prettier'],
+    },
+    {
+        name: 'type-check-on-edit',
+        event: 'PostToolUse',
+        matcher: 'Edit',
+        command: 'npx tsc --noEmit 2>&1 | head -20 || true',
+        description: 'Run TypeScript type checking after edits',
+        triggers: ['type errors', 'typescript', 'tsc', 'type mismatch'],
+    },
+    {
+        name: 'test-related-on-edit',
+        event: 'PostToolUse',
+        matcher: 'Edit',
+        command: 'npm test -- --findRelatedTests "$TOOL_INPUT_file_path" --passWithNoTests 2>/dev/null || true',
+        description: 'Run related tests after editing files',
+        triggers: ['test failures', 'broken tests', 'test coverage'],
+    },
+    {
+        name: 'format-on-write',
+        event: 'PostToolUse',
+        matcher: 'Write',
+        command: 'npx prettier --write "$TOOL_INPUT_file_path" 2>/dev/null || true',
+        description: 'Auto-format newly written files',
+        triggers: ['formatting', 'prettier', 'code style'],
+    },
+    {
+        name: 'build-check',
+        event: 'PostToolUse',
+        matcher: 'Edit',
+        command: 'npm run build 2>&1 | tail -10 || true',
+        description: 'Check if build succeeds after changes',
+        triggers: ['build errors', 'compilation', 'bundle'],
+    },
+];
+const MCP_KNOWLEDGE_BASE = [
+    {
+        name: 'postgres',
+        description: 'Direct PostgreSQL access for queries and schema inspection',
+        triggers: ['postgres', 'postgresql', 'database', 'sql query', 'pg_dump', 'psql'],
+        npmPackage: '@modelcontextprotocol/server-postgres',
+        setupInstructions: `Add to your MCP settings:
+{
+  "mcpServers": {
+    "postgres": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@localhost/db"]
+    }
+  }
+}`,
+    },
+    {
+        name: 'github',
+        description: 'GitHub integration for issues, PRs, and repo management',
+        triggers: ['github api', 'issues', 'pull requests', 'gh pr', 'repository'],
+        npmPackage: '@modelcontextprotocol/server-github',
+        setupInstructions: `Add to your MCP settings:
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token" }
+    }
+  }
+}`,
+    },
+    {
+        name: 'filesystem',
+        description: 'Controlled filesystem access with explicit allowed directories',
+        triggers: ['file access', 'read files', 'directory', 'filesystem'],
+        npmPackage: '@modelcontextprotocol/server-filesystem',
+        setupInstructions: `Add to your MCP settings:
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"]
+    }
+  }
+}`,
+    },
+    {
+        name: 'memory',
+        description: 'Persistent memory storage for context across sessions',
+        triggers: ['remember', 'memory', 'store context', 'knowledge graph'],
+        npmPackage: '@modelcontextprotocol/server-memory',
+        setupInstructions: `Add to your MCP settings:
+{
+  "mcpServers": {
+    "memory": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-memory"]
+    }
+  }
+}`,
+    },
+    {
+        name: 'slack',
+        description: 'Slack integration for messaging and channel management',
+        triggers: ['slack', 'slack api', 'send message', 'channel'],
+        npmPackage: '@modelcontextprotocol/server-slack',
+        setupInstructions: `Add to your MCP settings:
+{
+  "mcpServers": {
+    "slack": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-slack"],
+      "env": { "SLACK_BOT_TOKEN": "xoxb-your-token" }
+    }
+  }
+}`,
+    },
+];
+const CLAUDE_MD_PATTERNS = [
+    {
+        pattern: /we\s+use\s+(postgres(?:ql)?|mysql|mongodb|redis|sqlite)/i,
+        category: 'tech-stack',
+        section: '## Database',
+        extractContent: (match) => `- ${match[1]} for data storage`,
+    },
+    {
+        pattern: /we\s+use\s+(react|vue|angular|svelte|next\.?js|nuxt)/i,
+        category: 'tech-stack',
+        section: '## Frontend Framework',
+        extractContent: (match) => `- ${match[1]} for frontend`,
+    },
+    {
+        pattern: /we\s+use\s+(jest|vitest|pytest|mocha|cypress|playwright)\s+for\s+test/i,
+        category: 'tech-stack',
+        section: '## Testing',
+        extractContent: (match) => `- ${match[1]} for testing`,
+    },
+    {
+        pattern: /we\s+(always|prefer|use)\s+(2|4|tab)\s*(-|\s)?space\s+indent/i,
+        category: 'conventions',
+        section: '## Code Style',
+        extractContent: (match) => `- Use ${match[2]}-space indentation`,
+    },
+    {
+        pattern: /we\s+(use|follow|prefer)\s+(kebab|camel|snake|pascal)\s*(-|\s)?case/i,
+        category: 'conventions',
+        section: '## Naming Conventions',
+        extractContent: (match) => `- Use ${match[2]}-case for naming`,
+    },
+    {
+        pattern: /don't\s+use\s+(\w+)/i,
+        category: 'preferences',
+        section: '## Preferences',
+        extractContent: (match) => `- Avoid using ${match[1]}`,
+    },
+    {
+        pattern: /prefer\s+(\w+)\s+over\s+(\w+)/i,
+        category: 'preferences',
+        section: '## Preferences',
+        extractContent: (match) => `- Prefer ${match[1]} over ${match[2]}`,
+    },
+];
+// ============================================================================
+// Constants
+// ============================================================================
+const ADVISOR_STATE_FILE = 'advisor-state.json';
+const DEFAULT_CONFIG = {
+    minPromptOccurrences: 3,
+    minErrorRate: 0.3,
+    minClarificationOccurrences: 2,
+    minSessionsForModelAnalysis: 5,
+    lookbackDays: 14,
+    confidenceThreshold: 0.5,
+};
+// Stop words for prompt normalization
+const STOP_WORDS = new Set([
+    'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should',
+    'may', 'might', 'must', 'shall', 'can', 'need', 'dare', 'ought', 'used',
+    'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as', 'into',
+    'through', 'during', 'before', 'after', 'above', 'below', 'between',
+    'and', 'but', 'or', 'nor', 'so', 'yet', 'both', 'either', 'neither',
+    'not', 'only', 'own', 'same', 'than', 'too', 'very', 'just', 'also',
+    'this', 'that', 'these', 'those', 'i', 'me', 'my', 'we', 'our', 'you', 'your',
+    'he', 'him', 'his', 'she', 'her', 'it', 'its', 'they', 'them', 'their',
+    'what', 'which', 'who', 'whom', 'when', 'where', 'why', 'how',
+    'all', 'each', 'every', 'any', 'some', 'no', 'none', 'one', 'two',
+    'please', 'thanks', 'thank', 'hey', 'hi', 'hello', 'ok', 'okay',
+]);
+// ============================================================================
+// INTELLIGENT FILTERING - Patterns that indicate NON-user-intent messages
+// ============================================================================
+// Patterns that indicate this is a TOOL RESULT, not a user request
+const TOOL_RESULT_PATTERNS = [
+    // File paths as first content
+    /^\/[a-zA-Z]/, // Starts with absolute path
+    /^[a-zA-Z]:\\/, // Windows path
+    /^~\//, // Home directory path
+    /^\.\.\//, // Relative path
+    /^\.\//, // Current directory path
+    // Tool result markers
+    /^\[?tool_result/i,
+    /^\[?tool_use/i,
+    /^Tool result/i,
+    /^Error:/,
+    /^error\[/i,
+    /^warning\[/i,
+    /^note:/i,
+    // System messages
+    /<system-reminder>/,
+    /<\/system-reminder>/,
+    /^<[a-z-]+>/, // XML-like tags
+    // File contents indicators
+    /^```/, // Code block
+    /^import\s+/, // Import statement
+    /^export\s+/, // Export statement
+    /^const\s+\w+\s*=/, // Const declaration
+    /^let\s+\w+\s*=/, // Let declaration
+    /^var\s+\w+\s*=/, // Var declaration
+    /^function\s+\w+/, // Function declaration
+    /^class\s+\w+/, // Class declaration
+    /^interface\s+\w+/, // Interface declaration
+    /^type\s+\w+\s*=/, // Type declaration
+    /^package\s+/, // Package declaration
+    /^#!\//, // Shebang
+    /^\s*\d+[→│|]\s*/, // Line numbers (from file reads)
+    // Command outputs
+    /^total\s+\d+/, // ls output
+    /^drwx/, // Directory listing
+    /^-rw/, // File listing
+    /^commit\s+[a-f0-9]{7,40}/i, // Git commit
+    /^Author:/, // Git log
+    /^Date:/, // Git log
+    /^Merge:/, // Git merge
+    /^diff --git/, // Git diff
+    /^@@\s+-\d+,\d+\s+\+\d+,\d+\s+@@/, // Diff hunk
+    /^\+\+\+\s+/, // Diff header
+    /^---\s+/, // Diff header
+    /^npm\s+(WARN|ERR!)/, // npm output
+    /^added\s+\d+\s+packages?/, // npm install output
+    /^up to date/, // npm output
+    /^audited\s+\d+/, // npm audit
+    /^\d+\s+packages?\s+are looking/, // npm funding
+    /^found\s+\d+\s+vulnerabilities?/i, // npm audit
+    /^Successfully/i, // Success messages
+    /^Created\s+/, // File creation output
+    /^Deleted\s+/, // File deletion output
+    /^Modified\s+/, // File modification output
+    /^Reading\s+/, // Reading output
+    /^Writing\s+/, // Writing output
+    /^Building\s+/, // Build output
+    /^Compiling\s+/, // Compile output
+    /^Bundling\s+/, // Bundle output
+    /^✓\s+/, // Success checkmark
+    /^✗\s+/, // Failure mark
+    /^•\s+/, // Bullet point output
+    /^>\s+\w+@/, // npm script output
+    /^vite\s+v\d/, // Vite output
+    /^dist\//, // Build output paths
+    /^chunks?\s+/i, // Build chunks
+    /^assets?\s+/i, // Build assets
+    /^gzip:/i, // Compression info
+    /^\(node:\d+\)/, // Node.js output
+    /^at\s+\w+\s+\(/, // Stack trace
+    /^    at\s+/, // Stack trace indent
+    /^\s+\d+\s*\|\s*/, // Error location
+    /^Process exited/, // Process output
+    /^Exit code:/, // Exit code
+    /^PASS\s+/, // Test output
+    /^FAIL\s+/, // Test output
+    /^Test Suites?:/, // Jest output
+    /^Tests?:/, // Test output
+    /^Snapshots?:/, // Jest output
+    /^Time:/, // Test time
+    /^Ran all test/, // Test summary
+    /^Coverage:/, // Coverage output
+    // JSON/data structures
+    /^\s*\{/, // JSON object start
+    /^\s*\[/, // JSON array start
+    // HTML/XML
+    /^<!DOCTYPE/i,
+    /^<html/i,
+    /^<head/i,
+    /^<body/i,
+    /^<meta/i,
+    /^<link/i,
+    /^<script/i,
+    /^<style/i,
+    /^<div/i,
+];
+// Patterns that indicate short/trivial messages (not skill-worthy)
+const TRIVIAL_PATTERNS = [
+    /^(ok|okay|yes|no|sure|thanks?|ty|thx|got it|understood|perfect|great|awesome|nice|cool|good|done|fixed|works?)\.?$/i,
+    /^(y|n|yep|nope|yup|nah)\.?$/i,
+    /^(sounds good|looks good|lgtm|makes sense)\.?$/i,
+    /^(continue|go ahead|proceed|next)\.?$/i,
+    /^👍|^👎|^✓|^✗|^❌|^✅/,
+];
+// Patterns that indicate this is an AI response accidentally in user messages
+const AI_RESPONSE_PATTERNS = [
+    /^(let me|i'll|i will|i can|i'm going to|here's|here is)/i,
+    /^(certainly|absolutely|of course|sure thing)/i,
+    /^(the file|the code|the function|the class|the component)/i,
+    /^(i've|i have) (created|updated|modified|fixed|added|removed)/i,
+    /^(now|first|next),?\s+(let me|i'll|i will)/i,
+    /^(looking at|analyzing|examining|checking|reading)/i,
+];
+// Patterns that indicate task/todo updates (system generated)
+const SYSTEM_GENERATED_PATTERNS = [
+    /^todos?\s+(modified|updated|created|deleted)/i,
+    /^task\s+(created|updated|completed|modified)/i,
+    /^file\s+(created|updated|modified|deleted)\s+successfully/i,
+    /^successfully\s+(created|updated|modified|deleted)/i,
+    /^output\s+file/i,
+    /^background\s+(task|shell|command)/i,
+    /^running\s+in\s+background/i,
+    /command\s+(running|completed|failed)/i,
+];
+// ============================================================================
+// POSITIVE INDICATORS - Patterns that suggest genuine user intent
+// ============================================================================
+// Action verbs that suggest a user request
+const USER_INTENT_VERBS = [
+    'add', 'create', 'make', 'build', 'implement', 'write', 'generate',
+    'fix', 'repair', 'debug', 'solve', 'resolve', 'correct',
+    'update', 'change', 'modify', 'edit', 'refactor', 'improve', 'optimize',
+    'remove', 'delete', 'clean', 'clear',
+    'test', 'check', 'verify', 'validate', 'ensure',
+    'deploy', 'publish', 'release', 'ship',
+    'install', 'setup', 'configure', 'init',
+    'explain', 'describe', 'show', 'tell', 'help',
+    'find', 'search', 'look', 'locate',
+    'run', 'execute', 'start', 'stop',
+    'review', 'analyze', 'examine',
+];
+// Question words that indicate user queries
+const QUESTION_INDICATORS = [
+    'how', 'what', 'why', 'where', 'when', 'which', 'who',
+    'can you', 'could you', 'would you', 'will you',
+    'is there', 'are there', 'do we', 'should we', 'shall we',
+];
+// ============================================================================
+// Advisor Service
+// ============================================================================
+export class AdvisorService {
+    claudeDir;
+    sessionService;
+    analyticsService;
+    skillsService;
+    hooksService;
+    memoryService;
+    agentsService;
+    config;
+    constructor(claudeDir, sessionService, analyticsService, skillsService, hooksService, memoryService, agentsService, config) {
+        this.claudeDir = claudeDir;
+        this.sessionService = sessionService;
+        this.analyticsService = analyticsService;
+        this.skillsService = skillsService;
+        this.hooksService = hooksService;
+        this.memoryService = memoryService;
+        this.agentsService = agentsService;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    // --------------------------------------------------------------------------
+    // CORE INTELLIGENCE: Is this a genuine user request?
+    // --------------------------------------------------------------------------
+    /**
+     * Determines if a message is a genuine user request that could become a skill.
+     * This is the CRITICAL function that filters out tool results, code, etc.
+     */
+    isGenuineUserRequest(content) {
+        if (!content)
+            return false;
+        const trimmed = content.trim();
+        // Length checks
+        if (trimmed.length < 15)
+            return false; // Too short
+        if (trimmed.length > 500)
+            return false; // Likely file content
+        // Check for tool result patterns (MOST COMMON FALSE POSITIVE)
+        for (const pattern of TOOL_RESULT_PATTERNS) {
+            if (pattern.test(trimmed)) {
+                return false;
+            }
+        }
+        // Check for trivial responses
+        for (const pattern of TRIVIAL_PATTERNS) {
+            if (pattern.test(trimmed)) {
+                return false;
+            }
+        }
+        // Check for AI response patterns
+        for (const pattern of AI_RESPONSE_PATTERNS) {
+            if (pattern.test(trimmed)) {
+                return false;
+            }
+        }
+        // Check for system-generated patterns
+        for (const pattern of SYSTEM_GENERATED_PATTERNS) {
+            if (pattern.test(trimmed)) {
+                return false;
+            }
+        }
+        // Check for code indicators (multiple lines with code patterns)
+        const lines = trimmed.split('\n');
+        if (lines.length > 5) {
+            // Multiple lines is usually file content
+            return false;
+        }
+        // Check if content looks like code
+        if (this.looksLikeCode(trimmed)) {
+            return false;
+        }
+        // Check if content looks like a file path
+        if (this.looksLikeFilePath(trimmed)) {
+            return false;
+        }
+        // Check if content has too many special characters (likely code or data)
+        const specialCharRatio = (trimmed.match(/[{}\[\]<>()=;:,`'"]/g) || []).length / trimmed.length;
+        if (specialCharRatio > 0.15) {
+            return false;
+        }
+        // POSITIVE CHECK: Does this look like a user request?
+        const lowerContent = trimmed.toLowerCase();
+        // Check for action verbs at the start
+        for (const verb of USER_INTENT_VERBS) {
+            if (lowerContent.startsWith(verb + ' ') || lowerContent.startsWith(verb + '\n')) {
+                return true;
+            }
+            // Also check for "please <verb>" or "can you <verb>"
+            if (lowerContent.includes(`please ${verb}`) || lowerContent.includes(`can you ${verb}`)) {
+                return true;
+            }
+        }
+        // Check for question patterns
+        for (const q of QUESTION_INDICATORS) {
+            if (lowerContent.startsWith(q + ' ') || lowerContent.includes(' ' + q + ' ')) {
+                return true;
+            }
+        }
+        // Check for imperative sentence structure (starts with verb-like word)
+        const firstWord = lowerContent.split(/\s+/)[0];
+        if (firstWord && USER_INTENT_VERBS.some(v => firstWord.startsWith(v))) {
+            return true;
+        }
+        // If the message ends with a question mark and isn't too long, likely a user question
+        if (trimmed.endsWith('?') && trimmed.length < 200) {
+            return true;
+        }
+        // Default: if it passed all negative filters but no strong positive signal,
+        // only accept if it reads like natural language (high word/char ratio, few special chars)
+        const words = trimmed.split(/\s+/).filter(w => w.length > 0);
+        const avgWordLength = words.reduce((sum, w) => sum + w.length, 0) / words.length;
+        // Natural language typically has average word length 4-8
+        if (avgWordLength >= 3 && avgWordLength <= 10 && words.length >= 3 && specialCharRatio < 0.05) {
+            return true;
+        }
+        return false;
+    }
+    looksLikeCode(content) {
+        const codeIndicators = [
+            /^(import|export|const|let|var|function|class|interface|type)\s/m,
+            /[{};]\s*$/m,
+            /^\s*(if|else|for|while|switch|try|catch)\s*\(/m,
+            /=>\s*{/,
+            /\(\)\s*{/,
+            /^\s*return\s/m,
+            /^\s*@\w+/m, // Decorators
+            /^\s*#include/m,
+            /^\s*#define/m,
+            /^\s*#pragma/m,
+            /\{\{.*\}\}/, // Template syntax
+            /^\s*<\w+\s+/m, // JSX/HTML tags
+            /<\/\w+>\s*$/m, // Closing tags
+        ];
+        for (const pattern of codeIndicators) {
+            if (pattern.test(content)) {
+                return true;
+            }
+        }
+        // Check for high density of brackets/braces
+        const brackets = (content.match(/[{}\[\]()<>]/g) || []).length;
+        if (brackets > content.length * 0.1) {
+            return true;
+        }
+        return false;
+    }
+    looksLikeFilePath(content) {
+        const trimmed = content.trim();
+        // Check for file path patterns
+        if (/^(\/|~\/|\.\/|\.\.\/)/.test(trimmed))
+            return true;
+        if (/^[a-zA-Z]:\\/.test(trimmed))
+            return true; // Windows
+        if (/^\w+\/\w+/.test(trimmed) && trimmed.includes('/'))
+            return true; // Relative paths
+        // Check if most of the content is path-like
+        const pathChars = (trimmed.match(/[\/\\._-]/g) || []).length;
+        if (pathChars > trimmed.length * 0.2 && trimmed.length < 200) {
+            return true;
+        }
+        return false;
+    }
+    // --------------------------------------------------------------------------
+    // State Management
+    // --------------------------------------------------------------------------
+    getStatePath() {
+        return path.join(this.claudeDir.root, ADVISOR_STATE_FILE);
+    }
+    async getState() {
+        try {
+            const content = await fs.readFile(this.getStatePath(), 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return {
+                recommendations: [],
+                lastAnalyzedAt: null,
+                dismissedIds: [],
+                appliedIds: [],
+            };
+        }
+    }
+    async saveState(state) {
+        await fs.writeFile(this.getStatePath(), JSON.stringify(state, null, 2));
+    }
+    // --------------------------------------------------------------------------
+    // Public API
+    // --------------------------------------------------------------------------
+    async getRecommendations() {
+        const state = await this.getState();
+        return state.recommendations.filter(r => r.status === 'pending' && !state.dismissedIds.includes(r.id));
+    }
+    async getAllRecommendations() {
+        const state = await this.getState();
+        return state.recommendations;
+    }
+    async dismissRecommendation(id) {
+        const state = await this.getState();
+        const rec = state.recommendations.find(r => r.id === id);
+        if (rec) {
+            rec.status = 'dismissed';
+            rec.dismissedAt = new Date().toISOString();
+            if (!state.dismissedIds.includes(id)) {
+                state.dismissedIds.push(id);
+            }
+            await this.saveState(state);
+        }
+    }
+    async applyRecommendation(id) {
+        const state = await this.getState();
+        const rec = state.recommendations.find(r => r.id === id);
+        if (!rec) {
+            return { success: false, error: 'Recommendation not found' };
+        }
+        try {
+            switch (rec.type) {
+                case 'skill':
+                    await this.applySkillRecommendation(rec);
+                    break;
+                case 'agent':
+                    await this.applyAgentRecommendation(rec);
+                    break;
+                case 'hook':
+                    await this.applyHookRecommendation(rec);
+                    break;
+                case 'claude-md':
+                    await this.applyClaudeMdRecommendation(rec);
+                    break;
+                case 'mcp-server':
+                    // MCP recommendations are informational - user must manually configure
+                    // We just mark it as applied
+                    break;
+                case 'settings':
+                    // Settings recommendations are informational for now
+                    break;
+                case 'model':
+                    // Model recommendations are informational only
+                    break;
+            }
+            rec.status = 'applied';
+            rec.appliedAt = new Date().toISOString();
+            if (!state.appliedIds.includes(id)) {
+                state.appliedIds.push(id);
+            }
+            await this.saveState(state);
+            return { success: true };
+        }
+        catch (err) {
+            return { success: false, error: String(err) };
+        }
+    }
+    async runAnalysis(force = false) {
+        const state = await this.getState();
+        // Check if we should run (not more than once per hour unless forced)
+        if (!force && state.lastAnalyzedAt) {
+            const lastRun = new Date(state.lastAnalyzedAt).getTime();
+            const hourAgo = Date.now() - 60 * 60 * 1000;
+            if (lastRun > hourAgo) {
+                return {
+                    newRecommendations: 0,
+                    totalRecommendations: state.recommendations.filter(r => r.status === 'pending').length,
+                };
+            }
+        }
+        console.log('[Advisor] Starting analysis...');
+        const startTime = Date.now();
+        // Gather data
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - this.config.lookbackDays);
+        const cutoffStr = cutoffDate.toISOString();
+        const { sessions } = await this.sessionService.listSessions({ limit: 500 });
+        const recentSessions = sessions.filter(s => s.startedAt >= cutoffStr);
+        console.log(`[Advisor] Analyzing ${recentSessions.length} sessions from last ${this.config.lookbackDays} days`);
+        // Load full session details for analysis
+        const sessionDetails = await Promise.all(recentSessions.slice(0, 100).map(s => this.sessionService.getSession(s.id)));
+        const validSessions = sessionDetails.filter(s => s !== null);
+        // Run all detectors
+        const newRecommendations = [];
+        // 1. Repeated prompts → Skills
+        const promptPatterns = this.detectRepeatedPrompts(validSessions);
+        console.log(`[Advisor] Found ${promptPatterns.length} potential prompt patterns`);
+        for (const pattern of promptPatterns) {
+            if (pattern.count >= this.config.minPromptOccurrences) {
+                const rec = this.createSkillRecommendation(pattern);
+                if (rec && !this.isDuplicate(state.recommendations, rec)) {
+                    newRecommendations.push(rec);
+                }
+            }
+        }
+        // 2. Error patterns → Hooks (simplified for now)
+        // Planned for v0.2.0: hook detection — analyze error patterns to recommend hooks
+        // 3. Clarification loops → CLAUDE.md (simplified for now)
+        // Planned for v0.2.0: clarification detection — identify repeated clarifications to recommend CLAUDE.md entries
+        // Merge new recommendations
+        state.recommendations.push(...newRecommendations);
+        state.lastAnalyzedAt = new Date().toISOString();
+        await this.saveState(state);
+        const elapsed = Date.now() - startTime;
+        console.log(`[Advisor] Analysis complete in ${elapsed}ms. Found ${newRecommendations.length} new recommendations.`);
+        return {
+            newRecommendations: newRecommendations.length,
+            totalRecommendations: state.recommendations.filter(r => r.status === 'pending').length,
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Pattern Detectors
+    // --------------------------------------------------------------------------
+    detectRepeatedPrompts(sessions) {
+        const patternMap = new Map();
+        let totalChecked = 0;
+        let totalAccepted = 0;
+        for (const session of sessions) {
+            for (const msg of session.messages || []) {
+                if (msg.type !== 'user')
+                    continue;
+                const content = msg.content;
+                totalChecked++;
+                // Use the intelligent filter
+                if (!this.isGenuineUserRequest(content)) {
+                    continue;
+                }
+                totalAccepted++;
+                const normalized = this.normalizePrompt(content);
+                if (normalized.length < 10)
+                    continue;
+                const fingerprint = this.generateFingerprint(normalized);
+                const keywords = this.extractKeywords(content);
+                // Additional keyword quality check
+                const goodKeywords = keywords.filter(kw => this.isGoodKeyword(kw));
+                if (goodKeywords.length < 2)
+                    continue;
+                const existing = patternMap.get(fingerprint);
+                if (existing) {
+                    existing.count++;
+                    if (existing.examples.length < 5) {
+                        existing.examples.push(content.slice(0, 300));
+                    }
+                    existing.timestamps.push(msg.timestamp);
+                    existing.sessions.add(session.id);
+                    // Merge keywords
+                    for (const kw of goodKeywords) {
+                        if (!existing.keywords.includes(kw)) {
+                            existing.keywords.push(kw);
+                        }
+                    }
+                }
+                else {
+                    patternMap.set(fingerprint, {
+                        fingerprint,
+                        normalizedText: normalized,
+                        keywords: goodKeywords.slice(0, 10),
+                        count: 1,
+                        examples: [content.slice(0, 300)],
+                        timestamps: [msg.timestamp],
+                        sessions: new Set([session.id]),
+                        projectPaths: new Set([session.projectPath]),
+                    });
+                }
+            }
+        }
+        console.log(`[Advisor] Checked ${totalChecked} user messages, accepted ${totalAccepted} as genuine requests`);
+        // Also check for similar patterns (not exact match)
+        const patterns = Array.from(patternMap.values());
+        const merged = this.mergeSimilarPatterns(patterns);
+        return merged
+            .filter(p => p.count >= 2 && p.sessions.size >= 2)
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 50); // Limit to top 50
+    }
+    // --------------------------------------------------------------------------
+    // Agent Opportunity Detection
+    // --------------------------------------------------------------------------
+    detectAgentOpportunities(sessions) {
+        const taskCategories = new Map();
+        for (const session of sessions) {
+            for (const msg of session.messages || []) {
+                if (msg.type !== 'user')
+                    continue;
+                const content = (msg.content || '').toLowerCase();
+                if (!this.isGenuineUserRequest(msg.content || ''))
+                    continue;
+                // Check each agent template for matching triggers
+                for (const template of AGENT_KNOWLEDGE_BASE) {
+                    for (const trigger of template.triggers) {
+                        if (content.includes(trigger.toLowerCase())) {
+                            const existing = taskCategories.get(template.name);
+                            if (existing) {
+                                existing.count++;
+                                existing.sessions.add(session.id);
+                                if (existing.examples.length < 5) {
+                                    existing.examples.push((msg.content || '').slice(0, 150));
+                                }
+                            }
+                            else {
+                                taskCategories.set(template.name, {
+                                    agentName: template.name,
+                                    category: template.category,
+                                    count: 1,
+                                    sessions: new Set([session.id]),
+                                    examples: [(msg.content || '').slice(0, 150)],
+                                    triggers: template.triggers,
+                                });
+                            }
+                            break; // Only count once per template per message
+                        }
+                    }
+                }
+            }
+        }
+        console.log(`[Advisor] Found ${taskCategories.size} agent opportunity patterns`);
+        // Return patterns that meet threshold
+        return Array.from(taskCategories.values())
+            .filter(p => p.count >= 3 && p.sessions.size >= 2)
+            .sort((a, b) => b.count - a.count);
+    }
+    // --------------------------------------------------------------------------
+    // CLAUDE.md Opportunity Detection
+    // --------------------------------------------------------------------------
+    detectClaudeMdOpportunities(sessions) {
+        const contextStatements = new Map();
+        for (const session of sessions) {
+            for (const msg of session.messages || []) {
+                if (msg.type !== 'user')
+                    continue;
+                const content = msg.content || '';
+                // Check against CLAUDE.md patterns
+                for (const pattern of CLAUDE_MD_PATTERNS) {
+                    const match = content.match(pattern.pattern);
+                    if (match) {
+                        const key = `${pattern.section}:${match[0].toLowerCase()}`;
+                        const existing = contextStatements.get(key);
+                        if (existing) {
+                            existing.count++;
+                            if (existing.examples.length < 5) {
+                                existing.examples.push(content.slice(0, 150));
+                            }
+                        }
+                        else {
+                            contextStatements.set(key, {
+                                count: 1,
+                                examples: [content.slice(0, 150)],
+                                category: pattern.category,
+                                section: pattern.section,
+                                content: pattern.extractContent(match, content),
+                            });
+                        }
+                    }
+                }
+                // Detect repeated context statements
+                // Pattern: "we use X", "our Y is Z", "always/never do X"
+                const contextPatterns = [
+                    /\bwe\s+use\s+(.+?)(?:\s+for|\s+to|\s+in|\s*$)/i,
+                    /\bour\s+(\w+)\s+is\s+(.+?)(?:\s+and|\s*$)/i,
+                    /\balways\s+(.+?)(?:\s+when|\s*$)/i,
+                    /\bnever\s+(.+?)(?:\s+because|\s*$)/i,
+                ];
+                for (const pattern of contextPatterns) {
+                    const match = content.match(pattern);
+                    if (match && match[0].length < 100) {
+                        const key = `context:${match[0].toLowerCase().slice(0, 50)}`;
+                        const existing = contextStatements.get(key);
+                        if (existing) {
+                            existing.count++;
+                            if (existing.examples.length < 5) {
+                                existing.examples.push(content.slice(0, 150));
+                            }
+                        }
+                        else {
+                            contextStatements.set(key, {
+                                count: 1,
+                                examples: [content.slice(0, 150)],
+                                category: 'context',
+                                section: '## Project Context',
+                                content: match[0],
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        console.log(`[Advisor] Found ${contextStatements.size} CLAUDE.md opportunity patterns`);
+        // Convert to ClaudeMdPattern and filter by threshold
+        const patterns = [];
+        for (const [key, data] of contextStatements.entries()) {
+            if (data.count >= 2) {
+                patterns.push({
+                    key,
+                    category: data.category,
+                    count: data.count,
+                    examples: data.examples,
+                    suggestedSection: data.section,
+                    suggestedContent: data.content,
+                });
+            }
+        }
+        return patterns.sort((a, b) => b.count - a.count).slice(0, 20);
+    }
+    // --------------------------------------------------------------------------
+    // Hook Opportunity Detection
+    // --------------------------------------------------------------------------
+    detectHookOpportunities(sessions) {
+        const hookPatterns = [];
+        const errorCounts = new Map();
+        for (const session of sessions) {
+            for (const msg of session.messages || []) {
+                // Look for tool errors and failures
+                if (msg.type === 'tool-result' && msg.content) {
+                    const content = msg.content.toLowerCase();
+                    // Detect lint/format errors
+                    if (content.includes('eslint') || content.includes('lint error') || content.includes('prettier')) {
+                        const key = 'lint-errors';
+                        const existing = errorCounts.get(key);
+                        if (existing) {
+                            existing.count++;
+                            if (existing.examples.length < 3)
+                                existing.examples.push(msg.content.slice(0, 100));
+                        }
+                        else {
+                            errorCounts.set(key, { count: 1, examples: [msg.content.slice(0, 100)] });
+                        }
+                    }
+                    // Detect type errors
+                    if (content.includes('type error') || content.includes('typescript') || content.includes('tsc')) {
+                        const key = 'type-errors';
+                        const existing = errorCounts.get(key);
+                        if (existing) {
+                            existing.count++;
+                            if (existing.examples.length < 3)
+                                existing.examples.push(msg.content.slice(0, 100));
+                        }
+                        else {
+                            errorCounts.set(key, { count: 1, examples: [msg.content.slice(0, 100)] });
+                        }
+                    }
+                    // Detect test failures
+                    if (content.includes('test failed') || content.includes('failing test') || content.includes('jest')) {
+                        const key = 'test-failures';
+                        const existing = errorCounts.get(key);
+                        if (existing) {
+                            existing.count++;
+                            if (existing.examples.length < 3)
+                                existing.examples.push(msg.content.slice(0, 100));
+                        }
+                        else {
+                            errorCounts.set(key, { count: 1, examples: [msg.content.slice(0, 100)] });
+                        }
+                    }
+                    // Detect build errors
+                    if (content.includes('build failed') || content.includes('compilation error') || content.includes('bundle error')) {
+                        const key = 'build-errors';
+                        const existing = errorCounts.get(key);
+                        if (existing) {
+                            existing.count++;
+                            if (existing.examples.length < 3)
+                                existing.examples.push(msg.content.slice(0, 100));
+                        }
+                        else {
+                            errorCounts.set(key, { count: 1, examples: [msg.content.slice(0, 100)] });
+                        }
+                    }
+                }
+            }
+        }
+        console.log(`[Advisor] Found ${errorCounts.size} hook opportunity patterns`);
+        // Map error patterns to hook templates
+        const errorToHook = {
+            'lint-errors': 'lint-on-edit',
+            'type-errors': 'type-check-on-edit',
+            'test-failures': 'test-related-on-edit',
+            'build-errors': 'build-check',
+        };
+        for (const [errorKey, data] of errorCounts.entries()) {
+            if (data.count >= 3) {
+                const hookName = errorToHook[errorKey];
+                const template = HOOK_KNOWLEDGE_BASE.find(h => h.name === hookName);
+                if (template) {
+                    hookPatterns.push({
+                        event: template.event,
+                        matcher: template.matcher,
+                        command: template.command,
+                        reason: `Detected ${data.count} ${errorKey.replace('-', ' ')} across sessions`,
+                        count: data.count,
+                        examples: data.examples,
+                    });
+                }
+            }
+        }
+        return hookPatterns;
+    }
+    // --------------------------------------------------------------------------
+    // MCP Server Opportunity Detection
+    // --------------------------------------------------------------------------
+    detectMCPOpportunities(sessions) {
+        const mcpOpportunities = new Map();
+        for (const session of sessions) {
+            for (const msg of session.messages || []) {
+                if (msg.type !== 'user')
+                    continue;
+                const content = (msg.content || '').toLowerCase();
+                // Check each MCP template for matching triggers
+                for (const template of MCP_KNOWLEDGE_BASE) {
+                    for (const trigger of template.triggers) {
+                        if (content.includes(trigger.toLowerCase())) {
+                            const existing = mcpOpportunities.get(template.name);
+                            if (existing) {
+                                existing.count++;
+                                if (existing.examples.length < 5) {
+                                    existing.examples.push((msg.content || '').slice(0, 150));
+                                }
+                            }
+                            else {
+                                mcpOpportunities.set(template.name, {
+                                    count: 1,
+                                    examples: [(msg.content || '').slice(0, 150)],
+                                });
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        console.log(`[Advisor] Found ${mcpOpportunities.size} MCP opportunity patterns`);
+        // Convert to MCPPattern and filter
+        const patterns = [];
+        for (const [serverName, data] of mcpOpportunities.entries()) {
+            const template = MCP_KNOWLEDGE_BASE.find(t => t.name === serverName);
+            if (data.count >= 3 && template) {
+                patterns.push({
+                    serverName,
+                    triggers: template.triggers,
+                    count: data.count,
+                    examples: data.examples,
+                });
+            }
+        }
+        return patterns.sort((a, b) => b.count - a.count);
+    }
+    // --------------------------------------------------------------------------
+    // Keyword Quality Check
+    // --------------------------------------------------------------------------
+    isGoodKeyword(keyword) {
+        // Reject keywords that are:
+        // - Too short
+        if (keyword.length < 3)
+            return false;
+        // - Numbers or hex strings
+        if (/^[0-9a-f]+$/i.test(keyword))
+            return false;
+        // - File extensions
+        if (/^\.\w+$/.test(keyword))
+            return false;
+        // - Common technical noise
+        const noise = new Set([
+            'const', 'let', 'var', 'function', 'class', 'type', 'interface',
+            'import', 'export', 'from', 'return', 'true', 'false', 'null', 'undefined',
+            'string', 'number', 'boolean', 'object', 'array', 'void',
+            'async', 'await', 'try', 'catch', 'throw', 'new', 'delete',
+            'public', 'private', 'protected', 'static', 'readonly',
+            'josharsh', 'users', 'development', 'staff', 'drwxr', 'drwx', // User-specific noise
+            'node_modules', 'dist', 'build', 'src', 'lib', 'bin',
+            'json', 'yaml', 'toml', 'xml', 'html', 'css', 'tsx', 'jsx',
+            'http', 'https', 'localhost', 'port',
+            'todo', 'fixme', 'hack', 'xxx', 'note',
+            'code', 'file', 'path', 'dir', 'folder',
+            'successfully', 'error', 'warning', 'info', 'debug',
+            'total', 'count', 'index', 'length', 'size',
+        ]);
+        if (noise.has(keyword.toLowerCase()))
+            return false;
+        // - Paths or path segments
+        if (keyword.includes('/') || keyword.includes('\\'))
+            return false;
+        // - Looks like a hash or UUID
+        if (/^[a-f0-9]{8,}$/i.test(keyword))
+            return false;
+        return true;
+    }
+    // --------------------------------------------------------------------------
+    // Recommendation Creators
+    // --------------------------------------------------------------------------
+    createAgentRecommendation(pattern) {
+        const template = AGENT_KNOWLEDGE_BASE.find(t => t.name === pattern.agentName);
+        if (!template)
+            return null;
+        return {
+            id: `agent-${crypto.randomUUID().slice(0, 8)}`,
+            type: 'agent',
+            title: `Create "${pattern.agentName}" agent`,
+            description: `You've performed ${pattern.category}-related tasks ${pattern.count} times across ${pattern.sessions.size} sessions. A dedicated agent could handle this workflow.`,
+            confidence: Math.min(0.95, 0.6 + (pattern.count - 3) * 0.05 + (pattern.sessions.size - 2) * 0.1),
+            evidence: [
+                `Found ${pattern.count} ${pattern.category} task requests`,
+                `Across ${pattern.sessions.size} different sessions`,
+                `Category: ${pattern.category}`,
+            ],
+            action: {
+                type: 'agent',
+                agentName: pattern.agentName,
+                agentContent: template.content,
+                template: template.name,
+            },
+            examples: pattern.examples,
+            createdAt: new Date().toISOString(),
+            status: 'pending',
+        };
+    }
+    createClaudeMdRecommendation(pattern) {
+        return {
+            id: `claude-md-${crypto.randomUUID().slice(0, 8)}`,
+            type: 'claude-md',
+            title: `Add to CLAUDE.md: ${pattern.suggestedSection}`,
+            description: `You've mentioned "${pattern.suggestedContent}" ${pattern.count} times. Adding it to CLAUDE.md will save you from repeating this context.`,
+            confidence: Math.min(0.9, 0.5 + pattern.count * 0.1),
+            evidence: [
+                `Mentioned ${pattern.count} times`,
+                `Category: ${pattern.category}`,
+                `Example: "${pattern.examples[0]?.slice(0, 80)}..."`,
+            ],
+            action: {
+                type: 'claude-md',
+                section: pattern.suggestedSection,
+                addition: pattern.suggestedContent,
+            },
+            examples: pattern.examples,
+            createdAt: new Date().toISOString(),
+            status: 'pending',
+        };
+    }
+    createHookRecommendation(pattern) {
+        return {
+            id: `hook-${crypto.randomUUID().slice(0, 8)}`,
+            type: 'hook',
+            title: `Add "${pattern.event}" hook`,
+            description: pattern.reason,
+            confidence: Math.min(0.85, 0.5 + pattern.count * 0.1),
+            evidence: [
+                `Detected ${pattern.count} times`,
+                `Event: ${pattern.event}`,
+                pattern.matcher ? `Matcher: ${pattern.matcher}` : 'No matcher',
+            ],
+            action: {
+                type: 'hook',
+                event: pattern.event,
+                matcher: pattern.matcher,
+                command: pattern.command,
+            },
+            examples: pattern.examples,
+            createdAt: new Date().toISOString(),
+            status: 'pending',
+        };
+    }
+    createMCPRecommendation(pattern) {
+        const template = MCP_KNOWLEDGE_BASE.find(t => t.name === pattern.serverName);
+        if (!template)
+            return null;
+        return {
+            id: `mcp-${crypto.randomUUID().slice(0, 8)}`,
+            type: 'mcp-server',
+            title: `Add "${pattern.serverName}" MCP server`,
+            description: `You've referenced ${pattern.serverName}-related functionality ${pattern.count} times. An MCP server could provide native integration.`,
+            confidence: Math.min(0.8, 0.4 + pattern.count * 0.1),
+            evidence: [
+                `Mentioned ${pattern.count} times`,
+                `Triggers: ${pattern.triggers.slice(0, 3).join(', ')}`,
+                template.npmPackage ? `Package: ${template.npmPackage}` : 'Custom server needed',
+            ],
+            action: {
+                type: 'mcp-server',
+                serverName: pattern.serverName,
+                description: template.description,
+                setupInstructions: template.setupInstructions,
+                npmPackage: template.npmPackage,
+            },
+            examples: pattern.examples,
+            createdAt: new Date().toISOString(),
+            status: 'pending',
+        };
+    }
+    createSkillRecommendation(pattern) {
+        if (pattern.keywords.length < 2)
+            return null;
+        const skillName = this.generateSkillName(pattern.keywords);
+        // Skip if skill name is too generic or looks bad
+        if (skillName.length < 5 || skillName.includes('file') || skillName.includes('users')) {
+            return null;
+        }
+        const skillContent = this.generateSkillContent(pattern);
+        return {
+            id: `skill-${crypto.randomUUID().slice(0, 8)}`,
+            type: 'skill',
+            title: `Create "${skillName}" skill`,
+            description: `You've asked similar questions ${pattern.count} times across ${pattern.sessions.size} sessions. Creating a skill would let you invoke this workflow with /${skillName}.`,
+            confidence: Math.min(0.95, 0.5 + (pattern.count - 2) * 0.05 + (pattern.sessions.size - 1) * 0.1),
+            evidence: [
+                `Found ${pattern.count} similar prompts`,
+                `Across ${pattern.sessions.size} different sessions`,
+                `Keywords: ${pattern.keywords.slice(0, 5).join(', ')}`,
+            ],
+            action: {
+                type: 'skill',
+                skillName,
+                skillContent,
+            },
+            examples: pattern.examples,
+            createdAt: new Date().toISOString(),
+            status: 'pending',
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Proactive Recommendations (Knowledge-Based)
+    // --------------------------------------------------------------------------
+    /**
+     * Detects the tech stack from user's projects
+     */
+    async detectTechStack() {
+        const techStack = new Set();
+        const projects = await this.sessionService.listProjects();
+        for (const project of projects.slice(0, 10)) { // Check top 10 projects
+            const projectPath = project.path;
+            if (!projectPath || projectPath === 'unknown')
+                continue;
+            try {
+                // Check for package.json (Node.js/JS projects)
+                try {
+                    const pkgPath = path.join(projectPath, 'package.json');
+                    const pkgContent = await fs.readFile(pkgPath, 'utf-8');
+                    const pkg = JSON.parse(pkgContent);
+                    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                    // Detect frameworks
+                    if (deps['next'])
+                        techStack.add('nextjs');
+                    if (deps['react'])
+                        techStack.add('react');
+                    if (deps['vue'])
+                        techStack.add('vue');
+                    if (deps['svelte'])
+                        techStack.add('svelte');
+                    if (deps['astro'])
+                        techStack.add('astro');
+                    if (deps['vite'])
+                        techStack.add('vite');
+                    if (deps['express'])
+                        techStack.add('express');
+                    if (deps['fastify'])
+                        techStack.add('fastify');
+                    if (deps['hono'])
+                        techStack.add('hono');
+                    if (deps['typescript'])
+                        techStack.add('typescript');
+                    if (deps['jest'] || deps['vitest'])
+                        techStack.add('testing');
+                    if (deps['eslint'])
+                        techStack.add('eslint');
+                    if (deps['playwright'])
+                        techStack.add('playwright');
+                    techStack.add('node');
+                    techStack.add('javascript');
+                }
+                catch { }
+                // Check for Python
+                try {
+                    await fs.access(path.join(projectPath, 'pyproject.toml'));
+                    techStack.add('python');
+                }
+                catch { }
+                try {
+                    await fs.access(path.join(projectPath, 'requirements.txt'));
+                    techStack.add('python');
+                }
+                catch { }
+                // Check for Rust
+                try {
+                    await fs.access(path.join(projectPath, 'Cargo.toml'));
+                    techStack.add('rust');
+                }
+                catch { }
+                // Check for Go
+                try {
+                    await fs.access(path.join(projectPath, 'go.mod'));
+                    techStack.add('go');
+                }
+                catch { }
+                // Check for Vercel/Netlify
+                try {
+                    await fs.access(path.join(projectPath, 'vercel.json'));
+                    techStack.add('vercel');
+                }
+                catch { }
+                try {
+                    await fs.access(path.join(projectPath, 'netlify.toml'));
+                    techStack.add('netlify');
+                }
+                catch { }
+            }
+            catch {
+                // Project path not accessible
+            }
+        }
+        return techStack;
+    }
+    /**
+     * Analyzes usage patterns to find relevant triggers
+     */
+    analyzeUsagePatterns(sessions) {
+        const triggerCounts = new Map();
+        for (const session of sessions) {
+            for (const msg of session.messages || []) {
+                if (msg.type !== 'user')
+                    continue;
+                const content = (msg.content || '').toLowerCase();
+                // Count trigger words
+                for (const template of SKILL_KNOWLEDGE_BASE) {
+                    for (const trigger of template.triggers) {
+                        if (content.includes(trigger)) {
+                            const key = template.name;
+                            triggerCounts.set(key, (triggerCounts.get(key) || 0) + 1);
+                        }
+                    }
+                }
+            }
+        }
+        return triggerCounts;
+    }
+    /**
+     * Gets list of skills the user already has
+     */
+    async getExistingSkills() {
+        try {
+            const skills = await this.skillsService.listSkills();
+            return new Set(skills.map(s => s.name.toLowerCase()));
+        }
+        catch {
+            return new Set();
+        }
+    }
+    /**
+     * Gets list of agents the user already has
+     */
+    async getExistingAgents() {
+        try {
+            const agents = await this.agentsService.listAgents();
+            return new Set(agents.map(a => a.name.toLowerCase()));
+        }
+        catch {
+            return new Set();
+        }
+    }
+    /**
+     * Generate proactive recommendations based on tech stack and best practices
+     */
+    async generateProactiveRecommendations(sessions, existingRecommendationNames) {
+        console.log('[Advisor] Generating proactive recommendations...');
+        const techStack = await this.detectTechStack();
+        console.log(`[Advisor] Detected tech stack: ${Array.from(techStack).join(', ')}`);
+        const triggerCounts = this.analyzeUsagePatterns(sessions);
+        const existingSkills = await this.getExistingSkills();
+        const recommendations = [];
+        for (const template of SKILL_KNOWLEDGE_BASE) {
+            // Skip if user already has this skill
+            if (existingSkills.has(template.name.toLowerCase())) {
+                continue;
+            }
+            // Skip if we already recommended this
+            if (existingRecommendationNames.has(template.name.toLowerCase())) {
+                continue;
+            }
+            // Check if relevant to user's tech stack
+            const isRelevant = template.techStack.includes('*') ||
+                template.techStack.some(tech => techStack.has(tech));
+            if (!isRelevant)
+                continue;
+            // Calculate confidence based on trigger matches
+            const triggerCount = triggerCounts.get(template.name) || 0;
+            let confidence = template.confidence;
+            // Boost confidence if user has mentioned related triggers
+            if (triggerCount > 0) {
+                confidence = Math.min(0.98, confidence + Math.min(0.2, triggerCount * 0.02));
+            }
+            // Determine evidence
+            const evidence = [];
+            if (techStack.size > 0) {
+                const relevantTech = template.techStack.filter(t => techStack.has(t));
+                if (relevantTech.length > 0) {
+                    evidence.push(`Matches your tech stack: ${relevantTech.join(', ')}`);
+                }
+            }
+            if (triggerCount > 0) {
+                evidence.push(`You've mentioned related topics ${triggerCount} times`);
+            }
+            evidence.push(`Category: ${template.category}`);
+            evidence.push('Recommended best practice');
+            // Only include high-relevance recommendations
+            if (confidence >= 0.7 || triggerCount >= 3) {
+                recommendations.push({
+                    id: `skill-proactive-${crypto.randomUUID().slice(0, 8)}`,
+                    type: 'skill',
+                    title: `Add "${template.name}" skill`,
+                    description: template.description,
+                    confidence,
+                    evidence,
+                    action: {
+                        type: 'skill',
+                        skillName: template.name,
+                        skillContent: template.content,
+                    },
+                    examples: [], // No examples for proactive recommendations
+                    createdAt: new Date().toISOString(),
+                    status: 'pending',
+                });
+            }
+        }
+        // Sort by confidence
+        recommendations.sort((a, b) => b.confidence - a.confidence);
+        console.log(`[Advisor] Generated ${recommendations.length} proactive recommendations`);
+        return recommendations.slice(0, 10); // Limit to top 10
+    }
+    // --------------------------------------------------------------------------
+    // Apply Recommendations
+    // --------------------------------------------------------------------------
+    async applySkillRecommendation(rec) {
+        const action = rec.action;
+        await this.skillsService.createSkill(action.skillName, action.skillContent);
+    }
+    async applyAgentRecommendation(rec) {
+        const action = rec.action;
+        await this.agentsService.createAgent(action.agentName, action.agentContent);
+    }
+    async applyHookRecommendation(rec) {
+        const action = rec.action;
+        await this.hooksService.createHook({
+            event: action.event,
+            matcher: action.matcher,
+            command: action.command,
+            enabled: true,
+        });
+    }
+    async applyClaudeMdRecommendation(rec) {
+        const action = rec.action;
+        const currentMemory = await this.memoryService.getMemory();
+        // Check if section already exists
+        const sectionHeader = action.section;
+        const hasSection = currentMemory && currentMemory.includes(sectionHeader);
+        let newMemory;
+        if (hasSection) {
+            // Append to existing section
+            const sectionIndex = currentMemory.indexOf(sectionHeader);
+            const afterSection = currentMemory.slice(sectionIndex + sectionHeader.length);
+            const nextSectionMatch = afterSection.match(/\n##\s/);
+            const insertPoint = nextSectionMatch
+                ? sectionIndex + sectionHeader.length + (nextSectionMatch.index ?? afterSection.length)
+                : currentMemory.length;
+            newMemory =
+                currentMemory.slice(0, insertPoint).trimEnd() +
+                    '\n' + action.addition +
+                    currentMemory.slice(insertPoint);
+        }
+        else if (currentMemory) {
+            // Add new section
+            newMemory = `${currentMemory.trimEnd()}\n\n${sectionHeader}\n${action.addition}`;
+        }
+        else {
+            // Create new memory file
+            newMemory = `# Project Context\n\n${sectionHeader}\n${action.addition}`;
+        }
+        await this.memoryService.updateMemory(newMemory);
+    }
+    // --------------------------------------------------------------------------
+    // Helper Methods
+    // --------------------------------------------------------------------------
+    normalizePrompt(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter(word => word.length > 2 && !STOP_WORDS.has(word))
+            .join(' ')
+            .trim();
+    }
+    generateFingerprint(normalized) {
+        // Simple fingerprint using sorted significant words
+        const words = normalized.split(/\s+/).slice(0, 10).sort();
+        return crypto.createHash('md5').update(words.join('|')).digest('hex').slice(0, 12);
+    }
+    extractKeywords(text) {
+        const words = text
+            .toLowerCase()
+            .replace(/[^\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter(word => word.length > 3 && !STOP_WORDS.has(word));
+        // Count frequency
+        const freq = new Map();
+        for (const word of words) {
+            freq.set(word, (freq.get(word) || 0) + 1);
+        }
+        // Return top keywords
+        return Array.from(freq.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 15)
+            .map(([word]) => word);
+    }
+    mergeSimilarPatterns(patterns) {
+        // Simple merge: if patterns share >50% keywords, merge them
+        const merged = [];
+        const used = new Set();
+        for (let i = 0; i < patterns.length; i++) {
+            if (used.has(i))
+                continue;
+            const pattern = { ...patterns[i] };
+            pattern.sessions = new Set(pattern.sessions);
+            pattern.projectPaths = new Set(pattern.projectPaths);
+            for (let j = i + 1; j < patterns.length; j++) {
+                if (used.has(j))
+                    continue;
+                const other = patterns[j];
+                const shared = pattern.keywords.filter(k => other.keywords.includes(k)).length;
+                const similarity = shared / Math.max(pattern.keywords.length, other.keywords.length);
+                if (similarity > 0.4) {
+                    // Merge
+                    pattern.count += other.count;
+                    for (const s of other.sessions)
+                        pattern.sessions.add(s);
+                    for (const p of other.projectPaths)
+                        pattern.projectPaths.add(p);
+                    pattern.examples.push(...other.examples);
+                    pattern.timestamps.push(...other.timestamps);
+                    used.add(j);
+                }
+            }
+            merged.push(pattern);
+        }
+        return merged;
+    }
+    generateSkillName(keywords) {
+        // Take first 2-3 meaningful keywords that are good
+        const goodKeywords = keywords.filter(kw => this.isGoodKeyword(kw)).slice(0, 3);
+        const name = goodKeywords
+            .join('-')
+            .toLowerCase()
+            .replace(/[^a-z0-9-]/g, '')
+            .slice(0, 32);
+        return name || 'custom-workflow';
+    }
+    generateSkillContent(pattern) {
+        const name = this.generateSkillName(pattern.keywords);
+        const description = `Automates: ${pattern.examples[0]?.slice(0, 100) || pattern.keywords.join(', ')}`;
+        return `---
+name: ${name}
+description: ${description}
+user-invocable: true
+---
+
+# ${name.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')}
+
+This skill was auto-generated based on your repeated prompts.
+
+## What it does
+
+${pattern.examples[0] || 'Executes the workflow you commonly request.'}
+
+## Usage
+
+Invoke with \`/${name}\` followed by any specific parameters.
+
+## Examples
+
+${pattern.examples.slice(0, 3).map((ex, i) => `${i + 1}. ${ex.slice(0, 150)}...`).join('\n')}
+`;
+    }
+    isDuplicate(existing, newRec) {
+        return existing.some(r => {
+            if (r.type !== newRec.type)
+                return false;
+            if (r.status === 'applied' || r.status === 'dismissed')
+                return true;
+            // Check similarity of title/action
+            if (r.title === newRec.title)
+                return true;
+            // Type-specific checks
+            if (r.type === 'skill' && newRec.type === 'skill') {
+                const rAction = r.action;
+                const nAction = newRec.action;
+                return rAction.skillName === nAction.skillName;
+            }
+            return false;
+        });
+    }
+    // --------------------------------------------------------------------------
+    // AI-Powered Pattern Evaluation
+    // --------------------------------------------------------------------------
+    async isClaudeAvailable() {
+        try {
+            await execAsync('which claude');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Uses Claude to intelligently evaluate detected patterns and determine
+     * which ones represent meaningful, automatable workflows.
+     */
+    async evaluatePatternsWithAI(patterns) {
+        if (patterns.length === 0)
+            return [];
+        const claudeAvailable = await this.isClaudeAvailable();
+        if (!claudeAvailable) {
+            console.log('[Advisor] Claude CLI not available, skipping AI evaluation');
+            return [];
+        }
+        console.log(`[Advisor] Evaluating ${patterns.length} patterns with AI...`);
+        // Prepare compact pattern data to include directly in prompt
+        const patternsData = patterns.map((p, i) => ({
+            index: i,
+            keywords: p.keywords.slice(0, 6),
+            examples: p.examples.slice(0, 2).map(e => e.slice(0, 150)), // Keep examples short
+            count: p.count,
+            sessions: p.sessions.size,
+        }));
+        // Build the AI evaluation prompt with data embedded
+        const promptFilePath = path.join(this.claudeDir.root, 'advisor-prompt-temp.txt');
+        const prompt = this.buildAIEvaluationPrompt(patternsData);
+        await fs.writeFile(promptFilePath, prompt);
+        try {
+            // Call Claude CLI
+            const { stdout, stderr } = await execAsync(`cat "${promptFilePath}" | claude -p --output-format text`, {
+                cwd: process.cwd(),
+                env: { ...process.env, NO_COLOR: '1', FORCE_COLOR: '0' },
+                maxBuffer: 10 * 1024 * 1024,
+                timeout: 180000, // 3 minutes for larger analysis
+            });
+            if (stderr) {
+                console.log('[Advisor] Claude stderr:', stderr.slice(0, 200));
+            }
+            // Save response for debugging if parsing fails
+            const debugFilePath = path.join(this.claudeDir.root, 'advisor-ai-response-debug.txt');
+            await fs.writeFile(debugFilePath, stdout);
+            // Parse the response
+            const evaluations = this.parseAIResponse(stdout, patterns.length);
+            console.log(`[Advisor] AI evaluated ${evaluations.length} patterns`);
+            // Cleanup temp files (keep debug file for inspection)
+            await fs.unlink(promptFilePath).catch(() => { });
+            return evaluations;
+        }
+        catch (err) {
+            console.error('[Advisor] AI evaluation failed:', err?.message || err);
+            // Cleanup on error
+            await fs.unlink(promptFilePath).catch(() => { });
+            return [];
+        }
+    }
+    buildAIEvaluationPrompt(patternsData) {
+        const patternsJson = JSON.stringify(patternsData, null, 2);
+        return `You are an expert developer workflow analyst. Evaluate these usage patterns and determine which represent meaningful, automatable workflows.
+
+## PATTERNS TO EVALUATE
+
+${patternsJson}
+
+Each pattern has:
+- index: pattern number (use this in patternIndex)
+- keywords: extracted from user prompts
+- examples: actual prompts the user typed
+- count: how many times similar prompts appeared
+- sessions: across how many sessions
+
+## YOUR TASK
+
+For each pattern, determine:
+1. Is this a GENUINE workflow a developer would want to automate?
+2. What's the best skill name (action-verb first, kebab-case, 2-4 words)?
+3. Should it be accepted or rejected?
+
+## SKILL NAMING RULES
+
+GOOD names (action + target):
+- "deploy-vercel", "run-tests", "create-component", "review-pr", "fix-types", "commit-changes"
+
+BAD names (REJECT these patterns):
+- Random words: "continue-tier-engineer", "sure-ahead-best"
+- Path fragments: "file-users-josharsh"
+- Meaningless: "most-page-update", "code-export-type"
+
+## ACCEPT patterns where examples show clear intent:
+- "deploy this to vercel" → deploy-vercel
+- "run the tests" → run-tests
+- "create a component for..." → create-component
+
+## REJECT patterns that are:
+- Random keyword combinations
+- Conversation fragments ("yes continue", "thanks")
+- Code/path fragments
+- Vague requests
+
+## OUTPUT FORMAT
+
+Return ONLY this JSON (no markdown, no explanation):
+
+{"evaluations":[{"patternIndex":0,"isValidWorkflow":true,"confidence":0.9,"reasoning":"Clear deployment workflow","suggestedSkillName":"deploy-vercel","suggestedDescription":"Deploy to Vercel","category":"deployment","skillContent":"---\\ndescription: Deploy to Vercel\\nuser-invocable: true\\n---\\n\\n# Deploy to Vercel\\n\\nDeploy the current project.\\n\\n## Steps\\n1. Run vercel CLI\\n2. Return deployment URL\\n\\n$ARGUMENTS"},{"patternIndex":1,"isValidWorkflow":false,"confidence":0.95,"reasoning":"Random word combination","suggestedSkillName":null,"suggestedDescription":null,"category":"invalid","skillContent":null}],"summary":"1 valid, 1 rejected"}
+
+IMPORTANT: Output ONLY the JSON object. No other text.`;
+    }
+    parseAIResponse(response, expectedCount) {
+        try {
+            console.log(`[Advisor] Raw response length: ${response.length} chars`);
+            console.log(`[Advisor] Response preview: ${response.slice(0, 300)}...`);
+            // Clean up response - remove any markdown code blocks
+            let cleaned = response.trim();
+            // Handle various markdown code block formats
+            // Remove ```json at start
+            cleaned = cleaned.replace(/^```json\s*/i, '');
+            // Remove ``` at start (without json)
+            cleaned = cleaned.replace(/^```\s*/, '');
+            // Remove ``` at end
+            cleaned = cleaned.replace(/\s*```\s*$/, '');
+            cleaned = cleaned.trim();
+            // Try to find JSON object in response - use a more robust approach
+            // Look for the outermost { ... } that contains "evaluations"
+            let jsonStart = -1;
+            let braceCount = 0;
+            let jsonEnd = -1;
+            for (let i = 0; i < cleaned.length; i++) {
+                if (cleaned[i] === '{') {
+                    if (jsonStart === -1)
+                        jsonStart = i;
+                    braceCount++;
+                }
+                else if (cleaned[i] === '}') {
+                    braceCount--;
+                    if (braceCount === 0 && jsonStart !== -1) {
+                        jsonEnd = i + 1;
+                        // Check if this contains "evaluations"
+                        const candidate = cleaned.slice(jsonStart, jsonEnd);
+                        if (candidate.includes('"evaluations"')) {
+                            break;
+                        }
+                        else {
+                            // Reset and keep looking
+                            jsonStart = -1;
+                        }
+                    }
+                }
+            }
+            if (jsonStart === -1 || jsonEnd === -1) {
+                // Fallback to regex
+                const jsonMatch = cleaned.match(/\{[\s\S]*"evaluations"[\s\S]*\}/);
+                if (!jsonMatch) {
+                    console.error('[Advisor] No JSON with "evaluations" found in AI response');
+                    console.error('[Advisor] Cleaned response preview:', cleaned.slice(0, 500));
+                    return [];
+                }
+                cleaned = jsonMatch[0];
+            }
+            else {
+                cleaned = cleaned.slice(jsonStart, jsonEnd);
+            }
+            console.log(`[Advisor] Extracted JSON length: ${cleaned.length} chars`);
+            const parsed = JSON.parse(cleaned);
+            if (!parsed.evaluations || !Array.isArray(parsed.evaluations)) {
+                console.error('[Advisor] Invalid AI response structure - no evaluations array');
+                console.error('[Advisor] Parsed keys:', Object.keys(parsed));
+                return [];
+            }
+            console.log(`[Advisor] Found ${parsed.evaluations.length} evaluations in response`);
+            // Validate and filter evaluations
+            const valid = parsed.evaluations.filter(e => typeof e.patternIndex === 'number' &&
+                typeof e.isValidWorkflow === 'boolean' &&
+                e.patternIndex >= 0 &&
+                e.patternIndex < expectedCount);
+            console.log(`[Advisor] ${valid.length} evaluations passed validation`);
+            return valid;
+        }
+        catch (err) {
+            console.error('[Advisor] Failed to parse AI response:', err?.message || err);
+            return [];
+        }
+    }
+    /**
+     * Creates an AI-enhanced recommendation from a pattern and its evaluation.
+     */
+    createAIEnhancedRecommendation(pattern, evaluation) {
+        if (!evaluation.isValidWorkflow || !evaluation.suggestedSkillName) {
+            return null;
+        }
+        const skillName = evaluation.suggestedSkillName
+            .toLowerCase()
+            .replace(/[^a-z0-9-]/g, '-')
+            .replace(/-+/g, '-')
+            .slice(0, 32);
+        if (skillName.length < 3)
+            return null;
+        // Use AI-generated content or fall back to template
+        const skillContent = evaluation.skillContent || this.generateSkillContent(pattern);
+        return {
+            id: `skill-${crypto.randomUUID().slice(0, 8)}`,
+            type: 'skill',
+            title: `Create "${skillName}" skill`,
+            description: evaluation.suggestedDescription ||
+                `You've asked similar questions ${pattern.count} times across ${pattern.sessions.size} sessions. Creating a skill would let you invoke this workflow with /${skillName}.`,
+            confidence: Math.min(0.98, evaluation.confidence),
+            evidence: [
+                `Found ${pattern.count} similar prompts`,
+                `Across ${pattern.sessions.size} different sessions`,
+                `AI Category: ${evaluation.category}`,
+                `Keywords: ${pattern.keywords.slice(0, 5).join(', ')}`,
+            ],
+            action: {
+                type: 'skill',
+                skillName,
+                skillContent,
+            },
+            examples: pattern.examples,
+            createdAt: new Date().toISOString(),
+            status: 'pending',
+        };
+    }
+    /**
+     * Enhanced analysis that uses AI to filter and improve recommendations.
+     */
+    async runAnalysisWithAI(force = false) {
+        const state = await this.getState();
+        // Check if we should run
+        if (!force && state.lastAnalyzedAt) {
+            const lastRun = new Date(state.lastAnalyzedAt).getTime();
+            const hourAgo = Date.now() - 60 * 60 * 1000;
+            if (lastRun > hourAgo) {
+                return {
+                    newRecommendations: 0,
+                    totalRecommendations: state.recommendations.filter(r => r.status === 'pending').length,
+                    aiEvaluated: false,
+                };
+            }
+        }
+        console.log('[Advisor] Starting AI-powered analysis...');
+        const startTime = Date.now();
+        // Gather data
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - this.config.lookbackDays);
+        const cutoffStr = cutoffDate.toISOString();
+        const { sessions } = await this.sessionService.listSessions({ limit: 500 });
+        const recentSessions = sessions.filter(s => s.startedAt >= cutoffStr);
+        console.log(`[Advisor] Analyzing ${recentSessions.length} sessions from last ${this.config.lookbackDays} days`);
+        // Load session details
+        const sessionDetails = await Promise.all(recentSessions.slice(0, 100).map(s => this.sessionService.getSession(s.id)));
+        const validSessions = sessionDetails.filter(s => s !== null);
+        // Phase 1: Heuristic pattern detection (fast)
+        const promptPatterns = this.detectRepeatedPrompts(validSessions);
+        console.log(`[Advisor] Heuristics found ${promptPatterns.length} potential patterns`);
+        // Filter to top candidates for AI evaluation
+        const candidates = promptPatterns
+            .filter(p => p.count >= this.config.minPromptOccurrences)
+            .slice(0, 20); // Limit to avoid huge AI calls
+        if (candidates.length === 0) {
+            state.lastAnalyzedAt = new Date().toISOString();
+            await this.saveState(state);
+            return {
+                newRecommendations: 0,
+                totalRecommendations: state.recommendations.filter(r => r.status === 'pending').length,
+                aiEvaluated: false,
+            };
+        }
+        // Phase 2: AI evaluation (quality filter)
+        const evaluations = await this.evaluatePatternsWithAI(candidates);
+        const aiEvaluated = evaluations.length > 0;
+        const newRecommendations = [];
+        if (aiEvaluated) {
+            // Use AI evaluations
+            for (const evaluation of evaluations) {
+                if (!evaluation.isValidWorkflow)
+                    continue;
+                const pattern = candidates[evaluation.patternIndex];
+                if (!pattern)
+                    continue;
+                const rec = this.createAIEnhancedRecommendation(pattern, evaluation);
+                if (rec && !this.isDuplicate(state.recommendations, rec)) {
+                    newRecommendations.push(rec);
+                }
+            }
+            console.log(`[Advisor] AI approved ${newRecommendations.length} pattern-based recommendations`);
+        }
+        else {
+            // Fallback to heuristic-only recommendations
+            console.log('[Advisor] Falling back to heuristic recommendations');
+            for (const pattern of candidates) {
+                const rec = this.createSkillRecommendation(pattern);
+                if (rec && !this.isDuplicate(state.recommendations, rec)) {
+                    newRecommendations.push(rec);
+                }
+            }
+        }
+        // Phase 2.5: Agent Recommendations
+        const agentPatterns = this.detectAgentOpportunities(validSessions);
+        const existingAgents = await this.getExistingAgents();
+        for (const pattern of agentPatterns) {
+            if (existingAgents.has(pattern.agentName.toLowerCase()))
+                continue;
+            const rec = this.createAgentRecommendation(pattern);
+            if (rec && !this.isDuplicate(state.recommendations, rec) && !this.isDuplicate(newRecommendations, rec)) {
+                newRecommendations.push(rec);
+            }
+        }
+        console.log(`[Advisor] Created ${agentPatterns.length} agent recommendations`);
+        // Phase 2.6: CLAUDE.md Recommendations
+        const claudeMdPatterns = this.detectClaudeMdOpportunities(validSessions);
+        for (const pattern of claudeMdPatterns) {
+            const rec = this.createClaudeMdRecommendation(pattern);
+            if (rec && !this.isDuplicate(state.recommendations, rec) && !this.isDuplicate(newRecommendations, rec)) {
+                newRecommendations.push(rec);
+            }
+        }
+        console.log(`[Advisor] Created ${claudeMdPatterns.length} CLAUDE.md recommendations`);
+        // Phase 2.7: Hook Recommendations
+        const hookPatterns = this.detectHookOpportunities(validSessions);
+        for (const pattern of hookPatterns) {
+            const rec = this.createHookRecommendation(pattern);
+            if (rec && !this.isDuplicate(state.recommendations, rec) && !this.isDuplicate(newRecommendations, rec)) {
+                newRecommendations.push(rec);
+            }
+        }
+        console.log(`[Advisor] Created ${hookPatterns.length} hook recommendations`);
+        // Phase 2.8: MCP Server Recommendations
+        const mcpPatterns = this.detectMCPOpportunities(validSessions);
+        for (const pattern of mcpPatterns) {
+            const rec = this.createMCPRecommendation(pattern);
+            if (rec && !this.isDuplicate(state.recommendations, rec) && !this.isDuplicate(newRecommendations, rec)) {
+                newRecommendations.push(rec);
+            }
+        }
+        console.log(`[Advisor] Created ${mcpPatterns.length} MCP server recommendations`);
+        // Phase 3: Proactive recommendations (knowledge-based)
+        // Get existing recommendation names to avoid duplicates
+        const existingRecNames = new Set([...state.recommendations, ...newRecommendations]
+            .filter(r => r.action.type === 'skill')
+            .map(r => r.action.skillName.toLowerCase()));
+        const proactiveRecs = await this.generateProactiveRecommendations(validSessions, existingRecNames);
+        for (const rec of proactiveRecs) {
+            if (!this.isDuplicate(state.recommendations, rec) && !this.isDuplicate(newRecommendations, rec)) {
+                newRecommendations.push(rec);
+            }
+        }
+        console.log(`[Advisor] Total new recommendations: ${newRecommendations.length} (including ${proactiveRecs.length} proactive)`);
+        // Save state
+        state.recommendations.push(...newRecommendations);
+        state.lastAnalyzedAt = new Date().toISOString();
+        await this.saveState(state);
+        const elapsed = Date.now() - startTime;
+        console.log(`[Advisor] Analysis complete in ${elapsed}ms. Found ${newRecommendations.length} new recommendations.`);
+        return {
+            newRecommendations: newRecommendations.length,
+            totalRecommendations: state.recommendations.filter(r => r.status === 'pending').length,
+            aiEvaluated,
+        };
+    }
+}
+//# sourceMappingURL=advisor.js.map