elsabro 2.3.0 → 3.7.0

package/references/configuration-management.md

@@ -0,0 +1,1810 @@
+# ELSABRO Configuration Management System
+
+> Sistema avanzado de configuración con environments, feature flags, validación y remote config.
+
+## Arquitectura General
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                    Configuration Management                          │
+├─────────────────────────────────────────────────────────────────────┤
+│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐            │
+│  │ ConfigManager │  │ FeatureFlags  │  │  EnvResolver  │            │
+│  │   ─────────   │  │   ─────────   │  │   ─────────   │            │
+│  │ • Load/Save   │  │ • Targeting   │  │ • Variables   │            │
+│  │ • Merge       │  │ • Percentage  │  │ • Inheritance │            │
+│  │ • Watch       │  │ • Schedules   │  │ • Secrets     │            │
+│  └───────────────┘  └───────────────┘  └───────────────┘            │
+│                              │                                       │
+│  ┌───────────────────────────┴───────────────────────────┐          │
+│  │                   ConfigValidator                      │          │
+│  │  • JSON Schema • Type Coercion • Required Fields      │          │
+│  └────────────────────────────────────────────────────────┘          │
+│                              │                                       │
+│  ┌───────────────────────────┴───────────────────────────┐          │
+│  │                   RemoteConfigSync                     │          │
+│  │  • Polling • Webhooks • Caching • Fallback            │          │
+│  └────────────────────────────────────────────────────────┘          │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 1. ConfigManager
+
+### Propósito
+Gestiona la carga, fusión y persistencia de configuraciones con soporte para múltiples fuentes.
+
+### Interfaz
+
+```typescript
+interface ConfigSource {
+  type: 'file' | 'env' | 'remote' | 'memory';
+  path?: string;
+  url?: string;
+  priority: number;  // Higher = override lower
+  required?: boolean;
+  format?: 'json' | 'yaml' | 'toml' | 'env';
+}
+
+interface ConfigOptions {
+  sources: ConfigSource[];
+  environment: string;
+  watchForChanges: boolean;
+  reloadOnChange: boolean;
+  mergeStrategy: 'deep' | 'shallow' | 'replace';
+  encryptionKey?: string;
+}
+
+interface ConfigManager {
+  // Core operations
+  load(): Promise<void>;
+  get<T>(path: string, defaultValue?: T): T;
+  set(path: string, value: unknown): void;
+  has(path: string): boolean;
+  delete(path: string): void;
+
+  // Bulk operations
+  getAll(): Record<string, unknown>;
+  merge(config: Record<string, unknown>): void;
+  reset(): void;
+
+  // Environment
+  getEnvironment(): string;
+  setEnvironment(env: string): Promise<void>;
+
+  // Persistence
+  save(source?: string): Promise<void>;
+  export(format: 'json' | 'yaml' | 'env'): string;
+
+  // Events
+  onChange(path: string, callback: (newValue: unknown, oldValue: unknown) => void): () => void;
+  onReload(callback: (config: Record<string, unknown>) => void): () => void;
+}
+```
+
+### Implementación
+
+```typescript
+class ConfigManagerImpl implements ConfigManager {
+  private config: Map<string, unknown> = new Map();
+  private sources: ConfigSource[] = [];
+  private watchers: Map<string, Set<Function>> = new Map();
+  private environment: string;
+  private options: ConfigOptions;
+
+  constructor(options: ConfigOptions) {
+    this.options = options;
+    this.environment = options.environment;
+    this.sources = options.sources.sort((a, b) => a.priority - b.priority);
+  }
+
+  async load(): Promise<void> {
+    const configs: Record<string, unknown>[] = [];
+
+    for (const source of this.sources) {
+      try {
+        const config = await this.loadSource(source);
+        configs.push(config);
+      } catch (error) {
+        if (source.required) {
+          throw new ConfigLoadError(`Required config source failed: ${source.path || source.url}`, error);
+        }
+        console.warn(`Optional config source unavailable: ${source.path || source.url}`);
+      }
+    }
+
+    // Merge all configs in priority order
+    const merged = this.mergeConfigs(configs);
+
+    // Apply environment-specific overrides
+    const envConfig = merged.environments?.[this.environment];
+    if (envConfig) {
+      this.mergeConfigs([merged, envConfig as Record<string, unknown>]);
+    }
+
+    // Store flattened config
+    this.flattenAndStore(merged);
+
+    // Setup watchers if enabled
+    if (this.options.watchForChanges) {
+      this.setupWatchers();
+    }
+  }
+
+  private async loadSource(source: ConfigSource): Promise<Record<string, unknown>> {
+    switch (source.type) {
+      case 'file':
+        return this.loadFileConfig(source);
+      case 'env':
+        return this.loadEnvConfig(source);
+      case 'remote':
+        return this.loadRemoteConfig(source);
+      case 'memory':
+        return source.data || {};
+      default:
+        throw new Error(`Unknown config source type: ${source.type}`);
+    }
+  }
+
+  private async loadFileConfig(source: ConfigSource): Promise<Record<string, unknown>> {
+    const content = await fs.readFile(source.path!, 'utf-8');
+
+    switch (source.format || this.detectFormat(source.path!)) {
+      case 'json':
+        return JSON.parse(content);
+      case 'yaml':
+        return yaml.parse(content);
+      case 'toml':
+        return toml.parse(content);
+      case 'env':
+        return this.parseEnvFile(content);
+      default:
+        return JSON.parse(content);
+    }
+  }
+
+  private loadEnvConfig(source: ConfigSource): Record<string, unknown> {
+    const prefix = source.path || '';
+    const config: Record<string, unknown> = {};
+
+    for (const [key, value] of Object.entries(process.env)) {
+      if (prefix && !key.startsWith(prefix)) continue;
+
+      const configKey = prefix ? key.slice(prefix.length + 1) : key;
+      this.setNestedValue(config, configKey.toLowerCase().replace(/_/g, '.'), value);
+    }
+
+    return config;
+  }
+
+  private async loadRemoteConfig(source: ConfigSource): Promise<Record<string, unknown>> {
+    const response = await fetch(source.url!, {
+      headers: source.headers || {},
+      timeout: source.timeout || 5000
+    });
+
+    if (!response.ok) {
+      throw new Error(`Remote config fetch failed: ${response.status}`);
+    }
+
+    return response.json();
+  }
+
+  get<T>(path: string, defaultValue?: T): T {
+    const value = this.config.get(path);
+    return (value !== undefined ? value : defaultValue) as T;
+  }
+
+  set(path: string, value: unknown): void {
+    const oldValue = this.config.get(path);
+    this.config.set(path, value);
+    this.notifyWatchers(path, value, oldValue);
+  }
+
+  has(path: string): boolean {
+    return this.config.has(path);
+  }
+
+  onChange(path: string, callback: Function): () => void {
+    if (!this.watchers.has(path)) {
+      this.watchers.set(path, new Set());
+    }
+    this.watchers.get(path)!.add(callback);
+
+    return () => {
+      this.watchers.get(path)?.delete(callback);
+    };
+  }
+
+  private notifyWatchers(path: string, newValue: unknown, oldValue: unknown): void {
+    // Exact path watchers
+    this.watchers.get(path)?.forEach(cb => cb(newValue, oldValue));
+
+    // Wildcard watchers
+    this.watchers.forEach((callbacks, pattern) => {
+      if (pattern.includes('*') && this.matchesPattern(path, pattern)) {
+        callbacks.forEach(cb => cb(newValue, oldValue));
+      }
+    });
+  }
+
+  private mergeConfigs(configs: Record<string, unknown>[]): Record<string, unknown> {
+    switch (this.options.mergeStrategy) {
+      case 'shallow':
+        return Object.assign({}, ...configs);
+      case 'replace':
+        return configs[configs.length - 1] || {};
+      case 'deep':
+      default:
+        return this.deepMerge({}, ...configs);
+    }
+  }
+
+  private deepMerge(...objects: Record<string, unknown>[]): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+
+    for (const obj of objects) {
+      for (const [key, value] of Object.entries(obj)) {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+          result[key] = this.deepMerge(
+            (result[key] || {}) as Record<string, unknown>,
+            value as Record<string, unknown>
+          );
+        } else {
+          result[key] = value;
+        }
+      }
+    }
+
+    return result;
+  }
+}
+```
+
+### Uso
+
+```typescript
+const config = new ConfigManager({
+  environment: process.env.NODE_ENV || 'development',
+  sources: [
+    { type: 'file', path: '.elsabro/config.json', priority: 1 },
+    { type: 'file', path: '.elsabro/config.local.json', priority: 2, required: false },
+    { type: 'env', path: 'ELSABRO', priority: 3 },
+    { type: 'remote', url: 'https://config.example.com/elsabro', priority: 4, required: false }
+  ],
+  watchForChanges: true,
+  reloadOnChange: true,
+  mergeStrategy: 'deep'
+});
+
+await config.load();
+
+// Get values
+const llmModel = config.get('llm.model', 'claude-sonnet-4-20250514');
+const maxTokens = config.get<number>('llm.maxTokens', 4096);
+
+// Watch for changes
+config.onChange('llm.*', (newValue, oldValue) => {
+  console.log('LLM config changed:', { newValue, oldValue });
+});
+```
+
+---
+
+## 2. FeatureFlags
+
+### Propósito
+Sistema de feature flags con targeting, rollout gradual y programación temporal.
+
+### Interfaz
+
+```typescript
+interface FeatureFlag {
+  key: string;
+  name: string;
+  description?: string;
+  enabled: boolean;
+
+  // Targeting
+  targeting?: {
+    rules: TargetingRule[];
+    defaultVariant: string;
+  };
+
+  // Variants for A/B testing
+  variants?: {
+    [key: string]: {
+      value: unknown;
+      weight?: number;  // For percentage rollout
+    };
+  };
+
+  // Schedule
+  schedule?: {
+    enableAt?: string;   // ISO date
+    disableAt?: string;  // ISO date
+    timezone?: string;
+  };
+
+  // Metadata
+  tags?: string[];
+  owner?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface TargetingRule {
+  attribute: string;
+  operator: 'eq' | 'neq' | 'in' | 'nin' | 'gt' | 'lt' | 'contains' | 'regex';
+  value: unknown;
+  variant: string;
+}
+
+interface EvaluationContext {
+  userId?: string;
+  sessionId?: string;
+  environment?: string;
+  attributes?: Record<string, unknown>;
+}
+
+interface FeatureFlagService {
+  // Evaluation
+  isEnabled(key: string, context?: EvaluationContext): boolean;
+  getVariant(key: string, context?: EvaluationContext): string;
+  getValue<T>(key: string, context?: EvaluationContext): T | undefined;
+
+  // Management
+  getFlag(key: string): FeatureFlag | undefined;
+  getAllFlags(): FeatureFlag[];
+  createFlag(flag: Omit<FeatureFlag, 'createdAt' | 'updatedAt'>): FeatureFlag;
+  updateFlag(key: string, updates: Partial<FeatureFlag>): FeatureFlag;
+  deleteFlag(key: string): void;
+
+  // Bulk operations
+  enableAll(tags?: string[]): void;
+  disableAll(tags?: string[]): void;
+
+  // Events
+  onFlagChange(key: string, callback: (flag: FeatureFlag) => void): () => void;
+}
+```
+
+### Implementación
+
+```typescript
+class FeatureFlagServiceImpl implements FeatureFlagService {
+  private flags: Map<string, FeatureFlag> = new Map();
+  private listeners: Map<string, Set<Function>> = new Map();
+  private hashSeed: string;
+
+  constructor(private config: ConfigManager, seed?: string) {
+    this.hashSeed = seed || 'elsabro-feature-flags';
+    this.loadFlags();
+  }
+
+  private loadFlags(): void {
+    const flagsConfig = this.config.get<Record<string, FeatureFlag>>('featureFlags', {});
+    for (const [key, flag] of Object.entries(flagsConfig)) {
+      this.flags.set(key, { ...flag, key });
+    }
+  }
+
+  isEnabled(key: string, context: EvaluationContext = {}): boolean {
+    const flag = this.flags.get(key);
+    if (!flag) return false;
+
+    // Check schedule
+    if (!this.isWithinSchedule(flag)) return false;
+
+    // Check base enabled state
+    if (!flag.enabled) return false;
+
+    // Evaluate targeting rules
+    if (flag.targeting?.rules) {
+      for (const rule of flag.targeting.rules) {
+        if (this.evaluateRule(rule, context)) {
+          return rule.variant === 'enabled' || rule.variant === 'true';
+        }
+      }
+    }
+
+    // Percentage rollout
+    if (flag.variants) {
+      const variant = this.getVariantByPercentage(flag, context);
+      return variant === 'enabled' || variant === 'true';
+    }
+
+    return true;
+  }
+
+  getVariant(key: string, context: EvaluationContext = {}): string {
+    const flag = this.flags.get(key);
+    if (!flag) return 'control';
+
+    if (!this.isWithinSchedule(flag)) return 'control';
+    if (!flag.enabled) return 'control';
+
+    // Evaluate targeting rules
+    if (flag.targeting?.rules) {
+      for (const rule of flag.targeting.rules) {
+        if (this.evaluateRule(rule, context)) {
+          return rule.variant;
+        }
+      }
+    }
+
+    // Percentage-based variant selection
+    if (flag.variants) {
+      return this.getVariantByPercentage(flag, context);
+    }
+
+    return flag.targeting?.defaultVariant || 'control';
+  }
+
+  getValue<T>(key: string, context: EvaluationContext = {}): T | undefined {
+    const flag = this.flags.get(key);
+    if (!flag || !flag.variants) return undefined;
+
+    const variant = this.getVariant(key, context);
+    return flag.variants[variant]?.value as T;
+  }
+
+  private isWithinSchedule(flag: FeatureFlag): boolean {
+    if (!flag.schedule) return true;
+
+    const now = new Date();
+    const { enableAt, disableAt } = flag.schedule;
+
+    if (enableAt && new Date(enableAt) > now) return false;
+    if (disableAt && new Date(disableAt) < now) return false;
+
+    return true;
+  }
+
+  private evaluateRule(rule: TargetingRule, context: EvaluationContext): boolean {
+    const attributeValue = this.getAttributeValue(rule.attribute, context);
+
+    switch (rule.operator) {
+      case 'eq':
+        return attributeValue === rule.value;
+      case 'neq':
+        return attributeValue !== rule.value;
+      case 'in':
+        return Array.isArray(rule.value) && rule.value.includes(attributeValue);
+      case 'nin':
+        return Array.isArray(rule.value) && !rule.value.includes(attributeValue);
+      case 'gt':
+        return Number(attributeValue) > Number(rule.value);
+      case 'lt':
+        return Number(attributeValue) < Number(rule.value);
+      case 'contains':
+        return String(attributeValue).includes(String(rule.value));
+      case 'regex':
+        return new RegExp(String(rule.value)).test(String(attributeValue));
+      default:
+        return false;
+    }
+  }
+
+  private getAttributeValue(attribute: string, context: EvaluationContext): unknown {
+    // Built-in attributes
+    switch (attribute) {
+      case 'userId':
+        return context.userId;
+      case 'sessionId':
+        return context.sessionId;
+      case 'environment':
+        return context.environment;
+      default:
+        return context.attributes?.[attribute];
+    }
+  }
+
+  private getVariantByPercentage(flag: FeatureFlag, context: EvaluationContext): string {
+    if (!flag.variants) return 'control';
+
+    // Generate deterministic hash for consistent bucketing
+    const identifier = context.userId || context.sessionId || 'anonymous';
+    const hash = this.hashString(`${flag.key}:${identifier}:${this.hashSeed}`);
+    const bucket = hash % 100;
+
+    // Calculate cumulative weights
+    let cumulative = 0;
+    for (const [variant, config] of Object.entries(flag.variants)) {
+      cumulative += config.weight || 0;
+      if (bucket < cumulative) {
+        return variant;
+      }
+    }
+
+    return flag.targeting?.defaultVariant || Object.keys(flag.variants)[0] || 'control';
+  }
+
+  private hashString(str: string): number {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash);
+  }
+
+  createFlag(flag: Omit<FeatureFlag, 'createdAt' | 'updatedAt'>): FeatureFlag {
+    const now = new Date().toISOString();
+    const newFlag: FeatureFlag = {
+      ...flag,
+      createdAt: now,
+      updatedAt: now
+    };
+
+    this.flags.set(flag.key, newFlag);
+    this.notifyListeners(flag.key, newFlag);
+    return newFlag;
+  }
+
+  updateFlag(key: string, updates: Partial<FeatureFlag>): FeatureFlag {
+    const existing = this.flags.get(key);
+    if (!existing) {
+      throw new Error(`Flag not found: ${key}`);
+    }
+
+    const updated: FeatureFlag = {
+      ...existing,
+      ...updates,
+      key, // Prevent key change
+      createdAt: existing.createdAt,
+      updatedAt: new Date().toISOString()
+    };
+
+    this.flags.set(key, updated);
+    this.notifyListeners(key, updated);
+    return updated;
+  }
+
+  onFlagChange(key: string, callback: Function): () => void {
+    if (!this.listeners.has(key)) {
+      this.listeners.set(key, new Set());
+    }
+    this.listeners.get(key)!.add(callback);
+
+    return () => {
+      this.listeners.get(key)?.delete(callback);
+    };
+  }
+
+  private notifyListeners(key: string, flag: FeatureFlag): void {
+    this.listeners.get(key)?.forEach(cb => cb(flag));
+    this.listeners.get('*')?.forEach(cb => cb(flag));
+  }
+}
+```
+
+### Uso
+
+```typescript
+const flags = new FeatureFlagService(config);
+
+// Simple check
+if (flags.isEnabled('new-agent-ui')) {
+  renderNewUI();
+}
+
+// With targeting context
+const context = {
+  userId: 'user-123',
+  environment: 'production',
+  attributes: {
+    plan: 'enterprise',
+    region: 'us-west'
+  }
+};
+
+if (flags.isEnabled('beta-features', context)) {
+  enableBetaFeatures();
+}
+
+// A/B testing
+const variant = flags.getVariant('checkout-flow', context);
+switch (variant) {
+  case 'single-page':
+    renderSinglePageCheckout();
+    break;
+  case 'multi-step':
+    renderMultiStepCheckout();
+    break;
+  default:
+    renderDefaultCheckout();
+}
+
+// Get variant value
+const buttonColor = flags.getValue<string>('button-color', context);
+```
+
+---
+
+## 3. EnvResolver
+
+### Propósito
+Resuelve variables de entorno con herencia, interpolación y soporte para secretos.
+
+### Interfaz
+
+```typescript
+interface EnvDefinition {
+  name: string;
+  inherits?: string;  // Parent environment
+  variables: Record<string, EnvVariable>;
+}
+
+interface EnvVariable {
+  value?: string;
+  secret?: boolean;
+  required?: boolean;
+  default?: string;
+  description?: string;
+  validation?: {
+    type?: 'string' | 'number' | 'boolean' | 'url' | 'email';
+    pattern?: string;
+    min?: number;
+    max?: number;
+    enum?: string[];
+  };
+}
+
+interface ResolvedEnv {
+  [key: string]: string;
+}
+
+interface EnvResolver {
+  // Resolution
+  resolve(envName: string): Promise<ResolvedEnv>;
+  get(envName: string, key: string): Promise<string | undefined>;
+
+  // Interpolation
+  interpolate(template: string, env?: ResolvedEnv): Promise<string>;
+
+  // Validation
+  validate(envName: string): Promise<ValidationResult>;
+
+  // Environment management
+  getEnvironments(): string[];
+  getCurrentEnvironment(): string;
+  setCurrentEnvironment(name: string): void;
+}
+
+interface ValidationResult {
+  valid: boolean;
+  errors: ValidationError[];
+  warnings: ValidationWarning[];
+}
+```
+
+### Implementación
+
+```typescript
+class EnvResolverImpl implements EnvResolver {
+  private definitions: Map<string, EnvDefinition> = new Map();
+  private cache: Map<string, ResolvedEnv> = new Map();
+  private currentEnv: string = 'development';
+
+  constructor(
+    private config: ConfigManager,
+    private secretsVault?: SecretsVault
+  ) {
+    this.loadDefinitions();
+  }
+
+  private loadDefinitions(): void {
+    const envs = this.config.get<Record<string, EnvDefinition>>('environments', {});
+    for (const [name, def] of Object.entries(envs)) {
+      this.definitions.set(name, { ...def, name });
+    }
+  }
+
+  async resolve(envName: string): Promise<ResolvedEnv> {
+    // Check cache
+    if (this.cache.has(envName)) {
+      return this.cache.get(envName)!;
+    }
+
+    const definition = this.definitions.get(envName);
+    if (!definition) {
+      throw new Error(`Environment not found: ${envName}`);
+    }
+
+    // Build inheritance chain
+    const chain = this.buildInheritanceChain(envName);
+
+    // Merge variables from all environments in chain
+    let resolved: ResolvedEnv = {};
+    for (const env of chain) {
+      const envDef = this.definitions.get(env)!;
+      resolved = { ...resolved, ...await this.resolveVariables(envDef.variables) };
+    }
+
+    // Apply process.env overrides (highest priority)
+    for (const key of Object.keys(resolved)) {
+      if (process.env[key] !== undefined) {
+        resolved[key] = process.env[key]!;
+      }
+    }
+
+    // Interpolate variable references
+    resolved = await this.interpolateAll(resolved);
+
+    this.cache.set(envName, resolved);
+    return resolved;
+  }
+
+  private buildInheritanceChain(envName: string): string[] {
+    const chain: string[] = [];
+    let current = envName;
+    const visited = new Set<string>();
+
+    while (current) {
+      if (visited.has(current)) {
+        throw new Error(`Circular inheritance detected: ${current}`);
+      }
+      visited.add(current);
+      chain.unshift(current);
+
+      const def = this.definitions.get(current);
+      current = def?.inherits || '';
+    }
+
+    return chain;
+  }
+
+  private async resolveVariables(
+    variables: Record<string, EnvVariable>
+  ): Promise<ResolvedEnv> {
+    const resolved: ResolvedEnv = {};
+
+    for (const [key, variable] of Object.entries(variables)) {
+      let value: string | undefined;
+
+      if (variable.secret && this.secretsVault) {
+        // Retrieve from secrets vault
+        value = await this.secretsVault.get(key);
+      } else if (variable.value !== undefined) {
+        value = variable.value;
+      } else if (variable.default !== undefined) {
+        value = variable.default;
+      }
+
+      if (value === undefined && variable.required) {
+        throw new Error(`Required environment variable not set: ${key}`);
+      }
+
+      if (value !== undefined) {
+        resolved[key] = value;
+      }
+    }
+
+    return resolved;
+  }
+
+  private async interpolateAll(env: ResolvedEnv): Promise<ResolvedEnv> {
+    const result: ResolvedEnv = {};
+    let changed = true;
+    let iterations = 0;
+    const maxIterations = 10;
+
+    // Copy initial values
+    for (const [key, value] of Object.entries(env)) {
+      result[key] = value;
+    }
+
+    // Iteratively resolve references until stable
+    while (changed && iterations < maxIterations) {
+      changed = false;
+      iterations++;
+
+      for (const [key, value] of Object.entries(result)) {
+        const interpolated = await this.interpolate(value, result);
+        if (interpolated !== result[key]) {
+          result[key] = interpolated;
+          changed = true;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  async interpolate(template: string, env?: ResolvedEnv): Promise<string> {
+    const resolvedEnv = env || await this.resolve(this.currentEnv);
+
+    // Pattern: ${VAR_NAME} or ${VAR_NAME:-default}
+    return template.replace(/\$\{([^}]+)\}/g, (match, expr) => {
+      const [key, defaultValue] = expr.split(':-');
+
+      if (key in resolvedEnv) {
+        return resolvedEnv[key];
+      }
+      if (process.env[key]) {
+        return process.env[key]!;
+      }
+      if (defaultValue !== undefined) {
+        return defaultValue;
+      }
+
+      return match; // Keep unresolved
+    });
+  }
+
+  async validate(envName: string): Promise<ValidationResult> {
+    const errors: ValidationError[] = [];
+    const warnings: ValidationWarning[] = [];
+
+    const definition = this.definitions.get(envName);
+    if (!definition) {
+      return {
+        valid: false,
+        errors: [{ key: '', message: `Environment not found: ${envName}` }],
+        warnings: []
+      };
+    }
+
+    const resolved = await this.resolve(envName);
+
+    for (const [key, variable] of Object.entries(definition.variables)) {
+      const value = resolved[key];
+
+      // Required check
+      if (variable.required && !value) {
+        errors.push({ key, message: 'Required variable is missing' });
+        continue;
+      }
+
+      if (!value) continue;
+
+      // Type validation
+      if (variable.validation) {
+        const v = variable.validation;
+
+        switch (v.type) {
+          case 'number':
+            if (isNaN(Number(value))) {
+              errors.push({ key, message: 'Must be a number' });
+            } else {
+              const num = Number(value);
+              if (v.min !== undefined && num < v.min) {
+                errors.push({ key, message: `Must be at least ${v.min}` });
+              }
+              if (v.max !== undefined && num > v.max) {
+                errors.push({ key, message: `Must be at most ${v.max}` });
+              }
+            }
+            break;
+
+          case 'boolean':
+            if (!['true', 'false', '1', '0'].includes(value.toLowerCase())) {
+              errors.push({ key, message: 'Must be a boolean' });
+            }
+            break;
+
+          case 'url':
+            try {
+              new URL(value);
+            } catch {
+              errors.push({ key, message: 'Must be a valid URL' });
+            }
+            break;
+
+          case 'email':
+            if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+              errors.push({ key, message: 'Must be a valid email' });
+            }
+            break;
+        }
+
+        // Pattern validation
+        if (v.pattern && !new RegExp(v.pattern).test(value)) {
+          errors.push({ key, message: `Must match pattern: ${v.pattern}` });
+        }
+
+        // Enum validation
+        if (v.enum && !v.enum.includes(value)) {
+          errors.push({ key, message: `Must be one of: ${v.enum.join(', ')}` });
+        }
+      }
+
+      // Warnings for potential issues
+      if (variable.secret && !this.secretsVault) {
+        warnings.push({ key, message: 'Secret variable without vault configured' });
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+
+  getEnvironments(): string[] {
+    return Array.from(this.definitions.keys());
+  }
+
+  getCurrentEnvironment(): string {
+    return this.currentEnv;
+  }
+
+  setCurrentEnvironment(name: string): void {
+    if (!this.definitions.has(name)) {
+      throw new Error(`Environment not found: ${name}`);
+    }
+    this.currentEnv = name;
+    this.cache.clear();
+  }
+}
+```
+
+### Uso
+
+```typescript
+const envResolver = new EnvResolver(config, secretsVault);
+
+// Resolve all variables for an environment
+const prodEnv = await envResolver.resolve('production');
+console.log(prodEnv.DATABASE_URL);
+
+// Interpolate templates
+const connectionString = await envResolver.interpolate(
+  'postgresql://${DB_USER}:${DB_PASS}@${DB_HOST}:${DB_PORT:-5432}/${DB_NAME}'
+);
+
+// Validate environment
+const validation = await envResolver.validate('production');
+if (!validation.valid) {
+  console.error('Environment validation failed:', validation.errors);
+}
+```
+
+---
+
+## 4. ConfigValidator
+
+### Propósito
+Valida configuraciones contra JSON Schema con coerción de tipos y mensajes de error amigables.
+
+### Interfaz
+
+```typescript
+interface SchemaDefinition {
+  $schema?: string;
+  type: string;
+  properties?: Record<string, SchemaDefinition>;
+  required?: string[];
+  items?: SchemaDefinition;
+  enum?: unknown[];
+  minimum?: number;
+  maximum?: number;
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  format?: string;
+  default?: unknown;
+  description?: string;
+  additionalProperties?: boolean | SchemaDefinition;
+}
+
+interface ValidationOptions {
+  coerceTypes?: boolean;
+  removeAdditional?: boolean;
+  useDefaults?: boolean;
+  allErrors?: boolean;
+}
+
+interface ConfigValidatorResult {
+  valid: boolean;
+  errors: ConfigValidationError[];
+  coerced?: Record<string, unknown>;
+}
+
+interface ConfigValidationError {
+  path: string;
+  message: string;
+  keyword: string;
+  params?: Record<string, unknown>;
+}
+
+interface ConfigValidator {
+  // Schema management
+  addSchema(name: string, schema: SchemaDefinition): void;
+  getSchema(name: string): SchemaDefinition | undefined;
+
+  // Validation
+  validate(data: unknown, schemaName: string, options?: ValidationOptions): ConfigValidatorResult;
+  validatePartial(data: unknown, schemaName: string, paths: string[]): ConfigValidatorResult;
+
+  // Utilities
+  coerce(data: unknown, schemaName: string): unknown;
+  getDefaults(schemaName: string): Record<string, unknown>;
+}
+```
+
+### Implementación
+
+```typescript
+class ConfigValidatorImpl implements ConfigValidator {
+  private schemas: Map<string, SchemaDefinition> = new Map();
+
+  constructor() {
+    // Register built-in formats
+    this.registerFormats();
+  }
+
+  private formatValidators: Record<string, (value: string) => boolean> = {
+    'date-time': (v) => !isNaN(Date.parse(v)),
+    'date': (v) => /^\d{4}-\d{2}-\d{2}$/.test(v),
+    'time': (v) => /^\d{2}:\d{2}:\d{2}$/.test(v),
+    'email': (v) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v),
+    'uri': (v) => { try { new URL(v); return true; } catch { return false; } },
+    'uuid': (v) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(v),
+    'hostname': (v) => /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.test(v),
+    'ipv4': (v) => /^(\d{1,3}\.){3}\d{1,3}$/.test(v) && v.split('.').every(n => parseInt(n) <= 255),
+  };
+
+  addSchema(name: string, schema: SchemaDefinition): void {
+    this.schemas.set(name, schema);
+  }
+
+  getSchema(name: string): SchemaDefinition | undefined {
+    return this.schemas.get(name);
+  }
+
+  validate(
+    data: unknown,
+    schemaName: string,
+    options: ValidationOptions = {}
+  ): ConfigValidatorResult {
+    const schema = this.schemas.get(schemaName);
+    if (!schema) {
+      return {
+        valid: false,
+        errors: [{ path: '', message: `Schema not found: ${schemaName}`, keyword: 'schema' }]
+      };
+    }
+
+    const errors: ConfigValidationError[] = [];
+    let coerced = options.coerceTypes ? this.deepClone(data) : data;
+
+    if (options.useDefaults) {
+      coerced = this.applyDefaults(coerced as Record<string, unknown>, schema);
+    }
+
+    if (options.coerceTypes) {
+      coerced = this.coerceTypes(coerced, schema);
+    }
+
+    this.validateValue(coerced, schema, '', errors, options);
+
+    if (options.removeAdditional && schema.type === 'object') {
+      coerced = this.removeAdditionalProps(coerced as Record<string, unknown>, schema);
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      coerced: options.coerceTypes ? coerced as Record<string, unknown> : undefined
+    };
+  }
+
+  private validateValue(
+    value: unknown,
+    schema: SchemaDefinition,
+    path: string,
+    errors: ConfigValidationError[],
+    options: ValidationOptions
+  ): void {
+    // Type validation
+    if (!this.checkType(value, schema.type)) {
+      errors.push({
+        path,
+        message: `Expected ${schema.type}, got ${typeof value}`,
+        keyword: 'type',
+        params: { expected: schema.type, actual: typeof value }
+      });
+      if (!options.allErrors) return;
+    }
+
+    switch (schema.type) {
+      case 'object':
+        this.validateObject(value as Record<string, unknown>, schema, path, errors, options);
+        break;
+      case 'array':
+        this.validateArray(value as unknown[], schema, path, errors, options);
+        break;
+      case 'string':
+        this.validateString(value as string, schema, path, errors);
+        break;
+      case 'number':
+      case 'integer':
+        this.validateNumber(value as number, schema, path, errors);
+        break;
+    }
+
+    // Enum validation
+    if (schema.enum && !schema.enum.includes(value)) {
+      errors.push({
+        path,
+        message: `Must be one of: ${schema.enum.join(', ')}`,
+        keyword: 'enum',
+        params: { allowed: schema.enum }
+      });
+    }
+  }
+
+  private validateObject(
+    obj: Record<string, unknown>,
+    schema: SchemaDefinition,
+    path: string,
+    errors: ConfigValidationError[],
+    options: ValidationOptions
+  ): void {
+    // Required fields
+    if (schema.required) {
+      for (const field of schema.required) {
+        if (!(field in obj)) {
+          errors.push({
+            path: this.joinPath(path, field),
+            message: 'Required field is missing',
+            keyword: 'required'
+          });
+        }
+      }
+    }
+
+    // Property validation
+    if (schema.properties) {
+      for (const [key, propSchema] of Object.entries(schema.properties)) {
+        if (key in obj) {
+          this.validateValue(obj[key], propSchema, this.joinPath(path, key), errors, options);
+        }
+      }
+    }
+
+    // Additional properties
+    if (schema.additionalProperties === false) {
+      const allowed = new Set(Object.keys(schema.properties || {}));
+      for (const key of Object.keys(obj)) {
+        if (!allowed.has(key)) {
+          errors.push({
+            path: this.joinPath(path, key),
+            message: 'Additional property not allowed',
+            keyword: 'additionalProperties'
+          });
+        }
+      }
+    }
+  }
+
+  private validateArray(
+    arr: unknown[],
+    schema: SchemaDefinition,
+    path: string,
+    errors: ConfigValidationError[],
+    options: ValidationOptions
+  ): void {
+    if (schema.items) {
+      arr.forEach((item, index) => {
+        this.validateValue(item, schema.items!, `${path}[${index}]`, errors, options);
+      });
+    }
+  }
+
+  private validateString(
+    value: string,
+    schema: SchemaDefinition,
+    path: string,
+    errors: ConfigValidationError[]
+  ): void {
+    if (schema.minLength !== undefined && value.length < schema.minLength) {
+      errors.push({
+        path,
+        message: `Must be at least ${schema.minLength} characters`,
+        keyword: 'minLength'
+      });
+    }
+
+    if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+      errors.push({
+        path,
+        message: `Must be at most ${schema.maxLength} characters`,
+        keyword: 'maxLength'
+      });
+    }
+
+    if (schema.pattern && !new RegExp(schema.pattern).test(value)) {
+      errors.push({
+        path,
+        message: `Must match pattern: ${schema.pattern}`,
+        keyword: 'pattern'
+      });
+    }
+
+    if (schema.format && this.formatValidators[schema.format]) {
+      if (!this.formatValidators[schema.format](value)) {
+        errors.push({
+          path,
+          message: `Invalid ${schema.format} format`,
+          keyword: 'format'
+        });
+      }
+    }
+  }
+
+  private validateNumber(
+    value: number,
+    schema: SchemaDefinition,
+    path: string,
+    errors: ConfigValidationError[]
+  ): void {
+    if (schema.type === 'integer' && !Number.isInteger(value)) {
+      errors.push({
+        path,
+        message: 'Must be an integer',
+        keyword: 'type'
+      });
+    }
+
+    if (schema.minimum !== undefined && value < schema.minimum) {
+      errors.push({
+        path,
+        message: `Must be at least ${schema.minimum}`,
+        keyword: 'minimum'
+      });
+    }
+
+    if (schema.maximum !== undefined && value > schema.maximum) {
+      errors.push({
+        path,
+        message: `Must be at most ${schema.maximum}`,
+        keyword: 'maximum'
+      });
+    }
+  }
+
+  private checkType(value: unknown, type: string): boolean {
+    switch (type) {
+      case 'object':
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+      case 'array':
+        return Array.isArray(value);
+      case 'string':
+        return typeof value === 'string';
+      case 'number':
+        return typeof value === 'number' && !isNaN(value);
+      case 'integer':
+        return typeof value === 'number' && Number.isInteger(value);
+      case 'boolean':
+        return typeof value === 'boolean';
+      case 'null':
+        return value === null;
+      default:
+        return true;
+    }
+  }
+
+  private coerceTypes(value: unknown, schema: SchemaDefinition): unknown {
+    if (value === undefined || value === null) return value;
+
+    switch (schema.type) {
+      case 'string':
+        return String(value);
+      case 'number':
+        return Number(value);
+      case 'integer':
+        return Math.floor(Number(value));
+      case 'boolean':
+        if (typeof value === 'string') {
+          return value.toLowerCase() === 'true' || value === '1';
+        }
+        return Boolean(value);
+      case 'object':
+        if (typeof value === 'object' && schema.properties) {
+          const obj = value as Record<string, unknown>;
+          const result: Record<string, unknown> = {};
+          for (const [key, propSchema] of Object.entries(schema.properties)) {
+            if (key in obj) {
+              result[key] = this.coerceTypes(obj[key], propSchema);
+            }
+          }
+          return result;
+        }
+        return value;
+      case 'array':
+        if (Array.isArray(value) && schema.items) {
+          return value.map(item => this.coerceTypes(item, schema.items!));
+        }
+        return value;
+      default:
+        return value;
+    }
+  }
+
+  private applyDefaults(
+    obj: Record<string, unknown>,
+    schema: SchemaDefinition
+  ): Record<string, unknown> {
+    const result = { ...obj };
+
+    if (schema.properties) {
+      for (const [key, propSchema] of Object.entries(schema.properties)) {
+        if (!(key in result) && propSchema.default !== undefined) {
+          result[key] = this.deepClone(propSchema.default);
+        } else if (key in result && propSchema.type === 'object') {
+          result[key] = this.applyDefaults(
+            result[key] as Record<string, unknown>,
+            propSchema
+          );
+        }
+      }
+    }
+
+    return result;
+  }
+
+  getDefaults(schemaName: string): Record<string, unknown> {
+    const schema = this.schemas.get(schemaName);
+    if (!schema) return {};
+    return this.extractDefaults(schema);
+  }
+
+  private extractDefaults(schema: SchemaDefinition): Record<string, unknown> {
+    const defaults: Record<string, unknown> = {};
+
+    if (schema.properties) {
+      for (const [key, propSchema] of Object.entries(schema.properties)) {
+        if (propSchema.default !== undefined) {
+          defaults[key] = propSchema.default;
+        } else if (propSchema.type === 'object') {
+          const nested = this.extractDefaults(propSchema);
+          if (Object.keys(nested).length > 0) {
+            defaults[key] = nested;
+          }
+        }
+      }
+    }
+
+    return defaults;
+  }
+
+  private joinPath(base: string, key: string): string {
+    return base ? `${base}.${key}` : key;
+  }
+
+  private deepClone<T>(obj: T): T {
+    return JSON.parse(JSON.stringify(obj));
+  }
+}
+```
+
+### Uso
+
+```typescript
+const validator = new ConfigValidator();
+
+// Register schema
+validator.addSchema('elsabro-config', {
+  type: 'object',
+  required: ['llm', 'agents'],
+  properties: {
+    llm: {
+      type: 'object',
+      required: ['model'],
+      properties: {
+        model: {
+          type: 'string',
+          enum: ['claude-sonnet-4-20250514', 'claude-opus-4-20250514', 'claude-3-5-haiku-20241022'],
+          default: 'claude-sonnet-4-20250514'
+        },
+        maxTokens: {
+          type: 'integer',
+          minimum: 1,
+          maximum: 200000,
+          default: 4096
+        },
+        temperature: {
+          type: 'number',
+          minimum: 0,
+          maximum: 1,
+          default: 0.7
+        }
+      }
+    },
+    agents: {
+      type: 'object',
+      additionalProperties: {
+        type: 'object',
+        properties: {
+          enabled: { type: 'boolean', default: true },
+          model: { type: 'string' },
+          maxIterations: { type: 'integer', minimum: 1 }
+        }
+      }
+    }
+  }
+});
+
+// Validate config
+const result = validator.validate(userConfig, 'elsabro-config', {
+  coerceTypes: true,
+  useDefaults: true,
+  allErrors: true
+});
+
+if (!result.valid) {
+  console.error('Config validation failed:');
+  result.errors.forEach(err => {
+    console.error(`  ${err.path}: ${err.message}`);
+  });
+} else {
+  // Use coerced config with defaults applied
+  const validConfig = result.coerced;
+}
+```
+
+---
+
+## 5. RemoteConfigSync
+
+### Propósito
+Sincroniza configuración desde fuentes remotas con caching, fallback y actualización automática.
+
+### Interfaz
+
+```typescript
+interface RemoteConfigOptions {
+  url: string;
+  pollingInterval?: number;  // ms, 0 = disabled
+  cacheEnabled?: boolean;
+  cacheTTL?: number;  // ms
+  fallbackToCache?: boolean;
+  headers?: Record<string, string>;
+  timeout?: number;
+  retryAttempts?: number;
+  retryDelay?: number;
+}
+
+interface RemoteConfigSync {
+  // Fetch operations
+  fetch(): Promise<Record<string, unknown>>;
+  fetchWithFallback(): Promise<Record<string, unknown>>;
+
+  // Polling
+  startPolling(): void;
+  stopPolling(): void;
+
+  // Cache
+  getFromCache(): Record<string, unknown> | null;
+  clearCache(): void;
+
+  // Events
+  onUpdate(callback: (config: Record<string, unknown>) => void): () => void;
+  onError(callback: (error: Error) => void): () => void;
+
+  // Status
+  getStatus(): RemoteConfigStatus;
+}
+
+interface RemoteConfigStatus {
+  lastFetch: Date | null;
+  lastSuccess: Date | null;
+  lastError: Error | null;
+  isPolling: boolean;
+  cacheAge: number | null;
+}
+```
+
+### Implementación
+
+```typescript
+class RemoteConfigSyncImpl implements RemoteConfigSync {
+  private options: Required<RemoteConfigOptions>;
+  private cache: { data: Record<string, unknown>; timestamp: number } | null = null;
+  private pollingTimer: NodeJS.Timer | null = null;
+  private updateCallbacks: Set<Function> = new Set();
+  private errorCallbacks: Set<Function> = new Set();
+  private status: RemoteConfigStatus = {
+    lastFetch: null,
+    lastSuccess: null,
+    lastError: null,
+    isPolling: false,
+    cacheAge: null
+  };
+
+  constructor(options: RemoteConfigOptions) {
+    this.options = {
+      pollingInterval: 0,
+      cacheEnabled: true,
+      cacheTTL: 300000, // 5 minutes
+      fallbackToCache: true,
+      headers: {},
+      timeout: 10000,
+      retryAttempts: 3,
+      retryDelay: 1000,
+      ...options
+    };
+  }
+
+  async fetch(): Promise<Record<string, unknown>> {
+    this.status.lastFetch = new Date();
+
+    let lastError: Error | null = null;
+
+    for (let attempt = 1; attempt <= this.options.retryAttempts; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+
+        const response = await fetch(this.options.url, {
+          headers: this.options.headers,
+          signal: controller.signal
+        });
+
+        clearTimeout(timeoutId);
+
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+
+        const data = await response.json();
+
+        // Update cache
+        if (this.options.cacheEnabled) {
+          this.cache = {
+            data,
+            timestamp: Date.now()
+          };
+        }
+
+        this.status.lastSuccess = new Date();
+        this.status.lastError = null;
+
+        // Notify listeners
+        this.updateCallbacks.forEach(cb => cb(data));
+
+        return data;
+      } catch (error) {
+        lastError = error as Error;
+
+        if (attempt < this.options.retryAttempts) {
+          await this.delay(this.options.retryDelay * attempt);
+        }
+      }
+    }
+
+    this.status.lastError = lastError;
+    this.errorCallbacks.forEach(cb => cb(lastError));
+    throw lastError;
+  }
+
+  async fetchWithFallback(): Promise<Record<string, unknown>> {
+    try {
+      return await this.fetch();
+    } catch (error) {
+      if (this.options.fallbackToCache && this.cache) {
+        console.warn('Remote config fetch failed, using cached config');
+        return this.cache.data;
+      }
+      throw error;
+    }
+  }
+
+  startPolling(): void {
+    if (this.pollingTimer || this.options.pollingInterval <= 0) {
+      return;
+    }
+
+    this.status.isPolling = true;
+
+    this.pollingTimer = setInterval(async () => {
+      try {
+        await this.fetch();
+      } catch (error) {
+        // Error already handled in fetch()
+      }
+    }, this.options.pollingInterval);
+
+    // Initial fetch
+    this.fetch().catch(() => {});
+  }
+
+  stopPolling(): void {
+    if (this.pollingTimer) {
+      clearInterval(this.pollingTimer);
+      this.pollingTimer = null;
+    }
+    this.status.isPolling = false;
+  }
+
+  getFromCache(): Record<string, unknown> | null {
+    if (!this.cache) return null;
+
+    const age = Date.now() - this.cache.timestamp;
+    if (age > this.options.cacheTTL) {
+      this.cache = null;
+      return null;
+    }
+
+    return this.cache.data;
+  }
+
+  clearCache(): void {
+    this.cache = null;
+  }
+
+  onUpdate(callback: Function): () => void {
+    this.updateCallbacks.add(callback);
+    return () => this.updateCallbacks.delete(callback);
+  }
+
+  onError(callback: Function): () => void {
+    this.errorCallbacks.add(callback);
+    return () => this.errorCallbacks.delete(callback);
+  }
+
+  getStatus(): RemoteConfigStatus {
+    return {
+      ...this.status,
+      cacheAge: this.cache ? Date.now() - this.cache.timestamp : null
+    };
+  }
+
+  private delay(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+```
+
+---
+
+## 6. Integración con ELSABRO
+
+### Inicialización
+
+```typescript
+// config/index.ts
+import { ConfigManager } from './ConfigManager';
+import { FeatureFlagService } from './FeatureFlags';
+import { EnvResolver } from './EnvResolver';
+import { ConfigValidator } from './ConfigValidator';
+import { RemoteConfigSync } from './RemoteConfigSync';
+
+export async function initializeConfig(): Promise<ConfigurationSystem> {
+  // 1. Create config manager
+  const configManager = new ConfigManager({
+    environment: process.env.NODE_ENV || 'development',
+    sources: [
+      { type: 'file', path: '.elsabro/config.json', priority: 1 },
+      { type: 'file', path: '.elsabro/config.local.json', priority: 2, required: false },
+      { type: 'env', path: 'ELSABRO', priority: 3 }
+    ],
+    watchForChanges: true,
+    mergeStrategy: 'deep'
+  });
+
+  await configManager.load();
+
+  // 2. Create validator and validate config
+  const validator = new ConfigValidator();
+  validator.addSchema('elsabro', elsabroConfigSchema);
+
+  const validation = validator.validate(configManager.getAll(), 'elsabro', {
+    coerceTypes: true,
+    useDefaults: true
+  });
+
+  if (!validation.valid) {
+    throw new ConfigValidationError(validation.errors);
+  }
+
+  // 3. Create env resolver
+  const envResolver = new EnvResolver(configManager);
+  const envValidation = await envResolver.validate(configManager.getEnvironment());
+
+  if (!envValidation.valid) {
+    console.warn('Environment validation warnings:', envValidation.warnings);
+  }
+
+  // 4. Create feature flags
+  const featureFlags = new FeatureFlagService(configManager);
+
+  // 5. Setup remote config if enabled
+  let remoteConfig: RemoteConfigSync | null = null;
+  if (configManager.get('remoteConfig.enabled')) {
+    remoteConfig = new RemoteConfigSync({
+      url: configManager.get('remoteConfig.url'),
+      pollingInterval: configManager.get('remoteConfig.pollingInterval', 60000)
+    });
+
+    remoteConfig.onUpdate((config) => {
+      configManager.merge(config);
+    });
+
+    remoteConfig.startPolling();
+  }
+
+  return {
+    config: configManager,
+    flags: featureFlags,
+    env: envResolver,
+    validator,
+    remoteConfig
+  };
+}
+```
+
+### Dashboard de Configuración
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                        ELSABRO Configuration Dashboard                       │
+├─────────────────────────────────────────────────────────────────────────────┤
+│  Environment: production                                                     │
+│  Config Sources: 4 loaded, 0 failed                                         │
+│  Last Validation: ✓ Valid (2024-01-15 10:30:45)                            │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                              Feature Flags                                   │
+├─────────────────┬──────────┬─────────────┬──────────────────────────────────┤
+│ Flag            │ Status   │ Targeting   │ Rollout                          │
+├─────────────────┼──────────┼─────────────┼──────────────────────────────────┤
+│ new-agent-ui    │ ✓ ON     │ All Users   │ ████████████████████ 100%        │
+│ beta-tools      │ ✓ ON     │ Enterprise  │ ████████░░░░░░░░░░░░  40%        │
+│ experimental    │ ✗ OFF    │ Internal    │ ░░░░░░░░░░░░░░░░░░░░   0%        │
+│ cost-optimizer  │ ⏰ SCHED │ All Users   │ Starts: 2024-02-01               │
+└─────────────────┴──────────┴─────────────┴──────────────────────────────────┘
+│                              Remote Config                                   │
+├─────────────────────────────────────────────────────────────────────────────┤
+│  Status: ● Connected                                                         │
+│  Last Sync: 2024-01-15 10:30:00 (45 seconds ago)                            │
+│  Polling: Every 60s                                                          │
+│  Cache: Valid (TTL: 4:15 remaining)                                         │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 7. Best Practices
+
+### Diseño de Configuración
+
+1. **Estructura jerárquica clara**: Agrupa configs relacionadas
+2. **Valores por defecto sensibles**: Funcionamiento out-of-the-box
+3. **Documentación inline**: Descripciones en schema
+4. **Validación estricta**: Falla temprano con errores claros
+
+### Feature Flags
+
+1. **Nombres descriptivos**: `enable-new-checkout` no `flag1`
+2. **Kill switches**: Siempre poder desactivar features
+3. **Cleanup regular**: Eliminar flags obsoletos
+4. **Auditoría**: Log de cambios en flags
+
+### Environments
+
+1. **Herencia clara**: `prod > staging > development`
+2. **Secretos separados**: Nunca en archivos de config
+3. **Validación por environment**: Diferentes requerimientos
+4. **Documentación de variables**: Qué hace cada una
+
+### Remote Config
+
+1. **Fallback robusto**: Cache local siempre disponible
+2. **Timeouts cortos**: No bloquear startup
+3. **Versionamiento**: Rollback fácil
+4. **Monitoring**: Alertas de sync failures
+
+---
+
+## Referencias
+
+- **REF-001**: Architecture Guide
+- **REF-006**: Observability & Metrics
+- **REF-022**: Security System (para integración con SecretsVault)
+- **REF-023**: Esta referencia (Configuration Management)