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

package/server/actionDispatch.ts

@@ -10,6 +10,8 @@ import {
   normalizeTaskTagsForStorage,
   parseTaskWithAutoTags,
   readTaskDefaultTagBucketEnabled,
+  resolvePersonalProjectForTaskUpdate,
+  resolveProjectForTaskUpdate,
   type TaskTagsStorageNormalizeOpts,
 } from "@/lib/taskParsing";
 
@@ -19,14 +21,23 @@ import {
   asRecord,
   deleteSubtaskInSession,
   deleteTaskInSession,
+  ensureMainTimerSegmentForRunningTask,
+  findTaskRecord,
   finishTaskInSession,
+  flushMainTimerSegmentOnTask,
+  flushSubtaskTimerOnTask,
+  forEachTaskRecordInSession,
   prepareSessionForExclusiveMainTimerUnpaused,
   purgeProjectEverywhere,
   purgeTagEverywhere,
+  renameProjectEverywhere,
+  renameTagEverywhere,
   reorderSubtasksInSession,
   resolveTaskSession,
+  SUBTASK_TIMER_STARTED_AT,
   setActiveSubtaskTimerInSession,
   setTaskPausedInSession,
+  scheduleTaskEndTimeInSession,
   toggleSubtaskInSession,
   updateSubtaskTitleInSession,
   updateTaskStartTimeInSession,
@@ -43,7 +54,13 @@ import {
 import {
   DEFAULT_DASHBOARD_TIME_ZONE,
   isValidIanaTimeZone,
+  readDashboardTimeZoneFromCfg,
 } from "@/lib/dashboardTimeZone";
+import {
+  formatSessionNameTemplate,
+  SESSION_NAME_TEMPLATE_CFG_MAX_LEN,
+  SESSION_NAME_TEMPLATE_MAX_LEN,
+} from "@/lib/formatSessionNameTemplate";
 import { defaultKronosysCfg } from "./defaultCfg";
 import { clearGitlabPatFromStore, readGitlabPatFromStore, writeGitlabPatToStore } from "./gitlabTokenStore";
 import {
@@ -59,10 +76,13 @@ import {
   clampWorkDurationSeconds,
   readWorkDurationSeconds,
 } from "@/lib/kronoFocusRhythm";
-import { readPayload, writePayload } from "./payloadStore";
+import { withPayloadWriteAsync, writePayload } from "./payloadStore";
+import { syncLiveIntoHistory } from "./liveHistorySync";
 import {
   ensureSessionWallSegmentOnLive,
+  finalizeLiveSessionClosedAt,
   flushSessionWallSegmentOnLive,
+  resumeLiveSessionWallIfPaused,
   SESSION_WALL_SEGMENT_STARTED_AT,
 } from "./sessionWallHydrate";
 
@@ -71,6 +91,22 @@ type ActionResult = {
   result?: Record<string, unknown>;
 };
 
+type TaskTemplateRecord = {
+  id: string;
+  name: string;
+  tags: string[];
+  project: string | null;
+  personalProject?: boolean;
+  createdAt: string;
+  updatedAt: string;
+};
+
+type ActionHandlerContext = {
+  p: KronosysUpdatePayload;
+  body: Record<string, unknown>;
+  finish: (result?: Record<string, unknown>) => ActionResult;
+};
+
 function tryPersistDevDataPreferenceFromCfg(merged: Record<string, unknown>): void {
   if (process.env.NODE_ENV !== "development") {
     return;
@@ -86,52 +122,133 @@ function tryPersistDevDataPreferenceFromCfg(merged: Record<string, unknown>): vo
   }
 }
 
-function syncLiveIntoHistory(p: KronosysUpdatePayload): void {
-  const cur = asRecord(p.current);
-  if (!cur) {
-    return;
+function ensureLive(p: KronosysUpdatePayload): Record<string, unknown> {
+  if (!p.current) {
+    p.current = {};
   }
-  const sid = typeof cur.sessionId === "string" ? cur.sessionId.trim() : "";
-  if (!sid) {
-    return;
+  return p.current as Record<string, unknown>;
+}
+
+type GlobalPauseContextSnapshot = {
+  sessionWasPaused: boolean;
+  taskIds: string[];
+  subtaskTimers: Array<{ taskId: string; subtaskId: string }>;
+};
+
+function readGlobalPauseContext(cur: Record<string, unknown>): GlobalPauseContextSnapshot | null {
+  const rec = asRecord(cur.globalPauseContext);
+  if (!rec) {
+    return null;
   }
-  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,
+  const taskIds = Array.isArray(rec.taskIds)
+    ? rec.taskIds
+        .map((v) => (typeof v === "string" ? v.trim() : ""))
+        .filter((v) => v.length > 0)
+    : [];
+  const subtaskTimers = Array.isArray(rec.subtaskTimers)
+    ? rec.subtaskTimers
+        .map((row) => {
+          const rr = asRecord(row);
+          const taskId = typeof rr?.taskId === "string" ? rr.taskId.trim() : "";
+          const subtaskId = typeof rr?.subtaskId === "string" ? rr.subtaskId.trim() : "";
+          return taskId && subtaskId ? { taskId, subtaskId } : null;
+        })
+        .filter((row): row is { taskId: string; subtaskId: string } => row !== null)
+    : [];
+  return {
+    sessionWasPaused: rec.sessionWasPaused === true,
+    taskIds,
+    subtaskTimers,
   };
-  if (typeof cur.scheduledStartAt === "string" && cur.scheduledStartAt.trim() !== "") {
-    snap.scheduledStartAt = cur.scheduledStartAt;
+}
+
+/** Instantané des minuteurs actifs mis en pause par la pause session (reprise ciblée). */
+type SessionPauseContextSnapshot = {
+  taskIds: string[];
+  subtaskTimers: Array<{ taskId: string; subtaskId: string }>;
+  pausedAt: string;
+};
+
+function readSessionPauseContext(cur: Record<string, unknown>): SessionPauseContextSnapshot | null {
+  const rec = asRecord(cur.sessionPauseContext);
+  if (!rec) {
+    return null;
   }
-  if (typeof cur.sessionStartOffsetMinutes === "number" && Number.isFinite(cur.sessionStartOffsetMinutes)) {
-    snap.sessionStartOffsetMinutes = cur.sessionStartOffsetMinutes;
+  const taskIds = Array.isArray(rec.taskIds)
+    ? rec.taskIds
+        .map((v) => (typeof v === "string" ? v.trim() : ""))
+        .filter((v) => v.length > 0)
+    : [];
+  const subtaskTimers = Array.isArray(rec.subtaskTimers)
+    ? rec.subtaskTimers
+        .map((row) => {
+          const rr = asRecord(row);
+          const taskId = typeof rr?.taskId === "string" ? rr.taskId.trim() : "";
+          const subtaskId = typeof rr?.subtaskId === "string" ? rr.subtaskId.trim() : "";
+          return taskId && subtaskId ? { taskId, subtaskId } : null;
+        })
+        .filter((row): row is { taskId: string; subtaskId: string } => row !== null)
+    : [];
+  const pausedAt = typeof rec.pausedAt === "string" ? rec.pausedAt.trim() : "";
+  if (!pausedAt) {
+    return null;
   }
-  const rk = normalizeSessionEndReasonKind(cur.sessionEndReasonKind);
-  if (rk) {
-    snap.sessionEndReasonKind = rk;
+  return { taskIds, subtaskTimers, pausedAt };
+}
+
+function pruneSessionPauseContextForTask(sess: Record<string, unknown>, taskId: string): void {
+  const tid = String(taskId ?? "").trim();
+  if (!tid) {
+    return;
   }
-  const rn = normalizeSessionEndReasonNote(cur.sessionEndReasonNote);
-  if (rn.length > 0) {
-    snap.sessionEndReasonNote = rn;
+  const rec = asRecord(sess.sessionPauseContext);
+  if (!rec) {
+    return;
+  }
+  const taskIds = Array.isArray(rec.taskIds)
+    ? rec.taskIds.map((v) => String(v)).filter((id) => id !== tid)
+    : [];
+  const subtaskTimers = Array.isArray(rec.subtaskTimers)
+    ? rec.subtaskTimers.filter((row) => {
+        const rr = asRecord(row);
+        return String(rr?.taskId ?? "").trim() !== tid;
+      })
+    : [];
+  if (taskIds.length === 0 && subtaskTimers.length === 0) {
+    delete sess.sessionPauseContext;
+  } else {
+    sess.sessionPauseContext = {
+      ...rec,
+      taskIds,
+      subtaskTimers,
+    };
   }
-  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>;
+function restoreLiveTasksFromSessionPauseSnapshot(
+  cur: Record<string, unknown>,
+  snap: SessionPauseContextSnapshot,
+): void {
+  const nowIso = new Date().toISOString();
+  const taskIds = new Set(snap.taskIds);
+  const subtaskMap = new Map(snap.subtaskTimers.map((row) => [row.taskId, row.subtaskId]));
+  forEachTaskRecordInSession(cur, (task, taskId) => {
+    if (task.isDone === true) {
+      return;
+    }
+    const subId = subtaskMap.get(taskId);
+    if (subId) {
+      task.activeSubtaskTimerId = subId;
+      task.manualTaskTimerPaused = false;
+      task[SUBTASK_TIMER_STARTED_AT] = nowIso;
+      return;
+    }
+    if (!taskIds.has(taskId)) {
+      return;
+    }
+    task.manualTaskTimerPaused = false;
+    ensureMainTimerSegmentForRunningTask(task);
+  });
 }
 
 /** Enrichit `knownTags` avec des étiquettes vues sur une tâche (suggestions / datalist). */
@@ -170,11 +287,157 @@ function mergeDiscoveredProjectIntoPayloadKnownProjects(
   p.knownProjects = known;
 }
 
+/** Enrichit `knownPersonalProjects` (jetons `!`) — distinct des projets `@`. */
+function mergeDiscoveredPersonalProjectIntoPayloadKnownPersonalProjects(
+  p: KronosysUpdatePayload,
+  project: string | null | undefined,
+  personal: boolean | undefined
+): void {
+  if (!personal || project === undefined || project === null) {
+    return;
+  }
+  const pk = normalizeProjectKey(String(project).trim());
+  if (!pk) {
+    return;
+  }
+  const lk = pk.toLowerCase();
+  const known = [...(((p as Record<string, unknown>).knownPersonalProjects || []) as string[])];
+  if (known.some((x) => normalizeProjectKey(String(x)).toLowerCase() === lk)) {
+    return;
+  }
+  known.push(pk);
+  (p as Record<string, unknown>).knownPersonalProjects = known;
+}
+
 function mergeCfg(p: KronosysUpdatePayload, patch: Record<string, unknown>): void {
   const base = { ...defaultKronosysCfg(), ...(asRecord(p.cfg) ?? {}) };
   p.cfg = { ...base, ...patch };
 }
 
+function handleUpdateKronosysSettings({
+  p,
+  body,
+  finish,
+}: ActionHandlerContext): ActionResult {
+  const s = asRecord(body.settings);
+  if (!s) {
+    return finish();
+  }
+  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;
+  }
+  if (typeof merged.dashboardDefaultSessionNameTemplate === "string") {
+    merged.dashboardDefaultSessionNameTemplate = merged.dashboardDefaultSessionNameTemplate
+      .trim()
+      .slice(0, SESSION_NAME_TEMPLATE_CFG_MAX_LEN);
+  }
+  p.cfg = { ...defaultKronosysCfg(), ...(p.cfg as Record<string, unknown>), ...merged };
+  return finish();
+}
+
+function handleResetKronosysSettings({ p, finish }: ActionHandlerContext): ActionResult {
+  resetCfgToDefaults(p);
+  tryPersistDevDataPreferenceFromCfg({ developmentUseProductionData: false });
+  return finish();
+}
+
+function handleSetGitIdentity({ p, body, finish }: ActionHandlerContext): ActionResult {
+  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();
+}
+
+function readTaskTemplates(p: KronosysUpdatePayload): TaskTemplateRecord[] {
+  const raw = Array.isArray((p as Record<string, unknown>).taskTemplates)
+    ? (((p as Record<string, unknown>).taskTemplates as unknown[]) ?? [])
+    : [];
+  const out: TaskTemplateRecord[] = [];
+  for (const row of raw) {
+    const rec = asRecord(row);
+    if (!rec) {
+      continue;
+    }
+    const id = typeof rec.id === "string" ? rec.id.trim() : "";
+    const name = typeof rec.name === "string" ? rec.name.trim() : "";
+    if (!id || !name) {
+      continue;
+    }
+    const tags = Array.isArray(rec.tags)
+      ? rec.tags
+          .map((t) => (typeof t === "string" ? normalizeTagKey(t) : ""))
+          .filter((t) => t.length > 0)
+      : [];
+    const projectRaw = typeof rec.project === "string" ? rec.project.trim() : "";
+    const project = projectRaw ? normalizeProjectKey(projectRaw) : null;
+    const personalProject = rec.personalProject === true;
+    const createdAt = typeof rec.createdAt === "string" && rec.createdAt.trim() ? rec.createdAt : new Date().toISOString();
+    const updatedAt = typeof rec.updatedAt === "string" && rec.updatedAt.trim() ? rec.updatedAt : createdAt;
+    out.push({ id, name, tags, project, personalProject, createdAt, updatedAt });
+  }
+  return out;
+}
+
+function transformTaskTagsInPayload(
+  p: KronosysUpdatePayload,
+  sourceTag: string,
+  targetTag: string,
+  mode: "move" | "copy",
+  tagNormOpts: TaskTagsStorageNormalizeOpts
+): void {
+  const sourceNorm = normalizeTagKey(sourceTag);
+  const targetNorm = normalizeTagKey(targetTag);
+  if (!sourceNorm || !targetNorm || sourceNorm.toLowerCase() === targetNorm.toLowerCase()) {
+    return;
+  }
+  const applyOnSession = (sess: Record<string, unknown> | undefined): void => {
+    if (!sess) {
+      return;
+    }
+    forEachTaskRecordInSession(sess, (task) => {
+      const tagsRaw = Array.isArray(task.tags) ? (task.tags as string[]) : [];
+      if (tagsRaw.length === 0) {
+        return;
+      }
+      const lowered = tagsRaw.map((t) => normalizeTagKey(String(t)).toLowerCase());
+      const sourceL = sourceNorm.toLowerCase();
+      if (!lowered.some((x) => x === sourceL)) {
+        return;
+      }
+      let next = tagsRaw.filter((t) => normalizeTagKey(String(t)).toLowerCase() !== sourceL);
+      if (mode === "copy") {
+        next = [...tagsRaw];
+      }
+      if (!next.some((t) => normalizeTagKey(String(t)).toLowerCase() === targetNorm.toLowerCase())) {
+        next.push(targetNorm);
+      }
+      task.tags = normalizeTaskTagsForStorage(next, tagNormOpts);
+    });
+  };
+  applyOnSession(asRecord(p.current));
+  for (const row of (p.history || []) as Record<string, unknown>[]) {
+    applyOnSession(row);
+  }
+  for (const row of (p.historyArchived || []) as Record<string, unknown>[]) {
+    applyOnSession(row);
+  }
+}
+
 const CFG_KEYS_PRESERVED_ON_RESET: readonly string[] = [
   "gitlabTokenStored",
   "gitlabTokenFromEnv",
@@ -599,6 +862,8 @@ function newTaskRecord(
     name: string;
     tags?: string[];
     project?: string | null;
+    personalProject?: boolean;
+    note?: string;
   },
   tagNormOpts: TaskTagsStorageNormalizeOpts
 ): Record<string, unknown> {
@@ -612,21 +877,50 @@ function newTaskRecord(
     kronoFocusCycles: 0,
     tags: normalizeTaskTagsForStorage(input.tags, tagNormOpts),
     project: input.project ?? null,
+    personalProject: input.personalProject === true,
+    note: typeof input.note === "string" ? input.note : "",
     subtasks: [],
   };
 }
 
+let dispatchQueue: Promise<void> = Promise.resolve();
+
+function enqueueDispatch<T>(run: () => Promise<T>): Promise<T> {
+  const next = dispatchQueue.then(run, run);
+  dispatchQueue = next.then(
+    () => undefined,
+    () => undefined,
+  );
+  return next;
+}
+
 export async function dispatchKronosysAction(body: Record<string, unknown>): Promise<ActionResult> {
+  return enqueueDispatch(async () =>
+    withPayloadWriteAsync((p) => dispatchKronosysActionWithPayload(body, p)),
+  );
+}
+
+async function dispatchKronosysActionWithPayload(
+  body: Record<string, unknown>,
+  p: KronosysUpdatePayload,
+): 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: {} };
+  const finish = (result: Record<string, unknown> = {}): ActionResult => {
+    return { ok: true, result };
+  };
+  const domainHandlers: Record<string, (ctx: ActionHandlerContext) => ActionResult> = {
+    updateKronosysSettings: handleUpdateKronosysSettings,
+    resetKronosysSettings: handleResetKronosysSettings,
+    setGitIdentity: handleSetGitIdentity,
   };
+  const domainHandler = domainHandlers[type];
+  if (domainHandler) {
+    return domainHandler({ p, body, finish });
+  }
 
   switch (type) {
     case "updateKronosysSettings": {
@@ -645,6 +939,10 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
         if ("dashboardUse24HourClock" in merged) {
           merged.dashboardUse24HourClock = merged.dashboardUse24HourClock !== false;
         }
+        if (typeof merged.dashboardDefaultSessionNameTemplate === "string") {
+          merged.dashboardDefaultSessionNameTemplate =
+            merged.dashboardDefaultSessionNameTemplate.trim().slice(0, SESSION_NAME_TEMPLATE_CFG_MAX_LEN);
+        }
         p.cfg = { ...defaultKronosysCfg(), ...(p.cfg as Record<string, unknown>), ...merged };
       }
       return finish();
@@ -677,16 +975,123 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
     }
     case "setPaused": {
       const cur = ensureLive(p);
+      if (readGlobalPauseContext(cur)) {
+        syncLiveIntoHistory(p);
+        return finish();
+      }
       if (body.paused === true) {
+        if (cur.isPaused === true) {
+          syncLiveIntoHistory(p);
+          return finish();
+        }
+        const pausedAt = new Date().toISOString();
+        const snapshot: SessionPauseContextSnapshot = {
+          taskIds: [],
+          subtaskTimers: [],
+          pausedAt,
+        };
+        forEachTaskRecordInSession(cur, (task, taskId) => {
+          if (task.isDone === true) {
+            return;
+          }
+          const activeSubtaskId =
+            typeof task.activeSubtaskTimerId === "string" ? task.activeSubtaskTimerId.trim() : "";
+          if (activeSubtaskId.length > 0) {
+            snapshot.subtaskTimers.push({ taskId, subtaskId: activeSubtaskId });
+            flushSubtaskTimerOnTask(task);
+          }
+          if (task.manualTaskTimerPaused !== true) {
+            snapshot.taskIds.push(taskId);
+            flushMainTimerSegmentOnTask(task);
+            task.manualTaskTimerPaused = true;
+          }
+        });
+        cur.sessionPauseContext = {
+          taskIds: snapshot.taskIds,
+          subtaskTimers: snapshot.subtaskTimers,
+          pausedAt: snapshot.pausedAt,
+        };
         flushSessionWallSegmentOnLive(cur);
         cur.isPaused = true;
       } else {
+        const sessSnap = readSessionPauseContext(cur);
+        if (sessSnap) {
+          restoreLiveTasksFromSessionPauseSnapshot(cur, sessSnap);
+          delete cur.sessionPauseContext;
+        }
         cur.isPaused = false;
         ensureSessionWallSegmentOnLive(cur);
       }
       syncLiveIntoHistory(p);
       return finish();
     }
+    case "toggleGlobalPauseContext": {
+      const cur = ensureLive(p);
+      const existing = readGlobalPauseContext(cur);
+      if (existing) {
+        const nowIso = new Date().toISOString();
+        const taskIds = new Set(existing.taskIds);
+        const subtaskMap = new Map(existing.subtaskTimers.map((row) => [row.taskId, row.subtaskId]));
+        if (!existing.sessionWasPaused) {
+          cur.isPaused = false;
+          ensureSessionWallSegmentOnLive(cur);
+        }
+        forEachTaskRecordInSession(cur, (task, taskId) => {
+          if (task.isDone === true) {
+            return;
+          }
+          const taskSubtaskId = subtaskMap.get(taskId);
+          if (taskSubtaskId) {
+            task.activeSubtaskTimerId = taskSubtaskId;
+            task.manualTaskTimerPaused = false;
+            task[SUBTASK_TIMER_STARTED_AT] = nowIso;
+            return;
+          }
+          if (!taskIds.has(taskId)) {
+            return;
+          }
+          task.manualTaskTimerPaused = false;
+          ensureMainTimerSegmentForRunningTask(task);
+        });
+        delete cur.globalPauseContext;
+        syncLiveIntoHistory(p);
+        return finish();
+      }
+      delete cur.sessionPauseContext;
+      const snapshot: GlobalPauseContextSnapshot = {
+        sessionWasPaused: cur.isPaused === true,
+        taskIds: [],
+        subtaskTimers: [],
+      };
+      forEachTaskRecordInSession(cur, (task, taskId) => {
+        if (task.isDone === true) {
+          return;
+        }
+        const activeSubtaskId =
+          typeof task.activeSubtaskTimerId === "string" ? task.activeSubtaskTimerId.trim() : "";
+        if (activeSubtaskId.length > 0) {
+          snapshot.subtaskTimers.push({ taskId, subtaskId: activeSubtaskId });
+          flushSubtaskTimerOnTask(task);
+        }
+        if (task.manualTaskTimerPaused !== true) {
+          snapshot.taskIds.push(taskId);
+          flushMainTimerSegmentOnTask(task);
+          task.manualTaskTimerPaused = true;
+        }
+      });
+      if (cur.isPaused !== true) {
+        flushSessionWallSegmentOnLive(cur);
+        cur.isPaused = true;
+      }
+      cur.globalPauseContext = {
+        sessionWasPaused: snapshot.sessionWasPaused,
+        taskIds: snapshot.taskIds,
+        subtaskTimers: snapshot.subtaskTimers,
+        pausedAt: new Date().toISOString(),
+      };
+      syncLiveIntoHistory(p);
+      return finish();
+    }
     case "setSessionName": {
       const name = typeof body.name === "string" ? body.name : "";
       const sid = typeof body.sessionId === "string" ? body.sessionId : undefined;
@@ -710,6 +1115,29 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
       syncLiveIntoHistory(p);
       return finish();
     }
+    case "setSessionNote": {
+      const note = typeof body.note === "string" ? body.note : "";
+      const sid = typeof body.sessionId === "string" ? body.sessionId : undefined;
+      const cur = asRecord(p.current);
+      if (sid && cur?.sessionId === sid) {
+        cur.sessionNote = note;
+      } else if (!sid && cur) {
+        cur.sessionNote = note;
+      }
+      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.sessionNote = note;
+      }
+      const arch = (p.historyArchived || []) as Record<string, unknown>[];
+      const ar = arch.find((h) => h.sessionId === id);
+      if (ar) {
+        ar.sessionNote = note;
+      }
+      syncLiveIntoHistory(p);
+      return finish();
+    }
     case "setSessionStartTime": {
       const sidFromBody = typeof body.sessionId === "string" ? body.sessionId.trim() : "";
       const isoRaw = typeof body.startAt === "string" ? body.startAt.trim() : "";
@@ -729,9 +1157,12 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
         if (!row) {
           return;
         }
-        row.startAt = startAtIso;
         const endRaw = typeof row.endAt === "string" ? row.endAt.trim() : "";
         const endMs = Date.parse(endRaw);
+        if (Number.isFinite(endMs) && startMs > endMs) {
+          return;
+        }
+        row.startAt = startAtIso;
         if (Number.isFinite(endMs) && endMs >= startMs) {
           row.sessionDurationMinutes = (endMs - startMs) / 60000;
           return;
@@ -770,24 +1201,34 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
           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;
         }
+        if (!prevEnd) {
+          if (row === cur && endMs <= Date.now()) {
+            finalizeLiveSessionClosedAt(p, endMs);
+            return;
+          }
+          row.scheduledEndAt = endAtIso;
+          return;
+        }
         row.endAt = endAtIso;
         row.sessionDurationMinutes = (endMs - startMs) / 60000;
       };
+      let finalizedLiveSession = false;
       if (cur?.sessionId === id) {
+        const hadCurrentBefore = !!asRecord(p.current);
         applyToRow(cur);
+        finalizedLiveSession = hadCurrentBefore && !asRecord(p.current);
+      }
+      if (!finalizedLiveSession) {
+        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));
       }
-      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();
     }
@@ -828,29 +1269,152 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
     }
     case "newSession": {
       const id = randomUUID();
-      const startMs = Date.now();
-      const now = new Date(startMs).toISOString();
+      const recordMs = Date.now();
+      const recordIso = new Date(recordMs).toISOString();
+      const bodyRec = body as Record<string, unknown>;
+      const startAtOverrideRaw =
+        typeof bodyRec.sessionStartAt === "string" ? bodyRec.sessionStartAt.trim() : "";
+      const parsedOverrideMs =
+        startAtOverrideRaw !== "" ? Date.parse(startAtOverrideRaw) : Number.NaN;
+      const hadExplicitStart = startAtOverrideRaw !== "" && Number.isFinite(parsedOverrideMs);
+      /** Début réellement dans le passé : on n’écrase pas la session live, on ajoute une ligne d’historique. */
+      const isBackdatedOnly =
+        hadExplicitStart && parsedOverrideMs < recordMs - 1000;
+      const mergedCfg = { ...defaultKronosysCfg(), ...(asRecord(p.cfg) ?? {}) };
+      const tmplRaw =
+        typeof mergedCfg.dashboardDefaultSessionNameTemplate === "string"
+          ? mergedCfg.dashboardDefaultSessionNameTemplate.trim()
+          : "";
+      const tz = readDashboardTimeZoneFromCfg(mergedCfg);
       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 =
+
+      if (isBackdatedOnly) {
+        const endAtOverrideRaw =
+          typeof bodyRec.sessionEndAt === "string" ? bodyRec.sessionEndAt.trim() : "";
+        const parsedEndMs =
+          endAtOverrideRaw !== "" ? Date.parse(endAtOverrideRaw) : Number.NaN;
+        const hadExplicitEnd = endAtOverrideRaw !== "" && Number.isFinite(parsedEndMs);
+        if (!hadExplicitEnd) {
+          return {
+            ok: false,
+            result: {
+              newSessionError:
+                "Une session passée exige une date et une heure de fin (`sessionEndAt`).",
+            },
+          };
+        }
+        if (parsedEndMs <= parsedOverrideMs) {
+          return {
+            ok: false,
+            result: {
+              newSessionError: "La fin de session doit être strictement après le début.",
+            },
+          };
+        }
+        if (parsedEndMs > recordMs + 1000) {
+          return {
+            ok: false,
+            result: {
+              newSessionError: "La fin de session ne peut pas être dans le futur.",
+            },
+          };
+        }
+        const sessionStartMs = parsedOverrideMs;
+        const sessionStartIso = new Date(sessionStartMs).toISOString();
+        const sessionEndIso = new Date(parsedEndMs).toISOString();
+        const computedSessionName =
+          tmplRaw === ""
+            ? ""
+            : formatSessionNameTemplate(tmplRaw, {
+                sessionId: id,
+                atMs: sessionStartMs,
+                timeZone: tz,
+              }).slice(0, SESSION_NAME_TEMPLATE_MAX_LEN);
+        const ass: SessionStartAssiduity | undefined =
+          typeof schedIn === "string" && schedIn.trim() !== ""
+            ? (assiduityFromScheduledStart(sessionStartMs, schedIn) ?? undefined)
+            : undefined;
+        const hist = [...((p.history || []) as Record<string, unknown>[])];
+        const newRow: Record<string, unknown> = {
+          sessionId: id,
+          sessionName: computedSessionName,
+          sessionNote: "",
+          archived: false,
+          isPaused: true,
+          savedAt: recordIso,
+          createdAt: sessionStartIso,
+          startAt: sessionStartIso,
+          endAt: sessionEndIso,
+          ...(ass
+            ? { scheduledStartAt: ass.scheduledStartAt, sessionStartOffsetMinutes: ass.sessionStartOffsetMinutes }
+            : {}),
+          sessionDurationMinutes: Math.max(0, (parsedEndMs - sessionStartMs) / 60000),
+          codingMinutesSession: 0,
+          activeMinutes: 0,
+          totalEvents: 0,
+          language: prevLang,
+          tasks: [],
+          activeTasks: [],
+          activeTask: null,
+          sessionScope: body.sessionScope,
+        };
+        hist.unshift(newRow);
+        p.history = hist;
+        return finish({ newHistorySessionId: id });
+      }
+
+      // Lancement immédiat : instantané d’ouverture = maintenant (le client impose la fin de session live si besoin).
+      const immediateStartIso = recordIso;
+      const immediateSessionName =
+        tmplRaw === ""
+          ? ""
+          : formatSessionNameTemplate(tmplRaw, {
+              sessionId: id,
+              atMs: recordMs,
+              timeZone: tz,
+            }).slice(0, SESSION_NAME_TEMPLATE_MAX_LEN);
+      /* Si la session courante est encore vivante (pas de `endAt`) au moment où l’on en démarre une
+       * nouvelle, on la finalise proprement avant de la sortir de `current` :
+       *   - flush du segment de durée murale ;
+       *   - `endAt` au moment de l’ouverture de la nouvelle session ;
+       *   - `isPaused = true` (la session quitte le rôle de session live).
+       * Sans ça, l’ancienne session se retrouvait dans `history` avec `endAt: null` et
+       * `sessionDurationMinutes: 0` (orpheline), faisant disparaître son temps mural des rapports.
+       */
+      const prevLive = asRecord(p.current);
+      if (prevLive) {
+        const prevSid = typeof prevLive.sessionId === "string" ? prevLive.sessionId.trim() : "";
+        const prevEndRaw = typeof prevLive.endAt === "string" ? prevLive.endAt.trim() : "";
+        if (prevSid && prevEndRaw === "") {
+          flushSessionWallSegmentOnLive(prevLive);
+          prevLive.endAt = recordIso;
+          prevLive.isPaused = true;
+        }
+      }
+      syncLiveIntoHistory(p);
+      const assImmediate: SessionStartAssiduity | undefined =
         typeof schedIn === "string" && schedIn.trim() !== ""
-          ? (assiduityFromScheduledStart(startMs, schedIn) ?? undefined)
+          ? (assiduityFromScheduledStart(recordMs, schedIn) ?? undefined)
           : undefined;
       p.current = {
         sessionId: id,
-        sessionName: "",
+        sessionName: immediateSessionName,
+        sessionNote: "",
         archived: false,
         isPaused: false,
-        savedAt: now,
-        createdAt: now,
-        startAt: now,
+        savedAt: recordIso,
+        createdAt: immediateStartIso,
+        startAt: immediateStartIso,
         endAt: null,
-        ...(ass
-          ? { scheduledStartAt: ass.scheduledStartAt, sessionStartOffsetMinutes: ass.sessionStartOffsetMinutes }
+        ...(assImmediate
+          ? {
+              scheduledStartAt: assImmediate.scheduledStartAt,
+              sessionStartOffsetMinutes: assImmediate.sessionStartOffsetMinutes,
+            }
           : {}),
-        [SESSION_WALL_SEGMENT_STARTED_AT]: now,
+        [SESSION_WALL_SEGMENT_STARTED_AT]: recordIso,
         sessionDurationMinutes: 0,
         codingMinutesSession: 0,
         activeMinutes: 0,
@@ -880,16 +1444,42 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
         Array.isArray(body.tags) ? (body.tags as string[]) : [],
         tagNormOpts
       );
-      const project = typeof body.project === "string" ? body.project : undefined;
+      const parsedTitle = parseTaskWithAutoTags(name);
+      const projFromBody = typeof body.project === "string" ? body.project.trim() : "";
+      const projectResolved = projFromBody
+        ? normalizeProjectKey(projFromBody)
+        : parsedTitle.project
+          ? normalizeProjectKey(parsedTitle.project)
+          : null;
+      const personalResolved =
+        (typeof body.personalProject === "boolean" ? body.personalProject : parsedTitle.personalProject) &&
+        Boolean(projectResolved);
+      const note = typeof body.note === "string" ? body.note : "";
       mergeDiscoveredTagsIntoPayloadKnownTags(p, mergeTagsForDisplay(name, tags));
-      mergeDiscoveredProjectIntoPayloadKnownProjects(p, project);
-      mergeDiscoveredProjectIntoPayloadKnownProjects(p, parseTaskWithAutoTags(name).project);
-      const task = newTaskRecord({ name, tags, project }, tagNormOpts);
+      mergeDiscoveredProjectIntoPayloadKnownProjects(p, projectResolved);
+      mergeDiscoveredPersonalProjectIntoPayloadKnownPersonalProjects(p, projectResolved, personalResolved);
+      mergeDiscoveredProjectIntoPayloadKnownProjects(p, parsedTitle.project);
+      mergeDiscoveredPersonalProjectIntoPayloadKnownPersonalProjects(
+        p,
+        parsedTitle.project,
+        parsedTitle.personalProject,
+      );
+      const task = newTaskRecord(
+        {
+          name,
+          tags,
+          project: projectResolved,
+          personalProject: personalResolved,
+          note,
+        },
+        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));
+      resumeLiveSessionWallIfPaused(cur);
       const bodyRec = body as Record<string, unknown>;
       if (body.startKronoFocus === true || bodyRec[LEGACY_START_TASK_WITH_TIMER_BODY_KEY] === true) {
         const pm = ensureKronoFocus(cur);
@@ -950,10 +1540,12 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
       p.inspectingSessionId = null;
       p.knownTags = [];
       p.knownProjects = [];
+      (p as Record<string, unknown>).knownPersonalProjects = [];
       p.userKnownTags = [];
       p.excludedSuggestionTags = [];
       p.tagDescriptions = {};
       p.projectDescriptions = {};
+      (p as Record<string, unknown>).taskTemplates = [];
       p.gitIdentity = {};
       delete p.gitStats;
       delete p.dismissArchiveSessionConfirm;
@@ -964,8 +1556,37 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
     case "endLiveSession": {
       const cur = asRecord(p.current);
       if (cur) {
+        const taskHandling =
+          body.taskHandling === "finish"
+            ? "finish"
+            : body.taskHandling === "moveToPausedSession"
+              ? "moveToPausedSession"
+              : "keep";
+        /* Une session terminée ne peut pas laisser des minuteurs « en cours » : on vide les segments
+         * et on met en pause, quel que soit le mode (keep / finish / transposition). */
+        forEachTaskRecordInSession(cur, (task) => {
+          if (task.isDone === true) {
+            return;
+          }
+          flushSubtaskTimerOnTask(task);
+          flushMainTimerSegmentOnTask(task);
+          task.manualTaskTimerPaused = true;
+        });
+        if (taskHandling === "finish") {
+          const openTaskIds: string[] = [];
+          forEachTaskRecordInSession(cur, (_task, taskId) => {
+            const task = findTaskRecord(cur, taskId);
+            if (task && task.isDone !== true) {
+              openTaskIds.push(taskId);
+            }
+          });
+          for (const taskId of openTaskIds) {
+            finishTaskInSession(cur, taskId, false, tagNormOpts);
+          }
+        }
         flushSessionWallSegmentOnLive(cur);
         cur.endAt = new Date().toISOString();
+        delete cur.scheduledEndAt;
         const rk = normalizeSessionEndReasonKind(body.sessionEndReasonKind);
         if (rk) {
           cur.sessionEndReasonKind = rk;
@@ -978,7 +1599,50 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
         } else {
           delete cur.sessionEndReasonNote;
         }
+        let movedSession: Record<string, unknown> | null = null;
+        if (taskHandling === "moveToPausedSession") {
+          const carriedTasks: Record<string, unknown>[] = [];
+          forEachTaskRecordInSession(cur, (task) => {
+            if (task.isDone === true) {
+              return;
+            }
+            carriedTasks.push({
+              ...task,
+              manualTaskTimerPaused: true,
+              activeSubtaskTimerId: null,
+            });
+          });
+          if (carriedTasks.length > 0) {
+            const now = new Date().toISOString();
+            movedSession = {
+              sessionId: randomUUID(),
+              sessionName:
+                typeof cur.sessionName === "string" && cur.sessionName.trim() !== ""
+                  ? `${cur.sessionName} (continued)`
+                  : "Continued session",
+              archived: false,
+              isPaused: true,
+              savedAt: now,
+              createdAt: now,
+              startAt: now,
+              endAt: null,
+              sessionDurationMinutes: 0,
+              codingMinutesSession: 0,
+              activeMinutes: 0,
+              totalEvents: 0,
+              language: typeof cur.language === "string" ? cur.language : "en",
+              tasks: carriedTasks,
+              activeTasks: [],
+              activeTask: null,
+            };
+          }
+        }
         syncLiveIntoHistory(p);
+        if (movedSession) {
+          p.current = movedSession;
+          syncLiveIntoHistory(p);
+          return finish();
+        }
       }
       p.current = undefined;
       return finish();
@@ -995,6 +1659,8 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
           : typeof body.project === "string"
             ? body.project
             : undefined;
+      const personalPatch =
+        body.personalProject === undefined ? undefined : body.personalProject === true;
       if (
         !updateTaskInSession(
           ctx.session,
@@ -1003,12 +1669,27 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
             name: typeof body.name === "string" ? body.name : undefined,
             tags: Array.isArray(body.tags) ? (body.tags as string[]) : undefined,
             project: projectPatch,
+            personalProject: personalPatch,
+            note: typeof body.note === "string" ? body.note : undefined,
           },
           tagNormOpts
         )
       ) {
         return finish();
       }
+      if (typeof body.name === "string") {
+        const inferredProj = resolveProjectForTaskUpdate(body.name);
+        const inferredPers = resolvePersonalProjectForTaskUpdate(body.name);
+        const t = findTaskRecord(ctx.session, taskId);
+        if (t) {
+          if (inferredProj !== undefined) {
+            t.project = inferredProj;
+          }
+          if (inferredPers !== undefined) {
+            t.personalProject = inferredPers;
+          }
+        }
+      }
       if (Array.isArray(body.tags)) {
         mergeDiscoveredTagsIntoPayloadKnownTags(p, body.tags as string[]);
       } else if (typeof body.name === "string") {
@@ -1016,8 +1697,22 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
       }
       if (typeof projectPatch === "string") {
         mergeDiscoveredProjectIntoPayloadKnownProjects(p, projectPatch);
+        const tAfter = findTaskRecord(ctx.session, taskId);
+        const pers =
+          personalPatch !== undefined
+            ? personalPatch
+            : typeof body.name === "string"
+              ? parseTaskWithAutoTags(body.name).personalProject
+              : tAfter?.personalProject === true;
+        mergeDiscoveredPersonalProjectIntoPayloadKnownPersonalProjects(
+          p,
+          normalizeProjectKey(projectPatch),
+          Boolean(pers),
+        );
       } else if (typeof body.name === "string") {
-        mergeDiscoveredProjectIntoPayloadKnownProjects(p, parseTaskWithAutoTags(body.name).project);
+        const pt = parseTaskWithAutoTags(body.name);
+        mergeDiscoveredProjectIntoPayloadKnownProjects(p, pt.project);
+        mergeDiscoveredPersonalProjectIntoPayloadKnownPersonalProjects(p, pt.project, pt.personalProject);
       }
       if (ctx.isLive) {
         syncLiveIntoHistory(p);
@@ -1034,7 +1729,18 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
       if (!taskId || !startTime) {
         return finish();
       }
-      const ok = updateTaskStartTimeInSession(ctx.session, taskId, startTime);
+      const durationAdjustModeRaw =
+        body.durationAdjustMode === "keep" || body.durationAdjustMode === "manual" || body.durationAdjustMode === "from_bounds"
+          ? body.durationAdjustMode
+          : undefined;
+      const manualDurationMs =
+        typeof body.manualDurationMs === "number" && Number.isFinite(body.manualDurationMs)
+          ? Math.max(0, Math.floor(body.manualDurationMs))
+          : undefined;
+      const ok = updateTaskStartTimeInSession(ctx.session, taskId, startTime, {
+        durationAdjustMode: durationAdjustModeRaw,
+        manualDurationMs,
+      });
       if (ok && ctx.isLive) {
         syncLiveIntoHistory(p);
       }
@@ -1050,7 +1756,20 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
       if (!taskId || !endTime) {
         return finish();
       }
-      const ok = updateTaskEndTimeInSession(ctx.session, taskId, endTime);
+      const durationAdjustModeRaw =
+        body.durationAdjustMode === "keep" || body.durationAdjustMode === "manual" || body.durationAdjustMode === "from_bounds"
+          ? body.durationAdjustMode
+          : undefined;
+      const manualDurationMs =
+        typeof body.manualDurationMs === "number" && Number.isFinite(body.manualDurationMs)
+          ? Math.max(0, Math.floor(body.manualDurationMs))
+          : undefined;
+      const ok = updateTaskEndTimeInSession(ctx.session, taskId, endTime, {
+        durationAdjustMode: durationAdjustModeRaw,
+        manualDurationMs,
+      })
+        ? true
+        : scheduleTaskEndTimeInSession(ctx.session, taskId, endTime);
       if (ok && ctx.isLive) {
         syncLiveIntoHistory(p);
       }
@@ -1088,7 +1807,13 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
       if (!ctx) {
         return finish();
       }
-      setTaskPausedInSession(ctx.session, String(body.taskId ?? ""), body.paused === true);
+      const paused = body.paused === true;
+      const taskId = String(body.taskId ?? "");
+      setTaskPausedInSession(ctx.session, taskId, paused);
+      if (ctx.isLive && !paused) {
+        pruneSessionPauseContextForTask(ctx.session, taskId);
+        resumeLiveSessionWallIfPaused(ctx.session);
+      }
       if (ctx.isLive) {
         syncLiveIntoHistory(p);
       }
@@ -1099,8 +1824,11 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
       if (!ctx) {
         return finish();
       }
-      setTaskPausedInSession(ctx.session, String(body.taskId ?? ""), false);
+      const taskId = String(body.taskId ?? "");
+      setTaskPausedInSession(ctx.session, taskId, false);
       if (ctx.isLive) {
+        pruneSessionPauseContextForTask(ctx.session, taskId);
+        resumeLiveSessionWallIfPaused(ctx.session);
         syncLiveIntoHistory(p);
       }
       return finish();
@@ -1117,20 +1845,49 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
       );
       const project =
         body.project === null ? null : typeof body.project === "string" ? body.project : undefined;
+      const parsedTitle = parseTaskWithAutoTags(name);
+      const projectResolved =
+        project !== undefined && project !== null && String(project).trim()
+          ? normalizeProjectKey(String(project).trim())
+          : parsedTitle.project
+            ? normalizeProjectKey(parsedTitle.project)
+            : null;
+      const personalResolved =
+        (typeof body.personalProject === "boolean" ? body.personalProject : parsedTitle.personalProject) &&
+        Boolean(projectResolved);
       const durationMs = typeof body.durationMs === "number" ? Math.round(body.durationMs) : 0;
+      const note = typeof body.note === "string" ? body.note : "";
       const startTime = typeof body.startTime === "string" ? body.startTime : "";
       const endTime = typeof body.endTime === "string" ? body.endTime : "";
-      addHistoricalTaskToSession(
+      const added = addHistoricalTaskToSession(
         ctx.session,
-        { name, tags, project, durationMs, startTime, endTime },
+        {
+          name,
+          tags,
+          project: projectResolved,
+          personalProject: personalResolved,
+          note,
+          durationMs,
+          startTime,
+          endTime,
+        },
         randomUUID(),
         tagNormOpts
       );
-      mergeDiscoveredTagsIntoPayloadKnownTags(p, mergeTagsForDisplay(name, tags));
-      if (typeof project === "string") {
-        mergeDiscoveredProjectIntoPayloadKnownProjects(p, project);
+      if (!added) {
+        return finish();
       }
-      mergeDiscoveredProjectIntoPayloadKnownProjects(p, parseTaskWithAutoTags(name).project);
+      mergeDiscoveredTagsIntoPayloadKnownTags(p, mergeTagsForDisplay(name, tags));
+      if (projectResolved) {
+        mergeDiscoveredProjectIntoPayloadKnownProjects(p, projectResolved);
+        mergeDiscoveredPersonalProjectIntoPayloadKnownPersonalProjects(p, projectResolved, personalResolved);
+      }
+      mergeDiscoveredProjectIntoPayloadKnownProjects(p, parsedTitle.project);
+      mergeDiscoveredPersonalProjectIntoPayloadKnownPersonalProjects(
+        p,
+        parsedTitle.project,
+        parsedTitle.personalProject,
+      );
       if (ctx.isLive) {
         syncLiveIntoHistory(p);
       }
@@ -1343,6 +2100,110 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
       p.userKnownTags = user;
       return finish();
     }
+    case "saveTaskTemplate": {
+      const name = typeof body.name === "string" ? body.name.trim() : "";
+      const tags = normalizeTaskTagsForStorage(
+        Array.isArray(body.tags) ? (body.tags as string[]) : [],
+        tagNormOpts
+      );
+      const projectRaw = typeof body.project === "string" ? body.project.trim() : "";
+      const project = projectRaw ? normalizeProjectKey(projectRaw) : null;
+      if (!name && tags.length === 0 && !project) {
+        return finish();
+      }
+      const incomingPersonal =
+        typeof body.personalProject === "boolean" ? body.personalProject : undefined;
+      const now = new Date().toISOString();
+      const list = readTaskTemplates(p);
+      const idOpt = typeof body.id === "string" ? body.id.trim() : "";
+      if (idOpt) {
+        const ix = list.findIndex((tpl) => tpl.id === idOpt);
+        if (ix < 0) {
+          return finish();
+        }
+        const prev = list[ix]!;
+        const personalProject =
+          incomingPersonal !== undefined ? incomingPersonal : prev.personalProject === true;
+        list[ix] = {
+          ...prev,
+          name: name || prev.name,
+          tags,
+          project,
+          personalProject,
+          updatedAt: now,
+        };
+        (p as Record<string, unknown>).taskTemplates = list.slice(0, 200);
+        if (tags.length > 0) {
+          mergeDiscoveredTagsIntoPayloadKnownTags(p, tags);
+        }
+        if (project) {
+          if (personalProject) {
+            mergeDiscoveredPersonalProjectIntoPayloadKnownPersonalProjects(p, project, true);
+          } else {
+            mergeDiscoveredProjectIntoPayloadKnownProjects(p, project);
+          }
+        }
+        return finish();
+      }
+      const sigPersonal = incomingPersonal === true;
+      const sig = `${name.toLowerCase()}|${sigPersonal ? "p" : "w"}|${project ? project.toLowerCase() : ""}|${tags
+        .map((t) => t.toLowerCase())
+        .sort()
+        .join(",")}`;
+      const idx = list.findIndex((tpl) => {
+        const rowSig = `${tpl.name.toLowerCase()}|${tpl.personalProject === true ? "p" : "w"}|${tpl.project ? tpl.project.toLowerCase() : ""}|${[...tpl.tags]
+          .map((t) => t.toLowerCase())
+          .sort()
+          .join(",")}`;
+        return rowSig === sig;
+      });
+      if (idx >= 0) {
+        const prev = list[idx]!;
+        const personalProject =
+          incomingPersonal !== undefined ? incomingPersonal : prev.personalProject === true;
+        list[idx] = {
+          ...prev,
+          name: name || prev.name,
+          tags,
+          project,
+          personalProject,
+          updatedAt: now,
+        };
+      } else {
+        list.unshift({
+          id: randomUUID(),
+          name: name || tags.join(" "),
+          tags,
+          project,
+          personalProject: incomingPersonal === true,
+          createdAt: now,
+          updatedAt: now,
+        });
+      }
+      (p as Record<string, unknown>).taskTemplates = list.slice(0, 200);
+      if (tags.length > 0) {
+        mergeDiscoveredTagsIntoPayloadKnownTags(p, tags);
+      }
+      if (project) {
+        const row = list[idx >= 0 ? idx : 0]!;
+        if (row.personalProject === true) {
+          mergeDiscoveredPersonalProjectIntoPayloadKnownPersonalProjects(p, project, true);
+        } else {
+          mergeDiscoveredProjectIntoPayloadKnownProjects(p, project);
+        }
+      }
+      return finish();
+    }
+    case "removeTaskTemplate": {
+      const rawId =
+        typeof body.taskTemplateId === "string" ? body.taskTemplateId.trim() : "";
+      if (!rawId) {
+        return finish();
+      }
+      const list = readTaskTemplates(p).filter((t) => t.id !== rawId);
+      (p as Record<string, unknown>).taskTemplates = list;
+      return finish();
+    }
     case "removeUserKnownTag": {
       const raw = typeof body.tag === "string" ? body.tag : "";
       const lk = normalizeTagKey(raw).toLowerCase();
@@ -1369,6 +2230,11 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
       p.projectDescriptions = pd;
       return finish();
     }
+    case "rememberKnownProject": {
+      const raw = typeof body.name === "string" ? body.name : "";
+      mergeDiscoveredProjectIntoPayloadKnownProjects(p, raw);
+      return finish();
+    }
     case "includeTagFromSuggestions": {
       const raw = typeof body.tag === "string" ? body.tag : "";
       const lk = normalizeTagKey(raw).toLowerCase();
@@ -1401,6 +2267,63 @@ export async function dispatchKronosysAction(body: Record<string, unknown>): Pro
       purgeProjectEverywhere(p, raw);
       return finish();
     }
+    case "renameTagMetadata": {
+      const source = typeof body.sourceTag === "string" ? body.sourceTag : "";
+      const target = typeof body.targetTag === "string" ? body.targetTag : "";
+      renameTagEverywhere(p, source, target, tagNormOpts);
+      return finish();
+    }
+    case "renameProjectMetadata": {
+      const source = typeof body.sourceName === "string" ? body.sourceName : "";
+      const target = typeof body.targetName === "string" ? body.targetName : "";
+      const personalOnly = body.personalOnly === true;
+      renameProjectEverywhere(p, source, target, { personalOnly });
+      return finish();
+    }
+    case "transformKnownTagScope": {
+      const sourceRaw = typeof body.sourceTag === "string" ? body.sourceTag : "";
+      const targetRaw = typeof body.targetTag === "string" ? body.targetTag : "";
+      const mode: "move" | "copy" = body.mode === "copy" ? "copy" : "move";
+      const source = normalizeTagKey(sourceRaw);
+      const target = normalizeTagKey(targetRaw);
+      if (!source || !target || source.toLowerCase() === target.toLowerCase()) {
+        return finish();
+      }
+      transformTaskTagsInPayload(p, source, target, mode, tagNormOpts);
+      const sourceL = source.toLowerCase();
+      const targetL = target.toLowerCase();
+      const known = [...((p.knownTags || []) as string[])];
+      if (!known.some((t) => normalizeTagKey(t).toLowerCase() === targetL)) {
+        known.push(target);
+      }
+      p.knownTags = mode === "move" ? known.filter((t) => normalizeTagKey(t).toLowerCase() !== sourceL) : known;
+      const userKnown = [...((p.userKnownTags || []) as string[])];
+      if (userKnown.some((t) => normalizeTagKey(t).toLowerCase() === sourceL)) {
+        if (!userKnown.some((t) => normalizeTagKey(t).toLowerCase() === targetL)) {
+          userKnown.push(target);
+        }
+      }
+      p.userKnownTags =
+        mode === "move" ? userKnown.filter((t) => normalizeTagKey(t).toLowerCase() !== sourceL) : userKnown;
+      const excluded = [...((p.excludedSuggestionTags || []) as string[])];
+      if (excluded.some((t) => normalizeTagKey(t).toLowerCase() === sourceL)) {
+        if (!excluded.some((t) => normalizeTagKey(t).toLowerCase() === targetL)) {
+          excluded.push(target);
+        }
+      }
+      p.excludedSuggestionTags =
+        mode === "move" ? excluded.filter((t) => normalizeTagKey(t).toLowerCase() !== sourceL) : excluded;
+      const td = { ...(asRecord(p.tagDescriptions) ?? {}) } as Record<string, string>;
+      const sourceDesc = typeof td[sourceL] === "string" ? td[sourceL] : "";
+      if (sourceDesc && !td[targetL]) {
+        td[targetL] = sourceDesc;
+      }
+      if (mode === "move") {
+        delete td[sourceL];
+      }
+      p.tagDescriptions = td;
+      return finish();
+    }
     case "fetchRemoteIssues":
       return await dispatchFetchRemoteIssues(p, body);
     case "pushSessionToMongo":