Add Rules & Expectations feature with TV overlay and dashboard layout updates

- Add Rules & Expectations admin section with drag-to-reorder, add/edit/delete
- Add Overlays card to Dashboard with Rules/Expectations toggle button (LIVE badge when active)
- Add full-screen rules overlay on TV view (green theme, numbered list, tap to dismiss)
- Backend: new RuleItem model, /api/rules CRUD + bulk reorder, /api/overlays WS broadcast endpoints
- Schedule store handles show_rules / hide_rules WebSocket events
- Rearrange Dashboard top row: TV Dashboard | 3 Strikes | Overlays (3-col, mobile stacks)
- Put Today's Session and Today's Schedule side-by-side at 50/50 width (mobile stacks)
- Update README with all new features, setup steps, WS events, and project structure

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

backend/app/main.py

@@ -14,7 +14,7 @@ from app.models.child import Child
 from app.models.subject import Subject
 from app.models.user import User
 from app.routers import auth, users, children, subjects, schedules, sessions, logs, dashboard
-from app.routers import morning_routine, break_activity, admin
+from app.routers import morning_routine, break_activity, admin, rules, overlays
 from app.websocket.manager import manager
 
 settings = get_settings()
@@ -113,6 +113,8 @@ app.include_router(morning_routine.router)
 app.include_router(break_activity.router)
 app.include_router(dashboard.router)
 app.include_router(admin.router)
+app.include_router(rules.router)
+app.include_router(overlays.router)
 
 
 @app.get("/api/health")

backend/app/models/__init__.py

@@ -9,6 +9,7 @@ from app.models.activity import ActivityLog
 from app.models.morning_routine import MorningRoutineItem
 from app.models.break_activity import BreakActivityItem
 from app.models.strike import StrikeEvent
+from app.models.rule import RuleItem
 
 __all__ = [
     "Base",
@@ -26,4 +27,5 @@ __all__ = [
     "MorningRoutineItem",
     "BreakActivityItem",
     "StrikeEvent",
+    "RuleItem",
 ]

backend/app/models/rule.py

@@ -0,0 +1,15 @@
+from sqlalchemy import ForeignKey, Integer, Text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.models.base import Base
+
+
+class RuleItem(Base):
+    __tablename__ = "rule_items"
+
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    user_id: Mapped[int] = mapped_column(ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
+    text: Mapped[str] = mapped_column(Text, nullable=False)
+    order_index: Mapped[int] = mapped_column(Integer, default=0)
+
+    user: Mapped["User"] = relationship("User")  # noqa: F821

backend/app/routers/overlays.py

@@ -0,0 +1,56 @@
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from app.dependencies import get_db, get_current_user
+from app.models.child import Child
+from app.models.rule import RuleItem
+from app.models.user import User
+from app.websocket.manager import manager
+
+router = APIRouter(prefix="/api/overlays", tags=["overlays"])
+
+
+class ChildTarget(BaseModel):
+    child_id: int
+
+
+async def _verify_child(child_id: int, user: User, db: AsyncSession) -> Child:
+    result = await db.execute(
+        select(Child).where(Child.id == child_id, Child.user_id == user.id)
+    )
+    child = result.scalar_one_or_none()
+    if not child:
+        raise HTTPException(status_code=404, detail="Child not found")
+    return child
+
+
+@router.post("/rules/show")
+async def show_rules_overlay(
+    body: ChildTarget,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    child = await _verify_child(body.child_id, current_user, db)
+
+    rules_result = await db.execute(
+        select(RuleItem)
+        .where(RuleItem.user_id == current_user.id)
+        .order_by(RuleItem.order_index, RuleItem.id)
+    )
+    rules = [item.text for item in rules_result.scalars().all()]
+
+    await manager.broadcast(child.id, {"event": "show_rules", "rules": rules})
+    return {"ok": True}
+
+
+@router.post("/rules/hide")
+async def hide_rules_overlay(
+    body: ChildTarget,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    child = await _verify_child(body.child_id, current_user, db)
+    await manager.broadcast(child.id, {"event": "hide_rules"})
+    return {"ok": True}

backend/app/routers/rules.py

@@ -0,0 +1,122 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from app.dependencies import get_db, get_current_user
+from app.models.rule import RuleItem
+from app.models.user import User
+
+router = APIRouter(prefix="/api/rules", tags=["rules"])
+
+
+class RuleItemOut(BaseModel):
+    id: int
+    text: str
+    order_index: int
+    model_config = {"from_attributes": True}
+
+
+class RuleItemCreate(BaseModel):
+    text: str
+    order_index: int = 0
+
+
+class RuleItemUpdate(BaseModel):
+    text: str | None = None
+    order_index: int | None = None
+
+
+class ReorderEntry(BaseModel):
+    id: int
+    order_index: int
+
+
+@router.get("", response_model=list[RuleItemOut])
+async def list_rules(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    result = await db.execute(
+        select(RuleItem)
+        .where(RuleItem.user_id == current_user.id)
+        .order_by(RuleItem.order_index, RuleItem.id)
+    )
+    return result.scalars().all()
+
+
+@router.post("", response_model=RuleItemOut, status_code=status.HTTP_201_CREATED)
+async def create_rule(
+    body: RuleItemCreate,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    item = RuleItem(user_id=current_user.id, text=body.text, order_index=body.order_index)
+    db.add(item)
+    await db.commit()
+    await db.refresh(item)
+    return item
+
+
+@router.patch("/{item_id}", response_model=RuleItemOut)
+async def update_rule(
+    item_id: int,
+    body: RuleItemUpdate,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    result = await db.execute(
+        select(RuleItem).where(
+            RuleItem.id == item_id,
+            RuleItem.user_id == current_user.id,
+        )
+    )
+    item = result.scalar_one_or_none()
+    if not item:
+        raise HTTPException(status_code=404, detail="Rule not found")
+    if body.text is not None:
+        item.text = body.text
+    if body.order_index is not None:
+        item.order_index = body.order_index
+    await db.commit()
+    await db.refresh(item)
+    return item
+
+
+@router.put("/reorder", status_code=status.HTTP_204_NO_CONTENT)
+async def reorder_rules(
+    body: list[ReorderEntry],
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    ids = [e.id for e in body]
+    result = await db.execute(
+        select(RuleItem).where(
+            RuleItem.id.in_(ids),
+            RuleItem.user_id == current_user.id,
+        )
+    )
+    items = {item.id: item for item in result.scalars().all()}
+    for entry in body:
+        if entry.id in items:
+            items[entry.id].order_index = entry.order_index
+    await db.commit()
+
+
+@router.delete("/{item_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_rule(
+    item_id: int,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    result = await db.execute(
+        select(RuleItem).where(
+            RuleItem.id == item_id,
+            RuleItem.user_id == current_user.id,
+        )
+    )
+    item = result.scalar_one_or_none()
+    if not item:
+        raise HTTPException(status_code=404, detail="Rule not found")
+    await db.delete(item)
+    await db.commit()