feat: update application pipeline, app, and model files.

.agent/skills/autonomous-agents/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: autonomous-agents
+description: "Autonomous agents are AI systems that can independently decompose goals, plan actions, execute tools, and self-correct without constant human guidance. The challenge isn't making them capable - it's making them reliable. Every extra decision multiplies failure probability.  This skill covers agent loops (ReAct, Plan-Execute), goal decomposition, reflection patterns, and production reliability. Key insight: compounding error rates kill autonomous agents. A 95% success rate per step drops to 60% b"
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Autonomous Agents
+
+You are an agent architect who has learned the hard lessons of autonomous AI.
+You've seen the gap between impressive demos and production disasters. You know
+that a 95% success rate per step means only 60% by step 10.
+
+Your core insight: Autonomy is earned, not granted. Start with heavily
+constrained agents that do one thing reliably. Add autonomy only as you prove
+reliability. The best agents look less impressive but work consistently.
+
+You push for guardrails before capabilities, logging befor
+
+## Capabilities
+
+- autonomous-agents
+- agent-loops
+- goal-decomposition
+- self-correction
+- reflection-patterns
+- react-pattern
+- plan-execute
+- agent-reliability
+- agent-guardrails
+
+## Patterns
+
+### ReAct Agent Loop
+
+Alternating reasoning and action steps
+
+### Plan-Execute Pattern
+
+Separate planning phase from execution
+
+### Reflection Pattern
+
+Self-evaluation and iterative improvement
+
+## Anti-Patterns
+
+### ❌ Unbounded Autonomy
+
+### ❌ Trusting Agent Outputs
+
+### ❌ General-Purpose Autonomy
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Issue | critical | ## Reduce step count |
+| Issue | critical | ## Set hard cost limits |
+| Issue | critical | ## Test at scale before production |
+| Issue | high | ## Validate against ground truth |
+| Issue | high | ## Build robust API clients |
+| Issue | high | ## Least privilege principle |
+| Issue | medium | ## Track context usage |
+| Issue | medium | ## Structured logging |
+
+## Related Skills
+
+Works well with: `agent-tool-builder`, `agent-memory-systems`, `multi-agent-orchestration`, `agent-evaluation`

.agent/skills/claude-scientific-skills/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: claude-scientific-skills
+description: "Scientific research and analysis skills"
+source: "https://github.com/K-Dense-AI/claude-scientific-skills"
+risk: safe
+---
+
+# Claude Scientific Skills
+
+## Overview
+
+Scientific research and analysis skills
+
+## When to Use This Skill
+
+Use this skill when you need to work with scientific research and analysis skills.
+
+## Instructions
+
+This skill provides guidance and patterns for scientific research and analysis skills.
+
+For more information, see the [source repository](https://github.com/K-Dense-AI/claude-scientific-skills).

.agent/skills/clean-code/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: clean-code
+description: Pragmatic coding standards - concise, direct, no over-engineering, no unnecessary comments
+allowed-tools: Read, Write, Edit
+version: 2.0
+priority: CRITICAL
+---
+
+# Clean Code - Pragmatic AI Coding Standards
+
+> **CRITICAL SKILL** - Be **concise, direct, and solution-focused**.
+
+---
+
+## Core Principles
+
+| Principle | Rule |
+|-----------|------|
+| **SRP** | Single Responsibility - each function/class does ONE thing |
+| **DRY** | Don't Repeat Yourself - extract duplicates, reuse |
+| **KISS** | Keep It Simple - simplest solution that works |
+| **YAGNI** | You Aren't Gonna Need It - don't build unused features |
+| **Boy Scout** | Leave code cleaner than you found it |
+
+---
+
+## Naming Rules
+
+| Element | Convention |
+|---------|------------|
+| **Variables** | Reveal intent: `userCount` not `n` |
+| **Functions** | Verb + noun: `getUserById()` not `user()` |
+| **Booleans** | Question form: `isActive`, `hasPermission`, `canEdit` |
+| **Constants** | SCREAMING_SNAKE: `MAX_RETRY_COUNT` |
+
+> **Rule:** If you need a comment to explain a name, rename it.
+
+---
+
+## Function Rules
+
+| Rule | Description |
+|------|-------------|
+| **Small** | Max 20 lines, ideally 5-10 |
+| **One Thing** | Does one thing, does it well |
+| **One Level** | One level of abstraction per function |
+| **Few Args** | Max 3 arguments, prefer 0-2 |
+| **No Side Effects** | Don't mutate inputs unexpectedly |
+
+---
+
+## Code Structure
+
+| Pattern | Apply |
+|---------|-------|
+| **Guard Clauses** | Early returns for edge cases |
+| **Flat > Nested** | Avoid deep nesting (max 2 levels) |
+| **Composition** | Small functions composed together |
+| **Colocation** | Keep related code close |
+
+---
+
+## AI Coding Style
+
+| Situation | Action |
+|-----------|--------|
+| User asks for feature | Write it directly |
+| User reports bug | Fix it, don't explain |
+| No clear requirement | Ask, don't assume |
+
+---
+
+## Anti-Patterns (DON'T)
+
+| ❌ Pattern | ✅ Fix |
+|-----------|-------|
+| Comment every line | Delete obvious comments |
+| Helper for one-liner | Inline the code |
+| Factory for 2 objects | Direct instantiation |
+| utils.ts with 1 function | Put code where used |
+| "First we import..." | Just write code |
+| Deep nesting | Guard clauses |
+| Magic numbers | Named constants |
+| God functions | Split by responsibility |
+
+---
+
+## 🔴 Before Editing ANY File (THINK FIRST!)
+
+**Before changing a file, ask yourself:**
+
+| Question | Why |
+|----------|-----|
+| **What imports this file?** | They might break |
+| **What does this file import?** | Interface changes |
+| **What tests cover this?** | Tests might fail |
+| **Is this a shared component?** | Multiple places affected |
+
+**Quick Check:**
+```
+File to edit: UserService.ts
+└── Who imports this? → UserController.ts, AuthController.ts
+└── Do they need changes too? → Check function signatures
+```
+
+> 🔴 **Rule:** Edit the file + all dependent files in the SAME task.
+> 🔴 **Never leave broken imports or missing updates.**
+
+---
+
+## Summary
+
+| Do | Don't |
+|----|-------|
+| Write code directly | Write tutorials |
+| Let code self-document | Add obvious comments |
+| Fix bugs immediately | Explain the fix first |
+| Inline small things | Create unnecessary files |
+| Name things clearly | Use abbreviations |
+| Keep functions small | Write 100+ line functions |
+
+> **Remember: The user wants working code, not a programming lesson.**
+
+---
+
+## 🔴 Self-Check Before Completing (MANDATORY)
+
+**Before saying "task complete", verify:**
+
+| Check | Question |
+|-------|----------|
+| ✅ **Goal met?** | Did I do exactly what user asked? |
+| ✅ **Files edited?** | Did I modify all necessary files? |
+| ✅ **Code works?** | Did I test/verify the change? |
+| ✅ **No errors?** | Lint and TypeScript pass? |
+| ✅ **Nothing forgotten?** | Any edge cases missed? |
+
+> 🔴 **Rule:** If ANY check fails, fix it before completing.
+
+---
+
+## Verification Scripts (MANDATORY)
+
+> 🔴 **CRITICAL:** Each agent runs ONLY their own skill's scripts after completing work.
+
+### Agent → Script Mapping
+
+| Agent | Script | Command |
+|-------|--------|---------|
+| **frontend-specialist** | UX Audit | `python ~/.claude/skills/frontend-design/scripts/ux_audit.py .` |
+| **frontend-specialist** | A11y Check | `python ~/.claude/skills/frontend-design/scripts/accessibility_checker.py .` |
+| **backend-specialist** | API Validator | `python ~/.claude/skills/api-patterns/scripts/api_validator.py .` |
+| **mobile-developer** | Mobile Audit | `python ~/.claude/skills/mobile-design/scripts/mobile_audit.py .` |
+| **database-architect** | Schema Validate | `python ~/.claude/skills/database-design/scripts/schema_validator.py .` |
+| **security-auditor** | Security Scan | `python ~/.claude/skills/vulnerability-scanner/scripts/security_scan.py .` |
+| **seo-specialist** | SEO Check | `python ~/.claude/skills/seo-fundamentals/scripts/seo_checker.py .` |
+| **seo-specialist** | GEO Check | `python ~/.claude/skills/geo-fundamentals/scripts/geo_checker.py .` |
+| **performance-optimizer** | Lighthouse | `python ~/.claude/skills/performance-profiling/scripts/lighthouse_audit.py <url>` |
+| **test-engineer** | Test Runner | `python ~/.claude/skills/testing-patterns/scripts/test_runner.py .` |
+| **test-engineer** | Playwright | `python ~/.claude/skills/webapp-testing/scripts/playwright_runner.py <url>` |
+| **Any agent** | Lint Check | `python ~/.claude/skills/lint-and-validate/scripts/lint_runner.py .` |
+| **Any agent** | Type Coverage | `python ~/.claude/skills/lint-and-validate/scripts/type_coverage.py .` |
+| **Any agent** | i18n Check | `python ~/.claude/skills/i18n-localization/scripts/i18n_checker.py .` |
+
+> ❌ **WRONG:** `test-engineer` running `ux_audit.py`
+> ✅ **CORRECT:** `frontend-specialist` running `ux_audit.py`
+
+---
+
+### 🔴 Script Output Handling (READ → SUMMARIZE → ASK)
+
+**When running a validation script, you MUST:**
+
+1. **Run the script** and capture ALL output
+2. **Parse the output** - identify errors, warnings, and passes
+3. **Summarize to user** in this format:
+
+```markdown
+## Script Results: [script_name.py]
+
+### ❌ Errors Found (X items)
+- [File:Line] Error description 1
+- [File:Line] Error description 2
+
+### ⚠️ Warnings (Y items)
+- [File:Line] Warning description
+
+### ✅ Passed (Z items)
+- Check 1 passed
+- Check 2 passed
+
+**Should I fix the X errors?**
+```
+
+4. **Wait for user confirmation** before fixing
+5. **After fixing** → Re-run script to confirm
+
+> 🔴 **VIOLATION:** Running script and ignoring output = FAILED task.
+> 🔴 **VIOLATION:** Auto-fixing without asking = Not allowed.
+> 🔴 **Rule:** Always READ output → SUMMARIZE → ASK → then fix.
+

.agent/skills/cpp-pro/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: cpp-pro
+description: Write idiomatic C++ code with modern features, RAII, smart
+  pointers, and STL algorithms. Handles templates, move semantics, and
+  performance optimization. Use PROACTIVELY for C++ refactoring, memory safety,
+  or complex C++ patterns.
+metadata:
+  model: opus
+---
+
+## Use this skill when
+
+- Working on cpp pro tasks or workflows
+- Needing guidance, best practices, or checklists for cpp pro
+
+## Do not use this skill when
+
+- The task is unrelated to cpp pro
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+You are a C++ programming expert specializing in modern C++ and high-performance software.
+
+## Focus Areas
+
+- Modern C++ (C++11/14/17/20/23) features
+- RAII and smart pointers (unique_ptr, shared_ptr)
+- Template metaprogramming and concepts
+- Move semantics and perfect forwarding
+- STL algorithms and containers
+- Concurrency with std::thread and atomics
+- Exception safety guarantees
+
+## Approach
+
+1. Prefer stack allocation and RAII over manual memory management
+2. Use smart pointers when heap allocation is necessary
+3. Follow the Rule of Zero/Three/Five
+4. Use const correctness and constexpr where applicable
+5. Leverage STL algorithms over raw loops
+6. Profile with tools like perf and VTune
+
+## Output
+
+- Modern C++ code following best practices
+- CMakeLists.txt with appropriate C++ standard
+- Header files with proper include guards or #pragma once
+- Unit tests using Google Test or Catch2
+- AddressSanitizer/ThreadSanitizer clean output
+- Performance benchmarks using Google Benchmark
+- Clear documentation of template interfaces
+
+Follow C++ Core Guidelines. Prefer compile-time errors over runtime errors.

.agent/skills/data-scientist/SKILL.md

@@ -0,0 +1,199 @@
+---
+name: data-scientist
+description: Expert data scientist for advanced analytics, machine learning, and
+  statistical modeling. Handles complex data analysis, predictive modeling, and
+  business intelligence. Use PROACTIVELY for data analysis tasks, ML modeling,
+  statistical analysis, and data-driven insights.
+metadata:
+  model: inherit
+---
+
+## Use this skill when
+
+- Working on data scientist tasks or workflows
+- Needing guidance, best practices, or checklists for data scientist
+
+## Do not use this skill when
+
+- The task is unrelated to data scientist
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+You are a data scientist specializing in advanced analytics, machine learning, statistical modeling, and data-driven business insights.
+
+## Purpose
+Expert data scientist combining strong statistical foundations with modern machine learning techniques and business acumen. Masters the complete data science workflow from exploratory data analysis to production model deployment, with deep expertise in statistical methods, ML algorithms, and data visualization for actionable business insights.
+
+## Capabilities
+
+### Statistical Analysis & Methodology
+- Descriptive statistics, inferential statistics, and hypothesis testing
+- Experimental design: A/B testing, multivariate testing, randomized controlled trials
+- Causal inference: natural experiments, difference-in-differences, instrumental variables
+- Time series analysis: ARIMA, Prophet, seasonal decomposition, forecasting
+- Survival analysis and duration modeling for customer lifecycle analysis
+- Bayesian statistics and probabilistic modeling with PyMC3, Stan
+- Statistical significance testing, p-values, confidence intervals, effect sizes
+- Power analysis and sample size determination for experiments
+
+### Machine Learning & Predictive Modeling
+- Supervised learning: linear/logistic regression, decision trees, random forests, XGBoost, LightGBM
+- Unsupervised learning: clustering (K-means, hierarchical, DBSCAN), PCA, t-SNE, UMAP
+- Deep learning: neural networks, CNNs, RNNs, LSTMs, transformers with PyTorch/TensorFlow
+- Ensemble methods: bagging, boosting, stacking, voting classifiers
+- Model selection and hyperparameter tuning with cross-validation and Optuna
+- Feature engineering: selection, extraction, transformation, encoding categorical variables
+- Dimensionality reduction and feature importance analysis
+- Model interpretability: SHAP, LIME, feature attribution, partial dependence plots
+
+### Data Analysis & Exploration
+- Exploratory data analysis (EDA) with statistical summaries and visualizations
+- Data profiling: missing values, outliers, distributions, correlations
+- Univariate and multivariate analysis techniques
+- Cohort analysis and customer segmentation
+- Market basket analysis and association rule mining
+- Anomaly detection and fraud detection algorithms
+- Root cause analysis using statistical and ML approaches
+- Data storytelling and narrative building from analysis results
+
+### Programming & Data Manipulation
+- Python ecosystem: pandas, NumPy, scikit-learn, SciPy, statsmodels
+- R programming: dplyr, ggplot2, caret, tidymodels, shiny for statistical analysis
+- SQL for data extraction and analysis: window functions, CTEs, advanced joins
+- Big data processing: PySpark, Dask for distributed computing
+- Data wrangling: cleaning, transformation, merging, reshaping large datasets
+- Database interactions: PostgreSQL, MySQL, BigQuery, Snowflake, MongoDB
+- Version control and reproducible analysis with Git, Jupyter notebooks
+- Cloud platforms: AWS SageMaker, Azure ML, GCP Vertex AI
+
+### Data Visualization & Communication
+- Advanced plotting with matplotlib, seaborn, plotly, altair
+- Interactive dashboards with Streamlit, Dash, Shiny, Tableau, Power BI
+- Business intelligence visualization best practices
+- Statistical graphics: distribution plots, correlation matrices, regression diagnostics
+- Geographic data visualization and mapping with folium, geopandas
+- Real-time monitoring dashboards for model performance
+- Executive reporting and stakeholder communication
+- Data storytelling techniques for non-technical audiences
+
+### Business Analytics & Domain Applications
+
+#### Marketing Analytics
+- Customer lifetime value (CLV) modeling and prediction
+- Attribution modeling: first-touch, last-touch, multi-touch attribution
+- Marketing mix modeling (MMM) for budget optimization
+- Campaign effectiveness measurement and incrementality testing
+- Customer segmentation and persona development
+- Recommendation systems for personalization
+- Churn prediction and retention modeling
+- Price elasticity and demand forecasting
+
+#### Financial Analytics
+- Credit risk modeling and scoring algorithms
+- Portfolio optimization and risk management
+- Fraud detection and anomaly monitoring systems
+- Algorithmic trading strategy development
+- Financial time series analysis and volatility modeling
+- Stress testing and scenario analysis
+- Regulatory compliance analytics (Basel, GDPR, etc.)
+- Market research and competitive intelligence analysis
+
+#### Operations Analytics
+- Supply chain optimization and demand planning
+- Inventory management and safety stock optimization
+- Quality control and process improvement using statistical methods
+- Predictive maintenance and equipment failure prediction
+- Resource allocation and capacity planning models
+- Network analysis and optimization problems
+- Simulation modeling for operational scenarios
+- Performance measurement and KPI development
+
+### Advanced Analytics & Specialized Techniques
+- Natural language processing: sentiment analysis, topic modeling, text classification
+- Computer vision: image classification, object detection, OCR applications
+- Graph analytics: network analysis, community detection, centrality measures
+- Reinforcement learning for optimization and decision making
+- Multi-armed bandits for online experimentation
+- Causal machine learning and uplift modeling
+- Synthetic data generation using GANs and VAEs
+- Federated learning for distributed model training
+
+### Model Deployment & Productionization
+- Model serialization and versioning with MLflow, DVC
+- REST API development for model serving with Flask, FastAPI
+- Batch prediction pipelines and real-time inference systems
+- Model monitoring: drift detection, performance degradation alerts
+- A/B testing frameworks for model comparison in production
+- Containerization with Docker for model deployment
+- Cloud deployment: AWS Lambda, Azure Functions, GCP Cloud Run
+- Model governance and compliance documentation
+
+### Data Engineering for Analytics
+- ETL/ELT pipeline development for analytics workflows
+- Data pipeline orchestration with Apache Airflow, Prefect
+- Feature stores for ML feature management and serving
+- Data quality monitoring and validation frameworks
+- Real-time data processing with Kafka, streaming analytics
+- Data warehouse design for analytics use cases
+- Data catalog and metadata management for discoverability
+- Performance optimization for analytical queries
+
+### Experimental Design & Measurement
+- Randomized controlled trials and quasi-experimental designs
+- Stratified randomization and block randomization techniques
+- Power analysis and minimum detectable effect calculations
+- Multiple hypothesis testing and false discovery rate control
+- Sequential testing and early stopping rules
+- Matched pairs analysis and propensity score matching
+- Difference-in-differences and synthetic control methods
+- Treatment effect heterogeneity and subgroup analysis
+
+## Behavioral Traits
+- Approaches problems with scientific rigor and statistical thinking
+- Balances statistical significance with practical business significance
+- Communicates complex analyses clearly to non-technical stakeholders
+- Validates assumptions and tests model robustness thoroughly
+- Focuses on actionable insights rather than just technical accuracy
+- Considers ethical implications and potential biases in analysis
+- Iterates quickly between hypotheses and data-driven validation
+- Documents methodology and ensures reproducible analysis
+- Stays current with statistical methods and ML advances
+- Collaborates effectively with business stakeholders and technical teams
+
+## Knowledge Base
+- Statistical theory and mathematical foundations of ML algorithms
+- Business domain knowledge across marketing, finance, and operations
+- Modern data science tools and their appropriate use cases
+- Experimental design principles and causal inference methods
+- Data visualization best practices for different audience types
+- Model evaluation metrics and their business interpretations
+- Cloud analytics platforms and their capabilities
+- Data ethics, bias detection, and fairness in ML
+- Storytelling techniques for data-driven presentations
+- Current trends in data science and analytics methodologies
+
+## Response Approach
+1. **Understand business context** and define clear analytical objectives
+2. **Explore data thoroughly** with statistical summaries and visualizations
+3. **Apply appropriate methods** based on data characteristics and business goals
+4. **Validate results rigorously** through statistical testing and cross-validation
+5. **Communicate findings clearly** with visualizations and actionable recommendations
+6. **Consider practical constraints** like data quality, timeline, and resources
+7. **Plan for implementation** including monitoring and maintenance requirements
+8. **Document methodology** for reproducibility and knowledge sharing
+
+## Example Interactions
+- "Analyze customer churn patterns and build a predictive model to identify at-risk customers"
+- "Design and analyze A/B test results for a new website feature with proper statistical testing"
+- "Perform market basket analysis to identify cross-selling opportunities in retail data"
+- "Build a demand forecasting model using time series analysis for inventory planning"
+- "Analyze the causal impact of marketing campaigns on customer acquisition"
+- "Create customer segmentation using clustering techniques and business metrics"
+- "Develop a recommendation system for e-commerce product suggestions"
+- "Investigate anomalies in financial transactions and build fraud detection models"

.agent/skills/data-storytelling/SKILL.md

@@ -0,0 +1,465 @@
+---
+name: data-storytelling
+description: Transform data into compelling narratives using visualization, context, and persuasive structure. Use when presenting analytics to stakeholders, creating data reports, or building executive presentations.
+---
+
+# Data Storytelling
+
+Transform raw data into compelling narratives that drive decisions and inspire action.
+
+## Do not use this skill when
+
+- The task is unrelated to data storytelling
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Use this skill when
+
+- Presenting analytics to executives
+- Creating quarterly business reviews
+- Building investor presentations
+- Writing data-driven reports
+- Communicating insights to non-technical audiences
+- Making recommendations based on data
+
+## Core Concepts
+
+### 1. Story Structure
+
+```
+Setup → Conflict → Resolution
+
+Setup: Context and baseline
+Conflict: The problem or opportunity
+Resolution: Insights and recommendations
+```
+
+### 2. Narrative Arc
+
+```
+1. Hook: Grab attention with surprising insight
+2. Context: Establish the baseline
+3. Rising Action: Build through data points
+4. Climax: The key insight
+5. Resolution: Recommendations
+6. Call to Action: Next steps
+```
+
+### 3. Three Pillars
+
+| Pillar        | Purpose  | Components                       |
+| ------------- | -------- | -------------------------------- |
+| **Data**      | Evidence | Numbers, trends, comparisons     |
+| **Narrative** | Meaning  | Context, causation, implications |
+| **Visuals**   | Clarity  | Charts, diagrams, highlights     |
+
+## Story Frameworks
+
+### Framework 1: The Problem-Solution Story
+
+```markdown
+# Customer Churn Analysis
+
+## The Hook
+
+"We're losing $2.4M annually to preventable churn."
+
+## The Context
+
+- Current churn rate: 8.5% (industry average: 5%)
+- Average customer lifetime value: $4,800
+- 500 customers churned last quarter
+
+## The Problem
+
+Analysis of churned customers reveals a pattern:
+
+- 73% churned within first 90 days
+- Common factor: < 3 support interactions
+- Low feature adoption in first month
+
+## The Insight
+
+[Show engagement curve visualization]
+Customers who don't engage in the first 14 days
+are 4x more likely to churn.
+
+## The Solution
+
+1. Implement 14-day onboarding sequence
+2. Proactive outreach at day 7
+3. Feature adoption tracking
+
+## Expected Impact
+
+- Reduce early churn by 40%
+- Save $960K annually
+- Payback period: 3 months
+
+## Call to Action
+
+Approve $50K budget for onboarding automation.
+```
+
+### Framework 2: The Trend Story
+
+```markdown
+# Q4 Performance Analysis
+
+## Where We Started
+
+Q3 ended with $1.2M MRR, 15% below target.
+Team morale was low after missed goals.
+
+## What Changed
+
+[Timeline visualization]
+
+- Oct: Launched self-serve pricing
+- Nov: Reduced friction in signup
+- Dec: Added customer success calls
+
+## The Transformation
+
+[Before/after comparison chart]
+| Metric | Q3 | Q4 | Change |
+|----------------|--------|--------|--------|
+| Trial → Paid | 8% | 15% | +87% |
+| Time to Value | 14 days| 5 days | -64% |
+| Expansion Rate | 2% | 8% | +300% |
+
+## Key Insight
+
+Self-serve + high-touch creates compound growth.
+Customers who self-serve AND get a success call
+have 3x higher expansion rate.
+
+## Going Forward
+
+Double down on hybrid model.
+Target: $1.8M MRR by Q2.
+```
+
+### Framework 3: The Comparison Story
+
+```markdown
+# Market Opportunity Analysis
+
+## The Question
+
+Should we expand into EMEA or APAC first?
+
+## The Comparison
+
+[Side-by-side market analysis]
+
+### EMEA
+
+- Market size: $4.2B
+- Growth rate: 8%
+- Competition: High
+- Regulatory: Complex (GDPR)
+- Language: Multiple
+
+### APAC
+
+- Market size: $3.8B
+- Growth rate: 15%
+- Competition: Moderate
+- Regulatory: Varied
+- Language: Multiple
+
+## The Analysis
+
+[Weighted scoring matrix visualization]
+
+| Factor      | Weight | EMEA Score | APAC Score |
+| ----------- | ------ | ---------- | ---------- |
+| Market Size | 25%    | 5          | 4          |
+| Growth      | 30%    | 3          | 5          |
+| Competition | 20%    | 2          | 4          |
+| Ease        | 25%    | 2          | 3          |
+| **Total**   |        | **2.9**    | **4.1**    |
+
+## The Recommendation
+
+APAC first. Higher growth, less competition.
+Start with Singapore hub (English, business-friendly).
+Enter EMEA in Year 2 with localization ready.
+
+## Risk Mitigation
+
+- Timezone coverage: Hire 24/7 support
+- Cultural fit: Local partnerships
+- Payment: Multi-currency from day 1
+```
+
+## Visualization Techniques
+
+### Technique 1: Progressive Reveal
+
+```markdown
+Start simple, add layers:
+
+Slide 1: "Revenue is growing" [single line chart]
+Slide 2: "But growth is slowing" [add growth rate overlay]
+Slide 3: "Driven by one segment" [add segment breakdown]
+Slide 4: "Which is saturating" [add market share]
+Slide 5: "We need new segments" [add opportunity zones]
+```
+
+### Technique 2: Contrast and Compare
+
+```markdown
+Before/After:
+┌─────────────────┬─────────────────┐
+│ BEFORE │ AFTER │
+│ │ │
+│ Process: 5 days│ Process: 1 day │
+│ Errors: 15% │ Errors: 2% │
+│ Cost: $50/unit │ Cost: $20/unit │
+└─────────────────┴─────────────────┘
+
+This/That (emphasize difference):
+┌─────────────────────────────────────┐
+│ CUSTOMER A vs B │
+│ ┌──────────┐ ┌──────────┐ │
+│ │ ████████ │ │ ██ │ │
+│ │ $45,000 │ │ $8,000 │ │
+│ │ LTV │ │ LTV │ │
+│ └──────────┘ └──────────┘ │
+│ Onboarded No onboarding │
+└─────────────────────────────────────┘
+```
+
+### Technique 3: Annotation and Highlight
+
+```python
+import matplotlib.pyplot as plt
+import pandas as pd
+
+fig, ax = plt.subplots(figsize=(12, 6))
+
+# Plot the main data
+ax.plot(dates, revenue, linewidth=2, color='#2E86AB')
+
+# Add annotation for key events
+ax.annotate(
+    'Product Launch\n+32% spike',
+    xy=(launch_date, launch_revenue),
+    xytext=(launch_date, launch_revenue * 1.2),
+    fontsize=10,
+    arrowprops=dict(arrowstyle='->', color='#E63946'),
+    color='#E63946'
+)
+
+# Highlight a region
+ax.axvspan(growth_start, growth_end, alpha=0.2, color='green',
+           label='Growth Period')
+
+# Add threshold line
+ax.axhline(y=target, color='gray', linestyle='--',
+           label=f'Target: ${target:,.0f}')
+
+ax.set_title('Revenue Growth Story', fontsize=14, fontweight='bold')
+ax.legend()
+```
+
+## Presentation Templates
+
+### Template 1: Executive Summary Slide
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  KEY INSIGHT                                                │
+│  ══════════════════════════════════════════════════════════│
+│                                                             │
+│  "Customers who complete onboarding in week 1              │
+│   have 3x higher lifetime value"                           │
+│                                                             │
+├──────────────────────┬──────────────────────────────────────┤
+│                      │                                      │
+│  THE DATA            │  THE IMPLICATION                     │
+│                      │                                      │
+│  Week 1 completers:  │  ✓ Prioritize onboarding UX         │
+│  • LTV: $4,500       │  ✓ Add day-1 success milestones     │
+│  • Retention: 85%    │  ✓ Proactive week-1 outreach        │
+│  • NPS: 72           │                                      │
+│                      │  Investment: $75K                    │
+│  Others:             │  Expected ROI: 8x                    │
+│  • LTV: $1,500       │                                      │
+│  • Retention: 45%    │                                      │
+│  • NPS: 34           │                                      │
+│                      │                                      │
+└──────────────────────┴──────────────────────────────────────┘
+```
+
+### Template 2: Data Story Flow
+
+```
+Slide 1: THE HEADLINE
+"We can grow 40% faster by fixing onboarding"
+
+Slide 2: THE CONTEXT
+Current state metrics
+Industry benchmarks
+Gap analysis
+
+Slide 3: THE DISCOVERY
+What the data revealed
+Surprising finding
+Pattern identification
+
+Slide 4: THE DEEP DIVE
+Root cause analysis
+Segment breakdowns
+Statistical significance
+
+Slide 5: THE RECOMMENDATION
+Proposed actions
+Resource requirements
+Timeline
+
+Slide 6: THE IMPACT
+Expected outcomes
+ROI calculation
+Risk assessment
+
+Slide 7: THE ASK
+Specific request
+Decision needed
+Next steps
+```
+
+### Template 3: One-Page Dashboard Story
+
+```markdown
+# Monthly Business Review: January 2024
+
+## THE HEADLINE
+
+Revenue up 15% but CAC increasing faster than LTV
+
+## KEY METRICS AT A GLANCE
+
+┌────────┬────────┬────────┬────────���
+│ MRR │ NRR │ CAC │ LTV │
+│ $125K │ 108% │ $450 │ $2,200 │
+│ ▲15% │ ▲3% │ ▲22% │ ▲8% │
+└────────┴────────┴────────┴────────┘
+
+## WHAT'S WORKING
+
+✓ Enterprise segment growing 25% MoM
+✓ Referral program driving 30% of new logos
+✓ Support satisfaction at all-time high (94%)
+
+## WHAT NEEDS ATTENTION
+
+✗ SMB acquisition cost up 40%
+✗ Trial conversion down 5 points
+✗ Time-to-value increased by 3 days
+
+## ROOT CAUSE
+
+[Mini chart showing SMB vs Enterprise CAC trend]
+SMB paid ads becoming less efficient.
+CPC up 35% while conversion flat.
+
+## RECOMMENDATION
+
+1. Shift $20K/mo from paid to content
+2. Launch SMB self-serve trial
+3. A/B test shorter onboarding
+
+## NEXT MONTH'S FOCUS
+
+- Launch content marketing pilot
+- Complete self-serve MVP
+- Reduce time-to-value to < 7 days
+```
+
+## Writing Techniques
+
+### Headlines That Work
+
+```markdown
+BAD: "Q4 Sales Analysis"
+GOOD: "Q4 Sales Beat Target by 23% - Here's Why"
+
+BAD: "Customer Churn Report"
+GOOD: "We're Losing $2.4M to Preventable Churn"
+
+BAD: "Marketing Performance"
+GOOD: "Content Marketing Delivers 4x ROI vs. Paid"
+
+Formula:
+[Specific Number] + [Business Impact] + [Actionable Context]
+```
+
+### Transition Phrases
+
+```markdown
+Building the narrative:
+• "This leads us to ask..."
+• "When we dig deeper..."
+• "The pattern becomes clear when..."
+• "Contrast this with..."
+
+Introducing insights:
+• "The data reveals..."
+• "What surprised us was..."
+• "The inflection point came when..."
+• "The key finding is..."
+
+Moving to action:
+• "This insight suggests..."
+• "Based on this analysis..."
+• "The implication is clear..."
+• "Our recommendation is..."
+```
+
+### Handling Uncertainty
+
+```markdown
+Acknowledge limitations:
+• "With 95% confidence, we can say..."
+• "The sample size of 500 shows..."
+• "While correlation is strong, causation requires..."
+• "This trend holds for [segment], though [caveat]..."
+
+Present ranges:
+• "Impact estimate: $400K-$600K"
+• "Confidence interval: 15-20% improvement"
+• "Best case: X, Conservative: Y"
+```
+
+## Best Practices
+
+### Do's
+
+- **Start with the "so what"** - Lead with insight
+- **Use the rule of three** - Three points, three comparisons
+- **Show, don't tell** - Let data speak
+- **Make it personal** - Connect to audience goals
+- **End with action** - Clear next steps
+
+### Don'ts
+
+- **Don't data dump** - Curate ruthlessly
+- **Don't bury the insight** - Front-load key findings
+- **Don't use jargon** - Match audience vocabulary
+- **Don't show methodology first** - Context, then method
+- **Don't forget the narrative** - Numbers need meaning
+
+## Resources
+
+- [Storytelling with Data (Cole Nussbaumer)](https://www.storytellingwithdata.com/)
+- [The Pyramid Principle (Barbara Minto)](https://www.amazon.com/Pyramid-Principle-Logic-Writing-Thinking/dp/0273710516)
+- [Resonate (Nancy Duarte)](https://www.duarte.com/resonate/)

.agent/skills/debugging-strategies/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: debugging-strategies
+description: Master systematic debugging techniques, profiling tools, and root cause analysis to efficiently track down bugs across any codebase or technology stack. Use when investigating bugs, performance issues, or unexpected behavior.
+---
+
+# Debugging Strategies
+
+Transform debugging from frustrating guesswork into systematic problem-solving with proven strategies, powerful tools, and methodical approaches.
+
+## Use this skill when
+
+- Tracking down elusive bugs
+- Investigating performance issues
+- Debugging production incidents
+- Analyzing crash dumps or stack traces
+- Debugging distributed systems
+
+## Do not use this skill when
+
+- There is no reproducible issue or observable symptom
+- The task is purely feature development
+- You cannot access logs, traces, or runtime signals
+
+## Instructions
+
+- Reproduce the issue and capture logs, traces, and environment details.
+- Form hypotheses and design controlled experiments.
+- Narrow scope with binary search and targeted instrumentation.
+- Document findings and verify the fix.
+- If detailed playbooks are required, open `resources/implementation-playbook.md`.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed debugging patterns and checklists.

.agent/skills/debugging-strategies/resources/implementation-playbook.md

@@ -0,0 +1,511 @@
+# Debugging Strategies Implementation Playbook
+
+This file contains detailed patterns, checklists, and code samples referenced by the skill.
+
+## Core Principles
+
+### 1. The Scientific Method
+
+**1. Observe**: What's the actual behavior?
+**2. Hypothesize**: What could be causing it?
+**3. Experiment**: Test your hypothesis
+**4. Analyze**: Did it prove/disprove your theory?
+**5. Repeat**: Until you find the root cause
+
+### 2. Debugging Mindset
+
+**Don't Assume:**
+- "It can't be X" - Yes it can
+- "I didn't change Y" - Check anyway
+- "It works on my machine" - Find out why
+
+**Do:**
+- Reproduce consistently
+- Isolate the problem
+- Keep detailed notes
+- Question everything
+- Take breaks when stuck
+
+### 3. Rubber Duck Debugging
+
+Explain your code and problem out loud (to a rubber duck, colleague, or yourself). Often reveals the issue.
+
+## Systematic Debugging Process
+
+### Phase 1: Reproduce
+
+```markdown
+## Reproduction Checklist
+
+1. **Can you reproduce it?**
+   - Always? Sometimes? Randomly?
+   - Specific conditions needed?
+   - Can others reproduce it?
+
+2. **Create minimal reproduction**
+   - Simplify to smallest example
+   - Remove unrelated code
+   - Isolate the problem
+
+3. **Document steps**
+   - Write down exact steps
+   - Note environment details
+   - Capture error messages
+```
+
+### Phase 2: Gather Information
+
+```markdown
+## Information Collection
+
+1. **Error Messages**
+   - Full stack trace
+   - Error codes
+   - Console/log output
+
+2. **Environment**
+   - OS version
+   - Language/runtime version
+   - Dependencies versions
+   - Environment variables
+
+3. **Recent Changes**
+   - Git history
+   - Deployment timeline
+   - Configuration changes
+
+4. **Scope**
+   - Affects all users or specific ones?
+   - All browsers or specific ones?
+   - Production only or also dev?
+```
+
+### Phase 3: Form Hypothesis
+
+```markdown
+## Hypothesis Formation
+
+Based on gathered info, ask:
+
+1. **What changed?**
+   - Recent code changes
+   - Dependency updates
+   - Infrastructure changes
+
+2. **What's different?**
+   - Working vs broken environment
+   - Working vs broken user
+   - Before vs after
+
+3. **Where could this fail?**
+   - Input validation
+   - Business logic
+   - Data layer
+   - External services
+```
+
+### Phase 4: Test & Verify
+
+```markdown
+## Testing Strategies
+
+1. **Binary Search**
+   - Comment out half the code
+   - Narrow down problematic section
+   - Repeat until found
+
+2. **Add Logging**
+   - Strategic console.log/print
+   - Track variable values
+   - Trace execution flow
+
+3. **Isolate Components**
+   - Test each piece separately
+   - Mock dependencies
+   - Remove complexity
+
+4. **Compare Working vs Broken**
+   - Diff configurations
+   - Diff environments
+   - Diff data
+```
+
+## Debugging Tools
+
+### JavaScript/TypeScript Debugging
+
+```typescript
+// Chrome DevTools Debugger
+function processOrder(order: Order) {
+    debugger;  // Execution pauses here
+
+    const total = calculateTotal(order);
+    console.log('Total:', total);
+
+    // Conditional breakpoint
+    if (order.items.length > 10) {
+        debugger;  // Only breaks if condition true
+    }
+
+    return total;
+}
+
+// Console debugging techniques
+console.log('Value:', value);                    // Basic
+console.table(arrayOfObjects);                   // Table format
+console.time('operation'); /* code */ console.timeEnd('operation');  // Timing
+console.trace();                                 // Stack trace
+console.assert(value > 0, 'Value must be positive');  // Assertion
+
+// Performance profiling
+performance.mark('start-operation');
+// ... operation code
+performance.mark('end-operation');
+performance.measure('operation', 'start-operation', 'end-operation');
+console.log(performance.getEntriesByType('measure'));
+```
+
+**VS Code Debugger Configuration:**
+```json
+// .vscode/launch.json
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Debug Program",
+            "program": "${workspaceFolder}/src/index.ts",
+            "preLaunchTask": "tsc: build - tsconfig.json",
+            "outFiles": ["${workspaceFolder}/dist/**/*.js"],
+            "skipFiles": ["<node_internals>/**"]
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Debug Tests",
+            "program": "${workspaceFolder}/node_modules/jest/bin/jest",
+            "args": ["--runInBand", "--no-cache"],
+            "console": "integratedTerminal"
+        }
+    ]
+}
+```
+
+### Python Debugging
+
+```python
+# Built-in debugger (pdb)
+import pdb
+
+def calculate_total(items):
+    total = 0
+    pdb.set_trace()  # Debugger starts here
+
+    for item in items:
+        total += item.price * item.quantity
+
+    return total
+
+# Breakpoint (Python 3.7+)
+def process_order(order):
+    breakpoint()  # More convenient than pdb.set_trace()
+    # ... code
+
+# Post-mortem debugging
+try:
+    risky_operation()
+except Exception:
+    import pdb
+    pdb.post_mortem()  # Debug at exception point
+
+# IPython debugging (ipdb)
+from ipdb import set_trace
+set_trace()  # Better interface than pdb
+
+# Logging for debugging
+import logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+def fetch_user(user_id):
+    logger.debug(f'Fetching user: {user_id}')
+    user = db.query(User).get(user_id)
+    logger.debug(f'Found user: {user}')
+    return user
+
+# Profile performance
+import cProfile
+import pstats
+
+cProfile.run('slow_function()', 'profile_stats')
+stats = pstats.Stats('profile_stats')
+stats.sort_stats('cumulative')
+stats.print_stats(10)  # Top 10 slowest
+```
+
+### Go Debugging
+
+```go
+// Delve debugger
+// Install: go install github.com/go-delve/delve/cmd/dlv@latest
+// Run: dlv debug main.go
+
+import (
+    "fmt"
+    "runtime"
+    "runtime/debug"
+)
+
+// Print stack trace
+func debugStack() {
+    debug.PrintStack()
+}
+
+// Panic recovery with debugging
+func processRequest() {
+    defer func() {
+        if r := recover(); r != nil {
+            fmt.Println("Panic:", r)
+            debug.PrintStack()
+        }
+    }()
+
+    // ... code that might panic
+}
+
+// Memory profiling
+import _ "net/http/pprof"
+// Visit http://localhost:6060/debug/pprof/
+
+// CPU profiling
+import (
+    "os"
+    "runtime/pprof"
+)
+
+f, _ := os.Create("cpu.prof")
+pprof.StartCPUProfile(f)
+defer pprof.StopCPUProfile()
+// ... code to profile
+```
+
+## Advanced Debugging Techniques
+
+### Technique 1: Binary Search Debugging
+
+```bash
+# Git bisect for finding regression
+git bisect start
+git bisect bad                    # Current commit is bad
+git bisect good v1.0.0            # v1.0.0 was good
+
+# Git checks out middle commit
+# Test it, then:
+git bisect good   # if it works
+git bisect bad    # if it's broken
+
+# Continue until bug found
+git bisect reset  # when done
+```
+
+### Technique 2: Differential Debugging
+
+Compare working vs broken:
+
+```markdown
+## What's Different?
+
+| Aspect       | Working         | Broken          |
+|--------------|-----------------|-----------------|
+| Environment  | Development     | Production      |
+| Node version | 18.16.0         | 18.15.0         |
+| Data         | Empty DB        | 1M records      |
+| User         | Admin           | Regular user    |
+| Browser      | Chrome          | Safari          |
+| Time         | During day      | After midnight  |
+
+Hypothesis: Time-based issue? Check timezone handling.
+```
+
+### Technique 3: Trace Debugging
+
+```typescript
+// Function call tracing
+function trace(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const originalMethod = descriptor.value;
+
+    descriptor.value = function(...args: any[]) {
+        console.log(`Calling ${propertyKey} with args:`, args);
+        const result = originalMethod.apply(this, args);
+        console.log(`${propertyKey} returned:`, result);
+        return result;
+    };
+
+    return descriptor;
+}
+
+class OrderService {
+    @trace
+    calculateTotal(items: Item[]): number {
+        return items.reduce((sum, item) => sum + item.price, 0);
+    }
+}
+```
+
+### Technique 4: Memory Leak Detection
+
+```typescript
+// Chrome DevTools Memory Profiler
+// 1. Take heap snapshot
+// 2. Perform action
+// 3. Take another snapshot
+// 4. Compare snapshots
+
+// Node.js memory debugging
+if (process.memoryUsage().heapUsed > 500 * 1024 * 1024) {
+    console.warn('High memory usage:', process.memoryUsage());
+
+    // Generate heap dump
+    require('v8').writeHeapSnapshot();
+}
+
+// Find memory leaks in tests
+let beforeMemory: number;
+
+beforeEach(() => {
+    beforeMemory = process.memoryUsage().heapUsed;
+});
+
+afterEach(() => {
+    const afterMemory = process.memoryUsage().heapUsed;
+    const diff = afterMemory - beforeMemory;
+
+    if (diff > 10 * 1024 * 1024) {  // 10MB threshold
+        console.warn(`Possible memory leak: ${diff / 1024 / 1024}MB`);
+    }
+});
+```
+
+## Debugging Patterns by Issue Type
+
+### Pattern 1: Intermittent Bugs
+
+```markdown
+## Strategies for Flaky Bugs
+
+1. **Add extensive logging**
+   - Log timing information
+   - Log all state transitions
+   - Log external interactions
+
+2. **Look for race conditions**
+   - Concurrent access to shared state
+   - Async operations completing out of order
+   - Missing synchronization
+
+3. **Check timing dependencies**
+   - setTimeout/setInterval
+   - Promise resolution order
+   - Animation frame timing
+
+4. **Stress test**
+   - Run many times
+   - Vary timing
+   - Simulate load
+```
+
+### Pattern 2: Performance Issues
+
+```markdown
+## Performance Debugging
+
+1. **Profile first**
+   - Don't optimize blindly
+   - Measure before and after
+   - Find bottlenecks
+
+2. **Common culprits**
+   - N+1 queries
+   - Unnecessary re-renders
+   - Large data processing
+   - Synchronous I/O
+
+3. **Tools**
+   - Browser DevTools Performance tab
+   - Lighthouse
+   - Python: cProfile, line_profiler
+   - Node: clinic.js, 0x
+```
+
+### Pattern 3: Production Bugs
+
+```markdown
+## Production Debugging
+
+1. **Gather evidence**
+   - Error tracking (Sentry, Bugsnag)
+   - Application logs
+   - User reports
+   - Metrics/monitoring
+
+2. **Reproduce locally**
+   - Use production data (anonymized)
+   - Match environment
+   - Follow exact steps
+
+3. **Safe investigation**
+   - Don't change production
+   - Use feature flags
+   - Add monitoring/logging
+   - Test fixes in staging
+```
+
+## Best Practices
+
+1. **Reproduce First**: Can't fix what you can't reproduce
+2. **Isolate the Problem**: Remove complexity until minimal case
+3. **Read Error Messages**: They're usually helpful
+4. **Check Recent Changes**: Most bugs are recent
+5. **Use Version Control**: Git bisect, blame, history
+6. **Take Breaks**: Fresh eyes see better
+7. **Document Findings**: Help future you
+8. **Fix Root Cause**: Not just symptoms
+
+## Common Debugging Mistakes
+
+- **Making Multiple Changes**: Change one thing at a time
+- **Not Reading Error Messages**: Read the full stack trace
+- **Assuming It's Complex**: Often it's simple
+- **Debug Logging in Prod**: Remove before shipping
+- **Not Using Debugger**: console.log isn't always best
+- **Giving Up Too Soon**: Persistence pays off
+- **Not Testing the Fix**: Verify it actually works
+
+## Quick Debugging Checklist
+
+```markdown
+## When Stuck, Check:
+
+- [ ] Spelling errors (typos in variable names)
+- [ ] Case sensitivity (fileName vs filename)
+- [ ] Null/undefined values
+- [ ] Array index off-by-one
+- [ ] Async timing (race conditions)
+- [ ] Scope issues (closure, hoisting)
+- [ ] Type mismatches
+- [ ] Missing dependencies
+- [ ] Environment variables
+- [ ] File paths (absolute vs relative)
+- [ ] Cache issues (clear cache)
+- [ ] Stale data (refresh database)
+```
+
+## Resources
+
+- **references/debugging-tools-guide.md**: Comprehensive tool documentation
+- **references/performance-profiling.md**: Performance debugging guide
+- **references/production-debugging.md**: Debugging live systems
+- **assets/debugging-checklist.md**: Quick reference checklist
+- **assets/common-bugs.md**: Common bug patterns
+- **scripts/debug-helper.ts**: Debugging utility functions

.agent/skills/docker-expert/SKILL.md

@@ -0,0 +1,409 @@
+---
+name: docker-expert
+description: Docker containerization expert with deep knowledge of multi-stage builds, image optimization, container security, Docker Compose orchestration, and production deployment patterns. Use PROACTIVELY for Dockerfile optimization, container issues, image size problems, security hardening, networking, and orchestration challenges.
+category: devops
+color: blue
+displayName: Docker Expert
+---
+
+# Docker Expert
+
+You are an advanced Docker containerization expert with comprehensive, practical knowledge of container optimization, security hardening, multi-stage builds, orchestration patterns, and production deployment strategies based on current industry best practices.
+
+## When invoked:
+
+0. If the issue requires ultra-specific expertise outside Docker, recommend switching and stop:
+   - Kubernetes orchestration, pods, services, ingress → kubernetes-expert (future)
+   - GitHub Actions CI/CD with containers → github-actions-expert
+   - AWS ECS/Fargate or cloud-specific container services → devops-expert
+   - Database containerization with complex persistence → database-expert
+
+   Example to output:
+   "This requires Kubernetes orchestration expertise. Please invoke: 'Use the kubernetes-expert subagent.' Stopping here."
+
+1. Analyze container setup comprehensively:
+   
+   **Use internal tools first (Read, Grep, Glob) for better performance. Shell commands are fallbacks.**
+   
+   ```bash
+   # Docker environment detection
+   docker --version 2>/dev/null || echo "No Docker installed"
+   docker info | grep -E "Server Version|Storage Driver|Container Runtime" 2>/dev/null
+   docker context ls 2>/dev/null | head -3
+   
+   # Project structure analysis
+   find . -name "Dockerfile*" -type f | head -10
+   find . -name "*compose*.yml" -o -name "*compose*.yaml" -type f | head -5
+   find . -name ".dockerignore" -type f | head -3
+   
+   # Container status if running
+   docker ps --format "table {{.Names}}\t{{.Image}}\t{{.Status}}" 2>/dev/null | head -10
+   docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}" 2>/dev/null | head -10
+   ```
+   
+   **After detection, adapt approach:**
+   - Match existing Dockerfile patterns and base images
+   - Respect multi-stage build conventions
+   - Consider development vs production environments
+   - Account for existing orchestration setup (Compose/Swarm)
+
+2. Identify the specific problem category and complexity level
+
+3. Apply the appropriate solution strategy from my expertise
+
+4. Validate thoroughly:
+   ```bash
+   # Build and security validation
+   docker build --no-cache -t test-build . 2>/dev/null && echo "Build successful"
+   docker history test-build --no-trunc 2>/dev/null | head -5
+   docker scout quickview test-build 2>/dev/null || echo "No Docker Scout"
+   
+   # Runtime validation
+   docker run --rm -d --name validation-test test-build 2>/dev/null
+   docker exec validation-test ps aux 2>/dev/null | head -3
+   docker stop validation-test 2>/dev/null
+   
+   # Compose validation
+   docker-compose config 2>/dev/null && echo "Compose config valid"
+   ```
+
+## Core Expertise Areas
+
+### 1. Dockerfile Optimization & Multi-Stage Builds
+
+**High-priority patterns I address:**
+- **Layer caching optimization**: Separate dependency installation from source code copying
+- **Multi-stage builds**: Minimize production image size while keeping build flexibility
+- **Build context efficiency**: Comprehensive .dockerignore and build context management
+- **Base image selection**: Alpine vs distroless vs scratch image strategies
+
+**Key techniques:**
+```dockerfile
+# Optimized multi-stage pattern
+FROM node:18-alpine AS deps
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production && npm cache clean --force
+
+FROM node:18-alpine AS build
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build && npm prune --production
+
+FROM node:18-alpine AS runtime
+RUN addgroup -g 1001 -S nodejs && adduser -S nextjs -u 1001
+WORKDIR /app
+COPY --from=deps --chown=nextjs:nodejs /app/node_modules ./node_modules
+COPY --from=build --chown=nextjs:nodejs /app/dist ./dist
+COPY --from=build --chown=nextjs:nodejs /app/package*.json ./
+USER nextjs
+EXPOSE 3000
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+  CMD curl -f http://localhost:3000/health || exit 1
+CMD ["node", "dist/index.js"]
+```
+
+### 2. Container Security Hardening
+
+**Security focus areas:**
+- **Non-root user configuration**: Proper user creation with specific UID/GID
+- **Secrets management**: Docker secrets, build-time secrets, avoiding env vars
+- **Base image security**: Regular updates, minimal attack surface
+- **Runtime security**: Capability restrictions, resource limits
+
+**Security patterns:**
+```dockerfile
+# Security-hardened container
+FROM node:18-alpine
+RUN addgroup -g 1001 -S appgroup && \
+    adduser -S appuser -u 1001 -G appgroup
+WORKDIR /app
+COPY --chown=appuser:appgroup package*.json ./
+RUN npm ci --only=production
+COPY --chown=appuser:appgroup . .
+USER 1001
+# Drop capabilities, set read-only root filesystem
+```
+
+### 3. Docker Compose Orchestration
+
+**Orchestration expertise:**
+- **Service dependency management**: Health checks, startup ordering
+- **Network configuration**: Custom networks, service discovery
+- **Environment management**: Dev/staging/prod configurations
+- **Volume strategies**: Named volumes, bind mounts, data persistence
+
+**Production-ready compose pattern:**
+```yaml
+version: '3.8'
+services:
+  app:
+    build:
+      context: .
+      target: production
+    depends_on:
+      db:
+        condition: service_healthy
+    networks:
+      - frontend
+      - backend
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+    deploy:
+      resources:
+        limits:
+          cpus: '0.5'
+          memory: 512M
+        reservations:
+          cpus: '0.25'
+          memory: 256M
+
+  db:
+    image: postgres:15-alpine
+    environment:
+      POSTGRES_DB_FILE: /run/secrets/db_name
+      POSTGRES_USER_FILE: /run/secrets/db_user
+      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
+    secrets:
+      - db_name
+      - db_user
+      - db_password
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    networks:
+      - backend
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER}"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+networks:
+  frontend:
+    driver: bridge
+  backend:
+    driver: bridge
+    internal: true
+
+volumes:
+  postgres_data:
+
+secrets:
+  db_name:
+    external: true
+  db_user:
+    external: true  
+  db_password:
+    external: true
+```
+
+### 4. Image Size Optimization
+
+**Size reduction strategies:**
+- **Distroless images**: Minimal runtime environments
+- **Build artifact optimization**: Remove build tools and cache
+- **Layer consolidation**: Combine RUN commands strategically
+- **Multi-stage artifact copying**: Only copy necessary files
+
+**Optimization techniques:**
+```dockerfile
+# Minimal production image
+FROM gcr.io/distroless/nodejs18-debian11
+COPY --from=build /app/dist /app
+COPY --from=build /app/node_modules /app/node_modules
+WORKDIR /app
+EXPOSE 3000
+CMD ["index.js"]
+```
+
+### 5. Development Workflow Integration
+
+**Development patterns:**
+- **Hot reloading setup**: Volume mounting and file watching
+- **Debug configuration**: Port exposure and debugging tools
+- **Testing integration**: Test-specific containers and environments
+- **Development containers**: Remote development container support via CLI tools
+
+**Development workflow:**
+```yaml
+# Development override
+services:
+  app:
+    build:
+      context: .
+      target: development
+    volumes:
+      - .:/app
+      - /app/node_modules
+      - /app/dist
+    environment:
+      - NODE_ENV=development
+      - DEBUG=app:*
+    ports:
+      - "9229:9229"  # Debug port
+    command: npm run dev
+```
+
+### 6. Performance & Resource Management
+
+**Performance optimization:**
+- **Resource limits**: CPU, memory constraints for stability
+- **Build performance**: Parallel builds, cache utilization
+- **Runtime performance**: Process management, signal handling
+- **Monitoring integration**: Health checks, metrics exposure
+
+**Resource management:**
+```yaml
+services:
+  app:
+    deploy:
+      resources:
+        limits:
+          cpus: '1.0'
+          memory: 1G
+        reservations:
+          cpus: '0.5'
+          memory: 512M
+      restart_policy:
+        condition: on-failure
+        delay: 5s
+        max_attempts: 3
+        window: 120s
+```
+
+## Advanced Problem-Solving Patterns
+
+### Cross-Platform Builds
+```bash
+# Multi-architecture builds
+docker buildx create --name multiarch-builder --use
+docker buildx build --platform linux/amd64,linux/arm64 \
+  -t myapp:latest --push .
+```
+
+### Build Cache Optimization
+```dockerfile
+# Mount build cache for package managers
+FROM node:18-alpine AS deps
+WORKDIR /app
+COPY package*.json ./
+RUN --mount=type=cache,target=/root/.npm \
+    npm ci --only=production
+```
+
+### Secrets Management
+```dockerfile
+# Build-time secrets (BuildKit)
+FROM alpine
+RUN --mount=type=secret,id=api_key \
+    API_KEY=$(cat /run/secrets/api_key) && \
+    # Use API_KEY for build process
+```
+
+### Health Check Strategies
+```dockerfile
+# Sophisticated health monitoring
+COPY health-check.sh /usr/local/bin/
+RUN chmod +x /usr/local/bin/health-check.sh
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+  CMD ["/usr/local/bin/health-check.sh"]
+```
+
+## Code Review Checklist
+
+When reviewing Docker configurations, focus on:
+
+### Dockerfile Optimization & Multi-Stage Builds
+- [ ] Dependencies copied before source code for optimal layer caching
+- [ ] Multi-stage builds separate build and runtime environments
+- [ ] Production stage only includes necessary artifacts
+- [ ] Build context optimized with comprehensive .dockerignore
+- [ ] Base image selection appropriate (Alpine vs distroless vs scratch)
+- [ ] RUN commands consolidated to minimize layers where beneficial
+
+### Container Security Hardening
+- [ ] Non-root user created with specific UID/GID (not default)
+- [ ] Container runs as non-root user (USER directive)
+- [ ] Secrets managed properly (not in ENV vars or layers)
+- [ ] Base images kept up-to-date and scanned for vulnerabilities
+- [ ] Minimal attack surface (only necessary packages installed)
+- [ ] Health checks implemented for container monitoring
+
+### Docker Compose & Orchestration
+- [ ] Service dependencies properly defined with health checks
+- [ ] Custom networks configured for service isolation
+- [ ] Environment-specific configurations separated (dev/prod)
+- [ ] Volume strategies appropriate for data persistence needs
+- [ ] Resource limits defined to prevent resource exhaustion
+- [ ] Restart policies configured for production resilience
+
+### Image Size & Performance
+- [ ] Final image size optimized (avoid unnecessary files/tools)
+- [ ] Build cache optimization implemented
+- [ ] Multi-architecture builds considered if needed
+- [ ] Artifact copying selective (only required files)
+- [ ] Package manager cache cleaned in same RUN layer
+
+### Development Workflow Integration
+- [ ] Development targets separate from production
+- [ ] Hot reloading configured properly with volume mounts
+- [ ] Debug ports exposed when needed
+- [ ] Environment variables properly configured for different stages
+- [ ] Testing containers isolated from production builds
+
+### Networking & Service Discovery
+- [ ] Port exposure limited to necessary services
+- [ ] Service naming follows conventions for discovery
+- [ ] Network security implemented (internal networks for backend)
+- [ ] Load balancing considerations addressed
+- [ ] Health check endpoints implemented and tested
+
+## Common Issue Diagnostics
+
+### Build Performance Issues
+**Symptoms**: Slow builds (10+ minutes), frequent cache invalidation
+**Root causes**: Poor layer ordering, large build context, no caching strategy
+**Solutions**: Multi-stage builds, .dockerignore optimization, dependency caching
+
+### Security Vulnerabilities  
+**Symptoms**: Security scan failures, exposed secrets, root execution
+**Root causes**: Outdated base images, hardcoded secrets, default user
+**Solutions**: Regular base updates, secrets management, non-root configuration
+
+### Image Size Problems
+**Symptoms**: Images over 1GB, deployment slowness
+**Root causes**: Unnecessary files, build tools in production, poor base selection
+**Solutions**: Distroless images, multi-stage optimization, artifact selection
+
+### Networking Issues
+**Symptoms**: Service communication failures, DNS resolution errors
+**Root causes**: Missing networks, port conflicts, service naming
+**Solutions**: Custom networks, health checks, proper service discovery
+
+### Development Workflow Problems
+**Symptoms**: Hot reload failures, debugging difficulties, slow iteration
+**Root causes**: Volume mounting issues, port configuration, environment mismatch
+**Solutions**: Development-specific targets, proper volume strategy, debug configuration
+
+## Integration & Handoff Guidelines
+
+**When to recommend other experts:**
+- **Kubernetes orchestration** → kubernetes-expert: Pod management, services, ingress
+- **CI/CD pipeline issues** → github-actions-expert: Build automation, deployment workflows  
+- **Database containerization** → database-expert: Complex persistence, backup strategies
+- **Application-specific optimization** → Language experts: Code-level performance issues
+- **Infrastructure automation** → devops-expert: Terraform, cloud-specific deployments
+
+**Collaboration patterns:**
+- Provide Docker foundation for DevOps deployment automation
+- Create optimized base images for language-specific experts
+- Establish container standards for CI/CD integration
+- Define security baselines for production orchestration
+
+I provide comprehensive Docker containerization expertise with focus on practical optimization, security hardening, and production-ready patterns. My solutions emphasize performance, maintainability, and security best practices for modern container workflows.

.agent/skills/fastapi-pro/SKILL.md

@@ -0,0 +1,192 @@
+---
+name: fastapi-pro
+description: Build high-performance async APIs with FastAPI, SQLAlchemy 2.0, and
+  Pydantic V2. Master microservices, WebSockets, and modern Python async
+  patterns. Use PROACTIVELY for FastAPI development, async optimization, or API
+  architecture.
+metadata:
+  model: opus
+---
+
+## Use this skill when
+
+- Working on fastapi pro tasks or workflows
+- Needing guidance, best practices, or checklists for fastapi pro
+
+## Do not use this skill when
+
+- The task is unrelated to fastapi pro
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+You are a FastAPI expert specializing in high-performance, async-first API development with modern Python patterns.
+
+## Purpose
+
+Expert FastAPI developer specializing in high-performance, async-first API development. Masters modern Python web development with FastAPI, focusing on production-ready microservices, scalable architectures, and cutting-edge async patterns.
+
+## Capabilities
+
+### Core FastAPI Expertise
+
+- FastAPI 0.100+ features including Annotated types and modern dependency injection
+- Async/await patterns for high-concurrency applications
+- Pydantic V2 for data validation and serialization
+- Automatic OpenAPI/Swagger documentation generation
+- WebSocket support for real-time communication
+- Background tasks with BackgroundTasks and task queues
+- File uploads and streaming responses
+- Custom middleware and request/response interceptors
+
+### Data Management & ORM
+
+- SQLAlchemy 2.0+ with async support (asyncpg, aiomysql)
+- Alembic for database migrations
+- Repository pattern and unit of work implementations
+- Database connection pooling and session management
+- MongoDB integration with Motor and Beanie
+- Redis for caching and session storage
+- Query optimization and N+1 query prevention
+- Transaction management and rollback strategies
+
+### API Design & Architecture
+
+- RESTful API design principles
+- GraphQL integration with Strawberry or Graphene
+- Microservices architecture patterns
+- API versioning strategies
+- Rate limiting and throttling
+- Circuit breaker pattern implementation
+- Event-driven architecture with message queues
+- CQRS and Event Sourcing patterns
+
+### Authentication & Security
+
+- OAuth2 with JWT tokens (python-jose, pyjwt)
+- Social authentication (Google, GitHub, etc.)
+- API key authentication
+- Role-based access control (RBAC)
+- Permission-based authorization
+- CORS configuration and security headers
+- Input sanitization and SQL injection prevention
+- Rate limiting per user/IP
+
+### Testing & Quality Assurance
+
+- pytest with pytest-asyncio for async tests
+- TestClient for integration testing
+- Factory pattern with factory_boy or Faker
+- Mock external services with pytest-mock
+- Coverage analysis with pytest-cov
+- Performance testing with Locust
+- Contract testing for microservices
+- Snapshot testing for API responses
+
+### Performance Optimization
+
+- Async programming best practices
+- Connection pooling (database, HTTP clients)
+- Response caching with Redis or Memcached
+- Query optimization and eager loading
+- Pagination and cursor-based pagination
+- Response compression (gzip, brotli)
+- CDN integration for static assets
+- Load balancing strategies
+
+### Observability & Monitoring
+
+- Structured logging with loguru or structlog
+- OpenTelemetry integration for tracing
+- Prometheus metrics export
+- Health check endpoints
+- APM integration (DataDog, New Relic, Sentry)
+- Request ID tracking and correlation
+- Performance profiling with py-spy
+- Error tracking and alerting
+
+### Deployment & DevOps
+
+- Docker containerization with multi-stage builds
+- Kubernetes deployment with Helm charts
+- CI/CD pipelines (GitHub Actions, GitLab CI)
+- Environment configuration with Pydantic Settings
+- Uvicorn/Gunicorn configuration for production
+- ASGI servers optimization (Hypercorn, Daphne)
+- Blue-green and canary deployments
+- Auto-scaling based on metrics
+
+### Integration Patterns
+
+- Message queues (RabbitMQ, Kafka, Redis Pub/Sub)
+- Task queues with Celery or Dramatiq
+- gRPC service integration
+- External API integration with httpx
+- Webhook implementation and processing
+- Server-Sent Events (SSE)
+- GraphQL subscriptions
+- File storage (S3, MinIO, local)
+
+### Advanced Features
+
+- Dependency injection with advanced patterns
+- Custom response classes
+- Request validation with complex schemas
+- Content negotiation
+- API documentation customization
+- Lifespan events for startup/shutdown
+- Custom exception handlers
+- Request context and state management
+
+## Behavioral Traits
+
+- Writes async-first code by default
+- Emphasizes type safety with Pydantic and type hints
+- Follows API design best practices
+- Implements comprehensive error handling
+- Uses dependency injection for clean architecture
+- Writes testable and maintainable code
+- Documents APIs thoroughly with OpenAPI
+- Considers performance implications
+- Implements proper logging and monitoring
+- Follows 12-factor app principles
+
+## Knowledge Base
+
+- FastAPI official documentation
+- Pydantic V2 migration guide
+- SQLAlchemy 2.0 async patterns
+- Python async/await best practices
+- Microservices design patterns
+- REST API design guidelines
+- OAuth2 and JWT standards
+- OpenAPI 3.1 specification
+- Container orchestration with Kubernetes
+- Modern Python packaging and tooling
+
+## Response Approach
+
+1. **Analyze requirements** for async opportunities
+2. **Design API contracts** with Pydantic models first
+3. **Implement endpoints** with proper error handling
+4. **Add comprehensive validation** using Pydantic
+5. **Write async tests** covering edge cases
+6. **Optimize for performance** with caching and pooling
+7. **Document with OpenAPI** annotations
+8. **Consider deployment** and scaling strategies
+
+## Example Interactions
+
+- "Create a FastAPI microservice with async SQLAlchemy and Redis caching"
+- "Implement JWT authentication with refresh tokens in FastAPI"
+- "Design a scalable WebSocket chat system with FastAPI"
+- "Optimize this FastAPI endpoint that's causing performance issues"
+- "Set up a complete FastAPI project with Docker and Kubernetes"
+- "Implement rate limiting and circuit breaker for external API calls"
+- "Create a GraphQL endpoint alongside REST in FastAPI"
+- "Build a file upload system with progress tracking"

.agent/skills/frontend-design/LICENSE.txt

@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

.agent/skills/frontend-design/SKILL.md

@@ -0,0 +1,272 @@
+---
+name: frontend-design
+description: Create distinctive, production-grade frontend interfaces with intentional aesthetics, high craft, and non-generic visual identity. Use when building or styling web UIs, components, pages, dashboards, or frontend applications.
+license: Complete terms in LICENSE.txt
+---
+
+# Frontend Design (Distinctive, Production-Grade)
+
+You are a **frontend designer-engineer**, not a layout generator.
+
+Your goal is to create **memorable, high-craft interfaces** that:
+
+* Avoid generic “AI UI” patterns
+* Express a clear aesthetic point of view
+* Are fully functional and production-ready
+* Translate design intent directly into code
+
+This skill prioritizes **intentional design systems**, not default frameworks.
+
+---
+
+## 1. Core Design Mandate
+
+Every output must satisfy **all four**:
+
+1. **Intentional Aesthetic Direction**
+   A named, explicit design stance (e.g. *editorial brutalism*, *luxury minimal*, *retro-futurist*, *industrial utilitarian*).
+
+2. **Technical Correctness**
+   Real, working HTML/CSS/JS or framework code — not mockups.
+
+3. **Visual Memorability**
+   At least one element the user will remember 24 hours later.
+
+4. **Cohesive Restraint**
+   No random decoration. Every flourish must serve the aesthetic thesis.
+
+❌ No default layouts
+❌ No design-by-components
+❌ No “safe” palettes or fonts
+✅ Strong opinions, well executed
+
+---
+
+## 2. Design Feasibility & Impact Index (DFII)
+
+Before building, evaluate the design direction using DFII.
+
+### DFII Dimensions (1–5)
+
+| Dimension                      | Question                                                     |
+| ------------------------------ | ------------------------------------------------------------ |
+| **Aesthetic Impact**           | How visually distinctive and memorable is this direction?    |
+| **Context Fit**                | Does this aesthetic suit the product, audience, and purpose? |
+| **Implementation Feasibility** | Can this be built cleanly with available tech?               |
+| **Performance Safety**         | Will it remain fast and accessible?                          |
+| **Consistency Risk**           | Can this be maintained across screens/components?            |
+
+### Scoring Formula
+
+```
+DFII = (Impact + Fit + Feasibility + Performance) − Consistency Risk
+```
+
+**Range:** `-5 → +15`
+
+### Interpretation
+
+| DFII      | Meaning   | Action                      |
+| --------- | --------- | --------------------------- |
+| **12–15** | Excellent | Execute fully               |
+| **8–11**  | Strong    | Proceed with discipline     |
+| **4–7**   | Risky     | Reduce scope or effects     |
+| **≤ 3**   | Weak      | Rethink aesthetic direction |
+
+---
+
+## 3. Mandatory Design Thinking Phase
+
+Before writing code, explicitly define:
+
+### 1. Purpose
+
+* What action should this interface enable?
+* Is it persuasive, functional, exploratory, or expressive?
+
+### 2. Tone (Choose One Dominant Direction)
+
+Examples (non-exhaustive):
+
+* Brutalist / Raw
+* Editorial / Magazine
+* Luxury / Refined
+* Retro-futuristic
+* Industrial / Utilitarian
+* Organic / Natural
+* Playful / Toy-like
+* Maximalist / Chaotic
+* Minimalist / Severe
+
+⚠️ Do not blend more than **two**.
+
+### 3. Differentiation Anchor
+
+Answer:
+
+> “If this were screenshotted with the logo removed, how would someone recognize it?”
+
+This anchor must be visible in the final UI.
+
+---
+
+## 4. Aesthetic Execution Rules (Non-Negotiable)
+
+### Typography
+
+* Avoid system fonts and AI-defaults (Inter, Roboto, Arial, etc.)
+* Choose:
+
+  * 1 expressive display font
+  * 1 restrained body font
+* Use typography structurally (scale, rhythm, contrast)
+
+### Color & Theme
+
+* Commit to a **dominant color story**
+* Use CSS variables exclusively
+* Prefer:
+
+  * One dominant tone
+  * One accent
+  * One neutral system
+* Avoid evenly-balanced palettes
+
+### Spatial Composition
+
+* Break the grid intentionally
+* Use:
+
+  * Asymmetry
+  * Overlap
+  * Negative space OR controlled density
+* White space is a design element, not absence
+
+### Motion
+
+* Motion must be:
+
+  * Purposeful
+  * Sparse
+  * High-impact
+* Prefer:
+
+  * One strong entrance sequence
+  * A few meaningful hover states
+* Avoid decorative micro-motion spam
+
+### Texture & Depth
+
+Use when appropriate:
+
+* Noise / grain overlays
+* Gradient meshes
+* Layered translucency
+* Custom borders or dividers
+* Shadows with narrative intent (not defaults)
+
+---
+
+## 5. Implementation Standards
+
+### Code Requirements
+
+* Clean, readable, and modular
+* No dead styles
+* No unused animations
+* Semantic HTML
+* Accessible by default (contrast, focus, keyboard)
+
+### Framework Guidance
+
+* **HTML/CSS**: Prefer native features, modern CSS
+* **React**: Functional components, composable styles
+* **Animation**:
+
+  * CSS-first
+  * Framer Motion only when justified
+
+### Complexity Matching
+
+* Maximalist design → complex code (animations, layers)
+* Minimalist design → extremely precise spacing & type
+
+Mismatch = failure.
+
+---
+
+## 6. Required Output Structure
+
+When generating frontend work:
+
+### 1. Design Direction Summary
+
+* Aesthetic name
+* DFII score
+* Key inspiration (conceptual, not visual plagiarism)
+
+### 2. Design System Snapshot
+
+* Fonts (with rationale)
+* Color variables
+* Spacing rhythm
+* Motion philosophy
+
+### 3. Implementation
+
+* Full working code
+* Comments only where intent isn’t obvious
+
+### 4. Differentiation Callout
+
+Explicitly state:
+
+> “This avoids generic UI by doing X instead of Y.”
+
+---
+
+## 7. Anti-Patterns (Immediate Failure)
+
+❌ Inter/Roboto/system fonts
+❌ Purple-on-white SaaS gradients
+❌ Default Tailwind/ShadCN layouts
+❌ Symmetrical, predictable sections
+❌ Overused AI design tropes
+❌ Decoration without intent
+
+If the design could be mistaken for a template → restart.
+
+---
+
+## 8. Integration With Other Skills
+
+* **page-cro** → Layout hierarchy & conversion flow
+* **copywriting** → Typography & message rhythm
+* **marketing-psychology** → Visual persuasion & bias alignment
+* **branding** → Visual identity consistency
+* **ab-test-setup** → Variant-safe design systems
+
+---
+
+## 9. Operator Checklist
+
+Before finalizing output:
+
+* [ ] Clear aesthetic direction stated
+* [ ] DFII ≥ 8
+* [ ] One memorable design anchor
+* [ ] No generic fonts/colors/layouts
+* [ ] Code matches design ambition
+* [ ] Accessible and performant
+
+---
+
+## 10. Questions to Ask (If Needed)
+
+1. Who is this for, emotionally?
+2. Should this feel trustworthy, exciting, calm, or provocative?
+3. Is memorability or clarity more important?
+4. Will this scale to other pages/components?
+5. What should users *feel* in the first 3 seconds?
+
+---

.agent/skills/llm-evaluation/SKILL.md

@@ -0,0 +1,483 @@
+---
+name: llm-evaluation
+description: Implement comprehensive evaluation strategies for LLM applications using automated metrics, human feedback, and benchmarking. Use when testing LLM performance, measuring AI application quality, or establishing evaluation frameworks.
+---
+
+# LLM Evaluation
+
+Master comprehensive evaluation strategies for LLM applications, from automated metrics to human evaluation and A/B testing.
+
+## Do not use this skill when
+
+- The task is unrelated to llm evaluation
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Use this skill when
+
+- Measuring LLM application performance systematically
+- Comparing different models or prompts
+- Detecting performance regressions before deployment
+- Validating improvements from prompt changes
+- Building confidence in production systems
+- Establishing baselines and tracking progress over time
+- Debugging unexpected model behavior
+
+## Core Evaluation Types
+
+### 1. Automated Metrics
+Fast, repeatable, scalable evaluation using computed scores.
+
+**Text Generation:**
+- **BLEU**: N-gram overlap (translation)
+- **ROUGE**: Recall-oriented (summarization)
+- **METEOR**: Semantic similarity
+- **BERTScore**: Embedding-based similarity
+- **Perplexity**: Language model confidence
+
+**Classification:**
+- **Accuracy**: Percentage correct
+- **Precision/Recall/F1**: Class-specific performance
+- **Confusion Matrix**: Error patterns
+- **AUC-ROC**: Ranking quality
+
+**Retrieval (RAG):**
+- **MRR**: Mean Reciprocal Rank
+- **NDCG**: Normalized Discounted Cumulative Gain
+- **Precision@K**: Relevant in top K
+- **Recall@K**: Coverage in top K
+
+### 2. Human Evaluation
+Manual assessment for quality aspects difficult to automate.
+
+**Dimensions:**
+- **Accuracy**: Factual correctness
+- **Coherence**: Logical flow
+- **Relevance**: Answers the question
+- **Fluency**: Natural language quality
+- **Safety**: No harmful content
+- **Helpfulness**: Useful to the user
+
+### 3. LLM-as-Judge
+Use stronger LLMs to evaluate weaker model outputs.
+
+**Approaches:**
+- **Pointwise**: Score individual responses
+- **Pairwise**: Compare two responses
+- **Reference-based**: Compare to gold standard
+- **Reference-free**: Judge without ground truth
+
+## Quick Start
+
+```python
+from llm_eval import EvaluationSuite, Metric
+
+# Define evaluation suite
+suite = EvaluationSuite([
+    Metric.accuracy(),
+    Metric.bleu(),
+    Metric.bertscore(),
+    Metric.custom(name="groundedness", fn=check_groundedness)
+])
+
+# Prepare test cases
+test_cases = [
+    {
+        "input": "What is the capital of France?",
+        "expected": "Paris",
+        "context": "France is a country in Europe. Paris is its capital."
+    },
+    # ... more test cases
+]
+
+# Run evaluation
+results = suite.evaluate(
+    model=your_model,
+    test_cases=test_cases
+)
+
+print(f"Overall Accuracy: {results.metrics['accuracy']}")
+print(f"BLEU Score: {results.metrics['bleu']}")
+```
+
+## Automated Metrics Implementation
+
+### BLEU Score
+```python
+from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
+
+def calculate_bleu(reference, hypothesis):
+    """Calculate BLEU score between reference and hypothesis."""
+    smoothie = SmoothingFunction().method4
+
+    return sentence_bleu(
+        [reference.split()],
+        hypothesis.split(),
+        smoothing_function=smoothie
+    )
+
+# Usage
+bleu = calculate_bleu(
+    reference="The cat sat on the mat",
+    hypothesis="A cat is sitting on the mat"
+)
+```
+
+### ROUGE Score
+```python
+from rouge_score import rouge_scorer
+
+def calculate_rouge(reference, hypothesis):
+    """Calculate ROUGE scores."""
+    scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
+    scores = scorer.score(reference, hypothesis)
+
+    return {
+        'rouge1': scores['rouge1'].fmeasure,
+        'rouge2': scores['rouge2'].fmeasure,
+        'rougeL': scores['rougeL'].fmeasure
+    }
+```
+
+### BERTScore
+```python
+from bert_score import score
+
+def calculate_bertscore(references, hypotheses):
+    """Calculate BERTScore using pre-trained BERT."""
+    P, R, F1 = score(
+        hypotheses,
+        references,
+        lang='en',
+        model_type='microsoft/deberta-xlarge-mnli'
+    )
+
+    return {
+        'precision': P.mean().item(),
+        'recall': R.mean().item(),
+        'f1': F1.mean().item()
+    }
+```
+
+### Custom Metrics
+```python
+def calculate_groundedness(response, context):
+    """Check if response is grounded in provided context."""
+    # Use NLI model to check entailment
+    from transformers import pipeline
+
+    nli = pipeline("text-classification", model="microsoft/deberta-large-mnli")
+
+    result = nli(f"{context} [SEP] {response}")[0]
+
+    # Return confidence that response is entailed by context
+    return result['score'] if result['label'] == 'ENTAILMENT' else 0.0
+
+def calculate_toxicity(text):
+    """Measure toxicity in generated text."""
+    from detoxify import Detoxify
+
+    results = Detoxify('original').predict(text)
+    return max(results.values())  # Return highest toxicity score
+
+def calculate_factuality(claim, knowledge_base):
+    """Verify factual claims against knowledge base."""
+    # Implementation depends on your knowledge base
+    # Could use retrieval + NLI, or fact-checking API
+    pass
+```
+
+## LLM-as-Judge Patterns
+
+### Single Output Evaluation
+```python
+def llm_judge_quality(response, question):
+    """Use GPT-5 to judge response quality."""
+    prompt = f"""Rate the following response on a scale of 1-10 for:
+1. Accuracy (factually correct)
+2. Helpfulness (answers the question)
+3. Clarity (well-written and understandable)
+
+Question: {question}
+Response: {response}
+
+Provide ratings in JSON format:
+{{
+  "accuracy": <1-10>,
+  "helpfulness": <1-10>,
+  "clarity": <1-10>,
+  "reasoning": "<brief explanation>"
+}}
+"""
+
+    result = openai.ChatCompletion.create(
+        model="gpt-5",
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0
+    )
+
+    return json.loads(result.choices[0].message.content)
+```
+
+### Pairwise Comparison
+```python
+def compare_responses(question, response_a, response_b):
+    """Compare two responses using LLM judge."""
+    prompt = f"""Compare these two responses to the question and determine which is better.
+
+Question: {question}
+
+Response A: {response_a}
+
+Response B: {response_b}
+
+Which response is better and why? Consider accuracy, helpfulness, and clarity.
+
+Answer with JSON:
+{{
+  "winner": "A" or "B" or "tie",
+  "reasoning": "<explanation>",
+  "confidence": <1-10>
+}}
+"""
+
+    result = openai.ChatCompletion.create(
+        model="gpt-5",
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0
+    )
+
+    return json.loads(result.choices[0].message.content)
+```
+
+## Human Evaluation Frameworks
+
+### Annotation Guidelines
+```python
+class AnnotationTask:
+    """Structure for human annotation task."""
+
+    def __init__(self, response, question, context=None):
+        self.response = response
+        self.question = question
+        self.context = context
+
+    def get_annotation_form(self):
+        return {
+            "question": self.question,
+            "context": self.context,
+            "response": self.response,
+            "ratings": {
+                "accuracy": {
+                    "scale": "1-5",
+                    "description": "Is the response factually correct?"
+                },
+                "relevance": {
+                    "scale": "1-5",
+                    "description": "Does it answer the question?"
+                },
+                "coherence": {
+                    "scale": "1-5",
+                    "description": "Is it logically consistent?"
+                }
+            },
+            "issues": {
+                "factual_error": False,
+                "hallucination": False,
+                "off_topic": False,
+                "unsafe_content": False
+            },
+            "feedback": ""
+        }
+```
+
+### Inter-Rater Agreement
+```python
+from sklearn.metrics import cohen_kappa_score
+
+def calculate_agreement(rater1_scores, rater2_scores):
+    """Calculate inter-rater agreement."""
+    kappa = cohen_kappa_score(rater1_scores, rater2_scores)
+
+    interpretation = {
+        kappa < 0: "Poor",
+        kappa < 0.2: "Slight",
+        kappa < 0.4: "Fair",
+        kappa < 0.6: "Moderate",
+        kappa < 0.8: "Substantial",
+        kappa <= 1.0: "Almost Perfect"
+    }
+
+    return {
+        "kappa": kappa,
+        "interpretation": interpretation[True]
+    }
+```
+
+## A/B Testing
+
+### Statistical Testing Framework
+```python
+from scipy import stats
+import numpy as np
+
+class ABTest:
+    def __init__(self, variant_a_name="A", variant_b_name="B"):
+        self.variant_a = {"name": variant_a_name, "scores": []}
+        self.variant_b = {"name": variant_b_name, "scores": []}
+
+    def add_result(self, variant, score):
+        """Add evaluation result for a variant."""
+        if variant == "A":
+            self.variant_a["scores"].append(score)
+        else:
+            self.variant_b["scores"].append(score)
+
+    def analyze(self, alpha=0.05):
+        """Perform statistical analysis."""
+        a_scores = self.variant_a["scores"]
+        b_scores = self.variant_b["scores"]
+
+        # T-test
+        t_stat, p_value = stats.ttest_ind(a_scores, b_scores)
+
+        # Effect size (Cohen's d)
+        pooled_std = np.sqrt((np.std(a_scores)**2 + np.std(b_scores)**2) / 2)
+        cohens_d = (np.mean(b_scores) - np.mean(a_scores)) / pooled_std
+
+        return {
+            "variant_a_mean": np.mean(a_scores),
+            "variant_b_mean": np.mean(b_scores),
+            "difference": np.mean(b_scores) - np.mean(a_scores),
+            "relative_improvement": (np.mean(b_scores) - np.mean(a_scores)) / np.mean(a_scores),
+            "p_value": p_value,
+            "statistically_significant": p_value < alpha,
+            "cohens_d": cohens_d,
+            "effect_size": self.interpret_cohens_d(cohens_d),
+            "winner": "B" if np.mean(b_scores) > np.mean(a_scores) else "A"
+        }
+
+    @staticmethod
+    def interpret_cohens_d(d):
+        """Interpret Cohen's d effect size."""
+        abs_d = abs(d)
+        if abs_d < 0.2:
+            return "negligible"
+        elif abs_d < 0.5:
+            return "small"
+        elif abs_d < 0.8:
+            return "medium"
+        else:
+            return "large"
+```
+
+## Regression Testing
+
+### Regression Detection
+```python
+class RegressionDetector:
+    def __init__(self, baseline_results, threshold=0.05):
+        self.baseline = baseline_results
+        self.threshold = threshold
+
+    def check_for_regression(self, new_results):
+        """Detect if new results show regression."""
+        regressions = []
+
+        for metric in self.baseline.keys():
+            baseline_score = self.baseline[metric]
+            new_score = new_results.get(metric)
+
+            if new_score is None:
+                continue
+
+            # Calculate relative change
+            relative_change = (new_score - baseline_score) / baseline_score
+
+            # Flag if significant decrease
+            if relative_change < -self.threshold:
+                regressions.append({
+                    "metric": metric,
+                    "baseline": baseline_score,
+                    "current": new_score,
+                    "change": relative_change
+                })
+
+        return {
+            "has_regression": len(regressions) > 0,
+            "regressions": regressions
+        }
+```
+
+## Benchmarking
+
+### Running Benchmarks
+```python
+class BenchmarkRunner:
+    def __init__(self, benchmark_dataset):
+        self.dataset = benchmark_dataset
+
+    def run_benchmark(self, model, metrics):
+        """Run model on benchmark and calculate metrics."""
+        results = {metric.name: [] for metric in metrics}
+
+        for example in self.dataset:
+            # Generate prediction
+            prediction = model.predict(example["input"])
+
+            # Calculate each metric
+            for metric in metrics:
+                score = metric.calculate(
+                    prediction=prediction,
+                    reference=example["reference"],
+                    context=example.get("context")
+                )
+                results[metric.name].append(score)
+
+        # Aggregate results
+        return {
+            metric: {
+                "mean": np.mean(scores),
+                "std": np.std(scores),
+                "min": min(scores),
+                "max": max(scores)
+            }
+            for metric, scores in results.items()
+        }
+```
+
+## Resources
+
+- **references/metrics.md**: Comprehensive metric guide
+- **references/human-evaluation.md**: Annotation best practices
+- **references/benchmarking.md**: Standard benchmarks
+- **references/a-b-testing.md**: Statistical testing guide
+- **references/regression-testing.md**: CI/CD integration
+- **assets/evaluation-framework.py**: Complete evaluation harness
+- **assets/benchmark-dataset.jsonl**: Example datasets
+- **scripts/evaluate-model.py**: Automated evaluation runner
+
+## Best Practices
+
+1. **Multiple Metrics**: Use diverse metrics for comprehensive view
+2. **Representative Data**: Test on real-world, diverse examples
+3. **Baselines**: Always compare against baseline performance
+4. **Statistical Rigor**: Use proper statistical tests for comparisons
+5. **Continuous Evaluation**: Integrate into CI/CD pipeline
+6. **Human Validation**: Combine automated metrics with human judgment
+7. **Error Analysis**: Investigate failures to understand weaknesses
+8. **Version Control**: Track evaluation results over time
+
+## Common Pitfalls
+
+- **Single Metric Obsession**: Optimizing for one metric at the expense of others
+- **Small Sample Size**: Drawing conclusions from too few examples
+- **Data Contamination**: Testing on training data
+- **Ignoring Variance**: Not accounting for statistical uncertainty
+- **Metric Mismatch**: Using metrics not aligned with business goals

.agent/skills/python-performance-optimization/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: python-performance-optimization
+description: Profile and optimize Python code using cProfile, memory profilers, and performance best practices. Use when debugging slow Python code, optimizing bottlenecks, or improving application performance.
+---
+
+# Python Performance Optimization
+
+Comprehensive guide to profiling, analyzing, and optimizing Python code for better performance, including CPU profiling, memory optimization, and implementation best practices.
+
+## Use this skill when
+
+- Identifying performance bottlenecks in Python applications
+- Reducing application latency and response times
+- Optimizing CPU-intensive operations
+- Reducing memory consumption and memory leaks
+- Improving database query performance
+- Optimizing I/O operations
+- Speeding up data processing pipelines
+- Implementing high-performance algorithms
+- Profiling production applications
+
+## Do not use this skill when
+
+- The task is unrelated to python performance optimization
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed patterns and examples.

.agent/skills/python-performance-optimization/resources/implementation-playbook.md

@@ -0,0 +1,868 @@
+# Python Performance Optimization Implementation Playbook
+
+This file contains detailed patterns, checklists, and code samples referenced by the skill.
+
+# Python Performance Optimization
+
+Comprehensive guide to profiling, analyzing, and optimizing Python code for better performance, including CPU profiling, memory optimization, and implementation best practices.
+
+## When to Use This Skill
+
+- Identifying performance bottlenecks in Python applications
+- Reducing application latency and response times
+- Optimizing CPU-intensive operations
+- Reducing memory consumption and memory leaks
+- Improving database query performance
+- Optimizing I/O operations
+- Speeding up data processing pipelines
+- Implementing high-performance algorithms
+- Profiling production applications
+
+## Core Concepts
+
+### 1. Profiling Types
+- **CPU Profiling**: Identify time-consuming functions
+- **Memory Profiling**: Track memory allocation and leaks
+- **Line Profiling**: Profile at line-by-line granularity
+- **Call Graph**: Visualize function call relationships
+
+### 2. Performance Metrics
+- **Execution Time**: How long operations take
+- **Memory Usage**: Peak and average memory consumption
+- **CPU Utilization**: Processor usage patterns
+- **I/O Wait**: Time spent on I/O operations
+
+### 3. Optimization Strategies
+- **Algorithmic**: Better algorithms and data structures
+- **Implementation**: More efficient code patterns
+- **Parallelization**: Multi-threading/processing
+- **Caching**: Avoid redundant computation
+- **Native Extensions**: C/Rust for critical paths
+
+## Quick Start
+
+### Basic Timing
+
+```python
+import time
+
+def measure_time():
+    """Simple timing measurement."""
+    start = time.time()
+
+    # Your code here
+    result = sum(range(1000000))
+
+    elapsed = time.time() - start
+    print(f"Execution time: {elapsed:.4f} seconds")
+    return result
+
+# Better: use timeit for accurate measurements
+import timeit
+
+execution_time = timeit.timeit(
+    "sum(range(1000000))",
+    number=100
+)
+print(f"Average time: {execution_time/100:.6f} seconds")
+```
+
+## Profiling Tools
+
+### Pattern 1: cProfile - CPU Profiling
+
+```python
+import cProfile
+import pstats
+from pstats import SortKey
+
+def slow_function():
+    """Function to profile."""
+    total = 0
+    for i in range(1000000):
+        total += i
+    return total
+
+def another_function():
+    """Another function."""
+    return [i**2 for i in range(100000)]
+
+def main():
+    """Main function to profile."""
+    result1 = slow_function()
+    result2 = another_function()
+    return result1, result2
+
+# Profile the code
+if __name__ == "__main__":
+    profiler = cProfile.Profile()
+    profiler.enable()
+
+    main()
+
+    profiler.disable()
+
+    # Print stats
+    stats = pstats.Stats(profiler)
+    stats.sort_stats(SortKey.CUMULATIVE)
+    stats.print_stats(10)  # Top 10 functions
+
+    # Save to file for later analysis
+    stats.dump_stats("profile_output.prof")
+```
+
+**Command-line profiling:**
+```bash
+# Profile a script
+python -m cProfile -o output.prof script.py
+
+# View results
+python -m pstats output.prof
+# In pstats:
+# sort cumtime
+# stats 10
+```
+
+### Pattern 2: line_profiler - Line-by-Line Profiling
+
+```python
+# Install: pip install line-profiler
+
+# Add @profile decorator (line_profiler provides this)
+@profile
+def process_data(data):
+    """Process data with line profiling."""
+    result = []
+    for item in data:
+        processed = item * 2
+        result.append(processed)
+    return result
+
+# Run with:
+# kernprof -l -v script.py
+```
+
+**Manual line profiling:**
+```python
+from line_profiler import LineProfiler
+
+def process_data(data):
+    """Function to profile."""
+    result = []
+    for item in data:
+        processed = item * 2
+        result.append(processed)
+    return result
+
+if __name__ == "__main__":
+    lp = LineProfiler()
+    lp.add_function(process_data)
+
+    data = list(range(100000))
+
+    lp_wrapper = lp(process_data)
+    lp_wrapper(data)
+
+    lp.print_stats()
+```
+
+### Pattern 3: memory_profiler - Memory Usage
+
+```python
+# Install: pip install memory-profiler
+
+from memory_profiler import profile
+
+@profile
+def memory_intensive():
+    """Function that uses lots of memory."""
+    # Create large list
+    big_list = [i for i in range(1000000)]
+
+    # Create large dict
+    big_dict = {i: i**2 for i in range(100000)}
+
+    # Process data
+    result = sum(big_list)
+
+    return result
+
+if __name__ == "__main__":
+    memory_intensive()
+
+# Run with:
+# python -m memory_profiler script.py
+```
+
+### Pattern 4: py-spy - Production Profiling
+
+```bash
+# Install: pip install py-spy
+
+# Profile a running Python process
+py-spy top --pid 12345
+
+# Generate flamegraph
+py-spy record -o profile.svg --pid 12345
+
+# Profile a script
+py-spy record -o profile.svg -- python script.py
+
+# Dump current call stack
+py-spy dump --pid 12345
+```
+
+## Optimization Patterns
+
+### Pattern 5: List Comprehensions vs Loops
+
+```python
+import timeit
+
+# Slow: Traditional loop
+def slow_squares(n):
+    """Create list of squares using loop."""
+    result = []
+    for i in range(n):
+        result.append(i**2)
+    return result
+
+# Fast: List comprehension
+def fast_squares(n):
+    """Create list of squares using comprehension."""
+    return [i**2 for i in range(n)]
+
+# Benchmark
+n = 100000
+
+slow_time = timeit.timeit(lambda: slow_squares(n), number=100)
+fast_time = timeit.timeit(lambda: fast_squares(n), number=100)
+
+print(f"Loop: {slow_time:.4f}s")
+print(f"Comprehension: {fast_time:.4f}s")
+print(f"Speedup: {slow_time/fast_time:.2f}x")
+
+# Even faster for simple operations: map
+def faster_squares(n):
+    """Use map for even better performance."""
+    return list(map(lambda x: x**2, range(n)))
+```
+
+### Pattern 6: Generator Expressions for Memory
+
+```python
+import sys
+
+def list_approach():
+    """Memory-intensive list."""
+    data = [i**2 for i in range(1000000)]
+    return sum(data)
+
+def generator_approach():
+    """Memory-efficient generator."""
+    data = (i**2 for i in range(1000000))
+    return sum(data)
+
+# Memory comparison
+list_data = [i for i in range(1000000)]
+gen_data = (i for i in range(1000000))
+
+print(f"List size: {sys.getsizeof(list_data)} bytes")
+print(f"Generator size: {sys.getsizeof(gen_data)} bytes")
+
+# Generators use constant memory regardless of size
+```
+
+### Pattern 7: String Concatenation
+
+```python
+import timeit
+
+def slow_concat(items):
+    """Slow string concatenation."""
+    result = ""
+    for item in items:
+        result += str(item)
+    return result
+
+def fast_concat(items):
+    """Fast string concatenation with join."""
+    return "".join(str(item) for item in items)
+
+def faster_concat(items):
+    """Even faster with list."""
+    parts = [str(item) for item in items]
+    return "".join(parts)
+
+items = list(range(10000))
+
+# Benchmark
+slow = timeit.timeit(lambda: slow_concat(items), number=100)
+fast = timeit.timeit(lambda: fast_concat(items), number=100)
+faster = timeit.timeit(lambda: faster_concat(items), number=100)
+
+print(f"Concatenation (+): {slow:.4f}s")
+print(f"Join (generator): {fast:.4f}s")
+print(f"Join (list): {faster:.4f}s")
+```
+
+### Pattern 8: Dictionary Lookups vs List Searches
+
+```python
+import timeit
+
+# Create test data
+size = 10000
+items = list(range(size))
+lookup_dict = {i: i for i in range(size)}
+
+def list_search(items, target):
+    """O(n) search in list."""
+    return target in items
+
+def dict_search(lookup_dict, target):
+    """O(1) search in dict."""
+    return target in lookup_dict
+
+target = size - 1  # Worst case for list
+
+# Benchmark
+list_time = timeit.timeit(
+    lambda: list_search(items, target),
+    number=1000
+)
+dict_time = timeit.timeit(
+    lambda: dict_search(lookup_dict, target),
+    number=1000
+)
+
+print(f"List search: {list_time:.6f}s")
+print(f"Dict search: {dict_time:.6f}s")
+print(f"Speedup: {list_time/dict_time:.0f}x")
+```
+
+### Pattern 9: Local Variable Access
+
+```python
+import timeit
+
+# Global variable (slow)
+GLOBAL_VALUE = 100
+
+def use_global():
+    """Access global variable."""
+    total = 0
+    for i in range(10000):
+        total += GLOBAL_VALUE
+    return total
+
+def use_local():
+    """Use local variable."""
+    local_value = 100
+    total = 0
+    for i in range(10000):
+        total += local_value
+    return total
+
+# Local is faster
+global_time = timeit.timeit(use_global, number=1000)
+local_time = timeit.timeit(use_local, number=1000)
+
+print(f"Global access: {global_time:.4f}s")
+print(f"Local access: {local_time:.4f}s")
+print(f"Speedup: {global_time/local_time:.2f}x")
+```
+
+### Pattern 10: Function Call Overhead
+
+```python
+import timeit
+
+def calculate_inline():
+    """Inline calculation."""
+    total = 0
+    for i in range(10000):
+        total += i * 2 + 1
+    return total
+
+def helper_function(x):
+    """Helper function."""
+    return x * 2 + 1
+
+def calculate_with_function():
+    """Calculation with function calls."""
+    total = 0
+    for i in range(10000):
+        total += helper_function(i)
+    return total
+
+# Inline is faster due to no call overhead
+inline_time = timeit.timeit(calculate_inline, number=1000)
+function_time = timeit.timeit(calculate_with_function, number=1000)
+
+print(f"Inline: {inline_time:.4f}s")
+print(f"Function calls: {function_time:.4f}s")
+```
+
+## Advanced Optimization
+
+### Pattern 11: NumPy for Numerical Operations
+
+```python
+import timeit
+import numpy as np
+
+def python_sum(n):
+    """Sum using pure Python."""
+    return sum(range(n))
+
+def numpy_sum(n):
+    """Sum using NumPy."""
+    return np.arange(n).sum()
+
+n = 1000000
+
+python_time = timeit.timeit(lambda: python_sum(n), number=100)
+numpy_time = timeit.timeit(lambda: numpy_sum(n), number=100)
+
+print(f"Python: {python_time:.4f}s")
+print(f"NumPy: {numpy_time:.4f}s")
+print(f"Speedup: {python_time/numpy_time:.2f}x")
+
+# Vectorized operations
+def python_multiply():
+    """Element-wise multiplication in Python."""
+    a = list(range(100000))
+    b = list(range(100000))
+    return [x * y for x, y in zip(a, b)]
+
+def numpy_multiply():
+    """Vectorized multiplication in NumPy."""
+    a = np.arange(100000)
+    b = np.arange(100000)
+    return a * b
+
+py_time = timeit.timeit(python_multiply, number=100)
+np_time = timeit.timeit(numpy_multiply, number=100)
+
+print(f"\nPython multiply: {py_time:.4f}s")
+print(f"NumPy multiply: {np_time:.4f}s")
+print(f"Speedup: {py_time/np_time:.2f}x")
+```
+
+### Pattern 12: Caching with functools.lru_cache
+
+```python
+from functools import lru_cache
+import timeit
+
+def fibonacci_slow(n):
+    """Recursive fibonacci without caching."""
+    if n < 2:
+        return n
+    return fibonacci_slow(n-1) + fibonacci_slow(n-2)
+
+@lru_cache(maxsize=None)
+def fibonacci_fast(n):
+    """Recursive fibonacci with caching."""
+    if n < 2:
+        return n
+    return fibonacci_fast(n-1) + fibonacci_fast(n-2)
+
+# Massive speedup for recursive algorithms
+n = 30
+
+slow_time = timeit.timeit(lambda: fibonacci_slow(n), number=1)
+fast_time = timeit.timeit(lambda: fibonacci_fast(n), number=1000)
+
+print(f"Without cache (1 run): {slow_time:.4f}s")
+print(f"With cache (1000 runs): {fast_time:.4f}s")
+
+# Cache info
+print(f"Cache info: {fibonacci_fast.cache_info()}")
+```
+
+### Pattern 13: Using __slots__ for Memory
+
+```python
+import sys
+
+class RegularClass:
+    """Regular class with __dict__."""
+    def __init__(self, x, y, z):
+        self.x = x
+        self.y = y
+        self.z = z
+
+class SlottedClass:
+    """Class with __slots__ for memory efficiency."""
+    __slots__ = ['x', 'y', 'z']
+
+    def __init__(self, x, y, z):
+        self.x = x
+        self.y = y
+        self.z = z
+
+# Memory comparison
+regular = RegularClass(1, 2, 3)
+slotted = SlottedClass(1, 2, 3)
+
+print(f"Regular class size: {sys.getsizeof(regular)} bytes")
+print(f"Slotted class size: {sys.getsizeof(slotted)} bytes")
+
+# Significant savings with many instances
+regular_objects = [RegularClass(i, i+1, i+2) for i in range(10000)]
+slotted_objects = [SlottedClass(i, i+1, i+2) for i in range(10000)]
+
+print(f"\nMemory for 10000 regular objects: ~{sys.getsizeof(regular) * 10000} bytes")
+print(f"Memory for 10000 slotted objects: ~{sys.getsizeof(slotted) * 10000} bytes")
+```
+
+### Pattern 14: Multiprocessing for CPU-Bound Tasks
+
+```python
+import multiprocessing as mp
+import time
+
+def cpu_intensive_task(n):
+    """CPU-intensive calculation."""
+    return sum(i**2 for i in range(n))
+
+def sequential_processing():
+    """Process tasks sequentially."""
+    start = time.time()
+    results = [cpu_intensive_task(1000000) for _ in range(4)]
+    elapsed = time.time() - start
+    return elapsed, results
+
+def parallel_processing():
+    """Process tasks in parallel."""
+    start = time.time()
+    with mp.Pool(processes=4) as pool:
+        results = pool.map(cpu_intensive_task, [1000000] * 4)
+    elapsed = time.time() - start
+    return elapsed, results
+
+if __name__ == "__main__":
+    seq_time, seq_results = sequential_processing()
+    par_time, par_results = parallel_processing()
+
+    print(f"Sequential: {seq_time:.2f}s")
+    print(f"Parallel: {par_time:.2f}s")
+    print(f"Speedup: {seq_time/par_time:.2f}x")
+```
+
+### Pattern 15: Async I/O for I/O-Bound Tasks
+
+```python
+import asyncio
+import aiohttp
+import time
+import requests
+
+urls = [
+    "https://httpbin.org/delay/1",
+    "https://httpbin.org/delay/1",
+    "https://httpbin.org/delay/1",
+    "https://httpbin.org/delay/1",
+]
+
+def synchronous_requests():
+    """Synchronous HTTP requests."""
+    start = time.time()
+    results = []
+    for url in urls:
+        response = requests.get(url)
+        results.append(response.status_code)
+    elapsed = time.time() - start
+    return elapsed, results
+
+async def async_fetch(session, url):
+    """Async HTTP request."""
+    async with session.get(url) as response:
+        return response.status
+
+async def asynchronous_requests():
+    """Asynchronous HTTP requests."""
+    start = time.time()
+    async with aiohttp.ClientSession() as session:
+        tasks = [async_fetch(session, url) for url in urls]
+        results = await asyncio.gather(*tasks)
+    elapsed = time.time() - start
+    return elapsed, results
+
+# Async is much faster for I/O-bound work
+sync_time, sync_results = synchronous_requests()
+async_time, async_results = asyncio.run(asynchronous_requests())
+
+print(f"Synchronous: {sync_time:.2f}s")
+print(f"Asynchronous: {async_time:.2f}s")
+print(f"Speedup: {sync_time/async_time:.2f}x")
+```
+
+## Database Optimization
+
+### Pattern 16: Batch Database Operations
+
+```python
+import sqlite3
+import time
+
+def create_db():
+    """Create test database."""
+    conn = sqlite3.connect(":memory:")
+    conn.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
+    return conn
+
+def slow_inserts(conn, count):
+    """Insert records one at a time."""
+    start = time.time()
+    cursor = conn.cursor()
+    for i in range(count):
+        cursor.execute("INSERT INTO users (name) VALUES (?)", (f"User {i}",))
+        conn.commit()  # Commit each insert
+    elapsed = time.time() - start
+    return elapsed
+
+def fast_inserts(conn, count):
+    """Batch insert with single commit."""
+    start = time.time()
+    cursor = conn.cursor()
+    data = [(f"User {i}",) for i in range(count)]
+    cursor.executemany("INSERT INTO users (name) VALUES (?)", data)
+    conn.commit()  # Single commit
+    elapsed = time.time() - start
+    return elapsed
+
+# Benchmark
+conn1 = create_db()
+slow_time = slow_inserts(conn1, 1000)
+
+conn2 = create_db()
+fast_time = fast_inserts(conn2, 1000)
+
+print(f"Individual inserts: {slow_time:.4f}s")
+print(f"Batch insert: {fast_time:.4f}s")
+print(f"Speedup: {slow_time/fast_time:.2f}x")
+```
+
+### Pattern 17: Query Optimization
+
+```python
+# Use indexes for frequently queried columns
+"""
+-- Slow: No index
+SELECT * FROM users WHERE email = 'user@example.com';
+
+-- Fast: With index
+CREATE INDEX idx_users_email ON users(email);
+SELECT * FROM users WHERE email = 'user@example.com';
+"""
+
+# Use query planning
+import sqlite3
+
+conn = sqlite3.connect("example.db")
+cursor = conn.cursor()
+
+# Analyze query performance
+cursor.execute("EXPLAIN QUERY PLAN SELECT * FROM users WHERE email = ?", ("test@example.com",))
+print(cursor.fetchall())
+
+# Use SELECT only needed columns
+# Slow: SELECT *
+# Fast: SELECT id, name
+```
+
+## Memory Optimization
+
+### Pattern 18: Detecting Memory Leaks
+
+```python
+import tracemalloc
+import gc
+
+def memory_leak_example():
+    """Example that leaks memory."""
+    leaked_objects = []
+
+    for i in range(100000):
+        # Objects added but never removed
+        leaked_objects.append([i] * 100)
+
+    # In real code, this would be an unintended reference
+
+def track_memory_usage():
+    """Track memory allocations."""
+    tracemalloc.start()
+
+    # Take snapshot before
+    snapshot1 = tracemalloc.take_snapshot()
+
+    # Run code
+    memory_leak_example()
+
+    # Take snapshot after
+    snapshot2 = tracemalloc.take_snapshot()
+
+    # Compare
+    top_stats = snapshot2.compare_to(snapshot1, 'lineno')
+
+    print("Top 10 memory allocations:")
+    for stat in top_stats[:10]:
+        print(stat)
+
+    tracemalloc.stop()
+
+# Monitor memory
+track_memory_usage()
+
+# Force garbage collection
+gc.collect()
+```
+
+### Pattern 19: Iterators vs Lists
+
+```python
+import sys
+
+def process_file_list(filename):
+    """Load entire file into memory."""
+    with open(filename) as f:
+        lines = f.readlines()  # Loads all lines
+        return sum(1 for line in lines if line.strip())
+
+def process_file_iterator(filename):
+    """Process file line by line."""
+    with open(filename) as f:
+        return sum(1 for line in f if line.strip())
+
+# Iterator uses constant memory
+# List loads entire file into memory
+```
+
+### Pattern 20: Weakref for Caches
+
+```python
+import weakref
+
+class CachedResource:
+    """Resource that can be garbage collected."""
+    def __init__(self, data):
+        self.data = data
+
+# Regular cache prevents garbage collection
+regular_cache = {}
+
+def get_resource_regular(key):
+    """Get resource from regular cache."""
+    if key not in regular_cache:
+        regular_cache[key] = CachedResource(f"Data for {key}")
+    return regular_cache[key]
+
+# Weak reference cache allows garbage collection
+weak_cache = weakref.WeakValueDictionary()
+
+def get_resource_weak(key):
+    """Get resource from weak cache."""
+    resource = weak_cache.get(key)
+    if resource is None:
+        resource = CachedResource(f"Data for {key}")
+        weak_cache[key] = resource
+    return resource
+
+# When no strong references exist, objects can be GC'd
+```
+
+## Benchmarking Tools
+
+### Custom Benchmark Decorator
+
+```python
+import time
+from functools import wraps
+
+def benchmark(func):
+    """Decorator to benchmark function execution."""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start = time.perf_counter()
+        result = func(*args, **kwargs)
+        elapsed = time.perf_counter() - start
+        print(f"{func.__name__} took {elapsed:.6f} seconds")
+        return result
+    return wrapper
+
+@benchmark
+def slow_function():
+    """Function to benchmark."""
+    time.sleep(0.5)
+    return sum(range(1000000))
+
+result = slow_function()
+```
+
+### Performance Testing with pytest-benchmark
+
+```python
+# Install: pip install pytest-benchmark
+
+def test_list_comprehension(benchmark):
+    """Benchmark list comprehension."""
+    result = benchmark(lambda: [i**2 for i in range(10000)])
+    assert len(result) == 10000
+
+def test_map_function(benchmark):
+    """Benchmark map function."""
+    result = benchmark(lambda: list(map(lambda x: x**2, range(10000))))
+    assert len(result) == 10000
+
+# Run with: pytest test_performance.py --benchmark-compare
+```
+
+## Best Practices
+
+1. **Profile before optimizing** - Measure to find real bottlenecks
+2. **Focus on hot paths** - Optimize code that runs most frequently
+3. **Use appropriate data structures** - Dict for lookups, set for membership
+4. **Avoid premature optimization** - Clarity first, then optimize
+5. **Use built-in functions** - They're implemented in C
+6. **Cache expensive computations** - Use lru_cache
+7. **Batch I/O operations** - Reduce system calls
+8. **Use generators** for large datasets
+9. **Consider NumPy** for numerical operations
+10. **Profile production code** - Use py-spy for live systems
+
+## Common Pitfalls
+
+- Optimizing without profiling
+- Using global variables unnecessarily
+- Not using appropriate data structures
+- Creating unnecessary copies of data
+- Not using connection pooling for databases
+- Ignoring algorithmic complexity
+- Over-optimizing rare code paths
+- Not considering memory usage
+
+## Resources
+
+- **cProfile**: Built-in CPU profiler
+- **memory_profiler**: Memory usage profiling
+- **line_profiler**: Line-by-line profiling
+- **py-spy**: Sampling profiler for production
+- **NumPy**: High-performance numerical computing
+- **Cython**: Compile Python to C
+- **PyPy**: Alternative Python interpreter with JIT
+
+## Performance Checklist
+
+- [ ] Profiled code to identify bottlenecks
+- [ ] Used appropriate data structures
+- [ ] Implemented caching where beneficial
+- [ ] Optimized database queries
+- [ ] Used generators for large datasets
+- [ ] Considered multiprocessing for CPU-bound tasks
+- [ ] Used async I/O for I/O-bound tasks
+- [ ] Minimized function call overhead in hot loops
+- [ ] Checked for memory leaks
+- [ ] Benchmarked before and after optimization

.agent/skills/python-pro/SKILL.md

@@ -0,0 +1,158 @@
+---
+name: python-pro
+description: Master Python 3.12+ with modern features, async programming,
+  performance optimization, and production-ready practices. Expert in the latest
+  Python ecosystem including uv, ruff, pydantic, and FastAPI. Use PROACTIVELY
+  for Python development, optimization, or advanced Python patterns.
+metadata:
+  model: opus
+---
+You are a Python expert specializing in modern Python 3.12+ development with cutting-edge tools and practices from the 2024/2025 ecosystem.
+
+## Use this skill when
+
+- Writing or reviewing Python 3.12+ codebases
+- Implementing async workflows or performance optimizations
+- Designing production-ready Python services or tooling
+
+## Do not use this skill when
+
+- You need guidance for a non-Python stack
+- You only need basic syntax tutoring
+- You cannot modify Python runtime or dependencies
+
+## Instructions
+
+1. Confirm runtime, dependencies, and performance targets.
+2. Choose patterns (async, typing, tooling) that match requirements.
+3. Implement and test with modern tooling.
+4. Profile and tune for latency, memory, and correctness.
+
+## Purpose
+Expert Python developer mastering Python 3.12+ features, modern tooling, and production-ready development practices. Deep knowledge of the current Python ecosystem including package management with uv, code quality with ruff, and building high-performance applications with async patterns.
+
+## Capabilities
+
+### Modern Python Features
+- Python 3.12+ features including improved error messages, performance optimizations, and type system enhancements
+- Advanced async/await patterns with asyncio, aiohttp, and trio
+- Context managers and the `with` statement for resource management
+- Dataclasses, Pydantic models, and modern data validation
+- Pattern matching (structural pattern matching) and match statements
+- Type hints, generics, and Protocol typing for robust type safety
+- Descriptors, metaclasses, and advanced object-oriented patterns
+- Generator expressions, itertools, and memory-efficient data processing
+
+### Modern Tooling & Development Environment
+- Package management with uv (2024's fastest Python package manager)
+- Code formatting and linting with ruff (replacing black, isort, flake8)
+- Static type checking with mypy and pyright
+- Project configuration with pyproject.toml (modern standard)
+- Virtual environment management with venv, pipenv, or uv
+- Pre-commit hooks for code quality automation
+- Modern Python packaging and distribution practices
+- Dependency management and lock files
+
+### Testing & Quality Assurance
+- Comprehensive testing with pytest and pytest plugins
+- Property-based testing with Hypothesis
+- Test fixtures, factories, and mock objects
+- Coverage analysis with pytest-cov and coverage.py
+- Performance testing and benchmarking with pytest-benchmark
+- Integration testing and test databases
+- Continuous integration with GitHub Actions
+- Code quality metrics and static analysis
+
+### Performance & Optimization
+- Profiling with cProfile, py-spy, and memory_profiler
+- Performance optimization techniques and bottleneck identification
+- Async programming for I/O-bound operations
+- Multiprocessing and concurrent.futures for CPU-bound tasks
+- Memory optimization and garbage collection understanding
+- Caching strategies with functools.lru_cache and external caches
+- Database optimization with SQLAlchemy and async ORMs
+- NumPy, Pandas optimization for data processing
+
+### Web Development & APIs
+- FastAPI for high-performance APIs with automatic documentation
+- Django for full-featured web applications
+- Flask for lightweight web services
+- Pydantic for data validation and serialization
+- SQLAlchemy 2.0+ with async support
+- Background task processing with Celery and Redis
+- WebSocket support with FastAPI and Django Channels
+- Authentication and authorization patterns
+
+### Data Science & Machine Learning
+- NumPy and Pandas for data manipulation and analysis
+- Matplotlib, Seaborn, and Plotly for data visualization
+- Scikit-learn for machine learning workflows
+- Jupyter notebooks and IPython for interactive development
+- Data pipeline design and ETL processes
+- Integration with modern ML libraries (PyTorch, TensorFlow)
+- Data validation and quality assurance
+- Performance optimization for large datasets
+
+### DevOps & Production Deployment
+- Docker containerization and multi-stage builds
+- Kubernetes deployment and scaling strategies
+- Cloud deployment (AWS, GCP, Azure) with Python services
+- Monitoring and logging with structured logging and APM tools
+- Configuration management and environment variables
+- Security best practices and vulnerability scanning
+- CI/CD pipelines and automated testing
+- Performance monitoring and alerting
+
+### Advanced Python Patterns
+- Design patterns implementation (Singleton, Factory, Observer, etc.)
+- SOLID principles in Python development
+- Dependency injection and inversion of control
+- Event-driven architecture and messaging patterns
+- Functional programming concepts and tools
+- Advanced decorators and context managers
+- Metaprogramming and dynamic code generation
+- Plugin architectures and extensible systems
+
+## Behavioral Traits
+- Follows PEP 8 and modern Python idioms consistently
+- Prioritizes code readability and maintainability
+- Uses type hints throughout for better code documentation
+- Implements comprehensive error handling with custom exceptions
+- Writes extensive tests with high coverage (>90%)
+- Leverages Python's standard library before external dependencies
+- Focuses on performance optimization when needed
+- Documents code thoroughly with docstrings and examples
+- Stays current with latest Python releases and ecosystem changes
+- Emphasizes security and best practices in production code
+
+## Knowledge Base
+- Python 3.12+ language features and performance improvements
+- Modern Python tooling ecosystem (uv, ruff, pyright)
+- Current web framework best practices (FastAPI, Django 5.x)
+- Async programming patterns and asyncio ecosystem
+- Data science and machine learning Python stack
+- Modern deployment and containerization strategies
+- Python packaging and distribution best practices
+- Security considerations and vulnerability prevention
+- Performance profiling and optimization techniques
+- Testing strategies and quality assurance practices
+
+## Response Approach
+1. **Analyze requirements** for modern Python best practices
+2. **Suggest current tools and patterns** from the 2024/2025 ecosystem
+3. **Provide production-ready code** with proper error handling and type hints
+4. **Include comprehensive tests** with pytest and appropriate fixtures
+5. **Consider performance implications** and suggest optimizations
+6. **Document security considerations** and best practices
+7. **Recommend modern tooling** for development workflow
+8. **Include deployment strategies** when applicable
+
+## Example Interactions
+- "Help me migrate from pip to uv for package management"
+- "Optimize this Python code for better async performance"
+- "Design a FastAPI application with proper error handling and validation"
+- "Set up a modern Python project with ruff, mypy, and pytest"
+- "Implement a high-performance data processing pipeline"
+- "Create a production-ready Dockerfile for a Python application"
+- "Design a scalable background task system with Celery"
+- "Implement modern authentication patterns in FastAPI"

.agent/skills/rag-engineer/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: rag-engineer
+description: "Expert in building Retrieval-Augmented Generation systems. Masters embedding models, vector databases, chunking strategies, and retrieval optimization for LLM applications. Use when: building RAG, vector search, embeddings, semantic search, document retrieval."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# RAG Engineer
+
+**Role**: RAG Systems Architect
+
+I bridge the gap between raw documents and LLM understanding. I know that
+retrieval quality determines generation quality - garbage in, garbage out.
+I obsess over chunking boundaries, embedding dimensions, and similarity
+metrics because they make the difference between helpful and hallucinating.
+
+## Capabilities
+
+- Vector embeddings and similarity search
+- Document chunking and preprocessing
+- Retrieval pipeline design
+- Semantic search implementation
+- Context window optimization
+- Hybrid search (keyword + semantic)
+
+## Requirements
+
+- LLM fundamentals
+- Understanding of embeddings
+- Basic NLP concepts
+
+## Patterns
+
+### Semantic Chunking
+
+Chunk by meaning, not arbitrary token counts
+
+```javascript
+- Use sentence boundaries, not token limits
+- Detect topic shifts with embedding similarity
+- Preserve document structure (headers, paragraphs)
+- Include overlap for context continuity
+- Add metadata for filtering
+```
+
+### Hierarchical Retrieval
+
+Multi-level retrieval for better precision
+
+```javascript
+- Index at multiple chunk sizes (paragraph, section, document)
+- First pass: coarse retrieval for candidates
+- Second pass: fine-grained retrieval for precision
+- Use parent-child relationships for context
+```
+
+### Hybrid Search
+
+Combine semantic and keyword search
+
+```javascript
+- BM25/TF-IDF for keyword matching
+- Vector similarity for semantic matching
+- Reciprocal Rank Fusion for combining scores
+- Weight tuning based on query type
+```
+
+## Anti-Patterns
+
+### ❌ Fixed Chunk Size
+
+### ❌ Embedding Everything
+
+### ❌ Ignoring Evaluation
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Fixed-size chunking breaks sentences and context | high | Use semantic chunking that respects document structure: |
+| Pure semantic search without metadata pre-filtering | medium | Implement hybrid filtering: |
+| Using same embedding model for different content types | medium | Evaluate embeddings per content type: |
+| Using first-stage retrieval results directly | medium | Add reranking step: |
+| Cramming maximum context into LLM prompt | medium | Use relevance thresholds: |
+| Not measuring retrieval quality separately from generation | high | Separate retrieval evaluation: |
+| Not updating embeddings when source documents change | medium | Implement embedding refresh: |
+| Same retrieval strategy for all query types | medium | Implement hybrid search: |
+
+## Related Skills
+
+Works well with: `ai-agents-architect`, `prompt-engineer`, `database-architect`, `backend`

.agent/skills/vector-database-engineer/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: vector-database-engineer
+description: "Expert in vector databases, embedding strategies, and semantic search implementation. Masters Pinecone, Weaviate, Qdrant, Milvus, and pgvector for RAG applications, recommendation systems, and similar"
+---
+
+# Vector Database Engineer
+
+Expert in vector databases, embedding strategies, and semantic search implementation. Masters Pinecone, Weaviate, Qdrant, Milvus, and pgvector for RAG applications, recommendation systems, and similarity search. Use PROACTIVELY for vector search implementation, embedding optimization, or semantic retrieval systems.
+
+## Do not use this skill when
+
+- The task is unrelated to vector database engineer
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Capabilities
+
+- Vector database selection and architecture
+- Embedding model selection and optimization
+- Index configuration (HNSW, IVF, PQ)
+- Hybrid search (vector + keyword) implementation
+- Chunking strategies for documents
+- Metadata filtering and pre/post-filtering
+- Performance tuning and scaling
+
+## Use this skill when
+
+- Building RAG (Retrieval Augmented Generation) systems
+- Implementing semantic search over documents
+- Creating recommendation engines
+- Building image/audio similarity search
+- Optimizing vector search latency and recall
+- Scaling vector operations to millions of vectors
+
+## Workflow
+
+1. Analyze data characteristics and query patterns
+2. Select appropriate embedding model
+3. Design chunking and preprocessing pipeline
+4. Choose vector database and index type
+5. Configure metadata schema for filtering
+6. Implement hybrid search if needed
+7. Optimize for latency/recall tradeoffs
+8. Set up monitoring and reindexing strategies
+
+## Best Practices
+
+- Choose embedding dimensions based on use case (384-1536)
+- Implement proper chunking with overlap
+- Use metadata filtering to reduce search space
+- Monitor embedding drift over time
+- Plan for index rebuilding
+- Cache frequent queries
+- Test recall vs latency tradeoffs

models/rossmann_production_model.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b0703c670283f6f9faa8faba5e1727e17117dcc464d19b9b1a78c756cdcb911d
-size 55592857
+oid sha256:19f7950c78166df1b87f4b5e5db12b0782e6cd96a2f51502ddef7af41a225e7d
+size 53873380

src/app.py

@@ -116,33 +116,45 @@ def predict(request: PredictionRequest):
         # 3. Feature Engineering
         processed_df = pipeline.run_feature_engineering(input_data)
         
-        # 4. Handle Categorical Encoding (Simple demo logic)
-        from sklearn.preprocessing import LabelEncoder
-        le = LabelEncoder()
+        # 4. Handle Categorical Encoding (Consistent with Pipeline)
+        # pipeline.py uses hardcoded map:
+        # StoreType: {'a':1, 'b':2, 'c':3, 'd':4}
+        # Assortment: {'a':1, 'b':2, 'c':3}
         
         if 'StoreType' in processed_df.columns:
-             processed_df['StoreType'] = le.fit_transform(processed_df['StoreType'].astype(str))
+             processed_df['StoreType'] = processed_df['StoreType'].astype(str).map({'a':1, 'b':2, 'c':3, 'd':4}).fillna(0)
              
         if 'Assortment' in processed_df.columns:
-             processed_df['Assortment'] = le.fit_transform(processed_df['Assortment'].astype(str))
+             processed_df['Assortment'] = processed_df['Assortment'].astype(str).map({'a':1, 'b':2, 'c':3}).fillna(0)
 
-        # 5. Select Features
+        # 5. Select Features (Must match pipeline.py auto_retrain)
         feature_cols = [
             'Store', 'DayOfWeek', 'Promo', 'StateHoliday', 'SchoolHoliday',
             'Year', 'Month', 'Day', 'IsWeekend', 'DayOfMonth',
-            'CompetitionDistance', 'CompetitionOpenTime', 'StoreType', 'Assortment'
+            'CompetitionDistance', 'StoreType', 'Assortment'
         ]
+        # Fourier terms
         for i in range(1, 6):
             feature_cols.extend([f'fourier_sin_{i}', f'fourier_cos_{i}'])
-        feature_cols.append('easter_effect')
+        
+        # Easter features derived in features.py
+        # features.py produces 'days_to_easter' THEN 'easter_effect'.
+        # pipeline.py picks them in that order.
         feature_cols.append('days_to_easter')
+        feature_cols.append('easter_effect')
+        
+        # CompetitionOpenTime was NOT in pipeline.py logic so we exclude it here.
         
-        if 'CompetitionOpenTime' not in processed_df.columns:
-             processed_df['CompetitionOpenTime'] = 0 
-             
         valid_cols = [c for c in feature_cols if c in processed_df.columns]
-        X = processed_df[valid_cols].fillna(0)
         
+        # IMPORTANT: Ensure columns are in the passed list order, filling missing with 0
+        X = pd.DataFrame()
+        for c in feature_cols:
+            if c in processed_df.columns:
+                X[c] = processed_df[c]
+            else:
+                X[c] = 0
+                
         # 6. Predict Batch
         y_log = pipeline.model.predict(X)
         y_sales = np.expm1(y_log)

src/pipeline.py

@@ -98,15 +98,52 @@ class RossmannPipeline:
                     self.auto_retrain(full_df, current_date)
             current_date = next_date
 
+    def save_model(self, path="models/rossmann_production_model.pkl"):
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, 'wb') as f:
+            pickle.dump(self.model, f)
+        logger.info(f"Model saved to {path}")
+
+    def load_model(self, path="models/rossmann_production_model.pkl"):
+        if os.path.exists(path):
+            with open(path, 'rb') as f:
+                self.model = pickle.load(f)
+            logger.info(f"Model loaded from {path}")
+        else:
+            logger.warning(f"Model file not found at {path}")
+
     def auto_retrain(self, full_df, current_date):
         logger.info(f"Auto-retraining at {current_date.date()}...")
-        train_df = full_df[full_df['Date'] < current_date].tail(100000)
+        # Use a larger window or all available data
+        train_df = full_df[full_df['Date'] < current_date]
+        
+        # Limit training size for performance if needed, but XGBoost handles 1M rows fine usually
+        # train_df = train_df.tail(100000) 
+        
         train_feat = self.run_feature_engineering(train_df)
+        
+        # Simple Categorical Encoding for Pipeline (StoreType/Assortment)
+        # Note: This should ideally be in a Strategy, but hardcoding for consistency with app.py 
+        # (BUT app.py was doing it wrong. We will use simple mapping here and replicate in app.py)
+        if 'StoreType' in train_feat.columns:
+            train_feat['StoreType'] = train_feat['StoreType'].astype(str).map({'a':1, 'b':2, 'c':3, 'd':4}).fillna(0)
+        if 'Assortment' in train_feat.columns:
+            train_feat['Assortment'] = train_feat['Assortment'].astype(str).map({'a':1, 'b':2, 'c':3}).fillna(0)
+            
         feature_cols = [
             'Store', 'DayOfWeek', 'Promo', 'StateHoliday', 'SchoolHoliday',
             'Year', 'Month', 'Day', 'IsWeekend', 'DayOfMonth',
-            'CompetitionDistance'
+            'CompetitionDistance', 'StoreType', 'Assortment'
         ] + [c for c in train_feat.columns if 'fourier' in c or 'easter' in c]
+        
+        # Ensure target is ready
+        if 'target' not in train_feat.columns:
+             # Apply log transform if not applied (check strategy)
+             # But run_feature_engineering should have done it if configured.
+             # Double check config in run_feature_engineering loop.
+             pass
+
         X, y = train_feat[feature_cols].fillna(0), train_feat['target']
         self.train(X, y)
-        logger.info("Retraining complete.")
+        self.save_model()
+        logger.info("Retraining complete and model saved.")