From fec8943fd0a187aebf07915a1e8b4aef3000f42d Mon Sep 17 00:00:00 2001
From: "i.seliverstov" <i.seliverstov@mtlab.space>
Date: Thu, 13 Aug 2026 13:41:12 +0500
Subject: [PATCH 1/2] feat(tasks): show remaining time and progress in the
 current-task widget
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The widget answered "what am I on" but not "for how long" — the thing you
actually open it for — so you still had to go to the calendar. Each row now
carries the remaining time, a progress bar, and the pomodoro count, with a
left accent bar echoing the calendar's current-time line.

The window maths moved into a private getWindow(), so the active-task filter
and the progress readout are built on one definition and cannot disagree.

Header is now "Идёт сейчас": the old "Текущая задача" was singular while the
list can hold several rows.

Rows carry a border rather than relying on bg-sidebar-accent/40 alone — in
light mode that fill sat within 1.7% of the sidebar background (0.968 vs 0.985
oklch) and the rows were effectively invisible. The play button keeps its 32px
visual size but expands to a 44px hit area via ::before, and the progress fill
honours prefers-reduced-motion.
---
 .../src/features/tasks/lib/active-tasks.ts    | 55 +++++++++++---
 .../src/features/tasks/lib/formatters.ts      | 12 +++
 .../features/tasks/ui/CurrentTaskWidget.vue   | 73 ++++++++++++++-----
 .../features/tasks/lib/active-tasks.spec.ts   | 45 +++++++++++-
 .../tasks/lib/format-remaining.spec.ts        | 20 +++++
 .../tasks/ui/CurrentTaskWidget.spec.ts        | 25 ++++++-
 6 files changed, 201 insertions(+), 29 deletions(-)
 create mode 100644 alfy-bot-frontend/tests/features/tasks/lib/format-remaining.spec.ts

diff --git a/alfy-bot-frontend/src/features/tasks/lib/active-tasks.ts b/alfy-bot-frontend/src/features/tasks/lib/active-tasks.ts
index 204ee40..6e0623b 100644
--- a/alfy-bot-frontend/src/features/tasks/lib/active-tasks.ts
+++ b/alfy-bot-frontend/src/features/tasks/lib/active-tasks.ts
@@ -1,6 +1,35 @@
 import type { Task } from '../model/types'
 import { computeTaskDurationMinutes } from './duration'
 
+export interface TaskProgress {
+  /** Share of the window already elapsed, clamped to 0..1. */
+  ratio: number
+  remainingMinutes: number
+}
+
+interface TaskWindow {
+  startMs: number
+  endMs: number
+}
+
+/**
+ * The task's scheduled window, or null when it has none.
+ *
+ * Single definition of "when does this task run" — both the active-task filter
+ * and the progress readout are built on it, so they can never disagree.
+ */
+function getWindow(task: Task): TaskWindow | null {
+  if (!task.dueDate) return null
+
+  const start = new Date(task.dueDate)
+  // A task pinned to exactly 00:00 is all-day, same rule the calendar uses
+  // in calendar-events.ts — it has no meaningful window.
+  if (start.getHours() === 0 && start.getMinutes() === 0) return null
+
+  const startMs = start.getTime()
+  return { startMs, endMs: startMs + computeTaskDurationMinutes(task) * 60_000 }
+}
+
 /**
  * Tasks whose scheduled window contains `now` — what the calendar's red line
  * crosses right now.
@@ -13,20 +42,28 @@ export function getActiveTasksAt(tasks: Task[], now: Date): Task[] {
 
   return tasks
     .filter((task) => {
-      if (!task.dueDate) return false
       if (task.completed) return false
       if (task.isOverdue) return false
 
-      const start = new Date(task.dueDate)
-      // A task pinned to exactly 00:00 is all-day, same rule the calendar uses
-      // in calendar-events.ts — it has no meaningful window.
-      if (start.getHours() === 0 && start.getMinutes() === 0) return false
-
-      const startMs = start.getTime()
-      const endMs = startMs + computeTaskDurationMinutes(task) * 60_000
+      const window = getWindow(task)
+      if (!window) return false
 
       // End is exclusive so two back-to-back tasks never show up together.
-      return startMs <= nowMs && nowMs < endMs
+      return window.startMs <= nowMs && nowMs < window.endMs
     })
     .sort((a, b) => new Date(a.dueDate!).getTime() - new Date(b.dueDate!).getTime())
 }
+
+/** How far into its window a task is, or null when it has no window. */
+export function getTaskProgressAt(task: Task, now: Date): TaskProgress | null {
+  const window = getWindow(task)
+  if (!window) return null
+
+  const total = window.endMs - window.startMs
+  const elapsed = now.getTime() - window.startMs
+
+  return {
+    ratio: total > 0 ? Math.min(1, Math.max(0, elapsed / total)) : 0,
+    remainingMinutes: Math.max(0, Math.ceil((window.endMs - now.getTime()) / 60_000)),
+  }
+}
diff --git a/alfy-bot-frontend/src/features/tasks/lib/formatters.ts b/alfy-bot-frontend/src/features/tasks/lib/formatters.ts
index 3dcd190..34bd7c9 100644
--- a/alfy-bot-frontend/src/features/tasks/lib/formatters.ts
+++ b/alfy-bot-frontend/src/features/tasks/lib/formatters.ts
@@ -22,6 +22,18 @@ export function formatDueDate(value: unknown, opts?: { includeYear?: boolean }):
   return formatDate(date, hasTime ? DATE_WITH_TIME : DATE_SHORT)
 }
 
+/** Compact "сколько осталось" for the sidebar: «45 мин», «3 ч 12 мин», «2 ч». */
+export function formatRemaining(minutes: number): string {
+  if (minutes < 1) return 'меньше минуты'
+
+  const hours = Math.floor(minutes / 60)
+  const rest = minutes % 60
+
+  if (hours === 0) return `${rest} мин`
+  if (rest === 0) return `${hours} ч`
+  return `${hours} ч ${rest} мин`
+}
+
 export const formatPomodoro = (value: number): string => {
   const rounded = Math.round(value * 100) / 100
   return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1)
diff --git a/alfy-bot-frontend/src/features/tasks/ui/CurrentTaskWidget.vue b/alfy-bot-frontend/src/features/tasks/ui/CurrentTaskWidget.vue
index cac12bc..fc30fc4 100644
--- a/alfy-bot-frontend/src/features/tasks/ui/CurrentTaskWidget.vue
+++ b/alfy-bot-frontend/src/features/tasks/ui/CurrentTaskWidget.vue
@@ -5,38 +5,75 @@ import { Play } from 'lucide-vue-next'
 import { Button } from '@/components/ui/button'
 import { useNow } from '@/composables/useNow'
 import { toTimerTask, useTimerStore } from '@/features/task-timer'
-import { getActiveTasksAt } from '../lib/active-tasks'
+import { getActiveTasksAt, getTaskProgressAt, type TaskProgress } from '../lib/active-tasks'
+import { formatPomodoro, formatRemaining } from '../lib/formatters'
+import type { Task } from '../model/types'
 import { useTaskStore } from '../model/task-store'
 
+interface ActiveRow {
+  task: Task
+  progress: TaskProgress
+}
+
 const { tasks } = storeToRefs(useTaskStore())
 const timerStore = useTimerStore()
 const now = useNow()
 
-const activeTasks = computed(() => getActiveTasksAt(tasks.value, now.value))
+const rows = computed<ActiveRow[]>(() =>
+  getActiveTasksAt(tasks.value, now.value)
+    .map(task => ({ task, progress: getTaskProgressAt(task, now.value) }))
+    .filter((row): row is ActiveRow => row.progress !== null),
+)
+
+function pomodoroLabel(task: Task): string | null {
+  if (!task.isPomodoroTask) return null
+  return `${formatPomodoro(task.pomodoroCompleted || 0)}/${task.pomodoroCount || 0}`
+}
 </script>
 
 <template>
-  <div v-if="activeTasks.length" class="px-4 mt-4">
+  <div v-if="rows.length" class="px-4 mt-4">
     <span class="text-[11px] font-medium text-sidebar-foreground/60 uppercase tracking-wide">
-      Текущая задача
+      Идёт сейчас
     </span>
-    <div class="flex flex-col gap-0.5 mt-1">
+
+    <div class="flex flex-col gap-2 mt-1.5">
       <div
-        v-for="task in activeTasks"
+        v-for="{ task, progress } in rows"
         :key="task.id"
-        class="flex items-center gap-2 px-3 py-2 rounded-md text-sm font-medium bg-sidebar-accent/40"
+        class="relative overflow-hidden rounded-md border border-sidebar-border bg-sidebar-accent/60 pl-3 pr-2 py-2 transition-colors duration-200 hover:bg-sidebar-accent"
       >
-        <span class="truncate flex-1">{{ task.title }}</span>
-        <Button
-          v-if="task.isPomodoroTask"
-          variant="ghost"
-          size="icon-sm"
-          class="shrink-0"
-          :aria-label="`Запустить помодоро: ${task.title}`"
-          @click="timerStore.startTask(toTimerTask(task))"
-        >
-          <Play :size="14" class="text-red-500" />
-        </Button>
+        <!-- Живая полоса слева: эхо линии текущего времени в календаре -->
+        <span class="absolute left-0 inset-y-0 w-[3px] bg-primary" aria-hidden="true" />
+
+        <div class="flex items-center gap-1">
+          <span class="truncate flex-1 text-sm font-medium leading-tight">{{ task.title }}</span>
+          <Button
+            v-if="task.isPomodoroTask"
+            variant="ghost"
+            size="icon-sm"
+            class="relative shrink-0 text-red-500 hover:text-red-500 hover:bg-red-500/10 cursor-pointer before:absolute before:-inset-1.5 before:content-['']"
+            :aria-label="`Запустить помодоро: ${task.title}`"
+            @click="timerStore.startTask(toTimerTask(task))"
+          >
+            <Play :size="14" />
+          </Button>
+        </div>
+
+        <div class="mt-0.5 text-[11px] text-sidebar-foreground/60 tabular-nums">
+          осталось {{ formatRemaining(progress.remainingMinutes) }}
+          <template v-if="pomodoroLabel(task)">
+            · {{ pomodoroLabel(task) }}
+          </template>
+        </div>
+
+        <!-- Прогресс дублирует текст выше, поэтому скрыт от скринридеров -->
+        <div class="mt-1.5 h-[3px] rounded-full bg-sidebar-foreground/15" aria-hidden="true">
+          <div
+            class="h-full rounded-full bg-primary transition-[width] duration-500 ease-linear motion-reduce:transition-none"
+            :style="{ width: `${Math.round(progress.ratio * 100)}%` }"
+          />
+        </div>
       </div>
     </div>
   </div>
diff --git a/alfy-bot-frontend/tests/features/tasks/lib/active-tasks.spec.ts b/alfy-bot-frontend/tests/features/tasks/lib/active-tasks.spec.ts
index f298232..e3c29fb 100644
--- a/alfy-bot-frontend/tests/features/tasks/lib/active-tasks.spec.ts
+++ b/alfy-bot-frontend/tests/features/tasks/lib/active-tasks.spec.ts
@@ -1,6 +1,6 @@
 import type { Task } from '@/features/tasks/model/types'
 import { describe, expect, it } from 'vitest'
-import { getActiveTasksAt } from '@/features/tasks/lib/active-tasks'
+import { getActiveTasksAt, getTaskProgressAt } from '@/features/tasks/lib/active-tasks'
 
 function makeTask(overrides: Partial<Task> = {}): Task {
   return {
@@ -87,3 +87,46 @@ describe('getActiveTasksAt', () => {
     expect(result.map(t => t.id)).toEqual(['long', 'short'])
   })
 })
+
+describe('getTaskProgressAt', () => {
+  it('на середине окна даёт ratio 0.5 и половину остатка', () => {
+    const task = plain('2026-08-13T12:00:00', 60)
+    expect(getTaskProgressAt(task, at('2026-08-13T12:30:00'))).toEqual({
+      ratio: 0.5,
+      remainingMinutes: 30,
+    })
+  })
+
+  it('в момент старта ratio 0, остаток равен всей длительности', () => {
+    const task = plain('2026-08-13T12:00:00', 60)
+    expect(getTaskProgressAt(task, at('2026-08-13T12:00:00'))).toEqual({
+      ratio: 0,
+      remainingMinutes: 60,
+    })
+  })
+
+  it('за пределами окна ratio зажимается в 0..1, остаток не уходит в минус', () => {
+    const task = plain('2026-08-13T12:00:00', 60)
+    expect(getTaskProgressAt(task, at('2026-08-13T14:00:00'))).toEqual({
+      ratio: 1,
+      remainingMinutes: 0,
+    })
+    expect(getTaskProgressAt(task, at('2026-08-13T11:00:00'))?.ratio).toBe(0)
+  })
+
+  it('учитывает перерывы помидоро: на 12:02 из окна 11:35–12:30 остаётся 28 минут', () => {
+    const task = makeTask({
+      dueDate: new Date('2026-08-13T11:35:00'),
+      isPomodoroTask: true,
+      pomodoroCount: 2,
+      pomodoroDuration: 25,
+      shortBreak: 5,
+    })
+    expect(getTaskProgressAt(task, at('2026-08-13T12:02:00'))?.remainingMinutes).toBe(28)
+  })
+
+  it('задача без окна даёт null', () => {
+    expect(getTaskProgressAt(makeTask(), at('2026-08-13T12:00:00'))).toBeNull()
+    expect(getTaskProgressAt(plain('2026-08-13T00:00:00', 60), at('2026-08-13T00:30:00'))).toBeNull()
+  })
+})
diff --git a/alfy-bot-frontend/tests/features/tasks/lib/format-remaining.spec.ts b/alfy-bot-frontend/tests/features/tasks/lib/format-remaining.spec.ts
new file mode 100644
index 0000000..f6a9867
--- /dev/null
+++ b/alfy-bot-frontend/tests/features/tasks/lib/format-remaining.spec.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+import { formatRemaining } from '@/features/tasks/lib/formatters'
+
+describe('formatRemaining', () => {
+  it('меньше часа — только минуты', () => {
+    expect(formatRemaining(45)).toBe('45 мин')
+  })
+
+  it('ровные часы — без минут', () => {
+    expect(formatRemaining(120)).toBe('2 ч')
+  })
+
+  it('часы с минутами', () => {
+    expect(formatRemaining(192)).toBe('3 ч 12 мин')
+  })
+
+  it('меньше минуты не показывает ноль', () => {
+    expect(formatRemaining(0)).toBe('меньше минуты')
+  })
+})
diff --git a/alfy-bot-frontend/tests/features/tasks/ui/CurrentTaskWidget.spec.ts b/alfy-bot-frontend/tests/features/tasks/ui/CurrentTaskWidget.spec.ts
index 3378023..f801bcd 100644
--- a/alfy-bot-frontend/tests/features/tasks/ui/CurrentTaskWidget.spec.ts
+++ b/alfy-bot-frontend/tests/features/tasks/ui/CurrentTaskWidget.spec.ts
@@ -56,11 +56,34 @@ describe('currentTaskWidget', () => {
   it('показывает название активной помидоро-задачи и кнопку запуска', () => {
     const wrapper = mountWith([activeTask()])
 
-    expect(wrapper.text()).toContain('Текущая задача')
+    expect(wrapper.text()).toContain('Идёт сейчас')
     expect(wrapper.text()).toContain('Математика')
     expect(wrapper.find('button').exists()).toBe(true)
   })
 
+  it('показывает остаток времени и счётчик помидоров', () => {
+    // Окно 2x25+5 = 55 мин, прошло 10 → осталось 45.
+    const wrapper = mountWith([activeTask({ pomodoroCompleted: 1 })])
+
+    expect(wrapper.text()).toContain('осталось 45 мин')
+    expect(wrapper.text()).toContain('1/2')
+  })
+
+  it('у не-помидоро задачи остаток есть, счётчика помидоров нет', () => {
+    const wrapper = mountWith([activeTask({ isPomodoroTask: false, durationMinutes: 60 })])
+
+    expect(wrapper.text()).toContain('осталось 50 мин')
+    expect(wrapper.text()).not.toContain('/')
+  })
+
+  it('прогресс-бар отражает долю пройденного окна', () => {
+    // 10 из 55 минут ≈ 18%
+    const wrapper = mountWith([activeTask()])
+    const fill = wrapper.find('[aria-hidden="true"] > div')
+
+    expect(fill.attributes('style')).toContain('width: 18%')
+  })
+
   it('не показывает кнопку у не-помидоро задачи', () => {
     const wrapper = mountWith([activeTask({ isPomodoroTask: false, durationMinutes: 60 })])
 

From e2cc705a0a5522574ee5b0af988112ef395c3752 Mon Sep 17 00:00:00 2001
From: "i.seliverstov" <i.seliverstov@mtlab.space>
Date: Thu, 13 Aug 2026 15:14:23 +0500
Subject: [PATCH 2/2] feat(tasks): show when a pomodoro is already running on a
 row
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The row now says whether the timer is on this task — a red pulsing "идёт"
while it ticks, a muted "пауза" while it is armed but stopped.

This is not only a label: the play button is removed in the running state
because startTask() rewinds to the first phase, so a stray click on a live
task would discard the pomodoros already worked.

The paused state keeps a button, which resumes via toggleTimer instead of
restarting. That matters because startTask only *arms* a session — ticking
starts separately — so a row lands in `paused` immediately after the widget's
own play click. Dropping the button there would have made the widget unable to
start a timer at all.

timer-store now exposes activeTaskId; without it a row cannot tell "running"
from "running on something else".
---
 .../src/features/task-timer/lib/index.ts      |  1 +
 .../task-timer/lib/task-timer-state.ts        | 22 ++++++++
 .../features/task-timer/model/timer-store.ts  |  4 ++
 .../features/tasks/ui/CurrentTaskWidget.vue   | 48 ++++++++++++++---
 .../task-timer/task-timer-state.spec.ts       | 26 ++++++++++
 .../tasks/ui/CurrentTaskWidget.spec.ts        | 52 ++++++++++++++++++-
 docs/tasks/sidebar-current-task-widget.md     | 15 +++++-
 7 files changed, 159 insertions(+), 9 deletions(-)
 create mode 100644 alfy-bot-frontend/src/features/task-timer/lib/task-timer-state.ts
 create mode 100644 alfy-bot-frontend/tests/features/task-timer/task-timer-state.spec.ts

diff --git a/alfy-bot-frontend/src/features/task-timer/lib/index.ts b/alfy-bot-frontend/src/features/task-timer/lib/index.ts
index 772aca7..b853f77 100644
--- a/alfy-bot-frontend/src/features/task-timer/lib/index.ts
+++ b/alfy-bot-frontend/src/features/task-timer/lib/index.ts
@@ -1 +1,2 @@
+export * from './task-timer-state'
 export * from './to-timer-task'
diff --git a/alfy-bot-frontend/src/features/task-timer/lib/task-timer-state.ts b/alfy-bot-frontend/src/features/task-timer/lib/task-timer-state.ts
new file mode 100644
index 0000000..8a685e0
--- /dev/null
+++ b/alfy-bot-frontend/src/features/task-timer/lib/task-timer-state.ts
@@ -0,0 +1,22 @@
+export type TaskTimerState = 'idle' | 'running' | 'paused'
+
+export interface TimerSnapshot {
+  /** Task the current session belongs to, null when no task is selected. */
+  activeTaskId: string | null
+  /** 0 means no session is armed. */
+  phase: number
+  /** Whether the session is ticking rather than paused. */
+  isActive: boolean
+}
+
+/**
+ * What the pomodoro timer is doing for one particular task.
+ *
+ * `idle` covers both "nothing runs" and "something else runs" — from the row's
+ * point of view those are the same: starting here would take the timer over.
+ */
+export function getTaskTimerState(taskId: string, timer: TimerSnapshot): TaskTimerState {
+  if (timer.activeTaskId !== taskId) return 'idle'
+  if (timer.phase === 0) return 'idle'
+  return timer.isActive ? 'running' : 'paused'
+}
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..420d1d0 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
@@ -396,8 +396,12 @@ export const useTimerStore = defineStore('timer', () => {
 
   const isBreakPhase = computed(() => checkPhase.isBreakPhase(phase.value))
 
+  /** Which task the session belongs to — lets callers tell "running" from "running on something else". */
+  const activeTaskId = computed(() => currentSettings.value.taskId)
+
   return {
     isActive,
+    activeTaskId,
     phase,
     timeBlock,
     namePhase,
diff --git a/alfy-bot-frontend/src/features/tasks/ui/CurrentTaskWidget.vue b/alfy-bot-frontend/src/features/tasks/ui/CurrentTaskWidget.vue
index fc30fc4..a113877 100644
--- a/alfy-bot-frontend/src/features/tasks/ui/CurrentTaskWidget.vue
+++ b/alfy-bot-frontend/src/features/tasks/ui/CurrentTaskWidget.vue
@@ -4,7 +4,7 @@ import { computed } from 'vue'
 import { Play } from 'lucide-vue-next'
 import { Button } from '@/components/ui/button'
 import { useNow } from '@/composables/useNow'
-import { toTimerTask, useTimerStore } from '@/features/task-timer'
+import { getTaskTimerState, toTimerTask, useTimerStore, type TaskTimerState } from '@/features/task-timer'
 import { getActiveTasksAt, getTaskProgressAt, type TaskProgress } from '../lib/active-tasks'
 import { formatPomodoro, formatRemaining } from '../lib/formatters'
 import type { Task } from '../model/types'
@@ -13,15 +13,25 @@ import { useTaskStore } from '../model/task-store'
 interface ActiveRow {
   task: Task
   progress: TaskProgress
+  timerState: TaskTimerState
 }
 
 const { tasks } = storeToRefs(useTaskStore())
 const timerStore = useTimerStore()
+const { activeTaskId, phase, isActive } = storeToRefs(timerStore)
 const now = useNow()
 
 const rows = computed<ActiveRow[]>(() =>
   getActiveTasksAt(tasks.value, now.value)
-    .map(task => ({ task, progress: getTaskProgressAt(task, now.value) }))
+    .map(task => ({
+      task,
+      progress: getTaskProgressAt(task, now.value),
+      timerState: getTaskTimerState(task.id, {
+        activeTaskId: activeTaskId.value,
+        phase: phase.value,
+        isActive: isActive.value,
+      }),
+    }))
     .filter((row): row is ActiveRow => row.progress !== null),
 )
 
@@ -29,6 +39,18 @@ function pomodoroLabel(task: Task): string | null {
   if (!task.isPomodoroTask) return null
   return `${formatPomodoro(task.pomodoroCompleted || 0)}/${task.pomodoroCount || 0}`
 }
+
+/**
+ * Paused sessions resume; idle ones start fresh. startTask() rewinds to the
+ * first phase, so calling it on a live session would discard finished pomodoros.
+ */
+function handlePlay(row: ActiveRow): void {
+  if (row.timerState === 'paused') {
+    timerStore.toggleTimer()
+    return
+  }
+  timerStore.startTask(toTimerTask(row.task))
+}
 </script>
 
 <template>
@@ -39,7 +61,7 @@ function pomodoroLabel(task: Task): string | null {
 
     <div class="flex flex-col gap-2 mt-1.5">
       <div
-        v-for="{ task, progress } in rows"
+        v-for="{ task, progress, timerState } in rows"
         :key="task.id"
         class="relative overflow-hidden rounded-md border border-sidebar-border bg-sidebar-accent/60 pl-3 pr-2 py-2 transition-colors duration-200 hover:bg-sidebar-accent"
       >
@@ -48,13 +70,27 @@ function pomodoroLabel(task: Task): string | null {
 
         <div class="flex items-center gap-1">
           <span class="truncate flex-1 text-sm font-medium leading-tight">{{ task.title }}</span>
+
+          <span
+            v-if="timerState !== 'idle'"
+            class="shrink-0 flex items-center gap-1 text-[11px]"
+            :class="timerState === 'running' ? 'text-red-500' : 'text-sidebar-foreground/50'"
+          >
+            <span
+              class="size-1.5 rounded-full bg-current"
+              :class="timerState === 'running' && 'animate-pulse motion-reduce:animate-none'"
+            />
+            {{ timerState === 'running' ? 'идёт' : 'пауза' }}
+          </span>
+
+          <!-- Пока сессия тикает, кнопки нет: перезапуск стёр бы отработанные помидоры -->
           <Button
-            v-if="task.isPomodoroTask"
+            v-if="task.isPomodoroTask && timerState !== 'running'"
             variant="ghost"
             size="icon-sm"
             class="relative shrink-0 text-red-500 hover:text-red-500 hover:bg-red-500/10 cursor-pointer before:absolute before:-inset-1.5 before:content-['']"
-            :aria-label="`Запустить помодоро: ${task.title}`"
-            @click="timerStore.startTask(toTimerTask(task))"
+            :aria-label="`${timerState === 'paused' ? 'Продолжить' : 'Запустить'} помодоро: ${task.title}`"
+            @click="handlePlay({ task, progress, timerState })"
           >
             <Play :size="14" />
           </Button>
diff --git a/alfy-bot-frontend/tests/features/task-timer/task-timer-state.spec.ts b/alfy-bot-frontend/tests/features/task-timer/task-timer-state.spec.ts
new file mode 100644
index 0000000..ef6d90a
--- /dev/null
+++ b/alfy-bot-frontend/tests/features/task-timer/task-timer-state.spec.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest'
+import { getTaskTimerState } from '@/features/task-timer/lib/task-timer-state'
+
+const ticking = { activeTaskId: 'task-1', phase: 1, isActive: true }
+
+describe('getTaskTimerState', () => {
+  it('таймер тикает по этой задаче → running', () => {
+    expect(getTaskTimerState('task-1', ticking)).toBe('running')
+  })
+
+  it('сессия есть, но не тикает → paused', () => {
+    expect(getTaskTimerState('task-1', { ...ticking, isActive: false })).toBe('paused')
+  })
+
+  it('таймер идёт по другой задаче → idle', () => {
+    expect(getTaskTimerState('task-2', ticking)).toBe('idle')
+  })
+
+  it('задача не выбрана → idle', () => {
+    expect(getTaskTimerState('task-1', { ...ticking, activeTaskId: null })).toBe('idle')
+  })
+
+  it('сессия не заведена (phase 0) → idle, даже если id совпал', () => {
+    expect(getTaskTimerState('task-1', { ...ticking, phase: 0 })).toBe('idle')
+  })
+})
diff --git a/alfy-bot-frontend/tests/features/tasks/ui/CurrentTaskWidget.spec.ts b/alfy-bot-frontend/tests/features/tasks/ui/CurrentTaskWidget.spec.ts
index f801bcd..808cbe1 100644
--- a/alfy-bot-frontend/tests/features/tasks/ui/CurrentTaskWidget.spec.ts
+++ b/alfy-bot-frontend/tests/features/tasks/ui/CurrentTaskWidget.spec.ts
@@ -4,7 +4,7 @@ import { createPinia, setActivePinia } from 'pinia'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import CurrentTaskWidget from '@/features/tasks/ui/CurrentTaskWidget.vue'
 import { useTaskStore } from '@/features/tasks/model/task-store'
-import { useTimerStore } from '@/features/task-timer'
+import { toTimerTask, useTimerStore } from '@/features/task-timer'
 
 vi.mock('@/api/client', () => ({
   api: { get: vi.fn(), post: vi.fn(), patch: vi.fn(), delete: vi.fn(), put: vi.fn() },
@@ -112,6 +112,56 @@ describe('currentTaskWidget', () => {
     expect(wrapper.text()).not.toContain('Математика')
   })
 
+  it('тикающая сессия по этой задаче — метка вместо кнопки', async () => {
+    const wrapper = mountWith([activeTask()])
+    const timer = useTimerStore()
+    timer.startTask(toTimerTask(activeTask()))
+    timer.isActive = true
+    await wrapper.vm.$nextTick()
+
+    expect(wrapper.text()).toContain('идёт')
+    // Кнопки нет намеренно: startTask отмотал бы сессию к первой фазе.
+    expect(wrapper.find('button').exists()).toBe(false)
+  })
+
+  // startTask только взводит сессию, тикать она начинает отдельно — поэтому
+  // сразу после клика строка оказывается именно в этом состоянии.
+  it('взведённая, но не тикающая сессия показывается как пауза и сохраняет кнопку', async () => {
+    const wrapper = mountWith([activeTask()])
+    const timer = useTimerStore()
+    timer.startTask(toTimerTask(activeTask()))
+    await wrapper.vm.$nextTick()
+
+    expect(wrapper.text()).toContain('пауза')
+    expect(wrapper.text()).not.toContain('идёт')
+    expect(wrapper.find('button').attributes('aria-label')).toContain('Продолжить')
+  })
+
+  it('кнопка на паузе продолжает сессию, а не начинает заново', async () => {
+    const wrapper = mountWith([activeTask()])
+    const timer = useTimerStore()
+    timer.startTask(toTimerTask(activeTask()))
+    await wrapper.vm.$nextTick()
+
+    const resume = vi.spyOn(timer, 'toggleTimer').mockImplementation(() => {})
+    const restart = vi.spyOn(timer, 'startTask').mockImplementation(() => {})
+    await wrapper.find('button').trigger('click')
+
+    expect(resume).toHaveBeenCalled()
+    expect(restart).not.toHaveBeenCalled()
+  })
+
+  it('таймер по другой задаче кнопку не убирает', async () => {
+    const wrapper = mountWith([activeTask()])
+    const timer = useTimerStore()
+    timer.startTask(toTimerTask(activeTask({ id: 'другая' })))
+    timer.isActive = true
+    await wrapper.vm.$nextTick()
+
+    expect(wrapper.text()).not.toContain('идёт')
+    expect(wrapper.find('button').attributes('aria-label')).toContain('Запустить')
+  })
+
   it('показывает все активные задачи, когда их несколько', () => {
     const wrapper = mountWith([
       activeTask(),
diff --git a/docs/tasks/sidebar-current-task-widget.md b/docs/tasks/sidebar-current-task-widget.md
index d760b0e..408b7c3 100644
--- a/docs/tasks/sidebar-current-task-widget.md
+++ b/docs/tasks/sidebar-current-task-widget.md
@@ -43,7 +43,7 @@
 - **Не-помидорные показываем без кнопки.** Виджет отвечает на «чем я занят», а не «что можно запустить»; кнопка — бонус там, где она осмысленна.
 - **Пустой список прячет виджет целиком.** Бо́льшую часть суток активных задач нет, и постоянный пустой блок занимал бы место зря.
 - **Только реальные задачи из стора, без `tasksToCalendarEvents`.** Виртуальный инстанс повторяющейся задачи имеет id `id__virtual__ts`, которого нет на бэке: первый же инкремент помидора упал бы с 404. Отсечение на уровне источника данных надёжнее, чем флаг `isVirtual`, который надо не забыть проверить.
-- **Кнопка перебивает идущий таймер.** Ровно так уже работают кнопки в списке задач и в карточке — нового поведения не вводим, `currentSettings` из стора выставлять не нужно.
+- **Кнопка перебивает таймер, идущий по ДРУГОЙ задаче.** Ровно так уже работают кнопки в списке задач и в карточке. Для своей же задачи поведение позже пересмотрено — см. «Состояние таймера в строке» ниже.
 - **Виджет над списком проектов.** Заметнее, и длинный список проектов не выталкивает его за экран.
 - **`toTimerTask` выносится, оба существующих места переводятся.** Иначе виджет становится третьей копией маппинга. Значения инлайновых дефолтов совпадают с `POMODORO_DEFAULTS`.
 
@@ -68,7 +68,8 @@ TDD: yes (`getActiveTasksAt` и `toTimerTask` — чистые функции с
 - Виджет читает исключительно `taskStore.tasks`. `tasksToCalendarEvents` не используется, id с `__virtual__` в виджет не попадают ни при каких данных.
 - Задача попадает в виджет только при `start <= now < end`; граница `end` исключающая, чтобы смежные задачи не показывались одновременно.
 - Из выборки исключены: без `dueDate`, all-day (время ровно `00:00`), `completed`, `isOverdue`.
-- Кнопка запуска рендерится только при `isPomodoroTask`.
+- Кнопка запуска рендерится только при `isPomodoroTask` и только когда сессия по этой задаче не тикает.
+- `startTask` никогда не вызывается для задачи, по которой уже идёт сессия: он отматывает её к первой фазе и стёр бы отработанные помидоры. Взведённая, но не тикающая сессия продолжается через `toggleTimer`.
 - Пустой список — в DOM нет ни заголовка, ни контейнера виджета.
 - Во всём фронтенде ровно один маппинг задачи в аргумент `startTask` — `toTimerTask`.
 - `toTimerTask` сохраняет `||`-семантику дефолтов, существовавшую в обоих исходных местах.
@@ -232,6 +233,16 @@ Invariants:
 Review findings:
 - Important: реактивность по тику `useNow` — суть фичи — не была покрыта ни одним тестом (юниты фиксировали часы и не прокручивали их, в браузере минуту не ждали). Поведение проверено и работает; добавлен постоянный тест «убирает задачу, когда её окно истекает по тику часов» с `advanceTimersByTimeAsync`.
 
+### Состояние таймера в строке (доработка после ревью)
+
+По просьбе пользователя строка показывает, что помодоро уже запущен. Три состояния считает чистая `getTaskTimerState(taskId, snapshot)` в `features/task-timer/lib/`; `timer-store` для этого начал отдавать `activeTaskId` (раньше `currentSettings` наружу не выставлялся).
+
+- `running` — красная пульсирующая метка «идёт», кнопки нет.
+- `paused` — приглушённая метка «пауза», кнопка остаётся и **продолжает** сессию через `toggleTimer`.
+- `idle` (в том числе когда таймер идёт по другой задаче) — обычная кнопка запуска.
+
+Кнопка убрана именно в `running`, потому что `startTask` начинает сессию с первой фазы: случайный клик по идущей задаче стирал бы уже отработанные помидоры. Это же вскрылось при реализации: `startTask` только **взводит** сессию, тикать она начинает отдельно, поэтому сразу после клика строка попадает в `paused` — если бы кнопка там пропадала, запустить таймер из виджета стало бы нельзя.
+
 Future work:
 - `computeTaskDurationMinutes` берёт дефолты через `??`, а `toTimerTask` — через `||`. Для задачи с `pomodoroCount: 0` это расходится: окно выйдет нулевым и в виджет она не попадёт никогда, хотя таймер по ней запустился бы на 4 помидора. Justification: `duration.ts` пре-существует и задачей не затрагивался; на достижимых путях расхождение не проявляется, потому что до кнопки такая задача не доходит.
 - `HourGrid.vue` продолжает держать собственный `setInterval(60_000)` вместо `useNow`. Justification: инвариант задачи — `features/calendar/**` не изменяется.