feat: idle cash alert and category hierarchy (subcategories)

Two of the four ideas picked from the Maybe/Sure feature audit:

- Idle cash: a 5th proactive alert flags a depository account (checking/
  savings/cash) sitting at or above a configurable balance with no
  transaction touching it for a configurable number of days.
- Category hierarchy: categories can now have one level of subcategories
  (Groceries -> Alcohol). Dashboard/report aggregations roll a
  subcategory's spending into its parent's slice.

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

backend/app/services/insights_service.py

@@ -1,20 +1,26 @@
 """Proactive early-warning checks, computed from data that already exists.
-Four signals: sustained negative monthly cash flow, a sustained net-worth
-decline, one or more over-budget categories, and too much capital in
-medium/high risk tiers (the "80% at zero risk, 20% at most exposed" rule).
-The first two only look at fully-elapsed calendar months, so a same-month
-false alarm (rent already paid, salary not landed yet) never fires — their
-"sustained for how long" thresholds, and the risk-allocation percentage, are
+Five signals: sustained negative monthly cash flow, a sustained net-worth
+decline, one or more over-budget categories, too much capital in medium/high
+risk tiers (the "80% at zero risk, 20% at most exposed" rule), and cash
+sitting idle in a depository account. The first two only look at
+fully-elapsed calendar months, so a same-month false alarm (rent already
+paid, salary not landed yet) never fires — their "sustained for how long"
+thresholds, the risk-allocation percentage, and the idle-cash amount/days are
 all user-configurable (Settings page), stored on AppSettings, see
 get_or_create_app_settings. The budget check is the opposite: it deliberately
 looks at the CURRENT, still-in-progress month, since the whole point is to
 catch overspending while there's still time to react.
 """
-from datetime import date
+from collections import defaultdict
+from datetime import date, timedelta
 from decimal import Decimal
 
+from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.models.account import Account
+from app.models.enums import AccountType, TransactionType
+from app.models.transaction import Transaction
 from app.schemas.insights import AlertsResponse, FinancialAlert
 from app.schemas.net_worth import NetWorthSummary
 from app.services.budget_service import get_budget_status
@@ -24,6 +30,11 @@ from app.services.settings_service import get_or_create_app_settings
 
 MAX_LOOKBACK_MONTHS = 24
 
+# Accounts where a big, untouched balance means money isn't working — a
+# credit card balance isn't "your cash", an investment account is already
+# invested, and OTHER is too ambiguous to guess at.
+_IDLE_CASH_ACCOUNT_TYPES = (AccountType.CHECKING, AccountType.SAVINGS, AccountType.CASH)
+
 
 def _previous_month(year: int, month: int) -> tuple[int, int]:
     return (year - 1, 12) if month == 1 else (year, month - 1)
@@ -68,6 +79,55 @@ def _net_worth_decline_streak(summary: NetWorthSummary) -> int:
     return streak
 
 
+async def _idle_cash_account_count(session: AsyncSession, threshold_amount: Decimal, threshold_days: int) -> int:
+    eligible_ids = set(
+        (
+            await session.execute(
+                select(Account.id).where(
+                    Account.is_archived.is_(False), Account.type.in_(_IDLE_CASH_ACCOUNT_TYPES)
+                )
+            )
+        )
+        .scalars()
+        .all()
+    )
+    if not eligible_ids:
+        return 0
+
+    # Same derivation account_service._account_balances uses — balance is
+    # never stored, only ever summed from the full transaction history — plus
+    # tracking the most recent date that touched each account along the way.
+    rows = await session.execute(
+        select(Transaction.type, Transaction.amount, Transaction.account_id, Transaction.transfer_account_id, Transaction.date)
+    )
+    balances: dict[int, Decimal] = defaultdict(Decimal)
+    last_activity: dict[int, date] = {}
+
+    def touch(account_id: int | None, tx_date: date) -> None:
+        if account_id in eligible_ids and (account_id not in last_activity or tx_date > last_activity[account_id]):
+            last_activity[account_id] = tx_date
+
+    for tx_type, amount, account_id, transfer_account_id, tx_date in rows.all():
+        if tx_type == TransactionType.INCOME:
+            balances[account_id] += amount
+        elif tx_type == TransactionType.EXPENSE:
+            balances[account_id] -= amount
+        elif tx_type == TransactionType.TRANSFER:
+            balances[account_id] -= amount
+            if transfer_account_id is not None:
+                balances[transfer_account_id] += amount
+        touch(account_id, tx_date)
+        touch(transfer_account_id, tx_date)
+
+    cutoff = date.today() - timedelta(days=threshold_days)
+    return sum(
+        1
+        for account_id in eligible_ids
+        if balances.get(account_id, Decimal("0")) >= threshold_amount
+        and last_activity.get(account_id, cutoff) <= cutoff
+    )
+
+
 async def get_financial_alerts(session: AsyncSession) -> AlertsResponse:
     settings = await get_or_create_app_settings(session)
     alerts: list[FinancialAlert] = []
@@ -116,4 +176,16 @@ async def get_financial_alerts(session: AsyncSession) -> AlertsResponse:
             )
         )
 
+    idle_cash_count = await _idle_cash_account_count(
+        session, settings.idle_cash_threshold_amount, settings.idle_cash_threshold_days
+    )
+    if idle_cash_count > 0:
+        alerts.append(
+            FinancialAlert(
+                key="idle_cash",
+                severity="warning",
+                params={"count": idle_cash_count, "days": settings.idle_cash_threshold_days},
+            )
+        )
+
     return AlertsResponse(alerts=alerts)