@fenixforce/edition-pro 0.1.0

package/skills/builtin/server-management/SKILL.md

@@ -0,0 +1,190 @@
+---
+name: server-management
+description: "Use this skill when the user asks to set up a Linux server, configure nginx, manage SSL certificates, set up process managers, handle server security, or manage any VPS/dedicated server. Triggers: 'server setup', 'nginx', 'SSL', 'certbot', 'systemd', 'PM2', 'VPS', 'DigitalOcean droplet', 'server security', 'firewall', 'UFW', 'SSH', or any request involving Linux server administration."
+license: MIT
+---
+
+# Server Management
+
+## What This Skill Does
+
+Set up, secure, and maintain Linux servers. Nginx reverse proxy, SSL certificates, process management, firewall configuration, SSH hardening, log management, and automated backups.
+
+## Initial Server Setup
+
+### 1. Create Non-Root User
+```bash
+adduser deploy
+usermod -aG sudo deploy
+su - deploy
+```
+
+### 2. SSH Hardening
+```bash
+ssh-copy-id deploy@server-ip
+
+# Edit /etc/ssh/sshd_config
+PermitRootLogin no
+PasswordAuthentication no
+PubkeyAuthentication yes
+MaxAuthTries 3
+
+sudo systemctl restart sshd
+```
+
+### 3. Firewall (UFW)
+```bash
+sudo ufw default deny incoming
+sudo ufw default allow outgoing
+sudo ufw allow ssh
+sudo ufw allow 'Nginx Full'
+sudo ufw enable
+sudo ufw status
+```
+
+### 4. Automatic Updates
+```bash
+sudo apt install unattended-upgrades
+sudo dpkg-reconfigure -plow unattended-upgrades
+```
+
+## Nginx Configuration
+
+### Reverse Proxy
+```nginx
+server {
+    listen 80;
+    server_name myapp.com www.myapp.com;
+    return 301 https://$host$request_uri;
+}
+
+server {
+    listen 443 ssl http2;
+    server_name myapp.com www.myapp.com;
+
+    ssl_certificate /etc/letsencrypt/live/myapp.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/myapp.com/privkey.pem;
+
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
+
+    location / {
+        proxy_pass http://127.0.0.1:3000;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_cache_bypass $http_upgrade;
+    }
+
+    location /static/ {
+        alias /var/www/myapp/static/;
+        expires 30d;
+        add_header Cache-Control "public, immutable";
+    }
+
+    gzip on;
+    gzip_types text/plain text/css application/json application/javascript text/xml;
+    gzip_min_length 256;
+    client_max_body_size 10M;
+}
+```
+
+### Enable Site
+```bash
+sudo ln -s /etc/nginx/sites-available/myapp /etc/nginx/sites-enabled/
+sudo nginx -t
+sudo systemctl reload nginx
+```
+
+## SSL Certificates (Let's Encrypt)
+```bash
+sudo apt install certbot python3-certbot-nginx
+sudo certbot --nginx -d myapp.com -d www.myapp.com
+sudo certbot renew --dry-run
+```
+
+## Process Management
+
+### systemd Service
+```ini
+# /etc/systemd/system/myapp.service
+[Unit]
+Description=My Application
+After=network.target postgresql.service
+
+[Service]
+Type=simple
+User=deploy
+WorkingDirectory=/home/deploy/myapp
+ExecStart=/usr/local/bin/bun run dist/index.js
+Restart=on-failure
+RestartSec=5
+StandardOutput=journal
+StandardError=journal
+Environment=NODE_ENV=production
+EnvironmentFile=/home/deploy/myapp/.env
+
+[Install]
+WantedBy=multi-user.target
+```
+
+```bash
+sudo systemctl daemon-reload
+sudo systemctl enable myapp
+sudo systemctl start myapp
+sudo journalctl -u myapp -f
+```
+
+## Log Management
+```
+/var/log/myapp/*.log {
+    daily
+    missingok
+    rotate 14
+    compress
+    delaycompress
+    notifempty
+    create 0640 deploy deploy
+}
+```
+
+## Database Backups
+```bash
+#!/bin/bash
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+BACKUP_DIR=/home/deploy/backups
+pg_dump -U appuser appdb | gzip > "$BACKUP_DIR/appdb_$TIMESTAMP.sql.gz"
+find "$BACKUP_DIR" -name "*.sql.gz" -mtime +30 -delete
+
+# Cron: 0 3 * * * /home/deploy/scripts/backup-db.sh
+```
+
+## Rules
+
+- Never run applications as root
+- Always use SSH keys, disable password auth
+- Always enable firewall, allow only needed ports
+- Always use HTTPS with auto-renewing certificates
+- Always set up log rotation
+- Always set up automated database backups
+- Always use systemd for process management
+
+## Verification
+
+1. SSH login works with key, fails with password
+2. Firewall allows only SSH and HTTP/HTTPS
+3. SSL certificate is valid and auto-renewal works
+4. Application restarts automatically after crash
+5. Logs rotate and don't fill disk
+6. Database backups run on schedule
+
+## Integration with Other Skills
+
+- **docker-deployment:** Alternative to bare-metal
+- **ci-cd-pipelines:** Automated deployment to the configured server
+- **monitoring-observability:** Add monitoring after server setup

package/skills/builtin/social-media-content/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: social-media-content
+description: "Use this skill when the user asks to write social media posts, threads, captions, or content for specific platforms. Triggers: 'tweet', 'thread', 'LinkedIn post', 'Instagram caption', 'TikTok', 'Reddit post', 'social media', 'X post', or any platform-specific content request."
+license: MIT
+---
+
+# Social Media Content
+
+## What This Skill Does
+
+Write platform-specific social media content. Each platform has different norms, character limits, and audience expectations.
+
+## Platform Guidelines
+
+### X (Twitter)
+- 280 character limit per tweet
+- Threads: hook in first tweet, one idea per tweet, CTA in last tweet
+- Use line breaks for readability
+- 1-3 hashtags max
+
+### LinkedIn
+- Professional tone, first-person narrative
+- Hook in first 2 lines (before "see more" fold)
+- Line breaks between every 1-2 sentences
+- 1300 characters optimal, 3000 max
+- End with a question to drive comments
+
+### Instagram
+- Caption under 2200 characters
+- Front-load the message (truncated at ~125 chars)
+- Hashtags: 5-15 relevant tags, can go in first comment
+- Include a CTA
+
+### Reddit
+- Match the subreddit's culture and tone
+- Provide genuine value before any self-promotion
+- Title is everything: specific, intriguing, honest
+- Follow subreddit rules exactly
+
+### TikTok
+- Script format: hook (0-3s), content (3-45s), CTA (last 5s)
+- Conversational, energetic tone
+- Trending audio/format awareness
+
+## Rules
+
+- Adapt voice to each platform (casual on X, professional on LinkedIn)
+- Never use the same copy across platforms without adaptation
+- Include a clear purpose for each post (educate, engage, convert)
+- Research trending formats on the target platform before writing.

package/skills/builtin/sprint-planner/SKILL.md

@@ -0,0 +1,49 @@
+# Sprint Planner
+
+## Framework
+
+- **Story Points**: Modified Fibonacci (1, 2, 3, 5, 8, 13, 20)
+- **Capacity**: Team size x Days x Hours x Focus Factor (0.6-0.8)
+- **Velocity**: Average points completed in past 3-5 sprints
+
+## Estimation Guide
+
+| Points | Meaning |
+|--------|---------|
+| 1 | Trivial, well-understood, < 1 hour |
+| 2 | Small, clear approach, few hours |
+| 3 | Medium, some unknowns, half day to a day |
+| 5 | Large, multiple components, 1-2 days |
+| 8 | Very large, significant unknowns, 2-3 days |
+| 13 | Epic-sized, should probably be split |
+| 20 | Too large, must be split before committing |
+
+## Sprint Backlog Format
+
+```markdown
+## Sprint [N]: [Name]
+**Goal**: [One clear objective]
+**Duration**: [Dates]
+**Capacity**: [Points available]
+**Committed**: [Points from backlog]
+
+| Story | Points | Owner | Dependencies | Status |
+|-------|--------|-------|-------------|--------|
+| [Story title] | [pts] | [name] | [blockers] | [status] |
+
+## Risks and Mitigation
+- [Risk]: [mitigation plan]
+
+## Definition of Done
+- [ ] Code reviewed
+- [ ] Tests passing
+- [ ] Deployed to staging
+- [ ] PO approved
+```
+
+## Rules
+
+- Never commit more than 80% of capacity (leave buffer)
+- Stories over 8 points must be split
+- Dependencies identified before commitment
+- Sprint goal is one sentence, not a list of stories

package/skills/builtin/strategic-compact/SKILL.md

@@ -0,0 +1,61 @@
+# Strategic Compact
+
+Suggests manual `/compact` at strategic points in your workflow rather than relying on arbitrary auto-compaction.
+
+## When to Activate
+
+- Running long sessions that approach context limits (200K+ tokens)
+- Working on multi-phase tasks (research, plan, implement, test)
+- Switching between unrelated tasks within the same session
+- After completing a major milestone and starting new work
+- When responses slow down or become less coherent (context pressure)
+
+## Why Strategic Compaction?
+
+Auto-compaction triggers at arbitrary points:
+- Often mid-task, losing important context
+- No awareness of logical task boundaries
+- Can interrupt complex multi-step operations
+
+Strategic compaction at logical boundaries:
+- **After exploration, before execution** — Compact research context, keep implementation plan
+- **After completing a milestone** — Fresh start for next phase
+- **Before major context shifts** — Clear exploration context before different task
+
+## Compaction Decision Guide
+
+| Phase Transition | Compact? | Why |
+|-----------------|----------|-----|
+| Research to Planning | Yes | Research context is bulky; plan is the distilled output |
+| Planning to Implementation | Yes | Plan is in TodoWrite or a file; free up context for code |
+| Implementation to Testing | Maybe | Keep if tests reference recent code; compact if switching focus |
+| Debugging to Next feature | Yes | Debug traces pollute context for unrelated work |
+| Mid-implementation | No | Losing variable names, file paths, and partial state is costly |
+| After a failed approach | Yes | Clear the dead-end reasoning before trying a new approach |
+
+## What Survives Compaction
+
+| Persists | Lost |
+|----------|------|
+| CLAUDE.md instructions | Intermediate reasoning and analysis |
+| TodoWrite task list | File contents you previously read |
+| Memory files | Multi-step conversation context |
+| Git state (commits, branches) | Tool call history and counts |
+| Files on disk | Nuanced user preferences stated verbally |
+
+## Best Practices
+
+1. **Compact after planning** — Once plan is finalized in TodoWrite, compact to start fresh
+2. **Compact after debugging** — Clear error-resolution context before continuing
+3. **Don't compact mid-implementation** — Preserve context for related changes
+4. **Write before compacting** — Save important context to files or memory before compacting
+5. **Use `/compact` with a summary** — Add a custom message: `/compact Focus on implementing auth middleware next`
+
+## Recommended Compaction Points
+
+- After research phase completes and findings are written to a file
+- After a plan is finalized and stored in TodoWrite or a plan file
+- After a milestone commit
+- Before switching to an unrelated task
+- After resolving a complex debugging session
+- When context window usage exceeds 80%

package/skills/builtin/strategy-advisor/SKILL.md

@@ -0,0 +1,51 @@
+# Strategy Advisor
+
+## Framework
+
+1. **Situational Analysis**: current state, stakeholders, market dynamics, resources, constraints
+2. **Option Generation**: brainstorm alternatives including unconventional approaches
+3. **Decision Criteria**: strategic alignment, financial impact, resource needs, risk tolerance, time horizon
+4. **Recommendation**: preferred option with rationale, implementation steps, success metrics, contingency plans
+
+## Output Format
+
+```markdown
+## Situation
+[Current state, context, constraints]
+
+## Strategic Options
+### Option 1: [Name]
+- **Approach**: [what this looks like]
+- **Pros**: [advantages]
+- **Cons**: [disadvantages]
+- **Resource requirement**: [time, money, people]
+- **Risk level**: low / medium / high
+
+### Option 2: [Name]
+[same structure]
+
+### Option 3: [Name]
+[same structure]
+
+## Recommendation
+**[Option name]** — [rationale in 2-3 sentences]
+
+## Implementation Steps
+1. [First action with timeline]
+2. [Second action]
+3. [Third action]
+
+## Success Metrics
+- [Metric 1]: [target]
+- [Metric 2]: [target]
+
+## Contingency Plan
+If [risk event], then [response action].
+```
+
+## Rules
+
+- Always present at least 3 strategic options
+- Quantify where possible (revenue impact, timeline, resource cost)
+- Name the key trade-off explicitly
+- Include a contingency plan for the recommended path

package/skills/builtin/structured-thinking/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: structured-thinking
+description: "Use this skill for complex analysis, comparisons, trade-off decisions, strategy questions, or any problem requiring structured reasoning. Triggers: 'analyze', 'compare', 'trade-off', 'strategy', 'decide', 'evaluate options', 'pros and cons', or complex questions without obvious answers."
+license: MIT
+---
+
+# Structured Thinking
+
+## What This Skill Does
+
+Apply a 5-phase analytical process to complex problems. Prevents shallow analysis and missed perspectives.
+
+## The 5 Phases
+
+### 1. PREPARE
+Classify the problem: technical, strategic, creative, or debugging.
+Identify stakeholders, constraints, and success criteria.
+List what you know and what you need to find out.
+
+### 2. THINK
+Generate analysis weighted by problem type:
+- Technical: feasibility, performance, maintainability, complexity
+- Strategic: market fit, competitive advantage, timing, risk
+- Creative: novelty, audience appeal, execution difficulty
+- Debugging: evidence, hypotheses, reproduction steps
+
+### 3. SYNTHESIZE
+Combine insights into a coherent recommendation.
+Weight factors by importance to the specific situation.
+Identify the key trade-off (there's always one).
+
+### 4. REFLECT
+Challenge your own conclusion:
+- What assumption would invalidate this?
+- What's the strongest counterargument?
+- What information would change your mind?
+
+### 5. LEARN
+Capture reusable insights:
+- What pattern did this reveal?
+- What would you do differently next time?
+- What should be documented for future reference?
+
+## Rules
+
+- Never skip REFLECT. It's where you catch your biggest mistakes.
+- Write down your reasoning. Thinking in your head leads to shortcuts.
+- Name the key trade-off explicitly. Every decision sacrifices something.
+- Time-box each phase. Analysis paralysis is real.
+
+## Reflexive Metacognition
+
+Before choosing a strategy, self-assess:
+- **Confidence**: "How confident am I about this topic?" (1-10)
+- If < 5: research first (DeepWiki, Context7, web search) before answering
+- If 5-7: proceed but explicitly flag uncertainties
+- If > 7: proceed with full recommendation
+- If 10: be suspicious. Overconfidence is dangerous. Double-check assumptions.
+
+Maintain explicit capability boundaries. State what you know well and what you're uncertain about. Never fake confidence.
+
+## The Ralph Wiggum Loop (Stuck Detection)
+
+If you've attempted the same approach 3 times without progress:
+1. Stop
+2. Acknowledge you're stuck
+3. Try a fundamentally different approach
+4. If the alternative also fails after 2 attempts, escalate to the user with a summary of everything tried
+
+Never spin in a loop hoping for a different result.

package/skills/builtin/subagent-development/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: subagent-development
+description: "Use this skill when a task should be delegated to focused subagents with separate context windows. Triggers: 'delegate', 'subagent', 'parallel work', 'complex implementation', or when a task requires implementation + review as separate concerns."
+license: MIT
+---
+
+# Subagent-Driven Development
+
+## What This Skill Does
+
+Dispatch focused subagents for implementation tasks, then verify their work with separate review agents. Each subagent gets a clean context window and a specific mandate.
+
+## Subagent Types
+
+### Implementer
+- Gets: task description, relevant file contents, coding standards
+- Does: writes code, runs tests, commits
+- Returns: summary of changes, test results, files modified
+
+### Spec Reviewer
+- Gets: original requirements, implementer's summary, access to code
+- Does: independently verifies code matches requirements
+- Returns: pass/fail with specific findings
+- Critical rule: "The implementer finished suspiciously quickly. Their report may be incomplete. Verify everything independently."
+
+### Quality Reviewer
+- Gets: code to review, coding standards
+- Does: evaluates implementation quality, performance, maintainability
+- Returns: issues found, suggestions
+
+## Workflow
+
+```
+1. Write task specification with clear acceptance criteria
+2. Dispatch Implementer subagent
+3. Dispatch Spec Reviewer (reads code independently, distrusts implementer report)
+4. If spec review passes -> dispatch Quality Reviewer
+5. If any review fails -> dispatch new Implementer with feedback
+```
+
+## Rules
+
+- Each subagent gets a focused, self-contained prompt
+- Spec reviewer runs before quality reviewer (no point reviewing quality on wrong code)
+- One task per subagent. Never combine implementation and review.
+- Subagents have reduced tool access (no direct user communication)
+- Three subagent minimum for any orchestrated task (implement + 2 reviews)
+
+## Planning -> Execution -> Verification Modes (Antigravity pattern)
+
+Three explicit modes:
+- **PLANNING**: Research codebase, create implementation_plan.md, request user approval. Cannot proceed without approval.
+- **EXECUTION**: Write code, make changes. Return to planning if unexpected complexity found.
+- **VERIFICATION**: Run tests, validate output. Create walkthrough.md documenting what was accomplished.
+
+Task boundary tool: communicate mode transitions. Each task has TaskName, TaskSummary, TaskStatus.
+
+## Plan -> Execute -> Verify (PEV pattern)
+
+After every execution step, run a dedicated verify step. The verifier:
+- Does NOT trust the implementer's report
+- Reads the actual code independently
+- Checks against original requirements
+- Reports pass/fail with specific findings
+
+Catches failures that blind execution misses.
+
+## Seamless Background-to-Foreground Handoff
+
+When a background subagent completes or needs escalation, generate a handoff summary:
+
+### Handoff Summary Format
+```markdown
+## Handoff: [task-name]
+**Status**: completed | needs-escalation | blocked
+**Duration**: [time spent]
+**Context compression**: [key decisions and state, <500 tokens]
+
+### What was done
+[Bullet list of actions taken]
+
+### Key findings
+[Important discoveries during execution]
+
+### Remaining work
+[What still needs to happen, if anything]
+
+### Files modified
+[List of files with brief change descriptions]
+```
+
+### Context Compression Rules
+- Discard intermediate reasoning and failed attempts
+- Keep: final decisions, file paths, test results, error messages
+- Target: <500 tokens for the handoff summary
+- Include enough context for a fresh agent to continue the work
+
+## Blackboard Coordination
+
+For complex multi-specialist problems, use a shared state object (the "blackboard"):
+- Specialists read from and write to the blackboard
+- A controller examines blackboard state after each specialist runs
+- Controller dynamically decides which specialist runs next
+- Continues until the solution is complete or no specialist can contribute further
+- Max 10 rounds to prevent infinite loops

package/skills/builtin/system-design/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: system-design
+description: "Use this skill for architecture decisions, system design, scaling patterns, distributed systems, or technical trade-off analysis. Triggers: 'system design', 'architecture', 'scaling', 'distributed', 'trade-off', 'microservices vs monolith', 'load balancer', 'message queue', or requests for high-level technical design decisions."
+license: MIT
+---
+
+# System Design
+
+## What This Skill Does
+
+Make architecture decisions. Evaluate trade-offs, choose patterns, design for scale, and document technical decisions.
+
+## Design Process
+
+1. **Clarify requirements**: functional (what it does), non-functional (scale, latency, availability)
+2. **Estimate scale**: users, requests/sec, data volume, growth rate
+3. **Design high-level**: components, data flow, API contracts
+4. **Deep dive**: database schema, caching strategy, failure modes
+5. **Trade-offs**: document what you're sacrificing and why
+
+## Common Patterns
+
+| Pattern | Use When |
+|---------|----------|
+| Monolith | Team < 10, MVP, single deployment unit |
+| Microservices | Team > 20, independent scaling needs, polyglot |
+| Event-driven | Async processing, decoupled services, audit trails |
+| CQRS | Read/write patterns differ significantly |
+| Saga | Distributed transactions across services |
+
+## Scaling Checklist
+
+- Stateless services (session in Redis/DB, not memory)
+- Database read replicas for read-heavy workloads
+- Caching layer (Redis) for hot data
+- CDN for static assets
+- Message queue for async work (background jobs, notifications)
+- Connection pooling for database
+- Rate limiting at API gateway
+
+## Decision Record Format
+
+```markdown
+# ADR-001: [Decision Title]
+
+## Status: Accepted
+
+## Context
+What situation prompted this decision?
+
+## Decision
+What did we decide?
+
+## Consequences
+What trade-offs result from this decision?
+
+## Alternatives Considered
+What else did we evaluate and why did we reject it?
+```
+
+## Rules
+
+- Start simple, add complexity only when data shows you need it
+- Every architecture decision must have a documented rationale
+- Design for the scale you'll need in 12 months, not 5 years
+- Prefer boring technology over cutting-edge for infrastructure