updatedTrailmode

app.py

@@ -526,17 +526,16 @@ def calendar_export(
 async def trial_chat_stream(request: Request):
     body = await request.json()
     message = body.get("message", "")
-    access_token = body.get("access_token", "")
     
     if not message:
         return {"error": "No message provided"}
     
     trial_user_id = f"trial-{request.client.host}"
     
-    financial_context = "NO_BANK_DATA"
-    if access_token:
-        financial_context = get_cached_financial_context(access_token, trial_user_id)
-    
+    # Trial mode: load fixture data directly
+    from plaid_client import get_snapshot_from_fixtures
+    financial_context = get_snapshot_from_fixtures()
+
     def generate():
         for token in stream_answer(message, trial_user_id, financial_context=financial_context):
             yield f"data: {json.dumps({'chunk': token})}\n\n"
@@ -553,39 +552,22 @@ async def trial_reset(request: Request):
 
 @app.post("/trial/plaid/create_link_token")
 async def trial_create_link_token(request: Request):
-    trial_user_id = f"trial-{request.client.host}"
-    from plaid_client import create_link_token
-    token = create_link_token(trial_user_id)
-    return {"link_token": token}
+    # Beta mode: no real Plaid link needed
+    return {"link_token": "trial-mock-link-token"}
 
 @app.post("/trial/plaid/exchange_token")
 async def trial_exchange_token(request: Request):
-    body = await request.json()
-    public_token = body.get("public_token", "")
-    
-    from plaid_client import plaid_client
-    from plaid.model.item_public_token_exchange_request import ItemPublicTokenExchangeRequest
-    
-    exchange_req = ItemPublicTokenExchangeRequest(public_token=public_token)
-    exchange_resp = plaid_client.item_public_token_exchange(exchange_req)
-    
-    return {"access_token": exchange_resp['access_token']}
+    # Beta mode: return mock token immediately
+    return {"access_token": "trial-mock-access-token"}
 
 
 @app.post("/trial/plaid/chart_data")
 async def trial_chart_data(request: Request):
-    body = await request.json()
-    access_token = body.get("access_token", "")
-    if not access_token:
-        return {"error": "No access token"}
-    from plaid_client import get_chart_data
-    return get_chart_data(access_token)
+    from plaid_client import get_chart_data_from_fixtures
+    return get_chart_data_from_fixtures()
+
 
 @app.post("/trial/plaid/recurring")
 async def trial_recurring(request: Request):
-    body = await request.json()
-    access_token = body.get("access_token", "")
-    if not access_token:
-        return {"error": "No access token"}
-    from plaid_client import get_recurring_transactions
-    return get_recurring_transactions(access_token)
+    from plaid_client import get_recurring_from_fixtures
+    return get_recurring_from_fixtures()

fixtures/raw_balances.json

@@ -0,0 +1,174 @@
+{
+  "accounts": [
+    {
+      "account_id": "a5QNQ0qoeOfMoQX5NP7wuwyzDnrQ9bi7aLkd9",
+      "balances": {
+        "available": 521.23,
+        "current": 23.23,
+        "limit": 500.0,
+        "iso_currency_code": "CAD",
+        "unofficial_currency_code": null
+      },
+      "mask": "0436",
+      "name": "RBC Advantage Banking",
+      "official_name": "RBC Advantage Banking",
+      "type": "depository",
+      "subtype": "checking"
+    },
+    {
+      "account_id": "xKZ8ZPNEzbH1Q7L0AYJ9uNde8n3PKoHOjN0DA",
+      "balances": {
+        "available": 722.07,
+        "current": 722.07,
+        "limit": 0.0,
+        "iso_currency_code": "CAD",
+        "unofficial_currency_code": null
+      },
+      "mask": "0707",
+      "name": "RBC Day to Day Savings",
+      "official_name": "RBC Day to Day Savings",
+      "type": "depository",
+      "subtype": "savings"
+    },
+    {
+      "account_id": "r1BjBd0RzbIr184AqmwzhxAbMoLNr3FVAx4yr",
+      "balances": {
+        "available": 0.0,
+        "current": 0.0,
+        "limit": 12000.0,
+        "iso_currency_code": "CAD",
+        "unofficial_currency_code": null
+      },
+      "mask": "0958",
+      "name": "RBC Business Cash Back Mastercard",
+      "official_name": "RBC Business Cash Back Mastercard",
+      "type": "credit",
+      "subtype": "credit card"
+    },
+    {
+      "account_id": "o6aAaXgkzNfvZOykDJbYudj8N3bAaXF4kYexL",
+      "balances": {
+        "available": 497679.49,
+        "current": 497679.49,
+        "limit": null,
+        "iso_currency_code": "CAD",
+        "unofficial_currency_code": null
+      },
+      "mask": "1001",
+      "name": "Mortgage Loan - Conventional",
+      "official_name": "Mortgage Loan - Conventional",
+      "type": "loan",
+      "subtype": "mortgage"
+    },
+    {
+      "account_id": "JXZjZB54opf3NykZKOzpuMe4yRAK8YSmQrZOQ",
+      "balances": {
+        "available": 0.1,
+        "current": 0.1,
+        "limit": 0.0,
+        "iso_currency_code": "CAD",
+        "unofficial_currency_code": null
+      },
+      "mask": "2769",
+      "name": "RBC High Interest eSavings",
+      "official_name": "RBC High Interest eSavings",
+      "type": "depository",
+      "subtype": "savings"
+    },
+    {
+      "account_id": "4VgRge5ZLXI89KO1jaJgUwDQOJ7yK5iREy5Yn",
+      "balances": {
+        "available": 1360.62,
+        "current": 1360.62,
+        "limit": 17000.0,
+        "iso_currency_code": "CAD",
+        "unofficial_currency_code": null
+      },
+      "mask": "2861",
+      "name": "Signature RBC Rewards Visa",
+      "official_name": "Signature RBC Rewards Visa",
+      "type": "credit",
+      "subtype": "credit card"
+    },
+    {
+      "account_id": "Z5rMrmdQNOfoEqrmkbPyuyE3Jz9dV8ib9NBAj",
+      "balances": {
+        "available": 19941.38,
+        "current": 19941.38,
+        "limit": null,
+        "iso_currency_code": "CAD",
+        "unofficial_currency_code": null
+      },
+      "mask": "3001",
+      "name": "Credit Line",
+      "official_name": "Credit Line",
+      "type": "loan",
+      "subtype": "line of credit"
+    },
+    {
+      "account_id": "8VzXz56nqeIm9w137BAQhjgyzRKrOnIxKNeLZ",
+      "balances": {
+        "available": 1335.36,
+        "current": 1335.36,
+        "limit": null,
+        "iso_currency_code": "CAD",
+        "unofficial_currency_code": null
+      },
+      "mask": "5601",
+      "name": "RRSP",
+      "official_name": "RRSP",
+      "type": "investment",
+      "subtype": "rrsp"
+    },
+    {
+      "account_id": "bgPdPRBjNptEv4r5xKn9uEXMQj3pgLSJdBybL",
+      "balances": {
+        "available": null,
+        "current": null,
+        "limit": null,
+        "iso_currency_code": "CAD",
+        "unofficial_currency_code": null
+      },
+      "mask": "7001",
+      "name": "RBC Homeline Plan",
+      "official_name": "RBC Homeline Plan",
+      "type": "loan",
+      "subtype": "mortgage"
+    },
+    {
+      "account_id": "5zgQgO7NDXIZDkKP6anju41Rvgqe75IwdePXA",
+      "balances": {
+        "available": 0.0,
+        "current": 0.0,
+        "limit": null,
+        "iso_currency_code": "CAD",
+        "unofficial_currency_code": null
+      },
+      "mask": "9001",
+      "name": "Credit Line",
+      "official_name": "Credit Line",
+      "type": "loan",
+      "subtype": "line of credit"
+    }
+  ],
+  "item": {
+    "item_id": "mdmKm7y8zNHybA8R6wxZuZYqgZnRe6CrQBwKz",
+    "webhook": "",
+    "error": null,
+    "available_products": [
+      "balance",
+      "signal"
+    ],
+    "billed_products": [
+      "transactions"
+    ],
+    "consent_expiration_time": null,
+    "update_type": "background",
+    "institution_id": "ins_39",
+    "institution_name": "RBC Royal Bank",
+    "products": [
+      "transactions"
+    ]
+  },
+  "request_id": "fe94ae6702db125"
+}

plaid_client.py

@@ -1,5 +1,22 @@
+"""
+plaid_client.py — real Plaid + fixture fallback for trial mode
+
+Real endpoints (get_financial_snapshot, get_chart_data, get_recurring_transactions)
+hit real Plaid. Trial-mode variants (get_snapshot_from_fixtures, etc.) load from 
+fixtures/raw_balances.json and fixtures/raw_transactions.json.
+
+Called from app.py:
+- Signed-in users → get_financial_snapshot / get_chart_data / get_recurring_transactions
+- Trial users → get_snapshot_from_fixtures / get_chart_data_from_fixtures / get_recurring_from_fixtures
+"""
+
 import os
+import json
 from datetime import date, timedelta
+from pathlib import Path
+from collections import defaultdict
+import re
+
 from plaid.api import plaid_api
 from plaid.configuration import Configuration
 from plaid.api_client import ApiClient
@@ -12,9 +29,7 @@ from plaid.model.transactions_get_request_options import TransactionsGetRequestO
 from plaid.model.link_token_create_request import LinkTokenCreateRequest
 from plaid.model.link_token_create_request_user import LinkTokenCreateRequestUser
 from plaid.model.item_public_token_exchange_request import ItemPublicTokenExchangeRequest
-from collections import defaultdict
-from datetime import date, timedelta
-import re
+
 
 # ---------- Client setup ----------
 
@@ -25,12 +40,11 @@ def _make_client():
         "development": "https://development.plaid.com",
         "production":  "https://production.plaid.com",
     }[env]
-
     config = Configuration(
         host=host,
         api_key={
-        "clientId": os.environ["PLAID_CLIENT_ID"],   # reads from .env
-        "secret":   os.environ["PLAID_SECRET"]
+            "clientId": os.environ["PLAID_CLIENT_ID"],
+            "secret":   os.environ["PLAID_SECRET"]
         }
     )
     return plaid_api.PlaidApi(ApiClient(config))
@@ -38,12 +52,33 @@ def _make_client():
 plaid_client = _make_client()
 
 
-# ---------- Balances ----------
+# ---------- Fixture loading (trial mode only) ----------
+
+FIXTURES_DIR = Path(__file__).parent / "fixtures"
+
+def _load_raw_balances():
+    path = FIXTURES_DIR / "raw_balances.json"
+    if not path.exists():
+        raise FileNotFoundError(f"Fixture not found: {path}")
+    return json.loads(path.read_text())
+
+def _load_raw_transactions():
+    path = FIXTURES_DIR / "raw_transactions.json"
+    if not path.exists():
+        raise FileNotFoundError(f"Fixture not found: {path}")
+    return json.loads(path.read_text())
+
+
+# ---------- REAL: Balances ----------
 
 def get_balances(access_token: str) -> str:
     request = AccountsBalanceGetRequest(access_token=access_token)
     response = plaid_client.accounts_balance_get(request)
+    return _format_balances(response)
 
+
+def _format_balances(response) -> str:
+    """Shared formatter used by both real and fixture paths."""
     lines = ["USER'S CURRENT ACCOUNT BALANCES:"]
     for account in response['accounts']:
         name    = account['name']
@@ -52,8 +87,6 @@ def get_balances(access_token: str) -> str:
 
         if current is None:
             continue
-
-        # Skip mortgage and line of credit — not relevant for daily budgeting
         if subtype in ['mortgage', 'line of credit']:
             continue
 
@@ -76,38 +109,13 @@ def get_balances(access_token: str) -> str:
             lines.append(f"- {name} ({subtype}): ${current:.2f}")
 
     return "\n".join(lines)
-    request = AccountsBalanceGetRequest(access_token=access_token)
-    response = plaid_client.accounts_balance_get(request)
 
-    lines = ["USER'S CURRENT ACCOUNT BALANCES:"]
-    for account in response['accounts']:
-        name    = account['name']
-        subtype = account['subtype']
-        current = account['balances']['current']
-
-        if current is None:
-            continue
-
-        if subtype == 'credit card':
-            limit     = account['balances']['limit'] or 0
-            available = account['balances']['available'] or (limit - current)
-            lines.append(
-                f"- {name} (Credit Card): "
-                f"${current:.2f} owing, ${available:.2f} available"
-            )
-        elif subtype in ['mortgage', 'line of credit']:
-            lines.append(f"- {name} ({subtype}): ${current:.2f} outstanding")
-        else:
-            lines.append(f"- {name} ({subtype}): ${current:.2f}")
-
-    return "\n".join(lines)
 
-# ---------- Transactions ----------
+# ---------- REAL: Transactions ----------
 
 def get_transactions(access_token: str, days: int = 30) -> str:
     end_date = date.today()
     start_date = end_date - timedelta(days=days)
-    week_start = end_date - timedelta(days=end_date.weekday())
 
     request = TransactionsGetRequest(
         access_token=access_token,
@@ -119,7 +127,13 @@ def get_transactions(access_token: str, days: int = 30) -> str:
         )
     )
     response = plaid_client.transactions_get(request)
-    transactions = response['transactions']
+    return _format_transactions(response['transactions'], days)
+
+
+def _format_transactions(transactions, days: int = 30) -> str:
+    """Shared formatter used by both real and fixture paths."""
+    end_date = date.today()
+    week_start = end_date - timedelta(days=end_date.weekday())
 
     if not transactions:
         return "No transactions found in the last 30 days."
@@ -133,29 +147,28 @@ def get_transactions(access_token: str, days: int = 30) -> str:
     for txn in transactions:
         amount = txn['amount']
         name = txn['name']
-        txn_date = txn['date']
+        txn_date_val = txn['date']
+        if isinstance(txn_date_val, str):
+            txn_date = date.fromisoformat(txn_date_val)
+        else:
+            txn_date = txn_date_val
         category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
 
-        # Skip internal transfers between own accounts
         if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
             continue
 
-        # Detect payroll mislabeled as loan payments
         name_lower = name.lower()
         if category == 'LOAN_PAYMENTS' and any(w in name_lower for w in ['payroll', 'salary', 'direct dep', 'employer', 'wages']):
             income_total += amount
             continue
 
-        # Skip other loan payments (mortgage, LOC) — not daily spending
         if category == 'LOAN_PAYMENTS':
             continue
 
-        # Income (negative = money in)
         if amount < 0:
             income_total += abs(amount)
             continue
 
-        # Spending
         month_total += amount
         readable = category.replace("_", " ").title()
         category_totals[readable] = category_totals.get(readable, 0) + amount
@@ -194,95 +207,9 @@ def get_transactions(access_token: str, days: int = 30) -> str:
         count += 1
 
     return "\n".join(lines)
-    end_date = date.today()
-    start_date = end_date - timedelta(days=days)
-    week_start = end_date - timedelta(days=end_date.weekday())
 
-    request = TransactionsGetRequest(
-        access_token=access_token,
-        start_date=start_date,
-        end_date=end_date,
-        options=TransactionsGetRequestOptions(
-            count=100,
-            include_personal_finance_category=True
-        )
-    )
-    response = plaid_client.transactions_get(request)
-    transactions = response['transactions']
-
-    if not transactions:
-        return "No transactions found in the last 30 days."
 
-    # Pre-calculate everything — never let LLM do math
-    today_total = 0.0
-    week_total = 0.0
-    month_total = 0.0
-    income_total = 0.0
-    category_totals: dict[str, float] = {}
-    today_transactions: list[str] = []
-    week_transactions: list[str] = []
-
-    for txn in transactions:
-        amount = txn['amount']
-        name = txn['name']
-        txn_date = txn['date']
-        category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-
-        # Income (negative = money in)
-        if amount < 0:
-            income_total += abs(amount)
-            continue
-
-        # Skip internal transfers
-        if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
-            continue
-
-        name_lower = name.lower()
-        if category == 'LOAN_PAYMENTS' and any(w in name_lower for w in ['payroll', 'salary', 'direct dep', 'employer', 'wages']):
-            income_total += amount
-            continue
-
-        # Spending totals by time period
-        month_total += amount
-        category_totals[category] = category_totals.get(category, 0) + amount
-
-        if txn_date >= week_start:
-            week_total += amount
-            week_transactions.append(f"  - {txn_date} {name}: ${amount:.2f}")
-
-        if txn_date == end_date:
-            today_total += amount
-            today_transactions.append(f"  - {name}: ${amount:.2f}")
-
-    # Build compact summary — no raw transaction dumps
-    lines = ["FINANCIAL SUMMARY (pre-calculated, do NOT recalculate):"]
-    lines.append(f"Today's spending: ${today_total:.2f}")
-    lines.append(f"This week's spending (since {week_start}): ${week_total:.2f}")
-    lines.append(f"This month's spending (last {days} days): ${month_total:.2f}")
-    
-    if income_total > 0:
-        lines.append(f"Income received (last {days} days): +${income_total:.2f}")
-
-    lines.append(f"Average daily spending: ${month_total / max(days, 1):.2f}")
-
-    lines.append("\nSPENDING BY CATEGORY:")
-    for category, total in sorted(category_totals.items(), key=lambda x: -x[1]):
-        readable = category.replace("_", " ").title()
-        pct = (total / month_total * 100) if month_total > 0 else 0
-        lines.append(f"- {readable}: ${total:.2f} ({pct:.0f}%)")
-
-    # Only include recent transactions, limited to 5
-    lines.append("\nRECENT TRANSACTIONS (last 5):")
-    for txn in transactions[:5]:
-        amount = txn['amount']
-        if amount <= 0:
-            continue
-        prefix = "-"
-        lines.append(f"  {prefix} {txn['date']} {txn['name']}: ${abs(amount):.2f}")
-
-    return "\n".join(lines)
-
-# ---------- Combined snapshot ----------
+# ---------- REAL: Combined snapshot ----------
 
 def get_financial_snapshot(access_token: str) -> str:
     try:
@@ -296,7 +223,8 @@ def get_financial_snapshot(access_token: str) -> str:
             return "BANK_REAUTH_REQUIRED"
         return "NO_BANK_DATA"
 
-# ---------- Update Mode Link Token ----------
+
+# ---------- REAL: Link tokens ----------
 
 def create_update_link_token(user_id: str, access_token: str) -> str:
     request = LinkTokenCreateRequest(
@@ -305,11 +233,12 @@ def create_update_link_token(user_id: str, access_token: str) -> str:
         country_codes=[CountryCode("CA")],
         language="en",
         access_token=access_token,
-        redirect_uri="https://chequeup.ca",   # ← add this
+        redirect_uri="https://chequeup.ca",
     )
     response = plaid_client.link_token_create(request)
     return response["link_token"]
 
+
 def create_link_token(user_id: str) -> str:
     request = LinkTokenCreateRequest(
         user=LinkTokenCreateRequestUser(client_user_id=user_id),
@@ -323,443 +252,135 @@ def create_link_token(user_id: str) -> str:
     return response["link_token"]
 
 
-
 def exchange_public_token(public_token: str) -> str:
-    """Exchanges a public token for a permanent access token."""
     request = ItemPublicTokenExchangeRequest(public_token=public_token)
     response = plaid_client.item_public_token_exchange(request)
     return response["access_token"]
 
 
+# ---------- REAL: Chart data ----------
+
 def get_chart_data(access_token: str) -> dict:
     """Returns burn-down velocity chart data based on chequing account."""
     end_date = date.today()
     start_date = end_date.replace(day=1)
 
-    # Get balances
-    accounts = []
-    chequing_balance = 0.0
-    chequing_account_id = None
-
     try:
         balance_req = AccountsBalanceGetRequest(access_token=access_token)
         balance_resp = plaid_client.accounts_balance_get(balance_req)
-        for account in balance_resp['accounts']:
-            current = account['balances']['current']
-            if current is None:
-                continue
-            subtype = str(account['subtype'])
-            
-            # Find the main chequing account
-            if subtype == 'checking':
-                chequing_balance = current
-                chequing_account_id = account['account_id']
-
-            # Skip mortgage and line of credit from display
-            if subtype in ['mortgage', 'line of credit']:
-                continue
-
-            accounts.append({
-                "name": account['name'],
-                "type": subtype,
-                "balance": round(current, 2),
-            })
+        balance_data = balance_resp
     except Exception as e:
         print(f"Balance error in chart_data: {e}", flush=True)
-
-    # Get transactions
-    burndown = []
-    income_total = 0.0
-    expense_total = 0.0
+        balance_data = {'accounts': []}
 
     try:
         request = TransactionsGetRequest(
             access_token=access_token,
             start_date=start_date,
             end_date=end_date,
-            options=TransactionsGetRequestOptions(
-                count=300,
-                include_personal_finance_category=True
-            )
+            options=TransactionsGetRequestOptions(count=300, include_personal_finance_category=True)
         )
         response = plaid_client.transactions_get(request)
         transactions = response['transactions']
-
-        # Separate spending by day across chequing + credit cards
-        daily_net: dict[str, float] = {}
-
-        for txn in transactions:
-            amount = txn['amount']
-            txn_date = str(txn['date'])
-            category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-
-            # Skip internal transfers between own accounts
-            if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
-                continue
-
-            # Skip loan payments that are actually payroll
-            name_lower = txn['name'].lower()
-            if category == 'LOAN_PAYMENTS' and any(w in name_lower for w in ['payroll', 'salary', 'direct dep', 'employer', 'wages']):
-                income_total += amount
-                daily_net[txn_date] = daily_net.get(txn_date, 0) - amount  # income adds to balance
-                continue
-
-            if amount < 0:
-                # Money coming in (income)
-                income_total += abs(amount)
-                daily_net[txn_date] = daily_net.get(txn_date, 0) + abs(amount)  # adds to balance
-            else:
-                # Money going out (spending)
-                expense_total += amount
-                daily_net[txn_date] = daily_net.get(txn_date, 0) - amount  # subtracts from balance
-
-        # Reconstruct daily balance working BACKWARD from today's chequing balance
-        # today_balance = chequing_balance
-        # yesterday_balance = today_balance - net_change_today
-        # (because net_change is already applied to get to today's balance)
-        
-        daily_balances: dict[str, float] = {}
-        running = chequing_balance
-        
-        # Work backward from today
-        current = end_date
-        while current >= start_date:
-            day_str = str(current)
-            daily_balances[day_str] = running
-            # Undo this day's net change to get previous day's balance
-            net_today = daily_net.get(day_str, 0)
-            running = running - net_today  # undo: if we spent $50 (net=-50), previous day was +50 higher
-            current -= timedelta(days=1)
-
-        # Now build burndown in forward order
-        current = start_date
-        while current <= end_date:
-            day_str = str(current)
-            balance = daily_balances.get(day_str, 0)
-            day_spend = 0
-            
-            # Calculate just spending for this day (not net)
-            for txn in transactions:
-                if str(txn['date']) == day_str and txn['amount'] > 0:
-                    cat = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-                    if cat not in ['TRANSFER_IN', 'TRANSFER_OUT']:
-                        day_spend += txn['amount']
-
-            burndown.append({
-                "date": current.strftime("%b %d"),
-                "balance": round(balance, 2),
-                "spent": round(day_spend, 2),
-            })
-            current += timedelta(days=1)
-
     except Exception as e:
         print(f"Transaction error in chart_data: {e}", flush=True)
+        transactions = []
 
-    return {
-        "burndown": burndown,
-        "income_total": round(income_total, 2),
-        "expense_total": round(expense_total, 2),
-        "accounts": accounts,
-    }
-    """Returns burn-down velocity chart data."""
-    end_date = date.today()
-    start_date = end_date.replace(day=1)  # Start of current month
-
-    # Get balances
-    accounts = []
-    try:
-        balance_req = AccountsBalanceGetRequest(access_token=access_token)
-        balance_resp = plaid_client.accounts_balance_get(balance_req)
-        for account in balance_resp['accounts']:
-            current = account['balances']['current']
-            if current is None:
-                continue
-            accounts.append({
-                "name": account['name'],
-                "type": str(account['subtype']),
-                "balance": round(current, 2),
-            })
-    except Exception as e:
-        print(f"Balance error in chart_data: {e}", flush=True)
-
-    # Get transactions for current month
-    burndown = []
-    income_total = 0.0
-    expense_total = 0.0
-
-    try:
-        request = TransactionsGetRequest(
-            access_token=access_token,
-            start_date=start_date,
-            end_date=end_date,
-            options=TransactionsGetRequestOptions(
-                count=200,
-                include_personal_finance_category=True
-            )
-        )
-        response = plaid_client.transactions_get(request)
-        transactions = response['transactions']
-
-        # Build daily income and spending
-        daily_income: dict[str, float] = {}
-        daily_spending: dict[str, float] = {}
-
-        for txn in transactions:
-            amount = txn['amount']
-            txn_date = str(txn['date'])
-            category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-
-            if amount < 0:
-                income_total += abs(amount)
-                daily_income[txn_date] = daily_income.get(txn_date, 0) + abs(amount)
-                continue
-
-            if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
-                continue
+    return _build_chart_data(balance_data, transactions, start_date, end_date)
 
-            name_lower = txn['name'].lower()
-            if category == 'LOAN_PAYMENTS' and any(w in name_lower for w in ['payroll', 'salary', 'direct dep', 'employer', 'wages']):
-                income_total += amount
-                daily_income[txn_date] = daily_income.get(txn_date, 0) + amount
-                continue
-
-            expense_total += amount
-            daily_spending[txn_date] = daily_spending.get(txn_date, 0) + amount
-
-        # Build burn-down: start with total income, subtract spending each day
-        running_balance = income_total
-        current = start_date
-        while current <= end_date:
-            day_str = str(current)
-            day_spend = daily_spending.get(day_str, 0)
-            day_income = daily_income.get(day_str, 0)
-            running_balance = running_balance - day_spend + (day_income if current != start_date else 0)
-
-            burndown.append({
-                "date": current.strftime("%b %d"),
-                "balance": round(running_balance, 2),
-                "spent": round(day_spend, 2),
-            })
-            current += timedelta(days=1)
 
-    except Exception as e:
-        print(f"Transaction error in chart_data: {e}", flush=True)
-
-    return {
-        "burndown": burndown,
-        "income_total": round(income_total, 2),
-        "expense_total": round(expense_total, 2),
-        "accounts": accounts,
-    }
-    """Returns structured JSON for frontend charts."""
-    end_date = date.today()
-    start_date = end_date - timedelta(days=30)
-
-    # Get balances (usually ready immediately)
-    try:
-        balance_req = AccountsBalanceGetRequest(access_token=access_token)
-        balance_resp = plaid_client.accounts_balance_get(balance_req)
-        accounts = []
-        for account in balance_resp['accounts']:
-            current = account['balances']['current']
-            if current is None:
-                continue
-            accounts.append({
-                "name": account['name'],
-                "type": str(account['subtype']),
-                "balance": round(current, 2),
-            })
-    except Exception as e:
-        print(f"Balance error in chart_data: {e}", flush=True)
-        accounts = []
-
-    # Get transactions (may not be ready yet)
-    category_chart = []
-    weekly_data = []
-    income_total = 0.0
-    expense_total = 0.0
-
-    try:
-        request = TransactionsGetRequest(
-            access_token=access_token,
-            start_date=start_date,
-            end_date=end_date,
-            options=TransactionsGetRequestOptions(
-                count=200,
-                include_personal_finance_category=True
-            )
-        )
-        response = plaid_client.transactions_get(request)
-        transactions = response['transactions']
-
-        category_totals: dict[str, float] = {}
-        daily_spending: dict[str, float] = {}
-        daily_income: dict[str, float] = {}
-
-        for txn in transactions:
-            amount = txn['amount']
-            txn_date = str(txn['date'])
-            category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-
-            if amount < 0:
-                income_total += abs(amount)
-                daily_income[txn_date] = daily_income.get(txn_date, 0) + abs(amount)
-                continue
-
-            if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
-                continue
-
-            name_lower = txn['name'].lower()
-            if category == 'LOAN_PAYMENTS' and any(w in name_lower for w in ['payroll', 'salary', 'direct dep', 'employer', 'wages']):
-                income_total += amount
-                daily_income[txn_date] = daily_income.get(txn_date, 0) + amount
-                continue
-
-            expense_total += amount
-            readable = category.replace("_", " ").title()
-            category_totals[readable] = category_totals.get(readable, 0) + amount
-            daily_spending[txn_date] = daily_spending.get(txn_date, 0) + amount
-
-        category_chart = [
-            {"name": cat, "value": round(total, 2)}
-            for cat, total in sorted(category_totals.items(), key=lambda x: -x[1])
-        ]
-
-        for i in range(4):
-            week_end = end_date - timedelta(weeks=i)
-            week_start_d = week_end - timedelta(days=6)
-            week_label = f"{week_start_d.strftime('%b %d')} - {week_end.strftime('%b %d')}"
-            week_spending = sum(v for k, v in daily_spending.items() if str(week_start_d) <= k <= str(week_end))
-            week_income = sum(v for k, v in daily_income.items() if str(week_start_d) <= k <= str(week_end))
-            weekly_data.append({"week": week_label, "spending": round(week_spending, 2), "income": round(week_income, 2)})
-        weekly_data.reverse()
-
-    except Exception as e:
-        print(f"Transaction error in chart_data: {e}", flush=True)
+def _build_chart_data(balance_data, transactions, start_date, end_date) -> dict:
+    """Shared chart builder used by both real and fixture paths."""
+    accounts = []
+    chequing_balance = 0.0
 
-    return {
-        "category_chart": category_chart,
-        "weekly_chart": weekly_data,
-        "income_vs_expenses": {
-            "income": round(income_total, 2),
-            "expenses": round(expense_total, 2),
-        },
-        "accounts": accounts,
-    }
-    """Returns structured JSON for frontend charts."""
-    end_date = date.today()
-    start_date = end_date - timedelta(days=30)
+    for account in balance_data['accounts']:
+        current = account['balances']['current']
+        if current is None:
+            continue
+        subtype = str(account['subtype'])
 
-    # Get transactions
-    request = TransactionsGetRequest(
-        access_token=access_token,
-        start_date=start_date,
-        end_date=end_date,
-        options=TransactionsGetRequestOptions(
-            count=200,
-            include_personal_finance_category=True
-        )
-    )
-    response = plaid_client.transactions_get(request)
-    transactions = response['transactions']
+        if subtype == 'checking':
+            chequing_balance = current
+        if subtype in ['mortgage', 'line of credit']:
+            continue
 
-    # Get balances
-    balance_req = AccountsBalanceGetRequest(access_token=access_token)
-    balance_resp = plaid_client.accounts_balance_get(balance_req)
+        accounts.append({
+            "name": account['name'],
+            "type": subtype,
+            "balance": round(current, 2),
+        })
 
-    # 1. Spending by category
-    category_totals: dict[str, float] = {}
+    burndown = []
     income_total = 0.0
     expense_total = 0.0
-    
-    # 2. Daily spending for weekly breakdown
-    daily_spending: dict[str, float] = {}
-    daily_income: dict[str, float] = {}
+    daily_net: dict[str, float] = {}
 
     for txn in transactions:
         amount = txn['amount']
         txn_date = str(txn['date'])
         category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
 
-        if amount < 0:
-            income_total += abs(amount)
-            daily_income[txn_date] = daily_income.get(txn_date, 0) + abs(amount)
-            continue
-
         if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
             continue
 
         name_lower = txn['name'].lower()
         if category == 'LOAN_PAYMENTS' and any(w in name_lower for w in ['payroll', 'salary', 'direct dep', 'employer', 'wages']):
             income_total += amount
-            daily_income[txn_date] = daily_income.get(txn_date, 0) + amount
+            daily_net[txn_date] = daily_net.get(txn_date, 0) - amount
             continue
 
-        expense_total += amount
-        readable = category.replace("_", " ").title()
-        category_totals[readable] = category_totals.get(readable, 0) + amount
-        daily_spending[txn_date] = daily_spending.get(txn_date, 0) + amount
-
-    # Build category chart data (sorted by amount)
-    category_chart = [
-        {"name": cat, "value": round(total, 2)}
-        for cat, total in sorted(category_totals.items(), key=lambda x: -x[1])
-    ]
-
-    # Build weekly chart data (last 4 weeks)
-    weekly_data = []
-    for i in range(4):
-        week_end = end_date - timedelta(weeks=i)
-        week_start = week_end - timedelta(days=6)
-        week_label = f"{week_start.strftime('%b %d')} - {week_end.strftime('%b %d')}"
-
-        week_spending = sum(
-            v for k, v in daily_spending.items()
-            if str(week_start) <= k <= str(week_end)
-        )
-        week_income = sum(
-            v for k, v in daily_income.items()
-            if str(week_start) <= k <= str(week_end)
-        )
-
-        weekly_data.append({
-            "week": week_label,
-            "spending": round(week_spending, 2),
-            "income": round(week_income, 2),
-        })
-
-    weekly_data.reverse()
-
-    # Build account balances
-    accounts = []
-    for account in balance_resp['accounts']:
-        current = account['balances']['current']
-        if current is None:
-            continue
-        accounts.append({
-            "name": account['name'],
-            "type": str(account['subtype']),
-            "balance": round(current, 2),
+        if amount < 0:
+            income_total += abs(amount)
+            daily_net[txn_date] = daily_net.get(txn_date, 0) + abs(amount)
+        else:
+            expense_total += amount
+            daily_net[txn_date] = daily_net.get(txn_date, 0) - amount
+
+    daily_balances: dict[str, float] = {}
+    running = chequing_balance
+    current = end_date
+    while current >= start_date:
+        day_str = str(current)
+        daily_balances[day_str] = running
+        net_today = daily_net.get(day_str, 0)
+        running = running - net_today
+        current -= timedelta(days=1)
+
+    current = start_date
+    while current <= end_date:
+        day_str = str(current)
+        balance = daily_balances.get(day_str, 0)
+        day_spend = 0
+        for txn in transactions:
+            if str(txn['date']) == day_str and txn['amount'] > 0:
+                cat = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
+                if cat not in ['TRANSFER_IN', 'TRANSFER_OUT']:
+                    day_spend += txn['amount']
+
+        burndown.append({
+            "date": current.strftime("%b %d"),
+            "balance": round(balance, 2),
+            "spent": round(day_spend, 2),
         })
+        current += timedelta(days=1)
 
     return {
-        "category_chart": category_chart,
-        "weekly_chart": weekly_data,
-        "income_vs_expenses": {
-            "income": round(income_total, 2),
-            "expenses": round(expense_total, 2),
-        },
+        "burndown": burndown,
+        "income_total": round(income_total, 2),
+        "expense_total": round(expense_total, 2),
         "accounts": accounts,
     }
 
 
+# ---------- REAL: Recurring transactions ----------
+
 def get_recurring_transactions(access_token: str) -> dict:
     """Analyze 6 months of transactions to find recurring patterns."""
     end_date = date.today()
     start_date = end_date - timedelta(days=180)
 
     try:
-        # Fetch all transactions for 6 months
         all_transactions = []
         offset = 0
         while True:
@@ -779,15 +400,12 @@ def get_recurring_transactions(access_token: str) -> dict:
                 break
             offset = len(all_transactions)
 
-        # ... rest of the function stays the same ...
+        return _detect_recurring(all_transactions, start_date, end_date)
 
     except Exception as e:
         error_str = str(e)
         print(f"Recurring transaction error: {error_str}", flush=True)
-        
-        # Check if it's PRODUCT_NOT_READY
         not_ready = 'PRODUCT_NOT_READY' in error_str or 'not yet ready' in error_str
-        
         return {
             'recurring_expenses': [],
             'recurring_income': [],
@@ -795,174 +413,174 @@ def get_recurring_transactions(access_token: str) -> dict:
             'analysis_period': None,
             'not_ready': not_ready,
         }
-    """Analyze 6 months of transactions to find recurring patterns."""
-    end_date = date.today()
-    start_date = end_date - timedelta(days=180)  # 6 months back
 
-    try:
-        # Fetch all transactions for 6 months
-        all_transactions = []
-        offset = 0
-        while True:
-            request = TransactionsGetRequest(
-                access_token=access_token,
-                start_date=start_date,
-                end_date=end_date,
-                options=TransactionsGetRequestOptions(
-                    count=500,
-                    offset=offset,
-                    include_personal_finance_category=True
-                )
-            )
-            response = plaid_client.transactions_get(request)
-            all_transactions.extend(response['transactions'])
-            if len(all_transactions) >= response['total_transactions']:
-                break
-            offset = len(all_transactions)
 
-        # Group transactions by normalized merchant name
-        merchant_groups: dict[str, list] = defaultdict(list)
-
-        for txn in all_transactions:
-            name = txn['name']
-            amount = txn['amount']
-            txn_date = txn['date']
-            category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-
-            # Skip transfers
-            if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
-                continue
-
-            # Normalize merchant name (remove numbers, extra spaces)
-            normalized = re.sub(r'[0-9#]+', '', name).strip()
-            normalized = re.sub(r'\s+', ' ', normalized).upper()
-
-            merchant_groups[normalized].append({
-                'date': str(txn_date),
-                'amount': amount,
-                'name': name,
-                'category': category,
-            })
-
-        # Detect recurring patterns
-        recurring = []
-        income = []
-
-        for merchant, txns in merchant_groups.items():
-            if len(txns) < 3:  # Need at least 3 occurrences
-                continue
-
-            # Sort by date
-            txns.sort(key=lambda x: x['date'])
-
-            # Check if amounts are consistent (within 10% variance)
-            amounts = [t['amount'] for t in txns]
-            avg_amount = sum(amounts) / len(amounts)
-            if avg_amount == 0:
-                continue
-            variance = max(amounts) - min(amounts)
-            is_consistent_amount = variance / abs(avg_amount) < 0.15
-
-            if not is_consistent_amount:
-                continue
-
-            # Detect frequency by analyzing gaps between transactions
-            dates = [date.fromisoformat(t['date']) for t in txns]
-            gaps = [(dates[i+1] - dates[i]).days for i in range(len(dates)-1)]
-            avg_gap = sum(gaps) / len(gaps) if gaps else 0
-
-            # Classify frequency
-            if 5 <= avg_gap <= 10:
-                frequency = 'weekly'
-                freq_days = 7
-            elif 12 <= avg_gap <= 17:
-                frequency = 'biweekly'
-                freq_days = 14
-            elif 25 <= avg_gap <= 35:
-                frequency = 'monthly'
-                freq_days = 30
-            else:
-                continue  # Irregular — skip
-
-            # Count consecutive months present
-            months_present = set()
-            for t in txns:
-                d = date.fromisoformat(t['date'])
-                months_present.add(f"{d.year}-{d.month:02d}")
-
-            consecutive = len(months_present)
-
-            # Determine if it's income or expense
-            is_income = avg_amount < 0  # Negative = money in
-
-            entry = {
-                'merchant': txns[0]['name'],
-                'normalized_name': merchant,
-                'amount': round(abs(avg_amount), 2),
-                'frequency': frequency,
-                'frequency_days': freq_days,
-                'category': txns[0]['category'],
-                'consecutive_months': consecutive,
-                'last_date': txns[-1]['date'],
-                'is_income': is_income,
-                'history': [{'date': t['date'], 'amount': t['amount']} for t in txns],
-            }
-
-            if consecutive >= 5:
-                entry['status'] = 'confirmed'  # 5+ months = add indefinitely
-            elif consecutive >= 3:
-                entry['status'] = 'likely'
-            else:
-                entry['status'] = 'possible'
-
-            if is_income:
-                income.append(entry)
-            else:
-                recurring.append(entry)
-
-        # Sort by amount descending
-        recurring.sort(key=lambda x: -x['amount'])
-        income.sort(key=lambda x: -x['amount'])
-
-        # Project future dates for confirmed recurring items
-        projected_events = []
-        today = date.today()
-
-        for item in recurring + income:
-            last = date.fromisoformat(item['last_date'])
-            freq = item['frequency_days']
-
-            # Project next 90 days
-            next_date = last + timedelta(days=freq)
-            while next_date <= today + timedelta(days=90):
-                if next_date >= today:
-                    projected_events.append({
-                        'date': str(next_date),
-                        'merchant': item['merchant'],
-                        'amount': item['amount'],
-                        'is_income': item['is_income'],
-                        'frequency': item['frequency'],
-                        'status': item['status'],
-                        'category': item['category'],
-                    })
-                next_date += timedelta(days=freq)
-
-        projected_events.sort(key=lambda x: x['date'])
+def _detect_recurring(all_transactions, start_date, end_date) -> dict:
+    """Shared recurring detector used by both real and fixture paths."""
+    merchant_groups: dict[str, list] = defaultdict(list)
 
-        return {
-            'recurring_expenses': recurring,
-            'recurring_income': income,
-            'projected_events': projected_events,
+    for txn in all_transactions:
+        name = txn['name']
+        amount = txn['amount']
+        txn_date = txn['date']
+        category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
+
+        if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
+            continue
+
+        normalized = re.sub(r'[0-9#]+', '', name).strip()
+        normalized = re.sub(r'\s+', ' ', normalized).upper()
+
+        merchant_groups[normalized].append({
+            'date': str(txn_date),
+            'amount': amount,
+            'name': name,
+            'category': category,
+        })
+
+    recurring = []
+    income = []
+
+    for merchant, txns in merchant_groups.items():
+        if len(txns) < 3:
+            continue
+
+        txns.sort(key=lambda x: x['date'])
+        amounts = [t['amount'] for t in txns]
+        avg_amount = sum(amounts) / len(amounts)
+        if avg_amount == 0:
+            continue
+        variance = max(amounts) - min(amounts)
+        if variance / abs(avg_amount) >= 0.15:
+            continue
+
+        dates = [date.fromisoformat(t['date']) for t in txns]
+        gaps = [(dates[i+1] - dates[i]).days for i in range(len(dates)-1)]
+        avg_gap = sum(gaps) / len(gaps) if gaps else 0
+
+        if 5 <= avg_gap <= 10:
+            frequency = 'weekly'
+            freq_days = 7
+        elif 12 <= avg_gap <= 17:
+            frequency = 'biweekly'
+            freq_days = 14
+        elif 25 <= avg_gap <= 35:
+            frequency = 'monthly'
+            freq_days = 30
+        else:
+            continue
+
+        months_present = set()
+        for t in txns:
+            d = date.fromisoformat(t['date'])
+            months_present.add(f"{d.year}-{d.month:02d}")
+
+        consecutive = len(months_present)
+        is_income = avg_amount < 0
+
+        entry = {
+            'merchant': txns[0]['name'],
+            'normalized_name': merchant,
+            'amount': round(abs(avg_amount), 2),
+            'frequency': frequency,
+            'frequency_days': freq_days,
+            'category': txns[0]['category'],
+            'consecutive_months': consecutive,
+            'last_date': txns[-1]['date'],
+            'is_income': is_income,
+            'history': [{'date': t['date'], 'amount': t['amount']} for t in txns],
+        }
+
+        if consecutive >= 5:
+            entry['status'] = 'confirmed'
+        elif consecutive >= 3:
+            entry['status'] = 'likely'
+        else:
+            entry['status'] = 'possible'
+
+        if is_income:
+            income.append(entry)
+        else:
+            recurring.append(entry)
+
+    recurring.sort(key=lambda x: -x['amount'])
+    income.sort(key=lambda x: -x['amount'])
+
+    projected_events = []
+    today = date.today()
+
+    for item in recurring + income:
+        last = date.fromisoformat(item['last_date'])
+        freq = item['frequency_days']
+        next_date = last + timedelta(days=freq)
+        while next_date <= today + timedelta(days=90):
+            if next_date >= today:
+                projected_events.append({
+                    'date': str(next_date),
+                    'merchant': item['merchant'],
+                    'amount': item['amount'],
+                    'is_income': item['is_income'],
+                    'frequency': item['frequency'],
+                    'status': item['status'],
+                    'category': item['category'],
+                })
+            next_date += timedelta(days=freq)
+
+    projected_events.sort(key=lambda x: x['date'])
+
+    return {
+        'recurring_expenses': recurring,
+        'recurring_income': income,
+        'projected_events': projected_events,
+        'total_transactions': len(all_transactions),
+        'analysis_period': {
+            'start': str(start_date),
+            'end': str(end_date),
             'total_transactions': len(all_transactions),
-            'analysis_period': {
-                'start': str(start_date),
-                'end': str(end_date),
-                'total_transactions': len(all_transactions),
-            }
         }
+    }
+
+
+# ============================================================================
+# TRIAL MODE: fixture-based variants
+# Called by /trial/* endpoints in app.py — no Plaid API calls.
+# ============================================================================
+
+def get_snapshot_from_fixtures() -> str:
+    """Trial mode: build financial snapshot from fixture data."""
+    try:
+        balances = _load_raw_balances()
+        transactions_data = _load_raw_transactions()
+        balance_text = _format_balances(balances)
+        transaction_text = _format_transactions(transactions_data['transactions'])
+        return f"{balance_text}\n\n{transaction_text}"
+    except Exception as e:
+        print(f"Fixture snapshot error: {e}", flush=True)
+        return "NO_BANK_DATA"
 
+
+def get_chart_data_from_fixtures() -> dict:
+    """Trial mode: build chart data from fixture data."""
+    end_date = date.today()
+    start_date = end_date.replace(day=1)
+    try:
+        balances = _load_raw_balances()
+        transactions_data = _load_raw_transactions()
+        return _build_chart_data(balances, transactions_data['transactions'], start_date, end_date)
+    except Exception as e:
+        print(f"Fixture chart_data error: {e}", flush=True)
+        return {"burndown": [], "income_total": 0, "expense_total": 0, "accounts": []}
+
+
+def get_recurring_from_fixtures() -> dict:
+    """Trial mode: detect recurring patterns from fixture data."""
+    end_date = date.today()
+    start_date = end_date - timedelta(days=180)
+    try:
+        transactions_data = _load_raw_transactions()
+        return _detect_recurring(transactions_data['transactions'], start_date, end_date)
     except Exception as e:
-        print(f"Recurring transaction error: {e}", flush=True)
+        print(f"Fixture recurring error: {e}", flush=True)
         return {
             'recurring_expenses': [],
             'recurring_income': [],