diff --git a/backend/alembic/versions/e1f0a2b3c4d5_garden_coins_items.py b/backend/alembic/versions/e1f0a2b3c4d5_garden_coins_items.py
new file mode 100644
index 0000000..8ad0a96
--- /dev/null
+++ b/backend/alembic/versions/e1f0a2b3c4d5_garden_coins_items.py
@@ -0,0 +1,57 @@
+"""Сад-сцена: журнал монет (coin_events) и элементы сцены (garden_items).
+
+Монеты начисляются за закрытые задачи (floor(xp/2)) задним числом по всем
+существующим xp_events; бонусы уровней и траты — в сервисе сада.
+
+Revision ID: e1f0a2b3c4d5
+Revises: d9e8f7c6b5a4
+Create Date: 2026-09-20
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision: str = "e1f0a2b3c4d5"
+down_revision: str | Sequence[str] | None = "d9e8f7c6b5a4"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "coin_events",
+        sa.Column("id", sa.Integer(), primary_key=True),
+        sa.Column("task_id", sa.Integer(), sa.ForeignKey("tasks.id", ondelete="SET NULL"), nullable=True),
+        sa.Column("level", sa.Integer(), nullable=True),
+        sa.Column("source", sa.String(length=16), nullable=False, server_default="task"),
+        sa.Column("amount", sa.Integer(), nullable=False),
+        sa.Column("item_key", sa.String(length=50), nullable=True),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+    )
+    op.create_table(
+        "garden_items",
+        sa.Column("id", sa.Integer(), primary_key=True),
+        sa.Column("kind", sa.String(length=16), nullable=False),
+        sa.Column("ref_id", sa.Integer(), sa.ForeignKey("xp_events.id", ondelete="CASCADE"), nullable=True),
+        sa.Column("item_key", sa.String(length=50), nullable=True),
+        sa.Column("x", sa.Integer(), nullable=False, server_default="0"),
+        sa.Column("y", sa.Integer(), nullable=False, server_default="0"),
+        sa.Column("stage", sa.Integer(), nullable=False, server_default="0"),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.UniqueConstraint("kind", "ref_id"),
+    )
+    # Монеты за уже закрытые задачи задним числом
+    op.get_bind().execute(
+        sa.text(
+            "INSERT INTO coin_events (task_id, source, amount, created_at) "
+            "SELECT task_id, 'task', amount / 2, created_at FROM xp_events"
+        )
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("garden_items")
+    op.drop_table("coin_events")
\ No newline at end of file
diff --git a/backend/app/api/garden.py b/backend/app/api/garden.py
new file mode 100644
index 0000000..fd5feba
--- /dev/null
+++ b/backend/app/api/garden.py
@@ -0,0 +1,194 @@
+"""API сада (ТЗ 3.13): сцена, монеты, магазин декораций и расширений."""
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from sqlalchemy import select
+
+from app.dependencies import DbDep, UserDep
+from app.models import GardenItem, Task, XpEvent
+from app.services import garden
+from app.services.garden import (
+    DECORATIONS,
+    EXPANSIONS,
+    MAX_STAGE,
+    UPGRADE_COSTS,
+    balance,
+    ensure_garden,
+    grid_size,
+    house_footprint,
+    next_expansion,
+    species_catalog,
+    spiral_position,
+)
+from app.services.xp import level_from_xp, total_xp
+
+router = APIRouter(prefix="/api/garden", tags=["garden"])
+
+
+class MoveIn(BaseModel):
+    x: int
+    y: int
+
+
+class BuyIn(BaseModel):
+    item_key: str
+
+
+def _state(db: Any) -> dict[str, Any]:
+    """Полное состояние сцены после ленивого обслуживания."""
+    ensure_garden(db)
+    level = level_from_xp(total_xp(db))
+    size = grid_size(db)
+
+    # Растения + их события (редкость, задача) одним запросом
+    rows = db.execute(
+        select(GardenItem, XpEvent, Task)
+        .join(XpEvent, GardenItem.ref_id == XpEvent.id, isouter=True)
+        .join(Task, XpEvent.task_id == Task.id, isouter=True)
+        .where(GardenItem.kind == "plant")
+        .order_by(GardenItem.id)
+    ).all()
+    items: list[dict[str, Any]] = []
+    for item, event, task in rows:
+        items.append(
+            {
+                "id": item.id,
+                "kind": "plant",
+                "ref_id": item.ref_id,
+                "item_key": item.item_key,
+                "x": item.x,
+                "y": item.y,
+                "stage": item.stage,
+                "rarity": event.rarity if event else "common",
+                "task_title": task.title if task else None,
+                "done_at": event.created_at.isoformat() if event else None,
+            }
+        )
+    decorations = db.scalars(
+        select(GardenItem).where(GardenItem.kind == "decoration").order_by(GardenItem.id)
+    ).all()
+    items += [
+        {
+            "id": d.id,
+            "kind": "decoration",
+            "ref_id": None,
+            "item_key": d.item_key,
+            "x": d.x,
+            "y": d.y,
+            "stage": 0,
+            "rarity": None,
+            "task_title": None,
+            "done_at": None,
+        }
+        for d in decorations
+    ]
+
+    expansion = next_expansion(db)
+    return {
+        "balance": balance(db),
+        "level": level,
+        "grid": size,
+        "items": items,
+        "decorations": [
+            {"key": key, "cost": spec["cost"], "unique": spec["unique"]}
+            for key, spec in DECORATIONS.items()
+        ],
+        "next_expansion": expansion,
+        "expansions_bought": garden.expansions_bought(db),
+        "species": species_catalog(level),
+        "upgrade_costs": UPGRADE_COSTS,
+    }
+
+
+@router.get("")
+async def get_garden(db: DbDep, user: UserDep) -> dict[str, Any]:
+    """Состояние сцены: баланс, элементы, каталоги, сетка."""
+    return _state(db)
+
+
+@router.patch("/items/{item_id}")
+async def move_item(item_id: int, move: MoveIn, db: DbDep, user: UserDep) -> dict[str, Any]:
+    item = db.get(GardenItem, item_id)
+    if item is None:
+        raise HTTPException(status_code=404, detail="Item not found")
+    size = grid_size(db)
+    if not (0 <= move.x < size["cols"] and 0 <= move.y < size["rows"]):
+        raise HTTPException(status_code=400, detail="Position outside the garden")
+    if item.kind == "plant" and (move.x, move.y) in house_footprint(
+        size["cols"], size["rows"]
+    ):
+        raise HTTPException(status_code=400, detail="Cannot place on the house")
+    item.x, item.y = move.x, move.y
+    db.flush()
+    return {"ok": True}
+
+
+@router.post("/plants/{item_id}/upgrade")
+async def upgrade_plant(item_id: int, db: DbDep, user: UserDep) -> dict[str, Any]:
+    item = db.get(GardenItem, item_id)
+    if item is None or item.kind != "plant":
+        raise HTTPException(status_code=404, detail="Plant not found")
+    if item.stage >= MAX_STAGE:
+        raise HTTPException(status_code=400, detail="Plant is fully grown")
+    event = db.get(XpEvent, item.ref_id) if item.ref_id else None
+    rarity = event.rarity if event else "common"
+    cost = UPGRADE_COSTS[rarity][item.stage]
+    if not garden.can_afford(db, cost):
+        raise HTTPException(
+            status_code=402, detail=f"Not enough coins: need {cost}"
+        )
+    garden.spend(db, cost, f"upgrade:{item.item_key}")
+    item.stage += 1
+    db.flush()
+    return {"ok": True, "stage": item.stage, "cost": cost, "balance": balance(db)}
+
+
+@router.post("/shop/buy")
+async def shop_buy(buy: BuyIn, db: DbDep, user: UserDep) -> dict[str, Any]:
+    item_key = buy.item_key
+    level = level_from_xp(total_xp(db))
+
+    if item_key in EXPANSIONS:
+        expansion = next_expansion(db)
+        if expansion is None or expansion["key"] != item_key:
+            raise HTTPException(status_code=409, detail="Expansion already bought")
+        spec = EXPANSIONS[item_key]
+        if level < spec["level"]:
+            raise HTTPException(
+                status_code=403, detail=f"Unlocks at level {spec['level']}"
+            )
+        if not garden.can_afford(db, spec["cost"]):
+            raise HTTPException(status_code=402, detail=f"Not enough coins: need {spec['cost']}")
+        garden.spend(db, spec["cost"], item_key)
+        db.flush()
+        return {"ok": True, "grid": grid_size(db), "balance": balance(db)}
+
+    if item_key in DECORATIONS:
+        spec = DECORATIONS[item_key]
+        owned = db.scalar(
+            select(GardenItem).where(
+                GardenItem.kind == "decoration", GardenItem.item_key == item_key
+            )
+        )
+        if spec["unique"] and owned is not None:
+            raise HTTPException(status_code=409, detail="Already bought")
+        if not garden.can_afford(db, spec["cost"]):
+            raise HTTPException(status_code=402, detail=f"Not enough coins: need {spec['cost']}")
+        size = grid_size(db)
+        occupied = {
+            (int(x), int(y)) for x, y in db.execute(select(GardenItem.x, GardenItem.y)).all()
+        } | house_footprint(size["cols"], size["rows"])
+        x, y = spiral_position(occupied, size["cols"], size["rows"])
+        item = GardenItem(kind="decoration", item_key=item_key, x=x, y=y)
+        db.add(item)
+        garden.spend(db, spec["cost"], item_key)
+        db.flush()
+        return {
+            "ok": True,
+            "item": {"id": item.id, "item_key": item.item_key, "x": item.x, "y": item.y},
+            "balance": balance(db),
+        }
+
+    raise HTTPException(status_code=400, detail=f"Unknown item: {item_key}")
diff --git a/backend/app/api/tasks.py b/backend/app/api/tasks.py
index e2e8f78..5bd53c3 100644
--- a/backend/app/api/tasks.py
+++ b/backend/app/api/tasks.py
@@ -6,7 +6,7 @@
 from sqlalchemy import select
 
 from app.dependencies import DbDep, UserDep
-from app.models import Project, Tag, Task, utcnow
+from app.models import CoinEvent, Project, Tag, Task, utcnow
 from app.schemas import (
     DEADLINE_PERIODS,
     RECUR_KINDS,
@@ -17,9 +17,10 @@
     TaskUpdate,
 )
 from app.services.detailing import apply_proposal, detail_task
+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
+from app.services.xp import grant_task_xp, level_from_xp, total_xp
 
 router = APIRouter(prefix="/api/tasks", tags=["tasks"])
 
@@ -156,6 +157,19 @@
             if task.mentally_hard:
                 # «Ментально сложная» — фронт украшает праздник («сила воли»)
                 response.headers["X-Mentally-Hard"] = "1"
+            # Монеты — вторая награда за закрытие (валюта сада, рядом с XP)
+            old_level = level_from_xp(total_xp(db) - event.amount)
+            coins = coins_for_xp(event.amount)
+            db.add(CoinEvent(task_id=task.id, source="task", amount=coins))
+            new_level = level_from_xp(total_xp(db))
+            if new_level > old_level:
+                coins += level_bonus_coins(new_level)
+                db.add(
+                    CoinEvent(
+                        source="level", level=new_level, amount=level_bonus_coins(new_level)
+                    )
+                )
+            response.headers["X-Earned-Coins"] = str(coins)
 
     db.flush()
     db.refresh(task)  # перечитать связи (project/tags) после обновления
diff --git a/backend/app/main.py b/backend/app/main.py
index df8380d..bc78401 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, projects, tags, tasks, xp
+from app.api import attachments, 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
@@ -63,6 +63,7 @@
 app.include_router(attachments.router)
 app.include_router(settings_router)
 app.include_router(xp.router)
+app.include_router(garden.router)
 
 # MCP-сервер для ИИ-агентов (M5)
 app.mount("/mcp", mcp_server.mcp.streamable_http_app())
diff --git a/backend/app/models.py b/backend/app/models.py
index 4a23bdd..357b0f8 100644
--- a/backend/app/models.py
+++ b/backend/app/models.py
@@ -257,3 +257,52 @@
     # Закрыто из режима «3 вариантов» (ТЗ 3.9) — для счётчика «выбрал и сделал»
     via_options: Mapped[bool] = mapped_column(Boolean, default=False)
     created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utcnow)
+
+
+class CoinEvent(Base):
+    """Событие монет (геймификация, ТЗ 3.13): журнал и заработка, и трат.
+
+    Монеты — валюта сада, отдельная от XP: опыт только растёт, монеты тратятся.
+    Баланс = сумма amount по всем событиям. Начисление за задачу — один раз
+    (вместе с XpEvent), бонус за уровень — один раз на уровень (уникальность
+    в сервисе), траты — отрицательные amount (source='shop').
+    """
+
+    __tablename__ = "coin_events"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    task_id: Mapped[int | None] = mapped_column(
+        ForeignKey("tasks.id", ondelete="SET NULL"), nullable=True, default=None
+    )
+    # Бонус за уровень (source='level') — какой уровень достигнут
+    level: Mapped[int | None] = mapped_column(Integer, nullable=True, default=None)
+    source: Mapped[str] = mapped_column(String(16), default="task")  # task | level | shop
+    amount: Mapped[int] = mapped_column(Integer)  # + заработано / − потрачено
+    # Ключ покупки (декорация или расширение карты) для трат
+    item_key: Mapped[str | None] = mapped_column(String(50), nullable=True, default=None)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utcnow)
+
+
+class GardenItem(Base):
+    """Элемент сцены сада: растение (закрытая задача) или декорация.
+
+    Растение привязано к XpEvent (не к задаче — растение переживает удаление
+    задачи); вид зафиксирован в item_key при рождении. Позиция — ячейки
+    мелкой сетки сада (см. services/garden.py).
+    """
+
+    __tablename__ = "garden_items"
+    __table_args__ = (UniqueConstraint("kind", "ref_id"),)
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    kind: Mapped[str] = mapped_column(String(16))  # plant | decoration
+    ref_id: Mapped[int | None] = mapped_column(
+        ForeignKey("xp_events.id", ondelete="CASCADE"), nullable=True, default=None
+    )
+    # Для растения — ключ вида (species), для декорации — ключ каталога
+    item_key: Mapped[str | None] = mapped_column(String(50), nullable=True, default=None)
+    x: Mapped[int] = mapped_column(Integer, default=0)
+    y: Mapped[int] = mapped_column(Integer, default=0)
+    # Стадия роста растения: 0 росток, 1 куст, 2 цветение
+    stage: Mapped[int] = mapped_column(Integer, default=0)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utcnow)
diff --git a/backend/app/services/garden.py b/backend/app/services/garden.py
new file mode 100644
index 0000000..8a557e5
--- /dev/null
+++ b/backend/app/services/garden.py
@@ -0,0 +1,224 @@
+"""Сад-сцена (ТЗ 3.13): монеты, размещение растений, декорации, расширения.
+
+Принцип «контент открывается за опыт, покупается за монеты»: опыт (уровень)
+открывает виды растений и землю, монеты покупают апгрейды, декорации и
+расширения карты. Монеты — валюта сада, отдельная от XP: опыт только растёт,
+монеты тратятся.
+"""
+
+from typing import Any
+
+from sqlalchemy import func, select
+from sqlalchemy.orm import Session
+
+from app.models import CoinEvent, GardenItem, XpEvent
+from app.services.xp import level_from_xp, total_xp
+
+# --- Экономика ---
+
+# Монеты за задачу: floor(xp / 2)
+COINS_PER_XP = 2
+
+# Бонус за достижение уровня L (одним событием при пересечении границы)
+LEVEL_BONUS = 25
+
+
+def coins_for_xp(xp: int) -> int:
+    return xp // COINS_PER_XP
+
+
+def level_bonus_coins(level: int) -> int:
+    return LEVEL_BONUS * level
+
+
+# Апгрейд растения по стадиям (0→1, 1→2), цена по редкости
+UPGRADE_COSTS: dict[str, tuple[int, int]] = {
+    "common": (20, 50),
+    "rare": (40, 100),
+    "epic": (80, 200),
+}
+MAX_STAGE = 2
+
+# Каталог декораций: ключ -> (цена, уникальная). Только косметика — без бонусов.
+DECORATIONS: dict[str, dict[str, Any]] = {
+    "fence": {"cost": 30, "unique": False},
+    "flowerbed": {"cost": 40, "unique": False},
+    "lantern": {"cost": 80, "unique": True},
+    "bench": {"cost": 90, "unique": True},
+    "birdbath": {"cost": 120, "unique": True},
+    "pond": {"cost": 250, "unique": True},
+    "gazebo": {"cost": 400, "unique": True},
+}
+
+# Расширения карты: ключ -> (уровень открытия, цена). Каждое добавляет
+# EXPANSION_PERIMETER клеток и к ширине, и к высоте; старт 32×20.
+BASE_COLS = 32
+BASE_ROWS = 20
+EXPANSION_PERIMETER = 8
+EXPANSIONS: dict[str, dict[str, int]] = {
+    "expansion_1": {"level": 3, "cost": 100},
+    "expansion_2": {"level": 5, "cost": 250},
+    "expansion_3": {"level": 8, "cost": 500},
+}
+
+# Виды растений: открываются уровнем («контент за опыт»); premium — только
+# для rare/epic закрытий («элитные виды приживаются у опытного садовника»).
+# Ключ = phosphor-иконка кита (проверено по icons.css).
+SPECIES: list[dict[str, Any]] = [
+    {"key": "ph-flower", "level": 1, "premium": False},
+    {"key": "ph-leaf", "level": 1, "premium": False},
+    {"key": "ph-tree-evergreen", "level": 1, "premium": False},
+    {"key": "ph-flower-lotus", "level": 2, "premium": False},
+    {"key": "ph-cactus", "level": 4, "premium": True},
+    {"key": "ph-tree", "level": 6, "premium": False},
+]
+
+# Домик в центре сетки: footprint, который не занимают растения (ячейки)
+HOUSE_COLS = 4
+HOUSE_ROWS = 3
+
+# Спираль авторазмещения: снаружи от footprint домика
+SPIRAL_START_RADIUS = 3
+
+
+def balance(db: Session) -> int:
+    total = db.scalar(select(func.coalesce(func.sum(CoinEvent.amount), 0)))
+    return int(total or 0)
+
+
+def expansions_bought(db: Session) -> int:
+    return int(
+        db.scalar(
+            select(func.count())
+            .select_from(CoinEvent)
+            .where(CoinEvent.source == "shop", CoinEvent.item_key.like("expansion_%"))
+        )
+        or 0
+    )
+
+
+def grid_size(db: Session) -> dict[str, int]:
+    extra = expansions_bought(db) * EXPANSION_PERIMETER
+    return {"cols": BASE_COLS + extra, "rows": BASE_ROWS + extra}
+
+
+def next_expansion(db: Session) -> dict[str, Any] | None:
+    """Следующее доступное расширение (ещё не купленное)."""
+    bought = expansions_bought(db)
+    keys = sorted(EXPANSIONS)
+    if bought >= len(keys):
+        return None
+    key = keys[bought]
+    return {"key": key, **EXPANSIONS[key]}
+
+
+def species_catalog(level: int) -> list[dict[str, Any]]:
+    """Каталог видов с пометкой «открыт на этом уровне»."""
+    return [{**s, "unlocked": level >= s["level"]} for s in SPECIES]
+
+
+def species_for(level: int, task_id: int, rarity: str) -> str:
+    """Вид нового растения: открытые уровнем виды, premium — только rare/epic.
+
+    Детерминированно от task_id — повторный вызов даёт тот же вид.
+    """
+    pool = [
+        s["key"]
+        for s in SPECIES
+        if level >= s["level"] and (not s["premium"] or rarity in ("rare", "epic"))
+    ]
+    return str(pool[task_id % len(pool)])
+
+
+def house_footprint(cols: int, rows: int) -> set[tuple[int, int]]:
+    cx = cols // 2 - HOUSE_COLS // 2
+    cy = rows // 2 - HOUSE_ROWS // 2
+    return {
+        (x, y) for x in range(cx, cx + HOUSE_COLS) for y in range(cy, cy + HOUSE_ROWS)
+    }
+
+
+def spiral_position(
+    occupied: set[tuple[int, int]], cols: int, rows: int
+) -> tuple[int, int]:
+    """Следующая свободная ячейка по спирали вокруг домика в центре."""
+    cx, cy = cols // 2, rows // 2
+    radius = SPIRAL_START_RADIUS
+    while radius < max(cols, rows):
+        for dx in range(-radius, radius + 1):
+            for dy in range(-radius, radius + 1):
+                if max(abs(dx), abs(dy)) != radius:
+                    continue
+                x, y = cx + dx, cy + dy
+                if 0 <= x < cols and 0 <= y < rows and (x, y) not in occupied:
+                    return (x, y)
+        radius += 1
+    # сетка кончилась — первая свободная ячейка по порядку
+    for y in range(rows):
+        for x in range(cols):
+            if (x, y) not in occupied:
+                return (x, y)
+    return (0, 0)
+
+
+def _level_at_event(db: Session, event: XpEvent) -> int:
+    """Уровень садовника на момент события XP — по сумме XP событий до него."""
+    xp_up_to = db.scalar(
+        select(func.coalesce(func.sum(XpEvent.amount), 0)).where(XpEvent.id <= event.id)
+    )
+    return level_from_xp(int(xp_up_to or 0))
+
+
+def ensure_garden(db: Session) -> None:
+    """Ленивое обслуживание сада: бонусы уровней + авторазмещение новых растений."""
+    # 1) Бонусы за достигнутые уровни (задним числом — для старых уровней)
+    reached = level_from_xp(total_xp(db))
+    granted = set(
+        db.scalars(
+            select(CoinEvent.level).where(
+                CoinEvent.source == "level", CoinEvent.level.is_not(None)
+            )
+        ).all()
+    )
+    for level in range(2, reached + 1):
+        if level not in granted:
+            db.add(CoinEvent(source="level", level=level, amount=level_bonus_coins(level)))
+
+    # 2) Растения для событий XP без размещённого элемента
+    placed_refs = set(
+        db.scalars(
+            select(GardenItem.ref_id).where(
+                GardenItem.kind == "plant", GardenItem.ref_id.is_not(None)
+            )
+        ).all()
+    )
+    pending = [
+        e
+        for e in db.scalars(select(XpEvent).order_by(XpEvent.id)).all()
+        if e.id not in placed_refs
+    ]
+    if pending:
+        size = grid_size(db)
+        occupied = {
+            (int(x), int(y)) for x, y in db.execute(select(GardenItem.x, GardenItem.y)).all()
+        } | house_footprint(size["cols"], size["rows"])
+        for event in pending:
+            # вид и уровень — на момент события, чтобы старые закрытия
+            # получили вид из пула своего времени
+            species = species_for(
+                _level_at_event(db, event), event.task_id or 0, event.rarity
+            )
+            x, y = spiral_position(occupied, size["cols"], size["rows"])
+            occupied.add((x, y))
+            db.add(GardenItem(kind="plant", ref_id=event.id, item_key=species, x=x, y=y))
+    db.flush()
+
+
+def can_afford(db: Session, cost: int) -> bool:
+    return balance(db) >= cost
+
+
+def spend(db: Session, cost: int, item_key: str) -> None:
+    db.add(CoinEvent(source="shop", amount=-cost, item_key=item_key))
+
+
diff --git a/backend/tests/test_garden.py b/backend/tests/test_garden.py
new file mode 100644
index 0000000..08fbb10
--- /dev/null
+++ b/backend/tests/test_garden.py
@@ -0,0 +1,194 @@
+"""Сад-сцена (ТЗ 3.13): монеты, магазин, апгрейды, перемещение, авторазмещение."""
+
+from typing import Any
+
+from fastapi.testclient import TestClient
+
+from app.services.garden import (
+    DECORATIONS,
+    EXPANSIONS,
+    coins_for_xp,
+    level_bonus_coins,
+    spiral_position,
+)
+
+
+def _create_task(client: TestClient, **patch: Any) -> int:
+    resp = client.post("/api/tasks", json={"title": "Задача для сада"})
+    task_id = resp.json()["id"]
+    if patch:
+        resp2 = client.patch(f"/api/tasks/{task_id}", json=patch)
+        assert resp2.status_code == 200
+    return task_id
+
+
+def _done(client: TestClient, task_id: int) -> dict[str, str]:
+    resp = client.patch(f"/api/tasks/{task_id}", json={"status": "done"})
+    assert resp.status_code == 200
+    return {
+        "xp": resp.headers.get("X-Earned-XP", ""),
+        "coins": resp.headers.get("X-Earned-Coins", ""),
+    }
+
+
+# --- Монеты за задачу ---
+
+
+def test_coins_on_done_and_idempotent(client: TestClient) -> None:
+    task_id = _create_task(client)
+    earned = _done(client, task_id)
+    assert int(earned["coins"]) == coins_for_xp(int(earned["xp"]))
+
+    # Повторное закрытие не добавляет ни XP, ни монет
+    earned2 = _done(client, task_id)
+    assert earned2["xp"] == "" and earned2["coins"] == ""
+
+    state = client.get("/api/garden").json()
+    assert state["balance"] == coins_for_xp(int(earned["xp"]))
+
+
+def test_level_bonus_coins(client: TestClient) -> None:
+    # Уровень 2 требует 100 XP: три тяжёлые задачи дают 3×40 = 120 → L2
+    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
+
+
+# --- Перемещение ---
+
+
+def test_move_and_validation(client: TestClient) -> None:
+    task_id = _create_task(client)
+    _done(client, task_id)
+    item = next(i for i in client.get("/api/garden").json()["items"] if i["kind"] == "plant")
+
+    resp = client.patch(f"/api/garden/items/{item['id']}", json={"x": 5, "y": 7})
+    assert resp.status_code == 200
+    state = client.get("/api/garden").json()
+    moved = next(i for i in state["items"] if i["id"] == item["id"])
+    assert (moved["x"], moved["y"]) == (5, 7)
+
+    # Вне сетки — 400
+    size = state["grid"]
+    resp = client.patch(f"/api/garden/items/{item['id']}", json={"x": size["cols"], "y": 0})
+    assert resp.status_code == 400
+
+
+# --- Апгрейд растений ---
+
+
+def test_plant_upgrade_costs_and_402(client: TestClient, monkeypatch: Any) -> None:
+    # Редкость случайна — фиксируем roll: всегда common
+    monkeypatch.setattr("app.services.xp.random.random", lambda: 0.99)
+    task_id = _create_task(client, priority=9, estimated_minutes=480)
+    _done(client, task_id)  # 40 XP → 20 монет
+    plant = next(i for i in client.get("/api/garden").json()["items"] if i["kind"] == "plant")
+    assert plant["rarity"] == "common"
+
+    # Первая стадия ровно по карману (20 = 20)
+    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
+
+    # Вторая стадия — не хватает (50 > 0)
+    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 — с запасом
+    resp = client.post(f"/api/garden/plants/{plant['id']}/upgrade")
+    assert resp.status_code == 200
+    assert resp.json()["stage"] == 2
+
+    # Больше нельзя — 400
+    resp = client.post(f"/api/garden/plants/{plant['id']}/upgrade")
+    assert resp.status_code == 400
+
+
+# --- Магазин ---
+
+
+def test_shop_buy_decoration_and_repeatable(client: TestClient, monkeypatch: Any) -> None:
+    monkeypatch.setattr("app.services.xp.random.random", lambda: 0.99)
+    _done(client, _create_task(client, priority=9, estimated_minutes=480))
+    _done(client, _create_task(client, priority=9, estimated_minutes=480))  # 40 монет
+    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"]
+    assert any(
+        i["kind"] == "decoration" and i["item_key"] == "fence"
+        for i in client.get("/api/garden").json()["items"]
+    )
+
+
+def test_shop_unknown_400_and_unique_409(client: TestClient, monkeypatch: Any) -> None:
+    assert client.post("/api/garden/shop/buy", json={"item_key": "nope"}).status_code == 400
+
+    # Уникальную декорацию нельзя купить дважды: 6 задач по 40 XP = 240 XP (L2),
+    # монеты 6×20 + бонус 50 = 170 ≥ 80
+    monkeypatch.setattr("app.services.xp.random.random", lambda: 0.99)
+    for _ in range(6):
+        _done(client, _create_task(client, priority=9, estimated_minutes=480))
+    assert client.post("/api/garden/shop/buy", json={"item_key": "lantern"}).status_code == 200
+    assert client.post("/api/garden/shop/buy", json={"item_key": "lantern"}).status_code == 409
+
+
+def test_shop_expansion_lock_and_order(client: TestClient, monkeypatch: Any) -> None:
+    # Уровень 1 < 3 — замок
+    resp = client.post("/api/garden/shop/buy", json={"item_key": "expansion_1"})
+    assert resp.status_code == 403
+    assert "3" in resp.json()["detail"]
+
+    # До L3 нужен 300 XP: 8 задач по 40 = 320; монеты 8×20 + бонусы 50+75 = 285
+    monkeypatch.setattr("app.services.xp.random.random", lambda: 0.99)
+    for _ in range(8):
+        _done(client, _create_task(client, priority=9, estimated_minutes=480))
+    state = client.get("/api/garden").json()
+    assert state["level"] == 3
+
+    resp = client.post("/api/garden/shop/buy", json={"item_key": "expansion_1"})
+    assert resp.status_code == 200
+    assert client.get("/api/garden").json()["grid"]["cols"] > 32
+
+    # Внепорядковое расширение (expansion_2 ещё следующий, 3 просит) — 409
+    resp = client.post("/api/garden/shop/buy", json={"item_key": "expansion_3"})
+    assert resp.status_code == 409
+
+
+# --- Авторазмещение и виды ---
+
+
+def test_species_unlock_and_placement(client: TestClient) -> None:
+    state = client.get("/api/garden").json()
+    # Уровень 1: только стартовые виды, cactus закрыт (premium)
+    keys = [s["key"] for s in state["species"] if s["unlocked"]]
+    assert "ph-flower" in keys and "ph-cactus" not in keys
+
+    _done(client, _create_task(client))
+    state = client.get("/api/garden").json()
+    plants = [i for i in state["items"] if i["kind"] == "plant"]
+    assert len(plants) == 1
+    # Размещение по спирали — вне footprint домика и в границах сетки
+    assert plants[0]["item_key"] in keys
+    assert 0 <= plants[0]["x"] < state["grid"]["cols"]
+    assert 0 <= plants[0]["y"] < state["grid"]["rows"]
+
+
+def test_spiral_position_skips_occupied() -> None:
+    occupied: set[tuple[int, int]] = set()
+    first = spiral_position(occupied, 32, 20)
+    assert first == (13, 7)  # радиус 3 от центра — первый шаг спирали
+    occupied.add(first)
+    second = spiral_position(occupied, 32, 20)
+    assert second not in occupied
+
+
+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"}
diff --git a/docs/TZ.md b/docs/TZ.md
index ed1f232..635cfa3 100644
--- a/docs/TZ.md
+++ b/docs/TZ.md
@@ -4,7 +4,7 @@
 
 | | |
 |---|---|
-| Версия ТЗ | 0.13 |
+| Версия ТЗ | 0.14 |
 | Дата | 2026-09-20 |
 | Статус | На обсуждении |
 
@@ -177,12 +177,46 @@
 - **Момент награды**: при закрытии задачи — короткая конфетти-анимация и тост
   «+N XP» с похвалой. Особые закрытия (редкое растение, крупная задача) —
   усиленное «золотое» конфетти.
-- **Сад** (отдельная страница): каждая закрытая задача — растение на грядке;
-  сад только растёт. Рядом — уровень, **«последний росток»** (что и когда
-  закрыто последним), **история по месяцам** (12 месяцев, столбики) и ачивки.
+- **Сад** (отдельная страница): живая **сцена** — графическое представление сада
+  с домиком в центре; вокруг сад на мелкой сетке (ячейка ~20px, привязка при
+  перемещении, наложения разрешены). Каждая закрытая задача — растение в саду;
+  сад только растёт, продавать и удалять растения нельзя. Растения и декорации
+  можно перетаскивать (drag&drop). Рядом — уровень, **кошелёк** (баланс монет),
+  **«последний росток»** (что и когда закрыто последним), **история по месяцам**
+  (12 месяцев, столбики) и ачивки.
+- **Две награды: опыт и монеты.** Опыт — «ранг садовника»: только растёт, ничего
+  не открывает в магазине напрямую. Монеты — «валюта сада»: тратятся. Общий
+  принцип: **контент открывается за опыт, покупается за монеты** — опыт (уровень)
+  открывает виды растений и землю, монеты покупают рост растений, декорации и
+  расширения карты.
+- **Монеты**: начисляются при закрытии задачи — `floor(xp / 2)` (заголовок
+  `X-Earned-Coins` рядом с XP в тосте), и бонусом **25 × L** при достижении
+  уровня L. Хранение — таблица `coin_events` (журнал заработка и трат; баланс =
+  сумма amount). Траты — отрицательные события (`source = shop`); продажи нет
+  («только позитив»).
 - **Редкие растения**: редкость решается в момент закрытия по весу задачи —
   чем больше XP, тем выше шанс редкого; эпик-растения — только у крупных
   закрытий. Редкость хранится в `xp_events`, визуально — золото + бейдж.
+- **Растения и виды**: растение рождается только от закрытой задачи (отпечаток
+  работы), вид выбирается детерминированно из пула видов, открытых **уровнем на
+  момент рождения** (premium-виды — только для rare/epic закрытий), и
+  фиксируется за растением (`garden_items.item_key`) — открытые позже виды не
+  перерисовывают старые растения. Растение привязано к событию XP (переживает
+  удаление задачи). Каталог видов — в маркете сада с замками «откроется на
+  уровне N».
+- **Рост растений за монеты**: растение растёт стадиями росток → куст →
+  цветение, каждая стадия покупается монетами (цена по редкости:
+  common 20/50, rare 40/100, epic 80/200). Автороста по времени нет.
+- **Маркет сада**: в модалке — **расширения карты** (первым блоком),
+  **декорации** и **каталог видов**. У каждой покупки три состояния: 🔒
+  «откроется на уровне N» (если уровень не открывает), цена золотом (кнопка
+  активна), цена серым + «не хватает N монет».
+  - **Декорации** — чисто косметика: фонарь, лавочка, поилка, пруд, беседка
+    (уникальные), изгородь и клумба (повторяемые). Размещаются автоматически на
+    свободной ячейке, двигаются как растения.
+  - **Расширения карты**: стартовая сетка 32×20 ячеек; каждое расширение
+    (+8 клеток периметра) открывается уровнем (I — ур. 3, II — ур. 5,
+    III — ур. 8) и покупается монетами (100/250/500). Финал ~56×44.
 - **Ачивки с тирами**: у каждой ачивки ступени I/II/III (например, 10/50/100
   задач), прогресс к следующей ступени виден всегда. Набор: вехи закрытий,
   уровни, макс. задач за день, разные проекты, суммарные часы, строгие
@@ -265,6 +299,19 @@
 Attachment    — файлы документов (изображения), document_id, mime.
                 URL скачивания файла неизменен: /api/attachments/{id}/file —
                 он зашит в сохранённый markdown-текст
+
+XpEvent       — начисление XP за закрытую задачу (идемпотентно по task_id):
+                amount, rarity (common | rare | epic), via_options
+
+CoinEvent     — журнал монет сада (заработок и траты; баланс = Σ amount):
+                task_id (nullable), level (nullable — бонус уровня),
+                source (task | level | shop), amount (+/−), item_key (ключ
+                покупки для трат), created_at
+
+GardenItem    — элемент сцены сада: kind (plant | decoration),
+                ref_id (→ xp_events для растений; уникально в паре с kind),
+                item_key (вид растения / ключ декорации), x, y (ячейки сетки),
+                stage (0 росток, 1 куст, 2 цветение)
 ```
 
 История завершённых задач (фактическое время) — источник для прогнозирования длительности.
diff --git a/frontend/src/api.ts b/frontend/src/api.ts
index e68694b..6085572 100644
--- a/frontend/src/api.ts
+++ b/frontend/src/api.ts
@@ -112,6 +112,45 @@
 
 export type AppSettingsUpdate = Partial<AppSettings>
 
+// Сад-сцена (ТЗ 3.13): элементы, каталоги, магазин
+export interface GardenItem {
+  id: number
+  kind: 'plant' | 'decoration'
+  ref_id: number | null
+  item_key: string | null
+  x: number
+  y: number
+  stage: number // 0 росток, 1 куст, 2 цветение
+  rarity: string | null
+  task_title: string | null
+  done_at: string | null
+}
+
+export interface GardenSpecies {
+  key: string
+  level: number
+  premium: boolean
+  unlocked: boolean
+}
+
+export interface GardenExpansion {
+  key: string
+  level: number
+  cost: number
+}
+
+export interface GardenState {
+  balance: number
+  level: number
+  grid: { cols: number; rows: number }
+  items: GardenItem[]
+  decorations: { key: string; cost: number; unique: boolean }[]
+  next_expansion: GardenExpansion | null
+  expansions_bought: number
+  species: GardenSpecies[]
+  upgrade_costs: Record<string, [number, number]>
+}
+
 export class ApiError extends Error {
   status: number
   constructor(status: number, message: string) {
@@ -139,6 +178,7 @@
   if (earned) {
     earnedXpBuffer = {
       xp: Number(earned) || 0,
+      coins: Number(res.headers.get('X-Earned-Coins')) || 0,
       rarity: res.headers.get('X-Plant-Rarity') ?? 'common',
       options: res.headers.get('X-Options-Close') === '1',
       hard: res.headers.get('X-Mentally-Hard') === '1',
@@ -150,6 +190,7 @@
 // Геймификация последнего закрывающего запроса (забирается через takeEarnedXp)
 export interface EarnedReward {
   xp: number
+  coins: number // монеты сада — вторая награда за закрытие
   rarity: string // common | rare | epic
   options: boolean // закрыто из режима «3 вариантов»
   hard: boolean // «ментально сложная» — награда за силу воли
@@ -232,4 +273,21 @@
   // геймификация (ТЗ 3.13)
   getXp: () => request<XpSummary>('/api/xp'),
   getXpEvents: () => request<XpEvent[]>('/api/xp/events'),
+  // сад (ТЗ 3.13)
+  getGarden: () => request<GardenState>('/api/garden'),
+  moveGardenItem: (id: number, x: number, y: number) =>
+    request<{ ok: boolean }>(`/api/garden/items/${id}`, {
+      method: 'PATCH',
+      body: JSON.stringify({ x, y }),
+    }),
+  upgradePlant: (id: number) =>
+    request<{ ok: boolean; stage: number; cost: number; balance: number }>(
+      `/api/garden/plants/${id}/upgrade`,
+      { method: 'POST' },
+    ),
+  buyGardenItem: (itemKey: string) =>
+    request<{ ok: boolean; balance: number }>('/api/garden/shop/buy', {
+      method: 'POST',
+      body: JSON.stringify({ item_key: itemKey }),
+    }),
 }
\ No newline at end of file
diff --git a/frontend/src/components/GardenScene.vue b/frontend/src/components/GardenScene.vue
new file mode 100644
index 0000000..d5649f5
--- /dev/null
+++ b/frontend/src/components/GardenScene.vue
@@ -0,0 +1,428 @@
+<script setup lang="ts">
+// Сцена сада (ТЗ 3.13): SVG-карта с домиком в центре, растениями и декорациями.
+// Мелкая сетка (ячейка 20px), drag&drop со привязкой к ячейке, наложения разрешены.
+// Растение = закрытая задача (item_key — вид, rarity — редкость); клик — поповер роста.
+import { computed, ref } from 'vue'
+import { useI18n } from 'vue-i18n'
+import type { GardenItem, GardenState } from '../api'
+
+defineOptions({ name: 'GardenScene' })
+
+const props = defineProps<{
+  state: GardenState
+  balance: number
+}>()
+
+const emit = defineEmits<{
+  move: [id: number, x: number, y: number]
+  upgrade: [id: number]
+}>()
+
+const { t } = useI18n()
+
+const CELL = 20
+const HOUSE_COLS = 4
+const HOUSE_ROWS = 3
+const HEDGE = 10 // ширина живой изгороди по границе
+
+const width = computed(() => props.state.grid.cols * CELL)
+const height = computed(() => props.state.grid.rows * CELL)
+
+// Домик в центре сетки (footprint 4×3 ячейки)
+const house = computed(() => ({
+  x: (props.state.grid.cols / 2 - HOUSE_COLS / 2) * CELL,
+  y: (props.state.grid.rows / 2 - HOUSE_ROWS / 2) * CELL,
+  w: HOUSE_COLS * CELL,
+  h: HOUSE_ROWS * CELL,
+}))
+
+// Растения и декорации в одном списке; z-порядок по y (дальние — позади)
+const items = computed(() =>
+  [...props.state.items].sort((a, b) => a.y - b.y || a.x - b.x),
+)
+
+// Размер растения по стадии и цвет по редкости
+function stageSize(stage: number): number {
+  return [20, 28, 36][Math.min(stage, 2)]
+}
+
+function plantTitle(item: GardenItem): string {
+  const species = item.item_key ? t(`garden.speciesNames.${item.item_key}`) : ''
+  const stageNames = [t('garden.stage.sprout'), t('garden.stage.bush'), t('garden.stage.bloom')]
+  const stage = stageNames[Math.min(item.stage, 2)]
+  return item.task_title ? `${species} · ${stage} — ${item.task_title}` : `${species} · ${stage}`
+}
+
+function decorTitle(item: GardenItem): string {
+  return item.item_key ? t(`garden.decorNames.${item.item_key}`) : ''
+}
+
+// Цена следующей стадии роста (UPGRADE_COSTS из state, редкость растения)
+function upgradeCost(item: GardenItem): number | null {
+  if (item.kind !== 'plant' || item.stage >= 2) return null
+  const pair = props.state.upgrade_costs[item.rarity ?? 'common']
+  return pair ? pair[item.stage] : null
+}
+
+// --- Drag & drop: pointer events, snap к ячейке, emit на отпускании ---
+
+const svgEl = ref<SVGSVGElement | null>(null)
+const drag = ref<{ id: number; dx: number; dy: number; moved: boolean } | null>(null)
+const dragPos = ref<{ id: number; x: number; y: number } | null>(null)
+
+function cellFromEvent(e: PointerEvent, offX: number, offY: number): { x: number; y: number } {
+  const svg = svgEl.value
+  if (!svg) return { x: 0, y: 0 }
+  const rect = svg.getBoundingClientRect()
+  const scale = width.value / rect.width
+  const px = (e.clientX - rect.left) * scale - offX
+  const py = (e.clientY - rect.top) * scale - offY
+  const maxCols = props.state.grid.cols
+  const maxRows = props.state.grid.rows
+  return {
+    x: Math.max(0, Math.min(maxCols - 1, Math.round(px / CELL))),
+    y: Math.max(0, Math.min(maxRows - 1, Math.round(py / CELL))),
+  }
+}
+
+function onPointerDown(item: GardenItem, e: PointerEvent): void {
+  // Клик без перетаскивания обрабатывается на pointerup (поповер роста)
+  const rect = svgEl.value?.getBoundingClientRect()
+  if (!rect) return
+  const scale = width.value / rect.width
+  drag.value = {
+    id: item.id,
+    dx: (e.clientX - rect.left) * scale - item.x * CELL,
+    dy: (e.clientY - rect.top) * scale - item.y * CELL,
+    moved: false,
+  }
+  dragPos.value = null
+  ;(e.target as Element).setPointerCapture?.(e.pointerId)
+}
+
+function onPointerMove(e: PointerEvent): void {
+  if (!drag.value) return
+  drag.value.moved = true
+  const pos = cellFromEvent(e, drag.value.dx, drag.value.dy)
+  dragPos.value = { id: drag.value.id, x: pos.x, y: pos.y }
+}
+
+function onPointerUp(item: GardenItem, e: PointerEvent): void {
+  const isDrag = drag.value !== null && drag.value.moved
+  drag.value = null
+  const pos = dragPos.value
+  dragPos.value = null
+  if (!isDrag) {
+    // Простой клик по растению — поповер роста; клик по кнопке поповера
+    // обрабатывается сам (pointerup по ней удалил бы кнопку до click)
+    if (item.kind === 'plant' && !(e.target as Element).closest?.('.popover-card')) {
+      selected.value = selected.value === item.id ? null : item.id
+    }
+    return
+  }
+  const cell = pos && pos.id === item.id ? pos : null
+  if (cell && (cell.x !== item.x || cell.y !== item.y)) {
+    emit('move', item.id, cell.x, cell.y)
+    // Снимок позиции применён визуально — бэк подтвердит при следующем load
+    item.x = cell.x
+    item.y = cell.y
+  }
+}
+
+// Позиция элемента с учётом перетаскивания
+function itemPos(item: GardenItem): { x: number; y: number } {
+  if (dragPos.value && dragPos.value.id === item.id) {
+    return { x: dragPos.value.x, y: dragPos.value.y }
+  }
+  return { x: item.x, y: item.y }
+}
+
+// --- Поповер роста растения ---
+const selected = ref<number | null>(null)
+
+function onUpgrade(item: GardenItem): void {
+  emit('upgrade', item.id)
+  selected.value = null
+}
+</script>
+
+<template>
+  <div class="scene-wrap">
+    <svg
+      ref="svgEl"
+      class="scene"
+      :viewBox="`0 0 ${width} ${height}`"
+      :style="{ aspectRatio: `${width} / ${height}` }"
+      @pointermove="onPointerMove"
+      @pointerleave="drag = null"
+    >
+      <defs>
+        <pattern id="cells" :width="CELL" :height="CELL" patternUnits="userSpaceOnUse">
+          <path
+            :d="`M ${CELL} 0 L 0 0 0 ${CELL}`"
+            fill="none"
+            stroke="rgba(0,0,0,0.07)"
+            stroke-width="1"
+          />
+        </pattern>
+      </defs>
+
+      <!-- Дикая земля за изгородью, затем газон текущей карты -->
+      <rect x="0" y="0" :width="width" :height="height" class="wild" />
+      <rect
+        :x="HEDGE"
+        :y="HEDGE"
+        :width="width - HEDGE * 2"
+        :height="height - HEDGE * 2"
+        rx="6"
+        class="lawn"
+      />
+      <rect
+        :x="HEDGE"
+        :y="HEDGE"
+        :width="width - HEDGE * 2"
+        :height="height - HEDGE * 2"
+        rx="6"
+        fill="url(#cells)"
+      />
+      <!-- Живая изгородь — визуальная граница сада -->
+      <rect
+        :x="HEDGE / 2"
+        :y="HEDGE / 2"
+        :width="width - HEDGE"
+        :height="height - HEDGE"
+        rx="8"
+        class="hedge"
+      />
+
+      <!-- Домик в центре -->
+      <g class="house" :transform="`translate(${house.x}, ${house.y})`">
+        <rect x="4" y="18" :width="house.w - 8" :height="house.h - 22" rx="3" class="house-body" />
+        <path :d="`M -2 20 L ${house.w / 2} -4 L ${house.w + 2} 20 Z`" class="house-roof" />
+        <rect :x="house.w / 2 - 6" :y="house.h - 22" width="12" height="18" rx="1.5" class="house-door" />
+        <rect x="12" y="26" width="10" height="9" rx="1.5" class="house-window" />
+        <rect :x="house.w - 22" y="26" width="10" height="9" rx="1.5" class="house-window" />
+      </g>
+
+      <!-- Элементы сада: растения и декорации, z-порядок по y -->
+      <g
+        v-for="item in items"
+        :key="item.id"
+        class="item"
+        :class="{ dragging: dragPos?.id === item.id, plant: item.kind === 'plant' }"
+        :transform="`translate(${itemPos(item).x * CELL + CELL / 2}, ${itemPos(item).y * CELL + CELL / 2})`"
+        @pointerdown="onPointerDown(item, $event)"
+        @pointerup="onPointerUp(item, $event)"
+      >
+        <title>{{ item.kind === 'plant' ? plantTitle(item) : decorTitle(item) }}</title>
+
+        <!-- Растение: phosphor-иконка кита во foreignObject, размер по стадии -->
+        <foreignObject
+          v-if="item.kind === 'plant'"
+          :x="-stageSize(item.stage) / 2"
+          :y="-stageSize(item.stage) / 2"
+          :width="stageSize(item.stage)"
+          :height="stageSize(item.stage)"
+        >
+          <i
+            :class="`ph ${item.item_key} plant-icon rarity-${item.rarity ?? 'common'}`"
+            :style="{ fontSize: `${stageSize(item.stage)}px` }"
+            aria-hidden="true"
+          />
+        </foreignObject>
+
+        <!-- Декорации: простые SVG-фигуры -->
+        <g v-else-if="item.item_key === 'lantern'" class="decor">
+          <rect x="-1.5" y="-6" width="3" height="14" class="d-wood" />
+          <rect x="-5" y="-14" width="10" height="9" rx="2" class="d-glass" />
+          <circle cx="0" cy="-9.5" r="1.8" class="d-glow" />
+        </g>
+        <g v-else-if="item.item_key === 'bench'" class="decor">
+          <rect x="-9" y="-2" width="18" height="3" rx="1" class="d-wood" />
+          <rect x="-9" y="-8" width="18" height="2.5" rx="1" class="d-wood" />
+          <rect x="-8" y="-2" width="2" height="6" class="d-wood" />
+          <rect x="6" y="-2" width="2" height="6" class="d-wood" />
+        </g>
+        <ellipse v-else-if="item.item_key === 'pond'" rx="9" ry="6" class="d-water" />
+        <ellipse v-else-if="item.item_key === 'birdbath'" cx="0" cy="0" rx="6" ry="3" class="d-water" />
+        <g v-else-if="item.item_key === 'gazebo'" class="decor">
+          <path d="M -9 2 L 0 -10 L 9 2 Z" class="d-roof" />
+          <rect x="-7" y="2" width="14" height="7" class="d-wood" />
+        </g>
+        <g v-else-if="item.item_key === 'flowerbed'" class="decor">
+          <ellipse rx="8" ry="4.5" class="d-bed" />
+          <circle cx="-3" cy="-1" r="1.8" class="d-flower" />
+          <circle cx="2" cy="1" r="1.8" class="d-flower2" />
+          <circle cx="4" cy="-1.5" r="1.6" class="d-flower" />
+        </g>
+        <g v-else-if="item.item_key === 'fence'" class="decor">
+          <rect x="-9" y="-3" width="18" height="2" class="d-wood" />
+          <rect x="-8" y="-5" width="2.5" height="7" class="d-wood" />
+          <rect x="0" y="-5" width="2.5" height="7" class="d-wood" />
+          <rect x="6" y="-5" width="2.5" height="7" class="d-wood" />
+        </g>
+
+        <!-- Поповер роста: цена следующей стадии или «полностью выросло» -->
+        <foreignObject
+          v-if="item.kind === 'plant' && selected === item.id"
+          x="-72"
+          y="-44"
+          width="144"
+          height="40"
+          class="popover"
+        >
+          <div xmlns="http://www.w3.org/1999/xhtml" class="popover-card">
+            <template v-if="upgradeCost(item) !== null">
+              <button
+                xmlns="http://www.w3.org/1999/xhtml"
+                class="popover-btn"
+                :disabled="balance < (upgradeCost(item) ?? 0)"
+                @click.stop="onUpgrade(item)"
+              >
+                <i class="ph ph-arrow-fat-up" aria-hidden="true" />
+                {{ t('garden.upgrade', { n: upgradeCost(item) }) }}
+              </button>
+              <span v-if="balance < (upgradeCost(item) ?? 0)" class="popover-hint">
+                {{ t('garden.notEnoughCoins', { n: (upgradeCost(item) ?? 0) - balance }) }}
+              </span>
+            </template>
+            <span v-else class="popover-max">
+              <i class="ph ph-check-circle" aria-hidden="true" />
+              {{ t('garden.maxStage') }}
+            </span>
+          </div>
+        </foreignObject>
+      </g>
+    </svg>
+  </div>
+</template>
+
+<style scoped>
+.scene-wrap {
+  margin-bottom: 2rem;
+}
+.scene {
+  display: block;
+  width: 100%;
+  border-radius: 12px;
+  border: 1px solid var(--border, #2a2f45);
+  touch-action: none;
+  user-select: none;
+}
+.wild {
+  fill: color-mix(in srgb, var(--text-muted, #888) 18%, #3b3222);
+}
+.lawn {
+  fill: color-mix(in srgb, var(--success, #9ece6a) 26%, var(--bg-page, #1a1f2e));
+}
+.hedge {
+  fill: none;
+  stroke: color-mix(in srgb, var(--success, #9ece6a) 60%, #2d5a27);
+  stroke-width: 10;
+}
+.house-body {
+  fill: color-mix(in srgb, var(--warning, #e0af68) 45%, var(--bg-page, #1a1f2e));
+  stroke: var(--border, #2a2f45);
+}
+.house-roof {
+  fill: color-mix(in srgb, #f7768e 45%, var(--bg-page, #1a1f2e));
+}
+.house-door {
+  fill: color-mix(in srgb, #7aa2f7 55%, var(--bg-page, #1a1f2e));
+}
+.house-window {
+  fill: color-mix(in srgb, #73daca 55%, var(--bg-page, #1a1f2e));
+}
+.item {
+  cursor: grab;
+}
+.item.dragging {
+  cursor: grabbing;
+}
+.item.plant:active {
+  cursor: grabbing;
+}
+.plant-icon {
+  display: block;
+  line-height: 1;
+  color: var(--success, #9ece6a);
+  pointer-events: none;
+}
+.plant-icon.rarity-rare {
+  color: #e0af68;
+}
+.plant-icon.rarity-epic {
+  color: #d4a017;
+  filter: drop-shadow(0 0 4px rgba(241, 196, 15, 0.7));
+}
+.decor {
+  pointer-events: none;
+}
+.d-wood {
+  fill: #8a6d4b;
+}
+.d-glass {
+  fill: color-mix(in srgb, #f1c40f 40%, var(--bg-page, #1a1f2e));
+}
+.d-glow {
+  fill: #f5d76e;
+}
+.d-water {
+  fill: color-mix(in srgb, #7aa2f7 60%, var(--bg-page, #1a1f2e));
+  stroke: rgba(122, 162, 247, 0.4);
+}
+.d-roof {
+  fill: color-mix(in srgb, #f7768e 50%, var(--bg-page, #1a1f2e));
+}
+.d-bed {
+  fill: #6b4f3a;
+}
+.d-flower {
+  fill: #f7768e;
+}
+.d-flower2 {
+  fill: #bb9af7;
+}
+.popover-card {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  padding: 4px;
+  border-radius: 8px;
+  background: var(--bg-card, #24283b);
+  border: 1px solid var(--border, #2a2f45);
+  font-size: 11px;
+  line-height: 1.2;
+}
+.popover-btn {
+  display: flex;
+  gap: 4px;
+  align-items: center;
+  padding: 3px 6px;
+  border: none;
+  border-radius: 6px;
+  background: var(--success, #9ece6a);
+  color: #1a1f2e;
+  font-weight: 600;
+  font-size: 11px;
+  cursor: pointer;
+  white-space: nowrap;
+}
+.popover-btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+.popover-hint {
+  color: #f7768e;
+  font-size: 10px;
+  white-space: nowrap;
+}
+.popover-max {
+  display: flex;
+  gap: 4px;
+  align-items: center;
+  color: var(--text-muted, #888);
+  font-size: 10px;
+  white-space: nowrap;
+}
+</style>
\ No newline at end of file
diff --git a/frontend/src/gamification.ts b/frontend/src/gamification.ts
index e1f2f72..53ca9de 100644
--- a/frontend/src/gamification.ts
+++ b/frontend/src/gamification.ts
@@ -66,7 +66,7 @@
   // «Ментально сложная» празднуется золотом всегда — закрыть через силу само по себе повод
   const special = reward.rarity !== 'common' || reward.xp >= 25 || reward.hard
   confetti(special)
-  const titleParts = [`+${reward.xp} XP`]
+  const titleParts = [`+${reward.xp} XP`, `+${reward.coins} ${i18n.global.t('gamify.coins')}`]
   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) })
diff --git a/frontend/src/locales/en.ts b/frontend/src/locales/en.ts
index b848f90..ad4c6b7 100644
--- a/frontend/src/locales/en.ts
+++ b/frontend/src/locales/en.ts
@@ -57,6 +57,7 @@
       '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.',
       'Earned XP raises your level — from Sprout to Garden Legend. Levels never drop: XP does not expire and is not taken away, even if a task is deleted.',
       'Sometimes a task yields a rare plant — the chance grows with the task weight. Epic plants only come from the biggest completions.',
+      'The general rule: experience unlocks, coins buy. Experience (level) unlocks new plant species and land; coins are spent on plant growth, decorations and map expansion. Coins come from completed tasks (half the XP) and from reaching new levels.',
       '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.',
     ],
@@ -77,6 +78,44 @@
       'Garden legend',
     ],
     achievements: 'Achievements',
+    coins: 'coins: {n}',
+    coinsHint: 'Garden currency: spent on plant growth and decorations',
+    shop: 'Market',
+    shopTitle: 'Garden market',
+    buy: 'Buy',
+    notEnoughCoins: 'Not enough coins — {n} short',
+    lockedUntil: 'Unlocks at level {n}',
+    expansion: 'Garden expansion',
+    expansionHint: 'More land — {n} cells added to the map perimeter',
+    expansionCurrent: 'Current map: {cols}×{rows}',
+    expansionMax: 'All land unlocked',
+    decorations: 'Decorations',
+    decorationsHint: 'Decorate your garden — decorations give no bonuses, just joy',
+    unique: 'unique',
+    rareOnly: 'rare plants only',
+    species: 'Plant species',
+    speciesHint:
+      'Experience unlocks new species and land, coins buy 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' },
+    speciesNames: {
+      'ph-flower': 'Flower',
+      'ph-leaf': 'Greens',
+      'ph-tree-evergreen': 'Pine',
+      'ph-flower-lotus': 'Lotus',
+      'ph-cactus': 'Cactus',
+      'ph-tree': 'Oak',
+    },
+    decorNames: {
+      fence: 'Fence',
+      flowerbed: 'Flowerbed',
+      lantern: 'Lantern',
+      bench: 'Bench',
+      birdbath: 'Birdbath',
+      pond: 'Pond',
+      gazebo: 'Gazebo',
+    },
     ach: {
       firstDone: 'First sprout',
       done10: 'Dozen',
@@ -105,6 +144,7 @@
     chosen: 'chose and did',
     willpower: 'willpower',
     willpowerText: 'Willpower! It was worth it.',
+    coins: 'coins',
   },
   stats: {
     title: 'Statistics',
diff --git a/frontend/src/locales/ru.ts b/frontend/src/locales/ru.ts
index 2872dab..cca2c37 100644
--- a/frontend/src/locales/ru.ts
+++ b/frontend/src/locales/ru.ts
@@ -58,6 +58,7 @@
       'За закрытие начисляется XP: база 10 + бонус за приоритет задачи (до 15) + бонус за объём работы по оценке времени (до 15) + 10 за «ментально сложную» — честная награда за силу воли. Крупные и срочные дела ценнее.',
       'Накопленный XP повышает уровень — от «Ростка» до «Легенды сада». Уровень не падает: XP не сгорает и не отнимается, даже если задачу удалить.',
       'Иногда задача приносит редкое растение — шанс тем выше, чем «весомее» задача. Эпические растения достаются только крупным закрытиям.',
+      'Общий принцип: опыт открывает, монеты покупают. Опыт (уровень) открывает новые виды растений и землю; монеты тратятся на рост растений, декорации и расширение карты. Монеты приходят за закрытые задачи (половина XP) и за новые уровни.',
       'Достижения отмечают вехи: закрытые задачи, уровни, разные проекты, часы работы, строгие дедлайны, «ментально сложные» задачи. У каждой ступени I, II, III — прогресс виден всегда.',
       'Задача, закрытая из режима «3 вариантов», отмечается меткой «выбрал и сделал». Закрытие «не хочется делать» празднуется золотом — сила воли того стоила. Ничего не сгорает, серий и наказаний нет — только приятные награды.',
     ],
@@ -78,6 +79,44 @@
       'Легенда сада',
     ],
     achievements: 'Достижения',
+    coins: 'монет: {n}',
+    coinsHint: 'Валюта сада: тратится на рост растений и декорации',
+    shop: 'Маркет',
+    shopTitle: 'Маркет сада',
+    buy: 'Купить',
+    notEnoughCoins: 'Не хватает {n} монет',
+    lockedUntil: 'Откроется на уровне {n}',
+    expansion: 'Расширение сада',
+    expansionHint: 'Больше земли — {n} клеток к периметру карты',
+    expansionCurrent: 'Текущая карта: {cols}×{rows}',
+    expansionMax: 'Вся земля открыта',
+    decorations: 'Декорации',
+    decorationsHint: 'Украсьте сад — декорации не дают бонусов, только настроение',
+    unique: 'уникальная',
+    rareOnly: 'только редкие растения',
+    species: 'Виды растений',
+    speciesHint:
+      'Опыт открывает новые виды и землю, монеты покупают рост и украшения. Вид фиксируется за растением в момент рождения.',
+    upgrade: 'Вырастить — {n} монет',
+    maxStage: 'Полностью выросло',
+    stage: { sprout: 'Росток', bush: 'Куст', bloom: 'Цветение' },
+    speciesNames: {
+      'ph-flower': 'Цветок',
+      'ph-leaf': 'Зелень',
+      'ph-tree-evergreen': 'Ель',
+      'ph-flower-lotus': 'Лотос',
+      'ph-cactus': 'Кактус',
+      'ph-tree': 'Дуб',
+    },
+    decorNames: {
+      fence: 'Изгородь',
+      flowerbed: 'Клумба',
+      lantern: 'Фонарь',
+      bench: 'Лавочка',
+      birdbath: 'Поилка для птиц',
+      pond: 'Пруд',
+      gazebo: 'Беседка',
+    },
     ach: {
       firstDone: 'Первый росток',
       done10: 'Десяток',
@@ -106,6 +145,7 @@
     chosen: 'выбрал и сделал',
     willpower: 'сила воли',
     willpowerText: 'Сила воли! Это того стоило.',
+    coins: 'монет',
   },
   stats: {
     title: 'Статистика',
diff --git a/frontend/src/locales/uk.ts b/frontend/src/locales/uk.ts
index 6b77f5d..43fcaca 100644
--- a/frontend/src/locales/uk.ts
+++ b/frontend/src/locales/uk.ts
@@ -57,6 +57,7 @@
       'За виконання нараховується XP: база 10 + бонус за пріоритет (до 15) + бонус за обсяг за оцінкою часу (до 15) + 10 за «ментально складне» — чесна нагорода за силу волі. Великі й термінові справи цінніші.',
       'Накопичений XP підвищує рівень — від «Паростка» до «Легенди саду». Рівень не падає: XP не згорає і не віднімається, навіть якщо завдання видалити.',
       'Іноді завдання приносить рідкісну рослину — шанс тим вищий, що «важче» завдання. Епічні рослини дістаються лише великим завершенням.',
+      'Загальний принцип: досвід відкриває, монети купують. Досвід (рівень) відкриває нові види рослин і землю; монети витрачаються на ріст рослин, декорації та розширення карти. Монети надходять за виконані завдання (половина XP) та за нові рівні.',
       'Досягнення відзначають віхи: виконані завдання, рівні, різні проєкти, години роботи, строгі дедлайни, «ментально складні» завдання. У кожного ступені I, II, III — прогрес видно завжди.',
       'Завдання, виконане з режиму «3 варіанти», відзначається меткою «обрав і зробив». Закриття «не хочеться робити» завжди святкується золотом — сила волі того варта. Нічого не згорає, серій і покарань немає — лише приємні нагороди.',
     ],
@@ -77,6 +78,44 @@
       'Легенда саду',
     ],
     achievements: 'Досягнення',
+    coins: 'монет: {n}',
+    coinsHint: 'Валюта саду: витрачається на ріст рослин і декорації',
+    shop: 'Маркет',
+    shopTitle: 'Маркет саду',
+    buy: 'Купити',
+    notEnoughCoins: 'Не вистачає {n} монет',
+    lockedUntil: 'Відкриється на рівні {n}',
+    expansion: 'Розширення саду',
+    expansionHint: 'Більше землі — {n} клітинок до периметра карти',
+    expansionCurrent: 'Поточна карта: {cols}×{rows}',
+    expansionMax: 'Вся земля відкрита',
+    decorations: 'Декорації',
+    decorationsHint: 'Прикрасьте сад — декорації не дають бонусів, лише настрій',
+    unique: 'унікальна',
+    rareOnly: 'лише рідкісні рослини',
+    species: 'Види рослин',
+    speciesHint:
+      'Досвід відкриває нові види й землю, монети купують ріст та прикраси. Вид фіксується за рослиною в момент народження.',
+    upgrade: 'Виростити — {n} монет',
+    maxStage: 'Повністю виросло',
+    stage: { sprout: 'Паросток', bush: 'Кущ', bloom: 'Цвітіння' },
+    speciesNames: {
+      'ph-flower': 'Квітка',
+      'ph-leaf': 'Зелень',
+      'ph-tree-evergreen': 'Ялина',
+      'ph-flower-lotus': 'Лотос',
+      'ph-cactus': 'Кактус',
+      'ph-tree': 'Дуб',
+    },
+    decorNames: {
+      fence: 'Огорожа',
+      flowerbed: 'Клумба',
+      lantern: 'Фонар',
+      bench: 'Лавка',
+      birdbath: 'Поїлка для птахів',
+      pond: 'Ставок',
+      gazebo: 'Альтанка',
+    },
     ach: {
       firstDone: 'Перший паросток',
       done10: 'Десятка',
@@ -105,6 +144,7 @@
     chosen: 'обрав і зробив',
     willpower: 'сила волі',
     willpowerText: 'Сила волі! Того варто було.',
+    coins: 'монет',
   },
   stats: {
     title: 'Статистика',
diff --git a/frontend/src/views/GardenView.vue b/frontend/src/views/GardenView.vue
index ca99df4..5e1992b 100644
--- a/frontend/src/views/GardenView.vue
+++ b/frontend/src/views/GardenView.vue
@@ -1,20 +1,28 @@
 <script setup lang="ts">
 import { computed, onMounted, ref } from 'vue'
 import { useI18n } from 'vue-i18n'
-import { api, type Task, type XpEvent, type XpSummary } from '../api'
+import {
+  api,
+  type GardenState,
+  type Task,
+  type XpEvent,
+  type XpSummary,
+} from '../api'
 import { formatDate } from '../taskui'
+import GardenScene from '../components/GardenScene.vue'
 
 defineOptions({ name: 'GardenView' })
 
-// Сад (ТЗ 3.13): каждая закрытая задача — растение на грядке. Только позитив:
-// сад никогда не уменьшается, стриков нет, уровень не падает.
-// Редкость растения и признак «из 3 вариантов» приходят из событий XP.
+// Сад (ТЗ 3.13): живая сцена — домик, растения (закрытые задачи), декорации.
+// Принцип «контент открывается за опыт, покупается за монеты»: XP — уровень,
+// монеты — валюта сада (рост растений, декорации, расширения карты).
 
 const { t, locale, tm } = useI18n()
 
 const tasks = ref<Task[]>([])
 const events = ref<XpEvent[]>([])
 const xp = ref<XpSummary | null>(null)
+const garden = ref<GardenState | null>(null)
 const error = ref('')
 const loading = ref(false)
 
@@ -27,29 +35,12 @@
     : []
 })
 
-// Растение детерминировано по id задачи — при каждом визите то же самое
-const PLANTS = ['ph-flower', 'ph-flower-lotus', 'ph-tree-evergreen', 'ph-tree', 'ph-leaf', 'ph-cactus']
-
 const doneTasks = computed(() =>
   tasks.value
     .filter((task) => task.status === 'done' && task.done_at)
     .sort((a, b) => (a.done_at! < b.done_at! ? 1 : -1)),
 )
 
-function plantIcon(task: Task): string {
-  if (task.task_type === 'recurring') return 'ph-tree'
-  return PLANTS[task.id % PLANTS.length]
-}
-
-// Редкость по событию XP (решается на бэке в момент закрытия по весу задачи)
-const rarityByTask = computed(() => {
-  const map = new Map<number, string>()
-  events.value.forEach((e) => {
-    if (e.task_id !== null) map.set(e.task_id, e.rarity)
-  })
-  return map
-})
-
 // Название уровня: 10 ботанических званий (garden.levels), дальше — последнее
 function levelName(level: number): string {
   const idx = Math.min(level, 10) - 1
@@ -157,18 +148,56 @@
   ]
 })
 
+// --- Маркет: расширения, декорации, каталог видов ---
+
+const shopOpen = ref(false)
+const shopBusy = ref<string | null>(null) // item_key текущего запроса
+
+// Состояние карточки магазина: замок / не хватает монет / можно купить
+type ShopState = 'locked' | 'poor' | 'ok' | 'max'
+
+function decorShopState(decor: { key: string; cost: number; unique: boolean }): ShopState {
+  if (decor.unique && (garden.value?.items ?? []).some((i) => i.item_key === decor.key)) {
+    return 'max'
+  }
+  return (garden.value?.balance ?? 0) >= decor.cost ? 'ok' : 'poor'
+}
+
+function expansionShopState(): ShopState {
+  const next = garden.value?.next_expansion
+  if (!next) return 'max'
+  if ((garden.value?.level ?? 1) < next.level) return 'locked'
+  return (garden.value?.balance ?? 0) >= next.cost ? 'ok' : 'poor'
+}
+
+async function buy(itemKey: string): Promise<void> {
+  shopBusy.value = itemKey
+  error.value = ''
+  try {
+    const res = await api.buyGardenItem(itemKey)
+    if (garden.value) garden.value.balance = res.balance
+    await load()
+  } catch (e) {
+    error.value = String(e)
+  } finally {
+    shopBusy.value = null
+  }
+}
+
 async function load() {
   loading.value = true
   error.value = ''
   try {
-    const [taskList, xpSummary, eventList] = await Promise.all([
+    const [taskList, xpSummary, eventList, gardenState] = await Promise.all([
       api.listTasks(),
       api.getXp(),
       api.getXpEvents(),
+      api.getGarden(),
     ])
     tasks.value = taskList
     xp.value = xpSummary
     events.value = eventList
+    garden.value = gardenState
   } catch (e) {
     error.value = String(e)
   } finally {
@@ -176,12 +205,29 @@
   }
 }
 
+async function onMove(id: number, x: number, y: number): Promise<void> {
+  try {
+    await api.moveGardenItem(id, x, y)
+  } catch {
+    await load() // позиция не принята — вернуть из состояния бэка
+  }
+}
+
+async function onUpgrade(id: number): Promise<void> {
+  try {
+    await api.upgradePlant(id)
+    await load()
+  } catch (e) {
+    error.value = String(e)
+  }
+}
+
 onMounted(load)
 </script>
 
 <template>
   <section>
-    <GnSkeleton v-if="loading && !xp" type="block" stack :count="2" class="page-skeleton" />
+    <GnSkeleton v-if="loading && !garden" type="block" stack :count="2" class="page-skeleton" />
 
     <template v-else>
       <GnPageHeader kicker="GNexus Tasks" :title="t('garden.title')">
@@ -192,11 +238,15 @@
           <GnBadge variant="neutral"><i class="ph ph-lightning" aria-hidden="true" />
             {{ t('garden.xpTotal', { n: xp?.total_xp ?? 0 }) }}
           </GnBadge>
-          <GnBadge variant="success"><i class="ph ph-leaf" aria-hidden="true" />
-            {{ t('garden.plants', { n: doneTasks.length }) }}
+          <GnBadge variant="warning" :title="t('garden.coinsHint')">
+            <i class="ph ph-coins" aria-hidden="true" />
+            {{ t('garden.coins', { n: garden?.balance ?? 0 }) }}
           </GnBadge>
         </template>
         <template #actions>
+          <GnButton variant="secondary" icon="ph-storefront" @click="shopOpen = true">
+            {{ t('garden.shop') }}
+          </GnButton>
           <GnIconButton icon="ph-question" :label="t('garden.aboutOpen')" :title="t('garden.aboutOpen')" @click="aboutOpen = true" />
         </template>
       </GnPageHeader>
@@ -208,6 +258,111 @@
         </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>
+
+          <!-- 1. Расширение сада -->
+          <div class="shop-block">
+            <div class="shop-block-title">
+              <i class="ph ph-map-trifold" aria-hidden="true" />
+              <span>{{ t('garden.expansion') }}</span>
+            </div>
+            <p class="shop-block-hint">
+              {{ t('garden.expansionCurrent', { cols: garden?.grid.cols, rows: garden?.grid.rows }) }}
+            </p>
+            <div v-if="garden?.next_expansion" class="shop-card" :class="expansionShopState()">
+              <i class="ph ph-tree-palm" aria-hidden="true" />
+              <span class="shop-name">{{ t(`garden.expansion`) }} {{ garden.expansions_bought + 1 }}</span>
+              <span class="shop-meta">
+                <template v-if="expansionShopState() === 'locked'">
+                  {{ t('garden.lockedUntil', { n: garden.next_expansion.level }) }}
+                </template>
+                <template v-else>{{ t('garden.expansionHint', { n: 8 }) }}</template>
+              </span>
+              <GnBadge variant="neutral">
+                <i class="ph ph-coins" aria-hidden="true" /> {{ garden.next_expansion.cost }}
+              </GnBadge>
+              <GnButton
+                size="sm"
+                variant="primary"
+                icon="ph-shopping-cart-simple"
+                :disabled="expansionShopState() !== 'ok' || shopBusy !== null"
+                :loading="shopBusy === garden.next_expansion.key"
+                @click="buy(garden.next_expansion.key)"
+              >
+                {{ t('garden.buy') }}
+              </GnButton>
+            </div>
+            <p v-else class="shop-max">{{ t('garden.expansionMax') }}</p>
+          </div>
+
+          <!-- 2. Декорации -->
+          <div class="shop-block">
+            <div class="shop-block-title">
+              <i class="ph ph-flowers" aria-hidden="true" />
+              <span>{{ t('garden.decorations') }}</span>
+            </div>
+            <p class="shop-block-hint">{{ t('garden.decorationsHint') }}</p>
+            <div
+              v-for="decor in garden?.decorations ?? []"
+              :key="decor.key"
+              class="shop-item"
+              :class="decorShopState(decor)"
+            >
+              <i class="ph ph-flower" aria-hidden="true" />
+              <span class="shop-name">
+                {{ t(`garden.decorNames.${decor.key}`) }}
+                <GnBadge v-if="decor.unique" variant="neutral">{{ t('garden.unique') }}</GnBadge>
+              </span>
+              <GnBadge variant="neutral" class="shop-price">
+                <i class="ph ph-coins" aria-hidden="true" /> {{ decor.cost }}
+              </GnBadge>
+              <span v-if="decorShopState(decor) === 'poor'" class="shop-poor">
+                {{ t('garden.notEnoughCoins', { n: decor.cost - (garden?.balance ?? 0) }) }}
+              </span>
+              <span v-else-if="decorShopState(decor) === 'max'" class="shop-owned">✓</span>
+              <GnButton
+                v-else
+                size="sm"
+                variant="secondary"
+                icon="ph-shopping-cart-simple"
+                :disabled="decorShopState(decor) !== 'ok'"
+                :loading="shopBusy === decor.key"
+                @click="buy(decor.key)"
+              >
+                {{ t('garden.buy') }}
+              </GnButton>
+            </div>
+          </div>
+
+          <!-- 3. Каталог видов растений (открываются уровнем, покупаются ростом) -->
+          <div class="shop-block">
+            <div class="shop-block-title">
+              <i class="ph ph-plant" aria-hidden="true" />
+              <span>{{ t('garden.species') }}</span>
+            </div>
+            <div
+              v-for="species in garden?.species ?? []"
+              :key="species.key"
+              class="shop-item"
+              :class="species.unlocked ? 'ok' : 'locked'"
+            >
+              <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">
+                {{ t('garden.lockedUntil', { n: species.level }) }}
+              </span>
+              <span v-else class="shop-meta">✓</span>
+            </div>
+          </div>
+        </div>
+      </GnModal>
+
       <GnAlert v-if="error" variant="error">{{ error }}</GnAlert>
 
       <!-- Прогресс уровня: XP только растёт, уровень не падает -->
@@ -225,6 +380,25 @@
         <span>{{ t('garden.lastPlant', { title: lastPlant.title, date: formatDate(lastPlant.done_at!) }) }}</span>
       </div>
 
+      <!-- Сцена сада: домик, растения (drag&drop), декорации -->
+      <GardenScene
+        v-if="garden && garden.items.length"
+        :state="garden"
+        :balance="garden.balance"
+        @move="onMove"
+        @upgrade="onUpgrade"
+      />
+      <GnEmptyState
+        v-else
+        icon="ph-flower-lotus"
+        :title="t('garden.emptyTitle')"
+        :text="t('garden.emptyText')"
+      >
+        <GnButton variant="secondary" icon="ph-question" @click="aboutOpen = true">
+          {{ t('garden.aboutOpen') }}
+        </GnButton>
+      </GnEmptyState>
+
       <!-- История: закрытых задач по месяцам (12 месяцев) -->
       <div class="history-title">
         <i class="ph ph-chart-bar" aria-hidden="true" />
@@ -241,37 +415,6 @@
         </div>
       </div>
 
-      <!-- Грядка: растение за каждую закрытую задачу -->
-      <div v-if="doneTasks.length" class="garden-grid">
-        <RouterLink
-          v-for="task in doneTasks"
-          :key="task.id"
-          class="plant"
-          :class="rarityByTask.get(task.id)"
-          :to="`/tasks/${task.id}`"
-        >
-          <i :class="`ph ${plantIcon(task)}`" aria-hidden="true" />
-          <span v-if="rarityByTask.get(task.id) === 'epic'" class="rarity-badge">
-            <i class="ph ph-crown-simple" aria-hidden="true" />
-          </span>
-          <span v-else-if="rarityByTask.get(task.id) === 'rare'" class="rarity-badge">
-            <i class="ph ph-sparkle" aria-hidden="true" />
-          </span>
-          <span class="plant-title">{{ task.title }}</span>
-          <span class="plant-date">{{ formatDate(task.done_at!) }}</span>
-        </RouterLink>
-      </div>
-      <GnEmptyState
-        v-else
-        icon="ph-flower-lotus"
-        :title="t('garden.emptyTitle')"
-        :text="t('garden.emptyText')"
-      >
-        <GnButton variant="secondary" icon="ph-question" @click="aboutOpen = true">
-          {{ t('garden.aboutOpen') }}
-        </GnButton>
-      </GnEmptyState>
-
       <!-- Ачивки с тирами: прогресс к следующей ступени виден всегда -->
       <div class="achievements-title">
         <i class="ph ph-trophy" aria-hidden="true" />
@@ -310,6 +453,90 @@
   font-size: 0.95em;
   line-height: 1.5;
 }
+/* маркет */
+.shop-body {
+  display: flex;
+  flex-direction: column;
+  gap: 1.25rem;
+  font-size: 0.95em;
+}
+.shop-hint {
+  color: var(--text-muted, #888);
+  line-height: 1.45;
+}
+.shop-block {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+.shop-block-title {
+  display: flex;
+  gap: 0.5rem;
+  align-items: center;
+  font-weight: 600;
+  font-size: 1rem;
+}
+.shop-block-title > i {
+  color: var(--accent, #7aa2f7);
+}
+.shop-block-hint {
+  margin: 0;
+  font-size: 0.88em;
+  color: var(--text-muted, #888);
+}
+.shop-item,
+.shop-card {
+  display: flex;
+  gap: 0.6rem;
+  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;
+  color: var(--accent, #7aa2f7);
+}
+.shop-item > i:first-child {
+  font-size: 1.3rem;
+  color: var(--success, #9ece6a);
+}
+.shop-item.locked > i:first-child {
+  color: var(--text-muted, #888);
+  opacity: 0.5;
+}
+.shop-item.locked {
+  opacity: 0.6;
+}
+.shop-name {
+  flex: 1 1 auto;
+  display: flex;
+  gap: 0.4rem;
+  align-items: center;
+  font-weight: 600;
+  font-size: 0.92em;
+}
+.shop-meta {
+  font-size: 0.82em;
+  color: var(--text-muted, #888);
+}
+.shop-price {
+  white-space: nowrap;
+}
+.shop-poor {
+  font-size: 0.82em;
+  color: #f7768e;
+  white-space: nowrap;
+}
+.shop-owned {
+  color: var(--success, #9ece6a);
+  font-weight: 700;
+}
+.shop-max {
+  margin: 0;
+  font-size: 0.9em;
+  color: var(--text-muted, #888);
+}
 /* последний росток */
 .last-plant {
   display: flex;
@@ -364,65 +591,6 @@
   color: var(--text-muted, #888);
   white-space: nowrap;
 }
-/* грядка: карточки-растения ровной сеткой, на узком экране — уже */
-.garden-grid {
-  display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(170px, 1fr));
-  gap: 0.75rem;
-  margin-bottom: 2rem;
-}
-.plant {
-  position: relative;
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: 0.3rem;
-  padding: 1rem 0.75rem;
-  border: 1px solid var(--border, #2a2f45);
-  border-radius: 10px;
-  text-decoration: none;
-  color: inherit;
-  background: color-mix(in srgb, var(--success, #9ece6a) 6%, transparent);
-}
-.plant > i {
-  font-size: 1.9rem;
-  color: var(--success, #9ece6a);
-}
-/* редкие растения: золото + бейдж редкости, эпик — ещё и свечение */
-.plant.rare > i {
-  color: #d4a017;
-}
-.plant.epic > i {
-  color: #d4a017;
-  text-shadow:
-    0 0 8px color-mix(in srgb, #f1c40f 70%, transparent),
-    0 0 18px color-mix(in srgb, #f1c40f 40%, transparent);
-}
-.rarity-badge {
-  position: absolute;
-  top: 0.4rem;
-  right: 0.4rem;
-  font-size: 0.9rem;
-  color: #d4a017;
-  line-height: 1;
-}
-.plant-title {
-  font-size: 0.85em;
-  font-weight: 600;
-  text-align: center;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  display: -webkit-box;
-  -webkit-line-clamp: 2;
-  -webkit-box-orient: vertical;
-}
-.plant-date {
-  font-size: 0.75em;
-  color: var(--text-muted, #888);
-}
-.plant:hover {
-  border-color: var(--success, #9ece6a);
-}
 /* ачивки */
 .achievements-title {
   display: flex;