@girardelli/architect 2.2.0 → 5.0.0

package/src/agent-generator/index.ts

@@ -0,0 +1,634 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, statSync } from 'fs';
+import { join } from 'path';
+import { AnalysisReport, RefactoringPlan } from '../types.js';
+import {
+  StackInfo,
+  AgentAuditFinding,
+  AgentItem,
+  AgentItemStatus,
+  AgentSuggestion,
+  TemplateContext,
+  EnrichedTemplateContext,
+  DomainInsights,
+  ModuleDetail,
+  DetectedEndpoint,
+  FrameworkInfo,
+  DetectedToolchain,
+  AgentGeneratorConfig,
+  DEFAULT_AGENT_CONFIG,
+} from './types.js';
+import { StackDetector } from './stack-detector.js';
+import { ContextEnricher } from './context-enricher.js';
+
+// ── Core Templates (Enterprise-Grade) ──
+import { generateIndexMd } from './templates/core/index-md.js';
+import { generateOrchestrator } from './templates/core/orchestrator.js';
+import { generatePreflight } from './templates/core/preflight.js';
+import { generateQualityGates } from './templates/core/quality-gates.js';
+import { generateGeneralRules } from './templates/core/general-rules.js';
+import { generateArchitectureRules } from './templates/core/architecture-rules.js';
+import { generateSecurityRules } from './templates/core/security-rules.js';
+import { generateNewFeatureWorkflow } from './templates/core/workflow-new-feature.js';
+import { generateFixBugWorkflow } from './templates/core/workflow-fix-bug.js';
+import { generateReviewWorkflow } from './templates/core/workflow-review.js';
+import {
+  generateBackendAgent,
+  generateFrontendAgent,
+  generateSecurityAgent,
+  generateQAAgent,
+  generateTechDebtAgent,
+  generateCodeReviewChecklist,
+  generateDatabaseAgent,
+  generateMobileAgent,
+} from './templates/core/agents.js';
+
+// ── Stack-Specific Templates ──
+import { generateStackRules, getStackRuleFileName } from './templates/stack/index.js';
+
+// ── Domain Templates ──
+import {
+  generateC4Template,
+  generateBddTemplate,
+  generateTddTemplate,
+  generateAdrTemplate,
+  generateThreatModelTemplate,
+} from './templates/domain/index.js';
+
+// ── Skills Generator ──
+import { generateProjectSkills, generateArchitectIntegrationSkill, generateCIPipelineSkill, generateMonorepoGuideSkill } from './templates/core/skills-generator.js';
+
+// ── Hooks Generator ──
+import { generatePreCommitHook, generatePrePushHook, generatePostAnalysisHook } from './templates/core/hooks-generator.js';
+
+// Re-export types for backward compatibility
+export type { StackInfo, AgentAuditFinding, AgentItem, AgentItemStatus, AgentSuggestion, EnrichedTemplateContext, DomainInsights, ModuleDetail, DetectedEndpoint, FrameworkInfo, DetectedToolchain };
+
+/**
+ * Agent Generator v3.1 — Enterprise-Grade
+ *
+ * Generates or audits .agent/ directories with enterprise-grade
+ * agent frameworks: detailed workflows, approval gates, quality enforcement,
+ * stack-specific agents, and domain templates.
+ */
+export class AgentGenerator {
+  private stackDetector = new StackDetector();
+  private contextEnricher = new ContextEnricher();
+
+  /** Max lines for any single generated .agent file */
+  private static readonly MAX_FILE_LINES = 500;
+
+  /** Paths that indicate third-party code — filter from agent context */
+  private static readonly EXCLUDED_SEGMENTS = [
+    'node_modules', '/dist/', '/build/', '/coverage/',
+    '/.next/', '/venv/', '/__pycache__/', '/target/',
+  ];
+
+  /**
+   * Sanitize the report before passing to agent generation.
+   * Removes anti-patterns, dependency nodes, and suggestions
+   * that reference node_modules or build artifacts.
+   */
+  private sanitizeReport(report: AnalysisReport): AnalysisReport {
+    const isProjectPath = (path: string): boolean => {
+      const normalized = path.replace(/\\/g, '/');
+      return !AgentGenerator.EXCLUDED_SEGMENTS.some(seg => normalized.includes(seg));
+    };
+
+    return {
+      ...report,
+      antiPatterns: report.antiPatterns.filter(ap => {
+        if (!isProjectPath(ap.location)) return false;
+        if (ap.affectedFiles?.some(f => !isProjectPath(f))) {
+          // Keep the pattern but clean affected files
+          ap.affectedFiles = ap.affectedFiles.filter(f => isProjectPath(f));
+        }
+        return true;
+      }),
+      dependencyGraph: {
+        nodes: report.dependencyGraph.nodes.filter(n => isProjectPath(n)),
+        edges: report.dependencyGraph.edges.filter(
+          e => isProjectPath(e.from) && isProjectPath(e.to)
+        ),
+      },
+      suggestions: report.suggestions.filter(
+        s => !s.description.includes('node_modules')
+      ),
+    };
+  }
+
+  /**
+   * Cap content to max lines to prevent oversized agent files.
+   */
+  private capContent(content: string): string {
+    const lines = content.split('\n');
+    if (lines.length <= AgentGenerator.MAX_FILE_LINES) return content;
+
+    const truncated = lines.slice(0, AgentGenerator.MAX_FILE_LINES);
+    truncated.push('');
+    truncated.push('<!-- Content truncated at ' + AgentGenerator.MAX_FILE_LINES + ' lines. Run `architect agents` to regenerate. -->');
+    return truncated.join('\n');
+  }
+
+  /**
+   * Suggest agents without writing files — for unified report.
+   */
+  suggest(
+    report: AnalysisReport,
+    plan: RefactoringPlan,
+    projectPath: string,
+  ): AgentSuggestion {
+    const cleanReport = this.sanitizeReport(report);
+    const stack = this.stackDetector.detect(cleanReport);
+    const agentDir = join(projectPath, '.agent');
+    const isExisting = existsSync(agentDir);
+
+    const existingFiles = (subdir: string): Set<string> => {
+      const dir = join(agentDir, subdir);
+      if (!existsSync(dir)) return new Set();
+      return new Set(readdirSync(dir).map(f => f.replace(/\.md$/, '')));
+    };
+
+    let audit: AgentAuditFinding[] = [];
+    if (isExisting) {
+      audit = this.auditExisting(agentDir, stack, report, plan);
+    }
+
+    const ctx = this.buildContext(cleanReport, plan, stack, projectPath);
+
+    const existingAgents = existingFiles('agents');
+    const existingRules = existingFiles('rules');
+    const existingGuards = existingFiles('guards');
+    const existingWorkflows = existingFiles('workflows');
+    const existingSkillsDir = join(agentDir, 'skills');
+    const existingSkillNames = existsSync(existingSkillsDir)
+      ? new Set(readdirSync(existingSkillsDir).filter(f => {
+          try { return statSync(join(existingSkillsDir, f)).isDirectory(); } catch { return false; }
+        }))
+      : new Set<string>();
+
+    const itemStatus = (name: string, existing: Set<string>): AgentItemStatus => {
+      const found = [...existing].some(e => e.toLowerCase() === name.toLowerCase());
+      if (!found) return 'CREATE';
+      const hasImprovement = audit.some(
+        f => f.file.toLowerCase().includes(name.toLowerCase()) && (f.type === 'IMPROVEMENT' || f.type === 'OUTDATED')
+      );
+      return hasImprovement ? 'MODIFY' : 'KEEP';
+    };
+
+    // ── Agent definitions ──
+    const agentDefs: { name: string; desc: string }[] = [
+      { name: 'AGENT-ORCHESTRATOR', desc: 'Centro de comando — decompõe requisições, enforça gates, coordena agentes' },
+    ];
+    if (stack.hasBackend) agentDefs.push({
+      name: `${stack.primary.toUpperCase()}-BACKEND-DEVELOPER`,
+      desc: `Especialista em ${stack.primary} — APIs, serviços, lógica de negócio, integration docs`,
+    });
+    if (stack.hasFrontend) {
+      const FRONTEND_FWS = ['Angular', 'Vue', 'Vue.js', 'Next.js', 'React', 'Nuxt', 'Svelte', 'Remix'];
+      const detectedFw = ctx.detectedFrameworks?.find(f => FRONTEND_FWS.includes(f.name));
+      const fw = detectedFw?.name ||
+        stack.frameworks.find(f => FRONTEND_FWS.includes(f)) || 'FRONTEND';
+      agentDefs.push({
+        name: `${fw.toUpperCase().replace('.', '').replace(/\s/g, '-')}-FRONTEND-DEVELOPER`,
+        desc: `Componentes ${fw}, state management, UX responsiva, todos os estados UI`,
+      });
+    }
+    if (stack.hasMobile) agentDefs.push({
+      name: 'FLUTTER-UI-DEVELOPER',
+      desc: 'Screens mobile, widgets, navegação, integração API, padrão visual do app',
+    });
+    if (stack.hasDatabase) agentDefs.push({
+      name: 'DATABASE-ENGINEER',
+      desc: 'Schema design, migrations reversíveis, indexação, performance de queries',
+    });
+    agentDefs.push(
+      { name: 'SECURITY-AUDITOR', desc: 'OWASP Top 10, STRIDE threat model, compliance, vulnerabilidades' },
+      { name: 'QA-TEST-ENGINEER', desc: 'BDD/TDD, cobertura mínima, planos de teste, regressão' },
+      { name: 'TECH-DEBT-CONTROLLER', desc: 'Score tracking, anti-patterns, refatorações, metas de qualidade' },
+    );
+
+    const ruleDefs: { name: string; desc: string }[] = [
+      { name: '00-general', desc: '9 Regras de Ouro, Git Flow, naming conventions, ações proibidas' },
+      { name: '01-architecture', desc: 'Separação de camadas, dependency rules, padrões de módulo' },
+      { name: '02-security', desc: 'Sanitização, secrets management, validação, OWASP' },
+    ];
+    const stackRuleName = getStackRuleFileName(ctx);
+    if (stackRuleName) {
+      const fwLabel = stack.frameworks[0] || stack.primary;
+      ruleDefs.push({ name: stackRuleName, desc: `Regras específicas ${fwLabel} — patterns, anti-patterns, checklist` });
+    }
+
+    const guardDefs = [
+      { name: 'PREFLIGHT', desc: '6-phase checklist pré-ação: ambiente → leitura → negócio → camada → commit → done' },
+      { name: 'QUALITY-GATES', desc: '3 níveis (CRITICAL/IMPORTANT/DESIRABLE), métricas, blockers, verificação em 4 estágios' },
+      { name: 'CODE-REVIEW-CHECKLIST', desc: 'Review em 6 dimensões: funcional, qualidade, testes, segurança, performance, arquitetura' },
+    ];
+
+    const workflowDefs = [
+      { name: 'new-feature', desc: '10 steps com 6 approval gates, mockup-first, backend-first, integration doc' },
+      { name: 'fix-bug', desc: '10 steps: diagnóstico → root cause → RED test → fix mínimo → regressão → docs' },
+      { name: 'review', desc: 'Code review em 6 dimensões com checklist estruturado' },
+    ];
+
+    // Build items
+    const suggestedAgents: AgentItem[] = agentDefs.map(({ name, desc }) => ({
+      name, status: itemStatus(name, existingAgents), description: desc,
+    }));
+    for (const existing of existingAgents) {
+      if (!agentDefs.some(d => d.name.toLowerCase() === existing.toLowerCase())) {
+        suggestedAgents.push({ name: existing, status: 'KEEP', reason: 'Custom agent', description: 'Agente customizado do projeto' });
+      }
+    }
+
+    const suggestedRules: AgentItem[] = ruleDefs.map(({ name, desc }) => ({
+      name, status: itemStatus(name, existingRules), description: desc,
+    }));
+    for (const existing of existingRules) {
+      if (!ruleDefs.some(d => d.name.toLowerCase() === existing.toLowerCase())) {
+        suggestedRules.push({ name: existing, status: 'KEEP', reason: 'Custom rule' });
+      }
+    }
+
+    const suggestedGuards: AgentItem[] = guardDefs.map(({ name, desc }) => ({
+      name, status: itemStatus(name, existingGuards), description: desc,
+    }));
+
+    const suggestedWorkflows: AgentItem[] = workflowDefs.map(({ name, desc }) => ({
+      name, status: itemStatus(name, existingWorkflows), description: desc,
+    }));
+    for (const existing of existingWorkflows) {
+      if (!workflowDefs.some(d => d.name.toLowerCase() === existing.toLowerCase())) {
+        suggestedWorkflows.push({ name: existing, status: 'KEEP', reason: 'Custom workflow' });
+      }
+    }
+
+    // Skills
+    const skillEntries = this.buildSkillEntries(stack, existingSkillNames);
+
+    return {
+      stack,
+      hasExistingAgents: isExisting,
+      suggestedAgents,
+      suggestedRules,
+      suggestedGuards,
+      suggestedWorkflows,
+      suggestedSkills: skillEntries,
+      audit,
+      command: `architect agents ${projectPath}`,
+    };
+  }
+
+  /**
+   * Generate or audit .agent/ directory for a project.
+   */
+  generate(
+    report: AnalysisReport,
+    plan: RefactoringPlan,
+    projectPath: string,
+    outputDir?: string
+  ): { generated: string[]; audit: AgentAuditFinding[] } {
+    const cleanReport = this.sanitizeReport(report);
+    const stack = this.stackDetector.detect(cleanReport);
+    const agentDir = outputDir || join(projectPath, '.agent');
+    const isExisting = existsSync(agentDir);
+
+    if (isExisting) {
+      const audit = this.auditExisting(agentDir, stack, cleanReport, plan);
+      const generated = this.generateMissing(agentDir, audit, cleanReport, plan, stack, projectPath);
+      return { generated, audit };
+    }
+
+    const generated = this.generateFull(agentDir, cleanReport, plan, stack, projectPath);
+    return { generated, audit: [] };
+  }
+
+  // ── Private: Build Template Context ──
+
+  private buildContext(report: AnalysisReport, plan: RefactoringPlan, stack: StackInfo, projectPath?: string): EnrichedTemplateContext {
+    if (projectPath) {
+      return this.contextEnricher.enrich(report, plan, stack, projectPath);
+    }
+    // Fallback to basic enriched context for backward compatibility
+    return {
+      report,
+      plan,
+      stack,
+      projectName: report.projectInfo.name || 'Project',
+      stackLabel: [...stack.languages, ...stack.frameworks].join(' + '),
+      config: DEFAULT_AGENT_CONFIG,
+      domain: {
+        domain: 'general',
+        subDomain: 'general',
+        description: '',
+        businessEntities: [],
+        compliance: [],
+        integrations: [],
+        keywords: [],
+        confidence: 0,
+      },
+      modules: [],
+      endpoints: [],
+      untestedModules: [],
+      criticalPaths: [],
+      projectDepth: 'small',
+      detectedFrameworks: [],
+      primaryFramework: null,
+      toolchain: {
+        buildCmd: 'echo "No build command detected"',
+        testCmd: 'echo "No test command detected"',
+        lintCmd: 'echo "No lint command detected"',
+        runCmd: 'echo "No run command detected"',
+        coverageCmd: 'echo "No coverage command detected"',
+        installCmd: 'echo "No install command detected"',
+        migrateCmd: null,
+        depsFile: 'unknown',
+      },
+      projectStructure: 'unknown',
+    };
+  }
+
+  // ── Private: Full Generation ──
+
+  private generateFull(agentDir: string, report: AnalysisReport, plan: RefactoringPlan, stack: StackInfo, projectPath: string): string[] {
+    const generated: string[] = [];
+    const ctx = this.buildContext(report, plan, stack, projectPath);
+
+    // Create directories
+    const dirs = ['agents', 'rules', 'guards', 'workflows', 'templates', 'skills', 'hooks'];
+    for (const d of dirs) mkdirSync(join(agentDir, d), { recursive: true });
+
+    // ── Core files (Enterprise-Grade) ──
+    const coreFiles: Record<string, string> = {
+      'INDEX.md': generateIndexMd(ctx),
+      'agents/AGENT-ORCHESTRATOR.md': generateOrchestrator(ctx),
+      'guards/PREFLIGHT.md': generatePreflight(ctx),
+      'guards/QUALITY-GATES.md': generateQualityGates(ctx),
+      'guards/CODE-REVIEW-CHECKLIST.md': generateCodeReviewChecklist(ctx),
+      'rules/00-general.md': generateGeneralRules(ctx),
+      'rules/01-architecture.md': generateArchitectureRules(ctx),
+      'rules/02-security.md': generateSecurityRules(ctx),
+      'workflows/new-feature.md': generateNewFeatureWorkflow(ctx),
+      'workflows/fix-bug.md': generateFixBugWorkflow(ctx),
+      'workflows/review.md': generateReviewWorkflow(ctx),
+    };
+
+    // ── Stack-specific agents ──
+    if (stack.hasBackend) {
+      coreFiles[`agents/${stack.primary.toUpperCase()}-BACKEND-DEVELOPER.md`] = generateBackendAgent(ctx);
+    }
+    if (stack.hasFrontend) {
+      const FRONTEND_FWS = ['Angular', 'Vue', 'Vue.js', 'Next.js', 'React', 'Nuxt', 'Svelte', 'Remix'];
+      const detectedFw = ctx.detectedFrameworks?.find(f => FRONTEND_FWS.includes(f.name));
+      const fwName = detectedFw?.name ||
+        stack.frameworks.find(f => FRONTEND_FWS.includes(f)) || 'Frontend';
+      coreFiles[`agents/${fwName.toUpperCase().replace('.', '').replace(/\s/g, '-')}-FRONTEND-DEVELOPER.md`] = generateFrontendAgent(ctx);
+    }
+    if (stack.hasMobile) {
+      coreFiles['agents/FLUTTER-UI-DEVELOPER.md'] = generateMobileAgent(ctx);
+    }
+    if (stack.hasDatabase) {
+      coreFiles['agents/DATABASE-ENGINEER.md'] = generateDatabaseAgent(ctx);
+    }
+    coreFiles['agents/SECURITY-AUDITOR.md'] = generateSecurityAgent(ctx);
+    coreFiles['agents/QA-TEST-ENGINEER.md'] = generateQAAgent(ctx);
+    coreFiles['agents/TECH-DEBT-CONTROLLER.md'] = generateTechDebtAgent(ctx);
+
+    // ── Stack-specific rules ──
+    const stackRuleContent = generateStackRules(ctx);
+    const stackRuleFile = getStackRuleFileName(ctx);
+    if (stackRuleContent && stackRuleFile) {
+      coreFiles[`rules/${stackRuleFile}.md`] = stackRuleContent;
+    }
+
+    // ── Domain templates ──
+    coreFiles['templates/C4.md'] = generateC4Template(ctx);
+    coreFiles['templates/BDD.md'] = generateBddTemplate(ctx);
+    coreFiles['templates/TDD.md'] = generateTddTemplate(ctx);
+    coreFiles['templates/ADR.md'] = generateAdrTemplate(ctx);
+    coreFiles['templates/THREAT-MODEL.md'] = generateThreatModelTemplate(ctx);
+
+    // ── Project Skills (padrões detectados) ──
+    const skillsContent = generateProjectSkills(ctx);
+    if (skillsContent) {
+      coreFiles['skills/PROJECT-PATTERNS.md'] = skillsContent;
+    }
+
+    // ── Data-driven Skills (real project data) ──
+    coreFiles['skills/ARCHITECT-INTEGRATION.md'] = generateArchitectIntegrationSkill(ctx);
+    coreFiles['skills/CI-PIPELINE.md'] = generateCIPipelineSkill(ctx);
+
+    const monorepoGuide = generateMonorepoGuideSkill(ctx);
+    if (monorepoGuide) {
+      coreFiles['skills/MONOREPO-GUIDE.md'] = monorepoGuide;
+    }
+
+    // ── Executable Hooks ──
+    coreFiles['hooks/pre-commit.sh'] = generatePreCommitHook(ctx);
+    coreFiles['hooks/pre-push.sh'] = generatePrePushHook(ctx);
+    coreFiles['hooks/post-analysis.sh'] = generatePostAnalysisHook(ctx);
+
+    // ── Write all files (with size cap) ──
+    for (const [path, content] of Object.entries(coreFiles)) {
+      const fullPath = join(agentDir, path);
+      const dir = join(fullPath, '..');
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+      writeFileSync(fullPath, this.capContent(content));
+      generated.push(path);
+    }
+
+    return generated;
+  }
+
+  // ── Private: Generate Missing (for existing .agent/) ──
+
+  private generateMissing(
+    agentDir: string,
+    audit: AgentAuditFinding[],
+    report: AnalysisReport,
+    plan: RefactoringPlan,
+    stack: StackInfo,
+    projectPath: string,
+  ): string[] {
+    const generated: string[] = [];
+    const missing = audit.filter(f => f.type === 'MISSING');
+    const ctx = this.buildContext(report, plan, stack, projectPath);
+
+    for (const finding of missing) {
+      const fullPath = join(agentDir, finding.file);
+      const dir = join(fullPath, '..');
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+      const content = this.getTemplateFor(finding.file, ctx);
+      if (content) {
+        writeFileSync(fullPath, content);
+        generated.push(finding.file);
+      }
+    }
+
+    return generated;
+  }
+
+  private getTemplateFor(file: string, ctx: EnrichedTemplateContext): string | null {
+    if (file.includes('INDEX')) return generateIndexMd(ctx);
+    if (file.includes('ORCHESTRATOR')) return generateOrchestrator(ctx);
+    if (file.includes('PREFLIGHT')) return generatePreflight(ctx);
+    if (file.includes('QUALITY-GATES')) return generateQualityGates(ctx);
+    if (file.includes('CODE-REVIEW')) return generateCodeReviewChecklist(ctx);
+    if (file.includes('SECURITY')) return generateSecurityAgent(ctx);
+    if (file.includes('QA')) return generateQAAgent(ctx);
+    if (file.includes('TECH-DEBT')) return generateTechDebtAgent(ctx);
+    if (file.includes('BACKEND')) return generateBackendAgent(ctx);
+    if (file.includes('FRONTEND')) return generateFrontendAgent(ctx);
+    if (file.includes('FLUTTER')) return generateMobileAgent(ctx);
+    if (file.includes('DATABASE')) return generateDatabaseAgent(ctx);
+    if (file.includes('00-general')) return generateGeneralRules(ctx);
+    if (file.includes('01-architecture')) return generateArchitectureRules(ctx);
+    if (file.includes('02-security')) return generateSecurityRules(ctx);
+    if (file.includes('03-')) return generateStackRules(ctx);
+    if (file.includes('new-feature') || file.includes('develop')) return generateNewFeatureWorkflow(ctx);
+    if (file.includes('fix-bug')) return generateFixBugWorkflow(ctx);
+    if (file.includes('review')) return generateReviewWorkflow(ctx);
+    if (file.includes('C4')) return generateC4Template(ctx);
+    if (file.includes('BDD')) return generateBddTemplate(ctx);
+    if (file.includes('TDD')) return generateTddTemplate(ctx);
+    if (file.includes('ADR')) return generateAdrTemplate(ctx);
+    if (file.includes('THREAT')) return generateThreatModelTemplate(ctx);
+    return null;
+  }
+
+  // ── Private: Audit ──
+
+  private auditExisting(
+    agentDir: string,
+    stack: StackInfo,
+    report: AnalysisReport,
+    plan: RefactoringPlan,
+  ): AgentAuditFinding[] {
+    const findings: AgentAuditFinding[] = [];
+
+    const checkExists = (subpath: string, category: string, desc: string): void => {
+      const full = join(agentDir, subpath);
+      if (!existsSync(full)) {
+        findings.push({ type: 'MISSING', category, file: subpath, description: desc });
+      } else {
+        findings.push({ type: 'OK', category, file: subpath, description: `${subpath} exists` });
+      }
+    };
+
+    // Core structure
+    checkExists('INDEX.md', 'core', 'Master navigation guide');
+    checkExists('agents/AGENT-ORCHESTRATOR.md', 'agents', 'Orchestrator agent with approval gates');
+    checkExists('rules/00-general.md', 'rules', 'Golden rules and conventions');
+    checkExists('rules/01-architecture.md', 'rules', 'Layer rules, dependency direction, module patterns');
+    checkExists('rules/02-security.md', 'rules', 'OWASP, input validation, secrets management');
+    checkExists('guards/PREFLIGHT.md', 'guards', '6-phase preflight checklist');
+    checkExists('guards/QUALITY-GATES.md', 'guards', '3-level quality gates');
+    checkExists('guards/CODE-REVIEW-CHECKLIST.md', 'guards', 'Structured code review checklist');
+    checkExists('workflows/new-feature.md', 'workflows', '10-step feature workflow with approval gates');
+    checkExists('workflows/fix-bug.md', 'workflows', 'Diagnostic bug fix workflow');
+
+    // Domain templates
+    checkExists('templates/C4.md', 'templates', 'C4 architecture template');
+    checkExists('templates/BDD.md', 'templates', 'BDD scenario template');
+    checkExists('templates/TDD.md', 'templates', 'TDD test template');
+    checkExists('templates/ADR.md', 'templates', 'ADR decision record template');
+    checkExists('templates/THREAT-MODEL.md', 'templates', 'STRIDE threat model template');
+
+    // Stack-specific agents
+    if (stack.hasBackend) {
+      const found = this.findAgentByRole(agentDir, 'backend');
+      if (!found) {
+        findings.push({
+          type: 'MISSING', category: 'agents',
+          file: `agents/${stack.primary.toUpperCase()}-BACKEND-DEVELOPER.md`,
+          description: `No backend developer agent for ${stack.primary}`,
+        });
+      }
+    }
+    if (stack.hasFrontend) {
+      const found = this.findAgentByRole(agentDir, 'frontend');
+      if (!found) {
+        findings.push({
+          type: 'MISSING', category: 'agents',
+          file: 'agents/FRONTEND-DEVELOPER.md',
+          description: 'No frontend developer agent',
+        });
+      }
+    }
+
+    // Quality improvements
+    if (plan.steps.length > 0) {
+      const found = this.findAgentByRole(agentDir, 'tech-debt');
+      if (!found) {
+        findings.push({
+          type: 'IMPROVEMENT', category: 'agents',
+          file: 'agents/TECH-DEBT-CONTROLLER.md',
+          description: `${plan.steps.length} refactoring steps found but no Tech Debt agent`,
+          suggestion: 'Create a Tech Debt Controller to track and prioritize refactoring',
+        });
+      }
+    }
+
+    if (report.score.overall < 80) {
+      findings.push({
+        type: 'IMPROVEMENT', category: 'guards',
+        file: 'guards/QUALITY-GATES.md',
+        description: `Score is ${report.score.overall}/100 — quality gates should enforce improvement`,
+        suggestion: `Set minimum score threshold to ${report.score.overall + 5} and add regression guards`,
+      });
+    }
+
+    return findings;
+  }
+
+  private findAgentByRole(agentDir: string, role: string): string | null {
+    const dir = join(agentDir, 'agents');
+    if (!existsSync(dir)) return null;
+    const files = readdirSync(dir);
+    for (const file of files) {
+      const content = readFileSync(join(dir, file), 'utf-8').toLowerCase();
+      if (content.includes(role)) return file;
+    }
+    return null;
+  }
+
+  // ── Private: Skills ──
+
+  private buildSkillEntries(stack: StackInfo, existing: Set<string>) {
+    const entries: { name: string; source: string; description: string; status: AgentItemStatus }[] = [
+      { name: 'test-driven-development', source: 'anthropic/courses/test-driven-development', description: 'TDD: Red → Green → Refactor', status: 'CREATE' },
+      { name: 'systematic-debugging', source: 'anthropic/courses/systematic-debugging', description: 'Structured debugging methodology', status: 'CREATE' },
+      { name: 'code-review', source: 'anthropic/courses/requesting-code-review', description: 'Code review best practices', status: 'CREATE' },
+      { name: 'security-best-practices', source: 'anthropic/courses/security-best-practices', description: 'Security patterns and vulnerability prevention', status: 'CREATE' },
+      { name: 'performance-optimization', source: 'anthropic/courses/performance-optimization', description: 'Performance analysis and optimization', status: 'CREATE' },
+      { name: 'git-workflow', source: 'anthropic/courses/git-workflow', description: 'Git branching, commits, collaboration', status: 'CREATE' },
+    ];
+
+    // Stack-specific skills
+    if (stack.languages.includes('TypeScript') || stack.languages.includes('JavaScript')) {
+      entries.push({ name: 'api-design-principles', source: 'anthropic/courses/api-design-principles', description: 'REST/GraphQL API design', status: 'CREATE' });
+    }
+    if (stack.frameworks.includes('Angular') || stack.frameworks.includes('Vue') || stack.frameworks.includes('React') || stack.frameworks.includes('Next.js')) {
+      entries.push(
+        { name: 'frontend-design', source: 'anthropic/courses/frontend-design', description: 'Modern frontend patterns', status: 'CREATE' },
+        { name: 'web-accessibility', source: 'anthropic/courses/web-accessibility', description: 'WCAG accessibility standards', status: 'CREATE' },
+      );
+    }
+    if (stack.languages.includes('Dart') || stack.frameworks.includes('Flutter')) {
+      entries.push({ name: 'flutter-animations', source: 'anthropic/courses/flutter-animations', description: 'Flutter animation patterns', status: 'CREATE' });
+    }
+    if (stack.languages.includes('Python')) {
+      entries.push({ name: 'python-performance', source: 'anthropic/courses/python-performance-optimization', description: 'Python optimization and profiling', status: 'CREATE' });
+    }
+    if (stack.hasDatabase) {
+      entries.push({ name: 'database-schema-design', source: 'anthropic/courses/database-schema-design', description: 'Schema design, indexing, migrations', status: 'CREATE' });
+    }
+
+    // Update status based on existing
+    for (const entry of entries) {
+      if (existing.has(entry.name)) entry.status = 'KEEP';
+    }
+
+    return entries;
+  }
+}