{#if isMac}
+ {@render betterStatsBtn()}
{@render statsBtn()}
{@render settingsBtn()}
{:else}
diff --git a/src/lib/components/better-stats/ConsistencySection.svelte b/src/lib/components/better-stats/ConsistencySection.svelte
new file mode 100644
index 00000000..3440e8b9
--- /dev/null
+++ b/src/lib/components/better-stats/ConsistencySection.svelte
@@ -0,0 +1,183 @@
+
+
+
+
+
+
+
{m.better_consistency_title()}
+
+
+
+
+
+
+
+
+
+
+
+ {m.better_length_title()}
+ {#if totalBucketRounds > 0}
+ {m.better_no_data()}
+ {/if}
+
+
+
+
diff --git a/src/lib/components/better-stats/HeroSection.svelte b/src/lib/components/better-stats/HeroSection.svelte
new file mode 100644
index 00000000..1cdb7e1a
--- /dev/null
+++ b/src/lib/components/better-stats/HeroSection.svelte
@@ -0,0 +1,379 @@
+
+
+
+
+
+
+ {m.better_momentum_today()}
+ {insights.today}
+
+
+
+
+
+
+ {fmtMins(insights.today_focus_mins)}
+ {m.better_focus_time().toLowerCase()}
+
+
+ {#if baseline === null || roundsBehind === null}
+ {m.better_no_average()}
+ {:else if roundsBehind > 1}
+ {m.better_behind_average({ n: roundsBehind })}
+ {:else if roundsBehind === 1}
+ {m.better_behind_average_one({ n: 1 })}
+ {:else if roundsBehind === 0}
+ {m.better_average_matched()}
+ {:else}
+ {m.better_ahead_of_average()}
+ {/if}
+
+
+ {#if baseline !== null}
+
+ {m.better_avg_per_active_day()}: {fmtAvg(baseline ?? 0)}
+
+ {/if}
+
+
+
+
+
+
+
+ {m.better_section_momentum()}
+ {m.better_delta_vs_prev()}
+
+
+
+
+ {insights.streak.current}
+ {streakLabel}
+
+
+ {m.better_records_streak()}
+ {#if insights.streak.at_risk}
+ {m.better_streak_at_risk()}
+ {:else}
+
+ {m.better_records_longest()}: {insights.streak.longest}
+
+ {/if}
+
+
+
+
+ {#each comparisons as c (c.label)}
+ {@const label = (LABEL_KEYS[c.label] ?? (() => c.label))()}
+ {@const tone = c.delta_pct === null ? '' : c.delta_pct > 0 ? 'up' : c.delta_pct < 0 ? 'down' : ''}
+
+ {label}
+
+ {fmtComparison(c.label, c.current)}
+ / {fmtComparison(c.label, c.previous)}
+
+
+ {fmtDelta(c.delta_pct)}
+
+
+ {/each}
+
+
+
+
+
+
+
+
diff --git a/src/lib/components/better-stats/MetaTile.svelte b/src/lib/components/better-stats/MetaTile.svelte
new file mode 100644
index 00000000..5368ca14
--- /dev/null
+++ b/src/lib/components/better-stats/MetaTile.svelte
@@ -0,0 +1,72 @@
+
+
+
+ {label}
+
+ {value}
+
+ {#if sub}
+ {sub}
+ {/if}
+
+
+
diff --git a/src/lib/components/better-stats/MomentumCharts.svelte b/src/lib/components/better-stats/MomentumCharts.svelte
new file mode 100644
index 00000000..9ddc4176
--- /dev/null
+++ b/src/lib/components/better-stats/MomentumCharts.svelte
@@ -0,0 +1,205 @@
+
+
+
+ {#snippet headerExtra()}
+
+ (mode = 'days')}
+ >{m.better_view_days()}
+ (mode = 'weeks')}
+ >{m.better_view_weeks()}
+
+ {/snippet}
+
+
+ {totalRounds} {m.better_rounds().toLowerCase()}·
+ {fmtMins(totalFocus)} {m.better_focus_time().toLowerCase()}·
+ {activeCount} /{points.length} {m.better_active_days().toLowerCase()}·
+ {m.better_consistency_avg()}: {fmtAvg(totalRounds / Math.max(1, points.length))}
+ {#if best && best.rounds > 0}
+
+ {m.better_best_day()}: {label(best)} ({best.rounds})
+
+ {/if}
+
+
+
+
+ {m.better_focus_per_week()}
+ w.rounds)}
+ secondaryUnit={m.better_rounds().toLowerCase()}
+ color="var(--color-long-round)"
+ highlightMax
+ labelEvery={2}
+ height={90}
+ />
+
+
+
+ {m.better_rounds_per_week()}
+ w.rounds)}
+ labels={weekLabels}
+ unit={m.better_rounds().toLowerCase()}
+ secondary={insights.weeks.map((w) => w.focus_mins)}
+ secondaryUnit="min"
+ color="var(--color-focus-round)"
+ highlightMax
+ labelEvery={2}
+ height={90}
+ />
+
+
+
+
diff --git a/src/lib/components/better-stats/RecordsSection.svelte b/src/lib/components/better-stats/RecordsSection.svelte
new file mode 100644
index 00000000..d00ab165
--- /dev/null
+++ b/src/lib/components/better-stats/RecordsSection.svelte
@@ -0,0 +1,69 @@
+
+
+
+
+
+
+
+
diff --git a/src/lib/components/better-stats/RhythmSection.svelte b/src/lib/components/better-stats/RhythmSection.svelte
new file mode 100644
index 00000000..511c1615
--- /dev/null
+++ b/src/lib/components/better-stats/RhythmSection.svelte
@@ -0,0 +1,105 @@
+
+
+
+ {#if hasData}
+
+
+ {m.better_weekday_title()}
+
+
+
+ {m.better_hour_title()}
+ {#if hourRows.length}
+ {m.better_no_data()}
+ {/if}
+
+
{m.better_no_data()}
+ {/if}
+
+
+
diff --git a/src/lib/components/better-stats/SectionBlock.svelte b/src/lib/components/better-stats/SectionBlock.svelte
new file mode 100644
index 00000000..4a4e3259
--- /dev/null
+++ b/src/lib/components/better-stats/SectionBlock.svelte
@@ -0,0 +1,55 @@
+
+
+
+
+ {title}
+ {#if headerExtra}
+ {@render headerExtra()}
+ {:else if hint}
+ {hint}
+ {/if}
+
+ {@render children?.()}
+
+
+
diff --git a/src/lib/components/better-stats/charts/Donut.svelte b/src/lib/components/better-stats/charts/Donut.svelte
new file mode 100644
index 00000000..550bbc52
--- /dev/null
+++ b/src/lib/components/better-stats/charts/Donut.svelte
@@ -0,0 +1,183 @@
+
+
+
+
+
+
+ {seg.label}: {Math.round(seg.frac * 100)}%
+
+ {/each}
+
+
+ {centerValue}
+ {#if centerCaption}
+ {centerCaption}
+ {/if}
+
+
+
+
+ {#each slices as s (s.label)}
+
+ {s.label}
+ {total > 0 ? Math.round((s.value / total) * 100) : 0}%
+
+ {/each}
+
+
+
+
diff --git a/src/lib/components/better-stats/charts/FocusHeatmap.svelte b/src/lib/components/better-stats/charts/FocusHeatmap.svelte
new file mode 100644
index 00000000..a929a30b
--- /dev/null
+++ b/src/lib/components/better-stats/charts/FocusHeatmap.svelte
@@ -0,0 +1,738 @@
+
+
+
+
+
+
+
+ (scope = 'recent')}>{m.better_scope_recent()}
+ (scope = 'month')}>{m.better_scope_month()}
+ (scope = 'year')}>{m.better_scope_year()}
+
+
+ {#if scope !== 'recent'}
+
+ (scope === 'month' ? shiftMonth(-1) : (yearCursor -= 1))}
+ >
+ ‹
+
+
+ {scope === 'month' ? `${MONTHS[monthCursor.month - 1]} ${monthCursor.year}` : yearCursor}
+
+ (scope === 'month' ? shiftMonth(1) : (yearCursor += 1))}
+ disabled={!canGoForward}
+ >
+ ›
+
+
+ {/if}
+
+
+
+ {m.stats_legend_less()}
+ {#each [0, 1, 2, 3, 4] as lvl}
+ {m.stats_legend_more()}
+
+
+
+
+ {totalRounds} {m.better_rounds().toLowerCase()}·
+ {fmtMins(totalFocus)} {m.better_focus_time().toLowerCase()}·
+ {activeDays} /{activePoints.length} {m.better_active_days().toLowerCase()}·
+ {m.better_no_data()}
+ {/if}
+
+
+
+ {#if scope === 'month'}
+
+
+ {#each ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'] as w}
+ {w}
+ {/each}
+
+ {#each Array(Math.ceil((weekdayOf(monthDays[0]?.date ?? today) + monthDays.length) / 7)) as _, week}
+
+ {#each Array(7) as _, wd}
+ {@const idx = week * 7 + wd - weekdayOf(monthDays[0]?.date ?? today)}
+ {#if idx >= 0 && idx < monthDays.length}
+ {@const p = monthDays[idx]}
+ (hovered = p)}
+ onfocus={() => (hovered = p)}
+ onblur={() => (hovered = null)}
+ >
+ {Number(p.date.slice(8, 10))}
+ {#if p.rounds > 0}
+ {p.rounds}
+ {/if}
+
+ {:else}
+
+ {/each}
+
+
+
+ {:else}
+
+
+ {#each WEEKDAY_LABELS as w}
+ {w}
+ {/each}
+
+
+
(hovered = null)}>
+ {#each scrollColumns as col, ci (ci)}
+
+ {#each Array(col.lead) as _}
+ (hovered = p)}
+ onfocus={() => (hovered = p)}
+ onblur={() => (hovered = null)}
+ >
+ {/each}
+
+ {/each}
+
+
+ {#each markers as { col, label } (col)}
+ {label}
+ {/each}
+
+
+
+ {/if}
+
+
+ {#if hovered}
+ {fmtDay(hovered.date)}
+ {hovered.rounds} {m.better_rounds().toLowerCase()}{fmtMins(hovered.focus_mins)}
+ {:else}
+ {m.better_heatmap_hint()}
+ {/if}
+
+
+
+
diff --git a/src/lib/components/better-stats/charts/HBarList.svelte b/src/lib/components/better-stats/charts/HBarList.svelte
new file mode 100644
index 00000000..a6930a76
--- /dev/null
+++ b/src/lib/components/better-stats/charts/HBarList.svelte
@@ -0,0 +1,113 @@
+
+
+
+ {#each rows as row (row.label)}
+
+
+ {row.label}
+ {#if row.sub}
+ {row.sub}
+ {/if}
+
+
+
+ {row.display}
+
+ {/each}
+
+
+
diff --git a/src/lib/components/better-stats/charts/MiniBars.svelte b/src/lib/components/better-stats/charts/MiniBars.svelte
new file mode 100644
index 00000000..5ce0730c
--- /dev/null
+++ b/src/lib/components/better-stats/charts/MiniBars.svelte
@@ -0,0 +1,184 @@
+
+
+
(hovered = null)}
+>
+ {#each values as v, i (i)}
+ {@const pct = (v / max) * 100}
+
(hovered = i)}
+ onfocus={() => (hovered = i)}
+ onblur={() => (hovered = null)}
+ >
+ {#if hovered === i}
+
+ {labels[i] ?? i}
+ {v} {unit}{secondary[i]} {secondaryUnit}
+ {/if}
+
+ {/if}
+ 0}
+ class:active={hovered === i}
+ style="height: {Math.max(2, pct)}%; --bar-color: {color}"
+ >
+ {#if i % labelEvery === 0}
+ {labels[i] ?? ''}
+ {/if}
+
+ {/each}
+
+
+
diff --git a/src/lib/components/better-stats/charts/RhythmGrid.svelte b/src/lib/components/better-stats/charts/RhythmGrid.svelte
new file mode 100644
index 00000000..8dcc63c6
--- /dev/null
+++ b/src/lib/components/better-stats/charts/RhythmGrid.svelte
@@ -0,0 +1,244 @@
+
+
+
+
+ {m.better_grid_title()}
+ {#if peak && peak.rounds > 0}
+
+ {m.better_grid_peak()}:
+ {weekdayLabel(peak.weekday)} {hourLabel(peak.hour)}
+
+ {/if}
+
+
+
+
+
+
+
+
diff --git a/src/lib/components/better-stats/charts/Ring.svelte b/src/lib/components/better-stats/charts/Ring.svelte
new file mode 100644
index 00000000..7b8ce8e0
--- /dev/null
+++ b/src/lib/components/better-stats/charts/Ring.svelte
@@ -0,0 +1,112 @@
+
+
+
+
+
+
+
+ {display}
+ {#if caption}
+ {caption}
+ {/if}
+
+
+
+
diff --git a/src/lib/components/better-stats/charts/TrendChart.svelte b/src/lib/components/better-stats/charts/TrendChart.svelte
new file mode 100644
index 00000000..0e1ab01e
--- /dev/null
+++ b/src/lib/components/better-stats/charts/TrendChart.svelte
@@ -0,0 +1,300 @@
+
+
+
+
(hovered = null)}
+ onfocus={() => (hovered = points.length - 1)}
+ onblur={() => (hovered = null)}
+ tabindex="-1"
+ >
+
+
+
+
+
+
+ {#each [0.25, 0.5, 0.75] as g}
+
+
+
+
+ {#each points as p, i (p.date)}
+ {#if tickLabel(p, i)}
+ {tickLabel(p, i)}
+ {/if}
+ {/each}
+
+
+ {#if hoveredPoint}
+
+ {formatDate(hoveredPoint)}
+
+ {hoveredPoint.rounds} rounds
+
+
+ {hoveredAvg.toFixed(1)}
+
+ {/if}
+
+ {/if}
+
+
+
diff --git a/src/lib/components/settings/sections/TimerSection.svelte b/src/lib/components/settings/sections/TimerSection.svelte
index cd1e1891..97ee4f9c 100644
--- a/src/lib/components/settings/sections/TimerSection.svelte
+++ b/src/lib/components/settings/sections/TimerSection.svelte
@@ -1,6 +1,6 @@
@@ -309,6 +387,136 @@
checked={$settings.dial_countdown}
onclick={() => toggle('dial_countdown', $settings.dial_countdown)}
/>
+
+
+
toggle('incremental_work_enabled', $settings.incremental_work_enabled)}
+ />
+
+
+
+
+ {m.timer_slider_increment()}
+
+
+
+ handleChange(
+ 'time_work_increment_secs',
+ (e.target as HTMLInputElement).valueAsNumber * 60
+ )}
+ />
+
+
+
+
+
+
+
+ {m.timer_slider_increment_cap()}
+ {capMins}m
+
+
+
+ handleChange('time_work_max_secs', (e.target as HTMLInputElement).valueAsNumber * 60)}
+ />
+
+
+
+
+
+
+ toggle('incremental_reset_on_long_break', $settings.incremental_reset_on_long_break)}
+ />
+ toggle('incremental_reset_daily', $settings.incremental_reset_daily)}
+ />
+
+
+
+
{m.timer_increment_ladder()}
+
+ {#each ladder as mins, i (i)}
+ = 1 && mins === ladder[i - 1]}>
+ {mins}m
+
+ {#if i < ladder.length - 1}
+ ›
+ {/if}
+ {/each}
+ …
+
+
+ {ladderCapped ? m.timer_increment_capped() : ladderHint}
+
+
+
+ {m.timer_increment_reset_now()}
+
+ {ladderResetDone ? m.timer_increment_reset_done() : m.timer_increment_reset_now_desc()}
+
+
+ ↺
+
+
diff --git a/src/lib/dev/mockTauri.js b/src/lib/dev/mockTauri.js
new file mode 100644
index 00000000..784e15c7
--- /dev/null
+++ b/src/lib/dev/mockTauri.js
@@ -0,0 +1,838 @@
+// @ts-nocheck
+/**
+ * DEV-ONLY Tauri IPC mock.
+ *
+ * The real app talks to a Rust backend over Tauri's IPC bridge. When the
+ * frontend is served by plain `npm run dev` (a normal browser), that bridge
+ * does not exist, so every `invoke()` rejects and each window stays blank.
+ *
+ * This module installs a lightweight stand-in bridge so the UI can be reviewed
+ * in a browser: settings and themes come back with defaults, the stats
+ * commands return realistic generated history, and the timer runs for real
+ * (ticks, pauses, skips) so the incremental ladder can be seen climbing.
+ *
+ * It is injected ONLY by the dev server (see `tauriDevMockPlugin` in
+ * vite.config.js) and is never part of a production bundle. It is also a no-op
+ * whenever a genuine Tauri bridge is present.
+ */
+
+const isTauri = () => typeof window !== 'undefined' && '__TAURI_INTERNALS__' in window;
+const isMac = typeof navigator !== 'undefined' && /Mac/i.test(navigator.userAgent || '');
+
+/** Present only in the `tauri dev` shell; harmless elsewhere. */
+export const MOCK_ACTIVE = !isTauri();
+
+// ---------------------------------------------------------------------------
+// Settings
+// ---------------------------------------------------------------------------
+
+const settings = {
+ time_work_secs: 300, // 5 min base — makes the increment easy to watch
+ time_short_break_secs: 300,
+ time_long_break_secs: 900,
+ incremental_work_enabled: true,
+ time_work_increment_secs: 300, // +5 min per completed work round
+ time_work_max_secs: 1200, // capped at 20 min
+ incremental_reset_on_long_break: true,
+ incremental_reset_daily: true,
+ long_break_interval: 4,
+ short_breaks_enabled: true,
+ long_breaks_enabled: true,
+ auto_start_work: false,
+ auto_start_break: false,
+ tray_icon_enabled: false,
+ min_to_tray: false,
+ min_to_tray_on_close: false,
+ notifications_enabled: false,
+ always_on_top: false,
+ break_always_on_top: false,
+ volume: 1.0,
+ tick_sounds_during_work: false,
+ tick_sounds_during_break: false,
+ shortcut_toggle: 'Control+F1',
+ shortcut_reset: 'Control+F2',
+ shortcut_skip: 'Control+F3',
+ shortcut_restart: 'Control+F4',
+ websocket_enabled: false,
+ websocket_port: 1314,
+ theme_mode: 'auto',
+ theme_light: 'Pomotroid Light',
+ theme_dark: 'Pomotroid',
+ dial_countdown: true,
+ language: 'en',
+ verbose_logging: false,
+ check_for_updates: false,
+ global_shortcuts_enabled: false,
+ local_shortcut_toggle: ' ',
+ local_shortcut_reset: 'ArrowLeft',
+ local_shortcut_skip: 'ArrowRight',
+ local_shortcut_volume_down: 'ArrowDown',
+ local_shortcut_volume_up: 'ArrowUp',
+ local_shortcut_mute: 'm',
+ local_shortcut_fullscreen: 'F11',
+};
+
+const themes = [
+ {
+ name: 'Pomotroid',
+ is_custom: false,
+ colors: {
+ '--color-background': '#2f384b',
+ '--color-foreground': '#f2f4f8',
+ '--color-foreground-darker': '#96a0b5',
+ '--color-separator': 'rgba(242, 244, 248, 0.12)',
+ '--color-hover': 'rgba(242, 244, 248, 0.08)',
+ '--color-focus-round': '#e9573f',
+ '--color-short-round': '#4fbf8b',
+ '--color-long-round': '#5b8def',
+ },
+ },
+ {
+ name: 'Pomotroid Light',
+ is_custom: false,
+ colors: {
+ '--color-background': '#f6f6f8',
+ '--color-foreground': '#1f2733',
+ '--color-foreground-darker': '#7b8798',
+ '--color-separator': 'rgba(31, 39, 51, 0.12)',
+ '--color-hover': 'rgba(31, 39, 51, 0.06)',
+ '--color-focus-round': '#d9452c',
+ '--color-short-round': '#2f9e6b',
+ '--color-long-round': '#3f6fd0',
+ },
+ },
+];
+
+// ---------------------------------------------------------------------------
+// Deterministic mock history
+// ---------------------------------------------------------------------------
+
+/** Local "YYYY-MM-DD" for a Date. */
+function ymd(d) {
+ const p = (n) => String(n).padStart(2, '0');
+ return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+
+/** Days between two "YYYY-MM-DD" strings. */
+function dayDiff(a, b) {
+ const [ay, am, ad] = a.split('-').map(Number);
+ const [by, bm, bd] = b.split('-').map(Number);
+ const da = Date.UTC(ay, am - 1, ad);
+ const db = Date.UTC(by, bm - 1, bd);
+ return Math.round((db - da) / 86400000);
+}
+
+function addDays(dateStr, n) {
+ const [y, m, d] = dateStr.split('-').map(Number);
+ const dt = new Date(Date.UTC(y, m - 1, d));
+ dt.setUTCDate(dt.getUTCDate() + n);
+ return `${dt.getUTCFullYear()}-${String(dt.getUTCMonth() + 1).padStart(2, '0')}-${String(
+ dt.getUTCDate()
+ ).padStart(2, '0')}`;
+}
+
+function weekdayIndex(dateStr) {
+ const [y, m, d] = dateStr.split('-').map(Number);
+ const dow = new Date(Date.UTC(y, m - 1, d)).getUTCDay(); // 0 = Sunday
+ return (dow + 6) % 7; // 0 = Monday
+}
+
+/** Stable pseudo-random in [0,1) derived from a date string. */
+function hash01(str) {
+ let h = 2166136261;
+ for (let i = 0; i < str.length; i += 1) {
+ h ^= str.charCodeAt(i);
+ h = Math.imul(h, 16777619);
+ }
+ return ((h >>> 0) % 10000) / 10000;
+}
+
+/** Plausible rounds for a given day: weekends are quieter, some days empty. */
+function roundsForDate(date, today) {
+ const age = dayDiff(date, today);
+ const wd = weekdayIndex(date);
+ const r = hash01(date);
+ if (wd >= 5) {
+ if (r < 0.55) return 0;
+ return 1 + Math.floor(r * 3);
+ }
+ if (r < 0.12) return 0;
+ const base = 3 + Math.floor(r * 7);
+ // Slight upward drift as the history gets more recent.
+ return Math.max(1, base + (age < 7 ? 1 : 0));
+}
+
+/** Mean of the trailing `window` values at each index (partial windows ramp up). */
+function movingAverage(points, window) {
+ return points.map((_, i) => {
+ const start = Math.max(0, i + 1 - window);
+ const slice = points.slice(start, i + 1);
+ return slice.reduce((s, p) => s + p.rounds, 0) / slice.length;
+ });
+}
+
+/** Histogram of round lengths, mirroring the Rust bucketing. */
+const BUCKET_BOUNDS = [
+ [0, 15],
+ [15, 25],
+ [25, 40],
+ [40, 60],
+ [60, null],
+];
+
+/** Build a full Insights payload mirroring the Rust `stats_get_insights` shape. */
+function buildInsights() {
+ const today = ymd(new Date());
+ const dayMap = new Map();
+
+ // ~200 days of history so the 120-day heatmap and 12-week rollup fill up.
+ for (let age = 200; age >= 0; age -= 1) {
+ const date = addDays(today, -age);
+ const rounds = roundsForDate(date, today);
+ if (rounds === 0) continue;
+ dayMap.set(date, { rounds, focus_mins: rounds * (20 + Math.floor(hash01(date + 'f') * 12)) });
+ }
+ // Guarantee some activity today.
+ dayMap.set(today, { rounds: 3, focus_mins: 75 });
+
+ const perDay = [...dayMap.entries()]
+ .map(([date, v]) => ({ date, ...v }))
+ .sort((a, b) => (a.date < b.date ? -1 : 1));
+
+ const todayByHour = Array(24).fill(0);
+ todayByHour[9] = 1;
+ todayByHour[14] = 1;
+ todayByHour[16] = 1;
+
+ const inWindow = (date, start, end) => date >= start && date <= end;
+
+ const summarise = (label, start, days) => {
+ const rows = perDay.filter((p) => inWindow(p.date, start, today));
+ const rounds = rows.reduce((s, p) => s + p.rounds, 0);
+ const focus_mins = rows.reduce((s, p) => s + p.focus_mins, 0);
+ const active_days = rows.length;
+ const best = rows.reduce((b, p) => (!b || p.rounds > b.rounds ? p : b), null);
+ // Started rounds are approximated as completed plus a small abandonment rate.
+ const started = Math.round(rounds * 1.14);
+ return {
+ label,
+ days,
+ rounds,
+ focus_mins,
+ active_days,
+ avg_rounds_per_active_day: active_days ? rounds / active_days : null,
+ avg_focus_mins_per_active_day: active_days ? focus_mins / active_days : null,
+ completion_rate: started ? rounds / started : null,
+ best_day: best ? { ...best } : null,
+ };
+ };
+
+ const fillDays = (count) => {
+ const out = [];
+ for (let age = count - 1; age >= 0; age -= 1) {
+ const date = addDays(today, -age);
+ const v = dayMap.get(date);
+ out.push({ date, rounds: v?.rounds ?? 0, focus_mins: v?.focus_mins ?? 0 });
+ }
+ return out;
+ };
+
+ const trend = fillDays(28);
+ const heatmap = fillDays(120);
+
+ const weeks = [];
+ const currentMonday = addDays(today, -weekdayIndex(today));
+ for (let w = 11; w >= 0; w -= 1) {
+ const start = addDays(currentMonday, -w * 7);
+ const end = addDays(start, 6);
+ const rows = perDay.filter((p) => inWindow(p.date, start, end));
+ weeks.push({
+ date: start,
+ rounds: rows.reduce((s, p) => s + p.rounds, 0),
+ focus_mins: rows.reduce((s, p) => s + p.focus_mins, 0),
+ });
+ }
+
+ // --- Rhythm ---------------------------------------------------------------
+ const hour_profile = Array.from({ length: 24 }, (_, hour) => ({ hour, rounds: 0, focus_mins: 0 }));
+ const grid = Array.from({ length: 7 * 24 }, (_, i) => ({
+ weekday: Math.floor(i / 24),
+ hour: i % 24,
+ rounds: 0,
+ focus_mins: 0,
+ }));
+
+ perDay.forEach((p, i) => {
+ const wd = weekdayIndex(p.date);
+ // Two focus blocks per active day: a morning one and an afternoon one.
+ const morning = 8 + (i % 3);
+ const afternoon = 13 + (i % 5);
+ const morningRounds = Math.ceil(p.rounds / 2);
+ const afternoonRounds = p.rounds - morningRounds;
+
+ for (const [hour, rounds] of [
+ [morning, morningRounds],
+ [afternoon, afternoonRounds],
+ ]) {
+ if (rounds <= 0) continue;
+ const mins = Math.round((p.focus_mins * rounds) / p.rounds);
+ hour_profile[hour].rounds += rounds;
+ hour_profile[hour].focus_mins += mins;
+ const cell = grid[wd * 24 + hour];
+ cell.rounds += rounds;
+ cell.focus_mins += mins;
+ }
+ });
+
+ const weekday_profile = Array.from({ length: 7 }, (_, weekday) => ({
+ weekday,
+ rounds: 0,
+ focus_mins: 0,
+ }));
+ perDay.forEach((p) => {
+ const idx = weekdayIndex(p.date);
+ weekday_profile[idx].rounds += p.rounds;
+ weekday_profile[idx].focus_mins += p.focus_mins;
+ });
+
+ const activeHours = hour_profile.filter((h) => h.rounds > 0).map((h) => h.hour);
+
+ // --- Streak ---------------------------------------------------------------
+ let current = 0;
+ for (let age = 0; age < 400; age += 1) {
+ if (!dayMap.has(addDays(today, -age))) {
+ if (age === 0) continue; // today may simply not be logged yet
+ break;
+ }
+ current += 1;
+ }
+ let longest = 1;
+ let run = 1;
+ for (let i = 1; i < perDay.length; i += 1) {
+ if (dayDiff(perDay[i - 1].date, perDay[i].date) === 1) {
+ run += 1;
+ longest = Math.max(longest, run);
+ } else {
+ run = 1;
+ }
+ }
+
+ // --- Consistency (trailing 30 days) --------------------------------------
+ const last30 = fillDays(30);
+ const active30 = last30.filter((p) => p.rounds > 0);
+ const total30 = last30.reduce((s, p) => s + p.rounds, 0);
+ const mean30 = total30 / last30.length;
+ const variance = last30.reduce((s, p) => s + (p.rounds - mean30) ** 2, 0) / last30.length;
+ const best30 = Math.max(0, ...last30.map((p) => p.rounds));
+ let bestStreak30 = 0;
+ let run30 = 0;
+ for (const p of last30) {
+ run30 = p.rounds > 0 ? run30 + 1 : 0;
+ bestStreak30 = Math.max(bestStreak30, run30);
+ }
+
+ // --- Records --------------------------------------------------------------
+ const total_rounds = perDay.reduce((s, p) => s + p.rounds, 0);
+ const total_focus_mins = perDay.reduce((s, p) => s + p.focus_mins, 0);
+ const bestDayRounds = perDay.reduce((b, p) => (!b || p.rounds > b.rounds ? p : b), null);
+ const bestDayFocus = perDay.reduce((b, p) => (!b || p.focus_mins > b.focus_mins ? p : b), null);
+ const bestWeek = weeks.reduce((b, p) => (!b || p.focus_mins > b.focus_mins ? p : b), null);
+
+ // --- Session-length histogram --------------------------------------------
+ const session_buckets = BUCKET_BOUNDS.map(([min, max]) => ({
+ min_mins: min,
+ max_mins: max,
+ rounds: 0,
+ focus_mins: 0,
+ }));
+ perDay.forEach((p, i) => {
+ // Spread each day's rounds across a plausible mix of round lengths.
+ const lengths = [12, 18, 24, 30, 45, 62];
+ for (let r = 0; r < p.rounds; r += 1) {
+ const mins = 5 + lengths[(i + r) % lengths.length];
+ const bucket = session_buckets.find((b) =>
+ b.max_mins === null ? mins >= b.min_mins : mins >= b.min_mins && mins < b.max_mins
+ );
+ if (bucket) {
+ bucket.rounds += 1;
+ bucket.focus_mins += mins;
+ }
+ }
+ });
+
+ // --- Momentum -------------------------------------------------------------
+ const week = summarise('week', addDays(today, -6), 7);
+ const month = summarise('month', addDays(today, -27), 28);
+ const last_7_days = summarise('last7', addDays(today, -6), 7);
+ const last_90_days = summarise('last90', addDays(today, -89), 90);
+ const previous_7_days = summarise('prev7', addDays(today, -13), 7);
+
+ const todayRounds = dayMap.get(today)?.rounds ?? 0;
+
+ const pctChange = (cur, prev) => (prev > 0 ? (cur - prev) / prev : null);
+
+ const comparisons = [
+ {
+ label: 'rounds_week',
+ current: last_7_days.rounds,
+ previous: previous_7_days.rounds,
+ delta_pct: pctChange(last_7_days.rounds, previous_7_days.rounds),
+ },
+ {
+ label: 'focus_week',
+ current: last_7_days.focus_mins,
+ previous: previous_7_days.focus_mins,
+ delta_pct: pctChange(last_7_days.focus_mins, previous_7_days.focus_mins),
+ },
+ {
+ label: 'active_days_week',
+ current: last_7_days.active_days,
+ previous: previous_7_days.active_days,
+ delta_pct: pctChange(last_7_days.active_days, previous_7_days.active_days),
+ },
+ {
+ label: 'avg_per_active_day',
+ current: last_7_days.avg_rounds_per_active_day ?? 0,
+ previous: previous_7_days.avg_rounds_per_active_day ?? 0,
+ delta_pct: pctChange(
+ last_7_days.avg_rounds_per_active_day ?? 0,
+ previous_7_days.avg_rounds_per_active_day ?? 0
+ ),
+ },
+ ];
+
+ const topHourMins = Math.max(...hour_profile.map((h) => h.focus_mins));
+ const topHourTotal = hour_profile.reduce((s, h) => s + h.focus_mins, 0);
+ const topWeekdayMins = Math.max(...weekday_profile.map((w) => w.focus_mins));
+ const topWeekdayTotal = weekday_profile.reduce((s, w) => s + w.focus_mins, 0);
+
+ return {
+ today,
+ today_rounds: todayRounds,
+ today_focus_mins: dayMap.get(today)?.focus_mins ?? 0,
+ today_by_hour: todayByHour,
+ rounds_to_beat_average:
+ week.avg_rounds_per_active_day === null
+ ? null
+ : Math.round(week.avg_rounds_per_active_day) - todayRounds,
+ ahead_of_average: todayRounds > (week.avg_rounds_per_active_day ?? 0),
+
+ week,
+ month,
+ last_7_days,
+ last_90_days,
+ previous_7_days,
+ comparisons,
+
+ trend,
+ heatmap,
+ daily_all: perDay.map((p) => ({ ...p })),
+ weeks,
+ moving_avg_7: movingAverage(trend, 7),
+ focus_trend: trend.map((p) => ({ ...p })),
+ daily_28: trend,
+
+ hour_profile,
+ weekday_profile,
+ rhythm_grid: grid,
+ active_from_hour: activeHours.length ? Math.min(...activeHours) : null,
+ active_to_hour: activeHours.length ? Math.max(...activeHours) : null,
+
+ session_buckets,
+ top_weekday_share: topWeekdayTotal ? topWeekdayMins / topWeekdayTotal : null,
+ top_hour_share: topHourTotal ? topHourMins / topHourTotal : null,
+
+ consistency: {
+ window_days: 30,
+ active_days: active30.length,
+ active_ratio: active30.length / 30,
+ avg_rounds_per_day: mean30,
+ avg_focus_mins_per_day:
+ last30.reduce((s, p) => s + p.focus_mins, 0) / last30.length,
+ stddev_rounds: Math.sqrt(variance),
+ strong_days: last30.filter((p) => p.rounds >= Math.ceil(best30 * 0.75) && best30 > 0).length,
+ light_days: last30.filter((p) => p.rounds > 0 && p.rounds <= Math.floor(best30 * 0.25))
+ .length,
+ rest_days: last30.filter((p) => p.rounds === 0).length,
+ best_streak_in_window: bestStreak30,
+ },
+
+ records: {
+ total_rounds,
+ total_focus_mins,
+ tracked_days: perDay.length,
+ avg_session_mins: total_rounds ? total_focus_mins / total_rounds : null,
+ longest_session_mins: Math.max(...session_buckets.map((b) => b.max_mins ?? b.min_mins)),
+ avg_rounds_per_active_day: perDay.length ? total_rounds / perDay.length : null,
+ best_day_rounds: bestDayRounds,
+ best_day_focus: bestDayFocus,
+ best_week: bestWeek,
+ },
+
+ streak: {
+ current,
+ longest,
+ last_active_date: perDay.length ? perDay[perDay.length - 1].date : null,
+ at_risk: current > 0 && todayRounds === 0,
+ },
+ };
+}
+
+// ---------------------------------------------------------------------------
+// Mock timer engine
+// ---------------------------------------------------------------------------
+
+const MOCK_ROUNDS_TOTAL = settings.long_break_interval;
+
+/** Local calendar date as "YYYY-MM-DD" (mirrors SQLite's date('now','localtime')). */
+function todayKey() {
+ const d = new Date();
+ const pad = (n) => String(n).padStart(2, '0');
+ return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+
+const timer = {
+ round_type: 'work',
+ previous_round_type: '',
+ elapsed_secs: 0,
+ is_running: false,
+ work_round_number: 1,
+ session_work_count: 1,
+ work_rounds_completed: 0,
+ ladder_day: todayKey(),
+ _interval: null,
+};
+
+/**
+ * Mirror of `SequenceState::check_day_rollover`: a new calendar day restarts the
+ * ladder unless the daily reset trigger is turned off.
+ */
+function checkDayRollover() {
+ const today = todayKey();
+ if (timer.ladder_day === today) return false;
+ const hadDay = timer.ladder_day !== null;
+ timer.ladder_day = today;
+ if (!hadDay || !settings.incremental_reset_daily) return false;
+ const changed = timer.work_rounds_completed !== 0;
+ timer.work_rounds_completed = 0;
+ return changed;
+}
+
+/**
+ * Mirror of the Rust `SequenceState::work_duration_secs` ladder so the mock
+ * shows the same escalating durations the real backend would compute.
+ */
+function currentDuration() {
+ if (timer.round_type === 'short-break') return settings.time_short_break_secs;
+ if (timer.round_type === 'long-break') return settings.time_long_break_secs;
+ const base = settings.time_work_secs;
+ if (!settings.incremental_work_enabled || settings.time_work_increment_secs === 0) return base;
+ const cap = Math.max(settings.time_work_max_secs, base);
+ return Math.min(base + settings.time_work_increment_secs * timer.work_rounds_completed, cap);
+}
+
+function snapshot() {
+ const base = settings.time_work_secs;
+ const inc = settings.time_work_increment_secs;
+ const cap = Math.max(settings.time_work_max_secs, base);
+ const active = settings.incremental_work_enabled && inc > 0;
+ return {
+ round_type: timer.round_type,
+ previous_round_type: timer.previous_round_type,
+ elapsed_secs: timer.elapsed_secs,
+ total_secs: currentDuration(),
+ is_running: timer.is_running,
+ is_paused: !timer.is_running && timer.elapsed_secs > 0,
+ work_round_number: timer.work_round_number,
+ work_rounds_total: MOCK_ROUNDS_TOTAL,
+ session_work_count: timer.session_work_count,
+ incremental_work_enabled: settings.incremental_work_enabled,
+ base_work_secs: base,
+ work_increment_secs: inc,
+ work_max_secs: settings.time_work_max_secs,
+ increment_steps: active ? timer.work_rounds_completed : 0,
+ at_increment_cap: active && base + inc * timer.work_rounds_completed >= cap,
+ };
+}
+
+function stopTicking() {
+ if (timer._interval !== null) {
+ clearInterval(timer._interval);
+ timer._interval = null;
+ }
+}
+
+function startTicking() {
+ stopTicking();
+ timer.is_running = true;
+ emit('timer:started', { total_secs: currentDuration() });
+ timer._interval = setInterval(() => {
+ timer.elapsed_secs += 1;
+ const total = currentDuration();
+ emit('timer:tick', { elapsed_secs: timer.elapsed_secs, total_secs: total });
+ if (timer.elapsed_secs >= total) advanceRound();
+ }, 1000);
+}
+
+function advanceRound() {
+ stopTicking();
+ const rolledOver = checkDayRollover();
+ const finishedWork = timer.round_type === 'work';
+ timer.previous_round_type = timer.round_type;
+
+ if (timer.round_type === 'work') {
+ timer.work_rounds_completed += 1;
+ if (timer.work_round_number >= MOCK_ROUNDS_TOTAL && settings.long_breaks_enabled) {
+ timer.round_type = 'long-break';
+ // Long-break reset trigger: the ladder restarts with the new cycle unless
+ // the user keeps it climbing across breaks.
+ if (settings.incremental_reset_on_long_break) timer.work_rounds_completed = 0;
+ } else {
+ if (timer.work_round_number >= MOCK_ROUNDS_TOTAL) timer.work_round_number = 1;
+ else timer.work_round_number += 1;
+ timer.round_type = 'short-break';
+ }
+ } else if (timer.round_type === 'long-break') {
+ timer.round_type = 'work';
+ timer.work_round_number = 1;
+ timer.session_work_count += 1;
+ } else {
+ timer.round_type = 'work';
+ timer.session_work_count += 1;
+ }
+
+ // A work round that finished just after midnight belongs to the day it
+ // started in, so it must not extend the new day's ladder.
+ if (rolledOver && finishedWork) timer.work_rounds_completed = 0;
+
+ timer.elapsed_secs = 0;
+ timer.is_running = false;
+ emit('timer:round-change', snapshot());
+}
+
+// --- Event bus -------------------------------------------------------------
+
+let nextEventId = 1;
+const eventListeners = new Map();
+
+function emit(name, payload) {
+ for (const cb of eventListeners.get(name) ?? []) {
+ try {
+ cb(payload);
+ } catch {
+ /* a listener throwing must not break the others */
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Command table
+// ---------------------------------------------------------------------------
+
+const commands = {
+ settings_get: () => ({ ...settings }),
+ settings_set: ({ key, value }) => {
+ if (key in settings) {
+ const current = settings[key];
+ if (typeof current === 'boolean') settings[key] = value === 'true';
+ else if (typeof current === 'number') settings[key] = Number(value);
+ else settings[key] = value;
+ }
+ emit('settings:changed', { ...settings });
+ checkDayRollover();
+ emit('timer:reset', snapshot());
+ return { ...settings };
+ },
+ settings_reset_defaults: () => ({ ...settings }),
+ shortcuts_reload: () => undefined,
+
+ themes_list: () => themes.map((t) => ({ ...t })),
+
+ timer_get_state: () => {
+ checkDayRollover();
+ return snapshot();
+ },
+ timer_toggle: () => {
+ checkDayRollover();
+ if (timer.is_running) {
+ stopTicking();
+ timer.is_running = false;
+ emit('timer:paused', { elapsed_secs: timer.elapsed_secs });
+ } else if (timer.elapsed_secs > 0) {
+ timer.is_running = true;
+ emit('timer:resumed', { elapsed_secs: timer.elapsed_secs });
+ startTicking();
+ } else {
+ startTicking();
+ }
+ },
+ timer_reset: () => {
+ stopTicking();
+ timer.round_type = 'work';
+ timer.previous_round_type = '';
+ timer.elapsed_secs = 0;
+ timer.is_running = false;
+ timer.work_round_number = 1;
+ timer.work_rounds_completed = 0;
+ timer.ladder_day = todayKey();
+ timer.session_work_count = 1;
+ emit('timer:reset', snapshot());
+ },
+ timer_reset_increment: () => {
+ timer.work_rounds_completed = 0;
+ timer.ladder_day = todayKey();
+ emit('timer:reset', snapshot());
+ },
+ timer_restart_round: () => {
+ stopTicking();
+ timer.elapsed_secs = 0;
+ timer.is_running = false;
+ emit('timer:reset', snapshot());
+ },
+ timer_skip: () => advanceRound(),
+
+ stats_get_insights: () => buildInsights(),
+ stats_get_detailed: () => {
+ const i = buildInsights();
+ return {
+ today: {
+ rounds: i.today_rounds,
+ focus_mins: i.today_focus_mins,
+ completion_rate: i.week.completion_rate,
+ by_hour: i.today_by_hour,
+ },
+ week: i.trend.slice(-7).map((p) => ({ date: p.date, rounds: p.rounds })),
+ streak: { current: i.streak.current, longest: i.streak.longest },
+ };
+ },
+ stats_get_heatmap: () => {
+ const i = buildInsights();
+ return {
+ entries: i.heatmap.map((p) => ({ date: p.date, count: p.rounds })),
+ total_rounds: i.records.total_rounds,
+ total_hours: Math.round(i.records.total_focus_mins / 60),
+ longest_streak: i.streak.longest,
+ };
+ },
+ sessions_clear: () => {
+ emit('sessions:cleared', undefined);
+ return undefined;
+ },
+
+ audio_get_custom_info: () => ({ work_alert: null, short_break_alert: null, long_break_alert: null }),
+ notification_show: () => undefined,
+ window_set_visibility: () => undefined,
+ open_log_dir: () => undefined,
+ get_log_dir: () => '/tmp/pomotroid-logs',
+ app_version: () => '1.7.2-dev+mock',
+ accessibility_trusted: () => true,
+ tray_supported: () => false,
+ check_update: () => null,
+
+ // --- Log plugin (used by @tauri-apps/plugin-log) ---
+ 'plugin:log|log': () => undefined,
+
+ // --- Event plugin bridge (used by @tauri-apps/api/event) ---
+ 'plugin:event|listen': ({ event, handler }) => {
+ const id = nextEventId++;
+ const callbacks = eventListeners.get(event) ?? [];
+ callbacks.push(window.__TAURI_INTERNALS__.callbacks[handler]);
+ eventListeners.set(event, callbacks);
+ return id;
+ },
+ 'plugin:event|unlisten': ({ event, eventId }) => {
+ const callbacks = eventListeners.get(event) ?? [];
+ if (callbacks.length) callbacks.pop();
+ void eventId;
+ return undefined;
+ },
+ 'plugin:event|emit': ({ event, payload }) => {
+ emit(event, payload);
+ return undefined;
+ },
+
+ // --- Window plugin (used by the settings/stats windows) ---
+ 'plugin:window|show': () => undefined,
+ 'plugin:window|hide': () => undefined,
+ 'plugin:window|close': () => undefined,
+ 'plugin:window|set_focus': () => undefined,
+ 'plugin:window|minimize': () => undefined,
+ 'plugin:window|toggle_maximize': () => undefined,
+ 'plugin:window|is_maximized': () => false,
+ 'plugin:window|start_dragging': () => undefined,
+ 'plugin:window|start_resize_dragging': () => undefined,
+ 'plugin:window|set_fullscreen': () => undefined,
+ 'plugin:window|is_fullscreen': () => false,
+ 'plugin:window|internal_toggle_maximize': () => undefined,
+ 'plugin:window|theme': () => 'dark',
+ 'plugin:webview|create_webview_window': (args) => {
+ const label = args?.options?.label ?? args?.label ?? 'window';
+ const url = args?.options?.url ?? args?.url ?? '/';
+ emit('mock:navigate', { label, url });
+ return undefined;
+ },
+ 'plugin:webview|get_all_webviews': () => [],
+};
+
+// ---------------------------------------------------------------------------
+// Bridge installation
+// ---------------------------------------------------------------------------
+
+let installed = false;
+
+export function installMockTauri() {
+ if (installed || isTauri() || typeof window === 'undefined') return;
+ // Never ship the mock: production builds skip installation entirely.
+ if (!import.meta.env.DEV) return;
+
+ let callbackId = 0;
+ const callbacks = {};
+
+ window.__TAURI_INTERNALS__ = {
+ callbacks,
+ transformCallback(cb, once = false) {
+ const id = callbackId++;
+ callbacks[id] = (payload) => {
+ if (once) delete callbacks[id];
+ if (typeof cb === 'function') cb(payload);
+ };
+ return id;
+ },
+ unregisterCallback(id) {
+ delete callbacks[id];
+ },
+ convertFileSrc(filePath) {
+ return filePath;
+ },
+ metadata: {
+ currentWindow: { label: 'main' },
+ currentWebview: { label: 'main', windowLabel: 'main' },
+ },
+ plugins: {},
+ async invoke(cmd, args = {}) {
+ const handler = commands[cmd];
+ if (!handler) {
+ // Unknown command: resolve quietly so optional features never break the UI.
+ console.warn(`[mock-tauri] unhandled command: ${cmd}`, args);
+ return undefined;
+ }
+ return handler(args);
+ },
+ };
+
+ // jsdom-free window metadata for `getCurrentWebviewWindow()`.
+ window.__TAURI_INTERNALS__.metadata.currentWindow.label = 'main';
+ window.__TAURI_INTERNALS__.metadata.currentWebview.label = 'main';
+
+ installed = true;
+
+ const reason = isMac ? 'macOS' : 'browser';
+ console.info(
+ `%c[mock-tauri]%c Running with a mocked Tauri bridge (${reason}). ` +
+ 'UI only — no real timer persistence or notifications.',
+ 'background:#e9573f;color:#fff;padding:1px 5px;border-radius:3px',
+ 'color:inherit'
+ );
+}
+
+installMockTauri();
diff --git a/src/lib/ipc/index.ts b/src/lib/ipc/index.ts
index b35c79d8..8319d054 100644
--- a/src/lib/ipc/index.ts
+++ b/src/lib/ipc/index.ts
@@ -11,6 +11,7 @@ import type {
CustomAudioInfo,
DetailedStats,
HeatmapStats,
+ Insights,
UpdateInfo,
} from '$lib/types';
@@ -18,6 +19,8 @@ import type {
export const timerToggle = () => invoke
('timer_toggle');
export const timerReset = () => invoke('timer_reset');
+/** Restart the incremental-focus ladder without touching the round counters. */
+export const timerResetIncrement = () => invoke('timer_reset_increment');
export const timerRestartRound = () => invoke('timer_restart_round');
export const timerSkip = () => invoke('timer_skip');
export const getTimerState = () => invoke('timer_get_state');
@@ -86,6 +89,9 @@ export const statsGetDetailed = () => invoke('stats_get_detailed'
/** Heatmap entries + lifetime totals (All Time tab). */
export const statsGetHeatmap = () => invoke('stats_get_heatmap');
+/** Full analytics payload for the "Better Stats" window. */
+export const statsGetInsights = () => invoke('stats_get_insights');
+
// --- Platform commands ---
export const accessibilityTrusted = () => invoke('accessibility_trusted');
diff --git a/src/lib/stores/settings.ts b/src/lib/stores/settings.ts
index cb9ef1b7..b6e37833 100644
--- a/src/lib/stores/settings.ts
+++ b/src/lib/stores/settings.ts
@@ -8,6 +8,11 @@ const defaults: Settings = {
time_work_secs: 1500,
time_short_break_secs: 300,
time_long_break_secs: 900,
+ incremental_work_enabled: false,
+ time_work_increment_secs: 300,
+ time_work_max_secs: 5400,
+ incremental_reset_on_long_break: true,
+ incremental_reset_daily: true,
long_break_interval: 4,
short_breaks_enabled: true,
long_breaks_enabled: true,
diff --git a/src/lib/stores/timer.ts b/src/lib/stores/timer.ts
index 0b7bbfa0..94f81baf 100644
--- a/src/lib/stores/timer.ts
+++ b/src/lib/stores/timer.ts
@@ -14,6 +14,12 @@ const initial: TimerState = {
work_round_number: 1,
work_rounds_total: 4,
session_work_count: 1,
+ incremental_work_enabled: false,
+ base_work_secs: 25 * 60,
+ work_increment_secs: 5 * 60,
+ work_max_secs: 90 * 60,
+ increment_steps: 0,
+ at_increment_cap: false,
};
export const timerState = writable(initial);
diff --git a/src/lib/types.ts b/src/lib/types.ts
index 88a82594..2cd53c46 100644
--- a/src/lib/types.ts
+++ b/src/lib/types.ts
@@ -14,6 +14,13 @@ export interface TimerState {
work_round_number: number; // current work round (1-based)
work_rounds_total: number; // total work rounds before long break
session_work_count: number; // monotonic focus round count since last reset
+ // --- Incremental focus mode ---
+ incremental_work_enabled: boolean; // escalating work-duration ladder is active
+ base_work_secs: number; // un-escalated work duration from settings
+ work_increment_secs: number; // seconds added per completed work round
+ work_max_secs: number; // escalation ceiling
+ increment_steps: number; // increments currently applied
+ at_increment_cap: boolean; // work duration has reached the ceiling
}
/** Mirrors Rust `Settings` struct returned by `settings_get`. */
@@ -21,6 +28,16 @@ export interface Settings {
time_work_secs: number;
time_short_break_secs: number;
time_long_break_secs: number;
+ /** Incremental focus mode: each work round gets longer than the last. */
+ incremental_work_enabled: boolean;
+ /** Seconds added to the work duration after each completed work round. */
+ time_work_increment_secs: number;
+ /** Ceiling for the escalated work duration, in seconds. */
+ time_work_max_secs: number;
+ /** Restart the incremental ladder when a long break begins. */
+ incremental_reset_on_long_break: boolean;
+ /** Restart the incremental ladder when the local calendar day changes. */
+ incremental_reset_daily: boolean;
long_break_interval: number;
short_breaks_enabled: boolean;
long_breaks_enabled: boolean;
@@ -119,3 +136,141 @@ export interface HeatmapStats {
total_hours: number;
longest_streak: number;
}
+
+// ---------------------------------------------------------------------------
+// Insights types — powering the "Better Stats" window
+// ---------------------------------------------------------------------------
+
+/** One calendar day of completed work activity. */
+export interface TrendPoint {
+ date: string; // "YYYY-MM-DD"
+ rounds: number;
+ focus_mins: number;
+}
+
+/** Aggregate activity over a rolling window of days. */
+export interface PeriodSummary {
+ label: string;
+ days: number;
+ rounds: number;
+ focus_mins: number;
+ active_days: number;
+ avg_rounds_per_active_day: number | null;
+ avg_focus_mins_per_active_day: number | null;
+ completion_rate: number | null; // completed / started; null when nothing started
+ best_day: TrendPoint | null;
+}
+
+export interface WeekdayStat {
+ weekday: number; // 0 = Monday … 6 = Sunday
+ rounds: number;
+ focus_mins: number;
+}
+
+export interface HourStat {
+ hour: number; // 0–23
+ rounds: number;
+ focus_mins: number;
+}
+
+/** One cell of the day-of-week × hour-of-day activity grid. */
+export interface RhythmCell {
+ weekday: number; // 0 = Monday … 6 = Sunday
+ hour: number; // 0–23
+ rounds: number;
+ focus_mins: number;
+}
+
+/** A bucket in the session-length histogram. */
+export interface SessionLengthBucket {
+ min_mins: number;
+ max_mins: number | null; // null for the open-ended top bucket
+ rounds: number;
+ focus_mins: number;
+}
+
+/** A two-point series used for momentum comparisons. */
+export interface Comparison {
+ label: string; // 'rounds_week' | 'focus_week' | 'active_days_week' | 'avg_per_active_day'
+ current: number;
+ previous: number;
+ delta_pct: number | null;
+}
+
+export interface StreakSummary {
+ current: number;
+ longest: number;
+ last_active_date: string | null;
+ at_risk: boolean;
+}
+
+export interface ConsistencyStats {
+ window_days: number;
+ active_days: number;
+ active_ratio: number; // 0–1
+ avg_rounds_per_day: number;
+ avg_focus_mins_per_day: number;
+ stddev_rounds: number;
+ strong_days: number;
+ light_days: number;
+ rest_days: number;
+ best_streak_in_window: number;
+}
+
+export interface RecordStats {
+ total_rounds: number;
+ total_focus_mins: number;
+ tracked_days: number;
+ avg_session_mins: number | null;
+ longest_session_mins: number | null;
+ avg_rounds_per_active_day: number | null;
+ best_day_rounds: TrendPoint | null;
+ best_day_focus: TrendPoint | null;
+ best_week: TrendPoint | null;
+}
+
+/** Returned by stats_get_insights — the full "Better Stats" payload. */
+export interface Insights {
+ today: string; // "YYYY-MM-DD"
+
+ // Today
+ today_rounds: number;
+ today_focus_mins: number;
+ today_by_hour: number[]; // 24 entries
+ rounds_to_beat_average: number | null;
+ ahead_of_average: boolean;
+
+ // Momentum
+ week: PeriodSummary;
+ month: PeriodSummary;
+ last_7_days: PeriodSummary;
+ last_90_days: PeriodSummary;
+ previous_7_days: PeriodSummary;
+ comparisons: Comparison[];
+
+ // Trends
+ trend: TrendPoint[]; // trailing 28 days, zero-filled, oldest → newest
+ heatmap: TrendPoint[]; // trailing 120 days, zero-filled
+ daily_all: TrendPoint[]; // every recorded day, oldest → newest
+ weeks: TrendPoint[]; // trailing 12 Monday-start weeks
+ moving_avg_7: number[]; // 7-day moving average, aligned with `trend`
+ focus_trend: TrendPoint[]; // minutes per day for the trailing 28 days
+ daily_28: TrendPoint[];
+
+ // Rhythm
+ hour_profile: HourStat[]; // 24 entries, all time
+ weekday_profile: WeekdayStat[]; // 7 entries, Monday first
+ rhythm_grid: RhythmCell[]; // 7 × 24 = 168 cells, row-major from Monday
+ active_from_hour: number | null;
+ active_to_hour: number | null;
+
+ // Shape of the work
+ session_buckets: SessionLengthBucket[];
+ top_weekday_share: number | null; // 0–1
+ top_hour_share: number | null; // 0–1
+
+ // Consistency + records
+ consistency: ConsistencyStats;
+ records: RecordStats;
+ streak: StreakSummary;
+}
diff --git a/src/lib/utils/statsFormat.ts b/src/lib/utils/statsFormat.ts
new file mode 100644
index 00000000..48cee5dd
--- /dev/null
+++ b/src/lib/utils/statsFormat.ts
@@ -0,0 +1,113 @@
+// Formatting helpers shared by the Better Stats components.
+
+import type { PeriodSummary, TrendPoint } from '$lib/types';
+
+/** Above this many hours, minutes are dropped and the value is whole hours. */
+const HOURS_ONLY_THRESHOLD = 10;
+
+/**
+ * Human-readable focus duration.
+ *
+ * - under an hour: `45m`
+ * - up to 10 hours: `1h 30m` (minutes are dropped when they are zero)
+ * - 10 hours and above: whole hours only, e.g. `12h` — minute precision stops
+ * being meaningful at that scale and the longer form reads as clutter.
+ */
+export function fmtMins(mins: number): string {
+ const total = Math.max(0, Math.round(mins));
+ if (total < 60) return `${total}m`;
+
+ const hours = total / 60;
+ if (hours >= HOURS_ONLY_THRESHOLD) return `${Math.round(hours)}h`;
+
+ const whole = Math.floor(hours);
+ const rest = total % 60;
+ return rest === 0 ? `${whole}h` : `${whole}h ${rest}m`;
+}
+
+/** Duration with a leading `~`, for averages and estimates. */
+export function fmtMinsApprox(mins: number): string {
+ return `~${fmtMins(mins)}`;
+}
+
+/** Completion rate as a percentage, or an em dash when unknown. */
+export function fmtRate(rate: number | null): string {
+ if (rate === null || Number.isNaN(rate)) return '—';
+ return `${Math.round(rate * 100)}%`;
+}
+
+/** A one-decimal average, or an em dash when unknown. */
+export function fmtAvg(value: number | null, suffix = ''): string {
+ if (value === null || Number.isNaN(value)) return '—';
+ const rounded = Math.round(value * 10) / 10;
+ return `${Number.isInteger(rounded) ? rounded : rounded.toFixed(1)}${suffix}`;
+}
+
+/** Signed percentage change of `current` vs `previous`, or null if not comparable. */
+export function deltaPct(current: number, previous: number): number | null {
+ if (previous <= 0) return null;
+ return (current - previous) / previous;
+}
+
+/** "+42%" / "−18%" / "—" */
+export function fmtDelta(pct: number | null): string {
+ if (pct === null) return '—';
+ const sign = pct > 0 ? '+' : pct < 0 ? '−' : '';
+ return `${sign}${Math.abs(Math.round(pct * 100))}%`;
+}
+
+/** Short weekday label from a Monday-based index (0 = Mon). */
+const WEEKDAYS = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'];
+export function weekdayLabel(index: number): string {
+ return WEEKDAYS[((index % 7) + 7) % 7];
+}
+
+/** Hour label such as "9a", "12p", "11p". */
+export function hourLabel(hour: number): string {
+ const h = ((hour % 24) + 24) % 24;
+ if (h === 0) return '12a';
+ if (h === 12) return '12p';
+ return h < 12 ? `${h}a` : `${h - 12}p`;
+}
+
+/** "Mar 15" from a "YYYY-MM-DD" string, without timezone drift. */
+const MONTHS = [
+ 'Jan',
+ 'Feb',
+ 'Mar',
+ 'Apr',
+ 'May',
+ 'Jun',
+ 'Jul',
+ 'Aug',
+ 'Sep',
+ 'Oct',
+ 'Nov',
+ 'Dec',
+];
+export function fmtDay(date: string): string {
+ const [, m, d] = date.split('-').map((p) => parseInt(p, 10));
+ if (!m || !d) return date;
+ return `${MONTHS[m - 1]} ${d}`;
+}
+
+/** "Mar 11" for a week starting on that Monday. */
+export function fmtWeek(date: string): string {
+ return fmtDay(date);
+}
+
+/** The busiest entry in a profile list, or null when everything is zero. */
+export function peakOf(entries: T[]): T | null {
+ let best: T | null = null;
+ for (const e of entries) {
+ if (e.rounds <= 0) continue;
+ if (!best || e.rounds > best.rounds) best = e;
+ }
+ return best;
+}
+
+/** A summary's best day is only interesting once there is activity. */
+export function bestDayOf(period: PeriodSummary | null | undefined): TrendPoint | null {
+ if (!period || period.rounds === 0) return null;
+ return period.best_day;
+}
diff --git a/src/messages/de.json b/src/messages/de.json
index e7fa9739..0d36f63d 100644
--- a/src/messages/de.json
+++ b/src/messages/de.json
@@ -149,5 +149,120 @@
"tooltip_dial_countdown": "Wenn aktiviert, zählt der Fortschrittsbogen auf null herunter, anstatt sich zu füllen.",
"tooltip_auto_start_work": "Die nächste Arbeitsrunde automatisch starten, wenn eine Pause endet.",
"tooltip_auto_start_break": "Die Pause automatisch starten, wenn eine Arbeitsrunde endet.",
- "tooltip_websocket": "Aktiviert einen lokalen WebSocket-Server für externe Integrationen wie Stream-Overlays. Standardmäßig deaktiviert."
+ "tooltip_websocket": "Aktiviert einen lokalen WebSocket-Server für externe Integrationen wie Stream-Overlays. Standardmäßig deaktiviert.",
+ "timer_toggle_incremental": "Incremental Focus",
+ "timer_toggle_incremental_desc": "Each work round is longer than the last, up to a maximum.",
+ "timer_slider_increment": "Add per Round",
+ "timer_slider_increment_cap": "Maximum Focus",
+ "timer_increment_ladder": "Focus ladder",
+ "timer_increment_ladder_hint": "Durations climb with each completed work round, then reset after a long break or on a new day.",
+ "timer_increment_capped": "Capped — later rounds hold at the maximum focus duration.",
+ "tooltip_incremental_focus": "Incremental focus is on: each completed work round lengthens the next one.",
+ "stats_better_title": "Better Stats",
+ "stats_better_subtitle": "Your focus, measured",
+ "tooltip_better_stats": "Open Better Stats",
+ "better_section_momentum": "Momentum",
+ "better_section_trend": "Focus Trend",
+ "better_section_rhythm": "Your Rhythm",
+ "better_section_records": "Records",
+ "better_momentum_today": "Today",
+ "better_momentum_week": "Last 7 Days",
+ "better_momentum_month": "Last 28 Days",
+ "better_momentum_vs_prev": "vs previous week",
+ "better_ahead_of_average": "Ahead of your 7-day average",
+ "better_behind_average_one": "{n} round to match your average",
+ "better_behind_average": "{n} rounds to match your average",
+ "better_average_matched": "Average matched — keep going",
+ "better_no_average": "Complete a few rounds to unlock comparisons",
+ "better_focus_time": "Focus Time",
+ "better_rounds": "Rounds",
+ "better_avg_per_active_day": "Avg / active day",
+ "better_completion_rate": "Completion",
+ "better_active_days": "Active days",
+ "better_best_day": "Best day",
+ "better_no_data": "No data yet",
+ "better_trend_hint": "Rounds per day over the last 28 days",
+ "better_weeks_hint": "Rounds per week over the last 12 weeks",
+ "better_view_days": "Days",
+ "better_view_weeks": "Weeks",
+ "better_rhythm_hours": "By hour of day",
+ "better_rhythm_weekdays": "By weekday",
+ "better_records_streak": "Current streak",
+ "better_records_longest": "Longest streak",
+ "better_records_total_rounds": "Total rounds",
+ "better_records_total_focus": "Total focus",
+ "better_records_tracked_days": "Tracked days",
+ "better_records_avg_session": "Avg session",
+ "better_streak_at_risk": "Log a round today to keep it alive",
+ "better_peak_hour": "Peak hour",
+ "better_peak_weekday": "Strongest day",
+ "better_empty_title": "Nothing to measure yet",
+ "better_empty_body": "Finish your first focus round and this page fills up with trends, streaks and your personal rhythm.",
+ "better_refresh": "Refresh",
+ "better_loading": "Crunching your sessions…",
+ "better_error": "Could not load your stats",
+ "timer_increment_step": "step {n}",
+ "timer_increment_step_1": "step 1",
+ "timer_increment_cap_short": "capped",
+ "timer_toggle_increment_reset_long_break": "Reset After Long Break",
+ "timer_toggle_increment_reset_long_break_desc": "The first focus round after a long break starts at your base focus time.",
+ "timer_toggle_increment_reset_daily": "Reset Each Day",
+ "timer_toggle_increment_reset_daily_desc": "The first focus round of a new day starts at your base focus time.",
+ "timer_increment_reset_now": "Reset Focus Ladder",
+ "timer_increment_reset_now_desc": "Start the next round at the base focus duration. Round counters are untouched.",
+ "timer_increment_reset_done": "Ladder reset — the next round starts at the base duration.",
+ "timer_increment_hint_daily": "Durations climb with each completed work round, then reset at the start of a new day.",
+ "timer_increment_hint_long_break": "Durations climb with each completed work round, then reset after a long break.",
+ "timer_increment_hint_never": "Durations keep climbing with every completed work round until you reset the ladder.",
+ "better_heatmap_hint": "Hover a square to see that day",
+ "better_heatmap_title": "Consistency",
+ "better_heatmap_sub": "Last 120 days of focus",
+ "better_grid_title": "When you focus",
+ "better_grid_peak": "Peak slot",
+ "better_grid_hint": "Hover a cell for that hour's total",
+ "better_consistency_title": "Habit Strength",
+ "better_consistency_active": "Active days",
+ "better_consistency_avg": "Daily average",
+ "better_consistency_steady": "Steadiness",
+ "better_consistency_steady_hint": "Lower spread means a steadier routine",
+ "better_consistency_split": "Day mix",
+ "better_consistency_strong": "Strong",
+ "better_consistency_light": "Light",
+ "better_consistency_rest": "Rest",
+ "better_consistency_run": "Best run",
+ "better_span_title": "Focus window",
+ "better_span_from": "Earliest start",
+ "better_span_to": "Latest start",
+ "better_span_concentration": "Concentration",
+ "better_span_concentration_hint": "Share of all focus in your busiest day of the week",
+ "better_length_title": "Round Length Mix",
+ "better_length_under": "Under {n}m",
+ "better_length_range": "{from}–{to}m",
+ "better_length_over": "{n}m and up",
+ "better_weekday_title": "Focus by Weekday",
+ "better_hour_title": "Focus by Hour",
+ "better_progress_title": "Progress Over Time",
+ "better_progress_days": "Daily",
+ "better_progress_weeks": "Weekly",
+ "better_moving_avg": "7-day avg",
+ "better_records_title": "Personal Bests",
+ "better_records_longest_session": "Longest round",
+ "better_records_best_day": "Best day",
+ "better_records_best_week": "Best week",
+ "better_records_avg_active_day": "Avg per active day",
+ "better_delta_vs_prev": "vs prev week",
+ "better_compare_rounds": "Rounds",
+ "better_compare_focus": "Focus",
+ "better_compare_active": "Active days",
+ "better_compare_avg": "Avg / active day",
+ "better_last_90": "Last 90 Days",
+ "better_focus_per_week": "Focus Minutes per Week",
+ "better_rounds_per_week": "Rounds per Week",
+ "better_scope_recent": "Recent",
+ "better_scope_month": "Month",
+ "better_scope_year": "Year",
+ "better_prev_month": "Previous month",
+ "better_next_month": "Next month",
+ "better_prev_year": "Previous year",
+ "better_next_year": "Next year"
}
diff --git a/src/messages/en.json b/src/messages/en.json
index 77f4f239..495c9931 100644
--- a/src/messages/en.json
+++ b/src/messages/en.json
@@ -149,5 +149,120 @@
"tooltip_dial_countdown": "When enabled, the progress arc counts down to zero instead of filling up.",
"tooltip_auto_start_work": "Automatically start the next work round when a break ends.",
"tooltip_auto_start_break": "Automatically start the break when a work round completes.",
- "tooltip_websocket": "Enables a local WebSocket server for external integrations such as stream overlays. Disabled by default."
+ "tooltip_websocket": "Enables a local WebSocket server for external integrations such as stream overlays. Disabled by default.",
+ "timer_toggle_incremental": "Incremental Focus",
+ "timer_toggle_incremental_desc": "Each work round is longer than the last, up to a maximum.",
+ "timer_slider_increment": "Add per Round",
+ "timer_slider_increment_cap": "Maximum Focus",
+ "timer_increment_ladder": "Focus ladder",
+ "timer_increment_ladder_hint": "Durations climb with each completed work round, then reset after a long break or on a new day.",
+ "timer_increment_capped": "Capped — later rounds hold at the maximum focus duration.",
+ "timer_increment_step": "step {n}",
+ "timer_increment_step_1": "step 1",
+ "timer_increment_cap_short": "capped",
+ "timer_toggle_increment_reset_long_break": "Reset After Long Break",
+ "timer_toggle_increment_reset_long_break_desc": "The first focus round after a long break starts at your base focus time.",
+ "timer_toggle_increment_reset_daily": "Reset Each Day",
+ "timer_toggle_increment_reset_daily_desc": "The first focus round of a new day starts at your base focus time.",
+ "timer_increment_reset_now": "Reset Focus Ladder",
+ "timer_increment_reset_now_desc": "Start the next round at the base focus duration. Round counters are untouched.",
+ "timer_increment_reset_done": "Ladder reset — the next round starts at the base duration.",
+ "timer_increment_hint_daily": "Durations climb with each completed work round, then reset at the start of a new day.",
+ "timer_increment_hint_long_break": "Durations climb with each completed work round, then reset after a long break.",
+ "timer_increment_hint_never": "Durations keep climbing with every completed work round until you reset the ladder.",
+ "tooltip_incremental_focus": "Incremental focus is on: each completed work round lengthens the next one.",
+ "stats_better_title": "Better Stats",
+ "stats_better_subtitle": "Your focus, measured",
+ "tooltip_better_stats": "Open Better Stats",
+ "better_section_momentum": "Momentum",
+ "better_section_trend": "Focus Trend",
+ "better_section_rhythm": "Your Rhythm",
+ "better_section_records": "Records",
+ "better_momentum_today": "Today",
+ "better_momentum_week": "Last 7 Days",
+ "better_momentum_month": "Last 28 Days",
+ "better_last_90": "Last 90 Days",
+ "better_momentum_vs_prev": "vs previous week",
+ "better_ahead_of_average": "Ahead of your 7-day average",
+ "better_behind_average_one": "{n} round to match your average",
+ "better_behind_average": "{n} rounds to match your average",
+ "better_average_matched": "Average matched — keep going",
+ "better_no_average": "Complete a few rounds to unlock comparisons",
+ "better_focus_time": "Focus Time",
+ "better_rounds": "Rounds",
+ "better_avg_per_active_day": "Avg / active day",
+ "better_completion_rate": "Completion",
+ "better_active_days": "Active days",
+ "better_best_day": "Best day",
+ "better_no_data": "No data yet",
+ "better_trend_hint": "Rounds per day over the last 28 days",
+ "better_weeks_hint": "Rounds per week over the last 12 weeks",
+ "better_view_days": "Days",
+ "better_view_weeks": "Weeks",
+ "better_rhythm_hours": "By hour of day",
+ "better_rhythm_weekdays": "By weekday",
+ "better_records_streak": "Current streak",
+ "better_records_longest": "Longest streak",
+ "better_records_total_rounds": "Total rounds",
+ "better_records_total_focus": "Total focus",
+ "better_records_tracked_days": "Tracked days",
+ "better_records_avg_session": "Avg session",
+ "better_streak_at_risk": "Log a round today to keep it alive",
+ "better_peak_hour": "Peak hour",
+ "better_peak_weekday": "Strongest day",
+ "better_empty_title": "Nothing to measure yet",
+ "better_empty_body": "Finish your first focus round and this page fills up with trends, streaks and your personal rhythm.",
+ "better_refresh": "Refresh",
+ "better_loading": "Crunching your sessions…",
+ "better_error": "Could not load your stats",
+ "better_heatmap_hint": "Hover a square to see that day",
+ "better_heatmap_title": "Consistency",
+ "better_heatmap_sub": "Last 120 days of focus",
+ "better_grid_title": "When you focus",
+ "better_grid_peak": "Peak slot",
+ "better_grid_hint": "Hover a cell for that hour's total",
+ "better_consistency_title": "Habit Strength",
+ "better_consistency_active": "Active days",
+ "better_consistency_avg": "Daily average",
+ "better_consistency_steady": "Steadiness",
+ "better_consistency_steady_hint": "Lower spread means a steadier routine",
+ "better_consistency_split": "Day mix",
+ "better_consistency_strong": "Strong",
+ "better_consistency_light": "Light",
+ "better_consistency_rest": "Rest",
+ "better_consistency_run": "Best run",
+ "better_span_title": "Focus window",
+ "better_span_from": "Earliest start",
+ "better_span_to": "Latest start",
+ "better_span_concentration": "Concentration",
+ "better_span_concentration_hint": "Share of all focus in your busiest day of the week",
+ "better_length_title": "Round Length Mix",
+ "better_length_under": "Under {n}m",
+ "better_length_range": "{from}–{to}m",
+ "better_length_over": "{n}m and up",
+ "better_weekday_title": "Focus by Weekday",
+ "better_hour_title": "Focus by Hour",
+ "better_progress_title": "Progress Over Time",
+ "better_progress_days": "Daily",
+ "better_progress_weeks": "Weekly",
+ "better_moving_avg": "7-day avg",
+ "better_records_title": "Personal Bests",
+ "better_records_longest_session": "Longest round",
+ "better_records_best_day": "Best day",
+ "better_records_best_week": "Best week",
+ "better_records_avg_active_day": "Avg per active day",
+ "better_delta_vs_prev": "vs prev week",
+ "better_compare_rounds": "Rounds",
+ "better_compare_focus": "Focus",
+ "better_compare_active": "Active days",
+ "better_compare_avg": "Avg / active day",
+ "better_focus_per_week": "Focus Minutes per Week",
+ "better_rounds_per_week": "Rounds per Week",
+ "better_scope_recent": "Recent",
+ "better_scope_month": "Month",
+ "better_scope_year": "Year",
+ "better_prev_month": "Previous month",
+ "better_next_month": "Next month",
+ "better_prev_year": "Previous year",
+ "better_next_year": "Next year"
}
diff --git a/src/messages/es.json b/src/messages/es.json
index 7c1bca18..47c0002b 100644
--- a/src/messages/es.json
+++ b/src/messages/es.json
@@ -149,5 +149,120 @@
"tooltip_dial_countdown": "Cuando está activado, el arco de progreso cuenta regresivamente hasta cero en lugar de llenarse.",
"tooltip_auto_start_work": "Iniciar automáticamente la siguiente ronda de trabajo cuando termina un descanso.",
"tooltip_auto_start_break": "Iniciar automáticamente el descanso cuando termina una ronda de trabajo.",
- "tooltip_websocket": "Activa un servidor WebSocket local para integraciones externas como overlays de streaming. Desactivado por defecto."
+ "tooltip_websocket": "Activa un servidor WebSocket local para integraciones externas como overlays de streaming. Desactivado por defecto.",
+ "timer_toggle_incremental": "Incremental Focus",
+ "timer_toggle_incremental_desc": "Each work round is longer than the last, up to a maximum.",
+ "timer_slider_increment": "Add per Round",
+ "timer_slider_increment_cap": "Maximum Focus",
+ "timer_increment_ladder": "Focus ladder",
+ "timer_increment_ladder_hint": "Durations climb with each completed work round, then reset after a long break or on a new day.",
+ "timer_increment_capped": "Capped — later rounds hold at the maximum focus duration.",
+ "tooltip_incremental_focus": "Incremental focus is on: each completed work round lengthens the next one.",
+ "stats_better_title": "Better Stats",
+ "stats_better_subtitle": "Your focus, measured",
+ "tooltip_better_stats": "Open Better Stats",
+ "better_section_momentum": "Momentum",
+ "better_section_trend": "Focus Trend",
+ "better_section_rhythm": "Your Rhythm",
+ "better_section_records": "Records",
+ "better_momentum_today": "Today",
+ "better_momentum_week": "Last 7 Days",
+ "better_momentum_month": "Last 28 Days",
+ "better_momentum_vs_prev": "vs previous week",
+ "better_ahead_of_average": "Ahead of your 7-day average",
+ "better_behind_average_one": "{n} round to match your average",
+ "better_behind_average": "{n} rounds to match your average",
+ "better_average_matched": "Average matched — keep going",
+ "better_no_average": "Complete a few rounds to unlock comparisons",
+ "better_focus_time": "Focus Time",
+ "better_rounds": "Rounds",
+ "better_avg_per_active_day": "Avg / active day",
+ "better_completion_rate": "Completion",
+ "better_active_days": "Active days",
+ "better_best_day": "Best day",
+ "better_no_data": "No data yet",
+ "better_trend_hint": "Rounds per day over the last 28 days",
+ "better_weeks_hint": "Rounds per week over the last 12 weeks",
+ "better_view_days": "Days",
+ "better_view_weeks": "Weeks",
+ "better_rhythm_hours": "By hour of day",
+ "better_rhythm_weekdays": "By weekday",
+ "better_records_streak": "Current streak",
+ "better_records_longest": "Longest streak",
+ "better_records_total_rounds": "Total rounds",
+ "better_records_total_focus": "Total focus",
+ "better_records_tracked_days": "Tracked days",
+ "better_records_avg_session": "Avg session",
+ "better_streak_at_risk": "Log a round today to keep it alive",
+ "better_peak_hour": "Peak hour",
+ "better_peak_weekday": "Strongest day",
+ "better_empty_title": "Nothing to measure yet",
+ "better_empty_body": "Finish your first focus round and this page fills up with trends, streaks and your personal rhythm.",
+ "better_refresh": "Refresh",
+ "better_loading": "Crunching your sessions…",
+ "better_error": "Could not load your stats",
+ "timer_increment_step": "step {n}",
+ "timer_increment_step_1": "step 1",
+ "timer_increment_cap_short": "capped",
+ "timer_toggle_increment_reset_long_break": "Reset After Long Break",
+ "timer_toggle_increment_reset_long_break_desc": "The first focus round after a long break starts at your base focus time.",
+ "timer_toggle_increment_reset_daily": "Reset Each Day",
+ "timer_toggle_increment_reset_daily_desc": "The first focus round of a new day starts at your base focus time.",
+ "timer_increment_reset_now": "Reset Focus Ladder",
+ "timer_increment_reset_now_desc": "Start the next round at the base focus duration. Round counters are untouched.",
+ "timer_increment_reset_done": "Ladder reset — the next round starts at the base duration.",
+ "timer_increment_hint_daily": "Durations climb with each completed work round, then reset at the start of a new day.",
+ "timer_increment_hint_long_break": "Durations climb with each completed work round, then reset after a long break.",
+ "timer_increment_hint_never": "Durations keep climbing with every completed work round until you reset the ladder.",
+ "better_heatmap_hint": "Hover a square to see that day",
+ "better_heatmap_title": "Consistency",
+ "better_heatmap_sub": "Last 120 days of focus",
+ "better_grid_title": "When you focus",
+ "better_grid_peak": "Peak slot",
+ "better_grid_hint": "Hover a cell for that hour's total",
+ "better_consistency_title": "Habit Strength",
+ "better_consistency_active": "Active days",
+ "better_consistency_avg": "Daily average",
+ "better_consistency_steady": "Steadiness",
+ "better_consistency_steady_hint": "Lower spread means a steadier routine",
+ "better_consistency_split": "Day mix",
+ "better_consistency_strong": "Strong",
+ "better_consistency_light": "Light",
+ "better_consistency_rest": "Rest",
+ "better_consistency_run": "Best run",
+ "better_span_title": "Focus window",
+ "better_span_from": "Earliest start",
+ "better_span_to": "Latest start",
+ "better_span_concentration": "Concentration",
+ "better_span_concentration_hint": "Share of all focus in your busiest day of the week",
+ "better_length_title": "Round Length Mix",
+ "better_length_under": "Under {n}m",
+ "better_length_range": "{from}–{to}m",
+ "better_length_over": "{n}m and up",
+ "better_weekday_title": "Focus by Weekday",
+ "better_hour_title": "Focus by Hour",
+ "better_progress_title": "Progress Over Time",
+ "better_progress_days": "Daily",
+ "better_progress_weeks": "Weekly",
+ "better_moving_avg": "7-day avg",
+ "better_records_title": "Personal Bests",
+ "better_records_longest_session": "Longest round",
+ "better_records_best_day": "Best day",
+ "better_records_best_week": "Best week",
+ "better_records_avg_active_day": "Avg per active day",
+ "better_delta_vs_prev": "vs prev week",
+ "better_compare_rounds": "Rounds",
+ "better_compare_focus": "Focus",
+ "better_compare_active": "Active days",
+ "better_compare_avg": "Avg / active day",
+ "better_last_90": "Last 90 Days",
+ "better_focus_per_week": "Focus Minutes per Week",
+ "better_rounds_per_week": "Rounds per Week",
+ "better_scope_recent": "Recent",
+ "better_scope_month": "Month",
+ "better_scope_year": "Year",
+ "better_prev_month": "Previous month",
+ "better_next_month": "Next month",
+ "better_prev_year": "Previous year",
+ "better_next_year": "Next year"
}
diff --git a/src/messages/fr.json b/src/messages/fr.json
index fe7b63b8..952a3742 100644
--- a/src/messages/fr.json
+++ b/src/messages/fr.json
@@ -149,5 +149,120 @@
"tooltip_dial_countdown": "Lorsqu'activé, l'arc de progression compte à rebours vers zéro au lieu de se remplir.",
"tooltip_auto_start_work": "Démarrer automatiquement la prochaine session de travail lorsqu'une pause se termine.",
"tooltip_auto_start_break": "Démarrer automatiquement la pause lorsqu'une session de travail se termine.",
- "tooltip_websocket": "Active un serveur WebSocket local pour les intégrations externes telles que les overlays de streaming. Désactivé par défaut."
+ "tooltip_websocket": "Active un serveur WebSocket local pour les intégrations externes telles que les overlays de streaming. Désactivé par défaut.",
+ "timer_toggle_incremental": "Incremental Focus",
+ "timer_toggle_incremental_desc": "Each work round is longer than the last, up to a maximum.",
+ "timer_slider_increment": "Add per Round",
+ "timer_slider_increment_cap": "Maximum Focus",
+ "timer_increment_ladder": "Focus ladder",
+ "timer_increment_ladder_hint": "Durations climb with each completed work round, then reset after a long break or on a new day.",
+ "timer_increment_capped": "Capped — later rounds hold at the maximum focus duration.",
+ "tooltip_incremental_focus": "Incremental focus is on: each completed work round lengthens the next one.",
+ "stats_better_title": "Better Stats",
+ "stats_better_subtitle": "Your focus, measured",
+ "tooltip_better_stats": "Open Better Stats",
+ "better_section_momentum": "Momentum",
+ "better_section_trend": "Focus Trend",
+ "better_section_rhythm": "Your Rhythm",
+ "better_section_records": "Records",
+ "better_momentum_today": "Today",
+ "better_momentum_week": "Last 7 Days",
+ "better_momentum_month": "Last 28 Days",
+ "better_momentum_vs_prev": "vs previous week",
+ "better_ahead_of_average": "Ahead of your 7-day average",
+ "better_behind_average_one": "{n} round to match your average",
+ "better_behind_average": "{n} rounds to match your average",
+ "better_average_matched": "Average matched — keep going",
+ "better_no_average": "Complete a few rounds to unlock comparisons",
+ "better_focus_time": "Focus Time",
+ "better_rounds": "Rounds",
+ "better_avg_per_active_day": "Avg / active day",
+ "better_completion_rate": "Completion",
+ "better_active_days": "Active days",
+ "better_best_day": "Best day",
+ "better_no_data": "No data yet",
+ "better_trend_hint": "Rounds per day over the last 28 days",
+ "better_weeks_hint": "Rounds per week over the last 12 weeks",
+ "better_view_days": "Days",
+ "better_view_weeks": "Weeks",
+ "better_rhythm_hours": "By hour of day",
+ "better_rhythm_weekdays": "By weekday",
+ "better_records_streak": "Current streak",
+ "better_records_longest": "Longest streak",
+ "better_records_total_rounds": "Total rounds",
+ "better_records_total_focus": "Total focus",
+ "better_records_tracked_days": "Tracked days",
+ "better_records_avg_session": "Avg session",
+ "better_streak_at_risk": "Log a round today to keep it alive",
+ "better_peak_hour": "Peak hour",
+ "better_peak_weekday": "Strongest day",
+ "better_empty_title": "Nothing to measure yet",
+ "better_empty_body": "Finish your first focus round and this page fills up with trends, streaks and your personal rhythm.",
+ "better_refresh": "Refresh",
+ "better_loading": "Crunching your sessions…",
+ "better_error": "Could not load your stats",
+ "timer_increment_step": "step {n}",
+ "timer_increment_step_1": "step 1",
+ "timer_increment_cap_short": "capped",
+ "timer_toggle_increment_reset_long_break": "Reset After Long Break",
+ "timer_toggle_increment_reset_long_break_desc": "The first focus round after a long break starts at your base focus time.",
+ "timer_toggle_increment_reset_daily": "Reset Each Day",
+ "timer_toggle_increment_reset_daily_desc": "The first focus round of a new day starts at your base focus time.",
+ "timer_increment_reset_now": "Reset Focus Ladder",
+ "timer_increment_reset_now_desc": "Start the next round at the base focus duration. Round counters are untouched.",
+ "timer_increment_reset_done": "Ladder reset — the next round starts at the base duration.",
+ "timer_increment_hint_daily": "Durations climb with each completed work round, then reset at the start of a new day.",
+ "timer_increment_hint_long_break": "Durations climb with each completed work round, then reset after a long break.",
+ "timer_increment_hint_never": "Durations keep climbing with every completed work round until you reset the ladder.",
+ "better_heatmap_hint": "Hover a square to see that day",
+ "better_heatmap_title": "Consistency",
+ "better_heatmap_sub": "Last 120 days of focus",
+ "better_grid_title": "When you focus",
+ "better_grid_peak": "Peak slot",
+ "better_grid_hint": "Hover a cell for that hour's total",
+ "better_consistency_title": "Habit Strength",
+ "better_consistency_active": "Active days",
+ "better_consistency_avg": "Daily average",
+ "better_consistency_steady": "Steadiness",
+ "better_consistency_steady_hint": "Lower spread means a steadier routine",
+ "better_consistency_split": "Day mix",
+ "better_consistency_strong": "Strong",
+ "better_consistency_light": "Light",
+ "better_consistency_rest": "Rest",
+ "better_consistency_run": "Best run",
+ "better_span_title": "Focus window",
+ "better_span_from": "Earliest start",
+ "better_span_to": "Latest start",
+ "better_span_concentration": "Concentration",
+ "better_span_concentration_hint": "Share of all focus in your busiest day of the week",
+ "better_length_title": "Round Length Mix",
+ "better_length_under": "Under {n}m",
+ "better_length_range": "{from}–{to}m",
+ "better_length_over": "{n}m and up",
+ "better_weekday_title": "Focus by Weekday",
+ "better_hour_title": "Focus by Hour",
+ "better_progress_title": "Progress Over Time",
+ "better_progress_days": "Daily",
+ "better_progress_weeks": "Weekly",
+ "better_moving_avg": "7-day avg",
+ "better_records_title": "Personal Bests",
+ "better_records_longest_session": "Longest round",
+ "better_records_best_day": "Best day",
+ "better_records_best_week": "Best week",
+ "better_records_avg_active_day": "Avg per active day",
+ "better_delta_vs_prev": "vs prev week",
+ "better_compare_rounds": "Rounds",
+ "better_compare_focus": "Focus",
+ "better_compare_active": "Active days",
+ "better_compare_avg": "Avg / active day",
+ "better_last_90": "Last 90 Days",
+ "better_focus_per_week": "Focus Minutes per Week",
+ "better_rounds_per_week": "Rounds per Week",
+ "better_scope_recent": "Recent",
+ "better_scope_month": "Month",
+ "better_scope_year": "Year",
+ "better_prev_month": "Previous month",
+ "better_next_month": "Next month",
+ "better_prev_year": "Previous year",
+ "better_next_year": "Next year"
}
diff --git a/src/messages/ja.json b/src/messages/ja.json
index d90a9f08..9064d976 100644
--- a/src/messages/ja.json
+++ b/src/messages/ja.json
@@ -149,5 +149,120 @@
"tooltip_dial_countdown": "有効にすると、進捗アークがゼロに向かってカウントダウンします（塗りつぶしではなく）。",
"tooltip_auto_start_work": "休憩終了後に次の作業ラウンドを自動的に開始する。",
"tooltip_auto_start_break": "作業ラウンド終了後に休憩を自動的に開始する。",
- "tooltip_websocket": "ストリームオーバーレイなどの外部統合用のローカルWebSocketサーバーを有効にします。デフォルトでは無効です。"
+ "tooltip_websocket": "ストリームオーバーレイなどの外部統合用のローカルWebSocketサーバーを有効にします。デフォルトでは無効です。",
+ "timer_toggle_incremental": "Incremental Focus",
+ "timer_toggle_incremental_desc": "Each work round is longer than the last, up to a maximum.",
+ "timer_slider_increment": "Add per Round",
+ "timer_slider_increment_cap": "Maximum Focus",
+ "timer_increment_ladder": "Focus ladder",
+ "timer_increment_ladder_hint": "Durations climb with each completed work round, then reset after a long break or on a new day.",
+ "timer_increment_capped": "Capped — later rounds hold at the maximum focus duration.",
+ "tooltip_incremental_focus": "Incremental focus is on: each completed work round lengthens the next one.",
+ "stats_better_title": "Better Stats",
+ "stats_better_subtitle": "Your focus, measured",
+ "tooltip_better_stats": "Open Better Stats",
+ "better_section_momentum": "Momentum",
+ "better_section_trend": "Focus Trend",
+ "better_section_rhythm": "Your Rhythm",
+ "better_section_records": "Records",
+ "better_momentum_today": "Today",
+ "better_momentum_week": "Last 7 Days",
+ "better_momentum_month": "Last 28 Days",
+ "better_momentum_vs_prev": "vs previous week",
+ "better_ahead_of_average": "Ahead of your 7-day average",
+ "better_behind_average_one": "{n} round to match your average",
+ "better_behind_average": "{n} rounds to match your average",
+ "better_average_matched": "Average matched — keep going",
+ "better_no_average": "Complete a few rounds to unlock comparisons",
+ "better_focus_time": "Focus Time",
+ "better_rounds": "Rounds",
+ "better_avg_per_active_day": "Avg / active day",
+ "better_completion_rate": "Completion",
+ "better_active_days": "Active days",
+ "better_best_day": "Best day",
+ "better_no_data": "No data yet",
+ "better_trend_hint": "Rounds per day over the last 28 days",
+ "better_weeks_hint": "Rounds per week over the last 12 weeks",
+ "better_view_days": "Days",
+ "better_view_weeks": "Weeks",
+ "better_rhythm_hours": "By hour of day",
+ "better_rhythm_weekdays": "By weekday",
+ "better_records_streak": "Current streak",
+ "better_records_longest": "Longest streak",
+ "better_records_total_rounds": "Total rounds",
+ "better_records_total_focus": "Total focus",
+ "better_records_tracked_days": "Tracked days",
+ "better_records_avg_session": "Avg session",
+ "better_streak_at_risk": "Log a round today to keep it alive",
+ "better_peak_hour": "Peak hour",
+ "better_peak_weekday": "Strongest day",
+ "better_empty_title": "Nothing to measure yet",
+ "better_empty_body": "Finish your first focus round and this page fills up with trends, streaks and your personal rhythm.",
+ "better_refresh": "Refresh",
+ "better_loading": "Crunching your sessions…",
+ "better_error": "Could not load your stats",
+ "timer_increment_step": "step {n}",
+ "timer_increment_step_1": "step 1",
+ "timer_increment_cap_short": "capped",
+ "timer_toggle_increment_reset_long_break": "Reset After Long Break",
+ "timer_toggle_increment_reset_long_break_desc": "The first focus round after a long break starts at your base focus time.",
+ "timer_toggle_increment_reset_daily": "Reset Each Day",
+ "timer_toggle_increment_reset_daily_desc": "The first focus round of a new day starts at your base focus time.",
+ "timer_increment_reset_now": "Reset Focus Ladder",
+ "timer_increment_reset_now_desc": "Start the next round at the base focus duration. Round counters are untouched.",
+ "timer_increment_reset_done": "Ladder reset — the next round starts at the base duration.",
+ "timer_increment_hint_daily": "Durations climb with each completed work round, then reset at the start of a new day.",
+ "timer_increment_hint_long_break": "Durations climb with each completed work round, then reset after a long break.",
+ "timer_increment_hint_never": "Durations keep climbing with every completed work round until you reset the ladder.",
+ "better_heatmap_hint": "Hover a square to see that day",
+ "better_heatmap_title": "Consistency",
+ "better_heatmap_sub": "Last 120 days of focus",
+ "better_grid_title": "When you focus",
+ "better_grid_peak": "Peak slot",
+ "better_grid_hint": "Hover a cell for that hour's total",
+ "better_consistency_title": "Habit Strength",
+ "better_consistency_active": "Active days",
+ "better_consistency_avg": "Daily average",
+ "better_consistency_steady": "Steadiness",
+ "better_consistency_steady_hint": "Lower spread means a steadier routine",
+ "better_consistency_split": "Day mix",
+ "better_consistency_strong": "Strong",
+ "better_consistency_light": "Light",
+ "better_consistency_rest": "Rest",
+ "better_consistency_run": "Best run",
+ "better_span_title": "Focus window",
+ "better_span_from": "Earliest start",
+ "better_span_to": "Latest start",
+ "better_span_concentration": "Concentration",
+ "better_span_concentration_hint": "Share of all focus in your busiest day of the week",
+ "better_length_title": "Round Length Mix",
+ "better_length_under": "Under {n}m",
+ "better_length_range": "{from}–{to}m",
+ "better_length_over": "{n}m and up",
+ "better_weekday_title": "Focus by Weekday",
+ "better_hour_title": "Focus by Hour",
+ "better_progress_title": "Progress Over Time",
+ "better_progress_days": "Daily",
+ "better_progress_weeks": "Weekly",
+ "better_moving_avg": "7-day avg",
+ "better_records_title": "Personal Bests",
+ "better_records_longest_session": "Longest round",
+ "better_records_best_day": "Best day",
+ "better_records_best_week": "Best week",
+ "better_records_avg_active_day": "Avg per active day",
+ "better_delta_vs_prev": "vs prev week",
+ "better_compare_rounds": "Rounds",
+ "better_compare_focus": "Focus",
+ "better_compare_active": "Active days",
+ "better_compare_avg": "Avg / active day",
+ "better_last_90": "Last 90 Days",
+ "better_focus_per_week": "Focus Minutes per Week",
+ "better_rounds_per_week": "Rounds per Week",
+ "better_scope_recent": "Recent",
+ "better_scope_month": "Month",
+ "better_scope_year": "Year",
+ "better_prev_month": "Previous month",
+ "better_next_month": "Next month",
+ "better_prev_year": "Previous year",
+ "better_next_year": "Next year"
}
diff --git a/src/messages/pt.json b/src/messages/pt.json
index bd6f7a11..cfb1beb1 100644
--- a/src/messages/pt.json
+++ b/src/messages/pt.json
@@ -149,5 +149,120 @@
"tooltip_dial_countdown": "Quando ativado, o arco de progresso faz contagem regressiva até zero em vez de se preencher.",
"tooltip_auto_start_work": "Iniciar automaticamente a próxima rodada de trabalho quando uma pausa terminar.",
"tooltip_auto_start_break": "Iniciar automaticamente a pausa quando uma rodada de trabalho terminar.",
- "tooltip_websocket": "Ativa um servidor WebSocket local para integrações externas como overlays de streaming. Desativado por padrão."
+ "tooltip_websocket": "Ativa um servidor WebSocket local para integrações externas como overlays de streaming. Desativado por padrão.",
+ "timer_toggle_incremental": "Incremental Focus",
+ "timer_toggle_incremental_desc": "Each work round is longer than the last, up to a maximum.",
+ "timer_slider_increment": "Add per Round",
+ "timer_slider_increment_cap": "Maximum Focus",
+ "timer_increment_ladder": "Focus ladder",
+ "timer_increment_ladder_hint": "Durations climb with each completed work round, then reset after a long break or on a new day.",
+ "timer_increment_capped": "Capped — later rounds hold at the maximum focus duration.",
+ "tooltip_incremental_focus": "Incremental focus is on: each completed work round lengthens the next one.",
+ "stats_better_title": "Better Stats",
+ "stats_better_subtitle": "Your focus, measured",
+ "tooltip_better_stats": "Open Better Stats",
+ "better_section_momentum": "Momentum",
+ "better_section_trend": "Focus Trend",
+ "better_section_rhythm": "Your Rhythm",
+ "better_section_records": "Records",
+ "better_momentum_today": "Today",
+ "better_momentum_week": "Last 7 Days",
+ "better_momentum_month": "Last 28 Days",
+ "better_momentum_vs_prev": "vs previous week",
+ "better_ahead_of_average": "Ahead of your 7-day average",
+ "better_behind_average_one": "{n} round to match your average",
+ "better_behind_average": "{n} rounds to match your average",
+ "better_average_matched": "Average matched — keep going",
+ "better_no_average": "Complete a few rounds to unlock comparisons",
+ "better_focus_time": "Focus Time",
+ "better_rounds": "Rounds",
+ "better_avg_per_active_day": "Avg / active day",
+ "better_completion_rate": "Completion",
+ "better_active_days": "Active days",
+ "better_best_day": "Best day",
+ "better_no_data": "No data yet",
+ "better_trend_hint": "Rounds per day over the last 28 days",
+ "better_weeks_hint": "Rounds per week over the last 12 weeks",
+ "better_view_days": "Days",
+ "better_view_weeks": "Weeks",
+ "better_rhythm_hours": "By hour of day",
+ "better_rhythm_weekdays": "By weekday",
+ "better_records_streak": "Current streak",
+ "better_records_longest": "Longest streak",
+ "better_records_total_rounds": "Total rounds",
+ "better_records_total_focus": "Total focus",
+ "better_records_tracked_days": "Tracked days",
+ "better_records_avg_session": "Avg session",
+ "better_streak_at_risk": "Log a round today to keep it alive",
+ "better_peak_hour": "Peak hour",
+ "better_peak_weekday": "Strongest day",
+ "better_empty_title": "Nothing to measure yet",
+ "better_empty_body": "Finish your first focus round and this page fills up with trends, streaks and your personal rhythm.",
+ "better_refresh": "Refresh",
+ "better_loading": "Crunching your sessions…",
+ "better_error": "Could not load your stats",
+ "timer_increment_step": "step {n}",
+ "timer_increment_step_1": "step 1",
+ "timer_increment_cap_short": "capped",
+ "timer_toggle_increment_reset_long_break": "Reset After Long Break",
+ "timer_toggle_increment_reset_long_break_desc": "The first focus round after a long break starts at your base focus time.",
+ "timer_toggle_increment_reset_daily": "Reset Each Day",
+ "timer_toggle_increment_reset_daily_desc": "The first focus round of a new day starts at your base focus time.",
+ "timer_increment_reset_now": "Reset Focus Ladder",
+ "timer_increment_reset_now_desc": "Start the next round at the base focus duration. Round counters are untouched.",
+ "timer_increment_reset_done": "Ladder reset — the next round starts at the base duration.",
+ "timer_increment_hint_daily": "Durations climb with each completed work round, then reset at the start of a new day.",
+ "timer_increment_hint_long_break": "Durations climb with each completed work round, then reset after a long break.",
+ "timer_increment_hint_never": "Durations keep climbing with every completed work round until you reset the ladder.",
+ "better_heatmap_hint": "Hover a square to see that day",
+ "better_heatmap_title": "Consistency",
+ "better_heatmap_sub": "Last 120 days of focus",
+ "better_grid_title": "When you focus",
+ "better_grid_peak": "Peak slot",
+ "better_grid_hint": "Hover a cell for that hour's total",
+ "better_consistency_title": "Habit Strength",
+ "better_consistency_active": "Active days",
+ "better_consistency_avg": "Daily average",
+ "better_consistency_steady": "Steadiness",
+ "better_consistency_steady_hint": "Lower spread means a steadier routine",
+ "better_consistency_split": "Day mix",
+ "better_consistency_strong": "Strong",
+ "better_consistency_light": "Light",
+ "better_consistency_rest": "Rest",
+ "better_consistency_run": "Best run",
+ "better_span_title": "Focus window",
+ "better_span_from": "Earliest start",
+ "better_span_to": "Latest start",
+ "better_span_concentration": "Concentration",
+ "better_span_concentration_hint": "Share of all focus in your busiest day of the week",
+ "better_length_title": "Round Length Mix",
+ "better_length_under": "Under {n}m",
+ "better_length_range": "{from}–{to}m",
+ "better_length_over": "{n}m and up",
+ "better_weekday_title": "Focus by Weekday",
+ "better_hour_title": "Focus by Hour",
+ "better_progress_title": "Progress Over Time",
+ "better_progress_days": "Daily",
+ "better_progress_weeks": "Weekly",
+ "better_moving_avg": "7-day avg",
+ "better_records_title": "Personal Bests",
+ "better_records_longest_session": "Longest round",
+ "better_records_best_day": "Best day",
+ "better_records_best_week": "Best week",
+ "better_records_avg_active_day": "Avg per active day",
+ "better_delta_vs_prev": "vs prev week",
+ "better_compare_rounds": "Rounds",
+ "better_compare_focus": "Focus",
+ "better_compare_active": "Active days",
+ "better_compare_avg": "Avg / active day",
+ "better_last_90": "Last 90 Days",
+ "better_focus_per_week": "Focus Minutes per Week",
+ "better_rounds_per_week": "Rounds per Week",
+ "better_scope_recent": "Recent",
+ "better_scope_month": "Month",
+ "better_scope_year": "Year",
+ "better_prev_month": "Previous month",
+ "better_next_month": "Next month",
+ "better_prev_year": "Previous year",
+ "better_next_year": "Next year"
}
diff --git a/src/messages/tr.json b/src/messages/tr.json
index a950c011..a69fba4e 100644
--- a/src/messages/tr.json
+++ b/src/messages/tr.json
@@ -149,5 +149,120 @@
"tooltip_dial_countdown": "Etkinleştirildiğinde, ilerleme yayı dolmak yerine sıfıra doğru geri sayar.",
"tooltip_auto_start_work": "Bir mola bittiğinde sonraki çalışma turunu otomatik olarak başlat.",
"tooltip_auto_start_break": "Bir çalışma turu tamamlandığında molayı otomatik olarak başlat.",
- "tooltip_websocket": "Yayın yerleşimleri gibi harici entegrasyonlar için yerel bir WebSocket sunucusu etkinleştirir. Varsayılan olarak devre dışıdır."
+ "tooltip_websocket": "Yayın yerleşimleri gibi harici entegrasyonlar için yerel bir WebSocket sunucusu etkinleştirir. Varsayılan olarak devre dışıdır.",
+ "timer_toggle_incremental": "Incremental Focus",
+ "timer_toggle_incremental_desc": "Each work round is longer than the last, up to a maximum.",
+ "timer_slider_increment": "Add per Round",
+ "timer_slider_increment_cap": "Maximum Focus",
+ "timer_increment_ladder": "Focus ladder",
+ "timer_increment_ladder_hint": "Durations climb with each completed work round, then reset after a long break or on a new day.",
+ "timer_increment_capped": "Capped — later rounds hold at the maximum focus duration.",
+ "tooltip_incremental_focus": "Incremental focus is on: each completed work round lengthens the next one.",
+ "stats_better_title": "Better Stats",
+ "stats_better_subtitle": "Your focus, measured",
+ "tooltip_better_stats": "Open Better Stats",
+ "better_section_momentum": "Momentum",
+ "better_section_trend": "Focus Trend",
+ "better_section_rhythm": "Your Rhythm",
+ "better_section_records": "Records",
+ "better_momentum_today": "Today",
+ "better_momentum_week": "Last 7 Days",
+ "better_momentum_month": "Last 28 Days",
+ "better_momentum_vs_prev": "vs previous week",
+ "better_ahead_of_average": "Ahead of your 7-day average",
+ "better_behind_average_one": "{n} round to match your average",
+ "better_behind_average": "{n} rounds to match your average",
+ "better_average_matched": "Average matched — keep going",
+ "better_no_average": "Complete a few rounds to unlock comparisons",
+ "better_focus_time": "Focus Time",
+ "better_rounds": "Rounds",
+ "better_avg_per_active_day": "Avg / active day",
+ "better_completion_rate": "Completion",
+ "better_active_days": "Active days",
+ "better_best_day": "Best day",
+ "better_no_data": "No data yet",
+ "better_trend_hint": "Rounds per day over the last 28 days",
+ "better_weeks_hint": "Rounds per week over the last 12 weeks",
+ "better_view_days": "Days",
+ "better_view_weeks": "Weeks",
+ "better_rhythm_hours": "By hour of day",
+ "better_rhythm_weekdays": "By weekday",
+ "better_records_streak": "Current streak",
+ "better_records_longest": "Longest streak",
+ "better_records_total_rounds": "Total rounds",
+ "better_records_total_focus": "Total focus",
+ "better_records_tracked_days": "Tracked days",
+ "better_records_avg_session": "Avg session",
+ "better_streak_at_risk": "Log a round today to keep it alive",
+ "better_peak_hour": "Peak hour",
+ "better_peak_weekday": "Strongest day",
+ "better_empty_title": "Nothing to measure yet",
+ "better_empty_body": "Finish your first focus round and this page fills up with trends, streaks and your personal rhythm.",
+ "better_refresh": "Refresh",
+ "better_loading": "Crunching your sessions…",
+ "better_error": "Could not load your stats",
+ "timer_increment_step": "step {n}",
+ "timer_increment_step_1": "step 1",
+ "timer_increment_cap_short": "capped",
+ "timer_toggle_increment_reset_long_break": "Reset After Long Break",
+ "timer_toggle_increment_reset_long_break_desc": "The first focus round after a long break starts at your base focus time.",
+ "timer_toggle_increment_reset_daily": "Reset Each Day",
+ "timer_toggle_increment_reset_daily_desc": "The first focus round of a new day starts at your base focus time.",
+ "timer_increment_reset_now": "Reset Focus Ladder",
+ "timer_increment_reset_now_desc": "Start the next round at the base focus duration. Round counters are untouched.",
+ "timer_increment_reset_done": "Ladder reset — the next round starts at the base duration.",
+ "timer_increment_hint_daily": "Durations climb with each completed work round, then reset at the start of a new day.",
+ "timer_increment_hint_long_break": "Durations climb with each completed work round, then reset after a long break.",
+ "timer_increment_hint_never": "Durations keep climbing with every completed work round until you reset the ladder.",
+ "better_heatmap_hint": "Hover a square to see that day",
+ "better_heatmap_title": "Consistency",
+ "better_heatmap_sub": "Last 120 days of focus",
+ "better_grid_title": "When you focus",
+ "better_grid_peak": "Peak slot",
+ "better_grid_hint": "Hover a cell for that hour's total",
+ "better_consistency_title": "Habit Strength",
+ "better_consistency_active": "Active days",
+ "better_consistency_avg": "Daily average",
+ "better_consistency_steady": "Steadiness",
+ "better_consistency_steady_hint": "Lower spread means a steadier routine",
+ "better_consistency_split": "Day mix",
+ "better_consistency_strong": "Strong",
+ "better_consistency_light": "Light",
+ "better_consistency_rest": "Rest",
+ "better_consistency_run": "Best run",
+ "better_span_title": "Focus window",
+ "better_span_from": "Earliest start",
+ "better_span_to": "Latest start",
+ "better_span_concentration": "Concentration",
+ "better_span_concentration_hint": "Share of all focus in your busiest day of the week",
+ "better_length_title": "Round Length Mix",
+ "better_length_under": "Under {n}m",
+ "better_length_range": "{from}–{to}m",
+ "better_length_over": "{n}m and up",
+ "better_weekday_title": "Focus by Weekday",
+ "better_hour_title": "Focus by Hour",
+ "better_progress_title": "Progress Over Time",
+ "better_progress_days": "Daily",
+ "better_progress_weeks": "Weekly",
+ "better_moving_avg": "7-day avg",
+ "better_records_title": "Personal Bests",
+ "better_records_longest_session": "Longest round",
+ "better_records_best_day": "Best day",
+ "better_records_best_week": "Best week",
+ "better_records_avg_active_day": "Avg per active day",
+ "better_delta_vs_prev": "vs prev week",
+ "better_compare_rounds": "Rounds",
+ "better_compare_focus": "Focus",
+ "better_compare_active": "Active days",
+ "better_compare_avg": "Avg / active day",
+ "better_last_90": "Last 90 Days",
+ "better_focus_per_week": "Focus Minutes per Week",
+ "better_rounds_per_week": "Rounds per Week",
+ "better_scope_recent": "Recent",
+ "better_scope_month": "Month",
+ "better_scope_year": "Year",
+ "better_prev_month": "Previous month",
+ "better_next_month": "Next month",
+ "better_prev_year": "Previous year",
+ "better_next_year": "Next year"
}
diff --git a/src/messages/zh.json b/src/messages/zh.json
index 28ea6821..69f64b91 100644
--- a/src/messages/zh.json
+++ b/src/messages/zh.json
@@ -149,5 +149,120 @@
"tooltip_dial_countdown": "启用后，进度弧从满倒计时至零，而非从零填充。",
"tooltip_auto_start_work": "休息结束后自动开始下一个工作轮次。",
"tooltip_auto_start_break": "工作轮次结束后自动开始休息。",
- "tooltip_websocket": "启用本地 WebSocket 服务器，用于直播覆盖层等外部集成。默认禁用。"
+ "tooltip_websocket": "启用本地 WebSocket 服务器，用于直播覆盖层等外部集成。默认禁用。",
+ "timer_toggle_incremental": "Incremental Focus",
+ "timer_toggle_incremental_desc": "Each work round is longer than the last, up to a maximum.",
+ "timer_slider_increment": "Add per Round",
+ "timer_slider_increment_cap": "Maximum Focus",
+ "timer_increment_ladder": "Focus ladder",
+ "timer_increment_ladder_hint": "Durations climb with each completed work round, then reset after a long break or on a new day.",
+ "timer_increment_capped": "Capped — later rounds hold at the maximum focus duration.",
+ "tooltip_incremental_focus": "Incremental focus is on: each completed work round lengthens the next one.",
+ "stats_better_title": "Better Stats",
+ "stats_better_subtitle": "Your focus, measured",
+ "tooltip_better_stats": "Open Better Stats",
+ "better_section_momentum": "Momentum",
+ "better_section_trend": "Focus Trend",
+ "better_section_rhythm": "Your Rhythm",
+ "better_section_records": "Records",
+ "better_momentum_today": "Today",
+ "better_momentum_week": "Last 7 Days",
+ "better_momentum_month": "Last 28 Days",
+ "better_momentum_vs_prev": "vs previous week",
+ "better_ahead_of_average": "Ahead of your 7-day average",
+ "better_behind_average_one": "{n} round to match your average",
+ "better_behind_average": "{n} rounds to match your average",
+ "better_average_matched": "Average matched — keep going",
+ "better_no_average": "Complete a few rounds to unlock comparisons",
+ "better_focus_time": "Focus Time",
+ "better_rounds": "Rounds",
+ "better_avg_per_active_day": "Avg / active day",
+ "better_completion_rate": "Completion",
+ "better_active_days": "Active days",
+ "better_best_day": "Best day",
+ "better_no_data": "No data yet",
+ "better_trend_hint": "Rounds per day over the last 28 days",
+ "better_weeks_hint": "Rounds per week over the last 12 weeks",
+ "better_view_days": "Days",
+ "better_view_weeks": "Weeks",
+ "better_rhythm_hours": "By hour of day",
+ "better_rhythm_weekdays": "By weekday",
+ "better_records_streak": "Current streak",
+ "better_records_longest": "Longest streak",
+ "better_records_total_rounds": "Total rounds",
+ "better_records_total_focus": "Total focus",
+ "better_records_tracked_days": "Tracked days",
+ "better_records_avg_session": "Avg session",
+ "better_streak_at_risk": "Log a round today to keep it alive",
+ "better_peak_hour": "Peak hour",
+ "better_peak_weekday": "Strongest day",
+ "better_empty_title": "Nothing to measure yet",
+ "better_empty_body": "Finish your first focus round and this page fills up with trends, streaks and your personal rhythm.",
+ "better_refresh": "Refresh",
+ "better_loading": "Crunching your sessions…",
+ "better_error": "Could not load your stats",
+ "timer_increment_step": "step {n}",
+ "timer_increment_step_1": "step 1",
+ "timer_increment_cap_short": "capped",
+ "timer_toggle_increment_reset_long_break": "Reset After Long Break",
+ "timer_toggle_increment_reset_long_break_desc": "The first focus round after a long break starts at your base focus time.",
+ "timer_toggle_increment_reset_daily": "Reset Each Day",
+ "timer_toggle_increment_reset_daily_desc": "The first focus round of a new day starts at your base focus time.",
+ "timer_increment_reset_now": "Reset Focus Ladder",
+ "timer_increment_reset_now_desc": "Start the next round at the base focus duration. Round counters are untouched.",
+ "timer_increment_reset_done": "Ladder reset — the next round starts at the base duration.",
+ "timer_increment_hint_daily": "Durations climb with each completed work round, then reset at the start of a new day.",
+ "timer_increment_hint_long_break": "Durations climb with each completed work round, then reset after a long break.",
+ "timer_increment_hint_never": "Durations keep climbing with every completed work round until you reset the ladder.",
+ "better_heatmap_hint": "Hover a square to see that day",
+ "better_heatmap_title": "Consistency",
+ "better_heatmap_sub": "Last 120 days of focus",
+ "better_grid_title": "When you focus",
+ "better_grid_peak": "Peak slot",
+ "better_grid_hint": "Hover a cell for that hour's total",
+ "better_consistency_title": "Habit Strength",
+ "better_consistency_active": "Active days",
+ "better_consistency_avg": "Daily average",
+ "better_consistency_steady": "Steadiness",
+ "better_consistency_steady_hint": "Lower spread means a steadier routine",
+ "better_consistency_split": "Day mix",
+ "better_consistency_strong": "Strong",
+ "better_consistency_light": "Light",
+ "better_consistency_rest": "Rest",
+ "better_consistency_run": "Best run",
+ "better_span_title": "Focus window",
+ "better_span_from": "Earliest start",
+ "better_span_to": "Latest start",
+ "better_span_concentration": "Concentration",
+ "better_span_concentration_hint": "Share of all focus in your busiest day of the week",
+ "better_length_title": "Round Length Mix",
+ "better_length_under": "Under {n}m",
+ "better_length_range": "{from}–{to}m",
+ "better_length_over": "{n}m and up",
+ "better_weekday_title": "Focus by Weekday",
+ "better_hour_title": "Focus by Hour",
+ "better_progress_title": "Progress Over Time",
+ "better_progress_days": "Daily",
+ "better_progress_weeks": "Weekly",
+ "better_moving_avg": "7-day avg",
+ "better_records_title": "Personal Bests",
+ "better_records_longest_session": "Longest round",
+ "better_records_best_day": "Best day",
+ "better_records_best_week": "Best week",
+ "better_records_avg_active_day": "Avg per active day",
+ "better_delta_vs_prev": "vs prev week",
+ "better_compare_rounds": "Rounds",
+ "better_compare_focus": "Focus",
+ "better_compare_active": "Active days",
+ "better_compare_avg": "Avg / active day",
+ "better_last_90": "Last 90 Days",
+ "better_focus_per_week": "Focus Minutes per Week",
+ "better_rounds_per_week": "Rounds per Week",
+ "better_scope_recent": "Recent",
+ "better_scope_month": "Month",
+ "better_scope_year": "Year",
+ "better_prev_month": "Previous month",
+ "better_next_month": "Next month",
+ "better_prev_year": "Previous year",
+ "better_next_year": "Next year"
}
diff --git a/src/routes/+layout.svelte b/src/routes/+layout.svelte
index 8dcf734a..9f233510 100644
--- a/src/routes/+layout.svelte
+++ b/src/routes/+layout.svelte
@@ -1,5 +1,9 @@
+
+
+
+
+ {m.stats_better_title()}
+ {#if !isMac}
+ void refresh()} aria-label={m.better_refresh()}>
+
+
+
+
+
+
+
+ {/if}
+
+
+
+ {#if loading}
+
+ {m.better_loading()}
+
+ {:else if loadError}
+
+ {m.better_error()}
+ {loadError}
+ void refresh()}>{m.better_refresh()}
+
+ {:else if !hasData}
+
+ {m.better_empty_title()}
+ {m.better_empty_body()}
+
+ {:else if insights}
+
+
+ {/if}
+
+
+
+
+
+
+