+
+
+ {WEEKDAY_LABELS.map((label) => (
+
+ {label}
+
+ ))}
+
+
+
+ {WEEKDAYS.map((weekdayIndex) => (
+
+ {HOURS_OF_DAY.map((hourValue) => {
+ const cell = cellsByKey.get(`${weekdayIndex}:${hourValue}`);
+ const intensity = cell ? cell.tokens / maxTokens : 0;
+ const cellTitle = cell
+ ? `${weekdayLabel(weekdayIndex)} ${hourValue}:00 — ${formatTokens(cell.tokens)} токенов, ${cell.sessions} сессий`
+ : `${weekdayLabel(weekdayIndex)} ${hourValue}:00`;
+ return (
+
0 ? intensityColor(intensity) : "var(--color-muted)" }}
+ />
+ );
+ })}
+
+ ))}
+
+
+ 00:00
+ 06:00
+ 12:00
+ 18:00
+ 23:00
+
+
+
+
+ меньше
+ {[0.1, 0.35, 0.6, 0.85, 1].map((legendIntensity) => (
+
+ ))}
+ больше
+
+
+
+ );
+}
diff --git a/apps/web/src/ru-fork/stats/components/widgets/ModelsCard.tsx b/apps/web/src/ru-fork/stats/components/widgets/ModelsCard.tsx
new file mode 100644
index 00000000000..b1c3f777a77
--- /dev/null
+++ b/apps/web/src/ru-fork/stats/components/widgets/ModelsCard.tsx
@@ -0,0 +1,64 @@
+/**
+ * ru-fork: Analytics — tokens by model (donut + legend).
+ *
+ * @module ru-fork/stats/components/widgets/ModelsCard
+ */
+import { BotIcon } from "lucide-react";
+import { Cell, Pie, PieChart } from "recharts";
+
+import { ChartContainer, ChartTooltip, ChartTooltipContent, type ChartConfig } from "../chart";
+import { formatInt, formatPct, formatTokens } from "../../model/format";
+import type { NamedTokenSlice } from "../../model/types";
+import { chartColor, WidgetCard } from "../primitives";
+
+const MODELS_CONFIG: ChartConfig = { value: { label: "Токены" } };
+
+interface ModelsCardProps {
+ readonly models: readonly NamedTokenSlice[];
+ readonly onExpand: () => void;
+}
+
+export function ModelsCard({ models, onExpand }: ModelsCardProps) {
+ const chartData = models.map((model) => ({ modelKey: model.groupKey, label: model.label, value: model.tokens }));
+ const totalSessions = models.reduce((runningTotal, model) => runningTotal + model.sessions, 0);
+
+ return (
+
+
+
+
+ } />
+
+ {chartData.map((datum, datumIndex) => (
+ |
+ ))}
+
+
+
+
+ {models.map((model, modelIndex) => (
+ -
+
+ {model.label}
+ {formatTokens(model.tokens)}
+ {formatPct(model.sharePct, 0)}
+
+ ))}
+ {models.length === 0 ? - Нет данных
: null}
+
+
+ {formatInt(totalSessions)} сессий · окно контекста до 128K
+
+
+ );
+}
diff --git a/apps/web/src/ru-fork/stats/components/widgets/ProjectsCard.tsx b/apps/web/src/ru-fork/stats/components/widgets/ProjectsCard.tsx
new file mode 100644
index 00000000000..885f7dc6797
--- /dev/null
+++ b/apps/web/src/ru-fork/stats/components/widgets/ProjectsCard.tsx
@@ -0,0 +1,48 @@
+/**
+ * ru-fork: Analytics — top projects leaderboard (clickable → filters to project).
+ *
+ * @module ru-fork/stats/components/widgets/ProjectsCard
+ */
+import { FolderGitIcon } from "lucide-react";
+
+import { Badge } from "~/components/ui/badge";
+import { formatInt, formatTokens } from "../../model/format";
+import type { NamedTokenSlice } from "../../model/types";
+import { BarRow, chartBackground, WidgetCard } from "../primitives";
+
+interface ProjectsCardProps {
+ readonly projects: readonly NamedTokenSlice[];
+ readonly onPick: (projectId: string) => void;
+ readonly onExpand: () => void;
+}
+
+export function ProjectsCard({ projects, onPick, onExpand }: ProjectsCardProps) {
+ const maxTokens = projects[0]?.tokens ?? 1;
+ const topProjects = projects.slice(0, 6);
+
+ return (
+
+ {topProjects.map((project, projectIndex) => (
+ onPick(project.groupKey)}
+ trailing={
+ project.kind === "temp" ? (
+
+ песочница
+
+ ) : undefined
+ }
+ />
+ ))}
+ {topProjects.length === 0 ? (
+ Нет данных за период
+ ) : null}
+
+ );
+}
diff --git a/apps/web/src/ru-fork/stats/components/widgets/ReliabilityCard.tsx b/apps/web/src/ru-fork/stats/components/widgets/ReliabilityCard.tsx
new file mode 100644
index 00000000000..7ac03be7b8f
--- /dev/null
+++ b/apps/web/src/ru-fork/stats/components/widgets/ReliabilityCard.tsx
@@ -0,0 +1,92 @@
+/**
+ * ru-fork: Analytics — reliability: latency histogram, error types, approvals.
+ *
+ * @module ru-fork/stats/components/widgets/ReliabilityCard
+ */
+import { ShieldCheckIcon } from "lucide-react";
+import { Bar, BarChart, Cell, XAxis } from "recharts";
+
+import { cn } from "~/lib/utils";
+import { ChartContainer, ChartTooltip, ChartTooltipContent, type ChartConfig } from "../chart";
+import { formatInt } from "../../model/format";
+import type { ApprovalSplit, ErrorStat, LatencyBucket } from "../../model/types";
+import { WidgetCard } from "../primitives";
+
+const LATENCY_CONFIG: ChartConfig = { count: { label: "Запросы", color: "var(--color-chart-1)" } };
+
+interface ReliabilityCardProps {
+ readonly latency: readonly LatencyBucket[];
+ readonly errors: readonly ErrorStat[];
+ readonly approvals: ApprovalSplit;
+ readonly onExpand: () => void;
+}
+
+export function ReliabilityCard({ latency, errors, approvals, onExpand }: ReliabilityCardProps) {
+ const totalErrors = errors.reduce((runningTotal, errorStat) => runningTotal + errorStat.count, 0);
+ const approvalTotal = approvals.autoAccepted + approvals.rejected + approvals.manual || 1;
+
+ return (
+
+
+ Распределение задержки
+
+
+
+
+ } />
+
+ {latency.map((bucket, bucketIndex) => (
+ |
+ ))}
+
+
+
+
+
+
+
+ Ошибки
+ {formatInt(totalErrors)}
+
+
+ {errors.slice(0, 4).map((errorStat) => (
+ -
+
+
+ {errorStat.type}
+
+ {errorStat.count}
+
+ ))}
+ {errors.length === 0 ? - Ошибок нет 🎉
: null}
+
+
+
+
+ Одобрения инструментов
+
+
+
+
+
+
+
+
+
+ );
+}
+
+function ApprovalLegendRow({ colorClass, label, value }: { colorClass: string; label: string; value: number }) {
+ return (
+
+
+ {label}
+ {formatInt(value)}
+
+ );
+}
diff --git a/apps/web/src/ru-fork/stats/components/widgets/SessionsTableCard.tsx b/apps/web/src/ru-fork/stats/components/widgets/SessionsTableCard.tsx
new file mode 100644
index 00000000000..def993ded94
--- /dev/null
+++ b/apps/web/src/ru-fork/stats/components/widgets/SessionsTableCard.tsx
@@ -0,0 +1,100 @@
+/**
+ * ru-fork: Analytics — recent sessions table; a row opens the session detail.
+ *
+ * @module ru-fork/stats/components/widgets/SessionsTableCard
+ */
+import { ChevronRightIcon, TableIcon } from "lucide-react";
+
+import { Badge } from "~/components/ui/badge";
+import { formatDateTime, formatDuration, formatInt, formatTokens } from "../../model/format";
+import type { StatsSession } from "../../model/types";
+import { WidgetCard } from "../primitives";
+
+function sumRecordValues(record: Readonly
>): number {
+ let total = 0;
+ for (const value of Object.values(record)) total += value;
+ return total;
+}
+
+function visibleTokenTotal(session: StatsSession): number {
+ return session.tokens.input + session.tokens.output + session.tokens.thinking;
+}
+
+interface SessionsTableCardProps {
+ readonly sessions: readonly StatsSession[];
+ readonly onSelect: (sessionId: string) => void;
+ readonly onExpand: () => void;
+ readonly limit?: number;
+}
+
+export function SessionsTableCard({ sessions, onSelect, onExpand, limit = 10 }: SessionsTableCardProps) {
+ const visibleSessions = sessions.slice(0, limit);
+
+ return (
+
+
+
+
+
+ | Дата |
+ Проект |
+ Ветка |
+ Токены |
+ Ходы |
+ Инстр. |
+ Длит. |
+ |
+
+
+
+ {visibleSessions.map((session) => {
+ const errorCount = sumRecordValues(session.errorTypes);
+ return (
+ onSelect(session.sessionId)}
+ className="group/row cursor-pointer border-b border-border/40 last:border-0 hover:bg-accent/50"
+ >
+ | {formatDateTime(session.startedAt)} |
+
+
+ {session.projectLabel}
+ {session.projectKind === "temp" ? temp : null}
+ {session.isBackground ? фон : null}
+
+ |
+ {session.branch} |
+ {formatTokens(visibleTokenTotal(session))} |
+ {session.turns} |
+ {formatInt(sumRecordValues(session.toolCounts))} |
+ {formatDuration(session.durationMs)} |
+
+
+ {errorCount > 0 ? (
+
+ ) : null}
+
+
+ |
+
+ );
+ })}
+ {visibleSessions.length === 0 ? (
+
+ |
+ Нет сессий под текущие фильтры
+ |
+
+ ) : null}
+
+
+
+
+
+
+ } />
+
+ {slices.map((slice, sliceIndex) => (
+ |
+ ))}
+
+
+
+
+ {formatTokens(visibleTotal)}
+ токенов
+
+
+
+ {slices.map((slice, sliceIndex) => (
+ -
+
+ {slice.label}
+ {formatTokens(slice.value)}
+
+ {formatPct((slice.value / visibleTotal) * 100, 0)}
+
+
+ ))}
+ -
+
+ Из кэша
+ 0
+ 0%
+
+
+
Нет вызовов за период
+ ) : null}
+
+ );
+}
diff --git a/apps/web/src/ru-fork/stats/components/widgets/UsageOverTimeCard.tsx b/apps/web/src/ru-fork/stats/components/widgets/UsageOverTimeCard.tsx
new file mode 100644
index 00000000000..68a1fd27265
--- /dev/null
+++ b/apps/web/src/ru-fork/stats/components/widgets/UsageOverTimeCard.tsx
@@ -0,0 +1,81 @@
+/**
+ * ru-fork: Analytics — tokens-over-time hero chart (stacked area, day/week).
+ *
+ * @module ru-fork/stats/components/widgets/UsageOverTimeCard
+ */
+import { useMemo } from "react";
+import { TrendingUpIcon } from "lucide-react";
+import { Area, AreaChart, CartesianGrid, XAxis, YAxis } from "recharts";
+
+import { ChartContainer, ChartTooltip, ChartTooltipContent } from "../chart";
+import { formatDayLabel, formatTokens } from "../../model/format";
+import type { Granularity, TimeBucket } from "../../model/types";
+import { Segmented, USAGE_CHART_CONFIG, WidgetCard } from "../primitives";
+
+const GRANULARITY_OPTIONS: readonly { value: Granularity; label: string }[] = [
+ { value: "day", label: "По дням" },
+ { value: "week", label: "По неделям" },
+];
+
+const STACKED_SERIES: readonly ("input" | "output" | "thinking")[] = ["input", "output", "thinking"];
+
+interface UsageOverTimeCardProps {
+ readonly series: readonly TimeBucket[];
+ readonly granularity: Granularity;
+ readonly onGranularityChange: (granularity: Granularity) => void;
+ readonly onExpand: () => void;
+}
+
+export function UsageOverTimeCard({ series, granularity, onGranularityChange, onExpand }: UsageOverTimeCardProps) {
+ const chartData = useMemo(
+ () => series.map((bucket) => ({ ...bucket, label: formatDayLabel(bucket.bucketKey) })),
+ [series],
+ );
+
+ return (
+
+ }
+ bodyClassName="pt-2"
+ >
+
+
+
+ {STACKED_SERIES.map((seriesKey, seriesIndex) => (
+
+
+
+
+ ))}
+
+
+
+ formatTokens(tickValue)}
+ />
+ } />
+ {STACKED_SERIES.map((seriesKey, seriesIndex) => (
+
+ ))}
+
+
+
+ );
+}
diff --git a/apps/web/src/ru-fork/stats/index.ts b/apps/web/src/ru-fork/stats/index.ts
new file mode 100644
index 00000000000..9568fd4612a
--- /dev/null
+++ b/apps/web/src/ru-fork/stats/index.ts
@@ -0,0 +1,11 @@
+/**
+ * ru-fork: Analytics (stats) — public surface.
+ *
+ * A read-only Settings panel that scans the CLI's per-project chat transcripts
+ * and surfaces usage analytics (tokens, models, tools, reliability, activity).
+ * Currently driven by fake/demo data — no server logic — but the model shapes
+ * mirror the real on-disk qwen telemetry so a real loader is a drop-in later.
+ *
+ * @module ru-fork/stats
+ */
+export { StatsDashboard } from "./components/StatsDashboard";
diff --git a/apps/web/src/ru-fork/stats/model/catalog.ts b/apps/web/src/ru-fork/stats/model/catalog.ts
new file mode 100644
index 00000000000..9e07db701c8
--- /dev/null
+++ b/apps/web/src/ru-fork/stats/model/catalog.ts
@@ -0,0 +1,107 @@
+/**
+ * ru-fork: Analytics — the dimension catalog the fake generator samples from.
+ * Weights/labels are lifted from the real `projects/` scan so the demo reads
+ * like genuine usage (model, project mix, tool histogram, error types, branches).
+ *
+ * Each catalog is typed as a non-empty tuple so the weighted picker can return a
+ * definite element without any cast.
+ *
+ * @module ru-fork/stats/model/catalog
+ */
+import type { ProjectKind, ToolGroup } from "./types";
+
+/** Anything the weighted random picker can choose between. */
+export interface Weighted {
+ readonly weight: number;
+}
+
+export interface ProjectDefinition extends Weighted {
+ readonly projectId: string;
+ readonly label: string;
+ readonly path: string;
+ readonly kind: ProjectKind;
+}
+
+/** Real projects (+ a folded "sandbox" group for the many temp dirs). */
+export const PROJECTS: readonly [ProjectDefinition, ...ProjectDefinition[]] = [
+ { projectId: "ai-playground", label: "ai-playground", path: "~/WORKSPACE/Projects/ai-playground", kind: "real", weight: 38 },
+ { projectId: "atomic-code", label: "atomic-code", path: "~/WORKSPACE/Projects/experements/atomic-code", kind: "real", weight: 24 },
+ { projectId: "t3code", label: "t3code", path: "~/WORKSPACE/Projects/experements/t3code", kind: "real", weight: 20 },
+ { projectId: "t3code-copy", label: "t3code-copy", path: "~/WORKSPACE/Projects/experements/t3code-copy", kind: "real", weight: 8 },
+ { projectId: "test1", label: "test1", path: "~/WORKSPACE/test1", kind: "real", weight: 6 },
+ { projectId: "n8tb1t-tools", label: "n8tb1t-tools", path: "~/WORKSPACE/Projects/open-source/n8tb1t-tools", kind: "real", weight: 3 },
+ { projectId: "server", label: "t3code-apps-server", path: "~/WORKSPACE/Projects/experements/t3code-apps-server", kind: "real", weight: 3 },
+ { projectId: "test3", label: "test3", path: "~/WORKSPACE/test3", kind: "real", weight: 2 },
+ { projectId: "sandbox", label: "Песочница / temp", path: "/var/folders/…/acp-test-*", kind: "temp", weight: 14 },
+];
+
+export interface ModelDefinition extends Weighted {
+ readonly modelId: string;
+ readonly label: string;
+ readonly contextWindow: number;
+}
+
+/** qwen3.6-35b dominates the real data; the others give the model widget life. */
+export const MODELS: readonly [ModelDefinition, ...ModelDefinition[]] = [
+ { modelId: "qwen/qwen3.6-35b-a3b", label: "qwen3.6-35b-a3b", contextWindow: 60_000, weight: 72 },
+ { modelId: "qwen/qwen3.6-coder-7b", label: "qwen3.6-coder-7b", contextWindow: 32_000, weight: 16 },
+ { modelId: "qwen/qwen3.6-72b-a14b", label: "qwen3.6-72b-a14b", contextWindow: 128_000, weight: 12 },
+];
+
+export interface BranchDefinition extends Weighted {
+ readonly name: string;
+}
+
+export const BRANCHES: readonly [BranchDefinition, ...BranchDefinition[]] = [
+ { name: "ru-code", weight: 30 },
+ { name: "feat/qwen", weight: 26 },
+ { name: "main", weight: 20 },
+ { name: "feat/public", weight: 14 },
+ { name: "atomic-code/ab43438f", weight: 10 },
+];
+
+export interface ToolDefinition extends Weighted {
+ readonly name: string;
+ readonly group: ToolGroup;
+ /** Baseline success probability (mirrors the real per-tool ok-rate). */
+ readonly successRate: number;
+}
+
+export const TOOLS: readonly [ToolDefinition, ...ToolDefinition[]] = [
+ { name: "ask_user_question", group: "flow", weight: 159, successRate: 0.61 },
+ { name: "run_shell_command", group: "shell", weight: 132, successRate: 0.91 },
+ { name: "write_file", group: "fs", weight: 115, successRate: 0.85 },
+ { name: "read_file", group: "fs", weight: 115, successRate: 1.0 },
+ { name: "todo_write", group: "flow", weight: 80, successRate: 0.99 },
+ { name: "skill", group: "agent", weight: 69, successRate: 0.65 },
+ { name: "exit_plan_mode", group: "flow", weight: 67, successRate: 0.18 },
+ { name: "grep_search", group: "search", weight: 53, successRate: 1.0 },
+ { name: "glob", group: "search", weight: 53, successRate: 0.85 },
+ { name: "agent", group: "agent", weight: 49, successRate: 0.96 },
+ { name: "list_directory", group: "fs", weight: 30, successRate: 0.87 },
+ { name: "web_fetch", group: "web", weight: 22, successRate: 0.73 },
+ { name: "edit", group: "fs", weight: 22, successRate: 0.95 },
+ { name: "mcp__context7__query-docs", group: "mcp", weight: 6, successRate: 1.0 },
+ { name: "mcp__context7__resolve-library-id", group: "mcp", weight: 6, successRate: 1.0 },
+];
+
+export interface ErrorTypeDefinition extends Weighted {
+ readonly type: string;
+}
+
+export const ERROR_TYPES: readonly [ErrorTypeDefinition, ...ErrorTypeDefinition[]] = [
+ { type: "APIUserAbortError", weight: 28 },
+ { type: "APIError", weight: 12 },
+ { type: "BadRequestError", weight: 8 },
+ { type: "APIConnectionError", weight: 2 },
+];
+
+export const TOOL_GROUP_LABEL: Record = {
+ fs: "Файлы",
+ shell: "Shell",
+ search: "Поиск",
+ flow: "Поток",
+ agent: "Агенты",
+ mcp: "MCP",
+ web: "Веб",
+};
diff --git a/apps/web/src/ru-fork/stats/model/fakeData.ts b/apps/web/src/ru-fork/stats/model/fakeData.ts
new file mode 100644
index 00000000000..2edbfc065d4
--- /dev/null
+++ b/apps/web/src/ru-fork/stats/model/fakeData.ts
@@ -0,0 +1,56 @@
+/**
+ * ru-fork: Analytics — the demo dataset + filter-option helpers.
+ *
+ * `BASE_SESSIONS` is generated once (stable seed). `sessionsForSeed` lets the
+ * "refresh" control re-roll a near-identical dataset so the dashboard feels
+ * live (numbers nudge, ordering wobbles) without any backend.
+ *
+ * @module ru-fork/stats/model/fakeData
+ */
+import { MODELS, PROJECTS } from "./catalog";
+import { DEMO_TODAY, generateSessions } from "./generateSessions";
+import type { StatsSession } from "./types";
+
+export { DEMO_TODAY };
+
+export const BASE_SESSIONS: readonly StatsSession[] = generateSessions();
+
+/** Re-roll with a different seed (used by the manual refresh to feel live). */
+export function sessionsForSeed(seed: number): readonly StatsSession[] {
+ return generateSessions(0xc0ffee ^ (seed * 2654435761));
+}
+
+export interface FilterOption {
+ readonly value: string;
+ readonly label: string;
+}
+
+export const PROJECT_OPTIONS: readonly FilterOption[] = [
+ { value: "all", label: "Все проекты" },
+ ...PROJECTS.map((project) => ({ value: project.projectId, label: project.label })),
+];
+
+export const MODEL_OPTIONS: readonly FilterOption[] = [
+ { value: "all", label: "Все модели" },
+ ...MODELS.map((model) => ({ value: model.modelId, label: model.label })),
+];
+
+export const BRANCH_OPTIONS: readonly FilterOption[] = [
+ { value: "all", label: "Все ветки" },
+ ...Array.from(new Set(BASE_SESSIONS.map((session) => session.branch))).map((branch) => ({
+ value: branch,
+ label: branch,
+ })),
+];
+
+export interface RangeOption {
+ readonly value: number;
+ readonly label: string;
+}
+
+export const RANGE_OPTIONS: readonly RangeOption[] = [
+ { value: 7, label: "7 дней" },
+ { value: 14, label: "14 дней" },
+ { value: 30, label: "30 дней" },
+ { value: 48, label: "Всё время" },
+];
diff --git a/apps/web/src/ru-fork/stats/model/format.ts b/apps/web/src/ru-fork/stats/model/format.ts
new file mode 100644
index 00000000000..1db61760ac6
--- /dev/null
+++ b/apps/web/src/ru-fork/stats/model/format.ts
@@ -0,0 +1,84 @@
+/**
+ * ru-fork: Analytics — display formatters (tokens, counts, durations, dates).
+ * Russian-locale, compact, single source so every widget formats identically.
+ *
+ * @module ru-fork/stats/model/format
+ */
+
+function roundToOneDecimal(value: number): string {
+ const rounded = Math.round(value * 10) / 10;
+ return Number.isInteger(rounded) ? `${rounded}` : rounded.toFixed(1);
+}
+
+export function formatCompact(value: number): string {
+ if (!Number.isFinite(value)) return "—";
+ const magnitude = Math.abs(value);
+ if (magnitude >= 1_000_000_000) return `${roundToOneDecimal(value / 1_000_000_000)} млрд`;
+ if (magnitude >= 1_000_000) return `${roundToOneDecimal(value / 1_000_000)}M`;
+ if (magnitude >= 1_000) return `${roundToOneDecimal(value / 1_000)}K`;
+ return `${Math.round(value)}`;
+}
+
+export function formatTokens(value: number): string {
+ return formatCompact(value);
+}
+
+export function formatInt(value: number): string {
+ return Math.round(value).toLocaleString("ru-RU");
+}
+
+export function formatPct(value: number, fractionDigits = 1): string {
+ if (!Number.isFinite(value)) return "—";
+ return `${value.toFixed(fractionDigits)}%`;
+}
+
+export function formatSignedPct(value: number): string {
+ if (!Number.isFinite(value) || value === 0) return "0%";
+ const arrow = value > 0 ? "▲" : "▼";
+ return `${arrow}${Math.abs(value).toFixed(0)}%`;
+}
+
+export function formatDuration(milliseconds: number): string {
+ if (!Number.isFinite(milliseconds)) return "—";
+ if (milliseconds < 1000) return `${Math.round(milliseconds)}мс`;
+ const seconds = milliseconds / 1000;
+ if (seconds < 60) return `${roundToOneDecimal(seconds)}с`;
+ const minutes = Math.floor(seconds / 60);
+ const remainderSeconds = Math.round(seconds % 60);
+ return remainderSeconds ? `${minutes}м ${remainderSeconds}с` : `${minutes}м`;
+}
+
+const MONTHS_SHORT = ["янв", "фев", "мар", "апр", "мая", "июн", "июл", "авг", "сен", "окт", "ноя", "дек"];
+
+function monthShort(monthIndex: number): string {
+ return MONTHS_SHORT.at(monthIndex) ?? "";
+}
+
+/** "17 июн" from an ISO date or yyyy-mm-dd key. */
+export function formatDayLabel(isoString: string): string {
+ const date = new Date(isoString.length <= 10 ? `${isoString}T00:00:00Z` : isoString);
+ return `${date.getUTCDate()} ${monthShort(date.getUTCMonth())}`;
+}
+
+export function formatDateTime(isoString: string): string {
+ const date = new Date(isoString);
+ const hours = `${date.getUTCHours()}`.padStart(2, "0");
+ const minutes = `${date.getUTCMinutes()}`.padStart(2, "0");
+ return `${date.getUTCDate()} ${monthShort(date.getUTCMonth())}, ${hours}:${minutes}`;
+}
+
+export const WEEKDAY_LABELS: readonly string[] = ["Пн", "Вт", "Ср", "Чт", "Пт", "Сб", "Вс"];
+
+export function weekdayLabel(mondayBasedWeekday: number): string {
+ return WEEKDAY_LABELS.at(mondayBasedWeekday) ?? "";
+}
+
+/** ISO weekday index with Monday = 0. */
+export function isoWeekday(isoString: string): number {
+ const sundayBasedDay = new Date(isoString).getUTCDay(); // 0=Sunday
+ return (sundayBasedDay + 6) % 7;
+}
+
+export function dayKey(isoString: string): string {
+ return isoString.slice(0, 10);
+}
diff --git a/apps/web/src/ru-fork/stats/model/generateSessions.ts b/apps/web/src/ru-fork/stats/model/generateSessions.ts
new file mode 100644
index 00000000000..d3c9dd1a539
--- /dev/null
+++ b/apps/web/src/ru-fork/stats/model/generateSessions.ts
@@ -0,0 +1,164 @@
+/**
+ * ru-fork: Analytics — deterministic fake-session generator.
+ *
+ * A seeded PRNG (mulberry32) makes the dataset stable across reloads so the
+ * dashboard looks the same every time (and snapshots/screenshots are diffable).
+ * Timestamps hang off a fixed "today" so the demo never drifts. Pure: no I/O.
+ *
+ * @module ru-fork/stats/model/generateSessions
+ */
+import { BRANCHES, ERROR_TYPES, MODELS, PROJECTS, TOOLS, type Weighted } from "./catalog";
+import type { StatsSession } from "./types";
+
+/** Anchor day for the whole demo (matches the real scan's last day). */
+export const DEMO_TODAY = "2026-06-17";
+const MILLISECONDS_PER_DAY = 86_400_000;
+const MILLISECONDS_PER_HOUR = 3_600_000;
+const GENERATED_SPAN_DAYS = 48;
+const GENERATED_SESSION_COUNT = 168;
+
+/** Returns a deterministic [0, 1) generator seeded from `seed`. */
+function createSeededRandom(seed: number): () => number {
+ let state = seed >>> 0;
+ return () => {
+ state |= 0;
+ state = (state + 0x6d2b79f5) | 0;
+ let mixed = Math.imul(state ^ (state >>> 15), 1 | state);
+ mixed = (mixed + Math.imul(mixed ^ (mixed >>> 7), 61 | mixed)) ^ mixed;
+ return ((mixed ^ (mixed >>> 14)) >>> 0) / 4294967296;
+ };
+}
+
+/** Pick one element with probability proportional to its weight. */
+function pickWeighted- (
+ random: () => number,
+ items: readonly [Item, ...Item[]],
+): Item {
+ const totalWeight = items.reduce((runningWeight, candidate) => runningWeight + candidate.weight, 0);
+ let threshold = random() * totalWeight;
+ let chosen = items[0];
+ for (const candidate of items) {
+ chosen = candidate;
+ threshold -= candidate.weight;
+ if (threshold <= 0) break;
+ }
+ return chosen;
+}
+
+function randomInt(random: () => number, minimum: number, maximum: number): number {
+ return Math.floor(minimum + random() * (maximum - minimum + 1));
+}
+
+/** Heavier activity on working/evening hours so the heatmap looks real. */
+function pickActiveHour(random: () => number): number {
+ const activeHours: readonly number[] = [9, 10, 11, 14, 15, 16, 17, 21, 22, 23, 1];
+ if (random() < 0.72) {
+ const position = randomInt(random, 0, activeHours.length - 1);
+ return activeHours.at(position) ?? randomInt(random, 0, 23);
+ }
+ return randomInt(random, 0, 23);
+}
+
+interface ToolUsage {
+ readonly callsByTool: Record;
+ readonly failuresByTool: Record;
+ readonly totalCalls: number;
+ readonly failedCalls: number;
+}
+
+function buildToolUsage(random: () => number, intensity: number): ToolUsage {
+ const callsByTool: Record = {};
+ const failuresByTool: Record = {};
+ let totalCalls = 0;
+ let failedCalls = 0;
+ const distinctToolPicks = randomInt(random, 2, 6) + Math.round(intensity * 4);
+ for (let pickIndex = 0; pickIndex < distinctToolPicks; pickIndex += 1) {
+ const tool = pickWeighted(random, TOOLS);
+ const callCount = randomInt(random, 1, 4);
+ callsByTool[tool.name] = (callsByTool[tool.name] ?? 0) + callCount;
+ totalCalls += callCount;
+ let failuresForTool = 0;
+ for (let attempt = 0; attempt < callCount; attempt += 1) {
+ if (random() > tool.successRate) failuresForTool += 1;
+ }
+ if (failuresForTool > 0) {
+ failuresByTool[tool.name] = (failuresByTool[tool.name] ?? 0) + failuresForTool;
+ failedCalls += failuresForTool;
+ }
+ }
+ return { callsByTool, failuresByTool, totalCalls, failedCalls };
+}
+
+const EMPTY_TOOL_USAGE: ToolUsage = { callsByTool: {}, failuresByTool: {}, totalCalls: 0, failedCalls: 0 };
+
+export function generateSessions(seed = 0xc0ffee): readonly StatsSession[] {
+ const random = createSeededRandom(seed);
+ const anchorMs = Date.parse(`${DEMO_TODAY}T23:59:59.000Z`);
+ const sessions: StatsSession[] = [];
+
+ for (let sessionIndex = 0; sessionIndex < GENERATED_SESSION_COUNT; sessionIndex += 1) {
+ const project = pickWeighted(random, PROJECTS);
+ const model = pickWeighted(random, MODELS);
+ const branch = pickWeighted(random, BRANCHES);
+
+ // Recency bias: more sessions in the recent weeks.
+ const dayOffset = Math.floor(random() ** 1.7 * GENERATED_SPAN_DAYS);
+ const hour = pickActiveHour(random);
+ const startedAtMs =
+ anchorMs -
+ dayOffset * MILLISECONDS_PER_DAY -
+ (24 - hour) * MILLISECONDS_PER_HOUR -
+ randomInt(random, 0, 3_540_000) * 1000;
+ const startedAt = new Date(startedAtMs).toISOString();
+
+ const isBackground = random() < 0.06;
+ const intensity = random() ** 1.5; // 0..1 skewed small
+ const turns = isBackground ? 1 : randomInt(random, 1, 4) + Math.round(intensity * 22);
+ const apiCalls = isBackground ? 1 : turns + randomInt(random, 0, turns);
+
+ // Input dominates (context re-sent each call); output is small.
+ const inputPerCall = randomInt(random, 9_000, 22_000) + Math.round(intensity * 30_000);
+ const inputTokens = inputPerCall * apiCalls;
+ const outputTokens = apiCalls * randomInt(random, 60, 520);
+ const thinkingTokens = random() < 0.3 ? apiCalls * randomInt(random, 0, 30) : 0;
+
+ const toolUsage = isBackground ? EMPTY_TOOL_USAGE : buildToolUsage(random, intensity);
+
+ const errorTypes: Record = {};
+ if (random() < 0.22) {
+ const errorType = pickWeighted(random, ERROR_TYPES);
+ errorTypes[errorType.type] = randomInt(random, 1, 2);
+ }
+
+ const autoAccepted = Math.round(toolUsage.totalCalls * 0.15 * random());
+ const rejected = random() < 0.08 ? randomInt(random, 1, 2) : 0;
+
+ const avgLatencyMs = randomInt(random, 4_000, 16_000) + Math.round(intensity * 9_000);
+ const maxLatencyMs = avgLatencyMs + randomInt(random, 2_000, 60_000);
+
+ sessions.push({
+ sessionId: `session-${(sessionIndex + 1).toString().padStart(3, "0")}-${Math.floor(random() * 1e6).toString(36)}`,
+ projectId: project.projectId,
+ projectLabel: project.label,
+ projectPath: project.path,
+ projectKind: project.kind,
+ branch: branch.name,
+ model: model.modelId,
+ startedAt,
+ durationMs: Math.max(turns, 1) * randomInt(random, 25_000, 95_000),
+ turns,
+ isBackground,
+ apiCalls,
+ tokens: { input: inputTokens, output: outputTokens, thinking: thinkingTokens, cached: 0 },
+ avgLatencyMs,
+ maxLatencyMs,
+ toolCounts: toolUsage.callsByTool,
+ toolFailures: toolUsage.failuresByTool,
+ errorTypes,
+ autoAccepted,
+ rejected,
+ });
+ }
+
+ return sessions.toSorted((first, second) => second.startedAt.localeCompare(first.startedAt));
+}
diff --git a/apps/web/src/ru-fork/stats/model/selectors.ts b/apps/web/src/ru-fork/stats/model/selectors.ts
new file mode 100644
index 00000000000..756b22d0091
--- /dev/null
+++ b/apps/web/src/ru-fork/stats/model/selectors.ts
@@ -0,0 +1,330 @@
+/**
+ * ru-fork: Analytics — pure aggregation. Filters narrow the session set; this
+ * turns the survivors into every widget's view model. One source of truth: change
+ * a filter and the KPIs, charts, tables and heatmap all recompute from here.
+ *
+ * @module ru-fork/stats/model/selectors
+ */
+import { TOOLS } from "./catalog";
+import { DEMO_TODAY } from "./generateSessions";
+import { dayKey, isoWeekday } from "./format";
+import type {
+ ApprovalSplit,
+ ErrorStat,
+ Granularity,
+ HeatCell,
+ KpiSet,
+ LatencyBucket,
+ NamedTokenSlice,
+ StatsFilters,
+ StatsSession,
+ StatsView,
+ TimeBucket,
+ ToolGroup,
+ ToolStat,
+ TokenBreakdown,
+} from "./types";
+
+const MILLISECONDS_PER_DAY = 86_400_000;
+const ANCHOR_MS = Date.parse(`${DEMO_TODAY}T23:59:59.000Z`);
+
+const TOOL_GROUP_BY_NAME: ReadonlyMap = new Map(
+ TOOLS.map((tool) => [tool.name, tool.group]),
+);
+function toolGroupForName(toolName: string): ToolGroup {
+ return TOOL_GROUP_BY_NAME.get(toolName) ?? (toolName.startsWith("mcp__") ? "mcp" : "flow");
+}
+
+function startsWithinRange(session: StatsSession, rangeDays: number, anchorMs = ANCHOR_MS): boolean {
+ const cutoffMs = anchorMs - rangeDays * MILLISECONDS_PER_DAY;
+ return Date.parse(session.startedAt) >= cutoffMs;
+}
+
+function matchesDimensions(session: StatsSession, filters: StatsFilters): boolean {
+ if (!filters.includeTemp && session.projectKind === "temp") return false;
+ if (filters.projectId !== "all" && session.projectId !== filters.projectId) return false;
+ if (filters.model !== "all" && session.model !== filters.model) return false;
+ if (filters.branch !== "all" && session.branch !== filters.branch) return false;
+ return true;
+}
+
+export function filterSessions(
+ sessions: readonly StatsSession[],
+ filters: StatsFilters,
+): readonly StatsSession[] {
+ return sessions.filter((session) => {
+ if (!matchesDimensions(session, filters)) return false;
+ if (filters.traffic === "turns" && session.isBackground) return false;
+ if (filters.traffic === "background" && !session.isBackground) return false;
+ return startsWithinRange(session, filters.rangeDays);
+ });
+}
+
+function sumTokens(sessions: readonly StatsSession[]): TokenBreakdown {
+ return sessions.reduce(
+ (accumulator, session) => ({
+ input: accumulator.input + session.tokens.input,
+ output: accumulator.output + session.tokens.output,
+ thinking: accumulator.thinking + session.tokens.thinking,
+ cached: accumulator.cached + session.tokens.cached,
+ }),
+ { input: 0, output: 0, thinking: 0, cached: 0 },
+ );
+}
+
+function visibleTotal(tokens: TokenBreakdown): number {
+ return tokens.input + tokens.output + tokens.thinking;
+}
+
+function sumRecordValues(record: Readonly>): number {
+ let total = 0;
+ for (const value of Object.values(record)) total += value;
+ return total;
+}
+
+function buildKpis(
+ allSessions: readonly StatsSession[],
+ filteredSessions: readonly StatsSession[],
+ filters: StatsFilters,
+): KpiSet {
+ const tokens = sumTokens(filteredSessions);
+ const apiCalls = filteredSessions.reduce((total, session) => total + session.apiCalls, 0);
+ const toolCalls = filteredSessions.reduce((total, session) => total + sumRecordValues(session.toolCounts), 0);
+ const errors = filteredSessions.reduce((total, session) => total + sumRecordValues(session.errorTypes), 0);
+ const latencyWeighted = filteredSessions.reduce(
+ (total, session) => total + session.avgLatencyMs * session.apiCalls,
+ 0,
+ );
+ const projectCount = new Set(filteredSessions.map((session) => session.projectId)).size;
+
+ // Previous equal-length window for the trend chips.
+ const previousWindowEndMs = ANCHOR_MS - filters.rangeDays * MILLISECONDS_PER_DAY;
+ const previousWindowStartMs = previousWindowEndMs - filters.rangeDays * MILLISECONDS_PER_DAY;
+ const previousSessions = allSessions.filter((session) => {
+ if (!matchesDimensions(session, filters)) return false;
+ const startedMs = Date.parse(session.startedAt);
+ return startedMs >= previousWindowStartMs && startedMs < previousWindowEndMs;
+ });
+ const previousTokens = visibleTotal(sumTokens(previousSessions));
+ const currentTokens = visibleTotal(tokens);
+ const tokensDeltaPct = previousTokens > 0 ? ((currentTokens - previousTokens) / previousTokens) * 100 : 0;
+
+ return {
+ totalTokens: currentTokens,
+ inputTokens: tokens.input,
+ outputTokens: tokens.output,
+ thinkingTokens: tokens.thinking,
+ cachedTokens: tokens.cached,
+ apiCalls,
+ toolCalls,
+ sessions: filteredSessions.length,
+ projects: projectCount,
+ errors,
+ errorRatePct: apiCalls > 0 ? (errors / apiCalls) * 100 : 0,
+ avgLatencyMs: apiCalls > 0 ? latencyWeighted / apiCalls : 0,
+ tokensDeltaPct,
+ };
+}
+
+interface MutableTimeBucket {
+ bucketKey: string;
+ label: string;
+ input: number;
+ output: number;
+ thinking: number;
+ total: number;
+ calls: number;
+}
+
+function weekStartKey(isoString: string): string {
+ const mondayMs = Date.parse(isoString) - isoWeekday(isoString) * MILLISECONDS_PER_DAY;
+ return new Date(mondayMs).toISOString().slice(0, 10);
+}
+
+function buildSeries(sessions: readonly StatsSession[], granularity: Granularity): readonly TimeBucket[] {
+ const bucketsByKey = new Map();
+ for (const session of sessions) {
+ const bucketKey = granularity === "day" ? dayKey(session.startedAt) : weekStartKey(session.startedAt);
+ const bucket =
+ bucketsByKey.get(bucketKey) ??
+ { bucketKey, label: bucketKey, input: 0, output: 0, thinking: 0, total: 0, calls: 0 };
+ bucket.input += session.tokens.input;
+ bucket.output += session.tokens.output;
+ bucket.thinking += session.tokens.thinking;
+ bucket.total += visibleTotal(session.tokens);
+ bucket.calls += session.apiCalls;
+ bucketsByKey.set(bucketKey, bucket);
+ }
+ return Array.from(bucketsByKey.values()).toSorted((first, second) =>
+ first.bucketKey.localeCompare(second.bucketKey),
+ );
+}
+
+interface GroupDescriptor {
+ readonly groupKey: string;
+ readonly label: string;
+ readonly kind?: StatsSession["projectKind"] | undefined;
+}
+
+interface MutableSlice {
+ label: string;
+ tokens: number;
+ sessions: number;
+ kind?: StatsSession["projectKind"] | undefined;
+}
+
+function groupSlices(
+ sessions: readonly StatsSession[],
+ describeGroup: (session: StatsSession) => GroupDescriptor,
+): readonly NamedTokenSlice[] {
+ const slicesByKey = new Map();
+ let grandTotal = 0;
+ for (const session of sessions) {
+ const descriptor = describeGroup(session);
+ const sessionTokens = visibleTotal(session.tokens);
+ grandTotal += sessionTokens;
+ const slice =
+ slicesByKey.get(descriptor.groupKey) ??
+ { label: descriptor.label, tokens: 0, sessions: 0, kind: descriptor.kind };
+ slice.tokens += sessionTokens;
+ slice.sessions += 1;
+ slicesByKey.set(descriptor.groupKey, slice);
+ }
+ return Array.from(slicesByKey.entries())
+ .map(([groupKey, slice]) => ({
+ groupKey,
+ label: slice.label,
+ tokens: slice.tokens,
+ sessions: slice.sessions,
+ kind: slice.kind,
+ sharePct: grandTotal > 0 ? (slice.tokens / grandTotal) * 100 : 0,
+ }))
+ .toSorted((first, second) => second.tokens - first.tokens);
+}
+
+function buildTools(sessions: readonly StatsSession[]): readonly ToolStat[] {
+ const callsByTool = new Map();
+ const failuresByTool = new Map();
+ for (const session of sessions) {
+ for (const [toolName, callCount] of Object.entries(session.toolCounts)) {
+ callsByTool.set(toolName, (callsByTool.get(toolName) ?? 0) + callCount);
+ }
+ for (const [toolName, failureCount] of Object.entries(session.toolFailures)) {
+ failuresByTool.set(toolName, (failuresByTool.get(toolName) ?? 0) + failureCount);
+ }
+ }
+ return Array.from(callsByTool.entries())
+ .map(([toolName, calls]) => {
+ const failures = failuresByTool.get(toolName) ?? 0;
+ return {
+ name: toolName,
+ calls,
+ failures,
+ successPct: calls > 0 ? ((calls - failures) / calls) * 100 : 0,
+ group: toolGroupForName(toolName),
+ };
+ })
+ .toSorted((first, second) => second.calls - first.calls);
+}
+
+function buildErrors(sessions: readonly StatsSession[]): readonly ErrorStat[] {
+ const countsByType = new Map();
+ let totalErrors = 0;
+ for (const session of sessions) {
+ for (const [errorType, count] of Object.entries(session.errorTypes)) {
+ countsByType.set(errorType, (countsByType.get(errorType) ?? 0) + count);
+ totalErrors += count;
+ }
+ }
+ return Array.from(countsByType.entries())
+ .map(([errorType, count]) => ({
+ type: errorType,
+ count,
+ sharePct: totalErrors > 0 ? (count / totalErrors) * 100 : 0,
+ }))
+ .toSorted((first, second) => second.count - first.count);
+}
+
+function buildApprovals(sessions: readonly StatsSession[]): ApprovalSplit {
+ let autoAccepted = 0;
+ let rejected = 0;
+ let toolCalls = 0;
+ for (const session of sessions) {
+ autoAccepted += session.autoAccepted;
+ rejected += session.rejected;
+ toolCalls += sumRecordValues(session.toolCounts);
+ }
+ return { autoAccepted, rejected, manual: Math.max(0, toolCalls - autoAccepted - rejected) };
+}
+
+const LATENCY_BUCKETS: readonly { readonly label: string; readonly maximumMs: number }[] = [
+ { label: "<5с", maximumMs: 5_000 },
+ { label: "5–10с", maximumMs: 10_000 },
+ { label: "10–20с", maximumMs: 20_000 },
+ { label: "20–40с", maximumMs: 40_000 },
+ { label: "40с+", maximumMs: Number.POSITIVE_INFINITY },
+];
+
+function buildLatency(sessions: readonly StatsSession[]): readonly LatencyBucket[] {
+ const counts = LATENCY_BUCKETS.map((bucket) => ({ label: bucket.label, count: 0 }));
+ for (const session of sessions) {
+ const matchIndex = LATENCY_BUCKETS.findIndex((bucket) => session.avgLatencyMs < bucket.maximumMs);
+ const targetIndex = matchIndex === -1 ? LATENCY_BUCKETS.length - 1 : matchIndex;
+ const target = counts[targetIndex];
+ if (target) target.count += session.apiCalls;
+ }
+ return counts;
+}
+
+interface MutableHeatCell {
+ weekday: number;
+ hour: number;
+ tokens: number;
+ sessions: number;
+}
+
+function buildHeatmap(sessions: readonly StatsSession[]): readonly HeatCell[] {
+ const cellsByKey = new Map();
+ for (const session of sessions) {
+ const weekday = isoWeekday(session.startedAt);
+ const hour = new Date(session.startedAt).getUTCHours();
+ const cellKey = `${weekday}:${hour}`;
+ const cell = cellsByKey.get(cellKey) ?? { weekday, hour, tokens: 0, sessions: 0 };
+ cell.tokens += visibleTotal(session.tokens);
+ cell.sessions += 1;
+ cellsByKey.set(cellKey, cell);
+ }
+ return Array.from(cellsByKey.values());
+}
+
+export function buildView(
+ allSessions: readonly StatsSession[],
+ filters: StatsFilters,
+ granularity: Granularity,
+): StatsView {
+ const filteredSessions = filterSessions(allSessions, filters);
+ return {
+ kpis: buildKpis(allSessions, filteredSessions, filters),
+ series: buildSeries(filteredSessions, granularity),
+ composition: sumTokens(filteredSessions),
+ byModel: groupSlices(filteredSessions, (session) => ({
+ groupKey: session.model,
+ label: session.model.replace("qwen/", ""),
+ })),
+ byProject: groupSlices(filteredSessions, (session) => ({
+ groupKey: session.projectId,
+ label: session.projectLabel,
+ kind: session.projectKind,
+ })),
+ byBranch: groupSlices(filteredSessions, (session) => ({
+ groupKey: session.branch,
+ label: session.branch,
+ })),
+ tools: buildTools(filteredSessions),
+ errors: buildErrors(filteredSessions),
+ approvals: buildApprovals(filteredSessions),
+ latency: buildLatency(filteredSessions),
+ heatmap: buildHeatmap(filteredSessions),
+ sessions: filteredSessions,
+ };
+}
diff --git a/apps/web/src/ru-fork/stats/model/types.ts b/apps/web/src/ru-fork/stats/model/types.ts
new file mode 100644
index 00000000000..d93b3c5a00d
--- /dev/null
+++ b/apps/web/src/ru-fork/stats/model/types.ts
@@ -0,0 +1,150 @@
+/**
+ * ru-fork: Analytics (stats) — domain types.
+ *
+ * Everything the dashboard renders derives from a single atomic unit, a
+ * {@link StatsSession} (one CLI chat). Filters narrow the session set; the
+ * selectors aggregate the survivors into the per-widget view models. This is
+ * fake/demo data — no server logic — but the shapes mirror what the real
+ * on-disk qwen telemetry (`qwen-code.api_response` / `.tool_call` / `.api_error`)
+ * would yield, so swapping in a real loader later is a drop-in.
+ *
+ * @module ru-fork/stats/model/types
+ */
+
+export type ProjectKind = "real" | "temp";
+
+export interface TokenBreakdown {
+ readonly input: number;
+ readonly output: number;
+ readonly thinking: number;
+ readonly cached: number;
+}
+
+/** One CLI chat session — the atomic record all widgets aggregate from. */
+export interface StatsSession {
+ readonly sessionId: string;
+ readonly projectId: string;
+ readonly projectLabel: string;
+ readonly projectPath: string;
+ readonly projectKind: ProjectKind;
+ readonly branch: string;
+ readonly model: string;
+ /** ISO timestamp of the session start. */
+ readonly startedAt: string;
+ readonly durationMs: number;
+ readonly turns: number;
+ readonly isBackground: boolean;
+ readonly apiCalls: number;
+ readonly tokens: TokenBreakdown;
+ readonly avgLatencyMs: number;
+ readonly maxLatencyMs: number;
+ /** functionName -> call count. */
+ readonly toolCounts: Readonly>;
+ /** functionName -> failed call count (subset of toolCounts). */
+ readonly toolFailures: Readonly>;
+ /** errorType -> count. */
+ readonly errorTypes: Readonly>;
+ readonly autoAccepted: number;
+ readonly rejected: number;
+}
+
+/** Active dashboard filters (lives in the store). */
+export interface StatsFilters {
+ readonly rangeDays: RangeDays;
+ readonly projectId: string | "all";
+ readonly model: string | "all";
+ readonly branch: string | "all";
+ readonly includeTemp: boolean;
+ readonly traffic: TrafficFilter;
+}
+
+export type RangeDays = 7 | 14 | 30 | 48;
+export type TrafficFilter = "all" | "turns" | "background";
+export type Granularity = "day" | "week";
+
+// ── derived view models (selector outputs) ──────────────────────────────────
+
+export interface KpiSet {
+ readonly totalTokens: number;
+ readonly inputTokens: number;
+ readonly outputTokens: number;
+ readonly thinkingTokens: number;
+ readonly cachedTokens: number;
+ readonly apiCalls: number;
+ readonly toolCalls: number;
+ readonly sessions: number;
+ readonly projects: number;
+ readonly errors: number;
+ readonly errorRatePct: number;
+ readonly avgLatencyMs: number;
+ readonly tokensDeltaPct: number;
+}
+
+export interface TimeBucket {
+ readonly bucketKey: string;
+ readonly label: string;
+ readonly input: number;
+ readonly output: number;
+ readonly thinking: number;
+ readonly total: number;
+ readonly calls: number;
+}
+
+export interface NamedTokenSlice {
+ readonly groupKey: string;
+ readonly label: string;
+ readonly tokens: number;
+ readonly sessions: number;
+ readonly sharePct: number;
+ readonly kind?: ProjectKind | undefined;
+}
+
+export interface ToolStat {
+ readonly name: string;
+ readonly calls: number;
+ readonly failures: number;
+ readonly successPct: number;
+ readonly group: ToolGroup;
+}
+
+export type ToolGroup = "fs" | "shell" | "search" | "flow" | "agent" | "mcp" | "web";
+
+export interface ErrorStat {
+ readonly type: string;
+ readonly count: number;
+ readonly sharePct: number;
+}
+
+export interface HeatCell {
+ readonly weekday: number; // 0=Monday
+ readonly hour: number; // 0..23
+ readonly tokens: number;
+ readonly sessions: number;
+}
+
+export interface ApprovalSplit {
+ readonly autoAccepted: number;
+ readonly rejected: number;
+ readonly manual: number;
+}
+
+export interface LatencyBucket {
+ readonly label: string;
+ readonly count: number;
+}
+
+/** The fully-aggregated dashboard payload for the current filters. */
+export interface StatsView {
+ readonly kpis: KpiSet;
+ readonly series: readonly TimeBucket[];
+ readonly composition: TokenBreakdown;
+ readonly byModel: readonly NamedTokenSlice[];
+ readonly byProject: readonly NamedTokenSlice[];
+ readonly byBranch: readonly NamedTokenSlice[];
+ readonly tools: readonly ToolStat[];
+ readonly errors: readonly ErrorStat[];
+ readonly approvals: ApprovalSplit;
+ readonly latency: readonly LatencyBucket[];
+ readonly heatmap: readonly HeatCell[];
+ readonly sessions: readonly StatsSession[];
+}
diff --git a/apps/web/src/ru-fork/stats/store.ts b/apps/web/src/ru-fork/stats/store.ts
new file mode 100644
index 00000000000..203cfb4d92f
--- /dev/null
+++ b/apps/web/src/ru-fork/stats/store.ts
@@ -0,0 +1,106 @@
+/**
+ * ru-fork: Analytics — UI state (zustand) + the derived-view hook.
+ *
+ * Holds filters, chart granularity, the refresh cadence setting, and which
+ * drill-down (widget detail / session) is open. The actual numbers are derived
+ * by {@link useStatsView} from the fake session set for the current seed —
+ * "refresh" just bumps the seed + stamps a time, so it feels live, 0 server.
+ *
+ * @module ru-fork/stats/store
+ */
+import { useMemo } from "react";
+import { create } from "zustand";
+
+import { BASE_SESSIONS, sessionsForSeed } from "./model/fakeData";
+import { buildView } from "./model/selectors";
+import type { Granularity, StatsFilters, StatsSession, StatsView } from "./model/types";
+
+/** Which expandable widget detail panel is open. */
+export type WidgetId =
+ | "usage"
+ | "models"
+ | "projects"
+ | "tools"
+ | "reliability"
+ | "activity"
+ | "branches"
+ | "composition";
+
+export interface RefreshIntervalOption {
+ readonly value: number;
+ readonly label: string;
+}
+
+export const REFRESH_INTERVAL_OPTIONS: readonly RefreshIntervalOption[] = [
+ { value: 5, label: "5 минут" },
+ { value: 15, label: "15 минут" },
+ { value: 30, label: "30 минут" },
+ { value: 60, label: "1 час" },
+ { value: 360, label: "6 часов" },
+];
+
+const DEFAULT_FILTERS: StatsFilters = {
+ rangeDays: 30,
+ projectId: "all",
+ model: "all",
+ branch: "all",
+ includeTemp: false,
+ traffic: "all",
+};
+
+interface StatsState {
+ readonly filters: StatsFilters;
+ readonly granularity: Granularity;
+ readonly refreshIntervalMin: number;
+ readonly seed: number;
+ readonly lastRefreshedAtMs: number;
+ readonly isRefreshing: boolean;
+ readonly openWidget: WidgetId | null;
+ readonly selectedSessionId: string | null;
+
+ readonly setFilters: (patch: Partial) => void;
+ readonly resetFilters: () => void;
+ readonly setGranularity: (granularity: Granularity) => void;
+ readonly setRefreshIntervalMin: (refreshIntervalMin: number) => void;
+ readonly startRefresh: () => void;
+ readonly finishRefresh: () => void;
+ readonly openWidgetDetail: (widget: WidgetId | null) => void;
+ readonly selectSession: (sessionId: string | null) => void;
+}
+
+export const useStatsStore = create()((set) => ({
+ filters: DEFAULT_FILTERS,
+ granularity: "day",
+ refreshIntervalMin: 30,
+ seed: 0,
+ lastRefreshedAtMs: Date.now(),
+ isRefreshing: false,
+ openWidget: null,
+ selectedSessionId: null,
+
+ setFilters: (patch) => set((state) => ({ filters: { ...state.filters, ...patch } })),
+ resetFilters: () => set({ filters: DEFAULT_FILTERS }),
+ setGranularity: (granularity) => set({ granularity }),
+ setRefreshIntervalMin: (refreshIntervalMin) => set({ refreshIntervalMin }),
+ startRefresh: () => set({ isRefreshing: true }),
+ finishRefresh: () =>
+ set((state) => ({ isRefreshing: false, seed: state.seed + 1, lastRefreshedAtMs: Date.now() })),
+ openWidgetDetail: (openWidget) => set({ openWidget }),
+ selectSession: (selectedSessionId) => set({ selectedSessionId }),
+}));
+
+/** Derived dashboard view for the active filters/seed. Memoized per input. */
+export function useStatsView(): StatsView {
+ const filters = useStatsStore((state) => state.filters);
+ const granularity = useStatsStore((state) => state.granularity);
+ const seed = useStatsStore((state) => state.seed);
+ return useMemo(() => {
+ const sessions = seed === 0 ? BASE_SESSIONS : sessionsForSeed(seed);
+ return buildView(sessions, filters, granularity);
+ }, [filters, granularity, seed]);
+}
+
+export function findSessionById(view: StatsView, sessionId: string | null): StatsSession | null {
+ if (!sessionId) return null;
+ return view.sessions.find((session) => session.sessionId === sessionId) ?? null;
+}
diff --git a/apps/web/src/themes/ru-fork.css b/apps/web/src/themes/ru-fork.css
index 4ec425c5764..fa20546f401 100644
--- a/apps/web/src/themes/ru-fork.css
+++ b/apps/web/src/themes/ru-fork.css
@@ -29,6 +29,13 @@
--success-foreground: var(--color-emerald-700);
--warning: var(--color-amber-500);
--warning-foreground: var(--color-amber-700);
+ /* ru-fork: chart series palette (shadcn --chart-* convention), tuned to the
+ blue primary so analytics charts inherit the default theme. */
+ --chart-1: oklch(0.55 0.2 264);
+ --chart-2: oklch(0.62 0.16 162);
+ --chart-3: oklch(0.68 0.15 70);
+ --chart-4: oklch(0.58 0.22 18);
+ --chart-5: oklch(0.55 0.2 310);
}
.dark[data-theme="ru-fork"] {
@@ -59,5 +66,10 @@
--success-foreground: var(--color-emerald-400);
--warning: var(--color-amber-500);
--warning-foreground: var(--color-amber-400);
+ --chart-1: oklch(0.62 0.19 264);
+ --chart-2: oklch(0.7 0.15 162);
+ --chart-3: oklch(0.75 0.14 70);
+ --chart-4: oklch(0.66 0.2 18);
+ --chart-5: oklch(0.64 0.19 310);
}
}