create-baton 1.0.0

package/templates/ide/CLAUDE.md.template

@@ -0,0 +1,105 @@
+# {{PROJECT_NAME}}
+
+## What Is This?
+
+This project uses **Baton Protocol** — an AI orchestration system where:
+- AI manages code, documentation, and handoffs
+- Human makes decisions and approves
+- Context is preserved across sessions
+
+**You are a technical co-founder, not a contractor. Own the outcome.**
+
+---
+
+## How to Start a Session
+
+1. Read the current handoff file: `handoff/SESSION_{{CURRENT_SESSION}}.md`
+2. Read context files (listed below)
+3. Follow the session protocol
+4. End by creating `handoff/SESSION_{{NEXT_SESSION}}.md`
+
+---
+
+## Context Files (Read in Order)
+
+| Priority | File | Purpose |
+|----------|------|---------|
+| 1 | `handoff/SESSION_N.md` | Current session tasks |
+| 2 | `.ai-rules/project.md` | Project decisions & rules |
+| 3 | `.ai-rules/tech-stack.md` | Stack patterns |
+| 4 | `.ai-rules/patterns.md` | Discovered quirks (check first!) |
+| 5 | `.ai-rules/structure.md` | File organization |
+| 6 | `PROGRESS.md` | Session history |
+| 7 | `BACKLOG.md` | Deferred items |
+
+---
+
+## Skills Library
+
+**Check these BEFORE web searching:**
+
+| Folder | Contains |
+|--------|----------|
+| `skills/core/` | Security, testing, production rules |
+| `skills/stacks/` | Tech stack patterns ({{STACK}}) |
+| `skills/patterns/` | Implementation patterns |
+| `skills/domains/` | Business domain knowledge |
+
+---
+
+## Session Protocol
+
+### Starting
+1. Read handoff file for current session
+2. Run health check (build, verify previous work)
+3. Ask: Any feedback? Blockers? Quick wins?
+
+### During
+- **Tiny tasks:** Do 3-4
+- **Normal tasks:** Do 2
+- **Large tasks:** Do 1
+- Verify each task works before moving on
+- Update docs as you go
+- ASK when unsure
+
+### Ending
+1. Build passes
+2. New features work
+3. PROGRESS.md updated
+4. handoff/SESSION_{N+1}.md created
+5. Ask: **"next"** or **"done"**?
+
+---
+
+## Key Rules
+
+1. **Verify before moving on** — Build must pass, feature must work
+2. **Document as you go** — Update structure.md, patterns.md
+3. **Skills before search** — Check skills/ before web research
+4. **Ask when unsure** — Never guess on business logic
+5. **Handoff is mandatory** — Session isn't done without next handoff
+
+---
+
+## Quick Commands
+
+```bash
+# Build
+{{BUILD_COMMAND}}
+
+# Dev server
+{{DEV_COMMAND}}
+
+# Type check
+{{TYPECHECK_COMMAND}}
+```
+
+---
+
+## Project-Specific Rules
+
+{{PROJECT_RULES}}
+
+---
+
+*Protocol: Baton v3.1*

package/templates/ide/cursorrules.template

@@ -0,0 +1,64 @@
+# Baton Protocol — {{PROJECT_NAME}}
+
+You are a technical co-founder building {{PROJECT_NAME}}.
+This project uses Baton — an AI orchestration protocol.
+
+## Start Each Session
+
+1. Read `handoff/SESSION_N.md` (current session)
+2. Read `.ai-rules/` files for context
+3. Run health check (build, verify previous work)
+4. Ask: Any feedback? Blockers?
+
+## During Session
+
+- Tiny tasks: Do 3-4
+- Normal tasks: Do 2
+- Large tasks: Do 1
+- Verify each task works before moving to next
+- Update documentation as you go
+- ASK when unsure about business logic
+
+## End Each Session
+
+- Verify build passes
+- Update PROGRESS.md
+- Create `handoff/SESSION_{N+1}.md`
+- Ask user: **"next"** or **"done"**?
+
+## Skills (Check Before Web Search)
+
+- `skills/core/` — Security, testing, production rules
+- `skills/stacks/` — {{STACK}} patterns
+- `skills/patterns/` — Implementation guides
+- `.ai-rules/patterns.md` — Project-specific quirks
+
+## Key Files
+
+- `handoff/SESSION_N.md` — Current session tasks
+- `.ai-rules/project.md` — Decisions and rules
+- `.ai-rules/patterns.md` — Discovered quirks
+- `PROGRESS.md` — Session log
+- `BACKLOG.md` — Deferred work
+
+## Rules
+
+- Never commit secrets
+- Always use environment variables
+- RLS on all database tables
+- Zod validation on all inputs
+- Verify before declaring done
+- Document quirks in patterns.md
+- Create handoff before ending session
+
+## Commands
+
+```
+Build: {{BUILD_COMMAND}}
+Dev: {{DEV_COMMAND}}
+Types: {{TYPECHECK_COMMAND}}
+```
+
+## Project Rules
+
+{{PROJECT_RULES}}

package/templates/skills/core/anti-overengineering/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: anti-overengineering
+description: >-
+  Prevents AI from adding unnecessary complexity, features, and abstractions.
+  Enforces YAGNI, size limits, and simplicity-first approach.
+  Use when building features, reviewing code complexity, or when the AI
+  starts adding things nobody asked for.
+---
+
+# Anti-Over-Engineering Skill
+
+> YAGNI: You Aren't Gonna Need It.
+> The best code is code you didn't write.
+
+---
+
+## The Problem
+
+AI loves to add complexity. Research shows:
+- PR sizes up 154% with AI assistance
+- 4x more code duplication
+- 9% more bugs per developer
+
+**More code = more bugs = more maintenance = slower progress.**
+
+---
+
+## Before Writing ANY Code
+
+Ask these 3 questions:
+
+1. **Does this solve the immediate problem?**
+   - If no → don't build it
+
+2. **Am I adding features nobody asked for?**
+   - If yes → stop
+
+3. **Can this be simpler?**
+   - If yes → make it simpler first
+
+---
+
+## Red Flags (Stop and Reconsider)
+
+| Red Flag | What's Happening |
+|----------|-----------------|
+| "While we're at it..." | Scope creep |
+| "For flexibility later..." | Premature abstraction |
+| "Just in case..." | YAGNI violation |
+| "Best practice says..." | Cargo culting |
+| "Let me refactor this first..." | Yak shaving |
+| PR > 200 lines for simple task | Over-engineering |
+
+---
+
+## Rules
+
+### 1. One Thing at a Time
+
+```
+BAD:
+"Add login button, and while I'm here let me also
+refactor the header, add dark mode toggle, and
+improve the responsive layout"
+
+GOOD:
+"Add login button"
+(That's it. Next task is next task.)
+```
+
+### 2. No Speculative Features
+
+```
+BAD:
+"Adding config options for future customization"
+"Building plugin system for extensibility"
+"Creating abstraction layer for flexibility"
+
+GOOD:
+"Building exactly what's needed now"
+(Add flexibility when you need it, not before)
+```
+
+### 3. Three Strikes Rule
+
+Don't abstract until you've written the same thing THREE times.
+
+```
+First time: Just write it
+Second time: Note the duplication
+Third time: NOW consider abstracting
+```
+
+### 4. Boring Technology
+
+```
+BAD:
+"Let's try this new framework/library/pattern"
+(Unless specifically requested)
+
+GOOD:
+"Using proven, stable technology"
+(New = risk = debugging = time waste)
+```
+
+### 5. Delete Before Add
+
+Before adding new code, ask:
+- Can I delete something instead?
+- Can I simplify existing code?
+- Is there dead code to remove?
+
+---
+
+## Size Limits
+
+| Change Type | Max Lines | If Larger... |
+|------------|-----------|--------------|
+| Bug fix | 50 | Split it up |
+| Small feature | 150 | Split it up |
+| Normal feature | 300 | Split into tasks |
+| Large feature | 500 | Split into sessions |
+
+**If a "simple" change is 200+ lines, something is wrong.**
+
+---
+
+## Complexity Checklist
+
+Before ending a task, verify:
+
+- [ ] No unnecessary abstractions added
+- [ ] No "just in case" code
+- [ ] No premature optimization
+- [ ] No gold-plating (extra polish nobody asked for)
+- [ ] Could a junior developer understand this?
+- [ ] Is the PR focused on ONE thing?
+
+---
+
+## When User Asks for Something Complex
+
+Don't just build it. Ask:
+
+> "This could be built simply (Option A) or with more flexibility (Option B).
+>
+> **Option A (Recommended):** [Simple approach] — Works for current needs, easy to extend later.
+>
+> **Option B:** [Complex approach] — More flexible but adds complexity.
+>
+> Which do you prefer?"
+
+**Default to simple. Let user explicitly choose complexity.**
+
+---
+
+## Recovery: Already Over-Engineered?
+
+If you realize you've over-engineered:
+
+1. Stop immediately
+2. Tell the user what happened
+3. Propose simpler alternative
+4. Ask if they want to simplify or keep
+
+Don't hide it. Don't keep building on bad foundation.
+
+---
+
+## Mantras
+
+- Simplicity is a feature
+- Working > perfect
+- Ship > polish
+- Delete > add
+- Ask > assume
+
+---
+
+*Last updated: Baton Protocol v3.1*

package/templates/skills/core/cost-awareness/SKILL.md

@@ -0,0 +1,207 @@
+---
+name: cost-awareness
+description: >-
+  AI cost tracking and optimization. Covers model pricing, model selection
+  guide, cost-saving practices, and session cost tracking.
+  Use when discussing AI costs, choosing models, optimizing token usage,
+  or when spending seems high.
+---
+
+# Cost Awareness Skill
+
+> AI isn't free. Know what you're spending.
+> Expensive ≠ better. Smart model selection saves money.
+
+---
+
+## Why This Matters
+
+Real examples from developers:
+- "$60 in 3 days just fixing React components"
+- "Blew through monthly budget in one week"
+- "Didn't realize web search costs extra tokens"
+
+**Don't be surprised. Be aware.**
+
+---
+
+## 2026 Model Pricing (Approximate)
+
+| Model | Input (per 1M tokens) | Output (per 1M tokens) | Best For |
+|-------|----------------------|------------------------|----------|
+| **Claude Opus 4.5** | $15 | $75 | Complex reasoning, architecture |
+| **Claude Sonnet** | $3 | $15 | Daily coding, most tasks |
+| **Claude Haiku** | $0.25 | $1.25 | Simple tasks, quick checks |
+| **GPT-5.3-Codex** | $10 | $40 | Agentic coding |
+| **Gemini 3 Pro** | $1.25 | $5 | Long context, large codebases |
+
+*Prices change. Check current rates.*
+
+---
+
+## Model Selection Guide
+
+### Use Opus/Expensive Models For:
+
+- Architecture decisions
+- Complex debugging
+- Security reviews
+- Major refactors
+- When you're stuck
+
+### Use Sonnet/Mid-tier For:
+
+- Daily feature building
+- Code generation
+- Documentation
+- Most normal work
+
+### Use Haiku/Cheap Models For:
+
+- Simple questions
+- Formatting
+- Quick lookups
+- Repetitive tasks
+
+---
+
+## Cost-Saving Practices
+
+### 1. Check Skills Before Web Search
+
+```
+EXPENSIVE:
+"Search the web for Next.js best practices"
+(Tokens for search + results + processing)
+
+CHEAP:
+"Read skills/stacks/nextjs.md"
+(Just file read, minimal tokens)
+```
+
+**Skills library exists to save money.**
+
+### 2. Don't Reload Context Unnecessarily
+
+```
+EXPENSIVE:
+Reading all .ai-rules files every time you ask a question
+
+BETTER:
+Read at session start, reference from memory
+```
+
+### 3. Ask Specific Questions
+
+```
+EXPENSIVE:
+"Help me with authentication"
+(Vague → long back-and-forth)
+
+CHEAP:
+"Add Supabase auth to the login form at src/app/login/page.tsx"
+(Specific → one-shot answer)
+```
+
+### 4. Use Smaller Models for Simple Tasks
+
+```
+EXPENSIVE:
+Using Opus to rename a variable
+
+CHEAP:
+Using Haiku for simple edits, Opus for complex reasoning
+```
+
+---
+
+## Session Cost Tracking
+
+At end of each session, note in PROGRESS.md:
+
+```markdown
+### Session N - [Date]
+
+**Cost:** ~$X.XX
+**Model:** Claude Opus 4.5
+**Notes:** Heavy research session, expect higher cost
+
+**Running Total:** ~$XX.XX
+```
+
+---
+
+## Cost Red Flags
+
+| Red Flag | Likely Cause | Solution |
+|----------|--------------|----------|
+| >$20 in one session | Long context, many searches | Split work, use skills |
+| Repeated research | Not using patterns.md | Document discoveries |
+| Many failed attempts | Poor prompts | Be more specific |
+| Constant clarification | Vague requests | Ask complete questions |
+
+---
+
+## Budget Guidelines
+
+| Project Type | Expected Total | Per Session |
+|--------------|---------------|-------------|
+| Simple app (5 sessions) | $20-50 | $4-10 |
+| Medium app (10 sessions) | $50-150 | $5-15 |
+| Complex app (20+ sessions) | $150-500 | $7-25 |
+
+*These are estimates. Actual varies by complexity and efficiency.*
+
+---
+
+## When Costs Are High
+
+If spending seems high:
+
+1. **Review:** What's using tokens?
+   - Web searches?
+   - Long files?
+   - Repeated context?
+
+2. **Optimize:**
+   - Use skills library more
+   - Be more specific in prompts
+   - Consider cheaper model for simple tasks
+
+3. **Communicate:**
+   - Tell user if session was expensive and why
+   - Suggest optimizations for next session
+
+---
+
+## Cost vs. Time Trade-off
+
+Sometimes expensive is worth it:
+
+| Situation | Recommendation |
+|-----------|----------------|
+| Stuck for 30+ minutes | Use Opus, worth the cost |
+| Simple task | Use Haiku, save money |
+| Architecture decision | Use Opus, get it right |
+| Formatting/cleanup | Use Haiku |
+| Security review | Use Opus, don't skimp |
+
+**Cheap mistakes cost more than expensive prevention.**
+
+---
+
+## Token Estimation
+
+Rough guidelines:
+
+| Content | Approximate Tokens |
+|---------|-------------------|
+| 1 page of code (~50 lines) | ~500 tokens |
+| Average source file | 500-2000 tokens |
+| BATON_v3.1.md | ~2000 tokens |
+| All .ai-rules files | ~3000-5000 tokens |
+| Web search results | ~1000-3000 tokens |
+
+---
+
+*Last updated: Baton Protocol v3.1*