diff --git a/client/src/App.tsx b/client/src/App.tsx
index 091b0c5..420492c 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -14,6 +14,7 @@ import { useToast } from "@/hooks/use-toast";
 import { usePrefetchOfflineTasks } from "@/hooks/usePrefetchOfflineTasks";
 import { useEvents } from "@/hooks/useEvents";
 import { usePwaFontSize } from "@/hooks/usePwaFontSize";
+import { useGpsTracking } from "@/hooks/useGpsTracking";
 import { GlobalErrorBoundary } from "@/components/GlobalErrorBoundary";
 import { Loader2 } from "lucide-react";
 
@@ -78,6 +79,7 @@ const DashboardPage = safeLazy(() => import("@/pages/DashboardPage"));
 const CalendarPage = safeLazy(() => import("@/pages/CalendarPage"));
 const GanttPage = safeLazy(() => import("@/pages/GanttPage"));
 const MedSchedulePage = safeLazy(() => import("@/pages/medschedule"));
+const GpsPage = safeLazy(() => import("@/pages/gps"));
 const ShareTarget = safeLazy(() => import("@/pages/ShareTarget"));
 const QrHandler = safeLazy(() => import("@/pages/QrHandler"));
 const NotFound = safeLazy(() => import("@/pages/not-found"));
@@ -98,6 +100,7 @@ const ROUTE_TITLES: Array<[RegExp, string]> = [
   [/^\/calendar/, 'Календарь'],
   [/^\/gantt/, 'Гантт'],
   [/^\/med/, 'MedSchedule'],
+  [/^\/gps/, 'GPS-мониторинг'],
   [/^\/chat/, 'Чат'],
   [/^\/users/, 'Пользователи'],
   [/^\/forms\/[^/]+\/tasks/, 'Задачи'],
@@ -172,6 +175,8 @@ function Router() {  return (
         <Route path="/gantt" component={GanttPage} />
         <Route path="/med" component={MedSchedulePage} />
         <Route path="/med/:tab" component={MedSchedulePage} />
+        <Route path="/gps" component={GpsPage} />
+        <Route path="/gps/:tab" component={GpsPage} />
         <Route path="/billing" component={Billing} />
         <Route path="/finance" component={FinanceDashboard} />
         <Route path="/income" component={IncomeOverview} />
@@ -214,6 +219,12 @@ function PrefetchWrapper({ children }: { children: React.ReactNode }) {
   return <>{children}</>;
 }
 
+/** Глобальный GPS-трекинг: шлёт геолокацию пользователя, если включено в профиле */
+function GpsTrackingRunner() {
+  useGpsTracking();
+  return null;
+}
+
 function GlobalEventListener() {
   useEvents({
     onNotification: useCallback(async () => {
@@ -312,6 +323,7 @@ function App() {
                 <Toaster />
                 <GlobalEventListener />
                 <ForegroundPushHandler />
+                {auth.isAuthenticated && <GpsTrackingRunner />}
                 <GlobalErrorBoundary>
                   <Router />
                 </GlobalErrorBoundary>
diff --git a/client/src/components/MobileBottomNav.tsx b/client/src/components/MobileBottomNav.tsx
index 8fb1905..509bbcd 100644
--- a/client/src/components/MobileBottomNav.tsx
+++ b/client/src/components/MobileBottomNav.tsx
@@ -17,7 +17,7 @@ import {
   DialogHeader,
   DialogTitle,
 } from '@/components/ui/dialog';
-import { Bookmark, User, Folder, Menu, FileText, Table2, CheckSquare, BarChart3, Layers, Users, Settings, MessageSquare, Home, Download, Smartphone, PiggyBank } from 'lucide-react';
+import { Bookmark, User, Folder, Menu, FileText, Table2, CheckSquare, BarChart3, Layers, Users, Settings, MessageSquare, Home, Download, Smartphone, PiggyBank, MapPin } from 'lucide-react';
 import { useAuth } from '@/hooks/useAuth';
 import { useBookmarkFolders, useBookmarksByFolder } from '@/hooks/useBookmarks';
 import { CreateBookmarkModal } from '@/components/CreateBookmarkModal';
@@ -381,6 +381,12 @@ export function MobileBottomNav() {
                 </DropdownMenuItem>
               </Link>
             )}
+            <Link href="/gps">
+              <DropdownMenuItem className="text-xs">
+                <MapPin className="w-3.5 h-3.5 mr-2" />
+                GPS-мониторинг
+              </DropdownMenuItem>
+            </Link>
             <Link href="/settings">
               <DropdownMenuItem className="text-xs">
                 <Settings className="w-3.5 h-3.5 mr-2" />
diff --git a/client/src/components/Sidebar.tsx b/client/src/components/Sidebar.tsx
index 3a410c5..e648057 100644
--- a/client/src/components/Sidebar.tsx
+++ b/client/src/components/Sidebar.tsx
@@ -59,6 +59,7 @@ import {
   LayoutDashboard,
   ChartGantt,
   HeartPulse,
+  MapPin,
 } from 'lucide-react';
 import { useAuth } from '@/hooks/useAuth';
 import { useTheme } from '@/hooks/use-theme';
@@ -1267,6 +1268,43 @@ function GanttNavItem({ collapsed }: { collapsed: boolean }) {
   );
 }
 
+function GpsNavItem({ collapsed }: { collapsed: boolean }) {
+  const [location] = useLocation();
+  const isActive = location === '/gps' || location.startsWith('/gps/');
+
+  if (collapsed) {
+    return (
+      <Tooltip delayDuration={100}>
+        <TooltipTrigger asChild>
+          <Link href="/gps">
+            <div className={cn(
+              "flex items-center justify-center p-1.5 rounded transition-colors cursor-pointer",
+              isActive ? "bg-muted text-foreground" : "text-muted-foreground hover:bg-muted/50 hover:text-foreground"
+            )}>
+              <MapPin className="w-4 h-4 shrink-0" />
+            </div>
+          </Link>
+        </TooltipTrigger>
+        <TooltipContent side="right" sideOffset={8} className="text-xs">
+          GPS-мониторинг
+        </TooltipContent>
+      </Tooltip>
+    );
+  }
+
+  return (
+    <Link href="/gps">
+      <div className={cn(
+        "w-full flex items-center gap-2 p-1.5 rounded text-xs transition-colors cursor-pointer",
+        isActive ? "bg-muted text-foreground font-medium" : "text-muted-foreground hover:bg-muted/50 hover:text-foreground"
+      )}>
+        <MapPin className="w-4 h-4 shrink-0" />
+        <span className="truncate">GPS</span>
+      </div>
+    </Link>
+  );
+}
+
 function MedScheduleNavItem({ collapsed }: { collapsed: boolean }) {
   const { user } = useAuth();
   const [location] = useLocation();
@@ -1491,6 +1529,7 @@ export function Sidebar({ children }: SidebarProps) {
               <DashboardNavItem collapsed={collapsed} />
               <CalendarNavItem collapsed={collapsed} />
               <GanttNavItem collapsed={collapsed} />
+              <GpsNavItem collapsed={collapsed} />
               <MedScheduleNavItem collapsed={collapsed} />
               <UsersNavItem collapsed={collapsed} />
               <FinanceNavItem collapsed={collapsed} />
diff --git a/client/src/components/gps/YandexMap.tsx b/client/src/components/gps/YandexMap.tsx
new file mode 100644
index 0000000..0b61aba
--- /dev/null
+++ b/client/src/components/gps/YandexMap.tsx
@@ -0,0 +1,136 @@
+import { createContext, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { Loader2, MapPin } from 'lucide-react';
+import type { DomEventHandler } from '@yandex/ymaps3-types/imperative/YMapListener';
+import { loadYandexMaps, type YmapsReactModule } from './ymaps-loader';
+
+/** [долгота, широта] — порядок координат Яндекс.Карт JS API 3.0 (LngLat) */
+export type LngLat = [number, number];
+/** Прямоугольник карты: [[lng, lat], [lng, lat]] (юго-запад, северо-восток) */
+export type LngLatBounds = [LngLat, LngLat];
+
+/** Контекст с reactify-модулем ymaps3 — дочерние компоненты (маркеры, фичи) берут из него YMapMarker/YMapFeature */
+const YmapsContext = createContext<YmapsReactModule | null>(null);
+
+/** Доступ к react-компонентам ymaps3 внутри <YandexMap>; null, пока скрипт не загружен */
+export function useYmaps(): YmapsReactModule | null {
+  return useContext(YmapsContext);
+}
+
+interface YandexMapProps {
+  /** API-ключ Яндекс.Карт; null — ключ не настроен, показываем заглушку */
+  apiKey?: string | null;
+  /** Центр [lng, lat]; по умолчанию — Москва */
+  center?: LngLat;
+  zoom?: number;
+  /** Границы для автоподгонки; приоритетнее center/zoom */
+  bounds?: LngLatBounds;
+  /** Клик по карте (используется для рисования геозон) */
+  onMapClick?: (coordinates: LngLat) => void;
+  className?: string;
+  children?: React.ReactNode;
+}
+
+const MOSCOW: LngLat = [37.617698, 55.755864];
+
+/**
+ * Обёртка над Яндекс.Картами JS API 3.0.
+ * Загружает скрипт один раз (singleton в ymaps-loader), пока грузится — скелетон,
+ * без ключа — заглушка с инструкцией.
+ */
+export function YandexMap({
+  apiKey,
+  center,
+  zoom = 10,
+  bounds,
+  onMapClick,
+  className,
+  children,
+}: YandexMapProps) {
+  const [ymaps, setYmaps] = useState<YmapsReactModule | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!apiKey) return;
+    let cancelled = false;
+    setError(null);
+    loadYandexMaps(apiKey)
+      .then((module) => {
+        if (!cancelled) setYmaps(module);
+      })
+      .catch((err) => {
+        console.error('[GPS] Ошибка загрузки Яндекс.Карт:', err);
+        if (!cancelled) setError('Не удалось загрузить Яндекс.Карты. Проверьте API-ключ и доступность api-maps.yandex.ru.');
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [apiKey]);
+
+  // Стабильная location: пересоздаём объект только при реальном изменении,
+  // чтобы рефетчи react-query не сбрасывали viewport, который двигает пользователь
+  const locationKey = bounds ? `b:${JSON.stringify(bounds)}` : `c:${center?.[0]},${center?.[1]}:${zoom}`;
+  const location = useMemo(
+    () => (bounds ? { bounds } : { center: center ?? MOSCOW, zoom }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [locationKey]
+  );
+
+  // Колбэк клика через ref, чтобы не пересоздавать YMapListener
+  const onMapClickRef = useRef(onMapClick);
+  useEffect(() => {
+    onMapClickRef.current = onMapClick;
+  });
+
+  const handleMapClick: DomEventHandler = (_object, event) => {
+    const c = event.coordinates;
+    onMapClickRef.current?.([c[0], c[1]]);
+  };
+
+  if (!apiKey) {
+    return (
+      <div className={className}>
+        <div className="flex flex-col items-center justify-center h-full min-h-[300px] gap-3 rounded-md border border-dashed border-border bg-muted/30 p-6 text-center">
+          <MapPin className="h-8 w-8 text-muted-foreground" />
+          <p className="text-sm text-muted-foreground max-w-md">
+            Укажите API-ключ Яндекс.Карт в настройках (Боты → Доступы к сервисам → «Яндекс.Карты (для модуля GPS)»).
+          </p>
+        </div>
+      </div>
+    );
+  }
+
+  if (error) {
+    return (
+      <div className={className}>
+        <div className="flex items-center justify-center h-full min-h-[300px] rounded-md border border-dashed border-border bg-muted/30 p-6">
+          <p className="text-sm text-destructive">{error}</p>
+        </div>
+      </div>
+    );
+  }
+
+  if (!ymaps) {
+    return (
+      <div className={className}>
+        <div className="flex items-center justify-center h-full min-h-[300px] rounded-md border border-border bg-muted/30">
+          <Loader2 className="h-6 w-6 animate-spin text-muted-foreground" />
+        </div>
+      </div>
+    );
+  }
+
+  const { YMap, YMapDefaultSchemeLayer, YMapDefaultFeaturesLayer, YMapListener } = ymaps;
+
+  return (
+    <div className={className}>
+      <YmapsContext.Provider value={ymaps}>
+        <YMap location={location}>
+          <YMapDefaultSchemeLayer />
+          <YMapDefaultFeaturesLayer />
+          <YMapListener onClick={handleMapClick} />
+          {children}
+        </YMap>
+      </YmapsContext.Provider>
+    </div>
+  );
+}
diff --git a/client/src/components/gps/map-features.tsx b/client/src/components/gps/map-features.tsx
new file mode 100644
index 0000000..13b8fa4
--- /dev/null
+++ b/client/src/components/gps/map-features.tsx
@@ -0,0 +1,165 @@
+import { Car, User } from 'lucide-react';
+import { useYmaps, type LngLat } from './YandexMap';
+
+/**
+ * Общие элементы карты GPS-модуля: маркер объекта, полигон геозоны, полилиния трека.
+ * Все компоненты должны рендериться внутри <YandexMap> (берут ymaps3 из контекста).
+ */
+
+const DEFAULT_COLOR = '#3b82f6';
+
+/** DOM-содержимое маркера объекта: цветной кружок с иконкой + подпись */
+function AssetMarkerContent({
+  name,
+  type,
+  color,
+  isOnline,
+}: {
+  name: string;
+  type: 'vehicle' | 'person';
+  color?: string | null;
+  isOnline?: boolean | null;
+}) {
+  const Icon = type === 'person' ? User : Car;
+  return (
+    <div
+      className="flex flex-col items-center select-none"
+      style={{ transform: 'translate(-50%, -50%)', opacity: isOnline === false ? 0.5 : 1 }}
+    >
+      <div
+        className="flex items-center justify-center w-7 h-7 rounded-full border-2 border-white shadow-md"
+        style={{ backgroundColor: color || DEFAULT_COLOR }}
+      >
+        <Icon className="w-4 h-4 text-white" />
+      </div>
+      <div
+        className="mt-0.5 px-1 rounded text-[10px] leading-4 font-medium bg-background/90 border border-border whitespace-nowrap max-w-[120px] truncate"
+        title={name}
+      >
+        {name}
+      </div>
+    </div>
+  );
+}
+
+/** Маркер объекта на карте */
+export function GpsAssetMarker({
+  coordinates,
+  name,
+  type,
+  color,
+  isOnline,
+  zIndex,
+  onClick,
+}: {
+  coordinates: LngLat;
+  name: string;
+  type: 'vehicle' | 'person';
+  color?: string | null;
+  isOnline?: boolean | null;
+  zIndex?: number;
+  onClick?: () => void;
+}) {
+  const ymaps = useYmaps();
+  if (!ymaps) return null;
+  const { YMapMarker } = ymaps;
+  return (
+    <YMapMarker
+      coordinates={coordinates}
+      zIndex={zIndex}
+      onClick={onClick ? () => onClick() : undefined}
+    >
+      <AssetMarkerContent name={name} type={type} color={color} isOnline={isOnline} />
+    </YMapMarker>
+  );
+}
+
+/** Простой круглый маркер (старт/финиш трека, точка воспроизведения) */
+export function GpsDotMarker({
+  coordinates,
+  color,
+  label,
+  zIndex,
+}: {
+  coordinates: LngLat;
+  color: string;
+  label?: string;
+  zIndex?: number;
+}) {
+  const ymaps = useYmaps();
+  if (!ymaps) return null;
+  const { YMapMarker } = ymaps;
+  return (
+    <YMapMarker coordinates={coordinates} zIndex={zIndex}>
+      <div className="flex flex-col items-center select-none" style={{ transform: 'translate(-50%, -50%)' }}>
+        <div
+          className="w-4 h-4 rounded-full border-2 border-white shadow"
+          style={{ backgroundColor: color }}
+          title={label}
+        />
+        {label && (
+          <div className="mt-0.5 px-1 rounded text-[10px] leading-4 font-medium bg-background/90 border border-border whitespace-nowrap">
+            {label}
+          </div>
+        )}
+      </div>
+    </YMapMarker>
+  );
+}
+
+/** Полигон геозоны (polygon хранится как пары [lat, lng] — конвертируем в LngLat) */
+export function GpsGeozonePolygon({
+  polygon,
+  color,
+  fillOpacity = 0.15,
+}: {
+  polygon: Array<[number, number]>;
+  color?: string | null;
+  fillOpacity?: number;
+}) {
+  const ymaps = useYmaps();
+  if (!ymaps || polygon.length < 3) return null;
+  const { YMapFeature } = ymaps;
+  const c = color || DEFAULT_COLOR;
+  return (
+    <YMapFeature
+      geometry={{
+        type: 'Polygon',
+        coordinates: [polygon.map(([lat, lng]) => [lng, lat] as LngLat)],
+      }}
+      style={{
+        fill: c,
+        fillOpacity,
+        stroke: [{ color: c, width: 2 }],
+      }}
+    />
+  );
+}
+
+/** Полилиния трека/маршрута (points — пары [lat, lng]) */
+export function GpsPolyline({
+  points,
+  color = DEFAULT_COLOR,
+  width = 4,
+  dashed = false,
+}: {
+  points: Array<[number, number]>;
+  color?: string;
+  width?: number;
+  dashed?: boolean;
+}) {
+  const ymaps = useYmaps();
+  if (!ymaps || points.length < 2) return null;
+  const { YMapFeature } = ymaps;
+  return (
+    <YMapFeature
+      geometry={{
+        type: 'LineString',
+        coordinates: points.map(([lat, lng]) => [lng, lat] as LngLat),
+      }}
+      style={{
+        stroke: [{ color, width, ...(dashed ? { dash: [8, 6] } : {}) }],
+      }}
+    />
+  );
+}
diff --git a/client/src/components/gps/ymaps-loader.ts b/client/src/components/gps/ymaps-loader.ts
new file mode 100644
index 0000000..1be6cd8
--- /dev/null
+++ b/client/src/components/gps/ymaps-loader.ts
@@ -0,0 +1,69 @@
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+// Типы JS API 3.0: подключают глобальный `ymaps3` и типы reactify-модуля.
+// Пакет types-only, в рантайме скрипт грузится с api-maps.yandex.ru.
+import type { ReactifiedModule } from '@yandex/ymaps3-types/reactify';
+
+/**
+ * Реакт-обёртка над ymaps3: результат reactify.module(ymaps3).
+ * Содержит YMap, YMapDefaultSchemeLayer, YMapDefaultFeaturesLayer,
+ * YMapMarker, YMapFeature, YMapListener и т.д. как React-компоненты.
+ */
+export type YmapsReactModule = ReactifiedModule<typeof import('@yandex/ymaps3-types')>;
+
+let loadPromise: Promise<YmapsReactModule> | null = null;
+let loadedApiKey: string | null = null;
+
+/**
+ * Загружает Яндекс.Карты JS API 3.0 и возвращает reactify-модуль (singleton).
+ * Скрипт подключается один раз на страницу; при повторных вызовах
+ * с тем же ключом возвращается тот же промис.
+ *
+ * Официальная схема (https://yandex.ru/dev/jsapi30/):
+ *   <script src="https://api-maps.yandex.ru/v3/?apikey=KEY&lang=ru_RU">
+ *   await ymaps3.ready;
+ *   const ymaps3React = await ymaps3.import('@yandex/ymaps3-reactify');
+ *   const reactify = ymaps3React.reactify.bindTo(React, ReactDOM);
+ *   const { YMap, ... } = reactify.module(ymaps3);
+ */
+export function loadYandexMaps(apiKey: string): Promise<YmapsReactModule> {
+  if (loadPromise && loadedApiKey === apiKey) return loadPromise;
+  if (loadPromise) {
+    // Скрипт уже загружен с другим ключом — переиспользовать загруженный модуль
+    // (ключ меняется крайне редко; до перезагрузки страницы работает старый).
+    console.warn('[GPS] API-ключ Яндекс.Карт изменился после загрузки скрипта, используется уже загруженный модуль');
+    return loadPromise;
+  }
+
+  loadedApiKey = apiKey;
+  loadPromise = (async () => {
+    await injectScript(apiKey);
+    await ymaps3.ready;
+    const ymaps3React = await ymaps3.import('@yandex/ymaps3-reactify');
+    const reactify = (ymaps3React as { reactify: { bindTo(r: unknown, rd: unknown): { module(m: unknown): YmapsReactModule } } })
+      .reactify.bindTo(React, ReactDOM);
+    return reactify.module(ymaps3);
+  })().catch((err) => {
+    // При ошибке сбрасываем singleton, чтобы следующий рендер мог повторить попытку
+    loadPromise = null;
+    loadedApiKey = null;
+    throw err;
+  });
+
+  return loadPromise;
+}
+
+function injectScript(apiKey: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (typeof window !== 'undefined' && (window as unknown as { ymaps3?: unknown }).ymaps3) {
+      resolve();
+      return;
+    }
+    const script = document.createElement('script');
+    script.src = `https://api-maps.yandex.ru/v3/?apikey=${encodeURIComponent(apiKey)}&lang=ru_RU`;
+    script.type = 'text/javascript';
+    script.onload = () => resolve();
+    script.onerror = () => reject(new Error('Не удалось загрузить скрипт Яндекс.Карт'));
+    document.head.appendChild(script);
+  });
+}
diff --git a/client/src/components/profile/ProfileGpsTab.tsx b/client/src/components/profile/ProfileGpsTab.tsx
new file mode 100644
index 0000000..9853b51
--- /dev/null
+++ b/client/src/components/profile/ProfileGpsTab.tsx
@@ -0,0 +1,107 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Switch } from '@/components/ui/switch';
+import { Label } from '@/components/ui/label';
+import { Loader2, MapPin } from 'lucide-react';
+import { apiRequest } from '@/lib/queryClient';
+import { useToast } from '@/hooks/use-toast';
+
+interface MyTrackingResponse {
+  success: boolean;
+  enabled: boolean;
+  assetId: number | null;
+}
+
+/**
+ * Вкладка «GPS» в профиле пользователя: включение/выключение отправки
+ * собственной геолокации. Координаты отправляются, пока открыто приложение
+ * (см. хук useGpsTracking, подключён глобально в App.tsx).
+ */
+export function ProfileGpsTab() {
+  const { toast } = useToast();
+  const queryClient = useQueryClient();
+
+  const { data, isLoading } = useQuery<MyTrackingResponse>({
+    queryKey: ['/api/gps/my-tracking'],
+  });
+  const enabled = data?.enabled === true;
+
+  const mutation = useMutation({
+    mutationFn: async (nextEnabled: boolean) => {
+      const res = await apiRequest('PUT', '/api/gps/my-tracking', { enabled: nextEnabled });
+      return res.json();
+    },
+    onSuccess: (_data, nextEnabled) => {
+      queryClient.invalidateQueries({ queryKey: ['/api/gps/my-tracking'] });
+      toast({ title: nextEnabled ? 'GPS-отслеживание включено' : 'GPS-отслеживание выключено' });
+    },
+    onError: (err: any) => {
+      toast({
+        title: 'Ошибка',
+        description: err?.message || 'Не удалось изменить настройку',
+        variant: 'destructive',
+      });
+    },
+  });
+
+  const handleToggle = (checked: boolean) => {
+    if (!checked) {
+      mutation.mutate(false);
+      return;
+    }
+    // При включении сразу запрашиваем разрешение геолокации у браузера
+    if (!('geolocation' in navigator)) {
+      toast({
+        title: 'Геолокация недоступна',
+        description: 'Ваш браузер не поддерживает геолокацию',
+        variant: 'destructive',
+      });
+      return;
+    }
+    navigator.geolocation.getCurrentPosition(
+      () => mutation.mutate(true),
+      (err) => {
+        toast({
+          title: 'Нет доступа к геолокации',
+          description: err.message || 'Разрешите доступ к геолокации в настройках браузера',
+          variant: 'destructive',
+        });
+      },
+      { timeout: 10_000 }
+    );
+  };
+
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle className="text-base flex items-center gap-2">
+          <MapPin className="w-4 h-4" />
+          GPS-отслеживание
+        </CardTitle>
+      </CardHeader>
+      <CardContent className="space-y-3">
+        {isLoading ? (
+          <div className="flex items-center justify-center h-16">
+            <Loader2 className="h-5 w-5 animate-spin text-muted-foreground" />
+          </div>
+        ) : (
+          <>
+            <div className="flex items-center gap-3">
+              <Switch
+                checked={enabled}
+                onCheckedChange={handleToggle}
+                disabled={mutation.isPending}
+                data-testid="switch-gps-tracking"
+              />
+              <Label>Отслеживать мою геолокацию</Label>
+            </div>
+            <p className="text-xs text-muted-foreground">
+              Координаты отправляются, пока открыто приложение. Для фонового отслеживания используйте приложение
+              Traccar Client.
+            </p>
+          </>
+        )}
+      </CardContent>
+    </Card>
+  );
+}
diff --git a/client/src/hooks/useEvents.ts b/client/src/hooks/useEvents.ts
index 75648c2..5d80c57 100644
--- a/client/src/hooks/useEvents.ts
+++ b/client/src/hooks/useEvents.ts
@@ -16,6 +16,10 @@ interface UseEventsOptions {
   onConvTypingStopped?: (data: { conversationId: number; botName: string }) => void;
   onReactionUpdated?: (data: { taskMessageId?: number; convMessageId?: number; conversationId?: number; reactions: any[] }) => void;
   onPollUpdated?: (data: { taskMessageId?: number; convMessageId?: number; conversationId?: number; poll: any }) => void;
+  /** GPS: объект получил новую позицию (payload формирует server/gps) */
+  onGpsAssetMoved?: (data: any) => void;
+  /** GPS: объект перешёл в офлайн по таймауту (payload формирует server/gps) */
+  onGpsAssetOffline?: (data: any) => void;
   reconnectInterval?: number;
 }
 
@@ -64,6 +68,8 @@ export const useEvents = (options: UseEventsOptions = {}) => {
     if (options.onConvTypingStopped) unsubs.push(sseManager.on('conv_typing_stopped', wrap('onConvTypingStopped')));
     if (options.onReactionUpdated) unsubs.push(sseManager.on('reaction_updated', wrap('onReactionUpdated')));
     if (options.onPollUpdated) unsubs.push(sseManager.on('poll_updated', wrap('onPollUpdated')));
+    if (options.onGpsAssetMoved) unsubs.push(sseManager.on('gps_asset_moved', wrap('onGpsAssetMoved')));
+    if (options.onGpsAssetOffline) unsubs.push(sseManager.on('gps_asset_offline', wrap('onGpsAssetOffline')));
     return () => { for (const u of unsubs) u(); };
   }, []);
 
diff --git a/client/src/hooks/useGps.ts b/client/src/hooks/useGps.ts
new file mode 100644
index 0000000..2c64305
--- /dev/null
+++ b/client/src/hooks/useGps.ts
@@ -0,0 +1,131 @@
+import { useCallback } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { apiRequest, queryClient } from '@/lib/queryClient';
+import { useEvents } from '@/hooks/useEvents';
+import type {
+  GpsAsset,
+  GpsConfig,
+  GpsGeozone,
+  GpsGeozoneEvent,
+  GpsGroup,
+  GpsPosition,
+  GpsSubscriber,
+  GpsTrackResponse,
+} from '@/pages/gps/types';
+
+/** Ключ API Яндекс.Карт организации (из external_services, service_type='yandex_maps') */
+export function useGpsConfig() {
+  return useQuery<GpsConfig>({
+    queryKey: ['/api/gps/config'],
+    staleTime: 5 * 60_000,
+  });
+}
+
+/** Список объектов мониторинга организации */
+export function useGpsAssets() {
+  return useQuery<{ success: boolean; assets: GpsAsset[] }>({
+    queryKey: ['/api/gps/assets'],
+  });
+}
+
+/**
+ * Текущие позиции активных объектов.
+ * Обновляются по SSE (gps_asset_moved / gps_asset_offline) + fallback polling 30 сек.
+ */
+export function useGpsPositions(enabled = true) {
+  return useQuery<{ success: boolean; positions: GpsPosition[] }>({
+    queryKey: ['/api/gps/assets/positions'],
+    refetchInterval: 30_000,
+    enabled,
+  });
+}
+
+/** Подписка на живые GPS-события: инвалидирует позиции и список объектов */
+export function useGpsLiveUpdates(enabled = true) {
+  const invalidate = useCallback(() => {
+    queryClient.invalidateQueries({ queryKey: ['/api/gps/assets/positions'] });
+    queryClient.invalidateQueries({ queryKey: ['/api/gps/assets'] });
+  }, []);
+
+  useEvents(
+    enabled
+      ? {
+          onGpsAssetMoved: invalidate,
+          onGpsAssetOffline: invalidate,
+        }
+      : {}
+  );
+}
+
+/** Список геозон организации */
+export function useGpsGeozones() {
+  return useQuery<{ success: boolean; geozones: GpsGeozone[] }>({
+    queryKey: ['/api/gps/geozones'],
+  });
+}
+
+/** Группы объектов (с assetIds) */
+export function useGpsGroups() {
+  return useQuery<{ success: boolean; groups: GpsGroup[] }>({
+    queryKey: ['/api/gps/groups'],
+  });
+}
+
+/** Журнал событий входа/выхода из геозон с фильтрами */
+export function useGpsGeozoneEvents(filters: { assetId?: number; geozoneId?: number; from?: string; to?: string; limit?: number }) {
+  const params = new URLSearchParams();
+  if (filters.assetId) params.set('assetId', String(filters.assetId));
+  if (filters.geozoneId) params.set('geozoneId', String(filters.geozoneId));
+  if (filters.from) params.set('from', filters.from);
+  if (filters.to) params.set('to', filters.to);
+  if (filters.limit) params.set('limit', String(filters.limit));
+  const qs = params.toString();
+
+  return useQuery<{ success: boolean; events: GpsGeozoneEvent[] }>({
+    queryKey: ['/api/gps/geozone-events', filters.assetId, filters.geozoneId, filters.from, filters.to, filters.limit],
+    queryFn: async () => {
+      const res = await apiRequest('GET', `/api/gps/geozone-events${qs ? `?${qs}` : ''}`);
+      return res.json();
+    },
+  });
+}
+
+/** Трек объекта за период; загружается только при enabled (по кнопке «Показать») */
+export function useGpsTrack(assetId: number | null, from: string, to: string, enabled: boolean) {
+  return useQuery<GpsTrackResponse>({
+    queryKey: ['/api/gps/assets', assetId, 'track', from, to],
+    queryFn: async () => {
+      const params = new URLSearchParams({ from, to });
+      const res = await apiRequest('GET', `/api/gps/assets/${assetId}/track?${params.toString()}`);
+      return res.json();
+    },
+    enabled: enabled && !!assetId && !!from && !!to,
+  });
+}
+
+/** Подписчики объекта */
+export function useGpsAssetSubscribers(assetId: number | null) {
+  return useQuery<{ success: boolean; subscribers: GpsSubscriber[] }>({
+    queryKey: ['/api/gps/assets', assetId, 'subscribers'],
+    queryFn: async () => {
+      const res = await apiRequest('GET', `/api/gps/assets/${assetId}/subscribers`);
+      return res.json();
+    },
+    enabled: !!assetId,
+  });
+}
+
+/** Список пользователей организации (для выбора владельца объекта и подписчиков) */
+export function useOrgUsers() {
+  return useQuery<{ success: boolean; users: Array<{ id: number; firstName?: string; lastName?: string; email: string; fullName?: string }> }>({
+    queryKey: ['/api/users/list'],
+    staleTime: 60_000,
+  });
+}
+
+/** Инвалидация всех GPS-запросов после мутаций */
+export function invalidateGps(...keys: Array<'assets' | 'positions' | 'geozones' | 'groups' | 'geozone-events'>) {
+  for (const key of keys) {
+    queryClient.invalidateQueries({ queryKey: [`/api/gps/${key}`] });
+  }
+}
diff --git a/client/src/hooks/useGpsTracking.ts b/client/src/hooks/useGpsTracking.ts
new file mode 100644
index 0000000..f8fbe81
--- /dev/null
+++ b/client/src/hooks/useGpsTracking.ts
@@ -0,0 +1,71 @@
+import { useEffect } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { apiRequest } from '@/lib/queryClient';
+import { useAuth } from '@/hooks/useAuth';
+
+/** Минимальный интервал отправки позиции на сервер (не чаще раза в 60 сек) */
+const MIN_SEND_INTERVAL_MS = 60_000;
+
+interface MyTrackingResponse {
+  success: boolean;
+  enabled: boolean;
+  assetId: number | null;
+}
+
+/**
+ * Фоновый трекинг геолокации пользователя (PWA).
+ * Если трекинг включён (GET /api/gps/my-tracking), запускает
+ * navigator.geolocation.watchPosition и шлёт точки на POST /api/gps/my-position
+ * не чаще раза в MIN_SEND_INTERVAL_MS. Работает, пока открыто приложение.
+ */
+export function useGpsTracking() {
+  const { user } = useAuth();
+
+  const { data } = useQuery<MyTrackingResponse>({
+    queryKey: ['/api/gps/my-tracking'],
+    enabled: !!user,
+    staleTime: 60_000,
+  });
+  const enabled = !!user && data?.enabled === true;
+
+  useEffect(() => {
+    if (!enabled) return;
+    if (!('geolocation' in navigator)) {
+      console.warn('[GPS] Геолокация не поддерживается браузером');
+      return;
+    }
+
+    let lastSentAt = 0;
+    let lastErrorLogged = false;
+
+    const sendPosition = (pos: GeolocationPosition) => {
+      const now = Date.now();
+      if (now - lastSentAt < MIN_SEND_INTERVAL_MS) return;
+      lastSentAt = now;
+
+      const { latitude, longitude, speed, heading, accuracy } = pos.coords;
+      apiRequest('POST', '/api/gps/my-position', {
+        lat: latitude,
+        lng: longitude,
+        // Geolocation API отдаёт скорость в м/с — приводим к км/ч
+        speed: speed != null && !Number.isNaN(speed) ? speed * 3.6 : null,
+        course: heading != null && !Number.isNaN(heading) ? heading : null,
+        accuracy: accuracy ?? null,
+      }).catch((err) => {
+        // Не спамим в консоль одинаковыми ошибками (например, 403 при отключённом трекинге)
+        if (!lastErrorLogged) {
+          console.warn('[GPS] Не удалось отправить позицию:', err);
+          lastErrorLogged = true;
+        }
+      });
+    };
+
+    const watchId = navigator.geolocation.watchPosition(
+      sendPosition,
+      (err) => console.warn('[GPS] Ошибка геолокации:', err.message),
+      { enableHighAccuracy: true, maximumAge: 30_000 }
+    );
+
+    return () => navigator.geolocation.clearWatch(watchId);
+  }, [enabled]);
+}
diff --git a/client/src/lib/sseManager.ts b/client/src/lib/sseManager.ts
index 568838e..ff6b952 100644
--- a/client/src/lib/sseManager.ts
+++ b/client/src/lib/sseManager.ts
@@ -28,6 +28,8 @@ const KNOWN_EVENTS = [
   'conv_typing_stopped',
   'reaction_updated',
   'poll_updated',
+  'gps_asset_moved',
+  'gps_asset_offline',
 ];
 
 function emit(event: string, data: any) {
diff --git a/client/src/pages/Bots.tsx b/client/src/pages/Bots.tsx
index 65c29ed..6bd0957 100644
--- a/client/src/pages/Bots.tsx
+++ b/client/src/pages/Bots.tsx
@@ -173,6 +173,7 @@ const updateServiceFormSchema = z.object({
 const serviceTypeLabels: Record<string, string> = {
   dadata: 'DaData',
   openstreetmap: 'OpenStreetMap',
+  yandex_maps: 'Яндекс.Карты (для модуля GPS)',
   sms: 'SMS',
   email: 'Email',
 };
@@ -2295,6 +2296,7 @@ export const BotsContent = () => {
                                 </FormControl>
                                 <SelectContent>
                                   <SelectItem value="dadata">DaData</SelectItem>
+                                  <SelectItem value="yandex_maps">Яндекс.Карты (для модуля GPS)</SelectItem>
                                   <SelectItem value="sms">SMS</SelectItem>
                                   <SelectItem value="email">Email</SelectItem>
                                 </SelectContent>
diff --git a/client/src/pages/UserProfilePage.tsx b/client/src/pages/UserProfilePage.tsx
index 2a614fc..1df0625 100644
--- a/client/src/pages/UserProfilePage.tsx
+++ b/client/src/pages/UserProfilePage.tsx
@@ -20,7 +20,7 @@ import { apiRequest, queryClient } from '@/lib/queryClient';
 import { authService } from '@/services/auth.service';
 import { normalizeSelectOptions } from '@/lib/fieldOptions';
 import { SearchableMultiSelect } from '@/components/fields/SearchableMultiSelect';
-import { ArrowLeft, Save, Loader2, User as UserIcon, Mail, Shield, Briefcase, FileText, History, Calendar, Clock, CheckCircle2, Circle, AlertCircle, UserCheck, Bell, WifiOff, Palette, Lock } from 'lucide-react';
+import { ArrowLeft, Save, Loader2, User as UserIcon, Mail, Shield, Briefcase, FileText, History, Calendar, Clock, CheckCircle2, Circle, AlertCircle, UserCheck, Bell, WifiOff, Palette, Lock, MapPin } from 'lucide-react';
 import { Link } from 'wouter';
 import CompanyFieldInput from '@/components/CompanyFieldInput';
 import GeoField from '@/components/GeoField';
@@ -32,6 +32,7 @@ import { ProfileNotificationsTab } from '@/components/profile/ProfileNotificatio
 import { ProfileOfflineTab } from '@/components/profile/ProfileOfflineTab';
 import { ProfileInterfaceTab } from '@/components/profile/ProfileInterfaceTab';
 import { ProfileSecurityTab } from '@/components/profile/ProfileSecurityTab';
+import { ProfileGpsTab } from '@/components/profile/ProfileGpsTab';
 
 interface UserProfileTab {
   id: number;
@@ -967,6 +968,10 @@ export default function UserProfilePage({ userId: userIdProp }: { userId?: numbe
                   <Lock className="w-3.5 h-3.5" />
                   Безопасность
                 </TabsTrigger>
+                <TabsTrigger value="gps" className="flex items-center gap-1">
+                  <MapPin className="w-3.5 h-3.5" />
+                  GPS
+                </TabsTrigger>
               </>
             )}
           </TabsList>
@@ -1309,6 +1314,9 @@ export default function UserProfilePage({ userId: userIdProp }: { userId?: numbe
               <TabsContent value="security" className="space-y-4">
                 <ProfileSecurityTab />
               </TabsContent>
+              <TabsContent value="gps" className="space-y-4">
+                <ProfileGpsTab />
+              </TabsContent>
             </>
           )}
         </Tabs>
diff --git a/client/src/pages/gps/AssetsTab.tsx b/client/src/pages/gps/AssetsTab.tsx
new file mode 100644
index 0000000..1aabf32
--- /dev/null
+++ b/client/src/pages/gps/AssetsTab.tsx
@@ -0,0 +1,450 @@
+import { useEffect, useState } from 'react';
+import { useMutation } from '@tanstack/react-query';
+import { Card, CardContent } from '@/components/ui/card';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Badge } from '@/components/ui/badge';
+import { Switch } from '@/components/ui/switch';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
+import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from '@/components/ui/dialog';
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table';
+import { Loader2, Pencil, Plus, Trash2, BellRing } from 'lucide-react';
+import { apiRequest } from '@/lib/queryClient';
+import { useToast } from '@/hooks/use-toast';
+import { invalidateGps, useGpsAssetSubscribers, useGpsAssets, useOrgUsers } from '@/hooks/useGps';
+import { MultiSelectPopover } from '@/components/MultiSelectPopover';
+import type { GpsAsset, GpsSubscriber } from './types';
+
+function formatDateTime(value: string | null): string {
+  if (!value) return '—';
+  return new Date(value).toLocaleString('ru-RU');
+}
+
+function userLabel(u: { firstName?: string; lastName?: string; email: string; fullName?: string }): string {
+  return u.fullName || `${u.firstName || ''} ${u.lastName || ''}`.trim() || u.email;
+}
+
+/** Форма создания/редактирования объекта */
+interface AssetFormState {
+  name: string;
+  type: 'vehicle' | 'person';
+  userId: string;
+  externalId: string;
+  color: string;
+  isActive: boolean;
+}
+
+const EMPTY_FORM: AssetFormState = {
+  name: '',
+  type: 'vehicle',
+  userId: '',
+  externalId: '',
+  color: '#3b82f6',
+  isActive: true,
+};
+
+/**
+ * Таб «Объекты»: реестр объектов мониторинга, CRUD, подписчики на события.
+ */
+export function GpsAssetsTab() {
+  const { toast } = useToast();
+  const { data, isLoading } = useGpsAssets();
+  const { data: usersData } = useOrgUsers();
+  const assets = data?.assets || [];
+  const users = usersData?.users || [];
+
+  const [dialogOpen, setDialogOpen] = useState(false);
+  const [editing, setEditing] = useState<GpsAsset | null>(null);
+  const [form, setForm] = useState<AssetFormState>(EMPTY_FORM);
+  const [subscribersAsset, setSubscribersAsset] = useState<GpsAsset | null>(null);
+
+  const openCreate = () => {
+    setEditing(null);
+    setForm(EMPTY_FORM);
+    setDialogOpen(true);
+  };
+
+  const openEdit = (asset: GpsAsset) => {
+    setEditing(asset);
+    setForm({
+      name: asset.name,
+      type: asset.type,
+      userId: asset.userId ? String(asset.userId) : '',
+      externalId: asset.externalId || '',
+      color: asset.color || '#3b82f6',
+      isActive: asset.isActive !== false,
+    });
+    setDialogOpen(true);
+  };
+
+  const saveMutation = useMutation({
+    mutationFn: async () => {
+      const body = {
+        name: form.name.trim(),
+        type: form.type,
+        userId: form.type === 'person' && form.userId ? Number(form.userId) : null,
+        externalId: form.externalId.trim() || null,
+        color: form.color,
+        isActive: form.isActive,
+      };
+      const res = editing
+        ? await apiRequest('PATCH', `/api/gps/assets/${editing.id}`, body)
+        : await apiRequest('POST', '/api/gps/assets', body);
+      return res.json();
+    },
+    onSuccess: () => {
+      toast({ title: editing ? 'Объект обновлён' : 'Объект создан' });
+      setDialogOpen(false);
+      invalidateGps('assets', 'positions');
+    },
+    onError: (err: any) => {
+      toast({ title: 'Ошибка', description: err?.message || 'Не удалось сохранить объект', variant: 'destructive' });
+    },
+  });
+
+  const deleteMutation = useMutation({
+    mutationFn: async (id: number) => {
+      const res = await apiRequest('DELETE', `/api/gps/assets/${id}`);
+      return res.json();
+    },
+    onSuccess: () => {
+      toast({ title: 'Объект удалён' });
+      invalidateGps('assets', 'positions');
+    },
+    onError: (err: any) => {
+      toast({ title: 'Ошибка', description: err?.message || 'Не удалось удалить объект', variant: 'destructive' });
+    },
+  });
+
+  return (
+    <div className="space-y-3">
+      <div className="flex justify-end">
+        <Button size="sm" className="h-8" onClick={openCreate}>
+          <Plus className="w-4 h-4 mr-1" />
+          Добавить объект
+        </Button>
+      </div>
+
+      <Card>
+        <CardContent className="p-0">
+          {isLoading ? (
+            <div className="flex items-center justify-center h-32">
+              <Loader2 className="h-6 w-6 animate-spin text-muted-foreground" />
+            </div>
+          ) : assets.length === 0 ? (
+            <p className="text-center text-sm text-muted-foreground py-8">
+              Нет объектов. Добавьте машину или человека для отслеживания.
+            </p>
+          ) : (
+            <Table>
+              <TableHeader>
+                <TableRow>
+                  <TableHead>Название</TableHead>
+                  <TableHead>Тип</TableHead>
+                  <TableHead>Статус</TableHead>
+                  <TableHead>ID трекера</TableHead>
+                  <TableHead>Последняя точка</TableHead>
+                  <TableHead>Группы</TableHead>
+                  <TableHead className="text-right">Действия</TableHead>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {assets.map((asset) => (
+                  <TableRow key={asset.id} className={asset.isActive === false ? 'opacity-50' : ''}>
+                    <TableCell>
+                      <div className="flex items-center gap-2">
+                        <span
+                          className="w-3 h-3 rounded-full shrink-0 border border-border"
+                          style={{ backgroundColor: asset.color || '#3b82f6' }}
+                        />
+                        <span className="font-medium text-sm">{asset.name}</span>
+                      </div>
+                    </TableCell>
+                    <TableCell>
+                      <Badge variant="outline" className="text-[10px]">
+                        {asset.type === 'person' ? 'Человек' : 'Транспорт'}
+                      </Badge>
+                    </TableCell>
+                    <TableCell>
+                      <span className="flex items-center gap-1.5 text-xs">
+                        <span
+                          className="w-2 h-2 rounded-full"
+                          style={{ backgroundColor: asset.isOnline ? '#22c55e' : '#9ca3af' }}
+                        />
+                        {asset.isOnline ? 'Онлайн' : 'Офлайн'}
+                      </span>
+                    </TableCell>
+                    <TableCell className="text-xs font-mono">{asset.externalId || '—'}</TableCell>
+                    <TableCell className="text-xs text-muted-foreground">{formatDateTime(asset.lastSeenAt)}</TableCell>
+                    <TableCell>
+                      <div className="flex items-center gap-1 flex-wrap">
+                        {(asset.groups || []).map((g) => (
+                          <Badge key={g.id} variant="secondary" className="text-[10px]">
+                            {g.name}
+                          </Badge>
+                        ))}
+                      </div>
+                    </TableCell>
+                    <TableCell className="text-right">
+                      <div className="flex items-center justify-end gap-1">
+                        <Button
+                          variant="ghost"
+                          size="sm"
+                          className="h-7 w-7 p-0"
+                          title="Подписчики на события"
+                          onClick={() => setSubscribersAsset(asset)}
+                        >
+                          <BellRing className="w-3.5 h-3.5" />
+                          {(asset.subscriberCount ?? 0) > 0 && (
+                            <span className="ml-0.5 text-[10px]">{asset.subscriberCount}</span>
+                          )}
+                        </Button>
+                        <Button variant="ghost" size="sm" className="h-7 w-7 p-0" onClick={() => openEdit(asset)}>
+                          <Pencil className="w-3.5 h-3.5" />
+                        </Button>
+                        <Button
+                          variant="ghost"
+                          size="sm"
+                          className="h-7 w-7 p-0"
+                          onClick={() => {
+                            if (window.confirm(`Удалить объект «${asset.name}»? История позиций будет удалена.`)) {
+                              deleteMutation.mutate(asset.id);
+                            }
+                          }}
+                        >
+                          <Trash2 className="w-3.5 h-3.5 text-destructive" />
+                        </Button>
+                      </div>
+                    </TableCell>
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          )}
+        </CardContent>
+      </Card>
+
+      {/* Диалог создания/редактирования */}
+      <Dialog open={dialogOpen} onOpenChange={setDialogOpen}>
+        <DialogContent className="max-w-md">
+          <DialogHeader>
+            <DialogTitle>{editing ? 'Редактирование объекта' : 'Новый объект'}</DialogTitle>
+            <DialogDescription>
+              Для трекера укажите его IMEI/ID; для человека можно включить трекинг из профиля или через приложение
+              Traccar Client
+            </DialogDescription>
+          </DialogHeader>
+          <div className="space-y-3">
+            <div className="space-y-1">
+              <Label className="text-xs">Название</Label>
+              <Input
+                className="h-8"
+                value={form.name}
+                onChange={(e) => setForm((f) => ({ ...f, name: e.target.value }))}
+                placeholder="Например: КамАЗ А123ВС"
+              />
+            </div>
+            <div className="grid grid-cols-2 gap-3">
+              <div className="space-y-1">
+                <Label className="text-xs">Тип</Label>
+                <Select
+                  value={form.type}
+                  onValueChange={(v) => setForm((f) => ({ ...f, type: v as 'vehicle' | 'person' }))}
+                >
+                  <SelectTrigger className="h-8">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="vehicle">Транспорт</SelectItem>
+                    <SelectItem value="person">Человек</SelectItem>
+                  </SelectContent>
+                </Select>
+              </div>
+              <div className="space-y-1">
+                <Label className="text-xs">Цвет на карте</Label>
+                <Input
+                  type="color"
+                  className="h-8 w-full p-1 cursor-pointer"
+                  value={form.color}
+                  onChange={(e) => setForm((f) => ({ ...f, color: e.target.value }))}
+                />
+              </div>
+            </div>
+            {form.type === 'person' && (
+              <div className="space-y-1">
+                <Label className="text-xs">Пользователь</Label>
+                <Select
+                  value={form.userId}
+                  onValueChange={(v) => setForm((f) => ({ ...f, userId: v }))}
+                >
+                  <SelectTrigger className="h-8">
+                    <SelectValue placeholder="Выберите пользователя" />
+                  </SelectTrigger>
+                  <SelectContent>
+                    {users.map((u) => (
+                      <SelectItem key={u.id} value={String(u.id)}>
+                        {userLabel(u)}
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              </div>
+            )}
+            <div className="space-y-1">
+              <Label className="text-xs">IMEI / ID трекера</Label>
+              <Input
+                className="h-8 font-mono"
+                value={form.externalId}
+                onChange={(e) => setForm((f) => ({ ...f, externalId: e.target.value }))}
+                placeholder="Например: 352909082345678"
+              />
+            </div>
+            <div className="flex items-center gap-2">
+              <Switch
+                checked={form.isActive}
+                onCheckedChange={(v) => setForm((f) => ({ ...f, isActive: v }))}
+              />
+              <Label className="text-xs">Активен (принимать позиции)</Label>
+            </div>
+            <Button
+              className="w-full h-8"
+              disabled={saveMutation.isPending || !form.name.trim()}
+              onClick={() => saveMutation.mutate()}
+            >
+              {saveMutation.isPending && <Loader2 className="w-3.5 h-3.5 mr-1 animate-spin" />}
+              {editing ? 'Сохранить' : 'Создать'}
+            </Button>
+          </div>
+        </DialogContent>
+      </Dialog>
+
+      {/* Диалог подписчиков */}
+      <SubscribersDialog asset={subscribersAsset} onClose={() => setSubscribersAsset(null)} />
+    </div>
+  );
+}
+
+/**
+ * Диалог подписчиков объекта: мультиселект пользователей + переключатели
+ * событий (вход в геозону / выход / офлайн). Сохранение — полная замена списка.
+ */
+function SubscribersDialog({ asset, onClose }: { asset: GpsAsset | null; onClose: () => void }) {
+  const { toast } = useToast();
+  const { data: usersData } = useOrgUsers();
+  const { data: subscribersData, isLoading } = useGpsAssetSubscribers(asset?.id ?? null);
+  const users = usersData?.users || [];
+
+  const [list, setList] = useState<GpsSubscriber[]>([]);
+
+  useEffect(() => {
+    if (subscribersData?.subscribers) {
+      setList(subscribersData?.subscribers.map((s) => ({
+        userId: s.userId,
+        onEnter: s.onEnter,
+        onExit: s.onExit,
+        onOffline: s.onOffline,
+      })));
+    }
+  }, [subscribersData]);
+
+  const saveMutation = useMutation({
+    mutationFn: async () => {
+      const res = await apiRequest('PUT', `/api/gps/assets/${asset!.id}/subscribers`, list);
+      return res.json();
+    },
+    onSuccess: () => {
+      toast({ title: 'Подписчики сохранены' });
+      invalidateGps('assets');
+      onClose();
+    },
+    onError: (err: any) => {
+      toast({ title: 'Ошибка', description: err?.message || 'Не удалось сохранить подписчиков', variant: 'destructive' });
+    },
+  });
+
+  const selectedIds = new Set(list.map((s) => String(s.userId)));
+
+  const toggleFlag = (userId: number, flag: 'onEnter' | 'onExit' | 'onOffline') => {
+    setList((prev) => prev.map((s) => (s.userId === userId ? { ...s, [flag]: !s[flag] } : s)));
+  };
+
+  return (
+    <Dialog open={!!asset} onOpenChange={(open) => !open && onClose()}>
+      <DialogContent className="max-w-lg">
+        <DialogHeader>
+          <DialogTitle>Подписчики: {asset?.name}</DialogTitle>
+          <DialogDescription>
+            Пользователи получат уведомления о входе/выходе объекта из геозон и о переходе в офлайн
+          </DialogDescription>
+        </DialogHeader>
+        {isLoading ? (
+          <div className="flex items-center justify-center h-24">
+            <Loader2 className="h-5 w-5 animate-spin text-muted-foreground" />
+          </div>
+        ) : (
+          <div className="space-y-3">
+            <MultiSelectPopover
+              label="Пользователи"
+              search
+              items={users.map((u) => ({ value: String(u.id), label: userLabel(u) }))}
+              selected={selectedIds}
+              onChange={(next) => {
+                setList((prev) => {
+                  const kept = prev.filter((s) => next.has(String(s.userId)));
+                  const keptIds = new Set(kept.map((s) => s.userId));
+                  const added = [...next]
+                    .filter((id) => !keptIds.has(Number(id)))
+                    .map((id) => ({ userId: Number(id), onEnter: true, onExit: true, onOffline: false }));
+                  return [...kept, ...added];
+                });
+              }}
+            />
+            {list.length === 0 ? (
+              <p className="text-xs text-muted-foreground">Подписчиков нет</p>
+            ) : (
+              <div className="space-y-2">
+                {list.map((s) => {
+                  const u = users.find((x) => x.id === s.userId);
+                  return (
+                    <div key={s.userId} className="flex items-center gap-3 border border-border rounded px-2.5 py-2">
+                      <span className="text-xs font-medium flex-1 truncate">{u ? userLabel(u) : `ID ${s.userId}`}</span>
+                      <label className="flex items-center gap-1 text-[11px] text-muted-foreground">
+                        <Switch
+                          className="scale-[0.7]"
+                          checked={s.onEnter}
+                          onCheckedChange={() => toggleFlag(s.userId, 'onEnter')}
+                        />
+                        Вход
+                      </label>
+                      <label className="flex items-center gap-1 text-[11px] text-muted-foreground">
+                        <Switch
+                          className="scale-[0.7]"
+                          checked={s.onExit}
+                          onCheckedChange={() => toggleFlag(s.userId, 'onExit')}
+                        />
+                        Выход
+                      </label>
+                      <label className="flex items-center gap-1 text-[11px] text-muted-foreground">
+                        <Switch
+                          className="scale-[0.7]"
+                          checked={s.onOffline}
+                          onCheckedChange={() => toggleFlag(s.userId, 'onOffline')}
+                        />
+                        Офлайн
+                      </label>
+                    </div>
+                  );
+                })}
+              </div>
+            )}
+            <Button className="w-full h-8" disabled={saveMutation.isPending} onClick={() => saveMutation.mutate()}>
+              {saveMutation.isPending && <Loader2 className="w-3.5 h-3.5 mr-1 animate-spin" />}
+              Сохранить
+            </Button>
+          </div>
+        )}
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/client/src/pages/gps/GeozonesTab.tsx b/client/src/pages/gps/GeozonesTab.tsx
new file mode 100644
index 0000000..6fee38f
--- /dev/null
+++ b/client/src/pages/gps/GeozonesTab.tsx
@@ -0,0 +1,400 @@
+import { useState } from 'react';
+import { useMutation } from '@tanstack/react-query';
+import { Card, CardContent } from '@/components/ui/card';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Badge } from '@/components/ui/badge';
+import { Switch } from '@/components/ui/switch';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
+import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from '@/components/ui/dialog';
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table';
+import { Loader2, Pencil, Trash2, Undo2, Check, Hexagon } from 'lucide-react';
+import { apiRequest } from '@/lib/queryClient';
+import { useToast } from '@/hooks/use-toast';
+import { YandexMap } from '@/components/gps/YandexMap';
+import { GpsDotMarker, GpsGeozonePolygon, GpsPolyline } from '@/components/gps/map-features';
+import { invalidateGps, useGpsConfig, useGpsGeozoneEvents, useGpsGeozones } from '@/hooks/useGps';
+import type { GpsGeozone } from './types';
+
+function formatDateTime(value: string): string {
+  return new Date(value).toLocaleString('ru-RU');
+}
+
+/** Форма сохранения геозоны (создание и редактирование) */
+interface GeozoneFormState {
+  name: string;
+  color: string;
+  notifyEnter: boolean;
+  notifyExit: boolean;
+}
+
+const DEFAULT_FORM: GeozoneFormState = {
+  name: '',
+  color: '#f97316',
+  notifyEnter: true,
+  notifyExit: true,
+};
+
+/**
+ * Таб «Геозоны»: слева список зон, справа карта с рисованием полигонов,
+ * ниже — журнал событий входа/выхода с фильтром по зоне.
+ */
+export function GpsGeozonesTab() {
+  const { toast } = useToast();
+  const { data: configData } = useGpsConfig();
+  const { data: geozonesData, isLoading } = useGpsGeozones();
+  const geozones = geozonesData?.geozones || [];
+
+  // Режим рисования: накапливаем вершины кликами по карте ([lat, lng])
+  const [drawing, setDrawing] = useState(false);
+  const [draft, setDraft] = useState<Array<[number, number]>>([]);
+  const [saveDialogOpen, setSaveDialogOpen] = useState(false);
+
+  // Редактирование существующей зоны
+  const [editing, setEditing] = useState<GpsGeozone | null>(null);
+  const [form, setForm] = useState<GeozoneFormState>(DEFAULT_FORM);
+
+  const startDrawing = () => {
+    setDraft([]);
+    setDrawing(true);
+  };
+
+  const cancelDrawing = () => {
+    setDrawing(false);
+    setDraft([]);
+  };
+
+  const undoVertex = () => setDraft((d) => d.slice(0, -1));
+
+  const finishDrawing = () => {
+    if (draft.length < 3) return;
+    setForm(DEFAULT_FORM);
+    setSaveDialogOpen(true);
+  };
+
+  const createMutation = useMutation({
+    mutationFn: async () => {
+      const res = await apiRequest('POST', '/api/gps/geozones', {
+        name: form.name.trim(),
+        polygon: draft,
+        color: form.color,
+        notifyEnter: form.notifyEnter,
+        notifyExit: form.notifyExit,
+      });
+      return res.json();
+    },
+    onSuccess: () => {
+      toast({ title: 'Геозона создана' });
+      setSaveDialogOpen(false);
+      cancelDrawing();
+      invalidateGps('geozones');
+    },
+    onError: (err: any) => {
+      toast({ title: 'Ошибка', description: err?.message || 'Не удалось создать геозону', variant: 'destructive' });
+    },
+  });
+
+  const updateMutation = useMutation({
+    mutationFn: async () => {
+      const res = await apiRequest('PATCH', `/api/gps/geozones/${editing!.id}`, {
+        name: form.name.trim(),
+        color: form.color,
+        notifyEnter: form.notifyEnter,
+        notifyExit: form.notifyExit,
+      });
+      return res.json();
+    },
+    onSuccess: () => {
+      toast({ title: 'Геозона обновлена' });
+      setEditing(null);
+      invalidateGps('geozones');
+    },
+    onError: (err: any) => {
+      toast({ title: 'Ошибка', description: err?.message || 'Не удалось обновить геозону', variant: 'destructive' });
+    },
+  });
+
+  const deleteMutation = useMutation({
+    mutationFn: async (id: number) => {
+      const res = await apiRequest('DELETE', `/api/gps/geozones/${id}`);
+      return res.json();
+    },
+    onSuccess: () => {
+      toast({ title: 'Геозона удалена' });
+      invalidateGps('geozones', 'geozone-events');
+    },
+    onError: (err: any) => {
+      toast({ title: 'Ошибка', description: err?.message || 'Не удалось удалить геозону', variant: 'destructive' });
+    },
+  });
+
+  const openEdit = (g: GpsGeozone) => {
+    setForm({
+      name: g.name,
+      color: g.color || '#f97316',
+      notifyEnter: g.notifyEnter !== false,
+      notifyExit: g.notifyExit !== false,
+    });
+    setEditing(g);
+  };
+
+  return (
+    <div className="space-y-4">
+      <div className="grid grid-cols-1 lg:grid-cols-[320px_1fr] gap-4">
+        {/* Список геозон */}
+        <Card>
+          <CardContent className="p-3 space-y-2">
+            <div className="flex items-center justify-between">
+              <h3 className="text-sm font-semibold">Геозоны</h3>
+              {!drawing ? (
+                <Button size="sm" className="h-7 text-xs" onClick={startDrawing}>
+                  <Hexagon className="w-3.5 h-3.5 mr-1" />
+                  Нарисовать зону
+                </Button>
+              ) : (
+                <Badge variant="secondary" className="text-[10px]">
+                  Рисование…
+                </Badge>
+              )}
+            </div>
+            {isLoading ? (
+              <div className="flex items-center justify-center h-24">
+                <Loader2 className="h-5 w-5 animate-spin text-muted-foreground" />
+              </div>
+            ) : geozones.length === 0 ? (
+              <p className="text-xs text-muted-foreground py-4 text-center">
+                Геозон пока нет. Нажмите «Нарисовать зону» и кликайте по карте.
+              </p>
+            ) : (
+              <div className="space-y-1.5">
+                {geozones.map((g) => (
+                  <div
+                    key={g.id}
+                    className={`border border-border rounded px-2.5 py-2 ${g.isActive === false ? 'opacity-50' : ''}`}
+                  >
+                    <div className="flex items-center gap-2">
+                      <span
+                        className="w-3 h-3 rounded-sm shrink-0 border border-border"
+                        style={{ backgroundColor: g.color || '#f97316' }}
+                      />
+                      <span className="text-xs font-medium flex-1 truncate">{g.name}</span>
+                      <Button variant="ghost" size="sm" className="h-6 w-6 p-0" onClick={() => openEdit(g)}>
+                        <Pencil className="w-3 h-3" />
+                      </Button>
+                      <Button
+                        variant="ghost"
+                        size="sm"
+                        className="h-6 w-6 p-0"
+                        onClick={() => {
+                          if (window.confirm(`Удалить геозону «${g.name}»?`)) {
+                            deleteMutation.mutate(g.id);
+                          }
+                        }}
+                      >
+                        <Trash2 className="w-3 h-3 text-destructive" />
+                      </Button>
+                    </div>
+                    <div className="flex items-center gap-1.5 mt-1 flex-wrap">
+                      <span className="text-[10px] text-muted-foreground">Вершин: {g.polygon.length}</span>
+                      {g.notifyEnter !== false && (
+                        <Badge variant="outline" className="text-[9px] h-4 px-1">вход</Badge>
+                      )}
+                      {g.notifyExit !== false && (
+                        <Badge variant="outline" className="text-[9px] h-4 px-1">выход</Badge>
+                      )}
+                      {g.isActive === false && (
+                        <Badge variant="secondary" className="text-[9px] h-4 px-1">неактивна</Badge>
+                      )}
+                    </div>
+                  </div>
+                ))}
+              </div>
+            )}
+          </CardContent>
+        </Card>
+
+        {/* Карта с зонами и рисованием */}
+        <div className="space-y-2">
+          {drawing && (
+            <div className="flex items-center gap-2 flex-wrap">
+              <span className="text-xs text-muted-foreground">
+                Кликайте по карте, чтобы добавить вершины ({draft.length})
+              </span>
+              <Button size="sm" variant="outline" className="h-7 text-xs" onClick={undoVertex} disabled={draft.length === 0}>
+                <Undo2 className="w-3.5 h-3.5 mr-1" />
+                Отменить точку
+              </Button>
+              <Button size="sm" className="h-7 text-xs" onClick={finishDrawing} disabled={draft.length < 3}>
+                <Check className="w-3.5 h-3.5 mr-1" />
+                Завершить
+              </Button>
+              <Button size="sm" variant="ghost" className="h-7 text-xs" onClick={cancelDrawing}>
+                Отмена
+              </Button>
+            </div>
+          )}
+          <YandexMap
+            apiKey={configData?.yandexMapsKey}
+            className="h-[55vh] min-h-[350px] w-full rounded-md overflow-hidden border border-border"
+            onMapClick={
+              drawing
+                ? ([lng, lat]) => setDraft((d) => [...d, [lat, lng]])
+                : undefined
+            }
+          >
+            {geozones.map((g) => (
+              <GpsGeozonePolygon key={g.id} polygon={g.polygon} color={g.color} />
+            ))}
+            {/* Строящийся полигон: замкнутая заливка при 3+ точках, иначе пунктирная линия */}
+            {draft.length >= 3 && <GpsGeozonePolygon polygon={draft} color="#f97316" fillOpacity={0.25} />}
+            {draft.length >= 2 && <GpsPolyline points={draft} color="#f97316" width={2} dashed />}
+            {draft.map(([lat, lng], idx) => (
+              <GpsDotMarker key={idx} coordinates={[lng, lat]} color="#f97316" label={String(idx + 1)} zIndex={10} />
+            ))}
+          </YandexMap>
+        </div>
+      </div>
+
+      {/* Журнал событий */}
+      <GeozoneEventsJournal geozones={geozones} />
+
+      {/* Диалог сохранения нарисованной зоны */}
+      <Dialog open={saveDialogOpen} onOpenChange={(open) => !open && setSaveDialogOpen(false)}>
+        <DialogContent className="max-w-md">
+          <DialogHeader>
+            <DialogTitle>Новая геозона</DialogTitle>
+            <DialogDescription>Полигон из {draft.length} вершин</DialogDescription>
+          </DialogHeader>
+          <GeozoneForm form={form} onChange={setForm} />
+          <Button
+            className="w-full h-8"
+            disabled={createMutation.isPending || !form.name.trim()}
+            onClick={() => createMutation.mutate()}
+          >
+            {createMutation.isPending && <Loader2 className="w-3.5 h-3.5 mr-1 animate-spin" />}
+            Создать
+          </Button>
+        </DialogContent>
+      </Dialog>
+
+      {/* Диалог редактирования */}
+      <Dialog open={!!editing} onOpenChange={(open) => !open && setEditing(null)}>
+        <DialogContent className="max-w-md">
+          <DialogHeader>
+            <DialogTitle>Редактирование геозоны</DialogTitle>
+            <DialogDescription>Изменение контура пока не поддерживается — удалите зону и нарисуйте заново</DialogDescription>
+          </DialogHeader>
+          <GeozoneForm form={form} onChange={setForm} />
+          <Button
+            className="w-full h-8"
+            disabled={updateMutation.isPending || !form.name.trim()}
+            onClick={() => updateMutation.mutate()}
+          >
+            {updateMutation.isPending && <Loader2 className="w-3.5 h-3.5 mr-1 animate-spin" />}
+            Сохранить
+          </Button>
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}
+
+/** Общая форма параметров геозоны (имя, цвет, уведомления) */
+function GeozoneForm({ form, onChange }: { form: GeozoneFormState; onChange: (f: GeozoneFormState) => void }) {
+  return (
+    <div className="space-y-3">
+      <div className="space-y-1">
+        <Label className="text-xs">Название</Label>
+        <Input
+          className="h-8"
+          value={form.name}
+          onChange={(e) => onChange({ ...form, name: e.target.value })}
+          placeholder="Например: Склад №1"
+        />
+      </div>
+      <div className="space-y-1">
+        <Label className="text-xs">Цвет</Label>
+        <Input
+          type="color"
+          className="h-8 w-full p-1 cursor-pointer"
+          value={form.color}
+          onChange={(e) => onChange({ ...form, color: e.target.value })}
+        />
+      </div>
+      <div className="flex items-center gap-2">
+        <Switch checked={form.notifyEnter} onCheckedChange={(v) => onChange({ ...form, notifyEnter: v })} />
+        <Label className="text-xs">Уведомлять о входе в зону</Label>
+      </div>
+      <div className="flex items-center gap-2">
+        <Switch checked={form.notifyExit} onCheckedChange={(v) => onChange({ ...form, notifyExit: v })} />
+        <Label className="text-xs">Уведомлять о выходе из зоны</Label>
+      </div>
+    </div>
+  );
+}
+
+/** Журнал событий входа/выхода из геозон с фильтром по зоне */
+function GeozoneEventsJournal({ geozones }: { geozones: GpsGeozone[] }) {
+  const [geozoneFilter, setGeozoneFilter] = useState<string>('all');
+  const { data, isLoading } = useGpsGeozoneEvents({
+    geozoneId: geozoneFilter === 'all' ? undefined : Number(geozoneFilter),
+    limit: 200,
+  });
+  const events = data?.events || [];
+
+  return (
+    <Card>
+      <CardContent className="p-3 space-y-2">
+        <div className="flex items-center justify-between gap-2 flex-wrap">
+          <h3 className="text-sm font-semibold">Журнал событий</h3>
+          <Select value={geozoneFilter} onValueChange={setGeozoneFilter}>
+            <SelectTrigger className="w-56 h-8 text-xs">
+              <SelectValue placeholder="Все геозоны" />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem value="all">Все геозоны</SelectItem>
+              {geozones.map((g) => (
+                <SelectItem key={g.id} value={String(g.id)}>
+                  {g.name}
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+        </div>
+        {isLoading ? (
+          <div className="flex items-center justify-center h-24">
+            <Loader2 className="h-5 w-5 animate-spin text-muted-foreground" />
+          </div>
+        ) : events.length === 0 ? (
+          <p className="text-xs text-muted-foreground py-4 text-center">Событий пока нет</p>
+        ) : (
+          <Table>
+            <TableHeader>
+              <TableRow>
+                <TableHead>Время</TableHead>
+                <TableHead>Объект</TableHead>
+                <TableHead>Геозона</TableHead>
+                <TableHead>Событие</TableHead>
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {events.map((e) => (
+                <TableRow key={e.id}>
+                  <TableCell className="text-xs text-muted-foreground">{formatDateTime(e.createdAt)}</TableCell>
+                  <TableCell className="text-xs font-medium">{e.assetName || `#${e.assetId}`}</TableCell>
+                  <TableCell className="text-xs">{e.geozoneName || `#${e.geozoneId}`}</TableCell>
+                  <TableCell>
+                    <Badge variant={e.event === 'enter' ? 'default' : 'secondary'} className="text-[10px]">
+                      {e.event === 'enter' ? 'Вход' : 'Выход'}
+                    </Badge>
+                  </TableCell>
+                </TableRow>
+              ))}
+            </TableBody>
+          </Table>
+        )}
+      </CardContent>
+    </Card>
+  );
+}
diff --git a/client/src/pages/gps/GroupsTab.tsx b/client/src/pages/gps/GroupsTab.tsx
new file mode 100644
index 0000000..f33d1f2
--- /dev/null
+++ b/client/src/pages/gps/GroupsTab.tsx
@@ -0,0 +1,186 @@
+import { useState } from 'react';
+import { useMutation } from '@tanstack/react-query';
+import { Card, CardContent } from '@/components/ui/card';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Badge } from '@/components/ui/badge';
+import { Dialog, DialogContent, DialogHeader, DialogTitle } from '@/components/ui/dialog';
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table';
+import { Loader2, Pencil, Plus, Trash2 } from 'lucide-react';
+import { apiRequest } from '@/lib/queryClient';
+import { useToast } from '@/hooks/use-toast';
+import { invalidateGps, useGpsAssets, useGpsGroups } from '@/hooks/useGps';
+import { MultiSelectPopover } from '@/components/MultiSelectPopover';
+import type { GpsGroup } from './types';
+
+/**
+ * Таб «Группы»: CRUD групп объектов (имя + состав).
+ */
+export function GpsGroupsTab() {
+  const { toast } = useToast();
+  const { data: groupsData, isLoading } = useGpsGroups();
+  const { data: assetsData } = useGpsAssets();
+  const groups = groupsData?.groups || [];
+  const assets = assetsData?.assets || [];
+
+  const [dialogOpen, setDialogOpen] = useState(false);
+  const [editing, setEditing] = useState<GpsGroup | null>(null);
+  const [name, setName] = useState('');
+  const [assetIds, setAssetIds] = useState<Set<string>>(new Set());
+
+  const openCreate = () => {
+    setEditing(null);
+    setName('');
+    setAssetIds(new Set());
+    setDialogOpen(true);
+  };
+
+  const openEdit = (group: GpsGroup) => {
+    setEditing(group);
+    setName(group.name);
+    setAssetIds(new Set(group.assetIds.map(String)));
+    setDialogOpen(true);
+  };
+
+  const saveMutation = useMutation({
+    mutationFn: async () => {
+      const body = { name: name.trim(), assetIds: [...assetIds].map(Number) };
+      const res = editing
+        ? await apiRequest('PATCH', `/api/gps/groups/${editing.id}`, body)
+        : await apiRequest('POST', '/api/gps/groups', body);
+      return res.json();
+    },
+    onSuccess: () => {
+      toast({ title: editing ? 'Группа обновлена' : 'Группа создана' });
+      setDialogOpen(false);
+      invalidateGps('groups', 'assets');
+    },
+    onError: (err: any) => {
+      toast({ title: 'Ошибка', description: err?.message || 'Не удалось сохранить группу', variant: 'destructive' });
+    },
+  });
+
+  const deleteMutation = useMutation({
+    mutationFn: async (id: number) => {
+      const res = await apiRequest('DELETE', `/api/gps/groups/${id}`);
+      return res.json();
+    },
+    onSuccess: () => {
+      toast({ title: 'Группа удалена' });
+      invalidateGps('groups', 'assets');
+    },
+    onError: (err: any) => {
+      toast({ title: 'Ошибка', description: err?.message || 'Не удалось удалить группу', variant: 'destructive' });
+    },
+  });
+
+  const assetName = (id: number) => assets.find((a) => a.id === id)?.name || `#${id}`;
+
+  return (
+    <div className="space-y-3">
+      <div className="flex justify-end">
+        <Button size="sm" className="h-8" onClick={openCreate}>
+          <Plus className="w-4 h-4 mr-1" />
+          Добавить группу
+        </Button>
+      </div>
+
+      <Card>
+        <CardContent className="p-0">
+          {isLoading ? (
+            <div className="flex items-center justify-center h-32">
+              <Loader2 className="h-6 w-6 animate-spin text-muted-foreground" />
+            </div>
+          ) : groups.length === 0 ? (
+            <p className="text-center text-sm text-muted-foreground py-8">
+              Групп пока нет. Группы удобны для фильтрации объектов на карте.
+            </p>
+          ) : (
+            <Table>
+              <TableHeader>
+                <TableRow>
+                  <TableHead>Название</TableHead>
+                  <TableHead>Объекты</TableHead>
+                  <TableHead className="text-right">Действия</TableHead>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {groups.map((group) => (
+                  <TableRow key={group.id}>
+                    <TableCell className="font-medium text-sm">{group.name}</TableCell>
+                    <TableCell>
+                      <div className="flex items-center gap-1 flex-wrap">
+                        {group.assetIds.length === 0 ? (
+                          <span className="text-xs text-muted-foreground">пусто</span>
+                        ) : (
+                          group.assetIds.map((id) => (
+                            <Badge key={id} variant="secondary" className="text-[10px]">
+                              {assetName(id)}
+                            </Badge>
+                          ))
+                        )}
+                      </div>
+                    </TableCell>
+                    <TableCell className="text-right">
+                      <div className="flex items-center justify-end gap-1">
+                        <Button variant="ghost" size="sm" className="h-7 w-7 p-0" onClick={() => openEdit(group)}>
+                          <Pencil className="w-3.5 h-3.5" />
+                        </Button>
+                        <Button
+                          variant="ghost"
+                          size="sm"
+                          className="h-7 w-7 p-0"
+                          onClick={() => {
+                            if (window.confirm(`Удалить группу «${group.name}»? Объекты не удалятся.`)) {
+                              deleteMutation.mutate(group.id);
+                            }
+                          }}
+                        >
+                          <Trash2 className="w-3.5 h-3.5 text-destructive" />
+                        </Button>
+                      </div>
+                    </TableCell>
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          )}
+        </CardContent>
+      </Card>
+
+      <Dialog open={dialogOpen} onOpenChange={setDialogOpen}>
+        <DialogContent className="max-w-md">
+          <DialogHeader>
+            <DialogTitle>{editing ? 'Редактирование группы' : 'Новая группа'}</DialogTitle>
+          </DialogHeader>
+          <div className="space-y-3">
+            <div className="space-y-1">
+              <Label className="text-xs">Название</Label>
+              <Input className="h-8" value={name} onChange={(e) => setName(e.target.value)} placeholder="Например: Грузовой парк" />
+            </div>
+            <div className="space-y-1">
+              <Label className="text-xs">Объекты</Label>
+              <MultiSelectPopover
+                label="Выберите объекты"
+                search
+                className="w-full"
+                items={assets.map((a) => ({ value: String(a.id), label: a.name }))}
+                selected={assetIds}
+                onChange={setAssetIds}
+              />
+            </div>
+            <Button
+              className="w-full h-8"
+              disabled={saveMutation.isPending || !name.trim()}
+              onClick={() => saveMutation.mutate()}
+            >
+              {saveMutation.isPending && <Loader2 className="w-3.5 h-3.5 mr-1 animate-spin" />}
+              {editing ? 'Сохранить' : 'Создать'}
+            </Button>
+          </div>
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}
diff --git a/client/src/pages/gps/MapTab.tsx b/client/src/pages/gps/MapTab.tsx
new file mode 100644
index 0000000..53f3e31
--- /dev/null
+++ b/client/src/pages/gps/MapTab.tsx
@@ -0,0 +1,155 @@
+import { useEffect, useMemo, useState } from 'react';
+import { Card } from '@/components/ui/card';
+import { Button } from '@/components/ui/button';
+import { Badge } from '@/components/ui/badge';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
+import { X, Route } from 'lucide-react';
+import { YandexMap, type LngLatBounds } from '@/components/gps/YandexMap';
+import { GpsAssetMarker, GpsGeozonePolygon } from '@/components/gps/map-features';
+import { useGpsAssets, useGpsConfig, useGpsGeozones, useGpsGroups, useGpsLiveUpdates, useGpsPositions } from '@/hooks/useGps';
+import type { GpsPosition } from './types';
+
+function formatDateTime(value: string | null): string {
+  if (!value) return '—';
+  return new Date(value).toLocaleString('ru-RU');
+}
+
+/**
+ * Таб «Карта»: текущие позиции всех активных объектов, геозоны,
+ * фильтр по группе, попап объекта с переходом к маршруту за сегодня.
+ */
+export function GpsMapTab({ onShowRoute }: { onShowRoute: (assetId: number) => void }) {
+  const { data: configData } = useGpsConfig();
+  const { data: assetsData } = useGpsAssets();
+  const { data: positionsData } = useGpsPositions();
+  const { data: geozonesData } = useGpsGeozones();
+  const { data: groupsData } = useGpsGroups();
+  useGpsLiveUpdates();
+
+  const [groupFilter, setGroupFilter] = useState<string>('all');
+  const [selected, setSelected] = useState<GpsPosition | null>(null);
+
+  const assets = assetsData?.assets || [];
+  const positions = (positionsData?.positions || []).filter((p) => p.lat != null && p.lng != null);
+  const geozones = (geozonesData?.geozones || []).filter((g) => g.isActive !== false);
+  const groups = groupsData?.groups || [];
+
+  // Фильтр по группе: принадлежность объекта группам берём из списка assets
+  const groupAssetIds = useMemo(() => {
+    if (groupFilter === 'all') return null;
+    const group = groups.find((g) => String(g.id) === groupFilter);
+    return group ? new Set(group.assetIds) : new Set<number>();
+  }, [groupFilter, groups]);
+
+  const visiblePositions = useMemo(
+    () => (groupAssetIds ? positions.filter((p) => groupAssetIds.has(p.assetId)) : positions),
+    [positions, groupAssetIds]
+  );
+
+  // Автоподгонка bounds при первой загрузке позиций (дальше пользователь двигает карту сам)
+  const [bounds, setBounds] = useState<LngLatBounds | null>(null);
+  useEffect(() => {
+    if (bounds || positions.length === 0) return;
+    const lats = positions.map((p) => p.lat as number);
+    const lngs = positions.map((p) => p.lng as number);
+    const pad = 0.01;
+    setBounds([
+      [Math.min(...lngs) - pad, Math.min(...lats) - pad],
+      [Math.max(...lngs) + pad, Math.max(...lats) + pad],
+    ]);
+  }, [positions, bounds]);
+
+  // Если выбранный объект пропал из позиций (стал неактивным) — закрываем панель
+  useEffect(() => {
+    if (selected && !positions.some((p) => p.assetId === selected.assetId)) {
+      setSelected(null);
+    }
+  }, [positions, selected]);
+
+  const selectedAsset = selected ? assets.find((a) => a.id === selected.assetId) : null;
+  const selectedLive = selected ? positions.find((p) => p.assetId === selected.assetId) ?? selected : null;
+
+  return (
+    <div className="space-y-3">
+      <div className="flex items-center gap-2 flex-wrap">
+        <Select value={groupFilter} onValueChange={setGroupFilter}>
+          <SelectTrigger className="w-56 h-8 text-xs">
+            <SelectValue placeholder="Все группы" />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem value="all">Все группы</SelectItem>
+            {groups.map((g) => (
+              <SelectItem key={g.id} value={String(g.id)}>
+                {g.name}
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+        <span className="text-xs text-muted-foreground">
+          Объектов на карте: {visiblePositions.length}
+        </span>
+      </div>
+
+      <div className="relative">
+        <YandexMap
+          apiKey={configData?.yandexMapsKey}
+          bounds={bounds ?? undefined}
+          className="h-[60vh] min-h-[400px] w-full rounded-md overflow-hidden border border-border"
+        >
+          {geozones.map((g) => (
+            <GpsGeozonePolygon key={`gz-${g.id}`} polygon={g.polygon} color={g.color} />
+          ))}
+          {visiblePositions.map((p) => (
+            <GpsAssetMarker
+              key={p.assetId}
+              coordinates={[p.lng as number, p.lat as number]}
+              name={p.name}
+              type={p.type}
+              color={p.color}
+              isOnline={p.isOnline}
+              onClick={() => setSelected(p)}
+            />
+          ))}
+        </YandexMap>
+
+        {/* Панель выбранного объекта поверх карты */}
+        {selectedLive && (
+          <Card className="absolute top-2 right-2 w-72 p-3 space-y-2 shadow-lg z-10">
+            <div className="flex items-start justify-between gap-2">
+              <div className="min-w-0">
+                <div className="font-medium text-sm truncate">{selectedLive.name}</div>
+                <div className="flex items-center gap-1.5 mt-1">
+                  <Badge variant="outline" className="text-[10px]">
+                    {selectedLive.type === 'person' ? 'Человек' : 'Транспорт'}
+                  </Badge>
+                  <span className="flex items-center gap-1 text-[11px] text-muted-foreground">
+                    <span
+                      className="w-2 h-2 rounded-full"
+                      style={{ backgroundColor: selectedLive.isOnline ? '#22c55e' : '#9ca3af' }}
+                    />
+                    {selectedLive.isOnline ? 'Онлайн' : 'Офлайн'}
+                  </span>
+                </div>
+              </div>
+              <Button variant="ghost" size="sm" className="h-6 w-6 p-0" onClick={() => setSelected(null)}>
+                <X className="w-3.5 h-3.5" />
+              </Button>
+            </div>
+            <div className="text-xs text-muted-foreground space-y-0.5">
+              <div>
+                Скорость:{' '}
+                {selectedLive.speed != null ? `${Math.round(selectedLive.speed)} км/ч` : '—'}
+              </div>
+              <div>Последняя точка: {formatDateTime(selectedLive.recordedAt)}</div>
+              {selectedAsset?.externalId && <div>Трекер: {selectedAsset.externalId}</div>}
+            </div>
+            <Button size="sm" className="w-full h-8" onClick={() => onShowRoute(selectedLive.assetId)}>
+              <Route className="w-3.5 h-3.5 mr-1" />
+              Маршрут за сегодня
+            </Button>
+          </Card>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/client/src/pages/gps/RoutesTab.tsx b/client/src/pages/gps/RoutesTab.tsx
new file mode 100644
index 0000000..6016ff7
--- /dev/null
+++ b/client/src/pages/gps/RoutesTab.tsx
@@ -0,0 +1,294 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { useSearch } from 'wouter';
+import { Card, CardContent } from '@/components/ui/card';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
+import { Loader2, Pause, Play } from 'lucide-react';
+import { YandexMap, type LngLatBounds } from '@/components/gps/YandexMap';
+import { GpsDotMarker, GpsPolyline } from '@/components/gps/map-features';
+import { useGpsAssets, useGpsConfig, useGpsTrack } from '@/hooks/useGps';
+import type { GpsTrackPoint } from './types';
+
+/** Расстояние между двумя точками в км (формула гаверсинуса) */
+function haversineKm(lat1: number, lng1: number, lat2: number, lng2: number): number {
+  const R = 6371;
+  const dLat = ((lat2 - lat1) * Math.PI) / 180;
+  const dLng = ((lng2 - lng1) * Math.PI) / 180;
+  const a =
+    Math.sin(dLat / 2) ** 2 +
+    Math.cos((lat1 * Math.PI) / 180) * Math.cos((lat2 * Math.PI) / 180) * Math.sin(dLng / 2) ** 2;
+  return 2 * R * Math.asin(Math.sqrt(a));
+}
+
+/** Значение для input type="datetime-local" в локальной таймзоне */
+function toLocalInputValue(d: Date): string {
+  const pad = (n: number) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+function todayRange(): { from: string; to: string } {
+  const now = new Date();
+  const start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  return { from: toLocalInputValue(start), to: toLocalInputValue(now) };
+}
+
+const PLAY_SPEEDS = [1, 5, 20] as const;
+
+/**
+ * Таб «Маршруты»: трек объекта за период — полилиния на карте,
+ * статистика (пробег, время, скорость) и анимация воспроизведения.
+ */
+export function GpsRoutesTab() {
+  const { data: configData } = useGpsConfig();
+  const { data: assetsData } = useGpsAssets();
+  const assets = (assetsData?.assets || []).filter((a) => a.isActive !== false);
+
+  // Предвыбор объекта из query (?assetId=) — переход «Маршрут за сегодня» с карты
+  const search = useSearch();
+  const preselectedAssetId = useMemo(() => {
+    const v = new URLSearchParams(search).get('assetId');
+    return v && Number.isFinite(Number(v)) ? Number(v) : null;
+  }, [search]);
+
+  const [assetId, setAssetId] = useState<string>(preselectedAssetId ? String(preselectedAssetId) : '');
+  const initialRange = useMemo(todayRange, []);
+  const [from, setFrom] = useState(initialRange.from);
+  const [to, setTo] = useState(initialRange.to);
+  // Применённые параметры запроса — трек грузится только по кнопке «Показать»
+  const [applied, setApplied] = useState<{ assetId: number; from: string; to: string } | null>(null);
+
+  // Пришли по ссылке с карты — сразу показываем трек за сегодня
+  useEffect(() => {
+    if (preselectedAssetId && !applied) {
+      const range = todayRange();
+      setAssetId(String(preselectedAssetId));
+      setFrom(range.from);
+      setTo(range.to);
+      setApplied({ assetId: preselectedAssetId, from: range.from, to: range.to });
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [preselectedAssetId]);
+
+  const { data: trackData, isFetching } = useGpsTrack(
+    applied?.assetId ?? null,
+    applied ? new Date(applied.from).toISOString() : '',
+    applied ? new Date(applied.to).toISOString() : '',
+    !!applied
+  );
+  const points: GpsTrackPoint[] = trackData?.points || [];
+
+  const selectedAsset = assets.find((a) => String(a.id) === (applied ? String(applied.assetId) : assetId));
+
+  // Статистика трека
+  const stats = useMemo(() => {
+    if (points.length === 0) return null;
+    let distance = 0;
+    let maxSpeed = 0;
+    for (let i = 1; i < points.length; i++) {
+      distance += haversineKm(points[i - 1].lat, points[i - 1].lng, points[i].lat, points[i].lng);
+    }
+    for (const p of points) {
+      if (p.speed != null && p.speed > maxSpeed) maxSpeed = p.speed;
+    }
+    const startTs = new Date(points[0].recordedAt).getTime();
+    const endTs = new Date(points[points.length - 1].recordedAt).getTime();
+    const durationMin = Math.max(0, Math.round((endTs - startTs) / 60000));
+    return { distance, maxSpeed, durationMin, startTs, endTs };
+  }, [points]);
+
+  // Автоподгонка карты под трек
+  const bounds: LngLatBounds | undefined = useMemo(() => {
+    if (points.length === 0) return undefined;
+    const lats = points.map((p) => p.lat);
+    const lngs = points.map((p) => p.lng);
+    const pad = 0.005;
+    return [
+      [Math.min(...lngs) - pad, Math.min(...lats) - pad],
+      [Math.max(...lngs) + pad, Math.max(...lats) + pad],
+    ];
+  }, [points]);
+
+  // === Воспроизведение трека ===
+  const [playing, setPlaying] = useState(false);
+  const [playSpeed, setPlaySpeed] = useState<(typeof PLAY_SPEEDS)[number]>(5);
+  const [playTs, setPlayTs] = useState<number | null>(null);
+  const playRef = useRef<number | null>(null);
+
+  const stopPlayback = () => {
+    setPlaying(false);
+    setPlayTs(null);
+    if (playRef.current !== null) {
+      window.clearInterval(playRef.current);
+      playRef.current = null;
+    }
+  };
+
+  // Сбрасываем воспроизведение при смене трека
+  useEffect(() => {
+    stopPlayback();
+  }, [trackData]);
+
+  useEffect(() => {
+    if (!playing || !stats) return;
+    playRef.current = window.setInterval(() => {
+      setPlayTs((ts) => {
+        const next = (ts ?? stats.startTs) + 100 * playSpeed;
+        if (next >= stats.endTs) {
+          // Конец трека — останавливаемся на последней точке
+          window.setTimeout(stopPlayback, 0);
+          return stats.endTs;
+        }
+        return next;
+      });
+    }, 100);
+    return () => {
+      if (playRef.current !== null) {
+        window.clearInterval(playRef.current);
+        playRef.current = null;
+      }
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [playing, playSpeed, stats]);
+
+  // Текущая точка воспроизведения: последняя точка с recordedAt <= playTs
+  const playPoint = useMemo(() => {
+    if (playTs === null || points.length === 0) return null;
+    let current = points[0];
+    for (const p of points) {
+      if (new Date(p.recordedAt).getTime() <= playTs) current = p;
+      else break;
+    }
+    return current;
+  }, [playTs, points]);
+
+  const trackCoords = points.map((p) => [p.lat, p.lng] as [number, number]);
+  const first = points[0];
+  const last = points[points.length - 1];
+
+  return (
+    <div className="space-y-3">
+      <div className="flex items-end gap-2 flex-wrap">
+        <div className="space-y-1">
+          <Label className="text-xs">Объект</Label>
+          <Select value={assetId} onValueChange={setAssetId}>
+            <SelectTrigger className="w-56 h-8 text-xs">
+              <SelectValue placeholder="Выберите объект" />
+            </SelectTrigger>
+            <SelectContent>
+              {assets.map((a) => (
+                <SelectItem key={a.id} value={String(a.id)}>
+                  {a.name}
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+        </div>
+        <div className="space-y-1">
+          <Label className="text-xs">С</Label>
+          <Input type="datetime-local" className="w-auto h-8 text-xs" value={from} onChange={(e) => setFrom(e.target.value)} />
+        </div>
+        <div className="space-y-1">
+          <Label className="text-xs">По</Label>
+          <Input type="datetime-local" className="w-auto h-8 text-xs" value={to} onChange={(e) => setTo(e.target.value)} />
+        </div>
+        <Button
+          size="sm"
+          className="h-8"
+          disabled={!assetId || !from || !to || isFetching}
+          onClick={() => setApplied({ assetId: Number(assetId), from, to })}
+        >
+          {isFetching && <Loader2 className="w-3.5 h-3.5 mr-1 animate-spin" />}
+          Показать
+        </Button>
+      </div>
+
+      <YandexMap
+        apiKey={configData?.yandexMapsKey}
+        bounds={bounds}
+        className="h-[55vh] min-h-[350px] w-full rounded-md overflow-hidden border border-border"
+      >
+        <GpsPolyline points={trackCoords} color={selectedAsset?.color || '#3b82f6'} />
+        {first && <GpsDotMarker coordinates={[first.lng, first.lat]} color="#22c55e" label="Старт" zIndex={5} />}
+        {last && points.length > 1 && (
+          <GpsDotMarker coordinates={[last.lng, last.lat]} color="#ef4444" label="Финиш" zIndex={5} />
+        )}
+        {playPoint && (
+          <GpsDotMarker
+            coordinates={[playPoint.lng, playPoint.lat]}
+            color={selectedAsset?.color || '#3b82f6'}
+            zIndex={20}
+          />
+        )}
+      </YandexMap>
+
+      {applied && !isFetching && points.length === 0 && (
+        <p className="text-sm text-muted-foreground text-center py-4">
+          За выбранный период точек нет
+        </p>
+      )}
+
+      {stats && (
+        <Card>
+          <CardContent className="p-3 space-y-3">
+            <div className="flex items-center gap-4 flex-wrap text-xs text-muted-foreground">
+              <span>
+                Точек: <span className="text-foreground font-medium">{points.length}</span>
+                {trackData?.sampled && ` (всего ${trackData.total}, показана каждая N-я)`}
+              </span>
+              <span>
+                Пробег: <span className="text-foreground font-medium">{stats.distance.toFixed(1)} км</span>
+              </span>
+              <span>
+                Время в пути:{' '}
+                <span className="text-foreground font-medium">
+                  {Math.floor(stats.durationMin / 60)} ч {stats.durationMin % 60} мин
+                </span>
+              </span>
+              <span>
+                Макс. скорость: <span className="text-foreground font-medium">{Math.round(stats.maxSpeed)} км/ч</span>
+              </span>
+            </div>
+            <div className="flex items-center gap-2">
+              <Button
+                size="sm"
+                variant="outline"
+                className="h-8"
+                onClick={() => {
+                  if (playing) {
+                    stopPlayback();
+                  } else {
+                    setPlayTs((ts) => ts ?? stats.startTs);
+                    setPlaying(true);
+                  }
+                }}
+              >
+                {playing ? <Pause className="w-3.5 h-3.5 mr-1" /> : <Play className="w-3.5 h-3.5 mr-1" />}
+                {playing ? 'Пауза' : 'Проиграть'}
+              </Button>
+              <div className="flex items-center gap-1">
+                {PLAY_SPEEDS.map((s) => (
+                  <Button
+                    key={s}
+                    size="sm"
+                    variant={playSpeed === s ? 'default' : 'outline'}
+                    className="h-8 px-2 text-xs"
+                    onClick={() => setPlaySpeed(s)}
+                  >
+                    x{s}
+                  </Button>
+                ))}
+              </div>
+              {playTs !== null && (
+                <span className="text-xs text-muted-foreground">
+                  {new Date(playTs).toLocaleTimeString('ru-RU')}
+                </span>
+              )}
+            </div>
+          </CardContent>
+        </Card>
+      )}
+    </div>
+  );
+}
diff --git a/client/src/pages/gps/index.tsx b/client/src/pages/gps/index.tsx
new file mode 100644
index 0000000..4ff5572
--- /dev/null
+++ b/client/src/pages/gps/index.tsx
@@ -0,0 +1,64 @@
+import { useLocation } from 'wouter';
+import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
+import { Map, Truck, Hexagon, Route, Folder } from 'lucide-react';
+import Layout from '@/components/Layout';
+import { GpsMapTab } from './MapTab';
+import { GpsAssetsTab } from './AssetsTab';
+import { GpsGeozonesTab } from './GeozonesTab';
+import { GpsRoutesTab } from './RoutesTab';
+import { GpsGroupsTab } from './GroupsTab';
+
+const TABS = [
+  { value: 'map', label: 'Карта', icon: Map },
+  { value: 'assets', label: 'Объекты', icon: Truck },
+  { value: 'geozones', label: 'Геозоны', icon: Hexagon },
+  { value: 'routes', label: 'Маршруты', icon: Route },
+  { value: 'groups', label: 'Группы', icon: Folder },
+];
+
+/**
+ * GPS-мониторинг: карта с объектами, геозоны, маршруты, группы.
+ * Вкладки адресуются роутами /gps и /gps/:tab.
+ */
+export default function GpsPage() {
+  const [location, setLocation] = useLocation();
+  const match = location.match(/\/gps\/(.*)/);
+  const activeTab = TABS.some((t) => t.value === match?.[1]) ? match![1] : 'map';
+
+  const onTabChange = (value: string) => setLocation(value === 'map' ? '/gps' : `/gps/${value}`);
+
+  return (
+    <Layout>
+      <div className="container mx-auto p-4 max-w-7xl">
+        <h1 className="text-2xl font-bold mb-4">GPS-мониторинг</h1>
+
+        <Tabs value={activeTab} onValueChange={onTabChange} className="w-full">
+          <TabsList className="flex-wrap h-auto mb-4">
+            {TABS.map((t) => (
+              <TabsTrigger key={t.value} value={t.value} className="gap-1">
+                <t.icon className="h-4 w-4" />
+                <span className="hidden sm:inline">{t.label}</span>
+              </TabsTrigger>
+            ))}
+          </TabsList>
+
+          <TabsContent value="map">
+            <GpsMapTab onShowRoute={(assetId) => setLocation(`/gps/routes?assetId=${assetId}`)} />
+          </TabsContent>
+          <TabsContent value="assets">
+            <GpsAssetsTab />
+          </TabsContent>
+          <TabsContent value="geozones">
+            <GpsGeozonesTab />
+          </TabsContent>
+          <TabsContent value="routes">
+            <GpsRoutesTab />
+          </TabsContent>
+          <TabsContent value="groups">
+            <GpsGroupsTab />
+          </TabsContent>
+        </Tabs>
+      </div>
+    </Layout>
+  );
+}
diff --git a/client/src/pages/gps/types.ts b/client/src/pages/gps/types.ts
new file mode 100644
index 0000000..1fab008
--- /dev/null
+++ b/client/src/pages/gps/types.ts
@@ -0,0 +1,111 @@
+/**
+ * Клиентские типы GPS-модуля.
+ * Соответствуют ответам серверных роутов server/gps/routes.ts
+ * (источники — таблицы gps_assets, gps_geozones, gps_groups и т.д. из shared/schema.ts).
+ */
+
+/** Объект мониторинга (машина или человек) */
+export interface GpsAsset {
+  id: number;
+  organizationId: number;
+  name: string;
+  type: 'vehicle' | 'person';
+  userId: number | null;
+  externalId: string | null;
+  color: string | null;
+  isActive: boolean | null;
+  isOnline: boolean | null;
+  lastLat: number | null;
+  lastLng: number | null;
+  lastSpeed: number | null;
+  lastCourse: number | null;
+  lastSeenAt: string | null;
+  createdAt: string | null;
+  /** Группы объекта (добавляет GET /api/gps/assets) */
+  groups?: Array<{ id: number; name: string }>;
+  /** Число подписчиков (добавляет GET /api/gps/assets) */
+  subscriberCount?: number;
+}
+
+/** Текущая позиция объекта (GET /api/gps/assets/positions) */
+export interface GpsPosition {
+  assetId: number;
+  name: string;
+  type: 'vehicle' | 'person';
+  color: string | null;
+  isOnline: boolean | null;
+  lat: number | null;
+  lng: number | null;
+  speed: number | null;
+  course: number | null;
+  recordedAt: string | null;
+}
+
+/** Точка трека (GET /api/gps/assets/:id/track) */
+export interface GpsTrackPoint {
+  id: number;
+  assetId: number;
+  lat: number;
+  lng: number;
+  speed: number | null;
+  course: number | null;
+  accuracy: number | null;
+  recordedAt: string;
+}
+
+export interface GpsTrackResponse {
+  success: boolean;
+  points: GpsTrackPoint[];
+  total: number;
+  sampled: boolean;
+}
+
+/** Геозона: polygon — массив пар [lat, lng] */
+export interface GpsGeozone {
+  id: number;
+  organizationId: number;
+  name: string;
+  polygon: Array<[number, number]>;
+  color: string | null;
+  notifyEnter: boolean | null;
+  notifyExit: boolean | null;
+  isActive: boolean | null;
+  createdAt: string | null;
+}
+
+/** Событие входа/выхода из геозоны */
+export interface GpsGeozoneEvent {
+  id: number;
+  geozoneId: number;
+  assetId: number;
+  event: 'enter' | 'exit';
+  lat: number | null;
+  lng: number | null;
+  createdAt: string;
+  assetName: string | null;
+  geozoneName: string | null;
+}
+
+/** Группа объектов */
+export interface GpsGroup {
+  id: number;
+  organizationId: number;
+  name: string;
+  createdAt: string | null;
+  assetIds: number[];
+}
+
+/** Подписчик объекта на события геозон/офлайна */
+export interface GpsSubscriber {
+  id?: number;
+  assetId?: number;
+  userId: number;
+  onEnter: boolean;
+  onExit: boolean;
+  onOffline: boolean;
+}
+
+export interface GpsConfig {
+  success: boolean;
+  yandexMapsKey: string | null;
+}
diff --git a/docker-compose.yml b/docker-compose.yml
index 7d19ae7..6c9cafb 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -8,6 +8,8 @@ services:
     environment:
       OLLAMA_BASE_URL: ${OLLAMA_BASE_URL:-http://ollama:11434}
       DOC_WORKER_URL: ${DOC_WORKER_URL:-http://document-worker:3000}
+      # GPS: URL Traccar API внутри Docker-сети (user/password — в .env)
+      TRACCAR_API_URL: ${TRACCAR_API_URL:-http://traccar:8082}
     volumes:
       - crm_data:/app/data
     restart: unless-stopped
@@ -135,8 +137,25 @@ services:
       retries: 3
       start_period: 30s
 
+  traccar:
+    image: traccar/traccar:latest
+    container_name: traccar
+    restart: unless-stopped
+    ports:
+      - "5055:5055"      # OsmAnd/HTTP — приём точек с трекеров/приложений
+      - "5023:5023"      # GT06
+      # Web UI Traccar наружу не публикуем — только внутренняя Docker-сеть.
+      # При необходимости доступа извне раскомментируйте:
+      # - "5082:8082"      # web UI
+    volumes:
+      - traccar_logs:/opt/traccar/logs
+      - traccar_data:/opt/traccar/data
+      - ./traccar/traccar.xml:/opt/traccar/conf/traccar.xml:ro
+
 volumes:
   crm_data:
   postgres_data:
   minio_data:
   ollama_data:
+  traccar_logs:
+  traccar_data:
diff --git a/migrations/0069_gps_tracking.sql b/migrations/0069_gps_tracking.sql
new file mode 100644
index 0000000..4eb717f
--- /dev/null
+++ b/migrations/0069_gps_tracking.sql
@@ -0,0 +1,106 @@
+-- GPS-мониторинг: объекты (транспорт/люди), треки, геозоны, события, группы, подписки.
+-- Интеграция с Traccar (forward позиций на /api/gps/ingest) и приём геолокации из PWA.
+
+-- Объекты мониторинга (машины, люди с трекерами)
+CREATE TABLE IF NOT EXISTS gps_assets (
+  id SERIAL PRIMARY KEY,
+  organization_id INTEGER NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  type TEXT NOT NULL DEFAULT 'vehicle',
+  user_id INTEGER REFERENCES users(id),
+  external_id TEXT,
+  color TEXT DEFAULT '#3b82f6',
+  is_active BOOLEAN DEFAULT TRUE,
+  is_online BOOLEAN DEFAULT FALSE,
+  last_lat DOUBLE PRECISION,
+  last_lng DOUBLE PRECISION,
+  last_speed DOUBLE PRECISION,
+  last_course DOUBLE PRECISION,
+  last_seen_at TIMESTAMP,
+  created_at TIMESTAMP DEFAULT NOW()
+);
+CREATE INDEX IF NOT EXISTS gps_assets_org_idx ON gps_assets(organization_id);
+-- IMEI/идентификатор трекера уникален в рамках организации (только для заполненных)
+CREATE UNIQUE INDEX IF NOT EXISTS gps_assets_org_external_idx
+  ON gps_assets(organization_id, external_id) WHERE external_id IS NOT NULL;
+CREATE INDEX IF NOT EXISTS gps_assets_user_idx ON gps_assets(user_id);
+
+-- История позиций (треки)
+CREATE TABLE IF NOT EXISTS gps_positions (
+  id BIGSERIAL PRIMARY KEY,
+  asset_id INTEGER NOT NULL REFERENCES gps_assets(id) ON DELETE CASCADE,
+  organization_id INTEGER NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  lat DOUBLE PRECISION NOT NULL,
+  lng DOUBLE PRECISION NOT NULL,
+  speed DOUBLE PRECISION,
+  course DOUBLE PRECISION,
+  accuracy DOUBLE PRECISION,
+  recorded_at TIMESTAMP NOT NULL,
+  created_at TIMESTAMP DEFAULT NOW()
+);
+CREATE INDEX IF NOT EXISTS gps_positions_asset_recorded_idx ON gps_positions(asset_id, recorded_at);
+CREATE INDEX IF NOT EXISTS gps_positions_org_recorded_idx ON gps_positions(organization_id, recorded_at);
+
+-- Геозоны (полигоны)
+CREATE TABLE IF NOT EXISTS gps_geozones (
+  id SERIAL PRIMARY KEY,
+  organization_id INTEGER NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  polygon JSONB NOT NULL,
+  color TEXT DEFAULT '#f59e0b',
+  notify_enter BOOLEAN DEFAULT TRUE,
+  notify_exit BOOLEAN DEFAULT TRUE,
+  is_active BOOLEAN DEFAULT TRUE,
+  created_at TIMESTAMP DEFAULT NOW()
+);
+CREATE INDEX IF NOT EXISTS gps_geozones_org_idx ON gps_geozones(organization_id);
+
+-- События входа/выхода из геозон
+CREATE TABLE IF NOT EXISTS gps_geozone_events (
+  id BIGSERIAL PRIMARY KEY,
+  organization_id INTEGER NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  geozone_id INTEGER NOT NULL REFERENCES gps_geozones(id) ON DELETE CASCADE,
+  asset_id INTEGER NOT NULL REFERENCES gps_assets(id) ON DELETE CASCADE,
+  event TEXT NOT NULL,
+  lat DOUBLE PRECISION,
+  lng DOUBLE PRECISION,
+  created_at TIMESTAMP DEFAULT NOW()
+);
+CREATE INDEX IF NOT EXISTS gps_geozone_events_asset_idx ON gps_geozone_events(asset_id, created_at);
+CREATE INDEX IF NOT EXISTS gps_geozone_events_org_idx ON gps_geozone_events(organization_id, created_at);
+
+-- Текущее состояние «объект внутри геозоны» (для детекта входа/выхода)
+CREATE TABLE IF NOT EXISTS gps_geozone_states (
+  asset_id INTEGER NOT NULL REFERENCES gps_assets(id) ON DELETE CASCADE,
+  geozone_id INTEGER NOT NULL REFERENCES gps_geozones(id) ON DELETE CASCADE,
+  inside BOOLEAN NOT NULL,
+  updated_at TIMESTAMP DEFAULT NOW(),
+  PRIMARY KEY (asset_id, geozone_id)
+);
+
+-- Группы объектов (для фильтров на карте)
+CREATE TABLE IF NOT EXISTS gps_groups (
+  id SERIAL PRIMARY KEY,
+  organization_id INTEGER NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  created_at TIMESTAMP DEFAULT NOW()
+);
+CREATE INDEX IF NOT EXISTS gps_groups_org_idx ON gps_groups(organization_id);
+
+-- Связь групп и объектов (многие-ко-многим)
+CREATE TABLE IF NOT EXISTS gps_group_assets (
+  group_id INTEGER NOT NULL REFERENCES gps_groups(id) ON DELETE CASCADE,
+  asset_id INTEGER NOT NULL REFERENCES gps_assets(id) ON DELETE CASCADE,
+  PRIMARY KEY (group_id, asset_id)
+);
+
+-- Подписчики на события объекта (уведомления о входе/выходе/офлайне)
+CREATE TABLE IF NOT EXISTS gps_asset_subscribers (
+  id SERIAL PRIMARY KEY,
+  asset_id INTEGER NOT NULL REFERENCES gps_assets(id) ON DELETE CASCADE,
+  user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  on_enter BOOLEAN DEFAULT TRUE,
+  on_exit BOOLEAN DEFAULT TRUE,
+  on_offline BOOLEAN DEFAULT FALSE,
+  UNIQUE (asset_id, user_id)
+);
diff --git a/package-lock.json b/package-lock.json
index d8e316d..6fb9e80 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -165,13 +165,14 @@
         "@types/react-dom": "^18.3.1",
         "@types/ws": "^8.5.13",
         "@vitejs/plugin-react": "^4.3.2",
+        "@yandex/ymaps3-types": "^1.0.20315584",
         "autoprefixer": "^10.4.20",
         "drizzle-kit": "^0.31.10",
         "esbuild": "^0.28.1",
         "postcss": "^8.4.47",
         "tailwindcss": "^3.4.17",
         "tsx": "^4.19.1",
-        "typescript": "5.6.3",
+        "typescript": "^5.6.3",
         "vite": "^5.4.19"
       },
       "optionalDependencies": {
@@ -6948,6 +6949,29 @@
         "node": ">=10.0.0"
       }
     },
+    "node_modules/@yandex/ymaps3-types": {
+      "version": "1.0.20315584",
+      "resolved": "https://registry.npmjs.org/@yandex/ymaps3-types/-/ymaps3-types-1.0.20315584.tgz",
+      "integrity": "sha512-fJ6K8uat1RYt9ASE1wMlcg2IpPQDHdQBDtcRKHvLrWHhQRTRnFGbvYY8XVo5rTYRN9Mr94X7f2BZOMtrxN16ag==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "@types/react": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "@types/react-dom": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "@vue/runtime-core": "3"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        },
+        "@vue/runtime-core": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/abbrev": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-2.0.0.tgz",
diff --git a/package.json b/package.json
index c8f9bfc..a364904 100644
--- a/package.json
+++ b/package.json
@@ -169,6 +169,7 @@
     "@types/react-dom": "^18.3.1",
     "@types/ws": "^8.5.13",
     "@vitejs/plugin-react": "^4.3.2",
+    "@yandex/ymaps3-types": "^1.0.20315584",
     "autoprefixer": "^10.4.20",
     "drizzle-kit": "^0.31.10",
     "esbuild": "^0.28.1",
diff --git a/server/gps/geozone.service.ts b/server/gps/geozone.service.ts
new file mode 100644
index 0000000..24cfed1
--- /dev/null
+++ b/server/gps/geozone.service.ts
@@ -0,0 +1,232 @@
+import { gpsStorage } from "./storage";
+import { storage } from "../storage";
+import { webPushService } from "../services/web-push.service";
+import { eventBus, publishNotificationSSE } from "../routes/shared";
+import type { GpsAsset, GpsGeozone } from "@shared/schema";
+
+/**
+ * Сервис обработки GPS-позиций и геозон.
+ * Детект входа/выхода — сравнение point-in-polygon с сохранённым состоянием
+ * gps_geozone_states; при смене состояния создаётся событие и рассылаются
+ * уведомления подписчикам объекта.
+ */
+
+/**
+ * Ray casting: находится ли точка внутри полигона.
+ * polygon — массив пар [lat, lng]. Без внешних зависимостей.
+ */
+export function pointInPolygon(lat: number, lng: number, polygon: Array<[number, number]>): boolean {
+  if (!Array.isArray(polygon) || polygon.length < 3) return false;
+
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const [latI, lngI] = polygon[i];
+    const [latJ, lngJ] = polygon[j];
+
+    const intersects =
+      lngI > lng !== lngJ > lng &&
+      lat < ((latJ - latI) * (lng - lngI)) / (lngJ - lngI) + latI;
+    if (intersects) inside = !inside;
+  }
+  return inside;
+}
+
+export interface ProcessPositionInput {
+  lat: number;
+  lng: number;
+  speed?: number | null;
+  course?: number | null;
+  accuracy?: number | null;
+  recordedAt?: Date;
+}
+
+/**
+ * Основная точка входа: сохраняет позицию, обновляет last_* объекта,
+ * проверяет геозоны и рассылает SSE/уведомления.
+ */
+export async function processPosition(
+  assetId: number,
+  organizationId: number,
+  input: ProcessPositionInput
+): Promise<void> {
+  const recordedAt = input.recordedAt ?? new Date();
+
+  // 1. Сохраняем точку в историю
+  await gpsStorage.insertPosition({
+    assetId,
+    organizationId,
+    lat: input.lat,
+    lng: input.lng,
+    speed: input.speed ?? null,
+    course: input.course ?? null,
+    accuracy: input.accuracy ?? null,
+    recordedAt,
+  });
+
+  // 2. Обновляем последнюю позицию объекта (и переводим в online)
+  await gpsStorage.updateAssetLastPosition(assetId, {
+    lat: input.lat,
+    lng: input.lng,
+    speed: input.speed,
+    course: input.course,
+    recordedAt,
+  });
+
+  // 3. SSE-событие о перемещении — broadcast по организации,
+  //    чтобы карта у всех открытых клиентов обновилась в реальном времени
+  eventBus.publishEvent({
+    type: "gps_asset_moved",
+    data: {
+      assetId,
+      lat: input.lat,
+      lng: input.lng,
+      speed: input.speed ?? null,
+      course: input.course ?? null,
+      recordedAt: recordedAt.toISOString(),
+    },
+    organizationId,
+  });
+
+  // 4. Проверка геозон
+  await checkGeozones(assetId, organizationId, input, recordedAt);
+}
+
+async function checkGeozones(
+  assetId: number,
+  organizationId: number,
+  input: ProcessPositionInput,
+  recordedAt: Date
+): Promise<void> {
+  const geozones = await gpsStorage.listActiveGeozones(organizationId);
+  if (geozones.length === 0) return;
+
+  const states = await gpsStorage.getGeozoneStatesForAsset(assetId);
+  const asset = await gpsStorage.getAsset(assetId, organizationId);
+  if (!asset) return;
+
+  for (const geozone of geozones) {
+    try {
+      const nowInside = pointInPolygon(input.lat, input.lng, geozone.polygon);
+      const wasInside = states.get(geozone.id) ?? false;
+
+      if (nowInside === wasInside) continue;
+
+      // Состояние изменилось — фиксируем и создаём событие
+      await gpsStorage.upsertGeozoneState(assetId, geozone.id, nowInside);
+      const eventType = nowInside ? ("enter" as const) : ("exit" as const);
+      await gpsStorage.insertGeozoneEvent({
+        organizationId,
+        geozoneId: geozone.id,
+        assetId,
+        event: eventType,
+        lat: input.lat,
+        lng: input.lng,
+      });
+
+      const notifyEnabled = nowInside ? geozone.notifyEnter : geozone.notifyExit;
+      if (notifyEnabled) {
+        await notifySubscribers(asset, geozone, eventType, input.lat, input.lng, recordedAt);
+      }
+    } catch (err) {
+      console.error(`[GPS] Geozone check failed (asset ${assetId}, geozone ${geozone.id}):`, err);
+    }
+  }
+}
+
+/**
+ * Рассылка уведомлений подписчикам объекта о событии геозоны.
+ * In-app (user_notifications) + Web Push + SSE для мгновенного обновления бейджа.
+ */
+async function notifySubscribers(
+  asset: GpsAsset,
+  geozone: GpsGeozone,
+  eventType: "enter" | "exit",
+  lat: number,
+  lng: number,
+  recordedAt: Date
+): Promise<void> {
+  const subscribers = await gpsStorage.listSubscribers(asset.id);
+  const eventText = eventType === "enter" ? "вошёл в зону" : "вышел из зоны";
+  const title = `GPS: ${asset.name}`;
+  const message = `${asset.name} ${eventText} «${geozone.name}»`;
+
+  for (const sub of subscribers) {
+    const enabled = eventType === "enter" ? sub.onEnter : sub.onExit;
+    if (!enabled) continue;
+
+    try {
+      const notification = await storage.createUserNotification({
+        userId: sub.userId,
+        organizationId: asset.organizationId,
+        type: "gps.geozone",
+        title,
+        message,
+        isRead: false,
+      });
+
+      publishNotificationSSE(sub.userId, asset.organizationId, {
+        type: "gps.geozone",
+        notificationId: notification.id,
+      });
+
+      await webPushService.sendToUser(sub.userId, asset.organizationId, {
+        title,
+        body: message,
+        icon: "/icon-192.png",
+        url: "/gps",
+        tag: `gps-geozone-${asset.id}-${geozone.id}`,
+        data: {
+          type: "gps",
+          event: eventType,
+          assetId: asset.id.toString(),
+          geozoneId: geozone.id.toString(),
+          lat: lat.toString(),
+          lng: lng.toString(),
+          recordedAt: recordedAt.toISOString(),
+        },
+      });
+    } catch (err) {
+      console.error(`[GPS] Notify subscriber ${sub.userId} failed:`, err);
+    }
+  }
+}
+
+/**
+ * Уведомление подписчиков о переходе объекта в офлайн (вызывается воркером).
+ */
+export async function notifyOffline(asset: GpsAsset): Promise<void> {
+  const subscribers = await gpsStorage.listSubscribers(asset.id);
+  const title = `GPS: ${asset.name}`;
+  const message = `${asset.name} не выходит на связь более 15 минут`;
+
+  for (const sub of subscribers) {
+    if (!sub.onOffline) continue;
+
+    try {
+      const notification = await storage.createUserNotification({
+        userId: sub.userId,
+        organizationId: asset.organizationId,
+        type: "gps.offline",
+        title,
+        message,
+        isRead: false,
+      });
+
+      publishNotificationSSE(sub.userId, asset.organizationId, {
+        type: "gps.offline",
+        notificationId: notification.id,
+      });
+
+      await webPushService.sendToUser(sub.userId, asset.organizationId, {
+        title,
+        body: message,
+        icon: "/icon-192.png",
+        url: "/gps",
+        tag: `gps-offline-${asset.id}`,
+        data: { type: "gps", event: "offline", assetId: asset.id.toString() },
+      });
+    } catch (err) {
+      console.error(`[GPS] Notify offline subscriber ${sub.userId} failed:`, err);
+    }
+  }
+}
diff --git a/server/gps/routes.ts b/server/gps/routes.ts
new file mode 100644
index 0000000..7340295
--- /dev/null
+++ b/server/gps/routes.ts
@@ -0,0 +1,545 @@
+import { Router } from "express";
+import type { Express, Response } from "express";
+import { authenticateToken, type AuthenticatedRequest } from "../middleware/auth.middleware";
+import { gpsStorage } from "./storage";
+import { processPosition } from "./geozone.service";
+import { ensureDevice, deleteDevice } from "./traccar.client";
+import { storage } from "../storage";
+
+/**
+ * Роуты GPS-модуля.
+ * Публичный POST /api/gps/ingest (приём точек от Traccar, секрет в заголовке)
+ * регистрируется отдельно, ДО роутера с authenticateToken.
+ */
+
+const MAX_TRACK_POINTS = 2000;
+
+function parseDateParam(value: unknown): Date | null {
+  if (typeof value !== "string" || !value) return null;
+  const d = new Date(value);
+  return isNaN(d.getTime()) ? null : d;
+}
+
+function parseNum(value: unknown): number | null {
+  if (value === undefined || value === null || value === "") return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function badRequest(res: Response, error: string) {
+  return res.status(400).json({ success: false, error });
+}
+
+// =====================
+// Приём позиций от Traccar (публичный, по секрету)
+// =====================
+
+interface NormalizedPoint {
+  externalId: string;
+  lat: number;
+  lng: number;
+  speed: number | null;
+  course: number | null;
+  accuracy: number | null;
+  recordedAt: Date | null;
+}
+
+/**
+ * Нормализация одной точки. Поддерживает два формата:
+ * 1. Простой: { externalId, lat, lng, speed?, course?, accuracy?, timestamp? }
+ * 2. Нативный forward Traccar: { position: {...}, device: { uniqueId } }
+ */
+function normalizePoint(raw: any): NormalizedPoint | null {
+  if (!raw || typeof raw !== "object") return null;
+
+  // Нативный формат Traccar event forwarding
+  if (raw.position && raw.device?.uniqueId) {
+    const p = raw.position;
+    const lat = parseNum(p.latitude);
+    const lng = parseNum(p.longitude);
+    if (lat === null || lng === null) return null;
+    return {
+      externalId: String(raw.device.uniqueId),
+      lat,
+      lng,
+      speed: parseNum(p.speed),
+      course: parseNum(p.course),
+      accuracy: parseNum(p.accuracy),
+      recordedAt: parseDateParam(p.fixTime ?? p.deviceTime),
+    };
+  }
+
+  // Простой формат
+  const lat = parseNum(raw.lat);
+  const lng = parseNum(raw.lng);
+  if (lat === null || lng === null || !raw.externalId) return null;
+  return {
+    externalId: String(raw.externalId),
+    lat,
+    lng,
+    speed: parseNum(raw.speed),
+    course: parseNum(raw.course),
+    accuracy: parseNum(raw.accuracy),
+    recordedAt: parseDateParam(raw.timestamp),
+  };
+}
+
+async function handleIngest(req: AuthenticatedRequest, res: Response) {
+  // Endpoint отключён, если секрет не задан в env
+  const expectedToken = process.env.GPS_INGEST_TOKEN;
+  if (!expectedToken) {
+    return res.status(503).json({ success: false, error: "GPS ingest отключён: не задан GPS_INGEST_TOKEN" });
+  }
+
+  const token = req.headers["x-gps-token"];
+  if (token !== expectedToken) {
+    return res.status(401).json({ success: false, error: "Неверный токен" });
+  }
+
+  const items = Array.isArray(req.body) ? req.body : [req.body];
+  let processed = 0;
+  let ignored = 0;
+
+  for (const item of items) {
+    const point = normalizePoint(item);
+    if (!point) {
+      ignored++;
+      continue;
+    }
+
+    // Объект ищется по external_id в любой организации;
+    // невалидный external_id не раскрываем — просто считаем проигнорированным
+    const asset = await gpsStorage.getAssetByExternalId(point.externalId);
+    if (!asset || !asset.isActive) {
+      ignored++;
+      continue;
+    }
+
+    try {
+      await processPosition(asset.id, asset.organizationId, {
+        lat: point.lat,
+        lng: point.lng,
+        speed: point.speed,
+        course: point.course,
+        accuracy: point.accuracy,
+        recordedAt: point.recordedAt ?? undefined,
+      });
+      processed++;
+    } catch (err) {
+      console.error(`[GPS] Ingest error (asset ${asset.id}):`, err);
+      ignored++;
+    }
+  }
+
+  res.json({ success: true, processed, ...(ignored > 0 ? { ignored } : {}) });
+}
+
+// =====================
+// Авторизованные роуты
+// =====================
+
+export function registerGpsRoutes(app: Express) {
+  // Публичный приём точек — без authenticateToken, защита секретом в заголовке
+  app.post("/api/gps/ingest", (req, res) => {
+    handleIngest(req as AuthenticatedRequest, res).catch((err) => {
+      console.error("[GPS] Ingest handler error:", err);
+      res.status(500).json({ success: false, error: "Внутренняя ошибка" });
+    });
+  });
+
+  const router = Router();
+  router.use(authenticateToken);
+
+  // =====================
+  // Конфигурация клиента (ключ Яндекс.Карт из external_services)
+  // =====================
+
+  router.get("/config", async (req: AuthenticatedRequest, res: Response) => {
+    const orgId = req.user!.organizationId;
+    let yandexMapsKey: string | null = null;
+
+    const service = await storage.getExternalServiceByType("yandex_maps", orgId);
+    if (service?.isActive && service.apiKey) {
+      const { decrypt } = await import("../crypto");
+      yandexMapsKey = decrypt(service.apiKey);
+    }
+
+    res.json({ success: true, yandexMapsKey });
+  });
+
+  // =====================
+  // Объекты (assets)
+  // =====================
+
+  router.get("/assets", async (req: AuthenticatedRequest, res: Response) => {
+    const assets = await gpsStorage.listAssets(req.user!.organizationId);
+    res.json({ success: true, assets });
+  });
+
+  router.post("/assets", async (req: AuthenticatedRequest, res: Response) => {
+    const orgId = req.user!.organizationId;
+    const { name, type, externalId, color, userId } = req.body ?? {};
+
+    if (!name || typeof name !== "string") {
+      return badRequest(res, "Название объекта обязательно");
+    }
+    if (type !== undefined && !["vehicle", "person"].includes(type)) {
+      return badRequest(res, "Тип объекта: vehicle или person");
+    }
+
+    const asset = await gpsStorage.createAsset({
+      organizationId: orgId,
+      name: name.trim(),
+      type: type === "person" ? "person" : "vehicle",
+      externalId: externalId ? String(externalId).trim() : null,
+      color: color || undefined,
+      userId: userId ?? null,
+    });
+
+    // Регистрируем устройство в Traccar (no-op, если Traccar не настроен)
+    if (asset.externalId) {
+      await ensureDevice(asset.externalId, asset.name);
+    }
+
+    res.status(201).json({ success: true, asset });
+  });
+
+  router.patch("/assets/:id", async (req: AuthenticatedRequest, res: Response) => {
+    const orgId = req.user!.organizationId;
+    const id = Number(req.params.id);
+    const { name, type, externalId, color, isActive, userId } = req.body ?? {};
+
+    const updates: Record<string, unknown> = {};
+    if (name !== undefined) updates.name = String(name).trim();
+    if (type !== undefined) {
+      if (!["vehicle", "person"].includes(type)) {
+        return badRequest(res, "Тип объекта: vehicle или person");
+      }
+      updates.type = type;
+    }
+    if (externalId !== undefined) updates.externalId = externalId ? String(externalId).trim() : null;
+    if (color !== undefined) updates.color = color;
+    if (isActive !== undefined) updates.isActive = Boolean(isActive);
+    if (userId !== undefined) updates.userId = userId ?? null;
+
+    const asset = await gpsStorage.updateAsset(id, orgId, updates);
+    if (!asset) return res.status(404).json({ success: false, error: "Объект не найден" });
+
+    // Если появился/сменился external_id — регистрируем устройство в Traccar
+    if (updates.externalId && asset.externalId) {
+      await ensureDevice(asset.externalId, asset.name);
+    }
+
+    res.json({ success: true, asset });
+  });
+
+  router.delete("/assets/:id", async (req: AuthenticatedRequest, res: Response) => {
+    const orgId = req.user!.organizationId;
+    const id = Number(req.params.id);
+
+    const asset = await gpsStorage.getAsset(id, orgId);
+    if (!asset) return res.status(404).json({ success: false, error: "Объект не найден" });
+
+    if (asset.externalId) {
+      await deleteDevice(asset.externalId);
+    }
+
+    await gpsStorage.deleteAsset(id, orgId);
+    res.json({ success: true });
+  });
+
+  // =====================
+  // Позиции и треки
+  // =====================
+
+  // Текущие last_* всех активных объектов организации
+  router.get("/assets/positions", async (req: AuthenticatedRequest, res: Response) => {
+    const assets = await gpsStorage.listCurrentPositions(req.user!.organizationId);
+    res.json({
+      success: true,
+      positions: assets.map((a) => ({
+        assetId: a.id,
+        name: a.name,
+        type: a.type,
+        color: a.color,
+        isOnline: a.isOnline,
+        lat: a.lastLat,
+        lng: a.lastLng,
+        speed: a.lastSpeed,
+        course: a.lastCourse,
+        recordedAt: a.lastSeenAt,
+      })),
+    });
+  });
+
+  // Трек объекта за период (точки ASC; при > 2000 — прореживание)
+  router.get("/assets/:id/track", async (req: AuthenticatedRequest, res: Response) => {
+    const orgId = req.user!.organizationId;
+    const id = Number(req.params.id);
+
+    const asset = await gpsStorage.getAsset(id, orgId);
+    if (!asset) return res.status(404).json({ success: false, error: "Объект не найден" });
+
+    const from = parseDateParam(req.query.from);
+    const to = parseDateParam(req.query.to);
+
+    const all = await gpsStorage.getTrack(id, orgId, from ?? undefined, to ?? undefined);
+    const total = all.length;
+
+    let points = all;
+    let sampled = false;
+    if (total > MAX_TRACK_POINTS) {
+      const step = Math.ceil(total / MAX_TRACK_POINTS);
+      points = all.filter((_, idx) => idx % step === 0);
+      // Всегда включаем последнюю точку трека
+      if (points[points.length - 1] !== all[total - 1]) {
+        points.push(all[total - 1]);
+      }
+      sampled = true;
+    }
+
+    res.json({ success: true, points, total, sampled });
+  });
+
+  // =====================
+  // Геозоны
+  // =====================
+
+  router.get("/geozones", async (req: AuthenticatedRequest, res: Response) => {
+    const geozones = await gpsStorage.listGeozones(req.user!.organizationId);
+    res.json({ success: true, geozones });
+  });
+
+  router.post("/geozones", async (req: AuthenticatedRequest, res: Response) => {
+    const orgId = req.user!.organizationId;
+    const { name, polygon, color, notifyEnter, notifyExit } = req.body ?? {};
+
+    if (!name || typeof name !== "string") {
+      return badRequest(res, "Название геозоны обязательно");
+    }
+    if (!isValidPolygon(polygon)) {
+      return badRequest(res, "Полигон: массив минимум из 3 пар [lat, lng]");
+    }
+
+    const geozone = await gpsStorage.createGeozone({
+      organizationId: orgId,
+      name: name.trim(),
+      polygon,
+      color: color || undefined,
+      notifyEnter: notifyEnter ?? undefined,
+      notifyExit: notifyExit ?? undefined,
+    });
+
+    res.status(201).json({ success: true, geozone });
+  });
+
+  router.patch("/geozones/:id", async (req: AuthenticatedRequest, res: Response) => {
+    const orgId = req.user!.organizationId;
+    const id = Number(req.params.id);
+    const { name, polygon, color, notifyEnter, notifyExit, isActive } = req.body ?? {};
+
+    const updates: Record<string, unknown> = {};
+    if (name !== undefined) updates.name = String(name).trim();
+    if (polygon !== undefined) {
+      if (!isValidPolygon(polygon)) {
+        return badRequest(res, "Полигон: массив минимум из 3 пар [lat, lng]");
+      }
+      updates.polygon = polygon;
+    }
+    if (color !== undefined) updates.color = color;
+    if (notifyEnter !== undefined) updates.notifyEnter = Boolean(notifyEnter);
+    if (notifyExit !== undefined) updates.notifyExit = Boolean(notifyExit);
+    if (isActive !== undefined) updates.isActive = Boolean(isActive);
+
+    const geozone = await gpsStorage.updateGeozone(id, orgId, updates);
+    if (!geozone) return res.status(404).json({ success: false, error: "Геозона не найдена" });
+
+    res.json({ success: true, geozone });
+  });
+
+  router.delete("/geozones/:id", async (req: AuthenticatedRequest, res: Response) => {
+    const deleted = await gpsStorage.deleteGeozone(Number(req.params.id), req.user!.organizationId);
+    if (!deleted) return res.status(404).json({ success: false, error: "Геозона не найдена" });
+    res.json({ success: true });
+  });
+
+  // События входа/выхода из геозон
+  router.get("/geozone-events", async (req: AuthenticatedRequest, res: Response) => {
+    const orgId = req.user!.organizationId;
+    const events = await gpsStorage.listGeozoneEvents(orgId, {
+      assetId: req.query.assetId ? Number(req.query.assetId) : undefined,
+      geozoneId: req.query.geozoneId ? Number(req.query.geozoneId) : undefined,
+      from: parseDateParam(req.query.from) ?? undefined,
+      to: parseDateParam(req.query.to) ?? undefined,
+      limit: req.query.limit ? Math.min(Number(req.query.limit), 1000) : undefined,
+    });
+    res.json({ success: true, events });
+  });
+
+  // =====================
+  // Группы
+  // =====================
+
+  router.get("/groups", async (req: AuthenticatedRequest, res: Response) => {
+    const groups = await gpsStorage.listGroups(req.user!.organizationId);
+    res.json({ success: true, groups });
+  });
+
+  router.post("/groups", async (req: AuthenticatedRequest, res: Response) => {
+    const orgId = req.user!.organizationId;
+    const { name, assetIds } = req.body ?? {};
+
+    if (!name || typeof name !== "string") {
+      return badRequest(res, "Название группы обязательно");
+    }
+
+    const group = await gpsStorage.createGroup(
+      orgId,
+      name.trim(),
+      Array.isArray(assetIds) ? assetIds.map(Number).filter(Number.isFinite) : []
+    );
+    res.status(201).json({ success: true, group });
+  });
+
+  router.patch("/groups/:id", async (req: AuthenticatedRequest, res: Response) => {
+    const orgId = req.user!.organizationId;
+    const id = Number(req.params.id);
+    const { name, assetIds } = req.body ?? {};
+
+    const group = await gpsStorage.updateGroup(id, orgId, {
+      name: name !== undefined ? String(name).trim() : undefined,
+      assetIds: Array.isArray(assetIds) ? assetIds.map(Number).filter(Number.isFinite) : undefined,
+    });
+    if (!group) return res.status(404).json({ success: false, error: "Группа не найдена" });
+
+    res.json({ success: true, group });
+  });
+
+  router.delete("/groups/:id", async (req: AuthenticatedRequest, res: Response) => {
+    const deleted = await gpsStorage.deleteGroup(Number(req.params.id), req.user!.organizationId);
+    if (!deleted) return res.status(404).json({ success: false, error: "Группа не найдена" });
+    res.json({ success: true });
+  });
+
+  // =====================
+  // Подписчики объекта
+  // =====================
+
+  router.get("/assets/:id/subscribers", async (req: AuthenticatedRequest, res: Response) => {
+    const orgId = req.user!.organizationId;
+    const id = Number(req.params.id);
+
+    const asset = await gpsStorage.getAsset(id, orgId);
+    if (!asset) return res.status(404).json({ success: false, error: "Объект не найден" });
+
+    const subscribers = await gpsStorage.listSubscribers(id);
+    res.json({ success: true, subscribers });
+  });
+
+  // Полная замена списка подписчиков: [{ userId, onEnter, onExit, onOffline }]
+  router.put("/assets/:id/subscribers", async (req: AuthenticatedRequest, res: Response) => {
+    const orgId = req.user!.organizationId;
+    const id = Number(req.params.id);
+
+    const asset = await gpsStorage.getAsset(id, orgId);
+    if (!asset) return res.status(404).json({ success: false, error: "Объект не найден" });
+
+    const list = Array.isArray(req.body) ? req.body : req.body?.subscribers;
+    if (!Array.isArray(list)) {
+      return badRequest(res, "Ожидается массив подписчиков [{ userId, onEnter, onExit, onOffline }]");
+    }
+
+    const subscribers = list.map((s: any) => ({
+      userId: Number(s.userId),
+      onEnter: Boolean(s.onEnter ?? true),
+      onExit: Boolean(s.onExit ?? true),
+      onOffline: Boolean(s.onOffline ?? false),
+    })).filter((s: { userId: number }) => Number.isFinite(s.userId));
+
+    const result = await gpsStorage.replaceSubscribers(id, subscribers);
+    res.json({ success: true, subscribers: result });
+  });
+
+  // =====================
+  // PWA-трекинг (личная геолокация пользователя)
+  // =====================
+
+  router.post("/my-position", async (req: AuthenticatedRequest, res: Response) => {
+    const user = req.user!;
+    const orgId = user.organizationId;
+    const { lat, lng, speed, course, accuracy } = req.body ?? {};
+
+    const latN = parseNum(lat);
+    const lngN = parseNum(lng);
+    if (latN === null || lngN === null) {
+      return badRequest(res, "Обязательные поля: lat, lng");
+    }
+
+    // Находим или создаём персональный объект пользователя
+    let asset = await gpsStorage.getPersonAssetByUser(user.id, orgId);
+    if (!asset) {
+      asset = await gpsStorage.createAsset({
+        organizationId: orgId,
+        name: `${user.firstName} ${user.lastName}`.trim() || user.email,
+        type: "person",
+        userId: user.id,
+      });
+    }
+    if (!asset.isActive) {
+      return res.status(403).json({ success: false, error: "Отслеживание геолокации выключено" });
+    }
+
+    await processPosition(asset.id, orgId, {
+      lat: latN,
+      lng: lngN,
+      speed: parseNum(speed),
+      course: parseNum(course),
+      accuracy: parseNum(accuracy),
+    });
+
+    res.json({ success: true, assetId: asset.id });
+  });
+
+  router.get("/my-tracking", async (req: AuthenticatedRequest, res: Response) => {
+    const user = req.user!;
+    const asset = await gpsStorage.getPersonAssetByUser(user.id, user.organizationId);
+    res.json({ success: true, enabled: Boolean(asset?.isActive), assetId: asset?.id ?? null });
+  });
+
+  router.put("/my-tracking", async (req: AuthenticatedRequest, res: Response) => {
+    const user = req.user!;
+    const orgId = user.organizationId;
+    const enabled = Boolean(req.body?.enabled);
+
+    let asset = await gpsStorage.getPersonAssetByUser(user.id, orgId);
+    if (!asset) {
+      if (!enabled) {
+        // Выключать нечего — объекта ещё нет
+        return res.json({ success: true, enabled: false, assetId: null });
+      }
+      asset = await gpsStorage.createAsset({
+        organizationId: orgId,
+        name: `${user.firstName} ${user.lastName}`.trim() || user.email,
+        type: "person",
+        userId: user.id,
+        isActive: true,
+      });
+    } else if (asset.isActive !== enabled) {
+      asset = (await gpsStorage.updateAsset(asset.id, orgId, { isActive: enabled }))!;
+    }
+
+    res.json({ success: true, enabled, assetId: asset.id });
+  });
+
+  app.use("/api/gps", router);
+}
+
+function isValidPolygon(polygon: unknown): polygon is Array<[number, number]> {
+  return (
+    Array.isArray(polygon) &&
+    polygon.length >= 3 &&
+    polygon.every(
+      (p) => Array.isArray(p) && p.length === 2 && Number.isFinite(Number(p[0])) && Number.isFinite(Number(p[1]))
+    )
+  );
+}
diff --git a/server/gps/storage.ts b/server/gps/storage.ts
new file mode 100644
index 0000000..c1b214a
--- /dev/null
+++ b/server/gps/storage.ts
@@ -0,0 +1,443 @@
+import { db } from "../db";
+import {
+  gpsAssets,
+  gpsPositions,
+  gpsGeozones,
+  gpsGeozoneEvents,
+  gpsGeozoneStates,
+  gpsGroups,
+  gpsGroupAssets,
+  gpsAssetSubscribers,
+  type GpsAsset,
+  type GpsPosition,
+  type GpsGeozone,
+  type GpsGeozoneEvent,
+  type GpsGroup,
+  type GpsAssetSubscriber,
+  type InsertGpsAsset,
+  type InsertGpsGeozone,
+  type InsertGpsPosition,
+} from "@shared/schema";
+import { eq, and, asc, desc, gte, lte, lt, inArray, sql, isNotNull } from "drizzle-orm";
+
+/**
+ * Хранилище GPS-модуля. Все публичные методы, работающие с данными
+ * конкретной организации, обязательно фильтруют по organizationId.
+ * Исключения (помечены отдельно): поиск по external_id для ingest
+ * и выборка «протухших» объектов для воркера — они обходят все организации.
+ */
+export class GpsStorage {
+  // =====================
+  // Объекты (assets)
+  // =====================
+
+  async listAssets(organizationId: number) {
+    const assets = await db
+      .select()
+      .from(gpsAssets)
+      .where(eq(gpsAssets.organizationId, organizationId))
+      .orderBy(asc(gpsAssets.name));
+
+    if (assets.length === 0) return [];
+
+    const assetIds = assets.map((a) => a.id);
+
+    // Группы каждого объекта
+    const groupLinks = await db
+      .select({
+        assetId: gpsGroupAssets.assetId,
+        groupId: gpsGroups.id,
+        groupName: gpsGroups.name,
+      })
+      .from(gpsGroupAssets)
+      .innerJoin(gpsGroups, eq(gpsGroupAssets.groupId, gpsGroups.id))
+      .where(
+        and(
+          inArray(gpsGroupAssets.assetId, assetIds),
+          eq(gpsGroups.organizationId, organizationId)
+        )
+      );
+
+    // Число подписчиков каждого объекта
+    const subscriberCounts = await db
+      .select({
+        assetId: gpsAssetSubscribers.assetId,
+        count: sql<number>`count(*)::int`,
+      })
+      .from(gpsAssetSubscribers)
+      .where(inArray(gpsAssetSubscribers.assetId, assetIds))
+      .groupBy(gpsAssetSubscribers.assetId);
+
+    const groupsByAsset = new Map<number, Array<{ id: number; name: string }>>();
+    for (const link of groupLinks) {
+      const list = groupsByAsset.get(link.assetId) ?? [];
+      list.push({ id: link.groupId, name: link.groupName });
+      groupsByAsset.set(link.assetId, list);
+    }
+    const countByAsset = new Map(subscriberCounts.map((r) => [r.assetId, r.count]));
+
+    return assets.map((asset) => ({
+      ...asset,
+      groups: groupsByAsset.get(asset.id) ?? [],
+      subscriberCount: countByAsset.get(asset.id) ?? 0,
+    }));
+  }
+
+  async getAsset(id: number, organizationId: number): Promise<GpsAsset | undefined> {
+    const [asset] = await db
+      .select()
+      .from(gpsAssets)
+      .where(and(eq(gpsAssets.id, id), eq(gpsAssets.organizationId, organizationId)));
+    return asset;
+  }
+
+  /**
+   * Поиск объекта по external_id без фильтра организации.
+   * Используется только публичным ingest-endpoint'ом (Traccar).
+   */
+  async getAssetByExternalId(externalId: string): Promise<GpsAsset | undefined> {
+    const [asset] = await db
+      .select()
+      .from(gpsAssets)
+      .where(eq(gpsAssets.externalId, externalId));
+    return asset;
+  }
+
+  /** Персональный объект (type='person') пользователя в организации */
+  async getPersonAssetByUser(userId: number, organizationId: number): Promise<GpsAsset | undefined> {
+    const [asset] = await db
+      .select()
+      .from(gpsAssets)
+      .where(
+        and(
+          eq(gpsAssets.userId, userId),
+          eq(gpsAssets.organizationId, organizationId),
+          eq(gpsAssets.type, "person")
+        )
+      );
+    return asset;
+  }
+
+  async createAsset(data: InsertGpsAsset): Promise<GpsAsset> {
+    const [asset] = await db.insert(gpsAssets).values(data).returning();
+    return asset;
+  }
+
+  async updateAsset(id: number, organizationId: number, updates: Partial<InsertGpsAsset>): Promise<GpsAsset | undefined> {
+    const [asset] = await db
+      .update(gpsAssets)
+      .set(updates)
+      .where(and(eq(gpsAssets.id, id), eq(gpsAssets.organizationId, organizationId)))
+      .returning();
+    return asset;
+  }
+
+  async deleteAsset(id: number, organizationId: number): Promise<boolean> {
+    const deleted = await db
+      .delete(gpsAssets)
+      .where(and(eq(gpsAssets.id, id), eq(gpsAssets.organizationId, organizationId)))
+      .returning({ id: gpsAssets.id });
+    return deleted.length > 0;
+  }
+
+  /** Обновление последней позиции объекта (и перевод в online) */
+  async updateAssetLastPosition(
+    assetId: number,
+    data: { lat: number; lng: number; speed?: number | null; course?: number | null; recordedAt: Date }
+  ): Promise<void> {
+    await db
+      .update(gpsAssets)
+      .set({
+        lastLat: data.lat,
+        lastLng: data.lng,
+        lastSpeed: data.speed ?? null,
+        lastCourse: data.course ?? null,
+        lastSeenAt: data.recordedAt,
+        isOnline: true,
+      })
+      .where(eq(gpsAssets.id, assetId));
+  }
+
+  async setAssetOnline(assetId: number, isOnline: boolean): Promise<void> {
+    await db.update(gpsAssets).set({ isOnline }).where(eq(gpsAssets.id, assetId));
+  }
+
+  /** Текущие позиции всех активных объектов организации */
+  async listCurrentPositions(organizationId: number): Promise<GpsAsset[]> {
+    return db
+      .select()
+      .from(gpsAssets)
+      .where(
+        and(
+          eq(gpsAssets.organizationId, organizationId),
+          eq(gpsAssets.isActive, true),
+          isNotNull(gpsAssets.lastLat)
+        )
+      );
+  }
+
+  /**
+   * Онлайн-объекты, от которых давно не было точек (для воркера офлайн-детекта).
+   * Обходит все организации — вызывается под withSuperAdmin.
+   */
+  async getStaleOnlineAssets(cutoff: Date): Promise<GpsAsset[]> {
+    return db
+      .select()
+      .from(gpsAssets)
+      .where(
+        and(
+          eq(gpsAssets.isActive, true),
+          eq(gpsAssets.isOnline, true),
+          isNotNull(gpsAssets.lastSeenAt),
+          lt(gpsAssets.lastSeenAt, cutoff)
+        )
+      );
+  }
+
+  // =====================
+  // Позиции (треки)
+  // =====================
+
+  async insertPosition(data: InsertGpsPosition): Promise<GpsPosition> {
+    const [position] = await db.insert(gpsPositions).values(data).returning();
+    return position;
+  }
+
+  async getTrack(assetId: number, organizationId: number, from?: Date, to?: Date): Promise<GpsPosition[]> {
+    const conditions = [
+      eq(gpsPositions.assetId, assetId),
+      eq(gpsPositions.organizationId, organizationId),
+    ];
+    if (from) conditions.push(gte(gpsPositions.recordedAt, from));
+    if (to) conditions.push(lte(gpsPositions.recordedAt, to));
+
+    return db
+      .select()
+      .from(gpsPositions)
+      .where(and(...conditions))
+      .orderBy(asc(gpsPositions.recordedAt));
+  }
+
+  // =====================
+  // Геозоны
+  // =====================
+
+  async listGeozones(organizationId: number): Promise<GpsGeozone[]> {
+    return db
+      .select()
+      .from(gpsGeozones)
+      .where(eq(gpsGeozones.organizationId, organizationId))
+      .orderBy(asc(gpsGeozones.name));
+  }
+
+  async listActiveGeozones(organizationId: number): Promise<GpsGeozone[]> {
+    return db
+      .select()
+      .from(gpsGeozones)
+      .where(and(eq(gpsGeozones.organizationId, organizationId), eq(gpsGeozones.isActive, true)));
+  }
+
+  async getGeozone(id: number, organizationId: number): Promise<GpsGeozone | undefined> {
+    const [geozone] = await db
+      .select()
+      .from(gpsGeozones)
+      .where(and(eq(gpsGeozones.id, id), eq(gpsGeozones.organizationId, organizationId)));
+    return geozone;
+  }
+
+  async createGeozone(data: InsertGpsGeozone): Promise<GpsGeozone> {
+    const [geozone] = await db.insert(gpsGeozones).values(data).returning();
+    return geozone;
+  }
+
+  async updateGeozone(id: number, organizationId: number, updates: Partial<InsertGpsGeozone>): Promise<GpsGeozone | undefined> {
+    const [geozone] = await db
+      .update(gpsGeozones)
+      .set(updates)
+      .where(and(eq(gpsGeozones.id, id), eq(gpsGeozones.organizationId, organizationId)))
+      .returning();
+    return geozone;
+  }
+
+  async deleteGeozone(id: number, organizationId: number): Promise<boolean> {
+    const deleted = await db
+      .delete(gpsGeozones)
+      .where(and(eq(gpsGeozones.id, id), eq(gpsGeozones.organizationId, organizationId)))
+      .returning({ id: gpsGeozones.id });
+    return deleted.length > 0;
+  }
+
+  // =====================
+  // События геозон и состояния
+  // =====================
+
+  async insertGeozoneEvent(data: {
+    organizationId: number;
+    geozoneId: number;
+    assetId: number;
+    event: "enter" | "exit";
+    lat?: number | null;
+    lng?: number | null;
+  }): Promise<GpsGeozoneEvent> {
+    const [event] = await db.insert(gpsGeozoneEvents).values(data).returning();
+    return event;
+  }
+
+  async listGeozoneEvents(
+    organizationId: number,
+    filters: { assetId?: number; geozoneId?: number; from?: Date; to?: Date; limit?: number }
+  ): Promise<Array<GpsGeozoneEvent & { assetName: string | null; geozoneName: string | null }>> {
+    const conditions = [eq(gpsGeozoneEvents.organizationId, organizationId)];
+    if (filters.assetId) conditions.push(eq(gpsGeozoneEvents.assetId, filters.assetId));
+    if (filters.geozoneId) conditions.push(eq(gpsGeozoneEvents.geozoneId, filters.geozoneId));
+    if (filters.from) conditions.push(gte(gpsGeozoneEvents.createdAt, filters.from));
+    if (filters.to) conditions.push(lte(gpsGeozoneEvents.createdAt, filters.to));
+
+    const rows = await db
+      .select({
+        event: gpsGeozoneEvents,
+        assetName: gpsAssets.name,
+        geozoneName: gpsGeozones.name,
+      })
+      .from(gpsGeozoneEvents)
+      .leftJoin(gpsAssets, eq(gpsGeozoneEvents.assetId, gpsAssets.id))
+      .leftJoin(gpsGeozones, eq(gpsGeozoneEvents.geozoneId, gpsGeozones.id))
+      .where(and(...conditions))
+      .orderBy(desc(gpsGeozoneEvents.createdAt))
+      .limit(filters.limit ?? 200);
+
+    return rows.map((r) => ({ ...r.event, assetName: r.assetName, geozoneName: r.geozoneName }));
+  }
+
+  /** Состояния «внутри геозоны» для конкретного объекта */
+  async getGeozoneStatesForAsset(assetId: number): Promise<Map<number, boolean>> {
+    const rows = await db
+      .select()
+      .from(gpsGeozoneStates)
+      .where(eq(gpsGeozoneStates.assetId, assetId));
+    return new Map(rows.map((r) => [r.geozoneId, r.inside]));
+  }
+
+  async upsertGeozoneState(assetId: number, geozoneId: number, inside: boolean): Promise<void> {
+    await db
+      .insert(gpsGeozoneStates)
+      .values({ assetId, geozoneId, inside, updatedAt: new Date() })
+      .onConflictDoUpdate({
+        target: [gpsGeozoneStates.assetId, gpsGeozoneStates.geozoneId],
+        set: { inside, updatedAt: new Date() },
+      });
+  }
+
+  // =====================
+  // Группы
+  // =====================
+
+  async listGroups(organizationId: number): Promise<Array<GpsGroup & { assetIds: number[] }>> {
+    const groups = await db
+      .select()
+      .from(gpsGroups)
+      .where(eq(gpsGroups.organizationId, organizationId))
+      .orderBy(asc(gpsGroups.name));
+
+    if (groups.length === 0) return [];
+
+    const links = await db
+      .select()
+      .from(gpsGroupAssets)
+      .where(inArray(gpsGroupAssets.groupId, groups.map((g) => g.id)));
+
+    const assetsByGroup = new Map<number, number[]>();
+    for (const link of links) {
+      const list = assetsByGroup.get(link.groupId) ?? [];
+      list.push(link.assetId);
+      assetsByGroup.set(link.groupId, list);
+    }
+
+    return groups.map((g) => ({ ...g, assetIds: assetsByGroup.get(g.id) ?? [] }));
+  }
+
+  async getGroup(id: number, organizationId: number): Promise<GpsGroup | undefined> {
+    const [group] = await db
+      .select()
+      .from(gpsGroups)
+      .where(and(eq(gpsGroups.id, id), eq(gpsGroups.organizationId, organizationId)));
+    return group;
+  }
+
+  async createGroup(organizationId: number, name: string, assetIds: number[]): Promise<GpsGroup> {
+    const [group] = await db.insert(gpsGroups).values({ organizationId, name }).returning();
+    await this.setGroupAssets(group.id, assetIds);
+    return group;
+  }
+
+  async updateGroup(id: number, organizationId: number, updates: { name?: string; assetIds?: number[] }): Promise<GpsGroup | undefined> {
+    let group: GpsGroup | undefined;
+    if (updates.name !== undefined) {
+      [group] = await db
+        .update(gpsGroups)
+        .set({ name: updates.name })
+        .where(and(eq(gpsGroups.id, id), eq(gpsGroups.organizationId, organizationId)))
+        .returning();
+    } else {
+      group = await this.getGroup(id, organizationId);
+    }
+    if (!group) return undefined;
+    if (updates.assetIds !== undefined) {
+      await this.setGroupAssets(id, updates.assetIds);
+    }
+    return group;
+  }
+
+  async deleteGroup(id: number, organizationId: number): Promise<boolean> {
+    const deleted = await db
+      .delete(gpsGroups)
+      .where(and(eq(gpsGroups.id, id), eq(gpsGroups.organizationId, organizationId)))
+      .returning({ id: gpsGroups.id });
+    return deleted.length > 0;
+  }
+
+  /** Полная замена состава группы */
+  private async setGroupAssets(groupId: number, assetIds: number[]): Promise<void> {
+    await db.delete(gpsGroupAssets).where(eq(gpsGroupAssets.groupId, groupId));
+    if (assetIds.length > 0) {
+      await db
+        .insert(gpsGroupAssets)
+        .values(assetIds.map((assetId) => ({ groupId, assetId })))
+        .onConflictDoNothing();
+    }
+  }
+
+  // =====================
+  // Подписчики
+  // =====================
+
+  async listSubscribers(assetId: number): Promise<GpsAssetSubscriber[]> {
+    return db
+      .select()
+      .from(gpsAssetSubscribers)
+      .where(eq(gpsAssetSubscribers.assetId, assetId));
+  }
+
+  /** Полная замена списка подписчиков объекта */
+  async replaceSubscribers(
+    assetId: number,
+    subscribers: Array<{ userId: number; onEnter: boolean; onExit: boolean; onOffline: boolean }>
+  ): Promise<GpsAssetSubscriber[]> {
+    await db.delete(gpsAssetSubscribers).where(eq(gpsAssetSubscribers.assetId, assetId));
+    if (subscribers.length === 0) return [];
+    return db
+      .insert(gpsAssetSubscribers)
+      .values(
+        subscribers.map((s) => ({
+          assetId,
+          userId: s.userId,
+          onEnter: s.onEnter,
+          onExit: s.onExit,
+          onOffline: s.onOffline,
+        }))
+      )
+      .returning();
+  }
+}
+
+export const gpsStorage = new GpsStorage();
diff --git a/server/gps/traccar.client.ts b/server/gps/traccar.client.ts
new file mode 100644
index 0000000..d4bdd61
--- /dev/null
+++ b/server/gps/traccar.client.ts
@@ -0,0 +1,95 @@
+/**
+ * Клиент Traccar REST API.
+ * Настройка через env: TRACCAR_API_URL, TRACCAR_USER, TRACCAR_PASSWORD.
+ * Если переменные не заданы — все методы тихо no-op с логом,
+ * чтобы GPS-модуль работал и без Traccar (например, только PWA-трекинг).
+ */
+
+const TRACCAR_API_URL = process.env.TRACCAR_API_URL;
+const TRACCAR_USER = process.env.TRACCAR_USER;
+const TRACCAR_PASSWORD = process.env.TRACCAR_PASSWORD;
+
+function isConfigured(): boolean {
+  return Boolean(TRACCAR_API_URL && TRACCAR_USER && TRACCAR_PASSWORD);
+}
+
+function authHeaders(): Record<string, string> {
+  const basic = Buffer.from(`${TRACCAR_USER}:${TRACCAR_PASSWORD}`).toString("base64");
+  return {
+    Authorization: `Basic ${basic}`,
+    "Content-Type": "application/json",
+  };
+}
+
+interface TraccarDevice {
+  id: number;
+  uniqueId: string;
+  name: string;
+}
+
+/** Найти устройство по uniqueId; возвращает null, если не найдено */
+async function findDevice(uniqueId: string): Promise<TraccarDevice | null> {
+  const url = `${TRACCAR_API_URL}/api/devices?uniqueId=${encodeURIComponent(uniqueId)}`;
+  const res = await fetch(url, { headers: authHeaders() });
+  if (!res.ok) {
+    throw new Error(`Traccar GET /api/devices: HTTP ${res.status}`);
+  }
+  const devices = (await res.json()) as TraccarDevice[];
+  return devices.find((d) => d.uniqueId === uniqueId) ?? null;
+}
+
+/**
+ * Создаёт устройство в Traccar, если его ещё нет.
+ * Возвращает id устройства или null при ошибке/отсутствии конфигурации.
+ */
+export async function ensureDevice(uniqueId: string, name: string): Promise<number | null> {
+  if (!isConfigured()) {
+    console.log("[GPS] Traccar не настроен (TRACCAR_API_URL/USER/PASSWORD), ensureDevice пропущен");
+    return null;
+  }
+
+  try {
+    const existing = await findDevice(uniqueId);
+    if (existing) return existing.id;
+
+    const res = await fetch(`${TRACCAR_API_URL}/api/devices`, {
+      method: "POST",
+      headers: authHeaders(),
+      body: JSON.stringify({ uniqueId, name }),
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Traccar POST /api/devices: HTTP ${res.status} ${text}`);
+    }
+    const device = (await res.json()) as TraccarDevice;
+    console.log(`[GPS] Traccar: создано устройство '${name}' (${uniqueId}), id=${device.id}`);
+    return device.id;
+  } catch (err) {
+    console.error("[GPS] Traccar ensureDevice error:", err);
+    return null;
+  }
+}
+
+/** Удаляет устройство из Traccar по uniqueId (если существует) */
+export async function deleteDevice(uniqueId: string): Promise<void> {
+  if (!isConfigured()) {
+    console.log("[GPS] Traccar не настроен, deleteDevice пропущен");
+    return;
+  }
+
+  try {
+    const existing = await findDevice(uniqueId);
+    if (!existing) return;
+
+    const res = await fetch(`${TRACCAR_API_URL}/api/devices/${existing.id}`, {
+      method: "DELETE",
+      headers: authHeaders(),
+    });
+    if (!res.ok && res.status !== 404) {
+      throw new Error(`Traccar DELETE /api/devices/${existing.id}: HTTP ${res.status}`);
+    }
+    console.log(`[GPS] Traccar: удалено устройство ${uniqueId}`);
+  } catch (err) {
+    console.error("[GPS] Traccar deleteDevice error:", err);
+  }
+}
diff --git a/server/gps/worker.ts b/server/gps/worker.ts
new file mode 100644
index 0000000..b203409
--- /dev/null
+++ b/server/gps/worker.ts
@@ -0,0 +1,53 @@
+import { withSuperAdmin } from "../db";
+import { gpsStorage } from "./storage";
+import { notifyOffline } from "./geozone.service";
+import { eventBus } from "../routes/shared";
+
+/**
+ * Воркер офлайн-детекта GPS-объектов.
+ * Раз в минуту ищет активные онлайн-объекты, от которых не было точек
+ * более 15 минут, переводит их в offline и уведомляет подписчиков (on_offline).
+ * Обратный переход в online происходит в processPosition при новой точке.
+ * Работает независимо от Traccar (PWA-трекинг тоже покрывается).
+ */
+
+const TICK_MS = 60_000;
+const OFFLINE_THRESHOLD_MS = 15 * 60_000;
+
+let isRunning = false;
+
+async function tick(): Promise<void> {
+  const cutoff = new Date(Date.now() - OFFLINE_THRESHOLD_MS);
+  const staleAssets = await withSuperAdmin(() => gpsStorage.getStaleOnlineAssets(cutoff));
+
+  for (const asset of staleAssets) {
+    try {
+      await withSuperAdmin(async () => {
+        await gpsStorage.setAssetOnline(asset.id, false);
+        await notifyOffline(asset);
+      });
+
+      // SSE — чтобы открытые карты сразу «погасили» маркер
+      eventBus.publishEvent({
+        type: "gps_asset_offline",
+        data: { assetId: asset.id },
+        organizationId: asset.organizationId,
+      });
+
+      console.log(`[GPS Worker] Объект ${asset.id} ('${asset.name}', org ${asset.organizationId}) переведён в offline`);
+    } catch (err) {
+      console.error(`[GPS Worker] Ошибка обработки объекта ${asset.id}:`, err);
+    }
+  }
+}
+
+export function startGpsWorker(): void {
+  if (isRunning) return;
+  isRunning = true;
+
+  setInterval(() => {
+    tick().catch((err) => console.error("[GPS Worker] Tick error:", err));
+  }, TICK_MS);
+
+  console.log("[GPS Worker] started");
+}
diff --git a/server/index.ts b/server/index.ts
index 35479bf..532cf49 100644
--- a/server/index.ts
+++ b/server/index.ts
@@ -8,6 +8,7 @@ import { notificationService } from "./services/notification.service";
 import { webPushService } from "./services/web-push.service";
 import { startMedScheduleWorker } from "./medschedule/worker";
 import { startAutomationScheduler } from "./workers/automation-scheduler";
+import { startGpsWorker } from "./gps/worker";
 import { storage } from "./storage";
 import type { ReminderRecipient } from "@shared/schema";
 import { db, withSuperAdmin } from "./db"; // lazy proxy — safe at module load; throws on first use if DATABASE_URL missing
@@ -1099,6 +1100,10 @@ async function runStartupDataPatches() {
   startAutomationScheduler();
   log('Automation scheduler started');
 
+  // Start GPS worker (offline detection for tracked assets)
+  startGpsWorker();
+  log('GPS worker started');
+
   // Clean up duplicate subscriptions then backfill defaults for existing users
   (async () => {
     try {
diff --git a/server/routes/index.ts b/server/routes/index.ts
index 6243aaa..84002ff 100644
--- a/server/routes/index.ts
+++ b/server/routes/index.ts
@@ -41,6 +41,7 @@ import organizationSkinsRouter from "./organization-skins.routes";
 import { registerSyncRoutes } from "./sync.routes";
 import { registerMedScheduleRoutes } from "../medschedule/routes";
 import { registerMedScheduleBotRoutes } from "../medschedule/bot.routes";
+import { registerGpsRoutes } from "../gps/routes";
 import { registerVpnRoutes } from "../vpn";
 import { FIELD_TYPE_DEFINITIONS } from "../../shared/field-types";
 export { publishNotificationSSE };
@@ -120,6 +121,8 @@ export async function registerRoutes(app: Express): Promise<Server> {
   registerSyncRoutes(app);
   registerMedScheduleRoutes(app);
   registerMedScheduleBotRoutes(app);
+  // GPS-модуль: публичный /api/gps/ingest регистрируется внутри до authenticateToken
+  registerGpsRoutes(app);
   registerVpnRoutes(app);
 
   const httpServer = createServer(app);
diff --git a/shared/schema.ts b/shared/schema.ts
index 817aef9..bc16360 100644
--- a/shared/schema.ts
+++ b/shared/schema.ts
@@ -1,5 +1,5 @@
 import { sql, relations } from "drizzle-orm";
-import { pgTable, text, varchar, integer, boolean, timestamp, jsonb, serial, unique, foreignKey, uniqueIndex, index, numeric, real, date, uuid, type AnyPgColumn, customType } from "drizzle-orm/pg-core";
+import { pgTable, text, varchar, integer, boolean, timestamp, jsonb, serial, bigserial, doublePrecision, unique, foreignKey, uniqueIndex, index, numeric, real, date, uuid, type AnyPgColumn, customType } from "drizzle-orm/pg-core";
 import { createInsertSchema } from "drizzle-zod";
 import { z } from "zod";
 
@@ -3967,3 +3967,142 @@ export const medBotBindings = pgTable("med_bot_bindings", {
 
 export type MedBotBinding = typeof medBotBindings.$inferSelect;
 export type InsertMedBotBinding = typeof medBotBindings.$inferInsert;
+
+
+// =====================
+// GPS-мониторинг (объекты, треки, геозоны)
+// =====================
+
+// Объекты мониторинга: транспорт ('vehicle') или люди ('person')
+export const gpsAssets = pgTable("gps_assets", {
+  id: serial("id").primaryKey(),
+  organizationId: integer("organization_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  type: text("type").$type<"vehicle" | "person">().notNull().default("vehicle"),
+  userId: integer("user_id").references(() => users.id),
+  externalId: text("external_id"), // IMEI/идентификатор трекера (уникален в рамках организации)
+  color: text("color").default("#3b82f6"),
+  isActive: boolean("is_active").default(true),
+  isOnline: boolean("is_online").default(false),
+  lastLat: doublePrecision("last_lat"),
+  lastLng: doublePrecision("last_lng"),
+  lastSpeed: doublePrecision("last_speed"),
+  lastCourse: doublePrecision("last_course"),
+  lastSeenAt: timestamp("last_seen_at"),
+  createdAt: timestamp("created_at").defaultNow(),
+}, (table) => ({
+  orgIdx: index("gps_assets_org_idx").on(table.organizationId),
+  orgExternalIdx: uniqueIndex("gps_assets_org_external_idx").on(table.organizationId, table.externalId),
+  userIdx: index("gps_assets_user_idx").on(table.userId),
+}));
+
+export type GpsAsset = typeof gpsAssets.$inferSelect;
+export type InsertGpsAsset = typeof gpsAssets.$inferInsert;
+
+// История позиций (треки)
+export const gpsPositions = pgTable("gps_positions", {
+  id: bigserial("id", { mode: "number" }).primaryKey(),
+  assetId: integer("asset_id").notNull().references(() => gpsAssets.id, { onDelete: "cascade" }),
+  organizationId: integer("organization_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+  lat: doublePrecision("lat").notNull(),
+  lng: doublePrecision("lng").notNull(),
+  speed: doublePrecision("speed"),
+  course: doublePrecision("course"),
+  accuracy: doublePrecision("accuracy"),
+  recordedAt: timestamp("recorded_at").notNull(),
+  createdAt: timestamp("created_at").defaultNow(),
+}, (table) => ({
+  assetRecordedIdx: index("gps_positions_asset_recorded_idx").on(table.assetId, table.recordedAt),
+  orgRecordedIdx: index("gps_positions_org_recorded_idx").on(table.organizationId, table.recordedAt),
+}));
+
+export type GpsPosition = typeof gpsPositions.$inferSelect;
+export type InsertGpsPosition = typeof gpsPositions.$inferInsert;
+
+// Геозоны (полигоны; polygon — массив пар [lat, lng])
+export const gpsGeozones = pgTable("gps_geozones", {
+  id: serial("id").primaryKey(),
+  organizationId: integer("organization_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  polygon: jsonb("polygon").$type<Array<[number, number]>>().notNull(),
+  color: text("color").default("#f59e0b"),
+  notifyEnter: boolean("notify_enter").default(true),
+  notifyExit: boolean("notify_exit").default(true),
+  isActive: boolean("is_active").default(true),
+  createdAt: timestamp("created_at").defaultNow(),
+}, (table) => ({
+  orgIdx: index("gps_geozones_org_idx").on(table.organizationId),
+}));
+
+export type GpsGeozone = typeof gpsGeozones.$inferSelect;
+export type InsertGpsGeozone = typeof gpsGeozones.$inferInsert;
+
+// События входа/выхода из геозон
+export const gpsGeozoneEvents = pgTable("gps_geozone_events", {
+  id: bigserial("id", { mode: "number" }).primaryKey(),
+  organizationId: integer("organization_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+  geozoneId: integer("geozone_id").notNull().references(() => gpsGeozones.id, { onDelete: "cascade" }),
+  assetId: integer("asset_id").notNull().references(() => gpsAssets.id, { onDelete: "cascade" }),
+  event: text("event").$type<"enter" | "exit">().notNull(),
+  lat: doublePrecision("lat"),
+  lng: doublePrecision("lng"),
+  createdAt: timestamp("created_at").defaultNow(),
+}, (table) => ({
+  assetIdx: index("gps_geozone_events_asset_idx").on(table.assetId, table.createdAt),
+  orgIdx: index("gps_geozone_events_org_idx").on(table.organizationId, table.createdAt),
+}));
+
+export type GpsGeozoneEvent = typeof gpsGeozoneEvents.$inferSelect;
+export type InsertGpsGeozoneEvent = typeof gpsGeozoneEvents.$inferInsert;
+
+// Текущее состояние «объект внутри геозоны» (для детекта входа/выхода)
+export const gpsGeozoneStates = pgTable("gps_geozone_states", {
+  assetId: integer("asset_id").notNull().references(() => gpsAssets.id, { onDelete: "cascade" }),
+  geozoneId: integer("geozone_id").notNull().references(() => gpsGeozones.id, { onDelete: "cascade" }),
+  inside: boolean("inside").notNull(),
+  updatedAt: timestamp("updated_at").defaultNow(),
+}, (table) => ({
+  pk: uniqueIndex("gps_geozone_states_pk").on(table.assetId, table.geozoneId),
+}));
+
+export type GpsGeozoneState = typeof gpsGeozoneStates.$inferSelect;
+export type InsertGpsGeozoneState = typeof gpsGeozoneStates.$inferInsert;
+
+// Группы объектов (для фильтров на карте)
+export const gpsGroups = pgTable("gps_groups", {
+  id: serial("id").primaryKey(),
+  organizationId: integer("organization_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  createdAt: timestamp("created_at").defaultNow(),
+}, (table) => ({
+  orgIdx: index("gps_groups_org_idx").on(table.organizationId),
+}));
+
+export type GpsGroup = typeof gpsGroups.$inferSelect;
+export type InsertGpsGroup = typeof gpsGroups.$inferInsert;
+
+// Связь групп и объектов (многие-ко-многим)
+export const gpsGroupAssets = pgTable("gps_group_assets", {
+  groupId: integer("group_id").notNull().references(() => gpsGroups.id, { onDelete: "cascade" }),
+  assetId: integer("asset_id").notNull().references(() => gpsAssets.id, { onDelete: "cascade" }),
+}, (table) => ({
+  pk: uniqueIndex("gps_group_assets_pk").on(table.groupId, table.assetId),
+}));
+
+export type GpsGroupAsset = typeof gpsGroupAssets.$inferSelect;
+export type InsertGpsGroupAsset = typeof gpsGroupAssets.$inferInsert;
+
+// Подписчики на события объекта
+export const gpsAssetSubscribers = pgTable("gps_asset_subscribers", {
+  id: serial("id").primaryKey(),
+  assetId: integer("asset_id").notNull().references(() => gpsAssets.id, { onDelete: "cascade" }),
+  userId: integer("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  onEnter: boolean("on_enter").default(true),
+  onExit: boolean("on_exit").default(true),
+  onOffline: boolean("on_offline").default(false),
+}, (table) => ({
+  assetUserIdx: uniqueIndex("gps_asset_subscribers_asset_user_idx").on(table.assetId, table.userId),
+}));
+
+export type GpsAssetSubscriber = typeof gpsAssetSubscribers.$inferSelect;
+export type InsertGpsAssetSubscriber = typeof gpsAssetSubscribers.$inferInsert;
diff --git a/traccar/traccar.xml b/traccar/traccar.xml
new file mode 100644
index 0000000..a34ae1c
--- /dev/null
+++ b/traccar/traccar.xml
@@ -0,0 +1,25 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!DOCTYPE properties SYSTEM 'http://java.sun.com/dtd/properties.dtd'>
+<properties>
+
+    <!-- Минимальная конфигурация Traccar для GPS-модуля iistwin -->
+
+    <!-- Встроенная база H2 (данные в volume traccar_data) -->
+    <entry key='database.driver'>org.h2.Driver</entry>
+    <entry key='database.url'>jdbc:h2:/opt/traccar/data/database</entry>
+    <entry key='database.user'>sa</entry>
+    <entry key='database.password'></entry>
+
+    <!-- Web-интерфейс и REST API (внутри Docker-сети — порт 8082) -->
+    <entry key='web.enable'>true</entry>
+    <entry key='web.port'>8082</entry>
+
+    <!-- Forward позиций в CRM iistwin.
+         ВНИМАНИЕ: Traccar не подставляет env-переменные в конфиг —
+         в forward.header нужно вписать тот же токен, что задан
+         в переменной GPS_INGEST_TOKEN в .env CRM. -->
+    <entry key='forward.enable'>true</entry>
+    <entry key='forward.url'>http://app:5000/api/gps/ingest</entry>
+    <entry key='forward.header'>X-Gps-Token: ВСТАВИТЬ_СЮДА_ТОКЕН_GPS_INGEST_TOKEN</entry>
+
+</properties>