[buffbench] Expand Codelayer agent collection with specialized agents

and comprehensive documentation

Adds five new Codelayer agents (spec-parser, completion-verifier,
project-context-analyzer, smart-discovery, validation-pipeline) to
enhance the foundational agent's capabilities. Includes implementation
strategy, improvement plans, evaluation results, and summary
documentation for the expanded agent ecosystem.

🤖 Generated with Codebuff Co-Authored-By: Codebuff
<noreply@codebuff.com>

Author: brandonkachen

.agents/codelayer/codelayer-base.ts

@@ -24,6 +24,11 @@ const definition: SecretAgentDefinition = {
     'thoughts-analyzer',
     'thoughts-locator',
     'web-search-researcher',
+    'codelayer/spec-parser',
+    'codelayer/completion-verifier',
+    'codelayer/project-context-analyzer',
+    'codelayer/smart-discovery',
+    'codelayer/validation-pipeline',
   ],
 
   inputSchema: {
@@ -79,6 +84,8 @@ Always read the command files to get the latest instructions rather than relying
 
   instructionsPrompt:
     'As Codelayer Base, you are a foundational agent in the Codelayer collection that provides core functionality and coordination. You can detect trigger phrases in user input and execute corresponding commands by reading markdown files from the commands directory. When you detect triggers, read the appropriate .md file, extract the prompt section, and follow the instructions. Always coordinate with other Codelayer agents as needed and provide clear, helpful responses about command execution and results.',
+
+
 }
 
 export default definition

.agents/codelayer/completion-verifier.ts

@@ -0,0 +1,103 @@
+import type { AgentDefinition } from '../types/agent-definition'
+
+const definition: AgentDefinition = {
+  id: 'completion-verifier',
+  publisher: 'codelayer',
+  model: 'google/gemini-2.5-flash',
+  displayName: 'Completion Verifier',
+  
+  toolNames: ['read_files', 'code_search', 'set_output'],
+  
+  inputSchema: {
+    prompt: {
+      type: 'string',
+      description: 'Context about what should be verified for completion'
+    },
+    params: {
+      type: 'object',
+      properties: {
+        requirements: {
+          type: 'array',
+          description: 'Original requirements from spec-parser'
+        },
+        completedSubgoals: {
+          type: 'array',
+          description: 'List of completed subgoal IDs'
+        }
+      },
+      required: ['requirements']
+    }
+  },
+  
+  outputMode: 'structured_output',
+  outputSchema: {
+    type: 'object',
+    properties: {
+      overallComplete: {
+        type: 'boolean'
+      },
+      completedRequirements: {
+        type: 'array',
+        items: { type: 'string' }
+      },
+      missingRequirements: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            id: { type: 'string' },
+            description: { type: 'string' },
+            reason: { type: 'string' }
+          }
+        }
+      },
+      qualityIssues: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            file: { type: 'string' },
+            issue: { type: 'string' },
+            severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low'] }
+          }
+        }
+      }
+    },
+    required: ['overallComplete', 'completedRequirements', 'missingRequirements']
+  },
+  
+  spawnerPrompt: 'Verify that all requirements from a user request have been properly completed and implemented',
+  
+  systemPrompt: 'You are a completion verifier that ensures all parts of a user request have been properly implemented. Your job is to prevent the common failure mode of dropping requirements.',
+  
+  instructionsPrompt: `Verify completion by checking each requirement against actual implementation:
+
+**Verification Process:**
+1. **Cross-reference requirements** - Check each requirement against completed work
+2. **File existence checks** - Verify expected files were created/modified
+3. **Test coverage verification** - Ensure test files exist for code changes
+4. **Schema/migration checks** - Verify database changes include proper migrations
+5. **Documentation updates** - Check for changelog, README, or other doc updates
+
+**Key Verification Points:**
+- Code changes: Verify the actual code was modified as required
+- Test updates: Check that test files exist and cover new functionality
+- Schema updates: Ensure migrations or schema files were updated
+- Documentation: Verify any required docs were updated
+
+**Quality Checks:**
+- Look for obvious bugs or architectural issues
+- Check for incomplete implementations
+- Verify imports and dependencies are correct
+- Ensure no dead code was left behind
+
+**Output Guidelines:**
+- Mark overallComplete as false if ANY requirement is missing
+- Provide specific reasons for missing requirements
+- Flag quality issues by severity
+- Be thorough but efficient in verification
+
+This is a critical safety step - be comprehensive in your verification.`,
+}
+
+export default definition

.agents/codelayer/project-context-analyzer.ts

@@ -0,0 +1,138 @@
+import type { AgentDefinition } from '../types/agent-definition'
+
+const definition: AgentDefinition = {
+  id: 'project-context-analyzer',
+  publisher: 'codelayer',
+  model: 'anthropic/claude-4-sonnet-20250522',
+  displayName: 'Project Context Analyzer',
+  
+  toolNames: ['read_files', 'code_search', 'set_output', 'spawn_agents'],
+  spawnableAgents: ['codebase-analyzer', 'codebase-pattern-finder'],
+  
+  inputSchema: {
+    prompt: {
+      type: 'string',
+      description: 'Context about what architectural analysis is needed'
+    },
+  },
+  
+  outputMode: 'structured_output',
+  outputSchema: {
+    type: 'object',
+    properties: {
+      framework: {
+        type: 'string',
+        description: 'Primary framework (nextjs, express, django, etc.)'
+      },
+      architecture: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            pattern: { type: 'string' },
+            locations: { type: 'array', items: { type: 'string' } },
+            description: { type: 'string' }
+          }
+        }
+      },
+      conventions: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            type: { type: 'string' },
+            rule: { type: 'string' },
+            examples: { type: 'array', items: { type: 'string' } }
+          }
+        }
+      },
+      testingStrategy: {
+        type: 'object',
+        properties: {
+          framework: { type: 'string' },
+          patterns: { type: 'array', items: { type: 'string' } },
+          locations: { type: 'array', items: { type: 'string' } }
+        }
+      },
+      fileStructure: {
+        type: 'object',
+        properties: {
+          sourceDirectories: { type: 'array', items: { type: 'string' } },
+          testDirectories: { type: 'array', items: { type: 'string' } },
+          configFiles: { type: 'array', items: { type: 'string' } },
+          schemaFiles: { type: 'array', items: { type: 'string' } }
+        }
+      },
+      packageManager: {
+        type: 'string',
+        enum: ['npm', 'yarn', 'pnpm', 'bun']
+      }
+    },
+    required: ['framework', 'architecture', 'conventions', 'testingStrategy', 'fileStructure']
+  },
+  
+  spawnerPrompt: 'Analyze project architecture, frameworks, conventions, and patterns to provide context for implementation decisions',
+  
+  systemPrompt: 'You are a project context analyzer that provides comprehensive architectural understanding to prevent incorrect implementation decisions.',
+  
+  instructionsPrompt: `Analyze the project to understand its architecture and conventions:
+
+**Framework Detection:**
+- Identify the primary framework (Next.js, Express, Django, etc.)
+- Look at package.json, framework-specific config files
+- Note any meta-frameworks or additional tools
+
+**Architecture Patterns:**
+- Identify common patterns (MVC, hexagonal, microservices, etc.)
+- Note how modules are organized
+- Understand data flow and dependency patterns
+
+**Code Conventions:**
+- Naming conventions for files, functions, variables
+- Import/export patterns
+- Error handling approaches
+- Logging and debugging patterns
+
+**Testing Strategy:**
+- Testing framework in use (Jest, Vitest, etc.)
+- Test file naming and location patterns
+- Test coverage expectations
+- Mock/stub patterns
+
+**File Structure:**
+- Source code organization
+- Test file locations
+- Configuration file patterns
+- Schema/migration file locations
+
+**Package Management:**
+- Detect package manager from lock files
+- Note any special scripts or tooling
+
+Use the codebase-analyzer and codebase-pattern-finder agents to gather comprehensive information, then synthesize into structured context that can guide implementation decisions.`,
+  
+  handleSteps: function* ({ prompt }) {
+    // Parallel analysis of different aspects
+    const { toolResult } = yield {
+      toolName: 'spawn_agents',
+      input: {
+        agents: [
+          {
+            agent_type: 'codebase-analyzer',
+            prompt: 'Analyze the overall project framework, architecture patterns, and file organization structure'
+          },
+          {
+            agent_type: 'codebase-pattern-finder',
+            prompt: 'Find common coding patterns, naming conventions, testing strategies, and implementation approaches used throughout the codebase'
+          }
+        ],
+        cb_easp: true
+      }
+    }
+    
+    // Process and synthesize the results into structured output
+    yield 'STEP_ALL'
+  },
+}
+
+export default definition