Discover Standards

I've identified these areas in your codebase:

1. **API Routes** (src/api/) — Request handling, response formats
2. **Database** (src/models/, src/db/) — Models, queries, migrations
3. **React Components** (src/components/) — UI patterns, props, state
4. **Authentication** (src/auth/) — Login, sessions, permissions

Which area should we focus on for discovering standards? (Pick one, or suggest a different area)

Wait for user response before proceeding.

Step 2: Analyze & Present Findings

Once an area is determined:

1. Read key files in that area (5-10 representative files)

2. Look for patterns that are:

   • Unusual or unconventional — Not standard framework/library patterns
   • Opinionated — Specific choices that could have gone differently
   • Tribal — Things a new developer wouldn't know without being told
   • Consistent — Patterns repeated across multiple files

3. Use AskUserQuestion to present findings and let user select:

I analyzed [area] and found these potential standards worth documenting:

1. **API Response Envelope** — All responses use { success, data, error } structure
2. **Error Codes** — Custom error codes like AUTH_001, DB_002 with specific meanings
3. **Pagination Pattern** — Cursor-based pagination with consistent param names

Which would you like to document?

Options:
- "Yes, all of them"
- "Just 1 and 3"
- "Add: [your suggestion]"
- "Skip this area"

Wait for user selection before proceeding.

Step 3: Ask Why, Then Draft Each Standard

IMPORTANT: For each selected standard, you MUST complete this full loop before moving to the next standard:

1. Ask 1-2 clarifying questions about the "why" behind the pattern. Use your AskUserQuestion tool for this.
2. Wait for user response
3. Draft the standard incorporating their answer
4. Confirm with user before creating the file
5. Create the file if approved

Example questions to ask (adapt based on the specific standard):

• "What problem does this pattern solve? Why not use the default/common approach?"
• "Are there exceptions where this pattern shouldn't be used?"
• "What's the most common mistake a developer or agent makes with this?"

Do NOT batch all questions upfront. Process one standard at a time through the full loop.

Step 4: Create the Standard File

For each standard (after completing Step 3's Q&A):

1. Determine the appropriate folder (create if needed):

   • api/, database/, javascript/, css/, backend/, testing/, global/

2. Check if a related standard file already exists — append to it if so

3. Draft the content and use AskUserQuestion to confirm:

Here's the draft for api/response-format.md:

---
# API Response Format

All API responses use this envelope:

\`\`\`json
{ "success": true, "data": { ... } }
{ "success": false, "error": { "code": "...", "message": "..." } }
\`\`\`

- Never return raw data without the envelope
- Error responses must include both code and message
- Success responses omit the error field entirely
---

Create this file? (yes / edit: [your changes] / skip)

1. Create or update the file in agent-os/standards/[folder]/
2. Then repeat Steps 3-4 for the next selected standard

Step 5: Update the Index

After all standards are created:

1. Scan agent-os/standards/ for all .md files
2. For each new file without an index entry, use AskUserQuestion:

New standard needs an index entry:
  File: api/response-format.md

Suggested description: "API response envelope structure and error format"

Accept this description? (yes / or type a better one)

1. Update agent-os/standards/index.yml: