@iservu-inc/adf-cli 0.11.0 → 0.12.9

package/lib/generators/agents-md-generator.js

@@ -2,9 +2,10 @@ const ToolConfigGenerator = require('./tool-config-generator');
 
 /**
  * Generator for AGENTS.md - Universal AI coding agent instructions
- * Supported by: OpenAI Codex, Cursor, Windsurf, Google Jules, Factory, and more
+ * Supported by: OpenAI Codex, Cursor, Windsurf, Google Jules, Factory, Zed, Antigravity, and more
  *
  * AGENTS.md is the industry standard open format for AI agent configuration
+ * Follows the Agent-Native Development Framework (ANDF) specification
  * See: https://agents.md/ and https://github.com/openai/agents.md
  */
 class AgentsMdGenerator extends ToolConfigGenerator {
@@ -14,6 +15,10 @@ class AgentsMdGenerator extends ToolConfigGenerator {
   async generate() {
     await this.initialize();
 
+    // Generate YAML frontmatter
+    const frontmatter = this.generateFrontmatter();
+
+    // Generate content based on framework
     let content;
     if (this.framework === 'rapid') {
       content = this.generateFromPRP();
@@ -25,90 +30,245 @@ class AgentsMdGenerator extends ToolConfigGenerator {
       throw new Error(`Unknown framework: ${this.framework}`);
     }
 
-    const filePath = await this.writeToProject('AGENTS.md', content);
+    // Combine frontmatter and content
+    const fullContent = `${frontmatter}\n${content}`;
+
+    const filePath = await this.writeToProject('AGENTS.md', fullContent);
     return filePath;
   }
 
   /**
-   * Generate AGENTS.md from PRP framework
+   * Generate YAML frontmatter with agent metadata and MCP tools
+   * Follows ANDF specification
    */
-  generateFromPRP() {
+  generateFrontmatter() {
+    const agentName = this.getAgentName();
+    const description = this.getAgentDescription();
+    const tools = this.getMCPTools();
+
+    const frontmatter = `---
+name: ${agentName}
+description: ${description}
+tools:${tools.map(tool => `
+  - name: ${tool.name}
+    ${tool.url ? `url: ${tool.url}` : `command: ${tool.command}`}${tool.args ? `
+    args: ${JSON.stringify(tool.args)}` : ''}${tool.description ? `
+    description: ${tool.description}` : ''}`).join('')}
+---`;
+
+    return frontmatter;
+  }
+
+  /**
+   * Get agent name based on framework and project
+   */
+  getAgentName() {
     const projectName = this.getProjectName();
-    const sections = this.outputs.sections || {};
 
-    return `# ${projectName}
+    // Map framework to agent role
+    const roleMap = {
+      'rapid': 'Developer',
+      'balanced': 'Project Architect',
+      'comprehensive': 'Solutions Architect'
+    };
 
-## Overview
+    const role = roleMap[this.framework] || 'Developer';
+    return `${projectName} ${role}`;
+  }
 
-${sections['1._goal_definition'] || sections['goal_definition'] || 'AI-powered software development project'}
+  /**
+   * Get agent description based on framework and tech stack
+   */
+  getAgentDescription() {
+    const techStack = this.extractTechStackForDescription();
 
-## Tech Stack
+    const roleDescriptions = {
+      'rapid': `Expert developer specializing in ${techStack}`,
+      'balanced': `Full-stack architect with expertise in ${techStack}`,
+      'comprehensive': `Enterprise solutions architect specializing in ${techStack}`
+    };
 
-${this.extractTechStack(sections)}
+    return roleDescriptions[this.framework] || `Software development expert in ${techStack}`;
+  }
 
-## Build Commands
+  /**
+   * Extract tech stack for description
+   */
+  extractTechStackForDescription() {
+    // Try to extract from metadata
+    if (this.metadata && this.metadata.techStack) {
+      return this.metadata.techStack;
+    }
+
+    // Try to extract from outputs based on framework
+    if (this.framework === 'rapid' && this.outputs.sections) {
+      const sections = this.outputs.sections;
+      const contextSection = sections['3._contextual_intelligence'] || sections['contextual_intelligence'] || '';
+
+      // Look for common tech stack patterns
+      const techPatterns = [
+        /(?:using|built with|tech stack|technologies):\s*([^\n]+)/i,
+        /(?:react|vue|angular|next|svelte|node|express|django|rails|spring)/gi
+      ];
+
+      for (const pattern of techPatterns) {
+        const match = contextSection.match(pattern);
+        if (match) {
+          return match[1] || match[0];
+        }
+      }
+    }
+
+    return 'modern web technologies';
+  }
 
+  /**
+   * Get MCP tools configuration
+   * Returns array of tool configurations for various MCP servers
+   */
+  getMCPTools() {
+    const tools = [
+      {
+        name: 'project_context',
+        command: 'npx',
+        args: ['@modelcontextprotocol/server-filesystem', '.context'],
+        description: 'Access project context files (architecture, glossary, memory)'
+      }
+    ];
+
+    // Add Archon if configured in environment or metadata
+    const archonUrl = process.env.ARCHON_MCP_URL || this.metadata?.archonUrl;
+    if (archonUrl) {
+      tools.unshift({
+        name: 'archon',
+        url: archonUrl,
+        description: 'Internal API documentation and RAG system'
+      });
+    }
+
+    return tools;
+  }
+
+  /**
+   * Generate AGENTS.md from PRP framework (ANDF-compliant)
+   */
+  generateFromPRP() {
+    const projectName = this.getProjectName();
+    const sections = this.outputs.sections || {};
+    const sessionId = this.getSessionId();
+
+    return `
+# AGENTS.md - The Agent Manifest
+
+## 1. Operational Rules (High Priority)
+
+- **Source of Truth**: Before answering, consult \`.context/memory/architecture.md\` for system design
+- **Read Context First**: Review \`.adf/sessions/${sessionId}/outputs/prp.md\` for complete requirements
+- **Security**: Never output \`.env\` secrets or API keys in code or logs
+- **Testing**: All code changes must pass the test suite before committing
+- **Follow Blueprint**: Implement features exactly as specified in the Implementation Blueprint
+- **Validate Success**: Verify against Success Criteria before marking tasks complete
+
+## 2. Build & Test Commands
+
+### Installation
 \`\`\`bash
 # Install dependencies
 npm install
+\`\`\`
 
+### Development
+\`\`\`bash
 # Build project
 npm run build
-\`\`\`
 
-## Test Commands
+# Run in development mode (if applicable)
+npm run dev
+\`\`\`
 
+### Testing
 \`\`\`bash
 # Run tests
 npm test
 
 # Run tests with coverage
 npm run test:coverage
-\`\`\`
-
-## Implementation Blueprint
 
-${sections['4._implementation_blueprint'] || sections['implementation_blueprint'] || ''}
+# Run linter
+npm run lint
+\`\`\`
 
-## Success Criteria
+## 3. Project Structure
 
-${sections['5._validation'] || sections['validation'] || ''}
+- \`/.adf/\`: Framework data (sessions, learning, configuration) - DO NOT MODIFY
+- \`/.context/\`: Agent-accessible deep context
+  - \`/memory/architecture.md\`: System architecture and technical design
+  - \`/memory/glossary.md\`: Domain-specific terminology
+- \`/src/\`: Application source code
+- \`/tests/\`: Test files
 
-## Development Workflow
+## 4. Workflow Directives
 
-1. Review the goal and requirements
+### Development Process
+1. Review the goal definition and requirements
 2. Check the implementation blueprint
-3. Write tests first (if applicable)
-4. Implement feature following the blueprint
+3. Write tests first (TDD approach when applicable)
+4. Implement feature following the blueprint exactly
 5. Verify against success criteria
-6. Test thoroughly before committing
+6. Run full test suite
+7. Review code quality and documentation
+
+### Code Standards
+- **Commits**: Use Conventional Commits format (e.g., \`feat: add user auth\`)
+- **Refactoring**: Prioritize readability and maintainability over brevity
+- **Documentation**: Add comments for complex logic, update README when needed
+- **Error Handling**: Handle errors gracefully with descriptive messages
+
+## 5. Project Context
+
+### Goal Definition
+${sections['1._goal_definition'] || sections['goal_definition'] || 'AI-powered software development project'}
+
+### Tech Stack
+${this.extractTechStack(sections)}
 
-## Key Context
+### Implementation Blueprint
+${sections['4._implementation_blueprint'] || sections['implementation_blueprint'] || 'See PRP document for implementation details'}
 
-All project requirements and context are documented in:
-- Framework outputs: \`.adf/sessions/${this.getSessionId()}/outputs/\`
-- Q&A responses: \`.adf/sessions/${this.getSessionId()}/qa-responses/\`
+### Success Criteria
+${sections['5._validation'] || sections['validation'] || 'See PRP document for validation criteria'}
 
-## AI Agent Instructions
+## 6. Key Context Files
 
-When working on this project:
-1. **Read the full context** in \`.adf/sessions/${this.getSessionId()}/outputs/prp.md\`
-2. **Follow the implementation blueprint** exactly as specified
-3. **Validate against success criteria** before marking tasks complete
-4. **Ask clarifying questions** if requirements are unclear
-5. **Maintain consistency** with the tech stack and architecture
+- **PRP Document**: \`.adf/sessions/${sessionId}/outputs/prp.md\` - Complete requirements
+- **Architecture**: \`.context/memory/architecture.md\` - System design (reference this first!)
+- **Q&A Responses**: \`.adf/sessions/${sessionId}/qa-responses/\` - Detailed interview responses
+
+## 7. AI Agent Instructions
+
+When working on this project, you MUST:
+
+1. **Read architecture first** - Consult \`.context/memory/architecture.md\` before making changes
+2. **Follow the blueprint** - Implement exactly as specified, don't deviate
+3. **Validate continuously** - Check against success criteria throughout development
+4. **Ask before changing** - If requirements are unclear or architecture changes needed, ask first
+5. **Maintain consistency** - With established tech stack, patterns, and conventions
+6. **Test thoroughly** - All changes must pass tests before committing
+7. **Never compromise security** - Follow security best practices, no secrets in code
 
 ---
 
 *Generated by [ADF CLI](https://www.npmjs.com/package/@iservu-inc/adf-cli) v${this.getADFVersion()}*
+*Framework: Rapid Development (PRP) | Session: ${sessionId}*
 `;
   }
 
   /**
-   * Generate AGENTS.md from Balanced framework
+   * Generate AGENTS.md from Balanced framework (ANDF-compliant)
    */
   generateFromBalanced() {
     const projectName = this.getProjectName();
+    const sessionId = this.getSessionId();
     const constitution = this.outputs.constitution || '';
     const specification = this.outputs.specification || '';
     const plan = this.outputs.plan || '';
@@ -118,47 +278,42 @@ When working on this project:
     const architecture = this.extractSection(specification, 'Architecture');
     const techStack = this.extractSection(plan, 'Technology Stack');
 
-    return `# ${projectName}
-
-## Overview
-
-${this.extractSection(specification, 'Overview') || this.extractSection(specification, 'Purpose')}
-
-## Constitution
-
-### Core Principles
-
-${principles || 'Follow best practices for software development'}
-
-### Constraints
-
-${constraints || 'No specific constraints defined'}
-
-## Tech Stack
-
-${techStack || 'See technical plan for details'}
+    return `
+# AGENTS.md - The Agent Manifest
 
-## Architecture
+## 1. Operational Rules (High Priority)
 
-${architecture || 'See specification.md for complete architecture'}
+- **Source of Truth**: Consult \`.context/memory/architecture.md\` for system design decisions
+- **Read Constitution First**: Review \`.adf/sessions/${sessionId}/outputs/constitution.md\` for principles
+- **Security**: Never output \`.env\` secrets or API keys in code or logs
+- **Testing**: All code changes must pass the test suite before committing
+- **Follow Spec**: Implement according to specification.md requirements exactly
+- **Respect Constraints**: The constraints in constitution.md are NON-NEGOTIABLE
+- **Architecture First**: Never deviate from architectural patterns without approval
 
-## Build Commands
+## 2. Build & Test Commands
 
+### Installation
 \`\`\`bash
 # Install dependencies
 npm install
+\`\`\`
 
+### Development
+\`\`\`bash
 # Build project
 npm run build
 
 # Run in development mode
 npm run dev
-\`\`\`
 
-## Test Commands
+# Watch for changes
+npm run watch
+\`\`\`
 
+### Testing
 \`\`\`bash
-# Run tests
+# Run all tests
 npm test
 
 # Run tests with coverage
@@ -166,58 +321,95 @@ npm run test:coverage
 
 # Run linter
 npm run lint
-\`\`\`
 
-## Development Workflow
+# Run type checking (if applicable)
+npm run type-check
+\`\`\`
 
-1. Review the constitution and principles
-2. Check the specification for requirements
-3. Consult the technical plan for architecture decisions
-4. Review tasks.md for implementation breakdown
-5. Write tests first (TDD approach)
-6. Implement following architecture patterns
+## 3. Project Structure
+
+- \`/.adf/\`: Framework data (sessions, learning, configuration) - DO NOT MODIFY
+- \`/.context/\`: Agent-accessible deep context
+  - \`/memory/architecture.md\`: Complete system architecture and design decisions
+  - \`/memory/glossary.md\`: Domain-specific terminology and definitions
+- \`/src/\`: Application source code
+- \`/tests/\`: Test files and test utilities
+- \`/docs/\`: Additional documentation
+
+## 4. Workflow Directives
+
+### Development Process
+1. Review the constitution - understand principles and constraints
+2. Study the specification - know detailed requirements
+3. Consult the technical plan - understand architecture and tech stack
+4. Review tasks.md - understand implementation breakdown
+5. Write tests first (strict TDD approach)
+6. Implement following established architecture patterns
 7. Verify against acceptance criteria
-8. Run tests and linter before committing
+8. Run full test suite and linter
+9. Review code quality and documentation
+
+### Code Standards
+- **Commits**: Use Conventional Commits format (e.g., \`feat: add user auth\`)
+- **Refactoring**: Prioritize readability and maintainability
+- **Documentation**: Comprehensive comments for complex logic
+- **Error Handling**: Graceful error handling with descriptive messages
+- **Type Safety**: Use TypeScript or JSDoc for type annotations (if applicable)
+
+### Architecture Patterns
+${architecture ? `\n${architecture}\n` : 'See specification.md and .context/memory/architecture.md for detailed patterns'}
+
+## 5. Constitution & Constraints
+
+### Core Principles
+${principles || 'Follow best practices for software development'}
+
+### Constraints (NON-NEGOTIABLE)
+${constraints || 'No specific constraints defined - follow general best practices'}
 
-## Code Style
+## 6. Technical Overview
 
-See technical plan for detailed coding standards.
+### Tech Stack
+${techStack || 'See technical plan for complete technology stack details'}
 
-**Key Points:**
-- Follow the architecture patterns defined in specification.md
-- Adhere to the constraints in constitution.md
-- Implement tasks as outlined in tasks.md
+### System Architecture
+${this.extractSection(specification, 'Overview') || this.extractSection(specification, 'Purpose') || 'See specification.md for complete system overview'}
 
-## Key Context Files
+## 7. Key Context Files
 
-- **Constitution**: \`.adf/sessions/${this.getSessionId()}/outputs/constitution.md\` - Principles and constraints
-- **Specification**: \`.adf/sessions/${this.getSessionId()}/outputs/specification.md\` - Detailed requirements
-- **Technical Plan**: \`.adf/sessions/${this.getSessionId()}/outputs/plan.md\` - Architecture and decisions
-- **Tasks**: \`.adf/sessions/${this.getSessionId()}/outputs/tasks.md\` - Implementation breakdown
+- **Constitution**: \`.adf/sessions/${sessionId}/outputs/constitution.md\` - Principles and constraints (read first!)
+- **Specification**: \`.adf/sessions/${sessionId}/outputs/specification.md\` - Detailed requirements and design
+- **Technical Plan**: \`.adf/sessions/${sessionId}/outputs/plan.md\` - Architecture decisions and tech stack
+- **Tasks**: \`.adf/sessions/${sessionId}/outputs/tasks.md\` - Implementation breakdown and phases
+- **Architecture**: \`.context/memory/architecture.md\` - Complete system design (reference this!)
 
-## AI Agent Instructions
+## 8. AI Agent Instructions
 
-When working on this project:
+When working on this project, you MUST:
 
-1. **Read the constitution first** - Understand principles and constraints
-2. **Review the specification** - Know what needs to be built
-3. **Check the technical plan** - Follow architectural decisions
-4. **Reference tasks.md** - Understand implementation phases
-5. **Never violate constraints** - These are non-negotiable
-6. **Ask before deviating** - If architecture changes are needed
-7. **Maintain consistency** - With established patterns and decisions
+1. **Read constitution FIRST** - Understand principles and constraints before any code
+2. **Never violate constraints** - Constraints are non-negotiable, NO EXCEPTIONS
+3. **Follow architecture** - Stick to patterns defined in specification and architecture docs
+4. **Consult technical plan** - All tech decisions should align with the plan
+5. **Reference tasks.md** - Understand the implementation phases and current priorities
+6. **Ask before deviating** - If requirements conflict or architecture needs changes, ASK
+7. **Maintain consistency** - With established patterns, conventions, and decisions
+8. **Test thoroughly** - TDD approach, all tests must pass
+9. **Document decisions** - Update docs when making significant choices
 
 ---
 
 *Generated by [ADF CLI](https://www.npmjs.com/package/@iservu-inc/adf-cli) v${this.getADFVersion()}*
+*Framework: Balanced (Specification-Driven) | Session: ${sessionId}*
 `;
   }
 
   /**
-   * Generate AGENTS.md from BMAD framework
+   * Generate AGENTS.md from BMAD framework (ANDF-compliant)
    */
   generateFromBMAD() {
     const projectName = this.getProjectName();
+    const sessionId = this.getSessionId();
     const prd = this.outputs.prd || '';
     const architecture = this.outputs.architecture || '';
 
@@ -229,42 +421,50 @@ When working on this project:
     const archOverview = this.extractSection(architecture, 'System Overview') ||
                          this.extractSection(architecture, 'Architecture Overview');
 
-    return `# ${projectName}
-
-## Product Overview
-
-${overview || 'Comprehensive software development project'}
-
-## Goals and Objectives
-
-${goals || 'See PRD for detailed goals'}
-
-## Technical Requirements
+    return `
+# AGENTS.md - The Agent Manifest
 
-${techRequirements || 'See PRD for complete technical requirements'}
+## 1. Operational Rules (High Priority)
 
-## Architecture
+- **Source of Truth**: Consult \`.context/memory/architecture.md\` for complete system design
+- **Read PRD First**: Review \`.adf/sessions/${sessionId}/outputs/prd.md\` for product vision
+- **Security**: Never output \`.env\` secrets, API keys, or sensitive data in code or logs
+- **Testing**: All code changes must pass unit, integration, and e2e tests before committing
+- **Follow Architecture**: Strictly adhere to architectural patterns defined in architecture.md
+- **User Stories**: Implement exactly as specified in stories.md with acceptance criteria
+- **Quality Standards**: Maintain >= 80% test coverage for all new code
+- **Performance First**: Consider scalability, performance, and resource usage in all decisions
 
-${archOverview || 'See architecture.md for complete system design'}
-
-## Build Commands
+## 2. Build & Test Commands
 
+### Installation
 \`\`\`bash
 # Install dependencies
 npm install
 
+# Install development tools
+npm run install:dev
+\`\`\`
+
+### Development
+\`\`\`bash
 # Build project
 npm run build
 
 # Run in development mode
 npm run dev
 
-# Run production build
+# Run in production mode
+npm run start
+
+# Build for production
 npm run build:production
-\`\`\`
 
-## Test Commands
+# Watch for changes
+npm run watch
+\`\`\`
 
+### Testing
 \`\`\`bash
 # Run all tests
 npm test
@@ -272,74 +472,144 @@ npm test
 # Run tests with coverage
 npm run test:coverage
 
+# Run unit tests only
+npm run test:unit
+
 # Run integration tests
 npm run test:integration
 
-# Run e2e tests
+# Run end-to-end tests
 npm run test:e2e
 
 # Run linter
 npm run lint
-\`\`\`
-
-## Development Workflow
-
-1. Review the PRD (Product Requirements Document)
-2. Understand the system architecture
-3. Review relevant user stories
-4. Plan implementation approach
-5. Write tests first (TDD)
-6. Implement following architecture patterns
-7. Verify against acceptance criteria
-8. Run full test suite
-9. Create pull request with description
-
-## Code Quality Standards
-
-- Maintain test coverage >= 80%
-- Follow architectural patterns defined in architecture.md
-- Implement user stories as specified in stories.md
-- Write clean, maintainable, documented code
-- Handle errors gracefully
-- Consider scalability and performance
 
-## Key Context Files
+# Run type checking
+npm run type-check
 
-- **PRD**: \`.adf/sessions/${this.getSessionId()}/outputs/prd.md\` - Complete product requirements
-- **Architecture**: \`.adf/sessions/${this.getSessionId()}/outputs/architecture.md\` - System design and technical architecture
-- **User Stories**: \`.adf/sessions/${this.getSessionId()}/outputs/stories.md\` - Detailed user stories with acceptance criteria
-
-## AI Agent Instructions
-
-When working on this project:
-
-1. **Read the PRD thoroughly** - Understand the complete product vision
-2. **Study the architecture** - Know the system design and component structure
-3. **Review user stories** - Understand user needs and acceptance criteria
-4. **Follow architectural patterns** - Maintain consistency with established design
-5. **Implement with quality** - Tests, documentation, error handling
-6. **Think long-term** - Consider scalability, maintainability, performance
-7. **Validate against requirements** - Ensure implementation matches PRD
-8. **Ask before major changes** - Architectural decisions should be discussed
+# Run full CI suite
+npm run ci
+\`\`\`
 
-## Security Notes
+### Quality Checks
+\`\`\`bash
+# Run security audit
+npm audit
 
-- Never commit sensitive data (API keys, passwords, tokens)
-- Use environment variables for configuration
-- Validate all user input
-- Follow security best practices
-- See PRD for specific security requirements
+# Check for outdated dependencies
+npm outdated
 
-## Performance Considerations
+# Run performance benchmarks (if applicable)
+npm run benchmark
+\`\`\`
 
-- Follow performance requirements in PRD
-- Optimize critical paths
-- Monitor resource usage
-- See architecture.md for performance patterns
+## 3. Project Structure
+
+- \`/.adf/\`: Framework data (sessions, learning, configuration) - DO NOT MODIFY
+- \`/.context/\`: Agent-accessible deep context
+  - \`/memory/architecture.md\`: Complete enterprise architecture and design decisions
+  - \`/memory/glossary.md\`: Domain-specific terminology and business definitions
+- \`/src/\`: Application source code
+- \`/tests/\`: Comprehensive test suite
+  - \`/unit/\`: Unit tests
+  - \`/integration/\`: Integration tests
+  - \`/e2e/\`: End-to-end tests
+- \`/docs/\`: Documentation (API docs, architecture diagrams, guides)
+- \`/scripts/\`: Build and deployment scripts
+
+## 4. Workflow Directives
+
+### Development Process (Enterprise-Grade)
+1. Review the PRD - understand complete product vision and business requirements
+2. Study the architecture document - know system design, components, and data flow
+3. Review relevant user stories - understand user needs and acceptance criteria
+4. Plan implementation approach - design before coding
+5. Write tests FIRST (strict TDD approach)
+   - Unit tests for business logic
+   - Integration tests for component interaction
+   - E2E tests for user workflows
+6. Implement following established architecture patterns exactly
+7. Verify against acceptance criteria continuously
+8. Run full test suite (unit + integration + e2e)
+9. Run linter, type checker, and security audit
+10. Review code quality and performance
+11. Create pull request with comprehensive description
+12. Request code review from team
+
+### Code Standards (Enterprise-Grade)
+- **Commits**: Use Conventional Commits format with scope (e.g., \`feat(auth): add OAuth support\`)
+- **Refactoring**: Prioritize readability, maintainability, and performance
+- **Documentation**: Comprehensive JSDoc/TSDoc for all public APIs
+- **Error Handling**: Graceful error handling with structured logging
+- **Type Safety**: Full TypeScript types or comprehensive JSDoc type annotations
+- **Code Coverage**: Maintain >= 80% coverage, >= 90% for critical paths
+- **Performance**: Profile before optimizing, benchmark critical operations
+
+### Architecture Patterns (Enterprise)
+${archOverview ? `\n${archOverview}\n` : 'See architecture.md and .context/memory/architecture.md for comprehensive patterns'}
+
+## 5. Product Vision & Requirements
+
+### Product Overview
+${overview || 'Comprehensive enterprise software development project'}
+
+### Goals and Objectives
+${goals || 'See PRD for detailed business goals and success metrics'}
+
+### Technical Requirements
+${techRequirements || 'See PRD for complete technical requirements and constraints'}
+
+## 6. Quality Standards
+
+### Test Coverage Requirements
+- **Unit Tests**: >= 80% coverage for all business logic
+- **Integration Tests**: All component interfaces and APIs
+- **E2E Tests**: All critical user workflows and happy paths
+- **Security**: OWASP Top 10 compliance, regular security audits
+
+### Performance Standards
+- Follow performance requirements defined in PRD
+- Optimize critical paths (database queries, API calls, rendering)
+- Monitor resource usage (memory, CPU, network)
+- See architecture.md for specific performance patterns and benchmarks
+
+### Security Standards
+- Never commit sensitive data (API keys, passwords, tokens, credentials)
+- Use environment variables for all configuration
+- Validate and sanitize all user input
+- Implement proper authentication and authorization
+- Follow security best practices (HTTPS, CORS, CSP, etc.)
+- See PRD for specific security requirements and compliance needs
+
+## 7. Key Context Files
+
+- **PRD**: \`.adf/sessions/${sessionId}/outputs/prd.md\` - Complete product requirements (read first!)
+- **Architecture**: \`.adf/sessions/${sessionId}/outputs/architecture.md\` - System design and technical architecture
+- **User Stories**: \`.adf/sessions/${sessionId}/outputs/stories.md\` - Detailed user stories with acceptance criteria
+- **Architecture Memory**: \`.context/memory/architecture.md\` - Complete enterprise architecture (reference this!)
+- **Glossary**: \`.context/memory/glossary.md\` - Business and technical terminology
+
+## 8. AI Agent Instructions
+
+When working on this project, you MUST:
+
+1. **Read PRD thoroughly FIRST** - Understand complete product vision and business context
+2. **Study architecture deeply** - Know system design, component structure, and data flow
+3. **Review user stories** - Understand user needs and acceptance criteria before coding
+4. **Follow architecture religiously** - Maintain consistency with established enterprise patterns
+5. **Think long-term** - Consider scalability, maintainability, performance, and extensibility
+6. **Implement with quality** - Comprehensive tests, documentation, error handling, logging
+7. **Validate continuously** - Ensure implementation matches PRD and user stories
+8. **Ask before major changes** - Architectural decisions and pattern changes require discussion
+9. **Never compromise security** - Security is non-negotiable, follow all best practices
+10. **Test thoroughly** - Unit + integration + e2e tests, all must pass
+11. **Document comprehensively** - Code comments, API docs, architecture decisions
+12. **Monitor performance** - Profile, benchmark, and optimize critical paths
 
 ---
 
 *Generated by [ADF CLI](https://www.npmjs.com/package/@iservu-inc/adf-cli) v${this.getADFVersion()}*
+*Framework: BMAD Comprehensive (Enterprise) | Session: ${sessionId}*
 `;
   }