diff --git a/.env.example b/.env.example
index aa0c465..79a9a98 100644
--- a/.env.example
+++ b/.env.example
@@ -12,7 +12,7 @@
 
 # Ollama (M2)
 OLLAMA_BASE_URL=http://localhost:11434
-OLLAMA_MODEL=qwen2.5:3b
+OLLAMA_MODEL=qwen3.5:2b-q4_K_M
 
 # MCP-сервер (M5): bearer-токен для ИИ-агентов; пусто — /mcp закрыт
 MCP_TOKEN=change-me-mcp-token
diff --git a/backend/alembic/versions/a5b6c7d8e9f0_project_archive.py b/backend/alembic/versions/a5b6c7d8e9f0_project_archive.py
new file mode 100644
index 0000000..a2436bb
--- /dev/null
+++ b/backend/alembic/versions/a5b6c7d8e9f0_project_archive.py
@@ -0,0 +1,36 @@
+"""Архив проектов (ТЗ 3.11): поле is_archived.
+
+«Закрыт» (relevance_status='archived') уходит: такие проекты переезжают
+в архив (is_archived=True, relevance_status='active') — история сохраняется,
+из рабочих видов пропадают.
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "a5b6c7d8e9f0"
+down_revision: str | Sequence[str] | None = "b3c4d5e6f7a8"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "projects",
+        sa.Column("is_archived", sa.Boolean(), nullable=False, server_default=sa.false()),
+    )
+    op.execute(
+        "UPDATE projects SET is_archived = true, relevance_status = 'active'"
+        " WHERE relevance_status = 'archived'"
+    )
+
+
+def downgrade() -> None:
+    op.execute(
+        "UPDATE projects SET relevance_status = 'archived' WHERE is_archived = true"
+    )
+    op.drop_column("projects", "is_archived")
diff --git a/backend/alembic/versions/b3c4d5e6f7a8_xp_events_kind.py b/backend/alembic/versions/b3c4d5e6f7a8_xp_events_kind.py
new file mode 100644
index 0000000..a0b8f69
--- /dev/null
+++ b/backend/alembic/versions/b3c4d5e6f7a8_xp_events_kind.py
@@ -0,0 +1,28 @@
+"""Награды за создание (ТЗ 3.13): поле kind в xp_events.
+
+kind='task' — закрытие задачи (растение в саду); kind='create_task' /
+'create_project' — микронаграда за создание, растения не даёт.
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "b3c4d5e6f7a8"
+down_revision: str | Sequence[str] | None = "f2a3b4c5d6e7"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "xp_events",
+        sa.Column("kind", sa.String(length=20), nullable=False, server_default="task"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("xp_events", "kind")
diff --git a/backend/app/api/events.py b/backend/app/api/events.py
new file mode 100644
index 0000000..574c606
--- /dev/null
+++ b/backend/app/api/events.py
@@ -0,0 +1,60 @@
+"""SSE-эндпоинт (ТЗ 3.14): поток событий для SPA.
+
+EventSource фронтенда держит соединение открытым; сервер шлёт события шины
+и ping каждые PING_SECONDS секунд (keep-alive, чтобы прокси не рвал поток).
+"""
+
+import asyncio
+import json
+from collections.abc import AsyncIterator
+from typing import Any
+
+from fastapi import APIRouter
+from starlette.requests import Request
+from starlette.responses import StreamingResponse
+
+from app.dependencies import UserDep
+from app.realtime import Event, bus
+
+router = APIRouter(prefix="/api/events", tags=["events"])
+
+# keep-alive: прокси (Vite dev, nginx) закрывают «тихие» соединения
+PING_SECONDS = 20.0
+
+
+def _sse_json(kind: str, data: dict[str, Any] | None = None) -> str:
+    payload: dict[str, Any] = {"kind": kind}
+    if data:
+        payload["data"] = data
+    return json.dumps(payload, ensure_ascii=False)
+
+
+async def _event_source(request: Request, user_id: str) -> AsyncIterator[str]:
+    queue = bus.subscribe(user_id)
+    try:
+        yield f"data: {_sse_json('ready')}\n\n"
+        while True:
+            if await request.is_disconnected():
+                return
+            try:
+                event: Event = await asyncio.wait_for(queue.get(), timeout=PING_SECONDS)
+                payload = _sse_json(event.kind, event.data)
+            except TimeoutError:
+                payload = _sse_json("ping")
+            yield f"data: {payload}\n\n"
+    finally:
+        bus.unsubscribe(user_id, queue)
+
+
+@router.get("")
+async def events(request: Request, user: UserDep) -> StreamingResponse:
+    """SSE-поток: события изменений + ping (keep-alive)."""
+    return StreamingResponse(
+        _event_source(request, str(user["user_id"])),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            # nginx в проде не буферизует стрим
+            "X-Accel-Buffering": "no",
+        },
+    )
diff --git a/backend/app/api/garden.py b/backend/app/api/garden.py
index 74c4c43..2b0bc12 100644
--- a/backend/app/api/garden.py
+++ b/backend/app/api/garden.py
@@ -8,6 +8,7 @@
 
 from app.dependencies import DbDep, UserDep
 from app.models import GardenItem, Task, XpEvent
+from app.realtime import publish
 from app.services import garden
 from app.services.garden import (
     DECORATIONS,
@@ -18,6 +19,7 @@
     ensure_garden,
     grid_size,
     house_footprint,
+    make_seed_plant,
     next_expansion,
     species_catalog,
 )
@@ -97,6 +99,10 @@
             for key, spec in DECORATIONS.items()
         ],
         "next_expansion": expansion,
+        # весь список расширений — для дерева уровней (что открывается на уровне)
+        "expansions": [
+            {"key": key, **spec} for key, spec in sorted(EXPANSIONS.items())
+        ],
         "expansions_bought": garden.expansions_bought(db),
         "species": species_catalog(level),
         "upgrade_costs": UPGRADE_COSTS,
@@ -119,7 +125,8 @@
         if item.kind != "decoration":
             raise HTTPException(status_code=400, detail="Plants cannot be stored")
         item.x, item.y = None, None
-        db.flush()
+        db.commit()
+        publish(str(user["user_id"]), "garden.changed", {"reason": "move"})
         return {"ok": True}
     size = grid_size(db)
     if not (0 <= move.x < size["cols"] and 0 <= move.y < size["rows"]):
@@ -129,7 +136,8 @@
     ):
         raise HTTPException(status_code=400, detail="Cannot place on the house")
     item.x, item.y = move.x, move.y
-    db.flush()
+    db.commit()
+    publish(str(user["user_id"]), "garden.changed", {"reason": "move"})
     return {"ok": True}
 
 
@@ -149,7 +157,8 @@
         )
     garden.spend(db, cost, f"upgrade:{item.item_key}")
     item.stage += 1
-    db.flush()
+    db.commit()
+    publish(str(user["user_id"]), "garden.changed", {"reason": "upgrade"})
     return {"ok": True, "stage": item.stage, "cost": cost, "balance": balance(db)}
 
 
@@ -158,6 +167,29 @@
     item_key = buy.item_key
     level = level_from_xp(total_xp(db))
 
+    # Семя растения: вид из каталога, открытие по уровню, посадка сразу
+    if item_key.startswith("seed:"):
+        species = item_key.removeprefix("seed:")
+        spec = next((s for s in species_catalog(level) if s["key"] == species), None)
+        if spec is None:
+            raise HTTPException(status_code=400, detail=f"Unknown species: {species}")
+        if level < spec["level"]:
+            raise HTTPException(status_code=403, detail=f"Unlocks at level {spec['level']}")
+        if not garden.can_afford(db, spec["seed_cost"]):
+            raise HTTPException(
+                status_code=402, detail=f"Not enough coins: need {spec['seed_cost']}"
+            )
+        garden.spend(db, spec["seed_cost"], item_key)
+        item = make_seed_plant(db, species)
+        db.flush()
+        db.commit()
+        publish(str(user["user_id"]), "garden.changed", {"reason": "seed"})
+        return {
+            "ok": True,
+            "item": {"id": item.id, "item_key": item.item_key, "x": item.x, "y": item.y},
+            "balance": balance(db),
+        }
+
     if item_key in EXPANSIONS:
         expansion = next_expansion(db)
         if expansion is None or expansion["key"] != item_key:
@@ -171,6 +203,8 @@
             raise HTTPException(status_code=402, detail=f"Not enough coins: need {spec['cost']}")
         garden.spend(db, spec["cost"], item_key)
         db.flush()
+        db.commit()
+        publish(str(user["user_id"]), "garden.changed", {"reason": "expansion"})
         return {"ok": True, "grid": grid_size(db), "balance": balance(db)}
 
     if item_key in DECORATIONS:
@@ -190,6 +224,8 @@
         db.add(item)
         garden.spend(db, spec["cost"], item_key)
         db.flush()
+        db.commit()
+        publish(str(user["user_id"]), "garden.changed", {"reason": "shop"})
         return {
             "ok": True,
             "item": {"id": item.id, "item_key": item.item_key, "x": item.x, "y": item.y},
diff --git a/backend/app/api/projects.py b/backend/app/api/projects.py
index 65bb6c0..b087307 100644
--- a/backend/app/api/projects.py
+++ b/backend/app/api/projects.py
@@ -1,31 +1,51 @@
 """API проектов M1."""
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Query, Response
 from sqlalchemy import select
 
 from app.dependencies import DbDep, UserDep
-from app.models import Project
+from app.models import CoinEvent, Project
+from app.realtime import publish
 from app.schemas import ProjectCreate, ProjectOut, ProjectUpdate
+from app.services.xp import coins_for_create, grant_create_xp
 
 router = APIRouter(prefix="/api/projects", tags=["projects"])
 
-VALID_RELEVANCE = {"active", "paused", "archived"}
+# «Закрыт» (archived) больше нет — вместо него архив (ТЗ 3.11)
+VALID_RELEVANCE = {"active", "paused"}
 
 
 @router.post("", response_model=ProjectOut)
-async def create_project(schema: ProjectCreate, db: DbDep, user: UserDep) -> Project:
+async def create_project(
+    schema: ProjectCreate, db: DbDep, user: UserDep, response: Response
+) -> Project:
     exists = db.scalars(select(Project).where(Project.name == schema.name)).first()
     if exists is not None:
         raise HTTPException(status_code=409, detail="Project name already exists")
     project = Project(name=schema.name, priority=schema.priority, note=schema.note)
     db.add(project)
     db.flush()
+    # Микронаграда за создание (ТЗ 3.13): чуть больше XP, чем за задачу
+    grant_create_xp(db, "create_project")
+    db.add(CoinEvent(source="create_project", amount=coins_for_create("create_project")))
+    response.headers["X-Created-XP"] = "5"
+    response.headers["X-Created-Coins"] = "2"
+    db.commit()
+    publish(str(user["user_id"]), "project.changed", {"id": project.id})
+    publish(str(user["user_id"]), "xp.changed", {"celebrate": False})
     return project
 
 
 @router.get("", response_model=list[ProjectOut])
-async def list_projects(db: DbDep, user: UserDep) -> list[Project]:
-    return list(db.scalars(select(Project).order_by(Project.id)).all())
+async def list_projects(
+    db: DbDep, user: UserDep, archived: bool = Query(False)
+) -> list[Project]:
+    """Активные проекты; archived=true — список архива (история)."""
+    return list(
+        db.scalars(
+            select(Project).where(Project.is_archived == archived).order_by(Project.id)
+        ).all()
+    )
 
 
 @router.get("/{project_id}", response_model=ProjectOut)
@@ -50,13 +70,41 @@
         )
     for field, value in data.items():
         setattr(project, field, value)
+    db.commit()
+    publish(str(user["user_id"]), "project.changed", {"id": project.id})
+    return project
+
+
+@router.post("/{project_id}/archive", response_model=ProjectOut)
+async def archive_project(project_id: int, db: DbDep, user: UserDep) -> Project:
+    """Отправить проект в архив — вместе со всеми его задачами (ТЗ 3.11)."""
+    project = db.get(Project, project_id)
+    if project is None:
+        raise HTTPException(status_code=404, detail="Project not found")
+    project.is_archived = True
+    db.commit()
+    publish(str(user["user_id"]), "project.changed", {"id": project.id})
+    return project
+
+
+@router.post("/{project_id}/restore", response_model=ProjectOut)
+async def restore_project(project_id: int, db: DbDep, user: UserDep) -> Project:
+    """Вернуть проект из архива — со всеми задачами и историей."""
+    project = db.get(Project, project_id)
+    if project is None:
+        raise HTTPException(status_code=404, detail="Project not found")
+    project.is_archived = False
+    db.commit()
+    publish(str(user["user_id"]), "project.changed", {"id": project.id})
     return project
 
 
 @router.delete("/{project_id}")
-async def delete_project(project_id: int, db: DbDep) -> dict[str, bool]:
+async def delete_project(project_id: int, db: DbDep, user: UserDep) -> dict[str, bool]:
     project = db.get(Project, project_id)
     if project is None:
         raise HTTPException(status_code=404, detail="Project not found")
     db.delete(project)
+    db.commit()
+    publish(str(user["user_id"]), "project.deleted", {"id": project_id})
     return {"ok": True}
diff --git a/backend/app/api/settings.py b/backend/app/api/settings.py
index 3b18269..5324941 100644
--- a/backend/app/api/settings.py
+++ b/backend/app/api/settings.py
@@ -6,6 +6,7 @@
 
 from app.dependencies import DbDep, UserDep
 from app.models import AppSetting
+from app.realtime import publish
 from app.schemas import CURRENCIES, LANGUAGES, AppSettingsOut, AppSettingsUpdate
 
 router = APIRouter(prefix="/api/settings", tags=["settings"])
@@ -48,6 +49,8 @@
     if schema.language is not None:
         _upsert(db, LANGUAGE_KEY, schema.language)
     db.flush()
+    db.commit()
+    publish(str(user["user_id"]), "settings.changed")
     return AppSettingsOut(
         currency=_read_value(db, CURRENCY_KEY, CURRENCIES, DEFAULT_CURRENCY),
         language=_read_value(db, LANGUAGE_KEY, LANGUAGES + ("",), DEFAULT_LANGUAGE),
diff --git a/backend/app/api/tasks.py b/backend/app/api/tasks.py
index 5bd53c3..caa9fe6 100644
--- a/backend/app/api/tasks.py
+++ b/backend/app/api/tasks.py
@@ -3,10 +3,11 @@
 from typing import Any, cast
 
 from fastapi import APIRouter, BackgroundTasks, HTTPException, Query, Response
-from sqlalchemy import select
+from sqlalchemy import Select, or_, select
 
 from app.dependencies import DbDep, UserDep
 from app.models import CoinEvent, Project, Tag, Task, utcnow
+from app.realtime import publish
 from app.schemas import (
     DEADLINE_PERIODS,
     RECUR_KINDS,
@@ -20,7 +21,13 @@
 from app.services.garden import coins_for_xp, level_bonus_coins
 from app.services.options import pick_options
 from app.services.recurrence import spawn_next
-from app.services.xp import grant_task_xp, level_from_xp, total_xp
+from app.services.xp import (
+    coins_for_create,
+    grant_create_xp,
+    grant_task_xp,
+    level_from_xp,
+    total_xp,
+)
 
 router = APIRouter(prefix="/api/tasks", tags=["tasks"])
 
@@ -34,6 +41,11 @@
     return task
 
 
+def _archived_project_ids(db: Any) -> Select[tuple[int]]:
+    """id проектов в архиве — их задачи в рабочих видах не показываются."""
+    return select(Project.id).where(Project.is_archived.is_(True))
+
+
 def _validate_parent(db: Any, task: Task | None, parent_id: int | None) -> None:
     """Родитель должен существовать; циклы в дереве запрещены."""
     if parent_id is None:
@@ -53,7 +65,7 @@
 
 @router.post("")
 async def create_task(
-    schema: TaskCreate, db: DbDep, user: UserDep, background: BackgroundTasks
+    schema: TaskCreate, db: DbDep, user: UserDep, background: BackgroundTasks, response: Response
 ) -> dict[str, int]:
     """Быстрый захват: достаточно title — задача попадает в стек (raw, to_do).
 
@@ -66,9 +78,17 @@
     )
     db.add(task)
     db.flush()
+    # Микронаграда за создание (ТЗ 3.13): без конфетти, просто тост —
+    # заголовки X-Created-* фронт буферизует отдельно от награды за закрытие
+    grant_create_xp(db, "create_task")
+    db.add(CoinEvent(source="create_task", amount=coins_for_create("create_task")))
+    response.headers["X-Created-XP"] = "2"
+    response.headers["X-Created-Coins"] = "1"
     # Коммитим до планирования фоновой работы: BackgroundTasks выполняются ДО
     # teardown-коммита зависимости get_db, а detail_task открывает свою сессию.
     db.commit()
+    publish(str(user["user_id"]), "task.changed", {"id": task.id})
+    publish(str(user["user_id"]), "xp.changed", {"celebrate": False})
     background.add_task(detail_task, task.id)
     return {"id": task.id}
 
@@ -82,6 +102,7 @@
     project_id: int | None = Query(None),
     tag_id: int | None = Query(None),
     parent_id: int | None = Query(None),
+    include_archived: bool = Query(False),
 ) -> list[Task]:
     stmt = select(Task).order_by(Task.created_at.desc())
     if detail_state:
@@ -90,6 +111,11 @@
         stmt = stmt.where(Task.status == status)
     if project_id:
         stmt = stmt.where(Task.project_id == project_id)
+    elif not include_archived:
+        # задачи архивных проектов — только в истории (ТЗ 3.11)
+        stmt = stmt.where(
+            or_(Task.project_id.is_(None), Task.project_id.not_in(_archived_project_ids(db)))
+        )
     if parent_id is not None:
         stmt = stmt.where(Task.parent_task_id == parent_id)
     if tag_id:
@@ -136,6 +162,7 @@
         task.tags = list(tags)
     # Пометка источника закрытия (геймификация): не поле задачи, в setattr не идёт
     earned_via = data.pop("earned_via", None)
+    earned_event = None
 
     for field, value in data.items():
         setattr(task, field, value)
@@ -170,9 +197,20 @@
                     )
                 )
             response.headers["X-Earned-Coins"] = str(coins)
+            earned_event = event
 
     db.flush()
     db.refresh(task)  # перечитать связи (project/tags) после обновления
+    # События после коммита: подписчик SSE может сразу перечитать данные
+    db.commit()
+    publish(str(user["user_id"]), "task.changed", {"id": task.id})
+    if earned_event is not None:
+        publish(
+            str(user["user_id"]),
+            "xp.changed",
+            {"amount": earned_event.amount, "rarity": earned_event.rarity, "celebrate": True},
+        )
+        publish(str(user["user_id"]), "garden.changed", {"reason": "task"})
     return task
 
 
@@ -193,6 +231,8 @@
     task.approved_at = utcnow()
     db.flush()
     db.refresh(task)
+    db.commit()
+    publish(str(user["user_id"]), "task.changed", {"id": task.id})
     return task
 
 
@@ -206,6 +246,7 @@
     # Коммит до фоновой работы, чтобы worker не прочитал старое состояние
     # и его запись не перезаписалась teardown-коммитом (см. create_task).
     db.commit()
+    publish(str(user["user_id"]), "task.changed", {"id": task.id})
     background.add_task(detail_task, task.id)
     return task
 
@@ -219,4 +260,6 @@
 @router.delete("/{task_id}")
 async def delete_task(task_id: int, db: DbDep, user: UserDep) -> dict[str, bool]:
     db.delete(_get_task_or_404(db, task_id))
+    db.commit()
+    publish(str(user["user_id"]), "task.deleted", {"id": task_id})
     return {"ok": True}
diff --git a/backend/app/api/xp.py b/backend/app/api/xp.py
index ce35eae..968e613 100644
--- a/backend/app/api/xp.py
+++ b/backend/app/api/xp.py
@@ -1,11 +1,12 @@
-"""API геймификации (ТЗ 3.13): XP, уровень, прогресс, события начисления."""
+"""API геймификации (ТЗ 3.13): XP, уровень, прогресс, события начисления, дейли."""
 
 from typing import Any
 
 from fastapi import APIRouter
 
 from app.dependencies import DbDep, UserDep
-from app.services.xp import xp_events, xp_summary
+from app.realtime import publish
+from app.services.xp import claim_daily, xp_events, xp_summary
 
 router = APIRouter(prefix="/api/xp", tags=["xp"])
 
@@ -20,3 +21,13 @@
 async def get_xp_events(db: DbDep, user: UserDep) -> list[dict[str, Any]]:
     """Все события начисления: редкость растения, признак «из 3 вариантов», даты."""
     return xp_events(db)
+
+
+@router.post("/daily")
+async def post_daily(db: DbDep, user: UserDep) -> dict[str, Any]:
+    """Ежедневная награда за визит: 50 монет раз в сутки (идемпотентно)."""
+    result = claim_daily(db)
+    if result.get("granted"):
+        db.commit()
+        publish(str(user["user_id"]), "xp.changed", {"celebrate": False})
+    return result
diff --git a/backend/app/config.py b/backend/app/config.py
index bd6c71a..0d39e0b 100644
--- a/backend/app/config.py
+++ b/backend/app/config.py
@@ -22,8 +22,8 @@
     session_cookie_name: str = "gntodo_session"
 
     # Ollama (M2)
-    ollama_base_url: str = "http://localhost:11434"
-    ollama_model: str = "gemma4:e2b-it-qat"
+    ollama_base_url: str = "http://192.168.1.130:11434"
+    ollama_model: str = "qwen3.5:2b-q4_K_M"
 
     # Хранилище вложений (M2)
     attachments_path: str = "data/attachments"
diff --git a/backend/app/main.py b/backend/app/main.py
index bc78401..2de5d34 100644
--- a/backend/app/main.py
+++ b/backend/app/main.py
@@ -11,7 +11,7 @@
 from starlette.responses import JSONResponse, Response
 
 from app import mcp_server
-from app.api import attachments, garden, projects, tags, tasks, xp
+from app.api import attachments, events, garden, projects, tags, tasks, xp
 from app.api.settings import router as settings_router
 from app.auth.routes import router as auth_router
 from app.config import get_settings
@@ -64,6 +64,7 @@
 app.include_router(settings_router)
 app.include_router(xp.router)
 app.include_router(garden.router)
+app.include_router(events.router)
 
 # MCP-сервер для ИИ-агентов (M5)
 app.mount("/mcp", mcp_server.mcp.streamable_http_app())
diff --git a/backend/app/mcp_server.py b/backend/app/mcp_server.py
index 3bdf863..6308364 100644
--- a/backend/app/mcp_server.py
+++ b/backend/app/mcp_server.py
@@ -15,6 +15,7 @@
 
 from app.db import get_session_factory
 from app.models import Attachment, Document, Project, Tag, Task, utcnow
+from app.realtime import publish
 from app.schemas import DEADLINE_PERIODS, RECUR_KINDS
 from app.services.detailing import detail_task
 from app.services.recurrence import spawn_next
@@ -109,6 +110,8 @@
             task.tags = tags
         session.add(task)
         session.commit()
+        # Агент меняет данные вне UI — уведомляем все открытые SSE-соединения
+        publish(None, "task.changed", {"id": task.id, "source": "mcp"})
         # Автодетализация — в фоновом потоке (LLM работает десятки секунд)
         threading.Thread(target=detail_task, args=(task.id,), daemon=True).start()
         return {"id": task.id, "title": task.title, "detail_state": task.detail_state}
@@ -213,6 +216,7 @@
             # Регулярная задача: следующий экземпляр по фиксированному календарю
             spawned = spawn_next(session, task)
         session.commit()
+        publish(None, "task.changed", {"id": task.id, "source": "mcp"})
         result = _compact(task)
         if spawned is not None:
             result["spawned_next_id"] = spawned.id
diff --git a/backend/app/models.py b/backend/app/models.py
index 9673642..986e322 100644
--- a/backend/app/models.py
+++ b/backend/app/models.py
@@ -157,8 +157,10 @@
     def document_id(self) -> int | None:
         return self.document.id if self.document else None
 
-    # Статус актуальности проекта
+    # Статус актуальности проекта («Закрыт» теперь выражается архивом)
     relevance_status: Mapped[str] = mapped_column(String(20), default="active")
+    # Архив (ТЗ 3.11): проект уезжает в историю со всеми задачами
+    is_archived: Mapped[bool] = mapped_column(Boolean, default=False)
     priority: Mapped[int | None] = mapped_column(Integer, nullable=True, default=None)
 
     tasks: Mapped[list[Task]] = relationship(back_populates="project")
@@ -251,6 +253,9 @@
     task_id: Mapped[int | None] = mapped_column(
         ForeignKey("tasks.id", ondelete="SET NULL"), nullable=True, default=None
     )
+    # Событие награды: закрытие задачи или создание (задача/проект).
+    # Растения в саду растут только из событий kind='task'.
+    kind: Mapped[str] = mapped_column(String(20), default="task", server_default="task")
     amount: Mapped[int] = mapped_column(Integer)
     # Редкость растения в саду — решается в момент закрытия по весу задачи
     rarity: Mapped[str] = mapped_column(String(16), default="common")
diff --git a/backend/app/realtime.py b/backend/app/realtime.py
new file mode 100644
index 0000000..f25e071
--- /dev/null
+++ b/backend/app/realtime.py
@@ -0,0 +1,82 @@
+"""Серверные события (SSE): шина публикации (ТЗ 3.14).
+
+События грубозернистые: подписчики получают «kind + данные» и сами решают,
+что перечитать (refetch вместо патчей состояния). Издатели — HTTP-хендлеры,
+MCP-инструменты (потоки FastMCP) и фоновый detail_task: публикация всегда
+идёт через loop.call_soon_threadsafe, поэтому работает из любого потока.
+"""
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Размер очереди подписчика: при переполнении события пропускаются —
+# coarse-модель самовосстанавливается (клиент перечитывает данные целиком)
+QUEUE_MAXSIZE = 64
+
+
+@dataclass(frozen=True)
+class Event:
+    kind: str
+    data: dict[str, Any] | None = None
+
+
+class EventBus:
+    """Реестр подписок по user_id (None при publish = broadcast всем)."""
+
+    def __init__(self) -> None:
+        # user_id -> очереди его соединений (несколько вкладок = несколько очередей)
+        self._subscribers: dict[str, set[asyncio.Queue[Event]]] = {}
+        # Loop берётся лениво при первой подписке: lifespan в тестах не стартует,
+        # а после закрытия loop публикация молча сбрасывает его на новый
+        self._loop: asyncio.AbstractEventLoop | None = None
+
+    def subscribe(self, user_id: str) -> asyncio.Queue[Event]:
+        queue: asyncio.Queue[Event] = asyncio.Queue(maxsize=QUEUE_MAXSIZE)
+        self._subscribers.setdefault(user_id, set()).add(queue)
+        try:
+            self._loop = asyncio.get_running_loop()
+        except RuntimeError:
+            pass  # вне loop (не бывает для SSE-хендлера) — оставляем прежний
+        return queue
+
+    def unsubscribe(self, user_id: str, queue: asyncio.Queue[Event]) -> None:
+        queues = self._subscribers.get(user_id)
+        if queues is not None:
+            queues.discard(queue)
+            if not queues:
+                del self._subscribers[user_id]
+
+    def publish(self, user_id: str | None, kind: str, data: dict[str, Any] | None = None) -> None:
+        """Положить событие всем подписчикам (None = всем). Потокобезопасно."""
+        if not self._subscribers or self._loop is None:
+            return  # подписчиков нет — клиент догонит refetch'ем при подключении
+        event = Event(kind=kind, data=data)
+        try:
+            self._loop.call_soon_threadsafe(self._dispatch, user_id, event)
+        except RuntimeError:
+            # loop закрыт (перезапуск uvicorn --reload) — сбросим и ждём новую подписку
+            self._loop = None
+
+    def _dispatch(self, user_id: str | None, event: Event) -> None:
+        if user_id is None:
+            targets = list(self._subscribers.values())
+        else:
+            targets = [self._subscribers.get(user_id, set())]
+        for queues in targets:
+            for queue in queues:
+                try:
+                    queue.put_nowait(event)
+                except asyncio.QueueFull:
+                    logger.warning("SSE queue overflow for %r: event %r dropped", queue, event.kind)
+
+
+bus = EventBus()
+
+
+def publish(user_id: str | None, kind: str, data: dict[str, Any] | None = None) -> None:
+    """Точка публикации для хендлеров/агентов (см. ТЗ 3.14)."""
+    bus.publish(user_id, kind, data)
diff --git a/backend/app/schemas.py b/backend/app/schemas.py
index 1c54953..4888250 100644
--- a/backend/app/schemas.py
+++ b/backend/app/schemas.py
@@ -24,6 +24,7 @@
     id: int
     name: str
     relevance_status: str
+    is_archived: bool
     priority: int | None
     note: str
     document_id: int | None
diff --git a/backend/app/services/detailing.py b/backend/app/services/detailing.py
index c52e4c1..abb3f33 100644
--- a/backend/app/services/detailing.py
+++ b/backend/app/services/detailing.py
@@ -15,6 +15,7 @@
 from app.config import get_settings
 from app.db import get_session_factory
 from app.models import Project, Tag, Task
+from app.realtime import publish
 
 logger = logging.getLogger(__name__)
 
@@ -52,9 +53,18 @@
         self.model = model or settings.ollama_model
 
     def generate(self, prompt: str) -> str:
+        # think: false — «думающие» модели (qwen3.5) с format:json кладут ответ
+        # в поле thinking, а response оставляют пустым; для черновых метаданных
+        # рассуждения не нужны
         response = httpx.post(
             f"{self.base_url}/api/generate",
-            json={"model": self.model, "prompt": prompt, "format": "json", "stream": False},
+            json={
+                "model": self.model,
+                "prompt": prompt,
+                "format": "json",
+                "stream": False,
+                "think": False,
+            },
             timeout=180.0,
         )
         response.raise_for_status()
@@ -147,5 +157,7 @@
         if proposal is not None:
             task.ai_proposal = proposal
             session.commit()
+            # LLM работает вне запроса — уведомляем все вкладки (ТЗ 3.14)
+            publish(None, "detail.changed", {"id": task_id})
     finally:
         session.close()
diff --git a/backend/app/services/garden.py b/backend/app/services/garden.py
index abebb79..9ae5b7c 100644
--- a/backend/app/services/garden.py
+++ b/backend/app/services/garden.py
@@ -42,11 +42,16 @@
 # Каталог декораций: ключ -> (цена, уникальная). Только косметика — без бонусов.
 DECORATIONS: dict[str, dict[str, Any]] = {
     "fence": {"cost": 30, "unique": False},
+    "bush": {"cost": 25, "unique": False},
     "flowerbed": {"cost": 40, "unique": False},
     "lantern": {"cost": 80, "unique": True},
     "bench": {"cost": 90, "unique": True},
     "birdbath": {"cost": 120, "unique": True},
+    "flag": {"cost": 150, "unique": True},
+    "birdhouse": {"cost": 180, "unique": True},
+    "gem": {"cost": 350, "unique": True},
     "pond": {"cost": 250, "unique": True},
+    "greenhouse": {"cost": 600, "unique": True},
     "gazebo": {"cost": 400, "unique": True},
 }
 
@@ -59,6 +64,8 @@
     "expansion_1": {"level": 3, "cost": 100},
     "expansion_2": {"level": 5, "cost": 250},
     "expansion_3": {"level": 8, "cost": 500},
+    "expansion_4": {"level": 9, "cost": 750},
+    "expansion_5": {"level": 11, "cost": 1000},
 }
 
 # Виды растений: открываются уровнем («контент за опыт»); premium — только
@@ -71,8 +78,34 @@
     {"key": "ph-flower-lotus", "level": 2, "premium": False},
     {"key": "ph-cactus", "level": 4, "premium": True},
     {"key": "ph-tree", "level": 6, "premium": False},
+    {"key": "ph-drop", "level": 7, "premium": False},
+    {"key": "ph-sun", "level": 8, "premium": False},
+    {"key": "ph-tree-structure", "level": 9, "premium": False},
+    {"key": "ph-butterfly", "level": 10, "premium": False},
+    {"key": "ph-campfire", "level": 11, "premium": True},
+    {"key": "ph-sparkle", "level": 12, "premium": True},
+    {"key": "ph-fire", "level": 13, "premium": True},
 ]
 
+# Семена растений в маркете: вид -> цена. Покупка сразу сажает растение
+# (стадия 0) на свободную клетку по спирали; доступность — по уровню (SPECIES).
+# Вид из семени — обычной редкости; редкие/эпик рождаются только из задач.
+SEED_COSTS: dict[str, int] = {
+    "ph-flower": 30,
+    "ph-leaf": 40,
+    "ph-tree-evergreen": 60,
+    "ph-flower-lotus": 90,
+    "ph-cactus": 150,
+    "ph-tree": 200,
+    "ph-drop": 250,
+    "ph-sun": 300,
+    "ph-tree-structure": 400,
+    "ph-butterfly": 500,
+    "ph-campfire": 700,
+    "ph-sparkle": 900,
+    "ph-fire": 1200,
+}
+
 # Домик в центре сетки: footprint, который не занимают растения (ячейки)
 HOUSE_COLS = 4
 HOUSE_ROWS = 3
@@ -113,8 +146,19 @@
 
 
 def species_catalog(level: int) -> list[dict[str, Any]]:
-    """Каталог видов с пометкой «открыт на этом уровне»."""
-    return [{**s, "unlocked": level >= s["level"]} for s in SPECIES]
+    """Каталог видов с пометкой «открыт на этом уровне» и ценой семени."""
+    return [
+        {**s, "unlocked": level >= s["level"], "seed_cost": SEED_COSTS[s["key"]]}
+        for s in SPECIES
+    ]
+
+
+def make_seed_plant(db: Session, species: str) -> GardenItem:
+    """Купленное семя: растение-росток в инвентаре (x/y NULL), пользователь
+    сам перетаскивает его на карту. Размещённое семя обратно убрать нельзя."""
+    item = GardenItem(kind="plant", ref_id=None, item_key=species, x=None, y=None, stage=0)
+    db.add(item)
+    return item
 
 
 def species_for(level: int, task_id: int, rarity: str) -> str:
@@ -184,7 +228,8 @@
         if level not in granted:
             db.add(CoinEvent(source="level", level=level, amount=level_bonus_coins(level)))
 
-    # 2) Растения для событий XP без размещённого элемента
+    # 2) Растения для закрытых задач без размещённого элемента (события
+    #    создания kind='create_*' растения не дают — только закрытия)
     placed_refs = set(
         db.scalars(
             select(GardenItem.ref_id).where(
@@ -194,7 +239,9 @@
     )
     pending = [
         e
-        for e in db.scalars(select(XpEvent).order_by(XpEvent.id)).all()
+        for e in db.scalars(
+            select(XpEvent).where(XpEvent.kind == "task").order_by(XpEvent.id)
+        ).all()
         if e.id not in placed_refs
     ]
     if pending:
diff --git a/backend/app/services/options.py b/backend/app/services/options.py
index 333dfe7..09bd96c 100644
--- a/backend/app/services/options.py
+++ b/backend/app/services/options.py
@@ -64,7 +64,8 @@
 
     active_projects: set[int | None] = {None}
     for p in db.scalars(select(Project)).all():
-        if p.relevance_status == "active":
+        # архивный проект в выдачу задачи не попадает, даже «активный»
+        if p.relevance_status == "active" and not p.is_archived:
             active_projects.add(p.id)
 
     used_projects: set[int | None] = set()
diff --git a/backend/app/services/xp.py b/backend/app/services/xp.py
index 54ba3c5..89b113d 100644
--- a/backend/app/services/xp.py
+++ b/backend/app/services/xp.py
@@ -5,12 +5,13 @@
 """
 
 import random
+from datetime import UTC, datetime, time
 from typing import Any
 
 from sqlalchemy import func, select
 from sqlalchemy.orm import Session
 
-from app.models import Task, XpEvent
+from app.models import CoinEvent, Task, XpEvent
 
 # База за любую закрытую задачу
 XP_BASE = 10
@@ -22,6 +23,14 @@
 # Бонус за «ментально сложную» (метка «не хочется делать»): награда за силу воли
 WILLPOWER_BONUS = 10
 
+# Микронаграды за создание (ТЗ 3.13): капля XP/монет, чтобы захват был заметен
+XP_CREATE_TASK = 2
+COINS_CREATE_TASK = 1
+XP_CREATE_PROJECT = 5
+COINS_CREATE_PROJECT = 2
+# Ежедневная награда за визит (раз в сутки, только монеты)
+DAILY_COINS = 50
+
 # Уровень L достигается при XP >= LEVEL_FACTOR * (L-1) * L / 2:
 # L2 = 100, L3 = 300, L4 = 600, L5 = 1000 ... на уровень L -> L+1 нужно 100*L
 LEVEL_FACTOR = 100
@@ -87,6 +96,7 @@
     amount = compute_task_xp(task)
     event = XpEvent(
         task_id=task.id,
+        kind="task",
         amount=amount,
         rarity=compute_rarity(amount, random.random()),
     )
@@ -95,6 +105,40 @@
     return event
 
 
+def grant_create_xp(db: Session, kind: str) -> XpEvent:
+    """Микронаграда за создание (kind='create_task' | 'create_project').
+
+    Растения в саду не даёт (их растят только закрытия — см. ensure_garden);
+    task_id остаётся NULL — удаление задачи/проекта награду не отнимает.
+    """
+    amount = XP_CREATE_TASK if kind == "create_task" else XP_CREATE_PROJECT
+    event = XpEvent(task_id=None, kind=kind, amount=amount, rarity="common")
+    db.add(event)
+    db.flush()
+    return event
+
+
+def coins_for_create(kind: str) -> int:
+    return COINS_CREATE_TASK if kind == "create_task" else COINS_CREATE_PROJECT
+
+
+def claim_daily(db: Session) -> dict[str, Any]:
+    """Ежедневная награда: 50 монет раз в сутки (граница дня — UTC).
+
+    Идемпотентно: если за текущий день начисление уже было — granted=False.
+    """
+    now = datetime.now(UTC)
+    day_start = datetime.combine(now.date(), time.min, tzinfo=UTC)
+    claimed = db.scalar(
+        select(CoinEvent).where(CoinEvent.source == "daily", CoinEvent.created_at >= day_start)
+    )
+    if claimed is not None:
+        return {"granted": False, "coins": 0}
+    db.add(CoinEvent(source="daily", amount=DAILY_COINS))
+    db.flush()
+    return {"granted": True, "coins": DAILY_COINS}
+
+
 def total_xp(db: Session) -> int:
     return int(db.scalar(select(func.coalesce(func.sum(XpEvent.amount), 0))) or 0)
 
@@ -120,7 +164,10 @@
         "level_xp": xp - current_floor,
         "level_span": span,
         "level_percent": round((xp - current_floor) / span * 100) if span else 100,
-        "completed_count": int(db.scalar(select(func.count(XpEvent.id))) or 0),
+        # Счётчик закрытых задач: события создания (kind='create_*') не считаются
+        "completed_count": int(
+            db.scalar(select(func.count(XpEvent.id)).where(XpEvent.kind == "task")) or 0
+        ),
     }
 
 
@@ -130,6 +177,7 @@
     return [
         {
             "task_id": r.task_id,
+            "kind": r.kind,
             "amount": r.amount,
             "rarity": r.rarity,
             "via_options": r.via_options,
diff --git a/backend/tests/test_events.py b/backend/tests/test_events.py
new file mode 100644
index 0000000..8c116e5
--- /dev/null
+++ b/backend/tests/test_events.py
@@ -0,0 +1,213 @@
+"""Серверные события (ТЗ 3.14): шина публикации и SSE-генератор.
+
+TestClient буферизует весь ответ (portal.call ждёт завершения приложения),
+поэтому бесконечный SSE-стрим через client.stream нечитаем в принципе —
+генератор `_event_source` тестируем напрямую, HTTP-публикации — перехватом
+publish.
+"""
+
+import asyncio
+import threading
+from collections.abc import AsyncIterator, Iterator
+from typing import Any
+
+import pytest
+
+from app.api import events as events_api
+from app.realtime import Event, bus, publish
+
+
+@pytest.fixture(autouse=True)
+def _fresh_bus() -> Iterator[None]:
+    """Шина между тестами пуста: asyncio.run юнит-тестов оставляет мёртвый loop."""
+    bus._subscribers.clear()
+    bus._loop = None
+    yield
+    bus._subscribers.clear()
+    bus._loop = None
+
+
+class _FakeRequest:
+    """Минимальный двойник Request для _event_source (is_disconnected → False)."""
+
+    async def is_disconnected(self) -> bool:
+        return False
+
+
+async def _anext_timeout(gen: AsyncIterator[str], timeout: float = 2.0) -> str:
+    return await asyncio.wait_for(gen.__anext__(), timeout=timeout)
+
+
+# --- юниты шины ---
+
+
+def test_dispatch_same_loop() -> None:
+    """Подписка и публикация в текущем loop: событие попадает в очередь."""
+
+    async def scenario() -> Any:
+        queue = bus.subscribe("u1")
+        try:
+            publish("u1", "task.changed", {"id": 1})
+            return await asyncio.wait_for(queue.get(), timeout=2)
+        finally:
+            bus.unsubscribe("u1", queue)
+
+    event = asyncio.run(scenario())
+    assert event.kind == "task.changed"
+    assert event.data == {"id": 1}
+
+
+def test_publish_from_thread() -> None:
+    """publish из другого потока (как MCP/detail_task) доезжает через call_soon_threadsafe."""
+
+    async def scenario() -> Any:
+        queue = bus.subscribe("u1")
+        try:
+            thread = threading.Thread(
+                target=publish, args=(None, "garden.changed"), kwargs={"data": {"reason": "shop"}}
+            )
+            thread.start()
+            return await asyncio.wait_for(queue.get(), timeout=2)
+        finally:
+            bus.unsubscribe("u1", queue)
+
+    event = asyncio.run(scenario())
+    assert event.kind == "garden.changed"
+
+
+def test_queue_overflow_skips() -> None:
+    """Переполнение очереди не бросает: событие пропускается (coarse-модель)."""
+
+    async def scenario() -> None:
+        queue = bus.subscribe("u1")
+        try:
+            for i in range(100):
+                publish("u1", "task.changed", {"i": i})
+            # очередь забита до maxsize — следующий publish не бросает
+            publish("u1", "task.changed", {"overflow": True})
+        finally:
+            bus.unsubscribe("u1", queue)
+
+    asyncio.run(scenario())
+
+
+def test_no_subscribers_is_noop() -> None:
+    """Publish без подписчиков — тихий no-op (клиент догонит refetch'ем)."""
+    publish(None, "task.changed", {"id": 1})
+
+
+# --- SSE-генератор ---
+
+
+def test_event_source_ready_then_publish() -> None:
+    """Первый кадр ready; событие шины доезжает в стрим; отсоединение завершает."""
+
+    async def scenario() -> list[str]:
+        gen = events_api._event_source(_FakeRequest(), "u1")  # type: ignore[arg-type]
+        frames: list[str] = []
+        frames.append(await _anext_timeout(gen))  # subscribe внутри → loop забинден
+        publish("u1", "project.changed", {"id": 5})
+        frames.append(await _anext_timeout(gen))
+        await gen.aclose()
+        return frames
+
+    frames = asyncio.run(scenario())
+    assert frames[0] == "data: " + events_api._sse_json("ready") + "\n\n"
+    assert '"project.changed"' in frames[1]
+    assert '"id": 5' in frames[1]
+    # после aclose подписчик отписан
+    assert bus._subscribers == {}
+
+
+def test_event_source_unsubscribe_on_disconnect() -> None:
+    """is_disconnected → генератор завершается, подписка снята (finally)."""
+
+    class _Disconnecting:
+        def __init__(self) -> None:
+            self.calls = 0
+
+        async def is_disconnected(self) -> bool:
+            self.calls += 1
+            return True  # ready уходит без проверки, затем сразу disconnect
+
+    async def scenario() -> None:
+        gen = events_api._event_source(_Disconnecting(), "u1")  # type: ignore[arg-type]
+        await _anext_timeout(gen)
+        with pytest.raises(StopAsyncIteration):
+            await _anext_timeout(gen)
+
+    asyncio.run(scenario())
+    assert bus._subscribers == {}
+
+
+def test_event_source_ping_on_idle() -> None:
+    """Тишина в шине дольше PING_SECONDS → кадр ping (keep-alive для прокси)."""
+
+    async def scenario() -> str:
+        gen = events_api._event_source(_FakeRequest(), "u1")  # type: ignore[arg-type]
+        await _anext_timeout(gen)  # ready
+        # подменить таймаут на минимум, чтобы не ждать 20 секунд
+        saved = events_api.PING_SECONDS
+        events_api.PING_SECONDS = 0.01
+        try:
+            return await _anext_timeout(gen)
+        finally:
+            events_api.PING_SECONDS = saved
+            await gen.aclose()
+
+    frame = asyncio.run(scenario())
+    assert '"ping"' in frame
+
+
+# --- HTTP-публикации (перехват publish: TestClient стрим не читает) ---
+
+
+@pytest.fixture
+def published(monkeypatch: pytest.MonkeyPatch) -> list[Event]:
+    """Перехват publish в модуле api.tasks: события собираются в список."""
+    seen: list[Event] = []
+    import app.api.tasks as tasks_api
+
+    def _spy(user_id: str | None, kind: str, data: dict[str, Any] | None = None) -> None:
+        seen.append(Event(kind=kind, data=data))
+        publish(user_id, kind, data)
+
+    monkeypatch.setattr(tasks_api, "publish", _spy)
+    return seen
+
+
+def test_create_task_publishes(client: Any, published: list[Event]) -> None:
+    """Создание задачи → task.changed + xp.changed (без конфетти)."""
+    created = client.post("/api/tasks", json={"title": "Тест SSE"})
+    assert created.status_code == 200
+    kinds = [e.kind for e in published]
+    assert "task.changed" in kinds
+    assert "xp.changed" in kinds
+    xp = next(e for e in published if e.kind == "xp.changed")
+    assert xp.data == {"celebrate": False}
+
+
+def test_close_task_publishes_xp(client: Any, published: list[Event]) -> None:
+    """Закрытие задачи → task.changed + xp.changed {celebrate: True} + garden.changed."""
+    task_id = client.post("/api/tasks", json={"title": "Закрыть"}).json()["id"]
+    published.clear()
+    approved = client.post(f"/api/tasks/{task_id}/approve")
+    assert approved.status_code == 200
+    published.clear()
+    closed = client.patch(f"/api/tasks/{task_id}", json={"status": "done"})
+    assert closed.status_code == 200
+    kinds = [e.kind for e in published]
+    assert "task.changed" in kinds
+    assert "xp.changed" in kinds
+    assert "garden.changed" in kinds
+    xp = next(e for e in published if e.kind == "xp.changed")
+    assert xp.data is not None and xp.data["celebrate"] is True
+
+
+def test_delete_task_publishes_deleted(client: Any, published: list[Event]) -> None:
+    """Удаление задачи → task.deleted {id}."""
+    task_id = client.post("/api/tasks", json={"title": "Удалить"}).json()["id"]
+    published.clear()
+    deleted = client.delete(f"/api/tasks/{task_id}")
+    assert deleted.status_code == 200
+    assert [e for e in published if e.kind == "task.deleted" and e.data == {"id": task_id}]
diff --git a/backend/tests/test_garden.py b/backend/tests/test_garden.py
index 0e8f91d..49d098e 100644
--- a/backend/tests/test_garden.py
+++ b/backend/tests/test_garden.py
@@ -44,7 +44,8 @@
     assert earned2["xp"] == "" and earned2["coins"] == ""
 
     state = client.get("/api/garden").json()
-    assert state["balance"] == coins_for_xp(int(earned["xp"]))
+    # баланс = монеты за закрытие + микронаграда за создание задачи (+1)
+    assert state["balance"] == coins_for_xp(int(earned["xp"])) + 1
 
 
 def test_level_bonus_coins(client: TestClient) -> None:
@@ -52,8 +53,8 @@
     for _ in range(3):
         task_id = _create_task(client, priority=9, estimated_minutes=480)
         _done(client, task_id)
-    # Монеты: 3 × 20 за задачи + бонус 25×2 = 110
-    assert client.get("/api/garden").json()["balance"] == 110
+    # Монеты: 3 × 20 за задачи + 3 × 1 за создание + бонус 25×2 = 113
+    assert client.get("/api/garden").json()["balance"] == 113
 
 
 # --- Перемещение ---
@@ -87,19 +88,19 @@
     plant = next(i for i in client.get("/api/garden").json()["items"] if i["kind"] == "plant")
     assert plant["rarity"] == "common"
 
-    # Первая стадия ровно по карману (20 = 20)
+    # Первая стадия ровно по карману (20 = 20, +1 за создание задачи)
     resp = client.post(f"/api/garden/plants/{plant['id']}/upgrade")
     assert resp.status_code == 200
     assert resp.json()["stage"] == 1
-    assert resp.json()["balance"] == 0
+    assert resp.json()["balance"] == 1
 
-    # Вторая стадия — не хватает (50 > 0)
+    # Вторая стадия — не хватает (50 > 1)
     resp = client.post(f"/api/garden/plants/{plant['id']}/upgrade")
     assert resp.status_code == 402
     assert "50" in resp.json()["detail"]
 
     for _ in range(10):
-        _done(client, _create_task(client))  # 10×5 монет + бонус L2 — с запасом
+        _done(client, _create_task(client))  # 10×5 монет + создания + бонус L2 — с запасом
     resp = client.post(f"/api/garden/plants/{plant['id']}/upgrade")
     assert resp.status_code == 200
     assert resp.json()["stage"] == 2
@@ -119,7 +120,8 @@
     resp = client.post("/api/garden/shop/buy", json={"item_key": "fence"})
     assert resp.status_code == 200
     balance_after = resp.json()["balance"]
-    assert balance_after == 40 - DECORATIONS["fence"]["cost"]
+    # 2 закрытия по 20 + 2 создания по 1 − изгородь
+    assert balance_after == 40 + 2 - DECORATIONS["fence"]["cost"]
     # Покупка кладёт декорацию в инвентарь: элемент есть, координат нет
     item = next(
         i
@@ -219,4 +221,10 @@
 def test_level_bonus_helper() -> None:
     assert level_bonus_coins(2) == 50
     assert coins_for_xp(40) == 20
-    assert set(EXPANSIONS) == {"expansion_1", "expansion_2", "expansion_3"}
+    assert set(EXPANSIONS) == {
+        "expansion_1",
+        "expansion_2",
+        "expansion_3",
+        "expansion_4",
+        "expansion_5",
+    }
diff --git a/backend/tests/test_tasks_api.py b/backend/tests/test_tasks_api.py
index 8d9565b..d79ecbb 100644
--- a/backend/tests/test_tasks_api.py
+++ b/backend/tests/test_tasks_api.py
@@ -90,6 +90,51 @@
     assert bad.status_code == 422
 
 
+def test_project_archive_lifecycle(client: TestClient) -> None:
+    """Архив (ТЗ 3.11): проект уходит в архив с задачами и возвращается."""
+    pid = client.post("/api/projects", json={"name": "ремонт"}).json()["id"]
+    task_id = create_task(client, "поклеить обои")["id"]
+    client.patch(f"/api/tasks/{task_id}", json={"project_id": pid})
+    standalone = create_task(client, "без проекта")
+
+    # в архиве пусто, в активных проект и задача видны
+    assert client.get("/api/projects", params={"archived": "true"}).json() == []
+    assert any(p["id"] == pid for p in client.get("/api/projects").json())
+    assert any(t["id"] == task_id for t in client.get("/api/tasks").json())
+
+    # архивируем: проект скрыт, задача с ним уходит из рабочих видов
+    archived = client.post(f"/api/projects/{pid}/archive")
+    assert archived.status_code == 200
+    assert archived.json()["is_archived"] is True
+    assert client.get("/api/projects").json() == []
+    archived_list = client.get("/api/projects", params={"archived": "true"}).json()
+    assert [p["id"] for p in archived_list] == [pid]
+
+    tasks = client.get("/api/tasks").json()
+    assert all(t["id"] != task_id for t in tasks)
+    assert any(t["id"] == standalone["id"] for t in tasks)
+    # но на странице проекта (фильтр по project_id) история видна
+    assert any(
+        t["id"] == task_id
+        for t in client.get("/api/tasks", params={"project_id": pid}).json()
+    )
+    # и в выдаче задачи архивные проекты не участвуют
+    options = client.post("/api/tasks/suggest", json={"available_minutes": 600}).json()
+    assert all(t["id"] != task_id for t in options)
+
+    # восстановление возвращает всё как было
+    restored = client.post(f"/api/projects/{pid}/restore")
+    assert restored.status_code == 200
+    assert restored.json()["is_archived"] is False
+    assert any(t["id"] == task_id for t in client.get("/api/tasks").json())
+
+
+def test_archive_invalid_relevance_rejected(client: TestClient) -> None:
+    pid = client.post("/api/projects", json={"name": "устаревший статус"}).json()["id"]
+    resp = client.patch(f"/api/projects/{pid}", json={"relevance_status": "archived"})
+    assert resp.status_code == 422
+
+
 def test_tag_duplicate(client: TestClient) -> None:
     assert client.post("/api/tags", json={"name": "быт"}).status_code == 200
     assert client.post("/api/tags", json={"name": "быт"}).status_code == 409
diff --git a/backend/tests/test_xp.py b/backend/tests/test_xp.py
index 0edceff..8c70b3b 100644
--- a/backend/tests/test_xp.py
+++ b/backend/tests/test_xp.py
@@ -17,14 +17,19 @@
 
 
 def test_xp_granted_on_done(client: TestClient) -> None:
-    task_id = _create_task(client)
+    # Создание задачи — микронаграда (заголовки X-Created-*)
+    resp_create = client.post("/api/tasks", json={"title": "Задача для XP"})
+    assert resp_create.headers.get("X-Created-XP") == "2"
+    assert resp_create.headers.get("X-Created-Coins") == "1"
+    task_id = resp_create.json()["id"]
     resp = client.patch(f"/api/tasks/{task_id}", json={"status": "done"})
     assert resp.status_code == 200
     # база 10, без приоритета и оценки — только база
     assert resp.headers.get("X-Earned-XP") == "10"
 
     summary = client.get("/api/xp").json()
-    assert summary["total_xp"] == 10
+    # XP: 2 за создание + 10 за закрытие; счётчик закрытий — только kind='task'
+    assert summary["total_xp"] == 12
     assert summary["level"] == 1
     assert summary["completed_count"] == 1
 
@@ -46,19 +51,20 @@
     client.patch(f"/api/tasks/{task_id}", json={"status": "in_progress"})
     resp = client.patch(f"/api/tasks/{task_id}", json={"status": "done"})
     assert "X-Earned-XP" not in resp.headers
-    assert client.get("/api/xp").json()["total_xp"] == 10
+    assert client.get("/api/xp").json()["total_xp"] == 12
 
 
 def test_deleting_task_keeps_xp(client: TestClient) -> None:
     task_id = _create_task(client)
     client.patch(f"/api/tasks/{task_id}", json={"status": "done"})
     client.delete(f"/api/tasks/{task_id}")
-    assert client.get("/api/xp").json()["total_xp"] == 10
+    assert client.get("/api/xp").json()["total_xp"] == 12
 
 
 def test_level_progression(client: TestClient) -> None:
-    # 9 закрытий по 10 XP = 90 — уровень 1; 10 закрытий = 100 — уровень 2
-    for _ in range(9):
+    # каждая задача: 2 XP за создание + 10 за закрытие = 12
+    # 8 закрытий = 96 — уровень 1; 9-е выводит за 100 — уровень 2
+    for _ in range(8):
         task_id = _create_task(client)
         client.patch(f"/api/tasks/{task_id}", json={"status": "done"})
     assert client.get("/api/xp").json()["level"] == 1
@@ -66,9 +72,9 @@
     client.patch(f"/api/tasks/{task_id}", json={"status": "done"})
     summary = client.get("/api/xp").json()
     assert summary["level"] == 2
-    assert summary["level_xp"] == 0
+    assert summary["level_xp"] == 8
     assert summary["level_span"] == 200
-    assert summary["level_percent"] == 0
+    assert summary["level_percent"] == 4
 
 
 def test_compute_rarity_boundaries() -> None:
@@ -86,7 +92,9 @@
     assert compute_rarity(40, 0.99) == "common"
 
 
-def test_xp_granted_with_rarity_and_options(client: TestClient) -> None:
+def test_xp_granted_with_rarity_and_options(client: TestClient, monkeypatch: Any) -> None:
+    # редкость случайна — фиксируем roll, чтобы тест не мигал (rare при xp=10 — 5%)
+    monkeypatch.setattr("app.services.xp.random.random", lambda: 0.99)
     task_id = _create_task(client)
     resp = client.patch(
         f"/api/tasks/{task_id}", json={"status": "done", "earned_via": "options"}
@@ -97,11 +105,13 @@
     assert resp.headers.get("X-Options-Close") == "1"
 
     events = client.get("/api/xp/events").json()
-    assert len(events) == 1
-    assert events[0]["task_id"] == task_id
-    assert events[0]["amount"] == 10
-    assert events[0]["rarity"] == "common"
-    assert events[0]["via_options"] is True
+    assert len(events) == 2  # событие создания + событие закрытия
+    close_event = next(e for e in events if e["task_id"] == task_id)
+    assert close_event["amount"] == 10
+    assert close_event["rarity"] == "common"
+    assert close_event["via_options"] is True
+    created_event = next(e for e in events if e["task_id"] is None)
+    assert created_event["kind"] == "create_task"
 
     # закрытие из обычного списка — via_options не ставится
     task2 = _create_task(client)
@@ -142,3 +152,50 @@
     resp = client.patch(f"/api/tasks/{task_id}", json={"status": "done"})
     assert resp.headers.get("X-Earned-XP") == "10"
     assert "X-Mentally-Hard" not in resp.headers
+
+
+# --- Микронаграды за создание (ТЗ 3.13) ---
+
+
+def test_project_creation_reward(client: TestClient) -> None:
+    resp = client.post("/api/projects", json={"name": "Проект награды"})
+    assert resp.status_code == 200
+    assert resp.headers.get("X-Created-XP") == "5"
+    assert resp.headers.get("X-Created-Coins") == "2"
+
+    # XP проекта в суммарный опыт входит, счётчик закрытий — нет
+    summary = client.get("/api/xp").json()
+    assert summary["total_xp"] == 5
+    assert summary["completed_count"] == 0
+    events = client.get("/api/xp/events").json()
+    assert [e["kind"] for e in events] == ["create_project"]
+
+    # Сад: событие создания не рождает растение
+    state = client.get("/api/garden").json()
+    assert state["balance"] == 2
+    assert not [i for i in state["items"] if i["kind"] == "plant"]
+
+
+def test_task_creation_reward_counts_in_xp_but_not_plants(client: TestClient) -> None:
+    client.post("/api/tasks", json={"title": "Только создание"})
+    summary = client.get("/api/xp").json()
+    assert summary["total_xp"] == 2
+    assert summary["completed_count"] == 0
+
+    state = client.get("/api/garden").json()
+    assert state["balance"] == 1
+    assert not [i for i in state["items"] if i["kind"] == "plant"]
+
+
+# --- Ежедневная награда (ТЗ 3.13) ---
+
+
+def test_daily_reward_once_per_day(client: TestClient) -> None:
+    first = client.post("/api/xp/daily")
+    assert first.status_code == 200
+    assert first.json() == {"granted": True, "coins": 50}
+
+    # Повторный визит в те же сутки — молча, без начисления
+    second = client.post("/api/xp/daily")
+    assert second.json() == {"granted": False, "coins": 0}
+    assert client.get("/api/garden").json()["balance"] == 50
diff --git a/docs/TZ.md b/docs/TZ.md
index 7bc0214..732a859 100644
--- a/docs/TZ.md
+++ b/docs/TZ.md
@@ -4,8 +4,8 @@
 
 | | |
 |---|---|
-| Версия ТЗ | 0.16 |
-| Дата | 2026-09-20 |
+| Версия ТЗ | 0.24 |
+| Дата | 2026-09-21 |
 | Статус | На обсуждении |
 
 ---
@@ -107,6 +107,10 @@
 ### 3.6. Представления задач
 
 - **Классический вид**: список с фильтрами (проект, тег, статус, приоритет).
+- **Пагинация**: длинные списки (список задач, стек на главной, задачи проекта,
+  проекты, архив) разбиваются на страницы **по 30 элементов**; навигация кнопками
+  (‹ номера ›, с усечением «…» и подписью «Страница N из M»). Смена фильтров
+  возвращает на первую страницу; при одной странице контрол не показывается.
 - Подзадачи показываются карточками внутри задачи и в списке; представление
   «дерево» убрано (проба 0.5 показала, что оно мешает — возможен возврат позже).
   Связь подзадачи с родителем (`parent_task_id`) в модели данных сохраняется.
@@ -121,17 +125,34 @@
 
 ### 3.8. Проекты
 
-- Статус **актуальности** проекта (активен / приостановлен / закрыт).
+- Статус **актуальности** проекта (активен / приостановлен; «закрыт» выражается архивом, см. 3.8.1).
 - **Приоритет** проекта.
 - **Заметка к проекту**: Markdown-поле для ссылок на ресурсы проекта и прочего контекста; заметка — тот же «документ», что и описание задачи: в неё можно вставлять изображения из буфера (Ctrl+V).
 
-### 3.9. Режим выбора («3 варианта»)
+#### 3.8.1. Архив
 
-Анти-прокрастинационный режим: пользователь указывает доступное время (например, «3 часа»), система предлагает **3 варианта задач**, подходящих под это время; пользователь выбирает один и выполняет сразу.
+Проект, с которым пользователь закончил работу, **отправляется в архив** — один архив
+на все проекты, отдельных архивов задач нет.
+
+- Архивация — с подтверждением («Отправить проект и его N задач в архив?»).
+- Архивный проект пропадает из рабочих видов: списка проектов, фильтров, выдачи
+  задачи (3.9); его задачи не видны в активных списках задач. **Задачи живут и
+  уезжают в архив только вместе с проектом**: отдельной архивации/удаления
+  для задач внутри проекта нет (удаление отдельной задачи остаётся — гигиена).
+- Статистика и XP не пересчитываются: закрытия в архивных проектах остаются в истории.
+- **Страница «Архив»** (отдельный раздел меню): история архивных проектов —
+  открытие проекта, все задачи, заметка. Восстановление возвращает проект
+  со всеми задачами и статусами как были. Доступно и «удалить навсегда».
+- У архивного проекта страница доступна на чтение (с плашкой «в архиве»);
+  создание задач и правки спрятаны.
+
+### 3.9. Выдача задачи (бывший режим «3 вариантов»)
+
+Анти-прокрастинационный режим: пользователь указывает доступное время в часах (например, «3», можно 0.5), система предлагает подходящие задачи; предложение — те же карточки, что в списке задач.
 
 - Выбор кандидатов учитывает: прогнозируемую длительность ≤ доступного времени, приоритеты, статус актуальности проектов.
-- Варианты должны быть осмысленно разными (не три дубликата).
-- После выбора — прямой переход к выполнению задачи (отметка начала, быстрый доступ к описанию).
+- Варианты должны быть осмысленно разными (не дубликаты).
+- Отдельной кнопки выбора/выполнения на странице выдачи нет: пользователь открывает карточку задачи (переход несёт `?via=options`) и берёт её в работу на странице задачи; закрытие задачи, открытой из выдачи, помечается «выбрал и сделал».
 
 ### 3.10. MCP-интерфейс
 
@@ -170,10 +191,24 @@
 
 - **XP за закрытие задачи**: база 10 + бонус за приоритет (0–15) + бонус за
   объём по оценке времени (0–15). Начисление — один раз на задачу (идемпотентно);
-  удаление задачи не отнимает заработанное. Хранение — таблица `xp_events`.
+  удаление задачи не отнимает заработанное. Хранение — таблица `xp_events`
+  (поле `kind` разделяет события: `task` — закрытие, `create_task` /
+  `create_project` — создание).
+- **Микронаграды за создание** (без конфетти — скромный тост «+N XP • +M монет»):
+  создание задачи — +2 XP и +1 монета, создание проекта — +5 XP и +2 монеты.
+  В суммарный опыт (уровень) входят, растений в саду не рождают, счётчик
+  закрытых задач не увеличивают; хранятся с `task_id = NULL` — удаление задачи
+  или проекта награду не отнимает.
+- **Ежедневная награда за визит**: при открытии приложения фронт запрашивает
+  `POST /api/xp/daily` — раз в сутки (граница дня UTC) начисляется **50 монет**
+  (только монеты, XP нет), повторные визиты в те же сутки молча пропускаются.
+  Тост «+50 монет» только в день первого визита.
 - **Уровень**: растёт из суммарного XP (уровень не падает); прогресс до следующего
   уровня и **название звания** показываются в «Саду». Звания ботанические
-  (Росток, Сеянцев, Садовник, … Легенда сада — 10 званий).
+  (Росток, Сеянцев, Садовник, … Легенда сада — 13 званий; порог уровня
+  L = 100·L·(L−1)/2 XP). **Дерево уровней** — модалка со списком всех уровней:
+  звание, порог XP, что открывается (виды растений с ценой семени и
+  premium-пометкой, расширения карты); пройденные отмечены, текущий подсвечен.
 - **Момент награды**: при закрытии задачи — короткая конфетти-анимация и тост
   «+N XP» с похвалой. Особые закрытия (редкое растение, крупная задача) —
   усиленное «золотое» конфетти.
@@ -187,7 +222,7 @@
   - **Отрисовка сцены** — пиксель-арт на **PixiJS 8** (WebGL): `nearest`
     масштабирование без сглаживания, целочисленный «нативный пиксель» (матрицы
     16px × 2 = 32px на клетку). Все спрайты (тайлы травы/дикой земли, изгородь,
-    домик, 6 видов растений × 3 стадии, декорации, кольца редкости, блёстки)
+    домик, 13 видов растений × 3 стадии, декорации, кольца редкости, блёстки)
     генерируются из пиксель-матриц прямо в коде — внешних файлов-ассетов нет.
     Рендерер (`src/game/GardenRenderer.ts`) — обычный класс, **не** оборачивается
     во Vue-reactive (deep-прокси ломает внутренние identity-проверки Pixi);
@@ -211,17 +246,38 @@
   момент рождения** (premium-виды — только для rare/epic закрытий), и
   фиксируется за растением (`garden_items.item_key`) — открытые позже виды не
   перерисовывают старые растения. Растение привязано к событию XP (переживает
-  удаление задачи). Каталог видов — в маркете сада с замками «откроется на
-  уровне N».
+  удаление задачи).
+- **Семена растений** (покупка видов за монеты): в маркете блок **«Семена
+  растений»** — открытые уровнем виды продаются семенами (цены 30–1200 по
+  «дороговизне» вида; 13 видов, открытие растянуто по уровням 1–13 —
+  прогрессия рассчитана примерно на 300 закрытых задач при среднем
+  ~26 XP за закрытие). Покупка кладёт растение-росток в **инвентарь** (как
+  декорации); перетаскивание из инвентаря на свободную клетку сажает его.
+  Размещённое семя обратно в инвентарь вернуть нельзя (сад только растёт);
+  редкость — common, задача-родитель отсутствует. Доступность семени — по
+  уровню вида (🔒 «откроется на уровне N»), независимо от premium-флага вида
+  (вопрос о premium-видах в семенах — открыт, см. раздел 8).
 - **Рост растений за монеты**: растение растёт стадиями росток → куст →
   цветение, каждая стадия покупается монетами (цена по редкости:
   common 20/50, rare 40/100, epic 80/200). Автороста по времени нет.
 - **Маркет сада**: в модалке — **расширения карты** (первым блоком),
-  **декорации** и **каталог видов**. У каждой покупки три состояния: 🔒
-  «откроется на уровне N» (если уровень не открывает), цена золотом (кнопка
-  активна), цена серым + «не хватает N монет».
-  - **Декорации** — чисто косметика: фонарь, лавочка, поилка, пруд, беседка
-    (уникальные), изгородь и клумба (повторяемые). Двигаются как растения.
+  **декорации**, **семена растений** и каталог видов (справка о редкости).
+  У каждой покупки три состояния: 🔒 «откроется на уровне N» (если уровень
+  не открывает), цена золотом (кнопка активна), цена серым + «не хватает
+  N монет».
+  - **Декорации** — чисто косметика: фонарь, лавочка, поилка, пруд, беседка,
+    флюгер, скворечник, садовый самоцвет, теплица (уникальные), изгородь,
+    клумба и куст (повторяемые). Двигаются как растения. **Изгородь —
+    самосоединяющиеся секции**: текстура выбирается по маске соседей (N/E/S/W),
+    секция соединяется только с соседними секциями изгороди. **Постройки
+    в изометрии (домик, теплица, беседка) — крупная изометрия 2:1** (домик
+    с двором, теплица со стеклянными стенами и каркасом, беседка с площадкой
+    у входа). Дорожки убраны (не прижились — сложность рендера и соединений).
+  - **Подпись выбранного объекта**: клик по любому объекту сада (растение
+    или декорация) показывает у клетки чип с иконкой и названием
+    («Скворечник», «Куст», «Подсолнух»); у растений одновременно открывается
+    поповер роста. Повторный клик по объекту или клик по пустому месту
+    снимает выбор.
   - **Инвентарь декораций**: покупка кладёт декорацию в **инвентарь** под картой
     (`garden_items.x/y = NULL`) — место покупки всегда видно пользователю. Из
     инвентаря декорация перетаскивается на карту; перетаскивание размещённой
@@ -229,12 +285,13 @@
     инвентарь вернуть нельзя — сад только растёт).
   - **Расширения карты**: стартовая сетка 32×20 ячеек; каждое расширение
     (+8 клеток периметра) открывается уровнем (I — ур. 3, II — ур. 5,
-    III — ур. 8) и покупается монетами (100/250/500). Финал ~56×44.
+    III — ур. 8, IV — ур. 9, V — ур. 11) и покупается монетами
+    (100/250/500/750/1000). Финал ~72×60.
 - **Ачивки с тирами**: у каждой ачивки ступени I/II/III (например, 10/50/100
   задач), прогресс к следующей ступени виден всегда. Набор: вехи закрытий,
   уровни, макс. задач за день, разные проекты, суммарные часы, строгие
-  дедлайны, закрытия через режим «3 вариантов» (см. 3.9), регулярная, проект.
-- **Связка с «3 вариантами»** (3.9): закрытие задачи из режима помечается
+  дедлайны, закрытия через выдачу задачи (см. 3.9), регулярная, проект.
+- **Связка с выдачей задачи** (3.9): закрытие задачи, открытой из выдачи, помечается
   (`earned_via`) и празднуется меткой «выбрал и сделал» + счётчик-ачивкой;
   XP при этом не меняется.
 - **Страница «Статистика»**: закрываемость за выбранный **день / неделю / месяц**
@@ -255,6 +312,41 @@
 - **Справка «О саде»**: кнопка на странице сада открывает модалку с объяснением
   механик (XP, уровни, растения и редкости, ачивки, принцип «только позитив»).
 
+### 3.14. Реактивность: серверные события (SSE)
+
+Данные меняются не только из UI: MCP-агенты (3.10) и фоновая автодетализация (3.2)
+пишут в БД вне HTTP-запроса. Все виды обновляются событиями от сервера — без
+обновления страницы и переходов между страницами.
+
+- **Эндпоинт**: `GET /api/events` (авторизация штатная, 401 — на вход).
+  Транспорт — **SSE** (`text/event-stream`), по одному соединению на вкладку
+  (`EventSource`, авто-reconnect браузером). Keep-alive: при тишине дольше 20 с
+  сервер шлёт кадр `ping`, чтобы прокси (Vite dev, nginx) не рвал поток.
+- **Модель — грубозернистые события**: событие это `kind` + опциональные данные;
+  фронт реагирует **refetch'ем** (перечитывает данные целиком), а не патчами.
+  Трейлинг-debounce 300 мс коалесцирует бёрсты (закрытие задачи = 2–3 события).
+  Виды подписываются на свои kind'ы: стек/список — `task.changed`,
+  `task.deleted`, `detail.changed`, `project.changed`, `project.deleted`;
+  статистика — `xp.changed`, `task.changed`; сад — `garden.changed`, `xp.changed`,
+  `task.changed` (рефetch подавляется на время drag по сцене); страница задачи —
+  перечитывается при `task.changed`/`detail.changed` своего `id`.
+- **Точки публикации** (строго после коммита транзакции): HTTP-хендлеры задач,
+  проектов, сада, XP-дейли и настроек; MCP-инструменты и фоновая детализация —
+  broadcast (всем вкладкам). Список kind'ов: `task.changed {id}`,
+  `task.deleted {id}`, `detail.changed {id}`, `project.changed {id}`,
+  `project.deleted {id}`, `garden.changed {reason}`, `xp.changed {amount?,
+  celebrate}`, `settings.changed`, `ready` (первый кадр), `ping`.
+  Упрощение: закрытие задачи через MCP не шлёт `garden.changed` — растение
+  создаётся лениво, refetch по `task.changed` покрывает.
+- **Дедуп XP-тостов**: действие своей вкладки празднуется по заголовкам ответа
+  (`X-Earned-XP`, ТЗ 3.13); SSE-эхо и эхо соседней вкладки молчат — окно
+  активности 3 с (localStorage). Соседние вкладки показывают скромный тост
+  «+N XP» без конфетти.
+- **Reconnect**: при обрыве — backoff 1→2→5→15 с; 401 при проверке сессии —
+  редирект на вход; после переподключения — форс-рефреш всех открытых видов
+  (данные за время разрыва могли измениться).
+
+
 ## 4. Нефункциональные требования
 
 | Требование | Значение |
@@ -269,6 +361,7 @@
 | Упаковка | В итоге всё пакуется в **Docker** (docker-compose: API, PostgreSQL, фронт, Ollama + модель) |
 | Мобильность | На старте — **только PWA**; Android-приложение — вне скоупа стартовой версии (вернуться к нему позже) |
 | Приватность | Все данные и LLM-вызовы — на собственном сервере |
+| Реактивность | SSE (`/api/events`): грубозернистые события + refetch, см. 3.14 |
 
 Внешние зависимости проекта (не форкать, обновлять через пакетный менеджер):
 
@@ -300,7 +393,9 @@
 
 Project
   id, name
-  relevance_status  active | paused | archived   — статус актуальности
+  relevance_status  active | paused               — статус актуальности
+  is_archived       bool — архив (3.8.1): проект и его задачи скрыты
+                    из рабочих видов, восстановимы из «Архива»
   priority
   note              markdown — живёт в Document (owner_type = project):
                     ссылки, контекст, картинки
@@ -334,17 +429,19 @@
 ```
 ┌─────────────┐     ┌────────────────────── VPS (docker-compose) ─────────────┐
 │  Web SPA    │────▶│  API (FastAPI) ──▶ PostgreSQL                           │
-│  Vue 3 +    │     │       │                                                 │
-│  gnexus-    │     │       ├──▶ Сервис автодетализации ──▶ Ollama (модель    │
-│  ui-kit     │     │       │      — LLM, модель из конфига)                  │
-└─────────────┘     │       ├──▶ Хранилище вложений (файлы)                   │
-                    │       └──▶ MCP-сервер (для ИИ-агентов)                  │
+│  Vue 3 +    │     │   ▲    │                                                │
+│  gnexus-    │     │   │    ├──▶ Сервис автодетализации ──▶ Ollama (модель    │
+│  ui-kit     │     │   │    │      — LLM, модель из конфига)                  │
+└─────────────┘     │   │    ├──▶ Хранилище вложений (файлы)                   │
+      ▲             │   │    └──▶ MCP-сервер (для ИИ-агентов)                  │
+      └─ SSE ───────┤ шина событий (realtime)                                  │
                     └─────────────────────────────────────────────────────────┘
                                      ▲ SSO auth.gnexus.space (клиент gnexus-gauth)
 ```
 
 - API и MCP-сервер — одно Python-приложение (общая бизнес-логика).
 - Вложения — файлы на диске VPS + метаданные в БД.
+- Изменения данных публикуются в шину событий и уходят в SPA по SSE (3.14).
 
 ## 7. Этапы разработки (предложение)
 
@@ -354,7 +451,7 @@
 | M1 — MVP задач | CRUD задач, быстрый ввод, стек входящих, теги, проекты (базово), ручная детализация |
 | M2 — детализация | Интеграция Ollama + модель из конфига, автопредзаполнение метаданных, подтверждение/редактирование, Markdown-редактор, вложения из буфера |
 | M3 — структура | Подзадачи (parent_task_id), классический список с фильтрами, заметки проектов |
-| M4 — умность | Прогнозирование времени, бюджет, режим «3 варианта» |
+| M4 — умность | Прогнозирование времени, бюджет, выдача задачи |
 | M5 — MCP | MCP-сервер, инструменты для агентов |
 | M6 — мобильность | PWA (Android-приложение — позже, вне стартового скоупа) |
 | M7 — упаковка | Docker (docker-compose: API, PostgreSQL, фронт, Ollama + модель) |
@@ -370,4 +467,6 @@
 5. **Модель для Ollama**: какая конкретно модель и параметры (в конфиг, но нужно выбрать для проверки M2).
 6. **Практическое различие `cancelled` / `deferred`**: определения зафиксированы (3.4), но поведение в интерфейсе почти одинаковое — скрыть из активных списков и оставить доступным для возврата. Уточнить при проектировании представлений, нужны ли оба статуса или их поведение сольётся.
 7. **Анти-дюп награды за статус**: убедиться, что перевод задачи в «завершена» и обратно (и повторное закрытие) **не** начисляет XP/монеты/растение повторно — идемпотентность начисления при любых переключениях статуса (лазейка для дюпа награды). Проверить и покрыть тестом.
-8. ~~**Пиксель-арт сцена сада**~~ — **решено 2026-09-20**: сцена переведена на пиксель-арт (PixiJS 8, WebGL); спрайты генерируются из пиксель-матриц в коде (без внешних ассетов и лицензий), см. 3.13.
\ No newline at end of file
+8. ~~**Пиксель-арт сцена сада**~~ — **решено 2026-09-20**: сцена переведена на пиксель-арт (PixiJS 8, WebGL); спрайты генерируются из пиксель-матриц в коде (без внешних ассетов и лицензий), см. 3.13.
+9. **Premium-виды в семенах**: premium-виды (сейчас кактус) рождаются только из rare/epic закрытий — «отпечаток крупной работы». Семена же продаются за монеты и дают common-растение; сейчас семя premium-вида купить можно. Оставить ли покупку семян premium-видов (простой доступ к виду) или запретить (эксклюзив rare/epic сохраняется) — решить.
+10. **Самосоединяющийся забор**: секции изгороди автоматически соединяются с соседними секциями (маска соседей N/E/S/W → текстура); ручного поворота нет. Соединяются только соседние секции забора — диагонали не считаются. Подтвердить, что поведение устраивает.
\ No newline at end of file
diff --git a/frontend/src/App.vue b/frontend/src/App.vue
index b449560..d20e285 100644
--- a/frontend/src/App.vue
+++ b/frontend/src/App.vue
@@ -4,6 +4,7 @@
 import { useRoute } from 'vue-router'
 import { api } from './api'
 import { resolveLocale } from './i18n/locale'
+import { startRealtime } from './realtime'
 import { setCurrency } from './taskui'
 import GamifyBridge from './components/GamifyBridge.vue'
 import type { UserInfo } from './types'
@@ -14,11 +15,13 @@
 const accountUrl = ref('')
 const navItems = computed(() => [
   { id: 'home', label: t('nav.home'), icon: 'ph-house', to: '/' },
-  { id: 'garden', label: t('nav.garden'), icon: 'ph-leaf', to: '/garden' },
-  { id: 'stats', label: t('nav.stats'), icon: 'ph-chart-bar', to: '/stats' },
+  { id: 'options', label: t('nav.options'), icon: 'ph-shuffle', to: '/options' },
   { id: 'list', label: t('nav.list'), icon: 'ph-list-bullets', to: '/list' },
   { id: 'projects', label: t('nav.projects'), icon: 'ph-folders', to: '/projects' },
-  { id: 'options', label: t('nav.options'), icon: 'ph-shuffle', to: '/options' },
+  { id: 'garden', label: t('nav.garden'), icon: 'ph-leaf', to: '/garden' },
+  { id: 'stats', label: t('nav.stats'), icon: 'ph-chart-bar', to: '/stats' },
+  // архив — редко используемый раздел, предпоследний пункт
+  { id: 'archive', label: t('nav.archive'), icon: 'ph-archive', to: '/archive' },
   { id: 'settings', label: t('nav.settings'), icon: 'ph-gear-six', to: '/settings' },
 ])
 
@@ -28,6 +31,7 @@
   // глубокие страницы: задача → страница задачи, проект → раздел проектов
   if (route.path.startsWith('/tasks/')) return t('nav.task')
   if (route.path.startsWith('/projects/')) return t('nav.projects')
+  if (route.path.startsWith('/archive')) return t('nav.archive')
   return 'GNexus Tasks'
 })
 
@@ -37,6 +41,9 @@
     const data = await res.json()
     user.value = data.user
     accountUrl.value = data.account_url ?? ''
+    // SSE-события (ТЗ 3.14): только для авторизованных — иначе EventSource
+    // будет бесконечно ловить 401
+    startRealtime()
   }
   // валюта и язык — глобальные настройки; язык без переопределения берётся из SSO
   try {
@@ -139,11 +146,16 @@
 .app-content .page-header::after {
   display: none;
 }
-/* меню в шапке прижимается к правому краю кнопки (left:0 кита вылетает за вьюпорт) */
+/* меню в шапке прижимается к правому краю кнопки (left:0 кита вылетает за вьюпорт);
+   общий в пределах экрана фикс — installDropdownClamp (JS) в main.ts */
 .page-header .dropdown.is-open .dropdown-menu {
   left: auto;
   right: 0;
 }
+/* страховка: меню не шире экрана (длинные пункты переносятся) */
+.dropdown-menu {
+  max-width: calc(100vw - 16px);
+}
 /* иконки в заголовках карточек — тёмные, не выпячиваются */
 .app-content .card .card-title-icon {
   color: #3b4261;
@@ -170,7 +182,6 @@
   top: -16px;
   width: 9px;
   height: 14px;
-  border-radius: 2px;
   animation-name: confetti-fall;
   animation-timing-function: ease-in;
   animation-fill-mode: forwards;
diff --git a/frontend/src/api.ts b/frontend/src/api.ts
index dd89a9a..07d6280 100644
--- a/frontend/src/api.ts
+++ b/frontend/src/api.ts
@@ -1,5 +1,6 @@
 // Мини-клиент API. Ошибки авторизации редиректят на вход.
 import i18n from './i18n'
+import { markOwnActivity } from './realtime'
 
 export interface Tag {
   id: number
@@ -10,6 +11,7 @@
   id: number
   name: string
   relevance_status: string
+  is_archived: boolean
   priority: number | null
   note: string
   document_id: number | null
@@ -98,6 +100,7 @@
 
 export interface XpEvent {
   task_id: number | null
+  kind: 'task' | 'create_task' | 'create_project'
   amount: number
   rarity: string
   via_options: boolean
@@ -132,6 +135,7 @@
   level: number
   premium: boolean
   unlocked: boolean
+  seed_cost: number
 }
 
 export interface GardenExpansion {
@@ -147,6 +151,7 @@
   items: GardenItem[]
   decorations: { key: string; cost: number; unique: boolean }[]
   next_expansion: GardenExpansion | null
+  expansions: GardenExpansion[] // все расширения — для дерева уровней
   expansions_bought: number
   species: GardenSpecies[]
   upgrade_costs: Record<string, [number, number]>
@@ -174,9 +179,11 @@
     throw new ApiError(res.status, body.detail ?? i18n.global.t('common.error'))
   }
   // Геймификация: бэк помечает закрытие задачи заголовками (XP, редкость, «3 варианта»,
-  // «ментально сложная»)
+  // «ментально сложная»). Заголовки = собственное действие: отметка для дедупа
+  // SSE-эха (realtime.ts, окно 3 с)
   const earned = res.headers.get('X-Earned-XP')
   if (earned) {
+    markOwnActivity()
     earnedXpBuffer = {
       xp: Number(earned) || 0,
       coins: Number(res.headers.get('X-Earned-Coins')) || 0,
@@ -185,6 +192,15 @@
       hard: res.headers.get('X-Mentally-Hard') === '1',
     }
   }
+  // Микронаграда за создание (задача/проект): без конфетти, просто тост
+  const createdXp = res.headers.get('X-Created-XP')
+  if (createdXp) {
+    markOwnActivity()
+    createdRewardBuffer = {
+      xp: Number(createdXp) || 0,
+      coins: Number(res.headers.get('X-Created-Coins')) || 0,
+    }
+  }
   return res.json() as Promise<T>
 }
 
@@ -205,6 +221,20 @@
   return value
 }
 
+// Микронаграда за создание (задача/проект): забирается через takeCreatedReward
+export interface CreatedReward {
+  xp: number
+  coins: number
+}
+
+let createdRewardBuffer: CreatedReward | null = null
+
+export function takeCreatedReward(): CreatedReward | null {
+  const value = createdRewardBuffer
+  createdRewardBuffer = null
+  return value
+}
+
 export const api = {
   // tasks
   listTasks: (params: Record<string, string | number | null | undefined> = {}) => {
@@ -254,13 +284,18 @@
     request<{ ok: boolean }>(`/api/attachments/${id}`, { method: 'DELETE' }),
   // Ссылка на файл вложения (нужна сессионная cookie — просто <img src>)
   attachmentUrl: (id: number) => `/api/attachments/${id}/file`,
-  // projects
-  listProjects: () => request<Project[]>('/api/projects'),
+  // projects (архив — ТЗ 3.11: archived=true отдаёт историю)
+  listProjects: (archived = false) =>
+    request<Project[]>(`/api/projects?archived=${archived}`),
   getProject: (id: number) => request<Project>(`/api/projects/${id}`),
   createProject: (name: string) =>
     request<Project>('/api/projects', { method: 'POST', body: JSON.stringify({ name }) }),
   updateProject: (id: number, patch: Partial<Omit<Project, 'id'>>) =>
     request<Project>(`/api/projects/${id}`, { method: 'PATCH', body: JSON.stringify(patch) }),
+  archiveProject: (id: number) =>
+    request<Project>(`/api/projects/${id}/archive`, { method: 'POST' }),
+  restoreProject: (id: number) =>
+    request<Project>(`/api/projects/${id}/restore`, { method: 'POST' }),
   deleteProject: (id: number) =>
     request<{ ok: boolean }>(`/api/projects/${id}`, { method: 'DELETE' }),
   // tags
@@ -274,6 +309,9 @@
   // геймификация (ТЗ 3.13)
   getXp: () => request<XpSummary>('/api/xp'),
   getXpEvents: () => request<XpEvent[]>('/api/xp/events'),
+  // дейли-награда за визит (раз в сутки, идемпотентно)
+  claimDaily: () =>
+    request<{ granted: boolean; coins: number }>('/api/xp/daily', { method: 'POST' }),
   // сад (ТЗ 3.13)
   getGarden: () => request<GardenState>('/api/garden'),
   moveGardenItem: (id: number, x: number | null, y: number | null) =>
diff --git a/frontend/src/components/ConfirmDialog.vue b/frontend/src/components/ConfirmDialog.vue
new file mode 100644
index 0000000..f7fbd3f
--- /dev/null
+++ b/frontend/src/components/ConfirmDialog.vue
@@ -0,0 +1,47 @@
+<script setup lang="ts">
+// Диалог подтверждения поверх GnConfirmDialog кита. У кита порядок кнопок
+// зашит («Отмена» слева), вариант и иконка кнопки подтверждения не настраиваются
+// — собираем на публичных GnModal + GnButton: подтверждение первым, у кнопки
+// опциональная иконка. Поведение то же: confirm/cancel закрывают диалог.
+const props = defineProps<{
+  open: boolean
+  title: string
+  message?: string
+  confirmText: string
+  cancelText: string
+  /** Вариант кнопки подтверждения (warning/danger/...) */
+  confirmVariant?: string
+  /** Иконка на кнопке подтверждения (например ph-trash) */
+  confirmIcon?: string
+}>()
+
+const emit = defineEmits<{
+  'update:open': [value: boolean]
+  confirm: []
+  cancel: []
+}>()
+
+function confirm() {
+  emit('confirm')
+  emit('update:open', false)
+}
+
+function cancel() {
+  emit('cancel')
+  emit('update:open', false)
+}
+</script>
+
+<template>
+  <GnModal :open="props.open" :title="props.title" @update:open="emit('update:open', $event)">
+    <slot>
+      <p v-if="props.message">{{ props.message }}</p>
+    </slot>
+    <template #actions>
+      <GnButton :variant="props.confirmVariant ?? 'primary'" :icon="props.confirmIcon" @click="confirm">
+        {{ props.confirmText }}
+      </GnButton>
+      <GnButton variant="primary" @click="cancel">{{ props.cancelText }}</GnButton>
+    </template>
+  </GnModal>
+</template>
\ No newline at end of file
diff --git a/frontend/src/components/Dashboard.vue b/frontend/src/components/Dashboard.vue
index 7411719..1192706 100644
--- a/frontend/src/components/Dashboard.vue
+++ b/frontend/src/components/Dashboard.vue
@@ -9,9 +9,8 @@
 import {
   deadlineLabel,
   deadlineOverdue,
-  priorityLabel,
-  priorityVariant,
 } from '../taskui'
+import PriorityBadge from './PriorityBadge.vue'
 
 const props = defineProps<{
   tasks: Task[]
@@ -133,9 +132,7 @@
             <div v-for="task in section.tasks" :key="`${section.key}-${task.id}`" class="dash-task">
               <RouterLink class="dash-task-title" :to="`/tasks/${task.id}`">{{ task.title }}</RouterLink>
               <div class="dash-task-badges">
-                <GnBadge v-if="task.priority !== null" :variant="priorityVariant(task.priority)">
-                  <i class="ph ph-flag" aria-hidden="true" />{{ priorityLabel(task.priority) }}
-                </GnBadge>
+                <PriorityBadge v-if="task.priority !== null" :priority="task.priority" />
                 <GnBadge
                   v-if="deadlineLabel(task)"
                   :variant="deadlineOverdue(task) ? 'error' : 'warning'"
diff --git a/frontend/src/components/DurationInput.vue b/frontend/src/components/DurationInput.vue
new file mode 100644
index 0000000..9aa69e7
--- /dev/null
+++ b/frontend/src/components/DurationInput.vue
@@ -0,0 +1,119 @@
+<script setup lang="ts">
+import { ref, watch } from 'vue'
+import { useI18n } from 'vue-i18n'
+
+// Ввод длительности: два поля — часы и минуты (минуты с шагом 5). Заставлять
+// пользователя переводить время в минуты не нужно. Значение компонента —
+// минуты (число|null), как в API; часы/минуты раскладываются при вводе и
+// собираются обратно при изменении. Оба поля пустые = null («не указано»).
+
+const props = defineProps<{
+  modelValue: number | null
+  /** Общая подпись блока; в инлайн-редакторах подпись даёт строка параметров */
+  label?: string
+  /** Минимальное суммарное значение в минутах (0 = можно пусто) */
+  min?: number
+}>()
+
+const emit = defineEmits<{ 'update:modelValue': [value: number | null] }>()
+
+const { t } = useI18n()
+
+const hoursText = ref('')
+const minutesText = ref('')
+
+function toNumber(text: string): number | null {
+  const trimmed = text.trim()
+  if (trimmed === '') return null
+  const n = Number(trimmed)
+  return Number.isFinite(n) ? n : null
+}
+
+// внешнее значение → поля (загрузка задачи, сброс формы)
+watch(
+  () => props.modelValue,
+  (v) => {
+    if (v === null || v === undefined) {
+      hoursText.value = ''
+      minutesText.value = ''
+      return
+    }
+    hoursText.value = String(Math.floor(v / 60))
+    minutesText.value = String(v % 60)
+  },
+  { immediate: true },
+)
+
+watch([hoursText, minutesText], () => {
+  const h = toNumber(hoursText.value)
+  const m = toNumber(minutesText.value)
+  if (h === null && m === null) {
+    emit('update:modelValue', null)
+    return
+  }
+  let total = Math.max(0, h ?? 0) * 60 + Math.max(0, m ?? 0)
+  const min = props.min ?? 0
+  if (total < min) total = min
+  emit('update:modelValue', total)
+})
+</script>
+
+<template>
+  <span class="duration-input">
+    <span v-if="label" class="duration-label">{{ label }}</span>
+    <span class="duration-fields">
+      <GnInput
+        v-model="hoursText"
+        type="number"
+        min="0"
+        class="hours"
+        :aria-label="t('duration.hours')"
+      />
+      <span class="unit">{{ t('duration.h') }}</span>
+      <GnInput
+        v-model="minutesText"
+        type="number"
+        min="0"
+        max="55"
+        step="5"
+        class="minutes"
+        :aria-label="t('duration.minutes')"
+      />
+      <span class="unit">{{ t('duration.min') }}</span>
+    </span>
+  </span>
+</template>
+
+<style scoped>
+.duration-input {
+  display: inline-flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 0.25rem;
+  min-width: 0;
+}
+.duration-label {
+  font-size: 0.85em;
+  color: var(--text-muted, #888);
+}
+.duration-fields {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.4rem;
+}
+/* GnInput рендерит div.form-group > label > input: убираем вертикальные
+   отступы формы и задаём компактную ширину полей (переопределение размеров,
+   стили кита остаются) */
+.duration-fields :deep(.form-group) {
+  margin: 0;
+  width: auto;
+}
+.duration-fields :deep(input) {
+  width: 4rem;
+  padding: 4px 10px;
+}
+.unit {
+  color: var(--text-muted, #888);
+  font-size: 0.9em;
+}
+</style>
\ No newline at end of file
diff --git a/frontend/src/components/GamifyBridge.vue b/frontend/src/components/GamifyBridge.vue
index a34447c..8f2e538 100644
--- a/frontend/src/components/GamifyBridge.vue
+++ b/frontend/src/components/GamifyBridge.vue
@@ -2,10 +2,31 @@
 // Регистрация toast-провайдера кита для геймификации: useToast() кит требует
 // вызывать внутри <GnToastProvider> — потому мостик живёт внутри провайдера,
 // а не в App.vue (который провайдер только рендерит).
+import { onMounted } from 'vue'
 import { useToast } from 'gnexus-ui-kit/vue'
-import { initGamification } from '../gamification'
+import { api } from '../api'
+import { initGamification, notifyDaily, notifyRemoteXp } from '../gamification'
+import { onRealtime } from '../realtime'
 
 initGamification(useToast())
+
+// SSE-эхо начисления XP (ТЗ 3.14): своя вкладка празднует по заголовкам ответа,
+// соседние вкладки показывают скромный тост (дедуп wasOwnActivity)
+onRealtime('xp.changed', (e) => {
+  const amount = Number(e.data?.amount)
+  if (e.data?.celebrate) notifyRemoteXp(amount)
+})
+
+// Дейли-награда за визит (ТЗ 3.13): при каждой загрузке приложения спрашиваем
+// бэк — он начисляет 50 монет только раз в сутки, повторные входы молчат
+onMounted(async () => {
+  try {
+    const res = await api.claimDaily()
+    notifyDaily(res.granted, res.coins)
+  } catch {
+    // нет сети/сессии — награда не критична, тихо пропускаем
+  }
+})
 </script>
 
 <template />
\ No newline at end of file
diff --git a/frontend/src/components/GardenScene.vue b/frontend/src/components/GardenScene.vue
index d160136..396417e 100644
--- a/frontend/src/components/GardenScene.vue
+++ b/frontend/src/components/GardenScene.vue
@@ -6,7 +6,7 @@
 import { useI18n } from 'vue-i18n'
 import type { GardenItem, GardenState } from '../api'
 import { dataUrlFor } from '../game/pixelart'
-import { DECOR, PAL } from '../game/sprites'
+import { DECOR, PAL, PLANT_BUILDERS } from '../game/sprites'
 import type { GardenRenderer } from '../game/GardenRenderer'
 
 defineOptions({ name: 'GardenScene' })
@@ -19,16 +19,19 @@
 const emit = defineEmits<{
   move: [id: number, x: number | null, y: number | null]
   upgrade: [id: number]
+  dragging: [dragging: boolean]
 }>()
 
 const { t } = useI18n()
 
 const hostEl = ref<HTMLElement | null>(null)
 const invEl = ref<HTMLElement | null>(null)
+const wrapEl = ref<HTMLElement | null>(null)
 // shallowRef: внутри рендерера — Pixi-объекты; deep-reactive-прокси Vue ломает
 // identity-проверки Pixi (shared defaultScale) → TypeError при первом setHoverCell.
 const renderer = shallowRef<GardenRenderer | null>(null)
 const selected = ref<number | null>(null)
+const isFullscreen = ref(false)
 
 // Неразмещенные декорации (x/y null) — в инвентаре под сценой.
 const inventoryItems = computed(() =>
@@ -46,7 +49,9 @@
   const key = item.item_key ?? 'flowerbed'
   const hit = previewCache.get(key)
   if (hit) return hit
-  const url = dataUrlFor(DECOR[key] ?? DECOR.flowerbed!, PAL, 3)
+  // Растения (семена из маркета) — матрицей стадии «росток»; декорации — своей матрицей
+  const matrix = PLANT_BUILDERS[key] ? PLANT_BUILDERS[key]!(0) : (DECOR[key] ?? DECOR.flowerbed!)
+  const url = dataUrlFor(matrix, PAL, 3)
   previewCache.set(key, url)
   return url
 }
@@ -82,6 +87,16 @@
   renderer.value?.setSelected(null)
 }
 
+// Подпись выбранного объекта (имя у клетки) — для любых кликнутых предметов
+const objNameStyle = computed(() => {
+  const item = selectedItem.value
+  const r = renderer.value
+  if (!item || item.x === null || item.y === null || !r) return { display: 'none' }
+  const p = r.clientPointOfCell(item.x, item.y)
+  const left = Math.max(8, Math.min(window.innerWidth - 150, p.x - 60))
+  return { left: `${left}px`, top: `${p.y + 22}px` }
+})
+
 function onKeydown(e: KeyboardEvent): void {
   if (e.key === 'Escape') closePopover()
 }
@@ -89,6 +104,17 @@
   closePopover()
 }
 
+// --- Полноэкранный режим ---
+
+function onFullscreenChange(): void {
+  isFullscreen.value = document.fullscreenElement === wrapEl.value
+}
+
+function toggleFullscreen(): void {
+  if (document.fullscreenElement) void document.exitFullscreen()
+  else void wrapEl.value?.requestFullscreen()
+}
+
 watch(selected, (id) => renderer.value?.setSelected(id))
 
 // --- Синхронизация состояния (родитель перезагружает state после API) ---
@@ -99,6 +125,13 @@
   { deep: false },
 )
 
+function itemName(item: GardenItem): string {
+  if (!item.item_key) return ''
+  return item.kind === 'plant'
+    ? t(`garden.speciesNames.${item.item_key}`)
+    : t(`garden.decorNames.${item.item_key}`)
+}
+
 // --- Drag из инвентаря: призрак у курсора, бросок на карту размещает ---
 
 const ghost = ref<{ id: number; key: string; x: number; y: number } | null>(null)
@@ -109,6 +142,7 @@
 function onInvPointerDown(item: GardenItem, e: PointerEvent): void {
   e.preventDefault()
   ghost.value = { id: item.id, key: item.item_key ?? 'flowerbed', x: e.clientX, y: e.clientY }
+  emit('dragging', true)
   window.addEventListener('pointermove', onInvMove)
   window.addEventListener('pointerup', onInvUp)
 }
@@ -124,6 +158,7 @@
 function onInvUp(e: PointerEvent): void {
   window.removeEventListener('pointermove', onInvMove)
   window.removeEventListener('pointerup', onInvUp)
+  emit('dragging', false)
   const id = ghost.value?.id
   ghost.value = null
   renderer.value?.setHoverCell(null)
@@ -141,6 +176,7 @@
 onMounted(async () => {
   window.addEventListener('keydown', onKeydown)
   window.addEventListener('scroll', onScroll, { capture: true, passive: true })
+  document.addEventListener('fullscreenchange', onFullscreenChange)
   const { GardenRenderer: R } = await import('../game/GardenRenderer')
   if (!hostEl.value) return
   renderer.value = await R.create(hostEl.value, props.state, {
@@ -148,6 +184,7 @@
     onSelect: (id) => {
       selected.value = id
     },
+    onDragChange: (dragging) => emit('dragging', dragging),
     inventoryRect: () => invEl.value?.getBoundingClientRect() ?? null,
   })
 })
@@ -155,6 +192,7 @@
 onBeforeUnmount(() => {
   window.removeEventListener('keydown', onKeydown)
   window.removeEventListener('scroll', onScroll, { capture: true })
+  document.removeEventListener('fullscreenchange', onFullscreenChange)
   window.removeEventListener('pointermove', onInvMove)
   window.removeEventListener('pointerup', onInvUp)
   renderer.value?.destroy()
@@ -163,13 +201,52 @@
 </script>
 
 <template>
-  <div class="scene-wrap">
-    <!-- Canvas-host: аспект по сетке, рендерер сам растягивает canvas на 100% -->
-    <div
-      ref="hostEl"
-      class="scene"
-      :style="{ aspectRatio: `${state.grid.cols} / ${state.grid.rows}` }"
-    />
+  <div ref="wrapEl" class="scene-wrap" :style="{ '--ar': state.grid.cols / state.grid.rows }">
+    <div class="scene-box">
+      <!-- Canvas-host: аспект по сетке, рендерер сам растягивает canvas на 100% -->
+      <div
+        ref="hostEl"
+        class="scene"
+        :style="{ aspectRatio: `${state.grid.cols} / ${state.grid.rows}` }"
+      />
+
+      <!-- Управление зумом и полноэкранным режимом -->
+      <div class="scene-controls">
+        <button
+          class="ctrl-btn"
+          :title="t('garden.zoomOut')"
+          :aria-label="t('garden.zoomOut')"
+          @click="renderer?.zoomOut()"
+        >
+          <i class="ph ph-magnifying-glass-minus" aria-hidden="true" />
+        </button>
+        <button
+          class="ctrl-btn"
+          :title="t('garden.zoomIn')"
+          :aria-label="t('garden.zoomIn')"
+          @click="renderer?.zoomIn()"
+        >
+          <i class="ph ph-magnifying-glass-plus" aria-hidden="true" />
+        </button>
+        <button
+          class="ctrl-btn"
+          :title="t('garden.zoomReset')"
+          :aria-label="t('garden.zoomReset')"
+          @click="renderer?.resetView()"
+        >
+          <i class="ph ph-arrows-counter-clockwise" aria-hidden="true" />
+        </button>
+        <button
+          class="ctrl-btn"
+          :title="isFullscreen ? t('garden.fullscreenExit') : t('garden.fullscreen')"
+          :aria-label="isFullscreen ? t('garden.fullscreenExit') : t('garden.fullscreen')"
+          @click="toggleFullscreen"
+        >
+          <!-- ph-compress/ph-expand в ките нет — стрелки внутрь/наружу -->
+          <i :class="isFullscreen ? 'ph ph-arrows-in' : 'ph ph-arrows-out'" aria-hidden="true" />
+        </button>
+      </div>
+    </div>
 
     <!-- Поповер роста: DOM поверх canvas, фиксированный у клетки растения -->
     <div
@@ -197,8 +274,14 @@
       </span>
     </div>
 
+    <!-- Название выбранного объекта: подпись у клетки (любой предмет) -->
+    <div v-if="selectedItem" class="obj-name" :style="objNameStyle" @pointerdown.stop>
+      <i :class="selectedItem.kind === 'plant' ? 'ph ph-leaf' : 'ph ph-flower'" aria-hidden="true" />
+      {{ itemName(selectedItem) }}
+    </div>
+
     <!-- Инвентарь: купленные, но не размещённые декорации — drag на карту -->
-    <div v-if="inventoryItems.length" ref="invEl" class="inventory">
+    <div ref="invEl" class="inventory">
       <span class="inv-label">
         <i class="ph ph-package" aria-hidden="true" />
         {{ t('garden.inventory') }}
@@ -207,13 +290,14 @@
         v-for="item in inventoryItems"
         :key="item.id"
         class="inv-chip"
-        :title="item.item_key ? t(`garden.decorNames.${item.item_key}`) : ''"
+        :title="itemName(item)"
         @pointerdown="onInvPointerDown(item, $event)"
       >
         <img :src="chipPreview(item)" alt="" class="inv-img" />
-        <span>{{ item.item_key ? t(`garden.decorNames.${item.item_key}`) : '' }}</span>
+        <span>{{ itemName(item) }}</span>
       </div>
-      <span class="inv-hint">{{ t('garden.inventoryHint') }}</span>
+      <span v-if="!inventoryItems.length" class="inv-hint">{{ t('garden.inventoryEmpty') }}</span>
+      <span v-else class="inv-hint">{{ t('garden.inventoryHint') }}</span>
     </div>
 
     <!-- Призрак перетаскивания из инвентаря -->
@@ -227,13 +311,50 @@
 .scene-wrap {
   margin-bottom: 2rem;
 }
+.scene-box {
+  position: relative;
+}
 .scene {
   width: 100%;
-  border-radius: 12px;
-  border: 1px solid var(--border, #2a2f45);
   overflow: hidden;
   cursor: default;
 }
+/* Кнопки зума/фулскрина над сценой */
+.scene-controls {
+  position: absolute;
+  top: 8px;
+  right: 8px;
+  display: flex;
+  gap: 6px;
+  z-index: 10;
+}
+.ctrl-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 30px;
+  height: 30px;
+  border: 1px solid var(--border, #2a2f45);
+  background: color-mix(in srgb, var(--bg-card, #24283b) 85%, transparent);
+  color: var(--text, #d6dae4);
+  font-size: 15px;
+  cursor: pointer;
+}
+.ctrl-btn:hover {
+  background: color-mix(in srgb, var(--accent, #7aa2f7) 25%, var(--bg-card, #24283b));
+}
+/* Полноэкранный режим: сцена по центру, впишена в экран */
+.scene-wrap:fullscreen {
+  margin: 0;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  background: var(--bg-main, #1a1f2e);
+}
+.scene-wrap:fullscreen .scene-box {
+  width: min(100vw, calc(100vh * var(--ar)));
+}
 /* Поповер роста: fixed у клетки растения */
 .popover-card {
   position: fixed;
@@ -242,20 +363,33 @@
   flex-direction: column;
   gap: 3px;
   padding: 5px;
-  border-radius: 8px;
   background: var(--bg-card, #24283b);
   border: 1px solid var(--border, #2a2f45);
   font-size: 12px;
   line-height: 1.2;
   box-shadow: 0 4px 14px rgba(0, 0, 0, 0.4);
 }
+/* Подпись имени выбранного объекта (скворечник, куст, …) у клетки */
+.obj-name {
+  position: fixed;
+  z-index: 20;
+  display: flex;
+  align-items: center;
+  gap: 5px;
+  padding: 3px 8px;
+  background: var(--bg-card, #24283b);
+  border: 1px solid var(--border, #2a2f45);
+  font-size: 12px;
+  line-height: 1.2;
+  white-space: nowrap;
+  box-shadow: 0 4px 14px rgba(0, 0, 0, 0.4);
+}
 .popover-btn {
   display: flex;
   gap: 4px;
   align-items: center;
   padding: 3px 7px;
   border: none;
-  border-radius: 6px;
   background: var(--success, #9ece6a);
   color: #1a1f2e;
   font-weight: 600;
@@ -289,7 +423,6 @@
   margin-top: 0.6rem;
   padding: 0.6rem 0.75rem;
   border: 1px dashed var(--border, #2a2f45);
-  border-radius: 10px;
 }
 .inv-label {
   display: flex;
@@ -307,7 +440,6 @@
   align-items: center;
   padding: 0.25rem 0.6rem 0.25rem 0.35rem;
   border: 1px solid var(--border, #2a2f45);
-  border-radius: 8px;
   background: color-mix(in srgb, var(--warning, #e0af68) 10%, transparent);
   font-size: 0.85em;
   font-weight: 600;
diff --git a/frontend/src/components/InlineField.vue b/frontend/src/components/InlineField.vue
index 245918b..f3b4dbb 100644
--- a/frontend/src/components/InlineField.vue
+++ b/frontend/src/components/InlineField.vue
@@ -14,6 +14,8 @@
   label: string
   /** Родительский хендлер сохранения; promise → busy, throw → редактор открыт */
   save: () => Promise<unknown> | unknown
+  /** Редактор показывается под полем (на всю ширину), а не в строке значения */
+  below?: boolean
 }>()
 
 const emit = defineEmits<{ open: [] }>()
@@ -52,7 +54,7 @@
     <span v-if="!open" class="inline-display">
       <slot name="display" :edit="edit" />
     </span>
-    <span v-else class="inline-editing">
+    <span v-else class="inline-editing" :class="{ below }">
       <slot name="edit" :save="save" :cancel="cancel" :busy="busy" />
       <span class="inline-actions">
         <GnIconButton
@@ -101,4 +103,23 @@
   gap: 0.25rem;
   flex: none;
 }
+/* режим «под полем»: редактор на всю ширину строки (select/поля + кнопки ✓/✗
+   в один ряд), с внешним отступом снизу — узкие строки (сайдбар параметров)
+   не обрезают формочку */
+.inline-editing.below {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+  width: 100%;
+  margin-bottom: 1rem;
+}
+.inline-editing.below > :not(.inline-actions) {
+  /* width: auto — иначе базис auto у form-group кита (width:100%) выталкивает
+     кнопки ✓/✗ на следующую строку */
+  flex: 1 1 auto;
+  min-width: 0;
+  width: auto;
+}
 </style>
\ No newline at end of file
diff --git a/frontend/src/components/MdEditor.vue b/frontend/src/components/MdEditor.vue
index 2d13382..07914e4 100644
--- a/frontend/src/components/MdEditor.vue
+++ b/frontend/src/components/MdEditor.vue
@@ -249,5 +249,7 @@
 /* кликабельные картинки в предпросмотре */
 .md-preview :deep(img) {
   cursor: zoom-in;
+  max-width: 100%;
+  height: auto;
 }
 </style>
\ No newline at end of file
diff --git a/frontend/src/components/Pagination.vue b/frontend/src/components/Pagination.vue
new file mode 100644
index 0000000..9972d78
--- /dev/null
+++ b/frontend/src/components/Pagination.vue
@@ -0,0 +1,94 @@
+<script setup lang="ts">
+import { computed, watch } from 'vue'
+import { useI18n } from 'vue-i18n'
+
+// Кнопочная пагинация: ‹ 1 … p-1 [p] p+1 … N › (по 30 на страницу).
+// Клиентская нарезка: родитель передаёт total и v-model:page, элементы
+// списка режет computed — списки и так грузятся целиком (фильтры и
+// счётчики зависят от полного набора).
+
+const props = withDefaults(
+  defineProps<{ page: number; total: number; perPage?: number }>(),
+  { perPage: 30 },
+)
+const emit = defineEmits<{ 'update:page': [page: number] }>()
+
+const { t } = useI18n()
+
+const pageCount = computed(() => Math.max(1, Math.ceil(props.total / props.perPage)))
+
+// данные поредели (удаление, смена фильтра) — не остаёмся за последней страницей
+watch(pageCount, (n) => {
+  if (props.page > n) emit('update:page', n)
+})
+
+// номера страниц с усечением: края + соседние с текущей, между ними «…»
+const pages = computed<(number | '…')[]>(() => {
+  const n = pageCount.value
+  const cur = props.page
+  if (n <= 7) return Array.from({ length: n }, (_, i) => i + 1)
+  const keep = new Set([1, n, cur - 1, cur, cur + 1])
+  const out: (number | '…')[] = []
+  let prev = 0
+  for (let i = 1; i <= n; i++) {
+    if (!keep.has(i)) continue
+    if (prev && i - prev > 1) out.push('…')
+    out.push(i)
+    prev = i
+  }
+  return out
+})
+
+function go(p: number): void {
+  if (p >= 1 && p <= pageCount.value && p !== props.page) emit('update:page', p)
+}
+</script>
+
+<template>
+  <nav v-if="pageCount > 1" class="pagination" :aria-label="t('pagination.aria')">
+    <GnIconButton
+      icon="ph-caret-left"
+      :label="t('pagination.prev')"
+      :disabled="page <= 1"
+      @click="go(page - 1)"
+    />
+    <template v-for="(p, i) in pages" :key="`${p}-${i}`">
+      <span v-if="p === '…'" class="dots">…</span>
+      <GnButton
+        v-else
+        size="sm"
+        :variant="p === page ? 'primary' : 'secondary'"
+        @click="go(p)"
+      >
+        {{ p }}
+      </GnButton>
+    </template>
+    <GnIconButton
+      icon="ph-caret-right"
+      :label="t('pagination.next')"
+      :disabled="page >= pageCount"
+      @click="go(page + 1)"
+    />
+    <span class="page-info">{{ t('pagination.pageOf', { n: page, m: pageCount }) }}</span>
+  </nav>
+</template>
+
+<style scoped>
+.pagination {
+  display: flex;
+  gap: 0.35rem;
+  align-items: center;
+  justify-content: center;
+  flex-wrap: wrap;
+  margin-top: 1.25rem;
+}
+.dots {
+  color: var(--text-muted, #888);
+  padding: 0 0.2rem;
+}
+.page-info {
+  color: var(--text-muted, #888);
+  font-size: 0.85em;
+  margin-left: 0.5rem;
+}
+</style>
\ No newline at end of file
diff --git a/frontend/src/components/PriorityBadge.vue b/frontend/src/components/PriorityBadge.vue
new file mode 100644
index 0000000..76bb403
--- /dev/null
+++ b/frontend/src/components/PriorityBadge.vue
@@ -0,0 +1,13 @@
+<script setup lang="ts">
+import { priorityLabel, priorityVariant } from '../taskui'
+
+// Бейдж приоритета с иконкой — единый по всему проекту. GnBadge иконку
+// не принимает, `<i>` кладётся в слот (отступ даёт глобальный `.badge .ph`).
+defineProps<{ priority: number }>()
+</script>
+
+<template>
+  <GnBadge :variant="priorityVariant(priority)">
+    <i class="ph ph-flag" aria-hidden="true" />{{ priorityLabel(priority) }}
+  </GnBadge>
+</template>
\ No newline at end of file
diff --git a/frontend/src/components/QuickPrompt.vue b/frontend/src/components/QuickPrompt.vue
index fd8825c..aceabf5 100644
--- a/frontend/src/components/QuickPrompt.vue
+++ b/frontend/src/components/QuickPrompt.vue
@@ -3,7 +3,15 @@
 import { nextTick, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 
-const props = defineProps<{ open: boolean; title: string }>()
+const props = defineProps<{
+  open: boolean
+  title: string
+  /** Подпись поля ввода — без неё поле выглядит «ноунейм» */
+  label?: string
+  placeholder?: string
+  /** Текст подтверждающей кнопки (по умолчанию «Создать») */
+  confirmText?: string
+}>()
 const emit = defineEmits<{
   (e: 'update:open', value: boolean): void
   (e: 'confirm', text: string): void
@@ -18,7 +26,11 @@
   (open) => {
     if (open) {
       text.value = ''
-      void nextTick(() => inputRef.value?.querySelector('input')?.focus())
+      // ref указывает на компонент GnInput — корень достаём из $el
+      void nextTick(() => {
+        const el = (inputRef.value as { $el?: HTMLElement } | null)?.$el ?? inputRef.value
+        if (el instanceof HTMLElement) el.querySelector('input')?.focus()
+      })
     }
   },
 )
@@ -34,12 +46,17 @@
 <template>
   <GnModal :open="open" :title="title" @update:open="emit('update:open', $event)">
     <form class="quick-prompt" @submit.prevent="submit">
-      <GnInput ref="inputRef" v-model="text" />
+      <GnInput
+        ref="inputRef"
+        v-model="text"
+        :label="props.label"
+        :placeholder="props.placeholder"
+      />
       <div class="quick-prompt-actions">
-        <GnButton type="submit" variant="primary" icon="ph-check">
-          {{ t('common.save') }}
+        <GnButton type="submit" variant="success" icon="ph-check">
+          {{ props.confirmText ?? t('common.create') }}
         </GnButton>
-        <GnButton type="button" variant="secondary" @click="emit('update:open', false)">
+        <GnButton type="button" variant="primary" @click="emit('update:open', false)">
           {{ t('common.cancel') }}
         </GnButton>
       </div>
diff --git a/frontend/src/components/TaskBadges.vue b/frontend/src/components/TaskBadges.vue
index d957d7d..fbecbe3 100644
--- a/frontend/src/components/TaskBadges.vue
+++ b/frontend/src/components/TaskBadges.vue
@@ -7,30 +7,38 @@
   deadlineLabel,
   deadlineOverdue,
   formatMinutes,
-  priorityLabel,
-  priorityVariant,
   recurrenceLabel,
   statusIcon,
   statusLabel,
   statusVariant,
 } from '../taskui'
+import PriorityBadge from './PriorityBadge.vue'
 
 defineProps<{ task: Task; hideProject?: boolean }>()
 
 const { t } = useI18n()
+
+// Палитра тегов: цвет — по имени тега (стабильный хеш, один тег всегда одного
+// цвета); оттенки — варианты бейджа кита
+const TAG_VARIANTS = ['info', 'secondary', 'success', 'warning', 'primary'] as const
+
+function tagVariant(name: string): string {
+  let hash = 0
+  for (let i = 0; i < name.length; i++) hash = (hash * 31 + name.charCodeAt(i)) % 9973
+  return TAG_VARIANTS[hash % TAG_VARIANTS.length]
+}
 </script>
 
 <template>
   <GnBadge :variant="statusVariant(task.status)">
     <i :class="`ph ${statusIcon(task.status)}`" aria-hidden="true" />{{ statusLabel(task.status) }}
   </GnBadge>
-  <GnBadge v-if="task.project && !hideProject" variant="neutral"><i class="ph ph-folder" aria-hidden="true" />
+  <!-- проект: контурный бейдж-«ссылка» на сущность -->
+  <GnBadge v-if="task.project && !hideProject" variant="primary" outline><i class="ph ph-folder" aria-hidden="true" />
     {{ task.project.name }}
   </GnBadge>
-  <GnBadge v-if="task.priority !== null" :variant="priorityVariant(task.priority)">
-    <i class="ph ph-flag" aria-hidden="true" />{{ priorityLabel(task.priority) }}
-  </GnBadge>
-  <GnBadge v-if="task.estimated_minutes" variant="neutral">
+  <PriorityBadge v-if="task.priority !== null" :priority="task.priority" />
+  <GnBadge v-if="task.estimated_minutes" variant="primary">
     <i class="ph ph-timer" aria-hidden="true" />≈ {{ formatMinutes(task.estimated_minutes) }}
   </GnBadge>
   <GnBadge v-if="task.task_type === 'recurring'" variant="info"><i class="ph ph-repeat" aria-hidden="true" />
@@ -45,10 +53,10 @@
   <GnBadge v-if="task.mentally_hard" variant="warning">
     <i class="ph ph-brain" aria-hidden="true" />{{ t('task.mentallyHard.badge') }}
   </GnBadge>
-  <GnBadge v-if="task.budget_money !== null" variant="neutral">
+  <GnBadge v-if="task.budget_money !== null" variant="warning">
     <i class="ph ph-coins" aria-hidden="true" />{{ budgetBadge(task) }}
   </GnBadge>
-  <GnBadge v-for="tag in task.tags" :key="tag.id" variant="neutral">
+  <GnBadge v-for="tag in task.tags" :key="tag.id" :variant="tagVariant(tag.name)">
     <i class="ph ph-tag" aria-hidden="true" />{{ tag.name }}
   </GnBadge>
 </template>
\ No newline at end of file
diff --git a/frontend/src/components/TaskCard.vue b/frontend/src/components/TaskCard.vue
index 28a461c..83edca9 100644
--- a/frontend/src/components/TaskCard.vue
+++ b/frontend/src/components/TaskCard.vue
@@ -14,6 +14,8 @@
   task: Task
   /** Показывать бейдж проекта (скрывать на странице проекта) */
   showProject?: boolean
+  /** Параметры запроса у ссылок на задачу (например { via: 'options' }) */
+  linkQuery?: Record<string, string>
 }>()
 
 const emit = defineEmits<{
@@ -43,20 +45,24 @@
       icon: o.value === task.status ? 'ph-check' : undefined,
       onSelect: () => emit('status-change', task, o.value),
     })),
-    { label: t('card.open'), icon: 'ph-arrow-square-out', onSelect: () => open(task.id) },
+    { label: t('common.open'), icon: 'ph-arrow-square-out', onSelect: () => open(task.id) },
     { label: t('common.delete'), icon: 'ph-trash', danger: true, onSelect: () => emit('delete', task) },
   ]
 }
 
 function open(id: number) {
-  void router.push(`/tasks/${id}`)
+  void router.push({ path: `/tasks/${id}`, query: props.linkQuery })
 }
 </script>
 
 <template>
   <GnCard class="task-card">
     <div class="task-main">
-      <RouterLink class="title" :class="{ done: task.status === 'done' }" :to="`/tasks/${task.id}`">
+      <RouterLink
+        class="title"
+        :class="{ done: task.status === 'done' }"
+        :to="linkQuery ? { path: `/tasks/${task.id}`, query: linkQuery } : `/tasks/${task.id}`"
+      >
         {{ task.title }}
       </RouterLink>
       <GnDropdown class="task-menu" :items="menu(task)">
diff --git a/frontend/src/components/TaskForm.vue b/frontend/src/components/TaskForm.vue
index b552f45..776b6fe 100644
--- a/frontend/src/components/TaskForm.vue
+++ b/frontend/src/components/TaskForm.vue
@@ -2,9 +2,11 @@
 import { computed, nextTick, onMounted, ref } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { api, type Attachment, type Project, type Tag, type Task } from '../api'
+import { notifyCreated } from '../gamification'
 import { deadlinePeriodOptions, recurKindOptions, priorityOptions, gradeToPriority, priorityToGrade, weekdayShort } from '../taskui'
 import { useToast } from 'gnexus-ui-kit/vue'
 import MdEditor from './MdEditor.vue'
+import DurationInput from './DurationInput.vue'
 
 // Полная форма задачи: тип (радио), описание (Markdown-редактор с тулбаром),
 // метаданные, дедлайн, рекуррентность, вложения (Ctrl+V — картинка),
@@ -202,6 +204,8 @@
       const created = await api.createTask(f.title, f.description, props.parentId)
       task = await api.updateTask(created.id, patch)
       toast.success({ title: t('common.created'), text: t('task.createdRaw') })
+      // наградный тост после основного (провайдер кита держит один тост)
+      notifyCreated()
     }
     emit('saved', task)
   } catch (e) {
@@ -288,11 +292,10 @@
       <template #extra>
         <fieldset class="tags-fieldset">
           <legend>{{ t('stack.form.estimateLegend') }}</legend>
-          <GnInput
-            v-model.number="form.estimated_minutes"
+          <DurationInput
+            v-model="form.estimated_minutes"
             :label="t('stack.form.estimate')"
-            type="number"
-            min="1"
+            :min="1"
           />
           <GnInput
             v-model.number="form.cost_estimate_money"
@@ -369,7 +372,7 @@
       <GnButton type="submit" variant="success" icon="ph-check-circle">
         {{ submitText }}
       </GnButton>
-      <GnButton type="button" variant="secondary" class="btn-cancel" @click="emit('cancel')">
+      <GnButton type="button" variant="primary" @click="emit('cancel')">
         {{ t('common.cancel') }}
       </GnButton>
     </div>
@@ -385,7 +388,6 @@
 }
 .tags-fieldset {
   border: 1px solid var(--border, #333);
-  border-radius: 6px;
   padding: 0.75rem;
   display: flex;
   flex-wrap: wrap;
@@ -420,7 +422,6 @@
 .thumb img {
   max-width: 120px;
   max-height: 90px;
-  border-radius: 6px;
   border: 1px solid var(--border, #333);
   display: block;
 }
@@ -434,13 +435,4 @@
   flex-wrap: wrap;
   gap: 0.75rem;
 }
-/* Отмена — без рамки, менее заметная, чем вторичная */
-.btn-cancel {
-  border-color: transparent;
-  color: var(--text-muted, #888);
-}
-.btn-cancel:hover {
-  border-color: transparent;
-  color: var(--accent, #7aa2f7);
-}
 </style>
\ No newline at end of file
diff --git a/frontend/src/dropdownClamp.ts b/frontend/src/dropdownClamp.ts
new file mode 100644
index 0000000..1ea7adf
--- /dev/null
+++ b/frontend/src/dropdownClamp.ts
@@ -0,0 +1,33 @@
+// Фикс дропдаунов кита на мобильных: GnDropdown позиционирует меню от левого
+// края триггера (position:absolute; left:0), и у триггеров у правого края
+// экрана меню вылезает наружу. Кит не даёт ручек позиционирования — после
+// открытия выравниваем меню (и по горизонтали, и по вертикали) в пределах
+// вьюпорта, не трогая стили кита.
+export function installDropdownClamp(): void {
+  const clamp = () => {
+    for (const dropdown of Array.from(document.querySelectorAll<HTMLElement>('.dropdown.is-open'))) {
+      const menu = dropdown.querySelector<HTMLElement>('.dropdown-menu')
+      if (!menu) continue
+      const rect = dropdown.getBoundingClientRect()
+      const vw = document.documentElement.clientWidth
+      const vh = window.innerHeight
+
+      // Горизонталь: если меню не помещается справа от триггера — открыть влево
+      menu.style.left = 'auto'
+      menu.style.right = 'auto'
+      if (rect.left + menu.offsetWidth > vw - 8) menu.style.right = '0'
+      else menu.style.left = '0'
+
+      // Вертикаль: если не помещается под триггером, но есть место сверху — открыть вверх
+      menu.style.top = ''
+      menu.style.bottom = ''
+      if (rect.bottom + 8 + menu.offsetHeight > vh && rect.top - menu.offsetHeight > 0) {
+        menu.style.top = 'auto'
+        menu.style.bottom = 'calc(100% + 8px)'
+      }
+    }
+  }
+  // Открытие дропдауна происходит по клику синхронно, DOM обновляется в
+  // микротаске Vue — macrotask setTimeout отрабатывает уже после рендера
+  document.addEventListener('click', () => setTimeout(clamp, 0), true)
+}
\ No newline at end of file
diff --git a/frontend/src/game/GardenRenderer.ts b/frontend/src/game/GardenRenderer.ts
index 067606f..5ae3d8a 100644
--- a/frontend/src/game/GardenRenderer.ts
+++ b/frontend/src/game/GardenRenderer.ts
@@ -1,11 +1,12 @@
 // PixiJS-рендерер сцены сада (ТЗ 3.13): пиксель-арт на WebGL.
 // Вся Pixi-логика здесь; GardenScene.vue — тонкая обёртка (DOM-инвентарь,
 // поповер, drag-ghost). Клетка = 32 мировых px (матрица 16px × 2).
-import { Application, Container, Graphics, Sprite, TilingSprite } from 'pixi.js'
-import type { FederatedPointerEvent } from 'pixi.js'
+import { Application, Container, Sprite, TilingSprite } from 'pixi.js'
+import type { FederatedPointerEvent, Texture } from 'pixi.js'
 import type { GardenItem, GardenState } from '../api'
 import {
   decorTexture,
+  fenceTexture,
   houseTexture,
   plantTexture,
   ringTexture,
@@ -17,7 +18,6 @@
 
 export const CELL_WORLD = 32 // мировых px на клетку (16px матрица × 2)
 const PX = 2 // масштаб «нативного пикселя»
-const LAWN_INSET = 16 // газон внутри изгороди (10 svg-px ≈ 16 мировых)
 
 export interface GardenRendererCallbacks {
   /** Перемещение: x/y null — бросок в инвентарь (только декорации). */
@@ -26,6 +26,8 @@
   onSelect(id: number | null): void
   /** DOM-rect полосы инвентаря (для броска декорации с карты в инвентарь). */
   inventoryRect(): DOMRect | null
+  /** Начало/конец перетаскивания по канвасу (ТЗ 3.14: подавить refetch на жесте). */
+  onDragChange?(dragging: boolean): void
 }
 
 interface ItemView {
@@ -36,6 +38,8 @@
   sparkles: Sprite[]
   item: GardenItem
   growing: boolean
+  /** Маска соединений забора, по которой построена текущая текстура. */
+  fenceMask: number
 }
 
 interface Tween {
@@ -60,6 +64,8 @@
   private views = new Map<number, ItemView>()
   private selectedId: number | null = null
   private hoverOutline: Sprite | null = null
+  // клетки с забором (для самосоединения секций): "x,y" → маска соседей
+  private fenceCells = new Set<string>()
 
   private drag: {
     id: number
@@ -70,6 +76,13 @@
   private tweens: Tween[] = []
   private time = 0
 
+  // Зум/панорама: масштаб root = baseScale (fit по ширине) × zoom,
+  // panOffset — сдвиг в экранных px (0 при zoom = 1)
+  private zoom = 1
+  private baseScale = 1
+  private panOffset = { x: 0, y: 0 }
+  private panning: { sx: number; sy: number; px: number; py: number } | null = null
+
   private constructor(cb: GardenRendererCallbacks) {
     this.cb = cb
   }
@@ -125,6 +138,7 @@
 
     this.resizeObserver = new ResizeObserver(() => this.onHostResize(host))
     this.resizeObserver.observe(host)
+    app.canvas.addEventListener('wheel', this.onWheel, { passive: false })
 
     app.ticker.add(this.onTick)
     host.appendChild(app.canvas)
@@ -143,7 +157,60 @@
 
   private applyRootScale(host: HTMLElement): void {
     const w = host.clientWidth || 1
-    this.root.scale.set(w / this.worldWidth())
+    this.baseScale = w / this.worldWidth()
+    this.applyView()
+  }
+
+  /** Применить зум и панораму к корневому контейнеру. */
+  private applyView(): void {
+    this.root.scale.set(this.baseScale * this.zoom)
+    this.root.position.set(this.panOffset.x, this.panOffset.y)
+  }
+
+  /** Ограничить панораму: контент не должен уходить с экрана. */
+  private clampPan(): void {
+    const w = this.app.screen.width
+    const h = this.app.screen.height
+    const cw = this.worldWidth() * this.baseScale * this.zoom
+    const ch = this.worldHeight() * this.baseScale * this.zoom
+    this.panOffset.x = Math.max(w - cw, Math.min(0, this.panOffset.x))
+    // по вертикали, пока контент меньше экрана — прижат кверху (как без зума)
+    this.panOffset.y = ch >= h ? Math.max(h - ch, Math.min(0, this.panOffset.y)) : 0
+  }
+
+  /** Сменить зум, сохранив точку мира под экранными координатами (ax, ay). */
+  private applyZoom(next: number, ax: number, ay: number): void {
+    const scale = this.baseScale * this.zoom
+    const wx = (ax - this.panOffset.x) / scale
+    const wy = (ay - this.panOffset.y) / scale
+    this.zoom = Math.max(1, Math.min(4, next))
+    const ns = this.baseScale * this.zoom
+    this.panOffset.x = ax - wx * ns
+    this.panOffset.y = ay - wy * ns
+    this.clampPan()
+    this.applyView()
+  }
+
+  /** Кнопки зума: якорь — центр экрана. */
+  zoomIn(): void {
+    this.applyZoom(this.zoom * 1.25, this.app.screen.width / 2, this.app.screen.height / 2)
+  }
+
+  zoomOut(): void {
+    this.applyZoom(this.zoom / 1.25, this.app.screen.width / 2, this.app.screen.height / 2)
+  }
+
+  /** Сброс: fit по ширине, без сдвига. */
+  resetView(): void {
+    this.zoom = 1
+    this.panOffset = { x: 0, y: 0 }
+    this.applyView()
+  }
+
+  private readonly onWheel = (e: WheelEvent): void => {
+    e.preventDefault()
+    const rect = this.app.canvas.getBoundingClientRect()
+    this.applyZoom(this.zoom * (e.deltaY < 0 ? 1.2 : 1 / 1.2), e.clientX - rect.left, e.clientY - rect.top)
   }
 
   /** Мировые координаты центра клетки. */
@@ -169,49 +236,33 @@
     const wild = new TilingSprite({ texture: tileTexture('wild'), width: W, height: H })
     this.terrain.addChild(wild)
 
-    // газон из супер-тайла 32px (шахматка grass-a/b, период 2 клетки)
+    // газон из супер-тайла 64px (4 тайла, период 4 клетки) — на всё поле
     const lawnTex = tileTexture('grass-super')
-    const lawn = new TilingSprite({
-      texture: lawnTex,
-      width: W - LAWN_INSET * 2,
-      height: H - LAWN_INSET * 2,
-    })
-    lawn.position.set(LAWN_INSET, LAWN_INSET)
+    const lawn = new TilingSprite({ texture: lawnTex, width: W, height: H })
     this.terrain.addChild(lawn)
 
-    // кустики травы: ~8% клеток детерминированно
+    // кустики травы: ~8% клеток, два вида (пучок / с цветком);
+    // раскидка по целочисленному хешу клетки — без видимого паттерна
     for (let y = 0; y < this.rows; y++)
       for (let x = 0; x < this.cols; x++) {
-        if ((x * 7 + y * 11 + this.cols) % 12 !== 0) continue
-        const tuft = new Sprite(tileTexture('grass-tuft'))
+        const h = GardenRenderer.hash2(x, y)
+        if (h % 100 >= 8) continue
+        const tex = (h >>> 8) % 4 === 0 ? tileTexture('grass-daisy') : tileTexture('grass-tuft')
+        const tuft = new Sprite(tex)
         const { cx, cy } = this.cellCenter(x, y)
         tuft.anchor.set(0.5)
-        tuft.position.set(cx, cy)
+        // небольшой детерминированный сдвиг внутри клетки — живее
+        tuft.position.set(cx + ((h >>> 16) % 9) - 4, cy + ((h >>> 20) % 7) - 3)
         tuft.scale.set(PX)
         this.terrain.addChild(tuft)
       }
+  }
 
-    // сетка
-    const grid = new Graphics()
-    for (let x = 0; x <= this.cols; x++)
-      grid.moveTo(x * CELL_WORLD, LAWN_INSET).lineTo(x * CELL_WORLD, H - LAWN_INSET)
-    for (let y = 0; y <= this.rows; y++)
-      grid.moveTo(LAWN_INSET, y * CELL_WORLD).lineTo(W - LAWN_INSET, y * CELL_WORLD)
-    grid.stroke({ color: 0x000000, alpha: 0.07, width: 1 })
-    this.terrain.addChild(grid)
-
-    // изгородь по периметру (полосы толщиной с клетку)
-    const hedgeTex = tileTexture('hedge')
-    const top = new TilingSprite({ texture: hedgeTex, width: W, height: CELL_WORLD / 2 })
-    const bottom = new TilingSprite({ texture: hedgeTex, width: W, height: CELL_WORLD / 2 })
-    bottom.position.set(0, H - CELL_WORLD / 2)
-    const left = new TilingSprite({ texture: hedgeTex, width: H, height: CELL_WORLD / 2 })
-    left.position.set(CELL_WORLD / 2, 0)
-    left.rotation = Math.PI / 2
-    const right = new TilingSprite({ texture: hedgeTex, width: H, height: CELL_WORLD / 2 })
-    right.position.set(W - CELL_WORLD / 2, H)
-    right.rotation = -Math.PI / 2
-    this.terrain.addChild(top, bottom, left, right)
+  /** Целочисленный хеш пары координат (раскидка декора без паттернов). */
+  private static hash2(x: number, y: number): number {
+    let h = x * 374761393 + y * 668265263
+    h = (h ^ (h >> 13)) * 1274126177
+    return (h ^ (h >> 16)) >>> 0
   }
 
   private buildHouse(): void {
@@ -226,7 +277,7 @@
     const house = new Sprite(houseTexture())
     house.scale.set(PX)
     // anchor — центр основания ромба в матрице HOUSE (27, 32)
-    house.anchor.set(27 / 56, 32 / 46)
+    house.anchor.set(27 / 62, 32 / 52)
     house.position.set(this.worldWidth() / 2, this.worldHeight() / 2)
     this.houseLayer.addChild(house)
   }
@@ -253,6 +304,7 @@
       this.rebuildTerrain()
       this.buildHouse()
     }
+    this.syncFences(state)
     const seen = new Set<number>()
     for (const item of state.items) {
       if (item.x === null || item.y === null) {
@@ -262,7 +314,12 @@
       seen.add(item.id)
       const view = this.views.get(item.id)
       if (!view) this.addView(item)
-      else if (this.itemChanged(view.item, item)) this.updateView(view, item)
+      // у соединяемых секций (забор/дорожка) текстура зависит и от соседей
+      else if (
+        this.itemChanged(view.item, item) ||
+        (this.isLinked(item) && this.linkMaskOf(item) !== view.fenceMask)
+      )
+        this.updateView(view, item)
     }
     for (const id of [...this.views.keys()]) if (!seen.has(id)) this.removeView(id)
   }
@@ -297,7 +354,16 @@
     body.on('pointerdown', (e) => this.beginDrag(item.id, e))
     rootC.addChild(body)
 
-    const view: ItemView = { root: rootC, shadow, body, ring, sparkles: [], item: { ...item }, growing: true }
+    const view: ItemView = {
+      root: rootC,
+      shadow,
+      body,
+      ring,
+      sparkles: [],
+      item: { ...item },
+      growing: true,
+      fenceMask: this.isLinked(item) ? this.linkMaskOf(item) : -1,
+    }
     this.fitShadow(view)
 
     const sparkles: Sprite[] = []
@@ -338,7 +404,10 @@
       view.root.zIndex = (item.y ?? 0) * 1000 + (item.x ?? 0)
     }
     if (item.kind === 'plant') view.body.texture = plantTexture(item.item_key ?? '', item.stage)
-    else if (item.item_key) view.body.texture = decorTexture(item.item_key)
+    else if (this.isLinked(item)) {
+      view.body.texture = this.linkTexture(item)
+      view.fenceMask = this.linkMaskOf(item)
+    } else if (item.item_key) view.body.texture = decorTexture(item.item_key)
     this.fitShadow(view)
   }
 
@@ -353,13 +422,44 @@
     view.root.destroy({ children: true })
   }
 
+  /** Клетки соединяемых секций (забор) из нового состояния. */
+  private syncFences(state: GardenState): void {
+    this.fenceCells = new Set(
+      state.items
+        .filter((i) => i.kind === 'decoration' && i.item_key === 'fence')
+        .map((i) => `${i.x},${i.y}`),
+    )
+  }
+
+  /** Секция забора, размещённая на карте. */
+  private isLinked(item: GardenItem): boolean {
+    return item.kind === 'decoration' && item.item_key === 'fence' && item.x !== null && item.y !== null
+  }
+
+  /** Маска соединений секции с соседями: N=1, E=2, S=4, W=8. */
+  private linkMaskOf(item: GardenItem): number {
+    const cells = this.fenceCells
+    const x = item.x ?? 0
+    const y = item.y ?? 0
+    const at = (cx: number, cy: number): boolean => cells.has(`${cx},${cy}`)
+    return (at(x, y - 1) ? 1 : 0) | (at(x + 1, y) ? 2 : 0) | (at(x, y + 1) ? 4 : 0) | (at(x - 1, y) ? 8 : 0)
+  }
+
+  private linkTexture(item: GardenItem): Texture {
+    return fenceTexture(this.linkMaskOf(item))
+  }
+
   private textureOf(item: GardenItem) {
     if (item.kind === 'plant') return plantTexture(item.item_key ?? 'ph-flower', item.stage)
+    if (this.isLinked(item)) return this.linkTexture(item)
     return decorTexture(item.item_key ?? 'flowerbed')
   }
 
-  /** Подогнать тень под текущую текстуру тела (при смене стадии/вида). */
+  /** Подогнать тень под текущую текстуру тела (при смене стадии/вида).
+   *  У «плоских» декораций (озеро, дорожка) тени нет — она лежит в самой текстуре. */
   private fitShadow(view: ItemView): void {
+    view.shadow.visible = view.item.item_key !== 'pond' // тень лежит в текстуре
+    if (!view.shadow.visible) return
     const w = view.body.texture.width * PX * 0.9 + 4
     view.shadow.scale.set(w / 24, (w / 24) * 0.7)
     view.shadow.position.set(0, 2)
@@ -374,6 +474,7 @@
       startClientX: e.globalX,
       startClientY: e.globalY,
     }
+    this.cb.onDragChange?.(true)
   }
 
   private dragView(): ItemView | null {
@@ -382,6 +483,15 @@
   }
 
   private readonly onStageMove = (e: FederatedPointerEvent): void => {
+    // панорама: drag по пустому месту при зуме
+    if (this.panning) {
+      const p = this.panning
+      this.panOffset.x = p.px + (e.globalX - p.sx)
+      this.panOffset.y = p.py + (e.globalY - p.sy)
+      this.clampPan()
+      this.applyView()
+      return
+    }
     const view = this.dragView()
     if (!view) return
     const d = this.drag!
@@ -398,9 +508,14 @@
   }
 
   private readonly onStageUp = (e: FederatedPointerEvent): void => {
+    if (this.panning) {
+      this.panning = null
+      return
+    }
     const view = this.dragView()
     const d = this.drag
     this.drag = null
+    if (d) this.cb.onDragChange?.(false)
     if (!view || !d) return
     view.body.alpha = 1
     const item = view.item
@@ -409,8 +524,8 @@
     }
     if (!d.moved) {
       restoreZ(item)
-      // клик: поповер только у растений
-      this.selectedId = item.kind === 'plant' ? item.id : null
+      // клик: выбор объекта — поповер у растений, подпись имени у любых предметов
+      this.selectedId = item.id
       this.cb.onSelect(this.selectedId)
       return
     }
@@ -442,8 +557,10 @@
   }
 
   private readonly onStageDown = (e: FederatedPointerEvent): void => {
-    // клик по пустому месту закрывает поповер (target === stage)
+    // клик по пустому месту: панорама при зуме, иначе закрыть поповер
     if (e.target === this.app.stage) {
+      if (this.zoom > 1)
+        this.panning = { sx: e.globalX, sy: e.globalY, px: this.panOffset.x, py: this.panOffset.y }
       this.selectedId = null
       this.cb.onSelect(null)
     }
@@ -461,16 +578,22 @@
       clientY > rect.bottom
     )
       return null
-    const scale = rect.width / this.worldWidth()
-    return this.cellOfWorld((clientX - rect.left) / scale, (clientY - rect.top) / scale)
+    const scale = (rect.width / this.worldWidth()) * this.zoom
+    return this.cellOfWorld(
+      (clientX - rect.left - this.panOffset.x) / scale,
+      (clientY - rect.top - this.panOffset.y) / scale,
+    )
   }
 
   /** Экранные координаты центра клетки (позиция поповера). */
   clientPointOfCell(x: number, y: number): { x: number; y: number } {
     const rect = this.app.canvas.getBoundingClientRect()
-    const scale = rect.width / this.worldWidth()
+    const scale = (rect.width / this.worldWidth()) * this.zoom
     const { cx, cy } = this.cellCenter(x, y)
-    return { x: rect.left + cx * scale, y: rect.top + cy * scale }
+    return {
+      x: rect.left + cx * scale + this.panOffset.x,
+      y: rect.top + cy * scale + this.panOffset.y,
+    }
   }
 
   /** Подсветка целевой клетки при drag из инвентаря. */
@@ -505,6 +628,7 @@
   destroy(): void {
     this.disposed = true
     this.resizeObserver?.disconnect()
+    this.app.canvas.removeEventListener('wheel', this.onWheel)
     this.app.stage.off('pointermove', this.onStageMove)
     this.app.stage.off('pointerup', this.onStageUp)
     this.app.stage.off('pointerupoutside', this.onStageUp)
diff --git a/frontend/src/game/sprites.ts b/frontend/src/game/sprites.ts
index 146e9b5..7005b79 100644
--- a/frontend/src/game/sprites.ts
+++ b/frontend/src/game/sprites.ts
@@ -6,9 +6,9 @@
 
 /** Палитра сцены — тон в тон тёмной теме (фон ~#1a1f2e). */
 export const PAL: Palette = {
-  g: '#2e4a2b', // трава тёмная
-  G: '#385a32', // трава
-  H: '#41663a', // трава светлая / травинки
+  g: '#2c4a36', // трава тёмная (холодный оттенок)
+  G: '#365a41', // трава
+  H: '#40674b', // трава светлая / травинки
   w: '#3b3226', // дикая земля
   W: '#45392b', // дикая земля светлая
   e: '#35682c', // изгородь
@@ -26,6 +26,7 @@
   u: '#4a6fd4', // вода
   U: '#7aa2f7', // вода светлая
   b: '#6b4f3a', // клумба (земля)
+  S: '#b3a26b', // песок берега
   s: '#4a3826', // почва тёмная
   l: '#4a8f3c', // листва
   L: '#5fae4b', // листва светлая
@@ -38,6 +39,17 @@
   x: '#7d8496', // камень
   q: '#f5d76e', // свечение (эпик)
   m: '#243022', // тень на земле
+  i: '#c9b98a', // дорожка (гравий светлый)
+  I: '#9a8a5f', // дорожка тень
+  f: '#e8903a', // огонь / рябина
+  Z: '#f5b04a', // огонь светлая
+  v: '#7c5fd4', // звёздный/бабочий (сирень)
+  V: '#a48ae8', // сирень светлая
+  B: '#63b3e8', // голубой (роса)
+  A: '#8a5a3c', // янтарь (ягоды)
+  j: '#c9e06e', // подсолнух жёлтый
+  J: '#f0d75e', // подсолнух светлая
+  z: '#3e8f82', // стекло в тени (теплица)
 }
 
 /** Поставить пиксель (без выхода за границы). */
@@ -105,6 +117,23 @@
   )
 }
 
+/** Шахматная растушёвка края эллипса: переход полосы frac к цвету ch (' ' — фон). */
+function feather(
+  m: Matrix,
+  cx: number,
+  cy: number,
+  rx: number,
+  ry: number,
+  frac: number,
+  ch: string,
+): void {
+  for (let y = Math.floor(cy - ry); y <= Math.ceil(cy + ry); y++)
+    for (let x = Math.floor(cx - rx); x <= Math.ceil(cx + rx); x++) {
+      const d = ((x - cx) / rx) ** 2 + ((y - cy) / ry) ** 2
+      if (d > 1 - frac && d <= 1 && (x + y) % 2 === 0) put(m, x, y, ch)
+    }
+}
+
 // --- Тайлы (16×16, бесшовные) ---
 
 function speckle(m: Matrix, seed: number, chs: string[]): void {
@@ -118,30 +147,57 @@
 
 function grassTile(seed: number, base = 'g'): Matrix {
   const m = blank(16, 16).map(() => base.repeat(16)) as Matrix
-  speckle(m, seed, ['G', 'H', 'G'])
+  // фактура: светлые травинки и полутона (детерминированный «шум» в 2..13,
+  // края чистые — бесшовность при тайлировании)
+  for (let i = 0; i < 8; i++) {
+    const x = 2 + ((seed * 7 + i * 29) % 12)
+    const y = 2 + ((seed * 13 + i * 17) % 12)
+    put(m, x, y, i % 3 === 0 ? 'H' : 'G')
+  }
+  // редкие тёмные пятнышки почвы
+  for (let i = 0; i < 2; i++) {
+    const x = 2 + ((seed * 11 + i * 23) % 12)
+    const y = 2 + ((seed * 5 + i * 31) % 12)
+    put(m, x, y, 'k')
+  }
   return m
 }
 
 export const GRASS_A = grassTile(1)
-export const GRASS_B = grassTile(2, 'g')
+export const GRASS_B = grassTile(2)
+export const GRASS_C = grassTile(5)
+export const GRASS_D = grassTile(9)
 
-/** Супер-тайл 32×32: шахматка grass-a/b (период 2 клетки — глубина без рваного шума). */
-export const GRASS_SUPER: Matrix = (() => {
+function checker2(a: Matrix, b: Matrix): Matrix {
+  // 32×32: шахматка 2×2 из 16px тайлов
   const rows: Matrix = []
   for (let y = 0; y < 32; y++) {
-    const left = y < 16 ? GRASS_A[y]! : GRASS_B[y - 16]!
-    const right = y < 16 ? GRASS_B[y]! : GRASS_A[y - 16]!
+    const left = y < 16 ? a[y]! : b[y - 16]!
+    const right = y < 16 ? b[y]! : a[y - 16]!
     rows.push(left + right)
   }
   return rows
+}
+
+/** Супер-тайл 64×64: четыре разных тайла, период 4 клетки — вариативность без рваного шума. */
+export const GRASS_SUPER: Matrix = (() => {
+  const tl = checker2(GRASS_A, GRASS_B)
+  const tr = checker2(GRASS_C, GRASS_D)
+  const bl = checker2(GRASS_D, GRASS_C)
+  const br = checker2(GRASS_B, GRASS_A)
+  const rows: Matrix = []
+  for (let y = 0; y < 64; y++) {
+    rows.push((y < 32 ? tl[y]! : bl[y - 32]!) + (y < 32 ? tr[y]! : br[y - 32]!))
+  }
+  return rows
 })()
 
-export const GRASS_TUFT: Matrix = (() => {
-  const m = [...GRASS_A]
-  // кустики травинок: светлые пучки на тёмном стебле
-  const tuft = ['H.H.H', 'HHHHH', '.HtH.', '..t..']
-  return stamp(m, tuft, 5, 7)
-})()
+const TUFT = ['H.H.H', 'HHHHH', '.HtH.', '..t..']
+
+export const GRASS_TUFT: Matrix = stamp([...GRASS_A], TUFT, 5, 7)
+
+/** Кустиик с белым цветком — второй вариант травинки для разнообразия. */
+export const GRASS_TUFT_FLOWER: Matrix = stamp([...GRASS_C], ['h.h', 'hhh', '.t.'], 6, 8)
 
 export const WILD: Matrix = (() => {
   const m = blank(16, 16).map(() => 'w'.repeat(16)) as Matrix
@@ -174,8 +230,8 @@
 // скат над нижне-левой гранью — в тени (R), над верхне-правой — свет (r).
 
 export const HOUSE: Matrix = (() => {
-  const W = 56
-  const H = 46
+  const W = 62
+  const H = 52
   const ox = 23
   const oy = 20
   // мировая точка → матрица
@@ -440,6 +496,184 @@
   return m
 }
 
+/** Роса: тонкие стебли с голубыми цветками-каплями (ур. 7). */
+function plantDew(stage: number): Matrix {
+  const sizes: [number, number][] = [[12, 12], [16, 20], [24, 28]]
+  const [w, h] = sizes[stage]!
+  const m = blank(w, h)
+  const cx = Math.floor(w / 2)
+  // 2-4 изогнутых стебля веером
+  const stems = 1 + stage * 2
+  for (let i = 0; i < stems; i++) {
+    const dx = (i - (stems - 1) / 2) * Math.max(2, Math.floor(w / (stems + 2)))
+    const top = Math.floor(h * 0.25)
+    for (let y = h - 2; y >= top + Math.abs(dx); y--) put(m, cx + dx + ((h - y) % 2), y, 't')
+    // капля-цветок на конце стебля
+    const fx = cx + dx + Math.max(1, Math.floor(Math.abs(dx) / 2))
+    const fy = top + Math.abs(dx) - 1
+    put(m, fx, fy - 1, 'B')
+    put(m, fx - 1, fy, 'B')
+    put(m, fx, fy, 'B')
+    put(m, fx + 1, fy, 'B')
+    put(m, fx, fy + 1, 'h')
+  }
+  ellipse(m, cx, h - 3, Math.floor(w * 0.25), 1.6, 'l')
+  return m
+}
+
+/** Подсолнух: толстый стебель, крупное жёлтое соцветие (ур. 8). */
+function plantSunflower(stage: number): Matrix {
+  const sizes: [number, number][] = [[12, 14], [16, 22], [24, 32]]
+  const [w, h] = sizes[stage]!
+  const m = blank(w, h)
+  const cx = Math.floor(w / 2)
+  const headR = 2 + stage * 2
+  const headY = Math.floor(h * 0.3)
+  vline(m, cx, headY, h - 2, 't') // стебель
+  vline(m, cx + 1, headY + 2, h - 2, 'k')
+  // листья-лопасти по стеблю
+  for (let i = 0; i <= stage; i++) {
+    const ly = headY + Math.floor((h - headY) * (0.3 + i * 0.25))
+    hline(m, cx - 3 - (i % 2), cx - 1, ly, 'l')
+    hline(m, cx + 2, cx + 3 + (i % 2), ly + 2, 'l')
+  }
+  // соцветие: жёлтые лепестки вокруг тёмной сердцевины
+  ellipse(m, cx, headY, headR + 1, headR, 'j')
+  ellipse(m, cx, headY, headR, headR - 1, 'J')
+  ellipse(m, cx, headY, Math.max(1, headR - 2), Math.max(1, headR - 2), 's')
+  put(m, cx - headR - 1, headY, 'j')
+  put(m, cx + headR + 1, headY, 'j')
+  return m
+}
+
+/** Бонсай: изогнутый ствол, плоские ярусы кроны (ур. 9). */
+function plantBonsai(stage: number): Matrix {
+  const sizes: [number, number][] = [[14, 14], [20, 26], [28, 38]]
+  const [w, h] = sizes[stage]!
+  const m = blank(w, h)
+  const cx = Math.floor(w / 2)
+  const trunkH = Math.floor(h * (0.3 + stage * 0.06))
+  // S-изгиб ствола
+  for (let y = h - trunkH; y < h; y++) {
+    const t = (y - (h - trunkH)) / trunkH
+    const sway = Math.round(Math.sin(t * Math.PI) * (stage + 1) * 0.6)
+    put(m, cx + sway, y, 'o')
+    put(m, cx + sway + 1, y, 'O')
+  }
+  // крона: 2-3 плоских «подушки»
+  const pads = 1 + stage
+  const crownW = Math.floor(w * (0.28 + stage * 0.09))
+  for (let pad = 0; pad < pads; pad++) {
+    const py = h - trunkH - Math.floor((h - trunkH - 2) * (pad / pads)) - 1
+    const pw = Math.floor(crownW * (1 - pad * 0.25))
+    ellipse(m, cx, py, pw, 1.8, 'l')
+    ellipse(m, cx - 1, py - 1, Math.max(1, pw - 2), 1.2, 'L')
+    put(m, cx + pw - 1, py + 1, 'k')
+  }
+  return m
+}
+
+/** Бабочий куст: пучок стеблей с сиреневыми метёлками (ур. 10). */
+function plantButterflyBush(stage: number): Matrix {
+  const sizes: [number, number][] = [[12, 12], [16, 20], [24, 28]]
+  const [w, h] = sizes[stage]!
+  const m = blank(w, h)
+  const cx = Math.floor(w / 2)
+  const spikes = 3 + stage * 2
+  for (let i = 0; i < spikes; i++) {
+    const sx = cx + Math.round((i - (spikes - 1) / 2) * (w / (spikes + 1)))
+    const top = Math.floor(h * 0.2) + (i % 2) * 2
+    vline(m, sx, top + 3, h - 2, 'k')
+    const spikeH = Math.max(2, h - top - 5)
+    for (let dy = 0; dy < spikeH; dy++) {
+      const half = Math.max(0, Math.round((1 - dy / spikeH) * 2))
+      for (let dx = -half; dx <= half; dx++) put(m, sx + dx, top + dy, dy % 2 ? 'v' : 'V')
+    }
+    put(m, sx, top - 1, 'q')
+  }
+  ellipse(m, cx, h - 3, Math.floor(w * 0.3), 1.8, 'l')
+  return m
+}
+/** Рябина: дерево с огненно-оранжевой листвой и ягодами (ур. 11, premium). */
+function plantRowan(stage: number): Matrix {
+  const sizes: [number, number][] = [[16, 16], [22, 28], [32, 44]]
+  const [w, h] = sizes[stage]!
+  const m = blank(w, h)
+  const cx = Math.floor(w / 2)
+  const trunkH = Math.floor(h * (0.25 + stage * 0.08))
+  const crownR = Math.floor(w * (0.28 + stage * 0.08))
+  // крона в осенних тонах
+  ellipse(m, cx, h - trunkH - crownR * 0.6, crownR, crownR * 0.75, 'f')
+  ellipse(m, cx - crownR * 0.5, h - trunkH - crownR * 0.2, crownR * 0.6, crownR * 0.5, 'Z')
+  ellipse(m, cx + crownR * 0.5, h - trunkH - crownR * 0.25, crownR * 0.6, crownR * 0.5, 'f')
+  ellipse(m, cx - 1, h - trunkH - crownR * 0.8, crownR * 0.4, crownR * 0.4, 'Z')
+  // гроздья ягод
+  const clusters = 2 + stage
+  for (let i = 0; i < clusters; i++) {
+    const bx = cx - crownR + Math.floor((i * 2 * crownR) / (clusters - 1 || 1))
+    const by = h - trunkH - crownR * 0.4 + (i % 2) * 2
+    put(m, bx, by, 'A')
+    put(m, bx + 1, by + 1, 'A')
+  }
+  for (let y = h - trunkH; y < h; y++) {
+    put(m, cx, y, 'o')
+    put(m, cx + 1, y, 'O')
+  }
+  hline(m, cx - 2, cx + 3, h - 1, 'O')
+  return m
+}
+
+/** Звездоцвет: цветы-звёзды необычной сиреневой палитры (ур. 12, premium). */
+function plantStarflower(stage: number): Matrix {
+  const sizes: [number, number][] = [[12, 12], [16, 20], [24, 28]]
+  const [w, h] = sizes[stage]!
+  const m = blank(w, h)
+  const cx = Math.floor(w / 2)
+  const stems = 1 + stage
+  for (let i = 0; i < stems; i++) {
+    const dx = (i - (stems - 1) / 2) * Math.max(3, Math.floor(w / (stems + 2)))
+    const top = Math.floor(h * 0.3) + (i % 2)
+    vline(m, cx + dx, top, h - 2, 't')
+    // звезда: лучи из центра
+    const fy = top - 2
+    put(m, cx + dx, fy, 'h')
+    put(m, cx + dx, fy - 1, 'V')
+    put(m, cx + dx - 1, fy, 'V')
+    put(m, cx + dx + 1, fy, 'V')
+    put(m, cx + dx - 1, fy - 1, 'v')
+    put(m, cx + dx + 1, fy - 1, 'v')
+    put(m, cx + dx, fy + 1, 'v')
+    put(m, cx + dx, fy, 'q')
+  }
+  ellipse(m, cx, h - 3, Math.floor(w * 0.22), 1.5, 'l')
+  return m
+}
+
+/** Огнецвет: цветки-язычки пламени (ур. 13, premium). */
+function plantFireflower(stage: number): Matrix {
+  const sizes: [number, number][] = [[12, 12], [16, 20], [24, 28]]
+  const [w, h] = sizes[stage]!
+  const m = blank(w, h)
+  const cx = Math.floor(w / 2)
+  const stems = 1 + stage
+  for (let i = 0; i < stems; i++) {
+    const dx = (i - (stems - 1) / 2) * Math.max(3, Math.floor(w / (stems + 2)))
+    const top = Math.floor(h * 0.25) + (i % 2) * 2
+    vline(m, cx + dx, top, h - 2, 'k')
+    // пламя: внешние языки f, внутренние Z, ядро y
+    const fy = top - 2
+    put(m, cx + dx - 1, fy + 1, 'f')
+    put(m, cx + dx + 1, fy + 1, 'f')
+    put(m, cx + dx, fy, 'f')
+    put(m, cx + dx, fy - 1, 'Z')
+    put(m, cx + dx - 1, fy, 'Z')
+    put(m, cx + dx, fy + 2, 'y')
+    if (stage === 2) put(m, cx + dx, fy - 2, 'y')
+  }
+  ellipse(m, cx, h - 3, Math.floor(w * 0.24), 1.6, 'l')
+  return m
+}
+
 export const PLANT_BUILDERS: Record<string, (stage: number) => Matrix> = {
   'ph-flower': plantFlower,
   'ph-leaf': plantLeaf,
@@ -447,24 +681,62 @@
   'ph-flower-lotus': plantLotus,
   'ph-cactus': plantCactus,
   'ph-tree': plantOak,
+  'ph-drop': plantDew,
+  'ph-sun': plantSunflower,
+  'ph-tree-structure': plantBonsai,
+  'ph-butterfly': plantButterflyBush,
+  'ph-campfire': plantRowan,
+  'ph-sparkle': plantStarflower,
+  'ph-fire': plantFireflower,
 }
 
 // --- Декорации (item_key → матрица; используются и для чипов инвентаря) ---
 
-export const DECOR: Record<string, Matrix> = {
-  fence: (() => {
-    const m = blank(24, 10)
-    hline(m, 0, 23, 3, 'o')
-    hline(m, 0, 23, 4, 'O')
-    hline(m, 0, 23, 7, 'o')
-    hline(m, 0, 23, 8, 'O')
-    for (const px of [1, 11, 21]) {
-      vline(m, px, 0, 9, 'o')
-      vline(m, px + 1, 0, 9, 'O')
-      put(m, px, 0, 'O')
+/** Секция забора по маске соединений: N=1, E=2, S=4, W=8.
+ *  Столб по центру; прожилины тянутся к соседним секциям (вглубь — продолжение столба). */
+export function fenceMatrix(mask: number): Matrix {
+  const m = blank(16, 16)
+  // столб: x 7-8, от верха до земли
+  vline(m, 7, 2, 14, 'o')
+  vline(m, 8, 2, 14, 'O')
+  put(m, 7, 2, 'O')
+  put(m, 8, 1, 'o')
+  // горизонтальные прожилины (двойные: свет + тень)
+  for (const ry of [4, 8]) {
+    if (mask & 8) {
+      hline(m, 0, 6, ry, 'o')
+      hline(m, 0, 6, ry + 1, 'O')
     }
-    return m
-  })(),
+    if (mask & 2) {
+      hline(m, 9, 15, ry, 'o')
+      hline(m, 9, 15, ry + 1, 'O')
+    }
+  }
+  // вертикальные направления: тонкая прожилина (вид с торца) между столбами
+  if (mask & 1) {
+    put(m, 7, 0, 'o')
+    put(m, 7, 1, 'o')
+  }
+  if (mask & 4) put(m, 7, 15, 'o')
+  return m
+}
+
+/** Обычный зелёный куст (декорация): плотная листва в два тона, без цветов. */
+const BUSH: Matrix = (() => {
+  const m = blank(20, 16)
+  // тень-основание и крона в три слоя
+  ellipse(m, 10, 12, 9, 3.2, 'k')
+  ellipse(m, 10, 9, 8.5, 4.6, 'l')
+  ellipse(m, 8, 7.5, 5.5, 3.2, 'L')
+  // блики-листья
+  for (const [x, y] of [[5, 7], [7, 5], [11, 6], [13, 9], [9, 10]] as [number, number][])
+    put(m, x, y, 'L')
+  return m
+})()
+
+export const DECOR: Record<string, Matrix> = {
+  fence: fenceMatrix(2 | 8),
+  bush: BUSH,
   flowerbed: (() => {
     const m = blank(20, 10)
     ellipse(m, 10, 7, 9, 2.5, 'b')
@@ -519,31 +791,241 @@
     ellipse(m, 8, 10, 4, 1.4, 'x')
     return m
   })(),
+  flag: (() => {
+    // флюгер: столб с поворотной стрелкой и вымпелом
+    const m = blank(14, 20)
+    vline(m, 6, 2, 19, 'o')
+    vline(m, 7, 2, 19, 'O')
+    ellipse(m, 7, 19, 3, 1.4, 'x')
+    // вымпел вправо
+    for (let dy = 0; dy < 5; dy++)
+      hline(m, 8, 12 - Math.abs(dy - 2), 3 + dy, dy < 2 ? 'r' : 'R')
+    // стрелка-указатель
+    hline(m, 2, 11, 2, 'o')
+    put(m, 2, 1, 'o')
+    put(m, 1, 2, 'O')
+    return m
+  })(),
+  birdhouse: (() => {
+    // скворечник на столбике: домик с круглым летком
+    const m = blank(14, 16)
+    vline(m, 6, 8, 15, 'o')
+    vline(m, 7, 8, 15, 'O')
+    // корпус
+    for (let y = 4; y < 11; y++)
+      for (let x = 4; x < 10; x++) put(m, x, y, x === 4 || x === 9 ? 'O' : 'n')
+    // двускатная крыша
+    hline(m, 3, 10, 3, 'r')
+    hline(m, 4, 9, 2, 'r')
+    put(m, 6, 1, 'r')
+    put(m, 7, 1, 'R')
+    // леток + жёрдочка
+    put(m, 6, 6, 'O')
+    put(m, 7, 6, 'O')
+    hline(m, 5, 8, 11, 'o')
+    return m
+  })(),
+  gem: (() => {
+    // садовый самоцвет: кристалл на каменном постаменте
+    const m = blank(12, 16)
+    ellipse(m, 6, 13, 5, 2, 'x')
+    ellipse(m, 6, 12, 4, 1.6, 'x')
+    vline(m, 6, 13, 14, 'x')
+    // кристалл: гранёный ромб с бликом
+    fillPoly(m, [[6, 0], [9, 5], [6, 10], [3, 5]], 'd')
+    fillPoly(m, [[6, 0], [9, 5], [6, 10]], 'c')
+    put(m, 5, 3, 'h')
+    put(m, 4, 4, 'h')
+    put(m, 6, 8, 'U')
+    return m
+  })(),
   pond: (() => {
-    const m = blank(28, 14)
-    ellipse(m, 14, 7, 13, 6, 'x')
-    ellipse(m, 14, 7, 11, 4.6, 'u')
-    ellipse(m, 12, 6, 5, 2, 'U')
-    put(m, 18, 8, 'U')
-    put(m, 9, 9, 'U')
+    // большое озеро с переходами: камни → песок → отмель → глубина,
+    // границы колец растушёваны шахматным краем (без резких кромок)
+    const W = 72
+    const H = 36
+    const cx = 36
+    const cy = 18
+    const m = blank(W, H)
+    ellipse(m, cx, cy, 34, 16, 'x') // каменистый берег
+    ellipse(m, cx, cy, 30, 13.6, 'S') // песок
+    ellipse(m, cx, cy, 26.5, 11.8, 'U') // отмель
+    ellipse(m, cx, cy, 22, 9.4, 'u') // глубина
+    feather(m, cx, cy, 34, 16, 0.1, ' ') // камни → трава
+    feather(m, cx, cy, 30, 13.6, 0.1, 'x') // песок → камни
+    feather(m, cx, cy, 26.5, 11.8, 0.1, 'S') // отмель → песок
+    feather(m, cx, cy, 22, 9.4, 0.12, 'U') // глубина → отмель
+    ellipse(m, 30, 15, 9, 3.5, 'U') // блик
+    put(m, 44, 22, 'U')
+    put(m, 26, 24, 'U')
+    // кувшинки
+    for (const [lx, ly] of [
+      [18, 17],
+      [30, 21],
+      [42, 15],
+      [36, 12],
+      [24, 13],
+    ] as const) {
+      put(m, lx, ly, 'l')
+      put(m, lx + 1, ly, 'k')
+      put(m, lx, ly - 1, 'L')
+    }
+    // камыши у берега
+    for (const [rx, ry] of [
+      [7, 11],
+      [9, 9],
+      [62, 22],
+      [64, 20],
+      [12, 26],
+      [58, 13],
+    ] as const) {
+      vline(m, rx, ry, ry + 4, 't')
+      put(m, rx, ry - 1, 'k')
+    }
     return m
   })(),
   gazebo: (() => {
-    const m = blank(28, 24)
-    // крыша-конус
-    for (let y = 0; y <= 10; y++) {
-      const half = Math.round(2 + (y / 10) * 12)
-      for (let x = 14 - half; x < 14 + half; x++) put(m, x, y, 'r')
-      put(m, 14 - half, y, 'R')
-      put(m, 14 + half - 1, y, 'R')
+    // изометрия 2:1, как у домика: настил 16×16, столбы h=14, шатёр с apex z=30,
+    // свес крыши 2; видимые грани — передне-левая (тень R) и передне-правая (свет r)
+    const W = 44
+    const H = 50
+    const ox = 22
+    const oy = 30
+    const p = (wx: number, wy: number, wz: number): [number, number] => [
+      Math.round(wx - wy + ox),
+      Math.round((wx + wy) / 2 - wz + oy),
+    ]
+    const m = blank(W, H)
+
+    // настил: ромб A(0,0) B(16,0) C(16,16) D(0,16)
+    const FA = p(0, 0, 0)!
+    const FB = p(16, 0, 0)!
+    const FC = p(16, 16, 0)!
+    const FD = p(0, 16, 0)!
+    fillPoly(m, [FA, FB, FC, FD], 'o')
+    // доски настила: линии вдоль wy
+    for (let wy = 3; wy < 16; wy += 3) {
+      const q1 = p(0, wy, 0)!
+      const q2 = p(16, wy, 0)!
+      for (let t = 0; t <= 1; t += 1 / 32)
+        put(m, Math.round(q1[0] + (q2[0] - q1[0]) * t), Math.round(q1[1] + (q2[1] - q1[1]) * t), 'O')
     }
-    hline(m, 2, 25, 10, 'R')
-    // столбы и пол
-    for (const px of [4, 23]) vline(m, px, 11, 21, 'o')
-    vline(m, 14, 11, 21, 'O')
-    hline(m, 2, 25, 21, 'o')
-    hline(m, 2, 25, 22, 'O')
-    hline(m, 5, 22, 20, 'O')
+
+    // перила по видимым сторонам (z=8) + вертикальные стойки столбов
+    const seg = (a: [number, number], b: [number, number], ch: string): void => {
+      for (let t = 0; t <= 1; t += 1 / 48)
+        put(m, Math.round(a[0] + (b[0] - a[0]) * t), Math.round(a[1] + (b[1] - a[1]) * t), ch)
+    }
+    const R_B = p(16, 0, 8)!
+    const R_C = p(16, 16, 8)!
+    const R_D = p(0, 16, 8)!
+    seg(R_B, R_C, 'o')
+    seg(R_C, R_D, 'O')
+    // столбы: B (право, свет), C (перед), D (лево, тень)
+    for (const [fx, fy, lit] of [
+      [16, 0, true],
+      [16, 16, true],
+      [0, 16, false],
+    ] as const) {
+      const q = p(fx, fy, 0)!
+      vline(m, q[0], q[1] - 14, q[1], lit ? 'o' : 'O')
+      put(m, q[0] + (lit ? 1 : -1), q[1] - 10, lit ? 'O' : 'o')
+    }
+
+    // шатровая крыша: apex над центром, свес до -2..18
+    const apex = p(8, 8, 30)!
+    const EB = p(18, -2, 14)!
+    const EC = p(18, 18, 14)!
+    const ED = p(-2, 18, 14)!
+    fillPoly(m, [apex, EC, ED], 'R') // передне-левый скат (тень)
+    fillPoly(m, [apex, EB, EC], 'r') // передне-правый скат (свет)
+    // задний скат чуть виден над apex? нет — но добавим кромку конька
+    seg(ED, EC, 'O')
+    seg(EC, EB, 'O')
+    put(m, apex[0], apex[1], 'O')
+
+    return m
+  })(),
+  greenhouse: (() => {
+    // теплица в изометрии 2:1 (как домик): стеклянные стены с деревянным
+    // каркасом, двускатная стеклянная крыша
+    const W = 43
+    const H = 45
+    const ox = 18
+    const oy = 22
+    const p = (wx: number, wy: number, wz: number): [number, number] => [
+      Math.round(wx - wy + ox),
+      Math.round((wx + wy) / 2 - wz + oy),
+    ]
+    const m = blank(W, H)
+    const seg = (a: [number, number], b: [number, number], ch: string): void => {
+      for (let t = 0; t <= 1; t += 1 / 40)
+        put(m, Math.round(a[0] + (b[0] - a[0]) * t), Math.round(a[1] + (b[1] - a[1]) * t), ch)
+    }
+
+    const WX = 22 // длина по wx
+    const WY = 14 // глубина по wy
+    const WH = 9 // высота стен
+    const RZ = 17 // конёк
+
+    const B = p(WX, 0, 0)!
+    const C = p(WX, WY, 0)!
+    const D = p(0, WY, 0)!
+    const B2 = p(WX, 0, WH)!
+    const C2 = p(WX, WY, WH)!
+    const K1 = p(0, WY / 2, RZ)!
+    const K2 = p(WX, WY / 2, RZ)!
+
+    // стеклянные стены: передне-левая (тень) и передне-правая (свет)
+    wall(m, D[0], D[1], C[0], C[1], WH, 'z')
+    wall(m, C[0], C[1], B[0], B[1], WH, 'c')
+    // каркас стен: стойки каждые 4 ед. + горизонтальный пояс
+    for (let wx = 4; wx < WX; wx += 4) {
+      const q = p(wx, WY, 0)!
+      vline(m, q[0], q[1] - WH, q[1], 'O')
+    }
+    seg(p(0, WY, 4)!, p(WX, WY, 4)!, 'O')
+    for (let wy = 4; wy < WY; wy += 4) {
+      const q = p(WX, wy, 0)!
+      vline(m, q[0], q[1] - WH, q[1], 'O')
+    }
+    seg(p(WX, 0, 4)!, p(WX, WY, 4)!, 'O')
+
+    // двускатная крыша: задний скат (свет) и передний (тень), свес 2
+    const M1 = p(0, -2, WH)!
+    const M2 = p(WX, -2, WH)!
+    const P1 = p(0, WY + 2, WH)!
+    const P2 = p(WX, WY + 2, WH)!
+    fillPoly(m, [K1, K2, M2, M1], 'c')
+    fillPoly(m, [K1, K2, P2, P1], 'z')
+    // каркас крыши: линии по скатам каждые 4 ед. + кромки и конёк
+    for (let wx = 0; wx <= WX; wx += 4) {
+      seg(p(wx, -2, WH)!, p(wx, WY / 2, RZ)!, 'O')
+      seg(p(wx, WY / 2, RZ)!, p(wx, WY + 2, WH)!, 'O')
+    }
+    seg(M1, M2, 'O')
+    seg(P1, P2, 'O')
+    seg(K1, K2, 'O')
+    // щипец над правой гранью (стекло)
+    fillPoly(m, [C2, B2, K2], 'c')
+    seg(B2, K2, 'O')
+    seg(C2, K2, 'O')
+    // блики на стекле
+    put(m, 10, 16, 'h')
+    put(m, 30, 22, 'h')
+    put(m, 31, 17, 'h')
+
+    // цоколь — тёмная кромка по низу стен
+    for (let i = 0; i <= WX; i++) {
+      const q1 = p(i, WY, 0)
+      const q2 = p(WX, Math.round(WY - (i * WY) / WX), 0)
+      if (q1) put(m, q1[0], q1[1], 'O')
+      if (q2) put(m, q2[0], q2[1], 'O')
+    }
+
+    // дверь на правой грани: wy 8..12, высота 8
+    fillPoly(m, [p(WX, 12, 0)!, p(WX, 8, 0)!, p(WX, 8, 8)!, p(WX, 12, 8)!], 'd')
+
     return m
   })(),
 }
diff --git a/frontend/src/game/textures.ts b/frontend/src/game/textures.ts
index 7b0bcec..95390b9 100644
--- a/frontend/src/game/textures.ts
+++ b/frontend/src/game/textures.ts
@@ -11,6 +11,7 @@
   GRASS_B,
   GRASS_SUPER,
   GRASS_TUFT,
+  GRASS_TUFT_FLOWER,
   HEDGE,
   HOUSE,
   PAL,
@@ -20,6 +21,7 @@
   SELECT_OUTLINE,
   SHADOW,
   WILD,
+  fenceMatrix,
   plantFlower,
 } from './sprites'
 
@@ -44,7 +46,7 @@
 
 /** Текстура тайла по имени. */
 export function tileTexture(
-  name: 'grass-a' | 'grass-b' | 'grass-super' | 'grass-tuft' | 'wild' | 'hedge',
+  name: 'grass-a' | 'grass-b' | 'grass-super' | 'grass-tuft' | 'grass-daisy' | 'wild' | 'hedge',
 ): Texture {
   switch (name) {
     case 'grass-a':
@@ -55,6 +57,8 @@
       return textureFor('tile:grass-super', GRASS_SUPER, PAL)
     case 'grass-tuft':
       return textureFor('tile:grass-tuft', GRASS_TUFT, PAL)
+    case 'grass-daisy':
+      return textureFor('tile:grass-daisy', GRASS_TUFT_FLOWER, PAL)
     case 'wild':
       return textureFor('tile:wild', WILD, PAL)
     case 'hedge':
@@ -79,6 +83,11 @@
   return textureFor(`decor:${key}`, DECOR[key] ?? DECOR.flowerbed!, PAL)
 }
 
+/** Секция забора по маске соединений с соседями (N=1, E=2, S=4, W=8). */
+export function fenceTexture(mask: number): Texture {
+  return textureFor(`fence:${mask}`, fenceMatrix(mask), PAL)
+}
+
 /** Кольцо редкости. */
 export function ringTexture(rarity: string): Texture {
   return textureFor(`ring:${rarity}`, rarity === 'epic' ? RING_EPIC : RING_RARE, PAL)
diff --git a/frontend/src/gamification.ts b/frontend/src/gamification.ts
index 53ca9de..f28cb79 100644
--- a/frontend/src/gamification.ts
+++ b/frontend/src/gamification.ts
@@ -3,7 +3,8 @@
 // Особые закрытия (редкое растение, крупная задача, режим «3 вариантов»)
 // празднуются «золотым» конфетти и расширенным тостом.
 
-import { takeEarnedXp } from './api'
+import { takeCreatedReward, takeEarnedXp } from './api'
+import { wasOwnActivity } from './realtime'
 import type { EarnedReward } from './api'
 import i18n from './i18n'
 
@@ -70,4 +71,33 @@
   if (reward.options) titleParts.push(i18n.global.t('gamify.chosen'))
   if (reward.hard) titleParts.push(i18n.global.t('gamify.willpower'))
   toast?.success({ title: titleParts.join(' • '), text: rewardText(reward) })
+}
+
+// Микронаграда за создание (задача/проект): без конфетти — скромный тост,
+// что захват засчитан и капля награды начислена
+export function notifyCreated(): void {
+  const reward = takeCreatedReward()
+  if (!reward) return
+  const titleParts = [`+${reward.xp} XP`, `+${reward.coins} ${i18n.global.t('gamify.coins')}`]
+  toast?.success({
+    title: titleParts.join(' • '),
+    text: i18n.global.t('gamify.createdReward'),
+  })
+}
+
+// Дейли-награда за визит: вызывается один раз при загрузке приложения;
+// бэк решает, первый ли это визит за сутки — повторные входы молчат
+export function notifyDaily(granted: boolean, coins: number): void {
+  if (!granted || !coins) return
+  toast?.success({
+    title: `+${coins} ${i18n.global.t('gamify.coins')}`,
+    text: i18n.global.t('gamify.daily'),
+  })
+}
+
+// SSE-эхо закрытия (xp.changed {celebrate:true}): своя вкладка уже отпраздновала
+// по заголовкам ответа — тост только в соседних вкладках, без конфетти
+export function notifyRemoteXp(amount: number): void {
+  if (!amount || wasOwnActivity()) return
+  toast?.success({ title: `+${amount} XP`, text: randomPraise() })
 }
\ No newline at end of file
diff --git a/frontend/src/locales/en.ts b/frontend/src/locales/en.ts
index 62f6611..d1ea748 100644
--- a/frontend/src/locales/en.ts
+++ b/frontend/src/locales/en.ts
@@ -17,8 +17,12 @@
     confirmTitle: 'Confirmation',
     delete: 'Delete',
     open: 'Open',
+    expand: 'Expand',
+    collapse: 'Collapse',
     deleteConfirmTask: 'Delete task "{title}"? This cannot be undone.',
     deleteConfirmProject: 'Delete project "{name}"? Tasks will remain, but without a project.',
+    archive: 'To archive',
+    archiveTitle: 'Send to archive',
     saved: 'Saved',
     created: 'Created',
     create: 'Create',
@@ -41,7 +45,8 @@
     garden: 'Garden',
     stats: 'Statistics',
     projects: 'Projects',
-    options: '3 options',
+    archive: 'Archive',
+    options: 'Task handout',
     settings: 'Settings',
   },
   garden: {
@@ -52,6 +57,14 @@
     levelProgress: 'To next level: {xp} / {span} XP',
     aboutOpen: 'How it works',
     aboutTitle: 'How the garden works',
+    levelsTitle: 'Level tree',
+    levelsHint:
+      'XP thresholds and rewards of each level: new plant species (seed price) and map expansions. Levels grow from task XP — nothing expires.',
+    levelCurrent: 'current',
+    achDone: 'All steps completed (highest — {r})',
+    achStep: 'Step: roman numeral, fraction — progress to the next',
+    rewardCreateTask: 'task created',
+    rewardCreateProject: 'project created',
     about: [
       'Every completed task leaves a plant on the bed — the garden only grows and never shrinks.',
       'Completing a task earns XP: base 10 + a priority bonus (up to 15) + a size bonus from the time estimate (up to 15) + 10 for a “mentally hard” task — an honest reward for willpower. Bigger and more urgent work is worth more.',
@@ -61,8 +74,7 @@
       'Achievements mark milestones: tasks completed, levels, different projects, hours of work, strict deadlines, “mentally hard” tasks. Each has steps I, II, III with always-visible progress.',
       'A task completed from the “3 options” mode earns the “chose and did” mark. Closing a “don’t want to do it” task is always celebrated in gold — the willpower was worth it. Nothing expires, no streaks or penalties — only pleasant rewards.',
     ],
-    lastPlant: 'Latest sprout: {title} — {date}',
-    history: 'History: tasks completed by month',
+    lastReward: 'Latest reward for: {title} — {date}',
     emptyTitle: 'The garden is empty',
     emptyText: 'Complete your first task — a plant will grow on the bed.',
     levels: [
@@ -75,6 +87,9 @@
       'Garden master',
       'Garden keeper',
       'Royal gardener',
+      'Horticulture magister',
+      'Landscape architect',
+      'Keeper of legends',
       'Garden legend',
     ],
     achievements: 'Achievements',
@@ -90,15 +105,24 @@
     expansionCurrent: 'Current map: {cols}×{rows}',
     expansionMax: 'All land unlocked',
     inventory: 'Inventory',
-    inventoryHint: 'Drag a decoration onto the map; drag it back to store it',
+    inventoryHint: 'Drag a decoration or a seed onto the map; decorations can be dragged back',
+    inventoryEmpty: 'Empty for now: bought decorations wait here — drag them onto the map',
+    zoomIn: 'Zoom in',
+    zoomOut: 'Zoom out',
+    zoomReset: 'Reset view',
+    fullscreen: 'Fullscreen',
+    fullscreenExit: 'Exit fullscreen',
     boughtHint: 'Bought: {name} — drag it from the inventory below the map into the garden',
     decorations: 'Decorations',
     decorationsHint: 'Decorate your garden — decorations give no bonuses, just joy',
     unique: 'unique',
     rareOnly: 'rare plants only',
-    species: 'Plant species',
+    seeds: 'Plant seeds',
+    seedsHint:
+      'Species unlocked by level can be bought: a seed lands in the inventory — drag it onto a free cell. Rare/epic plants only grow from tasks.',
+    seedBought: 'Seed bought — drag it from the inventory onto the bed',
     speciesHint:
-      'Experience unlocks new species and land, coins buy growth and décor. A species is fixed to a plant at birth.',
+      'Experience unlocks new species and land, coins buy seeds, growth and décor. A species is fixed to a plant at birth.',
     upgrade: 'Grow — {n} coins',
     maxStage: 'Fully grown',
     stage: { sprout: 'Sprout', bush: 'Bush', bloom: 'Bloom' },
@@ -109,14 +133,26 @@
       'ph-flower-lotus': 'Lotus',
       'ph-cactus': 'Cactus',
       'ph-tree': 'Oak',
+      'ph-drop': 'Dewdrop',
+      'ph-sun': 'Sunflower',
+      'ph-tree-structure': 'Bonsai',
+      'ph-butterfly': 'Butterfly bush',
+      'ph-campfire': 'Rowan',
+      'ph-sparkle': 'Starflower',
+      'ph-fire': 'Firebloom',
     },
     decorNames: {
       fence: 'Fence',
+      bush: 'Bush',
       flowerbed: 'Flowerbed',
       lantern: 'Lantern',
       bench: 'Bench',
       birdbath: 'Birdbath',
+      flag: 'Weather vane',
+      birdhouse: 'Birdhouse',
+      gem: 'Garden gem',
       pond: 'Pond',
+      greenhouse: 'Greenhouse',
       gazebo: 'Gazebo',
     },
     ach: {
@@ -148,6 +184,8 @@
     willpower: 'willpower',
     willpowerText: 'Willpower! It was worth it.',
     coins: 'coins',
+    createdReward: 'Created — a drop of experience is yours',
+    daily: 'Daily visit reward',
   },
   stats: {
     title: 'Statistics',
@@ -211,7 +249,6 @@
     proposal: 'AI proposal:',
     proposalPending: 'Detailing in progress…',
     proposalNewProject: '+ project "{name}"',
-    proposalPriority: 'priority {n}',
     approveProposal: 'Yes, looks right',
     detail: 'Detail it',
     redetail: 'Ask AI again',
@@ -230,7 +267,7 @@
       tagsPlaceholder: 'Add a tag…',
       tags: 'Tags',
       priority: 'Priority',
-      estimate: 'Time estimate, minutes',
+      estimate: 'Time estimate',
       budget: 'Budget (in settings currency)',
       cost: 'Cost estimate (in settings currency)',
       estimateLegend: 'Estimates',
@@ -286,6 +323,7 @@
     noSubtasks: 'No subtasks',
     statusTitle: 'Status',
     changeStatus: 'Change status',
+    takeWork: 'Take on',
     mentallyHard: {
       set: "Don't want to do it",
       unset: 'Remove “mentally hard”',
@@ -327,10 +365,10 @@
     filterTag: 'Tag',
   },
   options: {
-    title: '3 options',
+    title: 'Task handout',
     done: 'Done',
     notNow: 'Not now — other options',
-    available: 'Available time, minutes',
+    availableHours: 'Available time, hours',
     suggest: 'Suggest',
     choose: 'Do it now',
     emptyTitle: 'No options',
@@ -344,6 +382,11 @@
     emptyText:
       'Create a project — tasks can be grouped and get notes with resources.',
     prompt: 'Name of the new project:',
+    promptLabel: 'Project name',
+    taskCounts: 'Tasks done {done}/{total}',
+    archived: 'Project sent to archive',
+    archiveConfirm:
+      'Send project "{name}" and its tasks ({n}) to the archive? Everything can be restored later.',
     edit: 'Edit',
     delete: 'Delete project',
     form: {
@@ -354,6 +397,24 @@
       preview: 'Preview',
     },
   },
+  pagination: {
+    prev: 'Previous',
+    next: 'Next',
+    pageOf: 'Page {n} of {m}',
+    aria: 'Pagination',
+  },
+  archive: {
+    title: 'Archive',
+    count: 'Projects: {n}',
+    emptyTitle: 'Archive is empty',
+    emptyText: 'Projects sent to the archive end up here — with all their tasks and history.',
+    restore: 'Restore',
+    restored: '"{name}" restored from the archive',
+    deleteForever: 'Delete forever',
+    deleteConfirm:
+      'Delete "{name}" forever? The project and all its tasks will be lost irreversibly.',
+    banner: 'This project is in the archive — history is read-only. Restore it to keep working.',
+  },
   settings: {
     title: 'Settings',
     currencyTitle: 'Budget currency',
@@ -382,6 +443,12 @@
     linkText: 'link text',
     code: 'Code',
   },
+  duration: {
+    hours: 'Hours',
+    minutes: 'Minutes',
+    h: 'h',
+    min: 'min',
+  },
   taskui: {
     priority: {
       very_low: 'Very low',
@@ -400,7 +467,6 @@
     relevance: {
       active: 'Active',
       paused: 'Paused',
-      archived: 'Archived',
     },
     time: {
       hm: '{h} h {m} m',
diff --git a/frontend/src/locales/ru.ts b/frontend/src/locales/ru.ts
index 37a762d..766c8b4 100644
--- a/frontend/src/locales/ru.ts
+++ b/frontend/src/locales/ru.ts
@@ -18,8 +18,12 @@
     confirmTitle: 'Подтверждение',
     delete: 'Удалить',
     open: 'Открыть',
+    expand: 'Развернуть',
+    collapse: 'Свернуть',
     deleteConfirmTask: 'Удалить задачу «{title}»? Действие необратимо.',
     deleteConfirmProject: 'Удалить проект «{name}»? Задачи останутся, но без проекта.',
+    archive: 'В архив',
+    archiveTitle: 'Отправить в архив',
     saved: 'Сохранено',
     created: 'Создано',
     create: 'Создать',
@@ -42,7 +46,8 @@
     garden: 'Сад',
     stats: 'Статистика',
     projects: 'Проекты',
-    options: '3 варианта',
+    archive: 'Архив',
+    options: 'Выдача задачи',
     settings: 'Настройки',
   },
   garden: {
@@ -53,6 +58,14 @@
     levelProgress: 'До уровня: {xp} / {span} XP',
     aboutOpen: 'Как это работает',
     aboutTitle: 'Как устроен сад',
+    levelsTitle: 'Дерево уровней',
+    levelsHint:
+      'Пороги XP и награды каждого уровня: новые виды растений (цена семени) и расширения карты. Уровень растёт из опыта за задачи — ничего не сгорает.',
+    levelCurrent: 'текущий',
+    achDone: 'Все ступени пройдены (высшая — {r})',
+    achStep: 'Ступень: римская — номер, дробь — прогресс к следующей',
+    rewardCreateTask: 'создание задачи',
+    rewardCreateProject: 'создание проекта',
     about: [
       'Каждая закрытая задача оставляет на грядке растение — сад только растёт и никогда не уменьшается.',
       'За закрытие начисляется XP: база 10 + бонус за приоритет задачи (до 15) + бонус за объём работы по оценке времени (до 15) + 10 за «ментально сложную» — честная награда за силу воли. Крупные и срочные дела ценнее.',
@@ -62,8 +75,7 @@
       'Достижения отмечают вехи: закрытые задачи, уровни, разные проекты, часы работы, строгие дедлайны, «ментально сложные» задачи. У каждой ступени I, II, III — прогресс виден всегда.',
       'Задача, закрытая из режима «3 вариантов», отмечается меткой «выбрал и сделал». Закрытие «не хочется делать» празднуется золотом — сила воли того стоила. Ничего не сгорает, серий и наказаний нет — только приятные награды.',
     ],
-    lastPlant: 'Последний росток: {title} — {date}',
-    history: 'История: закрытых задач по месяцам',
+    lastReward: 'Последняя награда за: {title} — {date}',
     emptyTitle: 'Сад пока пуст',
     emptyText: 'Закройте первую задачу — на грядке появится растение.',
     levels: [
@@ -76,6 +88,9 @@
       'Садовый мастер',
       'Хранитель сада',
       'Королевский садовник',
+      'Магистр садоводства',
+      'Ландшафтный архитектор',
+      'Хранитель легенд',
       'Легенда сада',
     ],
     achievements: 'Достижения',
@@ -91,15 +106,23 @@
     expansionCurrent: 'Текущая карта: {cols}×{rows}',
     expansionMax: 'Вся земля открыта',
     inventory: 'Инвентарь',
-    inventoryHint: 'Перетащите декорацию на карту; с карты можно вернуть обратно',
+    inventoryHint: 'Перетащите декорацию или семя на карту; декорацию можно вернуть обратно',
+    inventoryEmpty: 'Пока пусто: купленные декорации ждут здесь — перетащите их на карту',
+    zoomIn: 'Приблизить',
+    zoomOut: 'Отдалить',
+    zoomReset: 'Сбросить вид',
+    fullscreen: 'Во весь экран',
+    fullscreenExit: 'Выйти из полного экрана',
     boughtHint: 'Куплено: {name} — перетащите её из инвентаря под картой на сад',
     decorations: 'Декорации',
     decorationsHint: 'Украсьте сад — декорации не дают бонусов, только настроение',
     unique: 'уникальная',
     rareOnly: 'только редкие растения',
-    species: 'Виды растений',
+    seeds: 'Семена растений',
+    seedsHint: 'Открытые уровнем виды можно купить: семя попадает в инвентарь — перетащите его на свободную клетку. Редкие/эпик рождаются только из задач.',
+    seedBought: 'Семя куплено — перетащите его из инвентаря на грядку',
     speciesHint:
-      'Опыт открывает новые виды и землю, монеты покупают рост и украшения. Вид фиксируется за растением в момент рождения.',
+      'Опыт открывает новые виды и землю, монеты покупают семена, рост и украшения. Вид фиксируется за растением в момент рождения.',
     upgrade: 'Вырастить — {n} монет',
     maxStage: 'Полностью выросло',
     stage: { sprout: 'Росток', bush: 'Куст', bloom: 'Цветение' },
@@ -110,14 +133,26 @@
       'ph-flower-lotus': 'Лотос',
       'ph-cactus': 'Кактус',
       'ph-tree': 'Дуб',
+      'ph-drop': 'Роса',
+      'ph-sun': 'Подсолнух',
+      'ph-tree-structure': 'Бонсай',
+      'ph-butterfly': 'Бабочий куст',
+      'ph-campfire': 'Рябина',
+      'ph-sparkle': 'Звездоцвет',
+      'ph-fire': 'Огнецвет',
     },
     decorNames: {
       fence: 'Изгородь',
+      bush: 'Куст',
       flowerbed: 'Клумба',
       lantern: 'Фонарь',
       bench: 'Лавочка',
       birdbath: 'Поилка для птиц',
+      flag: 'Флюгер',
+      birdhouse: 'Скворечник',
+      gem: 'Садовый самоцвет',
       pond: 'Пруд',
+      greenhouse: 'Теплица',
       gazebo: 'Беседка',
     },
     ach: {
@@ -149,6 +184,8 @@
     willpower: 'сила воли',
     willpowerText: 'Сила воли! Это того стоило.',
     coins: 'монет',
+    createdReward: 'Создано — капля опыта уже ваша',
+    daily: 'Ежедневная награда за визит',
   },
   stats: {
     title: 'Статистика',
@@ -212,7 +249,6 @@
     proposal: 'Предложение ИИ:',
     proposalPending: 'Детализация подбирается…',
     proposalNewProject: '+ проект «{name}»',
-    proposalPriority: 'приоритет {n}',
     approveProposal: 'Да, всё верно',
     detail: 'Детализировать',
     redetail: 'Переспросить ИИ',
@@ -231,7 +267,7 @@
       tagsPlaceholder: 'Добавить тег…',
       tags: 'Теги',
       priority: 'Приоритет',
-      estimate: 'Оценка времени, минут',
+      estimate: 'Оценка времени',
       budget: 'Бюджет (в валюте настроек)',
       cost: 'Оценка затрат (в валюте настроек)',
       estimateLegend: 'Оценка',
@@ -287,6 +323,7 @@
     noSubtasks: 'Подзадач нет',
     statusTitle: 'Статус',
     changeStatus: 'Изменить статус',
+    takeWork: 'Взять в работу',
     mentallyHard: {
       set: 'Не хочется делать',
       unset: 'Снять «ментально сложная»',
@@ -328,10 +365,10 @@
     filterTag: 'Тег',
   },
   options: {
-    title: '3 варианта',
+    title: 'Выдача задачи',
     done: 'Готово',
     notNow: 'Не сейчас — другие варианты',
-    available: 'Доступное время, минут',
+    availableHours: 'Доступное время, часов',
     suggest: 'Предложить',
     choose: 'Делаем сейчас',
     emptyTitle: 'Вариантов нет',
@@ -346,6 +383,11 @@
     emptyText:
       'Создайте проект — задачи можно будет группировать и добавлять заметки с ресурсами.',
     prompt: 'Название нового проекта:',
+    promptLabel: 'Название проекта',
+    taskCounts: 'Задач закрыто {done}/{total}',
+    archived: 'Проект отправлен в архив',
+    archiveConfirm:
+      'Отправить проект «{name}» и его задачи ({n}) в архив? Всё можно будет восстановить из архива.',
     edit: 'Редактировать',
     delete: 'Удалить проект',
     form: {
@@ -356,6 +398,24 @@
       preview: 'Предпросмотр',
     },
   },
+  pagination: {
+    prev: 'Назад',
+    next: 'Вперёд',
+    pageOf: 'Страница {n} из {m}',
+    aria: 'Постраничная навигация',
+  },
+  archive: {
+    title: 'Архив',
+    count: 'Проектов: {n}',
+    emptyTitle: 'Архив пуст',
+    emptyText: 'Сюда попадают проекты, отправленные в архив, — вместе со всеми задачами и историей.',
+    restore: 'Восстановить',
+    restored: '«{name}» восстановлен из архива',
+    deleteForever: 'Удалить навсегда',
+    deleteConfirm:
+      'Удалить «{name}» навсегда? Проект и все его задачи будут потеряны безвозвратно.',
+    banner: 'Проект в архиве — история доступна только для просмотра. Восстановите его, чтобы продолжить работу.',
+  },
   settings: {
     title: 'Настройки',
     currencyTitle: 'Валюта бюджетов',
@@ -384,6 +444,12 @@
     linkText: 'текст ссылки',
     code: 'Код',
   },
+  duration: {
+    hours: 'Часы',
+    minutes: 'Минуты',
+    h: 'ч',
+    min: 'мин',
+  },
   taskui: {
     priority: {
       very_low: 'Очень низкий',
@@ -402,7 +468,6 @@
     relevance: {
       active: 'Активен',
       paused: 'Приостановлен',
-      archived: 'Закрыт',
     },
     time: {
       hm: '{h} ч {m} м',
diff --git a/frontend/src/locales/uk.ts b/frontend/src/locales/uk.ts
index 00b4bac..9bff265 100644
--- a/frontend/src/locales/uk.ts
+++ b/frontend/src/locales/uk.ts
@@ -17,8 +17,12 @@
     confirmTitle: 'Підтвердження',
     delete: 'Видалити',
     open: 'Відкрити',
+    expand: 'Розгорнути',
+    collapse: 'Згорнути',
     deleteConfirmTask: 'Видалити задачу «{title}»? Дію не можна скасувати.',
     deleteConfirmProject: 'Видалити проєкт «{name}»? Задачі залишаться, але без проєкту.',
+    archive: 'До архіву',
+    archiveTitle: 'Надіслати до архіву',
     saved: 'Збережено',
     created: 'Створено',
     create: 'Створити',
@@ -41,7 +45,8 @@
     garden: 'Сад',
     stats: 'Статистика',
     projects: 'Проєкти',
-    options: '3 варіанти',
+    archive: 'Архів',
+    options: 'Видача завдання',
     settings: 'Налаштування',
   },
   garden: {
@@ -52,6 +57,14 @@
     levelProgress: 'До наступного рівня: {xp} / {span} XP',
     aboutOpen: 'Як це працює',
     aboutTitle: 'Як влаштований сад',
+    levelsTitle: 'Дерево рівнів',
+    levelsHint:
+      'Пороги XP та нагороди кожного рівня: нові види рослин (ціна насіння) й розширення мапи. Рівень росте з досвіду за завдання — нічого не згорає.',
+    levelCurrent: 'поточний',
+    achDone: 'Усі щаблі пройдено (вищий — {r})',
+    achStep: 'Щабель: римська — номер, дріб — прогрес до наступного',
+    rewardCreateTask: 'створення завдання',
+    rewardCreateProject: 'створення проєкту',
     about: [
       'Кожне виконане завдання залишає на грядці рослину — сад лише зростає і ніколи не зменшується.',
       'За виконання нараховується XP: база 10 + бонус за пріоритет (до 15) + бонус за обсяг за оцінкою часу (до 15) + 10 за «ментально складне» — чесна нагорода за силу волі. Великі й термінові справи цінніші.',
@@ -61,8 +74,7 @@
       'Досягнення відзначають віхи: виконані завдання, рівні, різні проєкти, години роботи, строгі дедлайни, «ментально складні» завдання. У кожного ступені I, II, III — прогрес видно завжди.',
       'Завдання, виконане з режиму «3 варіанти», відзначається меткою «обрав і зробив». Закриття «не хочеться робити» завжди святкується золотом — сила волі того варта. Нічого не згорає, серій і покарань немає — лише приємні нагороди.',
     ],
-    lastPlant: 'Останній паросток: {title} — {date}',
-    history: 'Історія: виконаних завдань за місяцями',
+    lastReward: 'Остання нагорода за: {title} — {date}',
     emptyTitle: 'Сад поки порожній',
     emptyText: 'Закрийте перше завдання — на грядці зросте рослина.',
     levels: [
@@ -75,6 +87,9 @@
       'Садовий майстер',
       'Хранитель саду',
       'Королівський садівник',
+      'Магістр садівництва',
+      'Ландшафтний архітектор',
+      'Хранитель легенд',
       'Легенда саду',
     ],
     achievements: 'Досягнення',
@@ -90,15 +105,24 @@
     expansionCurrent: 'Поточна карта: {cols}×{rows}',
     expansionMax: 'Вся земля відкрита',
     inventory: 'Інвентар',
-    inventoryHint: 'Перетягніть декорацію на карту; з карти можна повернути назад',
+    inventoryHint: 'Перетягніть декорацію або насіння на карту; декорацію можна повернути назад',
+    inventoryEmpty: 'Поки порожньо: куплені декорації чекають тут — перетягніть їх на карту',
+    zoomIn: 'Наблизити',
+    zoomOut: 'Віддалити',
+    zoomReset: 'Скинути вид',
+    fullscreen: 'На весь екран',
+    fullscreenExit: 'Вийти з повного екрана',
     boughtHint: 'Куплено: {name} — перетягніть її з інвентаря під картою на сад',
     decorations: 'Декорації',
     decorationsHint: 'Прикрасьте сад — декорації не дають бонусів, лише настрій',
     unique: 'унікальна',
     rareOnly: 'лише рідкісні рослини',
-    species: 'Види рослин',
+    seeds: 'Насіння рослин',
+    seedsHint:
+      'Види, відкриті рівнем, можна купити: насіння потрапляє в інвентар — перетягніть його на вільну клітинку. Рідкісні/епік народжуються лише із завдань.',
+    seedBought: 'Насіння куплено — перетягніть його з інвентаря на грядку',
     speciesHint:
-      'Досвід відкриває нові види й землю, монети купують ріст та прикраси. Вид фіксується за рослиною в момент народження.',
+      'Досвід відкриває нові види й землю, монети купують насіння, ріст та прикраси. Вид фіксується за рослиною в момент народження.',
     upgrade: 'Виростити — {n} монет',
     maxStage: 'Повністю виросло',
     stage: { sprout: 'Паросток', bush: 'Кущ', bloom: 'Цвітіння' },
@@ -109,14 +133,26 @@
       'ph-flower-lotus': 'Лотос',
       'ph-cactus': 'Кактус',
       'ph-tree': 'Дуб',
+      'ph-drop': 'Роса',
+      'ph-sun': 'Соняшник',
+      'ph-tree-structure': 'Бонсай',
+      'ph-butterfly': 'Метеликів кущ',
+      'ph-campfire': 'Горобина',
+      'ph-sparkle': 'Зорецвіт',
+      'ph-fire': 'Вогнецвіт',
     },
     decorNames: {
       fence: 'Огорожа',
+      bush: 'Кущ',
       flowerbed: 'Клумба',
       lantern: 'Фонар',
       bench: 'Лавка',
       birdbath: 'Поїлка для птахів',
+      flag: 'Флюгер',
+      birdhouse: 'Шпаківня',
+      gem: 'Садове самоцвіт',
       pond: 'Ставок',
+      greenhouse: 'Теплиця',
       gazebo: 'Альтанка',
     },
     ach: {
@@ -148,6 +184,8 @@
     willpower: 'сила волі',
     willpowerText: 'Сила волі! Того варто було.',
     coins: 'монет',
+    createdReward: 'Створено — краплина досвіду вже ваша',
+    daily: 'Щоденна нагорода за візит',
   },
   stats: {
     title: 'Статистика',
@@ -211,7 +249,6 @@
     proposal: 'Пропозиція ШІ:',
     proposalPending: 'Деталізація підбирається…',
     proposalNewProject: '+ проєкт «{name}»',
-    proposalPriority: 'пріоритет {n}',
     approveProposal: 'Так, все вірно',
     detail: 'Деталізувати',
     redetail: 'Перепитати ШІ',
@@ -230,7 +267,7 @@
       tagsPlaceholder: 'Додати теґ…',
       tags: 'Теґи',
       priority: 'Пріоритет',
-      estimate: 'Оцінка часу, хвилин',
+      estimate: 'Оцінка часу',
       budget: 'Бюджет (у валюті налаштувань)',
       cost: 'Оцінка витрат (у валюті налаштувань)',
       estimateLegend: 'Оцінка',
@@ -286,6 +323,7 @@
     noSubtasks: 'Підзадач немає',
     statusTitle: 'Статус',
     changeStatus: 'Змінити статус',
+    takeWork: 'Взяти в роботу',
     mentallyHard: {
       set: 'Не хочеться робити',
       unset: 'Зняти «ментально складне»',
@@ -327,10 +365,10 @@
     filterTag: 'Теґ',
   },
   options: {
-    title: '3 варіанти',
+    title: 'Видача завдання',
     done: 'Готово',
     notNow: 'Не зараз — інші варіанти',
-    available: 'Доступний час, хвилин',
+    availableHours: 'Доступний час, годин',
     suggest: 'Запропонувати',
     choose: 'Робимо зараз',
     emptyTitle: 'Варіантів немає',
@@ -344,6 +382,11 @@
     emptyText:
       'Створіть проєкт — задачі можна буде групувати й додавати нотатки з ресурсами.',
     prompt: 'Назва нового проєкту:',
+    promptLabel: 'Назва проєкту',
+    taskCounts: 'Задач закрито {done}/{total}',
+    archived: 'Проєкт надіслано до архіву',
+    archiveConfirm:
+      'Надіслати проєкт «{name}» і його задачі ({n}) до архіву? Все можна буде відновити.',
     edit: 'Редагувати',
     delete: 'Видалити проєкт',
     form: {
@@ -354,6 +397,24 @@
       preview: 'Попередній перегляд',
     },
   },
+  pagination: {
+    prev: 'Назад',
+    next: 'Вперед',
+    pageOf: 'Сторінка {n} з {m}',
+    aria: 'Посторінкова навігація',
+  },
+  archive: {
+    title: 'Архів',
+    count: 'Проєктів: {n}',
+    emptyTitle: 'Архів порожній',
+    emptyText: 'Сюди потрапляють проєкти, надіслані до архіву, — разом із усіма задачами та історією.',
+    restore: 'Відновити',
+    restored: '«{name}» відновлено з архіву',
+    deleteForever: 'Видалити назавжди',
+    deleteConfirm:
+      'Видалити «{name}» назавжди? Проєкт і всі його задачі буде втрачено безповоротно.',
+    banner: 'Проєкт в архіві — історія доступна лише для перегляду. Відновіть його, щоб продовжити роботу.',
+  },
   settings: {
     title: 'Налаштування',
     currencyTitle: 'Валюта бюджетів',
@@ -382,6 +443,12 @@
     linkText: 'текст посилання',
     code: 'Код',
   },
+  duration: {
+    hours: 'Години',
+    minutes: 'Хвилини',
+    h: 'год',
+    min: 'хв',
+  },
   taskui: {
     priority: {
       very_low: 'Дуже низький',
@@ -400,7 +467,6 @@
     relevance: {
       active: 'Активний',
       paused: 'Призупинено',
-      archived: 'Закрито',
     },
     time: {
       hm: '{h} год {m} хв',
diff --git a/frontend/src/main.ts b/frontend/src/main.ts
index 677aac5..6519de0 100644
--- a/frontend/src/main.ts
+++ b/frontend/src/main.ts
@@ -7,8 +7,10 @@
 
 import App from './App.vue'
 import i18n from './i18n'
+import { installDropdownClamp } from './dropdownClamp'
 import { setPageTitle } from './taskui'
 import ListView from './views/ListView.vue'
+import ArchiveView from './views/ArchiveView.vue'
 import GardenView from './views/GardenView.vue'
 import StatsView from './views/StatsView.vue'
 import OptionsView from './views/OptionsView.vue'
@@ -30,6 +32,7 @@
     { path: '/projects', component: ProjectsView, meta: { title: 'nav.projects' } },
     // название проекта/задачи в тайтл подставляет вид после загрузки данных
     { path: '/projects/:id', component: ProjectView, meta: { title: 'nav.projects' } },
+    { path: '/archive', component: ArchiveView, meta: { title: 'nav.archive' } },
     { path: '/tasks/:id', component: TaskView, meta: { title: 'nav.task' } },
     { path: '/options', component: OptionsView, meta: { title: 'nav.options' } },
     { path: '/settings', component: SettingsView, meta: { title: 'nav.settings' } },
@@ -42,4 +45,7 @@
   setPageTitle(key ? i18n.global.t(key) : undefined)
 })
 
-createApp(App).use(router).use(i18n).use(GnexusUiVue).mount('#app')
\ No newline at end of file
+createApp(App).use(router).use(i18n).use(GnexusUiVue).mount('#app')
+
+// Дропдауны всегда в пределах экрана (мобильные: «⋯» у правого края)
+installDropdownClamp()
\ No newline at end of file
diff --git a/frontend/src/realtime.ts b/frontend/src/realtime.ts
new file mode 100644
index 0000000..32c1578
--- /dev/null
+++ b/frontend/src/realtime.ts
@@ -0,0 +1,142 @@
+// Серверные события (SSE, ТЗ 3.14): единый EventSource на вкладку.
+// События грубозернистые (kind + данные): подписчики реагируют refetch'ем.
+// Reconnect: браузер сам переподключает EventSource, но при CLOSED-состоянии
+// (сессия истекла / сеть лежит долго) включается backoff 1→2→5→15 с.
+import { onScopeDispose } from 'vue'
+
+export interface RealtimeEvent {
+  kind: string
+  data?: Record<string, unknown> | null
+}
+
+type Handler = (e: RealtimeEvent) => void
+
+// kind → подписчики; '*' — любые события и синтетика onopen (форс-рефреш)
+const handlers = new Map<string, Set<Handler>>()
+let source: EventSource | null = null
+let retryAttempt = 0
+let retryTimer: ReturnType<typeof setTimeout> | null = null
+
+const BACKOFFS = [1000, 2000, 5000, 15000]
+
+function emit(e: RealtimeEvent): void {
+  for (const h of handlers.get(e.kind) ?? []) h(e)
+  for (const h of handlers.get('*') ?? []) h(e)
+}
+
+function connect(): void {
+  source = new EventSource('/api/events')
+  source.onopen = () => {
+    retryAttempt = 0
+    // синтетическое событие: после разрыва все виды перечитывают данные
+    emit({ kind: '*' })
+  }
+  source.onmessage = (msg: MessageEvent) => {
+    try {
+      emit(JSON.parse(msg.data) as RealtimeEvent)
+    } catch {
+      // мусорный кадр — игнорируем
+    }
+  }
+  source.onerror = () => {
+    if (source && source.readyState === EventSource.CLOSED) {
+      source = null
+      scheduleReconnect()
+    }
+    // CONNECTING — браузер переподключается сам, ничего не делаем
+  }
+}
+
+function scheduleReconnect(): void {
+  if (retryTimer) return
+  const delay = BACKOFFS[Math.min(retryAttempt, BACKOFFS.length - 1)]
+  retryAttempt++
+  retryTimer = setTimeout(async () => {
+    retryTimer = null
+    // 401 — сессия истекла: на вход вместо вечного переподключения
+    try {
+      const res = await fetch('/api/xp')
+      if (res.status === 401) {
+        window.location.href = '/auth/login'
+        return
+      }
+    } catch {
+      // сеть лежит — пробуем дальше
+    }
+    connect()
+  }, delay)
+}
+
+// Idempotent: повторный вызов (HMR, повторный onMounted) соединение не дублирует
+export function startRealtime(): void {
+  if (source || retryTimer) return
+  retryAttempt = 0
+  connect()
+}
+
+export function stopRealtime(): void {
+  if (retryTimer) {
+    clearTimeout(retryTimer)
+    retryTimer = null
+  }
+  source?.close()
+  source = null
+}
+
+export function onRealtime(kind: string, handler: Handler): () => void {
+  let set = handlers.get(kind)
+  if (!set) {
+    set = new Set()
+    handlers.set(kind, set)
+  }
+  set.add(handler)
+  return () => {
+    set?.delete(handler)
+    if (set && set.size === 0) handlers.delete(kind)
+  }
+}
+
+// Дедуп XP-тостов (окно 3 с): собственные действия празднуются по заголовкам
+// ответа (celebrateEarned), SSE-эхо и эхо соседней вкладки молчат.
+const OWN_ACTIVITY_KEY = 'gntodo:own-activity'
+const OWN_ACTIVITY_WINDOW = 3000
+
+export function markOwnActivity(): void {
+  try {
+    localStorage.setItem(OWN_ACTIVITY_KEY, String(Date.now()))
+  } catch {
+    // приватный режим — дедуп не работает, тосты могут задвоиться
+  }
+}
+
+export function wasOwnActivity(): boolean {
+  try {
+    const ts = Number(localStorage.getItem(OWN_ACTIVITY_KEY))
+    return ts > 0 && Date.now() - ts < OWN_ACTIVITY_WINDOW
+  } catch {
+    return false
+  }
+}
+
+// Trailing-debounce refetch: бёрст «закрытие задачи» (task.changed + xp.changed +
+// garden.changed) коалесцирует в один запрос. Также слушает '*' — форс-рефреш
+// после reconnect'а. Вызывать в setup вида; отписка — при размонтировании.
+export function useRealtimeRefresh(
+  loader: () => void | Promise<void>,
+  kinds: string[],
+  debounceMs = 300,
+): void {
+  let timer: ReturnType<typeof setTimeout> | null = null
+  const run = () => {
+    if (timer) clearTimeout(timer)
+    timer = setTimeout(() => {
+      timer = null
+      void loader()
+    }, debounceMs)
+  }
+  const offs = [...kinds, '*'].map((kind) => onRealtime(kind, run))
+  onScopeDispose(() => {
+    offs.forEach((off) => off())
+    if (timer) clearTimeout(timer)
+  })
+}
\ No newline at end of file
diff --git a/frontend/src/taskui.ts b/frontend/src/taskui.ts
index 8690451..228120e 100644
--- a/frontend/src/taskui.ts
+++ b/frontend/src/taskui.ts
@@ -27,9 +27,11 @@
   return tOr(`taskui.status.${status}`, status)
 }
 
+// Цвета — варианты бейджа кита (accent у бейджей без раскраски, поэтому
+// «в работе» — синий secondary: полутон статуса читается сразу)
 export const STATUS_VARIANTS: Record<string, string> = {
   to_do: 'info',
-  in_progress: 'accent',
+  in_progress: 'secondary',
   done: 'success',
   cancelled: 'error',
   deferred: 'warning',
@@ -39,9 +41,10 @@
   return STATUS_VARIANTS[status] ?? 'neutral'
 }
 
-// Иконка статуса — согласована со счётчиками статистики (ph-square / ph-circle-half / …)
+// Иконка статуса — согласована со счётчиками статистики.
+// Серия кругов: пустой (к выполнению) → наполовину (в работе) → галочка (завершено).
 export const STATUS_ICONS: Record<string, string> = {
-  to_do: 'ph-square',
+  to_do: 'ph-circle',
   in_progress: 'ph-circle-half',
   done: 'ph-check-circle',
   cancelled: 'ph-x-circle',
@@ -49,7 +52,7 @@
 }
 
 export function statusIcon(status: string): string {
-  return STATUS_ICONS[status] ?? 'ph-square'
+  return STATUS_ICONS[status] ?? 'ph-circle'
 }
 
 export function relevanceLabel(status: string): string {
@@ -78,10 +81,11 @@
 }
 
 export function priorityVariant(priority: number): string {
+  // Шкала серьёзности: от нейтрального светлого к тревожному красному
   const variants: Record<PriorityGrade, string> = {
-    very_low: 'neutral',
+    very_low: 'primary',
     low: 'info',
-    medium: 'primary',
+    medium: 'secondary',
     high: 'warning',
     urgent: 'error',
   }
@@ -244,7 +248,7 @@
       label: p.new_project ? t('stack.proposalNewProject', { name: p.project }) : p.project,
     })
   if (p.priority !== null)
-    items.push({ icon: 'ph-flag', label: t('stack.proposalPriority', { n: p.priority }) })
+    items.push({ icon: 'ph-flag', label: priorityLabel(p.priority) })
   if (p.estimated_minutes !== null && p.estimated_minutes !== undefined)
     items.push({ icon: 'ph-timer', label: `≈ ${formatMinutes(p.estimated_minutes)}` })
   return items
diff --git a/frontend/src/views/ArchiveView.vue b/frontend/src/views/ArchiveView.vue
new file mode 100644
index 0000000..a8c4371
--- /dev/null
+++ b/frontend/src/views/ArchiveView.vue
@@ -0,0 +1,193 @@
+<script setup lang="ts">
+import { computed, onMounted, ref } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { useRouter } from 'vue-router'
+import { useToast } from 'gnexus-ui-kit/vue'
+import { api, type Project } from '../api'
+import { useRealtimeRefresh } from '../realtime'
+import { relevanceLabel } from '../taskui'
+import PriorityBadge from '../components/PriorityBadge.vue'
+import ConfirmDialog from '../components/ConfirmDialog.vue'
+import Pagination from '../components/Pagination.vue'
+
+// Архив (ТЗ 3.11): история проектов. Архивный проект виден со всей
+// историей задач (страница проекта доступна на чтение), его можно
+// восстановить как был или удалить навсегда.
+
+const { t } = useI18n()
+const router = useRouter()
+const toast = useToast()
+
+const projects = ref<Project[]>([])
+const error = ref('')
+const loading = ref(false)
+
+// Счётчики задач по проектам: всего / завершено (как на «Проектах»)
+const taskCounts = ref(new Map<number, { total: number; done: number }>())
+
+async function load() {
+  loading.value = true
+  error.value = ''
+  try {
+    const [archived, tasks] = await Promise.all([
+      api.listProjects(true),
+      api.listTasks({ include_archived: 'true' }),
+    ])
+    projects.value = archived
+    const map = new Map<number, { total: number; done: number }>()
+    tasks.forEach((task) => {
+      if (!task.project) return
+      const entry = map.get(task.project.id) ?? { total: 0, done: 0 }
+      entry.total += 1
+      if (task.status === 'done') entry.done += 1
+      map.set(task.project.id, entry)
+    })
+    taskCounts.value = map
+  } catch (e) {
+    error.value = String(e)
+  } finally {
+    loading.value = false
+  }
+}
+
+onMounted(load)
+
+// Реактивность (ТЗ 3.14): архив/восстановление из другой вкладки или MCP
+useRealtimeRefresh(load, ['project.changed', 'project.deleted'])
+
+// Пагинация: по 30 проектов на страницу
+const page = ref(1)
+const pagedProjects = computed(() =>
+  projects.value.slice((page.value - 1) * 30, page.value * 30),
+)
+
+function countsOf(id: number): { total: number; done: number } {
+  return taskCounts.value.get(id) ?? { total: 0, done: 0 }
+}
+
+// Восстановить: проект возвращается в «Проекты» со всеми задачами
+async function restore(project: Project) {
+  try {
+    await api.restoreProject(project.id)
+    toast.success({ title: t('archive.restored', { name: project.name }) })
+    await load()
+  } catch (e) {
+    toast.error({ title: t('common.error'), text: String(e) })
+  }
+}
+
+// Удалить навсегда — через подтверждение
+const deleteTarget = ref<Project | null>(null)
+const confirmOpen = ref(false)
+
+function askDelete(project: Project) {
+  deleteTarget.value = project
+  confirmOpen.value = true
+}
+
+async function remove() {
+  const project = deleteTarget.value
+  if (!project) return
+  confirmOpen.value = false
+  try {
+    await api.deleteProject(project.id)
+    toast.success({ title: t('common.projectDeleted') })
+    await load()
+  } catch (e) {
+    toast.error({ title: t('common.error'), text: String(e) })
+  }
+}
+
+const headerMeta = computed(() =>
+  projects.value.length ? t('archive.count', { n: projects.value.length }) : '',
+)
+</script>
+
+<template>
+  <section>
+    <GnPageHeader kicker="GNexus Tasks" :title="t('archive.title')">
+      <template #meta>{{ headerMeta }}</template>
+    </GnPageHeader>
+
+    <GnAlert v-if="error" variant="error">{{ error }}</GnAlert>
+
+    <GnSkeleton v-if="loading && projects.length === 0" type="block" stack :count="2" class="list-skeleton" />
+
+    <GnEmptyState
+      v-else-if="projects.length === 0"
+      icon="ph-archive"
+      :title="t('archive.emptyTitle')"
+      :text="t('archive.emptyText')"
+    />
+
+    <div class="archive-list">
+      <GnCard v-for="project in pagedProjects" :key="project.id" class="archive-card">
+        <template #title>
+          <RouterLink class="card-link" :to="`/projects/${project.id}`">{{ project.name }}</RouterLink>
+        </template>
+
+        <div class="archive-meta">
+          <GnBadge variant="neutral"><i class="ph ph-activity" aria-hidden="true" />
+            {{ relevanceLabel(project.relevance_status) }}
+          </GnBadge>
+          <PriorityBadge v-if="project.priority !== null" :priority="project.priority" />
+          <GnBadge variant="neutral"><i class="ph ph-list-checks" aria-hidden="true" />
+            {{ t('projects.taskCounts', countsOf(project.id)) }}
+          </GnBadge>
+        </div>
+
+        <div class="form-actions">
+          <GnButton variant="secondary" size="sm" icon="ph-arrow-square-out" @click="router.push(`/projects/${project.id}`)">
+            {{ t('common.open') }}
+          </GnButton>
+          <GnButton variant="success" size="sm" icon="ph-arrow-counter-clockwise" @click="restore(project)">
+            {{ t('archive.restore') }}
+          </GnButton>
+          <GnIconButton icon="ph-trash" :label="t('archive.deleteForever')" @click="askDelete(project)" />
+        </div>
+      </GnCard>
+    </div>
+
+    <Pagination v-model:page="page" :total="projects.length" />
+
+    <ConfirmDialog
+      v-model:open="confirmOpen"
+      :title="t('common.confirmTitle')"
+      :message="t('archive.deleteConfirm', { name: deleteTarget?.name ?? '' })"
+      :confirm-text="t('archive.deleteForever')"
+      :cancel-text="t('common.cancel')"
+      confirm-variant="danger"
+      confirm-icon="ph-trash"
+      @confirm="remove"
+    />
+  </section>
+</template>
+
+<style scoped>
+.archive-list {
+  display: flex;
+  flex-direction: column;
+  gap: 0.75rem;
+}
+.card-link {
+  color: inherit;
+  text-decoration: none;
+}
+.card-link:hover {
+  color: var(--accent, #7aa2f7);
+}
+.list-skeleton {
+  margin-bottom: 1rem;
+}
+.archive-meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+  margin-bottom: 0.75rem;
+}
+.form-actions {
+  display: flex;
+  gap: 0.75rem;
+  align-items: center;
+}
+</style>
\ No newline at end of file
diff --git a/frontend/src/views/GardenView.vue b/frontend/src/views/GardenView.vue
index 5501b42..c1cda74 100644
--- a/frontend/src/views/GardenView.vue
+++ b/frontend/src/views/GardenView.vue
@@ -3,12 +3,15 @@
 import { useI18n } from 'vue-i18n'
 import {
   api,
+  type GardenExpansion,
+  type GardenSpecies,
   type GardenState,
   type Task,
   type XpEvent,
   type XpSummary,
 } from '../api'
 import { formatDate } from '../taskui'
+import { useRealtimeRefresh } from '../realtime'
 import GardenScene from '../components/GardenScene.vue'
 
 defineOptions({ name: 'GardenView' })
@@ -17,7 +20,7 @@
 // Принцип «контент открывается за опыт, покупается за монеты»: XP — уровень,
 // монеты — валюта сада (рост растений, декорации, расширения карты).
 
-const { t, locale, tm } = useI18n()
+const { t, tm } = useI18n()
 
 const tasks = ref<Task[]>([])
 const events = ref<XpEvent[]>([])
@@ -41,40 +44,55 @@
     .sort((a, b) => (a.done_at! < b.done_at! ? 1 : -1)),
 )
 
-// Название уровня: 10 ботанических званий (garden.levels), дальше — последнее
+// Название уровня: 13 ботанических званий (garden.levels), дальше — последнее
 function levelName(level: number): string {
-  const idx = Math.min(level, 10) - 1
+  const idx = Math.min(level, 13) - 1
   return t(`garden.levels.${idx}`)
 }
 
-// Последнее закрытие — для строки «последний росток»
-const lastPlant = computed(() => doneTasks.value[0] ?? null)
+// --- Дерево уровней: что открывается на каждом уровне ---
 
-// --- История: закрытых задач по месяцам за последние 12 месяцев ---
+const levelsOpen = ref(false)
 
-interface MonthBucket {
-  label: string
-  count: number
+interface LevelNode {
+  level: number
+  name: string
+  threshold: number // порог XP: 100·L·(L−1)/2
+  species: GardenSpecies[]
+  expansion: GardenExpansion | null
+  expansionNo: number // порядковый номер расширения (I, II, …) — не совпадает с уровнем
 }
 
-const history = computed<MonthBucket[]>(() => {
-  const fmt = new Intl.DateTimeFormat(locale.value, { month: 'short' })
-  const buckets = new Map<string, MonthBucket>()
-  const now = new Date()
-  for (let i = 11; i >= 0; i--) {
-    const d = new Date(now.getFullYear(), now.getMonth() - i, 1)
-    const key = `${d.getFullYear()}-${d.getMonth()}`
-    buckets.set(key, { label: fmt.format(d), count: 0 })
+const EXPANSION_ROMANS = ['I', 'II', 'III', 'IV', 'V']
+
+const levelsTree = computed<LevelNode[]>(() => {
+  const expansions = garden.value?.expansions ?? []
+  const nodes: LevelNode[] = []
+  for (let level = 1; level <= 13; level++) {
+    const expIdx = expansions.findIndex((e) => e.level === level)
+    nodes.push({
+      level,
+      name: levelName(level),
+      threshold: (100 * level * (level - 1)) / 2,
+      species: (garden.value?.species ?? []).filter((s) => s.level === level),
+      expansion: expIdx >= 0 ? expansions[expIdx] : null,
+      expansionNo: expIdx + 1,
+    })
   }
-  events.value.forEach((e) => {
-    const d = new Date(e.created_at)
-    const bucket = buckets.get(`${d.getFullYear()}-${d.getMonth()}`)
-    if (bucket) bucket.count += 1
-  })
-  return [...buckets.values()]
+  return nodes
 })
 
-const historyMax = computed(() => Math.max(1, ...history.value.map((b) => b.count)))
+// Последняя награда: любое событие XP (закрытие, создание задачи/проекта)
+const lastReward = computed(() => events.value[0] ?? null)
+
+const rewardTitle = computed(() => {
+  const e = lastReward.value
+  if (!e) return ''
+  if (e.kind === 'create_task') return t('garden.rewardCreateTask')
+  if (e.kind === 'create_project') return t('garden.rewardCreateProject')
+  const task = tasks.value.find((task) => task.id === e.task_id)
+  return task?.title ?? doneTasks.value[0]?.title ?? ''
+})
 
 // --- Ачивки с тирами: ступени I/II/III внутри каждой, без «провала» ---
 
@@ -96,7 +114,8 @@
   const idx = currentTier(a)
   const inHours = a.key === 'marathon'
   const fmt = (n: number) => (inHours ? `${Math.round(n / 60)} ч` : `${n}`)
-  if (idx === -1) return `${ROMANS[a.tiers.length - 1]} · ${fmt(a.tiers[a.tiers.length - 1])} ✓`
+  // Пройдено: галочка + высшая ступень («✓ III»); в процессе: ступень и прогресс
+  if (idx === -1) return `✓ ${ROMANS[a.tiers.length - 1]}`
   return `${ROMANS[idx]} · ${fmt(a.progress)}/${fmt(a.tiers[idx])}`
 }
 
@@ -172,6 +191,11 @@
   return (garden.value?.balance ?? 0) >= next.cost ? 'ok' : 'poor'
 }
 
+function seedShopState(species: GardenSpecies): ShopState {
+  if (!species.unlocked) return 'locked'
+  return (garden.value?.balance ?? 0) >= species.seed_cost ? 'ok' : 'poor'
+}
+
 async function buy(itemKey: string): Promise<void> {
   shopBusy.value = itemKey
   error.value = ''
@@ -227,6 +251,28 @@
 }
 
 onMounted(load)
+
+// --- Реактивность (ТЗ 3.14) ---
+
+// Подавление refetch'а во время drag: событие с соседней вкладки посреди жеста
+// сбросило бы перетаскиваемый элемент (syncState пересобирает сцену)
+const dragHold = ref(false)
+let dragHoldTimer: ReturnType<typeof setTimeout> | undefined
+
+function onDragging(dragging: boolean): void {
+  if (dragging) {
+    dragHold.value = true
+    if (dragHoldTimer) clearTimeout(dragHoldTimer)
+    return
+  }
+  // конец жеста: летит move-запрос и его SSE-эхо — держим паузу ещё 300 мс
+  if (dragHoldTimer) clearTimeout(dragHoldTimer)
+  dragHoldTimer = setTimeout(() => (dragHold.value = false), 300)
+}
+
+useRealtimeRefresh(() => {
+  if (!dragHold.value) void load()
+}, ['garden.changed', 'xp.changed', 'task.changed'])
 </script>
 
 <template>
@@ -248,6 +294,9 @@
           </GnBadge>
         </template>
         <template #actions>
+          <GnButton variant="secondary" icon="ph-list-numbers" @click="levelsOpen = true">
+            {{ t('garden.levelsTitle') }}
+          </GnButton>
           <GnButton variant="secondary" icon="ph-storefront" @click="shopOpen = true">
             {{ t('garden.shop') }}
           </GnButton>
@@ -262,13 +311,69 @@
         </div>
       </GnModal>
 
+      <!-- Дерево уровней: звания, пороги XP и что открывается на каждом уровне -->
+      <GnModal :open="levelsOpen" :title="t('garden.levelsTitle')" @update:open="levelsOpen = $event">
+        <p class="levels-hint">{{ t('garden.levelsHint') }}</p>
+        <div class="levels-tree">
+          <div
+            v-for="node in levelsTree"
+            :key="node.level"
+            class="level-node"
+            :class="{ current: node.level === xp?.level, past: node.level < (xp?.level ?? 1) }"
+          >
+            <div class="level-node-head">
+              <i
+                :class="node.level < (xp?.level ?? 1) ? 'ph ph-check-circle' : 'ph ph-lock-simple'"
+                aria-hidden="true"
+              />
+              <span class="level-node-title">
+                {{ t('garden.level', { n: node.level }) }} · {{ node.name }}
+              </span>
+              <GnBadge variant="neutral" class="level-threshold">
+                <i class="ph ph-lightning" aria-hidden="true" /> {{ node.threshold }}
+              </GnBadge>
+              <GnBadge v-if="node.level === xp?.level" variant="success">
+                {{ t('garden.levelCurrent') }}
+              </GnBadge>
+            </div>
+            <div v-if="node.species.length || node.expansion" class="level-node-unlocks">
+              <i class="ph ph-lock-simple-open unlock-lock" aria-hidden="true" />
+              <span v-for="s in node.species" :key="s.key" class="level-unlock">
+                <i :class="`ph ${s.key}`" aria-hidden="true" />
+                {{ t(`garden.speciesNames.${s.key}`) }}
+                <GnBadge variant="neutral" class="unlock-price">
+                  <i class="ph ph-coins" aria-hidden="true" /> {{ s.seed_cost }}
+                </GnBadge>
+                <GnBadge v-if="s.premium" variant="warning">{{ t('garden.rareOnly') }}</GnBadge>
+              </span>
+              <span v-if="node.expansion" class="level-unlock">
+                <i class="ph ph-map-trifold" aria-hidden="true" />
+                {{ t('garden.expansion') }} {{ EXPANSION_ROMANS[node.expansionNo - 1] ?? node.expansionNo }}
+                <GnBadge variant="neutral" class="unlock-price">
+                  <i class="ph ph-coins" aria-hidden="true" /> {{ node.expansion.cost }}
+                </GnBadge>
+              </span>
+            </div>
+          </div>
+        </div>
+      </GnModal>
+
       <!-- Маркет: расширения (первым блоком), декорации, каталог видов -->
       <GnModal :open="shopOpen" :title="t('garden.shopTitle')" @update:open="shopOpen = $event">
         <div class="shop-body">
           <div class="shop-hint">{{ t('garden.speciesHint') }}</div>
+          <!-- Текущий баланс: обновляется сразу после покупки (buy пишет res.balance в state) -->
+          <GnBadge variant="warning" class="shop-coins" :title="t('garden.coinsHint')">
+            <i class="ph ph-coins" aria-hidden="true" />
+            {{ t('garden.coins', { n: garden?.balance ?? 0 }) }}
+          </GnBadge>
           <GnAlert v-if="boughtKey" variant="success" class="shop-bought">
-            <i class="ph ph-hand-grabbing" aria-hidden="true" />
-            {{ t('garden.boughtHint', { name: t(`garden.decorNames.${boughtKey}`) }) }}
+            <i :class="boughtKey.startsWith('seed:') ? 'ph ph-plant' : 'ph ph-hand-grabbing'" aria-hidden="true" />
+            {{
+              boughtKey.startsWith('seed:')
+                ? t('garden.seedBought')
+                : t('garden.boughtHint', { name: t(`garden.decorNames.${boughtKey}`) })
+            }}
           </GnAlert>
 
           <!-- 1. Расширение сада -->
@@ -345,27 +450,43 @@
             </div>
           </div>
 
-          <!-- 3. Каталог видов растений (открываются уровнем, покупаются ростом) -->
+          <!-- 3. Семена растений: открытые уровнем виды покупаются за монеты -->
           <div class="shop-block">
             <div class="shop-block-title">
               <i class="ph ph-plant" aria-hidden="true" />
-              <span>{{ t('garden.species') }}</span>
+              <span>{{ t('garden.seeds') }}</span>
             </div>
+            <p class="shop-block-hint">{{ t('garden.seedsHint') }}</p>
             <div
               v-for="species in garden?.species ?? []"
               :key="species.key"
               class="shop-item"
-              :class="species.unlocked ? 'ok' : 'locked'"
+              :class="seedShopState(species)"
             >
               <i :class="`ph ${species.key}`" aria-hidden="true" />
               <span class="shop-name">
                 {{ t(`garden.speciesNames.${species.key}`) }}
                 <GnBadge v-if="species.premium" variant="warning">{{ t('garden.rareOnly') }}</GnBadge>
               </span>
-              <span v-if="!species.unlocked" class="shop-meta">
+              <GnBadge variant="neutral" class="shop-price">
+                <i class="ph ph-coins" aria-hidden="true" /> {{ species.seed_cost }}
+              </GnBadge>
+              <span v-if="seedShopState(species) === 'locked'" class="shop-meta">
                 {{ t('garden.lockedUntil', { n: species.level }) }}
               </span>
-              <span v-else class="shop-meta">✓</span>
+              <span v-else-if="seedShopState(species) === 'poor'" class="shop-poor">
+                {{ t('garden.notEnoughCoins', { n: species.seed_cost - (garden?.balance ?? 0) }) }}
+              </span>
+              <GnButton
+                v-else
+                size="sm"
+                variant="secondary"
+                icon="ph-shopping-cart-simple"
+                :loading="shopBusy === `seed:${species.key}`"
+                @click="buy(`seed:${species.key}`)"
+              >
+                {{ t('garden.buy') }}
+              </GnButton>
             </div>
           </div>
         </div>
@@ -382,10 +503,15 @@
         :label="t('garden.levelProgress', { xp: xp.level_xp, span: xp.level_span })"
       />
 
-      <!-- Последний росток: что и когда закрыто последним -->
-      <div v-if="lastPlant" class="last-plant">
-        <i class="ph ph-sparkle" aria-hidden="true" />
-        <span>{{ t('garden.lastPlant', { title: lastPlant.title, date: formatDate(lastPlant.done_at!) }) }}</span>
+      <!-- Последняя награда: закрытие, создание задачи/проекта — что и когда начислено последним -->
+      <div v-if="lastReward" class="last-plant">
+        <i class="ph ph-gift" aria-hidden="true" />
+        <span>{{
+          t('garden.lastReward', {
+            title: rewardTitle,
+            date: formatDate(lastReward.created_at),
+          })
+        }}</span>
       </div>
 
       <!-- Сцена сада: домик, растения (drag&drop), декорации -->
@@ -395,6 +521,7 @@
         :balance="garden.balance"
         @move="onMove"
         @upgrade="onUpgrade"
+        @dragging="onDragging"
       />
       <GnEmptyState
         v-else
@@ -407,22 +534,6 @@
         </GnButton>
       </GnEmptyState>
 
-      <!-- История: закрытых задач по месяцам (12 месяцев) -->
-      <div class="history-title">
-        <i class="ph ph-chart-bar" aria-hidden="true" />
-        <span>{{ t('garden.history') }}</span>
-      </div>
-      <div class="history">
-        <div v-for="(bucket, i) in history" :key="i" class="history-month">
-          <div
-            class="history-bar"
-            :style="{ height: `${Math.max(4, (bucket.count / historyMax) * 64)}px` }"
-            :title="`${bucket.label}: ${bucket.count}`"
-          />
-          <span class="history-label">{{ bucket.label }}</span>
-        </div>
-      </div>
-
       <!-- Ачивки с тирами: прогресс к следующей ступени виден всегда -->
       <div class="achievements-title">
         <i class="ph ph-trophy" aria-hidden="true" />
@@ -437,7 +548,14 @@
         >
           <i :class="`ph ${a.icon}`" aria-hidden="true" />
           <span class="achievement-name">{{ t(`garden.ach.${a.key}`) }}</span>
-          <GnBadge :variant="currentTier(a) === -1 ? 'success' : 'neutral'">
+          <GnBadge
+            :variant="currentTier(a) === -1 ? 'success' : 'neutral'"
+            :title="
+              currentTier(a) === -1
+                ? t('garden.achDone', { r: ROMANS[a.tiers.length - 1] })
+                : t('garden.achStep')
+            "
+          >
             {{ tierLabel(a) }}
           </GnBadge>
         </div>
@@ -452,6 +570,8 @@
 }
 .level-progress {
   margin-bottom: 1rem;
+  /* на всю ширину контейнера (в ките .progress упёрт в max-width: 640px) */
+  max-width: 100%;
 }
 /* справка о саде */
 .about-body {
@@ -461,6 +581,76 @@
   font-size: 0.95em;
   line-height: 1.5;
 }
+/* дерево уровней */
+.levels-hint {
+  margin: 0 0 0.75rem;
+  font-size: 0.88em;
+  color: var(--text-muted, #888);
+  line-height: 1.45;
+}
+.levels-tree {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+.level-node {
+  padding: 0.6rem 0.75rem;
+  border: 1px solid var(--border, #2a2f45);
+  opacity: 0.6;
+}
+.level-node.past {
+  opacity: 0.85;
+  /* фон как у пройденных достижений: зелёная подложка */
+  background: color-mix(in srgb, var(--success, #9ece6a) 8%, transparent);
+}
+.level-node.current {
+  opacity: 1;
+  background: color-mix(in srgb, var(--accent, #7aa2f7) 8%, transparent);
+}
+.level-node-head {
+  display: flex;
+  gap: 0.5rem;
+  align-items: center;
+  font-weight: 600;
+  font-size: 0.95em;
+}
+.level-node-head > i {
+  font-size: 1.1rem;
+  color: var(--text-muted, #888);
+}
+.level-node.past > .level-node-head > i,
+.level-node.current > .level-node-head > i {
+  color: var(--success, #9ece6a);
+}
+.level-node-title {
+  flex: 1 1 auto;
+}
+.level-threshold {
+  white-space: nowrap;
+}
+.level-node-unlocks {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.35rem 1rem;
+  margin-top: 0.4rem;
+}
+.unlock-lock {
+  color: var(--success, #9ece6a);
+  align-self: center;
+}
+.level-unlock {
+  display: flex;
+  gap: 0.35rem;
+  align-items: center;
+  font-size: 0.85em;
+}
+.level-unlock > i:first-child {
+  font-size: 1rem;
+  color: var(--success, #9ece6a);
+}
+.unlock-price {
+  white-space: nowrap;
+}
 /* маркет */
 .shop-body {
   display: flex;
@@ -472,6 +662,9 @@
   color: var(--text-muted, #888);
   line-height: 1.45;
 }
+.shop-coins {
+  align-self: flex-start;
+}
 .shop-block {
   display: flex;
   flex-direction: column;
@@ -499,7 +692,6 @@
   align-items: center;
   padding: 0.6rem 0.75rem;
   border: 1px solid var(--border, #2a2f45);
-  border-radius: 10px;
 }
 .shop-card > i:first-child {
   font-size: 1.3rem;
@@ -557,48 +749,6 @@
 .last-plant > i {
   color: var(--accent, #7aa2f7);
 }
-/* история по месяцам: простые столбики, подписи — Intl */
-.history-title {
-  display: flex;
-  gap: 0.6rem;
-  align-items: center;
-  margin: 0 0 0.5rem;
-  font-weight: 600;
-  font-size: 1.05rem;
-}
-.history-title > i {
-  color: var(--accent, #7aa2f7);
-}
-.history {
-  display: flex;
-  align-items: flex-end;
-  gap: 0.4rem;
-  margin-bottom: 2rem;
-  padding: 0.75rem 0.5rem 0.25rem;
-  border: 1px solid var(--border, #2a2f45);
-  border-radius: 10px;
-  overflow-x: auto;
-}
-.history-month {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: 0.25rem;
-  min-width: 34px;
-  flex: 1 1 auto;
-}
-.history-bar {
-  width: 100%;
-  max-width: 26px;
-  border-radius: 4px 4px 0 0;
-  background: var(--success, #9ece6a);
-  opacity: 0.85;
-}
-.history-label {
-  font-size: 0.68em;
-  color: var(--text-muted, #888);
-  white-space: nowrap;
-}
 /* ачивки */
 .achievements-title {
   display: flex;
@@ -616,13 +766,18 @@
   grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
   gap: 0.75rem;
 }
+/* на десктопе — ровно 4 карточки в ряд */
+@media (min-width: 1024px) {
+  .achievements-grid {
+    grid-template-columns: repeat(4, 1fr);
+  }
+}
 .achievement {
   display: flex;
   gap: 0.6rem;
   align-items: center;
   padding: 0.75rem;
   border: 1px solid var(--border, #2a2f45);
-  border-radius: 10px;
   opacity: 0.55;
 }
 .achievement.unlocked {
diff --git a/frontend/src/views/ListView.vue b/frontend/src/views/ListView.vue
index d0c9494..fff3a3b 100644
--- a/frontend/src/views/ListView.vue
+++ b/frontend/src/views/ListView.vue
@@ -1,10 +1,12 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from 'vue'
+import { computed, onMounted, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { api, type Project, type Tag, type Task } from '../api'
 import { celebrateEarned } from '../gamification'
+import { useRealtimeRefresh } from '../realtime'
 import { statusOptions } from '../taskui'
 import TaskCard from '../components/TaskCard.vue'
+import Pagination from '../components/Pagination.vue'
 
 // Классический вид (ТЗ 3.6): список с фильтрами — проект, тег, статус.
 // Фильтры применяются сразу при смене значения.
@@ -18,11 +20,20 @@
 const loading = ref(false)
 
 const filters = ref({
-  status: '',
+  status: 'to_do',
   project_id: '',
   tag_id: '',
 })
 
+// Пагинация: по 30 карточек на страницу, смена фильтра — с первой
+const page = ref(1)
+const pagedTasks = computed(() =>
+  tasks.value.slice((page.value - 1) * 30, page.value * 30),
+)
+watch(filters, () => {
+  page.value = 1
+})
+
 async function load() {
   loading.value = true
   error.value = ''
@@ -46,6 +57,10 @@
   tags.value = await api.listTags()
 })
 
+// Реактивность (ТЗ 3.14): изменения задач/проектов (MCP, соседняя вкладка) —
+// перечитываем список с текущими фильтрами
+useRealtimeRefresh(load, ['task.changed', 'task.deleted', 'project.changed', 'project.deleted'])
+
 async function setStatus(task: Task, status: string) {
   error.value = ''
   try {
@@ -135,7 +150,7 @@
 
     <div class="task-list">
       <TaskCard
-        v-for="task in tasks"
+        v-for="task in pagedTasks"
         :key="task.id"
         :task="task"
         show-project
@@ -144,6 +159,8 @@
       />
     </div>
 
+    <Pagination v-model:page="page" :total="tasks.length" />
+
     <GnConfirmDialog
       v-model:open="confirmOpen"
       :title="t('common.confirmTitle')"
@@ -159,6 +176,10 @@
 <style scoped>
 .filters {
   margin-bottom: 1.5rem;
+  /* без подложки тулбара кита: рамка, фон и отступы не нужны */
+  padding: 0;
+  border: none;
+  background: none;
 }
 /* GnSelect рендерит div.form-group > label > div.select-wrap > select — сжимаем обёртки */
 .filters :deep(.form-group) {
@@ -177,4 +198,14 @@
   flex-direction: column;
   gap: 0.75rem;
 }
+/* на десктопе — карточки в две колонки, одной высоты в ряду */
+@media (min-width: 900px) {
+  .task-list {
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+  }
+  .task-list :deep(.task-card) {
+    height: 100%;
+  }
+}
 </style>
\ No newline at end of file
diff --git a/frontend/src/views/OptionsView.vue b/frontend/src/views/OptionsView.vue
index a7a8cea..f5ccf86 100644
--- a/frontend/src/views/OptionsView.vue
+++ b/frontend/src/views/OptionsView.vue
@@ -1,29 +1,27 @@
 <script setup lang="ts">
 import { onMounted, ref } from 'vue'
 import { useI18n } from 'vue-i18n'
-import { useToast } from 'gnexus-ui-kit/vue'
 import { api, type Task } from '../api'
-import { celebrateEarned } from '../gamification'
-import { formatMinutes, renderMarkdown, statusLabel } from '../taskui'
+import TaskCard from '../components/TaskCard.vue'
 
-// Режим «3 варианта» (ТЗ 3.8): анти-прокрастинация — выбрать задачу под
-// доступное время и делать её прямо сейчас.
+// «Выдача задачи» (ТЗ 3.8): под доступное время показываем те же карточки,
+// что в списке (TaskCard). Взять в работу можно здесь через меню или на
+// странице задачи — переход из выдачи несёт ?via=options, закрытие оттуда
+// помечается «выбрал и сделал».
 
 const { t } = useI18n()
-const toast = useToast()
 
-const availableMinutes = ref(180)
+// время в часах (можно 0.5); в API уходит в минутах
+const availableHours = ref(3)
 const options = ref<Task[]>([])
 const error = ref('')
 const loading = ref(false)
-const chosen = ref<Task | null>(null)
 
 async function fetchOptions() {
   loading.value = true
   error.value = ''
-  options.value = []
   try {
-    options.value = await api.suggestTasks(availableMinutes.value)
+    options.value = await api.suggestTasks(Math.round(availableHours.value * 60))
   } catch (e) {
     error.value = String(e)
   } finally {
@@ -33,34 +31,36 @@
 
 onMounted(fetchOptions)
 
-async function choose(task: Task) {
+async function setStatus(task: Task, status: string) {
+  error.value = ''
   try {
-    chosen.value = await api.updateTask(task.id, { status: 'in_progress' })
-    toast.success({ title: t('common.taskTaken') })
-    options.value = []
-  } catch (e) {
-    toast.error({ title: t('common.error'), text: String(e) })
-  }
-}
-
-async function finishChosen() {
-  if (!chosen.value) return
-  try {
-    // earned_via — для геймификации: счётчик «выбрал и сделал» в саду
-    await api.updateTask(chosen.value.id, { status: 'done', earned_via: 'options' })
-    celebrateEarned()
-    toast.success({ title: t('common.taskFinished') })
-    chosen.value = null
+    await api.updateTask(task.id, { status })
     await fetchOptions()
   } catch (e) {
-    toast.error({ title: t('common.error'), text: String(e) })
+    error.value = String(e)
   }
 }
 
-async function dropChosen() {
-  if (!chosen.value) return
-  chosen.value = null
-  await fetchOptions()
+// Удаление — через подтверждение
+const deleteTarget = ref<Task | null>(null)
+const confirmOpen = ref(false)
+
+function askDelete(task: Task) {
+  deleteTarget.value = task
+  confirmOpen.value = true
+}
+
+async function remove() {
+  const target = deleteTarget.value
+  if (!target) return
+  confirmOpen.value = false
+  error.value = ''
+  try {
+    await api.deleteTask(target.id)
+    await fetchOptions()
+  } catch (e) {
+    error.value = String(e)
+  }
 }
 </script>
 
@@ -68,35 +68,15 @@
   <section>
     <GnPageHeader kicker="GNexus Tasks" :title="t('options.title')" />
 
-    <!-- Выбранная задача: прямой переход к выполнению -->
-    <GnCard v-if="chosen" class="chosen-card">
-      <template #title>{{ chosen.title }}</template>
-      <div class="chosen-meta">
-        <GnBadge variant="accent">{{ statusLabel(chosen.status) }}</GnBadge>
-        <GnBadge v-if="chosen.estimated_minutes" variant="warning">
-          ≈ {{ formatMinutes(chosen.estimated_minutes) }}
-        </GnBadge>
-        <GnBadge v-if="chosen.project" variant="neutral">{{ chosen.project.name }}</GnBadge>
-      </div>
-      <div v-if="chosen.description" class="md-preview" v-html="renderMarkdown(chosen.description)" />
-      <div class="form-actions">
-        <GnButton variant="accent" icon="ph-check-circle" @click="finishChosen">
-          {{ t('options.done') }}
-        </GnButton>
-        <GnButton variant="secondary" icon="ph-shuffle" @click="dropChosen">
-          {{ t('options.notNow') }}
-        </GnButton>
-      </div>
-    </GnCard>
-
-    <form v-else class="time-form" @submit.prevent="fetchOptions">
+    <!-- Доступное время в часах (0.5 = полчаса) + предложение, в одну строку -->
+    <form class="time-form" @submit.prevent="fetchOptions">
       <GnInput
-        v-model.number="availableMinutes"
-        :label="t('options.available')"
+        v-model.number="availableHours"
+        :label="t('options.availableHours')"
         type="number"
-        icon="ph-hourglass"
-        min="5"
-        max="1440"
+        step="0.5"
+        min="0.5"
+        max="24"
       />
       <GnButton type="submit" variant="primary" icon="ph-shuffle" :disabled="loading">
         {{ t('options.suggest') }}
@@ -105,30 +85,37 @@
 
     <GnAlert v-if="error" variant="error">{{ error }}</GnAlert>
 
-    <template v-if="!chosen">
-      <GnSkeleton v-if="loading" type="block" stack :count="3" class="list-skeleton" />
-      <GnEmptyState
-        v-else-if="options.length === 0"
-        icon="ph-confetti"
-        :title="t('options.emptyTitle')"
-        :text="t('options.emptyText')"
+    <GnSkeleton v-if="loading" type="block" stack :count="3" class="list-skeleton" />
+
+    <GnEmptyState
+      v-else-if="options.length === 0"
+      icon="ph-confetti"
+      :title="t('options.emptyTitle')"
+      :text="t('options.emptyText')"
+    />
+
+    <!-- Те же карточки, что в списке задач; открытие несёт ?via=options -->
+    <div class="task-list">
+      <TaskCard
+        v-for="task in options"
+        :key="task.id"
+        :task="task"
+        show-project
+        :link-query="{ via: 'options' }"
+        @status-change="setStatus"
+        @delete="askDelete"
       />
-      <div class="options">
-        <GnCard v-for="task in options" :key="task.id" class="option-card">
-          <template #title>{{ task.title }}</template>
-          <div class="option-meta">
-            <GnBadge v-if="task.estimated_minutes" variant="warning">
-              ≈ {{ formatMinutes(task.estimated_minutes) }}
-            </GnBadge>
-            <GnBadge v-if="task.priority !== null" variant="info">P{{ task.priority }}</GnBadge>
-            <GnBadge v-if="task.project" variant="neutral">{{ task.project.name }}</GnBadge>
-          </div>
-          <GnButton variant="accent" icon="ph-play" @click="choose(task)">
-            {{ t('options.choose') }}
-          </GnButton>
-        </GnCard>
-      </div>
-    </template>
+    </div>
+
+    <GnConfirmDialog
+      v-model:open="confirmOpen"
+      :title="t('common.confirmTitle')"
+      :message="t('common.deleteConfirmTask', { title: deleteTarget?.title ?? '' })"
+      :confirm-text="t('common.delete')"
+      :cancel-text="t('common.cancel')"
+      confirm-variant="danger"
+      @confirm="remove"
+    />
   </section>
 </template>
 
@@ -136,16 +123,29 @@
 .time-form {
   display: flex;
   flex-wrap: wrap;
-  gap: 0.75rem;
-  align-items: end;
+  align-items: center;
+  gap: 1rem;
   margin-bottom: 1.5rem;
 }
-/* GnInput рендерит div.form-group > label > input — ограничиваем обёртку */
+/* GnInput кита рендерит div.form-group > label > (текст + иконка + input).
+   Разворачиваем подпись и поле в один ряд: «Доступное время, часов ⏳ [3]»,
+   кнопка «Предложить» — следом, вся полоса одной строкой */
 .time-form :deep(.form-group) {
-  width: 12rem;
+  flex: 0 0 auto;
+  width: max-content;
   margin-bottom: 0;
 }
-.options {
+.time-form :deep(.form-group .label) {
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  gap: 0.5rem;
+  white-space: nowrap;
+}
+.time-form :deep(input) {
+  width: 6rem;
+}
+.task-list {
   display: flex;
   flex-direction: column;
   gap: 0.75rem;
@@ -153,26 +153,4 @@
 .list-skeleton {
   margin-bottom: 1rem;
 }
-.option-meta,
-.chosen-meta {
-  display: flex;
-  gap: 0.5rem;
-  margin-bottom: 0.75rem;
-  flex-wrap: wrap;
-}
-.chosen-card {
-  margin-bottom: 1.5rem;
-}
-.form-actions {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 0.75rem;
-}
-.md-preview {
-  border: 1px solid var(--border, #333);
-  border-radius: 6px;
-  padding: 0.75rem;
-  margin-bottom: 0.75rem;
-  overflow-x: auto;
-}
 </style>
\ No newline at end of file
diff --git a/frontend/src/views/ProjectView.vue b/frontend/src/views/ProjectView.vue
index e094b1d..83b0437 100644
--- a/frontend/src/views/ProjectView.vue
+++ b/frontend/src/views/ProjectView.vue
@@ -6,11 +6,14 @@
 import { celebrateEarned } from '../gamification'
 import { api, ApiError, type Attachment, type Project, type Tag, type Task } from '../api'
 import { deadlineOverdue, gradeToPriority, priorityOptions, priorityToGrade, priorityLabel, priorityVariant, relevanceLabel, renderMarkdown, setPageTitle, statusOptions } from '../taskui'
+import PriorityBadge from '../components/PriorityBadge.vue'
 import MdEditor from '../components/MdEditor.vue'
 import MdLightbox from '../components/MdLightbox.vue'
 import InlineField from '../components/InlineField.vue'
+import ConfirmDialog from '../components/ConfirmDialog.vue'
 import TaskForm from '../components/TaskForm.vue'
 import TaskCard from '../components/TaskCard.vue'
+import Pagination from '../components/Pagination.vue'
 
 defineOptions({ name: 'ProjectView' })
 
@@ -37,8 +40,37 @@
   setPageTitle(project.value?.name ?? t('nav.projects'))
 })
 
-// Фильтры списка: статус, тег
-const filters = ref({ status: '', tag_id: '' })
+// Фильтры списка: статус (по умолчанию «К выполнению»), тег. Выбор пользователя
+// запоминается в localStorage с привязкой к проекту — вернувшись, видит те же
+// фильтры; в приватном окне/при очищенных данных просто работают дефолты.
+const filters = ref({ status: 'to_do', tag_id: '' })
+
+const filtersKey = computed(() => `gntodo:project-filters:${projectId.value}`)
+
+function loadStoredFilters() {
+  try {
+    const raw = localStorage.getItem(filtersKey.value)
+    if (raw) {
+      const saved = JSON.parse(raw) as { status?: string; tag_id?: string }
+      filters.value = {
+        status: saved.status ?? 'to_do',
+        tag_id: saved.tag_id ?? '',
+      }
+    }
+  } catch {
+    // битый JSON или недоступный localStorage — не мешаем работе
+  }
+}
+watch(filtersKey, loadStoredFilters, { immediate: true })
+// deep: ref хранит объект — по умолчанию watch видит лишь замену .value,
+// а селекты мутируют поля (v-model="filters.status")
+watch(filters, () => {
+  try {
+    localStorage.setItem(filtersKey.value, JSON.stringify(filters.value))
+  } catch {
+    // переполнение/запрет localStorage — фильтры просто не запомнятся
+  }
+}, { deep: true })
 
 const filteredTasks = computed(() =>
   tasks.value.filter(
@@ -48,6 +80,15 @@
   ),
 )
 
+// Пагинация: по 30 карточек, смена фильтра — с первой
+const page = ref(1)
+const pagedTasks = computed(() =>
+  filteredTasks.value.slice((page.value - 1) * 30, page.value * 30),
+)
+watch(filters, () => {
+  page.value = 1
+}, { deep: true })
+
 // Статистика по всем задачам проекта (фильтры не влияют)
 const stats = computed(() => {
   const list = tasks.value
@@ -70,7 +111,7 @@
     { key: 'total', icon: 'ph-stack', term: t('projectPage.total'), value: String(s.total) },
     { key: 'done', icon: 'ph-check-circle', term: t('projectPage.doneN'), value: String(s.done) },
     { key: 'inProgress', icon: 'ph-circle-half', term: t('projectPage.inProgress'), value: String(s.inProgress) },
-    { key: 'toDo', icon: 'ph-square', term: t('projectPage.toDo'), value: String(s.toDo) },
+    { key: 'toDo', icon: 'ph-circle', term: t('projectPage.toDo'), value: String(s.toDo) },
   ]
   if (s.overdue)
     rows.push({ key: 'overdue', icon: 'ph-alarm', term: t('projectPage.overdue'), value: String(s.overdue), warn: true })
@@ -219,6 +260,65 @@
   })
 }
 
+// Архив (ТЗ 3.11): у архивного проекта чтение и история доступны,
+// создание задач и правки не имеют смысла — они спрятаны в шаблоне
+const isArchived = computed(() => project.value?.is_archived ?? false)
+
+async function restore() {
+  const project0 = project.value
+  if (!project0) return
+  try {
+    project.value = await api.restoreProject(project0.id)
+    toast.success({ title: t('archive.restored', { name: project0.name }) })
+  } catch (e) {
+    toast.error({ title: t('common.error'), text: String(e) })
+  }
+}
+
+// Действия над самим проектом — дропдаун «…» в шапке: правка (drawer),
+// архив/восстановление, удаление; разрушительное — через подтверждение
+const archiveConfirmOpen = ref(false)
+const projectDeleteOpen = ref(false)
+
+const projectActions = computed(() =>
+  isArchived.value
+    ? [
+        { label: t('archive.restore'), icon: 'ph-arrow-counter-clockwise', onSelect: restore },
+        { label: t('common.delete'), icon: 'ph-trash', danger: true, onSelect: () => (projectDeleteOpen.value = true) },
+      ]
+    : [
+        { label: t('common.edit'), icon: 'ph-pencil-simple', onSelect: startEdit },
+        { label: t('common.archive'), icon: 'ph-archive', onSelect: () => (archiveConfirmOpen.value = true) },
+        { label: t('common.delete'), icon: 'ph-trash', danger: true, onSelect: () => (projectDeleteOpen.value = true) },
+      ],
+)
+
+async function archiveSelf() {
+  const project0 = project.value
+  if (!project0) return
+  archiveConfirmOpen.value = false
+  try {
+    await api.archiveProject(project0.id)
+    toast.success({ title: t('projects.archived') })
+    void router.push('/projects')
+  } catch (e) {
+    toast.error({ title: t('common.error'), text: String(e) })
+  }
+}
+
+async function deleteSelf() {
+  const project0 = project.value
+  if (!project0) return
+  projectDeleteOpen.value = false
+  try {
+    await api.deleteProject(project0.id)
+    toast.success({ title: t('common.projectDeleted') })
+    void router.push('/projects')
+  } catch (e) {
+    toast.error({ title: t('common.error'), text: String(e) })
+  }
+}
+
 // Правка проекта — drawer, как в списке проектов
 const drawerOpen = ref(false)
 const editForm = ref({
@@ -229,7 +329,8 @@
 })
 
 const relevanceOptions = computed(() =>
-  ['active', 'paused', 'archived'].map((value) => ({ value, label: relevanceLabel(value) })),
+  // «Закрыт» больше нет — вместо него архив (ТЗ 3.11)
+  ['active', 'paused'].map((value) => ({ value, label: relevanceLabel(value) })),
 )
 
 
@@ -336,7 +437,12 @@
       <GnPageHeader kicker="GNexus Tasks" :title="project.name">
         <template #title>
           <!-- Инлайн-правка названия: клик по нему же → поле на его месте -->
-          <InlineField :label="t('task.editTitle')" :save="saveName" @open="draftName = project.name">
+          <InlineField
+            v-if="!isArchived"
+            :label="t('task.editTitle')"
+            :save="saveName"
+            @open="draftName = project.name"
+          >
             <template #display="{ edit }">
               <button class="title-editable" type="button" @click="edit">{{ project.name }}</button>
             </template>
@@ -349,30 +455,40 @@
               />
             </template>
           </InlineField>
+          <span v-else>{{ project.name }}</span>
         </template>
         <template #meta>
           <GnBadge variant="info"><i class="ph ph-activity" aria-hidden="true" />
             {{ relevanceLabel(project.relevance_status) }}
           </GnBadge>
-          <GnBadge v-if="project.priority !== null" :variant="priorityVariant(project.priority)">
-            {{ priorityLabel(project.priority) }}
-          </GnBadge>
+          <PriorityBadge v-if="project.priority !== null" :priority="project.priority" />
           <GnBadge variant="neutral"><i class="ph ph-list-checks" aria-hidden="true" />
             {{ t('projectPage.taskCount', { n: tasks.length }) }}
           </GnBadge>
         </template>
         <template #actions>
-          <GnButton variant="secondary" icon="ph-pencil-simple" @click="startEdit">
-            {{ t('projects.edit') }}
-          </GnButton>
-          <GnButton variant="primary" icon="ph-plus" @click="newTaskOpen = true">
+          <GnButton v-if="!isArchived" variant="primary" icon="ph-plus" @click="newTaskOpen = true">
             {{ t('projectPage.newTask') }}
           </GnButton>
+          <GnDropdown class="project-menu" :items="projectActions">
+            <template #trigger="{ toggle }">
+              <GnIconButton icon="ph-dots-three-outline" :label="t('common.actions')" @click="toggle" />
+            </template>
+          </GnDropdown>
         </template>
       </GnPageHeader>
 
       <GnAlert v-if="error" variant="error">{{ error }}</GnAlert>
 
+      <!-- Проект в архиве: только история, восстановление из плашки -->
+      <GnAlert v-if="isArchived" variant="warning" class="archived-banner">
+        <i class="ph ph-archive" aria-hidden="true" />
+        {{ t('archive.banner') }}
+        <GnButton variant="success" size="sm" icon="ph-arrow-counter-clockwise" class="banner-restore" @click="restore">
+          {{ t('archive.restore') }}
+        </GnButton>
+      </GnAlert>
+
       <div class="project-grid">
         <div class="project-main">
           <!-- Заметка (Markdown: ссылки, контекст): карандаш — правка прямо здесь -->
@@ -381,7 +497,7 @@
               <span class="card-title-icon"><i class="ph ph-notebook" aria-hidden="true" /></span>
               {{ t('projectPage.note') }}
               <GnIconButton
-                v-if="!noteEditing"
+                v-if="!noteEditing && !isArchived"
                 icon="ph-pencil-simple"
                 size="sm"
                 :label="t('projectPage.editNote')"
@@ -452,13 +568,6 @@
                 ...tags.map((tg) => ({ value: String(tg.id), label: tg.name })),
               ]"
             />
-            <GnIconButton
-              v-if="filters.status || filters.tag_id"
-              class="filters-reset"
-              icon="ph-x"
-              :label="t('common.cancel')"
-              @click="filters.status = ''; filters.tag_id = ''"
-            />
           </div>
 
           <GnEmptyState
@@ -470,7 +579,7 @@
 
           <div class="task-list">
             <TaskCard
-              v-for="task in filteredTasks"
+              v-for="task in pagedTasks"
               :key="task.id"
               :task="task"
               :show-project="false"
@@ -478,6 +587,8 @@
               @delete="askDelete"
             />
           </div>
+
+          <Pagination v-model:page="page" :total="filteredTasks.length" />
         </div>
 
         <!-- Сайдбар: статистика, параметры, теги -->
@@ -510,9 +621,20 @@
                 <i :class="`ph ${row.icon}`" aria-hidden="true" />
                 <span class="p-term">{{ row.term }}</span>
 
+                <!-- Архив: только чтение -->
+                <template v-if="isArchived">
+                  <GnBadge v-if="row.badge" :variant="row.badge" class="p-value-badge">
+                    {{ row.value }}
+                  </GnBadge>
+                  <span v-else class="p-value" :class="{ empty: row.empty }">
+                    {{ row.empty ? t('common.notSet') : row.value }}
+                  </span>
+                </template>
+
                 <!-- Актуальность: select -->
                 <InlineField
-                  v-if="row.key === 'relevance'"
+                  v-else-if="row.key === 'relevance'"
+                  below
                   :label="t('projects.form.relevance')"
                   :save="saveRelevance"
                   @open="draftRelevance = project.relevance_status"
@@ -532,6 +654,7 @@
                 <!-- Приоритет: select -->
                 <InlineField
                   v-else
+                  below
                   :label="t('projects.form.priority')"
                   :save="savePriority"
                   @open="draftPriority = project.priority === null ? '' : priorityToGrade(project.priority)"
@@ -543,7 +666,7 @@
                       class="p-value-badge"
                       @click="edit"
                     >
-                      {{ row.value }}
+                      <i class="ph ph-flag" aria-hidden="true" />{{ row.value }}
                     </GnBadge>
                     <span v-else class="p-value empty clickable" @click="edit">
                       {{ t('common.notSet') }}
@@ -608,26 +731,58 @@
           <GnButton type="submit" variant="success" icon="ph-check-circle">
             {{ t('common.save') }}
           </GnButton>
-          <GnButton type="button" variant="secondary" class="btn-cancel" @click="closeDrawer">
+          <GnButton type="button" variant="primary" @click="closeDrawer">
             {{ t('common.cancel') }}
           </GnButton>
         </div>
       </form>
     </GnDrawer>
 
-    <GnConfirmDialog
+    <ConfirmDialog
       v-model:open="confirmOpen"
       :title="t('common.confirmTitle')"
       :message="t('common.deleteConfirmTask', { title: deleteTarget?.title ?? '' })"
       :confirm-text="t('common.delete')"
       :cancel-text="t('common.cancel')"
       confirm-variant="danger"
+      confirm-icon="ph-trash"
       @confirm="remove"
     />
+
+    <ConfirmDialog
+      v-model:open="archiveConfirmOpen"
+      :title="t('common.archiveTitle')"
+      :message="t('projects.archiveConfirm', { name: project?.name ?? '', n: tasks.length })"
+      :confirm-text="t('common.archive')"
+      :cancel-text="t('common.cancel')"
+      confirm-variant="warning"
+      @confirm="archiveSelf"
+    />
+
+    <ConfirmDialog
+      v-model:open="projectDeleteOpen"
+      :title="t('common.confirmTitle')"
+      :message="t('common.deleteConfirmProject', { name: project?.name ?? '' })"
+      :confirm-text="t('common.delete')"
+      :cancel-text="t('common.cancel')"
+      confirm-variant="danger"
+      confirm-icon="ph-trash"
+      @confirm="deleteSelf"
+    />
   </section>
 </template>
 
 <style scoped>
+/* Плашка архива: текст и кнопка в строку */
+.archived-banner {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  margin-bottom: 1.5rem;
+}
+.banner-restore {
+  margin-left: auto;
+}
 .page-skeleton {
   margin-bottom: 1rem;
 }
@@ -652,6 +807,10 @@
   font-size: 1.02rem;
   line-height: 1.65;
 }
+.md-view :deep(img) {
+  max-width: 100%;
+  height: auto;
+}
 .p-rows {
   display: flex;
   flex-direction: column;
@@ -683,10 +842,19 @@
 .p-row.warn .p-value {
   color: var(--danger, #f7768e);
 }
-/* строки с инлайн-правкой: редактору нужен center, а не baseline */
+/* строки с инлайн-правкой: пока редактор не открыт — обычная строка в один ряд;
+   при открытом редакторе (below в InlineField) он переносится на отдельную
+   строку на всю ширину. :has — по факту открытого редактора, а не по классу
+   строки: класс стоит всегда, показ ломаться не должен */
 .p-row.editing {
   align-items: center;
 }
+.p-row:has(.inline-editing) {
+  flex-wrap: wrap;
+}
+.p-row:has(.inline-editing) .inline-field {
+  flex: 1 1 100%;
+}
 /* кликабельное значение параметра: курсор + подсветка по hover */
 .p-value.clickable {
   cursor: pointer;
@@ -794,6 +962,10 @@
   align-items: flex-end;
   margin-bottom: 1rem;
 }
+/* Прогресс на всю ширину контейнера (в ките .progress упёрт в max-width: 640px) */
+.progress {
+  max-width: 100%;
+}
 .filters :deep(.form-group) {
   width: 14rem;
   margin-bottom: 0;
@@ -801,9 +973,6 @@
 .filters :deep(.select-wrap) {
   margin-top: 0;
 }
-.filters-reset {
-  margin-bottom: 0.25rem;
-}
 .task-list {
   display: flex;
   flex-direction: column;
@@ -821,17 +990,11 @@
 }
 .md-preview {
   border: 1px solid var(--border, #333);
-  border-radius: 6px;
   padding: 0.75rem;
   overflow-x: auto;
 }
-/* Отмена — без рамки, менее заметная, чем вторичная */
-.btn-cancel {
-  border-color: transparent;
-  color: var(--text-muted, #888);
-}
-.btn-cancel:hover {
-  border-color: transparent;
-  color: var(--accent, #7aa2f7);
+.md-preview :deep(img) {
+  max-width: 100%;
+  height: auto;
 }
 </style>
\ No newline at end of file
diff --git a/frontend/src/views/ProjectsView.vue b/frontend/src/views/ProjectsView.vue
index 8fa07c7..f862fb2 100644
--- a/frontend/src/views/ProjectsView.vue
+++ b/frontend/src/views/ProjectsView.vue
@@ -1,26 +1,36 @@
 <script setup lang="ts">
 import { computed, onMounted, ref } from 'vue'
 import { useI18n } from 'vue-i18n'
+import { useRouter } from 'vue-router'
 import { useToast } from 'gnexus-ui-kit/vue'
-import { api, type Attachment, type Project, type Task } from '../api'
+import { api, type Project, type Task } from '../api'
+import PriorityBadge from '../components/PriorityBadge.vue'
+import { notifyCreated } from '../gamification'
+import { useRealtimeRefresh } from '../realtime'
 import {
-  gradeToPriority,
-  priorityOptions,
-  priorityToGrade,
-  priorityLabel,
-  priorityVariant,
   relevanceLabel,
   renderMarkdown,
 } from '../taskui'
 import QuickPrompt from '../components/QuickPrompt.vue'
-import MdEditor from '../components/MdEditor.vue'
+import Pagination from '../components/Pagination.vue'
 
 // Проекты (ТЗ 3.7): актуальность, приоритет, Markdown-заметка с ресурсами.
 // Заголовок карточки — ссылка на страницу проекта; на карточке — счётчик задач.
 
 const { t } = useI18n()
+const router = useRouter()
 const toast = useToast()
 
+// Свёрнутость заметок на карточках: id проектов с развёрнутой заметкой
+const expandedNotes = ref(new Set<number>())
+
+function toggleNote(id: number): void {
+  const next = new Set(expandedNotes.value)
+  if (next.has(id)) next.delete(id)
+  else next.add(id)
+  expandedNotes.value = next
+}
+
 const projects = ref<Project[]>([])
 const tasks = ref<Task[]>([])
 const error = ref('')
@@ -39,14 +49,10 @@
   return map
 })
 
-const editing = ref<Project | null>(null)
-const drawerOpen = ref(false)
-const editForm = ref({
-  name: '',
-  relevance_status: 'active',
-  priorityGrade: '' as string,
-  note: '',
-})
+// Параметры для бейджа карточки: всего / закрыто / открыто
+function countsOf(id: number): { total: number; done: number } {
+  return taskCounts.value.get(id) ?? { total: 0, done: 0 }
+}
 
 async function load() {
   loading.value = true
@@ -62,52 +68,15 @@
 
 onMounted(load)
 
+// Реактивность (ТЗ 3.14): счётчики зависят от задач, карточки — от проектов
+useRealtimeRefresh(load, ['project.changed', 'project.deleted', 'task.changed', 'task.deleted'])
 
-// Редактирование — в боковой панели, карточка остаётся компактной
-function startEdit(project: Project) {
-  editing.value = project
-  editForm.value = {
-    name: project.name,
-    relevance_status: project.relevance_status,
-    priorityGrade: project.priority === null ? '' : priorityToGrade(project.priority),
-    note: project.note,
-  }
-  drawerOpen.value = true
-}
+// Пагинация: по 30 проектов на страницу
+const page = ref(1)
+const pagedProjects = computed(() =>
+  projects.value.slice((page.value - 1) * 30, page.value * 30),
+)
 
-function closeDrawer() {
-  drawerOpen.value = false
-  editing.value = null
-}
-
-// Картинки в заметке: загрузка из буфера (MdEditor вставит markdown в курсор)
-async function uploadImages(files: File[]): Promise<Attachment[]> {
-  if (!editing.value?.document_id) return []
-  try {
-    return await api.uploadAttachments(editing.value.document_id, files)
-  } catch (e) {
-    toast.error({ title: t('common.error'), text: String(e) })
-    return []
-  }
-}
-
-async function saveEdit() {
-  if (!editing.value) return
-  try {
-    await api.updateProject(editing.value.id, {
-      name: editForm.value.name,
-      relevance_status: editForm.value.relevance_status,
-      priority:
-        editForm.value.priorityGrade === '' ? null : gradeToPriority(editForm.value.priorityGrade),
-      note: editForm.value.note,
-    })
-    toast.success({ title: t('common.saved') })
-    closeDrawer()
-    await load()
-  } catch (e) {
-    toast.error({ title: t('common.error'), text: String(e) })
-  }
-}
 
 // Создание — модальное окно вместо window.prompt
 const createOpen = ref(false)
@@ -116,42 +85,14 @@
   try {
     await api.createProject(name)
     toast.success({ title: t('common.created') })
+    // наградный тост после основного (провайдер кита держит один тост)
+    notifyCreated()
     await load()
   } catch (e) {
     toast.error({ title: t('common.error'), text: String(e) })
   }
 }
 
-// Удаление — через подтверждение
-const deleteTarget = ref<Project | null>(null)
-const confirmOpen = ref(false)
-
-function askDelete(project: Project) {
-  deleteTarget.value = project
-  confirmOpen.value = true
-}
-
-async function remove() {
-  const project = deleteTarget.value
-  if (!project) return
-  confirmOpen.value = false
-  try {
-    await api.deleteProject(project.id)
-    toast.success({ title: t('common.projectDeleted') })
-    await load()
-  } catch (e) {
-    toast.error({ title: t('common.error'), text: String(e) })
-  }
-}
-
-const relevanceOptions = computed(() =>
-  ['active', 'paused', 'archived'].map((value) => ({ value, label: relevanceLabel(value) })),
-)
-
-const priorityOptionsWithNone = computed(() => [
-  { value: '', label: t('common.none') },
-  ...priorityOptions(),
-])
 </script>
 
 <template>
@@ -183,7 +124,7 @@
     </GnEmptyState>
 
     <div class="project-list">
-      <GnCard v-for="project in projects" :key="project.id" class="project-card">
+      <GnCard v-for="project in pagedProjects" :key="project.id" class="project-card">
         <template #title>
           <RouterLink class="card-link" :to="`/projects/${project.id}`">{{ project.name }}</RouterLink>
         </template>
@@ -192,61 +133,49 @@
           <GnBadge variant="info"><i class="ph ph-activity" aria-hidden="true" />
             {{ relevanceLabel(project.relevance_status) }}
           </GnBadge>
-          <GnBadge v-if="project.priority !== null" :variant="priorityVariant(project.priority)">
-            {{ priorityLabel(project.priority) }}
-          </GnBadge>
+          <PriorityBadge v-if="project.priority !== null" :priority="project.priority" />
           <GnBadge variant="neutral"><i class="ph ph-list-checks" aria-hidden="true" />
-            {{ t('projectPage.taskCount', { n: taskCounts.get(project.id)?.total ?? 0 }) }}
+            {{ t('projects.taskCounts', countsOf(project.id)) }}
           </GnBadge>
         </div>
-        <div v-if="project.note" class="md-preview note" v-html="renderMarkdown(project.note)" />
+        <div v-if="project.note" class="note-wrap">
+          <div
+            class="md-preview note"
+            :class="{ collapsed: !expandedNotes.has(project.id) }"
+            v-html="renderMarkdown(project.note)"
+          />
+          <button class="note-toggle" type="button" @click="toggleNote(project.id)">
+            <i
+              :class="expandedNotes.has(project.id) ? 'ph ph-caret-up' : 'ph ph-caret-down'"
+              aria-hidden="true"
+            />
+            {{ expandedNotes.has(project.id) ? t('common.collapse') : t('common.expand') }}
+          </button>
+        </div>
         <div class="form-actions">
-          <GnButton variant="secondary" size="sm" icon="ph-pencil-simple" @click="startEdit(project)">
-            {{ t('projects.edit') }}
+          <GnButton
+            variant="secondary"
+            size="sm"
+            icon="ph-arrow-square-out"
+            @click="router.push(`/projects/${project.id}`)"
+          >
+            {{ t('common.open') }}
           </GnButton>
-          <GnIconButton icon="ph-trash" :label="t('projects.delete')" @click="askDelete(project)" />
         </div>
       </GnCard>
     </div>
 
-    <GnDrawer v-model:open="drawerOpen" :title="editing?.name || t('projects.edit')" position="right" @close="closeDrawer">
-      <form v-if="editing" class="edit-form" @submit.prevent="saveEdit">
-        <GnInput v-model="editForm.name" :label="t('projects.form.name')" required />
-        <GnSelect
-          v-model="editForm.relevance_status"
-          :label="t('projects.form.relevance')"
-          icon="ph-activity"
-          :options="relevanceOptions"
-        />
-        <GnSelect
-          v-model="editForm.priorityGrade"
-          :label="t('projects.form.priority')"
-          icon="ph-flag"
-          :options="priorityOptionsWithNone"
-        />
-        <MdEditor v-model="editForm.note" :caption="t('projects.form.note')" :rows="6" :upload-images="uploadImages" />
-        <div class="form-actions">
-          <GnButton type="submit" variant="accent" icon="ph-check">
-            {{ t('common.save') }}
-          </GnButton>
-          <GnButton type="button" variant="secondary" @click="closeDrawer">
-            {{ t('common.cancel') }}
-          </GnButton>
-        </div>
-      </form>
-    </GnDrawer>
+    <Pagination v-model:page="page" :total="projects.length" />
 
-    <QuickPrompt v-model:open="createOpen" :title="t('projects.prompt')" @confirm="createProject" />
-
-    <GnConfirmDialog
-      v-model:open="confirmOpen"
-      :title="t('common.confirmTitle')"
-      :message="t('common.deleteConfirmProject', { name: deleteTarget?.name ?? '' })"
-      :confirm-text="t('common.delete')"
-      :cancel-text="t('common.cancel')"
-      confirm-variant="danger"
-      @confirm="remove"
+    <QuickPrompt
+      v-model:open="createOpen"
+      :title="t('projects.prompt')"
+      :label="t('projects.promptLabel')"
+      :placeholder="t('projects.prompt')"
+      :confirm-text="t('common.create')"
+      @confirm="createProject"
     />
+
   </section>
 </template>
 
@@ -283,11 +212,32 @@
 }
 .md-preview {
   border: 1px solid var(--border, #333);
-  border-radius: 6px;
   padding: 0.75rem;
   overflow-x: auto;
 }
-.note {
+.md-preview :deep(img) {
+  max-width: 100%;
+  height: auto;
+}
+.note-wrap {
   margin-bottom: 0.75rem;
 }
+/* Заметка по умолчанию свёрнута до нескольких строк */
+.note.collapsed {
+  max-height: 5.5em;
+  overflow: hidden;
+}
+.note-toggle {
+  display: flex;
+  gap: 0.3rem;
+  align-items: center;
+  margin-top: 0.25rem;
+  padding: 0;
+  border: none;
+  background: none;
+  color: var(--accent, #7aa2f7);
+  font: inherit;
+  font-size: 0.85em;
+  cursor: pointer;
+}
 </style>
\ No newline at end of file
diff --git a/frontend/src/views/SettingsView.vue b/frontend/src/views/SettingsView.vue
index ca1ecb8..d354083 100644
--- a/frontend/src/views/SettingsView.vue
+++ b/frontend/src/views/SettingsView.vue
@@ -65,7 +65,7 @@
     <GnCard>
       <template #title>{{ t('settings.currencyTitle') }}</template>
       <p class="hint">{{ t('settings.currencyHint') }}</p>
-      <GnRadioGroup v-model="currency" :options="currencyOptions()" />
+      <GnSelect v-model="currency" icon="ph-currency-circle-dollar" :options="currencyOptions()" />
       <div class="form-actions">
         <GnButton variant="primary" icon="ph-floppy-disk" :disabled="saving" @click="save">
           {{ t('common.save') }}
@@ -76,7 +76,7 @@
     <GnCard>
       <template #title>{{ t('settings.languageTitle') }}</template>
       <p class="hint">{{ t('settings.languageHint') }}</p>
-      <GnRadioGroup v-model="language" :options="languageOptions" />
+      <GnSelect v-model="language" icon="ph-globe-hemisphere-west" :options="languageOptions" />
       <div class="form-actions">
         <GnButton variant="primary" icon="ph-floppy-disk" :disabled="saving" @click="save">
           {{ t('common.save') }}
diff --git a/frontend/src/views/StackView.vue b/frontend/src/views/StackView.vue
index f55aee5..e320a44 100644
--- a/frontend/src/views/StackView.vue
+++ b/frontend/src/views/StackView.vue
@@ -1,13 +1,16 @@
 <script setup lang="ts">
-import { computed, onMounted, onUnmounted, ref } from 'vue'
+import { computed, onMounted, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { useRouter } from 'vue-router'
 import { api, type Project, type Task } from '../api'
+import { notifyCreated } from '../gamification'
 import { intlLocale } from '../i18n/locale'
+import { useRealtimeRefresh } from '../realtime'
 import { proposalItems } from '../taskui'
 import { useToast } from 'gnexus-ui-kit/vue'
 import TaskForm from '../components/TaskForm.vue'
 import Dashboard from '../components/Dashboard.vue'
+import Pagination from '../components/Pagination.vue'
 
 // Главная страница: дашборд активных задач сверху + стек входящих ниже.
 // LLM-предложение — черновик: «Да, всё верно» применяет его, иначе правим вручную
@@ -26,16 +29,21 @@
 
 const stack = computed(() => tasks.value.filter((task) => task.detail_state === 'raw'))
 
+// Пагинация стека: по 30 карточек
+const page = ref(1)
+const pagedStack = computed(() => stack.value.slice((page.value - 1) * 30, page.value * 30))
+watch(() => stack.value.length, (n) => {
+  if (page.value > Math.max(1, Math.ceil(n / 30))) page.value = Math.ceil(n / 30)
+})
+
 const editing = ref<Task | null>(null)
 const drawerOpen = ref(false)
 
-let pollTimer: number | undefined
-
 let loaded = false
 
 async function loadAll(silent = false) {
-  // silent-опрос (фоновые тики) не включает скелетон и не заменяет массивы,
-  // если данные не изменились — иначе страница дёргается каждые несколько секунд
+  // silent-опрос (фоновые события) не включает скелетон и не заменяет массивы,
+  // если данные не изменились — иначе страница дёргается при каждом refetch'е
   if (!silent || !loaded) loading.value = true
   try {
     const [taskList, projectList] = await Promise.all([api.listTasks(), api.listProjects()])
@@ -49,18 +57,18 @@
   }
 }
 
-// Опрос: LLM детализирует задачу в фоне — предложение появится через секунды
-function startPolling() {
-  pollTimer = window.setInterval(async () => {
-    if (!editing.value) await loadAll(true)
-  }, 5000)
-}
+// Реактивность (ТЗ 3.14): изменения приходят событиями от сервера — и чужие
+// (MCP, другая вкладка), и фоновая LLM-детализация (ai_proposal появится
+// через секунды — раньше тут был 5-секундный поллинг)
+useRealtimeRefresh(() => loadAll(true), [
+  'task.changed',
+  'task.deleted',
+  'detail.changed',
+  'project.changed',
+  'project.deleted',
+])
 
-onMounted(async () => {
-  await loadAll()
-  startPolling()
-})
-onUnmounted(() => window.clearInterval(pollTimer))
+onMounted(() => loadAll())
 
 async function quickAdd() {
   const title = quickTitle.value.trim()
@@ -69,6 +77,9 @@
     await api.createTask(title)
     quickTitle.value = ''
     toast.success({ title: t('stack.added') })
+    // наградный тост после основного: провайдер кита держит один тост —
+    // награда должна остаться видимой
+    notifyCreated()
     await loadAll()
   } catch (e) {
     toast.error({ title: t('common.error'), text: String(e) })
@@ -212,10 +223,11 @@
       icon="ph-tray"
       :title="t('stack.emptyTitle')"
       :text="t('stack.emptyText')"
+      class="stack-empty"
     />
 
     <div class="task-list">
-      <GnCard v-for="task in stack" :key="task.id" class="task-card">
+      <GnCard v-for="task in pagedStack" :key="task.id" class="task-card">
         <template #title>
           <RouterLink class="card-title" :to="`/tasks/${task.id}`">{{ task.title }}</RouterLink>
         </template>
@@ -260,6 +272,8 @@
       </GnCard>
     </div>
 
+    <Pagination v-model:page="page" :total="stack.length" />
+
     <!-- Редактирование метаданных и утверждение — боковая панель -->
     <GnDrawer v-model:open="drawerOpen" :title="t('stack.detailTitle')" position="right" @close="closeDrawer">
       <TaskForm
@@ -330,6 +344,10 @@
   flex-direction: column;
   gap: 0.75rem;
 }
+/* воздух под «Всё спокойно», чтобы пустая страница не слипалась к низу */
+.stack-empty {
+  margin-bottom: 3rem;
+}
 .card-title {
   color: inherit;
   text-decoration: none;
diff --git a/frontend/src/views/StatsView.vue b/frontend/src/views/StatsView.vue
index a287b36..6763457 100644
--- a/frontend/src/views/StatsView.vue
+++ b/frontend/src/views/StatsView.vue
@@ -2,6 +2,7 @@
 import { computed, onMounted, ref } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { api, type Task, type XpEvent } from '../api'
+import { useRealtimeRefresh } from '../realtime'
 
 defineOptions({ name: 'StatsView' })
 
@@ -390,6 +391,10 @@
 }
 
 onMounted(load)
+
+// Реактивность (ТЗ 3.14): закрытие задачи (в т.ч. из другой вкладки/MCP) —
+// график закрываемости и события XP перечитываются
+useRealtimeRefresh(load, ['xp.changed', 'task.changed'])
 </script>
 
 <template>
@@ -572,7 +577,6 @@
 .legend-swatch {
   width: 10px;
   height: 10px;
-  border-radius: 3px;
   display: inline-block;
   margin-left: 0.5rem;
 }
@@ -588,7 +592,6 @@
   gap: 0.3rem;
   padding: 0.75rem 0.5rem 0.25rem;
   border: 1px solid var(--border, #2a2f45);
-  border-radius: 10px;
   overflow-x: auto;
 }
 .chart-col {
@@ -609,7 +612,6 @@
 /* анимация «волной»: scaleY от нуля, задержка — inline по индексу колонки */
 .chart-bar {
   width: 12px;
-  border-radius: 3px 3px 0 0;
   background: var(--accent, #7aa2f7);
   opacity: 0.85;
   transform-origin: bottom;
@@ -654,7 +656,6 @@
 .heatmap-wrap {
   padding: 0.75rem;
   border: 1px solid var(--border, #2a2f45);
-  border-radius: 10px;
   overflow-x: auto;
 }
 .heatmap {
@@ -670,7 +671,6 @@
 .heat-cell {
   width: 12px;
   height: 12px;
-  border-radius: 3px;
   background: color-mix(in srgb, var(--border, #2a2f45) 55%, transparent);
 }
 .heat-cell.level-1 {
diff --git a/frontend/src/views/TaskView.vue b/frontend/src/views/TaskView.vue
index 5599090..748ed88 100644
--- a/frontend/src/views/TaskView.vue
+++ b/frontend/src/views/TaskView.vue
@@ -24,7 +24,9 @@
 } from '../taskui'
 import { useToast } from 'gnexus-ui-kit/vue'
 import { celebrateEarned } from '../gamification'
+import { onRealtime } from '../realtime'
 import InlineField from '../components/InlineField.vue'
+import DurationInput from '../components/DurationInput.vue'
 import MdEditor from '../components/MdEditor.vue'
 import MdLightbox from '../components/MdLightbox.vue'
 import TaskBadges from '../components/TaskBadges.vue'
@@ -87,6 +89,15 @@
 
 onMounted(load)
 
+// Реактивность (ТЗ 3.14): чужие изменения именно этой задачи (MCP, соседняя
+// вкладка, фоновая детализация) — перезагрузка без навигации
+onRealtime('task.changed', (e) => {
+  if (e.data?.id === taskId.value) void load()
+})
+onRealtime('detail.changed', (e) => {
+  if (e.data?.id === taskId.value) void load()
+})
+
 // Переход «подзадача → родитель» (и любой /tasks/:id → /tasks/:id) переиспользует
 // этот же инстанс компонента — onMounted не сработает; перезагружаемся по смене id
 watch(taskId, () => {
@@ -360,7 +371,12 @@
 async function setStatus(_task: Task, status: string) {
   error.value = ''
   try {
-    await api.updateTask(_task.id, { status })
+    await api.updateTask(_task.id, {
+      status,
+      // закрытие со страницы, открытой из «Выдачи задачи», помечается «выбрал и сделал»
+      earned_via:
+        status === 'done' && route.query.via === 'options' ? 'options' : undefined,
+    })
     celebrateEarned()
     await load()
   } catch (e) {
@@ -368,6 +384,20 @@
   }
 }
 
+// «Взять в работу» — быстрое взятие без дропдауна (кнопка success в статус-блоке)
+async function takeWork() {
+  const current = task.value
+  if (!current) return
+  error.value = ''
+  try {
+    await api.updateTask(current.id, { status: 'in_progress' })
+    toast.success({ title: t('common.taskTaken') })
+    await load()
+  } catch (e) {
+    error.value = String(e)
+  }
+}
+
 // Переключатель «не хочется делать»: метку можно ставить и снимать до закрытия
 async function toggleMentallyHard() {
   const task0 = task.value
@@ -520,12 +550,12 @@
         </template>
         <template #meta>
           <RouterLink v-if="parentTask" :to="`/tasks/${parentTask.id}`" class="meta-link">
-            <GnBadge variant="neutral">
+            <GnBadge variant="primary" outline>
               <i class="ph ph-arrow-bend-up-left" aria-hidden="true" />{{ parentTask.title }}
             </GnBadge>
           </RouterLink>
           <RouterLink v-if="task.project" :to="`/projects/${task.project.id}`" class="meta-link">
-            <GnBadge variant="neutral">
+            <GnBadge variant="primary" outline>
               <i class="ph ph-folder" aria-hidden="true" />{{ task.project.name }}
             </GnBadge>
           </RouterLink>
@@ -627,7 +657,7 @@
                   v-html="descriptionHtml"
                   @click="onDescClick"
                 />
-                <p v-else class="muted">
+                <p v-else class="muted desc-empty">
                   <i class="ph ph-note-blank" aria-hidden="true" />
                   {{ t('task.descriptionEmpty') }}
                 </p>
@@ -712,6 +742,17 @@
                   </template>
                 </GnDropdown>
               </div>
+              <!-- Быстрое взятие в работу: сразу из статуса, без меню -->
+              <GnButton
+                v-if="task.status === 'to_do'"
+                variant="success"
+                icon="ph-play"
+                size="sm"
+                class="take-work"
+                @click="takeWork"
+              >
+                {{ t('task.takeWork') }}
+              </GnButton>
               <!-- «Не хочется делать» (ТЗ 3.13): метка «ментально сложная», +10 XP.
                    Переключатель — снять можно до закрытия; после закрытия метка не меняется. -->
               <GnButton
@@ -746,6 +787,7 @@
                     <!-- Приоритет: select -->
                     <InlineField
                       v-if="row.key === 'priority'"
+                      below
                       :label="t('task.field.priority')"
                       :save="savePriority"
                       @open="draftPriority = task.priority === null ? '' : priorityToGrade(task.priority)"
@@ -757,7 +799,7 @@
                           class="p-value-badge"
                           @click="edit"
                         >
-                          {{ row.value }}
+                          <i class="ph ph-flag" aria-hidden="true" />{{ row.value }}
                         </GnBadge>
                         <span v-else class="p-value empty clickable" @click="edit">{{ t('common.notSet') }}</span>
                       </template>
@@ -773,6 +815,7 @@
                     <!-- Оценка времени: number -->
                     <InlineField
                       v-else-if="row.key === 'estimate'"
+                      below
                       :label="t('task.field.estimate')"
                       :save="saveEstimate"
                       @open="draftEstimate = task.estimated_minutes"
@@ -783,19 +826,14 @@
                         </span>
                       </template>
                       <template #edit="{ save }">
-                        <GnInput
-                          v-model.number="draftEstimate"
-                                                    type="number"
-                          min="1"
-                          class="inline-num"
-                          @keydown.enter="save"
-                        />
+                        <DurationInput v-model="draftEstimate" :min="1" @keydown.enter="save" />
                       </template>
                     </InlineField>
 
                     <!-- Фактически: number -->
                     <InlineField
                       v-else-if="row.key === 'actual'"
+                      below
                       :label="t('task.field.actual')"
                       :save="saveActual"
                       @open="draftActual = task.actual_minutes"
@@ -806,19 +844,14 @@
                         </span>
                       </template>
                       <template #edit="{ save }">
-                        <GnInput
-                          v-model.number="draftActual"
-                                                    type="number"
-                          min="0"
-                          class="inline-num"
-                          @keydown.enter="save"
-                        />
+                        <DurationInput v-model="draftActual" @keydown.enter="save" />
                       </template>
                     </InlineField>
 
                     <!-- Деньги: бюджет + оценка затрат одной группой, один PATCH -->
                     <InlineField
                       v-else-if="row.key === 'money'"
+                      below
                       :label="t('task.field.money')"
                       :save="saveMoney"
                       @open="draftBudget = task.budget_money; draftCost = task.cost_estimate_money"
@@ -853,6 +886,7 @@
                     <!-- Дедлайн: строгая дата + нестрогий период одной группой -->
                     <InlineField
                       v-else-if="row.key === 'deadline'"
+                      below
                       :label="t('task.field.deadline')"
                       :save="saveDeadline"
                       @open="draftDeadlineDate = task.deadline_date ?? ''; draftDeadlinePeriod = task.deadline_period ?? ''"
@@ -972,7 +1006,8 @@
 .status-badge {
   font-size: 0.95em;
 }
-/* кнопка «не хочется делать» под строкой статуса */
+/* кнопка «взять в работу» и «не хочется делать» под строкой статуса */
+.take-work,
 .hard-toggle {
   margin-top: 0.75rem;
   width: 100%;
@@ -1041,10 +1076,19 @@
 .p-row.warn .p-value {
   color: var(--danger, #f7768e);
 }
-/* строки с инлайн-правкой: редактору нужен center, а не baseline */
+/* строки с инлайн-правкой: пока редактор не открыт — обычная строка в один ряд;
+   при открытом редакторе (below в InlineField) он переносится на отдельную
+   строку на всю ширину. :has — по факту открытого редактора, а не по классу
+   строки: класс стоит всегда, показ ломаться не должен */
 .p-row.editing {
   align-items: center;
 }
+.p-row:has(.inline-editing) {
+  flex-wrap: wrap;
+}
+.p-row:has(.inline-editing) .inline-field {
+  flex: 1 1 100%;
+}
 /* кликабельное значение параметра: курсор + подсветка по hover */
 .p-value.clickable {
   cursor: pointer;
@@ -1158,11 +1202,22 @@
   color: var(--text-muted, #888);
   font-size: 0.9em;
 }
+/* пустое описание: иконка и текст в строку, по центру вертикали */
+.desc-empty {
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+  margin: 0;
+}
 .md-view {
   overflow-x: auto;
   font-size: 1.02rem;
   line-height: 1.65;
 }
+.md-view :deep(img) {
+  max-width: 100%;
+  height: auto;
+}
 .side-card {
   margin-bottom: 0;
 }
@@ -1187,7 +1242,6 @@
   width: 100%;
   aspect-ratio: 4 / 3;
   object-fit: cover;
-  border-radius: 8px;
   border: 1px solid var(--border, #333);
   display: block;
 }
@@ -1209,12 +1263,14 @@
   margin-bottom: 0.75rem;
 }
 .subtasks-title {
+  display: flex;
+  gap: 0.35rem;
+  align-items: center;
   margin: 0;
   font-size: 1.1rem;
 }
 .subtasks-title i {
   color: var(--accent, #7aa2f7);
-  margin-right: 0.35rem;
 }
 /* визуальное отделение сабтасков от основного таска */
 .subtask-list {