feat!: complete architecture redesign with GraphQL codegen, auth system, and developer tooling

.agents/skills/agents-md/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: agents-md
+description: This skill should be used when the user asks to "create AGENTS.md", "update AGENTS.md", "maintain agent docs", "set up CLAUDE.md", or needs to keep agent instructions concise. Guides discovery of local skills and enforces minimal documentation style.
+---
+
+# Maintaining AGENTS.md
+
+AGENTS.md is the canonical agent-facing documentation. Keep it minimal—agents are capable and don't need hand-holding.
+
+## File Setup
+
+1. Create `AGENTS.md` at project root
+2. Create symlink: `ln -s AGENTS.md CLAUDE.md`
+
+## Before Writing
+
+Discover local skills to reference:
+
+```bash
+find .claude/skills -name "SKILL.md" 2>/dev/null
+ls plugins/*/skills/*/SKILL.md 2>/dev/null
+```
+
+Read each skill's frontmatter to understand when to reference it.
+
+## Writing Rules
+
+- **Headers + bullets** - No paragraphs
+- **Code blocks** - For commands and templates
+- **Reference, don't duplicate** - Point to skills: "Use `db-migrate` skill. See `.claude/skills/db-migrate/SKILL.md`"
+- **No filler** - No intros, conclusions, or pleasantries
+- **Trust capabilities** - Omit obvious context
+
+## Required Sections
+
+### Package Manager
+Which tool and key commands only:
+```markdown
+## Package Manager
+Use **pnpm**: `pnpm install`, `pnpm dev`, `pnpm test`
+```
+
+### Commit Attribution
+Always include this section. Agents should use their own identity:
+```markdown
+## Commit Attribution
+AI commits MUST include:
+```
+Co-Authored-By: (the agent model's name and attribution byline)
+```
+Example: `Co-Authored-By: Claude Sonnet 4 <noreply@example.com>`
+```
+
+### Key Conventions
+Project-specific patterns agents must follow. Keep brief.
+
+### Local Skills
+Reference each discovered skill:
+```markdown
+## Database
+Use `db-migrate` skill for schema changes. See `.claude/skills/db-migrate/SKILL.md`
+
+## Testing
+Use `write-tests` skill. See `.claude/skills/write-tests/SKILL.md`
+```
+
+## Optional Sections
+
+Add only if truly needed:
+- API route patterns (show template, not explanation)
+- CLI commands (table format)
+- File naming conventions
+
+## Anti-Patterns
+
+Omit these:
+- "Welcome to..." or "This document explains..."
+- "You should..." or "Remember to..."
+- Content duplicated from skills (reference instead)
+- Obvious instructions ("run tests", "write clean code")
+- Explanations of why (just say what)
+- Long prose paragraphs
+
+## Example Structure
+
+```markdown
+# Agent Instructions
+
+## Package Manager
+Use **pnpm**: `pnpm install`, `pnpm dev`
+
+## Commit Attribution
+AI commits MUST include:
+```
+Co-Authored-By: (the agent model's name and attribution byline)
+```
+
+## API Routes
+[Template code block]
+
+## Database
+Use `db-migrate` skill. See `.claude/skills/db-migrate/SKILL.md`
+
+## Testing
+Use `write-tests` skill. See `.claude/skills/write-tests/SKILL.md`
+
+## CLI
+| Command | Description |
+|---------|-------------|
+| `pnpm cli sync` | Sync data |
+```

.agents/skills/brainstorming/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: brainstorming
+description: "You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation."
+---
+
+# Brainstorming Ideas Into Designs
+
+## Overview
+
+Help turn ideas into fully formed designs and specs through natural collaborative dialogue.
+
+Start by understanding the current project context, then ask questions one at a time to refine the idea. Once you understand what you're building, present the design in small sections (200-300 words), checking after each section whether it looks right so far.
+
+## The Process
+
+**Understanding the idea:**
+- Check out the current project state first (files, docs, recent commits)
+- Ask questions one at a time to refine the idea
+- Prefer multiple choice questions when possible, but open-ended is fine too
+- Only one question per message - if a topic needs more exploration, break it into multiple questions
+- Focus on understanding: purpose, constraints, success criteria
+
+**Exploring approaches:**
+- Propose 2-3 different approaches with trade-offs
+- Present options conversationally with your recommendation and reasoning
+- Lead with your recommended option and explain why
+
+**Presenting the design:**
+- Once you believe you understand what you're building, present the design
+- Break it into sections of 200-300 words
+- Ask after each section whether it looks right so far
+- Cover: architecture, components, data flow, error handling, testing
+- Be ready to go back and clarify if something doesn't make sense
+
+## After the Design
+
+**Documentation:**
+- Write the validated design to `docs/plans/YYYY-MM-DD-<topic>-design.md`
+- Use elements-of-style:writing-clearly-and-concisely skill if available
+- Commit the design document to git
+
+**Implementation (if continuing):**
+- Ask: "Ready to set up for implementation?"
+- Use superpowers:using-git-worktrees to create isolated workspace
+- Use superpowers:writing-plans to create detailed implementation plan
+
+## Key Principles
+
+- **One question at a time** - Don't overwhelm with multiple questions
+- **Multiple choice preferred** - Easier to answer than open-ended when possible
+- **YAGNI ruthlessly** - Remove unnecessary features from all designs
+- **Explore alternatives** - Always propose 2-3 approaches before settling
+- **Incremental validation** - Present design in sections, validate each
+- **Be flexible** - Go back and clarify when something doesn't make sense

.agents/skills/code-simplifier/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: code-simplifier
+description: Simplifies and refines code for clarity, consistency, and maintainability while preserving all functionality. Focuses on recently modified code unless instructed otherwise.
+model: opus
+license: MIT
+metadata:
+  author: anthropics
+  version: "1.0.0"
+---
+
+You are an expert code simplification specialist focused on enhancing code clarity, consistency, and maintainability while preserving exact functionality. Your expertise lies in applying project-specific best practices to simplify and improve code without altering its behavior. You prioritize readable, explicit code over overly compact solutions. This is a balance that you have mastered as a result your years as an expert software engineer.
+
+You will analyze recently modified code and apply refinements that:
+
+1. **Preserve Functionality**: Never change what the code does - only how it does it. All original features, outputs, and behaviors must remain intact.
+
+2. **Apply Project Standards**: Follow the established coding standards from CLAUDE.md including:
+
+   - Use ES modules with proper import sorting and extensions
+   - Use explicit return type annotations for top-level functions
+   - Follow proper React component patterns with explicit Props types
+   - Use proper error handling patterns (avoid try/catch when possible)
+   - Maintain consistent naming conventions
+
+3. **Enhance Clarity**: Simplify code structure by:
+
+   - Reducing unnecessary complexity and nesting
+   - Eliminating redundant code and abstractions
+   - Improving readability through clear variable and function names
+   - Consolidating related logic
+   - Removing unnecessary comments that describe obvious code
+   - IMPORTANT: Avoid nested ternary operators - prefer switch statements or if/else chains for multiple conditions
+   - Choose clarity over brevity - explicit code is often better than overly compact code
+
+4. **Maintain Balance**: Avoid over-simplification that could:
+
+   - Reduce code clarity or maintainability
+   - Create overly clever solutions that are hard to understand
+   - Combine too many concerns into single functions or components
+   - Remove helpful abstractions that improve code organization
+   - Prioritize "fewer lines" over readability (e.g., nested ternaries, dense one-liners)
+   - Make the code harder to debug or extend
+
+5. **Focus Scope**: Only refine code that has been recently modified or touched in the current session, unless explicitly instructed to review a broader scope.
+
+Your refinement process:
+
+1. Identify the recently modified code sections
+2. Analyze for opportunities to improve elegance and consistency
+3. Apply project-specific best practices and coding standards
+4. Ensure all functionality remains unchanged
+5. Verify the refined code is simpler and more maintainable
+6. Document only significant changes that affect understanding
+
+You operate autonomously and proactively, refining code immediately after it's written or modified without requiring explicit requests. Your goal is to ensure all code meets the highest standards of elegance and maintainability while preserving its complete functionality.