@nightkatana/kronosys-app 1.0.0-beta.0

package/lib/dashboardDetachedUrlHintStorage.ts

@@ -0,0 +1,24 @@
+/** Mémorise que l’utilisateur a masqué la note « onglet piloté par l’URL » sur le tableau de bord. */
+export const DETACHED_URL_HINT_DISMISS_KEY = "kronosys_detached_url_hint_dismiss_v1";
+
+export function readDashboardDetachedUrlHintDismissed(): boolean {
+  if (typeof globalThis.window === "undefined") {
+    return false;
+  }
+  try {
+    return globalThis.localStorage.getItem(DETACHED_URL_HINT_DISMISS_KEY) === "1";
+  } catch {
+    return false;
+  }
+}
+
+export function writeDashboardDetachedUrlHintDismissed(): void {
+  if (typeof globalThis.window === "undefined") {
+    return;
+  }
+  try {
+    globalThis.localStorage.setItem(DETACHED_URL_HINT_DISMISS_KEY, "1");
+  } catch {
+    /* ignore */
+  }
+}

package/lib/dashboardGitIdentityBannerStorage.ts

@@ -0,0 +1,36 @@
+/** Mémorise que l’utilisateur a masqué la bannière « configurez l’auteur Git » sur le tableau de bord. */
+export const GIT_IDENTITY_BANNER_DISMISS_KEY = "kronosys_git_banner_dismiss_v1";
+
+export function readGitIdentityBannerDismissed(): boolean {
+  if (typeof globalThis.window === "undefined") {
+    return false;
+  }
+  try {
+    return globalThis.localStorage.getItem(GIT_IDENTITY_BANNER_DISMISS_KEY) === "1";
+  } catch {
+    return false;
+  }
+}
+
+export function writeGitIdentityBannerDismissed(): void {
+  if (typeof globalThis.window === "undefined") {
+    return;
+  }
+  try {
+    globalThis.localStorage.setItem(GIT_IDENTITY_BANNER_DISMISS_KEY, "1");
+  } catch {
+    /* ignore */
+  }
+}
+
+/** À appeler après une réinitialisation (ex. effacement des données) pour reproposer la bannière si l’identité est vide. */
+export function resetGitIdentityBannerDismissed(): void {
+  if (typeof globalThis.window === "undefined") {
+    return;
+  }
+  try {
+    globalThis.localStorage.removeItem(GIT_IDENTITY_BANNER_DISMISS_KEY);
+  } catch {
+    /* ignore */
+  }
+}

package/lib/dashboardLangStorage.ts

@@ -0,0 +1,72 @@
+import type { Lang } from "./dashboardCopy";
+
+/** Langue UI du tableau de bord (menu, chaînes). Écrite au choix utilisateur après la visite guidée. */
+export const DASHBOARD_LANG_STORAGE_KEY = "kronosys-dashboard-ui-lang";
+
+/**
+ * Mis à « vrai » lorsque l’utilisateur choisit explicitement une langue (écran d’accueil ou menu).
+ * Tant que cette clé est absente et que la visite guidée n’est pas terminée, le tableau de bord
+ * affiche d’abord le sélecteur de langue et n’ouvre pas la visite dans une langue imposée.
+ */
+export const DASHBOARD_LANG_USER_CHOSEN_KEY = "kronosys.dashboard.lang.userChosen.v1";
+
+export function readStoredDashboardLang(): Lang | null {
+  if (typeof globalThis.window === "undefined") {
+    return null;
+  }
+  try {
+    const s = globalThis.localStorage.getItem(DASHBOARD_LANG_STORAGE_KEY);
+    if (s === "fr" || s === "en") {
+      return s;
+    }
+  } catch {
+    /* ignore */
+  }
+  return null;
+}
+
+export function writeStoredDashboardLang(lang: Lang): void {
+  if (typeof globalThis.window === "undefined") {
+    return;
+  }
+  try {
+    globalThis.localStorage.setItem(DASHBOARD_LANG_STORAGE_KEY, lang);
+  } catch {
+    /* ignore */
+  }
+}
+
+export function readDashboardLangUserChosen(): boolean {
+  if (typeof globalThis.window === "undefined") {
+    return false;
+  }
+  try {
+    return globalThis.localStorage.getItem(DASHBOARD_LANG_USER_CHOSEN_KEY) === "1";
+  } catch {
+    return false;
+  }
+}
+
+export function writeDashboardLangUserChosen(): void {
+  if (typeof globalThis.window === "undefined") {
+    return;
+  }
+  try {
+    globalThis.localStorage.setItem(DASHBOARD_LANG_USER_CHOSEN_KEY, "1");
+  } catch {
+    /* ignore */
+  }
+}
+
+/** Efface la langue mémorisée et le marqueur de choix explicite (ex. après « tout effacer » dans les paramètres). */
+export function resetDashboardLangPreference(): void {
+  if (typeof globalThis.window === "undefined") {
+    return;
+  }
+  try {
+    globalThis.localStorage.removeItem(DASHBOARD_LANG_USER_CHOSEN_KEY);
+    globalThis.localStorage.removeItem(DASHBOARD_LANG_STORAGE_KEY);
+  } catch {
+    /* ignore */
+  }
+}

package/lib/dashboardQuickSearch.ts

@@ -0,0 +1,476 @@
+import type { DashboardStrings } from "@/lib/dashboardCopy";
+import type { SessionListEntry } from "@/components/dashboard/SessionListPanel";
+import {
+  formatDuration,
+  formatProjectDisplay,
+  formatStopwatchMs,
+  formatTagDisplay,
+  mergeTagsForDisplay,
+  normalizeProjectKey,
+  normalizeTagKey,
+  parseProjectScopedTag,
+  parseTaskWithAutoTags,
+  taskTitleForDisplay,
+} from "@/lib/taskParsing";
+
+export type SearchLiveContext = {
+  sessionId: string;
+  sessionPaused: boolean;
+};
+
+export type SearchTimerState = "active" | "paused" | "off";
+
+export type DashboardSearchItem = {
+  id: string;
+  title: string;
+  subtitle?: string;
+  /** Projet / étiquettes affichés sous le titre (résultats de recherche). */
+  metaLine?: string;
+  /**
+   * Minuterie + temps enregistré (tâches) ou durée murale (session), pour donner du contexte à la recherche.
+   */
+  searchTimerLine?: string;
+  searchTimerState?: SearchTimerState;
+  /** Texte indexé pour le filtre (déjà en minuscules recommandé). */
+  haystack: string;
+  /**
+   * Durée en secondes (tâche : enregistrement de suivi ; session : durée « murale ») pour
+   * requêtes du type `12:55 <` ou `0:10 >`.
+   */
+  durationForSearchSec?: number;
+  onSelect: () => void;
+};
+
+type TaskLike = {
+  id?: string;
+  name?: string;
+  tags?: unknown;
+  project?: unknown;
+  isDone?: boolean;
+  manualTaskTimerPaused?: boolean;
+  /** ISO 8601 côté modèle tâche (début d’enregistrement / entrée passée). */
+  startTime?: string;
+  endTime?: string;
+  /** Durée du suivi enregistrée (ms). */
+  durationMs?: number;
+};
+
+const pad2 = (n: number) => String(n).padStart(2, "0");
+
+function readOptionalIsoString(x: unknown): string | undefined {
+  return typeof x === "string" && x.trim() ? x.trim() : undefined;
+}
+
+/**
+ * Volets texte pour qu’on puisse filtrer par saisies du type `2026-01-15` ou
+ * `2026-01-15 14:30:02` (Heure locale et UTC, plus la chaîne source et l’ISO).
+ */
+function collectDateSearchFragments(value: string | null | undefined): string {
+  if (value == null) {
+    return "";
+  }
+  const t = String(value).trim();
+  if (t === "") {
+    return "";
+  }
+  const ms = Date.parse(t);
+  if (Number.isNaN(ms)) {
+    return t.toLowerCase();
+  }
+  const d = new Date(ms);
+  const ymdU = `${d.getUTCFullYear()}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())}`;
+  const ymdL = `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+  const hmsU = `${pad2(d.getUTCHours())}:${pad2(d.getUTCMinutes())}:${pad2(d.getUTCSeconds())}`;
+  const hmsL = `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
+  const pieces = new Set<string>([t.toLowerCase(), ymdU, ymdL, `${ymdU} ${hmsU}`, `${ymdL} ${hmsL}`]);
+  pieces.add(`${ymdU} ${pad2(d.getUTCHours())}:${pad2(d.getUTCMinutes())}`);
+  pieces.add(`${ymdL} ${pad2(d.getHours())}:${pad2(d.getMinutes())}`);
+  return [...pieces].join(" ");
+}
+
+function dateHayFromFields(...fields: (string | null | undefined)[]): string {
+  return fields
+    .map((f) => collectDateSearchFragments(f))
+    .filter(Boolean)
+    .join(" ");
+}
+
+function buildTaskSearchIndex(
+  rawName: string,
+  storedTags: unknown,
+  storedProject: unknown
+): { haystackFragment: string; metaLine: string } {
+  const storedTagArr = Array.isArray(storedTags)
+    ? storedTags.filter((x): x is string => typeof x === "string")
+    : undefined;
+  const tagList = mergeTagsForDisplay(rawName, storedTagArr);
+  const parsed = parseTaskWithAutoTags(rawName);
+  const projRaw =
+    (typeof storedProject === "string" && storedProject.trim() ? storedProject.trim() : undefined) ??
+    parsed.project;
+
+  const hayPieces: string[] = [];
+  if (projRaw) {
+    hayPieces.push(projRaw, normalizeProjectKey(projRaw), formatProjectDisplay(projRaw), `@${normalizeProjectKey(projRaw)}`);
+  }
+  for (const tag of tagList) {
+    hayPieces.push(tag, normalizeTagKey(tag), formatTagDisplay(tag));
+    const scoped = parseProjectScopedTag(normalizeTagKey(tag));
+    if (scoped) {
+      hayPieces.push(
+        scoped.projectKey,
+        scoped.localTag,
+        `${scoped.projectKey}#${scoped.localTag}`,
+        `${scoped.projectKey.toLowerCase()}#${scoped.localTag.toLowerCase()}`
+      );
+    }
+  }
+
+  const metaParts: string[] = [];
+  if (projRaw) {
+    metaParts.push(formatProjectDisplay(projRaw));
+  }
+  for (const tag of tagList) {
+    metaParts.push(formatTagDisplay(tag));
+  }
+
+  return {
+    haystackFragment: hayPieces.join(" ").toLowerCase(),
+    metaLine: metaParts.join(" · "),
+  };
+}
+
+function truncateMetaLine(s: string, maxLen: number): string {
+  const t = s.trim();
+  if (t.length <= maxLen) {
+    return t;
+  }
+  return `${t.slice(0, Math.max(0, maxLen - 1)).trimEnd()}…`;
+}
+
+function taskIdDedupKey(id: string): string {
+  return id.trim();
+}
+
+function taskDurationSecondsFromRecord(t: TaskLike): number | undefined {
+  const ms = t.durationMs;
+  if (typeof ms === "number" && Number.isFinite(ms) && ms > 0) {
+    return ms / 1000;
+  }
+  return undefined;
+}
+
+function taskRecordedMinutesBestEffort(t: TaskLike): number {
+  const ms = t.durationMs;
+  if (typeof ms === "number" && Number.isFinite(ms) && ms > 0) {
+    return ms / 60000;
+  }
+  const st = typeof t.startTime === "string" ? Date.parse(t.startTime) : Number.NaN;
+  const en = typeof t.endTime === "string" ? Date.parse(t.endTime) : Number.NaN;
+  if (Number.isFinite(st) && Number.isFinite(en) && en >= st) {
+    return (en - st) / 60000;
+  }
+  return 0;
+}
+
+function taskStopwatchDisplayMs(t: TaskLike): number {
+  const dm = typeof t.durationMs === "number" && Number.isFinite(t.durationMs) ? t.durationMs : 0;
+  if (t.isDone === true) {
+    return Math.max(0, dm);
+  }
+  if (t.manualTaskTimerPaused !== true && typeof t.startTime === "string" && t.startTime.trim() !== "") {
+    const st = Date.parse(t.startTime);
+    if (Number.isFinite(st)) {
+      return Math.max(0, Date.now() - st);
+    }
+  }
+  return Math.max(0, dm);
+}
+
+function taskSearchTimerState(t: TaskLike): SearchTimerState {
+  if (t.isDone === true) {
+    return "off";
+  }
+  if (t.manualTaskTimerPaused === true) {
+    return "paused";
+  }
+  if (typeof t.startTime === "string" && t.startTime.trim() !== "") {
+    return "active";
+  }
+  return "off";
+}
+
+function buildTaskSearchTimerLine(
+  t: TaskLike,
+  dt: DashboardStrings
+): { line: string; state: SearchTimerState; hayFragment: string } {
+  const isDone = t.isDone === true;
+  const recMin = taskRecordedMinutesBestEffort(t);
+  const recStr = formatDuration(Math.max(0, recMin));
+  if (isDone) {
+    const line = `${dt.dataSearchTaskRecordedTimeLabel} ${recStr}`;
+    return { line, state: "off", hayFragment: line.toLowerCase() };
+  }
+  const swMs = taskStopwatchDisplayMs(t);
+  const chrono = formatStopwatchMs(swMs);
+  const recPart = formatDuration(
+    Math.max(0, (typeof t.durationMs === "number" && Number.isFinite(t.durationMs) ? t.durationMs : 0) / 60000)
+  );
+  const state = taskSearchTimerState(t);
+  const line = `${dt.dataSearchTaskStopwatchLabel} ${chrono} · ${dt.dataSearchTaskRecordedTimeLabel} ${recPart}`;
+  return { line, state, hayFragment: line.toLowerCase() };
+}
+
+function sessionSearchTimerInfo(
+  s: SessionListEntry,
+  live: SearchLiveContext | null | undefined,
+  dt: DashboardStrings
+): { line: string; state: SearchTimerState; hayFragment: string } {
+  const id = typeof s.sessionId === "string" ? s.sessionId.trim() : "";
+  const wallMin =
+    typeof s.sessionDurationMinutes === "number" && Number.isFinite(s.sessionDurationMinutes)
+      ? s.sessionDurationMinutes
+      : 0;
+  const wall = formatDuration(Math.max(0, wallMin));
+  const line = `${dt.dataSearchSessionWallLabel} ${wall}`;
+  const ended = typeof s.endAt === "string" && s.endAt.trim() !== "";
+  const isLive = Boolean(live?.sessionId && id && live.sessionId === id);
+  let state: SearchTimerState = "off";
+  if (isLive && !ended) {
+    state = live?.sessionPaused ? "paused" : "active";
+  }
+  return { line, state, hayFragment: line.toLowerCase() };
+}
+
+function sessionWallSecondsForSearch(s: SessionListEntry, tasks: TaskLike[]): number | undefined {
+  const m = s.sessionDurationMinutes;
+  if (typeof m === "number" && Number.isFinite(m) && m > 0) {
+    return m * 60;
+  }
+  let sum = 0;
+  let any = false;
+  for (const t of tasks) {
+    const sec = taskDurationSecondsFromRecord(t);
+    if (sec !== undefined) {
+      sum += sec;
+      any = true;
+    }
+  }
+  return any ? sum : undefined;
+}
+
+function collectTasksFromSessionShape(session: Record<string, unknown> | null | undefined): TaskLike[] {
+  if (!session) {
+    return [];
+  }
+  const byId = new Map<string, TaskLike>();
+  const add = (t: TaskLike | null | undefined) => {
+    if (!t || typeof t.id !== "string" || !t.id.trim()) {
+      return;
+    }
+    const key = taskIdDedupKey(t.id);
+    if (!key) {
+      return;
+    }
+    if (!byId.has(key)) {
+      byId.set(key, t);
+    }
+  };
+  const tasks = session.tasks;
+  if (Array.isArray(tasks)) {
+    for (const t of tasks) {
+      add(t as TaskLike);
+    }
+  }
+  const activeTasks = session.activeTasks;
+  if (Array.isArray(activeTasks)) {
+    for (const t of activeTasks) {
+      add(t as TaskLike);
+    }
+  }
+  add(session.activeTask as TaskLike | null | undefined);
+  return [...byId.values()];
+}
+
+function dedupeSearchItemsById(items: DashboardSearchItem[]): DashboardSearchItem[] {
+  const seen = new Set<string>();
+  return items.filter((it) => {
+    if (seen.has(it.id)) {
+      return false;
+    }
+    seen.add(it.id);
+    return true;
+  });
+}
+
+/**
+ * Entrées pour la palette Ctrl+K : sessions (historique + archives) et tâches de la session affichée au centre.
+ */
+export function buildDashboardQuickSearchItems(opts: {
+  history: SessionListEntry[];
+  historyArchived: SessionListEntry[];
+  sessionCurrent: Record<string, unknown> | null | undefined;
+  dt: DashboardStrings;
+  /** Session live (pour l’état actif / pause dans les résultats). */
+  liveSearchContext?: SearchLiveContext | null;
+  onSelectSession: (sessionId: string) => void | Promise<void>;
+  scrollToSession: (sessionId: string) => void;
+  focusTasksColumn: () => void;
+  scrollToTask: (taskId: string) => void;
+}): DashboardSearchItem[] {
+  const { history, historyArchived, sessionCurrent, dt, liveSearchContext, onSelectSession, scrollToSession, focusTasksColumn, scrollToTask } =
+    opts;
+  const items: DashboardSearchItem[] = [];
+  const seenSid = new Set<string>();
+
+  const pushSession = (s: SessionListEntry) => {
+    const id = typeof s.sessionId === "string" ? s.sessionId.trim() : "";
+    if (!id || seenSid.has(id)) {
+      return;
+    }
+    seenSid.add(id);
+    const label = s.sessionName?.trim() || id.slice(0, 8);
+    const tasks = collectTasksFromSessionShape(s as unknown as Record<string, unknown>);
+    const hayFrags: string[] = [];
+    const metaDedup: string[] = [];
+    const seenMeta = new Set<string>();
+    for (const t of tasks) {
+      const rawName = typeof t.name === "string" ? t.name : "";
+      const idx = buildTaskSearchIndex(rawName, t.tags, t.project);
+      hayFrags.push(idx.haystackFragment);
+      if (idx.metaLine) {
+        for (const part of idx.metaLine.split(" · ")) {
+          const p = part.trim();
+          if (!p) {
+            continue;
+          }
+          const k = p.toLowerCase();
+          if (seenMeta.has(k)) {
+            continue;
+          }
+          seenMeta.add(k);
+          metaDedup.push(p);
+        }
+      }
+    }
+    const sessionMeta = metaDedup.length > 0 ? truncateMetaLine(metaDedup.join(" · "), 140) : "";
+    const rec = s as unknown as Record<string, unknown>;
+    const sessionDateHay = dateHayFromFields(
+      readOptionalIsoString(rec.savedAt),
+      readOptionalIsoString(rec.startAt),
+      readOptionalIsoString(rec.endAt)
+    );
+    const taskTimeHayFrags: string[] = [];
+    for (const t of tasks) {
+      taskTimeHayFrags.push(
+        dateHayFromFields(
+          readOptionalIsoString(t.startTime),
+          readOptionalIsoString(t.endTime)
+        )
+      );
+    }
+    const sti = sessionSearchTimerInfo(s, liveSearchContext, dt);
+    const hay = `${label} ${id} ${hayFrags.join(" ")} ${sessionDateHay} ${taskTimeHayFrags.join(" ")} ${sti.hayFragment}`
+      .trim()
+      .toLowerCase();
+    const sessionDurSec = sessionWallSecondsForSearch(s, tasks);
+    items.push({
+      id: `search-session-${id}`,
+      title: label,
+      subtitle: dt.dataSearchKindSession,
+      metaLine: sessionMeta || undefined,
+      searchTimerLine: sti.line,
+      searchTimerState: sti.state,
+      haystack: hay,
+      durationForSearchSec: sessionDurSec,
+      onSelect: () => {
+        void onSelectSession(id);
+        scrollToSession(id);
+      },
+    });
+  };
+
+  for (const s of history) {
+    pushSession(s);
+  }
+  for (const s of historyArchived) {
+    pushSession(s);
+  }
+
+  const sessionDateHayForTaskRows = sessionCurrent
+    ? dateHayFromFields(
+        readOptionalIsoString(sessionCurrent.savedAt),
+        readOptionalIsoString(sessionCurrent.startAt),
+        readOptionalIsoString(sessionCurrent.endAt)
+      )
+    : "";
+
+  const pendingTasks: {
+    id: string;
+    titleKey: string;
+    hay: string;
+    idx: ReturnType<typeof buildTaskSearchIndex>;
+    durationSec: number | undefined;
+    timerInfo: ReturnType<typeof buildTaskSearchTimerLine>;
+  }[] = [];
+  for (const t of collectTasksFromSessionShape(sessionCurrent)) {
+    const id =
+      typeof t.id === "string" && t.id.trim() ? t.id : "";
+    if (!id) {
+      continue;
+    }
+    const rawName = typeof t.name === "string" ? t.name : "";
+    const display = taskTitleForDisplay(rawName);
+    const idx = buildTaskSearchIndex(rawName, t.tags, t.project);
+    const titleKey = (display || id.slice(0, 8)).trim() || id.slice(0, 8);
+    const taskTimeHay = dateHayFromFields(
+      readOptionalIsoString(t.startTime),
+      readOptionalIsoString(t.endTime)
+    );
+    const timerInfo = buildTaskSearchTimerLine(t, dt);
+    const hay = `${rawName} ${display} ${id} ${idx.haystackFragment} ${sessionDateHayForTaskRows} ${taskTimeHay} ${timerInfo.hayFragment}`
+      .trim()
+      .toLowerCase();
+    pendingTasks.push({
+      id,
+      titleKey,
+      hay,
+      idx,
+      durationSec: taskDurationSecondsFromRecord(t),
+      timerInfo,
+    });
+  }
+  const titleKeyCount = new Map<string, number>();
+  for (const p of pendingTasks) {
+    titleKeyCount.set(p.titleKey, (titleKeyCount.get(p.titleKey) ?? 0) + 1);
+  }
+  for (const p of pendingTasks) {
+    const duplicateTitle = (titleKeyCount.get(p.titleKey) ?? 0) > 1;
+    const idKey = taskIdDedupKey(p.id);
+    const idPart = dt.dataSearchTaskDistinguishId.replace("{id}", idKey);
+    let metaLine: string | undefined;
+    if (duplicateTitle) {
+      const tagLine = p.idx.metaLine.trim();
+      metaLine = tagLine ? `${idPart} · ${truncateMetaLine(tagLine, 120)}` : idPart;
+    } else {
+      metaLine = p.idx.metaLine.trim() ? truncateMetaLine(p.idx.metaLine, 160) : undefined;
+    }
+    const taskIdForDom = p.id;
+    items.push({
+      id: `search-task-${idKey}`,
+      title: p.titleKey,
+      subtitle: dt.dataSearchKindTask,
+      metaLine,
+      searchTimerLine: p.timerInfo.line,
+      searchTimerState: p.timerInfo.state,
+      haystack: p.hay,
+      durationForSearchSec: p.durationSec,
+      onSelect: () => {
+        focusTasksColumn();
+        globalThis.requestAnimationFrame(() => scrollToTask(taskIdForDom));
+      },
+    });
+  }
+
+  return dedupeSearchItemsById(items);
+}

package/lib/dashboardQuickSearchQuery.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import {
+  dataSearchItemMatches,
+  parseDataSearchQuery,
+} from "@/lib/dashboardQuickSearchQuery";
+import type { DashboardSearchItem } from "@/lib/dashboardQuickSearch";
+
+function item(hay: string, dur?: number): DashboardSearchItem {
+  return {
+    id: "x",
+    title: "t",
+    haystack: hay,
+    durationForSearchSec: dur,
+    onSelect: () => {},
+  };
+}
+
+describe("parseDataSearchQuery", () => {
+  it("extrait mm:ss et opérateur (après le temps)", () => {
+    const r = parseDataSearchQuery("  44:33 >  ");
+    expect(r.textPart).toBe("");
+    expect(r.durationPredicates).toEqual([{ op: "gt", seconds: 44 * 60 + 33 }]);
+  });
+
+  it("extrait et laisse du texte", () => {
+    const r = parseDataSearchQuery("bug 12:55 <");
+    expect(r.textPart).toBe("bug");
+    expect(r.durationPredicates).toEqual([{ op: "lt", seconds: 12 * 60 + 55 }]);
+  });
+
+  it("heure pleine h:m:s", () => {
+    const r = parseDataSearchQuery("1:0:0 >");
+    expect(r.durationPredicates).toEqual([{ op: "gt", seconds: 3600 }]);
+  });
+
+  it("opérateur avant le temps", () => {
+    const r = parseDataSearchQuery("> 0:10");
+    expect(r.textPart).toBe("");
+    expect(r.durationPredicates).toEqual([{ op: "gt", seconds: 10 }]);
+  });
+});
+
+describe("dataSearchItemMatches", () => {
+  it("filtre par durée seule", () => {
+    const under = item("x", 40);
+    const over = item("x", 90);
+    expect(dataSearchItemMatches(under, "1:0 <")).toBe(true);
+    expect(dataSearchItemMatches(over, "1:0 <")).toBe(false);
+  });
+
+  it("sans durée enregistrée : échec si prédicat temporel", () => {
+    expect(dataSearchItemMatches(item("hello", undefined), "0:1 >")).toBe(false);
+  });
+
+  it("texte + durée", () => {
+    const good = item("alpha #tag", 4000);
+    const badText = item("beta", 4000);
+    const badDur = item("alpha", 10);
+    expect(dataSearchItemMatches(good, "alpha 1:0:0 >")).toBe(true);
+    expect(dataSearchItemMatches(badText, "alpha 1:0:0 >")).toBe(false);
+    expect(dataSearchItemMatches(badDur, "alpha 1:0:0 >")).toBe(false);
+  });
+});