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

package/server/actionTaskSession.test.ts

@@ -1,713 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
-
-import {
-  ensureTaskParentDurationCoversSubtasksMs,
-  finishTaskInSession,
-  findTaskRecord,
-  flushAllSubtaskTimersInSession,
-  prepareSessionForExclusiveMainTimerUnpaused,
-  prepareSessionForSubtaskTimer,
-  purgeTagEverywhere,
-  reorderSubtasksInSession,
-  resolveTaskSession,
-  setActiveSubtaskTimerInSession,
-  setTaskPausedInSession,
-  sumSubtasksDurationMsStored,
-  updateTaskInSession,
-} from "./actionTaskSession";
-
-function basePayload(): KronosysUpdatePayload {
-  return {
-    viewType: "dashboard",
-    cfg: {},
-    history: [],
-    historyArchived: [],
-    knownTags: ["alpha"],
-    userKnownTags: [],
-    excludedSuggestionTags: [],
-    tagDescriptions: {},
-    projectDescriptions: {},
-  };
-}
-
-describe("resolveTaskSession", () => {
-  it("sans sessionId retourne la session live", () => {
-    const p = basePayload();
-    p.current = { sessionId: "live-1", tasks: [], activeTasks: [], activeTask: null };
-    const r = resolveTaskSession(p, undefined);
-    expect(r?.isLive).toBe(true);
-    expect(String(r?.session.sessionId)).toBe("live-1");
-  });
-
-  it("résout une entrée d’historique", () => {
-    const p = basePayload();
-    p.current = { sessionId: "live-1", tasks: [], activeTasks: [], activeTask: null };
-    p.history = [{ sessionId: "old-1", sessionName: "Arch", tasks: [], activeTasks: [], activeTask: null }];
-    const r = resolveTaskSession(p, "old-1");
-    expect(r?.isLive).toBe(false);
-    expect(String(r?.session.sessionId)).toBe("old-1");
-  });
-});
-
-describe("finishTaskInSession", () => {
-  it("déplace une tâche active vers tasks terminées", () => {
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      tasks: [],
-      activeTasks: [
-        {
-          id: "t1",
-          name: "X",
-          startTime: "2020-01-01T00:00:00.000Z",
-          durationMs: 0,
-          isDone: false,
-          tags: [],
-          project: null,
-          subtasks: [],
-        },
-      ],
-      activeTask: null,
-    };
-    const ok = finishTaskInSession(sess, "t1", false);
-    expect(ok).toBe(true);
-    expect((sess.activeTasks as unknown[]).length).toBe(0);
-    const tasks = sess.tasks as Record<string, unknown>[];
-    expect(tasks.length).toBe(1);
-    expect(tasks[0].isDone).toBe(true);
-    expect(tasks[0].shouldCommit).toBe(false);
-    expect(tasks[0].tags).toEqual(["default"]);
-  });
-
-  it("marque toutes les sous-tâches comme terminées à la fin de la tâche", () => {
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      tasks: [],
-      activeTasks: [
-        {
-          id: "t1",
-          name: "X",
-          startTime: "2020-01-01T00:00:00.000Z",
-          durationMs: 0,
-          isDone: false,
-          tags: [],
-          project: null,
-          subtasks: [
-            { id: "s1", title: "a", done: false },
-            { id: "s2", title: "b", done: true },
-          ],
-        },
-      ],
-      activeTask: null,
-    };
-    const ok = finishTaskInSession(sess, "t1", false);
-    expect(ok).toBe(true);
-    const tasks = sess.tasks as Record<string, unknown>[];
-    const subs = tasks[0].subtasks as { done: boolean }[];
-    expect(subs.every((x) => x.done === true)).toBe(true);
-    expect(tasks[0].tags as string[]).toEqual(["default"]);
-  });
-});
-
-describe("coherence parent / sous-tâches (durationMs)", () => {
-  it("ensureTaskParentDurationCoversSubtasksMs élève le parent si la somme des points la dépasse", () => {
-    const task: Record<string, unknown> = {
-      id: "t",
-      durationMs: 30_000,
-      subtasks: [
-        { id: "a", title: "A", done: false, durationMs: 20_000 },
-        { id: "b", title: "B", done: false, durationMs: 25_000 },
-      ],
-    };
-    expect(sumSubtasksDurationMsStored(task)).toBe(45_000);
-    ensureTaskParentDurationCoversSubtasksMs(task);
-    expect(task.durationMs).toBe(45_000);
-  });
-
-  it("ne réduit jamais le parent quand la somme des points est plus basse (temps sans point)", () => {
-    const task: Record<string, unknown> = {
-      id: "t",
-      durationMs: 120_000,
-      subtasks: [{ id: "a", title: "A", done: false, durationMs: 30_000 }],
-    };
-    ensureTaskParentDurationCoversSubtasksMs(task);
-    expect(task.durationMs).toBe(120_000);
-  });
-});
-
-describe("reorderSubtasksInSession", () => {
-  it("réordonne les sous-tâches selon la liste d’identifiants", () => {
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      tasks: [],
-      activeTasks: [
-        {
-          id: "t1",
-          name: "X",
-          startTime: "2020-01-01T00:00:00.000Z",
-          durationMs: 0,
-          isDone: false,
-          tags: [],
-          project: null,
-          subtasks: [
-            { id: "a", title: "premier", done: false },
-            { id: "b", title: "deuxième", done: false },
-            { id: "c", title: "troisième", done: false },
-          ],
-        },
-      ],
-      activeTask: null,
-    };
-    const ok = reorderSubtasksInSession(sess, "t1", ["c", "a", "b"]);
-    expect(ok).toBe(true);
-    const subs = (findTaskRecord(sess, "t1")?.subtasks ?? []) as { id: string }[];
-    expect(subs.map((s) => s.id)).toEqual(["c", "a", "b"]);
-  });
-
-  it("refuse une liste incomplète ou invalide", () => {
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      tasks: [],
-      activeTasks: [
-        {
-          id: "t1",
-          name: "X",
-          startTime: "2020-01-01T00:00:00.000Z",
-          durationMs: 0,
-          isDone: false,
-          tags: [],
-          project: null,
-          subtasks: [
-            { id: "a", title: "premier", done: false },
-            { id: "b", title: "deuxième", done: false },
-          ],
-        },
-      ],
-      activeTask: null,
-    };
-    const before = JSON.stringify(findTaskRecord(sess, "t1")?.subtasks);
-    expect(reorderSubtasksInSession(sess, "t1", ["a"])).toBe(false);
-    expect(JSON.stringify(findTaskRecord(sess, "t1")?.subtasks)).toBe(before);
-    expect(reorderSubtasksInSession(sess, "t1", ["a", "x"])).toBe(false);
-    expect(JSON.stringify(findTaskRecord(sess, "t1")?.subtasks)).toBe(before);
-  });
-});
-
-describe("setActiveSubtaskTimerInSession", () => {
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("enregistre la durée sur la sous-tâche à l’arrêt du minuteur", () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2026-01-10T12:00:00.000Z"));
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      tasks: [],
-      activeTasks: [
-        {
-          id: "t1",
-          name: "X",
-          startTime: "2026-01-10T11:00:00.000Z",
-          durationMs: 0,
-          isDone: false,
-          tags: [],
-          project: null,
-          subtasks: [{ id: "sub-a", title: "Point", done: false, durationMs: 0 }],
-        },
-      ],
-      activeTask: null,
-    };
-    expect(setActiveSubtaskTimerInSession(sess, "t1", "sub-a")).toBe(true);
-    vi.setSystemTime(new Date("2026-01-10T12:03:00.000Z"));
-    expect(setActiveSubtaskTimerInSession(sess, "t1", null)).toBe(true);
-    const task = (sess.activeTasks as Record<string, unknown>[])[0];
-    const subs = task.subtasks as Record<string, unknown>[];
-    expect(subs[0].durationMs).toBe(3 * 60 * 1000);
-    expect(task.durationMs).toBe(3 * 60 * 1000);
-    expect(task.activeSubtaskTimerId).toBeNull();
-  });
-
-  it("cumule plusieurs segments sur la même sous-tâche", () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2026-01-10T12:00:00.000Z"));
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      tasks: [],
-      activeTasks: [
-        {
-          id: "t1",
-          name: "X",
-          startTime: "2026-01-10T11:00:00.000Z",
-          durationMs: 0,
-          isDone: false,
-          tags: [],
-          project: null,
-          subtasks: [{ id: "sub-a", title: "Point", done: false, durationMs: 1000 }],
-        },
-      ],
-      activeTask: null,
-    };
-    setActiveSubtaskTimerInSession(sess, "t1", "sub-a");
-    vi.setSystemTime(new Date("2026-01-10T12:01:00.000Z"));
-    setActiveSubtaskTimerInSession(sess, "t1", null);
-    vi.setSystemTime(new Date("2026-01-10T12:02:00.000Z"));
-    setActiveSubtaskTimerInSession(sess, "t1", "sub-a");
-    vi.setSystemTime(new Date("2026-01-10T12:04:00.000Z"));
-    setActiveSubtaskTimerInSession(sess, "t1", null);
-    const task = (sess.activeTasks as Record<string, unknown>[])[0];
-    const subs = (task.subtasks as Record<string, unknown>[])[0];
-    expect(subs.durationMs).toBe(1000 + 60_000 + 120_000);
-    // Total parent = somme des points (le millier initial était déjà sur la sous-tâche)
-    expect(task.durationMs).toBe(1000 + 60_000 + 120_000);
-  });
-
-  it("déplace le suivi sur une autre tâche : l’ancienne sous-tâche est comptée et toutes les tâches seulement en pause (minuteur parent)", () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2026-01-10T12:00:00.000Z"));
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      tasks: [],
-      activeTasks: [
-        {
-          id: "t1",
-          name: "A",
-          startTime: "2026-01-10T11:00:00.000Z",
-          durationMs: 0,
-          isDone: false,
-          manualTaskTimerPaused: false,
-          tags: [],
-          project: null,
-          subtasks: [{ id: "sub-1", title: "P1", done: false, durationMs: 0 }],
-        },
-        {
-          id: "t2",
-          name: "B",
-          startTime: "2026-01-10T11:00:00.000Z",
-          durationMs: 0,
-          isDone: false,
-          manualTaskTimerPaused: false,
-          tags: [],
-          project: null,
-          subtasks: [{ id: "sub-2", title: "P2", done: false, durationMs: 0 }],
-        },
-      ],
-      activeTask: null,
-    };
-    setActiveSubtaskTimerInSession(sess, "t1", "sub-1");
-    vi.setSystemTime(new Date("2026-01-10T12:05:00.000Z"));
-    setActiveSubtaskTimerInSession(sess, "t2", "sub-2");
-    const t1 = (sess.activeTasks as Record<string, unknown>[]).find((x) => x.id === "t1");
-    const t2 = (sess.activeTasks as Record<string, unknown>[]).find((x) => x.id === "t2");
-    expect(t1?.activeSubtaskTimerId).toBeNull();
-    expect(t1?.manualTaskTimerPaused).toBe(true);
-    expect((t1?.subtasks as { durationMs?: number }[] | undefined)?.[0]?.durationMs).toBe(5 * 60_000);
-    expect(t2?.activeSubtaskTimerId).toBe("sub-2");
-    expect(t2?.manualTaskTimerPaused).toBe(false);
-  });
-});
-
-describe("exclusivité des minuteurs (helpers)", () => {
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("prepareSessionForExclusiveMainTimerUnpaused : toutes les sous-tâches sont arrêtées et seule la tâche ciblée a le parent non en pause", () => {
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      activeTasks: [
-        {
-          id: "a",
-          name: "A",
-          isDone: false,
-          manualTaskTimerPaused: true,
-          subtasks: [
-            { id: "s1", title: "c", done: false, durationMs: 0 },
-            { id: "s2", title: "d", done: false, durationMs: 0 },
-          ],
-          activeSubtaskTimerId: "s1",
-        },
-        {
-          id: "b",
-          name: "B",
-          isDone: false,
-          manualTaskTimerPaused: true,
-          subtasks: [],
-        },
-      ],
-      activeTask: null,
-      tasks: [
-        {
-          id: "c",
-          name: "C",
-          isDone: true,
-          manualTaskTimerPaused: true,
-          subtasks: [],
-        },
-      ],
-    };
-    prepareSessionForExclusiveMainTimerUnpaused(sess, "b");
-    const tA = findTaskRecord(sess, "a");
-    const tB = findTaskRecord(sess, "b");
-    const tC = findTaskRecord(sess, "c");
-    expect(tA?.activeSubtaskTimerId).toBeNull();
-    expect(tA?.manualTaskTimerPaused).toBe(true);
-    expect(tB?.manualTaskTimerPaused).toBe(false);
-    expect(tC?.manualTaskTimerPaused).toBe(true);
-  });
-
-  it("prepareSessionForSubtaskTimer : le suivi d’autres tâches (y compris dans `tasks` seul) est vidé", () => {
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      activeTasks: [
-        {
-          id: "a",
-          name: "A",
-          isDone: false,
-          manualTaskTimerPaused: false,
-          subtasks: [],
-        },
-      ],
-      activeTask: null,
-      tasks: [
-        {
-          id: "b",
-          name: "B",
-          isDone: false,
-          subtasks: [{ id: "sb", title: "P", done: false, durationMs: 0 }],
-          activeSubtaskTimerId: "sb",
-        },
-      ],
-    };
-    prepareSessionForSubtaskTimer(sess, "a");
-    const tA = findTaskRecord(sess, "a");
-    const tB = findTaskRecord(sess, "b");
-    expect(tA?.manualTaskTimerPaused).toBe(false);
-    expect(tB?.activeSubtaskTimerId).toBeNull();
-  });
-
-  it("flushAllSubtaskTimersInSession compte le temps de chaque segment puis vide les suivi", () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2026-03-01T10:00:00.000Z"));
-    const started = "2026-03-01T09:58:00.000Z";
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      activeTasks: [
-        {
-          id: "x",
-          isDone: false,
-          durationMs: 0,
-          subtasks: [{ id: "s1", title: "P", done: false, durationMs: 0 }],
-          activeSubtaskTimerId: "s1",
-          subtaskTimerStartedAt: started,
-        },
-        {
-          id: "y",
-          isDone: false,
-          durationMs: 0,
-          subtasks: [{ id: "s2", title: "Q", done: false, durationMs: 0 }],
-          activeSubtaskTimerId: "s2",
-          subtaskTimerStartedAt: "2026-03-01T09:55:00.000Z",
-        },
-      ],
-      activeTask: null,
-      tasks: [],
-    };
-    flushAllSubtaskTimersInSession(sess);
-    const tx = (sess.activeTasks as Record<string, unknown>[]).find((t) => t.id === "x");
-    const ty = (sess.activeTasks as Record<string, unknown>[]).find((t) => t.id === "y");
-    expect(tx?.activeSubtaskTimerId).toBeNull();
-    expect(((tx?.subtasks as { durationMs?: number }[] | undefined) ?? [])[0]?.durationMs).toBe(2 * 60_000);
-    expect(tx?.durationMs).toBe(2 * 60_000);
-    expect(ty?.activeSubtaskTimerId).toBeNull();
-  });
-});
-
-describe("exclusivité des minuteurs (sous-tâches)", () => {
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("démarrer une sous-tâche : seules les autres tâches parentes en pause, la tâche ciblée en marche", () => {
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      activeTasks: [
-        {
-          id: "t1",
-          isDone: false,
-          manualTaskTimerPaused: false,
-          subtasks: [{ id: "st1", title: "a", done: false, durationMs: 0 }],
-          tags: [],
-          project: null,
-        },
-        {
-          id: "t2",
-          isDone: false,
-          manualTaskTimerPaused: false,
-          subtasks: [],
-          tags: [],
-          project: null,
-        },
-        {
-          id: "t3",
-          isDone: false,
-          manualTaskTimerPaused: true,
-          subtasks: [],
-          tags: [],
-          project: null,
-        },
-      ],
-      activeTask: null,
-      tasks: [],
-    };
-    expect(setActiveSubtaskTimerInSession(sess, "t1", "st1")).toBe(true);
-    expect(findTaskRecord(sess, "t1")?.manualTaskTimerPaused).toBe(false);
-    expect(findTaskRecord(sess, "t2")?.manualTaskTimerPaused).toBe(true);
-    expect(findTaskRecord(sess, "t3")?.manualTaskTimerPaused).toBe(true);
-  });
-
-  it("basculer de sous-tâche a à b sur le même parent : a accumule, seul b reste actif", () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2026-05-20T15:00:00.000Z"));
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      activeTasks: [
-        {
-          id: "p",
-          isDone: false,
-          durationMs: 0,
-          subtasks: [
-            { id: "sa", title: "1", done: false, durationMs: 0 },
-            { id: "sb", title: "2", done: false, durationMs: 0 },
-          ],
-          tags: [],
-          project: null,
-        },
-      ],
-      activeTask: null,
-      tasks: [],
-    };
-    setActiveSubtaskTimerInSession(sess, "p", "sa");
-    vi.setSystemTime(new Date("2026-05-20T15:00:10.000Z"));
-    setActiveSubtaskTimerInSession(sess, "p", "sb");
-    const task = findTaskRecord(sess, "p");
-    const subs = task?.subtasks as { id: string; durationMs?: number }[];
-    expect(subs.find((s) => s.id === "sa")?.durationMs).toBe(10_000);
-    expect(subs.find((s) => s.id === "sb")?.durationMs).toBe(0);
-    expect(task?.activeSubtaskTimerId).toBe("sb");
-  });
-
-  it("arrêter le suivi (null) ne remet pas la parente en pause : elle était en marche avec le suivi", () => {
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      activeTasks: [
-        {
-          id: "k",
-          isDone: false,
-          manualTaskTimerPaused: true,
-          subtasks: [{ id: "u", title: "U", done: false, durationMs: 0 }],
-        },
-      ],
-      activeTask: null,
-      tasks: [],
-    };
-    setActiveSubtaskTimerInSession(sess, "k", "u");
-    expect(findTaskRecord(sess, "k")?.manualTaskTimerPaused).toBe(false);
-    expect(setActiveSubtaskTimerInSession(sess, "k", null)).toBe(true);
-    expect(findTaskRecord(sess, "k")?.manualTaskTimerPaused).toBe(false);
-  });
-
-  it("reprendre la tâche A avec une tâche B en suivi de sous-tâche horodaté : le temps B est compté puis effacé", () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2026-01-20T12:00:00.000Z"));
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      activeTasks: [
-        {
-          id: "A",
-          name: "A",
-          startTime: "2020-01-01T00:00:00.000Z",
-          isDone: false,
-          durationMs: 0,
-          manualTaskTimerPaused: true,
-          tags: [],
-          project: null,
-          subtasks: [],
-        },
-        {
-          id: "B",
-          name: "B",
-          startTime: "2020-01-01T00:00:00.000Z",
-          isDone: false,
-          durationMs: 0,
-          manualTaskTimerPaused: true,
-          tags: [],
-          project: null,
-          subtasks: [{ id: "sb", title: "B", done: false, durationMs: 0 }],
-          activeSubtaskTimerId: "sb",
-          subtaskTimerStartedAt: "2026-01-20T11:59:00.000Z",
-        },
-      ],
-      activeTask: null,
-      tasks: [],
-    };
-    vi.setSystemTime(new Date("2026-01-20T12:00:00.000Z"));
-    expect(setTaskPausedInSession(sess, "A", false)).toBe(true);
-    const tA = findTaskRecord(sess, "A");
-    const tB = findTaskRecord(sess, "B");
-    expect(tA?.manualTaskTimerPaused).toBe(false);
-    expect(tB?.activeSubtaskTimerId).toBeNull();
-    expect(
-      (tB?.subtasks as { id: string; durationMs?: number }[] | undefined)?.find((s) => s.id === "sb")?.durationMs
-    ).toBe(60_000);
-  });
-});
-
-describe("setTaskPausedInSession (exclusivité)", () => {
-  it("mettre la tâche parente en pause arrête le suivi de sous-tâche en cours", () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2026-02-10T12:00:00.000Z"));
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      activeTasks: [
-        {
-          id: "m",
-          isDone: false,
-          manualTaskTimerPaused: false,
-          durationMs: 0,
-          subtasks: [{ id: "subx", title: "X", done: false, durationMs: 0 }],
-          activeSubtaskTimerId: "subx",
-          subtaskTimerStartedAt: "2026-02-10T11:50:00.000Z",
-        },
-      ],
-      activeTask: null,
-      tasks: [],
-    };
-    expect(setTaskPausedInSession(sess, "m", true)).toBe(true);
-    const t = findTaskRecord(sess, "m");
-    expect(t?.manualTaskTimerPaused).toBe(true);
-    expect(t?.activeSubtaskTimerId).toBeNull();
-    expect(((t?.subtasks as { durationMs?: number }[] | undefined) ?? [])[0]?.durationMs).toBe(10 * 60_000);
-    vi.useRealTimers();
-  });
-
-  it("reprendre le minuteur tâche vide les suivi sous-tâches et seule celle-ci non en pause", () => {
-    const sess: Record<string, unknown> = {
-      sessionId: "s",
-      tasks: [],
-      activeTasks: [
-        {
-          id: "a",
-          name: "A",
-          startTime: "2020-01-01T00:00:00.000Z",
-          durationMs: 0,
-          isDone: false,
-          manualTaskTimerPaused: true,
-          tags: [],
-          project: null,
-          subtasks: [{ id: "s1", title: "x", done: false, durationMs: 0 }],
-          activeSubtaskTimerId: "s1",
-        },
-        {
-          id: "b",
-          name: "B",
-          startTime: "2020-01-01T00:00:00.000Z",
-          durationMs: 0,
-          isDone: false,
-          manualTaskTimerPaused: true,
-          tags: [],
-          project: null,
-          subtasks: [],
-        },
-      ],
-      activeTask: null,
-    };
-    expect(setTaskPausedInSession(sess, "a", false)).toBe(true);
-    const tA = (sess.activeTasks as Record<string, unknown>[])[0];
-    const tB = (sess.activeTasks as Record<string, unknown>[])[1];
-    expect(tA?.activeSubtaskTimerId).toBeNull();
-    expect(tA?.manualTaskTimerPaused).toBe(false);
-    expect(tB?.manualTaskTimerPaused).toBe(true);
-  });
-});
-
-describe("findTaskRecord / updateTaskInSession", () => {
-  it("met à jour le nom d’une tâche dans la pile", () => {
-    const sess: Record<string, unknown> = {
-      activeTasks: [{ id: "a", name: "n0", isDone: false, tags: [], subtasks: [] }],
-      activeTask: null,
-      tasks: [],
-    };
-    expect(updateTaskInSession(sess, "a", { name: "n1" })).toBe(true);
-    expect(findTaskRecord(sess, "a")?.name).toBe("n1");
-  });
-
-  it("normalise les étiquettes vides vers l’étiquette réservée default", () => {
-    const sess: Record<string, unknown> = {
-      activeTasks: [{ id: "a", name: "n0", isDone: false, tags: ["bug"], subtasks: [] }],
-      activeTask: null,
-      tasks: [],
-    };
-    expect(updateTaskInSession(sess, "a", { tags: [] })).toBe(true);
-    expect(findTaskRecord(sess, "a")?.tags).toEqual(["default"]);
-  });
-
-  it("normalise les étiquettes vides vers [] si assignDefaultTagBucket est false", () => {
-    const sess: Record<string, unknown> = {
-      activeTasks: [{ id: "a", name: "n0", isDone: false, tags: ["bug"], subtasks: [] }],
-      activeTask: null,
-      tasks: [],
-    };
-    expect(updateTaskInSession(sess, "a", { tags: [] }, { assignDefaultTagBucket: false })).toBe(true);
-    expect(findTaskRecord(sess, "a")?.tags).toEqual([]);
-  });
-});
-
-describe("purgeTagEverywhere", () => {
-  it("retire l’étiquette des listes et des tâches", () => {
-    const p = basePayload();
-    p.knownTags = ["bug", "feat"];
-    p.userKnownTags = ["bug"];
-    p.tagDescriptions = { bug: "d" };
-    p.current = {
-      sessionId: "c",
-      tasks: [{ id: "1", name: "t", tags: ["bug", "x"], isDone: true, subtasks: [] }],
-      activeTasks: [],
-      activeTask: null,
-    };
-    purgeTagEverywhere(p, "bug");
-    expect((p.knownTags as string[]).some((x) => x.toLowerCase() === "bug")).toBe(false);
-    const t = (p.current as Record<string, unknown>).tasks as Record<string, unknown>[];
-    expect((t[0].tags as string[]).includes("bug")).toBe(false);
-    expect((t[0].tags as string[]).includes("x")).toBe(true);
-  });
-
-  it("purgeTagEverywhere : retirer la dernière étiquette laisse le bucket default", () => {
-    const p = basePayload();
-    p.knownTags = ["solo"];
-    p.current = {
-      sessionId: "c",
-      tasks: [{ id: "1", name: "t", tags: ["solo"], isDone: true, subtasks: [] }],
-      activeTasks: [],
-      activeTask: null,
-    };
-    purgeTagEverywhere(p, "solo");
-    const t = (p.current as Record<string, unknown>).tasks as Record<string, unknown>[];
-    expect(t[0].tags as string[]).toEqual(["default"]);
-  });
-
-  it("purgeTagEverywhere : sans bucket par défaut, dernière étiquette retirée → []", () => {
-    const p = basePayload();
-    p.knownTags = ["solo"];
-    p.current = {
-      sessionId: "c",
-      tasks: [{ id: "1", name: "t", tags: ["solo"], isDone: true, subtasks: [] }],
-      activeTasks: [],
-      activeTask: null,
-    };
-    purgeTagEverywhere(p, "solo", { assignDefaultTagBucket: false });
-    const t = (p.current as Record<string, unknown>).tasks as Record<string, unknown>[];
-    expect(t[0].tags as string[]).toEqual([]);
-  });
-});