feat: update dashboard components and analytics for 7-day summaries

- Modified `ManagerWeeklySummary`, `MetricsTab`, and `ProductivityAnalytics` to reflect a focus on the last 7 days instead of the current week.
- Enhanced `ManagerSummaryService` and `MetricsService` to calculate metrics over a sliding 7-day window, improving data relevance.
- Added a new utility function `formatDistanceToNow` for better date formatting in French.
- Updated comments and documentation to clarify changes in timeframes.

src/actions/deadline-analytics.ts

@@ -0,0 +1,29 @@
+'use server';
+
+import { DeadlineAnalyticsService, DeadlineMetrics } from '@/services/analytics/deadline-analytics';
+
+export async function getDeadlineMetrics() {
+  try {
+    const metrics = await DeadlineAnalyticsService.getDeadlineMetrics();
+    return { success: true, data: metrics };
+  } catch (error) {
+    console.error('Erreur lors de la récupération des métriques d\'échéance:', error);
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : 'Erreur lors de la récupération des métriques d\'échéance'
+    };
+  }
+}
+
+export async function getCriticalDeadlines() {
+  try {
+    const tasks = await DeadlineAnalyticsService.getCriticalDeadlines();
+    return { success: true, data: tasks };
+  } catch (error) {
+    console.error('Erreur lors de la récupération des échéances critiques:', error);
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : 'Erreur lors de la récupération des échéances critiques'
+    };
+  }
+}

src/components/dashboard/ManagerWeeklySummary.tsx

@@ -27,7 +27,7 @@ export default function ManagerWeeklySummary({ initialSummary }: ManagerWeeklySu
 
 
   const formatPeriod = () => {
-    return `Semaine du ${format(summary.period.start, 'dd MMM', { locale: fr })} au ${format(summary.period.end, 'dd MMM yyyy', { locale: fr })}`;
+    return `7 derniers jours (${format(summary.period.start, 'dd MMM', { locale: fr })} - ${format(summary.period.end, 'dd MMM yyyy', { locale: fr })})`;
   };
 
   const getPriorityBadgeStyle = (priority: 'low' | 'medium' | 'high') => {
@@ -134,7 +134,7 @@ export default function ManagerWeeklySummary({ initialSummary }: ManagerWeeklySu
               </div>
               
               <div className="bg-green-50 p-4 rounded-lg border-l-4 border-green-400">
-                <h3 className="font-medium text-green-900 mb-2">🔮 Focus semaine prochaine</h3>
+                <h3 className="font-medium text-green-900 mb-2">🔮 Focus 7 prochains jours</h3>
                 <p className="text-green-800">{summary.narrative.nextWeekFocus}</p>
               </div>
             </CardContent>
@@ -346,7 +346,7 @@ export default function ManagerWeeklySummary({ initialSummary }: ManagerWeeklySu
       {activeView === 'accomplishments' && (
         <Card>
           <CardHeader>
-            <h2 className="text-lg font-semibold">✅ Accomplissements de la semaine</h2>
+            <h2 className="text-lg font-semibold">✅ Accomplissements des 7 derniers jours</h2>
             <p className="text-sm text-[var(--muted-foreground)]">
               {summary.keyAccomplishments.length} accomplissements significatifs • {summary.metrics.totalTasksCompleted} tâches • {summary.metrics.totalCheckboxesCompleted} todos complétés
             </p>

src/components/dashboard/MetricsTab.tsx

@@ -31,7 +31,7 @@ export function MetricsTab({ className }: MetricsTabProps) {
 
   const formatPeriod = () => {
     if (!metrics) return '';
-    return `Semaine du ${format(metrics.period.start, 'dd MMM', { locale: fr })} au ${format(metrics.period.end, 'dd MMM yyyy', { locale: fr })}`;
+    return `7 derniers jours (${format(metrics.period.start, 'dd MMM', { locale: fr })} - ${format(metrics.period.end, 'dd MMM yyyy', { locale: fr })})`;
   };
 
 

src/components/dashboard/ProductivityAnalytics.tsx

@@ -8,6 +8,7 @@ import { VelocityChart } from '@/components/charts/VelocityChart';
 import { PriorityDistributionChart } from '@/components/charts/PriorityDistributionChart';
 import { WeeklyStatsCard } from '@/components/charts/WeeklyStatsCard';
 import { Card } from '@/components/ui/Card';
+import { DeadlineOverview } from '@/components/deadline/DeadlineOverview';
 
 export function ProductivityAnalytics() {
   const [metrics, setMetrics] = useState<ProductivityMetrics | null>(null);
@@ -67,7 +68,10 @@ export function ProductivityAnalytics() {
 
   return (
     <div className="space-y-8">
-      {/* Titre de section */}
+      {/* Section Échéances Critiques */}
+      <DeadlineOverview />
+
+      {/* Titre de section Analytics */}
       <div className="flex items-center justify-between">
         <h2 className="text-2xl font-bold">📊 Analytics & Métriques</h2>
         <div className="text-sm text-[var(--muted-foreground)]">

src/components/deadline/CriticalDeadlinesCard.tsx

@@ -0,0 +1,169 @@
+'use client';
+
+import { DeadlineTask } from '@/services/analytics/deadline-analytics';
+import { Card } from '@/components/ui/Card';
+
+interface CriticalDeadlinesCardProps {
+  overdue: DeadlineTask[];
+  critical: DeadlineTask[];
+  warning: DeadlineTask[];
+}
+
+export function CriticalDeadlinesCard({ overdue, critical, warning }: CriticalDeadlinesCardProps) {
+  // Combiner toutes les tâches urgentes et trier par urgence
+  const urgentTasks = [...overdue, ...critical, ...warning]
+    .sort((a, b) => {
+      // En retard d'abord, puis critique, puis attention
+      const urgencyOrder: Record<string, number> = { 'overdue': 0, 'critical': 1, 'warning': 2 };
+      if (urgencyOrder[a.urgencyLevel] !== urgencyOrder[b.urgencyLevel]) {
+        return urgencyOrder[a.urgencyLevel] - urgencyOrder[b.urgencyLevel];
+      }
+      // Si même urgence, trier par jours restants
+      return a.daysRemaining - b.daysRemaining;
+    });
+
+  const getUrgencyStyle = (task: DeadlineTask) => {
+    if (task.urgencyLevel === 'overdue') {
+      return {
+        icon: '🔴',
+        text: task.daysRemaining === -1 ? 'En retard de 1 jour' : `En retard de ${Math.abs(task.daysRemaining)} jours`,
+        style: 'text-red-700 bg-red-50/40 border-red-200/60 dark:bg-red-950/20 dark:border-red-800/40 dark:text-red-300'
+      };
+    } else if (task.urgencyLevel === 'critical') {
+      return {
+        icon: '🟠',
+        text: task.daysRemaining === 0 ? 'Échéance aujourd\'hui' : 
+              task.daysRemaining === 1 ? 'Échéance demain' :
+              `Dans ${task.daysRemaining} jours`,
+        style: 'text-orange-700 bg-orange-50/40 border-orange-200/60 dark:bg-orange-950/20 dark:border-orange-800/40 dark:text-orange-300'
+      };
+    } else {
+      return {
+        icon: '🟡',
+        text: `Dans ${task.daysRemaining} jours`,
+        style: 'text-yellow-700 bg-yellow-50/40 border-yellow-200/60 dark:bg-yellow-950/20 dark:border-yellow-800/40 dark:text-yellow-300'
+      };
+    }
+  };
+
+  const getPriorityIcon = (priority: string) => {
+    switch (priority) {
+      case 'urgent': return '🔥';
+      case 'high': return '⬆️';
+      case 'medium': return '➡️';
+      case 'low': return '⬇️';
+      default: return '❓';
+    }
+  };
+
+  const getSourceIcon = (source: string) => {
+    switch (source.toLowerCase()) {
+      case 'jira': return '🔵';
+      case 'tfs': return '🟣';
+      case 'manual': return '✏️';
+      default: return '📋';
+    }
+  };
+
+  if (urgentTasks.length === 0) {
+    return (
+      <Card className="p-6 hover:shadow-lg transition-shadow">
+        <h3 className="text-lg font-semibold mb-4">Tâches Urgentes</h3>
+        <div className="text-center py-8">
+          <div className="text-4xl mb-2">🎉</div>
+          <h4 className="text-lg font-medium text-green-600 dark:text-green-400 mb-2">Excellent !</h4>
+          <p className="text-sm text-[var(--muted-foreground)]">
+            Aucune tâche urgente ou critique
+          </p>
+        </div>
+      </Card>
+    );
+  }
+
+  return (
+    <Card className="p-6 hover:shadow-lg transition-shadow">
+      <div className="flex items-center justify-between mb-4">
+        <h3 className="text-lg font-semibold">Tâches Urgentes</h3>
+        <div className="text-sm text-[var(--muted-foreground)]">
+          {urgentTasks.length} tâche{urgentTasks.length > 1 ? 's' : ''}
+        </div>
+      </div>
+
+      <div className="space-y-2 max-h-40 overflow-y-auto scrollbar-thin scrollbar-thumb-gray-300 dark:scrollbar-thumb-gray-600 scrollbar-track-transparent pr-2">
+        {urgentTasks.map((task) => {
+          const urgencyStyle = getUrgencyStyle(task);
+          
+          return (
+            <div 
+              key={task.id} 
+              className={`p-2.5 rounded-lg border transition-all hover:shadow-sm hover:scale-[1.01] ${urgencyStyle.style}`}
+            >
+              <div className="flex items-start justify-between gap-2">
+                <div className="flex-1 min-w-0">
+                  <div className="flex items-center gap-2 mb-1">
+                    <span className="text-sm">{urgencyStyle.icon}</span>
+                    <span className="text-sm">{getSourceIcon(task.source)}</span>
+                    <span className="text-sm">{getPriorityIcon(task.priority)}</span>
+                    {task.jiraKey && (
+                      <span className="text-xs px-1.5 py-0.5 bg-[var(--border)] rounded font-mono">
+                        {task.jiraKey}
+                      </span>
+                    )}
+                  </div>
+                  
+                  <h4 className="font-medium text-sm leading-tight mb-0.5 truncate" title={task.title}>
+                    {task.title}
+                  </h4>
+                  
+                  <div className="text-xs opacity-75">
+                    {urgencyStyle.text}
+                  </div>
+                  
+                  {task.tags.length > 0 && (
+                    <div className="flex gap-1 mt-1.5 flex-wrap">
+                      {task.tags.slice(0, 2).map((tag, index) => (
+                        <span 
+                          key={index}
+                          className="text-xs px-1.5 py-0.5 bg-[var(--accent)]/60 text-[var(--accent-foreground)] rounded"
+                        >
+                          {tag}
+                        </span>
+                      ))}
+                      {task.tags.length > 2 && (
+                        <span className="text-xs text-[var(--muted-foreground)] opacity-70">
+                          +{task.tags.length - 2}
+                        </span>
+                      )}
+                    </div>
+                  )}
+                </div>
+              </div>
+            </div>
+          );
+        })}
+      </div>
+
+      {urgentTasks.length > 0 && (
+        <div className="pt-3 border-t border-[var(--border)] mt-4">
+          <div className="flex flex-wrap gap-3 text-xs text-[var(--muted-foreground)] justify-center">
+            {overdue.length > 0 && (
+              <span className="text-red-600/80 dark:text-red-400/80 font-medium">
+                {overdue.length} en retard
+              </span>
+            )}
+            {critical.length > 0 && (
+              <span className="text-orange-600/80 dark:text-orange-400/80 font-medium">
+                {critical.length} critique{critical.length > 1 ? 's' : ''}
+              </span>
+            )}
+            {warning.length > 0 && (
+              <span className="text-yellow-600/80 dark:text-yellow-400/80 font-medium">
+                {warning.length} attention
+              </span>
+            )}
+          </div>
+        </div>
+      )}
+    </Card>
+  );
+}

src/components/deadline/DeadlineOverview.tsx

@@ -0,0 +1,89 @@
+'use client';
+
+import { useState, useEffect, useTransition } from 'react';
+import { DeadlineMetrics } from '@/services/analytics/deadline-analytics';
+import { getDeadlineMetrics } from '@/actions/deadline-analytics';
+import { Card } from '@/components/ui/Card';
+import { DeadlineRiskCard } from './DeadlineRiskCard';
+import { CriticalDeadlinesCard } from './CriticalDeadlinesCard';
+import { DeadlineSummaryCard } from './DeadlineSummaryCard';
+
+export function DeadlineOverview() {
+  const [metrics, setMetrics] = useState<DeadlineMetrics | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [isPending, startTransition] = useTransition();
+
+  useEffect(() => {
+    const loadMetrics = () => {
+      startTransition(async () => {
+        try {
+          setError(null);
+          const response = await getDeadlineMetrics();
+          
+          if (response.success && response.data) {
+            setMetrics(response.data);
+          } else {
+            setError(response.error || 'Erreur lors du chargement des échéances');
+          }
+        } catch (err) {
+          setError(err instanceof Error ? err.message : 'Erreur lors du chargement des échéances');
+          console.error('Erreur échéances:', err);
+        }
+      });
+    };
+
+    loadMetrics();
+  }, []);
+
+  if (isPending) {
+    return (
+      <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6 mb-8">
+        {Array.from({ length: 3 }).map((_, i) => (
+          <Card key={i} className="p-6 animate-pulse">
+            <div className="h-4 bg-[var(--border)] rounded mb-4 w-1/2"></div>
+            <div className="h-20 bg-[var(--border)] rounded"></div>
+          </Card>
+        ))}
+      </div>
+    );
+  }
+
+  if (error) {
+    return (
+      <Card className="p-6 mb-8">
+        <div className="text-center">
+          <div className="text-red-500 text-4xl mb-2">⚠️</div>
+          <h3 className="text-lg font-semibold mb-2">Erreur de chargement des échéances</h3>
+          <p className="text-[var(--muted-foreground)] text-sm">{error}</p>
+        </div>
+      </Card>
+    );
+  }
+
+  if (!metrics) {
+    return null;
+  }
+
+  return (
+    <div className="space-y-6">
+      {/* Titre de section */}
+      <div className="flex items-center justify-between">
+        <h2 className="text-2xl font-bold">🚨 Échéances Critiques</h2>
+        <div className="text-sm text-[var(--muted-foreground)]">
+          Surveillance temps réel
+        </div>
+      </div>
+
+      {/* Cards principales */}
+      <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
+        <DeadlineRiskCard metrics={metrics} />
+        <DeadlineSummaryCard metrics={metrics} />
+        <CriticalDeadlinesCard 
+          overdue={metrics.overdue} 
+          critical={metrics.critical}
+          warning={metrics.warning}
+        />
+      </div>
+    </div>
+  );
+}

src/components/deadline/DeadlineRiskCard.tsx

@@ -0,0 +1,89 @@
+'use client';
+
+import { DeadlineMetrics, DeadlineAnalyticsService } from '@/services/analytics/deadline-analytics';
+import { Card } from '@/components/ui/Card';
+
+interface DeadlineRiskCardProps {
+  metrics: DeadlineMetrics;
+}
+
+export function DeadlineRiskCard({ metrics }: DeadlineRiskCardProps) {
+  const riskAnalysis = DeadlineAnalyticsService.calculateRiskMetrics(metrics);
+
+  const getRiskIcon = (level: string) => {
+    switch (level) {
+      case 'critical': return '🔴';
+      case 'high': return '🟠';
+      case 'medium': return '🟡';
+      case 'low': return '🟢';
+      default: return '⚪';
+    }
+  };
+
+  const getRiskColor = (level: string) => {
+    switch (level) {
+      case 'critical': return 'text-red-600 dark:text-red-400';
+      case 'high': return 'text-orange-600 dark:text-orange-400';
+      case 'medium': return 'text-yellow-600 dark:text-yellow-400';
+      case 'low': return 'text-green-600 dark:text-green-400';
+      default: return 'text-gray-600 dark:text-gray-400';
+    }
+  };
+
+  const getRiskBgColor = (level: string) => {
+    switch (level) {
+      case 'critical': return 'bg-red-50/30 border-red-200/50 dark:bg-red-950/20 dark:border-red-800/30';
+      case 'high': return 'bg-orange-50/30 border-orange-200/50 dark:bg-orange-950/20 dark:border-orange-800/30';
+      case 'medium': return 'bg-yellow-50/30 border-yellow-200/50 dark:bg-yellow-950/20 dark:border-yellow-800/30';
+      case 'low': return 'bg-green-50/30 border-green-200/50 dark:bg-green-950/20 dark:border-green-800/30';
+      default: return 'bg-gray-50/30 border-gray-200/50 dark:bg-gray-950/20 dark:border-gray-800/30';
+    }
+  };
+
+  return (
+    <Card className={`p-6 ${getRiskBgColor(riskAnalysis.riskLevel)} transition-all hover:shadow-lg`}>
+      <div className="flex items-center justify-between mb-4">
+        <div className="flex items-center gap-2">
+          <span className="text-2xl">{getRiskIcon(riskAnalysis.riskLevel)}</span>
+          <h3 className="text-lg font-semibold">Niveau de Risque</h3>
+        </div>
+        <div className={`text-3xl font-bold ${getRiskColor(riskAnalysis.riskLevel)}`}>
+          {riskAnalysis.riskScore}
+        </div>
+      </div>
+
+      <div className="space-y-3">
+        {/* Barre de risque */}
+        <div className="w-full bg-gray-200 rounded-full h-3 overflow-hidden">
+          <div 
+            className={`h-3 rounded-full transition-all duration-500 ${
+              riskAnalysis.riskLevel === 'critical' ? 'bg-red-500/80' :
+              riskAnalysis.riskLevel === 'high' ? 'bg-orange-500/80' :
+              riskAnalysis.riskLevel === 'medium' ? 'bg-yellow-500/80' : 'bg-green-500/80'
+            }`}
+            style={{ width: `${Math.min(riskAnalysis.riskScore, 100)}%` }}
+          />
+        </div>
+
+        {/* Détails des risques */}
+        <div className="grid grid-cols-2 gap-2 text-sm">
+          <div className="flex justify-between">
+            <span className="text-[var(--muted-foreground)]">En retard:</span>
+            <span className="font-medium text-red-600/80 dark:text-red-400/80">{metrics.summary.overdueCount}</span>
+          </div>
+          <div className="flex justify-between">
+            <span className="text-[var(--muted-foreground)]">Critique:</span>
+            <span className="font-medium text-orange-600/80 dark:text-orange-400/80">{metrics.summary.criticalCount}</span>
+          </div>
+        </div>
+
+        {/* Recommandation */}
+        <div className="pt-2 border-t border-[var(--border)]">
+          <p className="text-xs text-[var(--muted-foreground)] leading-relaxed">
+            {riskAnalysis.recommendation}
+          </p>
+        </div>
+      </div>
+    </Card>
+  );
+}

src/components/deadline/DeadlineSummaryCard.tsx

@@ -0,0 +1,91 @@
+'use client';
+
+import { DeadlineMetrics } from '@/services/analytics/deadline-analytics';
+import { Card } from '@/components/ui/Card';
+
+interface DeadlineSummaryCardProps {
+  metrics: DeadlineMetrics;
+}
+
+export function DeadlineSummaryCard({ metrics }: DeadlineSummaryCardProps) {
+  const { summary } = metrics;
+
+  const summaryItems = [
+    {
+      label: 'En retard',
+      count: summary.overdueCount,
+      icon: '⏰',
+      color: 'text-red-600 dark:text-red-400',
+      bgColor: 'bg-red-100/50 dark:bg-red-900/30'
+    },
+    {
+      label: 'Critique (0-2j)',
+      count: summary.criticalCount,
+      icon: '🚨',
+      color: 'text-orange-600 dark:text-orange-400',
+      bgColor: 'bg-orange-100/50 dark:bg-orange-900/30'
+    },
+    {
+      label: 'Attention (3-7j)',
+      count: summary.warningCount,
+      icon: '⚠️',
+      color: 'text-yellow-600 dark:text-yellow-400',
+      bgColor: 'bg-yellow-100/50 dark:bg-yellow-900/30'
+    },
+    {
+      label: 'À venir (8-14j)',
+      count: summary.upcomingCount,
+      icon: '📅',
+      color: 'text-blue-600 dark:text-blue-400',
+      bgColor: 'bg-blue-100/50 dark:bg-blue-900/30'
+    }
+  ];
+
+  return (
+    <Card className="p-6 hover:shadow-lg transition-shadow">
+      <div className="flex items-center justify-between mb-4">
+        <h3 className="text-lg font-semibold">Répartition des Échéances</h3>
+        <div className="text-sm text-[var(--muted-foreground)]">
+          {summary.totalWithDeadlines} total
+        </div>
+      </div>
+
+      <div className="space-y-3">
+        {summaryItems.map((item, index) => (
+          <div key={index} className="flex items-center justify-between">
+            <div className="flex items-center gap-3">
+              <div className={`w-8 h-8 ${item.bgColor} rounded-full flex items-center justify-center text-sm`}>
+                {item.icon}
+              </div>
+              <span className="text-sm font-medium">{item.label}</span>
+            </div>
+            <div className={`text-lg font-bold ${item.color}`}>
+              {item.count}
+            </div>
+          </div>
+        ))}
+
+        {/* Indicateur de performance */}
+        <div className="pt-3 border-t border-[var(--border)]">
+          <div className="flex items-center justify-between text-sm">
+            <span className="text-[var(--muted-foreground)]">Tâches sous contrôle:</span>
+            <span className="font-medium">
+              {summary.totalWithDeadlines - summary.overdueCount - summary.criticalCount}/{summary.totalWithDeadlines}
+            </span>
+          </div>
+          <div className="w-full bg-gray-200/50 dark:bg-gray-700/50 rounded-full h-2 mt-2">
+            <div 
+              className="bg-green-500/80 h-2 rounded-full transition-all duration-300"
+              style={{ 
+                width: `${summary.totalWithDeadlines > 0 
+                  ? Math.round(((summary.totalWithDeadlines - summary.overdueCount - summary.criticalCount) / summary.totalWithDeadlines) * 100)
+                  : 100
+                }%` 
+              }}
+            />
+          </div>
+        </div>
+      </div>
+    </Card>
+  );
+}

src/components/deadline/index.ts

@@ -0,0 +1,4 @@
+export { DeadlineOverview } from './DeadlineOverview';
+export { DeadlineRiskCard } from './DeadlineRiskCard';
+export { CriticalDeadlinesCard } from './CriticalDeadlinesCard';
+export { DeadlineSummaryCard } from './DeadlineSummaryCard';

src/lib/date-utils.ts

@@ -3,7 +3,7 @@
  * Regroupe toutes les fonctions de formatage, manipulation et validation de dates
  */
 
-import { format, startOfDay, endOfDay, isValid } from 'date-fns';
+import { format, startOfDay, endOfDay, isValid, formatDistanceToNow as formatDistanceToNowFns } from 'date-fns';
 import { fr } from 'date-fns/locale';
 
 // Re-export des utilitaires workday existants
@@ -244,3 +244,17 @@ export function generateDateTitle(date: Date, emoji: string = '📅'): string {
   
   return `${emoji} ${formatDateShort(date)}`;
 }
+
+/**
+ * Formate la distance depuis maintenant en français
+ */
+export function formatDistanceToNow(date: Date, options?: { addSuffix?: boolean }): string {
+  if (!isValid(date)) {
+    throw new Error('Date invalide fournie à formatDistanceToNow');
+  }
+  
+  return formatDistanceToNowFns(date, {
+    locale: fr,
+    addSuffix: options?.addSuffix ?? true
+  });
+}

src/services/analytics/analytics.ts

@@ -13,6 +13,8 @@ export interface ProductivityMetrics {
     week: string;
     completed: number;
     average: number;
+    weekNumber?: number;
+    weekStart?: Date;
   }>;
   priorityDistribution: Array<{
     priority: string;
@@ -137,35 +139,41 @@ export class AnalyticsService {
    * Calcule la vélocité (tâches terminées par semaine)
    */
   private static calculateVelocity(tasks: Task[], start: Date, end: Date) {
-    const weeklyData: Array<{ week: string; completed: number; average: number }> = [];
+    const weeklyData: Array<{ week: string; completed: number; average: number; weekNumber: number; weekStart: Date }> = [];
     const completedTasks = tasks.filter(task => task.completedAt);
     
-    // Grouper par semaine
+    // Grouper par semaine en utilisant le numéro de semaine comme clé
-    const weekGroups = new Map<string, number>();
+    const weekGroups = new Map<number, { count: number; weekStart: Date }>();
     
     completedTasks.forEach(task => {
       if (task.completedAt && task.completedAt >= start && task.completedAt <= end) {
         const weekStart = this.getWeekStart(task.completedAt);
-        const weekKey = weekStart.toISOString().split('T')[0];
+        const weekNumber = this.getWeekNumber(weekStart);
-        weekGroups.set(weekKey, (weekGroups.get(weekKey) || 0) + 1);
+        
+        if (!weekGroups.has(weekNumber)) {
+          weekGroups.set(weekNumber, { count: 0, weekStart });
+        }
+        weekGroups.get(weekNumber)!.count++;
       }
     });
     
     // Calculer la moyenne mobile
-    const values = Array.from(weekGroups.values());
+    const values = Array.from(weekGroups.values()).map(w => w.count);
     const average = values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0;
     
     // Convertir en format pour le graphique
-    weekGroups.forEach((count, weekKey) => {
+    weekGroups.forEach((data, weekNumber) => {
-      const weekDate = parseDate(weekKey);
       weeklyData.push({
-        week: `Sem. ${this.getWeekNumber(weekDate)}`,
+        week: `Sem. ${weekNumber}`,
-        completed: count,
+        completed: data.count,
-        average: Math.round(average * 10) / 10
+        average: Math.round(average * 10) / 10,
+        weekNumber,
+        weekStart: data.weekStart
       });
     });
     
-    return weeklyData.sort((a, b) => a.week.localeCompare(b.week));
+    // Trier par numéro de semaine (pas alphabétiquement)
+    return weeklyData.sort((a, b) => a.weekNumber - b.weekNumber);
   }
 
   /**

src/services/analytics/deadline-analytics.ts

@@ -0,0 +1,206 @@
+import { TaskStatus } from '@/lib/types';
+import { prisma } from '@/services/core/database';
+import { getToday } from '@/lib/date-utils';
+
+export interface DeadlineTask {
+  id: string;
+  title: string;
+  status: TaskStatus;
+  priority: string;
+  dueDate: Date;
+  daysRemaining: number;
+  urgencyLevel: 'overdue' | 'critical' | 'warning' | 'normal';
+  source: string;
+  tags: string[];
+  jiraKey?: string;
+}
+
+export interface DeadlineMetrics {
+  overdue: DeadlineTask[];
+  critical: DeadlineTask[]; // 0-2 jours
+  warning: DeadlineTask[];  // 3-7 jours
+  upcoming: DeadlineTask[]; // 8-14 jours
+  summary: {
+    overdueCount: number;
+    criticalCount: number;
+    warningCount: number;
+    upcomingCount: number;
+    totalWithDeadlines: number;
+  };
+}
+
+export class DeadlineAnalyticsService {
+  /**
+   * Analyse les tâches selon leurs échéances
+   */
+  static async getDeadlineMetrics(): Promise<DeadlineMetrics> {
+    try {
+      const now = getToday();
+
+      // Récupérer toutes les tâches non terminées avec échéance
+      const dbTasks = await prisma.task.findMany({
+        where: {
+          dueDate: {
+            not: null
+          },
+          status: {
+            notIn: ['done', 'cancelled', 'archived']
+          }
+        },
+        include: {
+          taskTags: {
+            include: {
+              tag: true
+            }
+          }
+        },
+        orderBy: {
+          dueDate: 'asc'
+        }
+      });
+
+      // Convertir et analyser les tâches
+      const deadlineTasks: DeadlineTask[] = dbTasks.map(task => {
+        const dueDate = task.dueDate!;
+        const daysRemaining = Math.ceil((dueDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
+        
+        let urgencyLevel: DeadlineTask['urgencyLevel'];
+        if (daysRemaining < 0) {
+          urgencyLevel = 'overdue';
+        } else if (daysRemaining <= 2) {
+          urgencyLevel = 'critical';
+        } else if (daysRemaining <= 7) {
+          urgencyLevel = 'warning';
+        } else {
+          urgencyLevel = 'normal';
+        }
+
+        return {
+          id: task.id,
+          title: task.title,
+          status: task.status as TaskStatus,
+          priority: task.priority,
+          dueDate,
+          daysRemaining,
+          urgencyLevel,
+          source: task.source,
+          tags: task.taskTags.map(tt => tt.tag.name),
+          jiraKey: task.jiraKey || undefined
+        };
+      });
+
+      // Filtrer les tâches dans les 2 prochaines semaines
+      const relevantTasks = deadlineTasks.filter(task => 
+        task.daysRemaining <= 14 || task.urgencyLevel === 'overdue'
+      );
+
+      const overdue = relevantTasks.filter(t => t.urgencyLevel === 'overdue');
+      const critical = relevantTasks.filter(t => t.urgencyLevel === 'critical');
+      const warning = relevantTasks.filter(t => t.urgencyLevel === 'warning');
+      const upcoming = relevantTasks.filter(t => t.urgencyLevel === 'normal' && t.daysRemaining <= 14);
+
+      return {
+        overdue,
+        critical,
+        warning,
+        upcoming,
+        summary: {
+          overdueCount: overdue.length,
+          criticalCount: critical.length,
+          warningCount: warning.length,
+          upcomingCount: upcoming.length,
+          totalWithDeadlines: deadlineTasks.length
+        }
+      };
+    } catch (error) {
+      console.error('Erreur lors de l\'analyse des échéances:', error);
+      throw new Error('Impossible d\'analyser les échéances');
+    }
+  }
+
+  /**
+   * Retourne les tâches les plus critiques (en retard + échéance dans 48h)
+   */
+  static async getCriticalDeadlines(): Promise<DeadlineTask[]> {
+    const metrics = await this.getDeadlineMetrics();
+    return [
+      ...metrics.overdue,
+      ...metrics.critical
+    ].slice(0, 10); // Limite à 10 tâches les plus critiques
+  }
+
+  /**
+   * Analyse l'impact des échéances par priorité
+   */
+  static analyzeImpactByPriority(tasks: DeadlineTask[]): Array<{
+    priority: string;
+    count: number;
+    overdueCount: number;
+    criticalCount: number;
+  }> {
+    const priorityGroups = new Map<string, DeadlineTask[]>();
+    
+    tasks.forEach(task => {
+      const priority = task.priority || 'medium';
+      if (!priorityGroups.has(priority)) {
+        priorityGroups.set(priority, []);
+      }
+      priorityGroups.get(priority)!.push(task);
+    });
+
+    return Array.from(priorityGroups.entries()).map(([priority, tasks]) => ({
+      priority,
+      count: tasks.length,
+      overdueCount: tasks.filter(t => t.urgencyLevel === 'overdue').length,
+      criticalCount: tasks.filter(t => t.urgencyLevel === 'critical').length
+    })).sort((a, b) => {
+      // Trier par impact (retard + critique) puis par priorité
+      const aImpact = a.overdueCount + a.criticalCount;
+      const bImpact = b.overdueCount + b.criticalCount;
+      if (aImpact !== bImpact) return bImpact - aImpact;
+      
+      const priorityOrder: Record<string, number> = { urgent: 4, high: 3, medium: 2, low: 1 };
+      return (priorityOrder[b.priority] || 2) - (priorityOrder[a.priority] || 2);
+    });
+  }
+
+  /**
+   * Calcule les métriques de risque
+   */
+  static calculateRiskMetrics(metrics: DeadlineMetrics): {
+    riskScore: number; // 0-100
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
+    recommendation: string;
+  } {
+    const { summary } = metrics;
+    
+    // Calcul du score de risque basé sur les échéances
+    let riskScore = 0;
+    riskScore += summary.overdueCount * 25; // Retard = très grave
+    riskScore += summary.criticalCount * 15; // Critique = grave
+    riskScore += summary.warningCount * 5;   // Avertissement = attention
+    riskScore += summary.upcomingCount * 1;  // À venir = surveillance
+    
+    // Limiter à 100
+    riskScore = Math.min(riskScore, 100);
+
+    let riskLevel: 'low' | 'medium' | 'high' | 'critical';
+    let recommendation: string;
+
+    if (riskScore >= 75) {
+      riskLevel = 'critical';
+      recommendation = 'Action immédiate requise ! Plusieurs tâches en retard ou critiques.';
+    } else if (riskScore >= 50) {
+      riskLevel = 'high';
+      recommendation = 'Attention : échéances critiques approchent, planifier les priorités.';
+    } else if (riskScore >= 25) {
+      riskLevel = 'medium';
+      recommendation = 'Surveillance nécessaire, quelques échéances à surveiller.';
+    } else {
+      riskLevel = 'low';
+      recommendation = 'Situation stable, échéances sous contrôle.';
+    }
+
+    return { riskScore, riskLevel, recommendation };
+  }
+}

src/services/analytics/manager-summary.ts

@@ -1,5 +1,4 @@
 import { prisma } from '@/services/core/database';
-import { startOfWeek, endOfWeek } from 'date-fns';
 import { getToday } from '@/lib/date-utils';
 
 type TaskType = {
@@ -83,11 +82,13 @@ export interface ManagerSummary {
 
 export class ManagerSummaryService {
   /**
-   * Génère un résumé orienté manager pour la semaine
+   * Génère un résumé orienté manager pour les 7 derniers jours
    */
   static async getManagerSummary(date: Date = getToday()): Promise<ManagerSummary> {
-    const weekStart = startOfWeek(date, { weekStartsOn: 1 }); // Lundi
+    // Fenêtre glissante de 7 jours au lieu de semaine calendaire
-    const weekEnd = endOfWeek(date, { weekStartsOn: 1 }); // Dimanche
+    const weekEnd = new Date(date);
+    const weekStart = new Date(date);
+    weekStart.setDate(weekStart.getDate() - 6); // 7 jours en arrière (incluant aujourd'hui)
     
     // Récupérer les données de base
     const [tasks, checkboxes] = await Promise.all([
@@ -537,22 +538,22 @@ export class ManagerSummaryService {
     accomplishments: KeyAccomplishment[], 
     challenges: UpcomingChallenge[]
   ) {
-    // Points forts de la semaine
+    // Points forts des 7 derniers jours
     const topAccomplishments = accomplishments.slice(0, 3);
     const weekHighlight = topAccomplishments.length > 0
-      ? `Cette semaine, j'ai principalement progressé sur ${topAccomplishments.map(a => a.title).join(', ')}.`
+      ? `Ces 7 derniers jours, j'ai principalement progressé sur ${topAccomplishments.map(a => a.title).join(', ')}.`
-      : 'Semaine focalisée sur l\'exécution des tâches quotidiennes.';
+      : 'Période focalisée sur l\'exécution des tâches quotidiennes.';
 
     // Défis rencontrés
     const highImpactItems = accomplishments.filter(a => a.impact === 'high');
     const mainChallenges = highImpactItems.length > 0
       ? `Les principaux enjeux traités ont été liés aux ${[...new Set(highImpactItems.flatMap(a => a.tags))].join(', ')}.`
-      : 'Pas de blockers majeurs rencontrés cette semaine.';
+      : 'Pas de blockers majeurs rencontrés sur cette période.';
 
-    // Focus semaine prochaine
+    // Focus 7 prochains jours
     const topChallenges = challenges.slice(0, 3);
     const nextWeekFocus = topChallenges.length > 0
-      ? `La semaine prochaine sera concentrée sur ${topChallenges.map(c => c.title).join(', ')}.`
+      ? `Les 7 prochains jours seront concentrés sur ${topChallenges.map(c => c.title).join(', ')}.`
       : 'Continuation du travail en cours selon les priorités établies.';
 
     return {

src/services/analytics/metrics.ts

@@ -1,5 +1,5 @@
 import { prisma } from '@/services/core/database';
-import { startOfWeek, endOfWeek, eachDayOfInterval, format, startOfDay, endOfDay } from 'date-fns';
+import { eachDayOfInterval, format, startOfDay, endOfDay, startOfWeek, endOfWeek } from 'date-fns';
 import { fr } from 'date-fns/locale';
 import { formatDateForAPI, getDayName, getToday, subtractDays } from '@/lib/date-utils';
 
@@ -57,11 +57,13 @@ export interface WeeklyMetricsOverview {
 
 export class MetricsService {
   /**
-   * Récupère les métriques journalières de la semaine
+   * Récupère les métriques journalières des 7 derniers jours
    */
   static async getWeeklyMetrics(date: Date = getToday()): Promise<WeeklyMetricsOverview> {
-    const weekStart = startOfWeek(date, { weekStartsOn: 1 }); // Lundi
+    // Fenêtre glissante de 7 jours au lieu de semaine calendaire
-    const weekEnd = endOfWeek(date, { weekStartsOn: 1 }); // Dimanche
+    const weekEnd = new Date(date);
+    const weekStart = new Date(date);
+    weekStart.setDate(weekStart.getDate() - 6); // 7 jours en arrière (incluant aujourd'hui)
     
     // Générer tous les jours de la semaine
     const daysOfWeek = eachDayOfInterval({ start: weekStart, end: weekEnd });