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

package/server/actionTaskSession.ts

@@ -200,16 +200,48 @@ export function ensureTaskParentDurationCoversSubtasksMs(task: Record<string, un
 }
 
 /** Clé ISO : début du segment de minuteur courant sur une sous-tâche (tâche parente). */
-const SUBTASK_TIMER_STARTED_AT = "subtaskTimerStartedAt";
+export const SUBTASK_TIMER_STARTED_AT = "subtaskTimerStartedAt";
 
 /** Clé ISO : début du segment du minuteur principal (hors sous-tâche) — persisté pour ne pas perdre le temps hors tableau de bord. */
 export const MAIN_TIMER_SEGMENT_STARTED_AT = "mainTimerSegmentStartedAt";
+/** Clé ISO : heure de fin planifiée d'une tâche en cours. */
+export const TASK_SCHEDULED_END_AT = "scheduledEndAt";
+/** Liste chronologique des segments de suivi (laps) d'une tâche. */
+export const TASK_TIMER_LAPS = "taskTimerLaps";
+/** Clé ISO : début du lap courant (stable entre les matérialisations de segment). */
+export const TASK_CURRENT_LAP_STARTED_AT = "taskCurrentLapStartedAt";
+
+function ensureTaskTimerLaps(task: Record<string, unknown>): Record<string, unknown>[] {
+  if (!Array.isArray(task[TASK_TIMER_LAPS])) {
+    task[TASK_TIMER_LAPS] = [];
+  }
+  return task[TASK_TIMER_LAPS] as Record<string, unknown>[];
+}
+
+function appendTaskTimerLap(task: Record<string, unknown>, startMs: number, endMs: number): void {
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs < startMs) {
+    return;
+  }
+  const durationMs = Math.max(0, Math.floor(endMs - startMs));
+  if (durationMs < 1000) {
+    return;
+  }
+  const laps = ensureTaskTimerLaps(task);
+  laps.push({
+    startTime: new Date(startMs).toISOString(),
+    endTime: new Date(endMs).toISOString(),
+    durationMs,
+  });
+}
 
 /**
  * Vide le segment de minuteur principal en cours : ajoute le temps écoulé à `durationMs`.
  * Sans effet s’un suivi sous-tâche est actif (le parent ne cumule pas en parallèle).
  */
-export function flushMainTimerSegmentOnTask(task: Record<string, unknown>): void {
+export function flushMainTimerSegmentOnTask(
+  task: Record<string, unknown>,
+  flushClockEndMs: number = Date.now(),
+): void {
   if (String(task.activeSubtaskTimerId ?? "").trim() !== "") {
     return;
   }
@@ -222,11 +254,18 @@ export function flushMainTimerSegmentOnTask(task: Record<string, unknown>): void
     delete task[MAIN_TIMER_SEGMENT_STARTED_AT];
     return;
   }
-  const elapsed = Math.max(0, Math.floor(Date.now() - startedMs));
+  const elapsed = Math.max(0, Math.floor(flushClockEndMs - startedMs));
   const parentPrev =
     typeof task.durationMs === "number" && Number.isFinite(task.durationMs) ? Number(task.durationMs) : 0;
   task.durationMs = Math.floor(parentPrev + elapsed);
+  const lapRaw = task[TASK_CURRENT_LAP_STARTED_AT];
+  const lapStartedMs =
+    typeof lapRaw === "string" && lapRaw.trim() !== ""
+      ? Date.parse(lapRaw)
+      : Number.NaN;
+  appendTaskTimerLap(task, Number.isFinite(lapStartedMs) ? lapStartedMs : startedMs, flushClockEndMs);
   delete task[MAIN_TIMER_SEGMENT_STARTED_AT];
+  delete task[TASK_CURRENT_LAP_STARTED_AT];
   ensureTaskParentDurationCoversSubtasksMs(task);
 }
 
@@ -243,9 +282,15 @@ export function ensureMainTimerSegmentForRunningTask(task: Record<string, unknow
   }
   const raw = task[MAIN_TIMER_SEGMENT_STARTED_AT];
   if (typeof raw === "string" && raw.trim() !== "") {
+    const lapRaw = task[TASK_CURRENT_LAP_STARTED_AT];
+    if (!(typeof lapRaw === "string" && lapRaw.trim() !== "")) {
+      task[TASK_CURRENT_LAP_STARTED_AT] = raw;
+    }
     return;
   }
-  task[MAIN_TIMER_SEGMENT_STARTED_AT] = new Date().toISOString();
+  const nowIso = new Date().toISOString();
+  task[MAIN_TIMER_SEGMENT_STARTED_AT] = nowIso;
+  task[TASK_CURRENT_LAP_STARTED_AT] = nowIso;
 }
 
 /**
@@ -255,7 +300,10 @@ export function ensureMainTimerSegmentForRunningTask(task: Record<string, unknow
  * — rattrapage via `ensureTaskParentDurationCoversSubtasksMs` en fin de flush.
  * Efface ensuite `activeSubtaskTimerId` et l’horodatage de segment.
  */
-export function flushSubtaskTimerOnTask(task: Record<string, unknown>): void {
+export function flushSubtaskTimerOnTask(
+  task: Record<string, unknown>,
+  flushClockEndMs: number = Date.now(),
+): void {
   const activeId = String(task.activeSubtaskTimerId ?? "").trim();
   if (!activeId) {
     return;
@@ -272,7 +320,7 @@ export function flushSubtaskTimerOnTask(task: Record<string, unknown>): void {
     delete task[SUBTASK_TIMER_STARTED_AT];
     return;
   }
-  const elapsed = Math.max(0, Date.now() - startedMs);
+  const elapsed = Math.max(0, flushClockEndMs - startedMs);
   const st = ensureSubtasks(task).find((s) => String(s.id) === activeId);
   if (st && typeof st === "object" && !Array.isArray(st)) {
     const row = st as Record<string, unknown>;
@@ -282,8 +330,15 @@ export function flushSubtaskTimerOnTask(task: Record<string, unknown>): void {
   const parentPrev =
     typeof task.durationMs === "number" && Number.isFinite(task.durationMs) ? Number(task.durationMs) : 0;
   task.durationMs = Math.floor(parentPrev + elapsed);
+  const lapRaw = task[TASK_CURRENT_LAP_STARTED_AT];
+  const lapStartedMs =
+    typeof lapRaw === "string" && lapRaw.trim() !== ""
+      ? Date.parse(lapRaw)
+      : Number.NaN;
+  appendTaskTimerLap(task, Number.isFinite(lapStartedMs) ? lapStartedMs : startedMs, flushClockEndMs);
   task.activeSubtaskTimerId = null;
   delete task[SUBTASK_TIMER_STARTED_AT];
+  delete task[TASK_CURRENT_LAP_STARTED_AT];
   ensureTaskParentDurationCoversSubtasksMs(task);
 }
 
@@ -291,7 +346,8 @@ export function finishTaskInSession(
   sess: Record<string, unknown>,
   taskId: string,
   shouldCommit: boolean,
-  tagNormOpts?: TaskTagsStorageNormalizeOpts
+  tagNormOpts?: TaskTagsStorageNormalizeOpts,
+  options?: { completionInstantMs?: number },
 ): boolean {
   const id = taskId;
   let task: Record<string, unknown> | null = null;
@@ -322,10 +378,16 @@ export function finishTaskInSession(
     }
   }
 
-  flushSubtaskTimerOnTask(task);
-  flushMainTimerSegmentOnTask(task);
+  const flushEndMs =
+    typeof options?.completionInstantMs === "number" && Number.isFinite(options.completionInstantMs)
+      ? options.completionInstantMs
+      : Date.now();
+
+  flushSubtaskTimerOnTask(task, flushEndMs);
+  flushMainTimerSegmentOnTask(task, flushEndMs);
   task.isDone = true;
-  task.endTime = new Date().toISOString();
+  task.endTime = new Date(flushEndMs).toISOString();
+  delete task[TASK_SCHEDULED_END_AT];
   task.shouldCommit = shouldCommit;
   task.manualTaskTimerPaused = false;
   for (const st of ensureSubtasks(task)) {
@@ -380,7 +442,13 @@ export function deleteTaskInSession(sess: Record<string, unknown>, taskId: strin
 export function updateTaskInSession(
   sess: Record<string, unknown>,
   taskId: string,
-  patch: { name?: string; tags?: string[]; project?: string | null },
+  patch: {
+    name?: string;
+    tags?: string[];
+    project?: string | null;
+    personalProject?: boolean;
+    note?: string;
+  },
   tagNormOpts?: TaskTagsStorageNormalizeOpts
 ): boolean {
   const task = findTaskRecord(sess, taskId);
@@ -396,13 +464,23 @@ export function updateTaskInSession(
   if (patch.project !== undefined) {
     task.project = patch.project;
   }
+  if (patch.personalProject !== undefined) {
+    task.personalProject = patch.personalProject === true;
+  }
+  if (typeof patch.note === "string") {
+    task.note = patch.note;
+  }
   return true;
 }
 
 export function updateTaskStartTimeInSession(
   sess: Record<string, unknown>,
   taskId: string,
-  startTimeIso: string
+  startTimeIso: string,
+  options?: {
+    durationAdjustMode?: "keep" | "manual" | "from_bounds";
+    manualDurationMs?: number;
+  }
 ): boolean {
   const task = findTaskRecord(sess, taskId);
   if (!task) {
@@ -412,20 +490,39 @@ export function updateTaskStartTimeInSession(
   if (!Number.isFinite(startMs)) {
     return false;
   }
+  const boundEndRaw = typeof task.endTime === "string" ? task.endTime : "";
+  const boundEndMs = Date.parse(boundEndRaw);
+  if (Number.isFinite(boundEndMs) && startMs > boundEndMs) {
+    return false;
+  }
   const nowMs = Date.now();
+  const prevDurationMs =
+    typeof task.durationMs === "number" && Number.isFinite(task.durationMs) ? Math.max(0, Math.floor(task.durationMs)) : 0;
+  const mode = options?.durationAdjustMode ?? "from_bounds";
+  const manualMs =
+    typeof options?.manualDurationMs === "number" && Number.isFinite(options.manualDurationMs)
+      ? Math.max(0, Math.floor(options.manualDurationMs))
+      : null;
   task.startTime = new Date(startMs).toISOString();
-  const endRaw = typeof task.endTime === "string" ? task.endTime : "";
-  const endMs = Date.parse(endRaw);
-  if (Number.isFinite(endMs) && endMs >= startMs) {
+  const endMs = boundEndMs;
+  if (mode === "keep") {
+    task.durationMs = prevDurationMs;
+  } else if (mode === "manual" && manualMs !== null) {
+    task.durationMs = manualMs;
+  } else if (Number.isFinite(endMs) && endMs >= startMs) {
     task.durationMs = Math.max(0, Math.floor(endMs - startMs));
-    return true;
+  } else {
+    task.durationMs = Math.max(0, Math.floor(nowMs - startMs));
   }
-  task.durationMs = Math.max(0, Math.floor(nowMs - startMs));
   const subtaskRunning = String(task.activeSubtaskTimerId ?? "").trim() !== "";
   if (!subtaskRunning && task.manualTaskTimerPaused !== true && task.isDone !== true) {
     task[MAIN_TIMER_SEGMENT_STARTED_AT] = new Date(nowMs).toISOString();
   }
-  ensureTaskParentDurationCoversSubtasksMs(task);
+  // Ne pas réimposer la somme des sous-tâches après un recalcul explicite (bornes ou manuel) :
+  // sinon la durée choisie par l’utilisateur·rice est écrasée.
+  if (mode === "keep") {
+    ensureTaskParentDurationCoversSubtasksMs(task);
+  }
   return true;
 }
 
@@ -436,7 +533,11 @@ export function updateTaskStartTimeInSession(
 export function updateTaskEndTimeInSession(
   sess: Record<string, unknown>,
   taskId: string,
-  endTimeIso: string
+  endTimeIso: string,
+  options?: {
+    durationAdjustMode?: "keep" | "manual" | "from_bounds";
+    manualDurationMs?: number;
+  }
 ): boolean {
   const task = findTaskRecord(sess, taskId);
   if (!task || task.isDone !== true) {
@@ -451,9 +552,55 @@ export function updateTaskEndTimeInSession(
   if (!Number.isFinite(startMs) || endMs < startMs) {
     return false;
   }
+  const prevDurationMs =
+    typeof task.durationMs === "number" && Number.isFinite(task.durationMs) ? Math.max(0, Math.floor(task.durationMs)) : 0;
+  const mode = options?.durationAdjustMode ?? "from_bounds";
+  const manualMs =
+    typeof options?.manualDurationMs === "number" && Number.isFinite(options.manualDurationMs)
+      ? Math.max(0, Math.floor(options.manualDurationMs))
+      : null;
   task.endTime = new Date(endMs).toISOString();
-  task.durationMs = Math.max(0, Math.floor(endMs - startMs));
-  ensureTaskParentDurationCoversSubtasksMs(task);
+  if (mode === "keep") {
+    task.durationMs = prevDurationMs;
+  } else if (mode === "manual" && manualMs !== null) {
+    task.durationMs = manualMs;
+  } else {
+    task.durationMs = Math.max(0, Math.floor(endMs - startMs));
+  }
+  // Même logique que `updateTaskStartTimeInSession` : après « depuis début/fin » ou « manuel »,
+  // ne pas forcer le parent ≥ somme des sous-tâches (sinon le recalcul est annulé).
+  if (mode === "keep") {
+    ensureTaskParentDurationCoversSubtasksMs(task);
+  }
+  return true;
+}
+
+/**
+ * Programme une heure de fin pour une tâche en cours ; si l'échéance est déjà passée, termine la tâche à cet instant.
+ */
+export function scheduleTaskEndTimeInSession(
+  sess: Record<string, unknown>,
+  taskId: string,
+  endTimeIso: string,
+  nowMs = Date.now()
+): boolean {
+  const task = findTaskRecord(sess, taskId);
+  if (!task || task.isDone === true) {
+    return false;
+  }
+  const endMs = Date.parse(endTimeIso);
+  if (!Number.isFinite(endMs)) {
+    return false;
+  }
+  const startRaw = typeof task.startTime === "string" ? task.startTime : "";
+  const startMs = Date.parse(startRaw);
+  if (!Number.isFinite(startMs) || endMs < startMs) {
+    return false;
+  }
+  if (endMs <= nowMs) {
+    return finishTaskInSession(sess, taskId, false, undefined, { completionInstantMs: endMs });
+  }
+  task[TASK_SCHEDULED_END_AT] = new Date(endMs).toISOString();
   return true;
 }
 
@@ -536,7 +683,9 @@ export function setActiveSubtaskTimerInSession(
   prepareSessionForSubtaskTimer(sess, String(taskId));
   flushSubtaskTimerOnTask(task);
   task.activeSubtaskTimerId = sid;
-  task[SUBTASK_TIMER_STARTED_AT] = new Date().toISOString();
+  const nowIso = new Date().toISOString();
+  task[SUBTASK_TIMER_STARTED_AT] = nowIso;
+  task[TASK_CURRENT_LAP_STARTED_AT] = nowIso;
   task.manualTaskTimerPaused = false;
   return true;
 }
@@ -612,28 +761,43 @@ export function addHistoricalTaskToSession(
     name: string;
     tags: string[];
     project?: string | null;
+    personalProject?: boolean;
+    note?: string;
     durationMs: number;
     startTime: string;
     endTime: string;
   },
   newId: string,
   tagNormOpts?: TaskTagsStorageNormalizeOpts
-): void {
+): boolean {
+  const startMs = Date.parse(typeof input.startTime === "string" ? input.startTime : "");
+  const endMs = Date.parse(typeof input.endTime === "string" ? input.endTime : "");
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs <= startMs) {
+    return false;
+  }
+  const spanMs = endMs - startMs;
+  const dmRaw = typeof input.durationMs === "number" && Number.isFinite(input.durationMs) ? Math.floor(input.durationMs) : NaN;
+  if (!Number.isFinite(dmRaw) || dmRaw <= 0 || dmRaw > spanMs) {
+    return false;
+  }
   const task: Record<string, unknown> = {
     id: newId,
     name: input.name.trim(),
     startTime: input.startTime,
     endTime: input.endTime,
-    durationMs: input.durationMs,
+    durationMs: dmRaw,
     isDone: true,
     kronoFocusCycles: 0,
     tags: normalizeTaskTagsForStorage(input.tags, tagNormOpts),
     project: input.project ?? null,
+    personalProject: input.personalProject === true,
+    note: typeof input.note === "string" ? input.note : "",
     subtasks: [],
   };
   const tasks = getTasksArray(sess);
   tasks.push(task);
   sess.tasks = tasks;
+  return true;
 }
 
 function eachSessionRecord(p: KronosysUpdatePayload, fn: (sess: Record<string, unknown>) => void): void {
@@ -715,3 +879,152 @@ export function purgeProjectEverywhere(p: KronosysUpdatePayload, rawName: string
     }
   });
 }
+
+export function renameTagEverywhere(
+  p: KronosysUpdatePayload,
+  sourceRawTag: string,
+  targetRawTag: string,
+  tagNormOpts?: TaskTagsStorageNormalizeOpts
+): void {
+  const source = normalizeTagKey(sourceRawTag);
+  const target = normalizeTagKey(targetRawTag);
+  if (!source || !target || source.toLowerCase() === target.toLowerCase()) {
+    return;
+  }
+  const sourceL = source.toLowerCase();
+  const targetL = target.toLowerCase();
+  const remapUnique = (list: string[]): string[] => {
+    const out: string[] = [];
+    const seen = new Set<string>();
+    for (const raw of list) {
+      const n = normalizeTagKey(raw);
+      if (!n) {
+        continue;
+      }
+      const lk = n.toLowerCase();
+      const mapped = lk === sourceL ? target : n;
+      const mk = mapped.toLowerCase();
+      if (seen.has(mk)) {
+        continue;
+      }
+      seen.add(mk);
+      out.push(mapped);
+    }
+    return out;
+  };
+  p.knownTags = remapUnique((p.knownTags || []) as string[]);
+  p.userKnownTags = remapUnique((p.userKnownTags || []) as string[]);
+  p.excludedSuggestionTags = remapUnique((p.excludedSuggestionTags || []) as string[]);
+  const td = { ...(asRecord(p.tagDescriptions) ?? {}) } as Record<string, string>;
+  const sourceDesc = typeof td[sourceL] === "string" ? td[sourceL] : "";
+  if (sourceDesc && !td[targetL]) {
+    td[targetL] = sourceDesc;
+  }
+  delete td[sourceL];
+  p.tagDescriptions = td;
+  eachSessionRecord(p, (sess) => {
+    for (const t of [...getActiveTasksArray(sess), ...getTasksArray(sess)]) {
+      if (!Array.isArray(t.tags)) {
+        continue;
+      }
+      const mapped = (t.tags as string[]).map((x) => {
+        const n = normalizeTagKey(x);
+        return n.toLowerCase() === sourceL ? target : n;
+      });
+      t.tags = normalizeTaskTagsForStorage(mapped, tagNormOpts);
+    }
+    const at = asRecord(sess.activeTask);
+    if (!at || !Array.isArray(at.tags)) {
+      return;
+    }
+    const mapped = (at.tags as string[]).map((x) => {
+      const n = normalizeTagKey(x);
+      return n.toLowerCase() === sourceL ? target : n;
+    });
+    at.tags = normalizeTaskTagsForStorage(mapped, tagNormOpts);
+  });
+}
+
+export function renameProjectEverywhere(
+  p: KronosysUpdatePayload,
+  sourceRawName: string,
+  targetRawName: string,
+  opts?: { personalOnly?: boolean },
+): void {
+  const source = normalizeProjectKey(sourceRawName);
+  const target = normalizeProjectKey(targetRawName);
+  if (!source || !target || source.toLowerCase() === target.toLowerCase()) {
+    return;
+  }
+  const sourceL = source.toLowerCase();
+  const targetL = target.toLowerCase();
+  const personalOnly = opts?.personalOnly === true;
+
+  if (personalOnly) {
+    const known: string[] = [];
+    const seen = new Set<string>();
+    for (const raw of (((p as Record<string, unknown>).knownPersonalProjects || []) as string[])) {
+      const n = normalizeProjectKey(raw);
+      if (!n) {
+        continue;
+      }
+      const mapped = n.toLowerCase() === sourceL ? target : n;
+      const lk = mapped.toLowerCase();
+      if (seen.has(lk)) {
+        continue;
+      }
+      seen.add(lk);
+      known.push(mapped);
+    }
+    (p as Record<string, unknown>).knownPersonalProjects = known;
+  } else {
+    const known: string[] = [];
+    const seen = new Set<string>();
+    for (const raw of (p.knownProjects || []) as string[]) {
+      const n = normalizeProjectKey(raw);
+      if (!n) {
+        continue;
+      }
+      const mapped = n.toLowerCase() === sourceL ? target : n;
+      const lk = mapped.toLowerCase();
+      if (seen.has(lk)) {
+        continue;
+      }
+      seen.add(lk);
+      known.push(mapped);
+    }
+    p.knownProjects = known;
+  }
+
+  const pd = { ...(asRecord(p.projectDescriptions) ?? {}) } as Record<string, string>;
+  const sourceDesc = typeof pd[sourceL] === "string" ? pd[sourceL] : "";
+  if (sourceDesc && !pd[targetL]) {
+    pd[targetL] = sourceDesc;
+  }
+  delete pd[sourceL];
+  p.projectDescriptions = pd;
+  eachSessionRecord(p, (sess) => {
+    for (const t of [...getActiveTasksArray(sess), ...getTasksArray(sess)]) {
+      const proj = typeof t.project === "string" ? normalizeProjectKey(t.project) : "";
+      if (proj.toLowerCase() !== sourceL) {
+        continue;
+      }
+      const isPersonal = t.personalProject === true;
+      if (personalOnly !== isPersonal) {
+        continue;
+      }
+      t.project = target;
+    }
+    const at = asRecord(sess.activeTask);
+    if (!at) {
+      return;
+    }
+    const proj = typeof at.project === "string" ? normalizeProjectKey(at.project) : "";
+    if (proj.toLowerCase() === sourceL) {
+      const isPersonal = at.personalProject === true;
+      if (personalOnly === isPersonal) {
+        at.project = target;
+      }
+    }
+  });
+}

package/server/db.ts

@@ -1,11 +1,12 @@
-import Database from "better-sqlite3";
+import { DatabaseSync } from "node:sqlite";
 import * as path from "node:path";
 
 import { ensureDataDirectory, resetDataDirectoryCache } from "@/lib/dataDir";
+import { ensureCoreSchema } from "./dbSchema";
 
 const DB_NAME = "kronosys.sqlite";
 
-let db: Database.Database | null = null;
+let db: DatabaseSync | null = null;
 
 /** Ferme la connexion SQLite (tests ou changement de `TRACE_DATA_DIR` / cache de résolution). */
 export function resetSqliteConnection(): void {
@@ -20,23 +21,14 @@ export function resetSqliteConnection(): void {
   resetDataDirectoryCache();
 }
 
-export function getSqlite(): Database.Database {
+export function getSqlite(): DatabaseSync {
   if (db) {
     return db;
   }
   const dir = ensureDataDirectory();
   const file = path.join(dir, DB_NAME);
-  db = new Database(file);
-  db.pragma("journal_mode = WAL");
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS app_meta (
-      key TEXT PRIMARY KEY NOT NULL,
-      value TEXT NOT NULL
-    );
-    CREATE TABLE IF NOT EXISTS kv_store (
-      k TEXT PRIMARY KEY NOT NULL,
-      v TEXT NOT NULL
-    );
-  `);
+  db = new DatabaseSync(file);
+  db.exec("PRAGMA journal_mode = WAL;");
+  ensureCoreSchema(db);
   return db;
 }

package/server/dbSchema.ts

@@ -0,0 +1,24 @@
+import type { DatabaseSync } from "node:sqlite";
+
+export function ensureCoreSchema(db: DatabaseSync): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS app_meta (
+      key TEXT PRIMARY KEY NOT NULL,
+      value TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS kv_store (
+      k TEXT PRIMARY KEY NOT NULL,
+      v TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS user_action_logs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      created_at TEXT NOT NULL,
+      action_type TEXT NOT NULL,
+      ok INTEGER NOT NULL,
+      source_ip TEXT,
+      user_agent TEXT,
+      session_id TEXT,
+      payload_json TEXT
+    );
+  `);
+}

package/server/defaultCfg.ts

@@ -70,6 +70,11 @@ export function defaultKronosysCfg(): Record<string, unknown> {
     dashboardDisplayTimeZone: "America/Toronto",
     /** Affichage des heures : `true` = 24 h, `false` = 12 h (AM/PM). */
     dashboardUse24HourClock: true,
+    /**
+     * Gabarit appliqué au libellé de session lors du `newSession` (motif façon POSIX strftime ; voir aussi `%UUID`).
+     * Chaîne vide = aucun nom par défaut (champ vide comme aujourd’hui).
+     */
+    dashboardDefaultSessionNameTemplate: "",
     scheduleEnabled: false,
     scheduleDays: [1, 2, 3, 4, 5],
     scheduleStartTime: "09:00",

package/server/gitlabTokenStore.ts

@@ -6,17 +6,7 @@ import { getSqlite } from "./db";
  */
 const GITLAB_PAT_KV_KEY = "gitlab_secret_pat_v1";
 
-function ensureKv(): void {
-  getSqlite().exec(`
-    CREATE TABLE IF NOT EXISTS kv_store (
-      k TEXT PRIMARY KEY NOT NULL,
-      v TEXT NOT NULL
-    );
-  `);
-}
-
 export function readGitlabPatFromStore(): string {
-  ensureKv();
   const row = getSqlite().prepare("SELECT v FROM kv_store WHERE k = ?").get(GITLAB_PAT_KV_KEY) as
     | { v: string }
     | undefined;
@@ -24,11 +14,9 @@ export function readGitlabPatFromStore(): string {
 }
 
 export function writeGitlabPatToStore(token: string): void {
-  ensureKv();
   getSqlite().prepare("INSERT OR REPLACE INTO kv_store (k, v) VALUES (?, ?)").run(GITLAB_PAT_KV_KEY, token);
 }
 
 export function clearGitlabPatFromStore(): void {
-  ensureKv();
   getSqlite().prepare("DELETE FROM kv_store WHERE k = ?").run(GITLAB_PAT_KV_KEY);
 }

package/server/liveHistorySync.ts

@@ -0,0 +1,53 @@
+import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
+import {
+  normalizeSessionEndReasonKind,
+  normalizeSessionEndReasonNote,
+} from "@/lib/sessionEndReason";
+
+import { asRecord } from "./actionTaskSession";
+
+/** Copie l’instantané de la session live en tête de `history` (sans vider `current`). */
+export function syncLiveIntoHistory(p: KronosysUpdatePayload): void {
+  const cur = asRecord(p.current);
+  if (!cur) {
+    return;
+  }
+  const sid = typeof cur.sessionId === "string" ? cur.sessionId.trim() : "";
+  if (!sid) {
+    return;
+  }
+  const hist = ([...(p.history || [])] as Record<string, unknown>[]).filter((h) => h.sessionId !== sid);
+  const snap: Record<string, unknown> = {
+    sessionId: sid,
+    sessionName: cur.sessionName ?? "",
+    sessionNote: cur.sessionNote ?? "",
+    savedAt: new Date().toISOString(),
+    createdAt: cur.createdAt ?? cur.startAt ?? null,
+    startAt: cur.startAt ?? null,
+    endAt: cur.endAt ?? null,
+    sessionDurationMinutes: cur.sessionDurationMinutes,
+    tasks: cur.tasks ?? [],
+    activeTasks: cur.activeTasks ?? [],
+    activeTask: cur.activeTask ?? null,
+    archived: cur.archived === true,
+  };
+  if (typeof cur.scheduledStartAt === "string" && cur.scheduledStartAt.trim() !== "") {
+    snap.scheduledStartAt = cur.scheduledStartAt;
+  }
+  if (
+    typeof cur.sessionStartOffsetMinutes === "number" &&
+    Number.isFinite(cur.sessionStartOffsetMinutes)
+  ) {
+    snap.sessionStartOffsetMinutes = cur.sessionStartOffsetMinutes;
+  }
+  const rk = normalizeSessionEndReasonKind(cur.sessionEndReasonKind);
+  if (rk) {
+    snap.sessionEndReasonKind = rk;
+  }
+  const rn = normalizeSessionEndReasonNote(cur.sessionEndReasonNote);
+  if (rn.length > 0) {
+    snap.sessionEndReasonNote = rn;
+  }
+  hist.unshift(snap);
+  p.history = hist;
+}