@nightkatana/kronosys-app 1.0.0-beta.0

package/server/actionDispatch.ts

@@ -0,0 +1,1476 @@
+import { randomUUID } from "node:crypto";
+
+import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
+import { workspaceFolderPathStrings } from "@/lib/legacyEditorPayloadKeys";
+import { GITLAB_ISSUES_SEARCH_TIMEOUT_MS } from "@/lib/gitlabIssueSearch";
+import {
+  mergeTagsForDisplay,
+  normalizeProjectKey,
+  normalizeTagKey,
+  normalizeTaskTagsForStorage,
+  parseTaskWithAutoTags,
+  readTaskDefaultTagBucketEnabled,
+  type TaskTagsStorageNormalizeOpts,
+} from "@/lib/taskParsing";
+
+import {
+  addHistoricalTaskToSession,
+  addSubtaskInSession,
+  asRecord,
+  deleteSubtaskInSession,
+  deleteTaskInSession,
+  finishTaskInSession,
+  prepareSessionForExclusiveMainTimerUnpaused,
+  purgeProjectEverywhere,
+  purgeTagEverywhere,
+  reorderSubtasksInSession,
+  resolveTaskSession,
+  setActiveSubtaskTimerInSession,
+  setTaskPausedInSession,
+  toggleSubtaskInSession,
+  updateSubtaskTitleInSession,
+  updateTaskStartTimeInSession,
+  updateTaskEndTimeInSession,
+  updateTaskInSession,
+} from "./actionTaskSession";
+import { normalizeSessionEndReasonKind, normalizeSessionEndReasonNote } from "@/lib/sessionEndReason";
+import { assiduityFromScheduledStart, type SessionStartAssiduity } from "@/lib/sessionAssiduity";
+
+import {
+  isTruthyDevUseProdEnv,
+  writeUseProductionDataInDevelopmentToFile,
+} from "@/lib/devDataPreferenceFile";
+import {
+  DEFAULT_DASHBOARD_TIME_ZONE,
+  isValidIanaTimeZone,
+} from "@/lib/dashboardTimeZone";
+import { defaultKronosysCfg } from "./defaultCfg";
+import { clearGitlabPatFromStore, readGitlabPatFromStore, writeGitlabPatToStore } from "./gitlabTokenStore";
+import {
+  LEGACY_ACTION_PAUSE,
+  LEGACY_ACTION_RESET,
+  LEGACY_ACTION_SET_WORK_DURATION,
+  LEGACY_ACTION_START,
+  LEGACY_START_TASK_WITH_TIMER_BODY_KEY,
+  LEGACY_TIMER_DEADLINE_MS_KEY,
+} from "@/lib/legacyKronoFocusStorageKeys";
+import {
+  clampBreakDurationSeconds,
+  clampWorkDurationSeconds,
+  readWorkDurationSeconds,
+} from "@/lib/kronoFocusRhythm";
+import { readPayload, writePayload } from "./payloadStore";
+import {
+  ensureSessionWallSegmentOnLive,
+  flushSessionWallSegmentOnLive,
+  SESSION_WALL_SEGMENT_STARTED_AT,
+} from "./sessionWallHydrate";
+
+type ActionResult = {
+  ok: boolean;
+  result?: Record<string, unknown>;
+};
+
+function tryPersistDevDataPreferenceFromCfg(merged: Record<string, unknown>): void {
+  if (process.env.NODE_ENV !== "development") {
+    return;
+  }
+  if (process.env.TRACE_DATA_DIR?.trim()) {
+    return;
+  }
+  if (isTruthyDevUseProdEnv(process.env.KRONOSYS_DEV_USE_PROD_DATA)) {
+    return;
+  }
+  if (typeof merged.developmentUseProductionData === "boolean") {
+    writeUseProductionDataInDevelopmentToFile(merged.developmentUseProductionData);
+  }
+}
+
+function syncLiveIntoHistory(p: KronosysUpdatePayload): void {
+  const cur = asRecord(p.current);
+  if (!cur) {
+    return;
+  }
+  const sid = typeof cur.sessionId === "string" ? cur.sessionId.trim() : "";
+  if (!sid) {
+    return;
+  }
+  const hist = ([...(p.history || [])] as Record<string, unknown>[]).filter((h) => h.sessionId !== sid);
+  const snap: Record<string, unknown> = {
+    sessionId: sid,
+    sessionName: cur.sessionName ?? "",
+    savedAt: new Date().toISOString(),
+    createdAt: cur.createdAt ?? cur.startAt ?? null,
+    startAt: cur.startAt ?? null,
+    endAt: cur.endAt ?? null,
+    sessionDurationMinutes: cur.sessionDurationMinutes,
+    tasks: cur.tasks ?? [],
+    activeTasks: cur.activeTasks ?? [],
+    activeTask: cur.activeTask ?? null,
+    archived: cur.archived === true,
+  };
+  if (typeof cur.scheduledStartAt === "string" && cur.scheduledStartAt.trim() !== "") {
+    snap.scheduledStartAt = cur.scheduledStartAt;
+  }
+  if (typeof cur.sessionStartOffsetMinutes === "number" && Number.isFinite(cur.sessionStartOffsetMinutes)) {
+    snap.sessionStartOffsetMinutes = cur.sessionStartOffsetMinutes;
+  }
+  const rk = normalizeSessionEndReasonKind(cur.sessionEndReasonKind);
+  if (rk) {
+    snap.sessionEndReasonKind = rk;
+  }
+  const rn = normalizeSessionEndReasonNote(cur.sessionEndReasonNote);
+  if (rn.length > 0) {
+    snap.sessionEndReasonNote = rn;
+  }
+  hist.unshift(snap);
+  p.history = hist;
+}
+
+function ensureLive(p: KronosysUpdatePayload): Record<string, unknown> {
+  if (!p.current) {
+    p.current = {};
+  }
+  return p.current as Record<string, unknown>;
+}
+
+/** Enrichit `knownTags` avec des étiquettes vues sur une tâche (suggestions / datalist). */
+function mergeDiscoveredTagsIntoPayloadKnownTags(p: KronosysUpdatePayload, tagList: string[]): void {
+  const known = [...((p.knownTags || []) as string[])];
+  const seen = new Set(known.map((t) => normalizeTagKey(String(t)).toLowerCase()));
+  for (const raw of tagList) {
+    const nk = normalizeTagKey(typeof raw === "string" ? raw : String(raw));
+    const lk = nk.toLowerCase();
+    if (nk && !seen.has(lk)) {
+      seen.add(lk);
+      known.push(nk);
+    }
+  }
+  p.knownTags = known;
+}
+
+/** Enrichit `knownProjects` avec un projet vu sur une tâche (suggestions / datalist, Paramètres). */
+function mergeDiscoveredProjectIntoPayloadKnownProjects(
+  p: KronosysUpdatePayload,
+  project: string | null | undefined
+): void {
+  if (project === undefined || project === null) {
+    return;
+  }
+  const pk = normalizeProjectKey(String(project).trim());
+  if (!pk) {
+    return;
+  }
+  const lk = pk.toLowerCase();
+  const known = [...((p.knownProjects || []) as string[])];
+  if (known.some((x) => normalizeProjectKey(String(x)).toLowerCase() === lk)) {
+    return;
+  }
+  known.push(pk);
+  p.knownProjects = known;
+}
+
+function mergeCfg(p: KronosysUpdatePayload, patch: Record<string, unknown>): void {
+  const base = { ...defaultKronosysCfg(), ...(asRecord(p.cfg) ?? {}) };
+  p.cfg = { ...base, ...patch };
+}
+
+const CFG_KEYS_PRESERVED_ON_RESET: readonly string[] = [
+  "gitlabTokenStored",
+  "gitlabTokenFromEnv",
+  "mongodbUriConfigured",
+  "mongodbManualUriConfigured",
+  "mongodbPasswordConfigured",
+];
+
+/** Réinitialise `cfg` aux valeurs de `defaultKronosysCfg()`, sans effacer les drapeaux liés aux secrets déjà enregistrés. */
+function resetCfgToDefaults(p: KronosysUpdatePayload): void {
+  const prev = asRecord(p.cfg) ?? {};
+  const next: Record<string, unknown> = { ...defaultKronosysCfg() };
+  for (const key of CFG_KEYS_PRESERVED_ON_RESET) {
+    if (Object.prototype.hasOwnProperty.call(prev, key)) {
+      next[key] = prev[key];
+    }
+  }
+  p.cfg = next;
+}
+
+/** Chaîne vide ou origine https (sans chemin). `null` si la valeur est non vide mais illisible. */
+function parseGitlabInstanceOrigin(raw: string): string | null {
+  const t = raw.trim();
+  if (t.length === 0) {
+    return null;
+  }
+  let s = t.replace(/\/$/, "").replace(/\/api\/v4\/?$/i, "");
+  if (!/^https?:\/\//i.test(s)) {
+    s = `https://${s}`;
+  }
+  try {
+    const u = new URL(s);
+    if (u.protocol !== "http:" && u.protocol !== "https:") {
+      return null;
+    }
+    return u.origin;
+  } catch {
+    return null;
+  }
+}
+
+type ResolvedGitlabOrigin = { ok: true; origin: string } | { ok: false; reason: "invalid_url" };
+
+function resolveGitlabApiOrigin(cfg: Record<string, unknown>, body: Record<string, unknown>): ResolvedGitlabOrigin {
+  const bodyRaw = typeof body.gitlabApiBaseUrl === "string" ? body.gitlabApiBaseUrl.trim() : "";
+  if (bodyRaw.length > 0) {
+    const o = parseGitlabInstanceOrigin(bodyRaw);
+    if (!o) {
+      return { ok: false, reason: "invalid_url" };
+    }
+    return { ok: true, origin: o };
+  }
+  const cfgRaw = typeof cfg.gitlabApiBaseUrl === "string" ? cfg.gitlabApiBaseUrl.trim() : "";
+  if (cfgRaw.length > 0) {
+    const o = parseGitlabInstanceOrigin(cfgRaw);
+    if (o) {
+      return { ok: true, origin: o };
+    }
+  }
+  const envRaw = (process.env.GITLAB_INSTANCE_URL ?? "").trim();
+  if (envRaw.length > 0) {
+    const o = parseGitlabInstanceOrigin(envRaw);
+    if (o) {
+      return { ok: true, origin: o };
+    }
+  }
+  return { ok: true, origin: "https://gitlab.com" };
+}
+
+function resolveGitlabPat(cfg: Record<string, unknown>, body: Record<string, unknown>): string {
+  const fromBody = typeof body.token === "string" ? body.token.trim() : "";
+  if (fromBody.length > 0) {
+    return fromBody;
+  }
+  const fromStore = readGitlabPatFromStore().trim();
+  if (fromStore.length > 0) {
+    return fromStore;
+  }
+  if (cfg.gitlabTokenFromEnv === true) {
+    return (process.env.GITLAB_TOKEN ?? "").trim();
+  }
+  return "";
+}
+
+async function readGitlabApiErrorMessage(res: Response): Promise<string> {
+  const raw = await res.text();
+  let message = res.statusText || `HTTP ${res.status}`;
+  const trimmed = raw.trim();
+  if (trimmed.length > 0) {
+    try {
+      const j = JSON.parse(trimmed) as { message?: unknown };
+      if (typeof j.message === "string" && j.message.trim()) {
+        message = j.message.trim();
+      } else {
+        message = trimmed.slice(0, 240);
+      }
+    } catch {
+      message = trimmed.slice(0, 240);
+    }
+  }
+  return message;
+}
+
+function isGitlabIssuesFetchTimeoutError(e: unknown): boolean {
+  if (e instanceof Error && e.name === "TimeoutError") {
+    return true;
+  }
+  if (typeof DOMException !== "undefined" && e instanceof DOMException && e.name === "TimeoutError") {
+    return true;
+  }
+  if (e instanceof Error && e.name === "AbortError") {
+    const m = e.message.toLowerCase();
+    return m.includes("timeout") || m.includes("timed out");
+  }
+  return false;
+}
+
+function remoteIssuesGitlabTimeoutMessage(langFr: boolean): string {
+  const s = GITLAB_ISSUES_SEARCH_TIMEOUT_MS / 1000;
+  return langFr
+    ? `Dépassement du délai (${s}s) lors de l’appel à l’API GitLab. Vérifiez l’URL d’instance, le réseau ou réessayez.`
+    : `Timed out (${s}s) calling the GitLab API. Check instance URL, network, or try again.`;
+}
+
+function remoteIssuesFailureMessage(e: unknown, langFr: boolean): string {
+  if (isGitlabIssuesFetchTimeoutError(e)) {
+    return remoteIssuesGitlabTimeoutMessage(langFr);
+  }
+  return e instanceof Error ? e.message : String(e);
+}
+
+async function gitlabAuthorizedGet(url: string, token: string, timeoutMs: number): Promise<Response> {
+  const signal = AbortSignal.timeout(timeoutMs);
+  let res = await fetch(url, { headers: { "PRIVATE-TOKEN": token }, signal });
+  if (res.status === 401) {
+    await res.text().catch(() => undefined);
+    res = await fetch(url, { headers: { Authorization: `Bearer ${token}` }, signal });
+  }
+  return res;
+}
+
+const GITLAB_REMOTE_ISSUES_MAX = 30;
+
+function compactGitlabIssueSearchInput(raw: string): string {
+  return raw.trim().replace(/\s+/g, "");
+}
+
+/**
+ * Seul un IID numérique : `GET /issues?search=` ne cherche que titre/description ;
+ * GitLab attend `iids[]` pour filtrer par numéro d’issue dans les projets accessibles.
+ */
+function parseGitlabIssuesNumericOnlyIid(searchTrim: string): number | null {
+  const compact = compactGitlabIssueSearchInput(searchTrim);
+  const m = /^#?(\d{1,10})$/.exec(compact);
+  if (!m) {
+    return null;
+  }
+  const n = Number.parseInt(m[1], 10);
+  return Number.isFinite(n) && n >= 0 ? n : null;
+}
+
+function dedupeKeyForGitlabIssueRow(o: Record<string, unknown>): string | null {
+  if (typeof o.id === "number" && Number.isFinite(o.id)) {
+    return `id:${o.id}`;
+  }
+  const pid = o.project_id;
+  const iid = o.iid;
+  if (typeof pid === "number" && Number.isFinite(pid) && typeof iid === "number" && Number.isFinite(iid)) {
+    return `p${pid}:i${iid}`;
+  }
+  return null;
+}
+
+function mapGitlabIssueRowToRemote(o: Record<string, unknown>): {
+  title: string;
+  number: number | string;
+  source: string;
+} {
+  const iid = o.iid ?? o.id;
+  const title = typeof o.title === "string" ? o.title : "";
+  const web = typeof o.web_url === "string" ? o.web_url : "";
+  const refs = asRecord(o.references);
+  const full = typeof refs?.full === "string" ? refs.full : "";
+  let source = "";
+  if (full.length > 0) {
+    source = full;
+  } else if (web.length > 0) {
+    source = web;
+  }
+  let num: number | string = "";
+  if (typeof iid === "number" && Number.isFinite(iid)) {
+    num = iid;
+  } else if (typeof iid === "string" && iid.trim().length > 0) {
+    num = iid.trim();
+  } else if (typeof o.id === "number" && Number.isFinite(o.id)) {
+    num = o.id as number;
+  }
+  return { title, number: num, source };
+}
+
+function mergeGitlabIssueRows(primary: unknown[], secondary: unknown[], max: number) {
+  const seen = new Set<string>();
+  const out: ReturnType<typeof mapGitlabIssueRowToRemote>[] = [];
+  const consider = (rows: unknown[]) => {
+    if (!Array.isArray(rows)) {
+      return;
+    }
+    for (const item of rows) {
+      if (!item || typeof item !== "object") {
+        continue;
+      }
+      const o = item as Record<string, unknown>;
+      const k = dedupeKeyForGitlabIssueRow(o);
+      if (k) {
+        if (seen.has(k)) {
+          continue;
+        }
+        seen.add(k);
+      }
+      out.push(mapGitlabIssueRowToRemote(o));
+      if (out.length >= max) {
+        return;
+      }
+    }
+  };
+  consider(primary);
+  consider(secondary);
+  return out;
+}
+
+async function gitlabGetJsonArray(
+  urlStr: string,
+  token: string,
+  timeoutMs: number,
+  langFr: boolean,
+): Promise<{ ok: true; rows: unknown[] } | { ok: false; message: string }> {
+  try {
+    const res = await gitlabAuthorizedGet(urlStr, token, timeoutMs);
+    if (!res.ok) {
+      const message = await readGitlabApiErrorMessage(res);
+      return { ok: false, message };
+    }
+    const data: unknown = await res.json();
+    return { ok: true, rows: Array.isArray(data) ? data : [] };
+  } catch (e) {
+    return { ok: false, message: remoteIssuesFailureMessage(e, langFr) };
+  }
+}
+
+async function dispatchFetchRemoteIssues(
+  p: KronosysUpdatePayload,
+  body: Record<string, unknown>,
+): Promise<ActionResult> {
+  const cfg = { ...defaultKronosysCfg(), ...(asRecord(p.cfg) ?? {}) };
+  const langFr = body.lang === "fr";
+  const token = resolveGitlabPat(cfg, body);
+  if (!token) {
+    const hadStoredFlag = cfg.gitlabTokenStored === true;
+    const msg = hadStoredFlag
+      ? langFr
+        ? "Ce tableau de bord n’a pas de copie locale du jeton (un clic sur « Enregistrer le jeton » avec le champ vide l’efface). Collez le jeton, enregistrez avec le champ rempli, puis « Tester la connexion ». Sinon définissez GITLAB_TOKEN sur le processus serveur."
+        : "This dashboard has no local copy of the token (clicking Save token with an empty field clears it). Paste your token, save with a non-empty field, then Test connection. Or set GITLAB_TOKEN on the server process."
+      : langFr
+        ? "Aucun jeton GitLab disponible pour ce serveur : enregistrez le jeton dans les paramètres, ou définissez GITLAB_TOKEN si vous utilisez le jeton d’environnement."
+        : "No GitLab token available to this server: save your token in Settings, or set GITLAB_TOKEN when using the environment token.";
+    return {
+      ok: true,
+      result: {
+        remoteIssues: [],
+        remoteIssuesError: msg,
+      },
+    };
+  }
+  const resolved = resolveGitlabApiOrigin(cfg, body);
+  if (!resolved.ok) {
+    return {
+      ok: true,
+      result: {
+        remoteIssues: [],
+        remoteIssuesError: langFr ? "URL d’instance GitLab invalide." : "Invalid GitLab instance URL.",
+      },
+    };
+  }
+  const searchTrim = typeof body.search === "string" ? body.search.trim() : "";
+  if (searchTrim.length === 0) {
+    return { ok: true, result: { remoteIssues: [] } };
+  }
+  const origin = resolved.origin;
+  const timeout = GITLAB_ISSUES_SEARCH_TIMEOUT_MS;
+  const iidOnly = parseGitlabIssuesNumericOnlyIid(searchTrim);
+
+  try {
+    if (iidOnly !== null) {
+      const listUrl = new URL(`${origin}/api/v4/issues`);
+      listUrl.searchParams.set("state", "all");
+      listUrl.searchParams.set("scope", "all");
+      listUrl.searchParams.set("per_page", String(GITLAB_REMOTE_ISSUES_MAX));
+      listUrl.searchParams.set("order_by", "updated_at");
+      listUrl.searchParams.set("sort", "desc");
+      listUrl.searchParams.append("iids[]", String(iidOnly));
+      const first = await gitlabGetJsonArray(listUrl.toString(), token, timeout, langFr);
+      if (!first.ok) {
+        return { ok: true, result: { remoteIssues: [], remoteIssuesError: first.message } };
+      }
+      const remoteIssues = mergeGitlabIssueRows(first.rows, [], GITLAB_REMOTE_ISSUES_MAX);
+      return { ok: true, result: { remoteIssues } };
+    }
+
+    const issuesUrl = new URL(`${origin}/api/v4/issues`);
+    issuesUrl.searchParams.set("state", "all");
+    issuesUrl.searchParams.set("scope", "all");
+    issuesUrl.searchParams.set("per_page", String(GITLAB_REMOTE_ISSUES_MAX));
+    issuesUrl.searchParams.set("order_by", "updated_at");
+    issuesUrl.searchParams.set("sort", "desc");
+    issuesUrl.searchParams.set("search", searchTrim);
+
+    const searchUrl = new URL(`${origin}/api/v4/search`);
+    searchUrl.searchParams.set("scope", "issues");
+    searchUrl.searchParams.set("search", searchTrim);
+    searchUrl.searchParams.set("per_page", String(Math.min(20, GITLAB_REMOTE_ISSUES_MAX)));
+
+    const [issuesRes, searchRes] = await Promise.all([
+      gitlabGetJsonArray(issuesUrl.toString(), token, timeout, langFr),
+      gitlabGetJsonArray(searchUrl.toString(), token, timeout, langFr),
+    ]);
+
+    if (!issuesRes.ok && !searchRes.ok) {
+      return {
+        ok: true,
+        result: { remoteIssues: [], remoteIssuesError: issuesRes.message },
+      };
+    }
+
+    const rowsIssues = issuesRes.ok ? issuesRes.rows : [];
+    const rowsSearch = searchRes.ok ? searchRes.rows : [];
+    const remoteIssues = mergeGitlabIssueRows(rowsIssues, rowsSearch, GITLAB_REMOTE_ISSUES_MAX);
+    return { ok: true, result: { remoteIssues } };
+  } catch (e) {
+    const message = remoteIssuesFailureMessage(e, langFr);
+    return { ok: true, result: { remoteIssues: [], remoteIssuesError: message } };
+  }
+}
+
+async function dispatchGitlabConnectionTest(
+  p: KronosysUpdatePayload,
+  body: Record<string, unknown>,
+): Promise<ActionResult> {
+  const cfg = { ...defaultKronosysCfg(), ...(asRecord(p.cfg) ?? {}) };
+  const token = resolveGitlabPat(cfg, body);
+  if (!token) {
+    mergeCfg(p, { gitlabApiVerified: false });
+    writePayload(p);
+    return {
+      ok: true,
+      result: { gitlabConnectionTest: { outcome: "failed" as const, reason: "no_token" as const } },
+    };
+  }
+  const resolved = resolveGitlabApiOrigin(cfg, body);
+  if (!resolved.ok) {
+    const msg =
+      body.lang === "fr"
+        ? "URL d’instance GitLab invalide (ex. https://gitlab.com ou https://gitlab.entreprise.com)."
+        : "Invalid GitLab instance URL (e.g. https://gitlab.com or https://gitlab.company.com).";
+    mergeCfg(p, { gitlabApiVerified: false });
+    writePayload(p);
+    return {
+      ok: true,
+      result: { gitlabConnectionTest: { outcome: "failed" as const, message: msg } },
+    };
+  }
+  const { origin } = resolved;
+  const url = `${origin}/api/v4/user`;
+
+  try {
+    const res = await gitlabAuthorizedGet(url, token, 15_000);
+    if (!res.ok) {
+      const message = await readGitlabApiErrorMessage(res);
+      mergeCfg(p, { gitlabApiVerified: false });
+      writePayload(p);
+      return {
+        ok: true,
+        result: { gitlabConnectionTest: { outcome: "failed" as const, message } },
+      };
+    }
+    mergeCfg(p, { gitlabApiVerified: true });
+    writePayload(p);
+    return { ok: true, result: { gitlabConnectionTest: { outcome: "connected" as const } } };
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    mergeCfg(p, { gitlabApiVerified: false });
+    writePayload(p);
+    return {
+      ok: true,
+      result: { gitlabConnectionTest: { outcome: "failed" as const, message } },
+    };
+  }
+}
+
+function ensureKronoFocus(cur: Record<string, unknown>): Record<string, unknown> {
+  let pm = asRecord(cur.kronoFocus);
+  if (!pm) {
+    pm = {
+      mode: "work",
+      status: "idle",
+      timeLeftSeconds: 25 * 60,
+      sessionsCompleted: 0,
+      workDurationSeconds: 25 * 60,
+      shortBreakDurationSeconds: 5 * 60,
+      longBreakDurationSeconds: 15 * 60,
+    };
+    cur.kronoFocus = pm;
+  }
+  return pm;
+}
+
+function kronoFocusWorkSeconds(cur: Record<string, unknown>): number {
+  return readWorkDurationSeconds(asRecord(cur.kronoFocus));
+}
+
+function newTaskRecord(
+  input: {
+    name: string;
+    tags?: string[];
+    project?: string | null;
+  },
+  tagNormOpts: TaskTagsStorageNormalizeOpts
+): Record<string, unknown> {
+  const now = new Date().toISOString();
+  return {
+    id: randomUUID(),
+    name: input.name.trim(),
+    startTime: now,
+    durationMs: 0,
+    isDone: false,
+    kronoFocusCycles: 0,
+    tags: normalizeTaskTagsForStorage(input.tags, tagNormOpts),
+    project: input.project ?? null,
+    subtasks: [],
+  };
+}
+
+export async function dispatchKronosysAction(body: Record<string, unknown>): Promise<ActionResult> {
+  const type = typeof body.type === "string" ? body.type : "";
+  const p = readPayload();
+  const tagNormOpts: TaskTagsStorageNormalizeOpts = {
+    assignDefaultTagBucket: readTaskDefaultTagBucketEnabled(p.cfg),
+  };
+
+  const finish = (): ActionResult => {
+    writePayload(p);
+    return { ok: true, result: {} };
+  };
+
+  switch (type) {
+    case "updateKronosysSettings": {
+      const s = asRecord(body.settings);
+      if (s) {
+        const merged = { ...s };
+        if (typeof merged.gitlabApiBaseUrl === "string") {
+          const parsed = parseGitlabInstanceOrigin(merged.gitlabApiBaseUrl);
+          merged.gitlabApiBaseUrl = parsed ?? "";
+        }
+        tryPersistDevDataPreferenceFromCfg(merged);
+        if (typeof merged.dashboardDisplayTimeZone === "string") {
+          const z = merged.dashboardDisplayTimeZone.trim();
+          merged.dashboardDisplayTimeZone = isValidIanaTimeZone(z) ? z : DEFAULT_DASHBOARD_TIME_ZONE;
+        }
+        if ("dashboardUse24HourClock" in merged) {
+          merged.dashboardUse24HourClock = merged.dashboardUse24HourClock !== false;
+        }
+        p.cfg = { ...defaultKronosysCfg(), ...(p.cfg as Record<string, unknown>), ...merged };
+      }
+      return finish();
+    }
+    case "resetKronosysSettings": {
+      resetCfgToDefaults(p);
+      tryPersistDevDataPreferenceFromCfg({ developmentUseProductionData: false });
+      return finish();
+    }
+    case "setGitIdentity": {
+      const name = typeof body.gitUserName === "string" ? body.gitUserName.trim() : "";
+      const email = typeof body.gitUserEmail === "string" ? body.gitUserEmail.trim() : "";
+      const login = typeof body.gitAccountLogin === "string" ? body.gitAccountLogin.trim() : "";
+      p.gitIdentity = {
+        gitUserName: name.length > 0 ? name : null,
+        gitUserEmail: email.length > 0 ? email : null,
+        gitAccountLogin: login.length > 0 ? login : null,
+      };
+      return finish();
+    }
+    case "setLanguage": {
+      const cur = ensureLive(p);
+      cur.language = body.lang === "fr" ? "fr" : "en";
+      syncLiveIntoHistory(p);
+      return finish();
+    }
+    case "inspectSession": {
+      p.inspectingSessionId = body.sessionId === null || body.sessionId === undefined ? null : String(body.sessionId);
+      return finish();
+    }
+    case "setPaused": {
+      const cur = ensureLive(p);
+      if (body.paused === true) {
+        flushSessionWallSegmentOnLive(cur);
+        cur.isPaused = true;
+      } else {
+        cur.isPaused = false;
+        ensureSessionWallSegmentOnLive(cur);
+      }
+      syncLiveIntoHistory(p);
+      return finish();
+    }
+    case "setSessionName": {
+      const name = typeof body.name === "string" ? body.name : "";
+      const sid = typeof body.sessionId === "string" ? body.sessionId : undefined;
+      const cur = asRecord(p.current);
+      if (sid && cur?.sessionId === sid) {
+        cur.sessionName = name;
+      } else if (!sid && cur) {
+        cur.sessionName = name;
+      }
+      const hist = (p.history || []) as Record<string, unknown>[];
+      const id = sid ?? (typeof cur?.sessionId === "string" ? cur.sessionId : "");
+      const row = hist.find((h) => h.sessionId === id);
+      if (row) {
+        row.sessionName = name;
+      }
+      const arch = (p.historyArchived || []) as Record<string, unknown>[];
+      const ar = arch.find((h) => h.sessionId === id);
+      if (ar) {
+        ar.sessionName = name;
+      }
+      syncLiveIntoHistory(p);
+      return finish();
+    }
+    case "setSessionStartTime": {
+      const sidFromBody = typeof body.sessionId === "string" ? body.sessionId.trim() : "";
+      const isoRaw = typeof body.startAt === "string" ? body.startAt.trim() : "";
+      const startMs = Date.parse(isoRaw);
+      if (!Number.isFinite(startMs)) {
+        return finish();
+      }
+      const nowMs = Date.now();
+      const startAtIso = new Date(startMs).toISOString();
+      const cur = asRecord(p.current);
+      const id =
+        sidFromBody || (typeof cur?.sessionId === "string" ? String(cur.sessionId).trim() : "");
+      if (!id) {
+        return finish();
+      }
+      const applyToRow = (row: Record<string, unknown> | undefined): void => {
+        if (!row) {
+          return;
+        }
+        row.startAt = startAtIso;
+        const endRaw = typeof row.endAt === "string" ? row.endAt.trim() : "";
+        const endMs = Date.parse(endRaw);
+        if (Number.isFinite(endMs) && endMs >= startMs) {
+          row.sessionDurationMinutes = (endMs - startMs) / 60000;
+          return;
+        }
+        row.sessionDurationMinutes = Math.max(0, (nowMs - startMs) / 60000);
+        if (row === cur && row.isPaused !== true && row.archived !== true) {
+          row[SESSION_WALL_SEGMENT_STARTED_AT] = new Date(nowMs).toISOString();
+        }
+      };
+      if (cur?.sessionId === id) {
+        applyToRow(cur);
+      }
+      const hist = (p.history || []) as Record<string, unknown>[];
+      applyToRow(hist.find((h) => h.sessionId === id));
+      const arch = (p.historyArchived || []) as Record<string, unknown>[];
+      applyToRow(arch.find((h) => h.sessionId === id));
+      syncLiveIntoHistory(p);
+      return finish();
+    }
+    case "setSessionEndTime": {
+      const sidFromBody = typeof body.sessionId === "string" ? body.sessionId.trim() : "";
+      const isoRaw = typeof body.endAt === "string" ? body.endAt.trim() : "";
+      const endMs = Date.parse(isoRaw);
+      if (!Number.isFinite(endMs)) {
+        return finish();
+      }
+      const endAtIso = new Date(endMs).toISOString();
+      const cur = asRecord(p.current);
+      const id =
+        sidFromBody || (typeof cur?.sessionId === "string" ? String(cur.sessionId).trim() : "");
+      if (!id) {
+        return finish();
+      }
+      const applyToRow = (row: Record<string, unknown> | undefined): void => {
+        if (!row) {
+          return;
+        }
+        const prevEnd = typeof row.endAt === "string" ? row.endAt.trim() : "";
+        if (!prevEnd) {
+          return;
+        }
+        const startRaw = typeof row.startAt === "string" ? row.startAt.trim() : "";
+        const startMs = Date.parse(startRaw);
+        if (!Number.isFinite(startMs) || endMs < startMs) {
+          return;
+        }
+        row.endAt = endAtIso;
+        row.sessionDurationMinutes = (endMs - startMs) / 60000;
+      };
+      if (cur?.sessionId === id) {
+        applyToRow(cur);
+      }
+      const hist = (p.history || []) as Record<string, unknown>[];
+      applyToRow(hist.find((h) => h.sessionId === id));
+      const arch = (p.historyArchived || []) as Record<string, unknown>[];
+      applyToRow(arch.find((h) => h.sessionId === id));
+      syncLiveIntoHistory(p);
+      return finish();
+    }
+    case "setSessionEndReason": {
+      const sidFromBody = typeof body.sessionId === "string" ? body.sessionId.trim() : "";
+      const cur = asRecord(p.current);
+      const id =
+        sidFromBody || (typeof cur?.sessionId === "string" ? String(cur.sessionId).trim() : "");
+      if (!id) {
+        return finish();
+      }
+      const rk = normalizeSessionEndReasonKind(body.sessionEndReasonKind);
+      const rn = normalizeSessionEndReasonNote(body.sessionEndReasonNote);
+      const applyToRow = (row: Record<string, unknown> | undefined): void => {
+        if (!row) {
+          return;
+        }
+        if (rk) {
+          row.sessionEndReasonKind = rk;
+        } else {
+          delete row.sessionEndReasonKind;
+        }
+        if (rn.length > 0) {
+          row.sessionEndReasonNote = rn;
+        } else {
+          delete row.sessionEndReasonNote;
+        }
+      };
+      if (cur?.sessionId === id) {
+        applyToRow(cur);
+      }
+      const hist = (p.history || []) as Record<string, unknown>[];
+      applyToRow(hist.find((h) => h.sessionId === id));
+      const arch = (p.historyArchived || []) as Record<string, unknown>[];
+      applyToRow(arch.find((h) => h.sessionId === id));
+      syncLiveIntoHistory(p);
+      return finish();
+    }
+    case "newSession": {
+      const id = randomUUID();
+      const startMs = Date.now();
+      const now = new Date(startMs).toISOString();
+      const prevCur = asRecord(p.current);
+      const prevLang = typeof prevCur?.language === "string" ? String(prevCur.language) : "en";
+      const bodyRec = body as Record<string, unknown>;
+      const schedIn = bodyRec.scheduledStartAt;
+      const ass: SessionStartAssiduity | undefined =
+        typeof schedIn === "string" && schedIn.trim() !== ""
+          ? (assiduityFromScheduledStart(startMs, schedIn) ?? undefined)
+          : undefined;
+      p.current = {
+        sessionId: id,
+        sessionName: "",
+        archived: false,
+        isPaused: false,
+        savedAt: now,
+        createdAt: now,
+        startAt: now,
+        endAt: null,
+        ...(ass
+          ? { scheduledStartAt: ass.scheduledStartAt, sessionStartOffsetMinutes: ass.sessionStartOffsetMinutes }
+          : {}),
+        [SESSION_WALL_SEGMENT_STARTED_AT]: now,
+        sessionDurationMinutes: 0,
+        codingMinutesSession: 0,
+        activeMinutes: 0,
+        totalEvents: 0,
+        language: prevLang,
+        tasks: [],
+        activeTasks: [],
+        activeTask: null,
+        sessionScope: body.sessionScope,
+        kronoFocus: {
+          mode: "work",
+          status: "idle",
+          timeLeftSeconds: 25 * 60,
+          sessionsCompleted: 0,
+          workDurationSeconds: 25 * 60,
+          shortBreakDurationSeconds: 5 * 60,
+          longBreakDurationSeconds: 15 * 60,
+        },
+      };
+      syncLiveIntoHistory(p);
+      return finish();
+    }
+    case "startTask": {
+      const cur = ensureLive(p);
+      const name = typeof body.name === "string" ? body.name : "";
+      const tags = normalizeTaskTagsForStorage(
+        Array.isArray(body.tags) ? (body.tags as string[]) : [],
+        tagNormOpts
+      );
+      const project = typeof body.project === "string" ? body.project : undefined;
+      mergeDiscoveredTagsIntoPayloadKnownTags(p, mergeTagsForDisplay(name, tags));
+      mergeDiscoveredProjectIntoPayloadKnownProjects(p, project);
+      mergeDiscoveredProjectIntoPayloadKnownProjects(p, parseTaskWithAutoTags(name).project);
+      const task = newTaskRecord({ name, tags, project }, tagNormOpts);
+      const active = Array.isArray(cur.activeTasks) ? ([...cur.activeTasks] as Record<string, unknown>[]) : [];
+      active.push(task);
+      cur.activeTasks = active;
+      cur.activeTask = task;
+      prepareSessionForExclusiveMainTimerUnpaused(cur, String(task.id));
+      const bodyRec = body as Record<string, unknown>;
+      if (body.startKronoFocus === true || bodyRec[LEGACY_START_TASK_WITH_TIMER_BODY_KEY] === true) {
+        const pm = ensureKronoFocus(cur);
+        const ws = kronoFocusWorkSeconds(cur);
+        pm.mode = "work";
+        pm.status = "running";
+        pm.timeLeftSeconds = ws;
+        pm.kronoFocusDeadlineAtMs = Date.now() + ws * 1000;
+        pm.linkedTaskId = String(task.id);
+        pm.linkedTaskName = typeof task.name === "string" ? task.name : "";
+      }
+      syncLiveIntoHistory(p);
+      return finish();
+    }
+    case "deleteHistorySession": {
+      const sessionId = String(body.sessionId ?? "");
+      p.history = ((p.history || []) as Record<string, unknown>[]).filter((h) => h.sessionId !== sessionId);
+      p.historyArchived = ((p.historyArchived || []) as Record<string, unknown>[]).filter(
+        (h) => h.sessionId !== sessionId
+      );
+      const cur = asRecord(p.current);
+      if (cur?.sessionId === sessionId) {
+        p.current = undefined;
+      }
+      return finish();
+    }
+    case "archiveSession": {
+      const sessionId = String(body.sessionId ?? "");
+      const archived = body.archived === true;
+      const histOrig = (p.history || []) as Record<string, unknown>[];
+      const archOrig = (p.historyArchived || []) as Record<string, unknown>[];
+      const found =
+        histOrig.find((h) => h.sessionId === sessionId) || archOrig.find((h) => h.sessionId === sessionId);
+      if (!found) {
+        return finish();
+      }
+      const hist = histOrig.filter((h) => h.sessionId !== sessionId);
+      const arch = archOrig.filter((h) => h.sessionId !== sessionId);
+      const row = { ...found, archived };
+      if (archived) {
+        arch.unshift(row);
+      } else {
+        hist.unshift(row);
+      }
+      p.history = hist;
+      p.historyArchived = arch;
+      const cur = asRecord(p.current);
+      if (cur?.sessionId === sessionId) {
+        cur.archived = archived;
+      }
+      syncLiveIntoHistory(p);
+      return finish();
+    }
+    case "clearHistory": {
+      p.history = [];
+      p.historyArchived = [];
+      p.current = undefined;
+      p.inspectingSessionId = null;
+      p.knownTags = [];
+      p.knownProjects = [];
+      p.userKnownTags = [];
+      p.excludedSuggestionTags = [];
+      p.tagDescriptions = {};
+      p.projectDescriptions = {};
+      p.gitIdentity = {};
+      delete p.gitStats;
+      delete p.dismissArchiveSessionConfirm;
+      delete p.workspaceCodeSnapshot;
+      mergeCfg(p, { showWelcomeOnStartup: true });
+      return finish();
+    }
+    case "endLiveSession": {
+      const cur = asRecord(p.current);
+      if (cur) {
+        flushSessionWallSegmentOnLive(cur);
+        cur.endAt = new Date().toISOString();
+        const rk = normalizeSessionEndReasonKind(body.sessionEndReasonKind);
+        if (rk) {
+          cur.sessionEndReasonKind = rk;
+        } else {
+          delete cur.sessionEndReasonKind;
+        }
+        const rn = normalizeSessionEndReasonNote(body.sessionEndReasonNote);
+        if (rn.length > 0) {
+          cur.sessionEndReasonNote = rn;
+        } else {
+          delete cur.sessionEndReasonNote;
+        }
+        syncLiveIntoHistory(p);
+      }
+      p.current = undefined;
+      return finish();
+    }
+    case "updateTask": {
+      const ctx = resolveTaskSession(p, body.sessionId);
+      if (!ctx) {
+        return finish();
+      }
+      const taskId = String(body.taskId ?? "");
+      const projectPatch =
+        body.project === null
+          ? (null as string | null)
+          : typeof body.project === "string"
+            ? body.project
+            : undefined;
+      if (
+        !updateTaskInSession(
+          ctx.session,
+          taskId,
+          {
+            name: typeof body.name === "string" ? body.name : undefined,
+            tags: Array.isArray(body.tags) ? (body.tags as string[]) : undefined,
+            project: projectPatch,
+          },
+          tagNormOpts
+        )
+      ) {
+        return finish();
+      }
+      if (Array.isArray(body.tags)) {
+        mergeDiscoveredTagsIntoPayloadKnownTags(p, body.tags as string[]);
+      } else if (typeof body.name === "string") {
+        mergeDiscoveredTagsIntoPayloadKnownTags(p, mergeTagsForDisplay(body.name, []));
+      }
+      if (typeof projectPatch === "string") {
+        mergeDiscoveredProjectIntoPayloadKnownProjects(p, projectPatch);
+      } else if (typeof body.name === "string") {
+        mergeDiscoveredProjectIntoPayloadKnownProjects(p, parseTaskWithAutoTags(body.name).project);
+      }
+      if (ctx.isLive) {
+        syncLiveIntoHistory(p);
+      }
+      return finish();
+    }
+    case "setTaskStartTime": {
+      const ctx = resolveTaskSession(p, body.sessionId);
+      if (!ctx) {
+        return finish();
+      }
+      const taskId = String(body.taskId ?? "");
+      const startTime = typeof body.startTime === "string" ? body.startTime.trim() : "";
+      if (!taskId || !startTime) {
+        return finish();
+      }
+      const ok = updateTaskStartTimeInSession(ctx.session, taskId, startTime);
+      if (ok && ctx.isLive) {
+        syncLiveIntoHistory(p);
+      }
+      return finish();
+    }
+    case "setTaskEndTime": {
+      const ctx = resolveTaskSession(p, body.sessionId);
+      if (!ctx) {
+        return finish();
+      }
+      const taskId = String(body.taskId ?? "");
+      const endTime = typeof body.endTime === "string" ? body.endTime.trim() : "";
+      if (!taskId || !endTime) {
+        return finish();
+      }
+      const ok = updateTaskEndTimeInSession(ctx.session, taskId, endTime);
+      if (ok && ctx.isLive) {
+        syncLiveIntoHistory(p);
+      }
+      return finish();
+    }
+    case "finishTask": {
+      const ctx = resolveTaskSession(p, body.sessionId);
+      if (!ctx) {
+        return finish();
+      }
+      const okFinish = finishTaskInSession(
+        ctx.session,
+        String(body.taskId ?? ""),
+        body.shouldCommit === true,
+        tagNormOpts
+      );
+      if (okFinish && ctx.isLive) {
+        syncLiveIntoHistory(p);
+      }
+      return finish();
+    }
+    case "deleteTask": {
+      const ctx = resolveTaskSession(p, body.sessionId);
+      if (!ctx) {
+        return finish();
+      }
+      const okDel = deleteTaskInSession(ctx.session, String(body.taskId ?? ""));
+      if (okDel && ctx.isLive) {
+        syncLiveIntoHistory(p);
+      }
+      return finish();
+    }
+    case "setTaskTimerPaused": {
+      const ctx = resolveTaskSession(p, body.sessionId);
+      if (!ctx) {
+        return finish();
+      }
+      setTaskPausedInSession(ctx.session, String(body.taskId ?? ""), body.paused === true);
+      if (ctx.isLive) {
+        syncLiveIntoHistory(p);
+      }
+      return finish();
+    }
+    case "resumePausedTask": {
+      const ctx = resolveTaskSession(p, body.sessionId);
+      if (!ctx) {
+        return finish();
+      }
+      setTaskPausedInSession(ctx.session, String(body.taskId ?? ""), false);
+      if (ctx.isLive) {
+        syncLiveIntoHistory(p);
+      }
+      return finish();
+    }
+    case "addHistoricalTask": {
+      const ctx = resolveTaskSession(p, body.sessionId);
+      if (!ctx) {
+        return finish();
+      }
+      const name = typeof body.name === "string" ? body.name : "";
+      const tags = normalizeTaskTagsForStorage(
+        Array.isArray(body.tags) ? (body.tags as string[]) : [],
+        tagNormOpts
+      );
+      const project =
+        body.project === null ? null : typeof body.project === "string" ? body.project : undefined;
+      const durationMs = typeof body.durationMs === "number" ? Math.round(body.durationMs) : 0;
+      const startTime = typeof body.startTime === "string" ? body.startTime : "";
+      const endTime = typeof body.endTime === "string" ? body.endTime : "";
+      addHistoricalTaskToSession(
+        ctx.session,
+        { name, tags, project, durationMs, startTime, endTime },
+        randomUUID(),
+        tagNormOpts
+      );
+      mergeDiscoveredTagsIntoPayloadKnownTags(p, mergeTagsForDisplay(name, tags));
+      if (typeof project === "string") {
+        mergeDiscoveredProjectIntoPayloadKnownProjects(p, project);
+      }
+      mergeDiscoveredProjectIntoPayloadKnownProjects(p, parseTaskWithAutoTags(name).project);
+      if (ctx.isLive) {
+        syncLiveIntoHistory(p);
+      }
+      return finish();
+    }
+    case "toggleSubtask": {
+      const ctx = resolveTaskSession(p, body.sessionId);
+      if (!ctx) {
+        return finish();
+      }
+      toggleSubtaskInSession(ctx.session, String(body.taskId ?? ""), String(body.subtaskId ?? ""));
+      if (ctx.isLive) {
+        syncLiveIntoHistory(p);
+      }
+      return finish();
+    }
+    case "updateSubtaskTitle": {
+      const ctx = resolveTaskSession(p, body.sessionId);
+      if (!ctx) {
+        return finish();
+      }
+      updateSubtaskTitleInSession(
+        ctx.session,
+        String(body.taskId ?? ""),
+        String(body.subtaskId ?? ""),
+        typeof body.title === "string" ? body.title : ""
+      );
+      if (ctx.isLive) {
+        syncLiveIntoHistory(p);
+      }
+      return finish();
+    }
+    case "setActiveSubtaskTimer": {
+      const ctx = resolveTaskSession(p, body.sessionId);
+      if (!ctx) {
+        return finish();
+      }
+      const sid =
+        body.subtaskId === null || body.subtaskId === undefined ? null : String(body.subtaskId);
+      setActiveSubtaskTimerInSession(ctx.session, String(body.taskId ?? ""), sid);
+      if (ctx.isLive) {
+        syncLiveIntoHistory(p);
+      }
+      return finish();
+    }
+    case "deleteSubtask": {
+      const ctx = resolveTaskSession(p, body.sessionId);
+      if (!ctx) {
+        return finish();
+      }
+      deleteSubtaskInSession(ctx.session, String(body.taskId ?? ""), String(body.subtaskId ?? ""));
+      if (ctx.isLive) {
+        syncLiveIntoHistory(p);
+      }
+      return finish();
+    }
+    case "reorderSubtasks": {
+      const ctx = resolveTaskSession(p, body.sessionId);
+      if (!ctx) {
+        return finish();
+      }
+      const raw = body.orderedSubtaskIds;
+      const ids = Array.isArray(raw) ? raw.map((x) => String(x)) : [];
+      reorderSubtasksInSession(ctx.session, String(body.taskId ?? ""), ids);
+      if (ctx.isLive) {
+        syncLiveIntoHistory(p);
+      }
+      return finish();
+    }
+    case "addSubtask": {
+      const ctx = resolveTaskSession(p, body.sessionId);
+      if (!ctx) {
+        return finish();
+      }
+      addSubtaskInSession(ctx.session, String(body.taskId ?? ""), typeof body.title === "string" ? body.title : "");
+      if (ctx.isLive) {
+        syncLiveIntoHistory(p);
+      }
+      return finish();
+    }
+    case "startKronoFocus":
+    case LEGACY_ACTION_START: {
+      const cur = asRecord(p.current);
+      if (!cur) {
+        return { ok: true, result: {} };
+      }
+      const pm = ensureKronoFocus(cur);
+      const ws = kronoFocusWorkSeconds(cur);
+      pm.mode = "work";
+      pm.status = "running";
+      pm.timeLeftSeconds = ws;
+      pm.kronoFocusDeadlineAtMs = Date.now() + ws * 1000;
+      if (body.linkToActiveTask === true) {
+        const stack = Array.isArray(cur.activeTasks) ? (cur.activeTasks as Record<string, unknown>[]) : [];
+        const at = asRecord(cur.activeTask);
+        const pick = stack[0] ?? at;
+        if (pick && typeof pick.id === "string") {
+          pm.linkedTaskId = String(pick.id);
+          pm.linkedTaskName = typeof pick.name === "string" ? pick.name : "";
+        } else {
+          delete pm.linkedTaskId;
+          delete pm.linkedTaskName;
+        }
+      } else {
+        delete pm.linkedTaskId;
+        delete pm.linkedTaskName;
+      }
+      syncLiveIntoHistory(p);
+      return finish();
+    }
+    case "pauseKronoFocus":
+    case LEGACY_ACTION_PAUSE: {
+      const cur = asRecord(p.current);
+      if (!cur) {
+        return { ok: true, result: {} };
+      }
+      const pm = ensureKronoFocus(cur);
+      if (pm.status === "running") {
+        const dl = pm.kronoFocusDeadlineAtMs ?? pm[LEGACY_TIMER_DEADLINE_MS_KEY];
+        if (typeof dl === "number" && Number.isFinite(dl)) {
+          pm.timeLeftSeconds = Math.max(0, Math.ceil((dl - Date.now()) / 1000));
+        }
+        delete pm.kronoFocusDeadlineAtMs;
+        delete pm[LEGACY_TIMER_DEADLINE_MS_KEY];
+        pm.status = "paused";
+      }
+      syncLiveIntoHistory(p);
+      return finish();
+    }
+    case "resetKronoFocus":
+    case LEGACY_ACTION_RESET: {
+      const cur = asRecord(p.current);
+      if (!cur) {
+        return { ok: true, result: {} };
+      }
+      const pm = ensureKronoFocus(cur);
+      pm.mode = "work";
+      pm.status = "idle";
+      pm.timeLeftSeconds = kronoFocusWorkSeconds(cur);
+      delete pm.kronoFocusDeadlineAtMs;
+      delete pm[LEGACY_TIMER_DEADLINE_MS_KEY];
+      delete pm.linkedTaskId;
+      delete pm.linkedTaskName;
+      syncLiveIntoHistory(p);
+      return finish();
+    }
+    case "setKronoFocusWorkDuration":
+    case LEGACY_ACTION_SET_WORK_DURATION: {
+      const cur = asRecord(p.current);
+      if (!cur) {
+        return { ok: true, result: {} };
+      }
+      const secRaw = body.seconds;
+      const seconds =
+        typeof secRaw === "number" && Number.isFinite(secRaw)
+          ? clampWorkDurationSeconds(secRaw)
+          : kronoFocusWorkSeconds(cur);
+      const pm = ensureKronoFocus(cur);
+      pm.workDurationSeconds = seconds;
+      if (pm.status === "idle" && pm.mode === "work") {
+        pm.timeLeftSeconds = seconds;
+        delete pm.kronoFocusDeadlineAtMs;
+        delete pm[LEGACY_TIMER_DEADLINE_MS_KEY];
+      }
+      syncLiveIntoHistory(p);
+      return finish();
+    }
+    case "setKronoFocusDurations": {
+      const cur = asRecord(p.current);
+      if (!cur) {
+        return { ok: true, result: {} };
+      }
+      const pm = ensureKronoFocus(cur);
+      const bodyRec = body as Record<string, unknown>;
+      let touchedWork = false;
+      if (typeof bodyRec.workSeconds === "number" && Number.isFinite(bodyRec.workSeconds)) {
+        pm.workDurationSeconds = clampWorkDurationSeconds(bodyRec.workSeconds);
+        touchedWork = true;
+      }
+      if (typeof bodyRec.shortBreakSeconds === "number" && Number.isFinite(bodyRec.shortBreakSeconds)) {
+        pm.shortBreakDurationSeconds = clampBreakDurationSeconds(bodyRec.shortBreakSeconds);
+      }
+      if (typeof bodyRec.longBreakSeconds === "number" && Number.isFinite(bodyRec.longBreakSeconds)) {
+        pm.longBreakDurationSeconds = clampBreakDurationSeconds(bodyRec.longBreakSeconds);
+      }
+      if (pm.status === "idle" && pm.mode === "work" && touchedWork) {
+        pm.timeLeftSeconds = readWorkDurationSeconds(pm);
+        delete pm.kronoFocusDeadlineAtMs;
+        delete pm[LEGACY_TIMER_DEADLINE_MS_KEY];
+      }
+      syncLiveIntoHistory(p);
+      return finish();
+    }
+    case "addUserKnownTag": {
+      const raw = typeof body.tag === "string" ? body.tag.trim() : "";
+      if (!raw) {
+        return finish();
+      }
+      const canon = normalizeTagKey(raw) || raw;
+      const lk = canon.toLowerCase();
+      const known = [...((p.knownTags || []) as string[])];
+      const user = [...((p.userKnownTags || []) as string[])];
+      if (!known.some((t) => normalizeTagKey(t).toLowerCase() === lk)) {
+        known.push(canon);
+      }
+      if (!user.some((t) => normalizeTagKey(t).toLowerCase() === lk)) {
+        user.push(canon);
+      }
+      p.knownTags = known;
+      p.userKnownTags = user;
+      return finish();
+    }
+    case "removeUserKnownTag": {
+      const raw = typeof body.tag === "string" ? body.tag : "";
+      const lk = normalizeTagKey(raw).toLowerCase();
+      p.userKnownTags = ((p.userKnownTags || []) as string[]).filter(
+        (t) => normalizeTagKey(t).toLowerCase() !== lk
+      );
+      return finish();
+    }
+    case "setTagDescription": {
+      const raw = typeof body.tag === "string" ? body.tag : "";
+      const key = normalizeTagKey(raw).toLowerCase();
+      const desc = typeof body.description === "string" ? body.description : "";
+      const td = { ...(asRecord(p.tagDescriptions) ?? {}) } as Record<string, string>;
+      td[key] = desc;
+      p.tagDescriptions = td;
+      return finish();
+    }
+    case "setProjectDescription": {
+      const raw = typeof body.name === "string" ? body.name : "";
+      const key = normalizeProjectKey(raw).toLowerCase();
+      const desc = typeof body.description === "string" ? body.description : "";
+      const pd = { ...(asRecord(p.projectDescriptions) ?? {}) } as Record<string, string>;
+      pd[key] = desc;
+      p.projectDescriptions = pd;
+      return finish();
+    }
+    case "includeTagFromSuggestions": {
+      const raw = typeof body.tag === "string" ? body.tag : "";
+      const lk = normalizeTagKey(raw).toLowerCase();
+      p.excludedSuggestionTags = ((p.excludedSuggestionTags || []) as string[]).filter(
+        (t) => normalizeTagKey(t).toLowerCase() !== lk
+      );
+      return finish();
+    }
+    case "excludeTagFromSuggestions": {
+      const raw = typeof body.tag === "string" ? body.tag : "";
+      const canon = normalizeTagKey(raw) || raw;
+      const lk = canon.toLowerCase();
+      const ex = [...((p.excludedSuggestionTags || []) as string[])];
+      if (!ex.some((t) => normalizeTagKey(t).toLowerCase() === lk)) {
+        ex.push(canon);
+      }
+      p.excludedSuggestionTags = ex;
+      p.userKnownTags = ((p.userKnownTags || []) as string[]).filter(
+        (t) => normalizeTagKey(t).toLowerCase() !== lk
+      );
+      return finish();
+    }
+    case "purgeTagMetadata": {
+      const raw = typeof body.tag === "string" ? body.tag : "";
+      purgeTagEverywhere(p, raw, tagNormOpts);
+      return finish();
+    }
+    case "purgeProjectMetadata": {
+      const raw = typeof body.name === "string" ? body.name : "";
+      purgeProjectEverywhere(p, raw);
+      return finish();
+    }
+    case "fetchRemoteIssues":
+      return await dispatchFetchRemoteIssues(p, body);
+    case "pushSessionToMongo":
+      return {
+        ok: true,
+        result: { pushSessionToMongo: { ok: false, error: "disabled" } },
+      };
+    case "testMongoDbConnection":
+      return {
+        ok: true,
+        result: { mongoConnectionTest: { outcome: "disabled" as const } },
+      };
+    case "testGitlabConnection":
+      return await dispatchGitlabConnectionTest(p, body);
+    case "resyncMongoMirror":
+      return {
+        ok: true,
+        result: { mongoResync: { ok: false, reason: "disabled" as const } },
+      };
+    case "setMongoDbConnectionUri": {
+      const uri = typeof body.uri === "string" ? body.uri.trim() : "";
+      if (uri.length > 0) {
+        mergeCfg(p, { mongodbUriConfigured: true, mongodbManualUriConfigured: true });
+      } else {
+        mergeCfg(p, { mongodbUriConfigured: false, mongodbManualUriConfigured: false });
+      }
+      return finish();
+    }
+    case "setMongoDbPassword": {
+      const pass = typeof body.password === "string" ? body.password.trim() : "";
+      mergeCfg(p, { mongodbPasswordConfigured: pass.length > 0 });
+      return finish();
+    }
+    case "setGitlabToken": {
+      const tok = typeof body.token === "string" ? body.token.trim() : "";
+      if (tok.length > 0) {
+        writeGitlabPatToStore(tok);
+      } else {
+        clearGitlabPatFromStore();
+      }
+      mergeCfg(p, {
+        gitlabTokenStored: tok.length > 0,
+        gitlabTokenFromEnv: false,
+        gitlabApiVerified: false,
+      });
+      return finish();
+    }
+    case "createGlabRemoteRepo":
+      return {
+        ok: true,
+        result: { glabRepoCreate: { ok: false, error: "Désactivé dans le tableau de bord Next local." } },
+      };
+    case "pickStoragePath":
+      return finish();
+    case "refreshWorkspaceCodeSnapshot": {
+      const paths = workspaceFolderPathStrings(p);
+      const workspaceFolder = (paths[0] ?? "").trim() || process.cwd();
+      p.workspaceCodeSnapshot = {
+        ok: true,
+        totalLines: 0,
+        fileCount: 0,
+        byLanguage: [],
+        source: "walk",
+        computedAt: new Date().toISOString(),
+        workspaceFolder,
+      };
+      return finish();
+    }
+    default:
+      // No-op : maintient l’UI réactive ; affiner au fil du portage.
+      return finish();
+  }
+}