From b5a4da1285a3c861d4bf8d0bcdeb328416b00758 Mon Sep 17 00:00:00 2001
From: "i.seliverstov" <i.seliverstov@mtlab.space>
Date: Thu, 13 Aug 2026 18:04:10 +0500
Subject: [PATCH] feat(timer): sync open tabs via SSE

When a timer starts, pauses, or stops, other open clients restore state from the backend instead of staying stale.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 Caddyfile                                     |  11 ++
 alfy-bot-frontend/src/composables/useSse.ts   | 112 ++++++++++++++++++
 .../features/task-timer/model/timer-store.ts  |  32 ++++-
 .../src/features/task-timer/ui/TimeBlock.vue  |  10 +-
 alfy-bot-frontend/src/sw.ts                   |   4 +-
 .../tests/composables/useSse.spec.ts          | 108 +++++++++++++++++
 .../task-timer/timer-store-restore.spec.ts    |  90 ++++++++++++++
 alfy-bot/src/app.module.ts                    |   2 +
 .../modules/events/domain/user-events.port.ts |  11 ++
 .../modules/events/events.controller.spec.ts  |  37 ++++++
 .../src/modules/events/events.controller.ts   |  29 +++++
 alfy-bot/src/modules/events/events.module.ts  |  13 ++
 .../in-memory-user-events.hub.spec.ts         |  39 ++++++
 .../in-memory-user-events.hub.ts              |  37 ++++++
 alfy-bot/src/modules/task/task.module.ts      |   2 +
 .../task/timer-session.service.spec.ts        |  12 ++
 .../src/modules/task/timer-session.service.ts |  10 +-
 17 files changed, 549 insertions(+), 10 deletions(-)
 create mode 100644 alfy-bot-frontend/src/composables/useSse.ts
 create mode 100644 alfy-bot-frontend/tests/composables/useSse.spec.ts
 create mode 100644 alfy-bot-frontend/tests/features/task-timer/timer-store-restore.spec.ts
 create mode 100644 alfy-bot/src/modules/events/domain/user-events.port.ts
 create mode 100644 alfy-bot/src/modules/events/events.controller.spec.ts
 create mode 100644 alfy-bot/src/modules/events/events.controller.ts
 create mode 100644 alfy-bot/src/modules/events/events.module.ts
 create mode 100644 alfy-bot/src/modules/events/infrastructure/in-memory-user-events.hub.spec.ts
 create mode 100644 alfy-bot/src/modules/events/infrastructure/in-memory-user-events.hub.ts

diff --git a/Caddyfile b/Caddyfile
index 46c035f..f524b1e 100644
--- a/Caddyfile
+++ b/Caddyfile
@@ -6,6 +6,17 @@ tracker.rocketup.tech {
 		}
 	}
 
+	@sse path /api/events /api/events/*
+	handle @sse {
+		reverse_proxy backend:3002 {
+			flush_interval -1
+			transport http {
+				read_timeout 0
+				write_timeout 0
+			}
+		}
+	}
+
 	handle /api/* {
 		reverse_proxy backend:3002
 	}
diff --git a/alfy-bot-frontend/src/composables/useSse.ts b/alfy-bot-frontend/src/composables/useSse.ts
new file mode 100644
index 0000000..19bee20
--- /dev/null
+++ b/alfy-bot-frontend/src/composables/useSse.ts
@@ -0,0 +1,112 @@
+import { onUnmounted } from 'vue'
+import { api } from '@/api/client'
+import { getToken } from '@/api/tokenStorage'
+
+export type SseHandler = (event: string, data: unknown) => void
+
+const INITIAL_RETRY_MS = 1000
+const MAX_RETRY_MS = 30_000
+
+function parseSseBlock(block: string): { event: string, data: string } | null {
+  let event = 'message'
+  let data = ''
+  for (const line of block.split('\n')) {
+    if (line.startsWith('event:'))
+      event = line.slice(6).trim()
+    else if (line.startsWith('data:'))
+      data += line.slice(5).trim()
+  }
+  if (!data)
+    return null
+  return { event, data }
+}
+
+export function useSse(path: string, onEvent: SseHandler) {
+  let abort: AbortController | null = null
+  let retryMs = INITIAL_RETRY_MS
+  let stopped = false
+  let retryTimer: ReturnType<typeof setTimeout> | null = null
+
+  async function readStream(body: ReadableStream<Uint8Array>) {
+    const reader = body.getReader()
+    const decoder = new TextDecoder()
+    let buf = ''
+
+    while (true) {
+      if (stopped)
+        break
+      const { done, value } = await reader.read()
+      if (done)
+        break
+      buf += decoder.decode(value, { stream: true })
+      const parts = buf.split('\n\n')
+      buf = parts.pop() ?? ''
+      for (const block of parts) {
+        const parsed = parseSseBlock(block)
+        if (!parsed)
+          continue
+        try {
+          onEvent(parsed.event, JSON.parse(parsed.data))
+        }
+        catch {
+          onEvent(parsed.event, parsed.data)
+        }
+      }
+    }
+  }
+
+  async function connect() {
+    const token = getToken()
+    if (!token)
+      return
+
+    abort = new AbortController()
+    const base = String(api.defaults.baseURL ?? '').replace(/\/$/, '')
+    const res = await fetch(`${base}${path}`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: 'text/event-stream',
+      },
+      signal: abort.signal,
+    })
+
+    if (res.status === 401) {
+      stopped = true
+      return
+    }
+    if (!res.ok || !res.body)
+      throw new Error(`SSE ${res.status}`)
+
+    retryMs = INITIAL_RETRY_MS
+    await readStream(res.body)
+  }
+
+  async function loop() {
+    while (true) {
+      if (stopped)
+        return
+      try {
+        await connect()
+      }
+      catch (e) {
+        if (stopped || (e instanceof DOMException && e.name === 'AbortError'))
+          return
+      }
+      if (stopped)
+        return
+      await new Promise<void>((resolve) => {
+        retryTimer = setTimeout(resolve, retryMs)
+      })
+      retryMs = Math.min(retryMs * 2, MAX_RETRY_MS)
+    }
+  }
+
+  loop()
+
+  onUnmounted(() => {
+    stopped = true
+    if (retryTimer)
+      clearTimeout(retryTimer)
+    abort?.abort()
+  })
+}
diff --git a/alfy-bot-frontend/src/features/task-timer/model/timer-store.ts b/alfy-bot-frontend/src/features/task-timer/model/timer-store.ts
index e8bcd38..3455be1 100644
--- a/alfy-bot-frontend/src/features/task-timer/model/timer-store.ts
+++ b/alfy-bot-frontend/src/features/task-timer/model/timer-store.ts
@@ -30,6 +30,11 @@ export const useTimerStore = defineStore('timer', () => {
   const timerInterval: Ref<ReturnType<typeof setInterval> | null> = ref(null)
   const { play: playSound } = useSounds()
   let swListenerRegistered = false
+  let sseMutedUntil = 0
+
+  function muteRemoteRestore(ms = 1500): void {
+    sseMutedUntil = Date.now() + ms
+  }
 
   const checkPhase = {
     isWorkPhase: (phaseNumber: number): boolean => phaseNumber % 2 === 1,
@@ -200,6 +205,8 @@ export const useTimerStore = defineStore('timer', () => {
     const taskId = currentSettings.value.taskId
     if (!taskId) return
 
+    muteRemoteRestore()
+
     try {
       if (isActive.value) {
         const expiresAt = new Date(Date.now() + timeBlock.value * 1000).toISOString()
@@ -229,9 +236,14 @@ export const useTimerStore = defineStore('timer', () => {
   async function restoreSession(): Promise<void> {
     registerSWListener()
 
+    if (Date.now() < sseMutedUntil) return
+
     try {
       const { data: session } = await api.get('/tasks/timer')
-      if (!session) return
+      if (!session) {
+        clearLocalSession()
+        return
+      }
 
       if (session.task?.pomodoroConfig) {
         const cfg = session.task.pomodoroConfig
@@ -245,6 +257,8 @@ export const useTimerStore = defineStore('timer', () => {
         }
       }
 
+      stopLocalTicker()
+
       const sessionState = determineSessionState(session)
 
       switch (sessionState.type) {
@@ -318,28 +332,34 @@ export const useTimerStore = defineStore('timer', () => {
     }
   }
 
-  async function resetToInitialState(): Promise<void> {
+  function stopLocalTicker(): void {
     if (timerInterval.value) {
       clearInterval(timerInterval.value)
       timerInterval.value = null
     }
-
     const timerId = currentSettings.value.taskId || 'pomodoro'
     sendToSW({ type: 'TIMER_STOP', data: { id: timerId } })
-
     isActive.value = false
     expiresAt.value = null
+  }
+
+  function clearLocalSession(): void {
+    stopLocalTicker()
     phase.value = 0
     timeBlock.value = 0
     namePhase.value = ''
+    updateTitle()
+  }
+
+  async function resetToInitialState(): Promise<void> {
+    muteRemoteRestore()
+    clearLocalSession()
 
     try {
       await api.delete('/tasks/timer')
     } catch (err) {
       console.error('Ошибка деактивации таймера:', err)
     }
-
-    updateTitle()
   }
 
   function startTask(task: Task): void {
diff --git a/alfy-bot-frontend/src/features/task-timer/ui/TimeBlock.vue b/alfy-bot-frontend/src/features/task-timer/ui/TimeBlock.vue
index 48c4f8a..0d36c72 100644
--- a/alfy-bot-frontend/src/features/task-timer/ui/TimeBlock.vue
+++ b/alfy-bot-frontend/src/features/task-timer/ui/TimeBlock.vue
@@ -1,8 +1,9 @@
 <script setup lang="ts">
 import { computed, onMounted, onUnmounted, ref, watch } from 'vue'
-import { useTimerStore } from '../model/timer-store'
+import { Pause, Play, Square } from 'lucide-vue-next'
 import { Button } from '@/components/ui/button'
-import { Play, Pause, Square } from 'lucide-vue-next'
+import { useSse } from '@/composables/useSse'
+import { useTimerStore } from '../model/timer-store'
 
 const store = useTimerStore()
 const isFullscreen = ref(false)
@@ -56,6 +57,11 @@ onMounted(() => {
   store.restoreSession()
 })
 
+useSse('/events', (event) => {
+  if (event === 'timer.updated')
+    void store.restoreSession()
+})
+
 onUnmounted(() => {
   releaseWakeLock()
 })
diff --git a/alfy-bot-frontend/src/sw.ts b/alfy-bot-frontend/src/sw.ts
index 89a01e3..816f5b7 100644
--- a/alfy-bot-frontend/src/sw.ts
+++ b/alfy-bot-frontend/src/sw.ts
@@ -9,7 +9,9 @@ cleanupOutdatedCaches()
 
 registerRoute(
   ({ url }) =>
-    url.origin === self.location.origin && url.pathname.startsWith('/api'),
+    url.origin === self.location.origin &&
+    url.pathname.startsWith('/api') &&
+    !url.pathname.startsWith('/api/events'),
   new NetworkOnly(),
 )
 
diff --git a/alfy-bot-frontend/tests/composables/useSse.spec.ts b/alfy-bot-frontend/tests/composables/useSse.spec.ts
new file mode 100644
index 0000000..4e865b3
--- /dev/null
+++ b/alfy-bot-frontend/tests/composables/useSse.spec.ts
@@ -0,0 +1,108 @@
+import type { VueWrapper } from '@vue/test-utils'
+import { mount } from '@vue/test-utils'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { defineComponent } from 'vue'
+import { getToken } from '@/api/tokenStorage'
+import { useSse } from '@/composables/useSse'
+
+vi.mock('@/api/tokenStorage', () => ({
+  getToken: vi.fn(),
+}))
+
+vi.mock('@/api/client', () => ({
+  api: { defaults: { baseURL: 'http://localhost:3002/api' } },
+}))
+
+function sseStream(chunks: string[], hang = true): ReadableStream<Uint8Array> {
+  const encoder = new TextEncoder()
+  return new ReadableStream({
+    start(controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(encoder.encode(chunk))
+      }
+      if (!hang)
+        controller.close()
+    },
+  })
+}
+
+describe('useSse', () => {
+  let wrapper: VueWrapper | null = null
+  let fetchMock: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    vi.mocked(getToken).mockReturnValue('jwt-token')
+    fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+  })
+
+  afterEach(() => {
+    wrapper?.unmount()
+    wrapper = null
+    vi.unstubAllGlobals()
+  })
+
+  function mountSse(onEvent: (event: string, data: unknown) => void) {
+    wrapper = mount(defineComponent({
+      setup() {
+        useSse('/events', onEvent)
+        return () => null
+      },
+    }))
+    return wrapper
+  }
+
+  it('не коннектится без токена', async () => {
+    vi.mocked(getToken).mockReturnValue(null)
+    mountSse(vi.fn())
+    await Promise.resolve()
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('шлёт Bearer и парсит timer.updated', async () => {
+    const onEvent = vi.fn()
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      body: sseStream(['event: timer.updated\ndata: {}\n\n']),
+    })
+
+    mountSse(onEvent)
+    await vi.waitFor(() => expect(onEvent).toHaveBeenCalledWith('timer.updated', {}))
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      'http://localhost:3002/api/events',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: 'Bearer jwt-token',
+          Accept: 'text/event-stream',
+        }),
+      }),
+    )
+  })
+
+  it('не вызывает handler на ping', async () => {
+    const onEvent = vi.fn()
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      body: sseStream(['event: ping\ndata: {}\n\n', 'event: timer.updated\ndata: {}\n\n']),
+    })
+
+    mountSse((event, data) => {
+      if (event === 'ping')
+        return
+      onEvent(event, data)
+    })
+    await vi.waitFor(() => expect(onEvent).toHaveBeenCalledWith('timer.updated', {}))
+    expect(onEvent).toHaveBeenCalledTimes(1)
+  })
+
+  it('не ретраит 401', async () => {
+    fetchMock.mockResolvedValue({ ok: false, status: 401, body: null })
+    mountSse(vi.fn())
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+  })
+})
diff --git a/alfy-bot-frontend/tests/features/task-timer/timer-store-restore.spec.ts b/alfy-bot-frontend/tests/features/task-timer/timer-store-restore.spec.ts
new file mode 100644
index 0000000..1f293bf
--- /dev/null
+++ b/alfy-bot-frontend/tests/features/task-timer/timer-store-restore.spec.ts
@@ -0,0 +1,90 @@
+import { createPinia, setActivePinia } from 'pinia'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { api } from '@/api/client'
+import { useTimerStore } from '@/features/task-timer'
+
+vi.mock('@/api/client', () => ({
+  api: {
+    get: vi.fn(),
+    put: vi.fn(),
+    delete: vi.fn(),
+    patch: vi.fn(),
+  },
+}))
+
+vi.mock('@/composables/useSounds', () => ({
+  useSounds: () => ({ play: vi.fn() }),
+}))
+
+describe('timer store restoreSession', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('сбрасывает локальный таймер, если на бэке сессии нет', async () => {
+    const store = useTimerStore()
+    store.initSession({
+      pomodoroTime: 25,
+      breakTime: 5,
+      longBreakTime: 15,
+      longBreakInterval: 4,
+      countPomodoro: 10,
+      taskId: 'task-1',
+    })
+    store.nextPhase()
+    vi.mocked(api.get).mockResolvedValue({ data: null })
+
+    await store.restoreSession()
+
+    expect(store.phase).toBe(0)
+    expect(store.isActive).toBe(false)
+    expect(store.timeBlock).toBe(0)
+  })
+
+  it('останавливает локальный тик, если на бэке сессия на паузе', async () => {
+    vi.useFakeTimers()
+    const store = useTimerStore()
+    store.initSession({
+      pomodoroTime: 25,
+      breakTime: 5,
+      longBreakTime: 15,
+      longBreakInterval: 4,
+      countPomodoro: 10,
+      taskId: 'task-1',
+    })
+    store.nextPhase()
+    store.startTimer()
+    expect(store.isActive).toBe(true)
+
+    vi.mocked(api.get).mockResolvedValue({
+      data: {
+        taskId: 'task-1',
+        phase: 1,
+        lastStartTime: null,
+        countTimeAfterPause: 500,
+        isActive: false,
+        task: {
+          pomodoroConfig: {
+            pomodoroDuration: 25,
+            shortBreak: 5,
+            longBreak: 15,
+            longBreakInterval: 4,
+            pomodoroCount: 10,
+          },
+        },
+      },
+    })
+
+    await store.restoreSession()
+
+    expect(store.isActive).toBe(false)
+    expect(store.phase).toBe(1)
+    expect(store.timeBlock).toBe(500)
+    expect(store.timerInterval).toBeNull()
+  })
+})
diff --git a/alfy-bot/src/app.module.ts b/alfy-bot/src/app.module.ts
index ca91c8f..9c2b1d2 100644
--- a/alfy-bot/src/app.module.ts
+++ b/alfy-bot/src/app.module.ts
@@ -15,6 +15,7 @@ import { ReportModule } from './modules/report/report.module';
 import { TaskModule } from './modules/task/task.module';
 import { ProjectModule } from './modules/project/project.module';
 import { NotificationModule } from './modules/notification/notification.module';
+import { EventsModule } from './modules/events/events.module';
 import { UserModule } from './modules/user/user.module';
 import {
   Goal,
@@ -81,6 +82,7 @@ const telegramImports = isTelegramEnabled()
     TaskModule,
     ProjectModule,
     NotificationModule,
+    EventsModule,
   ],
   controllers: [AppController],
   providers: [
diff --git a/alfy-bot/src/modules/events/domain/user-events.port.ts b/alfy-bot/src/modules/events/domain/user-events.port.ts
new file mode 100644
index 0000000..2d40851
--- /dev/null
+++ b/alfy-bot/src/modules/events/domain/user-events.port.ts
@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+
+export interface UserEvent {
+  type: string;
+  data: Record<string, never>;
+}
+
+export abstract class UserEventsPort {
+  abstract emit(userId: number, type: string): void;
+  abstract subscribe(userId: number): Observable<UserEvent>;
+}
diff --git a/alfy-bot/src/modules/events/events.controller.spec.ts b/alfy-bot/src/modules/events/events.controller.spec.ts
new file mode 100644
index 0000000..799c4e9
--- /dev/null
+++ b/alfy-bot/src/modules/events/events.controller.spec.ts
@@ -0,0 +1,37 @@
+import { firstValueFrom } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import { Test } from '@nestjs/testing';
+import { JwtOrApiTokenGuard } from '../auth/guards/jwt-or-api-token.guard';
+import { UserEventsPort } from './domain/user-events.port';
+import { EventsController } from './events.controller';
+import { InMemoryUserEventsHub } from './infrastructure/in-memory-user-events.hub';
+
+describe('EventsController', () => {
+  let controller: EventsController;
+  let hub: InMemoryUserEventsHub;
+
+  beforeEach(async () => {
+    hub = new InMemoryUserEventsHub();
+    const module = await Test.createTestingModule({
+      controllers: [EventsController],
+      providers: [{ provide: UserEventsPort, useValue: hub }],
+    })
+      .overrideGuard(JwtOrApiTokenGuard)
+      .useValue({ canActivate: () => true })
+      .compile();
+
+    controller = module.get(EventsController);
+  });
+
+  it('стримит события текущего пользователя', async () => {
+    const stream = controller.stream({ user: { sub: 7 } } as never);
+    const received = firstValueFrom(
+      stream.pipe(filter((e) => e.type === 'timer.updated')),
+    );
+    hub.emit(7, 'timer.updated');
+    await expect(received).resolves.toEqual({
+      type: 'timer.updated',
+      data: {},
+    });
+  });
+});
diff --git a/alfy-bot/src/modules/events/events.controller.ts b/alfy-bot/src/modules/events/events.controller.ts
new file mode 100644
index 0000000..c3ca160
--- /dev/null
+++ b/alfy-bot/src/modules/events/events.controller.ts
@@ -0,0 +1,29 @@
+import { Controller, Request, Sse, UseGuards } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { Observable, interval, map, merge } from 'rxjs';
+import { JwtOrApiTokenGuard } from '../auth/guards/jwt-or-api-token.guard';
+import { JwtPayload } from '../auth/strategies/jwt.strategy';
+import { UserEvent, UserEventsPort } from './domain/user-events.port';
+
+interface AuthRequest extends Request {
+  user: JwtPayload;
+}
+
+const PING_INTERVAL_MS = 25_000;
+
+@ApiTags('events')
+@ApiBearerAuth()
+@UseGuards(JwtOrApiTokenGuard)
+@Controller('events')
+export class EventsController {
+  constructor(private readonly events: UserEventsPort) {}
+
+  @Sse()
+  @ApiOperation({ summary: 'SSE-поток событий текущего пользователя' })
+  stream(@Request() req: AuthRequest): Observable<UserEvent> {
+    return merge(
+      this.events.subscribe(req.user.sub),
+      interval(PING_INTERVAL_MS).pipe(map(() => ({ type: 'ping', data: {} }))),
+    );
+  }
+}
diff --git a/alfy-bot/src/modules/events/events.module.ts b/alfy-bot/src/modules/events/events.module.ts
new file mode 100644
index 0000000..246bcfd
--- /dev/null
+++ b/alfy-bot/src/modules/events/events.module.ts
@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { AuthModule } from '../auth/auth.module';
+import { UserEventsPort } from './domain/user-events.port';
+import { EventsController } from './events.controller';
+import { InMemoryUserEventsHub } from './infrastructure/in-memory-user-events.hub';
+
+@Module({
+  imports: [AuthModule],
+  controllers: [EventsController],
+  providers: [{ provide: UserEventsPort, useClass: InMemoryUserEventsHub }],
+  exports: [UserEventsPort],
+})
+export class EventsModule {}
diff --git a/alfy-bot/src/modules/events/infrastructure/in-memory-user-events.hub.spec.ts b/alfy-bot/src/modules/events/infrastructure/in-memory-user-events.hub.spec.ts
new file mode 100644
index 0000000..605c41b
--- /dev/null
+++ b/alfy-bot/src/modules/events/infrastructure/in-memory-user-events.hub.spec.ts
@@ -0,0 +1,39 @@
+import { firstValueFrom } from 'rxjs';
+import { InMemoryUserEventsHub } from './in-memory-user-events.hub';
+
+describe('InMemoryUserEventsHub', () => {
+  let hub: InMemoryUserEventsHub;
+
+  beforeEach(() => {
+    hub = new InMemoryUserEventsHub();
+  });
+
+  it('доставляет событие подписчику того же userId', async () => {
+    const received = firstValueFrom(hub.subscribe(1));
+    hub.emit(1, 'timer.updated');
+    await expect(received).resolves.toEqual({
+      type: 'timer.updated',
+      data: {},
+    });
+  });
+
+  it('не шлёт событие другому пользователю', () => {
+    const received: string[] = [];
+    const sub = hub.subscribe(1).subscribe((e) => received.push(e.type));
+    hub.emit(2, 'timer.updated');
+    sub.unsubscribe();
+    expect(received).toEqual([]);
+  });
+
+  it('не падает, если подписчиков нет', () => {
+    expect(() => hub.emit(1, 'timer.updated')).not.toThrow();
+  });
+
+  it('доставляет событие всем вкладкам одного пользователя', async () => {
+    const a = firstValueFrom(hub.subscribe(1));
+    const b = firstValueFrom(hub.subscribe(1));
+    hub.emit(1, 'timer.updated');
+    await expect(a).resolves.toEqual({ type: 'timer.updated', data: {} });
+    await expect(b).resolves.toEqual({ type: 'timer.updated', data: {} });
+  });
+});
diff --git a/alfy-bot/src/modules/events/infrastructure/in-memory-user-events.hub.ts b/alfy-bot/src/modules/events/infrastructure/in-memory-user-events.hub.ts
new file mode 100644
index 0000000..3d4e271
--- /dev/null
+++ b/alfy-bot/src/modules/events/infrastructure/in-memory-user-events.hub.ts
@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common';
+import { Observable, Subject } from 'rxjs';
+import { UserEvent, UserEventsPort } from '../domain/user-events.port';
+
+@Injectable()
+export class InMemoryUserEventsHub extends UserEventsPort {
+  private readonly subjects = new Map<number, Subject<UserEvent>>();
+  private readonly refs = new Map<number, number>();
+
+  emit(userId: number, type: string): void {
+    this.subjects.get(userId)?.next({ type, data: {} });
+  }
+
+  subscribe(userId: number): Observable<UserEvent> {
+    let subject = this.subjects.get(userId);
+    if (!subject) {
+      subject = new Subject<UserEvent>();
+      this.subjects.set(userId, subject);
+    }
+    this.refs.set(userId, (this.refs.get(userId) ?? 0) + 1);
+
+    return new Observable((subscriber) => {
+      const subscription = subject.subscribe(subscriber);
+      return () => {
+        subscription.unsubscribe();
+        const remaining = (this.refs.get(userId) ?? 1) - 1;
+        if (remaining <= 0) {
+          this.refs.delete(userId);
+          this.subjects.delete(userId);
+          subject.complete();
+        } else {
+          this.refs.set(userId, remaining);
+        }
+      };
+    });
+  }
+}
diff --git a/alfy-bot/src/modules/task/task.module.ts b/alfy-bot/src/modules/task/task.module.ts
index a23f0e8..31143e1 100644
--- a/alfy-bot/src/modules/task/task.module.ts
+++ b/alfy-bot/src/modules/task/task.module.ts
@@ -9,6 +9,7 @@ import {
 import { AuthModule } from '../auth/auth.module';
 import { UserModule } from '../user/user.module';
 import { NotificationModule } from '../notification/notification.module';
+import { EventsModule } from '../events/events.module';
 import { TaskRepositoryPort } from './domain/task-repository.port';
 import { TimerSessionRepositoryPort } from './domain/timer-session-repository.port';
 import { NotificationPort } from './domain/notification.port';
@@ -42,6 +43,7 @@ const notificationProviders = isTelegramEnabled()
     AuthModule,
     UserModule,
     NotificationModule,
+    EventsModule,
   ],
   controllers: [TaskController],
   providers: [
diff --git a/alfy-bot/src/modules/task/timer-session.service.spec.ts b/alfy-bot/src/modules/task/timer-session.service.spec.ts
index 6e15c26..192a573 100644
--- a/alfy-bot/src/modules/task/timer-session.service.spec.ts
+++ b/alfy-bot/src/modules/task/timer-session.service.spec.ts
@@ -2,6 +2,7 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { TimerSessionService } from './timer-session.service';
 import { TimerSessionRepositoryPort } from './domain/timer-session-repository.port';
 import { NotificationPort } from './domain/notification.port';
+import { UserEventsPort } from '../events/domain/user-events.port';
 import { TimerSession, Task } from '../../shared/entities';
 
 function makeSession(overrides: Partial<TimerSession> = {}): TimerSession {
@@ -27,6 +28,7 @@ describe('TimerSessionService', () => {
   let service: TimerSessionService;
   let timerRepo: Record<string, jest.Mock>;
   let notification: Record<string, jest.Mock>;
+  let events: Record<string, jest.Mock>;
 
   beforeEach(async () => {
     timerRepo = {
@@ -41,11 +43,16 @@ describe('TimerSessionService', () => {
       send: jest.fn().mockResolvedValue(undefined),
     };
 
+    events = {
+      emit: jest.fn(),
+    };
+
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         TimerSessionService,
         { provide: TimerSessionRepositoryPort, useValue: timerRepo },
         { provide: NotificationPort, useValue: notification },
+        { provide: UserEventsPort, useValue: events },
       ],
     }).compile();
 
@@ -66,6 +73,7 @@ describe('TimerSessionService', () => {
 
       expect(timerRepo.create).toHaveBeenCalled();
       expect(timerRepo.save).toHaveBeenCalled();
+      expect(events.emit).toHaveBeenCalledWith(1, 'timer.updated');
       expect(result.taskId).toBe('task-1');
       expect(result.isActive).toBe(true);
     });
@@ -140,6 +148,7 @@ describe('TimerSessionService', () => {
         '⏹ Таймер по задаче "Код ревью" остановлен',
       );
       expect(timerRepo.remove).toHaveBeenCalledWith(session);
+      expect(events.emit).toHaveBeenCalledWith(1, 'timer.updated');
     });
 
     it('ничего не делает если сессии нет', async () => {
@@ -149,6 +158,7 @@ describe('TimerSessionService', () => {
 
       expect(timerRepo.remove).not.toHaveBeenCalled();
       expect(notification.send).not.toHaveBeenCalled();
+      expect(events.emit).not.toHaveBeenCalled();
     });
   });
 
@@ -172,6 +182,7 @@ describe('TimerSessionService', () => {
         1,
         '⏰ Таймер по задаче "Написать отчёт" завершён!',
       );
+      expect(events.emit).toHaveBeenCalledWith(1, 'timer.updated');
     });
 
     it('обрабатывает несколько истёкших сессий', async () => {
@@ -205,6 +216,7 @@ describe('TimerSessionService', () => {
 
       expect(timerRepo.save).not.toHaveBeenCalled();
       expect(notification.send).not.toHaveBeenCalled();
+      expect(events.emit).not.toHaveBeenCalled();
     });
 
     it('вызывает notification.send для каждой истёкшей сессии', async () => {
diff --git a/alfy-bot/src/modules/task/timer-session.service.ts b/alfy-bot/src/modules/task/timer-session.service.ts
index f0332e9..d68e61f 100644
--- a/alfy-bot/src/modules/task/timer-session.service.ts
+++ b/alfy-bot/src/modules/task/timer-session.service.ts
@@ -2,13 +2,17 @@ import { Injectable } from '@nestjs/common';
 import { TimerSession } from '../../shared/entities/timer-session.entity';
 import { TimerSessionRepositoryPort } from './domain/timer-session-repository.port';
 import { NotificationPort } from './domain/notification.port';
+import { UserEventsPort } from '../events/domain/user-events.port';
 import { UpsertTimerSessionDto } from './dto/upsert-timer-session.dto';
 
+export const TIMER_UPDATED_EVENT = 'timer.updated';
+
 @Injectable()
 export class TimerSessionService {
   constructor(
     private readonly timerRepo: TimerSessionRepositoryPort,
     private readonly notification: NotificationPort,
+    private readonly events: UserEventsPort,
   ) {}
 
   async upsert(
@@ -36,7 +40,9 @@ export class TimerSessionService {
       });
     }
 
-    return this.timerRepo.save(session);
+    const saved = await this.timerRepo.save(session);
+    this.events.emit(userId, TIMER_UPDATED_EVENT);
+    return saved;
   }
 
   async getLatest(userId: number): Promise<TimerSession | null> {
@@ -55,6 +61,7 @@ export class TimerSessionService {
       `⏹ Таймер по задаче "${session.task?.title}" остановлен`,
     );
     await this.timerRepo.remove(session);
+    this.events.emit(userId, TIMER_UPDATED_EVENT);
   }
 
   async processExpiredTimers(): Promise<void> {
@@ -68,6 +75,7 @@ export class TimerSessionService {
         session.userId,
         `⏰ Таймер по задаче "${session.task?.title}" завершён!`,
       );
+      this.events.emit(session.userId, TIMER_UPDATED_EVENT);
     }
   }
 }