@nightkatana/kronosys-app 1.0.0-beta.2 → 1.0.0-beta.21

package/lib/reportingAggregate.ts

@@ -8,11 +8,16 @@ import {
 } from "./taskParsing";
 import type { KronosysUpdatePayload } from "./kronosysApi";
 import { LEGACY_TASK_CYCLES_KEY, LEGACY_TASK_USED_FLAG_KEY } from "./legacyKronoFocusStorageKeys";
-import { calendarDateKeyInTimeZone } from "./dashboardTimeZone";
+import {
+  calendarDateKeyInTimeZone,
+  calendarDayStartUtcMsInTimeZone,
+  splitMinutesByCalendarDay,
+} from "./dashboardTimeZone";
 import {
   localWeekStartKeyFromDayKey,
   type ReportingWeekStartsOn,
 } from "./reportingWeekLayout";
+import { normalizeSessionEndReasonKind } from "./sessionEndReason";
 
 export type LooseTask = {
   id?: string;
@@ -20,13 +25,33 @@ export type LooseTask = {
   endTime?: string;
   durationMs?: number;
   isDone?: boolean;
+  manualTaskTimerPaused?: boolean;
   usedKronoFocus?: boolean;
   kronoFocusCycles?: number;
   tags?: string[];
   project?: string | null;
+  /** Projet issu d’un jeton `!` (temps personnel), distinct des projets `@` productifs. */
+  personalProject?: boolean;
   subtasks?: Array<{ done?: boolean }>;
 };
 
+/** Filtre les tâches pour les agrégats « @ projet » vs « ! projet personnel ». */
+export type ReportingTaskProjectScope = "all" | "work" | "personal";
+
+export function taskMatchesReportingProjectScope(
+  task: LooseTask,
+  scope: ReportingTaskProjectScope,
+): boolean {
+  const isP = task.personalProject === true;
+  if (scope === "all") {
+    return true;
+  }
+  if (scope === "work") {
+    return !isP;
+  }
+  return isP;
+}
+
 export type LooseSession = {
   sessionId: string;
   savedAt?: string;
@@ -56,6 +81,8 @@ export type LooseSession = {
    * Présent seulement si `scheduledStartAt` a été enregistré.
    */
   sessionStartOffsetMinutes?: number | null;
+  /** Catégorie enregistrée à la clôture de session (voir {@link normalizeSessionEndReasonKind}). */
+  sessionEndReasonKind?: string;
 };
 
 export function mergeSessionsFromPayload(payload: KronosysUpdatePayload): LooseSession[] {
@@ -193,7 +220,14 @@ export function localWeekMondayFromDayKey(dayKey: string): string | null {
 }
 
 /**
- * Durée « murale » de la session : valeur persistée si disponible, sinon écart entre `startAt` et `endAt` (minutes).
+ * Durée « murale » de la session : valeur persistée si disponible, sinon écart `startAt` → `endAt` (minutes).
+ *
+ * Repli de dernier recours : si `endAt` manque et que la durée n’a pas été matérialisée
+ * (sessions « orphelines » : restées vivantes en historique sans clôture explicite, héritages
+ * de bogues côté hôte), on retombe sur `savedAt - startAt`. `savedAt` = dernier sync de la
+ * session ; c’est une borne supérieure raisonnable du temps écoulé tant que la session
+ * était active, et ça vaut mieux que de compter 0 minute pour une session qui a clairement
+ * eu de l’activité (présence de tâches, durées de tâches non nulles, etc.).
  */
 export function sessionWallClockMinutes(s: LooseSession): number {
   const persisted = s.sessionDurationMinutes;
@@ -205,9 +239,191 @@ export function sessionWallClockMinutes(s: LooseSession): number {
   if (Number.isFinite(start) && Number.isFinite(end) && end > start) {
     return (end - start) / 60000;
   }
+  const saved = s.savedAt ? Date.parse(s.savedAt) : NaN;
+  if (Number.isFinite(start) && Number.isFinite(saved) && saved > start) {
+    return (saved - start) / 60000;
+  }
   return 0;
 }
 
+function parseTaskIntervalMs(task: LooseTask): [number, number] | null {
+  const start = typeof task.startTime === "string" ? Date.parse(task.startTime) : NaN;
+  const end = typeof task.endTime === "string" ? Date.parse(task.endTime) : NaN;
+  if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) {
+    return null;
+  }
+  return [start, end];
+}
+
+/**
+ * Bornes UTC `[startMs, endMs]` du « segment d’ouverture » de la session. `endMs` privilégie
+ * `endAt` (session clôturée), retombe sur `savedAt` (session live → dernier sync ; orpheline →
+ * dernière trace en historique). Renvoie `null` si on ne peut pas borner correctement.
+ */
+function sessionWallSpanRangeMs(s: LooseSession): [number, number] | null {
+  const startMs = s.startAt ? Date.parse(s.startAt) : NaN;
+  if (!Number.isFinite(startMs)) {
+    return null;
+  }
+  const endIsoCandidate =
+    typeof s.endAt === "string" && s.endAt.trim() !== ""
+      ? s.endAt
+      : (s.savedAt ?? null);
+  const endMs = endIsoCandidate ? Date.parse(endIsoCandidate) : NaN;
+  if (!Number.isFinite(endMs) || endMs <= startMs) {
+    return null;
+  }
+  return [startMs, endMs];
+}
+
+/**
+ * Minutes « murales » de la session ventilées par jour calendaire local. Le total persisté
+ * (`sessionDurationMinutes` quand > 0, sinon `endAt - startAt`) est réparti **au prorata** de la
+ * fraction du segment d’ouverture tombant dans chaque jour. Les pauses ne sont donc pas
+ * attribuées précisément à leurs jours, mais le total reste correct et le découpage minuit est
+ * respecté.
+ *
+ * Renvoie une map vide quand la session n’a pas de bornes utilisables (orpheline sans `savedAt`).
+ */
+export function sessionWallMinutesByDay(s: LooseSession, timeZone: string): Map<string, number> {
+  const span = sessionWallSpanRangeMs(s);
+  if (!span) {
+    return new Map();
+  }
+  const [startMs, endMs] = span;
+  const spanByDay = splitMinutesByCalendarDay(startMs, endMs, timeZone);
+  const totalSpanMin = (endMs - startMs) / 60000;
+  if (totalSpanMin <= 0 || spanByDay.size === 0) {
+    return new Map();
+  }
+  const persistedTotal = sessionWallClockMinutes(s);
+  if (persistedTotal <= 0) {
+    return new Map();
+  }
+  if (spanByDay.size === 1) {
+    /** Cas typique : la session tient dans un seul jour calendaire. On évite l’imprécision
+     * arithmétique liée au prorata et on alloue exactement le total persisté. */
+    const [k] = spanByDay.keys();
+    return new Map([[k, persistedTotal]]);
+  }
+  const out = new Map<string, number>();
+  for (const [day, dayMin] of spanByDay) {
+    const ratio = dayMin / totalSpanMin;
+    const allocated = persistedTotal * ratio;
+    if (allocated > 0) {
+      out.set(day, allocated);
+    }
+  }
+  return out;
+}
+
+/**
+ * Minutes d’une tâche (`durationMs`) ventilées par jour calendaire local, **au prorata** de la
+ * fraction du segment `[startTime, endTime]` tombant dans chaque jour. Pour les tâches qui
+ * tiennent dans un seul jour, tout va dans ce jour ; sinon le découpage minuit est respecté.
+ *
+ * Renvoie `null` si on n’a pas de segment utilisable — l’appelant peut alors retomber sur
+ * la stratégie « jour de fin de tâche » (`endTime ?? startTime`).
+ */
+export function taskMinutesByDayInTimeZone(
+  task: LooseTask,
+  timeZone: string,
+): Map<string, number> | null {
+  const interval = parseTaskIntervalMs(task);
+  if (!interval) {
+    return null;
+  }
+  const [startMs, endMs] = interval;
+  const spanByDay = splitMinutesByCalendarDay(startMs, endMs, timeZone);
+  if (spanByDay.size === 0) {
+    return null;
+  }
+  const totalSpanMin = (endMs - startMs) / 60000;
+  const persistedMin = (task.durationMs ?? 0) / 60000;
+  if (persistedMin <= 0 || totalSpanMin <= 0) {
+    return null;
+  }
+  if (spanByDay.size === 1) {
+    const [k] = spanByDay.keys();
+    return new Map([[k, persistedMin]]);
+  }
+  const out = new Map<string, number>();
+  for (const [day, dayMin] of spanByDay) {
+    const allocated = persistedMin * (dayMin / totalSpanMin);
+    if (allocated > 0) {
+      out.set(day, allocated);
+    }
+  }
+  return out;
+}
+
+/**
+ * Découpe l’intervalle wall `[startTime, endTime]` d’une tâche aux frontières minuit (jour
+ * calendaire local) et renvoie pour chaque jour la liste des sous-intervalles `[start, end]` en
+ * millisecondes UTC. Sert à calculer correctement la durée non concurrente (union d’intervalles)
+ * par jour quand des tâches se chevauchent et qu’une partie traverse minuit.
+ */
+export function taskIntervalsByDayInTimeZone(
+  task: LooseTask,
+  timeZone: string,
+): Map<string, Array<[number, number]>> {
+  const out = new Map<string, Array<[number, number]>>();
+  const interval = parseTaskIntervalMs(task);
+  if (!interval) {
+    return out;
+  }
+  const [startMs, endMs] = interval;
+  let cursor = startMs;
+  /** Garde-fou : même borne que `splitMinutesByCalendarDay`. */
+  const maxDays = 366 * 5;
+  for (let i = 0; i < maxDays && cursor < endMs; i += 1) {
+    const dayKey = calendarDateKeyInTimeZone(new Date(cursor).toISOString(), timeZone);
+    if (!dayKey) {
+      return new Map();
+    }
+    const [yStr, mStr, dStr] = dayKey.split("-");
+    const y = Number.parseInt(yStr, 10);
+    const m = Number.parseInt(mStr, 10);
+    const d = Number.parseInt(dStr, 10);
+    if (!Number.isFinite(y) || !Number.isFinite(m) || !Number.isFinite(d)) {
+      return new Map();
+    }
+    const nextDayStart = calendarDayStartUtcMsInTimeZone(y, m, d + 1, timeZone);
+    const sliceEnd = Math.min(endMs, nextDayStart);
+    if (sliceEnd <= cursor) {
+      break;
+    }
+    const list = out.get(dayKey) ?? [];
+    list.push([cursor, sliceEnd]);
+    out.set(dayKey, list);
+    cursor = sliceEnd;
+  }
+  return out;
+}
+
+function mergeIntervalsToMinutes(intervals: Array<[number, number]>): number {
+  if (intervals.length === 0) {
+    return 0;
+  }
+  const sorted = [...intervals].sort((a, b) => a[0] - b[0]);
+  let [curStart, curEnd] = sorted[0];
+  let totalMs = 0;
+  for (let i = 1; i < sorted.length; i += 1) {
+    const [s, e] = sorted[i];
+    if (s <= curEnd) {
+      if (e > curEnd) {
+        curEnd = e;
+      }
+      continue;
+    }
+    totalMs += Math.max(0, curEnd - curStart);
+    curStart = s;
+    curEnd = e;
+  }
+  totalMs += Math.max(0, curEnd - curStart);
+  return totalMs / 60000;
+}
+
 function uniqueTaskTagEntries(
   task: LooseTask,
   fallbackTagDisplay: string
@@ -275,7 +491,12 @@ export function aggregateTagTaskMinutesByDayAndWeek(
   /** Libellé pour l’étiquette réservée « sans étiquette » / `default` (ex. « default » ou « défaut » selon la langue). */
   fallbackTaskTagDisplay: string,
   /** Lorsque `false`, les tâches sans étiquette sont ventilées sous la clé vide (pas `default`). */
-  defaultTagBucketEnabled: boolean = true
+  defaultTagBucketEnabled: boolean = true,
+  /**
+   * Limite les tâches comptées : `all` (défaut) = tout, `work` = hors `personalProject`,
+   * `personal` = uniquement tâches avec `personalProject: true`.
+   */
+  taskProjectScope: ReportingTaskProjectScope = "all",
 ): { byDay: ReportingTagTimeDayRow[]; byWeek: ReportingTagTimeWeekRow[] } {
   const byTagDay = new Map<string, Map<string, number>>();
   const byTagWeek = new Map<string, Map<string, number>>();
@@ -321,37 +542,53 @@ export function aggregateTagTaskMinutesByDayAndWeek(
       if (!taskIncludedInReportingTaskMetrics(s, t)) {
         continue;
       }
-      const taskDay = calendarDateKeyInTimeZone(t.endTime ?? t.startTime, timeZone);
-      if (!unbounded && !dayInRange(taskDay, dateFrom, dateTo)) {
+      if (!taskMatchesReportingProjectScope(t, taskProjectScope)) {
         continue;
       }
-      const taskBucket = taskDay ?? (unbounded ? UNDATED_KEY : null);
-      if (!taskBucket) {
+
+      /* Ventilation par jour calendaire (prorata du segment `[startTime, endTime]`) avec repli
+       * sur le jour de fin de tâche pour les tâches sans bornes utilisables (durée 0,
+       * `startTime`/`endTime` manquants). */
+      const splitMinutes = taskMinutesByDayInTimeZone(t, timeZone);
+      const distribution: Array<{ day: string; minutes: number }> = (() => {
+        if (splitMinutes && splitMinutes.size > 0) {
+          return [...splitMinutes].map(([day, minutes]) => ({ day, minutes }));
+        }
+        const fallbackDay = calendarDateKeyInTimeZone(t.endTime ?? t.startTime, timeZone);
+        const bucket = fallbackDay ?? (unbounded ? UNDATED_KEY : null);
+        const mins = (t.durationMs ?? 0) / 60000;
+        if (!bucket || mins <= 0) {
+          return [];
+        }
+        return [{ day: bucket, minutes: mins }];
+      })();
+      if (distribution.length === 0) {
         continue;
       }
 
-      const mins = (t.durationMs ?? 0) / 60000;
-      if (mins <= 0) {
+      const inRange = distribution.filter(({ day }) => unbounded || dayInRange(day, dateFrom, dateTo));
+      if (inRange.length === 0) {
         continue;
       }
 
       const entries = uniqueTaskTagEntries(t, fallbackTaskTagDisplay);
-      const weekStart =
-        taskBucket !== UNDATED_KEY
-          ? localWeekStartKeyFromDayKey(taskBucket, weekStartsOn)
-          : null;
-
-      if (entries.length === 0) {
-        const fallbackKey = defaultTagBucketEnabled ? DEFAULT_FALLBACK_TASK_TAG : "";
-        addDay(fallbackKey, fallbackTaskTagDisplay, taskBucket, mins);
-        if (weekStart) {
-          addWeek(fallbackKey, weekStart, mins);
+      const tagKeyList: Array<{ key: string; display: string }> =
+        entries.length === 0
+          ? [{
+              key: defaultTagBucketEnabled ? DEFAULT_FALLBACK_TASK_TAG : "",
+              display: fallbackTaskTagDisplay,
+            }]
+          : entries;
+
+      for (const { day, minutes } of inRange) {
+        if (minutes <= 0) {
+          continue;
         }
-      } else {
-        for (const e of entries) {
-          addDay(e.key, e.display, taskBucket, mins);
+        const weekStart = day !== UNDATED_KEY ? localWeekStartKeyFromDayKey(day, weekStartsOn) : null;
+        for (const e of tagKeyList) {
+          addDay(e.key, e.display, day, minutes);
           if (weekStart) {
-            addWeek(e.key, weekStart, mins);
+            addWeek(e.key, weekStart, minutes);
           }
         }
       }
@@ -399,6 +636,8 @@ export type ReportingResult = {
   tasksByDayActive: Record<string, number>;
   /** Minutes enregistrées sur les tâches (durationMs), par jour de tâche. */
   taskMinutesByDay: Record<string, number>;
+  /** Minutes non concurrentes (union des intervalles start/end), par jour de tâche. */
+  nonConcurrentTaskMinutesByDay: Record<string, number>;
   /** Minutes de codage session (codingMinutesSession), par jour de session. */
   sessionCodingMinutesByDay: Record<string, number>;
   /**
@@ -432,8 +671,22 @@ export type ReportingResult = {
    * ou `null` si aucune.
    */
   assiduityAverageLateMinutesWhenLate: number | null;
+  /**
+   * Comptage des sessions dans la plage par type de clôture enregistré (`planned` / `early` / …).
+   * Clé `unspecified` : pas de catégorie valide (session ouverte, ou clôture sans choix).
+   */
+  sessionCountByClosureKind: Record<string, number>;
 };
 
+/** Ordre d’affichage des lignes « sessions par type de clôture » dans les rapports. */
+export const REPORTING_SESSION_CLOSURE_DISPLAY_ORDER = [
+  "planned",
+  "early",
+  "overrun",
+  "other",
+  "unspecified",
+] as const;
+
 export function aggregateReporting(
   sessions: LooseSession[],
   selectedTagKeys: Set<string>,
@@ -447,8 +700,10 @@ export function aggregateReporting(
   const tasksByDayDone: Record<string, number> = {};
   const tasksByDayActive: Record<string, number> = {};
   const taskMinutesByDay: Record<string, number> = {};
+  const nonConcurrentTaskMinutesByDay: Record<string, number> = {};
   const sessionCodingMinutesByDay: Record<string, number> = {};
   const sessionWallClockMinutesByDay: Record<string, number> = {};
+  const taskIntervalsByDay = new Map<string, Array<[number, number]>>();
 
   let kronoFocusSessionsCompleted = 0;
   let kronoFocusTasksUsedCount = 0;
@@ -467,9 +722,27 @@ export function aggregateReporting(
   let assiduityReferenceSessionCount = 0;
   let assiduityLateSessionCount = 0;
   let assiduityLateMinutesTotal = 0;
+  const sessionCountByClosureKind: Record<string, number> = {};
 
   const unbounded = !dateFrom && !dateTo;
 
+  /**
+   * Ajoute des minutes à un agrégat jour-par-jour en respectant le filtre de plage.
+   */
+  const addInRange = (
+    target: Record<string, number>,
+    day: string,
+    minutes: number,
+  ): void => {
+    if (minutes <= 0) {
+      return;
+    }
+    if (!unbounded && !dayInRange(day, dateFrom, dateTo)) {
+      return;
+    }
+    target[day] = (target[day] ?? 0) + minutes;
+  };
+
   for (const s of sessions) {
     const allTasks = collectTasksDeduped(s);
     const matching = allTasks.filter((t) => taskMatchesTags(t, selectedTagKeys, defaultTagBucketEnabled));
@@ -480,29 +753,23 @@ export function aggregateReporting(
     const sessionDay = calendarDateKeyInTimeZone(s.savedAt ?? s.endAt ?? s.startAt, timeZone);
     const sessionRangeOk = unbounded || dayInRange(sessionDay, dateFrom, dateTo);
 
+    /* Métriques attribuées au jour de clôture (compte de sessions, type de clôture, lignes,
+     * assiduité, compteurs KronoFocus) : on continue à utiliser `sessionDay` comme bucket
+     * unique — cohérent avec « 1 session = 1 jour de clôture ». */
     if (sessionRangeOk) {
+      const rk = normalizeSessionEndReasonKind(s.sessionEndReasonKind);
+      const closureBucket = rk || "unspecified";
+      sessionCountByClosureKind[closureBucket] =
+        (sessionCountByClosureKind[closureBucket] ?? 0) + 1;
       const sessionBucket = sessionDay ?? (unbounded ? UNDATED_KEY : null);
       if (sessionBucket) {
         sessionsByDay[sessionBucket] = (sessionsByDay[sessionBucket] ?? 0) + 1;
-        const cm = s.codingMinutesSession ?? 0;
-        if (cm > 0) {
-          sessionCodingMinutesByDay[sessionBucket] =
-            (sessionCodingMinutesByDay[sessionBucket] ?? 0) + cm;
-        }
-        const wm = sessionWallClockMinutes(s);
-        if (wm > 0) {
-          sessionWallClockMinutesByDay[sessionBucket] =
-            (sessionWallClockMinutesByDay[sessionBucket] ?? 0) + wm;
-        }
       }
       sessionCountContributing += 1;
       const sc = s.kronoFocus?.sessionsCompleted;
       if (typeof sc === "number" && sc > 0) {
         kronoFocusSessionsCompleted += sc;
       }
-      sessionCodingMinutesTotal += s.codingMinutesSession ?? 0;
-      sessionActiveMinutesTotal += s.activeMinutes ?? 0;
-      sessionWallClockMinutesTotal += sessionWallClockMinutes(s);
       if (typeof s.linesWrittenTotal === "number") {
         linesWrittenTotalSum += s.linesWrittenTotal;
       }
@@ -514,7 +781,10 @@ export function aggregateReporting(
       }
       mergeTupleMap(locByLanguageAcc, s.locByLanguage);
       mergeTupleMap(codingSignalsAcc, s.codingSignalsByLanguage);
-      if (typeof s.sessionStartOffsetMinutes === "number" && Number.isFinite(s.sessionStartOffsetMinutes)) {
+      if (
+        typeof s.sessionStartOffsetMinutes === "number"
+        && Number.isFinite(s.sessionStartOffsetMinutes)
+      ) {
         assiduityReferenceSessionCount += 1;
         if (s.sessionStartOffsetMinutes > 0) {
           assiduityLateSessionCount += 1;
@@ -523,30 +793,125 @@ export function aggregateReporting(
       }
     }
 
+    /* Durée murale et codage session : ventilation par jour calendaire local en répartissant
+     * le total persisté au prorata du temps mural écoulé chaque jour (sessions à cheval sur
+     * minuit). Si le découpage est impossible (orpheline sans `savedAt` valide), on retombe
+     * sur l’ancien comportement « tout sur le jour de clôture ». */
+    const wallByDay = sessionWallMinutesByDay(s, timeZone);
+    if (wallByDay.size > 0) {
+      let wallAllocated = 0;
+      for (const v of wallByDay.values()) {
+        wallAllocated += v;
+      }
+      const codingTotal = s.codingMinutesSession ?? 0;
+      const activeTotal = s.activeMinutes ?? 0;
+      for (const [day, dayWallMin] of wallByDay) {
+        if (!unbounded && !dayInRange(day, dateFrom, dateTo)) {
+          continue;
+        }
+        sessionWallClockMinutesByDay[day] =
+          (sessionWallClockMinutesByDay[day] ?? 0) + dayWallMin;
+        sessionWallClockMinutesTotal += dayWallMin;
+        const ratio = wallAllocated > 0 ? dayWallMin / wallAllocated : 0;
+        if (codingTotal > 0) {
+          const allocCoding = codingTotal * ratio;
+          if (allocCoding > 0) {
+            sessionCodingMinutesByDay[day] =
+              (sessionCodingMinutesByDay[day] ?? 0) + allocCoding;
+            sessionCodingMinutesTotal += allocCoding;
+          }
+        }
+        if (activeTotal > 0) {
+          sessionActiveMinutesTotal += activeTotal * ratio;
+        }
+      }
+    } else if (sessionRangeOk && sessionDay) {
+      /* Repli : pas de span exploitable (rare). On préserve le comportement historique pour
+       * ne pas perdre la session du compte « total » à cause d’un défaut de bornes. */
+      const wm = sessionWallClockMinutes(s);
+      if (wm > 0) {
+        sessionWallClockMinutesByDay[sessionDay] =
+          (sessionWallClockMinutesByDay[sessionDay] ?? 0) + wm;
+        sessionWallClockMinutesTotal += wm;
+      }
+      const cm = s.codingMinutesSession ?? 0;
+      if (cm > 0) {
+        sessionCodingMinutesByDay[sessionDay] =
+          (sessionCodingMinutesByDay[sessionDay] ?? 0) + cm;
+        sessionCodingMinutesTotal += cm;
+      }
+      sessionActiveMinutesTotal += s.activeMinutes ?? 0;
+    }
+
     for (const t of matching) {
       if (!taskIncludedInReportingTaskMetrics(s, t)) {
         continue;
       }
-      const taskDay = calendarDateKeyInTimeZone(t.endTime ?? t.startTime, timeZone);
-      if (!unbounded && !dayInRange(taskDay, dateFrom, dateTo)) {
-        continue;
-      }
-      const taskBucket = taskDay ?? (unbounded ? UNDATED_KEY : null);
-      if (!taskBucket) {
+
+      /* Ventilation des minutes de tâche par jour : prorata du segment `[startTime, endTime]` ;
+       * repli sur le jour de fin de tâche si on n’a pas de bornes utilisables (tâche sans
+       * `endTime` finie, durée 0, etc.). */
+      const taskMinByDay = taskMinutesByDayInTimeZone(t, timeZone);
+      const taskCountedDay = (() => {
+        if (taskMinByDay) {
+          for (const day of taskMinByDay.keys()) {
+            if (unbounded || dayInRange(day, dateFrom, dateTo)) {
+              return day;
+            }
+          }
+          return null;
+        }
+        const fallbackDay = calendarDateKeyInTimeZone(t.endTime ?? t.startTime, timeZone);
+        if (!fallbackDay) {
+          return unbounded ? UNDATED_KEY : null;
+        }
+        if (!unbounded && !dayInRange(fallbackDay, dateFrom, dateTo)) {
+          return null;
+        }
+        return fallbackDay;
+      })();
+
+      if (taskCountedDay === null) {
         continue;
       }
 
       taskCountContributing += 1;
-      const mins = (t.durationMs ?? 0) / 60000;
-      taskMinutesTotal += mins;
-      if (mins > 0) {
-        taskMinutesByDay[taskBucket] = (taskMinutesByDay[taskBucket] ?? 0) + mins;
+      if (t.isDone === true) {
+        tasksByDayDone[taskCountedDay] = (tasksByDayDone[taskCountedDay] ?? 0) + 1;
+      } else {
+        tasksByDayActive[taskCountedDay] = (tasksByDayActive[taskCountedDay] ?? 0) + 1;
       }
 
-      if (t.isDone === true) {
-        tasksByDayDone[taskBucket] = (tasksByDayDone[taskBucket] ?? 0) + 1;
+      if (taskMinByDay) {
+        for (const [day, mins] of taskMinByDay) {
+          addInRange(taskMinutesByDay, day, mins);
+          if (unbounded || dayInRange(day, dateFrom, dateTo)) {
+            taskMinutesTotal += mins;
+          }
+        }
       } else {
-        tasksByDayActive[taskBucket] = (tasksByDayActive[taskBucket] ?? 0) + 1;
+        /* Repli sans bornes : tout sur le jour de fin (UNDATED si plage ouverte). */
+        const mins = (t.durationMs ?? 0) / 60000;
+        if (mins > 0) {
+          addInRange(taskMinutesByDay, taskCountedDay, mins);
+          if (unbounded || dayInRange(taskCountedDay, dateFrom, dateTo)) {
+            taskMinutesTotal += mins;
+          }
+        }
+      }
+
+      /* Intervalles non concurrents : on découpe à minuit pour que le merge par jour reflète
+       * correctement la fraction tombant dans chaque journée. */
+      const splitIntervals = taskIntervalsByDayInTimeZone(t, timeZone);
+      for (const [day, intervals] of splitIntervals) {
+        if (!unbounded && !dayInRange(day, dateFrom, dateTo)) {
+          continue;
+        }
+        const list = taskIntervalsByDay.get(day) ?? [];
+        for (const iv of intervals) {
+          list.push(iv);
+        }
+        taskIntervalsByDay.set(day, list);
       }
 
       const tr = t as Record<string, unknown>;
@@ -566,6 +931,12 @@ export function aggregateReporting(
   }
 
   const locByLanguageMerged = [...locByLanguageAcc.entries()].sort((a, b) => b[1] - a[1]);
+  for (const [bucket, intervals] of taskIntervalsByDay) {
+    const unionMinutes = mergeIntervalsToMinutes(intervals);
+    if (unionMinutes > 0) {
+      nonConcurrentTaskMinutesByDay[bucket] = unionMinutes;
+    }
+  }
   const codingSignalsByLanguageMerged = [...codingSignalsAcc.entries()].sort((a, b) => b[1] - a[1]);
   const assiduityAverageLateMinutesWhenLate =
     assiduityLateSessionCount > 0 ? assiduityLateMinutesTotal / assiduityLateSessionCount : null;
@@ -575,6 +946,7 @@ export function aggregateReporting(
     tasksByDayDone,
     tasksByDayActive,
     taskMinutesByDay,
+    nonConcurrentTaskMinutesByDay,
     sessionCodingMinutesByDay,
     sessionWallClockMinutesByDay,
     kronoFocusSessionsCompleted,
@@ -595,6 +967,7 @@ export function aggregateReporting(
     assiduityLateSessionCount,
     assiduityLateMinutesTotal,
     assiduityAverageLateMinutesWhenLate,
+    sessionCountByClosureKind,
   };
 }
 
@@ -625,7 +998,7 @@ function compareProjectKeyForSort(a: string, b: string): number {
 }
 
 /**
- * Temps enregistré sur les tâches (`durationMs`) par `@projet` et par jour de tâche (mêmes filtres que le tableau projet agrégé).
+ * Temps enregistré sur les tâches (`durationMs`) par projet (`@` productif ou `!` personnel selon le filtre) et par jour de tâche.
  */
 export function aggregateProjectTaskMinutesByDay(
   sessions: LooseSession[],
@@ -633,7 +1006,9 @@ export function aggregateProjectTaskMinutesByDay(
   dateFrom: string | null,
   dateTo: string | null,
   timeZone: string,
-  defaultTagBucketEnabled: boolean = true
+  defaultTagBucketEnabled: boolean = true,
+  /** Par défaut `work` : agrégat des projets `@` (hors temps personnel `!`). */
+  taskProjectScope: ReportingTaskProjectScope = "work",
 ): ReportingProjectTimeDayRow[] {
   const byProjDay = new Map<string, Map<string, number>>();
   const displayByProj = new Map<string, string>();
@@ -650,30 +1025,49 @@ export function aggregateProjectTaskMinutesByDay(
       if (!taskIncludedInReportingTaskMetrics(s, t)) {
         continue;
       }
-      const taskDay = calendarDateKeyInTimeZone(t.endTime ?? t.startTime, timeZone);
-      if (!unbounded && !dayInRange(taskDay, dateFrom, dateTo)) {
-        continue;
-      }
-      const taskBucket = taskDay ?? (unbounded ? UNDATED_KEY : null);
-      if (!taskBucket) {
+      if (!taskMatchesReportingProjectScope(t, taskProjectScope)) {
         continue;
       }
 
-      const mins = (t.durationMs ?? 0) / 60000;
-      if (mins <= 0) {
+      const splitMinutes = taskMinutesByDayInTimeZone(t, timeZone);
+      const distribution: Array<{ day: string; minutes: number }> = (() => {
+        if (splitMinutes && splitMinutes.size > 0) {
+          return [...splitMinutes].map(([day, minutes]) => ({ day, minutes }));
+        }
+        const fallbackDay = calendarDateKeyInTimeZone(t.endTime ?? t.startTime, timeZone);
+        const bucket = fallbackDay ?? (unbounded ? UNDATED_KEY : null);
+        const mins = (t.durationMs ?? 0) / 60000;
+        if (!bucket || mins <= 0) {
+          return [];
+        }
+        return [{ day: bucket, minutes: mins }];
+      })();
+      if (distribution.length === 0) {
         continue;
       }
 
       const raw = typeof t.project === "string" ? t.project.trim() : "";
-      const key = raw ? normalizeProjectKey(raw).toLowerCase() : "";
-      let inner = byProjDay.get(key);
-      if (!inner) {
-        inner = new Map();
-        byProjDay.set(key, inner);
+      if (taskProjectScope === "personal" && !raw) {
+        continue;
       }
-      inner.set(taskBucket, (inner.get(taskBucket) ?? 0) + mins);
-      if (raw && !displayByProj.has(key)) {
-        displayByProj.set(key, formatProjectDisplay(raw));
+      const key = raw ? normalizeProjectKey(raw).toLowerCase() : "";
+      const displayOpts = taskProjectScope === "personal" ? ({ personal: true } as const) : undefined;
+      for (const { day, minutes } of distribution) {
+        if (!unbounded && !dayInRange(day, dateFrom, dateTo)) {
+          continue;
+        }
+        if (minutes <= 0) {
+          continue;
+        }
+        let inner = byProjDay.get(key);
+        if (!inner) {
+          inner = new Map();
+          byProjDay.set(key, inner);
+        }
+        inner.set(day, (inner.get(day) ?? 0) + minutes);
+        if (raw && !displayByProj.has(key)) {
+          displayByProj.set(key, formatProjectDisplay(raw, displayOpts));
+        }
       }
     }
   }
@@ -686,7 +1080,8 @@ export function aggregateProjectTaskMinutesByDay(
         displayProject:
           projectKey === ""
             ? ""
-            : (displayByProj.get(projectKey) ?? formatProjectDisplay(projectKey)),
+            : (displayByProj.get(projectKey) ??
+              formatProjectDisplay(projectKey, taskProjectScope === "personal" ? { personal: true } : undefined)),
         day,
         minutes,
       });
@@ -747,14 +1142,28 @@ export function aggregateReportingByProject(
   dateFrom: string | null,
   dateTo: string | null,
   timeZone: string,
-  defaultTagBucketEnabled: boolean = true
+  defaultTagBucketEnabled: boolean = true,
+  /** Par défaut `work` : projets `@` (hors temps personnel `!`). */
+  taskProjectScope: ReportingTaskProjectScope = "work",
 ): ReportingProjectRow[] {
   const byKey = new Map<string, { label: string; minutes: number; count: number }>();
   const unbounded = !dateFrom && !dateTo;
+  const displayOpts = taskProjectScope === "personal" ? ({ personal: true } as const) : undefined;
 
-  const bump = (key: string, label: string, mins: number) => {
+  const bumpMinutes = (key: string, label: string, mins: number): void => {
+    if (mins <= 0) {
+      return;
+    }
     const cur = byKey.get(key) ?? { label, minutes: 0, count: 0 };
     cur.minutes += mins;
+    if (label && !cur.label) {
+      cur.label = label;
+    }
+    byKey.set(key, cur);
+  };
+
+  const bumpCount = (key: string, label: string): void => {
+    const cur = byKey.get(key) ?? { label, minutes: 0, count: 0 };
     cur.count += 1;
     if (label && !cur.label) {
       cur.label = label;
@@ -773,14 +1182,47 @@ export function aggregateReportingByProject(
       if (!taskIncludedInReportingTaskMetrics(s, t)) {
         continue;
       }
-      const taskDay = calendarDateKeyInTimeZone(t.endTime ?? t.startTime, timeZone);
-      if (!unbounded && !dayInRange(taskDay, dateFrom, dateTo)) {
+      if (!taskMatchesReportingProjectScope(t, taskProjectScope)) {
         continue;
       }
+
+      const splitMinutes = taskMinutesByDayInTimeZone(t, timeZone);
+      const distribution: Array<{ day: string; minutes: number }> = (() => {
+        if (splitMinutes && splitMinutes.size > 0) {
+          return [...splitMinutes].map(([day, minutes]) => ({ day, minutes }));
+        }
+        const fallbackDay = calendarDateKeyInTimeZone(t.endTime ?? t.startTime, timeZone);
+        const bucket = fallbackDay ?? (unbounded ? UNDATED_KEY : null);
+        const mins = (t.durationMs ?? 0) / 60000;
+        if (!bucket) {
+          return [];
+        }
+        return [{ day: bucket, minutes: mins }];
+      })();
+      if (distribution.length === 0) {
+        continue;
+      }
+
       const raw = typeof t.project === "string" ? t.project.trim() : "";
+      if (taskProjectScope === "personal" && !raw) {
+        continue;
+      }
       const key = raw ? normalizeProjectKey(raw).toLowerCase() : "";
-      const mins = (t.durationMs ?? 0) / 60000;
-      bump(key, formatProjectDisplay(raw), mins);
+      const label = formatProjectDisplay(raw, displayOpts);
+
+      let counted = false;
+      for (const { day, minutes } of distribution) {
+        if (!unbounded && !dayInRange(day, dateFrom, dateTo)) {
+          continue;
+        }
+        bumpMinutes(key, label, minutes);
+        if (!counted) {
+          /* Une tâche traversant minuit n’est comptée qu’une fois dans `taskCount`, sur le
+           * premier jour en plage : conserve la sémantique « 1 tâche = 1 contribution ». */
+          bumpCount(key, label);
+          counted = true;
+        }
+      }
     }
   }