@nightkatana/kronosys-app 1.0.0-beta.0

package/lib/reportingAggregate.ts

@@ -0,0 +1,819 @@
+import {
+  DEFAULT_FALLBACK_TASK_TAG,
+  formatProjectDisplay,
+  formatTagDisplay,
+  isFallbackTaskTagKey,
+  normalizeProjectKey,
+  normalizeTagKey,
+} from "./taskParsing";
+import type { KronosysUpdatePayload } from "./kronosysApi";
+import { LEGACY_TASK_CYCLES_KEY, LEGACY_TASK_USED_FLAG_KEY } from "./legacyKronoFocusStorageKeys";
+import { calendarDateKeyInTimeZone } from "./dashboardTimeZone";
+import {
+  localWeekStartKeyFromDayKey,
+  type ReportingWeekStartsOn,
+} from "./reportingWeekLayout";
+
+export type LooseTask = {
+  id?: string;
+  startTime?: string;
+  endTime?: string;
+  durationMs?: number;
+  isDone?: boolean;
+  usedKronoFocus?: boolean;
+  kronoFocusCycles?: number;
+  tags?: string[];
+  project?: string | null;
+  subtasks?: Array<{ done?: boolean }>;
+};
+
+export type LooseSession = {
+  sessionId: string;
+  savedAt?: string;
+  startAt?: string | null;
+  endAt?: string | null;
+  /** Fenêtre d’ouverture de session (premier → dernier événement), en minutes — voir {@link sessionWallClockMinutes}. */
+  sessionDurationMinutes?: number;
+  archived?: boolean;
+  codingMinutesSession?: number;
+  activeMinutes?: number;
+  linesWrittenTotal?: number;
+  linesWrittenHuman?: number;
+  linesWrittenAi?: number;
+  locByLanguage?: Array<[string, number]>;
+  codingSignalsByLanguage?: Array<[string, number]>;
+  kronoFocus?: { sessionsCompleted?: number };
+  tasks?: LooseTask[];
+  activeTasks?: LooseTask[];
+  activeTask?: LooseTask | null;
+  /**
+   * Heure de début de référence (ISO) fournie à la création, si l’hôte a indiqué une
+   * planification (horaire, session planifiée, etc.).
+   */
+  scheduledStartAt?: string | null;
+  /**
+   * `startAt` effectif moins l’heure de référence, en minutes (positif = retard).
+   * Présent seulement si `scheduledStartAt` a été enregistré.
+   */
+  sessionStartOffsetMinutes?: number | null;
+};
+
+export function mergeSessionsFromPayload(payload: KronosysUpdatePayload): LooseSession[] {
+  const map = new Map<string, LooseSession>();
+  const archived = (payload.historyArchived || []) as LooseSession[];
+  const hist = (payload.history || []) as LooseSession[];
+  for (const s of archived) {
+    if (s.sessionId) {
+      map.set(s.sessionId, s);
+    }
+  }
+  for (const s of hist) {
+    if (s.sessionId) {
+      map.set(s.sessionId, s);
+    }
+  }
+  const cur = payload.current as LooseSession | undefined;
+  if (cur?.sessionId) {
+    map.set(cur.sessionId, cur);
+  }
+  return [...map.values()];
+}
+
+export function collectTasksDeduped(s: LooseSession): LooseTask[] {
+  const list: LooseTask[] = [...(s.tasks || [])];
+  const ids = new Set(
+    list.map((t) => t.id).filter((id): id is string => typeof id === "string" && id.length > 0)
+  );
+  const actives =
+    Array.isArray(s.activeTasks) && s.activeTasks.length > 0
+      ? s.activeTasks
+      : s.activeTask
+        ? [s.activeTask]
+        : [];
+  for (const at of actives) {
+    const aid = at.id;
+    if (aid && !ids.has(aid)) {
+      list.push(at);
+      ids.add(aid);
+    }
+  }
+  return list;
+}
+
+export function buildTagFilterSet(selectedTags: string[]): Set<string> {
+  const set = new Set<string>();
+  for (const t of selectedTags) {
+    const k = normalizeTagKey(t).toLowerCase();
+    if (k) {
+      set.add(k);
+    }
+  }
+  return set;
+}
+
+export function taskMatchesTags(
+  task: LooseTask,
+  filter: Set<string>,
+  defaultTagBucketEnabled: boolean = true
+): boolean {
+  if (filter.size === 0) {
+    return true;
+  }
+  const tags = task.tags || [];
+  const keys = tags
+    .map((t) => normalizeTagKey(String(t)).toLowerCase())
+    .filter((k) => k.length > 0);
+  const effective =
+    keys.length > 0 ? keys : defaultTagBucketEnabled ? [DEFAULT_FALLBACK_TASK_TAG] : [];
+  return effective.some((k) => filter.has(k));
+}
+
+/**
+ * Sessions archivées : les métriques basées sur les tâches n’incluent que le travail
+ * entièrement bouclé (tâche terminée et toutes les sous-tâches cochées, s’il y en a).
+ */
+export function taskCountsTowardArchivedSessionReporting(task: LooseTask): boolean {
+  if (task.isDone !== true) {
+    return false;
+  }
+  const subs = task.subtasks;
+  if (subs && subs.length > 0) {
+    return subs.every((st) => st.done === true);
+  }
+  return true;
+}
+
+function taskIncludedInReportingTaskMetrics(session: LooseSession, task: LooseTask): boolean {
+  if (session.archived === true) {
+    return taskCountsTowardArchivedSessionReporting(task);
+  }
+  return true;
+}
+
+function mergeTupleMap(target: Map<string, number>, raw: unknown): void {
+  if (!Array.isArray(raw)) {
+    return;
+  }
+  for (const item of raw) {
+    if (!Array.isArray(item) || item.length < 2) {
+      continue;
+    }
+    const k = item[0];
+    const v = item[1];
+    if (typeof k !== "string" || typeof v !== "number") {
+      continue;
+    }
+    target.set(k, (target.get(k) ?? 0) + v);
+  }
+}
+
+export const UNDATED_KEY = "undated";
+
+export function dayInRange(day: string | null, from: string | null, to: string | null): boolean {
+  if (!from && !to) {
+    return true;
+  }
+  if (!day) {
+    return false;
+  }
+  if (from && day < from) {
+    return false;
+  }
+  if (to && day > to) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Lundi (date locale) de la semaine calendaire contenant `dayKey` — identique à {@link localWeekStartKeyFromDayKey}(…, `"monday"`).
+ */
+export function localWeekMondayFromDayKey(dayKey: string): string | null {
+  return localWeekStartKeyFromDayKey(dayKey, "monday");
+}
+
+/**
+ * Durée « murale » de la session : valeur persistée si disponible, sinon écart entre `startAt` et `endAt` (minutes).
+ */
+export function sessionWallClockMinutes(s: LooseSession): number {
+  const persisted = s.sessionDurationMinutes;
+  if (typeof persisted === "number" && Number.isFinite(persisted) && persisted > 0) {
+    return persisted;
+  }
+  const start = s.startAt ? Date.parse(s.startAt) : NaN;
+  const end = s.endAt ? Date.parse(s.endAt) : NaN;
+  if (Number.isFinite(start) && Number.isFinite(end) && end > start) {
+    return (end - start) / 60000;
+  }
+  return 0;
+}
+
+function uniqueTaskTagEntries(
+  task: LooseTask,
+  fallbackTagDisplay: string
+): Array<{ key: string; display: string }> {
+  const tags = task.tags ?? [];
+  const seen = new Set<string>();
+  const out: Array<{ key: string; display: string }> = [];
+  for (const raw of tags) {
+    const token = normalizeTagKey(String(raw)).trim();
+    if (!token) {
+      continue;
+    }
+    const key = token.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    const display =
+      key === DEFAULT_FALLBACK_TASK_TAG ? fallbackTagDisplay : formatTagDisplay(token);
+    out.push({ key, display });
+  }
+  return out;
+}
+
+function compareTagKeyForSort(a: string, b: string): number {
+  const fa = isFallbackTaskTagKey(a);
+  const fb = isFallbackTaskTagKey(b);
+  if (fa && !fb) {
+    return 1;
+  }
+  if (!fa && fb) {
+    return -1;
+  }
+  return a.localeCompare(b);
+}
+
+export type ReportingTagTimeDayRow = {
+  /** Clé stable (`default` = sans étiquette explicite ; clé vide possible pour données historiques). */
+  tagKey: string;
+  displayTag: string;
+  day: string;
+  minutes: number;
+};
+
+export type ReportingTagTimeWeekRow = {
+  tagKey: string;
+  displayTag: string;
+  /** Premier jour de la semaine (AAAA-MM-JJ, local), selon `weekStartsOn`. */
+  weekStart: string;
+  minutes: number;
+};
+
+/**
+ * Temps enregistré sur les tâches ventilé par étiquette (`#tag`), par jour de tâche et par semaine.
+ * Si une tâche porte plusieurs étiquettes, la durée complète est comptée pour chacune (les sommes par étiquette peuvent donc dépasser le temps réel lorsqu’on les additionne).
+ */
+export function aggregateTagTaskMinutesByDayAndWeek(
+  sessions: LooseSession[],
+  selectedTagKeys: Set<string>,
+  dateFrom: string | null,
+  dateTo: string | null,
+  /** Fuseau IANA pour le jour calendaire des tâches (ex. `America/Toronto`). */
+  timeZone: string,
+  weekStartsOn: ReportingWeekStartsOn,
+  /** 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
+): { byDay: ReportingTagTimeDayRow[]; byWeek: ReportingTagTimeWeekRow[] } {
+  const byTagDay = new Map<string, Map<string, number>>();
+  const byTagWeek = new Map<string, Map<string, number>>();
+  const displayByTag = new Map<string, string>();
+
+  const addDay = (tagKey: string, display: string, day: string, mins: number) => {
+    if (mins <= 0) {
+      return;
+    }
+    let inner = byTagDay.get(tagKey);
+    if (!inner) {
+      inner = new Map();
+      byTagDay.set(tagKey, inner);
+    }
+    inner.set(day, (inner.get(day) ?? 0) + mins);
+    if (display && !displayByTag.has(tagKey)) {
+      displayByTag.set(tagKey, display);
+    }
+  };
+
+  const addWeek = (tagKey: string, weekStart: string, mins: number) => {
+    if (mins <= 0) {
+      return;
+    }
+    let inner = byTagWeek.get(tagKey);
+    if (!inner) {
+      inner = new Map();
+      byTagWeek.set(tagKey, inner);
+    }
+    inner.set(weekStart, (inner.get(weekStart) ?? 0) + mins);
+  };
+
+  const unbounded = !dateFrom && !dateTo;
+
+  for (const s of sessions) {
+    const allTasks = collectTasksDeduped(s);
+    const matching = allTasks.filter((t) => taskMatchesTags(t, selectedTagKeys, defaultTagBucketEnabled));
+    if (selectedTagKeys.size > 0 && matching.length === 0) {
+      continue;
+    }
+
+    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) {
+        continue;
+      }
+
+      const mins = (t.durationMs ?? 0) / 60000;
+      if (mins <= 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);
+        }
+      } else {
+        for (const e of entries) {
+          addDay(e.key, e.display, taskBucket, mins);
+          if (weekStart) {
+            addWeek(e.key, weekStart, mins);
+          }
+        }
+      }
+    }
+  }
+
+  const byDay: ReportingTagTimeDayRow[] = [];
+  for (const [tagKey, inner] of byTagDay) {
+    for (const [day, minutes] of inner) {
+      byDay.push({
+        tagKey,
+        displayTag: isFallbackTaskTagKey(tagKey)
+          ? fallbackTaskTagDisplay
+          : (displayByTag.get(tagKey) ?? formatTagDisplay(tagKey)),
+        day,
+        minutes,
+      });
+    }
+  }
+  byDay.sort((a, b) => a.day.localeCompare(b.day) || compareTagKeyForSort(a.tagKey, b.tagKey));
+
+  const byWeek: ReportingTagTimeWeekRow[] = [];
+  for (const [tagKey, inner] of byTagWeek) {
+    for (const [weekStart, minutes] of inner) {
+      byWeek.push({
+        tagKey,
+        displayTag: isFallbackTaskTagKey(tagKey)
+          ? fallbackTaskTagDisplay
+          : (displayByTag.get(tagKey) ?? formatTagDisplay(tagKey)),
+        weekStart,
+        minutes,
+      });
+    }
+  }
+  byWeek.sort(
+    (a, b) => a.weekStart.localeCompare(b.weekStart) || compareTagKeyForSort(a.tagKey, b.tagKey)
+  );
+
+  return { byDay, byWeek };
+}
+
+export type ReportingResult = {
+  sessionsByDay: Record<string, number>;
+  tasksByDayDone: Record<string, number>;
+  tasksByDayActive: Record<string, number>;
+  /** Minutes enregistrées sur les tâches (durationMs), par jour de tâche. */
+  taskMinutesByDay: Record<string, number>;
+  /** Minutes de codage session (codingMinutesSession), par jour de session. */
+  sessionCodingMinutesByDay: Record<string, number>;
+  /**
+   * Durée « murale » des sessions (sessionDurationMinutes ou startAt→endAt), par jour de session.
+   */
+  sessionWallClockMinutesByDay: Record<string, number>;
+  kronoFocusSessionsCompleted: number;
+  kronoFocusTasksUsedCount: number;
+  kronoFocusTaskCyclesSum: number;
+  taskMinutesTotal: number;
+  sessionCodingMinutesTotal: number;
+  sessionActiveMinutesTotal: number;
+  /** Somme des durées murales des sessions dans la plage (voir {@link sessionWallClockMinutes}). */
+  sessionWallClockMinutesTotal: number;
+  sessionCountContributing: number;
+  taskCountContributing: number;
+  /** Sommes sur les sessions dans la plage (mêmes filtres que les totaux session). */
+  linesWrittenTotalSum: number;
+  linesWrittenHumanSum: number;
+  linesWrittenAiSum: number;
+  locByLanguageMerged: Array<[string, number]>;
+  codingSignalsByLanguageMerged: Array<[string, number]>;
+  /** Sessions dont l’hôte a enregistré une heure de référence (même règles de plage / étiquettes). */
+  assiduityReferenceSessionCount: number;
+  /** Parmi elles, sessions commencées après l’heure de référence (`sessionStartOffsetMinutes` > 0). */
+  assiduityLateSessionCount: number;
+  /** Somme des retards (minutes), compte seulement la partie > 0 par session. */
+  assiduityLateMinutesTotal: number;
+  /**
+   * Moyenne des retards (minutes) sur les seules sessions en retard dans la plage,
+   * ou `null` si aucune.
+   */
+  assiduityAverageLateMinutesWhenLate: number | null;
+};
+
+export function aggregateReporting(
+  sessions: LooseSession[],
+  selectedTagKeys: Set<string>,
+  dateFrom: string | null,
+  dateTo: string | null,
+  /** Fuseau IANA pour le jour calendaire des sessions et des tâches. */
+  timeZone: string,
+  defaultTagBucketEnabled: boolean = true
+): ReportingResult {
+  const sessionsByDay: Record<string, number> = {};
+  const tasksByDayDone: Record<string, number> = {};
+  const tasksByDayActive: Record<string, number> = {};
+  const taskMinutesByDay: Record<string, number> = {};
+  const sessionCodingMinutesByDay: Record<string, number> = {};
+  const sessionWallClockMinutesByDay: Record<string, number> = {};
+
+  let kronoFocusSessionsCompleted = 0;
+  let kronoFocusTasksUsedCount = 0;
+  let kronoFocusTaskCyclesSum = 0;
+  let taskMinutesTotal = 0;
+  let sessionCodingMinutesTotal = 0;
+  let sessionActiveMinutesTotal = 0;
+  let sessionWallClockMinutesTotal = 0;
+  let sessionCountContributing = 0;
+  let taskCountContributing = 0;
+  let linesWrittenTotalSum = 0;
+  let linesWrittenHumanSum = 0;
+  let linesWrittenAiSum = 0;
+  const locByLanguageAcc = new Map<string, number>();
+  const codingSignalsAcc = new Map<string, number>();
+  let assiduityReferenceSessionCount = 0;
+  let assiduityLateSessionCount = 0;
+  let assiduityLateMinutesTotal = 0;
+
+  const unbounded = !dateFrom && !dateTo;
+
+  for (const s of sessions) {
+    const allTasks = collectTasksDeduped(s);
+    const matching = allTasks.filter((t) => taskMatchesTags(t, selectedTagKeys, defaultTagBucketEnabled));
+    if (selectedTagKeys.size > 0 && matching.length === 0) {
+      continue;
+    }
+
+    const sessionDay = calendarDateKeyInTimeZone(s.savedAt ?? s.endAt ?? s.startAt, timeZone);
+    const sessionRangeOk = unbounded || dayInRange(sessionDay, dateFrom, dateTo);
+
+    if (sessionRangeOk) {
+      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;
+      }
+      if (typeof s.linesWrittenHuman === "number") {
+        linesWrittenHumanSum += s.linesWrittenHuman;
+      }
+      if (typeof s.linesWrittenAi === "number") {
+        linesWrittenAiSum += s.linesWrittenAi;
+      }
+      mergeTupleMap(locByLanguageAcc, s.locByLanguage);
+      mergeTupleMap(codingSignalsAcc, s.codingSignalsByLanguage);
+      if (typeof s.sessionStartOffsetMinutes === "number" && Number.isFinite(s.sessionStartOffsetMinutes)) {
+        assiduityReferenceSessionCount += 1;
+        if (s.sessionStartOffsetMinutes > 0) {
+          assiduityLateSessionCount += 1;
+          assiduityLateMinutesTotal += s.sessionStartOffsetMinutes;
+        }
+      }
+    }
+
+    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) {
+        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[taskBucket] = (tasksByDayDone[taskBucket] ?? 0) + 1;
+      } else {
+        tasksByDayActive[taskBucket] = (tasksByDayActive[taskBucket] ?? 0) + 1;
+      }
+
+      const tr = t as Record<string, unknown>;
+      if (t.usedKronoFocus === true || tr[LEGACY_TASK_USED_FLAG_KEY] === true) {
+        kronoFocusTasksUsedCount += 1;
+      }
+      const cyc =
+        typeof t.kronoFocusCycles === "number"
+          ? t.kronoFocusCycles
+          : typeof tr[LEGACY_TASK_CYCLES_KEY] === "number"
+            ? tr[LEGACY_TASK_CYCLES_KEY]
+            : undefined;
+      if (typeof cyc === "number" && cyc > 0) {
+        kronoFocusTaskCyclesSum += cyc;
+      }
+    }
+  }
+
+  const locByLanguageMerged = [...locByLanguageAcc.entries()].sort((a, b) => b[1] - a[1]);
+  const codingSignalsByLanguageMerged = [...codingSignalsAcc.entries()].sort((a, b) => b[1] - a[1]);
+  const assiduityAverageLateMinutesWhenLate =
+    assiduityLateSessionCount > 0 ? assiduityLateMinutesTotal / assiduityLateSessionCount : null;
+
+  return {
+    sessionsByDay,
+    tasksByDayDone,
+    tasksByDayActive,
+    taskMinutesByDay,
+    sessionCodingMinutesByDay,
+    sessionWallClockMinutesByDay,
+    kronoFocusSessionsCompleted,
+    kronoFocusTasksUsedCount,
+    kronoFocusTaskCyclesSum,
+    taskMinutesTotal,
+    sessionCodingMinutesTotal,
+    sessionActiveMinutesTotal,
+    sessionWallClockMinutesTotal,
+    sessionCountContributing,
+    taskCountContributing,
+    linesWrittenTotalSum,
+    linesWrittenHumanSum,
+    linesWrittenAiSum,
+    locByLanguageMerged,
+    codingSignalsByLanguageMerged,
+    assiduityReferenceSessionCount,
+    assiduityLateSessionCount,
+    assiduityLateMinutesTotal,
+    assiduityAverageLateMinutesWhenLate,
+  };
+}
+
+export type ReportingProjectRow = {
+  /** Clé stable tri (vide = sans projet). */
+  projectKey: string;
+  /** Libellé affiché (vide si sans projet — remplacer côté UI). */
+  displayLabel: string;
+  minutes: number;
+  taskCount: number;
+};
+
+export type ReportingProjectTimeDayRow = {
+  projectKey: string;
+  displayProject: string;
+  day: string;
+  minutes: number;
+};
+
+function compareProjectKeyForSort(a: string, b: string): number {
+  if (a === "" && b !== "") {
+    return 1;
+  }
+  if (b === "" && a !== "") {
+    return -1;
+  }
+  return a.localeCompare(b);
+}
+
+/**
+ * Temps enregistré sur les tâches (`durationMs`) par `@projet` et par jour de tâche (mêmes filtres que le tableau projet agrégé).
+ */
+export function aggregateProjectTaskMinutesByDay(
+  sessions: LooseSession[],
+  selectedTagKeys: Set<string>,
+  dateFrom: string | null,
+  dateTo: string | null,
+  timeZone: string,
+  defaultTagBucketEnabled: boolean = true
+): ReportingProjectTimeDayRow[] {
+  const byProjDay = new Map<string, Map<string, number>>();
+  const displayByProj = new Map<string, string>();
+  const unbounded = !dateFrom && !dateTo;
+
+  for (const s of sessions) {
+    const allTasks = collectTasksDeduped(s);
+    const matching = allTasks.filter((t) => taskMatchesTags(t, selectedTagKeys, defaultTagBucketEnabled));
+    if (selectedTagKeys.size > 0 && matching.length === 0) {
+      continue;
+    }
+
+    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) {
+        continue;
+      }
+
+      const mins = (t.durationMs ?? 0) / 60000;
+      if (mins <= 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);
+      }
+      inner.set(taskBucket, (inner.get(taskBucket) ?? 0) + mins);
+      if (raw && !displayByProj.has(key)) {
+        displayByProj.set(key, formatProjectDisplay(raw));
+      }
+    }
+  }
+
+  const out: ReportingProjectTimeDayRow[] = [];
+  for (const [projectKey, inner] of byProjDay) {
+    for (const [day, minutes] of inner) {
+      out.push({
+        projectKey,
+        displayProject:
+          projectKey === ""
+            ? ""
+            : (displayByProj.get(projectKey) ?? formatProjectDisplay(projectKey)),
+        day,
+        minutes,
+      });
+    }
+  }
+  out.sort((a, b) => a.day.localeCompare(b.day) || compareProjectKeyForSort(a.projectKey, b.projectKey));
+  return out;
+}
+
+/**
+ * Minutes enregistrées sur des tâches d’**sessions archivées** qui sont **exclues** des graphiques
+ * (tâche non terminée ou sous-tâche non cochée), avec les mêmes filtres dates et étiquettes que les autres agrégats tâche.
+ * Sert d’indicateur pour éviter d’afficher « rien » alors qu’il existait du temps sur disque.
+ */
+export function aggregateArchivedExcludedTaskMinutes(
+  sessions: LooseSession[],
+  selectedTagKeys: Set<string>,
+  dateFrom: string | null,
+  dateTo: string | null,
+  timeZone: string,
+  defaultTagBucketEnabled: boolean = true
+): number {
+  const unbounded = !dateFrom && !dateTo;
+  let total = 0;
+  for (const s of sessions) {
+    if (s.archived !== true) {
+      continue;
+    }
+    const allTasks = collectTasksDeduped(s);
+    const matching = allTasks.filter((t) => taskMatchesTags(t, selectedTagKeys, defaultTagBucketEnabled));
+    if (selectedTagKeys.size > 0 && matching.length === 0) {
+      continue;
+    }
+    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) {
+        continue;
+      }
+      const mins = (t.durationMs ?? 0) / 60000;
+      if (mins > 0) {
+        total += mins;
+      }
+    }
+  }
+  return total;
+}
+
+export function aggregateReportingByProject(
+  sessions: LooseSession[],
+  selectedTagKeys: Set<string>,
+  dateFrom: string | null,
+  dateTo: string | null,
+  timeZone: string,
+  defaultTagBucketEnabled: boolean = true
+): ReportingProjectRow[] {
+  const byKey = new Map<string, { label: string; minutes: number; count: number }>();
+  const unbounded = !dateFrom && !dateTo;
+
+  const bump = (key: string, label: string, mins: number) => {
+    const cur = byKey.get(key) ?? { label, minutes: 0, count: 0 };
+    cur.minutes += mins;
+    cur.count += 1;
+    if (label && !cur.label) {
+      cur.label = label;
+    }
+    byKey.set(key, cur);
+  };
+
+  for (const s of sessions) {
+    const allTasks = collectTasksDeduped(s);
+    const matching = allTasks.filter((t) => taskMatchesTags(t, selectedTagKeys, defaultTagBucketEnabled));
+    if (selectedTagKeys.size > 0 && matching.length === 0) {
+      continue;
+    }
+
+    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 raw = typeof t.project === "string" ? t.project.trim() : "";
+      const key = raw ? normalizeProjectKey(raw).toLowerCase() : "";
+      const mins = (t.durationMs ?? 0) / 60000;
+      bump(key, formatProjectDisplay(raw), mins);
+    }
+  }
+
+  return [...byKey.entries()]
+    .map(([projectKey, v]) => ({
+      projectKey,
+      displayLabel: v.label,
+      minutes: v.minutes,
+      taskCount: v.count,
+    }))
+    .sort((a, b) => b.minutes - a.minutes);
+}
+
+export function sortedDayKeys(
+  ...maps: Array<Record<string, number>>
+): string[] {
+  const set = new Set<string>();
+  for (const m of maps) {
+    for (const k of Object.keys(m)) {
+      set.add(k);
+    }
+  }
+  return [...set].sort();
+}
+
+export function maxBucket(maps: Array<Record<string, number>>): number {
+  let m = 0;
+  for (const map of maps) {
+    for (const v of Object.values(map)) {
+      if (v > m) {
+        m = v;
+      }
+    }
+  }
+  return m || 1;
+}