@nightkatana/kronosys-app 1.0.0-beta.0

package/server/actionTaskSession.test.ts

@@ -0,0 +1,713 @@
+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([]);
+  });
+});