claude-flow-novice 2.18.5 → 2.18.7

package/.claude/skills/cfn-transparency-middleware/invoke-transparency-stop.sh

@@ -0,0 +1,235 @@
+#!/usr/bin/env bash
+##
+## Transparency Middleware - Shutdown Script
+## Gracefully stop transparency middleware, flush queues, and cleanup resources
+##
+## Usage:
+##   ./invoke-transparency-stop.sh [OPTIONS]
+##
+## Options:
+##   --task-id <id>           Task ID for scoped shutdown
+##   --flush                  Flush message queue before shutdown
+##   --preserve-metrics       Preserve metrics data (don't delete)
+##   --preserve-config        Preserve configuration (don't delete)
+##   --force                  Force shutdown without confirmation
+##   --format <json|text>     Output format (default: text)
+##   --help                   Show this help message
+##
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+# Default configuration
+TASK_ID=""
+FLUSH="no"
+PRESERVE_METRICS="no"
+PRESERVE_CONFIG="no"
+FORCE="no"
+FORMAT="text"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-id)
+      TASK_ID="$2"
+      shift 2
+      ;;
+    --flush)
+      FLUSH="yes"
+      shift
+      ;;
+    --preserve-metrics)
+      PRESERVE_METRICS="yes"
+      shift
+      ;;
+    --preserve-config)
+      PRESERVE_CONFIG="yes"
+      shift
+      ;;
+    --force)
+      FORCE="yes"
+      shift
+      ;;
+    --format)
+      FORMAT="$2"
+      shift 2
+      ;;
+    --help)
+      grep "^##" "$0" | sed 's/^## \?//'
+      exit 0
+      ;;
+    *)
+      echo "Error: Unknown option: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+# Determine Redis keys
+SCOPE="${TASK_ID:-global}"
+CONFIG_KEY="transparency:config:${SCOPE}"
+STATE_KEY="transparency:state:${SCOPE}"
+METRICS_KEY="transparency:metrics:${SCOPE}"
+FILTERS_KEY="transparency:filters:${SCOPE}"
+MESSAGES_LIST="transparency:messages:list:${SCOPE}"
+MESSAGES_CHANNEL="transparency:messages:${SCOPE}"
+
+# Get current state
+STATE_JSON=$(redis-cli GET "$STATE_KEY" 2>/dev/null || echo "{}")
+MESSAGE_COUNT=$(echo "$STATE_JSON" | jq -r '.messageCount // 0')
+
+# Confirmation prompt (unless forced)
+if [[ "$FORCE" != "yes" && "$FORMAT" == "text" ]]; then
+  echo "Transparency Middleware Shutdown"
+  echo "================================="
+  echo "Scope: $SCOPE"
+  echo "Message Count: $MESSAGE_COUNT"
+  echo ""
+  echo "This will:"
+  echo "  - Stop message generation"
+  echo "  - Unsubscribe from Redis channels"
+  [[ "$FLUSH" == "yes" ]] && echo "  - Flush message queue"
+  [[ "$PRESERVE_METRICS" != "yes" ]] && echo "  - Delete metrics data"
+  [[ "$PRESERVE_CONFIG" != "yes" ]] && echo "  - Delete configuration"
+  echo ""
+  read -p "Continue? (y/N) " -n 1 -r
+  echo ""
+  if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo "Shutdown cancelled"
+    exit 0
+  fi
+fi
+
+# Track shutdown steps
+declare -A STEPS_COMPLETED
+SHUTDOWN_START=$(date +%s)
+
+# Step 1: Flush message queue
+if [[ "$FLUSH" == "yes" ]]; then
+  QUEUE_SIZE=$(redis-cli LLEN "$MESSAGES_LIST" 2>/dev/null || echo "0")
+
+  if [[ $QUEUE_SIZE -gt 0 ]]; then
+    # Get all messages before flushing
+    FLUSHED_MESSAGES=$(redis-cli LRANGE "$MESSAGES_LIST" 0 -1)
+
+    # Optionally save to file
+    FLUSH_FILE="/tmp/transparency-flush-${SCOPE}-$(date +%s).jsonl"
+    echo "$FLUSHED_MESSAGES" > "$FLUSH_FILE"
+
+    [[ "$FORMAT" == "text" ]] && echo "Flushed $QUEUE_SIZE messages to: $FLUSH_FILE"
+  fi
+
+  STEPS_COMPLETED["flush"]="true"
+else
+  STEPS_COMPLETED["flush"]="skipped"
+fi
+
+# Step 2: Update state to stopping
+STOPPING_STATE=$(cat <<EOF
+{
+  "initialized": false,
+  "status": "stopped",
+  "stoppedAt": $(date +%s),
+  "messageCount": $MESSAGE_COUNT,
+  "shutdownReason": "manual"
+}
+EOF
+)
+redis-cli SET "$STATE_KEY" "$STOPPING_STATE" > /dev/null
+STEPS_COMPLETED["state_update"]="true"
+
+# Step 3: Publish shutdown event
+SHUTDOWN_EVENT=$(cat <<EOF
+{
+  "event": "transparency_stopped",
+  "timestamp": $(date +%s),
+  "scope": "$SCOPE",
+  "messageCount": $MESSAGE_COUNT,
+  "preserveMetrics": $([ "$PRESERVE_METRICS" == "yes" ] && echo "true" || echo "false"),
+  "preserveConfig": $([ "$PRESERVE_CONFIG" == "yes" ] && echo "true" || echo "false")
+}
+EOF
+)
+redis-cli PUBLISH "transparency:events" "$SHUTDOWN_EVENT" > /dev/null
+STEPS_COMPLETED["event_publish"]="true"
+
+# Step 4: Clear message queue
+redis-cli DEL "$MESSAGES_LIST" > /dev/null
+STEPS_COMPLETED["queue_clear"]="true"
+
+# Step 5: Remove filters
+FILTER_COUNT=$(redis-cli HLEN "$FILTERS_KEY" 2>/dev/null || echo "0")
+redis-cli DEL "$FILTERS_KEY" > /dev/null
+STEPS_COMPLETED["filters_clear"]="true"
+
+# Step 6: Delete metrics (unless preserved)
+if [[ "$PRESERVE_METRICS" != "yes" ]]; then
+  redis-cli DEL "$METRICS_KEY" > /dev/null
+  STEPS_COMPLETED["metrics_delete"]="true"
+else
+  STEPS_COMPLETED["metrics_delete"]="preserved"
+fi
+
+# Step 7: Delete config (unless preserved)
+if [[ "$PRESERVE_CONFIG" != "yes" ]]; then
+  redis-cli DEL "$CONFIG_KEY" > /dev/null
+  STEPS_COMPLETED["config_delete"]="true"
+else
+  STEPS_COMPLETED["config_delete"]="preserved"
+fi
+
+# Step 8: Delete state
+redis-cli DEL "$STATE_KEY" > /dev/null
+STEPS_COMPLETED["state_delete"]="true"
+
+# Calculate shutdown duration
+SHUTDOWN_END=$(date +%s)
+SHUTDOWN_DURATION=$((SHUTDOWN_END - SHUTDOWN_START))
+
+# Build summary
+if [[ "$FORMAT" == "json" ]]; then
+  cat <<EOF
+{
+  "success": true,
+  "scope": "$SCOPE",
+  "messageCount": $MESSAGE_COUNT,
+  "filterCount": $FILTER_COUNT,
+  "shutdownDuration": $SHUTDOWN_DURATION,
+  "steps": {
+    "flush": "${STEPS_COMPLETED[flush]}",
+    "stateUpdate": "${STEPS_COMPLETED[state_update]}",
+    "eventPublish": "${STEPS_COMPLETED[event_publish]}",
+    "queueClear": "${STEPS_COMPLETED[queue_clear]}",
+    "filtersClear": "${STEPS_COMPLETED[filters_clear]}",
+    "metricsDelete": "${STEPS_COMPLETED[metrics_delete]}",
+    "configDelete": "${STEPS_COMPLETED[config_delete]}",
+    "stateDelete": "${STEPS_COMPLETED[state_delete]}"
+  },
+  "timestamp": $SHUTDOWN_END
+}
+EOF
+else
+  echo ""
+  echo "Shutdown Complete"
+  echo "================="
+  echo "Scope: $SCOPE"
+  echo "Duration: ${SHUTDOWN_DURATION}s"
+  echo ""
+  echo "Summary:"
+  echo "  Messages Processed: $MESSAGE_COUNT"
+  echo "  Filters Removed: $FILTER_COUNT"
+  echo "  Message Queue: Cleared"
+  echo "  Metrics: $([ "$PRESERVE_METRICS" == "yes" ] && echo "Preserved" || echo "Deleted")"
+  echo "  Config: $([ "$PRESERVE_CONFIG" == "yes" ] && echo "Preserved" || echo "Deleted")"
+  echo ""
+  echo "Transparency middleware has been stopped successfully."
+
+  if [[ "$FLUSH" == "yes" && -f "$FLUSH_FILE" ]]; then
+    echo ""
+    echo "Flushed messages saved to: $FLUSH_FILE"
+  fi
+fi
+
+exit 0

package/.claude/skills/cfn-transparency-middleware/src/agent_metrics.rs

@@ -0,0 +1,480 @@
+use std::collections::HashMap;
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct AgentData {
+    total_time: u64,
+    count: u64,
+}
+
+impl AgentData {
+    fn new() -> Self {
+        Self {
+            total_time: 0,
+            count: 0,
+        }
+    }
+
+    fn add_execution_time(&mut self, time: u64) {
+        self.total_time = self.total_time.saturating_add(time);
+        self.count = self.count.saturating_add(1);
+    }
+
+    fn average_time(&self) -> Option<f64> {
+        if self.count == 0 {
+            None
+        } else {
+            Some(self.total_time as f64 / self.count as f64)
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AgentMetrics {
+    agents: HashMap<String, AgentData>,
+}
+
+impl AgentMetrics {
+    pub fn new() -> Self {
+        Self {
+            agents: HashMap::new(),
+        }
+    }
+
+    pub fn add_execution_time(&mut self, agent_name: &str, time: u64) -> Result<()> {
+        let data = self.agents.entry(agent_name.to_string()).or_insert_with(AgentData::new);
+        data.add_execution_time(time);
+        Ok(())
+    }
+
+    pub fn get_average_time(&self, agent_name: &str) -> Result<Option<f64>> {
+        Ok(self.agents.get(agent_name).and_then(|data| data.average_time()))
+    }
+
+    pub fn get_total_executions(&self, agent_name: &str) -> Result<u64> {
+        Ok(self.agents.get(agent_name).map(|data| data.count).unwrap_or(0))
+    }
+
+    pub fn get_top_performers(&self, limit: usize) -> Result<Vec<(String, f64, u64)>> {
+        let mut performers: Vec<(String, f64, u64)> = self
+            .agents
+            .iter()
+            .filter_map(|(name, data)| {
+                data.average_time().map(|avg| (name.clone(), avg, data.count))
+            })
+            .collect();
+
+        performers.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));
+
+        performers.truncate(limit);
+        Ok(performers)
+    }
+
+    pub fn calculate_performance_percentile(&self, agent_name: &str) -> Result<Option<f64>> {
+        let agent_data = match self.agents.get(agent_name) {
+            Some(data) => data,
+            None => return Ok(None),
+        };
+        
+        let agent_avg = match agent_data.average_time() {
+            Some(avg) => avg,
+            None => return Ok(None),
+        };
+
+        let mut averages: Vec<f64> = self
+            .agents
+            .values()
+            .filter_map(|data| data.average_time())
+            .collect();
+
+        if averages.is_empty() {
+            return Ok(None);
+        }
+
+        averages.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
+
+        let total_agents = averages.len() as f64;
+        let better_agents = averages
+            .iter()
+            .filter(|&&avg| avg < agent_avg)
+            .count() as f64;
+
+        let percentile = if better_agents == 0.0 && agent_avg == averages[0] {
+            100.0
+        } else if better_agents == total_agents - 1.0 && agent_avg == averages[averages.len() - 1] {
+            0.0
+        } else {
+            ((total_agents - better_agents - 1.0) / total_agents) * 100.0
+        };
+
+        Ok(Some(percentile))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anyhow::Result;
+
+    #[test]
+    fn test_new_creates_empty_metrics() {
+        let metrics = AgentMetrics::new();
+        assert!(metrics.get_average_time("agent1").unwrap().is_none());
+        assert_eq!(metrics.get_total_executions("agent1").unwrap(), 0);
+    }
+
+    #[test]
+    fn test_add_execution_time_single_agent() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        metrics.add_execution_time("agent1", 100)?;
+        metrics.add_execution_time("agent1", 200)?;
+        metrics.add_execution_time("agent1", 300)?;
+        
+        assert_eq!(metrics.get_total_executions("agent1")?, 3);
+        assert_eq!(metrics.get_average_time("agent1")?, Some(200.0));
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_add_execution_time_multiple_agents() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        metrics.add_execution_time("agent1", 100)?;
+        metrics.add_execution_time("agent1", 200)?;
+        metrics.add_execution_time("agent2", 50)?;
+        metrics.add_execution_time("agent2", 150)?;
+        
+        assert_eq!(metrics.get_total_executions("agent1")?, 2);
+        assert_eq!(metrics.get_total_executions("agent2")?, 2);
+        assert_eq!(metrics.get_average_time("agent1")?, Some(150.0));
+        assert_eq!(metrics.get_average_time("agent2")?, Some(100.0));
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_get_average_time_unknown_agent() -> Result<()> {
+        let metrics = AgentMetrics::new();
+        assert!(metrics.get_average_time("unknown").unwrap().is_none());
+        Ok(())
+    }
+
+    #[test]
+    fn test_get_total_executions_unknown_agent() -> Result<()> {
+        let metrics = AgentMetrics::new();
+        assert_eq!(metrics.get_total_executions("unknown")?, 0);
+        Ok(())
+    }
+
+    #[test]
+    fn test_get_top_performers_empty() -> Result<()> {
+        let metrics = AgentMetrics::new();
+        let top = metrics.get_top_performers(5)?;
+        assert!(top.is_empty());
+        Ok(())
+    }
+
+    #[test]
+    fn test_get_top_performers_single_agent() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        metrics.add_execution_time("agent1", 100)?;
+        metrics.add_execution_time("agent1", 200)?;
+        
+        let top = metrics.get_top_performers(5)?;
+        assert_eq!(top.len(), 1);
+        assert_eq!(top[0], ("agent1".to_string(), 150.0, 2));
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_get_top_performers_multiple_agents() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        metrics.add_execution_time("fast", 50)?;
+        metrics.add_execution_time("fast", 70)?;
+        metrics.add_execution_time("medium", 100)?;
+        metrics.add_execution_time("medium", 120)?;
+        metrics.add_execution_time("slow", 200)?;
+        metrics.add_execution_time("slow", 220)?;
+        
+        let top = metrics.get_top_performers(3)?;
+        assert_eq!(top.len(), 3);
+        assert_eq!(top[0], ("fast".to_string(), 60.0, 2));
+        assert_eq!(top[1], ("medium".to_string(), 110.0, 2));
+        assert_eq!(top[2], ("slow".to_string(), 210.0, 2));
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_get_top_performers_limit() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        for i in 0..10 {
+            let name = format!("agent{}", i);
+            metrics.add_execution_time(&name, (i + 1) * 100)?;
+            metrics.add_execution_time(&name, (i + 1) * 100 + 50)?;
+        }
+        
+        let top = metrics.get_top_performers(3)?;
+        assert_eq!(top.len(), 3);
+        assert_eq!(top[0].0, "agent0");
+        assert_eq!(top[1].0, "agent1");
+        assert_eq!(top[2].0, "agent2");
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_get_top_performers_ties() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        metrics.add_execution_time("agent1", 100)?;
+        metrics.add_execution_time("agent1", 200)?;
+        metrics.add_execution_time("agent2", 100)?;
+        metrics.add_execution_time("agent2", 200)?;
+        metrics.add_execution_time("agent3", 300)?;
+        metrics.add_execution_time("agent3", 400)?;
+        
+        let top = metrics.get_top_performers(5)?;
+        assert_eq!(top.len(), 3);
+        
+        let avg1 = top[0].1;
+        let avg2 = top[1].1;
+        let avg3 = top[2].1;
+        
+        assert!(avg1 <= avg2);
+        assert!(avg2 <= avg3);
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_calculate_performance_percentile_empty() -> Result<()> {
+        let metrics = AgentMetrics::new();
+        assert!(metrics.calculate_performance_percentile("agent1").unwrap().is_none());
+        Ok(())
+    }
+
+    #[test]
+    fn test_calculate_performance_percentile_unknown_agent() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        metrics.add_execution_time("agent1", 100)?;
+        assert!(metrics.calculate_performance_percentile("unknown").unwrap().is_none());
+        Ok(())
+    }
+
+    #[test]
+    fn test_calculate_performance_percentile_single_agent() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        metrics.add_execution_time("agent1", 100)?;
+        
+        let percentile = metrics.calculate_performance_percentile("agent1")?;
+        assert_eq!(percentile, Some(100.0));
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_calculate_performance_percentile_fastest() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        metrics.add_execution_time("fast", 50)?;
+        metrics.add_execution_time("fast", 60)?;
+        metrics.add_execution_time("medium", 100)?;
+        metrics.add_execution_time("medium", 110)?;
+        metrics.add_execution_time("slow", 200)?;
+        metrics.add_execution_time("slow", 210)?;
+        
+        let percentile = metrics.calculate_performance_percentile("fast")?;
+        assert_eq!(percentile, Some(100.0));
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_calculate_performance_percentile_slowest() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        metrics.add_execution_time("fast", 50)?;
+        metrics.add_execution_time("fast", 60)?;
+        metrics.add_execution_time("medium", 100)?;
+        metrics.add_execution_time("medium", 110)?;
+        metrics.add_execution_time("slow", 200)?;
+        metrics.add_execution_time("slow", 210)?;
+        
+        let percentile = metrics.calculate_performance_percentile("slow")?;
+        assert_eq!(percentile, Some(0.0));
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_calculate_performance_percentile_middle() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        metrics.add_execution_time("fast", 50)?;
+        metrics.add_execution_time("fast", 60)?;
+        metrics.add_execution_time("medium", 100)?;
+        metrics.add_execution_time("medium", 110)?;
+        metrics.add_execution_time("slow", 200)?;
+        metrics.add_execution_time("slow", 210)?;
+        
+        let percentile = metrics.calculate_performance_percentile("medium")?;
+        assert_eq!(percentile, Some(50.0));
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_calculate_performance_percentile_multiple_middle() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        metrics.add_execution_time("agent1", 50)?;
+        metrics.add_execution_time("agent2", 60)?;
+        metrics.add_execution_time("agent3", 70)?;
+        metrics.add_execution_time("agent4", 80)?;
+        metrics.add_execution_time("agent5", 90)?;
+        
+        let percentile = metrics.calculate_performance_percentile("agent3")?;
+        assert_eq!(percentile, Some(50.0));
+        
+        let percentile = metrics.calculate_performance_percentile("agent2")?;
+        assert_eq!(percentile, Some(75.0));
+        
+        let percentile = metrics.calculate_performance_percentile("agent4")?;
+        assert_eq!(percentile, Some(25.0));
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_calculate_performance_percentile_with_ties() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        metrics.add_execution_time("agent1", 100)?;
+        metrics.add_execution_time("agent2", 100)?;
+        metrics.add_execution_time("agent3", 200)?;
+        
+        let percentile1 = metrics.calculate_performance_percentile("agent1")?;
+        let percentile2 = metrics.calculate_performance_percentile("agent2")?;
+        let percentile3 = metrics.calculate_performance_percentile("agent3")?;
+        
+        assert_eq!(percentile1, Some(100.0));
+        assert_eq!(percentile2, Some(100.0));
+        assert_eq!(percentile3, Some(0.0));
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_large_dataset_performance() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        for i in 0..1000 {
+            let name = format!("agent{}", i % 10);
+            metrics.add_execution_time(&name, (i % 100) as u64 * 10)?;
+        }
+        
+        let top = metrics.get_top_performers(5)?;
+        assert_eq!(top.len(), 5);
+        
+        for (agent_name, _, count) in top {
+            assert_eq!(count, 100);
+            assert!(agent_name.starts_with("agent"));
+        }
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_zero_duration_handling() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        metrics.add_execution_time("agent1", 0)?;
+        metrics.add_execution_time("agent1", 100)?;
+        
+        assert_eq!(metrics.get_total_executions("agent1")?, 2);
+        assert_eq!(metrics.get_average_time("agent1")?, Some(50.0));
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_maximum_duration_handling() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        metrics.add_execution_time("agent1", u64::MAX)?;
+        metrics.add_execution_time("agent1", 0)?;
+        
+        assert_eq!(metrics.get_total_executions("agent1")?, 2);
+        let avg = metrics.get_average_time("agent1")?.unwrap();
+        assert!(avg > 0.0);
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_agent_name_edge_cases() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        metrics.add_execution_time("", 100)?;
+        metrics.add_execution_time(" ", 200)?;
+        metrics.add_execution_time("agent with spaces", 300)?;
+        metrics.add_execution_time("agent-with-dashes", 400)?;
+        metrics.add_execution_time("agent_with_underscores", 500)?;
+        
+        assert_eq!(metrics.get_total_executions("")?, 1);
+        assert_eq!(metrics.get_total_executions(" ")?, 1);
+        assert_eq!(metrics.get_total_executions("agent with spaces")?, 1);
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_concurrent_additions_simulation() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        for i in 0..100 {
+            metrics.add_execution_time("agent1", i)?;
+            metrics.add_execution_time("agent2", i * 2)?;
+            metrics.add_execution_time("agent3", i * 3)?;
+        }
+        
+        assert_eq!(metrics.get_total_executions("agent1")?, 100);
+        assert_eq!(metrics.get_total_executions("agent2")?, 100);
+        assert_eq!(metrics.get_total_executions("agent3")?, 100);
+        
+        let avg1 = metrics.get_average_time("agent1")?.unwrap();
+        let avg2 = metrics.get_average_time("agent2")?.unwrap();
+        let avg3 = metrics.get_average_time("agent3")?.unwrap();
+        
+        assert!(avg1 < avg2);
+        assert!(avg2 < avg3);
+        
+        Ok(())
+    }
+
+    #[test]
+    fn test_percentile_calculation_precision() -> Result<()> {
+        let mut metrics = AgentMetrics::new();
+        
+        for i in 1..=100 {
+            metrics.add_execution_time(&format!("agent{}", i), i)?;
+        }
+        
+        let percentile_1 = metrics.calculate_performance_percentile("agent1")?;
+        let percentile_50 = metrics.calculate_performance_percentile("agent50")?;
+        let percentile_100 = metrics.calculate_performance_percentile("agent100")?;
+        
+        assert_eq!(percentile_1, Some(100.0));
+        assert_eq!(percentile_100, Some(0.0));
+        assert!(percentile_50.unwrap() > 45.0 && percentile_50.unwrap() < 55.0);
+        
+        Ok(())
+    }
+}