mkdir todo-app
cd todo-app
git init

cat > .gitignore << 'EOF'
# Dependencies
node_modules/
package-lock.json

# Test artifacts
coverage/
.test_baselines/

# Environment
.env
.env.local

# IDE
.vscode/
.idea/
*.swp
*.swo

# OS
.DS_Store
Thumbs.db

# Temporary
*.tmp
*.log
tmp/
temp/

# Build outputs
dist/
build/
EOF

git add .gitignore
git commit -m "Initial commit: Add .gitignore"

# Create all directories
mkdir -p backend frontend tests/api tests/backend tests/frontend tests/integration tools docs

# Create README for documentation
cat > README.md << 'EOF'
# Todo App

## Structure
- `/backend` - API service
- `/frontend` - Web interface
- `/tests` - Test suites
- `/tools` - Automation scripts
- `/docs` - API documentation

## Branches
- `main` - Stable, integrated code
- `backend-*` - Backend features
- `frontend-*` - Frontend features
- `test-*` - Test development
- `fix-*` - Bug fixes
EOF

git add README.md
git commit -m "docs: Add project structure and README"

cat > claude.md << 'EOF'
# TODO APP - GROUND RULES

## GIT WORKFLOW RULES
- **ALWAYS** read current git status before making changes
- **NEVER** modify files without checking git diff first
- **COMMIT** after each successful change
- **BRANCH** for new features (feature/name pattern)
- **TEST** before committing
- **MSG FORMAT**: type: description (feat:, fix:, test:, docs:, refactor:)

## ARCHITECTURE OVERVIEW
- Backend: Standalone todo service (Node.js/Express)
- Frontend: Static HTML/JS client
- Communication: HTTP/JSON only
- Storage: JSON file (no database setup)
- **NO CROSS-CONTAMINATION** between components

## TECHNOLOGY STACK
- Backend: Node.js 18+, Express only
- Frontend: Vanilla HTML/CSS/JavaScript
- Testing: Jest for backend, simple assertions for frontend
- Version Control: Git with feature branches

## CRITICAL CONSTRAINTS
- **NO** external dependencies beyond specified
- **NO** frameworks or libraries not listed
- **NO** modification of test files during implementation
- **NO** abstraction layers or future-proofing
- **SINGLE FILE** implementations preferred
- **GIT COMMIT** after each working change

## STATE MACHINE
Work proceeds in phases:
1. Structure → Documentation → Tests → Implementation
2. Each phase tracked in Git
3. Each phase must be complete before next
4. Tools verify phase completion

## GIT BRANCH STRATEGY
- main: Always working, all tests pass
- backend-{feature}: Backend development
- frontend-{feature}: Frontend development
- test-{component}: Test development
- fix-{issue}: Bug fixes
- Each branch merges to main only when tests pass

## COMMIT MESSAGE CONVENTION
- feat: New feature
- fix: Bug fix
- test: Test addition/modification
- docs: Documentation
- refactor: Code restructuring
- chore: Maintenance tasks

## FILE NAMING CONVENTIONS
- Tests: test_*.js
- Tools: tool_*.js
- Single entry points: server.js, index.html
EOF

git add claude.md
git commit -m "docs: Add Claude ground rules with Git workflow"

claude "TASK: Create a dynamic code map for the project
CONTEXT: The purpose of this document is to track the location of features, files, and code lines to make future LLM-powered development more efficient.

DELIVERABLE: CODE_MAP.md

CONTENT REQUIRED:
# CODE MAP

## Project Structure
- `/backend`: API service
- `/frontend`: Web interface
- `/tests`: All test suites
- `/tools`: Helper scripts and automation
- `docs/api-spec.md`: API contract

## Backend Code Map
### server.js
- `[TBD]`: Express server setup
- `[TBD]`: GET /api/todos - List all todos
- `[TBD]`: POST /api/todos - Create todo
- `[TBD]`: PUT /api/todos/:id - Update todo
- `[TBD]`: DELETE /api/todos/:id - Delete todo

## Frontend Code Map
### index.html
- `[TBD]`: HTML structure
- `[TBD]`: CSS styles
- `[TBD]`: JavaScript functions
- `[TBD]`: API calls
- `[TBD]`: Event handlers

## How to use this document
- When a feature is added or modified, update this document with the relevant file path and line number.
- Always include this document in the CONTEXT of future Claude Code sessions.

AFTER CREATING:
- git add CODE_MAP.md
- git commit -m 'docs: Add dynamic code map document'"

git checkout -b docs-api-spec

claude "TASK: Define todo API specification
CONTEXT: We're in branch 'docs-api-spec'

DELIVERABLE: /docs/api-spec.md

ENDPOINTS TO DEFINE:
- GET /api/todos - List all todos
- POST /api/todos - Create todo
- PUT /api/todos/:id - Update todo (mark complete)
- DELETE /api/todos/:id - Delete todo

REQUEST/RESPONSE FORMATS:
- Create: {text: string} → {id, text, completed, createdAt}
- Update: {completed: boolean} → {id, text, completed, createdAt}
- List: → [{id, text, completed, createdAt}]
- Delete: → {success: true}

ERROR RESPONSES:
- 400: {error: 'Invalid input'}
- 404: {error: 'Todo not found'}
- 500: {error: 'Server error'}

VALIDATION RULES:
- Text: required, 1-500 characters
- ID: UUID format
- Completed: boolean only

AFTER CREATING:
- Run: git add docs/api-spec.md
- Run: git commit -m 'docs: Add API specification'
- Do NOT merge to main yet"

claude "TASK: Create backend component documentation
WORKING BRANCH: docs-api-spec

DELIVERABLE: /backend/claude.md

CONTENT REQUIRED:
# BACKEND SERVICE RULES

## PURPOSE
Todo CRUD operations service following /docs/api-spec.md

## TECHNOLOGY CONSTRAINTS
- Node.js 18+, Express only
- No external dependencies beyond Express
- Single file implementation (server.js)

## API CONTRACT
See /docs/api-spec.md for complete specification

## FILE STRUCTURE
- /backend/server.js - Main service file
- /backend/package.json - Dependencies
- Port: 3000

## TESTING REQUIREMENTS
- All endpoints must pass /tests/backend/test_todo_service.js
- Run tests with: npm test or node test_todo_service.js

## CODE MAP (Update as implementation progresses)
### /backend/server.js
- Server setup: lines [TBD]
- Routes: lines [TBD]
- Todo storage: lines [TBD]
- Validation: lines [TBD]

### To add new endpoint:
1. Add route definition
2. Add validation
3. Update CODE MAP

## CRITICAL RULES
- **NEVER** import frontend code
- **NEVER** modify test files
- **ALWAYS** validate input per API spec
- **ALWAYS** return exact format from API spec

AFTER CREATING:
- git add backend/claude.md
- git commit -m 'docs: Add backend component rules'"

claude "TASK: Create frontend component documentation
WORKING BRANCH: docs-api-spec

DELIVERABLE: /frontend/claude.md

CONTENT:
# FRONTEND SERVICE RULES

## PURPOSE
Todo user interface that communicates with backend API

## TECHNOLOGY CONSTRAINTS
- Vanilla HTML/CSS/JavaScript only
- No frameworks or libraries
- Single file (index.html with embedded CSS/JS)

## API INTEGRATION
- Backend URL: http://localhost:3000
- All API calls to /api/todos endpoints
- See /docs/api-spec.md for formats

## UI REQUIREMENTS
- Input field for new todos
- List display of all todos
- Checkbox for completion
- Delete button per todo
- Error message display area
- Loading states during API calls

## CODE MAP (Update as implementation progresses)
### /frontend/index.html
- HTML structure: lines [TBD]
- CSS styles: lines [TBD]
- JavaScript functions: lines [TBD]
- API calls: lines [TBD]
- Event handlers: lines [TBD]

## CRITICAL RULES
- NO external dependencies
- NO server-side code
- Must handle API errors gracefully
- Must show connection errors clearly
- All API responses must be validated

AFTER CREATING:
- git add frontend/claude.md
- git commit -m 'docs: Add frontend component rules'"

claude "TASK: Create test suite documentation
WORKING BRANCH: docs-api-spec

DELIVERABLE: /tests/claude.md

CONTENT:
# TEST SUITE RULES

## PURPOSE
Gaming-resistant test suite that validates all components

## TEST CATEGORIES
1. API Contract Tests - Verify API matches specification
2. Backend Implementation Tests - Verify business logic
3. Frontend UI Tests - Verify user interface behavior
4. Integration Tests - Verify end-to-end workflows

## TESTING APPROACH
- External test data files (JSON)
- No inline assertions that can be gamed
- Test files are read-only during implementation
- All tests must fail before implementation

## TEST EXECUTION
- Individual: node tests/[category]/test_*.js
- All: node tools/run_tests.js
- With coverage: npm test

## PROTECTION RULES
- Test files cannot be modified during implementation
- Test guardian monitors file integrity
- Git tracks any test modifications
- Tests define success criteria before coding

## CRITICAL RULES
- NEVER modify test files to make them pass
- ALWAYS use external data files
- EVERY feature needs a test first
- ALL tests must pass before merge to main

AFTER CREATING:
- git add tests/claude.md
- git commit -m 'docs: Add test suite documentation'"

# Review all documentation created
ls -la docs/
ls -la backend/claude.md
ls -la frontend/claude.md
ls -la tests/claude.md
ls -la CODE_MAP.md

# If everything looks good, merge
git checkout main
git merge docs-api-spec --no-ff -m "merge: Complete project documentation"
git branch -d docs-api-spec

# Tag documentation complete
git tag -a v0.1-docs -m "Documentation phase complete"

claude "TASK: Create test file integrity guardian with Git awareness
WORKING BRANCH: test-infrastructure

DELIVERABLE: /tools/test_guardian.js

FUNCTIONALITY:
- Store MD5 hashes of all test files in a baseline file.
- Detect modifications to test files by comparing current hashes to the baseline.
- Integrate with `git status` to warn if uncommitted changes exist in test files.
- Prevent gaming by modification.

COMMANDS:
- `node tools/test_guardian.js baseline` - Store hashes of all test files.
- `node tools/test_guardian.js check` - Detect changes and report if files have been modified.
- `node tools/test_guardian.js git-check` - Compare with `git` and report uncommitted changes.

MONITORING:
- All files matching `/tests/**/*.js` and `/tests/**/*.json`
- Store hashes in `/tools/.test_hashes.json`

OUTPUT:
- Clean: '✓ All test files unchanged'
- Modified: '✗ TEST FILES MODIFIED: [list]'
- Git status: '⚠ Uncommitted test changes detected'

AFTER CREATING:
- `git add tools/test_guardian.js`
- `git commit -m 'feat: Add test guardian with git integration'`"

claude "TASK: Create API contract tests
WORKING BRANCH: test-infrastructure

DELIVERABLES:
1. /tests/api/test_api_contract.js
2. /tests/api/api_data.json

CONTEXT:
- The tests must strictly follow the API specification in `/docs/api-spec.md`.
- These tests do not use any internal backend logic; they simply make HTTP requests to `http://localhost:3000`.

TEST DATA STRUCTURE (api_data.json):
{
  "testCases": [
    {
      "endpoint": "/api/todos",
      "method": "POST",
      "payload": { "text": "Walk the dog" },
      "expectedStatus": 200,
      "expectedKeys": ["id", "text", "completed", "createdAt"]
    },
    {
      "endpoint": "/api/todos",
      "method": "POST",
      "payload": { "text": "" },
      "expectedStatus": 400,
      "expectedError": "Invalid input"
    },
    {
      "endpoint": "/api/todos/123",
      "method": "PUT",
      "payload": { "completed": true },
      "expectedStatus": 404,
      "expectedError": "Todo not found"
    }
  ]
}

REQUIREMENTS:
- Use an external JSON file (`api_data.json`) for test cases.
- Test all API endpoints: `GET`, `POST`, `PUT`, `DELETE`.
- Verify correct status codes and error messages for both success and failure cases.
- All tests must fail initially because no backend implementation exists yet.

AFTER CREATING:
- `mkdir tests/api`
- `git add tests/api/`
- `git commit -m 'test: Add API contract tests'`"

claude "TASK: Create backend implementation tests
WORKING BRANCH: test-infrastructure

DELIVERABLES:
1. /tests/backend/test_todo_service.js
2. /tests/backend/backend_data.json

CONTEXT:
- These tests will verify the internal business logic of the backend.
- They will be written with a testing framework like Jest, but without a real server running.

TEST DATA STRUCTURE (backend_data.json):
{
  'createTests': [
    {input: {text: 'Buy milk'}, expected: {text: 'Buy milk', completed: false}},
    {input: {text: ''}, expectedError: 'Invalid input'},
    {input: {}, expectedError: 'Invalid input'}
  ],
  'updateTests': [
    {id: 'test-id-1', update: {completed: true}, expected: {completed: true}},
    {id: 'invalid-id', expectedError: 'Todo not found'}
  ],
  'deleteTests': [
    {id: 'test-id-1', expectedSuccess: true},
    {id: 'invalid-id', expectedError: 'Todo not found'}
  ]
}

REQUIREMENTS:
- Load test cases from external JSON (`backend_data.json`).
- Test each CRUD operation (create, read, update, delete) thoroughly.
- Test error conditions and edge cases, such as invalid input or non-existent IDs.
- The tests should report results clearly and must fail initially.

AFTER CREATING:
- `mkdir tests/backend`
- `git add tests/backend/`
- `git commit -m 'test: Add backend implementation tests'`"

claude "TASK: Create frontend UI tests
WORKING BRANCH: test-infrastructure

DELIVERABLES:
1. /tests/frontend/test_ui.js
2. /tests/frontend/frontend_data.json

CONTEXT:
- These tests will be written in plain JavaScript to be run in a browser environment.
- They will verify that the HTML elements are rendered correctly and respond to user actions.

TEST DATA STRUCTURE (frontend_data.json):
{
  "testCases": [
    {"type": "elementExists", "selector": "#todo-input", "message": "Input field exists"},
    {"type": "elementExists", "selector": "#add-button", "message": "Add button exists"},
    {"type": "clickAndVerify", "input": "New todo", "expectedText": "New todo", "message": "Add button creates todo item"},
    {"type": "stateChange", "selector": ".todo-item .checkbox", "action": "click", "expectedClass": "completed", "message": "Checkbox toggles completion state"},
    {"type": "removal", "selector": ".todo-item .delete-button", "action": "click", "expectedRemoval": true, "message": "Delete button removes item"}
  ]
}

REQUIREMENTS:
- Load test cases from external JSON (`frontend_data.json`).
- Use simple assertions to verify UI state.
- Test the presence of key elements, adding new todos, marking them as complete, and deleting them.
- All tests must fail initially.

AFTER CREATING:
- `mkdir tests/frontend`
- `git add tests/frontend/`
- `git commit -m 'test: Add frontend UI tests'`"

claude "TASK: Create end-to-end integration tests
WORKING BRANCH: test-infrastructure

DELIVERABLES:
1. /tests/integration/test_e2e.js
2. /tests/integration/integration_data.json

CONTEXT:
- These tests simulate a full user workflow, from UI interaction to backend validation.
- They will assume the backend server is running and the frontend page is loaded.

TEST DATA STRUCTURE (integration_data.json):
{
  "testCases": [
    {"description": "Create a new todo", "actions": ["type 'Test todo' into #todo-input", "click #add-button"], "expected": {"element": ".todo-item", "text": "Test todo"}},
    {"description": "Mark a todo as complete", "actions": ["create 'Another todo'", "click .todo-item .checkbox"], "expected": {"element": ".todo-item.completed"}},
    {"description": "Delete a todo", "actions": ["create 'Todo to delete'", "click .todo-item .delete-button"], "expected": {"elementRemoved": ".todo-item"}}
  ]
}

REQUIREMENTS:
- Load test cases from external JSON (`integration_data.json`).
- Simulate user actions like typing, clicking, and waiting for UI updates.
- Verify that the final state of the UI is correct and reflects the backend's state.
- All tests must fail initially because no implementation exists yet.

AFTER CREATING:
- `mkdir tests/integration`
- `git add tests/integration/`
- `git commit -m 'test: Add end-to-end integration tests'`"

claude "TASK: Create comprehensive test runner
        WORKING BRANCH: test-infrastructure

        DELIVERABLE: /tools/run_tests.js

        FUNCTIONALITY:
        1. Check `git status` for uncommitted changes.
        2. Verify test file integrity by running the guardian (`node tools/test_guardian.js check`).
        3. Run all four test suites in a specific order:
           - API Contract tests
           - Backend Implementation tests
           - Frontend UI tests
           - Integration tests
        4. Report the results for each suite individually.
        5. Provide a clear summary of the overall status (e.g., 'FAILED', 'PASSED').

        TEST SUITES:
        - API Contract: /tests/api/test_api_contract.js
        - Backend: /tests/backend/test_todo_service.js
        - Frontend: /tests/frontend/test_ui.js
        - Integration: /tests/integration/test_e2e.js

        OUTPUT FORMAT:
        =====================================
        GIT STATUS: ✓ Working directory clean
        TEST INTEGRITY: ✓ All test files unchanged
        =====================================
        TEST RESULTS
        =====================================
        ✗ API Contract: 0/12 tests passed (no backend)
        ✗ Backend: 0/8 tests passed (not implemented)
        ✗ Frontend: 0/10 tests passed (not implemented)
        ✗ Integration: 0/5 tests passed (nothing to integrate)
        -------------------------------------
        OVERALL: FAILED (0/35 tests passed)
        =====================================
        Note: This is the expected output, as no implementation exists yet.

        AFTER CREATING:
        - `git add tools/run_tests.js`
        - `git commit -m 'feat: Add comprehensive test runner'`"

claude "TASK: Create development helper tools
WORKING BRANCH: test-infrastructure

DELIVERABLES:
1. /tools/watch_tests.js - Continuously run tests during development.
2. /tools/test_single.js - Run a specific test suite.
3. /tools/quick_check.js - Fast validation before commits.

TOOL 1 - `watch_tests.js`:
- Watch for file changes in `/backend` or `/frontend`.
- Automatically run the relevant test suite when files are modified.
- Clear the console and show results.
- Exit with Ctrl+C.

TOOL 2 - `test_single.js`:
- Usage: `node tools/test_single.js backend`
- Usage: `node tools/test_single.js frontend`
- Usage: `node tools/test_single.js api`
- Usage: `node tools/test_single.js integration`
- Run just one specific test suite for faster feedback.

TOOL 3 - `quick_check.js`:
- Run a quick validation check.
- This includes the guardian check and only the unit tests (API and Backend).
- It should skip the slower integration and frontend tests.
- Report results in under 5 seconds for rapid feedback.

AFTER CREATING:
- `git add tools/`
- `git commit -m 'feat: Add development helper tools'`"

claude "TASK: Create Makefile with git-aware commands
WORKING BRANCH: test-infrastructure

DELIVERABLE: Makefile

COMMANDS NEEDED:
# Development
install: npm install in backend
start: node tools/start_app.js
test: node tools/run_tests.js
test-backend: node tools/test_single.js backend
test-frontend: node tools/test_single.js frontend

# Git workflow
status: git status with pretty formatting
branch: show current branch and recent commits
commit: test then commit with message prompt
push: test, commit, then push to origin

# Protection
guardian-baseline: node tools/test_guardian.js baseline
guardian-check: node tools/test_guardian.js check
check-all: guardian-check + git status + test

# Cleanup
clean: remove node_modules and temp files
reset-hard: git reset --hard HEAD (with confirmation)

Add help text explaining each command

AFTER CREATING:
- `git add Makefile`
- `git commit -m 'feat: Add Makefile with git integration'`"

# Create the baseline for test protection
node tools/test_guardian.js baseline

# Commit the new baseline file
git add tools/.test_hashes.json
git commit -m "chore: Set test baseline for guardian"

# Run all tests to see they fail (expected!)
make test

# Review all the work in this branch
git log --oneline main..HEAD
git diff main...test-infrastructure --stat

# Merge to main
git checkout main
git merge test-infrastructure --no-ff -m "merge: Complete test infrastructure"

# Clean up and tag this milestone
git branch -d test-infrastructure
git tag -a v0.2-tests -m "All tests defined before implementation"

git checkout -b backend-core

claude "TASK: Create simplest todo backend - echo only
WORKING BRANCH: backend-core (confirm with git branch)

CONTEXT TO READ:
- /docs/api-spec.md
- /tests/backend/test_todo_service.js
- /CODE_MAP.md

DELIVERABLE: /backend/server.js

REQUIREMENTS:
- Express server on port 3000
- GET /api/todos returns empty array []
- POST /api/todos echoes back input with generated ID
- No actual storage yet

GIT WORKFLOW:
1. Create server.js
2. Test with: `make test-backend`
3. If tests pass (partially): git add backend/server.js CODE_MAP.md
4. git commit -m 'feat: Add echo backend service'
5. Do NOT merge to main yet

CONSTRAINTS:
- DO NOT modify test files
- Check git status before committing"

claude "Ensure all tests pass
make test-backend

# Review the complete backend implementation
git diff main...backend-core

# Check commit history
git log --oneline main..backend-core"

# Merge to main
git checkout main
git merge backend-core --no-ff -m "merge: Complete backend implementation"
git branch -d backend-core

# Tag this milestone
git tag -a v0.1-backend -m "Backend API complete"

git checkout -b frontend-core

claude "TASK: Create todo display interface
WORKING BRANCH: frontend-core

DELIVERABLE: /frontend/index.html
CONTEXT: /CODE_MAP.md

CREATE:
- Single HTML file with embedded CSS/JS
- Input field and Add button
- Todo list display area
- Complete/Delete buttons per todo

FUNCTIONALITY:
- Local state only (no API yet)
- Add updates display
- Complete toggles strikethrough
- Delete removes from display

GIT WORKFLOW:
1. Create index.html
2. Test in browser
3. git add frontend/index.html CODE_MAP.md
4. git commit -m 'feat: Add frontend UI with local state'

NO API INTEGRATION YET"

claude "TASK: Connect frontend to backend API
WORKING BRANCH: frontend-core

CHECK CURRENT STATE: git diff HEAD frontend/index.html
READ CONTEXT: /CODE_MAP.md

MODIFY:
- /frontend/index.html JavaScript section
- /CODE_MAP.md

ADD:
- Fetch calls to http://localhost:3000/api/todos
- Load todos on page load
- Create/Update/Delete via API
- Error handling for connection issues

TEST PROCESS:
1. Manually start the backend server in one terminal window by running: cd backend && node server.js
2. Open frontend/index.html in browser
3. Test all operations
4. Check browser console for errors

GIT WORKFLOW:
1. After testing works:
2. git diff frontend/index.html CODE_MAP.md (review changes)
3. git add frontend/index.html CODE_MAP.md
4. git commit -m 'feat: Add API integration to frontend'"

claude "Add loading states and better error messages to frontend
Show 'Loading...' during API calls
Show user-friendly error messages
git commit -am 'feat: Add loading states and error handling'"

# Test everything together
make start

# If all works, merge
git checkout main
git merge frontend-core --no-ff -m "merge: Complete frontend implementation"
git branch -d frontend-core

# Tag the complete basic version
git tag -a v1.0-basic -m "Basic todo app complete"

git checkout -b tooling-integration

claude "TASK: Create a robust app startup script with git awareness
WORKING BRANCH: tooling-integration

DELIVERABLE: /tools/start_app.js
CONTEXT: /CODE_MAP.md

FUNCTIONALITY:
1. Check git status - warn if uncommitted changes
2. Show current branch and last commit
3. Start backend server on port 3000
4. Implement a **robust check for server readiness**. Instead of a fixed delay, the script must **poll the server's health check endpoint** (GET /) every 500ms for a maximum of 30 seconds.
5. If the server becomes available, open the frontend in a new browser tab.
6. If the server does not become available within 30 seconds, print an error message and exit.
7. Handle Ctrl+C gracefully, shutting down the server process cleanly.

AFTER CREATING:
- git add tools/start_app.js CODE_MAP.md
- git commit -m 'feat: Add robust startup script with git awareness'"

claude Test all the tools
make check-all
make start

# Merge tooling
git checkout main
git merge tooling-integration --no-ff -m "merge: Complete tooling and automation"
git branch -d tooling-integration

# Tag the complete version
git tag -a v1.0-complete -m "Complete todo app with tooling"

# Push everything to remote (if you have one)
git push origin main --tags

# Always branch from main
git checkout main
git pull origin main  # If working with remote
git checkout -b feat-priority

claude "TASK: Add priority field to API spec
BRANCH: feat-priority (verify with git branch)

MODIFY: /docs/api-spec.md

ADD:
- priority field: high, medium, low
- Default: medium
- Add to all request/response examples

GIT WORKFLOW:
- git diff docs/api-spec.md
- git add docs/api-spec.md
- git commit -m 'docs: Add priority field to API spec'"

claude "TASK: Add priority test cases
BRANCH: feat-priority

CHECK: git log --oneline -1 (verify API spec committed)

MODIFY: /tests/backend/test_data.json

ADD:
- Test cases for all three priority levels
- Test default priority
- Test invalid priority rejection

IMPORTANT: Run guardian baseline BEFORE modifying tests
- node tools/test_guardian.js baseline

AFTER CHANGES:
- git diff tests/backend/test_data.json
- git add tests/backend/test_data.json
- git commit -m 'test: Add priority field test cases'
- node tools/test_guardian.js baseline (update baseline)"

claude "TASK: Add priority to backend
BRANCH: feat-priority

SHOW CHANGES SO FAR: git log --oneline main..HEAD
READ CONTEXT: /CODE_MAP.md

MODIFY:
- /backend/server.js
- /CODE_MAP.md

ADD:
- priority field to todo object
- Validation for priority values
- Default to 'medium' if not provided

TEST AND COMMIT:
- `make test-backend`
- git diff backend/server.js CODE_MAP.md
- git commit -am 'feat: Add priority field to backend'"

claude "TASK: Add priority UI
BRANCH: feat-priority

CURRENT PROGRESS: git log --oneline -3
READ CONTEXT: /CODE_MAP.md

MODIFY:
- /frontend/index.html
- /CODE_MAP.md

ADD:
- Priority dropdown in add form
- Priority badge display (colored)
- high=red, medium=yellow, low=green

TEST AND COMMIT:
- Manual testing in browser
- git diff frontend/index.html CODE_MAP.md
- git commit -am 'feat: Add priority UI to frontend'"

Claude Run all tests
make check-all

# Review all changes
git log --oneline main..HEAD
git diff main...HEAD

# Merge to main
git checkout main
git merge feat-priority --no-ff -m "merge: Add priority feature"

# Tag new version
git tag -a v1.1-priority -m "Add priority feature"

# Clean up
git branch -d feat-priority