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

package/lib/reportingMetricHelp.ts

@@ -114,6 +114,8 @@ export type ReportingMetricHelpBlock = {
   metricHelpAssiduityLateTotalBody: string;
   metricHelpAssiduityAvgLateAria: string;
   metricHelpAssiduityAvgLateBody: string;
+  metricHelpClosureBreakdownAria: string;
+  metricHelpClosureBreakdownBody: string;
 };
 
 export const reportingMetricHelpEn: ReportingMetricHelpBlock = {
@@ -269,6 +271,9 @@ export const reportingMetricHelpEn: ReportingMetricHelpBlock = {
   metricHelpAssiduityAvgLateAria: "Help: average late when late",
   metricHelpAssiduityAvgLateBody:
     "Cumulative late minutes divided by the number of late sessions (unchanged if there are zero late sessions, shown as —). A simple punctuality read when a reference time was stored.",
+  metricHelpClosureBreakdownAria: "Help: sessions by closure type",
+  metricHelpClosureBreakdownBody:
+    "How many included sessions fall into each closure category saved when the session ended (planned, early, overrun, other). “Unspecified” covers open sessions and ended sessions where no category was saved. Same session-day and tag rules as “Sessions (in range)”; the five counts sum to that total.",
 };
 
 export const reportingMetricHelpFr: ReportingMetricHelpBlock = {
@@ -427,4 +432,7 @@ export const reportingMetricHelpFr: ReportingMetricHelpBlock = {
   metricHelpAssiduityAvgLateAria: "Aide : retard moyen (lorsqu’en retard)",
   metricHelpAssiduityAvgLateBody:
     "Retard cumulé divisé par le nombre de sessions en retard ; indiqué en « — » s’il n’y en a pas. Pertinent lorsqu’une heure de début a été enregistrée côté hôte.",
+  metricHelpClosureBreakdownAria: "Aide : sessions par type de clôture",
+  metricHelpClosureBreakdownBody:
+    "Nombre de sessions incluses par catégorie enregistrée à la fin de session (conforme au prévu, anticipée, prolongation, autre). « Sans catégorie » regroupe les sessions encore ouvertes et celles terminées sans choix enregistré. Mêmes règles de jour de session et d’étiquettes que « Sessions (plage) » ; la somme des cinq lignes égale ce total.",
 };

package/lib/reportingStrings.ts

@@ -1,4 +1,5 @@
 import type { Lang } from "./dashboardCopy";
+import { dashboardStrings } from "./dashboardCopy";
 import {
   reportingMetricHelpEn,
   reportingMetricHelpFr,
@@ -9,8 +10,13 @@ export type ReportingNavStrings = {
   dashboard: string;
   reporting: string;
   settings: string;
+  logs: string;
   /** Guide d’utilisation in-app (`/guide`). */
   guide: string;
+  /** Page inventaire des user stories (`/implementation`). */
+  implementation: string;
+  /** Infobulle lorsque l’icône tableau de bord pulse (rappel conflit minuteurs). */
+  dashboardAttentionHint?: string;
 };
 
 export type ReportingStrings = ReportingNavStrings &
@@ -87,6 +93,8 @@ export type ReportingStrings = ReportingNavStrings &
   tableActive: string;
   /** Temps enregistré sur les tâches (durationMs), par jour de tâche. */
   tableTaskTime: string;
+  /** Temps non concurrent (union des intervalles horodatés), par jour de tâche. */
+  tableTaskTimeNonConcurrent: string;
   /** Temps de codage session (codingMinutesSession), par jour de session. */
   tableSessionCoding: string;
   tableSessionWall: string;
@@ -149,6 +157,11 @@ export type ReportingStrings = ReportingNavStrings &
   tocNavAria: string;
   /** Libellé court pour la grille d’indicateurs (pas de titre visible dans la section). */
   tocSummaryKpis: string;
+  /** Sessions regroupées par raison de clôture (sous-bloc du résumé). */
+  tocClosureBreakdown: string;
+  closureBreakdownTitle: string;
+  /** Sessions sans catégorie de clôture enregistrée (ou session encore ouverte). */
+  closureBreakdownUnspecified: string;
   /** Libellé pour le tableau jour / sessions / tâches. */
   tocDailyTable: string;
   tocTagTimeSection: string;
@@ -170,7 +183,9 @@ const en: ReportingStrings = {
   dashboard: "Dashboard",
   reporting: "Reporting",
   settings: "Settings",
+  logs: "Action logs",
   guide: "User guide",
+  implementation: "User stories — implementation",
   title: "Reporting",
   subtitle:
     "Aggregates from Kronosys history (local API). Filter by date range and tags. Task time by @project is included.",
@@ -197,7 +212,7 @@ const en: ReportingStrings = {
 
 • Workspace folder snapshot (lines in the open project): ignores filters — not Kronosys history.
 
-• Summary KPIs, charts, day-by-day table: filters apply. Session-day side: session count, session coding/active/wall time, KronoFocus sessions completed, lines written, and (when the host stored a planned start) punctuality aggregates: reference count, late session count, cumulative and average late minutes. Task-day side: task rows, recorded task time, done/in-progress counts, task KronoFocus used/cycles.
+• Summary KPIs, charts, day-by-day table: filters apply. Session-day side: session count, session coding/active/wall time, KronoFocus sessions completed, lines written, breakdown of sessions by closure type when the host saved one at session end, and (when the host stored a planned start) punctuality aggregates: reference count, late session count, cumulative and average late minutes. Task-day side: task rows, recorded task time, done/in-progress counts, task KronoFocus used/cycles.
 
 • “Lines by language” and “Coding signals” tables: session day within the range; with tags selected, a whole session is dropped if no task matches (same rule as elsewhere).
 
@@ -249,6 +264,7 @@ Archived sessions: task-based metrics only count fully completed tasks (subtasks
   tableDone: "Done",
   tableActive: "Active",
   tableTaskTime: "Task time",
+  tableTaskTimeNonConcurrent: "Task time (non-concurrent)",
   tableSessionCoding: "Session coding",
   tableSessionWall: "Session span",
   undatedLabel: "Undated",
@@ -307,6 +323,9 @@ Archived sessions: task-based metrics only count fully completed tasks (subtasks
   tocTitle: "On this page",
   tocNavAria: "Reporting — sections on this page",
   tocSummaryKpis: "Summary indicators",
+  tocClosureBreakdown: "Sessions by closure type",
+  closureBreakdownTitle: "Sessions by closure type",
+  closureBreakdownUnspecified: "Unspecified (open or no category)",
   tocDailyTable: "Day-by-day table",
   tocTagTimeSection: "Time by tag",
   weekNavPrev: "Previous week",
@@ -326,7 +345,9 @@ const fr: ReportingStrings = {
   dashboard: "Tableau de bord",
   reporting: "Rapports",
   settings: "Paramètres",
+  logs: "Journal des actions",
   guide: "Guide d’utilisation",
+  implementation: "User stories — implémentation",
   title: "Rapports",
   subtitle:
     "Agrégats à partir de l’historique Kronosys (API locale). Filtrez par plage de dates et par étiquettes. Le temps par @projet est inclus.",
@@ -354,7 +375,7 @@ const fr: ReportingStrings = {
 
 • Instantané « Dossier ouvert » (lignes par langage du workspace) : hors filtres — ce n’est pas l’historique Kronosys.
 
-• Indicateurs de synthèse, graphiques, tableau par jour : la plage et les étiquettes s’appliquent. Côté jour de session : nombre de sessions, temps de codage et d’activité, durée murale, KronoFocus « sessions terminées », lignes écrites, et (si l’hôte a enregistré un début prévu) indicateurs d’assiduité : sessions avec référence, sessions en retard, retard cumulé, retard moyen lorsqu’en retard. Côté jour de tâche : lignes de tâches, temps enregistré, tâches terminées / en cours, KronoFocus côté tâches.
+• Indicateurs de synthèse, graphiques, tableau par jour : la plage et les étiquettes s’appliquent. Côté jour de session : nombre de sessions, temps de codage et d’activité, durée murale, KronoFocus « sessions terminées », lignes écrites, ventilation des sessions par type de clôture lorsque l’hôte en a enregistré un à la fin de session, et (si l’hôte a enregistré un début prévu) indicateurs d’assiduité : sessions avec référence, sessions en retard, retard cumulé, retard moyen lorsqu’en retard. Côté jour de tâche : lignes de tâches, temps enregistré, tâches terminées / en cours, KronoFocus côté tâches.
 
 • Tableaux « Lignes par langage » et « Signaux de codage » : jour de session dans la plage ; avec étiquettes sélectionnées, toute la session est exclue si aucune tâche ne correspond (même règle qu’ailleurs).
 
@@ -407,6 +428,7 @@ Sessions archivées : pour les métriques basées sur les tâches, seules les t
   tableDone: "Terminées",
   tableActive: "En cours",
   tableTaskTime: "Temps (tâches)",
+  tableTaskTimeNonConcurrent: "Temps (tâches, non concurrent)",
   tableSessionCoding: "Codage (sessions)",
   tableSessionWall: "Durée session",
   undatedLabel: "Sans date",
@@ -466,6 +488,9 @@ Sessions archivées : pour les métriques basées sur les tâches, seules les t
   tocTitle: "Sur cette page",
   tocNavAria: "Rapports — sections de la page",
   tocSummaryKpis: "Indicateurs de synthèse",
+  tocClosureBreakdown: "Sessions par type de clôture",
+  closureBreakdownTitle: "Sessions par type de clôture",
+  closureBreakdownUnspecified: "Sans catégorie (ouverte ou non enregistrée)",
   tocDailyTable: "Tableau par jour",
   tocTagTimeSection: "Temps par étiquette",
   weekNavPrev: "Semaine précédente",
@@ -487,5 +512,14 @@ export function reportingStrings(lang: Lang): ReportingStrings {
 
 export function reportingNav(lang: Lang): ReportingNavStrings {
   const s = reportingStrings(lang);
-  return { dashboard: s.dashboard, reporting: s.reporting, settings: s.settings, guide: s.guide };
+  const d = dashboardStrings(lang);
+  return {
+    dashboard: s.dashboard,
+    reporting: s.reporting,
+    settings: s.settings,
+    logs: s.logs,
+    guide: s.guide,
+    implementation: s.implementation,
+    dashboardAttentionHint: d.navDashboardPlannedConflictPulseHint,
+  };
 }

package/lib/sessionListMerge.ts

@@ -7,6 +7,7 @@ type LiveLike = {
   createdAt?: string | null;
   startAt?: string | null;
   endAt?: string | null;
+  sessionNote?: string;
   sessionEndReasonKind?: unknown;
   sessionEndReasonNote?: unknown;
   sessionDurationMinutes?: number;
@@ -66,5 +67,8 @@ export function mergeLiveSessionIntoHistory(
   if (typeof live?.sessionEndReasonNote === "string" && live.sessionEndReasonNote.trim() !== "") {
     entry.sessionEndReasonNote = live.sessionEndReasonNote.trim();
   }
+  if (typeof live?.sessionNote === "string") {
+    entry.sessionNote = live.sessionNote;
+  }
   return [entry, ...without];
 }

package/lib/sessionTaskSidebarStats.ts

@@ -2,53 +2,214 @@
  * Compteurs de tâches pour la carte « session sélectionnée », alignés sur {@link TaskFocusPanel}.
  */
 
-type TaskLike = { id?: string; isDone?: boolean; manualTaskTimerPaused?: boolean };
+import { isTaskDisplayPlanned } from "./temporalDisplayPlanned";
+
+type TaskLike = {
+  id?: string;
+  isDone?: boolean;
+  manualTaskTimerPaused?: boolean;
+  startTime?: string;
+  endTime?: string;
+};
+type SubtaskLike = { id?: string; durationMs?: number };
+type SessionTaskLike = TaskLike & {
+  durationMs?: number;
+  subtasks?: SubtaskLike[];
+  activeSubtaskTimerId?: string | null;
+  subtaskTimerStartedAt?: string | number;
+  mainTimerSegmentStartedAt?: string | null;
+};
 
 type SessionLike = {
-  tasks?: TaskLike[];
-  activeTasks?: TaskLike[];
-  activeTask?: TaskLike | null;
+  tasks?: SessionTaskLike[];
+  activeTasks?: SessionTaskLike[];
+  activeTask?: SessionTaskLike | null;
   /** Session clôturée : pas de compteurs « en cours » ou « en liste » pour l’affichage carte session. */
   endAt?: string | null;
 };
+const SUBTASK_TIMER_STARTED_AT = "subtaskTimerStartedAt";
+const MAIN_TIMER_SEGMENT_STARTED_AT = "mainTimerSegmentStartedAt";
 
 function sessionClosedForDisplay(session: SessionLike | null | undefined): boolean {
   return typeof session?.endAt === "string" && session.endAt.trim() !== "";
 }
 
-function activeStackFromSession(session: SessionLike | null | undefined): TaskLike[] {
+function activeStackFromSession(session: SessionLike | null | undefined): SessionTaskLike[] {
   if (!session) {
     return [];
   }
-  const raw =
-    Array.isArray(session.activeTasks) && session.activeTasks.length > 0
-      ? session.activeTasks
-      : session.activeTask
-        ? [session.activeTask]
-        : [];
-  return raw.filter((t): t is TaskLike => Boolean(t));
+  const hasActiveTasks = Array.isArray(session.activeTasks) && session.activeTasks.length > 0;
+  let raw: Array<SessionTaskLike | null | undefined> = [];
+  if (hasActiveTasks) {
+    raw = session.activeTasks ?? [];
+  } else if (session.activeTask) {
+    raw = [session.activeTask];
+  }
+  return raw.filter((t): t is SessionTaskLike => Boolean(t));
+}
+
+function asNonNegativeIntMs(raw: unknown): number {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) {
+    return 0;
+  }
+  return Math.max(0, Math.floor(raw));
 }
 
-/** Tâches avec minuteur actif (!terminé, pas en pause manuelle). */
-export function countRunningTasksOnTimer(session: SessionLike | null | undefined): number {
-  return activeStackFromSession(session).filter((t) => !t.isDone && !t.manualTaskTimerPaused).length;
+function readTimerStartMs(raw: unknown): number | null {
+  if (typeof raw === "string" && raw.trim() !== "") {
+    const parsed = Date.parse(raw);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return raw;
+  }
+  return null;
+}
+
+function collectUniqueSessionTasks(session: SessionLike | null | undefined): SessionTaskLike[] {
+  const taskRows = new Map<string, SessionTaskLike>();
+  const pushTask = (task: SessionTaskLike | null | undefined) => {
+    if (!task) {
+      return;
+    }
+    const id = typeof task.id === "string" ? task.id.trim() : "";
+    if (!id || taskRows.has(id)) {
+      return;
+    }
+    taskRows.set(id, task);
+  };
+  for (const row of session?.activeTasks ?? []) {
+    pushTask(row);
+  }
+  pushTask(session?.activeTask ?? null);
+  for (const row of session?.tasks ?? []) {
+    pushTask(row);
+  }
+  return [...taskRows.values()];
+}
+
+function getTaskSubtasksSnapshot(task: SessionTaskLike): {
+  subtaskCount: number;
+  subtaskStoredMs: number;
+} {
+  const subtasks = Array.isArray(task.subtasks) ? task.subtasks : [];
+  let subtaskStoredMs = 0;
+  for (const subtask of subtasks) {
+    subtaskStoredMs += asNonNegativeIntMs(subtask?.durationMs);
+  }
+  return {
+    subtaskCount: subtasks.length,
+    subtaskStoredMs,
+  };
+}
+
+function getTaskInflightTimerMs(task: SessionTaskLike, nowMs: number): {
+  taskInflightMs: number;
+  subtaskInflightMs: number;
+} {
+  if (isTaskDisplayPlanned(task, nowMs)) {
+    return { taskInflightMs: 0, subtaskInflightMs: 0 };
+  }
+  const activeSubtaskId =
+    typeof task.activeSubtaskTimerId === "string" ? task.activeSubtaskTimerId.trim() : "";
+  if (activeSubtaskId) {
+    const startedMs = readTimerStartMs(task[SUBTASK_TIMER_STARTED_AT]);
+    const subtaskInflightMs =
+      startedMs === null ? 0 : Math.max(0, Math.floor(nowMs - startedMs));
+    return { taskInflightMs: subtaskInflightMs, subtaskInflightMs };
+  }
+  const startedMs = readTimerStartMs(task[MAIN_TIMER_SEGMENT_STARTED_AT]);
+  const taskInflightMs = startedMs === null ? 0 : Math.max(0, Math.floor(nowMs - startedMs));
+  return { taskInflightMs, subtaskInflightMs: 0 };
+}
+
+/** Tâches avec minuteur actif (!terminé, pas en pause manuelle, pas « planifiée » dans le futur). */
+export function countRunningTasksOnTimer(
+  session: SessionLike | null | undefined,
+  nowMs: number = Date.now(),
+): number {
+  return activeStackFromSession(session).filter(
+    (t) =>
+      !t.isDone &&
+      !t.manualTaskTimerPaused &&
+      !isTaskDisplayPlanned(t, nowMs),
+  ).length;
 }
 
 /**
- * Même regroupement que le panneau tâches : minuteur actif, liste des non terminées, terminées.
+ * Même regroupement que le panneau tâches : minuteur actif, planifiées, liste des autres non terminées, terminées.
  */
-export function countSessionTasksForSidebar(session: SessionLike | null | undefined): {
+export function countSessionTasksForSidebar(
+  session: SessionLike | null | undefined,
+  nowMs: number = Date.now(),
+): {
   running: number;
+  planned: number;
   pausedList: number;
   completed: number;
 } {
-  const taskList = session?.tasks ?? [];
-  const completed = taskList.filter((t) => t.isDone === true).length;
   const closed = sessionClosedForDisplay(session);
-  const pausedList = closed ? 0 : taskList.filter((t) => t.isDone !== true).length;
+  const unique = collectUniqueSessionTasks(session);
+  let planned = 0;
+  let completed = 0;
+  let pausedList = 0;
+  for (const t of unique) {
+    if (isTaskDisplayPlanned(t, nowMs)) {
+      planned += 1;
+      continue;
+    }
+    if (t.isDone === true) {
+      completed += 1;
+      continue;
+    }
+    if (closed) {
+      continue;
+    }
+    const onStack = activeStackFromSession(session).some(
+      (a) => String(a.id) === String(t.id),
+    );
+    const stackRunning =
+      onStack && !t.isDone && !t.manualTaskTimerPaused && !isTaskDisplayPlanned(t, nowMs);
+    if (!stackRunning) {
+      pausedList += 1;
+    }
+  }
   return {
-    running: closed ? 0 : countRunningTasksOnTimer(session),
+    running: closed ? 0 : countRunningTasksOnTimer(session, nowMs),
+    planned,
     pausedList,
     completed,
   };
 }
+
+export function getSessionTaskTimerBreakdown(
+  session: SessionLike | null | undefined,
+  nowMs: number = Date.now(),
+): {
+  taskCount: number;
+  subtaskCount: number;
+  taskTimersTotalMs: number;
+  subtaskTimersTotalMs: number;
+} {
+  const tasks = collectUniqueSessionTasks(session);
+
+  let taskTimersTotalMs = 0;
+  let subtaskTimersTotalMs = 0;
+  let subtaskCount = 0;
+
+  for (const task of tasks) {
+    const baseMs = asNonNegativeIntMs(task.durationMs);
+    const subtaskSnapshot = getTaskSubtasksSnapshot(task);
+    const inflight = getTaskInflightTimerMs(task, nowMs);
+    subtaskCount += subtaskSnapshot.subtaskCount;
+    taskTimersTotalMs += baseMs + inflight.taskInflightMs;
+    subtaskTimersTotalMs += subtaskSnapshot.subtaskStoredMs + inflight.subtaskInflightMs;
+  }
+
+  return {
+    taskCount: tasks.length,
+    subtaskCount,
+    taskTimersTotalMs,
+    subtaskTimersTotalMs,
+  };
+}