@nightkatana/kronosys-app 1.0.0-beta.0

package/server/actionDispatch.test.ts

@@ -0,0 +1,723 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { normalizeProjectKey } from "@/lib/taskParsing";
+
+import { resetSqliteConnection } from "./db";
+import { dispatchKronosysAction } from "./actionDispatch";
+import { readPayload, writePayload } from "./payloadStore";
+import { MAIN_TIMER_SEGMENT_STARTED_AT } from "./actionTaskSession";
+import { SESSION_WALL_SEGMENT_STARTED_AT } from "./sessionWallHydrate";
+
+describe("dispatchKronosysAction (SQLite isolé)", () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), "tb-disp-"));
+    process.env.TRACE_DATA_DIR = tmp;
+    resetSqliteConnection();
+  });
+
+  afterEach(() => {
+    resetSqliteConnection();
+    delete process.env.TRACE_DATA_DIR;
+    delete process.env.GITLAB_TOKEN;
+    vi.unstubAllGlobals();
+    if (tmp && fs.existsSync(tmp)) {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it("deux startTask d’affilée : seule la dernière tâche a le minuteur parent actif, l’autre en pause", async () => {
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({ type: "startTask", name: "Première", tags: [] });
+    await dispatchKronosysAction({ type: "startTask", name: "Deuxième", tags: [] });
+    const p = readPayload();
+    const cur = p.current as Record<string, unknown>;
+    const act = (cur.activeTasks as Record<string, unknown>[]) ?? [];
+    const second = act.find((t) => t.name === "Deuxième");
+    const first = act.find((t) => t.name === "Première");
+    expect(second?.manualTaskTimerPaused).toBeFalsy();
+    expect(first?.manualTaskTimerPaused).toBe(true);
+  });
+
+  it("setActiveSubtaskTimer : la tâche ciblée en marche, les autres en pause (minuteur parent)", async () => {
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({ type: "startTask", name: "A", tags: [] });
+    await dispatchKronosysAction({ type: "startTask", name: "B", tags: [] });
+    let p = readPayload();
+    const cur0 = p.current as Record<string, unknown>;
+    const tA0 = (cur0.activeTasks as Record<string, unknown>[]).find((t) => t.name === "A");
+    const tidA = String(tA0?.id ?? "");
+    await dispatchKronosysAction({ type: "addSubtask", taskId: tidA, title: "Point" });
+    p = readPayload();
+    const cur1 = p.current as Record<string, unknown>;
+    const tA1 = (cur1.activeTasks as Record<string, unknown>[]).find((t) => t.name === "A");
+    const st = (tA1?.subtasks as { id: string; title: string }[] | undefined)?.[0];
+    expect(st?.id).toBeDefined();
+    await dispatchKronosysAction({
+      type: "setActiveSubtaskTimer",
+      taskId: tidA,
+      subtaskId: st?.id,
+    });
+    p = readPayload();
+    const cur = p.current as Record<string, unknown>;
+    const tA = (cur.activeTasks as Record<string, unknown>[]).find((t) => t.name === "A");
+    const tB = (cur.activeTasks as Record<string, unknown>[]).find((t) => t.name === "B");
+    expect(tA?.manualTaskTimerPaused).toBeFalsy();
+    expect(tA?.activeSubtaskTimerId).toBe(st?.id);
+    expect(tB?.manualTaskTimerPaused).toBe(true);
+  });
+
+  it("resumePausedTask : une seule tâche a le minuteur parent actif, les suivi de sous-tâches sont effacés", async () => {
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({ type: "startTask", name: "A", tags: [] });
+    await dispatchKronosysAction({ type: "startTask", name: "B", tags: [] });
+    const p0 = readPayload();
+    const cur0 = p0.current as Record<string, unknown>;
+    const tA0 = (cur0.activeTasks as Record<string, unknown>[]).find((t) => t.name === "A");
+    const tB0 = (cur0.activeTasks as Record<string, unknown>[]).find((t) => t.name === "B");
+    const tidA = String(tA0?.id ?? "");
+    const tidB = String(tB0?.id ?? "");
+    await dispatchKronosysAction({ type: "addSubtask", taskId: tidA, title: "P" });
+    const p1 = readPayload();
+    const cur1 = p1.current as Record<string, unknown>;
+    const st = (
+      (cur1.activeTasks as Record<string, unknown>[]).find((t) => t.name === "A")?.subtasks as
+        | { id: string }[]
+        | undefined
+    )?.[0];
+    await dispatchKronosysAction({ type: "setActiveSubtaskTimer", taskId: tidA, subtaskId: st?.id });
+    await dispatchKronosysAction({ type: "resumePausedTask", taskId: tidB });
+    const p2 = readPayload();
+    const cur2 = p2.current as Record<string, unknown>;
+    const tA2 = (cur2.activeTasks as Record<string, unknown>[]).find((t) => t.name === "A");
+    const tB2 = (cur2.activeTasks as Record<string, unknown>[]).find((t) => t.name === "B");
+    expect(tA2?.activeSubtaskTimerId).toBeFalsy();
+    expect(tA2?.manualTaskTimerPaused).toBe(true);
+    expect(tB2?.manualTaskTimerPaused).toBeFalsy();
+  });
+
+  it("démarre une tâche puis la termine sur la session live", async () => {
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({ type: "startTask", name: "Alpha", tags: ["t1"] });
+    let p = readPayload();
+    expect((p.knownTags as string[]).some((x) => String(x).toLowerCase() === "t1")).toBe(true);
+    const cur = p.current as Record<string, unknown> | undefined;
+    const tid = String((cur?.activeTask as Record<string, unknown> | undefined)?.id ?? "");
+    expect(tid.length).toBeGreaterThan(10);
+
+    await dispatchKronosysAction({ type: "finishTask", taskId: tid, shouldCommit: false });
+    p = readPayload();
+    const cur2 = p.current as Record<string, unknown>;
+    const tasks = cur2.tasks as Record<string, unknown>[];
+    expect(tasks.some((t) => String(t.id) === tid && t.isDone === true)).toBe(true);
+    const active = cur2.activeTasks as unknown[];
+    expect(Array.isArray(active) && active.length).toBe(0);
+  });
+
+  it("startTask sans étiquette laisse tags vides si taskDefaultTagBucketEnabled est false", async () => {
+    await dispatchKronosysAction({
+      type: "updateKronosysSettings",
+      settings: { taskDefaultTagBucketEnabled: false },
+    });
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({ type: "startTask", name: "Sans tag", tags: [] });
+    const p = readPayload();
+    const at0 = (p.current as Record<string, unknown>).activeTask as Record<string, unknown> | undefined;
+    expect(at0?.tags).toEqual([]);
+  });
+
+  it("startTask enrichit knownProjects lorsqu’un @projet est fourni", async () => {
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({
+      type: "startTask",
+      name: "Tâche",
+      tags: [],
+      project: "nouveau-projet",
+    });
+    const p = readPayload();
+    const at0 = (p.current as Record<string, unknown>).activeTask as Record<string, unknown> | undefined;
+    expect(at0?.tags).toEqual(["default"]);
+    expect((p.knownProjects as string[]).map((x) => normalizeProjectKey(String(x)).toLowerCase())).toContain(
+      "nouveau-projet"
+    );
+  });
+
+  it("updateTask enrichit knownTags lorsqu’une nouvelle étiquette est appliquée", async () => {
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({ type: "startTask", name: "Une", tags: ["a"] });
+    let p = readPayload();
+    const tid = String(
+      ((p.current as Record<string, unknown>).activeTask as Record<string, unknown> | undefined)?.id ?? ""
+    );
+    expect((p.knownTags as string[]).map((x) => x.toLowerCase())).toContain("a");
+    expect((p.knownTags as string[]).map((x) => x.toLowerCase())).not.toContain("nouveau");
+    await dispatchKronosysAction({ type: "updateTask", taskId: tid, name: "Une", tags: ["a", "nouveau"] });
+    p = readPayload();
+    expect((p.knownTags as string[]).map((x) => x.toLowerCase())).toContain("nouveau");
+  });
+
+  it("updateTask enrichit knownProjects lorsqu’un projet est assigné", async () => {
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({ type: "startTask", name: "X", tags: [] });
+    let p = readPayload();
+    const tid = String(
+      ((p.current as Record<string, unknown>).activeTask as Record<string, unknown> | undefined)?.id ?? ""
+    );
+    expect(
+      ((p.current as Record<string, unknown>).activeTask as Record<string, unknown> | undefined)?.tags
+    ).toEqual(["default"]);
+    await dispatchKronosysAction({ type: "updateTask", taskId: tid, name: "X", project: "client-acme" });
+    p = readPayload();
+    expect(
+      (p.knownProjects as string[]).some(
+        (x) => normalizeProjectKey(String(x)).toLowerCase() === "client-acme"
+      )
+    ).toBe(true);
+  });
+
+  it("fetchRemoteIssues refuse sans jeton disponible", async () => {
+    readPayload();
+    const before = readPayload();
+    const res = await dispatchKronosysAction({ type: "fetchRemoteIssues", search: "x" });
+    expect(res.ok).toBe(true);
+    expect(res.result?.remoteIssuesError).toBeTruthy();
+    expect(res.result?.remoteIssues ?? []).toEqual([]);
+    expect(JSON.stringify(readPayload())).toBe(JSON.stringify(before));
+  });
+
+  it("fetchRemoteIssues retourne des issues ouvertes (mock GitLab)", async () => {
+    readPayload();
+    await dispatchKronosysAction({ type: "setGitlabToken", token: "glpat-x" });
+    const fetchMock = vi.fn((input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes("/api/v4/search")) {
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          json: async () => [],
+          text: async () => "[]",
+        });
+      }
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: async () => [
+          {
+            id: 9001,
+            iid: 3,
+            title: "Issue A",
+            references: { full: "group/proj#3" },
+            web_url: "https://gitlab.example/group/proj/-/issues/3",
+          },
+        ],
+        text: async () => "[]",
+      });
+    });
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+    const res = await dispatchKronosysAction({ type: "fetchRemoteIssues", search: "fix" });
+    expect(fetchMock.mock.calls.length).toBe(2);
+    expect(res.result?.remoteIssuesError).toBeUndefined();
+    const list = res.result?.remoteIssues as Array<{ title?: string; number: unknown; source?: string }> | undefined;
+    expect(Array.isArray(list)).toBe(true);
+    expect(list?.length).toBe(1);
+    expect(list?.[0]?.title).toBe("Issue A");
+    expect(list?.[0]?.number).toBe(3);
+    expect(list?.[0]?.source).toBe("group/proj#3");
+  });
+
+  it("fetchRemoteIssues par numéro seul utilise iids[] (pas search)", async () => {
+    readPayload();
+    await dispatchKronosysAction({ type: "setGitlabToken", token: "glpat-x" });
+    const fetchMock = vi.fn((_input: RequestInfo | URL) =>
+      Promise.resolve({
+        ok: true,
+        status: 200,
+        json: async () => [
+          {
+            id: 55,
+            iid: 8,
+            project_id: 1,
+            title: "Num",
+            references: { full: "g/p#8" },
+            web_url: "https://gitlab.example/g/p/-/issues/8",
+          },
+        ],
+        text: async () => "[]",
+      }),
+    );
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+    const res = await dispatchKronosysAction({ type: "fetchRemoteIssues", search: "  #8 " });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const calledUrl = String(fetchMock.mock.calls[0][0]);
+    expect(calledUrl).toContain("iids");
+    expect(calledUrl).toMatch(/=8(?:&|$)/);
+    expect(calledUrl).not.toMatch(/[?&]search=/);
+    const list = res.result?.remoteIssues as Array<{ title?: string; number?: unknown }> | undefined;
+    expect(list?.length).toBe(1);
+    expect(list?.[0]?.title).toBe("Num");
+  });
+
+  it("fetchRemoteIssues sans recherche n’appelle pas l’API GitLab", async () => {
+    readPayload();
+    await dispatchKronosysAction({ type: "setGitlabToken", token: "tok" });
+    const fetchMock = vi.fn();
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+    const res = await dispatchKronosysAction({ type: "fetchRemoteIssues", search: "" });
+    expect(res.result?.remoteIssues).toEqual([]);
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("fetchRemoteIssues renvoie un message clair si GitLab dépasse le délai", async () => {
+    readPayload();
+    await dispatchKronosysAction({ type: "setGitlabToken", token: "tok" });
+    const timeoutErr = new Error("The operation was aborted due to timeout");
+    timeoutErr.name = "TimeoutError";
+    vi.stubGlobal("fetch", vi.fn(() => Promise.reject(timeoutErr)) as unknown as typeof fetch);
+    const resFr = await dispatchKronosysAction({ type: "fetchRemoteIssues", search: "ab", lang: "fr" });
+    expect(resFr.result?.remoteIssues ?? []).toEqual([]);
+    expect(String(resFr.result?.remoteIssuesError)).toContain("12");
+    expect(String(resFr.result?.remoteIssuesError)).toContain("GitLab");
+    const resEn = await dispatchKronosysAction({ type: "fetchRemoteIssues", search: "ab", lang: "en" });
+    expect(String(resEn.result?.remoteIssuesError)).toMatch(/GitLab/i);
+    expect(String(resEn.result?.remoteIssuesError)).toMatch(/12/);
+  });
+
+  it("refreshWorkspaceCodeSnapshot enregistre un instantané minimal", async () => {
+    readPayload();
+    await dispatchKronosysAction({ type: "refreshWorkspaceCodeSnapshot" });
+    const p = readPayload();
+    const snap = p.workspaceCodeSnapshot as Record<string, unknown> | undefined;
+    expect(snap?.ok).toBe(true);
+    expect(snap?.totalLines).toBe(0);
+    expect(typeof snap?.workspaceFolder).toBe("string");
+  });
+
+  it("setMongoDbConnectionUri active les drapeaux de configuration", async () => {
+    readPayload();
+    await dispatchKronosysAction({ type: "setMongoDbConnectionUri", uri: "mongodb://127.0.0.1:27017" });
+    const p = readPayload();
+    const cfg = p.cfg as Record<string, unknown>;
+    expect(cfg.mongodbUriConfigured).toBe(true);
+    expect(cfg.mongodbManualUriConfigured).toBe(true);
+  });
+
+  it("clearHistory vide l’historique, l’identité Git, les stats Git et réactive l’écran d’accueil", async () => {
+    readPayload();
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({ type: "startTask", name: "A #alpha", tags: ["alpha"], project: "mon-projet" });
+    await dispatchKronosysAction({
+      type: "endLiveSession",
+      sessionEndReasonKind: "planned",
+      sessionEndReasonNote: "x",
+    });
+    let p = readPayload();
+    expect((p.history as unknown[]).length).toBeGreaterThanOrEqual(1);
+    expect((p.knownTags as string[]).length).toBeGreaterThan(0);
+    expect((p.knownProjects as string[]).length).toBeGreaterThan(0);
+    await dispatchKronosysAction({
+      type: "setGitIdentity",
+      gitUserName: "Ada L.",
+      gitUserEmail: "ada@example.com",
+      gitAccountLogin: "adal",
+    });
+    await dispatchKronosysAction({ type: "refreshWorkspaceCodeSnapshot" });
+    p = readPayload();
+    writePayload({
+      ...p,
+      gitStats: { isGitRepo: true, commitsOnHead: 3 },
+      dismissArchiveSessionConfirm: true,
+    });
+    await dispatchKronosysAction({
+      type: "updateKronosysSettings",
+      settings: { showWelcomeOnStartup: false },
+    });
+    await dispatchKronosysAction({ type: "clearHistory" });
+    p = readPayload();
+    expect(p.history).toEqual([]);
+    expect(p.historyArchived).toEqual([]);
+    expect(p.current).toBeUndefined();
+    expect(p.knownTags).toEqual([]);
+    expect(p.knownProjects).toEqual([]);
+    expect(p.userKnownTags).toEqual([]);
+    expect(p.excludedSuggestionTags).toEqual([]);
+    expect(p.tagDescriptions).toEqual({});
+    expect(p.projectDescriptions).toEqual({});
+    expect(p.gitIdentity).toEqual({});
+    expect(p.gitStats).toBeUndefined();
+    expect(p.dismissArchiveSessionConfirm).toBeUndefined();
+    expect(p.workspaceCodeSnapshot).toBeUndefined();
+    expect((p.cfg as Record<string, unknown>).showWelcomeOnStartup).toBe(true);
+  });
+
+  it("resetKronosysSettings rétablit les valeurs par défaut et conserve les drapeaux secrets", async () => {
+    readPayload();
+    await dispatchKronosysAction({
+      type: "updateKronosysSettings",
+      settings: {
+        flushIntervalSeconds: 99,
+        gitRemoteUrl: "https://example.com/repo.git",
+        gitlabTokenStored: true,
+        gitlabTokenFromEnv: false,
+      },
+    });
+    await dispatchKronosysAction({ type: "setMongoDbConnectionUri", uri: "mongodb://127.0.0.1:27017" });
+    await dispatchKronosysAction({ type: "setMongoDbPassword", password: "secret" });
+    await dispatchKronosysAction({ type: "resetKronosysSettings" });
+    const cfg = readPayload().cfg as Record<string, unknown>;
+    expect(cfg.flushIntervalSeconds).toBe(15);
+    expect(cfg.gitRemoteUrl).toBe("");
+    expect(cfg.gitlabTokenStored).toBe(true);
+    expect(cfg.gitlabTokenFromEnv).toBe(false);
+    expect(cfg.mongodbUriConfigured).toBe(true);
+    expect(cfg.mongodbManualUriConfigured).toBe(true);
+    expect(cfg.mongodbPasswordConfigured).toBe(true);
+  });
+
+  it("setGitIdentity enregistre nom, courriel et identifiant forge", async () => {
+    readPayload();
+    await dispatchKronosysAction({
+      type: "setGitIdentity",
+      gitUserName: "Ada L.",
+      gitUserEmail: "ada@example.com",
+      gitAccountLogin: "adal",
+    });
+    const p = readPayload();
+    const g = p.gitIdentity as Record<string, unknown> | undefined;
+    expect(g?.gitUserName).toBe("Ada L.");
+    expect(g?.gitUserEmail).toBe("ada@example.com");
+    expect(g?.gitAccountLogin).toBe("adal");
+  });
+
+  it("endLiveSession enregistre la raison sur l’instantané d’historique", async () => {
+    readPayload();
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({
+      type: "endLiveSession",
+      sessionEndReasonKind: "planned",
+      sessionEndReasonNote: "  Sprint fini  ",
+    });
+    const p = readPayload();
+    expect(p.current).toBeUndefined();
+    const hist = p.history as Record<string, unknown>[];
+    expect(hist.length).toBeGreaterThanOrEqual(1);
+    const row = hist[0];
+    expect(row.sessionEndReasonKind).toBe("planned");
+    expect(row.sessionEndReasonNote).toBe("Sprint fini");
+    expect(typeof row.endAt).toBe("string");
+  });
+
+  it("endLiveSession conserve les tâches terminées dans l’historique", async () => {
+    readPayload();
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({ type: "startTask", name: "Tâche visible", tags: [] });
+    const cur = readPayload().current as Record<string, unknown>;
+    const active = cur.activeTask as Record<string, unknown>;
+    await dispatchKronosysAction({
+      type: "finishTask",
+      taskId: active.id,
+      shouldCommit: false,
+    });
+    await dispatchKronosysAction({ type: "endLiveSession" });
+    const p = readPayload();
+    const hist = p.history as Record<string, unknown>[];
+    expect(p.current).toBeUndefined();
+    expect(hist.length).toBeGreaterThanOrEqual(1);
+    const tasks = hist[0].tasks as Record<string, unknown>[];
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].name).toBe("Tâche visible");
+    expect(tasks[0].isDone).toBe(true);
+  });
+
+  it("endLiveSession conserve aussi les tâches non terminées dans l’instantané d’historique", async () => {
+    readPayload();
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({ type: "startTask", name: "Tâche non terminée", tags: [] });
+    await dispatchKronosysAction({ type: "endLiveSession" });
+    const p = readPayload();
+    const hist = p.history as Record<string, unknown>[];
+    expect(p.current).toBeUndefined();
+    expect(hist.length).toBeGreaterThanOrEqual(1);
+    const activeTasks = hist[0].activeTasks as Record<string, unknown>[];
+    expect(activeTasks).toHaveLength(1);
+    expect(activeTasks[0].name).toBe("Tâche non terminée");
+    expect(activeTasks[0].isDone).toBe(false);
+  });
+
+  it("setSessionEndReason met à jour l’instantané dans l’historique", async () => {
+    readPayload();
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({
+      type: "endLiveSession",
+      sessionEndReasonKind: "planned",
+      sessionEndReasonNote: "Note A",
+    });
+    let p = readPayload();
+    let row = (p.history as Record<string, unknown>[])[0];
+    const sid = String(row.sessionId);
+    await dispatchKronosysAction({
+      type: "setSessionEndReason",
+      sessionId: sid,
+      sessionEndReasonKind: "early",
+      sessionEndReasonNote: "  Note B  ",
+    });
+    p = readPayload();
+    row = (p.history as Record<string, unknown>[])[0];
+    expect(row.sessionEndReasonKind).toBe("early");
+    expect(row.sessionEndReasonNote).toBe("Note B");
+    await dispatchKronosysAction({
+      type: "setSessionEndReason",
+      sessionId: sid,
+      sessionEndReasonKind: "",
+      sessionEndReasonNote: "",
+    });
+    p = readPayload();
+    row = (p.history as Record<string, unknown>[])[0];
+    expect(row.sessionEndReasonKind).toBeUndefined();
+    expect(row.sessionEndReasonNote).toBeUndefined();
+  });
+
+  it("setGitlabToken réinitialise gitlabApiVerified", async () => {
+    readPayload();
+    await dispatchKronosysAction({ type: "setGitlabToken", token: "abc" });
+    let p = readPayload();
+    expect((p.cfg as Record<string, unknown>).gitlabTokenStored).toBe(true);
+    expect((p.cfg as Record<string, unknown>).gitlabApiVerified).toBe(false);
+
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => ({
+        ok: true,
+        status: 200,
+        text: async () => "{}",
+        json: async () => ({}),
+      })) as unknown as typeof fetch,
+    );
+    await dispatchKronosysAction({ type: "testGitlabConnection", token: "abc" });
+    p = readPayload();
+    expect((p.cfg as Record<string, unknown>).gitlabApiVerified).toBe(true);
+
+    await dispatchKronosysAction({ type: "setGitlabToken", token: "xyz" });
+    p = readPayload();
+    expect((p.cfg as Record<string, unknown>).gitlabApiVerified).toBe(false);
+  });
+
+  it("testGitlabConnection refuse une URL d’instance invalide sans appeler fetch", async () => {
+    readPayload();
+    const fetchMock = vi.fn();
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+    const res = await dispatchKronosysAction({
+      type: "testGitlabConnection",
+      token: "glpat-x",
+      gitlabApiBaseUrl: "%%%not-a-valid-host",
+    });
+    expect((res.result?.gitlabConnectionTest as any)?.outcome).toBe("failed");
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("testGitlabConnection sans jeton renvoie no_token", async () => {
+    readPayload();
+    const res = await dispatchKronosysAction({ type: "testGitlabConnection", token: "" });
+    expect((res.result?.gitlabConnectionTest as any)?.outcome).toBe("failed");
+    expect((res.result?.gitlabConnectionTest as any)?.reason).toBe("no_token");
+  });
+
+  it("testGitlabConnection réessaie avec Bearer si PRIVATE-TOKEN renvoie 401", async () => {
+    readPayload();
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce({
+        status: 401,
+        ok: false,
+        text: async () => '{"message":"401 Unauthorized"}',
+        json: async () => ({}),
+      })
+      .mockResolvedValueOnce({
+        status: 200,
+        ok: true,
+        text: async () => '{"id":1}',
+        json: async () => ({ id: 1 }),
+      });
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+    const res = await dispatchKronosysAction({ type: "testGitlabConnection", token: "glpat-test" });
+    expect((res.result?.gitlabConnectionTest as any)?.outcome).toBe("connected");
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    const first = fetchMock.mock.calls[0]?.[1] as { headers?: Record<string, string> };
+    const second = fetchMock.mock.calls[1]?.[1] as { headers?: Record<string, string> };
+    expect(first?.headers?.["PRIVATE-TOKEN"]).toBe("glpat-test");
+    expect(second?.headers?.Authorization).toBe("Bearer glpat-test");
+  });
+
+  it("testGitlabConnection utilise GITLAB_TOKEN quand gitlabTokenFromEnv", async () => {
+    readPayload();
+    process.env.GITLAB_TOKEN = "from-env";
+    await dispatchKronosysAction({
+      type: "updateKronosysSettings",
+      settings: { gitlabTokenFromEnv: true, gitlabTokenStored: false },
+    });
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => ({
+        ok: true,
+        status: 200,
+        text: async () => "{}",
+      })) as unknown as typeof fetch,
+    );
+    const res = await dispatchKronosysAction({ type: "testGitlabConnection", token: "" });
+    expect((res.result?.gitlabConnectionTest as any)?.outcome).toBe("connected");
+    expect(vi.mocked(fetch)).toHaveBeenCalled();
+    const p = readPayload();
+    expect((p.cfg as Record<string, unknown>).gitlabApiVerified).toBe(true);
+  });
+
+  it("setKronoFocusDurations enregistre le rythme travail / pauses sur la session en cours", async () => {
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({
+      type: "setKronoFocusDurations",
+      workSeconds: 50 * 60,
+      shortBreakSeconds: 10 * 60,
+      longBreakSeconds: 20 * 60,
+    });
+    const p = readPayload();
+    const kf = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
+    expect(kf.workDurationSeconds).toBe(50 * 60);
+    expect(kf.shortBreakDurationSeconds).toBe(10 * 60);
+    expect(kf.longBreakDurationSeconds).toBe(20 * 60);
+    expect(kf.timeLeftSeconds).toBe(50 * 60);
+    expect(kf.mode).toBe("work");
+    expect(kf.status).toBe("idle");
+  });
+
+  it("setTaskStartTime recale la durée d'une tâche active et réinitialise le segment live", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-04-30T11:00:00.000Z"));
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({ type: "startTask", name: "Timer", tags: [] });
+    let p = readPayload();
+    const cur = p.current as Record<string, unknown>;
+    const active = (cur.activeTasks as Record<string, unknown>[])[0];
+    const tid = String(active.id ?? "");
+    const newStart = "2026-04-30T10:30:00.000Z";
+    await dispatchKronosysAction({ type: "setTaskStartTime", taskId: tid, startTime: newStart });
+    p = readPayload();
+    const cur2 = p.current as Record<string, unknown>;
+    const active2 = (cur2.activeTasks as Record<string, unknown>[])[0];
+    expect(active2.startTime).toBe(newStart);
+    expect(active2.durationMs).toBe(30 * 60 * 1000);
+    expect(active2[MAIN_TIMER_SEGMENT_STARTED_AT]).toBe("2026-04-30T11:00:00.000Z");
+    vi.useRealTimers();
+  });
+
+  it("setSessionStartTime recale la durée d'une session active et réinitialise le segment mural", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-04-30T11:00:00.000Z"));
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    const newStart = "2026-04-30T10:00:00.000Z";
+    await dispatchKronosysAction({ type: "setSessionStartTime", startAt: newStart });
+    const p = readPayload();
+    const cur = p.current as Record<string, unknown>;
+    expect(cur.startAt).toBe(newStart);
+    expect(cur.sessionDurationMinutes).toBe(60);
+    expect(cur[SESSION_WALL_SEGMENT_STARTED_AT]).toBe("2026-04-30T11:00:00.000Z");
+    vi.useRealTimers();
+  });
+
+  it("setSessionStartTime recale la durée d'une session terminée dans l'historique", async () => {
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({ type: "endLiveSession" });
+    let p = readPayload();
+    const sid = String(((p.history as Record<string, unknown>[])[0] ?? {}).sessionId ?? "");
+    const rowBefore = (p.history as Record<string, unknown>[])[0] ?? {};
+    const endAt = String(rowBefore.endAt ?? "");
+    const endMs = Date.parse(endAt);
+    const startMs = endMs - 90 * 60 * 1000;
+    const newStart = new Date(startMs).toISOString();
+    await dispatchKronosysAction({ type: "setSessionStartTime", sessionId: sid, startAt: newStart });
+    p = readPayload();
+    const rowAfter = (p.history as Record<string, unknown>[]).find((h) => String(h.sessionId) === sid) ?? {};
+    expect(rowAfter.startAt).toBe(newStart);
+    expect(Math.round(Number(rowAfter.sessionDurationMinutes))).toBe(90);
+  });
+
+  it("setTaskEndTime recale la durée d'une tâche terminée", async () => {
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({ type: "startTask", name: "Done", tags: [] });
+    let p = readPayload();
+    const cur = p.current as Record<string, unknown>;
+    const tid = String(((cur.activeTasks as Record<string, unknown>[])[0] ?? {}).id ?? "");
+    await dispatchKronosysAction({ type: "finishTask", taskId: tid, shouldCommit: false });
+    p = readPayload();
+    const cur2 = p.current as Record<string, unknown>;
+    const tasks = (cur2.tasks as Record<string, unknown>[]) ?? [];
+    const done = tasks.find((t) => String(t.id) === tid) ?? {};
+    const startIso = String(done.startTime ?? "");
+    const startMs = Date.parse(startIso);
+    const newEnd = new Date(startMs + 45 * 60 * 1000).toISOString();
+    await dispatchKronosysAction({ type: "setTaskEndTime", taskId: tid, endTime: newEnd });
+    p = readPayload();
+    const cur3 = p.current as Record<string, unknown>;
+    const tasks3 = (cur3.tasks as Record<string, unknown>[]) ?? [];
+    const done3 = tasks3.find((t) => String(t.id) === tid) ?? {};
+    expect(done3.endTime).toBe(newEnd);
+    expect(done3.durationMs).toBe(45 * 60 * 1000);
+  });
+
+  it("setSessionEndTime recale la durée d'une session terminée dans l'historique", async () => {
+    await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+    await dispatchKronosysAction({ type: "endLiveSession" });
+    let p = readPayload();
+    const sid = String(((p.history as Record<string, unknown>[])[0] ?? {}).sessionId ?? "");
+    const row = (p.history as Record<string, unknown>[])[0] ?? {};
+    const startAt = String(row.startAt ?? "");
+    const startMs = Date.parse(startAt);
+    const newEnd = new Date(startMs + 120 * 60 * 1000).toISOString();
+    await dispatchKronosysAction({
+      type: "setSessionEndTime",
+      sessionId: sid,
+      endAt: newEnd,
+    });
+    p = readPayload();
+    const rowAfter = (p.history as Record<string, unknown>[]).find((h) => String(h.sessionId) === sid) ?? {};
+    expect(rowAfter.endAt).toBe(newEnd);
+    expect(Math.round(Number(rowAfter.sessionDurationMinutes))).toBe(120);
+  });
+
+  it("newSession enregistre un horodatage de création en plus du UUID", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-04-24T14:36:00.000Z"));
+    try {
+      await dispatchKronosysAction({ type: "newSession", sessionScope: undefined });
+      const p = readPayload();
+      const cur = p.current as Record<string, unknown>;
+      expect(typeof cur.sessionId).toBe("string");
+      expect(cur.createdAt).toBe("2026-04-24T14:36:00.000Z");
+      expect(cur.startAt).toBe("2026-04-24T14:36:00.000Z");
+      const hist = p.history as Record<string, unknown>[];
+      expect(hist[0]?.createdAt).toBe("2026-04-24T14:36:00.000Z");
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("newSession enregistre scheduledStartAt et sessionStartOffsetMinutes si l’hôte fournit l’heure prévue", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-04-24T14:15:00.000Z"));
+    try {
+      await dispatchKronosysAction({
+        type: "newSession",
+        sessionScope: undefined,
+        scheduledStartAt: "2026-04-24T14:00:00.000Z",
+      } as Record<string, unknown>);
+      const p = readPayload();
+      const cur = p.current as Record<string, unknown>;
+      expect(cur.scheduledStartAt).toBe("2026-04-24T14:00:00.000Z");
+      expect(cur.sessionStartOffsetMinutes).toBe(15);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});