@nightkatana/kronosys-app 1.0.0-beta.0

package/server/db.ts

@@ -0,0 +1,42 @@
+import Database from "better-sqlite3";
+import * as path from "node:path";
+
+import { ensureDataDirectory, resetDataDirectoryCache } from "@/lib/dataDir";
+
+const DB_NAME = "kronosys.sqlite";
+
+let db: Database.Database | null = null;
+
+/** Ferme la connexion SQLite (tests ou changement de `TRACE_DATA_DIR` / cache de résolution). */
+export function resetSqliteConnection(): void {
+  if (db) {
+    try {
+      db.close();
+    } catch {
+      /* ignore */
+    }
+    db = null;
+  }
+  resetDataDirectoryCache();
+}
+
+export function getSqlite(): Database.Database {
+  if (db) {
+    return db;
+  }
+  const dir = ensureDataDirectory();
+  const file = path.join(dir, DB_NAME);
+  db = new Database(file);
+  db.pragma("journal_mode = WAL");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS app_meta (
+      key TEXT PRIMARY KEY NOT NULL,
+      value TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS kv_store (
+      k TEXT PRIMARY KEY NOT NULL,
+      v TEXT NOT NULL
+    );
+  `);
+  return db;
+}

package/server/defaultCfg.ts

@@ -0,0 +1,87 @@
+/** Valeurs par défaut du profil gestionnaire (SQLite, flux local). */
+export function defaultKronosysCfg(): Record<string, unknown> {
+  return {
+    autoStart: true,
+    enabled: true,
+    usageProfile: "manager",
+    anonymizePaths: false,
+    flushIntervalSeconds: 15,
+    heartbeatIntervalSeconds: 120,
+    maxBufferedEvents: 500,
+    historyStoragePath: "",
+    historyPartition: "daily",
+    sessionExportFormat: "json",
+    csvDelimiter: ",",
+    sessionStartMode: "continue",
+    autoGitSync: false,
+    gitRemoteUrl: "",
+    /** Jeton enregistré localement (drapeau seul dans le payload). */
+    gitlabTokenStored: false,
+    /** Jeton fourni par GITLAB_TOKEN sur le processus serveur. */
+    gitlabTokenFromEnv: false,
+    /** Dernière exécution réussie de « Tester la connexion GitLab » dans les paramètres. */
+    gitlabApiVerified: false,
+    /** Instance GitLab (origine sans `/api/v4`). Vide = GITLAB_INSTANCE_URL ou https://gitlab.com. */
+    gitlabApiBaseUrl: "",
+    mongodbEnabled: false,
+    mongodbDatabaseName: "kronosys",
+    mongodbCollectionName: "sessions",
+    mongodbHost: "127.0.0.1",
+    mongodbPort: 27017,
+    mongodbUsername: "",
+    mongodbAuthSource: "admin",
+    showWelcomeOnStartup: true,
+    dashboardSessionDurationAlertHours: 24,
+    dashboardShowKronoFocusInHeader: true,
+    dashboardShowKronoFocusInTaskOps: true,
+    /** Lorsque `false`, les tâches sans étiquette explicite ne reçoivent pas l’étiquette réservée `default`. */
+    taskDefaultTagBucketEnabled: true,
+    /** Autorise la correction du `startTime` des tâches depuis le tableau de bord (live + historique). */
+    dashboardAllowTaskStartTimeEdit: true,
+    /** Autorise la correction du `startAt` des sessions depuis le tableau de bord (live + historique). */
+    dashboardAllowSessionStartTimeEdit: true,
+    /** Autorise la correction du `endTime` des tâches terminées depuis le tableau de bord. */
+    dashboardAllowTaskEndTimeEdit: true,
+    /** Autorise la correction du `endAt` des sessions terminées depuis le tableau de bord. */
+    dashboardAllowSessionEndTimeEdit: true,
+    workspaceLocExcludedDirectoryNames: [
+      "node_modules",
+      ".git",
+      "dist",
+      "out",
+      "build",
+      ".next",
+      "coverage",
+      "target",
+      "__pycache__",
+      ".venv",
+      "venv",
+      "vendor",
+      ".turbo",
+      ".cache",
+      ".idea",
+    ],
+    workspaceLocExcludedPathPatterns: [],
+    localPersistenceDriver: "sqlite",
+    localApiPort: 5566,
+    dashboardWebUrl: "http://kronosys:5555",
+    dashboardWebPort: 5555,
+    /** Fuseau IANA pour les dates du tableau de bord et le regroupement des rapports (défaut : heure de l’Est). */
+    dashboardDisplayTimeZone: "America/Toronto",
+    /** Affichage des heures : `true` = 24 h, `false` = 12 h (AM/PM). */
+    dashboardUse24HourClock: true,
+    scheduleEnabled: false,
+    scheduleDays: [1, 2, 3, 4, 5],
+    scheduleStartTime: "09:00",
+    scheduleEndTime: "17:00",
+    scheduleCreateDailySession: true,
+    scheduleTransferTasks: true,
+    schedulePauseTasks: true,
+    plannedSessions: [],
+    /**
+     * Mode `next dev` : lorsque `true`, utiliser le même répertoire `v4` qu’en production.
+     * Persistance : SQLite + fichier de démarrage (voir `lib/devDataPreferenceFile.ts`).
+     */
+    developmentUseProductionData: false,
+  };
+}

package/server/gitlabTokenStore.ts

@@ -0,0 +1,34 @@
+import { getSqlite } from "./db";
+
+/**
+ * Jeton GitLab PAT pour le tableau de bord Next local : stocké dans SQLite (table
+ * `kv_store`), jamais dans le JSON du payload exposé par `/api/state`.
+ */
+const GITLAB_PAT_KV_KEY = "gitlab_secret_pat_v1";
+
+function ensureKv(): void {
+  getSqlite().exec(`
+    CREATE TABLE IF NOT EXISTS kv_store (
+      k TEXT PRIMARY KEY NOT NULL,
+      v TEXT NOT NULL
+    );
+  `);
+}
+
+export function readGitlabPatFromStore(): string {
+  ensureKv();
+  const row = getSqlite().prepare("SELECT v FROM kv_store WHERE k = ?").get(GITLAB_PAT_KV_KEY) as
+    | { v: string }
+    | undefined;
+  return typeof row?.v === "string" ? row.v : "";
+}
+
+export function writeGitlabPatToStore(token: string): void {
+  ensureKv();
+  getSqlite().prepare("INSERT OR REPLACE INTO kv_store (k, v) VALUES (?, ?)").run(GITLAB_PAT_KV_KEY, token);
+}
+
+export function clearGitlabPatFromStore(): void {
+  ensureKv();
+  getSqlite().prepare("DELETE FROM kv_store WHERE k = ?").run(GITLAB_PAT_KV_KEY);
+}

package/server/kronoFocusHydrate.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from "vitest";
+
+import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
+
+import { hydrateKronoFocusInPayload } from "./kronoFocusHydrate";
+
+function basePayload(pm: Record<string, unknown>): KronosysUpdatePayload {
+  return {
+    viewType: "dashboard",
+    current: {
+      sessionId: "s1",
+      kronoFocus: pm,
+    },
+    cfg: {},
+  } as KronosysUpdatePayload;
+}
+
+describe("hydrateKronoFocusInPayload", () => {
+  it("ancre une échéance pour un KronoFocus running sans deadline (données héritées)", () => {
+    const t0 = 1_000_000_000;
+    const p = basePayload({
+      mode: "work",
+      status: "running",
+      timeLeftSeconds: 100,
+    });
+    const dirty = hydrateKronoFocusInPayload(p, t0);
+    expect(dirty).toBe(true);
+    const pm = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
+    expect(pm.kronoFocusDeadlineAtMs).toBe(t0 + 100_000);
+    expect(pm.timeLeftSeconds).toBe(100);
+  });
+
+  it("décompte les secondes restantes avant l’échéance", () => {
+    const t0 = 1_000_000_000;
+    const p = basePayload({
+      mode: "work",
+      status: "running",
+      timeLeftSeconds: 9999,
+      kronoFocusDeadlineAtMs: t0 + 60_000,
+    });
+    const dirty = hydrateKronoFocusInPayload(p, t0 + 30_000);
+    expect(dirty).toBe(false);
+    const pm = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
+    expect(pm.timeLeftSeconds).toBe(30);
+    expect(pm.status).toBe("running");
+  });
+
+  it("à l’échéance d’un bloc travail : utilise shortBreakDurationSeconds du payload", () => {
+    const t0 = 1_000_000_000;
+    const p = basePayload({
+      mode: "work",
+      status: "running",
+      timeLeftSeconds: 10,
+      sessionsCompleted: 0,
+      shortBreakDurationSeconds: 10 * 60,
+      kronoFocusDeadlineAtMs: t0 + 10_000,
+    });
+    const dirty = hydrateKronoFocusInPayload(p, t0 + 10_000);
+    expect(dirty).toBe(true);
+    const pm = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
+    expect(pm.status).toBe("paused");
+    expect(pm.mode).toBe("break");
+    expect(pm.timeLeftSeconds).toBe(10 * 60);
+    expect(pm.sessionsCompleted).toBe(1);
+    expect(pm.kronoFocusDeadlineAtMs).toBeUndefined();
+  });
+
+  it("à l’échéance d’un bloc travail : pause, pause courte, incrémente sessionsCompleted", () => {
+    const t0 = 1_000_000_000;
+    const p = basePayload({
+      mode: "work",
+      status: "running",
+      timeLeftSeconds: 10,
+      sessionsCompleted: 0,
+      kronoFocusDeadlineAtMs: t0 + 10_000,
+    });
+    const dirty = hydrateKronoFocusInPayload(p, t0 + 10_000);
+    expect(dirty).toBe(true);
+    const pm = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
+    expect(pm.status).toBe("paused");
+    expect(pm.mode).toBe("break");
+    expect(pm.timeLeftSeconds).toBe(5 * 60);
+    expect(pm.sessionsCompleted).toBe(1);
+    expect(pm.kronoFocusDeadlineAtMs).toBeUndefined();
+  });
+
+  it("après 4 cycles travail : pause longue 15 min", () => {
+    const t0 = 1_000_000_000;
+    const p = basePayload({
+      mode: "work",
+      status: "running",
+      timeLeftSeconds: 1,
+      sessionsCompleted: 3,
+      kronoFocusDeadlineAtMs: t0 + 1000,
+    });
+    hydrateKronoFocusInPayload(p, t0 + 1000);
+    const pm = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
+    expect(pm.sessionsCompleted).toBe(4);
+    expect(pm.mode).toBe("longBreak");
+    expect(pm.timeLeftSeconds).toBe(15 * 60);
+  });
+
+  it("après 4 cycles travail : utilise longBreakDurationSeconds du payload", () => {
+    const t0 = 1_000_000_000;
+    const p = basePayload({
+      mode: "work",
+      status: "running",
+      timeLeftSeconds: 1,
+      sessionsCompleted: 3,
+      longBreakDurationSeconds: 22 * 60,
+      kronoFocusDeadlineAtMs: t0 + 1000,
+    });
+    hydrateKronoFocusInPayload(p, t0 + 1000);
+    const pm = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
+    expect(pm.sessionsCompleted).toBe(4);
+    expect(pm.mode).toBe("longBreak");
+    expect(pm.timeLeftSeconds).toBe(22 * 60);
+  });
+
+  it("fin d’une pause : retour au travail avec durée par défaut", () => {
+    const t0 = 1_000_000_000;
+    const p = basePayload({
+      mode: "break",
+      status: "running",
+      timeLeftSeconds: 1,
+      sessionsCompleted: 1,
+      kronoFocusDeadlineAtMs: t0 + 1000,
+    });
+    hydrateKronoFocusInPayload(p, t0 + 1000);
+    const pm = (p.current as Record<string, unknown>).kronoFocus as Record<string, unknown>;
+    expect(pm.mode).toBe("work");
+    expect(pm.status).toBe("paused");
+    expect(pm.timeLeftSeconds).toBe(25 * 60);
+  });
+
+  it("n’agit pas si pas de session courante ou KronoFocus absent", () => {
+    const p: KronosysUpdatePayload = { viewType: "dashboard", cfg: {} } as KronosysUpdatePayload;
+    expect(hydrateKronoFocusInPayload(p, 0)).toBe(false);
+    const p2 = basePayload({ mode: "work", status: "idle", timeLeftSeconds: 100 });
+    expect(hydrateKronoFocusInPayload(p2, 0)).toBe(false);
+  });
+});

package/server/kronoFocusHydrate.ts

@@ -0,0 +1,69 @@
+import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
+import { readLongBreakDurationSeconds, readShortBreakDurationSeconds, readWorkDurationSeconds } from "@/lib/kronoFocusRhythm";
+
+import { asRecord } from "./actionTaskSession";
+
+/**
+ * Met à jour le KronoFocus de la session live (`payload.current`) : décompte selon
+ * `kronoFocusDeadlineAtMs` quand `status === "running"`, puis passage en pause en fin de phase
+ * (aligné sur la logique historique de fin de phase KronoFocus côté collecte).
+ *
+ * @returns `true` si le stockage doit être réécrit (ancrage d’échéance pour données héritées, ou fin de phase).
+ */
+export function hydrateKronoFocusInPayload(p: KronosysUpdatePayload, nowMs = Date.now()): boolean {
+  const cur = asRecord(p.current);
+  if (!cur) {
+    return false;
+  }
+  const pm = asRecord(cur.kronoFocus);
+  if (!pm || pm.status !== "running") {
+    return false;
+  }
+
+  let needWrite = false;
+  let deadlineMs: number;
+  const rawDl = pm.kronoFocusDeadlineAtMs;
+  if (typeof rawDl === "number" && Number.isFinite(rawDl)) {
+    deadlineMs = rawDl;
+  } else {
+    const left =
+      typeof pm.timeLeftSeconds === "number" && Number.isFinite(pm.timeLeftSeconds)
+        ? Math.max(0, Math.floor(pm.timeLeftSeconds))
+        : 0;
+    deadlineMs = nowMs + left * 1000;
+    pm.kronoFocusDeadlineAtMs = deadlineMs;
+    needWrite = true;
+  }
+
+  const remaining = Math.max(0, Math.ceil((deadlineMs - nowMs) / 1000));
+  pm.timeLeftSeconds = remaining;
+
+  if (remaining > 0) {
+    return needWrite;
+  }
+
+  delete pm.kronoFocusDeadlineAtMs;
+  pm.status = "paused";
+
+  const mode = pm.mode;
+  if (mode === "work") {
+    const sc =
+      typeof pm.sessionsCompleted === "number" && Number.isFinite(pm.sessionsCompleted)
+        ? Math.floor(pm.sessionsCompleted)
+        : 0;
+    const next = sc + 1;
+    pm.sessionsCompleted = next;
+    if (next % 4 === 0) {
+      pm.mode = "longBreak";
+      pm.timeLeftSeconds = readLongBreakDurationSeconds(pm);
+    } else {
+      pm.mode = "break";
+      pm.timeLeftSeconds = readShortBreakDurationSeconds(pm);
+    }
+  } else {
+    pm.mode = "work";
+    pm.timeLeftSeconds = readWorkDurationSeconds(pm);
+  }
+
+  return true;
+}

package/server/kronoFocusMigrate.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+
+import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
+import {
+  LEGACY_SESSION_TIMER_OBJECT_KEY,
+  LEGACY_TASK_CYCLES_KEY,
+  LEGACY_TIMER_DEADLINE_MS_KEY,
+} from "@/lib/legacyKronoFocusStorageKeys";
+
+import { migrateLegacyKronoFocusPayload } from "./kronoFocusMigrate";
+
+describe("migrateLegacyKronoFocusPayload", () => {
+  it("fusionne l’objet minuteur hérité sur la session vers kronoFocus et renomme l’échéance", () => {
+    const legacyBlock: Record<string, unknown> = {
+      mode: "work",
+      status: "paused",
+      timeLeftSeconds: 120,
+      sessionsCompleted: 1,
+    };
+    legacyBlock[LEGACY_TIMER_DEADLINE_MS_KEY] = 999;
+
+    const p = {
+      viewType: "dashboard",
+      current: {
+        sessionId: "s1",
+        [LEGACY_SESSION_TIMER_OBJECT_KEY]: legacyBlock,
+      },
+    } as unknown as KronosysUpdatePayload;
+
+    expect(migrateLegacyKronoFocusPayload(p)).toBe(true);
+    const cur = p.current as Record<string, unknown>;
+    expect(cur[LEGACY_SESSION_TIMER_OBJECT_KEY]).toBeUndefined();
+    const kf = cur.kronoFocus as Record<string, unknown>;
+    expect(kf.status).toBe("paused");
+    expect(kf.kronoFocusDeadlineAtMs).toBe(999);
+    expect(kf[LEGACY_TIMER_DEADLINE_MS_KEY]).toBeUndefined();
+  });
+
+  it("renomme les cycles hérités sur les tâches en kronoFocusCycles", () => {
+    const p = {
+      viewType: "dashboard",
+      current: {
+        sessionId: "s1",
+        tasks: [{ id: "t1", name: "a", [LEGACY_TASK_CYCLES_KEY]: 3 }],
+      },
+    } as unknown as KronosysUpdatePayload;
+
+    expect(migrateLegacyKronoFocusPayload(p)).toBe(true);
+    const tasks = (p.current as Record<string, unknown>).tasks as Record<string, unknown>[];
+    expect(tasks[0].kronoFocusCycles).toBe(3);
+    expect(tasks[0][LEGACY_TASK_CYCLES_KEY]).toBeUndefined();
+  });
+});

package/server/kronoFocusMigrate.ts

@@ -0,0 +1,78 @@
+import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
+import {
+  LEGACY_SESSION_TIMER_OBJECT_KEY,
+  LEGACY_TASK_CYCLES_KEY,
+  LEGACY_TIMER_DEADLINE_MS_KEY,
+} from "@/lib/legacyKronoFocusStorageKeys";
+
+import { asRecord } from "./actionTaskSession";
+
+function migrateTasksInSession(sess: Record<string, unknown>): boolean {
+  let changed = false;
+  const bumpTask = (t: unknown): void => {
+    const tr = asRecord(t);
+    if (!tr) {
+      return;
+    }
+    if (LEGACY_TASK_CYCLES_KEY in tr) {
+      if (tr.kronoFocusCycles === undefined) {
+        const n = tr[LEGACY_TASK_CYCLES_KEY];
+        if (typeof n === "number" && Number.isFinite(n)) {
+          tr.kronoFocusCycles = Math.floor(n);
+        }
+      }
+      delete tr[LEGACY_TASK_CYCLES_KEY];
+      changed = true;
+    }
+  };
+  for (const t of (sess.tasks as unknown[]) || []) {
+    bumpTask(t);
+  }
+  for (const t of (sess.activeTasks as unknown[]) || []) {
+    bumpTask(t);
+  }
+  bumpTask(sess.activeTask);
+  return changed;
+}
+
+/** Fusionne l’objet minuteur hérité sur la session vers `kronoFocus` et renomme les cycles de tâches. */
+function migrateSessionRecord(sess: Record<string, unknown>): boolean {
+  let changed = false;
+  const legacyPm = asRecord(sess[LEGACY_SESSION_TIMER_OBJECT_KEY]);
+  if (legacyPm && Object.keys(legacyPm).length > 0) {
+    const kf = { ...asRecord(sess.kronoFocus), ...legacyPm } as Record<string, unknown>;
+    if (LEGACY_TIMER_DEADLINE_MS_KEY in kf) {
+      if (kf.kronoFocusDeadlineAtMs === undefined) {
+        kf.kronoFocusDeadlineAtMs = kf[LEGACY_TIMER_DEADLINE_MS_KEY];
+      }
+      delete kf[LEGACY_TIMER_DEADLINE_MS_KEY];
+    }
+    sess.kronoFocus = kf;
+    delete sess[LEGACY_SESSION_TIMER_OBJECT_KEY];
+    changed = true;
+  }
+  if (migrateTasksInSession(sess)) {
+    changed = true;
+  }
+  return changed;
+}
+
+/** @returns `true` si le JSON stocké doit être réécrit. */
+export function migrateLegacyKronoFocusPayload(p: KronosysUpdatePayload): boolean {
+  let changed = false;
+  const cur = asRecord(p.current);
+  if (cur && migrateSessionRecord(cur)) {
+    changed = true;
+  }
+  for (const h of (p.history || []) as Record<string, unknown>[]) {
+    if (migrateSessionRecord(h)) {
+      changed = true;
+    }
+  }
+  for (const h of (p.historyArchived || []) as Record<string, unknown>[]) {
+    if (migrateSessionRecord(h)) {
+      changed = true;
+    }
+  }
+  return changed;
+}

package/server/mainTimerHydrate.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
+import { MAIN_TIMER_SEGMENT_STARTED_AT } from "./actionTaskSession";
+import { materializeRunningMainTimersInPayload } from "./mainTimerHydrate";
+
+describe("materializeRunningMainTimersInPayload", () => {
+  it("avance durationMs pour une tâche au minuteur principal entre deux appels", () => {
+    const t0 = Date.UTC(2026, 0, 10, 12, 0, 0);
+    const task = {
+      id: "t1",
+      name: "Tâche",
+      durationMs: 1000,
+      isDone: false,
+      manualTaskTimerPaused: false,
+      subtasks: [],
+      [MAIN_TIMER_SEGMENT_STARTED_AT]: new Date(t0).toISOString(),
+    };
+    const p = {
+      viewType: "dashboard",
+      cfg: {},
+      current: {
+        sessionId: "sid",
+        tasks: [],
+        activeTasks: [task],
+        activeTask: task,
+      },
+    } as unknown as KronosysUpdatePayload;
+
+    const t1 = t0 + 5000;
+    const w1 = materializeRunningMainTimersInPayload(p, t1);
+    expect(w1).toBe(true);
+    expect(task.durationMs).toBe(6000);
+    expect(typeof task[MAIN_TIMER_SEGMENT_STARTED_AT]).toBe("string");
+
+    const t2 = t1 + 3000;
+    const w2 = materializeRunningMainTimersInPayload(p, t2);
+    expect(w2).toBe(true);
+    expect(task.durationMs).toBe(9000);
+  });
+
+  it("ignore les tâches en pause manuelle", () => {
+    const task = {
+      id: "t1",
+      name: "Tâche",
+      durationMs: 1000,
+      isDone: false,
+      manualTaskTimerPaused: true,
+      subtasks: [],
+    };
+    const p = {
+      viewType: "dashboard",
+      cfg: {},
+      current: {
+        sessionId: "sid",
+        tasks: [],
+        activeTasks: [task],
+        activeTask: task,
+      },
+    } as unknown as KronosysUpdatePayload;
+
+    const w = materializeRunningMainTimersInPayload(p, Date.UTC(2026, 0, 10, 12, 0, 10));
+    expect(w).toBe(false);
+    expect(task.durationMs).toBe(1000);
+  });
+});

package/server/mainTimerHydrate.ts

@@ -0,0 +1,53 @@
+import type { KronosysUpdatePayload } from "@/lib/kronosysApi";
+import {
+  asRecord,
+  ensureTaskParentDurationCoversSubtasksMs,
+  forEachTaskRecordInSession,
+  MAIN_TIMER_SEGMENT_STARTED_AT,
+} from "./actionTaskSession";
+
+/**
+ * Fait progresser `durationMs` des tâches au minuteur principal pendant que l’UI n’est pas sur
+ * le tableau de bord : chaque lecture d’état (`readPayload`) matérialise le segment courant.
+ */
+export function materializeRunningMainTimersInPayload(p: KronosysUpdatePayload, nowMs = Date.now()): boolean {
+  const cur = asRecord(p.current);
+  if (!cur) {
+    return false;
+  }
+  let needWrite = false;
+  forEachTaskRecordInSession(cur, (task) => {
+    if (task.isDone === true) {
+      return;
+    }
+    if (task.manualTaskTimerPaused === true) {
+      return;
+    }
+    if (String(task.activeSubtaskTimerId ?? "").trim() !== "") {
+      return;
+    }
+    const raw = task[MAIN_TIMER_SEGMENT_STARTED_AT];
+    if (typeof raw !== "string" || raw.trim() === "") {
+      task[MAIN_TIMER_SEGMENT_STARTED_AT] = new Date(nowMs).toISOString();
+      needWrite = true;
+      return;
+    }
+    const startedMs = Date.parse(raw);
+    if (!Number.isFinite(startedMs)) {
+      task[MAIN_TIMER_SEGMENT_STARTED_AT] = new Date(nowMs).toISOString();
+      needWrite = true;
+      return;
+    }
+    const elapsed = Math.max(0, Math.floor(nowMs - startedMs));
+    if (elapsed <= 0) {
+      return;
+    }
+    const parentPrev =
+      typeof task.durationMs === "number" && Number.isFinite(task.durationMs) ? Number(task.durationMs) : 0;
+    task.durationMs = Math.floor(parentPrev + elapsed);
+    task[MAIN_TIMER_SEGMENT_STARTED_AT] = new Date(nowMs).toISOString();
+    ensureTaskParentDurationCoversSubtasksMs(task);
+    needWrite = true;
+  });
+  return needWrite;
+}