feat: Add orchestrated health check workflow with CLI integration

- OrchestratedHealthCheckWorkflow with 3 modes (daily/weekly/release)
- Health score calculation (0-100) with weighted categories
- Trend tracking and smart recommendations
- CLI: empathy orchestrate health-check --mode [daily|weekly|release]
- Beautiful console output with Rich formatting
- 30 comprehensive tests (91.70% coverage)
- JSON export for CI/CD integration

Part of meta-orchestration system (v4.0)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: silversurfer562

src/empathy_os/cli.py

@@ -773,6 +773,7 @@ def cmd_orchestrate(args):
     import asyncio
     import json
 
+    from empathy_os.workflows.orchestrated_health_check import OrchestratedHealthCheckWorkflow
     from empathy_os.workflows.orchestrated_release_prep import OrchestratedReleasePrepWorkflow
     from empathy_os.workflows.test_coverage_boost import TestCoverageBoostWorkflow
 
@@ -924,12 +925,66 @@ def cmd_orchestrate(args):
             logger.exception("Orchestration workflow failed")
             return 1
 
+    elif workflow_type == "health-check":
+        # Health Check workflow
+        mode = args.mode or "daily"
+        project_root = args.project_root or "."
+        focus_area = getattr(args, "focus", None)
+
+        print(f"  Mode: {mode.upper()}")
+        print(f"  Project Root: {project_root}")
+        if focus_area:
+            print(f"  Focus Area: {focus_area}")
+        print()
+
+        # Show agents for mode
+        mode_agents = {
+            "daily": ["Security", "Coverage", "Quality"],
+            "weekly": ["Security", "Coverage", "Quality", "Performance", "Documentation"],
+            "release": [
+                "Security",
+                "Coverage",
+                "Quality",
+                "Performance",
+                "Documentation",
+                "Architecture",
+            ],
+        }
+
+        print(f"  🔍 {mode.capitalize()} Check Agents:")
+        for agent in mode_agents.get(mode, []):
+            print(f"    • {agent}")
+        print()
+
+        # Create workflow
+        workflow = OrchestratedHealthCheckWorkflow(mode=mode, project_root=project_root)
+
+        try:
+            # Execute workflow
+            report = asyncio.run(workflow.execute())
+
+            # Display results
+            if hasattr(args, "json") and args.json:
+                print(json.dumps(report.to_dict(), indent=2))
+            else:
+                print(report.format_console_output())
+
+            # Return appropriate exit code (70+ is passing)
+            return 0 if report.overall_health_score >= 70 else 1
+
+        except Exception as e:
+            print(f"  ❌ Error executing health check workflow: {e}")
+            print()
+            logger.exception("Health check workflow failed")
+            return 1
+
     else:
         print(f"  ❌ Unknown workflow type: {workflow_type}")
         print()
         print("  Available workflows:")
         print("    - release-prep: Release readiness validation (parallel agents)")
         print("    - test-coverage: Boost test coverage through sequential agent composition")
+        print("    - health-check: Project health assessment (daily/weekly/release modes)")
         print()
         return 1
 
@@ -3472,11 +3527,11 @@ def main():
     # Orchestrate command (meta-orchestration workflows)
     parser_orchestrate = subparsers.add_parser(
         "orchestrate",
-        help="Run meta-orchestration workflows (test-coverage, release-prep)",
+        help="Run meta-orchestration workflows (test-coverage, release-prep, health-check)",
     )
     parser_orchestrate.add_argument(
         "workflow",
-        choices=["test-coverage", "release-prep"],
+        choices=["test-coverage", "release-prep", "health-check"],
         help="Workflow to execute",
     )
     parser_orchestrate.add_argument(
@@ -3515,6 +3570,16 @@ def main():
         type=float,
         help="Maximum critical security issues (for release-prep, default: 0)",
     )
+    # Health-check workflow arguments
+    parser_orchestrate.add_argument(
+        "--mode",
+        choices=["daily", "weekly", "release"],
+        help="Health check mode (for health-check, default: daily)",
+    )
+    parser_orchestrate.add_argument(
+        "--focus",
+        help="Focus area for health check (for health-check, optional)",
+    )
     parser_orchestrate.add_argument(
         "--json",
         action="store_true",

src/empathy_os/cli_unified.py

@@ -538,6 +538,212 @@ def workflow_recommend(
     )
 
 
+# =============================================================================
+# ORCHESTRATE SUBCOMMAND GROUP (Meta-Orchestration v4.0)
+# =============================================================================
+
+orchestrate_app = typer.Typer(help="Meta-orchestration workflows (v4.0)")
+app.add_typer(orchestrate_app, name="orchestrate")
+
+
+@orchestrate_app.command("health-check")
+def orchestrate_health_check(
+    mode: str = typer.Option("daily", "--mode", "-m", help="Check mode: daily, weekly, release"),
+    project_root: Path = typer.Option(Path("."), "--project-root", "-p", help="Project root path"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """Run orchestrated health check with adaptive agent teams.
+
+    Modes:
+        daily: Quick parallel check (3 agents: Security, Coverage, Quality)
+        weekly: Comprehensive parallel (5 agents: adds Performance, Docs)
+        release: Deep refinement (6 agents: adds Architecture)
+    """
+    import asyncio
+
+    from empathy_os.workflows.orchestrated_health_check import OrchestratedHealthCheckWorkflow
+
+    async def run_health_check():
+        workflow = OrchestratedHealthCheckWorkflow(mode=mode)
+        report = await workflow.execute(project_root=str(project_root))
+
+        if json_output:
+            import json
+
+            console.print(json.dumps(report.to_dict(), indent=2))
+        else:
+            # Beautiful console output
+            console.print("\n[bold cyan]🏥 HEALTH CHECK REPORT[/bold cyan]")
+            console.print("=" * 60)
+
+            # Health score with color coding
+            score_color = (
+                "green"
+                if report.overall_health_score >= 80
+                else "yellow" if report.overall_health_score >= 60 else "red"
+            )
+            console.print(
+                f"\n[bold {score_color}]Health Score: {report.overall_health_score}/100 (Grade: {report.grade})[/bold {score_color}]"
+            )
+            console.print(f"[dim]Trend: {report.trend}[/dim]")
+            console.print(f"[dim]Duration: {report.execution_time:.2f}s[/dim]")
+
+            # Issues
+            if report.issues:
+                console.print(f"\n[bold red]⚠️  Issues Found ({len(report.issues)}):[/bold red]")
+                for issue in report.issues[:5]:
+                    console.print(f"  • {issue}")
+
+            # Recommendations
+            if report.recommendations:
+                console.print("\n[bold yellow]💡 Recommendations:[/bold yellow]")
+                for i, rec in enumerate(report.recommendations[:5], 1):
+                    console.print(f"  {i}. {rec}")
+
+            console.print("\n" + "=" * 60)
+
+        return report
+
+    try:
+        asyncio.run(run_health_check())
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        raise typer.Exit(code=1)
+
+
+@orchestrate_app.command("release-prep")
+def orchestrate_release_prep(
+    project_root: Path = typer.Option(Path("."), "--project-root", "-p", help="Project root path"),
+    min_coverage: float = typer.Option(80.0, "--min-coverage", help="Minimum test coverage %"),
+    min_quality: float = typer.Option(7.0, "--min-quality", help="Minimum quality score (0-10)"),
+    max_critical: int = typer.Option(0, "--max-critical", help="Max critical issues allowed"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """Run orchestrated release preparation with parallel validation.
+
+    Runs 4 agents in parallel:
+        - Security Auditor (vulnerability scan)
+        - Test Coverage Analyzer (gap analysis)
+        - Code Quality Reviewer (best practices)
+        - Documentation Writer (completeness check)
+    """
+    import asyncio
+
+    from empathy_os.workflows.orchestrated_release_prep import OrchestratedReleasePrepWorkflow
+
+    async def run_release_prep():
+        workflow = OrchestratedReleasePrepWorkflow(
+            quality_gates={
+                "min_coverage": min_coverage,
+                "min_quality_score": min_quality,
+                "max_critical_issues": max_critical,
+            }
+        )
+        report = await workflow.execute(path=str(project_root))
+
+        if json_output:
+            import json
+
+            console.print(json.dumps(report.to_dict(), indent=2))
+        else:
+            console.print("\n[bold cyan]📋 RELEASE PREPARATION REPORT[/bold cyan]")
+            console.print("=" * 60)
+
+            approval_color = "green" if report.approved else "red"
+            approval_emoji = "✅" if report.approved else "❌"
+            console.print(
+                f"\n[bold {approval_color}]{approval_emoji} {'APPROVED' if report.approved else 'NOT APPROVED'}[/bold {approval_color}]"
+            )
+            console.print(f"[dim]Confidence: {report.confidence}[/dim]")
+            console.print(f"[dim]Duration: {report.total_duration:.2f}s[/dim]")
+
+            # Quality gates
+            console.print("\n[bold]Quality Gates:[/bold]")
+            for gate in report.quality_gates:
+                gate_emoji = "✅" if gate.passed else "❌"
+                console.print(
+                    f"  {gate_emoji} {gate.name}: {gate.actual:.1f} (threshold: {gate.threshold:.1f})"
+                )
+
+            # Blockers
+            if report.blockers:
+                console.print("\n[bold red]🚫 Blockers:[/bold red]")
+                for blocker in report.blockers:
+                    console.print(f"  • {blocker}")
+
+            # Warnings
+            if report.warnings:
+                console.print("\n[bold yellow]⚠️  Warnings:[/bold yellow]")
+                for warning in report.warnings:
+                    console.print(f"  • {warning}")
+
+            console.print("\n" + "=" * 60)
+
+        return report
+
+    try:
+        asyncio.run(run_release_prep())
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        raise typer.Exit(code=1)
+
+
+@orchestrate_app.command("test-coverage")
+def orchestrate_test_coverage(
+    project_root: Path = typer.Option(Path("."), "--project-root", "-p", help="Project root path"),
+    target: float = typer.Option(90.0, "--target", "-t", help="Target coverage percentage"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """Run orchestrated test coverage boost with sequential stages.
+
+    Runs 3 stages sequentially:
+        1. Coverage Analyzer → Identify gaps
+        2. Test Generator → Create tests
+        3. Test Validator → Verify coverage
+    """
+    import asyncio
+
+    from empathy_os.workflows.test_coverage_boost import TestCoverageBoostWorkflow
+
+    async def run_test_coverage():
+        workflow = TestCoverageBoostWorkflow(target_coverage=target)
+        report = await workflow.execute(project_root=str(project_root))
+
+        if json_output:
+            import json
+
+            console.print(json.dumps(report.to_dict(), indent=2))
+        else:
+            console.print("\n[bold cyan]🧪 TEST COVERAGE BOOST REPORT[/bold cyan]")
+            console.print("=" * 60)
+
+            success_color = "green" if report.success else "red"
+            success_emoji = "✅" if report.success else "❌"
+            console.print(
+                f"\n[bold {success_color}]{success_emoji} {'SUCCESS' if report.success else 'FAILED'}[/bold {success_color}]"
+            )
+            console.print(f"[dim]Initial: {report.initial_coverage:.1f}%[/dim]")
+            console.print(f"[dim]Final: {report.final_coverage:.1f}%[/dim]")
+            console.print(f"[dim]Improvement: +{report.improvement:.1f}%[/dim]")
+            console.print(f"[dim]Duration: {report.total_duration:.2f}s[/dim]")
+
+            # Stage results
+            console.print("\n[bold]Stage Results:[/bold]")
+            for i, stage in enumerate(report.stage_results, 1):
+                stage_emoji = "✅" if stage["success"] else "❌"
+                console.print(f"  {stage_emoji} Stage {i}: {stage.get('description', 'N/A')}")
+
+            console.print("\n" + "=" * 60)
+
+        return report
+
+    try:
+        asyncio.run(run_test_coverage())
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        raise typer.Exit(code=1)
+
+
 # =============================================================================
 # TELEMETRY SUBCOMMAND GROUP
 # =============================================================================

src/empathy_os/workflows/__init__.py

@@ -66,6 +66,10 @@
 # Keyboard Conductor (v3.6) - keyboard shortcut generation
 from .keyboard_shortcuts import KeyboardShortcutWorkflow
 from .manage_documentation import ManageDocumentationCrew, ManageDocumentationCrewResult
+
+# Meta-orchestration workflows (v4.0)
+from .orchestrated_health_check import HealthCheckReport, OrchestratedHealthCheckWorkflow
+from .orchestrated_release_prep import OrchestratedReleasePrepWorkflow, ReleaseReadinessReport
 from .perf_audit import PerformanceAuditWorkflow
 from .pr_review import PRReviewResult, PRReviewWorkflow
 from .refactor_plan import RefactorPlanWorkflow
@@ -319,6 +323,7 @@ def list_workflows() -> list[dict]:
     "DocumentationOrchestrator",
     # Health check crew integration (v3.1)
     "HealthCheckWorkflow",
+    "HealthCheckReport",
     # Keyboard Conductor (v3.6)
     "KeyboardShortcutWorkflow",
     "ManageDocumentationCrew",
@@ -360,4 +365,8 @@ def list_workflows() -> list[dict]:
     "refresh_workflow_registry",
     "steps_from_tier_map",
     "validate_step_config",
+    # Meta-orchestration workflows (v4.0)
+    "OrchestratedHealthCheckWorkflow",
+    "OrchestratedReleasePrepWorkflow",
+    "ReleaseReadinessReport",
 ]