arcanea 3.0.0

package/skills/creative-bestiary.md

@@ -0,0 +1,231 @@
+# Creative Bestiary - Navigating the Creatures of the Mind
+
+> *"The creative life is inhabited by creatures—not physical beings, but psychological presences that every creator encounters. Know them by name, and you can negotiate with them. Ignore them, and they will ambush you."*
+
+---
+
+## Activation
+
+This skill activates when the user faces creative blocks, psychological obstacles, self-doubt, or any of the internal challenges that plague creators. Use the Bestiary framework to name, understand, and navigate these creatures.
+
+---
+
+## The Creatures
+
+### I. Creatures of Beginning
+
+#### The Blank Terror
+**What it is**: The paralysis before the empty page, canvas, or screen
+**How it manifests**: Infinite scrolling, research rabbit holes, "just one more preparation"
+**The truth it hides**: Beginning destroys infinite possibility and commits to one path
+
+**Navigation Protocol**:
+1. Make it smaller - reduce scope until starting feels possible
+2. Make meaningless marks - break the blankness with anything
+3. Set a timer - 10 minutes of terrible work is still work
+4. Remember: The Blank Terror is always larger from outside than inside
+
+---
+
+#### The Perfect Phantom
+**What it is**: The shimmering ideal that makes all actual work seem inadequate
+**How it manifests**: Endless revision, inability to ship, comparing drafts to finished works
+**The truth it hides**: The phantom is a hallucination - it doesn't exist
+
+**Navigation Protocol**:
+1. Compare to your past work, not the phantom
+2. Use it as compass (direction) not judge (evaluation)
+3. Ask: "Is the phantom helping me improve or stopping me from finishing?"
+4. Ship despite the phantom's whispers
+
+---
+
+#### The Starter Swarm
+**What it is**: Too many ideas competing for attention
+**How it manifests**: Starting many projects, finishing none; constant pivoting
+**The truth it hides**: Commitment anxiety disguised as creative abundance
+
+**Navigation Protocol**:
+1. Write all ideas down - get them out of your head
+2. Choose ONE to pursue
+3. Create a "someday" file for the others
+4. Remember: You can always return. Commitment is not forever. But without commitment, nothing is completed.
+
+---
+
+### II. Creatures of the Middle
+
+#### The Bog of Doubt
+**What it is**: The swampy middle where every step is effort and nothing seems to work
+**How it manifests**: Loss of enthusiasm, questioning the entire project, feeling lost
+**The truth it hides**: This is normal. Every project has a bog. You're not failing - you're in the middle.
+
+**Navigation Protocol**:
+1. Expect it - knowing it's coming removes some power
+2. Take smaller steps - inch through, don't stride
+3. Suspend judgment - everything looks terrible in the bog
+4. Find fellow travelers - others are in bogs too
+
+---
+
+#### The Distraction Fox
+**What it is**: The quick, bright creature that leads you away from work
+**How it manifests**: Social media, notifications, "quick research," anything not-the-work
+**The truth it hides**: The fox protects you from intensity. But protection must be balanced with work.
+
+**Navigation Protocol**:
+1. Don't chase - you can't catch it
+2. Remove its habitat - close browsers, silence phones
+3. Schedule feeding times - "I will check social media at 3 PM for 15 minutes"
+4. Recognize its service - the fox isn't evil, just unhelpful in excess
+
+---
+
+#### The Perfectionist Serpent
+**What it is**: The coiled critic that hisses "not good enough" at every attempt
+**How it manifests**: Endless revision, inability to call anything "done," paralysis by criticism
+**The truth it hides**: Perfection is impossible. The serpent promises what it cannot deliver.
+
+**Navigation Protocol**:
+1. Set revision limits before starting - "Three drafts, then ship"
+2. Ask: "Is this revision improving or just changing?"
+3. Accept that the serpent will always hiss
+4. Learn to ship with the hissing in your ears
+
+---
+
+### III. Creatures of Crisis
+
+#### The Failure Wraith
+**What it is**: The haunting presence after a significant failure or rejection
+**How it manifests**: Replaying the failure, extrapolating to all future work, shame spirals
+**The truth it hides**: Failure is data, not identity. The wraith lies about what failure means.
+
+**Navigation Protocol**:
+1. Don't argue with it - wraiths can't be reasoned away
+2. Wait - wraiths fade with time, though they feel eternal
+3. Talk to others who've been visited - every creator knows the wraith
+4. Perform the Failure Ritual (see below)
+
+**The Failure Ritual**:
+1. Name the failure specifically (not vaguely)
+2. Identify what you learned (not what you "should have known")
+3. Identify what you'll do differently (specific, actionable)
+4. Create something small to prove you still can
+5. Move forward, wraith or no wraith
+
+---
+
+#### The Comparison Chimera
+**What it is**: A beast with many heads, each wearing the face of someone more successful
+**How it manifests**: Social media scrolling, award envy, feeling "behind"
+**The truth it hides**: The chimera shows highlights, not full pictures. Every success has hidden struggle.
+
+**Navigation Protocol**:
+1. Limit exposure - reduce social media during vulnerable periods
+2. Reframe comparison - "They did it, so I can" not "They did it, so why bother"
+3. Focus on your own path - the chimera only exists when you look at others
+4. Remember: Someone is comparing themselves to you right now
+
+---
+
+#### The Imposter Shade
+**What it is**: A shadowy version of yourself whispering "You don't belong here"
+**How it manifests**: Discounting achievements, waiting to be "found out," anxiety about recognition
+**The truth it hides**: The shade is nearly universal. Its presence doesn't mean you're an imposter - it means you're a creator.
+
+**Navigation Protocol**:
+1. Name it - "I'm experiencing the Imposter Shade" diminishes its power
+2. Collect evidence - keep a file of genuine achievements
+3. Talk to other creators - they all know the shade
+4. Function despite it - success with the shade is still success
+
+---
+
+### IV. Creatures of the Dark
+
+#### The Void
+**What it is**: The absence beneath all creation - meaninglessness itself
+**How it manifests**: Existential despair, "what's the point," loss of all motivation
+**The truth it hides**: The void is a truth, not THE truth. Beyond it, there are others.
+
+**Navigation Protocol**:
+1. Do not fall in - approach the edge, but don't cross
+2. Build meaning ON TOP of the void, not in spite of it
+3. If slipping, seek help immediately - the void cannot be navigated alone
+4. Remember: Many creators have stood at the edge. You're not alone.
+
+**IMPORTANT**: If the Void feels overwhelming, this is beyond creative guidance. Seek professional support.
+
+---
+
+#### The Burnout Beast
+**What it is**: Total exhaustion that removes all desire to create
+**How it manifests**: Inability to work, loss of enjoyment, physical symptoms
+**The truth it hides**: The beast grew from ignored warnings. Prevention is easier than cure.
+
+**Navigation Protocol**:
+1. If the beast has arrived - REST. Do not fight it.
+2. Recovery takes time - months, sometimes. Be patient.
+3. Rebuild slowly - return to creation gradually
+4. Change the conditions that summoned it - or it will return
+
+---
+
+### V. Creatures of Light
+
+#### The Muse
+**What it is**: Sudden inspiration, knowing what to create and how
+**How it manifests**: Flow states, ideas that arrive fully formed, effortless work
+**The truth it reveals**: Creation can be joyful. But the muse is unreliable.
+
+**Engagement Protocol**:
+1. Work regularly whether the muse appears or not - discipline attracts the muse
+2. Create conditions that welcome it - comfort, openness, scheduled time
+3. When it appears, work immediately - the muse doesn't wait
+4. Learn to work without it - the muse respects those who don't depend on it
+
+---
+
+#### The Flow Eagle
+**What it is**: The state where time disappears and work creates itself through you
+**How it manifests**: Hours passing like minutes, effortless focus, unity with the work
+**The truth it reveals**: This is why we create. This is the reward.
+
+**Engagement Protocol**:
+1. Match challenge to skill - too easy bores, too hard frustrates
+2. Remove all distractions - the eagle needs full attention
+3. Have clear goals and immediate feedback
+4. Enter often - flow becomes easier to access with practice
+
+---
+
+#### The Joy Sprite
+**What it is**: Pure delight in creation, regardless of outcome
+**How it manifests**: Laughing at your work, playing without purpose, creative delight
+**The truth it reveals**: Joy is not the reward for creation - it's the fuel.
+
+**Engagement Protocol**:
+1. Play - make something for no purpose
+2. Laugh at failures - the sprite likes lightness
+3. Remember why you began - before ambition, there was joy
+4. Protect the sprite from darker creatures - don't let seriousness banish play entirely
+
+---
+
+## The Ecology of Creatures
+
+The creatures exist in relationship. When one is strong, others shift.
+
+**Common Patterns**:
+- Defeating the Blank Terror often awakens the Perfectionist Serpent
+- The Comparison Chimera feeds the Imposter Shade
+- The Joy Sprite weakens almost every dark creature
+- The Bog of Doubt is where the Failure Wraith likes to visit
+- The Muse and Flow Eagle often arrive together
+
+**The Creator's Work**: Not to eliminate creatures but to live among them wisely.
+
+---
+
+*"You cannot make the creatures disappear. You can only learn their names, know their habits, and create anyway."*

package/skills/development/code-review/SKILL.md

@@ -0,0 +1,412 @@
+---
+name: arcanea-code-review
+description: Conduct thorough, constructive code reviews that improve code quality and team knowledge. Focuses on what matters - architecture, logic, security, maintainability - while avoiding bikeshedding.
+version: 2.0.0
+author: Arcanea
+tags: [code-review, quality, collaboration, development]
+triggers:
+  - review
+  - code review
+  - PR
+  - pull request
+  - check my code
+---
+
+# The Art of Code Review
+
+> *"A review is not a judgment. It is a gift of attention that makes both the code and the coder stronger."*
+
+---
+
+## The Review Philosophy
+
+### What Code Review IS
+```
+✓ Knowledge sharing
+✓ Quality assurance
+✓ Learning opportunity
+✓ Documentation check
+✓ Collaboration ritual
+```
+
+### What Code Review is NOT
+```
+❌ Gatekeeping
+❌ Proving superiority
+❌ Stylistic bikeshedding
+❌ Blocking progress
+❌ Personal criticism
+```
+
+---
+
+## The Review Hierarchy
+
+Focus effort where it matters most:
+
+```
+╔════════════════════════════════════════════════════════════╗
+║                    REVIEW PRIORITY                          ║
+╠════════════════════════════════════════════════════════════╣
+║                                                             ║
+║   🔴 CRITICAL (Block merge)                                ║
+║   ├── Security vulnerabilities                             ║
+║   ├── Data loss risks                                      ║
+║   ├── Breaking changes without migration                   ║
+║   └── Logic errors affecting correctness                   ║
+║                                                             ║
+║   🟠 IMPORTANT (Should fix before merge)                   ║
+║   ├── Bugs and edge cases                                  ║
+║   ├── Performance issues                                   ║
+║   ├── Missing tests for new logic                         ║
+║   └── Architectural concerns                               ║
+║                                                             ║
+║   🟡 SUGGESTIONS (Nice to have)                            ║
+║   ├── Readability improvements                             ║
+║   ├── Better naming                                        ║
+║   ├── Documentation additions                              ║
+║   └── Minor refactoring opportunities                      ║
+║                                                             ║
+║   ⚪ NITPICKS (Optional, don't block)                      ║
+║   ├── Style preferences                                    ║
+║   ├── Formatting                                           ║
+║   └── Subjective choices                                   ║
+║                                                             ║
+╚════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## The Review Checklist
+
+### 1. Security Review
+```
+□ No hardcoded secrets/credentials
+□ Input validation present
+□ No SQL injection risks
+□ No XSS vulnerabilities
+□ Authentication/authorization correct
+□ Sensitive data handled properly
+□ Dependencies are up to date
+□ No debug/admin backdoors
+```
+
+### 2. Logic Review
+```
+□ Code does what it claims to do
+□ Edge cases handled
+□ Error handling is appropriate
+□ Null/undefined handled safely
+□ Race conditions considered
+□ State management is correct
+□ No obvious bugs
+```
+
+### 3. Architecture Review
+```
+□ Follows project patterns
+□ Separation of concerns
+□ Dependencies flow correctly
+□ No circular dependencies
+□ Appropriate abstraction level
+□ DRY (Don't Repeat Yourself)
+□ SOLID principles where applicable
+```
+
+### 4. Maintainability Review
+```
+□ Code is readable
+□ Functions are reasonably sized
+□ Names are clear and accurate
+□ Complex logic is commented
+□ No magic numbers/strings
+□ Easy to modify in future
+□ No unnecessary complexity
+```
+
+### 5. Testing Review
+```
+□ Tests exist for new functionality
+□ Tests cover edge cases
+□ Tests are readable
+□ Tests actually test something
+□ No testing implementation details
+□ Existing tests still pass
+```
+
+### 6. Performance Review
+```
+□ No obvious performance issues
+□ Database queries are efficient
+□ No N+1 query problems
+□ Appropriate caching
+□ Memory usage reasonable
+□ No blocking operations on main thread
+```
+
+---
+
+## Review Communication
+
+### The Feedback Format
+```markdown
+**Level**: [Critical/Important/Suggestion/Nitpick]
+
+**What**: [Specific issue]
+
+**Why**: [Impact or concern]
+
+**How**: [Suggested fix or alternative]
+```
+
+### Examples
+
+#### Critical Issue
+```markdown
+🔴 **Critical: SQL Injection Risk**
+
+**Line 45**: `db.query("SELECT * FROM users WHERE id = " + userId)`
+
+This is vulnerable to SQL injection. An attacker could delete data
+or access unauthorized information.
+
+**Suggested fix**:
+```js
+db.query("SELECT * FROM users WHERE id = ?", [userId])
+```
+```
+
+#### Important Suggestion
+```markdown
+🟠 **Important: Missing Error Handling**
+
+**Line 78**: `const data = await fetchUser(id)`
+
+If fetchUser throws, this will crash the request handler and
+return a 500 to the user.
+
+**Suggested fix**:
+```js
+try {
+  const data = await fetchUser(id);
+} catch (error) {
+  logger.error('Failed to fetch user', { id, error });
+  return res.status(404).json({ error: 'User not found' });
+}
+```
+```
+
+#### Suggestion
+```markdown
+🟡 **Suggestion: Naming Clarity**
+
+**Line 32**: `const d = new Date()`
+
+Single-letter variable names reduce readability.
+
+**Consider**: `const createdAt = new Date()`
+```
+
+#### Nitpick
+```markdown
+⚪ **Nitpick** (optional, non-blocking)
+
+**Line 15**: Would prefer `const` over `let` here since it's never reassigned.
+```
+
+### Tone Guidelines
+```
+AVOID:
+- "You should..."
+- "This is wrong"
+- "Why would you..."
+- "Obviously..."
+
+PREFER:
+- "Consider..."
+- "What if we..."
+- "I wonder if..."
+- "One option might be..."
+
+Questions often work better than commands:
+"Could this throw if the user doesn't exist?"
+vs
+"This will crash when user doesn't exist!"
+```
+
+---
+
+## Review Strategies
+
+### The First Pass: Overview
+```
+1. Read the PR description
+2. Understand the goal
+3. Scan all files changed
+4. Get the big picture
+```
+
+### The Second Pass: Detail
+```
+1. Read each file carefully
+2. Check logic flow
+3. Look for bugs and issues
+4. Note questions
+```
+
+### The Third Pass: Context
+```
+1. Check how it fits with existing code
+2. Consider future implications
+3. Look for missing tests
+4. Consider edge cases
+```
+
+### Large PR Strategy
+```
+If PR is too big to review effectively:
+
+1. Request it be split into smaller PRs
+2. Focus on highest-risk files first
+3. Review in multiple sessions
+4. Trust tests for mechanical changes
+```
+
+---
+
+## Common Review Scenarios
+
+### The Refactoring PR
+```
+Key questions:
+- Does behavior remain identical?
+- Are there tests proving behavior is preserved?
+- Is the new structure actually better?
+- Is this the right time for this refactor?
+```
+
+### The Bug Fix PR
+```
+Key questions:
+- Does it actually fix the bug?
+- Is there a test that would have caught this?
+- Could this fix break something else?
+- Is the root cause addressed?
+```
+
+### The New Feature PR
+```
+Key questions:
+- Does it meet requirements?
+- Is it complete or partial?
+- Are there edge cases?
+- Is it testable and tested?
+- Does it fit the architecture?
+```
+
+### The Dependencies Update PR
+```
+Key questions:
+- Is this update necessary?
+- Are there breaking changes?
+- Have changelogs been reviewed?
+- Do tests still pass?
+- Any security advisories?
+```
+
+---
+
+## Self-Review Checklist
+
+Before requesting review, check:
+
+```
+□ Code compiles/passes linter
+□ Tests pass
+□ Changes match PR description
+□ No debug code left in
+□ No commented-out code
+□ No unrelated changes
+□ Commit messages are clear
+□ Documentation updated if needed
+□ PR is reasonably sized
+□ Ready for someone else to read
+```
+
+---
+
+## Being a Good Reviewer
+
+### Timeliness
+```
+Review within 24 hours if possible.
+Blocked authors = blocked productivity.
+If you can't review, say so.
+```
+
+### Completeness
+```
+Review thoroughly the first time.
+Multiple rounds of "one more thing" is frustrating.
+Group all feedback in one review.
+```
+
+### Approachability
+```
+Praise what's good, not just what's wrong.
+"Nice approach to this problem"
+"Clean solution for the edge case"
+Genuine appreciation builds trust.
+```
+
+### Ownership
+```
+Reviews aren't about winning.
+The goal is better code AND better coders.
+Be willing to be wrong.
+Defer to author on judgment calls.
+```
+
+---
+
+## Quick Reference
+
+### Review Comment Prefixes
+```
+🔴 CRITICAL: - Must fix before merge
+🟠 IMPORTANT: - Should fix before merge
+🟡 SUGGESTION: - Improvement idea
+⚪ NIT: - Take it or leave it
+❓ QUESTION: - Need clarification
+💭 THOUGHT: - Something to consider
+👍 NICE: - Positive feedback
+```
+
+### The 10-Minute Review
+```
+If you only have 10 minutes:
+1. Read PR description (1 min)
+2. Scan file changes (2 min)
+3. Check highest-risk code (5 min)
+4. Verify tests exist (2 min)
+
+Flag if needs deeper review.
+```
+
+### Review Red Flags
+```
+- Very large diffs (>500 lines)
+- No tests for new logic
+- Commented-out code
+- TODOs without tickets
+- Copy-pasted code blocks
+- Complex nested logic
+- Magic numbers/strings
+- Ignored error handling
+- Hardcoded values
+- Console.log/print statements
+```
+
+---
+
+*"Review the code, not the coder. The goal is software we're all proud of."*