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

package/lib/backupCsvExport.test.ts

@@ -1,149 +0,0 @@
-import { unzipSync } from "fflate";
-import { describe, expect, it } from "vitest";
-import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
-import {
-  buildCsvBackupZipSync,
-  buildGitIdentityCsv,
-  buildSessionsBackupCsv,
-  buildStoreJsonBlobsCsv,
-  buildSubtasksBackupCsv,
-  buildTagDescriptionsCsv,
-  buildTagProjectRegistryCsv,
-  buildTasksBackupCsv,
-  isCsvBackupTable,
-} from "./backupCsvExport";
-
-function samplePayload(): KronosysUpdatePayload {
-  return {
-    viewType: "dashboard",
-    cfg: { autoStart: false, plannedSessions: [{ id: "p1" }] },
-    history: [
-      {
-        sessionId: "s-hist",
-        sessionName: "Hist",
-        startAt: "2026-04-01T10:00:00.000Z",
-        endAt: "2026-04-01T11:00:00.000Z",
-        savedAt: "2026-04-01T11:05:00.000Z",
-        sessionDurationMinutes: 60,
-        tasks: [
-          {
-            id: "t1",
-            name: "Do, thing",
-            tags: ["a", "b"],
-            project: "acme",
-            isDone: true,
-            durationMs: 3_600_000,
-            subtasks: [{ id: "st1", title: "Step, one", done: true, durationMs: 1000 }],
-          },
-        ],
-      },
-    ],
-    historyArchived: [
-      {
-        sessionId: "s-arch",
-        sessionName: "Arch",
-        savedAt: "2026-04-02T12:00:00.000Z",
-        tasks: [],
-      },
-    ],
-    current: {
-      sessionId: "s-live",
-      sessionName: "Live",
-      savedAt: "2026-04-03T08:00:00.000Z",
-      activeTasks: [{ id: "t2", name: "Running", isDone: false, durationMs: 0 }],
-      tasks: [],
-    },
-    knownTags: ["a"],
-    knownProjects: ["acme"],
-    userKnownTags: ["pinned"],
-    excludedSuggestionTags: ["hide-me"],
-    tagDescriptions: { alpha: "Desc, with comma" },
-    projectDescriptions: { acme: "Client" },
-    gitIdentity: { gitUserName: "n", gitUserEmail: "e@x.ca", gitAccountLogin: "gh" },
-    inspectingSessionId: "s-hist",
-    dismissArchiveSessionConfirm: true,
-  } as KronosysUpdatePayload;
-}
-
-describe("backupCsvExport", () => {
-  it("isCsvBackupTable reconnaît les noms de tables", () => {
-    expect(isCsvBackupTable("sessions")).toBe(true);
-    expect(isCsvBackupTable("nope")).toBe(false);
-  });
-
-  it("buildSessionsBackupCsv inclut la source et le JSON de session", () => {
-    const csv = buildSessionsBackupCsv(samplePayload());
-    expect(csv).toContain("scheduledStartAt");
-    expect(csv).toContain("sessionStartOffsetMinutes");
-    expect(csv).toContain("sessionSource");
-    expect(csv).toContain("s-hist");
-    expect(csv).toContain("history");
-    expect(csv).toContain("historyArchived");
-    expect(csv).toContain("current");
-    expect(csv).toContain("sessionJson");
-    expect(csv).toContain("Hist");
-  });
-
-  it("buildTasksBackupCsv échappe les virgules dans le nom et inclut taskJson", () => {
-    const csv = buildTasksBackupCsv(samplePayload());
-    expect(csv).toContain("Do, thing");
-    expect(csv).toContain("t1");
-    expect(csv).toContain("taskJson");
-    expect(csv).toContain('""id"":""t1""');
-  });
-
-  it("buildSubtasksBackupCsv liste les sous-tâches", () => {
-    const csv = buildSubtasksBackupCsv(samplePayload());
-    expect(csv).toContain("st1");
-    expect(csv).toContain("Step, one");
-  });
-
-  it("buildTagProjectRegistryCsv couvre les quatre listes", () => {
-    const csv = buildTagProjectRegistryCsv(samplePayload());
-    expect(csv).toContain("known_tag,a");
-    expect(csv).toContain("known_project,acme");
-    expect(csv).toContain("user_known_tag,pinned");
-    expect(csv).toContain("excluded_suggestion_tag,hide-me");
-  });
-
-  it("buildTagDescriptionsCsv échappe les descriptions", () => {
-    const csv = buildTagDescriptionsCsv(samplePayload());
-    expect(csv).toContain("alpha");
-    expect(csv).toContain("Desc, with comma");
-  });
-
-  it("buildGitIdentityCsv exporte les trois champs", () => {
-    const csv = buildGitIdentityCsv(samplePayload());
-    expect(csv.split("\n")[1]).toContain("n");
-    expect(csv.split("\n")[1]).toContain("e@x.ca");
-    expect(csv.split("\n")[1]).toContain("gh");
-  });
-
-  it("buildCsvBackupZipSync regroupe les huit CSV", () => {
-    const stamp = "TEST-STAMP";
-    const zip = buildCsvBackupZipSync(samplePayload(), stamp);
-    const entries = unzipSync(zip);
-    const names = Object.keys(entries).sort();
-    expect(names).toEqual([
-      `kronosys-git_identity-${stamp}.csv`,
-      `kronosys-project_descriptions-${stamp}.csv`,
-      `kronosys-sessions-${stamp}.csv`,
-      `kronosys-store_json_blobs-${stamp}.csv`,
-      `kronosys-subtasks-${stamp}.csv`,
-      `kronosys-tag_descriptions-${stamp}.csv`,
-      `kronosys-tag_project_registry-${stamp}.csv`,
-      `kronosys-tasks-${stamp}.csv`,
-    ]);
-    const sessionsUtf8 = new TextDecoder().decode(entries[`kronosys-sessions-${stamp}.csv`]);
-    expect(sessionsUtf8).toContain("sessionId");
-    expect(sessionsUtf8).toContain("s-hist");
-  });
-
-  it("buildStoreJsonBlobsCsv inclut cfg et métadonnées de tableau de bord", () => {
-    const csv = buildStoreJsonBlobsCsv(samplePayload());
-    expect(csv.startsWith("blobKind,json\n")).toBe(true);
-    expect(csv).toContain("autoStart");
-    expect(csv).toContain("inspectingSessionId");
-    expect(csv).toContain("s-hist");
-  });
-});

package/lib/dashboardQuickSearchQuery.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  dataSearchItemMatches,
-  parseDataSearchQuery,
-} from "@/lib/dashboardQuickSearchQuery";
-import type { DashboardSearchItem } from "@/lib/dashboardQuickSearch";
-
-function item(hay: string, dur?: number): DashboardSearchItem {
-  return {
-    id: "x",
-    title: "t",
-    haystack: hay,
-    durationForSearchSec: dur,
-    onSelect: () => {},
-  };
-}
-
-describe("parseDataSearchQuery", () => {
-  it("extrait mm:ss et opérateur (après le temps)", () => {
-    const r = parseDataSearchQuery("  44:33 >  ");
-    expect(r.textPart).toBe("");
-    expect(r.durationPredicates).toEqual([{ op: "gt", seconds: 44 * 60 + 33 }]);
-  });
-
-  it("extrait et laisse du texte", () => {
-    const r = parseDataSearchQuery("bug 12:55 <");
-    expect(r.textPart).toBe("bug");
-    expect(r.durationPredicates).toEqual([{ op: "lt", seconds: 12 * 60 + 55 }]);
-  });
-
-  it("heure pleine h:m:s", () => {
-    const r = parseDataSearchQuery("1:0:0 >");
-    expect(r.durationPredicates).toEqual([{ op: "gt", seconds: 3600 }]);
-  });
-
-  it("opérateur avant le temps", () => {
-    const r = parseDataSearchQuery("> 0:10");
-    expect(r.textPart).toBe("");
-    expect(r.durationPredicates).toEqual([{ op: "gt", seconds: 10 }]);
-  });
-});
-
-describe("dataSearchItemMatches", () => {
-  it("filtre par durée seule", () => {
-    const under = item("x", 40);
-    const over = item("x", 90);
-    expect(dataSearchItemMatches(under, "1:0 <")).toBe(true);
-    expect(dataSearchItemMatches(over, "1:0 <")).toBe(false);
-  });
-
-  it("sans durée enregistrée : échec si prédicat temporel", () => {
-    expect(dataSearchItemMatches(item("hello", undefined), "0:1 >")).toBe(false);
-  });
-
-  it("texte + durée", () => {
-    const good = item("alpha #tag", 4000);
-    const badText = item("beta", 4000);
-    const badDur = item("alpha", 10);
-    expect(dataSearchItemMatches(good, "alpha 1:0:0 >")).toBe(true);
-    expect(dataSearchItemMatches(badText, "alpha 1:0:0 >")).toBe(false);
-    expect(dataSearchItemMatches(badDur, "alpha 1:0:0 >")).toBe(false);
-  });
-});

package/lib/dataDir.test.ts

@@ -1,87 +0,0 @@
-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/formatIsoShort.test.ts

@@ -1,46 +0,0 @@
-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/kronoFocusRhythm.test.ts

@@ -1,130 +0,0 @@
-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/kronoFocusTimerUrgency.test.ts

@@ -1,74 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { getKronoFocusTimerUrgency } from "./kronoFocusTimerUrgency";
-
-describe("getKronoFocusTimerUrgency", () => {
-  it("retourne false/false si status est idle", () => {
-    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 0, mode: "work", status: "idle" }))
-      .toEqual({ blink: false, urgentHighlight: false });
-  });
-
-  it("retourne false/false si status est idle (longBreak)", () => {
-    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 10, mode: "longBreak", status: "idle" }))
-      .toEqual({ blink: false, urgentHighlight: false });
-  });
-
-  // --- mode work ---
-  it("work running — plus de 5min → pas d'urgence", () => {
-    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 301, mode: "work", status: "running" }))
-      .toEqual({ blink: false, urgentHighlight: false });
-  });
-
-  it("work running — exactement 5min → blink=true, urgentHighlight=false", () => {
-    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 300, mode: "work", status: "running" }))
-      .toEqual({ blink: true, urgentHighlight: false });
-  });
-
-  it("work running — moins de 5min → blink=true, urgentHighlight=false", () => {
-    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 120, mode: "work", status: "running" }))
-      .toEqual({ blink: true, urgentHighlight: false });
-  });
-
-  it("work running — exactement 30s → blink=true, urgentHighlight=true", () => {
-    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 30, mode: "work", status: "running" }))
-      .toEqual({ blink: true, urgentHighlight: true });
-  });
-
-  it("work running — 0s → blink=true, urgentHighlight=true", () => {
-    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 0, mode: "work", status: "running" }))
-      .toEqual({ blink: true, urgentHighlight: true });
-  });
-
-  // --- mode break (pause courte — pas de règle 5min) ---
-  it("break running — 300s → blink=false (règle 5min ne s'applique pas)", () => {
-    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 300, mode: "break", status: "running" }))
-      .toEqual({ blink: false, urgentHighlight: false });
-  });
-
-  it("break running — 30s → blink=true, urgentHighlight=true", () => {
-    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 30, mode: "break", status: "running" }))
-      .toEqual({ blink: true, urgentHighlight: true });
-  });
-
-  it("break running — 31s → blink=false, urgentHighlight=false", () => {
-    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 31, mode: "break", status: "running" }))
-      .toEqual({ blink: false, urgentHighlight: false });
-  });
-
-  // --- mode longBreak (règle 5min s'applique) ---
-  it("longBreak running — 300s → blink=true, urgentHighlight=false", () => {
-    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 300, mode: "longBreak", status: "running" }))
-      .toEqual({ blink: true, urgentHighlight: false });
-  });
-
-  it("longBreak running — 301s → blink=false", () => {
-    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 301, mode: "longBreak", status: "running" }))
-      .toEqual({ blink: false, urgentHighlight: false });
-  });
-
-  // --- status paused (actif) ---
-  it("work paused — 300s → mêmes règles que running", () => {
-    expect(getKronoFocusTimerUrgency({ timeLeftSeconds: 300, mode: "work", status: "paused" }))
-      .toEqual({ blink: true, urgentHighlight: false });
-  });
-});

package/lib/legacyKronoFocusStorageKeys.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  LEGACY_ACTION_PAUSE,
-  LEGACY_ACTION_RESET,
-  LEGACY_ACTION_SET_WORK_DURATION,
-  LEGACY_ACTION_START,
-  LEGACY_SESSION_TIMER_OBJECT_KEY,
-  LEGACY_TASK_CYCLES_KEY,
-  LEGACY_TASK_USED_FLAG_KEY,
-  LEGACY_TIMER_DEADLINE_MS_KEY,
-} from "./legacyKronoFocusStorageKeys";
-
-describe("legacyKronoFocusStorageKeys", () => {
-  it("reconstruit les mêmes identifiants que les anciennes versions", () => {
-    expect(LEGACY_SESSION_TIMER_OBJECT_KEY).toBe(_(["pom", "odoro"]));
-    expect(LEGACY_TIMER_DEADLINE_MS_KEY).toBe(_(["pom", "odoro", "DeadlineAtMs"]));
-    expect(LEGACY_TASK_CYCLES_KEY).toBe(_(["pom", "odoro", "Cycles"]));
-    expect(LEGACY_TASK_USED_FLAG_KEY).toBe(_(["used", "Pom", "odoro"]));
-    expect(LEGACY_ACTION_START).toBe(_(["start", "Pom", "odoro"]));
-    expect(LEGACY_ACTION_PAUSE).toBe(_(["pause", "Pom", "odoro"]));
-    expect(LEGACY_ACTION_RESET).toBe(_(["reset", "Pom", "odoro"]));
-    expect(LEGACY_ACTION_SET_WORK_DURATION).toBe(_(["set", "Pom", "odoro", "WorkDuration"]));
-  });
-});
-
-function _(parts: string[]): string {
-  return parts.join("");
-}