empathy-framework 4.6.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

empathy_os/workflows/progressive/orchestrator.py

@@ -11,11 +11,7 @@ The MetaOrchestrator is responsible for:
 import logging
 from typing import Any
 
-from empathy_os.workflows.progressive.core import (
-    EscalationConfig,
-    Tier,
-    TierResult,
-)
+from empathy_os.workflows.progressive.core import EscalationConfig, Tier, TierResult
 
 logger = logging.getLogger(__name__)
 
@@ -50,15 +46,11 @@ class MetaOrchestrator:
         self.tier_history: dict[Tier, list[float]] = {
             Tier.CHEAP: [],
             Tier.CAPABLE: [],
-            Tier.PREMIUM: []
+            Tier.PREMIUM: [],
         }
 
     def should_escalate(
-        self,
-        tier: Tier,
-        result: TierResult,
-        attempt: int,
-        config: EscalationConfig
+        self, tier: Tier, result: TierResult, attempt: int, config: EscalationConfig
     ) -> tuple[bool, str]:
         """Determine if tier should escalate to next tier.
 
@@ -104,9 +96,7 @@ class MetaOrchestrator:
             return False, "Premium tier is final"
 
     def _check_cheap_escalation(
-        self,
-        result: TierResult,
-        config: EscalationConfig
+        self, result: TierResult, config: EscalationConfig
     ) -> tuple[bool, str]:
         """Check if cheap tier should escalate to capable.
 
@@ -127,24 +117,30 @@ class MetaOrchestrator:
 
         # Check syntax errors (prioritize over CQS)
         if syntax_error_count > config.cheap_to_capable_max_syntax_errors:
-            return True, f"{syntax_error_count} syntax errors exceeds limit {config.cheap_to_capable_max_syntax_errors}"
+            return (
+                True,
+                f"{syntax_error_count} syntax errors exceeds limit {config.cheap_to_capable_max_syntax_errors}",
+            )
 
         # Check failure rate
         if failure_rate > config.cheap_to_capable_failure_rate:
-            return True, f"Failure rate {failure_rate:.1%} exceeds threshold {config.cheap_to_capable_failure_rate:.1%}"
+            return (
+                True,
+                f"Failure rate {failure_rate:.1%} exceeds threshold {config.cheap_to_capable_failure_rate:.1%}",
+            )
 
         # Check CQS threshold
         if cqs < config.cheap_to_capable_min_cqs:
-            return True, f"Quality score {cqs:.1f} below threshold {config.cheap_to_capable_min_cqs}"
+            return (
+                True,
+                f"Quality score {cqs:.1f} below threshold {config.cheap_to_capable_min_cqs}",
+            )
 
         # All checks passed, no escalation needed
         return False, f"Quality acceptable (CQS={cqs:.1f})"
 
     def _check_capable_escalation(
-        self,
-        result: TierResult,
-        attempt: int,
-        config: EscalationConfig
+        self, result: TierResult, attempt: int, config: EscalationConfig
     ) -> tuple[bool, str]:
         """Check if capable tier should escalate to premium.
 
@@ -165,15 +161,24 @@ class MetaOrchestrator:
 
         # Check max attempts first
         if attempt >= config.capable_max_attempts:
-            return True, f"Max attempts ({config.capable_max_attempts}) reached without achieving target quality"
+            return (
+                True,
+                f"Max attempts ({config.capable_max_attempts}) reached without achieving target quality",
+            )
 
         # Check syntax errors (strict for capable tier)
         if syntax_error_count > config.capable_to_premium_max_syntax_errors:
-            return True, f"{syntax_error_count} syntax errors exceeds limit {config.capable_to_premium_max_syntax_errors}"
+            return (
+                True,
+                f"{syntax_error_count} syntax errors exceeds limit {config.capable_to_premium_max_syntax_errors}",
+            )
 
         # Check failure rate
         if failure_rate > config.capable_to_premium_failure_rate:
-            return True, f"Failure rate {failure_rate:.1%} exceeds threshold {config.capable_to_premium_failure_rate:.1%}"
+            return (
+                True,
+                f"Failure rate {failure_rate:.1%} exceeds threshold {config.capable_to_premium_failure_rate:.1%}",
+            )
 
         # Check stagnation (consecutive runs with <5% improvement)
         # Only check if we have enough history
@@ -181,7 +186,7 @@ class MetaOrchestrator:
             is_stagnant, stagnation_reason = self._detect_stagnation(
                 self.tier_history[Tier.CAPABLE],
                 config.improvement_threshold,
-                config.consecutive_stagnation_limit
+                config.consecutive_stagnation_limit,
             )
 
             if is_stagnant:
@@ -189,16 +194,16 @@ class MetaOrchestrator:
 
         # Check CQS threshold (after stagnation check)
         if cqs < config.capable_to_premium_min_cqs and attempt >= config.capable_min_attempts:
-            return True, f"Quality score {cqs:.1f} below threshold {config.capable_to_premium_min_cqs}"
+            return (
+                True,
+                f"Quality score {cqs:.1f} below threshold {config.capable_to_premium_min_cqs}",
+            )
 
         # No escalation needed
         return False, f"Quality acceptable (CQS={cqs:.1f}), continuing improvement"
 
     def _detect_stagnation(
-        self,
-        cqs_history: list[float],
-        improvement_threshold: float,
-        consecutive_limit: int
+        self, cqs_history: list[float], improvement_threshold: float, consecutive_limit: int
     ) -> tuple[bool, str]:
         """Detect if improvement has stagnated.
 
@@ -246,10 +251,7 @@ class MetaOrchestrator:
         return False, "No stagnation detected"
 
     def build_tier_prompt(
-        self,
-        tier: Tier,
-        base_task: str,
-        failure_context: dict[str, Any] | None = None
+        self, tier: Tier, base_task: str, failure_context: dict[str, Any] | None = None
     ) -> str:
         """Build XML-enhanced prompt with failure context.
 
@@ -304,11 +306,7 @@ class MetaOrchestrator:
   </instructions>
 </task>"""
 
-    def _build_capable_prompt(
-        self,
-        base_task: str,
-        failure_context: dict[str, Any] | None
-    ) -> str:
+    def _build_capable_prompt(self, base_task: str, failure_context: dict[str, Any] | None) -> str:
         """Build enhanced prompt for capable tier with failure context.
 
         Args:
@@ -359,12 +357,14 @@ class MetaOrchestrator:
         # Add failure pattern analysis
         if failure_patterns:
             prompt_parts.append("    <failure_analysis>")
-            prompt_parts.append(f"      <total_failures>{failure_patterns.get('total_failures', 0)}</total_failures>")
+            prompt_parts.append(
+                f"      <total_failures>{failure_patterns.get('total_failures', 0)}</total_failures>"
+            )
             prompt_parts.append("      <patterns>")
 
             error_types = failure_patterns.get("error_types", {})
             for error_type, count in sorted(error_types.items(), key=lambda x: -x[1]):
-                prompt_parts.append(f"        <pattern type=\"{error_type}\" count=\"{count}\" />")
+                prompt_parts.append(f'        <pattern type="{error_type}" count="{count}" />')
 
             prompt_parts.append("      </patterns>")
 
@@ -382,68 +382,74 @@ class MetaOrchestrator:
                 error = example.get("error", "Unknown error")
                 code_snippet = example.get("code", "")[:200]  # Limit snippet length
 
-                prompt_parts.append(f"      <example number=\"{i}\">")
+                prompt_parts.append(f'      <example number="{i}">')
                 prompt_parts.append(f"        <error>{self._escape_xml(error)}</error>")
                 if code_snippet:
-                    prompt_parts.append(f"        <code_snippet>{self._escape_xml(code_snippet)}</code_snippet>")
+                    prompt_parts.append(
+                        f"        <code_snippet>{self._escape_xml(code_snippet)}</code_snippet>"
+                    )
                 prompt_parts.append("      </example>")
 
             prompt_parts.append("    </failed_attempts>")
             prompt_parts.append("")
 
-        prompt_parts.extend([
-            "    <improvement_needed>",
-            "      The cheap tier struggled with these items. Analyze the failure",
-            "      patterns above and generate improved solutions that specifically",
-            "      address these issues.",
-            "    </improvement_needed>",
-            "  </context_from_previous_tier>",
-            "",
-            "  <your_task>",
-            "    Generate improved output that avoids the specific failure patterns identified above.",
-            "",
-            "    <quality_requirements>",
-            "      <pass_rate>80%+</pass_rate>",
-            "      <coverage>70%+</coverage>",
-            "      <quality_score>80+</quality_score>",
-            "    </quality_requirements>",
-            "",
-            "    <focus_areas>",
-        ])
+        prompt_parts.extend(
+            [
+                "    <improvement_needed>",
+                "      The cheap tier struggled with these items. Analyze the failure",
+                "      patterns above and generate improved solutions that specifically",
+                "      address these issues.",
+                "    </improvement_needed>",
+                "  </context_from_previous_tier>",
+                "",
+                "  <your_task>",
+                "    Generate improved output that avoids the specific failure patterns identified above.",
+                "",
+                "    <quality_requirements>",
+                "      <pass_rate>80%+</pass_rate>",
+                "      <coverage>70%+</coverage>",
+                "      <quality_score>80+</quality_score>",
+                "    </quality_requirements>",
+                "",
+                "    <focus_areas>",
+            ]
+        )
 
         # Add targeted focus areas based on failure patterns
         if failure_patterns:
             error_types = failure_patterns.get("error_types", {})
             if "async_errors" in error_types:
-                prompt_parts.append("      <focus area=\"async\">Proper async/await patterns and error handling</focus>")
+                prompt_parts.append(
+                    '      <focus area="async">Proper async/await patterns and error handling</focus>'
+                )
             if "mocking_errors" in error_types:
-                prompt_parts.append("      <focus area=\"mocking\">Correct mock setup and teardown</focus>")
+                prompt_parts.append(
+                    '      <focus area="mocking">Correct mock setup and teardown</focus>'
+                )
             if "syntax_errors" in error_types:
-                prompt_parts.append("      <focus area=\"syntax\">Valid Python syntax and imports</focus>")
+                prompt_parts.append(
+                    '      <focus area="syntax">Valid Python syntax and imports</focus>'
+                )
             if "other_errors" in error_types:
-                prompt_parts.append("      <focus area=\"general\">Edge cases and error handling</focus>")
+                prompt_parts.append(
+                    '      <focus area="general">Edge cases and error handling</focus>'
+                )
         else:
             # Default focus areas
-            prompt_parts.extend([
-                "      <focus area=\"syntax\">Correct syntax and structure</focus>",
-                "      <focus area=\"coverage\">Comprehensive test coverage</focus>",
-                "      <focus area=\"errors\">Proper error handling</focus>",
-                "      <focus area=\"edge_cases\">Edge case coverage</focus>",
-            ])
-
-        prompt_parts.extend([
-            "    </focus_areas>",
-            "  </your_task>",
-            "</task>"
-        ])
+            prompt_parts.extend(
+                [
+                    '      <focus area="syntax">Correct syntax and structure</focus>',
+                    '      <focus area="coverage">Comprehensive test coverage</focus>',
+                    '      <focus area="errors">Proper error handling</focus>',
+                    '      <focus area="edge_cases">Edge case coverage</focus>',
+                ]
+            )
+
+        prompt_parts.extend(["    </focus_areas>", "  </your_task>", "</task>"])
 
         return "\n".join(prompt_parts)
 
-    def _build_premium_prompt(
-        self,
-        base_task: str,
-        failure_context: dict[str, Any] | None
-    ) -> str:
+    def _build_premium_prompt(self, base_task: str, failure_context: dict[str, Any] | None) -> str:
         """Build comprehensive prompt for premium tier.
 
         Args:
@@ -503,25 +509,35 @@ class MetaOrchestrator:
         # Add detailed failure analysis
         if failure_patterns:
             prompt_parts.append("    <persistent_issues>")
-            prompt_parts.append(f"      <total_failures>{failure_patterns.get('total_failures', 0)}</total_failures>")
+            prompt_parts.append(
+                f"      <total_failures>{failure_patterns.get('total_failures', 0)}</total_failures>"
+            )
             prompt_parts.append("      <failure_patterns>")
 
             error_types = failure_patterns.get("error_types", {})
             for error_type, count in sorted(error_types.items(), key=lambda x: -x[1]):
-                prompt_parts.append(f"        <pattern type=\"{error_type}\" count=\"{count}\">")
+                prompt_parts.append(f'        <pattern type="{error_type}" count="{count}">')
 
                 # Add specific guidance per error type
                 if error_type == "async_errors":
-                    prompt_parts.append("          <guidance>Use proper async/await patterns, handle timeouts correctly</guidance>")
+                    prompt_parts.append(
+                        "          <guidance>Use proper async/await patterns, handle timeouts correctly</guidance>"
+                    )
                 elif error_type == "mocking_errors":
-                    prompt_parts.append("          <guidance>Ensure mocks are properly configured and reset</guidance>")
+                    prompt_parts.append(
+                        "          <guidance>Ensure mocks are properly configured and reset</guidance>"
+                    )
                 elif error_type == "syntax_errors":
-                    prompt_parts.append("          <guidance>Double-check syntax, imports, and type annotations</guidance>")
+                    prompt_parts.append(
+                        "          <guidance>Double-check syntax, imports, and type annotations</guidance>"
+                    )
 
                 prompt_parts.append("        </pattern>")
 
             prompt_parts.append("      </failure_patterns>")
-            prompt_parts.append(f"      <primary_issue>{failure_patterns.get('primary_issue', 'unknown')}</primary_issue>")
+            prompt_parts.append(
+                f"      <primary_issue>{failure_patterns.get('primary_issue', 'unknown')}</primary_issue>"
+            )
             prompt_parts.append("    </persistent_issues>")
             prompt_parts.append("")
 
@@ -535,67 +551,77 @@ class MetaOrchestrator:
                 code_snippet = example.get("code", "")[:300]  # More context for premium
                 quality_score = example.get("quality_score", 0)
 
-                prompt_parts.append(f"      <attempt number=\"{i}\" quality_score=\"{quality_score}\">")
+                prompt_parts.append(f'      <attempt number="{i}" quality_score="{quality_score}">')
                 prompt_parts.append(f"        <error>{self._escape_xml(error)}</error>")
                 if code_snippet:
-                    prompt_parts.append(f"        <code_snippet>{self._escape_xml(code_snippet)}</code_snippet>")
+                    prompt_parts.append(
+                        f"        <code_snippet>{self._escape_xml(code_snippet)}</code_snippet>"
+                    )
                 prompt_parts.append("      </attempt>")
 
             prompt_parts.append("    </capable_tier_attempts>")
             prompt_parts.append("")
 
-        prompt_parts.extend([
-            "  </escalation_context>",
-            "",
-            "  <expert_task>",
-            "    <critical_notice>",
-            "      You are the FINAL tier in the progressive escalation system.",
-            "      Previous tiers (cheap and capable) have attempted this task",
-            "      multiple times and could not achieve the required quality.",
-            "",
-            "      This is the last automated attempt before human review.",
-            "      Excellence is not optional - it is required.",
-            "    </critical_notice>",
-            "",
-            "    <expert_techniques>",
-            "      Apply sophisticated approaches:",
-            "      - Deep analysis of why previous attempts failed",
-            "      - Production-grade error handling and edge cases",
-            "      - Comprehensive documentation and clarity",
-            "      - Defensive programming against subtle bugs",
-        ])
+        prompt_parts.extend(
+            [
+                "  </escalation_context>",
+                "",
+                "  <expert_task>",
+                "    <critical_notice>",
+                "      You are the FINAL tier in the progressive escalation system.",
+                "      Previous tiers (cheap and capable) have attempted this task",
+                "      multiple times and could not achieve the required quality.",
+                "",
+                "      This is the last automated attempt before human review.",
+                "      Excellence is not optional - it is required.",
+                "    </critical_notice>",
+                "",
+                "    <expert_techniques>",
+                "      Apply sophisticated approaches:",
+                "      - Deep analysis of why previous attempts failed",
+                "      - Production-grade error handling and edge cases",
+                "      - Comprehensive documentation and clarity",
+                "      - Defensive programming against subtle bugs",
+            ]
+        )
 
         # Add specific techniques based on failure patterns
         if failure_patterns:
             error_types = failure_patterns.get("error_types", {})
             if "async_errors" in error_types:
-                prompt_parts.append("      - Advanced async patterns (asyncio.gather, proper timeouts)")
+                prompt_parts.append(
+                    "      - Advanced async patterns (asyncio.gather, proper timeouts)"
+                )
             if "mocking_errors" in error_types:
-                prompt_parts.append("      - Sophisticated mocking (pytest fixtures, proper lifecycle)")
+                prompt_parts.append(
+                    "      - Sophisticated mocking (pytest fixtures, proper lifecycle)"
+                )
             if "syntax_errors" in error_types:
                 prompt_parts.append("      - Rigorous syntax validation before submission")
 
-        prompt_parts.extend([
-            "    </expert_techniques>",
-            "",
-            "    <quality_requirements>",
-            "      <pass_rate>95%+</pass_rate>",
-            "      <coverage>85%+</coverage>",
-            "      <quality_score>95+</quality_score>",
-            "      <zero_syntax_errors>MANDATORY</zero_syntax_errors>",
-            "    </quality_requirements>",
-            "",
-            "    <success_criteria>",
-            "      Your implementation must:",
-            "      1. Address ALL failure patterns identified above",
-            "      2. Achieve exceptional quality scores (95+)",
-            "      3. Have zero syntax errors or runtime failures",
-            "      4. Include comprehensive edge case coverage",
-            "      5. Be production-ready with proper documentation",
-            "    </success_criteria>",
-            "  </expert_task>",
-            "</task>"
-        ])
+        prompt_parts.extend(
+            [
+                "    </expert_techniques>",
+                "",
+                "    <quality_requirements>",
+                "      <pass_rate>95%+</pass_rate>",
+                "      <coverage>85%+</coverage>",
+                "      <quality_score>95+</quality_score>",
+                "      <zero_syntax_errors>MANDATORY</zero_syntax_errors>",
+                "    </quality_requirements>",
+                "",
+                "    <success_criteria>",
+                "      Your implementation must:",
+                "      1. Address ALL failure patterns identified above",
+                "      2. Achieve exceptional quality scores (95+)",
+                "      3. Have zero syntax errors or runtime failures",
+                "      4. Include comprehensive edge case coverage",
+                "      5. Be production-ready with proper documentation",
+                "    </success_criteria>",
+                "  </expert_task>",
+                "</task>",
+            ]
+        )
 
         return "\n".join(prompt_parts)
 
@@ -613,8 +639,7 @@ class MetaOrchestrator:
             'Error: &lt;missing&gt;'
         """
         return (
-            text
-            .replace("&", "&amp;")
+            text.replace("&", "&amp;")
             .replace("<", "&lt;")
             .replace(">", "&gt;")
             .replace('"', "&quot;")
@@ -622,9 +647,7 @@ class MetaOrchestrator:
         )
 
     def create_agent_team(
-        self,
-        tier: Tier,
-        failure_context: dict[str, Any] | None = None
+        self, tier: Tier, failure_context: dict[str, Any] | None = None
     ) -> list[str]:
         """Create specialized agent team for tier.
 
@@ -658,10 +681,7 @@ class MetaOrchestrator:
         else:  # PREMIUM
             return ["generator", "analyzer", "reviewer"]
 
-    def analyze_failure_patterns(
-        self,
-        failures: list[dict[str, Any]]
-    ) -> dict[str, Any]:
+    def analyze_failure_patterns(self, failures: list[dict[str, Any]]) -> dict[str, Any]:
         """Analyze failure patterns to inform next tier.
 
         Groups failures by type and identifies common issues.
@@ -697,5 +717,7 @@ class MetaOrchestrator:
         return {
             "total_failures": len(failures),
             "error_types": error_types,
-            "primary_issue": max(error_types.items(), key=lambda x: x[1])[0] if error_types else "unknown"
+            "primary_issue": (
+                max(error_types.items(), key=lambda x: x[1])[0] if error_types else "unknown"
+            ),
         }

empathy_os/workflows/progressive/reports.py

@@ -13,10 +13,7 @@ from pathlib import Path
 from typing import Any
 
 from empathy_os.config import _validate_file_path
-from empathy_os.workflows.progressive.core import (
-    ProgressiveWorkflowResult,
-    Tier,
-)
+from empathy_os.workflows.progressive.core import ProgressiveWorkflowResult, Tier
 
 logger = logging.getLogger(__name__)
 
@@ -61,7 +58,9 @@ def generate_progression_report(result: ProgressiveWorkflowResult) -> str:
 
     # Cost savings
     if result.cost_savings > 0:
-        report.append(f"Cost Savings: ${result.cost_savings:.2f} ({result.cost_savings_percent:.0f}% vs all-Premium)")
+        report.append(
+            f"Cost Savings: ${result.cost_savings:.2f} ({result.cost_savings_percent:.0f}% vs all-Premium)"
+        )
         report.append("")
 
     report.append("TIER BREAKDOWN:")
@@ -69,11 +68,7 @@ def generate_progression_report(result: ProgressiveWorkflowResult) -> str:
 
     # Tier-by-tier breakdown
     for tier_result in result.tier_results:
-        tier_emoji = {
-            Tier.CHEAP: "💰",
-            Tier.CAPABLE: "📊",
-            Tier.PREMIUM: "💎"
-        }[tier_result.tier]
+        tier_emoji = {Tier.CHEAP: "💰", Tier.CAPABLE: "📊", Tier.PREMIUM: "💎"}[tier_result.tier]
 
         report.append(f"{tier_emoji} {tier_result.tier.value.upper()} Tier ({tier_result.model})")
         report.append(f"   • Items: {len(tier_result.generated_items)}")
@@ -147,14 +142,16 @@ def save_results_to_disk(result: ProgressiveWorkflowResult, storage_path: str) -
         summary = {
             "workflow": result.workflow_name,
             "task_id": result.task_id,
-            "timestamp": result.tier_results[0].timestamp.isoformat() if result.tier_results else None,
+            "timestamp": (
+                result.tier_results[0].timestamp.isoformat() if result.tier_results else None
+            ),
             "total_cost": result.total_cost,
             "total_duration": result.total_duration,
             "cost_savings": result.cost_savings,
             "cost_savings_percent": result.cost_savings_percent,
             "success": result.success,
             "tier_count": len(result.tier_results),
-            "final_cqs": result.final_result.quality_score if result.final_result else 0
+            "final_cqs": result.final_result.quality_score if result.final_result else 0,
         }
 
         summary_file = validated_dir / "summary.json"
@@ -179,9 +176,9 @@ def save_results_to_disk(result: ProgressiveWorkflowResult, storage_path: str) -
                     "test_pass_rate": tier_result.failure_analysis.test_pass_rate,
                     "coverage": tier_result.failure_analysis.coverage_percent,
                     "assertion_depth": tier_result.failure_analysis.assertion_depth,
-                    "confidence": tier_result.failure_analysis.confidence_score
+                    "confidence": tier_result.failure_analysis.confidence_score,
                 },
-                "item_count": len(tier_result.generated_items)
+                "item_count": len(tier_result.generated_items),
             }
 
             tier_file = validated_dir / f"tier_{i}_{tier_result.tier.value}.json"
@@ -222,7 +219,9 @@ def _format_duration(seconds: float) -> str:
     return f"{minutes}m {remaining_seconds}s"
 
 
-def load_result_from_disk(task_id: str, storage_path: str = ".empathy/progressive_runs") -> dict[str, Any]:
+def load_result_from_disk(
+    task_id: str, storage_path: str = ".empathy/progressive_runs"
+) -> dict[str, Any]:
     """Load saved result from disk.
 
     Args:
@@ -262,11 +261,7 @@ def load_result_from_disk(task_id: str, storage_path: str = ".empathy/progressiv
     report_file = task_dir / "report.txt"
     report = report_file.read_text() if report_file.exists() else ""
 
-    return {
-        "summary": summary,
-        "tier_results": tier_results,
-        "report": report
-    }
+    return {"summary": summary, "tier_results": tier_results, "report": report}
 
 
 def list_saved_results(storage_path: str = ".empathy/progressive_runs") -> list[dict[str, Any]]:
@@ -311,9 +306,7 @@ def list_saved_results(storage_path: str = ".empathy/progressive_runs") -> list[
 
 
 def cleanup_old_results(
-    storage_path: str = ".empathy/progressive_runs",
-    retention_days: int = 30,
-    dry_run: bool = False
+    storage_path: str = ".empathy/progressive_runs", retention_days: int = 30, dry_run: bool = False
 ) -> tuple[int, int]:
     """Clean up old progressive workflow results.
 
@@ -363,6 +356,7 @@ def cleanup_old_results(
                 # Old result, delete it
                 if not dry_run:
                     import shutil
+
                     shutil.rmtree(task_dir)
                     logger.info(f"Deleted old result: {task_dir.name}")
                 else:
@@ -378,9 +372,7 @@ def cleanup_old_results(
     return (deleted_count, retained_count)
 
 
-def generate_cost_analytics(
-    storage_path: str = ".empathy/progressive_runs"
-) -> dict[str, Any]:
+def generate_cost_analytics(storage_path: str = ".empathy/progressive_runs") -> dict[str, Any]:
     """Generate cost optimization analytics from saved results.
 
     Analyzes historical progressive workflow runs to provide insights:
@@ -408,7 +400,7 @@ def generate_cost_analytics(
             "total_runs": 0,
             "total_cost": 0.0,
             "total_savings": 0.0,
-            "avg_savings_percent": 0.0
+            "avg_savings_percent": 0.0,
         }
 
     total_runs = len(results)
@@ -417,8 +409,7 @@ def generate_cost_analytics(
 
     # Calculate average savings percent (weighted by cost)
     weighted_savings = sum(
-        r.get("cost_savings_percent", 0) * r.get("total_cost", 0)
-        for r in results
+        r.get("cost_savings_percent", 0) * r.get("total_cost", 0) for r in results
     )
     avg_savings_percent = weighted_savings / total_cost if total_cost > 0 else 0
 
@@ -450,7 +441,7 @@ def generate_cost_analytics(
                 "runs": 0,
                 "total_cost": 0.0,
                 "total_savings": 0.0,
-                "successes": 0
+                "successes": 0,
             }
 
         stats = workflow_stats[workflow]
@@ -476,7 +467,7 @@ def generate_cost_analytics(
         "avg_final_cqs": round(avg_cqs, 1),
         "tier_usage": tier_usage,
         "tier_costs": tier_costs,
-        "workflow_stats": workflow_stats
+        "workflow_stats": workflow_stats,
     }