@codemieai/code 0.0.33 → 0.0.35

package/dist/agents/plugins/claude/plugin/claude-templates/templates/CLAUDE.md.template

@@ -1,304 +1,166 @@
 # CLAUDE.md
 
-**Purpose**: AI-optimized execution guide for Claude Code agents working with the [PROJECT_NAME] codebase
-
----
-
-## 📚 GUIDE IMPORTS
-
-This document references detailed guides stored in `.codemie/guides/`. Key references:
-
-### 🚨 MANDATORY RULE: Check Guides First
+<!--
+═══════════════════════════════════════════════════════════════════════════════
+TEMPLATE INSTRUCTIONS FOR LLM/AI
+═══════════════════════════════════════════════════════════════════════════════
+PURPOSE: Generate project-specific CLAUDE.md execution guide from this template.
+
+POPULATION RULES:
+1. ANALYZE codebase: structure, configs, existing patterns
+2. DISCOVER guides in .codemie/guides/ - read each and extract purpose
+3. EXTRACT technology stack from package.json/requirements.txt/pom.xml/go.mod
+4. REPLACE all [PLACEHOLDER] values with discovered information
+5. DELETE sections marked with [OPTIONAL] if not applicable
+6. REMOVE all <!-- INSTRUCTION --> comments after populating
+
+PLACEHOLDERS FORMAT:
+- [PLACEHOLDER] = Required, must be replaced
+- [PLACEHOLDER?] = Optional, delete row/section if not applicable
+
+OUTPUT: Clean, actionable reference file without any template artifacts.
+═══════════════════════════════════════════════════════════════════════════════
+-->
 
-**BEFORE searching files or codebase for information, you MUST:**
+**Purpose**: AI-optimized execution guide for Claude Code agents working with [PROJECT_NAME] codebase
 
-1. **Always check** if the guides referenced below contain relevant information for the prompt or task
-2. **Use the Task Classifier** in [Instant Start](#-instant-start-read-first) to identify which guides are relevant
-3. **Load and review** the appropriate P0 (required) guides BEFORE performing direct file searches
-4. **Only proceed** to codebase searches after confirming guides don't contain the needed patterns/information
+<!-- INSTRUCTION: Extract project name from package.json "name", pom.xml artifactId, pyproject.toml, or root folder name -->
 
-**This rule is MANDATORY and must be followed without exceptions.**
+---
 
-**Why**: Guides contain curated patterns, best practices, and architectural decisions. Checking them first:
-- Prevents reinventing existing patterns
-- Ensures consistency with established conventions
-- Saves time by providing direct answers to common questions
-- Reduces risk of introducing anti-patterns
+## 🚨 CRITICAL RULES (Check Every Task)
+
+| Rule | Trigger | Action |
+|------|---------|--------|
+| **Check Guides First** | ANY task/prompt | ALWAYS check relevant guides BEFORE searching codebase |
+| **Testing** | User says "test", "write tests", "run tests" | ONLY then work on tests |
+| **Git Ops** | User says "commit", "push", "PR", "branch" | ONLY then do git operations |
+| **[ENV_RULE_NAME?]** | [TRIGGER_CONDITION?] | [REQUIRED_ACTION?] |
+| **Shell** | ANY shell command | ONLY bash/Linux syntax |
+
+<!--
+INSTRUCTION: Populate environment rule based on project type:
+- Python with venv: "Virtualenv" | "ANY Python command" | "Activate first: `source .venv/bin/activate`"
+- Node with nvm: "Node Version" | "ANY npm/node command" | "Run: `nvm use`"
+- Docker: "Container" | "ANY app command" | "Run inside container"
+- If no special env requirement, delete the [ENV_RULE_NAME?] row
+-->
 
-**Workflow**: Prompt → Task Classifier → Load Relevant Guides → Check Guide Content → Then Search Codebase (if needed)
+**Recovery**: If stuck → Check [Troubleshooting](#-troubleshooting)
 
 ---
 
-### 📖 Guide References by Category
-
-<!-- FILL IN: Add references to your project-specific guides -->
+## 📚 GUIDE IMPORTS
 
-**[CATEGORY_1]**:
-- [Pattern name]: .codemie/guides/[category]/[pattern-name].md
+<!--
+INSTRUCTION:
+1. List all .md files in .codemie/guides/ directory recursively
+2. Read first 10-20 lines of each guide to understand its purpose
+3. Group by parent folder (category)
+4. Populate table with actual paths and extracted purposes
+-->
 
-**[CATEGORY_2]**:
-- [Pattern name]: .codemie/guides/[category]/[pattern-name].md
+| Category | Guide Path | Purpose |
+|----------|------------|---------|
+| [CATEGORY] | .codemie/guides/[category]/[filename].md | [Brief description extracted from guide] |
 
-<!-- Common categories to consider:
-- Agents & Tools (if using LLM agents)
-- API Development (REST/GraphQL patterns)
-- Architecture (layered architecture, service patterns)
-- Data & Database (database patterns, repositories)
-- Development Practices (error handling, logging, security)
-- Testing (testing patterns, frameworks)
-- Integrations (external services, cloud providers)
-- Standards (code quality, git workflow)
-- Workflows (business workflows, state machines)
+<!--
+EXAMPLE after population:
+| Architecture | .codemie/guides/architecture/layers.md | Service-repository-controller pattern |
+| API | .codemie/guides/api/rest-conventions.md | REST endpoint naming and response formats |
+| Testing | .codemie/guides/testing/unit-tests.md | Unit testing patterns and mocking |
+| Data | .codemie/guides/data/repository-pattern.md | Database access patterns |
 -->
 
 ---
 
-## ⚡ INSTANT START (Read First)
-
-### 1. Critical Rules (MANDATORY - Always Check)
-
-| Rule | Trigger | Action Required |
-|------|---------|-----------------|
-| 🚨 **Check Guides First** | ANY new prompt/task | ALWAYS check relevant guides BEFORE searching codebase → [Guide Imports](#-guide-imports) |
-| 🚨 **Testing** | User says "write tests", "run tests" | ONLY then work on tests → [Testing Policy](#testing-policy) |
-| 🚨 **Git Ops** | User says "commit", "push", "create PR" | ONLY then do git operations → [Git Policy](#git-operations-policy) |
-| 🚨 **[ENV_NAME]** | ANY [language/tool] command | ALWAYS [activation step] → [Env Policy](#environment-policy) |
-| 🚨 **Shell** | ANY shell command | ONLY bash/Linux syntax → [Shell Policy](#shell-environment-policy) |
-
-<!-- FILL IN: Add project-specific critical rules -->
+## ⚡ TASK CLASSIFIER
 
-**Emergency Recovery**: If commands fail → Check [Troubleshooting](#-troubleshooting-quick-reference)
+**Analyze request intent → Match category → Load appropriate guides**
 
-### 2. Task Classifier (What am I doing?)
-
-**Scan user request for keywords → Load guides → Execute**
-
-<!-- FILL IN: Customize based on your project's technology stack and patterns -->
+<!--
+INSTRUCTION:
+1. For each guide category discovered above, define:
+   - User Intent: What is the user trying to ACCOMPLISH (semantic meaning, not keywords)
+   - Example Requests: 2-3 realistic prompts that would match this category
+   - P0 Guide: Primary required guide
+   - P1 Guide: Optional secondary guide (if exists)
+2. Keep only categories that have actual guides
+-->
 
-| Keywords | Complexity | Load Guide (P0=Required) | Also Load (P1=Optional) |
-|----------|-----------|--------------------------|-------------------------|
-| **[keyword1, keyword2]** | Medium-High | .codemie/guides/[category]/[guide].md | .codemie/guides/[category]/[optional-guide].md |
-| **[keyword3, keyword4]** | Medium | .codemie/guides/[category]/[guide].md | - |
+| Category | User Intent / Purpose | Example Requests | P0 Guide | P1 Guide |
+|----------|----------------------|------------------|----------|----------|
+| **[CATEGORY]** | [What user is trying to accomplish] | "[Example 1]", "[Example 2]" | .codemie/guides/[path] | .codemie/guides/[path?] |
 
-<!-- Example entries:
-| **api, endpoint, router** | Medium | .codemie/guides/api/rest-api-patterns.md | .codemie/guides/api/endpoint-conventions.md |
-| **test, pytest** | Medium | .codemie/guides/testing/testing-patterns.md | .codemie/guides/testing/testing-api-patterns.md |
-| **database, sql** | Medium-High | .codemie/guides/data/database-patterns.md | .codemie/guides/data/database-optimization.md |
+<!--
+EXAMPLE after population:
+| **Architecture** | Design decisions, system structure, planning features | "How should I structure?", "Where should this go?" | .codemie/guides/architecture/layers.md | - |
+| **API** | Creating/modifying endpoints, routing, validation | "Create endpoint for...", "Add API to..." | .codemie/guides/api/rest-conventions.md | - |
+| **Data** | Database operations, queries, models, migrations | "Query database", "Add new table" | .codemie/guides/data/repository-pattern.md | - |
+| **Testing** | Writing tests, fixing tests, coverage | "Write tests for...", "Fix failing test" | .codemie/guides/testing/unit-tests.md | - |
 -->
 
-**Guide Path**: All guides in `.codemie/guides/<category>/`
-
-**Complexity Guide**:
-- **Simple**: 1 file, < 5 min, obvious pattern → Use direct tools (Grep/Glob/Read)
-- **Medium**: 2-5 files, 5-15 min, standard patterns → Use direct tools + guide reference
-- **High**: 6+ files, 15+ min, architectural decisions → Consider EnterPlanMode or Task tool
+### Intent Detection
 
-### 3. Self-Check Before Starting
+```
+USER REQUEST
+    ├─> What is the PRIMARY deliverable? → Primary Category (load P0)
+    ├─> What standards must be followed? → Secondary Categories (load P0s)
+    └─> How many files affected? → Complexity (1-2: Simple, 3-5: Medium, 6+: High)
+```
 
-Before any action:
-- [ ] Did I check relevant guides FIRST (before searching codebase)?
-- [ ] Which critical rules apply? (guides/testing/git/env/shell)
-- [ ] What keywords did I identify?
-- [ ] What's the complexity level?
-- [ ] Which guides do I need to load (P0 first)?
-- [ ] Am I 80%+ confident about approach?
+### Complexity Guide
 
-**Decision Gates**:
-- ❌ **NO to any above** → ASK USER or READ MORE before proceeding
-- ❌ **Confidence < 80%** → Load P0 guides, then re-assess
-- ✅ **YES to all + Confidence 80%+** → Proceed to execution
+| Level | Indicators | Action |
+|-------|------------|--------|
+| **Simple** | 1-2 files, clear pattern | P0 guide if unsure |
+| **Medium** | 3-5 files, standard scope | Load P0 guides |
+| **High** | 6+ files, architectural impact | All P0+P1 guides, consider planning mode |
 
 ---
 
-## 🔄 EXECUTION WORKFLOW (Step-by-Step)
-
-Follow this sequence for every task:
+## 🔄 EXECUTION WORKFLOW
 
 ```
 START
-  │
   ├─> STEP 1: Parse Request
-  │   ├─ Identify task keywords (see Task Classifier above)
-  │   ├─ Check which Critical Rules apply
-  │   ├─ Assess complexity level
-  │   └─ Gate: Can I identify 1+ relevant guides? NO → Ask user | YES → Continue
-  │
-  ├─> STEP 2: Confidence Check
-  │   ├─ Am I 80%+ confident about approach?
-  │   ├─ YES → Continue | NO → Load P0 guides
-  │   └─ Gate: After reading, confidence 80%+? NO → Load P1 guides or ask user | YES → Continue
+  │   └─ Match intent to Category → Assess complexity
   │
-  ├─> STEP 3: Load Documentation (Selective, Not Everything)
-  │   ├─ Load P0 guides from Task Classifier (REQUIRED for Medium/High complexity)
-  │   ├─ Scan P1 guides - load only if confidence still < 80% (OPTIONAL)
-  │   └─ Gate: Do I have enough context? NO → Load more or ask user | YES → Continue
+  ├─> STEP 2: Load Guides
+  │   └─ Load P0 guides → Confidence < 80%? → Load P1 or ask user
   │
-  ├─> STEP 4: Pattern Match (Use Quick References)
-  │   ├─ Check Pattern Tables below (error handling, logging, architecture)
-  │   ├─ Check Common Pitfalls table
-  │   └─ Gate: Do I know the correct pattern? NO → Read guide detail | YES → Continue
+  ├─> STEP 3: Execute
+  │   └─ Apply patterns from guides → Follow Critical Rules
   │
-  ├─> STEP 5: Execute (Apply Patterns)
-  │   ├─ Apply patterns from loaded guides
-  │   ├─ Follow Critical Rules (test/git/env/shell)
-  │   ├─ Track progress with success indicators
-  │   └─ Cross-check with Quick Validation (below)
-  │
-  └─> STEP 6: Validate (Before Delivery)
-      ├─ Run through Quick Validation checklist
-      ├─ Check Success Indicators
-      ├─ Gate: All checks pass? NO → Fix issues | YES → Deliver
-      └─ END
+  └─> STEP 4: Validate & Deliver
+      └─ Run checklist → All pass? → Deliver
 ```
 
-### Success Indicators (Am I on track?)
-
-| Stage | Good Signs | Warning Signs |
-|-------|-----------|---------------|
-| **Parse Request** | Keywords match Task Classifier | No matching keywords → ask user |
-| **Confidence Check** | 80%+ confident after reading | Still confused after P0 guides → need clarification |
-| **Load Docs** | Patterns clear, examples match task | Multiple conflicting patterns → ask user preference |
-| **Pattern Match** | Found exact pattern in quick ref | No matching pattern → read full guide |
-| **Execute** | Code compiles, follows architecture | Errors, missing imports → check guide again |
-| **Validate** | All checks pass, tests work | Any check fails → fix before delivery |
-
-### Quick Validation (Run Before Delivery)
-
-<!-- FILL IN: Customize based on your project's quality standards -->
-
-| Priority | Check | How to Verify | Fix If Failed |
-|----------|-------|---------------|---------------|
-| 🚨 | **Functionality** | Does it meet user request? | Re-read requirements |
-| 🚨 | **Critical Rules** | Did I follow test/git/env/shell rules? | Review policies below |
-| 🚨 | **Security** | No hardcoded secrets? Input validated? | See [Security Patterns](#security-patterns-mandatory) |
-| 🚨 | **Error Handling** | Using proper exceptions? | See [Error Handling](#error-handling-use-these-patterns) |
-| 🚨 | **Logging** | Following logging patterns? | See [Logging Patterns](#logging-patterns-mandatory) |
-| ⚠️ | **Architecture** | Followed project architecture? | See guides in .codemie/guides/architecture/ |
-| ⚠️ | **Async/Concurrency** | Used appropriate patterns? | See [Common Pitfalls](#common-pitfalls-avoid-these) |
-| ✅ | **Type Safety** | All functions typed? | See code quality guide |
-| ✅ | **Code Quality** | No TODOs, unused imports? | Run linter |
-
----
-
-## 📊 PATTERN QUICK REFERENCE
-
-<!-- FILL IN: Add quick reference tables for your most common patterns -->
+### Pre-Delivery Checklist
 
-### Error Handling (Use These Patterns)
-
-<!-- Example structure - customize for your project -->
-
-| When | Pattern/Exception | Import From | Related Patterns |
-|------|-------------------|-------------|------------------|
-| Validation failed | `[ValidationError]` | `[module.path]` | [Logging](#logging-patterns-mandatory) |
-| Not found | `[NotFoundException]` | `[module.path]` | [API Patterns](#api-patterns) |
-| Business logic | `[BusinessError]` | `[module.path]` | [Service Layer](#service-layer) |
-
-**Detail**: .codemie/guides/development/error-handling.md
-
-### Logging Patterns (MANDATORY)
-
-<!-- Example structure - customize for your project -->
-
-| ✅ DO | ❌ DON'T | Why | Related |
-|-------|----------|-----|---------|
-| [Best practice 1] | [Anti-pattern 1] | [Reason] | [Related pattern] |
-| [Best practice 2] | [Anti-pattern 2] | [Reason] | [Related pattern] |
-
-**Detail**: .codemie/guides/development/logging-patterns.md
-
-### Architecture Patterns (Core Rules)
-
-<!-- FILL IN: Document your project's architectural layers -->
-
-| Layer | Responsibility | Example Path | Related Guide |
-|-------|----------------|--------------|---------------|
-| **[Layer 1]** | [Responsibility] | `[path/to/layer]` | .codemie/guides/[guide].md |
-| **[Layer 2]** | [Responsibility] | `[path/to/layer]` | .codemie/guides/[guide].md |
-
-**Flow**: `[Layer1] → [Layer2] → [Layer3]` (Never skip layers)
-
-**Detail**: .codemie/guides/architecture/layered-architecture.md
-
-### Security Patterns (MANDATORY)
-
-<!-- FILL IN: Document security requirements -->
-
-| Rule | Implementation | Related Guide |
-|------|----------------|---------------|
-| No hardcoded credentials | [How to handle] | .codemie/guides/development/security-patterns.md |
-| Input validation | [Validation approach] | .codemie/guides/[guide].md |
-| Authentication | [Auth pattern] | .codemie/guides/[guide].md |
-
-**Detail**: .codemie/guides/development/security-patterns.md
-
-### Common Pitfalls (Avoid These)
-
-<!-- FILL IN: Document common mistakes and anti-patterns -->
-
-| Category | 🚨 Never Do This | ✅ Do This Instead | Guide Reference |
-|----------|------------------|---------------------|-----------------|
-| **[Language]** | [Anti-pattern] | [Correct pattern] | .codemie/guides/[guide].md |
-| **[Framework]** | [Anti-pattern] | [Correct pattern] | .codemie/guides/[guide].md |
-| **[Tool]** | [Anti-pattern] | [Correct pattern] | .codemie/guides/[guide].md |
+- [ ] Meets user's request requirements?
+- [ ] Follows patterns from loaded guides?
+- [ ] Critical Rules followed? (testing/git/env)
+- [ ] No hardcoded secrets or credentials?
 
 ---
 
-## 🛠️ DEVELOPMENT COMMANDS
-
-<!-- FILL IN: Document your project's common commands -->
-
-**🚨 CRITICAL**: [Environment setup instructions, e.g., "Activate virtualenv before ALL Python commands"]
+## 🛠️ COMMANDS
 
-### Common Commands
-
-| Task | Command | Env? | Notes |
-|------|---------|------|-------|
-| **Setup** | `[setup command]` | [Y/N] | First time setup |
-| **Run Server** | `[run command]` | [Y/N] | Dev server |
-| **Lint** | `[lint command]` | [Y/N] | Check code quality |
-| **Format** | `[format command]` | [Y/N] | Format code |
-| **Test** ⚠️ | `[test command]` | [Y/N] | ONLY if user requests |
-| **Build** | `[build command]` | [Y/N] | Build project |
-
-<!-- Example entries:
-| **Setup** | `npm install` | N/A | First time setup |
-| **Run Server** | `npm run dev` | N/A | Dev server (port 3000) |
-| **Lint** | `npm run lint` | N/A | ESLint check |
-| **Format** | `npm run format` | N/A | Prettier format |
-| **Test** ⚠️ | `npm test` | N/A | ONLY if user requests |
-| **Build** | `npm run build` | N/A | Production build |
+<!--
+INSTRUCTION:
+1. Extract from package.json scripts, Makefile, pyproject.toml, or build configs
+2. Document commonly used development commands
 -->
 
-**[Additional Info]**: [URLs, ports, documentation links]
-
----
-
-## 🔧 TROUBLESHOOTING QUICK REFERENCE
-
-### Common Issues & Fixes
-
-<!-- FILL IN: Document common issues and solutions -->
-
-| Symptom | Likely Cause | Fix | Prevention |
-|---------|--------------|-----|------------|
-| [Error message/symptom] | [Root cause] | [Solution steps] | [How to prevent] |
-| [Error message/symptom] | [Root cause] | [Solution steps] | [How to prevent] |
-
-### Diagnostic Commands
-
-| Need to Check | Command | What to Look For |
-|---------------|---------|------------------|
-| [System status] | `[diagnostic command]` | [Expected output] |
-| [Dependency status] | `[diagnostic command]` | [Expected output] |
-
-### Emergency Recovery
-
-| Situation | Action |
-|-----------|--------|
-| **Commands failing** | 1. [First recovery step]<br>2. [Second recovery step]<br>3. [Escalation step] |
-| **Build errors** | 1. [First recovery step]<br>2. [Second recovery step] |
-| **Pattern unclear** | 1. Search .codemie/guides/ for pattern<br>2. Check related patterns<br>3. Ask user if ambiguous |
+| Task | Command | Notes |
+|------|---------|-------|
+| **Setup** | `[SETUP_COMMAND]` | First-time setup |
+| **Run Dev** | `[RUN_COMMAND]` | Development server |
+| **Lint** | `[LINT_COMMAND]` | Code quality check |
+| **Format** | `[FORMAT_COMMAND?]` | Auto-format code |
+| **Build** | `[BUILD_COMMAND?]` | Production build |
+| **Test** ⚠️ | `[TEST_COMMAND]` | ONLY when user requests |
 
 ---
 
@@ -306,206 +168,85 @@ START
 
 ### Technology Stack
 
-<!-- FILL IN: Document your technology stack -->
+<!--
+INSTRUCTION: Extract from package.json, requirements.txt, pom.xml, go.mod, etc.
+-->
 
-| Component | Tool | Version | Purpose |
-|-----------|------|---------|---------|
-| Language | [Language] | [Version] | Core language |
-| Framework | [Framework] | [Version] | [Purpose] |
-| Database | [Database] | [Version] | [Purpose] |
-| Testing | [Test framework] | [Version] | Test framework |
-| Linting | [Linter] | [Version] | Code quality |
-| [Other] | [Tool] | [Version] | [Purpose] |
+| Component | Technology | Version |
+|-----------|------------|---------|
+| Language | [LANGUAGE] | [VERSION] |
+| Framework | [FRAMEWORK] | [VERSION] |
+| Database | [DATABASE?] | [VERSION?] |
+| Testing | [TEST_FRAMEWORK] | [VERSION] |
+| Linting | [LINTER?] | [VERSION?] |
 
-### Core Components
+### Project Structure
 
-<!-- FILL IN: Document your project's main components -->
+<!--
+INSTRUCTION: Document main directories developer will work with. Keep concise.
+-->
 
-| Component | Path | Purpose | Guide |
-|-----------|------|---------|-------|
-| [Component 1] | `[path/]` | [Description] | .codemie/guides/[guide].md |
-| [Component 2] | `[path/]` | [Description] | .codemie/guides/[guide].md |
+```
+[PROJECT_ROOT]/
+├── [DIR_1]/              # [Purpose]
+├── [DIR_2]/              # [Purpose]
+├── .codemie/guides/      # Architecture and pattern guides
+└── [DIR_3]/              # [Purpose]
+```
 
-### Key Integrations
+### Key Integrations [OPTIONAL]
 
-<!-- FILL IN: Document external integrations -->
+<!--
+INSTRUCTION: Document external services if any exist. DELETE section if none.
+-->
 
 | Integration | Purpose | Guide |
 |-------------|---------|-------|
-| [Service 1] | [Purpose] | .codemie/guides/integration/[guide].md |
-| [Service 2] | [Purpose] | .codemie/guides/integration/[guide].md |
-
-### Architecture Overview
-
-<!-- FILL IN: Brief architecture description -->
-
-**[Architecture Pattern Name]**:
-- [Key characteristic 1]
-- [Key characteristic 2]
-- [Key characteristic 3]
-- **Detail**: .codemie/guides/architecture/[guide].md
-
----
-
-## 📝 CODING STANDARDS
-
-### [Language] Features (Use These)
-
-<!-- FILL IN: Document language-specific features to use -->
-
-| Feature | Use For | Guide Reference |
-|---------|---------|-----------------|
-| [Feature 1] | [Use case] | .codemie/guides/standards/code-quality.md |
-| [Feature 2] | [Use case] | .codemie/guides/standards/code-quality.md |
-
-**Detail**: .codemie/guides/standards/code-quality.md
-
-### Type Safety (REQUIRED/OPTIONAL)
-
-<!-- FILL IN: Document type safety requirements -->
-
-[Type safety requirements and patterns]
-
-### Async/Concurrency Patterns (CRITICAL)
-
-<!-- FILL IN: Document async patterns if applicable -->
-
-| ✅ DO | ❌ DON'T | Guide |
-|-------|----------|-------|
-| [Best practice] | [Anti-pattern] | .codemie/guides/[guide].md |
+| [SERVICE?] | [Purpose] | .codemie/guides/[path?] |
 
 ---
 
-## 📚 DETAILED POLICIES
-
-### Testing Policy
-
-**MANDATORY RULE**: Tests ONLY when user EXPLICITLY requests
+## 🔧 TROUBLESHOOTING
 
-**Triggers** (work on tests ONLY if user says):
-- ✅ "write tests"
-- ✅ "run the tests"
-- ✅ "create unit tests"
-- ✅ "add test coverage"
-- ✅ `[test command]`
-
-**Never Do**:
-- ❌ Proactively write tests
-- ❌ Suggest running tests
-- ❌ Run tests unless asked
-
-**Framework**: [Test framework and tools]
-
-**Rationale**: Testing requires time and context. Only implement when explicitly needed.
-
-**If Unsure**: Ask user for clarification
-
-**Testing Details**: .codemie/guides/testing/testing-patterns.md
-
-### Git Operations Policy
-
-**MANDATORY RULE**: Git operations ONLY when user EXPLICITLY requests
-
-**Triggers** (do git ops ONLY if user says):
-- ✅ "commit these changes"
-- ✅ "create a commit"
-- ✅ "push to remote"
-- ✅ "create a branch"
-- ✅ "create a pull request"
-
-**Never Do**:
-- ❌ Proactively commit/push/branch
-- ❌ Suggest git operations
-
-**Branch Pattern**: [Branch naming convention]
-
-**Rationale**: Git affects version control history. Only perform when explicitly requested.
-
-**If Unsure**: Ask user for clarification
-
-**Git Details**: .codemie/guides/standards/git-workflow.md
-
-### Environment Policy
-
-<!-- FILL IN: Document environment setup requirements -->
-
-**MANDATORY RULE**: [Environment requirement, e.g., "ALWAYS activate virtualenv BEFORE Python commands"]
-
-**Why**: [Reason]
-
-**How to Activate**: `[activation command]`
-
-**Alternative**: [Alternative approach if applicable]
-
-**Rule of Thumb**: [When to know environment is not set up correctly]
-
-**Recovery**: See [Troubleshooting](#-troubleshooting-quick-reference)
-
-**Detail**: .codemie/guides/development/setup-guide.md
-
-### Shell Environment Policy
-
-**MANDATORY RULE**: Use bash/Linux commands ONLY
-
-**Requirements**:
-- ✅ Bash/shell syntax for all commands
-- ✅ Linux-compatible commands
-- ❌ No Windows commands (PowerShell, cmd.exe)
+<!--
+INSTRUCTION: Document known issues specific to this project. Include common setup problems.
+-->
 
-**Rationale**: Ensures consistency across development environments
+| Symptom | Cause | Solution |
+|---------|-------|----------|
+| [ERROR_OR_SYMPTOM] | [ROOT_CAUSE] | [FIX] |
+| Commands fail | Environment not set | [ACTIVATION_COMMAND] |
 
 ---
 
 ## 🎯 REMEMBER
 
-### Critical Workflow
-1. ⚡ Read [Instant Start](#-instant-start-read-first)
-2. ✅ Run [Self-Check](#3-self-check-before-starting) (check confidence level)
-3. 🔄 Follow [Execution Workflow](#-execution-workflow-step-by-step) (step-by-step with gates)
-4. 📊 Use [Pattern Quick Reference](#-pattern-quick-reference) (fast lookups)
-5. 🔍 Track [Success Indicators](#success-indicators-am-i-on-track) (am I on track?)
-6. ✅ [Validate before delivery](#quick-validation-run-before-delivery) (all checks must pass)
-
-### Critical Rules (Check EVERY Time)
-- 🚨 **Check Guides First**: ALWAYS check relevant guides BEFORE searching codebase
-- 🚨 **Testing**: Only when explicitly requested
-- 🚨 **Git**: Only when explicitly requested
-- 🚨 **Environment**: [Environment requirement]
-- 🚨 **Shell**: Bash/Linux only
-
-### Decision Making Framework
-1. **Parse**: Use Task Classifier to identify keywords → guides → complexity
-2. **Confidence**: Am I 80%+ confident? NO → Load P0 guides
-3. **Load**: P0 (required) first, then P1 (optional) only if needed
-4. **Execute**: Apply patterns, follow critical rules, track success indicators
-5. **Validate**: All checks must pass before delivery
-6. **Stuck?**: Check [Troubleshooting](#-troubleshooting-quick-reference), load more guides, or ask user
-
-### Quality Standards (Non-Negotiable)
-
-<!-- FILL IN: Document quality requirements -->
-
-- No hardcoded secrets (use environment variables)
-- No placeholders/TODOs in delivered code
-- [Security requirement]
-- [Architecture requirement]
-- [Performance requirement]
-- Type safety on all functions (if applicable)
-- Specific exception handling (no bare catches)
+### Workflow
+1. **Parse** → Match intent to Category (Task Classifier)
+2. **Load** → Read P0 guides for matched categories
+3. **Check** → Confidence ≥ 80%? No → load more or ask user
+4. **Execute** → Apply patterns from guides
+5. **Validate** → Checklist must pass
+6. **Deliver**
 
 ### When to Ask User
-- **Ambiguous requirements**: Multiple valid approaches possible
-- **Low confidence**: < 80% after reading P0+P1 guides
-- **Missing information**: Need clarification on scope/approach
-- **High complexity**: Task involves architectural decisions
-- **Policy unclear**: Unsure if testing/git/other policy applies
-
-### Confidence Calibration
-- **90%+ confident**: Proceed with execution, minimal guide lookup
-- **80-89% confident**: Review quick reference tables, proceed
-- **70-79% confident**: Load P0 guides, then re-assess
-- **< 70% confident**: Load P0+P1 guides, ask user if still unclear
+- Ambiguous requirements
+- Low confidence after reading guides
+- Missing information
+- Unsure if policy applies
 
-**Production Ready**: Deliver complete, tested, secure solutions without shortcuts.
+---
 
-**Questions?** Always better to ask than assume - ask for clarification when unsure.
+<!--
+═══════════════════════════════════════════════════════════════════════════════
+FINAL CHECKLIST BEFORE DELIVERING POPULATED CLAUDE.md:
+═══════════════════════════════════════════════════════════════════════════════
+[ ] All [PLACEHOLDER] values replaced with actual project data
+[ ] All [PLACEHOLDER?] either replaced or deleted with their rows/sections
+[ ] All <!-- INSTRUCTION --> comments removed
+[ ] Guide paths verified to exist
+[ ] Commands verified from config files
+[ ] Empty/optional sections deleted if not applicable
+[ ] No template artifacts remain
+═══════════════════════════════════════════════════════════════════════════════
+-->