@nightkatana/kronosys-app 1.0.0-beta.0

package/lib/dataDir.test.ts

@@ -0,0 +1,87 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const readUseProd = vi.hoisted(() => vi.fn(() => false));
+
+vi.mock("@/lib/devDataPreferenceFile", async (importOriginal) => {
+  const mod = await importOriginal<typeof import("@/lib/devDataPreferenceFile")>();
+  return {
+    ...mod,
+    readUseProductionDataInDevelopmentFromFile: () => readUseProd(),
+  };
+});
+
+import {
+  computeDataDirectoryForCurrentProcessEnv,
+  resetDataDirectoryCache,
+  resolveProductionDefaultDataDirectory,
+} from "./dataDir";
+import { resetSqliteConnection } from "@/server/db";
+
+describe("dataDir (dev / prod isolation)", () => {
+  const origNodeEnv = process.env.NODE_ENV;
+  const origTrace = process.env.TRACE_DATA_DIR;
+  const origKrono = process.env.KRONOSYS_DEV_USE_PROD_DATA;
+  const env = process.env as Record<string, string | undefined>;
+
+  beforeEach(() => {
+    readUseProd.mockReturnValue(false);
+    delete process.env.TRACE_DATA_DIR;
+    delete process.env.KRONOSYS_DEV_USE_PROD_DATA;
+    resetDataDirectoryCache();
+    resetSqliteConnection();
+  });
+
+  afterEach(() => {
+    if (origNodeEnv === undefined) {
+      delete env.NODE_ENV;
+    } else {
+      env.NODE_ENV = origNodeEnv;
+    }
+    if (origTrace === undefined) {
+      delete process.env.TRACE_DATA_DIR;
+    } else {
+      process.env.TRACE_DATA_DIR = origTrace;
+    }
+    if (origKrono === undefined) {
+      delete process.env.KRONOSYS_DEV_USE_PROD_DATA;
+    } else {
+      process.env.KRONOSYS_DEV_USE_PROD_DATA = origKrono;
+    }
+    readUseProd.mockReset();
+    readUseProd.mockReturnValue(false);
+    resetDataDirectoryCache();
+    resetSqliteConnection();
+  });
+
+  it("uses TRACE_DATA_DIR when set", () => {
+    env.NODE_ENV = "development";
+    process.env.TRACE_DATA_DIR = "/tmp/kronosys-trace-xyz";
+    expect(computeDataDirectoryForCurrentProcessEnv()).toBe("/tmp/kronosys-trace-xyz");
+  });
+
+  it("uses v4 for non-development NODE_ENV", () => {
+    env.NODE_ENV = "production";
+    const prod = resolveProductionDefaultDataDirectory();
+    expect(computeDataDirectoryForCurrentProcessEnv()).toBe(prod);
+  });
+
+  it("uses v4-dev in development by default (isolated file preference off)", () => {
+    env.NODE_ENV = "development";
+    const prod = resolveProductionDefaultDataDirectory();
+    const got = computeDataDirectoryForCurrentProcessEnv();
+    expect(got).not.toBe(prod);
+    expect(got).toMatch(/[\\/]v4-dev$/);
+  });
+
+  it("uses production v4 in development when KRONOSYS_DEV_USE_PROD_DATA is set", () => {
+    env.NODE_ENV = "development";
+    process.env.KRONOSYS_DEV_USE_PROD_DATA = "1";
+    expect(computeDataDirectoryForCurrentProcessEnv()).toBe(resolveProductionDefaultDataDirectory());
+  });
+
+  it("uses production v4 in development when file preference is on", () => {
+    env.NODE_ENV = "development";
+    readUseProd.mockReturnValue(true);
+    expect(computeDataDirectoryForCurrentProcessEnv()).toBe(resolveProductionDefaultDataDirectory());
+  });
+});

package/lib/dataDir.ts

@@ -0,0 +1,83 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import {
+  isTruthyDevUseProdEnv,
+  readUseProductionDataInDevelopmentFromFile,
+} from "@/lib/devDataPreferenceFile";
+
+type VersionSegment = "v4" | "v4-dev";
+
+let resolvedDataDirCache: string | null = null;
+
+function userDataRootWithSegment(segment: VersionSegment): string {
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support", "Kronosys", segment);
+  }
+  if (process.platform === "win32") {
+    const base = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+    return path.join(base, "Kronosys", segment);
+  }
+  return path.join(os.homedir(), ".local", "share", "kronosys", segment);
+}
+
+/**
+ * Répertoire « production » (instance packagée / `next start`), segment `v4` — pour affichage et comparaison.
+ */
+export function resolveProductionDefaultDataDirectory(): string {
+  return userDataRootWithSegment("v4");
+}
+
+/**
+ * Résout le chemin de données en fonction de l’environnement actuel, sans tenir compte du cache de processus.
+ * Utilisé pour afficher l’endroit qu’impliquerait le redémarrage après changement d’option.
+ */
+export function computeDataDirectoryForCurrentProcessEnv(): string {
+  const override = process.env.TRACE_DATA_DIR?.trim();
+  if (override) {
+    return path.resolve(override);
+  }
+  if (process.env.NODE_ENV !== "development") {
+    return userDataRootWithSegment("v4");
+  }
+  if (isTruthyDevUseProdEnv(process.env.KRONOSYS_DEV_USE_PROD_DATA)) {
+    return userDataRootWithSegment("v4");
+  }
+  if (readUseProductionDataInDevelopmentFromFile()) {
+    return userDataRootWithSegment("v4");
+  }
+  return userDataRootWithSegment("v4-dev");
+}
+
+/**
+ * Répertoire des données locales (SQLite). Surcharge : `TRACE_DATA_DIR`.
+ * Sous `next dev`, défaut : segment `v4-dev` (isolé) sauf préférence fichier ou `KRONOSYS_DEV_USE_PROD_DATA`.
+ */
+export function resolveDataDirectory(): string {
+  if (!resolvedDataDirCache) {
+    resolvedDataDirCache = computeDataDirectoryForCurrentProcessEnv();
+  }
+  return resolvedDataDirCache;
+}
+
+/**
+ * Lorsque la préférence ou les variables d’environnement ont changé sur le disque, le chemin « préféré »
+ * peut différer de celui utilisé par le processus (cache SQLite) jusqu’au redémarrage du serveur.
+ */
+export function dataDirectoryResolutionIsStale(): boolean {
+  return resolveDataDirectory() !== computeDataDirectoryForCurrentProcessEnv();
+}
+
+export function resetDataDirectoryCache(): void {
+  resolvedDataDirCache = null;
+}
+
+export function ensureDataDirectory(): string {
+  const dir = resolveDataDirectory();
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/** Expose le chemin du fichier de préférence (hors v4) pour l’UI paramètres. */
+export { getDevDataPreferenceFilePath } from "./devDataPreferenceFile";

package/lib/devDataPreferenceFile.ts

@@ -0,0 +1,55 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const FILE_NAME = "dev-data-preference.json";
+
+type DevDataPreferenceFile = {
+  /** Lorsque `true`, `next dev` utilise le même répertoire que l’exécutable de production (`v4`). */
+  useProductionDataInDevelopment?: boolean;
+};
+
+function preferenceFilePath(): string {
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support", "Kronosys", FILE_NAME);
+  }
+  if (process.platform === "win32") {
+    const base = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+    return path.join(base, "Kronosys", FILE_NAME);
+  }
+  return path.join(os.homedir(), ".config", "kronosys", FILE_NAME);
+}
+
+/**
+ * Fichier hors `v4` / `v4-dev` : préférence pour partager le coffre avec la prod en mode `next dev`.
+ * Ne s’applique pas si `TRACE_DATA_DIR` est défini.
+ */
+export function getDevDataPreferenceFilePath(): string {
+  return preferenceFilePath();
+}
+
+export function readUseProductionDataInDevelopmentFromFile(): boolean {
+  const p = preferenceFilePath();
+  try {
+    const raw = fs.readFileSync(p, "utf8");
+    const j = JSON.parse(raw) as DevDataPreferenceFile;
+    return j.useProductionDataInDevelopment === true;
+  } catch {
+    return false;
+  }
+}
+
+export function writeUseProductionDataInDevelopmentToFile(value: boolean): void {
+  const p = preferenceFilePath();
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  const body: DevDataPreferenceFile = { useProductionDataInDevelopment: value };
+  fs.writeFileSync(p, `${JSON.stringify(body, null, 2)}\n`, "utf8");
+}
+
+export function isTruthyDevUseProdEnv(value: string | undefined): boolean {
+  if (!value) {
+    return false;
+  }
+  const v = value.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes" || v === "on";
+}

package/lib/devDataRuntimeInfo.ts

@@ -0,0 +1,34 @@
+import {
+  getDevDataPreferenceFilePath,
+  isTruthyDevUseProdEnv,
+  readUseProductionDataInDevelopmentFromFile,
+} from "@/lib/devDataPreferenceFile";
+import {
+  computeDataDirectoryForCurrentProcessEnv,
+  dataDirectoryResolutionIsStale,
+  resolveDataDirectory,
+  resolveProductionDefaultDataDirectory,
+} from "@/lib/dataDir";
+import type { DevDataRuntimeInfo } from "@/lib/kronosysApi";
+
+/**
+ * Aperçu côté serveur pour l’isolation des données en `next dev` (répertoire distinct de `next start`).
+ */
+export function getDevDataRuntimeInfo(): DevDataRuntimeInfo {
+  const traceDataDirOverride = Boolean(process.env.TRACE_DATA_DIR?.trim());
+  const isNextDevelopment = process.env.NODE_ENV === "development";
+  const envForcesProductionData =
+    isNextDevelopment && isTruthyDevUseProdEnv(process.env.KRONOSYS_DEV_USE_PROD_DATA);
+  const useProductionDataInDevelopment = readUseProductionDataInDevelopmentFromFile();
+  return {
+    isNextDevelopment,
+    traceDataDirOverride,
+    envForcesProductionData,
+    useProductionDataInDevelopment,
+    activeDataDirectory: resolveDataDirectory(),
+    preferredDataDirectory: computeDataDirectoryForCurrentProcessEnv(),
+    dataDirectoryResolutionMismatch: dataDirectoryResolutionIsStale(),
+    preferencesFilePath: getDevDataPreferenceFilePath(),
+    productionDataDirectory: resolveProductionDefaultDataDirectory(),
+  };
+}

package/lib/formatIsoShort.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+
+import { formatIsoInstantShort } from "./formatIsoShort";
+
+describe("formatIsoInstantShort", () => {
+  it("retourne null pour une chaîne vide", () => {
+    expect(formatIsoInstantShort("", "fr")).toBeNull();
+    expect(formatIsoInstantShort("   ", "fr")).toBeNull();
+  });
+
+  it("retourne null pour une date invalide", () => {
+    expect(formatIsoInstantShort("pas-une-date", "fr")).toBeNull();
+    expect(formatIsoInstantShort("9999-99-99", "fr")).toBeNull();
+  });
+
+  it("retourne une chaîne non vide pour une date ISO valide en fr", () => {
+    const result = formatIsoInstantShort("2026-04-29T12:00:00Z", "fr");
+    expect(result).not.toBeNull();
+    expect(typeof result).toBe("string");
+    expect((result as string).length).toBeGreaterThan(0);
+  });
+
+  it("retourne une chaîne non vide pour une date ISO valide en en", () => {
+    const result = formatIsoInstantShort("2026-04-29T12:00:00Z", "en");
+    expect(result).not.toBeNull();
+    expect(typeof result).toBe("string");
+  });
+
+  it("fr utilise le locale fr-CA (pas en-CA)", () => {
+    // fr-CA formate typiquement aa-mm-jj hh:mm alors qu'en-CA est différent
+    const fr = formatIsoInstantShort("2026-01-15T00:00:00Z", "fr");
+    const en = formatIsoInstantShort("2026-01-15T00:00:00Z", "en");
+    expect(fr).not.toEqual(en);
+  });
+
+  it("supporte les dates sans timezone explicite (heure locale)", () => {
+    const result = formatIsoInstantShort("2026-06-01T08:30:00", "fr");
+    expect(result).not.toBeNull();
+  });
+
+  it("supporte les timestamps millis (new Date via ISO)", () => {
+    const iso = new Date(2026, 3, 1, 9, 0, 0).toISOString();
+    const result = formatIsoInstantShort(iso, "en");
+    expect(result).not.toBeNull();
+  });
+});

package/lib/formatIsoShort.ts

@@ -0,0 +1,29 @@
+import type { Lang } from "@/lib/dashboardCopy";
+import { DEFAULT_DASHBOARD_TIME_ZONE, isValidIanaTimeZone } from "@/lib/dashboardTimeZone";
+
+/** Affiche une date-heure ISO en style court cohérent avec le sélecteur de tâche passée. */
+export function formatIsoInstantShort(
+  iso: string,
+  lang: Lang,
+  timeZone: string = DEFAULT_DASHBOARD_TIME_ZONE,
+  use24HourClock: boolean = true
+): string | null {
+  const raw = iso.trim();
+  if (!raw) {
+    return null;
+  }
+  const d = new Date(raw);
+  if (Number.isNaN(d.getTime())) {
+    return null;
+  }
+  const tz = timeZone.trim();
+  const opts: Intl.DateTimeFormatOptions = {
+    dateStyle: "short",
+    timeStyle: "short",
+    hour12: !use24HourClock,
+  };
+  if (tz && isValidIanaTimeZone(tz)) {
+    opts.timeZone = tz;
+  }
+  return new Intl.DateTimeFormat(lang === "fr" ? "fr-CA" : "en-CA", opts).format(d);
+}

package/lib/generatedUserChangelog.ts

@@ -0,0 +1,34 @@
+/* Auto-generated by scripts/build-user-changelog.mjs. Do not edit manually. */
+export type UserChangelogEntry = {
+  version: string;
+  items: string[];
+};
+
+export const USER_CHANGELOG_ENTRIES: UserChangelogEntry[] = [
+  {
+    "version": "3.0.0",
+    "items": [
+      "aefaf9e: Première version officielle publiée."
+    ]
+  },
+  {
+    "version": "2.0.0",
+    "items": [
+      "aefaf9e: Première version officielle publiée."
+    ]
+  },
+  {
+    "version": "1.0.0",
+    "items": [
+      "aefaf9e: Première version officielle publiée."
+    ]
+  },
+  {
+    "version": "0.1.1",
+    "items": [
+      "Added an in-app user CHANGELOG page (`/changelog`).",
+      "Added an update modal on Dashboard startup that opens the CHANGELOG after a version change.",
+      "Added browser-local tracking of the last seen app version to show update notes once per version."
+    ]
+  }
+];

package/lib/gitlabIssueSearch.ts

@@ -0,0 +1,8 @@
+/** Délai maximal côté serveur pour un GET GitLab `/api/v4/issues` lors d’une recherche. */
+export const GITLAB_ISSUES_SEARCH_TIMEOUT_MS = 12_000;
+
+/**
+ * Délai maximal côté navigateur pour l’action `fetchRemoteIssues` (navigateur → API locale).
+ * Légère marge au-dessus du timeout GitLab pour laisser le serveur renvoyer une erreur structurée.
+ */
+export const TRACE_ISSUE_SEARCH_CLIENT_TIMEOUT_MS = GITLAB_ISSUES_SEARCH_TIMEOUT_MS + 5000;

package/lib/kronoFocusDurationHistory.ts

@@ -0,0 +1,71 @@
+/** Plage alignée sur le panneau KronoFocus (édition durée de travail). */
+const MAX_WORK_SEC = 8 * 3600;
+
+const STORAGE_KEY = "kronosys-kronoFocus-duration-custom-v1";
+
+/** Nombre maximal de durées personnalisées mémorisées (hors défaut 25 min). */
+export const MAX_KRONO_FOCUS_CUSTOM_DURATION_SLOTS = 12;
+
+/**
+ * Charge les durées personnalisées (secondes), les plus récentes en premier.
+ * Exclut la durée par défaut ; valeurs hors plage filtrées.
+ */
+export function loadKronoFocusDurationHistory(defaultWorkSec: number): number[] {
+  if (typeof window === "undefined") return [];
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw) as unknown;
+    if (!Array.isArray(parsed)) return [];
+    const seen = new Set<number>();
+    const out: number[] = [];
+    for (const item of parsed) {
+      const n = typeof item === "number" ? item : Number(item);
+      if (!Number.isFinite(n)) continue;
+      const s = Math.max(60, Math.min(MAX_WORK_SEC, Math.floor(n)));
+      if (s === defaultWorkSec) continue;
+      if (seen.has(s)) continue;
+      seen.add(s);
+      out.push(s);
+      if (out.length >= MAX_KRONO_FOCUS_CUSTOM_DURATION_SLOTS) break;
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+
+export function persistKronoFocusDurationHistory(entries: number[]): void {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.setItem(
+      STORAGE_KEY,
+      JSON.stringify(entries.slice(0, MAX_KRONO_FOCUS_CUSTOM_DURATION_SLOTS)),
+    );
+  } catch {
+    /* quota, navigation privée, etc. */
+  }
+}
+
+/** Supprime toutes les durées personnalisées mémorisées (le défaut 25 min n’y figure pas). */
+export function clearKronoFocusDurationHistory(): void {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.removeItem(STORAGE_KEY);
+  } catch {
+    /* ignore */
+  }
+}
+
+/**
+ * Après une durée appliquée avec succès : met la durée en tête de l’historique si elle n’est pas le défaut.
+ */
+export function pushKronoFocusDurationHistory(
+  previous: number[],
+  appliedSeconds: number,
+  defaultWorkSec: number,
+): number[] {
+  const s = Math.max(60, Math.min(MAX_WORK_SEC, Math.floor(appliedSeconds)));
+  if (s === defaultWorkSec) return previous;
+  return [s, ...previous.filter((x) => x !== s)].slice(0, MAX_KRONO_FOCUS_CUSTOM_DURATION_SLOTS);
+}

package/lib/kronoFocusRhythm.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  KRONO_FOCUS_MAX_BREAK_SEC,
+  KRONO_FOCUS_MAX_WORK_SEC,
+  KRONO_FOCUS_MIN_SEGMENT_SEC,
+  KRONO_FOCUS_RHYTHM_PRESETS,
+  clampBreakDurationSeconds,
+  clampWorkDurationSeconds,
+  readLongBreakDurationSeconds,
+  readShortBreakDurationSeconds,
+  readWorkDurationSeconds,
+} from "./kronoFocusRhythm";
+
+describe("constantes", () => {
+  it("KRONO_FOCUS_MIN_SEGMENT_SEC = 60s", () => {
+    expect(KRONO_FOCUS_MIN_SEGMENT_SEC).toBe(60);
+  });
+
+  it("KRONO_FOCUS_MAX_WORK_SEC = 8h", () => {
+    expect(KRONO_FOCUS_MAX_WORK_SEC).toBe(8 * 3600);
+  });
+
+  it("KRONO_FOCUS_MAX_BREAK_SEC = 8h", () => {
+    expect(KRONO_FOCUS_MAX_BREAK_SEC).toBe(8 * 3600);
+  });
+});
+
+describe("clampWorkDurationSeconds", () => {
+  it("valeur dans la plage → retournée telle quelle (floor)", () => {
+    expect(clampWorkDurationSeconds(25 * 60)).toBe(25 * 60);
+  });
+
+  it("valeur inférieure au minimum → ramenée à 60s", () => {
+    expect(clampWorkDurationSeconds(0)).toBe(60);
+    expect(clampWorkDurationSeconds(30)).toBe(60);
+  });
+
+  it("valeur supérieure au maximum → ramenée à 8h", () => {
+    expect(clampWorkDurationSeconds(9 * 3600)).toBe(8 * 3600);
+  });
+
+  it("applique Math.floor sur les décimales", () => {
+    expect(clampWorkDurationSeconds(90.9)).toBe(90);
+  });
+});
+
+describe("clampBreakDurationSeconds", () => {
+  it("valeur dans la plage → retournée telle quelle", () => {
+    expect(clampBreakDurationSeconds(5 * 60)).toBe(5 * 60);
+  });
+
+  it("valeur inférieure au minimum → 60s", () => {
+    expect(clampBreakDurationSeconds(10)).toBe(60);
+  });
+
+  it("valeur supérieure au maximum → 8h", () => {
+    expect(clampBreakDurationSeconds(9 * 3600)).toBe(8 * 3600);
+  });
+});
+
+describe("readWorkDurationSeconds", () => {
+  it("retourne le défaut 25min si pm est undefined", () => {
+    expect(readWorkDurationSeconds(undefined)).toBe(25 * 60);
+  });
+
+  it("retourne la valeur du payload si valide", () => {
+    expect(readWorkDurationSeconds({ workDurationSeconds: 50 * 60 })).toBe(50 * 60);
+  });
+
+  it("retourne le défaut si la valeur est inférieure au minimum", () => {
+    expect(readWorkDurationSeconds({ workDurationSeconds: 30 })).toBe(25 * 60);
+  });
+
+  it("retourne le défaut si la valeur est non numérique", () => {
+    expect(readWorkDurationSeconds({ workDurationSeconds: "abc" })).toBe(25 * 60);
+  });
+
+  it("retourne le défaut si la valeur est Infinity", () => {
+    expect(readWorkDurationSeconds({ workDurationSeconds: Infinity })).toBe(25 * 60);
+  });
+
+  it("clamp la valeur si elle dépasse le maximum", () => {
+    expect(readWorkDurationSeconds({ workDurationSeconds: 9 * 3600 })).toBe(8 * 3600);
+  });
+});
+
+describe("readShortBreakDurationSeconds", () => {
+  it("retourne le défaut 5min si pm est undefined", () => {
+    expect(readShortBreakDurationSeconds(undefined)).toBe(5 * 60);
+  });
+
+  it("retourne la valeur du payload si valide", () => {
+    expect(readShortBreakDurationSeconds({ shortBreakDurationSeconds: 10 * 60 })).toBe(10 * 60);
+  });
+
+  it("retourne le défaut si la valeur est trop petite", () => {
+    expect(readShortBreakDurationSeconds({ shortBreakDurationSeconds: 10 })).toBe(5 * 60);
+  });
+});
+
+describe("readLongBreakDurationSeconds", () => {
+  it("retourne le défaut 15min si pm est undefined", () => {
+    expect(readLongBreakDurationSeconds(undefined)).toBe(15 * 60);
+  });
+
+  it("retourne la valeur du payload si valide", () => {
+    expect(readLongBreakDurationSeconds({ longBreakDurationSeconds: 20 * 60 })).toBe(20 * 60);
+  });
+});
+
+describe("KRONO_FOCUS_RHYTHM_PRESETS", () => {
+  it("contient 4 presets", () => {
+    expect(KRONO_FOCUS_RHYTHM_PRESETS).toHaveLength(4);
+  });
+
+  it("le premier preset est 25-5-15", () => {
+    const p = KRONO_FOCUS_RHYTHM_PRESETS[0];
+    expect(p.id).toBe("25-5-15");
+    expect(p.workSeconds).toBe(25 * 60);
+    expect(p.shortBreakSeconds).toBe(5 * 60);
+    expect(p.longBreakSeconds).toBe(15 * 60);
+  });
+
+  it("tous les presets ont workSeconds >= 60", () => {
+    for (const p of KRONO_FOCUS_RHYTHM_PRESETS) {
+      expect(p.workSeconds).toBeGreaterThanOrEqual(60);
+    }
+  });
+});

package/lib/kronoFocusRhythm.ts

@@ -0,0 +1,46 @@
+/** Durée minimale d’un segment (travail ou pause), en secondes. */
+export const KRONO_FOCUS_MIN_SEGMENT_SEC = 60;
+export const KRONO_FOCUS_MAX_WORK_SEC = 8 * 3600;
+export const KRONO_FOCUS_MAX_BREAK_SEC = 8 * 3600;
+
+export function clampWorkDurationSeconds(n: number): number {
+  return Math.max(KRONO_FOCUS_MIN_SEGMENT_SEC, Math.min(KRONO_FOCUS_MAX_WORK_SEC, Math.floor(n)));
+}
+
+export function clampBreakDurationSeconds(n: number): number {
+  return Math.max(KRONO_FOCUS_MIN_SEGMENT_SEC, Math.min(KRONO_FOCUS_MAX_BREAK_SEC, Math.floor(n)));
+}
+
+function readSeconds(
+  pm: Record<string, unknown> | undefined,
+  key: string,
+  fallback: number,
+  clamp: (n: number) => number,
+): number {
+  if (!pm) return fallback;
+  const v = pm[key];
+  if (typeof v === "number" && Number.isFinite(v) && v >= KRONO_FOCUS_MIN_SEGMENT_SEC) {
+    return clamp(v);
+  }
+  return fallback;
+}
+
+export function readWorkDurationSeconds(pm: Record<string, unknown> | undefined): number {
+  return readSeconds(pm, "workDurationSeconds", 25 * 60, clampWorkDurationSeconds);
+}
+
+export function readShortBreakDurationSeconds(pm: Record<string, unknown> | undefined): number {
+  return readSeconds(pm, "shortBreakDurationSeconds", 5 * 60, clampBreakDurationSeconds);
+}
+
+export function readLongBreakDurationSeconds(pm: Record<string, unknown> | undefined): number {
+  return readSeconds(pm, "longBreakDurationSeconds", 15 * 60, clampBreakDurationSeconds);
+}
+
+/** Presets « travail / pause courte / pause longue » (après chaque 4e segment de travail). */
+export const KRONO_FOCUS_RHYTHM_PRESETS = [
+  { id: "25-5-15", workSeconds: 25 * 60, shortBreakSeconds: 5 * 60, longBreakSeconds: 15 * 60 },
+  { id: "50-10-20", workSeconds: 50 * 60, shortBreakSeconds: 10 * 60, longBreakSeconds: 20 * 60 },
+  { id: "45-15-15", workSeconds: 45 * 60, shortBreakSeconds: 15 * 60, longBreakSeconds: 15 * 60 },
+  { id: "52-17-30", workSeconds: 52 * 60, shortBreakSeconds: 17 * 60, longBreakSeconds: 30 * 60 },
+] as const;