agentic-qe 3.8.4 → 3.8.6

package/dist/domains/base-domain-coordinator.d.ts

@@ -52,21 +52,6 @@ export interface BaseDomainCoordinatorConfig {
     consensusStrategy: 'majority' | 'weighted' | 'unanimous';
     consensusMinModels: number;
 }
-/**
- * Abstract base class for all domain coordinators.
- *
- * Provides concrete implementations for:
- * - MinCut topology awareness (setMinCutBridge, isTopologyHealthy, etc.)
- * - Consensus lifecycle (initializeConsensus, disposeConsensus, etc.)
- * - Governance mixin access
- * - Workflow management (start, complete, fail, progress tracking)
- * - Initialization guard pattern
- *
- * Subclasses implement:
- * - onInitialize(): domain-specific setup (RL integrations, services, etc.)
- * - onDispose(): domain-specific teardown
- * - subscribeToEvents(): domain-specific event subscriptions
- */
 export declare abstract class BaseDomainCoordinator<TConfig extends BaseDomainCoordinatorConfig = BaseDomainCoordinatorConfig, TWorkflowType extends string = string> {
     protected readonly eventBus: EventBus;
     protected readonly domainName: DomainName;

package/dist/domains/base-domain-coordinator.js

@@ -16,6 +16,7 @@
  * - onDispose(): domain-specific cleanup
  * - subscribeToEvents(): domain-specific event subscriptions
  */
+import { LoggerFactory } from '../logging/index.js';
 // MinCut mixin (ADR-047)
 import { createMinCutAwareMixin, } from '../coordination/mixins/mincut-aware-domain.js';
 // Consensus mixin (MM-001)
@@ -40,6 +41,7 @@ import { createGovernanceAwareMixin, } from '../coordination/mixins/governance-a
  * - onDispose(): domain-specific teardown
  * - subscribeToEvents(): domain-specific event subscriptions
  */
+const baseLogger = LoggerFactory.create('base-domain-coordinator');
 export class BaseDomainCoordinator {
     eventBus;
     domainName;
@@ -92,11 +94,11 @@ export class BaseDomainCoordinator {
         if (this.config.enableConsensus) {
             try {
                 await this.consensusMixin.initializeConsensus();
-                console.log(`[${this.domainName}] Consensus engine initialized`);
+                baseLogger.info(`[${this.domainName}] Consensus engine initialized`);
             }
             catch (error) {
-                console.error(`[${this.domainName}] Failed to initialize consensus engine:`, error);
-                console.warn(`[${this.domainName}] Continuing without consensus verification`);
+                baseLogger.error(`[${this.domainName}] Failed to initialize consensus engine`, error instanceof Error ? error : undefined);
+                baseLogger.warn(`[${this.domainName}] Continuing without consensus verification`);
             }
         }
         this.initialized = true;
@@ -111,7 +113,7 @@ export class BaseDomainCoordinator {
             await this.consensusMixin.disposeConsensus();
         }
         catch (error) {
-            console.error(`[${this.domainName}] Error disposing consensus engine:`, error);
+            baseLogger.error(`[${this.domainName}] Error disposing consensus engine`, error instanceof Error ? error : undefined);
         }
         // Dispose MinCut mixin (ADR-047)
         this.minCutMixin.dispose();
@@ -125,7 +127,7 @@ export class BaseDomainCoordinator {
     // ==========================================================================
     setMinCutBridge(bridge) {
         this.minCutMixin.setMinCutBridge(bridge);
-        console.log(`[${this.domainName}] MinCut bridge connected`);
+        baseLogger.info(`[${this.domainName}] MinCut bridge connected`);
     }
     isTopologyHealthy() {
         return this.minCutMixin.isTopologyHealthy();

package/dist/domains/chaos-resilience/coordinator.d.ts

@@ -42,10 +42,6 @@ export interface CoordinatorConfig extends BaseDomainCoordinatorConfig {
     consensusConfig?: Partial<ConsensusEnabledConfig>;
 }
 type ChaosWorkflowType = 'chaos-suite' | 'load-suite' | 'assessment' | 'experiment-generation';
-/**
- * Chaos Resilience Coordinator
- * Orchestrates chaos engineering workflows and coordinates with agents
- */
 export declare class ChaosResilienceCoordinator extends BaseDomainCoordinator<CoordinatorConfig, ChaosWorkflowType> implements IChaosResilienceCoordinatorExtended {
     private readonly memory;
     private readonly agentCoordinator;

package/dist/domains/chaos-resilience/coordinator.js

@@ -2,6 +2,7 @@
  * Agentic QE v3 - Chaos & Resilience Coordinator
  * Orchestrates chaos engineering and resilience testing workflows
  */
+import { LoggerFactory } from '../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../shared/types';
 import { toError, toErrorMessage } from '../../shared/error-utils.js';
@@ -37,6 +38,7 @@ const DEFAULT_CONFIG = {
  * Chaos Resilience Coordinator
  * Orchestrates chaos engineering workflows and coordinates with agents
  */
+const logger = LoggerFactory.create('chaos-resilience');
 export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
     memory;
     agentCoordinator;
@@ -81,10 +83,10 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
                     hiddenLayers: [64, 64],
                 });
                 // First call to predict will initialize the algorithm
-                console.log('[chaos-resilience] PolicyGradient algorithm created successfully');
+                logger.info('PolicyGradient algorithm created successfully');
             }
             catch (error) {
-                console.error('[chaos-resilience] Failed to create PolicyGradient:', error);
+                logger.error('Failed to create PolicyGradient:', error instanceof Error ? error : undefined);
                 throw new Error(`PolicyGradient creation failed: ${toErrorMessage(error)}`);
             }
         }
@@ -98,12 +100,12 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
                     maxPatterns: 5000,
                     minConfidence: 0.6,
                 });
-                console.log('[chaos-resilience] PersistentSONAEngine initialized successfully');
+                logger.info('PersistentSONAEngine initialized successfully');
             }
             catch (error) {
                 // Log and continue - SONA is enhancement, not critical
-                console.error('[chaos-resilience] Failed to initialize PersistentSONAEngine:', error);
-                console.warn('[chaos-resilience] Continuing without SONA pattern persistence');
+                logger.error('Failed to initialize PersistentSONAEngine:', error instanceof Error ? error : undefined);
+                logger.warn('Continuing without SONA pattern persistence');
                 this.qesona = undefined;
             }
         }
@@ -140,7 +142,7 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
             this.startWorkflow(workflowId, 'chaos-suite');
             // ADR-047: Check topology health before running chaos experiments
             if (this.config.enableMinCutAwareness && !this.isTopologyHealthy()) {
-                console.warn(`[${this.domainName}] Topology degraded, using conservative chaos strategy`);
+                logger.warn(`Topology degraded, using conservative chaos strategy`);
                 // Continue with reduced blast radius when topology is unhealthy
             }
             // ADR-047: Check if operations should be paused due to critical topology
@@ -220,7 +222,7 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
             this.startWorkflow(workflowId, 'load-suite');
             // ADR-047: Check topology health before running load tests
             if (this.config.enableMinCutAwareness && !this.isTopologyHealthy()) {
-                console.warn(`[${this.domainName}] Topology degraded, using conservative load test parameters`);
+                logger.warn(`Topology degraded, using conservative load test parameters`);
             }
             // ADR-047: Check if operations should be paused due to critical topology
             if (this.minCutMixin.shouldPauseOperations()) {
@@ -289,7 +291,7 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
             this.startWorkflow(workflowId, 'assessment');
             // ADR-047: Check topology health before assessment
             if (this.config.enableMinCutAwareness && !this.isTopologyHealthy()) {
-                console.warn(`[${this.domainName}] Topology degraded, assessment may be limited`);
+                logger.warn(`Topology degraded, assessment may be limited`);
             }
             // ADR-047: Check if operations should be paused due to critical topology
             if (this.minCutMixin.shouldPauseOperations()) {
@@ -438,7 +440,7 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
             this.startWorkflow(workflowId, 'chaos-suite');
             // ADR-047: Check topology health before running strategic chaos
             if (this.config.enableMinCutAwareness && !this.isTopologyHealthy()) {
-                console.warn(`[${this.domainName}] Topology degraded, adjusting strategic chaos parameters`);
+                logger.warn(`Topology degraded, adjusting strategic chaos parameters`);
                 // Continue but may need to reduce experiment scope
             }
             // ADR-047: Check if operations should be paused due to critical topology
@@ -455,7 +457,7 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
                 return err(strategyResult.error);
             }
             const selectedExperiments = strategyResult.value.selectedExperiments;
-            console.log(`[chaos-resilience] Using ${strategyResult.value.strategy} strategy with ${selectedExperiments.length} experiments (confidence: ${strategyResult.value.confidence.toFixed(2)})`);
+            logger.info(`[chaos-resilience] Using ${strategyResult.value.strategy} strategy with ${selectedExperiments.length} experiments (confidence: ${strategyResult.value.confidence.toFixed(2)})`);
             if (selectedExperiments.length === 0) {
                 this.completeWorkflow(workflowId);
                 return ok({
@@ -970,7 +972,7 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
                 nextState: state,
                 done: true,
             });
-            console.log(`[chaos-resilience] PolicyGradient selected ${strategy} strategy for ${services.length} services (confidence: ${prediction.confidence.toFixed(2)})`);
+            logger.info(`[chaos-resilience] PolicyGradient selected ${strategy} strategy for ${services.length} services (confidence: ${prediction.confidence.toFixed(2)})`);
             return ok({
                 strategy,
                 selectedExperiments,
@@ -979,7 +981,7 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
             });
         }
         catch (error) {
-            console.error('[chaos-resilience] PolicyGradient strategy selection failed:', error);
+            logger.error('PolicyGradient strategy selection failed:', error instanceof Error ? error : undefined);
             // Return default strategy on error (graceful degradation)
             return ok({
                 strategy: 'fallback',
@@ -1072,10 +1074,10 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
                 faultType: experiment.faults[0]?.type,
                 hypothesisValidated: result.hypothesisValidated,
             });
-            console.log(`[chaos-resilience] Stored resilience pattern for ${experiment.id} (validated: ${result.hypothesisValidated}, quality: ${quality.toFixed(2)})`);
+            logger.info(`Stored resilience pattern for ${experiment.id} (validated: ${result.hypothesisValidated}, quality: ${quality.toFixed(2)})`);
         }
         catch (error) {
-            console.error('[chaos-resilience] Failed to store resilience pattern:', error);
+            logger.error('Failed to store resilience pattern:', error instanceof Error ? error : undefined);
         }
     }
     /**
@@ -1109,7 +1111,7 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
             if (adaptation.success && adaptation.pattern) {
                 const shouldRunChaos = adaptation.pattern.outcome.success;
                 const recommendedFaults = this.getRecommendedFaults(adaptation.pattern.action.type);
-                console.log(`[chaos-resilience] QESONA adapted strategy for ${service.name}: shouldRun=${shouldRunChaos}, faults=${recommendedFaults.join(',')}, confidence=${adaptation.similarity.toFixed(2)}`);
+                logger.info(`[chaos-resilience] QESONA adapted strategy for ${service.name}: shouldRun=${shouldRunChaos}, faults=${recommendedFaults.join(',')}, confidence=${adaptation.similarity.toFixed(2)}`);
                 return {
                     shouldRunChaos,
                     recommendedFaults,
@@ -1123,7 +1125,7 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
             };
         }
         catch (error) {
-            console.error('[chaos-resilience] QESONA strategy adaptation failed:', error);
+            logger.error('QESONA strategy adaptation failed:', error instanceof Error ? error : undefined);
             return {
                 shouldRunChaos: context.environment !== 'production',
                 recommendedFaults: ['latency', 'error'],
@@ -1218,10 +1220,10 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
         if (this.consensusMixin.requiresConsensus(finding)) {
             const result = await this.consensusMixin.verifyFinding(finding);
             if (result.success && result.value.verdict === 'verified') {
-                console.log(`[${this.domainName}] Chaos experiment '${experiment.name}' verified safe by consensus`);
+                logger.info(`Chaos experiment '${experiment.name}' verified safe by consensus`);
                 return true;
             }
-            console.warn(`[${this.domainName}] Chaos experiment '${experiment.name}' NOT verified safe: ${result.success ? result.value.verdict : result.error.message}`);
+            logger.warn(`Chaos experiment '${experiment.name}' NOT verified safe: ${result.success ? result.value.verdict : result.error.message}`);
             return false;
         }
         return true; // No consensus needed
@@ -1247,10 +1249,10 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
         if (this.consensusMixin.requiresConsensus(finding)) {
             const result = await this.consensusMixin.verifyFinding(finding);
             if (result.success && result.value.verdict === 'verified') {
-                console.log(`[${this.domainName}] Resilience assessment for '${assessment.service}' verified by consensus`);
+                logger.info(`Resilience assessment for '${assessment.service}' verified by consensus`);
                 return true;
             }
-            console.warn(`[${this.domainName}] Resilience assessment for '${assessment.service}' NOT verified`);
+            logger.warn(`Resilience assessment for '${assessment.service}' NOT verified`);
             return false;
         }
         return true; // No consensus needed
@@ -1276,10 +1278,10 @@ export class ChaosResilienceCoordinator extends BaseDomainCoordinator {
         if (this.consensusMixin.requiresConsensus(finding)) {
             const result = await this.consensusMixin.verifyFinding(finding);
             if (result.success && result.value.verdict === 'verified') {
-                console.log(`[${this.domainName}] Failure injection '${injection.faultType}' on '${injection.target}' verified safe by consensus`);
+                logger.info(`Failure injection '${injection.faultType}' on '${injection.target}' verified safe by consensus`);
                 return true;
             }
-            console.warn(`[${this.domainName}] Failure injection '${injection.faultType}' NOT verified safe: ${result.success ? result.value.verdict : result.error.message}`);
+            logger.warn(`Failure injection '${injection.faultType}' NOT verified safe: ${result.success ? result.value.verdict : result.error.message}`);
             return false;
         }
         return true; // No consensus needed

package/dist/domains/chaos-resilience/services/chaos-engineer.d.ts

@@ -29,10 +29,6 @@ export interface ChaosEngineerDependencies {
     memory: MemoryBackend;
     llmRouter?: HybridRouter;
 }
-/**
- * Chaos Engineering Service Implementation
- * Manages chaos experiments, fault injection, and steady state verification
- */
 export declare class ChaosEngineerService implements IChaosEngineeringService {
     private readonly config;
     private readonly activeExperiments;

package/dist/domains/chaos-resilience/services/chaos-engineer.js

@@ -2,12 +2,13 @@
  * Agentic QE v3 - Chaos Engineering Service
  * Implements IChaosEngineeringService for fault injection and experiment execution
  */
+import { LoggerFactory } from '../../../logging/index.js';
 import { ok, err } from '../../../shared/types';
 import { HttpClient } from '../../../shared/http';
 import { getSystemMetricsCollector, } from '../../../shared/metrics';
 import * as net from 'net';
 import { execFile } from 'child_process';
-import { validateCommand } from '../../../mcp/security/cve-prevention';
+import { validateCommand } from '../../../shared/security/command-validator.js';
 import { toErrorMessage, toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { secureRandom } from '../../../shared/utils/crypto-random.js';
@@ -25,6 +26,7 @@ const DEFAULT_CONFIG = {
  * Chaos Engineering Service Implementation
  * Manages chaos experiments, fault injection, and steady state verification
  */
+const logger = LoggerFactory.create('chaos-resilience/chaos-engineer');
 export class ChaosEngineerService {
     config;
     activeExperiments = new Map();
@@ -54,7 +56,7 @@ export class ChaosEngineerService {
             // ADR-051: Get LLM analysis of experiment hypothesis if available
             const llmAnalysis = await this.analyzeExperimentWithLLM(experiment);
             if (llmAnalysis) {
-                console.log(`[ChaosEngineerService] LLM Analysis:\n${llmAnalysis}`);
+                logger.info(`LLM Analysis:\n${llmAnalysis}`);
             }
             // Store experiment
             await this.memory.set(`chaos:experiments:${experiment.id}`, experiment, { namespace: 'chaos-resilience', persist: true });
@@ -322,7 +324,7 @@ Provide:
             return response.content;
         }
         catch (error) {
-            console.warn('[ChaosEngineerService] LLM analysis failed:', error);
+            logger.warn('LLM analysis failed:');
             return null;
         }
     }
@@ -434,7 +436,7 @@ Provide:
                 circuitBreaker: false,
             });
             if (!result.success) {
-                console.log(`HTTP probe failed: ${probe.name} -> ${result.error.message}`);
+                logger.info(`HTTP probe failed: ${probe.name} -> ${result.error.message}`);
                 return false;
             }
             const response = result.value;
@@ -442,7 +444,7 @@ Provide:
             if (probe.expectedStatus !== undefined) {
                 const passed = response.status === probe.expectedStatus;
                 if (!passed) {
-                    console.log(`HTTP probe ${probe.name}: expected status ${probe.expectedStatus}, got ${response.status}`);
+                    logger.info(`HTTP probe ${probe.name}: expected status ${probe.expectedStatus}, got ${response.status}`);
                 }
                 return passed;
             }
@@ -450,7 +452,7 @@ Provide:
             return response.ok;
         }
         catch (error) {
-            console.log(`HTTP probe error: ${probe.name} -> ${toErrorMessage(error)}`);
+            logger.info(`HTTP probe error: ${probe.name} -> ${toErrorMessage(error)}`);
             return false;
         }
     }
@@ -461,7 +463,7 @@ Provide:
                 const [host, portStr] = probe.target.split(':');
                 const port = parseInt(portStr, 10);
                 if (!host || isNaN(port)) {
-                    console.log(`TCP probe invalid target: ${probe.target} (expected host:port)`);
+                    logger.info(`TCP probe invalid target: ${probe.target} (expected host:port)`);
                     resolve(false);
                     return;
                 }
@@ -469,7 +471,7 @@ Provide:
                 const socket = new net.Socket();
                 const timer = setTimeout(() => {
                     socket.destroy();
-                    console.log(`TCP probe timeout: ${probe.name} -> ${probe.target}`);
+                    logger.info(`TCP probe timeout: ${probe.name} -> ${probe.target}`);
                     resolve(false);
                 }, timeout);
                 socket.connect(port, host, () => {
@@ -480,12 +482,12 @@ Provide:
                 socket.on('error', (err) => {
                     clearTimeout(timer);
                     socket.destroy();
-                    console.log(`TCP probe error: ${probe.name} -> ${err.message}`);
+                    logger.info(`TCP probe error: ${probe.name} -> ${err.message}`);
                     resolve(false);
                 });
             }
             catch (error) {
-                console.log(`TCP probe exception: ${probe.name} -> ${toErrorMessage(error)}`);
+                logger.info(`TCP probe exception: ${probe.name} -> ${toErrorMessage(error)}`);
                 resolve(false);
             }
         });
@@ -511,8 +513,8 @@ Provide:
             // Validate command against whitelist to prevent injection (CWE-78)
             const validation = validateCommand(probe.target, ChaosEngineerService.ALLOWED_PROBE_COMMANDS);
             if (!validation.valid) {
-                console.log(`Command probe ${probe.name} blocked: ${validation.error}`);
-                console.log(`Blocked patterns: ${validation.blockedPatterns?.join(', ') || 'none'}`);
+                logger.info(`Command probe ${probe.name} blocked: ${validation.error}`);
+                logger.info(`Blocked patterns: ${validation.blockedPatterns?.join(', ') || 'none'}`);
                 resolve(false);
                 return;
             }
@@ -524,7 +526,7 @@ Provide:
             // Use execFile instead of exec to avoid shell interpretation
             execFile(executable, args, { timeout }, (error, stdout, _stderr) => {
                 if (error) {
-                    console.log(`Command probe failed: ${probe.name} -> ${error.message}`);
+                    logger.info(`Command probe failed: ${probe.name} -> ${error.message}`);
                     resolve(false);
                     return;
                 }
@@ -532,7 +534,7 @@ Provide:
                 if (probe.expectedOutput !== undefined) {
                     const passed = stdout.trim().includes(probe.expectedOutput);
                     if (!passed) {
-                        console.log(`Command probe ${probe.name}: output did not contain expected value`);
+                        logger.info(`Command probe ${probe.name}: output did not contain expected value`);
                     }
                     resolve(passed);
                     return;
@@ -551,12 +553,12 @@ Provide:
                 circuitBreaker: false,
             });
             if (!result.success) {
-                console.log(`Metric probe failed: ${probe.name} -> ${result.error.message}`);
+                logger.info(`Metric probe failed: ${probe.name} -> ${result.error.message}`);
                 return false;
             }
             const response = result.value;
             if (!response.ok) {
-                console.log(`Metric probe HTTP error: ${probe.name} -> ${response.status}`);
+                logger.info(`Metric probe HTTP error: ${probe.name} -> ${response.status}`);
                 return false;
             }
             // Parse response body for metric value
@@ -571,7 +573,7 @@ Provide:
                 metricValue = parseFloat(text);
             }
             if (isNaN(metricValue)) {
-                console.log(`Metric probe ${probe.name}: could not parse metric value from response`);
+                logger.info(`Metric probe ${probe.name}: could not parse metric value from response`);
                 return false;
             }
             // Check threshold if specified
@@ -589,7 +591,7 @@ Provide:
             return true;
         }
         catch (error) {
-            console.log(`Metric probe error: ${probe.name} -> ${toErrorMessage(error)}`);
+            logger.info(`Metric probe error: ${probe.name} -> ${toErrorMessage(error)}`);
             return false;
         }
     }
@@ -616,27 +618,27 @@ Provide:
         // Latency injection is typically done at proxy/network level
         // For simulation, we store the config and check during probe execution
         const latencyMs = fault.parameters.latencyMs ?? 100;
-        console.log(`Latency injection configured: ${latencyMs}ms for ${fault.target.selector}`);
-        console.log(`Note: Actual latency injection requires network proxy (e.g., Toxiproxy, tc)`);
+        logger.info(`Latency injection configured: ${latencyMs}ms for ${fault.target.selector}`);
+        logger.info(`Note: Actual latency injection requires network proxy (e.g., Toxiproxy, tc)`);
         return ok(1);
     }
     async injectError(fault) {
         // Error injection typically requires proxy/service mesh
         const errorCode = fault.parameters.errorCode ?? 500;
-        console.log(`Error injection configured: ${errorCode} for ${fault.target.selector}`);
-        console.log(`Note: Actual error injection requires service mesh (e.g., Istio, Linkerd)`);
+        logger.info(`Error injection configured: ${errorCode} for ${fault.target.selector}`);
+        logger.info(`Note: Actual error injection requires service mesh (e.g., Istio, Linkerd)`);
         return ok(1);
     }
     async injectTimeout(fault) {
         // Timeout injection via proxy configuration
-        console.log(`Timeout injection configured for ${fault.target.selector}`);
-        console.log(`Note: Actual timeout injection requires network proxy configuration`);
+        logger.info(`Timeout injection configured for ${fault.target.selector}`);
+        logger.info(`Note: Actual timeout injection requires network proxy configuration`);
         return ok(1);
     }
     async injectPacketLoss(fault) {
         const lossPercent = fault.parameters.packetLossPercent ?? 10;
-        console.log(`Packet loss configured: ${lossPercent}% for ${fault.target.selector}`);
-        console.log(`Note: Actual packet loss requires tc/iptables (Linux) or similar`);
+        logger.info(`Packet loss configured: ${lossPercent}% for ${fault.target.selector}`);
+        logger.info(`Note: Actual packet loss requires tc/iptables (Linux) or similar`);
         return ok(1);
     }
     async injectCpuStress(fault) {
@@ -644,7 +646,7 @@ Provide:
         const cpuPercent = fault.parameters.cpuPercent ?? 80;
         const cores = fault.parameters.cores ?? 1;
         const duration = fault.duration;
-        console.log(`Injecting CPU stress: ${cpuPercent}% on ${cores} core(s) for ${duration}ms`);
+        logger.info(`Injecting CPU stress: ${cpuPercent}% on ${cores} core(s) for ${duration}ms`);
         // Create CPU-intensive work
         const startTime = Date.now();
         const workInterval = setInterval(() => {
@@ -669,7 +671,7 @@ Provide:
         // Real memory stress implementation by allocating buffers
         const memoryBytes = fault.parameters.memoryBytes ?? 1024 * 1024 * 100; // 100MB default
         const memoryMB = Math.round(memoryBytes / (1024 * 1024));
-        console.log(`Injecting memory stress: ${memoryMB}MB allocation`);
+        logger.info(`Injecting memory stress: ${memoryMB}MB allocation`);
         try {
             // Allocate memory in chunks to avoid single large allocation issues
             const chunkSize = 1024 * 1024; // 1MB chunks
@@ -683,7 +685,7 @@ Provide:
             }
             // Store reference to prevent garbage collection
             this.stressWorkers.set(fault.id, allocatedMemory);
-            console.log(`Memory stress active: ${allocatedMemory.length} chunks allocated`);
+            logger.info(`Memory stress active: ${allocatedMemory.length} chunks allocated`);
             return ok(1);
         }
         catch (error) {
@@ -692,36 +694,36 @@ Provide:
     }
     async injectDiskStress(fault) {
         // Disk stress would require file system operations
-        console.log(`Disk stress configured for ${fault.target.selector}`);
-        console.log(`Note: Actual disk stress requires file system write permissions`);
+        logger.info(`Disk stress configured for ${fault.target.selector}`);
+        logger.info(`Note: Actual disk stress requires file system write permissions`);
         return ok(1);
     }
     async injectNetworkPartition(fault) {
         // Network partition typically requires iptables or similar
-        console.log(`Network partition configured for ${fault.target.selector}`);
-        console.log(`Note: Actual network partition requires iptables/firewall rules`);
+        logger.info(`Network partition configured for ${fault.target.selector}`);
+        logger.info(`Note: Actual network partition requires iptables/firewall rules`);
         return ok(1);
     }
     async injectDnsFailure(fault) {
         // DNS failure injection via /etc/hosts or DNS server configuration
-        console.log(`DNS failure configured for ${fault.target.selector}`);
-        console.log(`Note: Actual DNS failure requires DNS server or /etc/hosts modification`);
+        logger.info(`DNS failure configured for ${fault.target.selector}`);
+        logger.info(`Note: Actual DNS failure requires DNS server or /etc/hosts modification`);
         return ok(1);
     }
     async injectProcessKill(fault) {
         // Process kill via system commands
         const processPattern = fault.target.selector;
-        console.log(`Process kill configured for pattern: ${processPattern}`);
-        console.log(`Note: Actual process kill requires appropriate permissions`);
+        logger.info(`Process kill configured for pattern: ${processPattern}`);
+        logger.info(`Note: Actual process kill requires appropriate permissions`);
         // In dry-run mode or without permissions, just log
         if (this.config.enableDryRun) {
-            console.log(`[DRY RUN] Would kill processes matching: ${processPattern}`);
+            logger.info(`Would kill processes matching: ${processPattern}`);
             return ok(0);
         }
         return ok(1);
     }
     async performFaultRemoval(fault) {
-        console.log(`Removing fault: ${fault.id} (${fault.type})`);
+        logger.info(`Removing fault: ${fault.id} (${fault.type})`);
         // Clean up any active stress workers
         const worker = this.stressWorkers.get(fault.id);
         if (worker) {
@@ -830,12 +832,12 @@ Provide:
     async rollbackExperiment(experiment) {
         // Execute rollback steps in order
         for (const step of experiment.rollbackPlan.steps.sort((a, b) => a.order - b.order)) {
-            console.log(`Executing rollback step ${step.order}: ${step.action}`);
+            logger.info(`Executing rollback step ${step.order}: ${step.action}`);
             try {
                 await this.executeRollbackAction(step.action, step.target, step.timeout);
             }
             catch (error) {
-                console.error(`Rollback step ${step.order} failed: ${toErrorMessage(error)}`);
+                logger.error(`Rollback step ${step.order} failed: ${toErrorMessage(error)}`);
                 // Continue with other rollback steps even if one fails
             }
         }
@@ -912,20 +914,20 @@ Provide:
         if (actionLower.includes('remove') || actionLower.includes('clear')) {
             // Clear any remaining state
             if (target) {
-                console.log(`Clearing state for target: ${target}`);
+                logger.info(`Clearing state for target: ${target}`);
             }
         }
         else if (actionLower.includes('restart')) {
             // Restart service (log only - actual restart would require orchestration)
-            console.log(`Restart requested for: ${target || 'service'}`);
+            logger.info(`Restart requested for: ${target || 'service'}`);
         }
         else if (actionLower.includes('restore')) {
             // Restore to previous state
-            console.log(`Restore requested for: ${target || 'system'}`);
+            logger.info(`Restore requested for: ${target || 'system'}`);
         }
         else {
             // Log-only for description actions
-            console.log(`Rollback action logged: ${action}`);
+            logger.info(`Rollback action logged: ${action}`);
         }
         // Brief pause between actions
         await this.sleep(100);

package/dist/domains/chaos-resilience/services/performance-profiler.d.ts

@@ -20,10 +20,6 @@ export interface PerformanceProfilerConfig {
      */
     simulateRandomFailures: boolean;
 }
-/**
- * Performance Profiler Service Implementation
- * Tests system resilience, recovery, failover, circuit breakers, and rate limiting
- */
 export declare class PerformanceProfilerService implements IResilienceTestingService {
     private readonly memory;
     private readonly config;