extra

.github/workflows/pytest.yml

@@ -1,30 +0,0 @@
-name: Run Tests
-on:
-  push:
-    paths:
-      - 'experiments/**'
-      - 'backend/**'
-      - 'requirements.txt'
-      - '.github/workflows/pytest.yml'
-  pull_request:
-    paths:
-      - 'experiments/**'
-      - 'backend/**'
-      - 'requirements.txt'
-      - '.github/workflows/pytest.yml'
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.13'
-          cache: 'pip'
-      - name: Install dependencies
-        run: |
-          python -m venv .venv
-          .venv/bin/pip install --upgrade pip
-          .venv/bin/pip install -r requirements.txt
-      - name: Run tests
-        run: .venv/bin/pytest -v

.gitignore

@@ -1,16 +1,6 @@
 **/.env
 **/.venv
-**/__pycache__
-**/.ipynb_checkpoints/
+PHANTOM.wiki/
 **/.virtual_documents/
-**/session_*.svg
-**/*graph.svg
-paper/src/bib/auto
-
-# Airflow logs - exclude DAG run logs
-experiments/airflow/logs/*
-experiments/airflow/logs/scheduler/
-experiments/airflow/logs/dag_processor_manager/
-tests/e2e/node_modules/**
-**/auto/*.el
-*.old
+**/__pycache__/
+**/.ipynb_checkpoints/

Makefile

@@ -4,81 +4,36 @@ BUILDDIR  := build
 TEX       := main.tex
 JOBNAME   := main
 PDF       := paper/$(BUILDDIR)/$(JOBNAME).pdf
-VENV      := .venv
-PYTHON    := $(VENV)/bin/python
-PIP       := $(VENV)/bin/pip
-PYTEST    := $(VENV)/bin/pytest
 
 .DEFAULT_GOAL := help
 
-.PHONY: help
-help:
-	@echo "pdf.build pdf.watch pdf.clean | test.backend test.e2e test.all | web.dev | install | stats.lines"
+all: pdf
+
+run.webapp:
+	@cd web && npm install && npm run dev
 
 $(BUILDDIR):
 	mkdir -p paper/$(BUILDDIR)
 
-.PHONY: pdf.build
-pdf.build: $(BUILDDIR)
+pdf: $(BUILDDIR)
+	@echo "Concatenating source code..."
 	@bash paper/concat_code.sh
 	@cd $(SRCDIR) && \
 	$(LATEXMK) -pdf -jobname=$(JOBNAME) \
 		-interaction=nonstopmode -file-line-error \
 		-outdir=../$(BUILDDIR) $(TEX)
 
-.PHONY: pdf.watch
-pdf.watch: $(BUILDDIR)
+watch: $(BUILDDIR)
 	@cd $(SRCDIR) && \
 	$(LATEXMK) -pvc -pdf -jobname=$(JOBNAME) \
 		-interaction=nonstopmode -file-line-error \
 		-r ../.latexmkrc \
 		-outdir=../$(BUILDDIR) $(TEX)
 
-.PHONY: pdf.clean
-pdf.clean:
+clean:
 	@cd $(SRCDIR) && \
 	$(LATEXMK) -C -jobname=$(JOBNAME) -outdir=../$(BUILDDIR) || true
 	rm -rf paper/$(BUILDDIR)/*
 
-.PHONY: test.backend
-test.backend: $(VENV)
-	$(PYTEST) -v
 
-.PHONY: test.e2e
-test.e2e:
-	@cd tests/e2e && npm install
-	@cd tests/e2e && npx playwright install chromium
-	@test -f tests/e2e/.env || cp tests/e2e/.env.example tests/e2e/.env
-	@timeout 30 bash -c 'until curl -sf http://localhost:5000/health > /dev/null 2>&1; do sleep 1; done' || (echo "Backend not ready" && exit 1)
-	@timeout 30 bash -c 'until curl -sf http://localhost:3000 > /dev/null 2>&1; do sleep 1; done' || (echo "Web app not ready" && exit 1)
-	@timeout 30 bash -c 'until curl -sf http://localhost:8085/health > /dev/null 2>&1; do sleep 1; done' || (echo "Airflow not ready" && exit 1)
-	@cd tests/e2e && npm test
-
-.PHONY: test.all
-test.all: test.backend test.e2e
-
-.PHONY: web.dev
-web.dev:
-	@cd web && npm install && npm run dev
-
-$(VENV):
-	python3 -m venv $(VENV)
-	$(PIP) install --upgrade pip
-
-.PHONY: install
-install: $(VENV)
-	$(PIP) install -r requirements.txt
-
-.PHONY: stats.lines
-stats.lines:
-	@find . \( -path '*/node_modules' -o -path '*/.venv' -o -path '*/venv' \) -prune -o \
-	\( -name "*.ts" -o -name "*.py" \) -type f -print0 | xargs -0 cat | wc -l
-
-.PHONY: pdf clean watch run.webapp test count-lines all
-pdf: pdf.build
-clean: pdf.clean
-watch: pdf.watch
-run.webapp: web.dev
-test: test.backend
-count-lines: stats.lines
-all: pdf.build
+.PHONY: all pdf clean watch run.webapp

README.md

@@ -1,12 +1,5 @@
-<img width="200" align="left" src="https://github.com/user-attachments/assets/d148b00d-e9f9-4280-89cc-0cc866e17251" />
-
-### PHANTOM
-
 [![Build PDF](https://github.com/velocitatem/PHANTOM/actions/workflows/latex.yml/badge.svg)](https://github.com/velocitatem/PHANTOM/actions/workflows/latex.yml)
-[![TPU Research Cloud](https://img.shields.io/badge/TPU%20Research%20Cloud-TRC%20supported-4285F4?logo=googlecloud&logoColor=white)](https://sites.research.google/trc/faq/)
-[![Vercel Deploy](https://deploy-badge.vercel.app/?url=https://phantom-hotel.vercel.app&name=Hotel)](https://phantom-hotel.vercel.app)
-[![Vercel Deploy](https://deploy-badge.vercel.app/?url=https://phantom-airline.vercel.app&name=Airline)](https://phantom-airline.vercel.app)
-
-
 
+- https://phantom-hotel.vercel.app/
+- https://phantom-airline.vercel.app/
 

backend/provider/app.py

@@ -1,112 +0,0 @@
-from fastapi import FastAPI, HTTPException, Query
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from typing import Literal, Optional
-import uvicorn, os, sys
-from supabase import create_client, Client
-from dotenv import load_dotenv
-import numpy as np
-import pandas as pd
-load_dotenv()
-
-# Local imports of registry and pricing function
-
-sys.path.append(os.path.dirname(os.path.abspath(__file__))+ "/../../experiments/")
-from procesing.providers import SupabaseProvider, BackendAPIProvider
-from procesing.pricers import (
-    StaticPricer,
-    RandomPricer,
-    ElasticityBasedPricer
-)
-from procesing.steps import (
-    PredictPricesStep
-)
-from procesing import PipelineContext
-sys.path.append(os.path.dirname(os.path.abspath(__file__))+ "/../../lib/")
-print(os.path.dirname(os.path.abspath(__file__))+ "/../../lib/")
-from lib.model_registry import ModelRegistry
-
-# Config
-app = FastAPI(title="PHANTOM Pricing Provider")
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
-
-supabase: Client = create_client(os.getenv("NEXT_PUBLIC_SUPABASE_URL"), os.getenv("NEXT_PUBLIC_SUPABASE_ANON_KEY"))
-registry = ModelRegistry()
-
-class PriceResponse(BaseModel):
-    productId: str
-    price: float
-    base_price: float
-    markup: float
-    elasticity: Optional[float] = None
-    model_version: str = 'latest'
-
-@app.get("/health")
-def health() -> dict:
-    return {"status": "healthy", "redis": registry.health_check()}
-
-@app.get("/api/{mode}/price/{productId}", response_model=PriceResponse)
-def get_price(mode: Literal['hotel', 'airline'], productId: str, sessionId: Optional[str] = Query(None), experimentId: Optional[str] = Query(None)):
-    """
-    THIS is the fast lookup service (mechanism).
-    Priority: session-keyed price > global optimal price > base price
-    """
-    product = supabase.table(f'{mode}_products').select("metadata").eq('id', productId).execute().data[0]
-    if not product: raise HTTPException(404, f"Product {productId} not found")
-
-    metadata = product['metadata']
-    base_price = metadata.get('base_price', 100.0)
-
-    # PRIORITY 1: session-aware price (computed by Airflow worker)
-    if sessionId:
-        session_price = registry.get_session_price(sessionId, productId)
-        if session_price is not None:
-            return PriceResponse(
-                productId=productId,
-                price=session_price,
-                base_price=base_price,
-                markup=session_price/base_price,
-                elasticity=None,
-                model_version='session-aware'
-            )
-
-    # PRIORITY 2: global pre-computed prices (surge pricing)
-    prices_df = registry.get_prices('latest')
-    if prices_df is not None:
-        product_price_row = prices_df[prices_df['productId'] == productId]
-        if not product_price_row.empty:
-            optimal_price = float(product_price_row['optimal_price'].iloc[0])
-            return PriceResponse(
-                productId=productId,
-                price=optimal_price,
-                base_price=base_price,
-                markup=optimal_price/base_price,
-                elasticity=None,
-                model_version='surge'
-            )
-
-    # PRIORITY 3: fallback to base price
-    return PriceResponse(
-        productId=productId,
-        price=base_price,
-        base_price=base_price,
-        markup=1.0,
-        elasticity=None,
-        model_version='base'
-    )
-
-@app.get("/models")
-def list_models(): return registry.list_models()
-
-@app.post("/models/reload")
-def reload_models():
-    elasticity, pricing_model = registry.get_elasticity('latest'), registry.get_pricing_model('latest')
-    return {
-        "elasticity_loaded": bool(elasticity),
-        "n_products": len(elasticity) if elasticity is not None else 0,
-        "pricing_model_loaded": bool(pricing_model),
-        "model_class": pricing_model.__class__.__name__ if pricing_model else None
-    }
-
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("PROVIDER_PORT", "5001")))

backend/provider/requirements.txt

@@ -1,16 +0,0 @@
-fastapi
-uvicorn[standard]
-pydantic
-numpy
-pandas
-scikit-learn
-redis
-supabase
-confluent-kafka>=2.3.0
-kafka-python
-graphviz
-python-dotenv>=1.0.0
-requests>=2.31.0
-typing-extensions>=4.8.0
-pypickle
-pymc

backend/server/app.py

@@ -7,11 +7,10 @@ import uvicorn
 import os
 import json
 from datetime import datetime
-from kafka import KafkaProducer, KafkaAdminClient, KafkaConsumer
+from kafka import KafkaProducer, KafkaAdminClient
 from kafka.admin import NewTopic
 from kafka.errors import TopicAlreadyExistsError
 from dotenv import load_dotenv
-from supabase import create_client, Client
 load_dotenv()
 
 app = FastAPI()
@@ -19,24 +18,11 @@ app = FastAPI()
 # kafka producer - lazy init
 _producer: Optional[KafkaProducer] = None
 
-# supabase client - lazy init
-_supabase: Optional[Client] = None
-
-def get_supabase() -> Client:
-    global _supabase
-    if _supabase is None:
-        url = os.getenv('NEXT_PUBLIC_SUPABASE_URL')
-        key = os.getenv('NEXT_PUBLIC_SUPABASE_ANON_KEY')
-        if not url or not key:
-            raise ValueError("Supabase credentials not configured")
-        _supabase = create_client(url, key)
-    return _supabase
-
 def get_producer() -> KafkaProducer:
     global _producer
     if _producer is None:
         host = os.getenv('KAFKA_HOST', 'localhost')
-        port = os.getenv('KAFKA_PORT', '9092')
+        port = os.getenv('KAFKA_PORT', '29092')  # use internal broker port
         broker = f'{host}:{port}' if port else host
         print(f"[KAFKA_INIT] Connecting to broker: {broker}")
         _producer = KafkaProducer(
@@ -55,7 +41,6 @@ def get_producer() -> KafkaProducer:
 
 class EventPayload(BaseModel):
     sessionId: str
-    experimentId: Optional[str] = None
     eventName: str
     page: str
     productId: Optional[str] = None
@@ -64,14 +49,6 @@ class EventPayload(BaseModel):
     userAgent: Optional[str] = None
     ts: Optional[str] = None
 
-class PriceLogPayload(BaseModel):
-    productId: str
-    price: float
-    sessionId: str
-    experimentId: Optional[str] = None
-    storeMode: str
-    ts: Optional[str] = None
-
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -84,7 +61,7 @@ app.add_middleware(
 async def startup_event():
     """create kafka topics on startup"""
     host = os.getenv('KAFKA_HOST', 'localhost')
-    port = os.getenv('KAFKA_PORT', '9092')
+    port = os.getenv('KAFKA_PORT', '29092')
     broker = f'{host}:{port}'
 
     try:
@@ -95,8 +72,7 @@ async def startup_event():
         )
 
         topics = [
-            NewTopic(name='user-interactions', num_partitions=3, replication_factor=1),
-            NewTopic(name='price-logs', num_partitions=3, replication_factor=1)
+            NewTopic(name='user-interactions', num_partitions=3, replication_factor=1)
         ]
 
         admin.create_topics(new_topics=topics, validate_only=False)
@@ -148,217 +124,11 @@ async def ingest_logs(event: EventPayload):
         print(traceback.format_exc())
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.post("/api/kafka/price-log")
-async def ingest_price_log(price_log: PriceLogPayload):
-    try:
-        if not price_log.ts:
-            price_log.ts = datetime.utcnow().isoformat() + 'Z'
-
-        producer = get_producer()
-        future = producer.send(
-            'price-logs',
-            key=price_log.productId,
-            value=price_log.model_dump()
-        )
-        future.add_errback(lambda e: print(f"[KAFKA_PRICE_LOG_ERROR] {e}"))
-
-        return {"success": True}
-    except Exception as e:
-        import traceback
-        print(f"[PRICE_LOG_ERROR] {e}")
-        print(traceback.format_exc())
-        raise HTTPException(status_code=500, detail=str(e))
-
 @app.get("/api/kafka/dump")
-def dump_logs(
-    topic: str = 'user-interactions',
-    last_n: Optional[int] = None,
-    t_start: Optional[str] = None,
-    t_end: Optional[str] = None
-):
-    """dump all messages from specified kafka topic
-
-    params:
-        topic: kafka topic to dump (default: user-interactions)
-        last_n: return only last n messages (default: all)
-        t_start: filter by start timestamp iso format
-        t_end: filter by end timestamp iso format
-    """
-    if topic not in ['user-interactions', 'price-logs']:
-        raise HTTPException(status_code=400, detail="Invalid topic")
-
-    host = os.getenv('KAFKA_HOST', 'localhost')
-    port = os.getenv('KAFKA_PORT', '9092')
-    broker = f'{host}:{port}'
-
-    try:
-        consumer = KafkaConsumer(
-            topic,
-            bootstrap_servers=[broker],
-            auto_offset_reset='earliest',
-            enable_auto_commit=False,
-            value_deserializer=lambda x: json.loads(x.decode('utf-8')),
-            consumer_timeout_ms=30000,
-            fetch_max_wait_ms=10000,
-            max_poll_records=1000
-        )
-
-        events = []
-        for msg in consumer:
-            events.append(msg.value)
-            if last_n and len(events) >= last_n * 2:
-                break
-
-        consumer.close()
-
-        # apply filters
-        if t_start or t_end:
-            filtered = []
-            for e in events:
-                ts = e.get('ts')
-                if ts:
-                    if t_start and ts < t_start:
-                        continue
-                    if t_end and ts > t_end:
-                        continue
-                filtered.append(e)
-            events = filtered
-
-        if last_n and last_n > 0:
-            events = events[-last_n:]
-
-        return {"success": True, "count": len(events), "data": events}
-
-    except Exception as e:
-        import traceback
-        print(f"[DUMP_ERROR] {e}")
-        print(traceback.format_exc())
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/products/{product_id}")
-async def get_product_by_id(product_id: str):
-    """fetch single product by id from either hotel_products or airline_products"""
-    try:
-        supabase = get_supabase()
-
-        # try hotel_products first
-        response = supabase.table('hotel_products').select('*').eq('id', product_id).execute()
-        if response.data and len(response.data) > 0:
-            return {"success": True, "data": response.data[0]}
-
-        # try airline_products
-        response = supabase.table('airline_products').select('*').eq('id', product_id).execute()
-        if response.data and len(response.data) > 0:
-            return {"success": True, "data": response.data[0]}
-
-        raise HTTPException(status_code=404, detail="Product not found")
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        import traceback
-        print(f"[PRODUCT_BY_ID_ERROR] {e}")
-        print(traceback.format_exc())
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/products/type/{product_type}")
-async def get_products(
-    product_type: str,
-    dateIndex: Optional[int] = None,
-    origin: Optional[str] = None,
-    destination: Optional[str] = None,
-    tripType: Optional[str] = None,
-    adults: Optional[int] = None,
-    children: Optional[int] = None,
-    infants: Optional[int] = None,
-    rooms: Optional[int] = None
-):
-    """fetch products from supabase based on type (hotel or airline)
-
-    params:
-        product_type: either 'hotel' or 'airline'
-        dateIndex: optional days offset from today (e.g., 0=today, 1=tomorrow, -1=yesterday)
-        origin: (airline) departure airport code
-        destination: (airline/hotel) arrival airport or hotel location
-        tripType: (airline) roundtrip, oneway, multicity
-        adults, children, infants: passenger counts
-        rooms: (hotel) number of rooms
-    """
-    if product_type not in ['hotel', 'airline']:
-        raise HTTPException(status_code=400, detail="product_type must be 'hotel' or 'airline'")
-
-    try:
-        supabase = get_supabase()
-        table = f'{product_type}_products'
-
-        query = supabase.table(table).select('*')
-
-        # filter by exact date_index if provided
-        # dateIndex from frontend is days from today, convert to days since epoch
-        if dateIndex is not None:
-            query = query.eq('date_index', dateIndex)
-
-        response = query.execute()
-        results = response.data
-
-        # apply in-memory filters based on metadata for airline products
-        if product_type == 'airline' and results:
-            filtered = []
-            for product in results:
-                metadata = product.get('metadata', {})
-
-                # filter by origin airport
-                if origin:
-                    dep = metadata.get('departure', {})
-                    if dep.get('airport') != origin:
-                        continue
-
-                # filter by destination airport
-                if destination:
-                    arr = metadata.get('arrival', {})
-                    if arr.get('airport') != destination:
-                        continue
-
-                # passenger count validation (ensure total capacity)
-                if adults is not None or children is not None or infants is not None:
-                    total_pax = (adults or 0) + (children or 0) + (infants or 0)
-                    avail = product.get('availability', 0)
-                    if avail < total_pax:
-                        continue
-
-                filtered.append(product)
-
-            results = filtered
-
-        # apply in-memory filters for hotel products
-        elif product_type == 'hotel' and results:
-            filtered = []
-            for product in results:
-                metadata = product.get('metadata', {})
-
-                # filter by occupancy capacity
-                if adults is not None:
-                    max_occ = metadata.get('max_occupancy', 2)
-                    if max_occ < adults:
-                        continue
-
-                # filter by room availability
-                if rooms is not None:
-                    avail = product.get('availability', 0)
-                    if avail < rooms:
-                        continue
-
-                filtered.append(product)
-
-            results = filtered
-
-        return {"success": True, "count": len(results), "data": results}
-
-    except Exception as e:
-        import traceback
-        print(f"[PRODUCTS_ERROR] {e}")
-        print(traceback.format_exc())
-        raise HTTPException(status_code=500, detail=str(e))
+def dump_logs():
+    # TODO: implement a dump of logs of time period t_start to t_end (params of get)
+    # OR: allow for params of last_n logs as a param - creating two modes of the dumping
+    pass
 
 
 

backend/server/requirements.txt

@@ -3,4 +3,3 @@ uvicorn[standard]==0.24.0
 kafka-python==2.0.2
 pydantic==2.5.0
 python-dotenv==1.0.0
-supabase==2.9.1

docker-compose.yml

@@ -1,24 +1,4 @@
 services:
-  tensorboard-rl:
-    image: tensorflow/tensorflow:latest
-    container_name: "PHANTOM-tensorboard-rl"
-    ports:
-      - "6007:6006"
-    volumes:
-      - ./sim/rl/runs:/logs
-    command: tensorboard --logdir=/logs --host=0.0.0.0 --port=6006
-    restart: unless-stopped
-
-  tensorboard-ml:
-    image: tensorflow/tensorflow:latest
-    container_name: "PHANTOM-tensorboard-ml"
-    ports:
-      - "6006:6006"
-    volumes:
-      - ./experiments/ml/runs:/logs
-    command: tensorboard --logdir=/logs --host=0.0.0.0 --port=6006
-    restart: unless-stopped
-
   backend:
     container_name: "PHANTOM-backend"
     build:
@@ -29,9 +9,6 @@ services:
     environment:
       - KAFKA_HOST=kafka
       - KAFKA_PORT=29092
-      - BACKEND_PORT=5000
-      - NEXT_PUBLIC_SUPABASE_URL=${NEXT_PUBLIC_SUPABASE_URL}
-      - NEXT_PUBLIC_SUPABASE_ANON_KEY=${NEXT_PUBLIC_SUPABASE_ANON_KEY}
     depends_on:
       - kafka
     restart: unless-stopped
@@ -91,149 +68,6 @@ services:
       - "${REDPANDA_CONSOLE_PORT:-8080}:8080"
     restart: unless-stopped
 
-  postgres:
-    container_name: "PHANTOM-postgres"
-    image: postgres:13
-    environment:
-      - POSTGRES_USER=airflow
-      - POSTGRES_PASSWORD=airflow
-      - POSTGRES_DB=airflow
-    ports:
-      - "5433:5432"
-    volumes:
-      - postgres_data:/var/lib/postgresql/data
-    restart: unless-stopped
-
-  airflow-init:
-    container_name: "PHANTOM-airflow-init"
-    build:
-      context: .
-      dockerfile: docker/Airflow.dockerfile
-    depends_on:
-      - postgres
-    environment:
-      - AIRFLOW__CORE__EXECUTOR=LocalExecutor
-      - AIRFLOW__DATABASE__SQL_ALCHEMY_CONN=postgresql+psycopg2://airflow:airflow@postgres/airflow
-      - AIRFLOW__CORE__FERNET_KEY=${AIRFLOW_FERNET_KEY}
-      - AIRFLOW__CORE__LOAD_EXAMPLES=false
-      - AIRFLOW__CORE__ENABLE_XCOM_PICKLING=true
-      - AIRFLOW__CORE__PARALLELISM=16
-      - AIRFLOW__CORE__DAG_CONCURRENCY=8
-      - AIRFLOW__CORE__MAX_ACTIVE_RUNS_PER_DAG=4
-      - _AIRFLOW_DB_MIGRATE=true
-      - _AIRFLOW_WWW_USER_CREATE=true
-      - _AIRFLOW_WWW_USER_USERNAME=admin
-      - _AIRFLOW_WWW_USER_PASSWORD=admin
-      - REDIS_HOST=redis
-      - REDIS_PORT=6379
-    command: version
-    restart: "no"
-
-  airflow-webserver:
-    container_name: "PHANTOM-airflow-webserver"
-    build:
-      context: .
-      dockerfile: docker/Airflow.dockerfile
-    depends_on:
-      - postgres
-      - airflow-init
-      - redis
-    environment:
-      - AIRFLOW__CORE__EXECUTOR=LocalExecutor
-      - AIRFLOW__DATABASE__SQL_ALCHEMY_CONN=postgresql+psycopg2://airflow:airflow@postgres/airflow
-      - AIRFLOW__CORE__FERNET_KEY=${AIRFLOW_FERNET_KEY}
-      - AIRFLOW__CORE__DAGS_ARE_PAUSED_AT_CREATION=true
-      - AIRFLOW__CORE__LOAD_EXAMPLES=false
-      - AIRFLOW__CORE__ENABLE_XCOM_PICKLING=true
-      - AIRFLOW__CORE__PARALLELISM=16
-      - AIRFLOW__CORE__DAG_CONCURRENCY=8
-      - AIRFLOW__CORE__MAX_ACTIVE_RUNS_PER_DAG=4
-      - AIRFLOW__SCHEDULER__MIN_FILE_PROCESS_INTERVAL=30
-      - AIRFLOW__SCHEDULER__DAG_DIR_LIST_INTERVAL=60
-      - AIRFLOW__WEBSERVER__EXPOSE_CONFIG=true
-      - AIRFLOW__WEBSERVER__SECRET_KEY=${AIRFLOW_SECRET_KEY}
-      - AIRFLOW__API__AUTH_BACKENDS=airflow.api.auth.backend.basic_auth
-      - KAFKA_HOST=kafka
-      - KAFKA_PORT=29092
-      - BACKEND_URL=http://backend:5000
-      - NEXT_PUBLIC_SUPABASE_URL=${NEXT_PUBLIC_SUPABASE_URL}
-      - NEXT_PUBLIC_SUPABASE_ANON_KEY=${NEXT_PUBLIC_SUPABASE_ANON_KEY}
-      - REDIS_HOST=redis
-      - REDIS_PORT=6379
-    ports:
-      - "${AIRFLOW_WEBSERVER_PORT:-8085}:8080"
-    command: webserver
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "curl", "--fail", "http://localhost:8080/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 5
-      start_period: 30s
-
-  airflow-scheduler:
-    container_name: "PHANTOM-airflow-scheduler"
-    build:
-      context: .
-      dockerfile: docker/Airflow.dockerfile
-    depends_on:
-      airflow-webserver:
-        condition: service_healthy
-      redis:
-        condition: service_started
-    environment:
-      - AIRFLOW__CORE__EXECUTOR=LocalExecutor
-      - AIRFLOW__DATABASE__SQL_ALCHEMY_CONN=postgresql+psycopg2://airflow:airflow@postgres/airflow
-      - AIRFLOW__CORE__FERNET_KEY=${AIRFLOW_FERNET_KEY}
-      - AIRFLOW__CORE__DAGS_ARE_PAUSED_AT_CREATION=true
-      - AIRFLOW__CORE__LOAD_EXAMPLES=false
-      - AIRFLOW__CORE__ENABLE_XCOM_PICKLING=true
-      - AIRFLOW__CORE__PARALLELISM=16
-      - AIRFLOW__CORE__DAG_CONCURRENCY=8
-      - AIRFLOW__CORE__MAX_ACTIVE_RUNS_PER_DAG=4
-      - AIRFLOW__SCHEDULER__MIN_FILE_PROCESS_INTERVAL=30
-      - AIRFLOW__SCHEDULER__DAG_DIR_LIST_INTERVAL=60
-      - AIRFLOW__SCHEDULER__PARSING_PROCESSES=2
-      - AIRFLOW__WEBSERVER__SECRET_KEY=${AIRFLOW_SECRET_KEY}
-      - AIRFLOW__API__AUTH_BACKENDS=airflow.api.auth.backend.basic_auth
-      - KAFKA_HOST=kafka
-      - KAFKA_PORT=29092
-      - BACKEND_URL=http://backend:5000
-      - NEXT_PUBLIC_SUPABASE_URL=${NEXT_PUBLIC_SUPABASE_URL}
-      - NEXT_PUBLIC_SUPABASE_ANON_KEY=${NEXT_PUBLIC_SUPABASE_ANON_KEY}
-      - REDIS_HOST=redis
-      - REDIS_PORT=6379
-    command: scheduler
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD-SHELL", 'airflow jobs check --job-type SchedulerJob --hostname "$${HOSTNAME}"']
-      interval: 30s
-      timeout: 10s
-      retries: 5
-      start_period: 30s
-
-  pricing-provider:
-    container_name: "PHANTOM-pricing-provider"
-    build:
-      context: .
-      dockerfile: docker/Provider.dockerfile
-    depends_on:
-      - redis
-      - kafka
-    environment:
-      - PROVIDER_PORT=5001
-      - REDIS_HOST=redis
-      - REDIS_PORT=6379
-      - KAFKA_HOST=kafka
-      - KAFKA_PORT=29092
-      - NEXT_PUBLIC_SUPABASE_URL=${NEXT_PUBLIC_SUPABASE_URL}
-      - NEXT_PUBLIC_SUPABASE_ANON_KEY=${NEXT_PUBLIC_SUPABASE_ANON_KEY}
-      - BACKEND_URL=http://localhost:5000
-    ports:
-      - "${PROVIDER_PORT:-5001}:5001"
-    restart: unless-stopped
-
 volumes:
   phantom_kafka_data:
   phantom_redis_data:
-  postgres_data:

docker/Airflow.dockerfile

@@ -1,30 +0,0 @@
-FROM apache/airflow:2.7.3-python3.11
-
-USER root
-
-# install system deps if needed
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
-
-USER airflow
-
-# copy requirements for pipeline dependencies
-COPY requirements.txt /tmp/requirements.txt
-RUN pip install --no-cache-dir -r /tmp/requirements.txt
-
-# install postgres driver and providers
-RUN pip install --no-cache-dir \
-    psycopg2-binary \
-    apache-airflow-providers-postgres
-
-# set airflow home
-ENV AIRFLOW_HOME=/opt/airflow
-
-COPY --chown=airflow:root experiments/airflow/dags ${AIRFLOW_HOME}/dags
-COPY --chown=airflow:root experiments/procesing ${AIRFLOW_HOME}/procesing
-COPY --chown=airflow:root lib ${AIRFLOW_HOME}/lib
-
-# create logs and plugins dirs (airflow expects them)
-RUN mkdir -p ${AIRFLOW_HOME}/logs ${AIRFLOW_HOME}/plugins

docker/Airflow.railway.dockerfile

@@ -1,41 +0,0 @@
-FROM apache/airflow:2.7.3-python3.11
-
-USER root
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential \
-    supervisor \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
-
-USER airflow
-
-COPY requirements.txt /tmp/requirements.txt
-RUN pip install --no-cache-dir -r /tmp/requirements.txt
-
-RUN pip install --no-cache-dir \
-    psycopg2-binary \
-    apache-airflow-providers-postgres
-
-ENV AIRFLOW_HOME=/opt/airflow
-ENV AIRFLOW__CORE__EXECUTOR=SequentialExecutor
-ENV AIRFLOW__CORE__LOAD_EXAMPLES=false
-ENV AIRFLOW__CORE__ENABLE_XCOM_PICKLING=true
-ENV AIRFLOW__WEBSERVER__EXPOSE_CONFIG=true
-
-# copy all code into image (standalone - no volume mounts needed)
-COPY --chown=airflow:root experiments/airflow/dags ${AIRFLOW_HOME}/dags
-COPY --chown=airflow:root experiments/procesing ${AIRFLOW_HOME}/procesing
-COPY --chown=airflow:root lib ${AIRFLOW_HOME}/lib
-
-RUN mkdir -p ${AIRFLOW_HOME}/logs ${AIRFLOW_HOME}/plugins
-
-# copy entrypoint script
-COPY --chown=airflow:root docker/airflow-railway-entrypoint.sh /entrypoint.sh
-USER root
-RUN chmod +x /entrypoint.sh
-USER airflow
-
-EXPOSE 8080
-
-ENTRYPOINT ["/entrypoint.sh"]

docker/Provider.dockerfile

@@ -1,26 +0,0 @@
-FROM python:3.11-slim
-
-WORKDIR /app
-
-# Install system dependencies including graphviz
-RUN apt-get update && apt-get install -y \
-    gcc \
-    g++ \
-    graphviz \
-    libgraphviz-dev \
-    && rm -rf /var/lib/apt/lists/*
-
-# Copy and install Python dependencies
-COPY backend/provider/requirements.txt /app/
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy application code into image
-COPY lib/ /app/lib/
-COPY experiments/procesing/ /app/procesing/
-COPY backend/provider/ /app/provider/
-
-ENV PYTHONPATH=/app:/app/lib:/app/procesing
-
-WORKDIR /app/provider
-
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "5001"]

docker/airflow-railway-entrypoint.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-set -e
-
-# init db and create admin user on first run
-airflow db migrate
-
-# create admin user if not exists
-airflow users create \
-    --username "${AIRFLOW_ADMIN_USER:-admin}" \
-    --password "${AIRFLOW_ADMIN_PASSWORD:-admin}" \
-    --firstname Admin \
-    --lastname User \
-    --role Admin \
-    --email admin@example.com || true
-
-# start scheduler in background
-airflow scheduler &
-
-# start webserver in foreground (Railway needs one foreground process)
-exec airflow webserver --port ${PORT:-8080}

experiments/README.md

@@ -1,8 +0,0 @@
-
-# Products
-# Agents
-# Pipeline
-
-Our pipeline technically should follow principles in a style like this:
-- Each step should be defined as an inheriting child of an scikit pipeline step, the granularity of the steps is dictated by the following: a step should be a transformation, augmentation or computation independently, no single stage should run multiple in-itself. This way we can modularize properly all the components and track properly in airflow. A stage can be defined as an sklearn step but then must be transalted to a function that takes the context in our DAG of airflow. All parametrization must be done via contexts.
-

experiments/agents/__init__.py

@@ -1 +0,0 @@
-"""Agentic behavior runner for PHANTOM research platform."""

experiments/agents/agent.py

@@ -1,47 +0,0 @@
-from .base import Agent as BaseAgent
-from browser_use import Browser, Agent, ChatOpenAI
-from enum import Enum
-
-class AgentTypes(str, Enum):
-    GENERIC_BROWSER_USE_AGENT = "generic_browser_use_agent"
-
-def _build_prompt(goal : str, environment_url : str) -> str:
-    #TODO: Improve prompt engineering here and experiment with
-    return f"""You are an autonomous agent tasked with achieving the following goal: {goal}
-You have access to a web browser to interact with the environment at {environment_url}.
-Use the browser to navigate, gather information, and perform actions necessary to accomplish your goal.
-Be thorough and ensure you complete the task fully."""
-
-class GenericBrowserUseAgent(BaseAgent):
-    def __init__(self,
-                 goal: str,
-                 url: str = "http://localhost:3000",
-                 timeout: int = 300,
-                 llm_model: str = "gpt-5-mini",
-                 headless: bool = True):
-        super().__init__(goal, url, timeout)
-        self.llm_model = ChatOpenAI(model=llm_model)
-        self.browser = Browser(headless=headless)
-        self.agent = Agent(task=_build_prompt(goal, url),
-                           llm=self.llm_model,
-                           browser=self.browser)
-    async def act(self) -> str:
-        self.result = await self.agent.run()
-        # https://github.com/browser-use/browser-use/blob/main/browser_use/agent/views.py#L301
-        return self.result.final_result()
-
-def get_agent(agent_type: AgentTypes,  **kwargs) -> Agent:
-    if agent_type == AgentTypes.GENERIC_BROWSER_USE_AGENT:
-        return GenericBrowserUseAgent(**kwargs)
-    else:
-        raise ValueError(f"Unknown agent type: {agent_type}")
-
-if __name__ == "__main__":
-    import asyncio
-    JTBD= "Find me the cheapest room in Madrid for 2 people in the next two days, review each hotel room in detail and then add it to cart."
-    agent = get_agent(AgentTypes.GENERIC_BROWSER_USE_AGENT,
-                      goal=JTBD,
-                      url="http://localhost:3000/start-task?uuid=d10f5ab3-a7b7-4e97-8d94-ab06f1537c0a",
-                      timeout=300)
-    R=asyncio.run(agent.act())
-    print(R)

experiments/agents/base.py

@@ -1,19 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Optional
-
-class Agent(ABC):
-    """Base interface for browser automation agents"""
-
-    def __init__(self, goal: str, url: str = "http://localhost:3000", timeout: int = 300):
-        self.goal = goal
-        self.url = url
-        self.timeout = timeout
-        self.result: Optional[str] = None
-
-    @abstractmethod
-    async def act(self) -> str:
-        """Execute goal and return result text"""
-        pass
-
-    def final_result(self) -> Optional[str]:
-        return self.result

experiments/agents/test.py

@@ -1,30 +0,0 @@
-import pytest
-import asyncio
-from experiments.agents.agent import get_agent, AgentTypes
-import os
-
-
-def test_agent_init():
-    agent = get_agent(AgentTypes.GENERIC_BROWSER_USE_AGENT, goal="test", url="http://example.com", timeout=100)
-    assert agent.goal == "test"
-    assert agent.url == "http://example.com"
-    assert agent.timeout == 100
-
-
-def test_invalid_agent():
-    with pytest.raises(ValueError):
-        get_agent("invalid", goal="test")
-
-
-@pytest.mark.asyncio
-@pytest.mark.skipif("OPENAI_API_KEY" not in os.environ, reason="OPENAI_API_KEY not set")
-async def test_agent_execution():
-    agent = get_agent(AgentTypes.GENERIC_BROWSER_USE_AGENT, goal="get page title", url="https://example.com", timeout=60)
-
-    result = await agent.act()
-    assert result
-    assert agent.final_result()
-    assert agent.final_result().history[-1].result[-1].is_done == True
-    assert isinstance(result, str)
-    assert "example" in result.lower()
-    assert len(result) > 0

experiments/airflow/dags/ml_training_pipeline.py

@@ -1,115 +0,0 @@
-from airflow import DAG, Dataset
-from airflow.decorators import task
-from airflow.utils.dates import days_ago
-from datetime import timedelta
-import pandas as pd
-import logging
-import sys
-import pickle
-
-sys.path.insert(0, '/opt/airflow')
-
-from procesing.context import PipelineContext
-from procesing.providers import SupabaseProvider, BackendAPIProvider
-from procesing.steps import (
-    FetchInteractionsStep,
-    ValidateDataStep,
-    ExtractSessionFeaturesStep,
-    JoinLabelsStep,
-)
-
-TRAINING_DATASET = Dataset('phantom://ml/training-data')
-
-DEFAULT_ARGS = {
-    'owner': 'phantom-research',
-    'depends_on_past': False,
-    'email_on_failure': False,
-    'email_on_retry': False,
-    'retries': 2,
-    'retry_delay': timedelta(minutes=5),
-}
-
-
-class CompositeProvider(SupabaseProvider, BackendAPIProvider):
-    def __init__(self):
-        SupabaseProvider.__init__(self)
-        BackendAPIProvider.__init__(self)
-
-
-def _get_context(store_mode: str = 'hotel') -> PipelineContext:
-    return PipelineContext(provider=CompositeProvider(), store_mode=store_mode)
-
-
-with DAG(
-    'ml_training_pipeline',
-    default_args=DEFAULT_ARGS,
-    description='ML training data pipeline: fetch -> validate -> extract features -> label -> publish',
-    schedule=None,
-    start_date=days_ago(1),
-    catchup=False,
-    max_active_runs=1,
-    tags=['ml', 'training', 'features', 'research'],
-) as dag:
-
-    @task
-    def fetch_interactions(**kwargs) -> bytes:
-        dag_conf = kwargs.get('dag_run').conf if kwargs.get('dag_run') else {}
-        ctx = _get_context(dag_conf.get('store_mode', 'hotel'))
-        df = FetchInteractionsStep(ctx).transform(None)
-        logging.info(f"Fetched {len(df)} interactions, {df['sessionId'].nunique()} sessions")
-        return pickle.dumps(df)
-
-    @task
-    def validate_data(raw_data: bytes, **kwargs) -> bytes:
-        df = pickle.loads(raw_data)
-        dag_conf = kwargs.get('dag_run').conf if kwargs.get('dag_run') else {}
-        ctx = _get_context(dag_conf.get('store_mode', 'hotel'))
-        validated = ValidateDataStep(ctx).transform(df)
-        report = ctx.get_cached('validation_report') or {}
-        logging.info(f"Validation: {report.get('status')}, {report.get('sessions', 0)} sessions")
-        return pickle.dumps(validated)
-
-    @task
-    def extract_session_features(validated_data: bytes, **kwargs) -> bytes:
-        df = pickle.loads(validated_data)
-        if df.empty:
-            logging.warning("Empty input, skipping feature extraction")
-            return pickle.dumps(pd.DataFrame())
-        dag_conf = kwargs.get('dag_run').conf if kwargs.get('dag_run') else {}
-        ctx = _get_context(dag_conf.get('store_mode', 'hotel'))
-        features = ExtractSessionFeaturesStep(ctx).transform(df)
-        logging.info(f"Extracted {len(features.columns)} features for {len(features)} sessions")
-        return pickle.dumps(features)
-
-    @task
-    def join_labels(features_data: bytes, **kwargs) -> bytes:
-        features_df = pickle.loads(features_data)
-        if features_df.empty:
-            logging.warning("Empty features, skipping label join")
-            return pickle.dumps(pd.DataFrame())
-        dag_conf = kwargs.get('dag_run').conf if kwargs.get('dag_run') else {}
-        ctx = _get_context(dag_conf.get('store_mode', 'hotel'))
-        labeled = JoinLabelsStep(ctx).transform(features_df)
-        n_agents = labeled['is_agent'].sum() if 'is_agent' in labeled.columns else 0
-        logging.info(f"Labeled {len(labeled)} sessions: {n_agents} agents")
-        return pickle.dumps(labeled)
-
-    @task(outlets=[TRAINING_DATASET])
-    def publish_training_data(labeled_data: bytes, **kwargs) -> dict:
-        labeled_df = pickle.loads(labeled_data)
-        if labeled_df.empty:
-            return {'status': 'skipped', 'reason': 'empty_data'}
-        dag_conf = kwargs.get('dag_run').conf if kwargs.get('dag_run') else {}
-        return {
-            'status': 'success',
-            'n_sessions': len(labeled_df),
-            'n_features': len([c for c in labeled_df.columns if c not in ['sessionId', 'experimentId', 'is_agent']]),
-            'store_mode': dag_conf.get('store_mode', 'hotel'),
-            'timestamp': pd.Timestamp.now().isoformat(),
-        }
-
-    raw = fetch_interactions()
-    validated = validate_data(raw)
-    features = extract_session_features(validated)
-    labeled = join_labels(features)
-    publish_training_data(labeled)

experiments/airflow/dags/surge_pricing_factory.py

@@ -1,220 +0,0 @@
-from pandas.core.algorithms import factorize_array
-from airflow import DAG
-from airflow.operators.python import PythonOperator
-from airflow.utils.dates import days_ago
-from datetime import timedelta
-import pandas as pd
-import logging
-import sys
-import pickle
-
-sys.path.insert(0, '/opt/airflow')
-
-from procesing.context import PipelineContext
-from procesing.providers import SupabaseProvider, BackendAPIProvider
-from procesing.steps import (
-    FetchInteractionsStep,
-    FetchPriceLogsStep,
-    ComputeDemandStep,
-    AggregatePriceLogsStep,
-    JoinProductFeaturesStep,
-)
-from procesing.pricers.simple import SimpleSurgePricer
-
-DEFAULT_ARGS = {
-    'owner': 'phantom-research',
-    'depends_on_past': False,
-    'email_on_failure': False,
-    'email_on_retry': False,
-    'retries': 2,
-    'retry_delay': timedelta(minutes=5),
-}
-
-class CompositeProvider(SupabaseProvider, BackendAPIProvider):
-    def __init__(self):
-        SupabaseProvider.__init__(self)
-        BackendAPIProvider.__init__(self)
-
-def _get_provider():
-    return CompositeProvider()
-
-def _make_task_callables(store_mode: str):
-    """Generate task callables bound to a specific store_mode."""
-
-    def get_context(**kwargs):
-        return PipelineContext(provider=_get_provider(), store_mode=store_mode)
-
-    def fetch_interactions(**kwargs):
-        ctx = get_context(**kwargs)
-        df = FetchInteractionsStep(ctx).transform(None)
-        kwargs['ti'].xcom_push(key='interactions_raw', value=pickle.dumps(df))
-        logging.info(f"[{store_mode}] Fetched {len(df)} interaction records")
-        return len(df)
-
-    def fetch_price_logs(**kwargs):
-        ctx = get_context(**kwargs)
-        df = FetchPriceLogsStep(ctx).transform(None)
-        kwargs['ti'].xcom_push(key='price_logs_raw', value=pickle.dumps(df))
-        logging.info(f"[{store_mode}] Fetched {len(df)} price records")
-        return len(df)
-
-    def compute_demand(**kwargs):
-        ti = kwargs['ti']
-        df = pickle.loads(ti.xcom_pull(key='interactions_raw'))
-        ctx = get_context(**kwargs)
-        demand_df = ComputeDemandStep(ctx).transform(df)
-        ti.xcom_push(key='demand_data', value=pickle.dumps(demand_df))
-        logging.info(f"[{store_mode}] Computed demand for {len(demand_df)} products")
-        return len(demand_df)
-
-    def aggregate_price_logs(**kwargs):
-        ti = kwargs['ti']
-        df = pickle.loads(ti.xcom_pull(key='price_logs_raw'))
-        ctx = get_context(**kwargs)
-        price_df = AggregatePriceLogsStep(ctx).transform(df)
-        ti.xcom_push(key='price_data', value=pickle.dumps(price_df))
-        logging.info(f"[{store_mode}] Aggregated price logs for {len(price_df)} products")
-        return len(price_df)
-
-    def join_product_features(**kwargs):
-        ti = kwargs['ti']
-        demand_df = pickle.loads(ti.xcom_pull(key='demand_data'))
-        price_df = pickle.loads(ti.xcom_pull(key='price_data'))
-        ctx = get_context(**kwargs)
-        joined_df = JoinProductFeaturesStep(ctx).transform((demand_df, price_df))
-        ti.xcom_push(key='product_features', value=pickle.dumps(joined_df))
-        logging.info(f"[{store_mode}] Joined features for {len(joined_df)} products")
-        return len(joined_df)
-
-    def apply_surge_pricing(**kwargs):
-        ti = kwargs['ti']
-        product_features = pickle.loads(ti.xcom_pull(key='product_features'))
-        dag_conf = kwargs.get('dag_run').conf if kwargs.get('dag_run') else {}
-
-        data = product_features.rename(columns={'demand_score': 'demand'})
-        surge_pricer = SimpleSurgePricer(
-            high_threshold=dag_conf.get('high_threshold', 10),
-            low_threshold=dag_conf.get('low_threshold', 2),
-            surge_multiplier=dag_conf.get('surge_multiplier', 1.2),
-            discount_multiplier=dag_conf.get('discount_multiplier', 0.9)
-        )
-        surge_pricer.fit(data)
-        data['optimal_price'] = surge_pricer.predict()
-
-        prices_df = data[['productId', 'price', 'base_price', 'optimal_price', 'demand']].rename(columns={
-            'price': 'current_price', 'demand': 'demand_score'
-        })
-        ti.xcom_push(key='predicted_prices', value=pickle.dumps(prices_df))
-        logging.info(f"[{store_mode}] Applied surge pricing for {len(prices_df)} products")
-        return len(prices_df)
-
-    def publish_results(**kwargs):
-        ti = kwargs['ti']
-        prices_df = pickle.loads(ti.xcom_pull(key='predicted_prices'))
-        from lib.model_registry import ModelRegistry
-
-        registry = ModelRegistry()
-        dag_conf = kwargs.get('dag_run').conf if kwargs.get('dag_run') else {}
-
-        metadata = {
-            'timestamp': pd.Timestamp.now().isoformat(),
-            'store_mode': store_mode,
-            'dag_run_id': kwargs['dag_run'].run_id if kwargs.get('dag_run') else 'manual',
-            'pricing_method': 'surge',
-            'high_threshold': dag_conf.get('high_threshold', 10),
-            'low_threshold': dag_conf.get('low_threshold', 2),
-            'surge_multiplier': dag_conf.get('surge_multiplier', 1.2),
-            'discount_multiplier': dag_conf.get('discount_multiplier', 0.9)
-        }
-        registry.publish_prices(prices_df, model_name=f'{store_mode}_latest', metadata=metadata)
-        logging.info(f"[{store_mode}] Published surge pricing for {len(prices_df)} products")
-
-        return {
-            'n_products': len(prices_df),
-            'registry_status': 'success',
-            'store_mode': store_mode,
-            'mean_demand': float(prices_df['demand_score'].mean()) if 'demand_score' in prices_df.columns else None
-        }
-
-    return {
-        'fetch_interactions': fetch_interactions,
-        'fetch_price_logs': fetch_price_logs,
-        'compute_demand': compute_demand,
-        'aggregate_price_logs': aggregate_price_logs,
-        'join_product_features': join_product_features,
-        'apply_surge_pricing': apply_surge_pricing,
-        'publish_results': publish_results,
-    }
-
-
-def create_surge_pricing_dag(store_mode: str) -> DAG:
-    """Factory: generates a surge pricing DAG for a given store_mode."""
-    callables = _make_task_callables(store_mode)
-
-    dag = DAG(
-        f'surge_pricing_{store_mode}',
-        default_args=DEFAULT_ARGS,
-        description=f'Surge pricing pipeline for {store_mode} store mode',
-        schedule_interval='*/15 * * * *',
-        start_date=days_ago(1),
-        catchup=False,
-        max_active_runs=1,
-        tags=['pricing', 'surge', 'research', store_mode],
-    )
-
-    with dag:
-        t_fetch_interactions = PythonOperator(
-            task_id='fetch_interactions',
-            python_callable=callables['fetch_interactions'],
-            provide_context=True,
-        )
-        t_fetch_price_logs = PythonOperator(
-            task_id='fetch_price_logs',
-            python_callable=callables['fetch_price_logs'],
-            provide_context=True,
-        )
-        t_compute_demand = PythonOperator(
-            task_id='compute_demand',
-            python_callable=callables['compute_demand'],
-            provide_context=True,
-        )
-        t_aggregate_prices = PythonOperator(
-            task_id='aggregate_price_logs',
-            python_callable=callables['aggregate_price_logs'],
-            provide_context=True,
-        )
-        t_join_features = PythonOperator(
-            task_id='join_product_features',
-            python_callable=callables['join_product_features'],
-            provide_context=True,
-        )
-        t_surge_pricing = PythonOperator(
-            task_id='apply_surge_pricing',
-            python_callable=callables['apply_surge_pricing'],
-            provide_context=True,
-        )
-        t_publish = PythonOperator(
-            task_id='publish_results',
-            python_callable=callables['publish_results'],
-            provide_context=True,
-        )
-
-        t_fetch_interactions >> t_compute_demand
-        t_fetch_price_logs >> t_aggregate_prices
-        [t_compute_demand, t_aggregate_prices] >> t_join_features >> t_surge_pricing >> t_publish
-
-    return dag
-
-
-# instantiate DAGs for Airflow to discover
-dag_airline = create_surge_pricing_dag('airline')
-dag_hotel = create_surge_pricing_dag('hotel')
-
-# TODO: Refactor this factory from a surge pricing factory to a general pricing factory
-# We will do this by passing a pricing strategy class to the factory, since the generic pipeline is:
-# take all interaction data, group by sessionId and assign a new price vector to each session
-# in the grouping we get a subset of the interactions per sessionId and we can map that to some Features
-# we define a custom _get_features(interactions .) methodin the strategy class
-# we then run only the inference which is the .predict(trajectory) per-session which will give us a new price vector
-# this we then publish for each sessionId group
-# this might include no deleting most of the pricers we have defined and starting with a super simple surge-pricing algorithm that is no-fit only predict. This we can then test end-to-end and observe changes to prices according to a desired strategy - we have to define this one as a very short term strategy because we run sessions that take only a few minutes.

experiments/airflow/dags/surge_pricing_pipeline.py

@@ -1,253 +0,0 @@
-from airflow import DAG
-from airflow.operators.python import PythonOperator
-from airflow.utils.dates import days_ago
-from datetime import timedelta
-import pandas as pd
-import logging
-import sys
-import pickle
-import io
-
-# add parent dir to path so procesing package can be imported
-sys.path.insert(0, '/opt/airflow')
-
-from procesing.context import PipelineContext
-from procesing.providers import SupabaseProvider, BackendAPIProvider
-from procesing.steps import (
-    FetchInteractionsStep,
-    FetchPriceLogsStep,
-    ComputeDemandStep,
-    AggregatePriceLogsStep,
-    JoinProductFeaturesStep,
-)
-from procesing.pricers.simple import SimpleSurgePricer
-
-default_args = {
-    'owner': 'phantom-research',
-    'depends_on_past': False,
-    'email_on_failure': False,
-    'email_on_retry': False,
-    'retries': 2,
-    'retry_delay': timedelta(minutes=5),
-}
-
-def get_provider():
-    """Factory to create composite provider"""
-    class CompositeProvider(SupabaseProvider, BackendAPIProvider): # TODO: Fix this into one global provider singelton instead of multiple inheritance declarations acoss the codebase
-        def __init__(self):
-            SupabaseProvider.__init__(self)
-            BackendAPIProvider.__init__(self)
-    return CompositeProvider()
-
-def get_context(**kwargs):
-    """Build pipeline context from Airflow config"""
-    dag_conf = kwargs.get('dag_run').conf if kwargs.get('dag_run') else {}
-    return PipelineContext(
-        provider=get_provider(),
-        store_mode=dag_conf.get('store_mode', 'hotel'),
-    )
-
-# atomic task functions (each wraps one sklearn step)
-def fetch_interactions(**kwargs):
-    """Task: Fetch interaction data from Kafka"""
-    context = get_context(**kwargs)
-    step = FetchInteractionsStep(context)
-    df = step.transform(None)
-
-    kwargs['ti'].xcom_push(key='interactions_raw', value=pickle.dumps(df))
-    logging.info(f"Fetched {len(df)} interaction records")
-    return len(df)
-
-def fetch_price_logs(**kwargs):
-    """Task: Fetch price logs from Kafka"""
-    context = get_context(**kwargs)
-    step = FetchPriceLogsStep(context)
-    df = step.transform(None)
-
-    kwargs['ti'].xcom_push(key='price_logs_raw', value=pickle.dumps(df))
-    logging.info(f"Fetched {len(df)} price records")
-    return len(df)
-
-def compute_demand(**kwargs):
-    """Task: Compute demand scores from interactions"""
-    ti = kwargs['ti']
-    df = pickle.loads(ti.xcom_pull(key='interactions_raw'))
-
-    context = get_context(**kwargs)
-    step = ComputeDemandStep(context)
-    demand_df = step.transform(df)
-    # TODO: clear the xcom
-
-
-    ti.xcom_push(key='demand_data', value=pickle.dumps(demand_df))
-    logging.info(f"Computed demand for {len(demand_df)} products")
-    return len(demand_df)
-
-def aggregate_price_logs(**kwargs):
-    """Task: Aggregate price logs"""
-    ti = kwargs['ti']
-    df = pickle.loads(ti.xcom_pull(key='price_logs_raw'))
-
-    context = get_context(**kwargs)
-    step = AggregatePriceLogsStep(context)
-    price_df = step.transform(df)
-
-    ti.xcom_push(key='price_data', value=pickle.dumps(price_df))
-    logging.info(f"Aggregated price logs for {len(price_df)} products")
-    return len(price_df)
-
-def join_product_features(**kwargs):
-    """Task: Join demand and price data"""
-    ti = kwargs['ti']
-    demand_df = pickle.loads(ti.xcom_pull(key='demand_data'))
-    price_df = pickle.loads(ti.xcom_pull(key='price_data'))
-
-    context = get_context(**kwargs)
-    step = JoinProductFeaturesStep(context)
-    joined_df = step.transform((demand_df, price_df))
-
-    ti.xcom_push(key='product_features', value=pickle.dumps(joined_df))
-    logging.info(f"Joined features for {len(joined_df)} products")
-    return len(joined_df)
-
-def apply_surge_pricing(**kwargs):
-    """Task: Apply surge pricing rules to generate optimal prices"""
-    ti = kwargs['ti']
-    product_features = pickle.loads(ti.xcom_pull(key='product_features'))
-
-    dag_conf = kwargs.get('dag_run').conf if kwargs.get('dag_run') else {}
-
-    # rename demand_score to demand for pricer compatibility
-    data = product_features.rename(columns={'demand_score': 'demand'})
-
-    high_thresh = dag_conf.get('high_threshold', 10)
-    low_thresh = dag_conf.get('low_threshold', 2)
-    surge_mult = dag_conf.get('surge_multiplier', 1.2)
-    discount_mult = dag_conf.get('discount_multiplier', 0.9)
-
-    logging.info(f"Surge pricing config: high_thresh={high_thresh}, low_thresh={low_thresh}, surge_mult={surge_mult}, discount_mult={discount_mult}")
-    logging.info(f"Demand stats: min={data['demand'].min():.2f}, max={data['demand'].max():.2f}, mean={data['demand'].mean():.2f}")
-    logging.info(f"Products with high demand (>={high_thresh}): {(data['demand'] >= high_thresh).sum()}")
-    logging.info(f"Products with low demand (<={low_thresh}): {(data['demand'] <= low_thresh).sum()}")
-
-    surge_pricer = SimpleSurgePricer(
-        high_threshold=high_thresh,
-        low_threshold=low_thresh,
-        surge_multiplier=surge_mult,
-        discount_multiplier=discount_mult
-    )
-    surge_pricer.fit(data)
-    data['optimal_price'] = surge_pricer.predict()
-
-    base_avg = data['base_price'].mean()
-    optimal_avg = data['optimal_price'].mean()
-    price_change_pct = ((optimal_avg - base_avg) / base_avg) * 100
-
-    logging.info(f"Price adjustment: base_avg={base_avg:.2f}, optimal_avg={optimal_avg:.2f}, change={price_change_pct:+.1f}%")
-
-    prices_df = data[['productId', 'price', 'base_price', 'optimal_price', 'demand']].rename(columns={
-        'price': 'current_price',
-        'demand': 'demand_score'
-    })
-
-    ti.xcom_push(key='predicted_prices', value=pickle.dumps(prices_df))
-    logging.info(f"Applied surge pricing for {len(prices_df)} products")
-    return len(prices_df)
-
-def publish_results(**kwargs):
-    """Task: Publish surge pricing results to registry"""
-    ti = kwargs['ti']
-    prices_df = pickle.loads(ti.xcom_pull(key='predicted_prices'))
-
-    sys.path.insert(0, '/opt/airflow')
-    from lib.model_registry import ModelRegistry
-
-    registry = ModelRegistry()
-    dag_conf = kwargs.get('dag_run').conf if kwargs.get('dag_run') else {}
-
-    metadata = {
-        'timestamp': pd.Timestamp.now().isoformat(),
-        'store_mode': dag_conf.get('store_mode', 'hotel'),
-        'dag_run_id': kwargs['dag_run'].run_id if kwargs.get('dag_run') else 'manual',
-        'pricing_method': 'surge',
-        'high_threshold': dag_conf.get('high_threshold', 10),
-        'low_threshold': dag_conf.get('low_threshold', 2),
-        'surge_multiplier': dag_conf.get('surge_multiplier', 1.2),
-        'discount_multiplier': dag_conf.get('discount_multiplier', 0.9)
-    }
-
-    registry.publish_prices(prices_df, model_name='latest', metadata=metadata)
-
-    logging.info(f"Published surge pricing for {len(prices_df)} products")
-
-    return {
-        'n_products': len(prices_df),
-        'registry_status': 'success',
-        'mean_demand': float(prices_df['demand_score'].mean()) if 'demand_score' in prices_df.columns else None
-    }
-
-
-# DAG definition
-with DAG(
-    'surge_pricing_pipeline',
-    default_args=default_args,
-    description='Simple surge pricing pipeline: demand aggregation + rule-based pricing',
-    schedule_interval='*/15 * * * *',
-    start_date=days_ago(1),
-    catchup=False,
-    max_active_runs=1,
-    tags=['pricing', 'surge', 'research', 'simplified'],
-) as dag:
-
-    # parallel data fetching
-    t_fetch_interactions = PythonOperator(
-        task_id='fetch_interactions',
-        python_callable=fetch_interactions,
-        provide_context=True,
-    )
-
-    t_fetch_price_logs = PythonOperator(
-        task_id='fetch_price_logs',
-        python_callable=fetch_price_logs,
-        provide_context=True,
-    )
-
-    # compute demand from interactions
-    t_compute_demand = PythonOperator(
-        task_id='compute_demand',
-        python_callable=compute_demand,
-        provide_context=True,
-    )
-
-    # aggregate price logs
-    t_aggregate_prices = PythonOperator(
-        task_id='aggregate_price_logs',
-        python_callable=aggregate_price_logs,
-        provide_context=True,
-    )
-
-    # join demand and prices
-    t_join_features = PythonOperator(
-        task_id='join_product_features',
-        python_callable=join_product_features,
-        provide_context=True,
-    )
-
-    # apply surge pricing
-    t_surge_pricing = PythonOperator(
-        task_id='apply_surge_pricing',
-        python_callable=apply_surge_pricing,
-        provide_context=True,
-    )
-
-    # publish to registry
-    t_publish = PythonOperator(
-        task_id='publish_results',
-        python_callable=publish_results,
-        provide_context=True,
-    )
-
-    # dependency graph: parallel fetch -> process -> join -> surge -> publish
-    t_fetch_interactions >> t_compute_demand
-    t_fetch_price_logs >> t_aggregate_prices
-    [t_compute_demand, t_aggregate_prices] >> t_join_features >> t_surge_pricing >> t_publish

experiments/ml/__init__.py

@@ -1,11 +0,0 @@
-from .evals import evaluate
-from .arch import (
-    XGBoostAgentClassifier,
-    LightGBMAgentClassifier
-)
-
-__all__ =[
-    'evaluate',
-    'XGBoostAgentClassifier',
-    'LightGBMAgentClassifier'
-]

experiments/ml/arch.py

@@ -1,122 +0,0 @@
-# sklearn compatible models for agent detection
-from sklearn.base import BaseEstimator, ClassifierMixin
-from procesing.context import PipelineContext
-from typing import Any, Optional, Tuple
-from abc import ABC, abstractmethod
-import xgboost as xgb
-import lightgbm as lgb
-import numpy as np
-import pandas as pd
-
-TASK = 'classification'
-LABELS = ['human', 'agent']
-
-
-class BaseAgentClassifier(BaseEstimator, ClassifierMixin, ABC):
-    """Base class for tree-based agent detection classifiers with common logic"""
-
-    def __init__(self, context: Optional[PipelineContext] = None, n_estimators: int = 200,
-                 max_depth: int = 6, learning_rate: float = 0.05,
-                 early_stopping_rounds: int = 20):
-        self.context = context
-        self.n_estimators = n_estimators
-        self.max_depth = max_depth
-        self.learning_rate = learning_rate
-        self.early_stopping_rounds = early_stopping_rounds
-        self.model_ = None
-        self.feature_names_ = None
-
-    def _to_array(self, X):
-        """Convert pandas structures to numpy arrays"""
-        return X.values if isinstance(X, (pd.DataFrame, pd.Series)) else X
-
-    def _compute_pos_weight(self, y_arr):
-        """Calculate scale_pos_weight for class imbalance handling"""
-        n_neg, n_pos = (y_arr == 0).sum(), (y_arr == 1).sum()
-        return n_neg / n_pos if n_pos > 0 else 1.0
-
-    def _prepare_eval_set(self, eval_set):
-        """Convert eval_set to numpy arrays if needed"""
-        if not eval_set:
-            return None
-        X_val, y_val = eval_set[0]
-        return [(self._to_array(X_val), self._to_array(y_val))]
-
-    @abstractmethod
-    def _build_model(self, scale_pos: float):
-        """Build the underlying model instance (must be implemented by subclasses)"""
-        pass
-
-    @abstractmethod
-    def _fit_with_eval(self, X_arr, y_arr, eval_arr):
-        """Fit model with evaluation set (must be implemented by subclasses)"""
-        pass
-
-    def fit(self, X, y, eval_set=None):
-        X_arr, y_arr = self._to_array(X), self._to_array(y)
-
-        if isinstance(X, pd.DataFrame):
-            self.feature_names_ = X.columns.tolist()
-
-        scale_pos = self._compute_pos_weight(y_arr)
-        self.model_ = self._build_model(scale_pos)
-
-        eval_arr = self._prepare_eval_set(eval_set)
-        if eval_arr:
-            self._fit_with_eval(X_arr, y_arr, eval_arr)
-        else:
-            self.model_.fit(X_arr, y_arr)
-
-        return self
-
-    def predict(self, X):
-        return self.model_.predict(self._to_array(X))
-
-    def predict_proba(self, X):
-        return self.model_.predict_proba(self._to_array(X))
-
-    @property
-    def feature_importances_(self):
-        return self.model_.feature_importances_ if self.model_ else None
-
-
-class XGBoostAgentClassifier(BaseAgentClassifier):
-    """XGBoost binary classifier for agent detection with class imbalance handling"""
-
-    def _build_model(self, scale_pos: float):
-        return xgb.XGBClassifier(
-            n_estimators=self.n_estimators,
-            max_depth=self.max_depth,
-            learning_rate=self.learning_rate,
-            scale_pos_weight=scale_pos,
-            eval_metric='auc',
-            early_stopping_rounds=self.early_stopping_rounds,
-            random_state=42,
-            tree_method='hist',
-            enable_categorical=False
-        )
-
-    def _fit_with_eval(self, X_arr, y_arr, eval_arr):
-        self.model_.fit(X_arr, y_arr, eval_set=eval_arr, verbose=False)
-
-
-class LightGBMAgentClassifier(BaseAgentClassifier):
-    """LightGBM binary classifier for agent detection with class imbalance handling"""
-
-    def _build_model(self, scale_pos: float):
-        return lgb.LGBMClassifier(
-            n_estimators=self.n_estimators,
-            max_depth=self.max_depth,
-            learning_rate=self.learning_rate,
-            scale_pos_weight=scale_pos,
-            metric='auc',
-            random_state=42,
-            verbosity=-1
-        )
-
-    def _fit_with_eval(self, X_arr, y_arr, eval_arr):
-        self.model_.fit(
-            X_arr, y_arr,
-            eval_set=eval_arr,
-            callbacks=[lgb.early_stopping(self.early_stopping_rounds, verbose=False)]
-        )

experiments/ml/evals.py

@@ -1,103 +0,0 @@
-from sklearn.metrics import (accuracy_score, precision_score, recall_score,
-                             f1_score, roc_auc_score, confusion_matrix, roc_curve)
-from torch.utils.tensorboard import SummaryWriter
-from logging import getLogger
-import numpy as np
-import matplotlib.pyplot as plt
-import io
-from PIL import Image
-
-logger = getLogger(__name__)
-
-
-def log_feature_importance(writer, model, feature_names, epoch):
-    """Visualize and log feature importance to TensorBoard"""
-    if not hasattr(model, 'feature_importances_') or model.feature_importances_ is None:
-        return
-
-    importance = model.feature_importances_
-    indices = np.argsort(importance)[::-1][:20]  # top 20
-    top_features = [feature_names[i] for i in indices]
-    top_importance = importance[indices]
-
-    for i, (feat, imp) in enumerate(zip(top_features, top_importance)):
-        writer.add_scalar(f'FeatureImportance/{feat}', imp, epoch)
-
-    fig, ax = plt.subplots(figsize=(10, 8))
-    ax.barh(range(len(top_features)), top_importance, align='center')
-    ax.set_yticks(range(len(top_features)))
-    ax.set_yticklabels(top_features)
-    ax.invert_yaxis()
-    ax.set_xlabel('Importance')
-    ax.set_title(f'Top 20 Feature Importance (Epoch {epoch})')
-    ax.grid(axis='x', alpha=0.3)
-
-    buf = io.BytesIO()
-    plt.tight_layout()
-    plt.savefig(buf, format='png', dpi=100)
-    buf.seek(0)
-    img = Image.open(buf)
-    img_arr = np.array(img)
-    writer.add_image('FeatureImportance/Chart', img_arr, epoch, dataformats='HWC')
-    plt.close()
-
-def evaluate(perdicted_class, predicted_proba, true_class, writer: SummaryWriter, epoch: int):
-    accuracy = accuracy_score(true_class, perdicted_class)
-    precision = precision_score(true_class, perdicted_class, zero_division=0)
-    recall = recall_score(true_class, perdicted_class, zero_division=0)
-    f1 = f1_score(true_class, perdicted_class, zero_division=0)
-    roc_auc = roc_auc_score(true_class, predicted_proba)
-
-    writer.add_scalar('Eval/Accuracy', accuracy, epoch)
-    writer.add_scalar('Eval/Precision', precision, epoch)
-    writer.add_scalar('Eval/Recall', recall, epoch)
-    writer.add_scalar('Eval/F1_Score', f1, epoch)
-    writer.add_scalar('Eval/ROC_AUC', roc_auc, epoch)
-
-    # confusion matrix
-    cm = confusion_matrix(true_class, perdicted_class)
-    tn, fp, fn, tp = cm.ravel()
-    writer.add_scalar('Eval/TrueNeg', tn, epoch)
-    writer.add_scalar('Eval/FalsePos', fp, epoch)
-    writer.add_scalar('Eval/FalseNeg', fn, epoch)
-    writer.add_scalar('Eval/TruePos', tp, epoch)
-
-    # specificity and sensitivity
-    specificity = tn / (tn + fp) if (tn + fp) > 0 else 0
-    sensitivity = recall  # same as recall/TPR
-    writer.add_scalar('Eval/Specificity', specificity, epoch)
-    writer.add_scalar('Eval/Sensitivity', sensitivity, epoch)
-
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
-    ax1.matshow(cm, cmap='Blues', alpha=0.7)
-    for i in range(2):
-        for j in range(2):
-            ax1.text(j, i, str(cm[i, j]), ha='center', va='center', fontsize=14)
-    ax1.set_xlabel('Predicted')
-    ax1.set_ylabel('True')
-    ax1.set_title(f'Confusion Matrix (Epoch {epoch})')
-    ax1.set_xticks([0, 1])
-    ax1.set_yticks([0, 1])
-    ax1.set_xticklabels(['Human', 'Agent'])
-    ax1.set_yticklabels(['Human', 'Agent'])
-
-    # ROC curve
-    fpr, tpr, _ = roc_curve(true_class, predicted_proba)
-    ax2.plot(fpr, tpr, label=f'AUC={roc_auc:.3f}', linewidth=2)
-    ax2.plot([0, 1], [0, 1], 'k--', label='Random')
-    ax2.set_xlabel('False Positive Rate')
-    ax2.set_ylabel('True Positive Rate')
-    ax2.set_title('ROC Curve')
-    ax2.legend()
-    ax2.grid(alpha=0.3)
-
-    buf = io.BytesIO()
-    plt.tight_layout()
-    plt.savefig(buf, format='png', dpi=100)
-    buf.seek(0)
-    img = Image.open(buf)
-    img_arr = np.array(img)
-    writer.add_image('Eval/Metrics', img_arr, epoch, dataformats='HWC')
-    plt.close()
-
-    logger.info(f"Eval {epoch}: Acc={accuracy:.4f} Prec={precision:.4f} Rec={recall:.4f} F1={f1:.4f} AUC={roc_auc:.4f}")

experiments/ml/requirements.txt

@@ -1,6 +0,0 @@
-torch
-tensorboard
-fastparquet
-pyarrow
-xgboost
-lightgbm

experiments/ml/train.py

@@ -1,137 +0,0 @@
-from torch.utils.tensorboard import SummaryWriter
-from sklearn.model_selection import train_test_split
-from logging import getLogger
-from pathlib import Path
-import pandas as pd
-import numpy as np
-import joblib
-from datetime import datetime
-from ml.evals import evaluate, log_feature_importance
-from ml.arch import XGBoostAgentClassifier, LightGBMAgentClassifier, LABELS
-
-logger = getLogger(__name__)
-
-FEATURE_COLS_EXCLUDE = ['sessionId', 'experimentId', 'is_agent', 'xp_human_only', 'xp_market_mode', 'browser_family']
-RUNS_DIR = Path('ml/runs')
-CHECKPOINTS_DIR = Path('ml/checkpoints')
-
-
-def prepare_data(df):
-    """
-    Prepare feature matrix and labels from raw dataframe
-    Handles missing labels, feature selection, and categorical encoding
-    Returns: (X, y, feature_cols)
-    """
-    # drop rows with missing labels
-    n_before = len(df)
-    df = df[df['is_agent'].notna()].copy()
-    n_dropped = n_before - len(df)
-    if n_dropped > 0:
-        logger.warning(f"Dropped {n_dropped} sessions with missing labels")
-
-    if len(df) == 0:
-        logger.error("No labeled data available")
-        return None, None, None
-
-    feature_cols = [c for c in df.columns if c not in FEATURE_COLS_EXCLUDE]
-
-    # handle categorical browser_family via one-hot encoding
-    if 'browser_family' in df.columns:
-        browser_dummies = pd.get_dummies(df['browser_family'], prefix='browser', drop_first=True)
-        df = pd.concat([df, browser_dummies], axis=1)
-        feature_cols.extend(browser_dummies.columns.tolist())
-
-    X = df[feature_cols].fillna(0)
-    y = df['is_agent'].astype(int)
-
-    return X, y, feature_cols
-
-
-def train(data_path=None, model_type='xgboost', test_size=0.2, random_state=42,
-          n_estimators=200, max_depth=6, learning_rate=0.05):
-    """
-    Train agent detection classifier
-    Args:
-        data_path: path to labeled feature matrix CSV or parquet
-        model_type: 'xgboost' or 'lightgbm'
-        test_size: fraction for test split
-        random_state: seed for reproducibility
-    """
-    RUNS_DIR.mkdir(exist_ok=True)
-    CHECKPOINTS_DIR.mkdir(exist_ok=True)
-
-    run_name = f"{model_type}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-    writer = SummaryWriter(log_dir=RUNS_DIR / run_name)
-    logger.info(f"Starting training run: {run_name}")
-
-    # load data
-    if data_path is None:
-        logger.error("data_path required")
-        return
-    df = pd.read_parquet(data_path)
-    logger.info(f"Loaded {len(df)} sessions from {data_path}")
-
-    # prepare features and labels
-    if 'is_agent' not in df.columns:
-        logger.error("Missing is_agent column")
-        return
-
-    X, y, feature_cols = prepare_data(df)
-    if X is None:
-        return
-
-    # class distribution
-    n_agents = y.sum()
-    n_humans = (y == 0).sum()
-    logger.info(f"Class distribution: {n_humans} humans, {n_agents} agents" + (f" (ratio {n_humans / n_agents:.2f})" if n_agents > 0 else ""))
-
-    # train/test split with stratification
-    X_train, X_test, y_train, y_test = train_test_split(
-        X, y, test_size=test_size, random_state=random_state, stratify=y
-    )
-    logger.info(f"Train: {len(X_train)}, Test: {len(X_test)}")
-
-    # init model
-    if model_type == 'xgboost':
-        model = XGBoostAgentClassifier(
-            n_estimators=n_estimators,
-            max_depth=max_depth,
-            learning_rate=learning_rate
-        )
-    elif model_type == 'lightgbm':
-        model = LightGBMAgentClassifier(
-            n_estimators=n_estimators,
-            max_depth=max_depth,
-            learning_rate=learning_rate
-        )
-    else:
-        logger.error(f"Unknown model type: {model_type}")
-        return
-
-    # train with eval set for early stopping
-    model.fit(X_train, y_train, eval_set=[(X_test, y_test)])
-    logger.info("Training complete")
-
-    # evaluate on test set
-    y_pred = model.predict(X_test)
-    y_prob = model.predict_proba(X_test)[:, 1]
-
-    evaluate(y_pred, y_prob, y_test, writer, epoch=0)
-
-    # log feature importance
-    log_feature_importance(writer, model, X.columns.tolist(), epoch=0)
-
-    # save model
-    model_path = CHECKPOINTS_DIR / f"{run_name}.pkl"
-    joblib.dump({'model': model, 'feature_cols': X.columns.tolist(), 'run_name': run_name}, model_path)
-    logger.info(f"Model saved to {model_path}")
-
-    writer.close()
-    return model, X.columns.tolist()
-
-
-if __name__ == "__main__":
-    import sys
-    data_path = sys.argv[1]
-    model_type = sys.argv[2] if len(sys.argv) > 2 else 'xgboost'
-    train(data_path, model_type=model_type)

experiments/procesing/__init__.py

@@ -1,51 +0,0 @@
-from procesing.context import PipelineContext
-from procesing.providers import DataProvider, SupabaseProvider, BackendAPIProvider
-from procesing.steps import (
-    BaseContextStep,
-    FetchInteractionsStep,
-    FetchPriceLogsStep,
-    FetchExperimentsStep,
-    JoinExperimentsStep,
-    CreatePriceBucketsStep,
-    AugmentEventNamesStep,
-    ChunkByTimeWindowStep,
-    ComputeDemandStep,
-    ComputeDemandForChunksStep,
-    AggregatePriceLogsStep,
-    # StateSpace,
-    # BuildStateSpaceStep,
-    FitPricingFunctionStep,
-    PredictPricesStep,
-)
-from procesing.pipelines import (
-    interaction_extraction_pipeline,
-    price_extraction_pipeline,
-    pricing_pipeline,
-    full_pipeline,
-)
-
-__all__ = [
-    'PipelineContext',
-    'DataProvider',
-    'SupabaseProvider',
-    'BackendAPIProvider',
-    'BaseContextStep',
-    'FetchInteractionsStep',
-    'FetchPriceLogsStep',
-    'FetchExperimentsStep',
-    'JoinExperimentsStep',
-    'CreatePriceBucketsStep',
-    'AugmentEventNamesStep',
-    'ChunkByTimeWindowStep',
-    'ComputeDemandStep',
-    'ComputeDemandForChunksStep',
-    'AggregatePriceLogsStep',
-    # 'StateSpace',
-    # 'BuildStateSpaceStep',
-    'FitPricingFunctionStep',
-    'PredictPricesStep',
-    'interaction_extraction_pipeline',
-    'price_extraction_pipeline',
-    'pricing_pipeline',
-    'full_pipeline',
-]

experiments/procesing/context.py

@@ -1,34 +0,0 @@
-from typing import Any, Dict
-import pandas as pd
-from procesing.providers.base import DataProvider
-
-class PipelineContext:
-    """
-    Context for pipeline execution holding config, provider, and cached data.
-    Enables dependency injection and eliminates global state.
-    """
-
-    def __init__(self,
-                 provider: DataProvider,
-                 store_mode: str,
-                 window_size: str = '30s',
-                 **config):
-        self.provider = provider
-        self.store_mode = store_mode
-        self.window_size = window_size
-        self.config = config
-        self._cache: Dict[str, Any] = {}
-
-    def get_cached(self, key: str, default=None):
-        return self._cache.get(key, default)
-
-    def cache(self, key: str, value):
-        self._cache[key] = value
-        return value
-
-    @property
-    def products(self) -> pd.DataFrame:
-        """Lazy-load and cache product catalog, single fetch per pipeline run"""
-        if 'products' not in self._cache:
-            self._cache['products'] = self.provider.fetch_products(self.store_mode)
-        return self._cache['products']

experiments/procesing/elasticity.py

@@ -1,332 +0,0 @@
-import numpy as np
-import pandas as pd
-from typing import List, Dict, Optional
-from sklearn.base import BaseEstimator, TransformerMixin
-from supabase import create_client, Client
-import os
-
-SUPABASE_URL = os.getenv("NEXT_PUBLIC_SUPABASE_URL", "")
-SUPABASE_KEY = os.getenv("NEXT_PUBLIC_SUPABASE_ANON_KEY", "")
-
-supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
-
-class TemporalElasticityEstimator(BaseEstimator, TransformerMixin):
-    """
-    Compute price elasticity from time-series demand and price data.
-
-    Elasticity = (% change in quantity) / (% change in price)
-
-    Works with chunked time-window data from ChunkInteractionsIntoSteps.
-    """
-
-    def __init__(self,
-                 method:str='point',
-                 min_observations:int=2,
-                 smooth_window:Optional[int]=None):
-        """
-        Args:
-            method: 'point' (point elasticity) or 'arc' (arc elasticity)
-            min_observations: min data points needed per product
-            smooth_window: if set, apply rolling avg smoothing to time series
-        """
-        self.method = method
-        self.min_observations = min_observations
-        self.smooth_window = smooth_window
-
-    def fit(self, X):
-        return self
-
-    def transform(self,
-                  demand_chunks: List[Dict],
-                  price_chunks: List[Dict],
-                  store_mode: str = 'hotel') -> pd.DataFrame:
-        """
-        Args:
-            demand_chunks: list from ChunkInteractionsIntoSteps + DemandEstimator
-                           each item: {'window_start', 'window_end', 'demand_vector'}
-            price_chunks: list of dicts with {'window_start', 'window_end', 'price_vector'}
-            store_mode: 'hotel' or 'airline' to fetch all products
-
-        Returns:
-            df with [productId, elasticity, std_error, n_observations]
-        """
-        # fetch all products from database
-        all_products = supabase.table(f'{store_mode}_products').select("id").execute()
-        all_product_ids = [p['id'] for p in all_products.data]
-
-        aligned = self._align_chunks(demand_chunks, price_chunks)
-        if not aligned:
-            # return all products with zero elasticity
-            return pd.DataFrame({
-                'productId': all_product_ids,
-                'elasticity': 0.0,
-                'std_error': 0.0,
-                'n_obs': 0
-            })
-
-        # build time series per product
-        product_series = self._build_product_timeseries(aligned)
-
-        # compute elasticity per product
-        elasticities = []
-        for pid, series in product_series.items():
-            if len(series) < self.min_observations:
-                # assign 0 elasticity for products with insufficient data
-                elasticities.append({
-                    'productId': pid,
-                    'elasticity': 0.0,
-                    'std_error': 0.0,
-                    'n_obs': len(series)
-                })
-                continue
-
-            # apply smoothing if requested
-            if self.smooth_window and len(series) >= self.smooth_window:
-                series = self._smooth_series(series, self.smooth_window)
-
-            elast = self._compute_elasticity(series)
-            elasticities.append({
-                'productId': pid,
-                'elasticity': elast['value'],
-                'std_error': elast.get('std_error', 0.0),
-                'n_obs': len(series)
-            })
-
-        result_df = pd.DataFrame(elasticities)
-
-        # fill in missing products with zero elasticity
-        observed_pids = set(result_df['productId'].unique())
-        missing_pids = [pid for pid in all_product_ids if pid not in observed_pids]
-
-        if missing_pids:
-            missing_df = pd.DataFrame({
-                'productId': missing_pids,
-                'elasticity': 0.0,
-                'std_error': 0.0,
-                'n_obs': 0
-            })
-            result_df = pd.concat([result_df, missing_df], ignore_index=True)
-
-        return result_df
-
-    def _align_chunks(self, demand_chunks, price_chunks):
-        """Align demand and price data by matching time windows."""
-        aligned = []
-
-        # create lookup for price chunks by window_start
-        price_lookup = {chunk['window_start']: chunk for chunk in price_chunks}
-
-        for demand_chunk in demand_chunks:
-            window_start = demand_chunk['window_start']
-            if window_start in price_lookup:
-                aligned.append({
-                    'window_start': window_start,
-                    'window_end': demand_chunk['window_end'],
-                    'demand': demand_chunk['demand_vector'],
-                    'prices': price_lookup[window_start]['price_vector']
-                })
-
-        return aligned
-
-    def _build_product_timeseries(self, aligned_chunks):
-        """Build time series [price, quantity] per product."""
-        # vectorize chunk merging instead of iterating rows
-        all_merged = []
-        for chunk in aligned_chunks:
-            merged = chunk['demand'].merge(chunk['prices'], on='productId', how='inner')
-            merged['timestamp'] = chunk['window_start']
-            all_merged.append(merged[['productId', 'timestamp', 'price', 'demand_score']])
-
-        if not all_merged:
-            return {}
-
-        # concat all chunks and group by productId in one pass
-        combined = pd.concat(all_merged, ignore_index=True)
-        series_by_product = {
-            pid: group[['timestamp', 'price', 'demand_score']].rename(
-                columns={'demand_score': 'quantity'}
-            ).to_dict('records')
-            for pid, group in combined.groupby('productId')
-        }
-
-        return series_by_product
-
-    def _smooth_series(self, series, window):
-        """Apply rolling average smoothing."""
-        df = pd.DataFrame(series)
-        df['price_smooth'] = df['price'].rolling(window=window, center=True).mean()
-        df['quantity_smooth'] = df['quantity'].rolling(window=window, center=True).mean()
-        df = df.dropna()
-
-        return [{'timestamp': row['timestamp'],
-                 'price': row['price_smooth'],
-                 'quantity': row['quantity_smooth']}
-                for _, row in df.iterrows()]
-
-    def _compute_elasticity(self, series):
-        """Compute elasticity from time series."""
-        if len(series) < 2:
-            return {'value': 0.0, 'std_error': 0.0}
-
-        prices = np.array([s['price'] for s in series])
-        quantities = np.array([s['quantity'] for s in series])
-
-        # filter out zero/negative values
-        valid = (prices > 0) & (quantities > 0)
-        if valid.sum() < 2:
-            return {'value': 0.0, 'std_error': 0.0}
-
-        prices = prices[valid]
-        quantities = quantities[valid]
-
-        if self.method == 'point':
-            return self._point_elasticity(prices, quantities)
-        elif self.method == 'arc':
-            return self._arc_elasticity(prices, quantities)
-        else:
-            raise ValueError(f"Unknown method: {self.method}")
-
-    def _point_elasticity(self, prices, quantities):
-        """
-        Point elasticity using log-log regression.
-        log(Q) = a + b*log(P), elasticity = b
-        """
-        if len(prices) < 2:
-            return {'value': 0.0, 'std_error': 0.0}
-
-        log_p = np.log(prices)
-        log_q = np.log(quantities)
-
-        # simple linear regression
-        if log_p.std() == 0:
-            return {'value': 0.0, 'std_error': 0.0}
-
-        cov = np.cov(log_p, log_q)[0, 1]
-        var = np.var(log_p)
-        b = cov / var
-
-        # std error estimate (avoid div by zero)
-        if len(prices) <= 2:
-            se_b = 0.0
-        else:
-            residuals = log_q - (log_q.mean() + b * (log_p - log_p.mean()))
-            mse = (residuals ** 2).sum() / (len(prices) - 2)
-            se_b = np.sqrt(mse / (len(prices) * var))
-
-        return {'value': b, 'std_error': se_b}
-
-    def _arc_elasticity(self, prices, quantities):
-        """
-        Arc elasticity: average of period-over-period elasticities.
-        E_t = (ΔQ/Q_avg) / (ΔP/P_avg)
-        """
-        elasticities = []
-
-        for i in range(1, len(prices)):
-            p1, p2 = prices[i-1], prices[i]
-            q1, q2 = quantities[i-1], quantities[i]
-
-            p_avg = (p1 + p2) / 2
-            q_avg = (q1 + q2) / 2
-
-            if p_avg == 0 or q_avg == 0:
-                continue
-
-            delta_p = p2 - p1
-            delta_q = q2 - q1
-
-            if delta_p == 0:
-                continue
-
-            e = (delta_q / q_avg) / (delta_p / p_avg)
-            elasticities.append(e)
-
-        if not elasticities:
-            return None
-
-        return {
-            'value': np.mean(elasticities),
-            'std_error': np.std(elasticities) / np.sqrt(len(elasticities))
-        }
-
-
-def aggregate_price_logs(price_logs: pd.DataFrame,
-                         window_size: str = '1H',
-                         ts_col: str = 'ts',
-                         store_mode : str = 'hotel') -> List[Dict]:
-    """
-    Recover price vectors treating prices as persistent state changes.
-
-    Prices are set-operations that persist until next change. For each window:
-    - If price logs exist: average all changes within window
-    - If no logs: carry forward last price before window end
-
-    Args:
-        price_logs: df with [productId, price, ts, ...]
-        window_size: time window size matching ChunkInteractionsIntoSteps
-        ts_col: timestamp column name
-
-    Returns:
-        list of dicts with {'window_start', 'window_end', 'price_vector'}
-        where price_vector is df with [productId, price]
-    """
-    if price_logs.empty:
-        return []
-
-    df = price_logs.copy()
-
-    if not pd.api.types.is_datetime64_any_dtype(df[ts_col]):
-        df[ts_col] = pd.to_datetime(df[ts_col])
-
-    df = df.sort_values([ts_col, 'productId'])
-    all_products=supabase.table(f'{store_mode}_products').select("id, room_type, date_index, metadata, availability").execute()
-    all_products = pd.DataFrame(all_products.data)
-    unique_products = all_products['id'].unique()
-
-    # generate windows across data range
-    min_time, max_time = df[ts_col].min(), df[ts_col].max()
-    windows = pd.date_range(
-        start=min_time.floor(window_size),
-        end=max_time,
-        freq=window_size
-    )
-
-    chunks = []
-
-    for window_start in windows:
-        window_end = window_start + pd.Timedelta(window_size)
-        price_vector = []
-
-        # all products with price history by window_end
-        #historical_products = df[df[ts_col] < window_end]['productId'].unique()
-        historical_products = unique_products.tolist()
-
-        for pid in historical_products:
-            product_data = df[df['productId'] == pid]
-
-            # logs within window
-            in_window = product_data[
-                (product_data[ts_col] >= window_start) &
-                (product_data[ts_col] < window_end)
-            ]
-
-            if not in_window.empty:
-                # average changes within window
-                price = in_window['price'].mean()
-            else:
-                # carry forward: last price before window end
-                before_window = product_data[product_data[ts_col] < window_end]
-                if before_window.empty:
-                    continue
-                price = before_window['price'].iloc[-1]
-
-            price_vector.append({'productId': pid, 'price': price})
-
-        if price_vector:
-            chunks.append({
-                'window_start': window_start,
-                'window_end': window_end,
-                'price_vector': pd.DataFrame(price_vector)
-            })
-
-    return chunks

experiments/procesing/metrics.py

@@ -1,245 +0,0 @@
-"""
-Revenue and KPI benchmark framework for pricing strategies.
-
-Computes session-level and aggregate metrics to compare pricing functions:
-    - Revenue: R_T = Σ P_t^T · Q_t
-    - Conversion rate
-    - Average order value (AOV)
-    - Agent exploitation loss: L_agent = R_oracle - R_observed
-"""
-from typing import Dict, List, Any, Optional
-from dataclasses import dataclass, field, asdict
-import pandas as pd
-import numpy as np
-
-
-@dataclass
-class SessionMetrics:
-    """KPIs for single session."""
-    session_id: str
-    experiment_id: Optional[str] = None
-
-    # interaction metrics
-    total_interactions: int = 0
-    page_views: int = 0
-    item_views: int = 0
-    searches: int = 0
-    cart_adds: int = 0
-
-    # revenue metrics
-    items_purchased: int = 0
-    total_revenue: float = 0.0
-    avg_item_price: float = 0.0
-    conversion_rate: float = 0.0
-
-    # pricing signals
-    total_price_shown: float = 0.0  # sum of all prices displayed
-    avg_markup: float = 0.0  # avg (price / base_price)
-
-    # behavioral features (for agent detection)
-    interaction_velocity: float = 0.0  # interactions per minute
-    session_duration_sec: float = 0.0
-    unique_products_viewed: int = 0
-
-    metadata: Dict[str, Any] = field(default_factory=dict)
-
-    def to_dict(self) -> Dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass
-class AggregateMetrics:
-    """Aggregate KPIs across sessions/experiments."""
-    experiment_id: Optional[str] = None
-    n_sessions: int = 0
-
-    # revenue aggregates
-    total_revenue: float = 0.0
-    avg_revenue_per_session: float = 0.0
-    median_revenue_per_session: float = 0.0
-
-    # conversion aggregates
-    total_conversions: int = 0
-    conversion_rate: float = 0.0  # purchases / sessions
-
-    # pricing aggregates
-    avg_markup: float = 0.0
-    median_markup: float = 0.0
-
-    # agent exploitation metrics
-    estimated_agent_sessions: int = 0  # sessions flagged as agent-driven
-    agent_revenue: float = 0.0
-    human_revenue: float = 0.0
-    agent_loss: float = 0.0  # L_agent = R_oracle - R_observed (if available)
-
-    def to_dict(self) -> Dict[str, Any]:
-        return asdict(self)
-
-
-class MetricsComputer:
-    """Compute session and aggregate metrics from interaction/price logs."""
-
-    @staticmethod
-    def compute_session_metrics(
-        session_id: str,
-        interactions: pd.DataFrame,
-        price_logs: pd.DataFrame,
-        purchases: Optional[pd.DataFrame] = None,
-        experiment_id: Optional[str] = None
-    ) -> SessionMetrics:
-        """
-        Compute metrics for single session.
-
-        Args:
-            session_id: session identifier
-            interactions: user-interactions events for this session
-            price_logs: price-logs for this session
-            purchases: purchase events (if available)
-            experiment_id: experiment identifier
-        """
-        metrics = SessionMetrics(session_id=session_id, experiment_id=experiment_id)
-
-        if interactions.empty:
-            return metrics
-
-        # interaction counts
-        event_counts = interactions['eventName'].value_counts().to_dict()
-        metrics.total_interactions = len(interactions)
-        metrics.page_views = event_counts.get('page_view', 0) + event_counts.get('view_item_page', 0)
-        metrics.item_views = event_counts.get('view_item_page', 0)
-        metrics.searches = event_counts.get('search', 0)
-        metrics.cart_adds = event_counts.get('add_item_to_cart', 0)
-
-        # unique products viewed
-        metrics.unique_products_viewed = interactions['productId'].dropna().nunique()
-
-        # session duration
-        if 'ts' in interactions.columns:
-            timestamps = pd.to_datetime(interactions['ts'])
-            metrics.session_duration_sec = (timestamps.max() - timestamps.min()).total_seconds()
-            if metrics.session_duration_sec > 0:
-                metrics.interaction_velocity = (metrics.total_interactions / metrics.session_duration_sec) * 60
-
-        # revenue from purchases
-        if purchases is not None and not purchases.empty:
-            metrics.items_purchased = len(purchases)
-            metrics.total_revenue = purchases['price'].sum() if 'price' in purchases.columns else 0.0
-            metrics.avg_item_price = metrics.total_revenue / metrics.items_purchased if metrics.items_purchased > 0 else 0.0
-            metrics.conversion_rate = 1.0 if metrics.items_purchased > 0 else 0.0
-
-        # pricing metrics
-        if not price_logs.empty:
-            metrics.total_price_shown = price_logs['price'].sum()
-            # compute markup if base_price available in price logs or join with product catalog
-            if 'base_price' in price_logs.columns:
-                valid_markup = price_logs[price_logs['base_price'] > 0]
-                if not valid_markup.empty:
-                    metrics.avg_markup = (valid_markup['price'] / valid_markup['base_price']).mean()
-
-        return metrics
-
-    @staticmethod
-    def compute_aggregate_metrics(
-        session_metrics_list: List[SessionMetrics],
-        experiment_id: Optional[str] = None,
-        agent_detector_fn: Optional[callable] = None
-    ) -> AggregateMetrics:
-        """
-        Aggregate metrics across sessions.
-
-        Args:
-            session_metrics_list: list of SessionMetrics
-            experiment_id: experiment identifier
-            agent_detector_fn: optional function to classify session as agent (returns bool)
-        """
-        agg = AggregateMetrics(experiment_id=experiment_id)
-        agg.n_sessions = len(session_metrics_list)
-
-        if agg.n_sessions == 0:
-            return agg
-
-        df = pd.DataFrame([m.to_dict() for m in session_metrics_list])
-
-        # revenue aggregates
-        agg.total_revenue = df['total_revenue'].sum()
-        agg.avg_revenue_per_session = df['total_revenue'].mean()
-        agg.median_revenue_per_session = df['total_revenue'].median()
-
-        # conversion aggregates
-        agg.total_conversions = (df['items_purchased'] > 0).sum()
-        agg.conversion_rate = agg.total_conversions / agg.n_sessions
-
-        # pricing aggregates
-        valid_markups = df[df['avg_markup'] > 0]
-        if not valid_markups.empty:
-            agg.avg_markup = valid_markups['avg_markup'].mean()
-            agg.median_markup = valid_markups['avg_markup'].median()
-
-        # agent detection (if detector provided)
-        if agent_detector_fn is not None:
-            agent_flags = [agent_detector_fn(m) for m in session_metrics_list]
-            agg.estimated_agent_sessions = sum(agent_flags)
-
-            agent_revenue = sum(m.total_revenue for m, is_agent in zip(session_metrics_list, agent_flags) if is_agent)
-            human_revenue = sum(m.total_revenue for m, is_agent in zip(session_metrics_list, agent_flags) if not is_agent)
-
-            agg.agent_revenue = agent_revenue
-            agg.human_revenue = human_revenue
-
-        return agg
-
-    @staticmethod
-    def compare_pricing_strategies(
-        experiments: Dict[str, List[SessionMetrics]],
-        baseline_experiment_id: Optional[str] = None
-    ) -> pd.DataFrame:
-        """
-        Compare multiple pricing strategies/experiments.
-
-        Args:
-            experiments: dict mapping experiment_id -> list of SessionMetrics
-            baseline_experiment_id: experiment to use as baseline for comparison
-
-        Returns:
-            DataFrame with comparative metrics
-        """
-        results = []
-        baseline_agg = None
-
-        for exp_id, session_metrics in experiments.items():
-            agg = MetricsComputer.compute_aggregate_metrics(session_metrics, experiment_id=exp_id)
-            result = agg.to_dict()
-
-            if exp_id == baseline_experiment_id:
-                baseline_agg = agg
-
-            results.append(result)
-
-        df = pd.DataFrame(results)
-
-        # add relative metrics if baseline exists
-        if baseline_agg is not None:
-            df['revenue_lift_pct'] = ((df['total_revenue'] - baseline_agg.total_revenue) / baseline_agg.total_revenue * 100)
-            df['conversion_lift_pct'] = ((df['conversion_rate'] - baseline_agg.conversion_rate) / baseline_agg.conversion_rate * 100)
-
-        return df
-
-
-def simple_agent_detector(session_metrics: SessionMetrics, velocity_threshold: float = 5.0) -> bool:
-    """
-    Simple heuristic agent detector based on interaction velocity.
-
-    Args:
-        session_metrics: SessionMetrics instance
-        velocity_threshold: interactions per minute threshold (default: 5.0)
-
-    Returns:
-        True if session likely agent-driven
-    """
-    # agents tend to have higher interaction velocity and lower session duration
-    if session_metrics.interaction_velocity > velocity_threshold:
-        return True
-    # agents often view many products quickly without converting
-    if session_metrics.unique_products_viewed > 10 and session_metrics.conversion_rate == 0:
-        return True
-    return False

experiments/procesing/pipelines.py

@@ -1,174 +0,0 @@
-from sklearn.pipeline import Pipeline
-import pandas as pd
-from procesing.context import PipelineContext
-from procesing.providers import SupabaseProvider, BackendAPIProvider
-import os
-from procesing.steps import (
-    FetchInteractionsStep,
-    FetchPriceLogsStep,
-    FetchExperimentsStep,
-    JoinExperimentsStep,
-    CreatePriceBucketsStep,
-    AugmentEventNamesStep,
-    ChunkByTimeWindowStep,
-    ComputeDemandForChunksStep,
-    AggregatePriceLogsStep,
-    FitPricingFunctionStep,
-    PredictPricesStep,
-    ComputeDemandStep,
-    JoinProductFeaturesStep,
-    ExtractSessionFeaturesStep,
-    JoinLabelsStep,
-    ValidateDataStep,
-)
-from procesing.pricers import SimpleSurgePricer
-
-def interaction_extraction_pipeline(context: PipelineContext):
-    """Pipeline for extracting and augmenting interaction data"""
-    return Pipeline([
-        ('fetch', FetchInteractionsStep(context)),
-        ('create_buckets', CreatePriceBucketsStep(context)),
-        ('augment_events', AugmentEventNamesStep(context)),
-    ])
-
-
-def price_extraction_pipeline(context: PipelineContext):
-    """Pipeline for extracting price logs"""
-    return Pipeline([
-        ('fetch', FetchPriceLogsStep(context)),
-    ])
-
-
-def product_features_pipeline(context: PipelineContext,
-                                    interactions_df: pd.DataFrame,
-                                    price_logs_df: pd.DataFrame):
-    demand_step = ComputeDemandStep(context)
-    price_step = AggregatePriceLogsStep(context)
-    join_step = JoinProductFeaturesStep(context)
-
-
-    demand_data = demand_step.transform(interactions_df)
-    price_data= price_step.transform(price_logs_df)
-    joined_data = join_step.transform((demand_data, price_data))
-
-    return joined_data
-
-
-
-def pricing_pipeline(context: "PipelineContext",
-                     data: pd.DataFrame,
-                     high_threshold: int = 10,
-                     low_threshold: int = 2,
-                     surge_multiplier: float = 1.2,
-                     discount_multiplier: float = 0.9) -> pd.DataFrame:
-
-    if data.empty or 'productId' not in data.columns:
-        return pd.DataFrame()
-
-    surge_pricer = SimpleSurgePricer()
-    surge_pricer.fit(data)
-    data['optimal_price'] = surge_pricer.predict()
-    return data
-
-
-def full_pipeline(context: PipelineContext,
-                  high_threshold: int = 10,
-                  low_threshold: int = 2,
-                  surge_multiplier: float = 1.2,
-                  discount_multiplier: float = 0.9):
-    """
-    Complete end-to-end pipeline: data extraction -> demand/price aggregation -> surge pricing
-
-    Args:
-        context: Pipeline context
-        high_threshold: Demand threshold for surge pricing
-        low_threshold: Demand threshold for discounts
-        surge_multiplier: Price multiplier for high demand
-        discount_multiplier: Price multiplier for low demand
-
-    Returns:
-        tuple: (product_features_df, optimal_prices_df)
-            - product_features_df: [productId, demand_score, price]
-            - optimal_prices_df: [productId, current_price, optimal_price, demand_score]
-    """
-    interaction_pipe = interaction_extraction_pipeline(context)
-    price_pipe = price_extraction_pipeline(context)
-
-    interactions_df = interaction_pipe.fit_transform(None)
-    price_logs_df = price_pipe.fit_transform(None)
-    product_features_df = product_features_pipeline(context, interactions_df, price_logs_df)
-    print(product_features_df.to_string())
-
-    # generate optimal prices using surge rules
-    optimal_prices_df = pricing_pipeline(context, product_features_df,
-                                          high_threshold=high_threshold,
-                                          low_threshold=low_threshold,
-                                          surge_multiplier=surge_multiplier,
-                                          discount_multiplier=discount_multiplier)
-
-    return product_features_df, optimal_prices_df
-
-
-def ml_training_pipeline(context: PipelineContext) -> pd.DataFrame:
-    """
-    Build labeled session-level feature matrix for ML model training.
-    Pipeline: fetch -> validate -> extract features -> join labels
-
-    Returns:
-        DataFrame with ~25 features per session + is_agent label
-        Columns: sessionId, experimentId, temporal/behavioral/product/ua features, is_agent
-    """
-    # fetch raw interactions
-    interactions_df = FetchInteractionsStep(context).transform(None)
-
-    # validate data quality (report cached in context)
-    interactions_df = ValidateDataStep(context).transform(interactions_df)
-    if interactions_df.empty:
-        return pd.DataFrame()
-
-    # extract vectorized session features
-    features_df = ExtractSessionFeaturesStep(context).transform(interactions_df)
-    if features_df.empty:
-        return pd.DataFrame()
-
-    # join experiment labels (is_agent = ~xp_human_only)
-    labeled_df = JoinLabelsStep(context).transform(features_df)
-
-    return labeled_df
-
-
-
-
-if __name__ == '__main__':
-
-    class ExperimentsProvider(SupabaseProvider, BackendAPIProvider):
-        def fetch_kafka_topic(self, topic: str) -> pd.DataFrame:
-            base_path = "/home/velocitatem/Documents/Projects/PHANTOM/experiments/collected_data/" # os.path.join(os.path.dirname(__file__), "collected_data")
-            if not os.path.isdir(base_path):
-                return pd.DataFrame()
-
-            files = {"user-interactions": "int.json", "price-logs": "price.json"}
-            file_to_read = files.get(topic, files["user-interactions"])
-            frames = []
-
-            for d in os.listdir(base_path):
-                full_path = os.path.join(base_path, d, file_to_read)
-                if not os.path.isfile(full_path):
-                    continue
-                try:
-                    data = pd.read_json(full_path)
-                    payloads = pd.DataFrame([r['payload'] for r in data['value'].to_list()])
-                    frames.append(payloads)
-                except Exception as e:
-                    print(f"Warning: Could not process {full_path}: {e}")
-
-            return pd.concat(frames, ignore_index=True) if frames else pd.DataFrame()
-
-    # demo: run ML training pipeline
-    context = PipelineContext(provider=ExperimentsProvider(), store_mode='hotel')
-    features = ml_training_pipeline(context)
-    print(f"Feature matrix: {features.shape}")
-    print(features.head())
-    print(features.info())
-
-    features.to_parquet("features.parquet")

experiments/procesing/pricers/__init__.py

@@ -1,14 +0,0 @@
-from procesing.pricers.base import PricingFunction
-from procesing.pricers.elasticity import ElasticityBasedPricer
-from procesing.pricers.simple import StaticPricer, RandomPricer, SimpleSurgePricer
-from procesing.pricers.session_aware import SessionAwarePricer, ProductSpecificSessionPricer
-
-__all__ = [
-    'PricingFunction',
-    'ElasticityBasedPricer',
-    'StaticPricer',
-    'RandomPricer',
-    'SimpleSurgePricer',
-    'SessionAwarePricer',
-    'ProductSpecificSessionPricer'
-]

experiments/procesing/pricers/base.py

@@ -1,67 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Optional, Dict, Any, List
-import numpy as np
-import pandas as pd
-
-
-class PricingFunction(ABC):
-    """
-    Abstract base for pricing functions.
-    Objective:
-        maximize E[R_T] = E[Σ P_t^T · Q_t]
-        subject to:
-            Q_t = g(P_t, S_t)  (demand response via elasticity)
-            P_t ≥ C  (cost floor)
-            minimize L_agent = R_oracle - R_observed
-    """
-
-    @abstractmethod
-    def fit(self, *kwargs):
-        """
-        Offline training on historical data.
-        This is where we can think about some maximization of expected revenue
-        over historical trajectories to learn parameters of the pricing function.
-        (This however we cover move in the RL side of things)
-
-        """
-        pass
-
-    @abstractmethod
-    def predict(self, *kwargs) -> np.ndarray:
-        """
-        Generate optimal prices given current state.
-        This is an abstract method that transitions from τ -> P*
-        which is the mapping from the trajectory to optimal prices under
-        some subset of session grouping (so, per sessionId)
-        """
-        pass
-
-    @abstractmethod
-    def _get_features(self, *kwargs) -> np.ndarray:
-        """
-        Extract features from trajectory for pricing decision.
-        Returns:
-            np.ndarray of shape (n_products, n_features)
-        """
-        pass
-
-    def update(self, observation: Dict[str, Any]):
-        """
-        Online learning update (optional).
-
-        Args:
-            observation: dict with {state, action, reward, next_state}
-                - state: StateSpace before pricing decision
-                - action: prices shown (P_t)
-                - reward: revenue/conversion signal
-                - next_state: StateSpace after user interaction
-        """
-        pass  # default: no online learning
-
-    def get_params(self) -> Dict[str, Any]:
-        """Return pricing function parameters for serialization."""
-        return {}
-
-    def set_params(self, params: Dict[str, Any]):
-        """Load pricing function parameters from dict."""
-        pass

experiments/procesing/pricers/elasticity.py

@@ -1,69 +0,0 @@
-import numpy as np
-import pandas as pd
-from procesing.pricers.base import PricingFunction
-
-
-class ElasticityBasedPricer(PricingFunction):
-    """
-    Pricing based on demand elasticity estimates.
-    f(Q, S) = base_price * (1 + alpha * elasticity * demand_deviation)
-    """
-
-    def __init__(self, alpha: float = 0.1, price_floor: float = 0.0, price_ceil: float = np.inf):
-        self.alpha = alpha
-        self.price_floor = price_floor
-        self.price_ceil = price_ceil
-        self.elasticity = None
-        self.base_prices = None
-        self.mean_demand = None
-
-    def fit(self, historical_data: pd.DataFrame):
-        """
-        Calibrate from historical elasticity estimates.
-        Expects: [productId, elasticity, base_price, mean_demand]
-        """
-        if 'elasticity' not in historical_data.columns:
-            raise ValueError("historical_data must contain 'elasticity' column")
-
-        self.elasticity = historical_data['elasticity'].values
-        self.base_prices = (historical_data['base_price'].values
-                           if 'base_price' in historical_data.columns
-                           else np.ones(len(historical_data)) * 100)
-        self.mean_demand = (historical_data['mean_demand'].values
-                           if 'mean_demand' in historical_data.columns
-                           else np.ones(len(historical_data)) * 10)
-        return self
-
-    def predict(self, state_space) -> np.ndarray:
-        """
-        Adjust prices based on demand deviation and elasticity.
-        Higher demand -> increase price (but less for elastic goods)
-        """
-        if self.elasticity is None:
-            raise ValueError("Must call fit() before predict()")
-
-        demand = np.asarray(state_space.demand)
-        if len(demand) != len(self.elasticity):
-            raise ValueError(f"Demand vector size {len(demand)} != elasticity size {len(self.elasticity)}")
-
-        # compute demand deviation from mean
-        demand_dev = (demand - self.mean_demand) / (self.mean_demand + 1e-6)
-
-        # adjust price: if demand high and elastic, don't increase much
-        # if demand high and inelastic, increase more
-        price_multiplier = 1 + self.alpha * np.abs(self.elasticity) * demand_dev
-        prices = self.base_prices * price_multiplier
-
-        # enforce bounds
-        prices = np.clip(prices, self.price_floor, self.price_ceil)
-        return prices
-
-    def _get_features(self, state_space=None) -> np.ndarray:
-        """Extract elasticity, demand, and demand deviation for each product"""
-        if state_space is None or self.elasticity is None:
-            n = len(self.elasticity) if self.elasticity is not None else 0
-            return np.zeros((n, 3))
-
-        demand = np.asarray(state_space.demand)
-        demand_dev = (demand - self.mean_demand) / (self.mean_demand + 1e-6)
-        return np.column_stack([self.elasticity, demand, demand_dev])

experiments/procesing/pricers/session_aware.py

@@ -1,211 +0,0 @@
-"""
-Session-aware pricing functions that leverage behavioral features S_t.
-These pricers aim to minimize L_agent = R_oracle - R_observed.
-"""
-import numpy as np
-import pandas as pd
-from procesing.pricers.base import PricingFunction
-from procesing.pricers.elasticity import ElasticityBasedPricer
-
-
-class SessionAwarePricer(PricingFunction):
-    """
-    Extends elasticity-based pricing with session behavioral signals.
-
-    f(Q, P, S) = base_price * elasticity_factor * session_factor
-
-    Where session_factor adjusts for:
-        - interaction_velocity (agent detection proxy)
-        - product_view_depth (interest signal)
-        - cart_to_view_ratio (conversion intent)
-
-    Strategy: charge higher prices to suspected agents (high velocity)
-    to recover oracle revenue from reconnaissance sessions.
-    """
-
-    def __init__(self,
-                 alpha: float = 0.1,
-                 beta_velocity: float = 0.05,
-                 beta_attention: float = 0.03,
-                 agent_velocity_threshold: float = 5.0,
-                 agent_markup: float = 1.2,
-                 price_floor: float = 0.0,
-                 price_ceil: float = np.inf):
-        """
-        Args:
-            alpha: elasticity sensitivity
-            beta_velocity: interaction velocity weight
-            beta_attention: product attention weight
-            agent_velocity_threshold: velocity above which to apply agent markup
-            agent_markup: price multiplier for suspected agent sessions
-            price_floor, price_ceil: price bounds
-        """
-        self.alpha = alpha
-        self.beta_velocity = beta_velocity
-        self.beta_attention = beta_attention
-        self.agent_velocity_threshold = agent_velocity_threshold
-        self.agent_markup = agent_markup
-        self.price_floor = price_floor
-        self.price_ceil = price_ceil
-
-        # fitted parameters
-        self.elasticity = None
-        self.base_prices = None
-        self.mean_demand = None
-
-    def fit(self, historical_data: pd.DataFrame, **kwargs):
-        """Calibrate from historical elasticity data."""
-        if 'elasticity' not in historical_data.columns:
-            raise ValueError("historical_data must contain 'elasticity'")
-
-        self.elasticity = historical_data['elasticity'].values
-        self.base_prices = (historical_data['base_price'].values
-                           if 'base_price' in historical_data.columns
-                           else np.ones(len(historical_data)) * 100)
-        self.mean_demand = (historical_data['mean_demand'].values
-                           if 'mean_demand' in historical_data.columns
-                           else np.ones(len(historical_data)) * 10)
-        return self
-
-    def predict(self, state_space) -> np.ndarray:
-        """Generate prices with session awareness."""
-        if self.elasticity is None:
-            raise ValueError("Must call fit() before predict()")
-
-        demand = np.asarray(state_space.demand)
-        n_products = len(demand)
-
-        # base elasticity-driven pricing
-        demand_dev = (demand - self.mean_demand) / (self.mean_demand + 1e-6)
-        elasticity_factor = 1 + self.alpha * np.abs(self.elasticity) * demand_dev
-
-        # session-aware adjustments
-        session_factor = np.ones(n_products)
-
-        if not state_space.session_features.empty:
-            sf = state_space.session_features.iloc[0]  # single session features
-
-            # agent detection via velocity
-            velocity = sf.get('interaction_velocity', 0.0)
-            if velocity > self.agent_velocity_threshold:
-                # suspected agent: apply markup to recover oracle revenue
-                session_factor *= self.agent_markup
-
-            # attention signal: higher view depth -> user interested -> can charge more
-            view_depth = sf.get('product_view_depth', 0)
-            if view_depth > 0:
-                attention_boost = 1 + self.beta_attention * np.log1p(view_depth)
-                session_factor *= attention_boost
-
-            # cart presence: if user has items in cart, slightly increase prices
-            cart_to_view = sf.get('cart_to_view_ratio', 0.0)
-            if cart_to_view > 0.1:
-                session_factor *= (1 + 0.02)  # small boost for conversion intent
-
-        prices = self.base_prices * elasticity_factor * session_factor
-        prices = np.clip(prices, self.price_floor, self.price_ceil)
-
-        return prices
-
-    def _get_features(self, state_space=None) -> np.ndarray:
-        """Extract elasticity, demand, and session features"""
-        if state_space is None or self.elasticity is None:
-            n = len(self.elasticity) if self.elasticity is not None else 0
-            return np.zeros((n, 5))
-
-        demand = np.asarray(state_space.demand)
-        n_products = len(demand)
-
-        # extract session features
-        velocity = 0.0
-        view_depth = 0.0
-        cart_to_view = 0.0
-
-        if not state_space.session_features.empty:
-            sf = state_space.session_features.iloc[0]
-            velocity = sf.get('interaction_velocity', 0.0)
-            view_depth = sf.get('product_view_depth', 0.0)
-            cart_to_view = sf.get('cart_to_view_ratio', 0.0)
-
-        # broadcast session features to all products
-        features = np.column_stack([
-            self.elasticity,
-            demand,
-            np.full(n_products, velocity),
-            np.full(n_products, view_depth),
-            np.full(n_products, cart_to_view)
-        ])
-        return features
-
-
-class ProductSpecificSessionPricer(PricingFunction):
-    """
-    Session-aware pricer with product-specific demand signals.
-
-    Uses S_t to extract per-product interaction counts and adjusts pricing
-    for products the user has already viewed/hovered.
-
-    Strategy: products viewed multiple times = high interest -> price up
-    """
-
-    def __init__(self,
-                 alpha: float = 0.1,
-                 view_boost: float = 0.02,
-                 max_view_boost: float = 0.15,
-                 price_floor: float = 0.0,
-                 price_ceil: float = np.inf):
-        self.alpha = alpha
-        self.view_boost = view_boost
-        self.max_view_boost = max_view_boost
-        self.price_floor = price_floor
-        self.price_ceil = price_ceil
-
-        self.elasticity = None
-        self.base_prices = None
-        self.mean_demand = None
-        self.product_ids = None
-
-    def fit(self, historical_data: pd.DataFrame, **kwargs):
-        if 'elasticity' not in historical_data.columns or 'productId' not in historical_data.columns:
-            raise ValueError("historical_data must contain 'elasticity' and 'productId'")
-
-        self.elasticity = historical_data['elasticity'].values
-        self.base_prices = (historical_data['base_price'].values
-                           if 'base_price' in historical_data.columns
-                           else np.ones(len(historical_data)) * 100)
-        self.mean_demand = (historical_data['mean_demand'].values
-                           if 'mean_demand' in historical_data.columns
-                           else np.ones(len(historical_data)) * 10)
-        self.product_ids = historical_data['productId'].values
-        return self
-
-    def predict(self, state_space) -> np.ndarray:
-        if self.elasticity is None:
-            raise ValueError("Must call fit() before predict()")
-
-        demand = np.asarray(state_space.demand)
-        n_products = len(demand)
-
-        # base pricing
-        demand_dev = (demand - self.mean_demand) / (self.mean_demand + 1e-6)
-        base_prices = self.base_prices * (1 + self.alpha * np.abs(self.elasticity) * demand_dev)
-
-        # product-specific session adjustments
-        if not state_space.session_features.empty and state_space.product_ids is not None:
-            # extract product interaction counts from session metadata
-            # (this would require session features to include per-product signals)
-            # for now, use uniform boost as placeholder
-            # TODO: extend session feature extraction to include product-specific counts
-            pass
-
-        prices = np.clip(base_prices, self.price_floor, self.price_ceil)
-        return prices
-
-    def _get_features(self, state_space=None) -> np.ndarray:
-        """Extract elasticity and demand features for product-specific pricing"""
-        if state_space is None or self.elasticity is None:
-            n = len(self.elasticity) if self.elasticity is not None else 0
-            return np.zeros((n, 2))
-
-        demand = np.asarray(state_space.demand)
-        return np.column_stack([self.elasticity, demand])

experiments/procesing/pricers/simple.py

@@ -1,158 +0,0 @@
-import numpy as np
-import pandas as pd
-from procesing.pricers.base import PricingFunction
-
-
-def session_features_to_demand(session_features: pd.DataFrame) -> float:
-    """
-    Map session behavioral features to demand proxy.
-    THIS is the critical θ̂ → D transformation for rule-based pricing.
-
-    Logic:
-      - High velocity → agent behavior → price up (revenue recovery)
-      - High cart ratio → purchase intent → price up
-      - Low activity → discount to convert
-
-    Returns: demand proxy score (0-20 range, higher = more demand)
-    """
-    if session_features.empty:
-        return 1.0
-
-    feat = session_features.iloc[0] if len(session_features) > 0 else {}
-
-    velocity = feat.get('interaction_velocity', 0)
-    cart_ratio = feat.get('cart_to_view_ratio', 0)
-    item_views = feat.get('item_views', 0)
-    cart_adds = feat.get('cart_adds', 0)
-
-    # baseline demand
-    demand = 1.0
-
-    # agent detection: high velocity → treat as high "demand" to price up
-    if velocity > 2.0:
-        demand += 10.0  # strong agent signal
-
-    # conversion intent: cart interaction → price up
-    if cart_ratio > 0.1 or cart_adds > 0:
-        demand += 5.0
-
-    # browsing depth: many views → interest signal
-    if item_views > 3:
-        demand += min(item_views, 5.0)
-
-    return min(demand, 20.0)  # cap at 20
-
-
-class StaticPricer(PricingFunction):
-    """Static pricing: always return fixed base prices"""
-
-    def __init__(self, base_prices: np.ndarray = None):
-        self.base_prices = base_prices
-
-    def fit(self, historical_data: pd.DataFrame):
-        """Extract base prices from historical data"""
-        if 'base_price' in historical_data.columns:
-            self.base_prices = historical_data['base_price'].values
-        elif 'price' in historical_data.columns:
-            self.base_prices = historical_data['price'].values
-        else:
-            raise ValueError("historical_data must contain 'base_price' or 'price' column")
-        return self
-
-    def predict(self, state_space) -> np.ndarray:
-        """Return static base prices regardless of state"""
-        if self.base_prices is None:
-            raise ValueError("Must call fit() or provide base_prices in constructor")
-        return self.base_prices.copy()
-
-    def _get_features(self, state_space=None) -> np.ndarray:
-        """Static pricer uses no features, returns empty array"""
-        n = len(self.base_prices) if self.base_prices is not None else 0
-        return np.zeros((n, 0))
-
-
-class RandomPricer(PricingFunction):
-    """Random pricing within bounds (for baseline comparison)"""
-
-    def __init__(self, price_min: float = 50.0, price_max: float = 500.0, seed: int = None):
-        self.price_min = price_min
-        self.price_max = price_max
-        self.seed = seed
-        self.n_products = None
-        self.rng = np.random.default_rng(seed)
-
-    def fit(self, historical_data: pd.DataFrame):
-        """Learn number of products"""
-        self.n_products = len(historical_data)
-        return self
-
-    def predict(self, state_space) -> np.ndarray:
-        """Generate random prices"""
-        if self.n_products is None:
-            self.n_products = len(state_space.demand)
-        return self.rng.uniform(self.price_min, self.price_max, size=self.n_products)
-
-    def _get_features(self, state_space=None) -> np.ndarray:
-        """Random pricer uses no features"""
-        n = self.n_products if self.n_products else 0
-        return np.zeros((n, 0))
-
-
-class SimpleSurgePricer(PricingFunction):
-    """
-    Rule-based surge pricer adjusting prices via demand thresholds.
-    Logic: if demand > high_threshold -> surge, if demand < low_threshold -> discount.
-    Simpler and more controllable than curve fitting approaches.
-    """
-
-    def __init__(self,
-                 base_prices: np.ndarray = None,
-                 high_threshold: int = 10,
-                 low_threshold: int = 2,
-                 surge_multiplier: float = 1.2,
-                 discount_multiplier: float = 0.9):
-        self.base_prices = base_prices
-        self.high_threshold = high_threshold
-        self.low_threshold = low_threshold
-        self.surge_multiplier = surge_multiplier
-        self.discount_multiplier = discount_multiplier
-
-    def fit(self, market_data: pd.DataFrame):
-        """Extract base prices from product catalog or historical averages"""
-        self.base_prices = market_data['base_price'].to_numpy() if 'base_price' in market_data.columns else market_data['price'].values
-        return self
-
-    def predict(self, state_space) -> np.ndarray:
-        """
-        Adjust prices based on current demand using surge rules.
-        state_space.demand: demand proxy per product (from session features)
-        state_space.prices: base prices
-        """
-        demand = np.asarray(state_space.demand) if state_space and hasattr(state_space, 'demand') else np.array([0])
-        base = np.asarray(state_space.prices) if state_space and hasattr(state_space, 'prices') else self.base_prices
-
-        if base is None:
-            base = np.ones(len(demand)) * 99.99
-
-        # ensure float dtype to allow multiplication by float multipliers
-        new_prices = base.astype(np.float64).copy()
-        high_mask = demand >= self.high_threshold
-        new_prices[high_mask] *= self.surge_multiplier
-
-        low_mask = demand <= self.low_threshold
-        new_prices[low_mask] *= self.discount_multiplier
-
-        return new_prices
-
-    def _get_features(self, state_space=None) -> np.ndarray:
-        """Extract demand and base price features for each product"""
-        if state_space is None:
-            n = len(self.base_prices) if self.base_prices is not None else 0
-            return np.zeros((n, 2))
-
-        demand = np.asarray(state_space.demand) if hasattr(state_space, 'demand') else np.array([0])
-        base = np.asarray(state_space.prices) if hasattr(state_space, 'prices') else self.base_prices
-        if base is None:
-            base = np.ones(len(demand)) * 99.99
-
-        return np.column_stack([demand, base])

experiments/procesing/pricing.py

@@ -1,272 +0,0 @@
-r"""
-Our state space comes as:
-$Q_t in R^n$ - our demand at a time t
-$P_t in R^n$ - prices at time t
-$S_t$ some form of interaction session features
-
-This is a single sate which we map under
-
-$f: (Q, S, H) \to P_{t+1}$
-
-With:
-
-$H_t = \{Q_{t-k}, P_{t-k}, S_{t-k}\}$
-
-
-We can have f be literally anything, analytical or learned or rule based or an RL policy.
-
-Our goal is to mazimize the expected revenue:
-
-$E[R_T] = E[\sum_{t=1}^T P_t^T \dot Q_t]$
-
-subject to Q_t = g(P_t, S_t) : demand response to price (estimated via elasticity) and P_t ≥ C : prices above cost floor and additionally minimizing the following:
-
-$L_{agent} = R_{oracle} - R_{observed}
-
-where: R_oracle = revenue if we knew agent intentions (from recon session) and R_observed = revenue under current pricing policy f
-
-I would start be defning a pricing function interface and standardizing how to train that based on historical data and define how to make it behave for online training (if we do that)
-
-We also need to develop a solid benchmark with mapping revenue and full KPIs from session interactions to measure differences between different price learning methods
-"""
-
-from abc import ABC, abstractmethod
-from sklearn.base import BaseEstimator, TransformerMixin
-import numpy as np
-import pandas as pd
-import os
-from dotenv import load_dotenv
-load_dotenv()
-from supabase import create_client, Client
-
-SUPABASE_URL = os.getenv("NEXT_PUBLIC_SUPABASE_URL", "")
-SUPABASE_KEY = os.getenv("NEXT_PUBLIC_SUPABASE_ANON_KEY", "")
-supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
-
-def expected_revenue(prices: np.ndarray, demand: np.ndarray) -> float:
-    """Returns: expected revenue R_t = P_t^T * Q_t"""
-    return float(np.dot(prices, demand))
-
-class StateSpace:
-    def __init__(self,
-                 demand : np.ndarray, # at time t, only values (assuming aligned by productId order)
-                 prices : np.ndarray, # at time t, only values (assuming aligned by productId order)
-                 session_features : pd.DataFrame):
-        self.demand = demand  # Q_t
-        self.prices = prices  # P_t
-        self.session_features = session_features  # S_t
-        self.history = []  # H_t
-
-class PricingFunction(BaseEstimator, TransformerMixin, ABC):
-    def __init__(self):
-        pass
-
-    def fit(self, historical_data):
-        """
-        Train the pricing function based on historical data.
-        historical_data: list of StateSpace instances with known outcomes
-        """
-        raise NotImplementedError("Train method must be implemented by subclass.")
-
-    def transform(self, state_space) -> np.ndarray:
-        """
-        Predict the next prices given the current state space.
-        state_space: StateSpace instance
-        Returns: predicted prices P_{t+1}
-        """
-        raise NotImplementedError("Predict method must be implemented by subclass.")
-
-
-class SimpleLinearPricingFunction(PricingFunction):
-    def __init__(self, price_sensitivity: float = -0.1):
-        super().__init__()
-        self.price_sensitivity = price_sensitivity
-
-    def fit(self, historical_data):
-        return self
-
-    def transform(self, state_space: StateSpace) -> np.ndarray:
-        new_prices = state_space.prices + self.price_sensitivity * state_space.demand
-        return np.maximum(new_prices, 0)
-
-
-class ElasticityBasedPricingFunction(PricingFunction):
-    """
-    Revenue-maximizing pricing using elasticity estimates.
-
-    For each product, optimal price P* maximizes R = P * Q(P)
-    where Q(P) follows power law: Q(P) = Q_0 * (P/P_0)^ε
-
-    Taking derivative dR/dP = 0 gives optimal markup:
-    P* = P_0 * (1 + 1/ε) if ε < -1 (elastic)
-
-    For inelastic demand (|ε| < 1), we apply bounded markup.
-    """
-
-    def __init__(self,
-                 cost_floor: float = 0.5,
-                 max_markup: float = 2.0,
-                 min_markup: float = 1.0,
-                 inelastic_markup: float = 1.3):
-        super().__init__()
-        self.cost_floor = cost_floor  # prices as fraction of base
-        self.max_markup = max_markup  # max price = base * max_markup
-        self.min_markup = min_markup  # min price = base * min_markup
-        self.inelastic_markup = inelastic_markup  # default for |ε| < 1
-        self.elasticity_map = {}  # productId -> elasticity
-
-    def fit(self, elasticity_df: pd.DataFrame):
-        """
-        Args:
-            elasticity_df: df with [productId, elasticity, std_error, n_obs]
-        """
-        if elasticity_df is not None and not elasticity_df.empty:
-            self.elasticity_map = dict(zip(
-                elasticity_df['productId'],
-                elasticity_df['elasticity']
-            ))
-        return self
-
-    def transform(self, state_space: StateSpace, product_ids: np.ndarray = None) -> np.ndarray:
-        """
-        Args:
-            state_space: current state (prices = base prices)
-            product_ids: array of productIds aligned with state_space.prices
-
-        Returns:
-            optimized prices P_{t+1}
-        """
-        base_prices = state_space.prices
-
-        if product_ids is None:
-            # fallback: use positional index as productId (not ideal)
-            product_ids = np.arange(len(base_prices))
-
-        new_prices = np.zeros_like(base_prices)
-
-        for i, (base_p, pid) in enumerate(zip(base_prices, product_ids)):
-            elasticity = self.elasticity_map.get(pid, 0.0)
-
-            if elasticity < -1:  # elastic demand
-                # optimal markup: (1 + 1/ε)
-                markup = 1 + (1 / elasticity)
-                optimal_p = base_p * markup
-            elif elasticity > -1 and elasticity < 0:  # inelastic
-                # conservative markup
-                optimal_p = base_p * self.inelastic_markup
-            else:  # ε ≥ 0 (demand increases with price, or no data)
-                # no elasticity data or anomalous, keep base price
-                optimal_p = base_p
-
-            # apply bounds
-            optimal_p = np.clip(
-                optimal_p,
-                base_p * self.min_markup,
-                base_p * self.max_markup
-            )
-            optimal_p = max(optimal_p, self.cost_floor)
-
-            new_prices[i] = optimal_p
-
-        return new_prices
-
-
-class ContextualElasticityPricing(PricingFunction):
-    """
-    Revenue optimization with contextual adjustments based on session features.
-
-    Combines elasticity-based pricing with surge/demand-based multipliers.
-    """
-
-    def __init__(self,
-                 base_pricer: ElasticityBasedPricingFunction = None,
-                 demand_sensitivity: float = 0.1,
-                 surge_threshold: float = 0.7):
-        super().__init__()
-        self.base_pricer = base_pricer or ElasticityBasedPricingFunction()
-        self.demand_sensitivity = demand_sensitivity
-        self.surge_threshold = surge_threshold
-
-    def fit(self, elasticity_df: pd.DataFrame):
-        self.base_pricer.fit(elasticity_df)
-        return self
-
-    def transform(self, state_space: StateSpace, product_ids: np.ndarray = None) -> np.ndarray:
-        # get base optimal prices from elasticity
-        base_optimal = self.base_pricer.transform(state_space, product_ids)
-
-        # compute surge multiplier from demand
-        if len(state_space.demand) > 0:
-            demand_normalized = state_space.demand / (state_space.demand.max() + 1e-8)
-            surge_multiplier = 1 + self.demand_sensitivity * np.maximum(
-                demand_normalized - self.surge_threshold, 0
-            )
-        else:
-            surge_multiplier = np.ones_like(base_optimal)
-
-        return base_optimal * surge_multiplier
-
-# Example usage:
-if __name__ == "__main__":
-    from pipeline import interaction_pipeline, price_data_pipeline, elasticity_pipeline
-
-    store_mode = 'hotel'
-    interaction_data = interaction_pipeline.fit_transform(None)
-    price_data = price_data_pipeline.fit_transform(None)
-
-    elasticity_df = elasticity_pipeline(interaction_data, price_data, window_size="30s", store_mode=store_mode)
-
-    # fetch all products with base prices from database
-    products_resp = supabase.table(f'{store_mode}_products').select("id, metadata").execute()
-    products_df = pd.DataFrame(products_resp.data)
-
-    # extract base_price from metadata
-    products_df['base_price'] = products_df['metadata'].apply(lambda m: m.get('base_price', 0) if isinstance(m, dict) else 0)
-    products_df = products_df.rename(columns={'id': 'productId'})[['productId', 'base_price']]
-
-    # override with logged prices where available
-    if not price_data.empty:
-        if 'ts' in price_data.columns and not pd.api.types.is_datetime64_any_dtype(price_data['ts']):
-            price_data['ts'] = pd.to_datetime(price_data['ts'])
-
-        # get latest logged price per product
-        price_logs_agg = price_data.sort_values('ts').groupby('productId', as_index=False).last()
-
-        # merge: start with all products (base prices), override with logged prices
-        products_df = products_df.merge(
-            price_logs_agg[['productId', 'price']],
-            on='productId',
-            how='left'
-        )
-        products_df['final_price'] = products_df['price'].fillna(products_df['base_price'])
-    else:
-        products_df['final_price'] = products_df['base_price']
-
-    # merge with elasticity
-    if elasticity_df is not None and not elasticity_df.empty:
-        price_data_merged = products_df[['productId', 'final_price']].merge(
-            elasticity_df[['productId', 'elasticity']],
-            on='productId',
-            how='left'
-        ).fillna({'elasticity': 0.0})
-
-        prices = price_data_merged['final_price'].values
-        elasticities = price_data_merged['elasticity'].values
-    else:
-        prices = np.array([])
-        elasticities = np.array([])
-
-    print(elasticities)
-    print(prices)
-
-    state_space = StateSpace(
-        demand=elasticities,
-        prices=prices,
-        session_features=interaction_data
-    )
-
-    pricing_function = SimpleLinearPricingFunction(price_sensitivity=-0.05)
-    pricing_function.fit([])  # No training data for simple model
-    predicted_prices = pricing_function.transform(state_space)
-
-    print("Predicted Prices:", predicted_prices)

experiments/procesing/providers/__init__.py

@@ -1,5 +0,0 @@
-from procesing.providers.base import DataProvider
-from procesing.providers.supabase import SupabaseProvider
-from procesing.providers.backend import BackendAPIProvider
-
-__all__ = ['DataProvider', 'SupabaseProvider', 'BackendAPIProvider']

experiments/procesing/providers/backend.py

@@ -1,19 +0,0 @@
-import os
-import pandas as pd
-import requests
-from typing import List
-from procesing.providers.base import DataProvider
-
-class BackendAPIProvider(DataProvider):
-    """Concrete backend API implementation"""
-    def __init__(self, backend_url: str = None):
-        self.backend_url = backend_url or os.getenv("BACKEND_URL", "http://localhost:5000")
-    def fetch_kafka_topic(self, topic: str) -> pd.DataFrame:
-        resp = requests.get(f"{self.backend_url}/api/kafka/dump?topic={topic}")
-        resp.raise_for_status()
-        data = resp.json()
-
-        if not data.get('success') or not data.get('data'):
-            return pd.DataFrame()
-
-        return pd.DataFrame(data['data'])

experiments/procesing/providers/base.py

@@ -1,21 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import List
-import pandas as pd
-
-class DataProvider(ABC):
-    """Abstract interface for data access, enables DI and testing"""
-
-    @abstractmethod
-    def fetch_products(self, store_mode: str) -> pd.DataFrame:
-        """Fetch product catalog for given store mode"""
-        pass
-
-    @abstractmethod
-    def fetch_experiments(self, experiment_ids: List[str]) -> pd.DataFrame:
-        """Fetch experiment metadata for given IDs"""
-        pass
-
-    @abstractmethod
-    def fetch_kafka_topic(self, topic: str) -> pd.DataFrame:
-        """Fetch data from Kafka topic via backend API"""
-        pass

experiments/procesing/providers/supabase.py

@@ -1,42 +0,0 @@
-import os
-import pandas as pd
-import requests
-from typing import List
-from supabase import create_client, Client
-from procesing.providers.base import DataProvider
-from dotenv import load_dotenv
-
-class SupabaseProvider(DataProvider):
-    """Concrete Supabase + backend API implementation"""
-
-    def __init__(self,
-                 supabase_url: str = None,
-                 supabase_key: str = None,):
-        load_dotenv()
-        self.supabase_url = supabase_url or os.getenv("NEXT_PUBLIC_SUPABASE_URL")
-        self.supabase_key = supabase_key or os.getenv("NEXT_PUBLIC_SUPABASE_ANON_KEY")
-        self.supabase: Client = create_client(self.supabase_url, self.supabase_key)
-
-    def fetch_products(self, store_mode: str) -> pd.DataFrame:
-        # hotel uses room_type, airline uses flight_type; select all and normalize
-        resp = self.supabase.table(f'{store_mode}_products').select("*").execute()
-        if not resp.data:
-            return pd.DataFrame()
-        df = pd.DataFrame(resp.data)
-        # normalize type column: hotel has room_type, airline has flight_type
-        if 'room_type' in df.columns:
-            df['product_type'] = df['room_type']
-        elif 'flight_type' in df.columns:
-            df['product_type'] = df['flight_type']
-        return df
-
-    def fetch_experiments(self, experiment_ids: List[str]) -> pd.DataFrame:
-        if not experiment_ids:
-            return pd.DataFrame()
-
-        resp = self.supabase.table('experiments').select(
-            'id, subject_name, xp_human_only, xp_market_mode, xp_task_id, '
-            'task:tasks(task_name, task_description, task_def_of_done)'
-        ).in_('id', experiment_ids).execute()
-
-        return pd.DataFrame(resp.data) if resp.data else pd.DataFrame()

experiments/procesing/steps/__init__.py

@@ -1,39 +0,0 @@
-from procesing.steps.base import BaseContextStep
-from procesing.steps.fetch import FetchInteractionsStep, FetchPriceLogsStep, FetchExperimentsStep
-from procesing.steps.join import JoinExperimentsStep, JoinProductFeaturesStep
-from procesing.steps.augment import CreatePriceBucketsStep, AugmentEventNamesStep, AugmentInteractionsStep
-from procesing.steps.chunk import ChunkByTimeWindowStep
-from procesing.steps.demand import ComputeDemandStep, ComputeDemandForChunksStep
-from procesing.steps.elasticity import AggregatePriceLogsStep
-from procesing.steps.pricing import FitPricingFunctionStep, PredictPricesStep
-from procesing.steps.session import (
-    ExtractSessionFeaturesStep, JoinLabelsStep, ValidateDataStep,
-    TemporalFeatureStep, BehavioralFeatureStep, ProductFeatureStep, UserAgentFeatureStep,
-    _extract_features_for_session
-)
-
-__all__ = [
-    'BaseContextStep',
-    'FetchInteractionsStep',
-    'FetchPriceLogsStep',
-    'FetchExperimentsStep',
-    'JoinExperimentsStep',
-    'JoinProductFeaturesStep',
-    'CreatePriceBucketsStep',
-    'AugmentEventNamesStep',
-    'AugmentInteractionsStep',
-    'ChunkByTimeWindowStep',
-    'ComputeDemandStep',
-    'ComputeDemandForChunksStep',
-    'AggregatePriceLogsStep',
-    'FitPricingFunctionStep',
-    'PredictPricesStep',
-    'ExtractSessionFeaturesStep',
-    'JoinLabelsStep',
-    'ValidateDataStep',
-    'TemporalFeatureStep',
-    'BehavioralFeatureStep',
-    'ProductFeatureStep',
-    'UserAgentFeatureStep',
-    '_extract_features_for_session',
-]

experiments/procesing/steps/augment.py

@@ -1,140 +0,0 @@
-import numpy as np
-import pandas as pd
-from procesing.steps.base import BaseContextStep
-
-
-class AugmentInteractionsStep(BaseContextStep):
-    """
-    Consolidated step: create price buckets, augment event names, join experiments.
-    Input: (interactions_df, price_logs_df)
-    Output: enriched interactions_df
-    """
-
-    def transform(self, data: tuple):
-        interactions_df, price_logs_df = data
-
-        if interactions_df.empty:
-            return interactions_df
-
-        # Step 1: Create price buckets
-        interactions_df = self._create_price_buckets(interactions_df)
-
-        # Step 2: Augment event names
-        interactions_df = self._augment_event_names(interactions_df)
-
-        # Step 3: Join experiments (optional)
-        if 'experimentId' in interactions_df.columns:
-            interactions_df = self._join_experiments(interactions_df)
-
-        return interactions_df
-
-    def _create_price_buckets(self, df: pd.DataFrame):
-        """Create price bucket labels from price data"""
-        if 'metadata_price' not in df.columns:
-            df['price_bucket'] = ""
-            return df
-
-        n_buckets = self.context.config.get('n_price_buckets', 5)
-
-        if df['metadata_price'].notnull().sum() > 0:
-            try:
-                price_buckets = pd.qcut(
-                    df['metadata_price'],
-                    q=n_buckets,
-                    labels=[f"PB_{i+1}" for i in range(n_buckets)],
-                    duplicates='drop'
-                )
-            except ValueError:
-                # fallback for insufficient unique values
-                price_buckets = df['metadata_price'].apply(
-                    lambda x: f"P_{int(x)}" if pd.notnull(x) else ""
-                )
-        else:
-            price_buckets = pd.Series([""] * len(df), index=df.index)
-
-        df['price_bucket'] = price_buckets
-        return df
-
-    def _augment_event_names(self, df: pd.DataFrame):
-        """Augment event names with product and price bucket schema"""
-        # Create schema: _productId@price_bucket
-        has_product = df.get('productId', pd.Series()).notnull()
-        has_bucket = df.get('price_bucket', pd.Series()).notnull()
-
-        df['metadata_schema'] = np.where(
-            has_product & has_bucket,
-            "_" + df['productId'].astype(str) + "@" + df['price_bucket'].astype(str),
-            ""
-        )
-
-        df['eventName'] = df['eventName'] + df['metadata_schema']
-        return df
-
-    def _join_experiments(self, df: pd.DataFrame):
-        """Join experiment metadata if experimentId present"""
-        exp_ids = df['experimentId'].dropna().unique().tolist()
-        if not exp_ids:
-            return df
-
-        experiments_df = self.context.provider.fetch_experiments(exp_ids)
-        if experiments_df.empty:
-            return df
-
-        return df.merge(
-            experiments_df,
-            left_on='experimentId',
-            right_on='id',
-            how='left',
-            suffixes=('', '_exp')
-        )
-
-
-class CreatePriceBucketsStep(BaseContextStep):
-    """Create price bucket labels from price data"""
-
-    def transform(self, df: pd.DataFrame):
-        if df.empty or 'metadata_price' not in df.columns:
-            df['price_bucket'] = ""
-            return df
-
-        n_buckets = self.context.config.get('n_price_buckets', 5)
-
-        if df['metadata_price'].notnull().sum() > 0:
-            try:
-                price_buckets = pd.qcut(
-                    df['metadata_price'],
-                    q=n_buckets,
-                    labels=[f"PB_{i+1}" for i in range(n_buckets)],
-                    duplicates='drop'
-                )
-            except ValueError:
-                # fallback for insufficient unique values
-                price_buckets = df['metadata_price'].apply(
-                    lambda x: f"P_{int(x)}" if pd.notnull(x) else ""
-                )
-        else:
-            price_buckets = pd.Series([""] * len(df), index=df.index)
-
-        df['price_bucket'] = price_buckets
-        return df
-
-
-class AugmentEventNamesStep(BaseContextStep):
-    """Augment event names with product and price bucket schema"""
-
-    def transform(self, df: pd.DataFrame):
-        if df.empty:
-            return df
-
-        # Create schema: _productId@price_bucket
-        has_product = df.get('productId', pd.Series()).notnull()
-        has_bucket = df.get('price_bucket', pd.Series()).notnull()
-
-        df['metadata_schema'] = np.where(
-            has_product & has_bucket,
-            "_" + df['productId'].astype(str) + "@" + df['price_bucket'].astype(str),
-            ""
-        )
-
-        df['eventName'] = df['eventName'] + df['metadata_schema']
-        return df

experiments/procesing/steps/base.py

@@ -1,32 +0,0 @@
-from abc import ABC, abstractmethod
-from sklearn.base import BaseEstimator, TransformerMixin
-from procesing.context import PipelineContext
-from typing import Any
-
-class BaseContextStep(BaseEstimator, TransformerMixin, ABC):
-    """
-    Base for all pipeline steps.
-    Each step is stateless, context-driven, and performs ONE transformation.
-    """
-
-    def __init__(self, context: PipelineContext):
-        self.context = context
-
-    def fit(self, X=None, y=None):
-        """Most steps don't need training"""
-        return self
-
-    @abstractmethod
-    def transform(self, X) -> Any:
-        """Transform input using context. Must be implemented by subclass."""
-        pass
-
-    def get_params(self, deep=True):
-        """sklearn compatibility"""
-        return {'context': self.context}
-
-    def set_params(self, **params):
-        """sklearn compatibility"""
-        if 'context' in params:
-            self.context = params['context']
-        return self

experiments/procesing/steps/chunk.py

@@ -1,34 +0,0 @@
-import pandas as pd
-from procesing.steps.base import BaseContextStep
-
-class ChunkByTimeWindowStep(BaseContextStep):
-    """
-    Chunk dataframe into time windows.
-    Returns list of dicts with window metadata.
-    """
-
-    def transform(self, df: pd.DataFrame):
-        if df.empty:
-            return []
-
-        df = df.copy()
-        ts_col = self.context.config.get('ts_col', 'ts')
-        window_size = self.context.window_size
-
-        # ensure datetime
-        if not pd.api.types.is_datetime64_any_dtype(df[ts_col]):
-            df[ts_col] = pd.to_datetime(df[ts_col])
-
-        df = df.sort_values(ts_col)
-        df['_window'] = df[ts_col].dt.floor(window_size)
-
-        chunks = []
-        for idx, (window_start, group) in enumerate(df.groupby('_window')):
-            chunks.append({
-                'window_start': window_start,
-                'window_end': window_start + pd.Timedelta(window_size),
-                'window_idx': idx,
-                'data': group.drop(columns=['_window'])
-            })
-
-        return chunks

experiments/procesing/steps/demand.py

@@ -1,61 +0,0 @@
-import pandas as pd
-from procesing.steps.base import BaseContextStep
-
-class ComputeDemandStep(BaseContextStep):
-    """
-    Compute demand vector for a single time window or dataframe.
-    Input: single chunk dict OR raw dataframe
-    Output: demand dataframe with [productId, demand_score]
-    """
-
-    def transform(self, chunk):
-        # handle both chunk dict and raw dataframe
-        if isinstance(chunk, dict):
-            interactions = chunk['data']
-            window_meta = {k: v for k, v in chunk.items() if k != 'data'}
-        else:
-            interactions = chunk
-            window_meta = {}
-
-        products = self.context.products
-        unique_products = products['id'].unique()
-
-        # apply filters if configured
-        session_filter = self.context.config.get('session_filter')
-        experiment_filter = self.context.config.get('experiment_filter')
-
-        if session_filter and 'sessionId' in interactions.columns:
-            interactions = interactions[interactions['sessionId'] == session_filter]
-        if experiment_filter and 'experimentId' in interactions.columns:
-            interactions = interactions[interactions['experimentId'] == experiment_filter]
-
-        interactions_with_products = interactions.dropna(subset=['productId'])
-
-        if interactions_with_products.empty:
-            demand_df = pd.DataFrame({
-                'productId': unique_products,
-                'demand_score': 0
-            })
-        else:
-            # crosstab for simple demand count
-            demand_df = pd.crosstab(
-                interactions_with_products['productId'],
-                'count'
-            ).reindex(unique_products, fill_value=0).reset_index()
-            demand_df.columns = ['productId', 'demand_score']
-
-        # attach window metadata if present
-        if window_meta:
-            return {**window_meta, 'demand_vector': demand_df}
-        return demand_df
-
-
-class ComputeDemandForChunksStep(BaseContextStep):
-    """Apply ComputeDemandStep to list of chunks"""
-
-    def transform(self, chunks: list):
-        if not chunks:
-            return []
-
-        demand_step = ComputeDemandStep(self.context)
-        return [demand_step.transform(chunk) for chunk in chunks]

experiments/procesing/steps/elasticity.py

@@ -1,42 +0,0 @@
-import numpy as np
-import pandas as pd
-from typing import Dict, List
-from procesing.steps.base import BaseContextStep
-
-class AggregatePriceLogsStep(BaseContextStep):
-    """
-    Aggregate price logs into time windows using VECTORIZED operations.
-    Input: price_logs_df
-    Output: DataFrame with columns [productId, price]
-    """
-
-    def transform(self, price_logs_df: pd.DataFrame):
-        if price_logs_df.empty:
-            return pd.DataFrame(columns=['productId', 'price'])
-
-        df = price_logs_df.copy()
-        ts_col = self.context.config.get('ts_col', 'ts')
-        #window_size = self.context.window_size WE ARE NOT USING CHUNKS ANYMORE
-
-        # ensure datetime
-        if not pd.api.types.is_datetime64_any_dtype(df[ts_col]):
-            df[ts_col] = pd.to_datetime(df[ts_col])
-
-        df = df.sort_values([ts_col, 'productId'])
-        products = self.context.products
-        # get base price from metadata if available 1) read the metadata col as json and get the base_price
-        products['base_price'] = products.apply(
-            lambda row: row['metadata'].get('base_price', 0) if isinstance(row['metadata'], dict) else 0,
-            axis=1
-        )
-
-        unique_products = products['id'].unique()
-
-        df_indexed = df.set_index(ts_col)
-        # we return a df of average price per product over the entire period
-        # TODO: maybe consider different opration to handle price aggregation over time
-        avg_prices = df_indexed.groupby('productId')['price'].mean().reindex(unique_products, fill_value=0).reset_index()
-        avg_prices.columns = ['productId', 'price']
-        # fill 0s with base_price from products
-        base_price_map = products.set_index('id')['base_price'].to_dict()
-        return avg_prices

experiments/procesing/steps/fetch.py

@@ -1,81 +0,0 @@
-import pandas as pd
-from procesing.steps.base import BaseContextStep
-
-class FetchInteractionsStep(BaseContextStep):
-    """Fetch raw interaction data from Kafka topic with optional time and store_mode filtering"""
-
-    def __init__(self, context, lookback: str = None):
-        super().__init__(context)
-        self.lookback = lookback
-
-    def transform(self, X=None):
-        df = self.context.provider.fetch_kafka_topic('user-interactions')
-
-        if df.empty:
-            return df
-
-        # Explode metadata JSON column
-        if 'metadata' in df.columns:
-            df = df.join(
-                pd.json_normalize(df.pop('metadata'), sep='.').add_prefix('metadata_')
-            )
-
-        df = df.dropna(subset=['eventName'])
-        # drop all where page has /admin/
-        df = df[~df['page'].str.contains('/admin/', na=False)]
-
-        # filter by store_mode from context
-        if 'storeMode' in df.columns:
-            df = df[df['storeMode'] == self.context.store_mode]
-
-        # Remap dateIndex if present
-        if 'metadata_dateIndex' in df.columns:
-            df['dateIndex'] = df['metadata_dateIndex'].astype('Int64')
-
-        # Apply time filtering if lookback specified
-        if self.lookback and 'ts' in df.columns:
-            df['ts'] = pd.to_datetime(df['ts'])
-            cutoff = pd.Timestamp.now() - pd.Timedelta(self.lookback)
-            df = df[df['ts'] >= cutoff]
-
-        return df
-
-
-class FetchPriceLogsStep(BaseContextStep):
-    """Fetch price log data from Kafka topic with optional time and store_mode filtering"""
-
-    def __init__(self, context, lookback: str = None):
-        super().__init__(context)
-        self.lookback = lookback
-
-    def transform(self, X=None):
-        df = self.context.provider.fetch_kafka_topic('price-logs')
-
-        if df.empty:
-            return df
-
-        # filter by store_mode from context
-        if 'storeMode' in df.columns:
-            df = df[df['storeMode'] == self.context.store_mode]
-
-        # Apply time filtering if lookback specified
-        if self.lookback and 'ts' in df.columns:
-            df['ts'] = pd.to_datetime(df['ts'])
-            cutoff = pd.Timestamp.now() - pd.Timedelta(self.lookback)
-            df = df[df['ts'] >= cutoff]
-
-        return df
-
-
-class FetchExperimentsStep(BaseContextStep):
-    """Fetch experiment metadata for given interaction data"""
-
-    def transform(self, interactions_df: pd.DataFrame):
-        if interactions_df.empty or 'experimentId' not in interactions_df.columns:
-            return pd.DataFrame()
-
-        exp_ids = interactions_df['experimentId'].dropna().unique().tolist()
-        if not exp_ids:
-            return pd.DataFrame()
-
-        return self.context.provider.fetch_experiments(exp_ids)

experiments/procesing/steps/join.py

@@ -1,58 +0,0 @@
-import pandas as pd
-from procesing.steps.base import BaseContextStep
-
-class JoinExperimentsStep(BaseContextStep):
-    """Join experiment metadata to interactions"""
-
-    def transform(self, data: tuple):
-        """
-        Args:
-            data: (interactions_df, experiments_df)
-        Returns:
-            merged interactions dataframe
-        """
-        interactions_df, experiments_df = data
-
-        if experiments_df.empty:
-            return interactions_df
-
-        # Flatten nested task field if present
-        if 'task' in experiments_df.columns and experiments_df['task'].notnull().any():
-            task_norm = pd.json_normalize(experiments_df['task'].dropna())
-            task_norm.index = experiments_df[experiments_df['task'].notnull()].index
-            experiments_df = experiments_df.drop('task', axis=1).join(task_norm, rsuffix='_task')
-
-        # Rename for clarity
-        experiments_df = experiments_df.rename(columns={
-            'id': 'experimentId',
-            'subject_name': 'exp_subject',
-            'xp_human_only': 'exp_human_only',
-            'xp_market_mode': 'exp_market_mode',
-            'xp_task_id': 'exp_task_id'
-        })
-
-        return interactions_df.merge(experiments_df, on='experimentId', how='left')
-
-class JoinProductFeaturesStep(BaseContextStep):
-    """Join product features to interactions"""
-
-    def transform(self, data: tuple):
-        """
-        Args:
-            data: (interactions_df, products_df)
-        Returns:
-            merged interactions dataframe
-        """
-        demand_df, price_df = data
-
-        # get base prices from products if available
-        products = self.context.products
-        products['base_price'] = products.apply(
-            lambda row: float(row['metadata'].get('base_price', 0.0)) if isinstance(row['metadata'], dict) else 0,
-            axis=1
-        )
-        products = products[['id', 'base_price']].rename(columns={'id': 'productId'})
-
-        if price_df.empty:
-            return demand_df
-        return demand_df.merge(price_df, on='productId', how='left').merge(products, on='productId', how='left')

experiments/procesing/steps/pricing.py

@@ -1,55 +0,0 @@
-import numpy as np
-import pandas as pd
-from typing import Optional, List, Dict, Any
-from dataclasses import dataclass, field
-from procesing.pricers.simple import StaticPricer
-from procesing.steps.base import BaseContextStep
-from procesing.pricers import ElasticityBasedPricer
-
-class State:
-    def __init__(self,
-                 last_action : str,
-                 last_productId : str,
-                 last_price : float,
-                 session_features : np.ndarray
-                 ):
-        pass
-
-
-
-class FitPricingFunctionStep(BaseContextStep):
-    """
-    Fit pricing function using data.
-    Input: pricing_data
-    Output: fitted pricing function instance
-    """
-
-    def transform(self, pricing_data: pd.DataFrame):
-        pricing_class = self.context.config.get('pricing_function_class', StaticPricer)
-        pricing_params = self.context.config.get('pricing_function_params', {})
-
-        pricer = pricing_class(**pricing_params)
-        pricer.fit(pricing_data)
-
-        return pricer
-
-
-class PredictPricesStep(BaseContextStep):
-    """
-    Predict optimal prices using fitted pricing function.
-    Input: (pricer, state_space)
-    Output: prices_df [productId, predicted_price]
-    """
-
-    def transform(self, data: tuple):
-        pricer, state_space = data
-
-        products = self.context.products
-        product_ids = products['id'].values
-
-        predicted_prices = pricer.predict(state_space)
-
-        return pd.DataFrame({
-            'productId': product_ids,
-            'predicted_price': predicted_prices
-        })

experiments/procesing/steps/session.py

@@ -1,262 +0,0 @@
-"""
-Session feature extraction for ML training pipeline.
-"""
-import pandas as pd
-import numpy as np
-import re
-from typing import Dict, Any
-from procesing.steps.base import BaseContextStep
-
-EVENT_CATS = {
-    'page_view': ['page_view'],
-    'item_view': ['view_item_page', 'learn_more_about_item'],
-    'cart_add': ['add_item_to_cart'],
-    'purchase': ['purchase', 'checkout_complete'],
-    'hover': ['hover_over_title', 'hover_over_paragraph', 'hover_over_link', 'hover_over_button'],
-    # 'filter': ['filter', 'search', 'apply_filter'],
-}
-HEADLESS_RE = re.compile(r'HeadlessChrome|Headless|PhantomJS', re.I)
-AUTOMATION_RE = re.compile(r'Selenium|Playwright|Puppeteer|WebDriver|chromedriver|geckodriver', re.I)
-BROWSER_PATTERNS = [('Chrome', r'Chrome/[\d.]+'), ('Firefox', r'Firefox/[\d.]+'),
-                    ('Safari', r'Safari/[\d.]+'), ('Edge', r'Edg/[\d.]+')]
-
-
-def _get_browser(s: str) -> str:
-    if pd.isna(s): return 'Unknown'
-    for name, pat in BROWSER_PATTERNS:
-        if re.search(pat, s): return name
-    return 'Other'
-
-
-class TemporalFeatureStep(BaseContextStep):
-    """Vectorized time-based features: durations, velocities, gaps."""
-
-    def __init__(self, context, timeout_sec: float = 900, velocity_window: str = '5min'):
-        super().__init__(context)
-        self.timeout_sec = timeout_sec
-        self.velocity_window = velocity_window
-
-    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
-        df = X.copy()
-        if df.empty or 'ts' not in df.columns:
-            return pd.DataFrame(columns=pd.Series(['sessionId']))
-
-        df['ts_dt'] = pd.to_datetime(df['ts'])
-        df = df.sort_values(['sessionId', 'ts_dt'])
-        df['time_diff'] = df.groupby('sessionId')['ts_dt'].diff().dt.total_seconds()
-        df['active_diff'] = df['time_diff'].where(df['time_diff'] <= self.timeout_sec, 0)
-
-        agg = df.groupby('sessionId').agg(
-            session_duration_sec=('active_diff', 'sum'),
-            total_interactions=('sessionId', 'count'),
-            avg_time_between_events=('time_diff', 'mean'),
-            std_time_between_events=('time_diff', 'std'),
-            min_time_between_events=('time_diff', 'min'),
-            session_start_hour=('ts_dt', lambda x: x.min().hour),
-        ).reset_index()
-        agg['std_time_between_events'] = agg['std_time_between_events'].fillna(0)
-        agg['interaction_velocity'] = np.where(
-            agg['session_duration_sec'] > 0,
-            (agg['total_interactions'] / agg['session_duration_sec']) * 60, 0)
-
-        vel = df.set_index('ts_dt').groupby('sessionId').resample(self.velocity_window, include_groups=False).size()
-        max_velocity = vel.groupby('sessionId').max().rename('max_velocity_5min')
-        agg = agg.merge(max_velocity, on='sessionId', how='left')
-        agg['max_velocity_5min'] = agg['max_velocity_5min'].fillna(0)
-        return agg
-
-
-class BehavioralFeatureStep(BaseContextStep):
-    """Vectorized event counts and ratios per session."""
-
-    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
-        df = X.copy()
-        if df.empty or 'eventName' not in df.columns:
-            return pd.DataFrame(columns=pd.Series(['sessionId']))
-
-        for cat, events in EVENT_CATS.items():
-            df[f'is_{cat}'] = df['eventName'].isin(events)
-        df['is_hover'] = df['is_hover'] | df['eventName'].str.startswith('hover_over_')
-
-        agg = df.groupby('sessionId').agg(
-            total_events=('eventName', 'count'), unique_pages=('page', 'nunique'),
-            page_views=('is_page_view', 'sum'), item_views=('is_item_view', 'sum'),
-            cart_adds=('is_cart_add', 'sum'), purchases=('is_purchase', 'sum'),
-            hover_events=('is_hover', 'sum'),
-            # filter_events=('is_filter', 'sum'),
-        ).reset_index()
-        agg['cart_to_view_ratio'] = np.where(agg['item_views'] > 0, agg['cart_adds'] / agg['item_views'], 0)
-        agg['conversion_rate'] = np.where(agg['item_views'] > 0, agg['purchases'] / agg['item_views'], 0)
-        agg['hover_intensity'] = np.where(agg['total_events'] > 0, agg['hover_events'] / agg['total_events'], 0)
-        return agg
-
-
-class ProductFeatureStep(BaseContextStep):
-    """Vectorized product interaction features: diversity, depth, price sensitivity."""
-
-    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
-        df = X.copy()
-        if df.empty:
-            return pd.DataFrame(columns=pd.Series(['sessionId']))
-        price_col = next((c for c in ['metadata_base_price', 'metadata_price', 'base_price'] if c in df.columns), None)
-        df['price_seen'] = pd.to_numeric(df[price_col], errors='coerce') if price_col else np.nan
-
-        prod_df = df[df['productId'].notna()]
-        if prod_df.empty:
-            return pd.DataFrame(columns=pd.Series(['sessionId', 'unique_products_viewed', 'product_view_depth', 'avg_price_seen', 'min_price_seen', 'max_price_seen', 'price_range']))
-
-        agg = prod_df.groupby('sessionId').agg(
-            unique_products_viewed=('productId', 'nunique'),
-            product_view_depth=('productId', lambda x: x.value_counts().iloc[0] if len(x) > 0 else 0),
-            avg_price_seen=('price_seen', 'mean'), min_price_seen=('price_seen', 'min'),
-            max_price_seen=('price_seen', 'max'),
-        ).reset_index()
-        agg['price_range'] = (agg['max_price_seen'] - agg['min_price_seen']).fillna(0)
-        return agg
-
-
-class UserAgentFeatureStep(BaseContextStep):
-    """Parse userAgent into bot-detection signals."""
-
-    def transform(self, X: pd.DataFrame) -> pd.DataFrame|pd.Series:
-        df = X.copy()
-        if df.empty or 'userAgent' not in df.columns:
-            return pd.DataFrame(columns=pd.Series(['sessionId']))
-
-        ua = df.groupby('sessionId')['userAgent'].first().reset_index()
-        ua['is_headless'] = ua['userAgent'].str.contains(HEADLESS_RE, na=False)
-        ua['is_automation'] = ua['userAgent'].str.contains(AUTOMATION_RE, na=False)
-        ua['browser_family'] = ua['userAgent'].apply(_get_browser)
-        return ua[['sessionId', 'is_headless', 'is_automation', 'browser_family']]
-
-
-class ExtractSessionFeaturesStep(BaseContextStep):
-    """
-    Vectorized session feature extraction - replaces O(n^2) per-row loop.
-    Input: interactions_df
-    Output: session-level feature matrix
-    THIS is our main mapping from tau (trajectory) to some features vector theta - we need to do this very well. This is what will go into demand esimation.
-    """
-
-    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
-        if X.empty:
-            return pd.DataFrame()
-        df = X.copy()
-
-        # run all feature steps and merge on sessionId
-        temporal = TemporalFeatureStep(self.context).transform(df)
-        behavioral = BehavioralFeatureStep(self.context).transform(df)
-        product = ProductFeatureStep(self.context).transform(df)
-        ua = UserAgentFeatureStep(self.context).transform(df)
-
-        result = temporal
-        for other in [behavioral, product, ua]:
-            if not other.empty and 'sessionId' in other.columns:
-                result = result.merge(other, on='sessionId', how='left')
-
-        # carry forward experimentId for label joining
-        if 'experimentId' in df.columns:
-            exp_map = df.groupby('sessionId')['experimentId'].first()
-            result = result.merge(exp_map, on='sessionId', how='left')
-
-        return result
-
-
-class JoinLabelsStep(BaseContextStep):
-    """
-    Join experiment labels to session features.
-    Input: (features_df, experiments_df) or features_df (fetches experiments)
-    Output: labeled feature matrix with is_agent column
-    """
-
-    def transform(self, X : tuple) -> pd.DataFrame:
-        data = X;
-        if isinstance(data, tuple):
-            features_df, experiments_df = data
-        else:
-            features_df = data
-            if 'experimentId' not in features_df.columns:
-                return features_df
-            exp_ids = features_df['experimentId'].dropna().unique().tolist()
-            experiments_df = self.context.provider.fetch_experiments(exp_ids) if exp_ids else pd.DataFrame()
-
-        if features_df.empty:
-            return features_df
-        if experiments_df.empty:
-            features_df['is_agent'] = np.nan
-            return features_df
-
-        exp = experiments_df.copy()
-        if 'id' in exp.columns:
-            exp = exp.rename(columns={'id': 'experimentId'})
-        if 'xp_human_only' in exp.columns:
-            exp['is_agent'] = ~exp['xp_human_only']
-
-        cols = ['experimentId'] + [c for c in ['is_agent', 'xp_human_only', 'xp_market_mode'] if c in exp.columns]
-        return features_df.merge(exp[cols].drop_duplicates(), on='experimentId', how='left')
-
-
-class ValidateDataStep(BaseContextStep):
-    """
-    Data quality checks before training.
-    Input: df
-    Output: df (unchanged, but logs validation report to context)
-    """
-    REQUIRED = ['sessionId', 'eventName', 'ts']
-
-    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
-        df = X.copy()
-        report = {'status': 'valid', 'rows': len(df), 'sessions': 0}
-        if df.empty:
-            report['status'] = 'empty'
-            self.context.cache('validation_report', report)
-            return df
-
-        missing = [c for c in self.REQUIRED if c not in df.columns]
-        if missing:
-            report['status'] = 'invalid'
-            report['missing_cols'] = missing
-
-        report['sessions'] = df['sessionId'].nunique() if 'sessionId' in df.columns else 0
-        report['null_sessions'] = int(df['sessionId'].isna().sum()) if 'sessionId' in df.columns else 0
-        if 'experimentId' in df.columns:
-            report['null_experiments'] = int(df['experimentId'].isna().sum())
-
-        self.context.cache('validation_report', report)
-        return df
-
-
-# legacy compat - kept for backwards compatibility with existing code
-def _extract_features_for_session(session_df: pd.DataFrame, session_timeout_sec: float = 900) -> Dict[str, Any]:
-    """Single-session feature extraction (legacy interface)."""
-    defaults = {k: 0 for k in ['total_interactions', 'page_views', 'item_views', 'searches',
-                               'cart_adds', 'hovers', 'unique_products_viewed', 'product_view_depth',
-                               'session_duration_sec', 'interaction_velocity',
-                               'avg_time_between_events', 'std_time_between_events', 'cart_to_view_ratio']}
-    if session_df.empty:
-        return defaults
-
-    session_df = session_df.copy()
-    if 'sessionId' not in session_df.columns:
-        session_df['sessionId'] = 'tmp'
-
-    # use a dummy context for the steps
-    class DummyCtx: config = {} # should maybe inherit but whatever
-    ctx = DummyCtx()
-
-    t = TemporalFeatureStep(ctx, timeout_sec=session_timeout_sec).transform(session_df)
-    b = BehavioralFeatureStep(ctx).transform(session_df)
-    p = ProductFeatureStep(ctx).transform(session_df)
-
-    result = {}
-    for df in [t, b, p]:
-        if not df.empty:
-            for col in df.columns:
-                if col != 'sessionId':
-                    result[col] = df[col].iloc[0] if len(df) > 0 else 0
-
-    remap = {'hover_events': 'hovers', 'filter_events': 'searches', 'unique_pages': 'unique_pages_visited'}
-    for old, new in remap.items():
-        if old in result:
-            result[new] = result.pop(old)
-    return result

experiments/procesing/tests/conftest.py

@@ -1,281 +0,0 @@
-import pytest
-import pandas as pd
-from typing import List
-from procesing.providers.base import DataProvider
-from procesing.context import PipelineContext
-
-
-class MockProvider(DataProvider):
-    """Mock provider for testing, holds in-memory fixtures"""
-
-    def __init__(self, products_df=None, experiments_df=None, kafka_data=None):
-        self._products = products_df if products_df is not None else pd.DataFrame()
-        self._experiments = experiments_df if experiments_df is not None else pd.DataFrame()
-        self._kafka_data = kafka_data if kafka_data is not None else {}
-
-    def fetch_products(self, store_mode: str) -> pd.DataFrame:
-        return self._products.copy()
-
-    def fetch_experiments(self, experiment_ids: List[str]) -> pd.DataFrame:
-        if self._experiments.empty:
-            return pd.DataFrame()
-        return self._experiments[
-            self._experiments['id'].isin(experiment_ids)
-        ].copy()
-
-    def fetch_kafka_topic(self, topic: str) -> pd.DataFrame:
-        return self._kafka_data.get(topic, pd.DataFrame()).copy()
-
-
-@pytest.fixture
-def mock_products():
-    """Standard product catalog fixture with realistic IDs from test data"""
-    return pd.DataFrame({
-        'id': [
-            'd018efc1-25e9-4284-b276-80386e048b25',
-            '51266ddb-5b07-47b7-89ee-5b5cae94bb11',
-            '2cd7f756-fc65-4ba0-ab01-74521c1fff43'
-        ],
-        'name': ['Junior Suite', 'Superior Room', 'Deluxe Room'],
-        'base_price': [200.0, 150.0, 180.0]
-    })
-
-
-@pytest.fixture
-def mock_interactions_raw_kafka():
-    """Raw Kafka message structure for interactions, matches production format"""
-    return [
-        {
-            'partitionID': 0, 'offset': 203, 'timestamp': 1764102082676,
-            'value': {
-                'payload': {
-                    'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
-                    'experimentId': '53aefd07-f66a-4d7f-ba8b-7ea1fc562d35',
-                    'eventName': 'learn_more_about_item',
-                    'page': '/hotel/products/d018efc1-25e9-4284-b276-80386e048b25',
-                    'productId': 'd018efc1-25e9-4284-b276-80386e048b25',
-                    'metadata': {'type': 'hotel', 'dateIndex': 1, 'roomType': 'Junior Suite'},
-                    'storeMode': 'hotel',
-                    'ts': '2025-11-25T20:21:22.674Z'
-                }
-            }
-        },
-        {
-            'partitionID': 0, 'offset': 204, 'timestamp': 1764102086982,
-            'value': {
-                'payload': {
-                    'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
-                    'experimentId': '53aefd07-f66a-4d7f-ba8b-7ea1fc562d35',
-                    'eventName': 'page_view',
-                    'page': '/hotel/products',
-                    'productId': None,
-                    'metadata': {'referrer': ''},
-                    'storeMode': 'hotel',
-                    'ts': '2025-11-25T20:21:26.947Z'
-                }
-            }
-        },
-        {
-            'partitionID': 0, 'offset': 205, 'timestamp': 1764102091825,
-            'value': {
-                'payload': {
-                    'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
-                    'experimentId': '53aefd07-f66a-4d7f-ba8b-7ea1fc562d35',
-                    'eventName': 'hover_over_title',
-                    'page': '/hotel/products',
-                    'productId': '51266ddb-5b07-47b7-89ee-5b5cae94bb11',
-                    'metadata': {'elementText': 'Superior Room', 'dateIndex': 1, 'dwellTime': 1200},
-                    'storeMode': 'hotel',
-                    'ts': '2025-11-25T20:21:31.823Z'
-                }
-            }
-        },
-        {
-            'partitionID': 0, 'offset': 206, 'timestamp': 1764102094193,
-            'value': {
-                'payload': {
-                    'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
-                    'experimentId': 'bbbbcccc-dddd-eeee-ffff-000011112222',
-                    'eventName': 'hover_over_paragraph',
-                    'page': '/hotel/products',
-                    'productId': '51266ddb-5b07-47b7-89ee-5b5cae94bb11',
-                    'metadata': {'elementText': 'price', 'dateIndex': 1, 'dwellTime': 1307},
-                    'storeMode': 'hotel',
-                    'ts': '2025-11-25T20:21:34.191Z'
-                }
-            }
-        },
-        {
-            'partitionID': 0, 'offset': 207, 'timestamp': 1764102101970,
-            'value': {
-                'payload': {
-                    'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
-                    'experimentId': 'bbbbcccc-dddd-eeee-ffff-000011112222',
-                    'eventName': 'hover_over_paragraph',
-                    'page': '/hotel/products',
-                    'productId': 'd018efc1-25e9-4284-b276-80386e048b25',
-                    'metadata': {'elementText': 'price', 'dateIndex': 1, 'dwellTime': 1201},
-                    'storeMode': 'hotel',
-                    'ts': '2025-11-25T20:21:41.967Z'
-                }
-            }
-        }
-    ]
-
-
-@pytest.fixture
-def mock_interactions(mock_interactions_raw_kafka):
-    """Processed interaction DataFrame (what provider.fetch_kafka_topic returns)"""
-    records = [msg['value']['payload'] for msg in mock_interactions_raw_kafka]
-    df = pd.DataFrame(records)
-    df['timestamp'] = pd.to_datetime(df['ts'])
-    return df
-
-
-@pytest.fixture
-def mock_price_logs_raw_kafka():
-    """Raw Kafka message structure for price logs, matches production format"""
-    return [
-        {
-            'partitionID': 0, 'offset': 32, 'timestamp': 1764104757969,
-            'value': {
-                'payload': {
-                    'productId': '2cd7f756-fc65-4ba0-ab01-74521c1fff43',
-                    'price': 162.47,
-                    'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
-                    'experimentId': '53aefd07-f66a-4d7f-ba8b-7ea1fc562d35',
-                    'storeMode': 'hotel',
-                    'ts': '2025-11-25T21:05:57.967Z'
-                }
-            }
-        },
-        {
-            'partitionID': 0, 'offset': 33, 'timestamp': 1764104757995,
-            'value': {
-                'payload': {
-                    'productId': '2ddabbfc-4127-48fc-86dc-ebc4c677efa2',
-                    'price': 743.49,
-                    'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
-                    'experimentId': '53aefd07-f66a-4d7f-ba8b-7ea1fc562d35',
-                    'storeMode': 'hotel',
-                    'ts': '2025-11-25T21:05:57.993Z'
-                }
-            }
-        },
-        {
-            'partitionID': 0, 'offset': 34, 'timestamp': 1764104758011,
-            'value': {
-                'payload': {
-                    'productId': '2cd7f756-fc65-4ba0-ab01-74521c1fff43',
-                    'price': 163.87,
-                    'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
-                    'experimentId': '53aefd07-f66a-4d7f-ba8b-7ea1fc562d35',
-                    'storeMode': 'hotel',
-                    'ts': '2025-11-25T21:05:58.009Z'
-                }
-            }
-        },
-        {
-            'partitionID': 0, 'offset': 35, 'timestamp': 1764104758050,
-            'value': {
-                'payload': {
-                    'productId': '2ddabbfc-4127-48fc-86dc-ebc4c677efa2',
-                    'price': 397.46,
-                    'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
-                    'experimentId': '53aefd07-f66a-4d7f-ba8b-7ea1fc562d35',
-                    'storeMode': 'hotel',
-                    'ts': '2025-11-25T21:05:58.049Z'
-                }
-            }
-        },
-        {
-            'partitionID': 0, 'offset': 36, 'timestamp': 1764104768865,
-            'value': {
-                'payload': {
-                    'productId': '2cd7f756-fc65-4ba0-ab01-74521c1fff43',
-                    'price': 401.66,
-                    'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
-                    'experimentId': '53aefd07-f66a-4d7f-ba8b-7ea1fc562d35',
-                    'storeMode': 'hotel',
-                    'ts': '2025-11-25T21:06:08.864Z'
-                }
-            }
-        }
-    ]
-
-
-@pytest.fixture
-def mock_price_logs(mock_price_logs_raw_kafka):
-    """Processed price logs DataFrame (what provider.fetch_kafka_topic returns)"""
-    # extract payloads and flatten
-    records = [msg['value']['payload'] for msg in mock_price_logs_raw_kafka]
-    df = pd.DataFrame(records)
-    df['timestamp'] = pd.to_datetime(df['ts'])
-    return df
-
-
-@pytest.fixture
-def mock_experiments():
-    """Standard experiment metadata fixture matching Supabase schema"""
-    return pd.DataFrame({
-        'id': ['53aefd07-f66a-4d7f-ba8b-7ea1fc562d35', 'bbbbcccc-dddd-eeee-ffff-000011112222'],
-        'created_at': pd.to_datetime(['2025-11-25T20:00:00Z', '2025-11-26T10:00:00Z']),
-        'subject_name': ['Session A', 'Session B'],
-        'xp_human_only': [True, False],
-        'xp_market_mode': ['hotel', 'airline'],
-        'xp_task_id': [None, None]
-    })
-
-
-@pytest.fixture
-def mock_provider(mock_products, mock_experiments, mock_interactions, mock_price_logs):
-    """Fully configured mock provider"""
-    return MockProvider(
-        products_df=mock_products,
-        experiments_df=mock_experiments,
-        kafka_data={
-            'user-interactions': mock_interactions,
-            'price-logs': mock_price_logs
-        }
-    )
-
-
-@pytest.fixture
-def pipeline_context(mock_provider):
-    """Standard pipeline context for testing"""
-    return PipelineContext(
-        provider=mock_provider,
-        store_mode='hotel',
-        window_size='30s',
-        n_price_buckets=3
-    )
-
-
-@pytest.fixture
-def empty_provider():
-    """Provider with no data, for edge case testing"""
-    return MockProvider(
-        products_df=pd.DataFrame(columns=['id', 'name', 'base_price']),
-        experiments_df=pd.DataFrame(columns=['id', 'created_at', 'subject_name', 'xp_human_only', 'xp_market_mode', 'xp_task_id']),
-        kafka_data={'user-interactions': pd.DataFrame(), 'price-logs': pd.DataFrame()}
-    )
-
-
-@pytest.fixture
-def empty_context(empty_provider):
-    """Context with empty provider"""
-    return PipelineContext(
-        provider=empty_provider,
-        store_mode='hotel',
-        window_size='30s'
-    )
-
-
-@pytest.fixture
-def session_interactions(mock_interactions):
-    """Enriched interaction data for session feature extraction tests"""
-    df = mock_interactions.copy()
-    df['userAgent'] = ['Mozilla/5.0 Chrome/120', 'Mozilla/5.0 Chrome/120',
-                       'HeadlessChrome/120', 'HeadlessChrome/120', 'HeadlessChrome/120']
-    df['metadata_base_price'] = [None, None, 150.0, 150.0, 200.0]
-    return df

experiments/procesing/tests/test_augement.py

@@ -1,45 +0,0 @@
-import pytest
-import random
-import pandas as pd
-from procesing.steps import (
-    CreatePriceBucketsStep,
-    AugmentEventNamesStep
-)
-
-def test_bucketing(pipeline_context):
-    step = CreatePriceBucketsStep(context=pipeline_context)
-
-    # Test with normal price data
-    df = pd.DataFrame({
-        'metadata_price': random.sample(range(10, 1000), 100)
-    })
-    result = step.transform(df)
-    assert 'price_bucket' in result.columns
-    # test if is categorical
-    assert isinstance(result['price_bucket'].dtype, pd.CategoricalDtype)
-    assert result['price_bucket'].nunique() == 3 # as per context config
-    # distribution check
-    counts = result['price_bucket'].value_counts()
-    assert all(counts > 0)
-    assert counts.max() - counts.min() <= 10  # roughly equal distribution for 100 samples
-    # Test with empty DataFrame
-    df = pd.DataFrame()
-    result = step.transform(df)
-    assert 'price_bucket' in result.columns
-    assert result.empty
-
-
-def test_augment_names(pipeline_context):
-    df = pd.DataFrame({
-        'eventName': ['click', 'view', 'purchase'],
-        'productId': ['prod_1', 'prod_2', None],
-        'price_bucket': ['PB_1', None, 'PB_3']
-    })
-    step = AugmentEventNamesStep(context=pipeline_context)
-    result = step.transform(df)
-    expected_event_names = [
-        'click_prod_1@PB_1',
-        'view',
-        'purchase'
-    ]
-    assert result['eventName'].tolist() == expected_event_names

experiments/procesing/tests/test_demand.py

@@ -1,49 +0,0 @@
-import pytest
-import random
-import pandas as pd
-from procesing.steps import (
-    ComputeDemandStep
-)
-
-def test_compute_demand(pipeline_context):
-    step = ComputeDemandStep(context=pipeline_context)
-
-    # Test with normal interaction data
-    df = pd.DataFrame({
-        'ts': pd.date_range(start='2023-01-01', periods=100, freq='h'),
-        'productId': random.choices([
-            'd018efc1-25e9-4284-b276-80386e048b25',
-            '51266ddb-5b07-47b7-89ee-5b5cae94bb11',
-            '2cd7f756-fc65-4ba0-ab01-74521c1fff43'
-        ], k=100),
-        'eventName': random.choices(['view', 'click', 'purchase'], k=100)
-    })
-    result = step.transform(df)
-    assert type(result) == pd.DataFrame
-    assert not result.empty
-    assert set(result['productId']) == set(pipeline_context.products['id'])
-    assert all(result['demand_score'] > 100/3 -10)
-
-
-def test_compute_demand_skewed(pipeline_context):
-    step = ComputeDemandStep(context=pipeline_context)
-
-    # Test with normal interaction data
-    df = pd.DataFrame({
-        'ts': pd.date_range(start='2023-01-01', periods=100, freq='h'),
-        'productId': random.choices([
-            'd018efc1-25e9-4284-b276-80386e048b25',
-            '51266ddb-5b07-47b7-89ee-5b5cae94bb11',
-            '2cd7f756-fc65-4ba0-ab01-74521c1fff43'
-        ], weights=[0.7, 0.2, 0.1], k=100),
-        'eventName': random.choices(['view', 'click', 'purchase'], k=100)
-    })
-    result = step.transform(df)
-    assert type(result) == pd.DataFrame
-    assert not result.empty
-    assert set(result['productId']) == set(pipeline_context.products['id'])
-    # test for skewness
-    scores = result.set_index('productId')['demand_score'].to_dict()
-    assert scores['d018efc1-25e9-4284-b276-80386e048b25'] > \
-           scores['51266ddb-5b07-47b7-89ee-5b5cae94bb11'] > \
-           scores['2cd7f756-fc65-4ba0-ab01-74521c1fff43']

experiments/procesing/tests/test_fetch.py

@@ -1,51 +0,0 @@
-import pytest
-import pandas as pd
-from procesing.steps import (
-    FetchInteractionsStep,
-    FetchPriceLogsStep,
-    FetchExperimentsStep,
-)
-
-
-def test_fetch_interactions_data(pipeline_context):
-    step = FetchInteractionsStep(pipeline_context)
-    data = step.transform(None)
-    assert data is not None
-    assert isinstance(data, pd.DataFrame)
-    expected_cols = [
-        "eventName",
-        "dateIndex",
-        "experimentId",
-        "storeMode",
-        "metadata_elementText"
-    ]
-    for expected in expected_cols:
-        assert expected in data.columns
-
-def test_fetch_price_logs(pipeline_context):
-    step = FetchPriceLogsStep(pipeline_context)
-    data = step.transform(None)
-    assert data is not None
-    assert isinstance(data, pd.DataFrame)
-    expected_cols = [
-        "price",
-        "productId"
-    ]
-    for expected in expected_cols:
-        assert expected in data.columns
-    prices = data['price'].to_list()
-    assert min(prices) >= 0
-    assert max(prices) <= 9999
-
-
-def test_experiments_fetching(pipeline_context):
-    interactions = FetchInteractionsStep(pipeline_context).transform(None)
-    assert interactions is not None
-    experiments = FetchExperimentsStep(pipeline_context)
-    experiment_data = experiments.transform(interactions)
-    assert experiment_data is not None
-    assert isinstance(experiment_data, pd.DataFrame)
-    assert not experiment_data.empty
-    assert 'id' in experiment_data.columns
-    assert len(experiment_data) == 2
-    assert '53aefd07-f66a-4d7f-ba8b-7ea1fc562d35' in experiment_data['id'].values

experiments/procesing/tests/test_pricing.py

@@ -1,87 +0,0 @@
-import pytest
-import pandas as pd
-
-from procesing.pricers import (
-    StaticPricer,
-    RandomPricer,
-    ElasticityBasedPricer
-)
-
-
-def test_static_pricer_fit_and_predict():
-    # Sample historical data
-    historical_data = pd.DataFrame({
-        'product_id': [1, 2, 3],
-        'base_price': [100.0, 150.0, 200.0]
-    })
-
-    # Initialize and fit StaticPricer
-    pricer = StaticPricer()
-    pricer.fit(historical_data)
-
-    # Predict prices
-    predicted_prices = pricer.predict(None)
-
-    # Assert that predicted prices match base prices
-    expected_prices = historical_data['base_price'].values
-    assert all(predicted_prices == expected_prices), "Predicted prices do not match base prices"
-
-
-def test_random_pricer_fit_and_predict():
-    # Sample historical data
-    historical_data = pd.DataFrame({
-        'product_id': [1, 2, 3],
-        'base_price': [100.0, 150.0, 200.0]
-    })
-
-    # Initialize and fit RandomPricer
-    pricer = RandomPricer(price_min=50.0, price_max=250.0, seed=42)
-    pricer.fit(historical_data)
-
-    # Predict prices
-    predicted_prices = pricer.predict(None)
-
-    # Assert that predicted prices are within bounds
-    assert predicted_prices.min() >= 50.0, "Predicted prices are below minimum bound"
-    assert predicted_prices.max() <= 250.0, "Predicted prices are above maximum bound"
-    # distribution check (not so strict)
-    assert len(set(predicted_prices)) > 1, "Predicted prices are not varied enough"
-    assert len(predicted_prices) == len(historical_data), "Number of predicted prices does not match number of products"
-
-def test_elasticity_based_pricer_fit_and_predict():
-    # Sample historical data
-    historical_data = pd.DataFrame({
-        'productId': [1, 2, 3],
-        'elasticity': [-1.5, -0.5, -2.0],
-        'base_price': [100.0, 150.0, 200.0],
-        'mean_demand': [10, 20, 15]
-    })
-
-    # Initialize and fit ElasticityBasedPricer
-    pricer = ElasticityBasedPricer(alpha=0.1, price_floor=50.0, price_ceil=300.0)
-    pricer.fit(historical_data)
-
-    # Create a mock state space with demand deviations
-    class MockStateSpace:
-        def __init__(self, demand):
-            self.demand = demand
-
-    # Simulate demand higher than mean for all products
-    state_space = MockStateSpace(demand=[15, 25, 20])
-
-    # Predict prices
-    predicted_prices = pricer.predict(state_space)
-
-    # Assert that predicted prices are within bounds
-    assert predicted_prices.min() >= 50.0, "Predicted prices are below minimum bound"
-    assert predicted_prices.max() <= 300.0, "Predicted prices are above maximum bound"
-    assert len(predicted_prices) == len(historical_data), "Number of predicted prices does not match number of products"
-
-    # now we gotta check semantic validity
-    # since demand is higher than mean, prices should generally increase
-    for i, row in historical_data.iterrows():
-        base_price = row['base_price']
-        elasticity = row['elasticity']
-        expected_increase = base_price * (1 + 0.1 * abs(elasticity) * ((state_space.demand[i] - row['mean_demand']) / row['mean_demand']))
-        assert predicted_prices[i] >= base_price, f"Predicted price for product {row['productId']} did not increase as expected"
-        assert abs(predicted_prices[i] - expected_increase) < 1e-5, f"Predicted price for product {row['productId']} does not match expected calculation within 1e-5 tolerance"

experiments/pytest.ini

@@ -1,8 +0,0 @@
-[pytest]
-pythonpath = .
-testpaths = procesing/tests agents
-python_files = test*.py
-python_classes = Test*
-python_functions = test_*
-asyncio_mode = auto
-asyncio_default_fixture_loop_scope = function

experiments/seed_products.py

@@ -1,125 +0,0 @@
-import random
-import json
-import os
-import logging
-from dotenv import load_dotenv
-from supabase import create_client, Client
-from tqdm import tqdm
-
-load_dotenv()
-
-logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
-log = logging.getLogger(__name__)
-
-SUPABASE_URL = os.getenv("NEXT_PUBLIC_SUPABASE_URL")
-SUPABASE_SERVICE_KEY = os.getenv("SUPABASE_SERVICE_ROLE_KEY")
-
-if not SUPABASE_SERVICE_KEY:
-    log.error("SUPABASE_SERVICE_ROLE_KEY not found in environment")
-    raise ValueError("Missing SUPABASE_SERVICE_ROLE_KEY - required for admin operations")
-
-supabase: Client = create_client(SUPABASE_URL, SUPABASE_SERVICE_KEY)
-
-DAYS = 14
-
-# hotel room configurations
-ROOMS = {
-    "Presidential Suite": {'amenities': ['ocean_view', 'balcony', 'jacuzzi', 'butler_service', 'premium_minibar'], 'total': 1, 'image_url': "", "base_price": 450, 'name': 'Presidential Suite', 'refundable': True, 'max_occupancy': 4},
-    "Executive Suite": {'amenities': ['city_view', 'balcony', 'workspace', 'lounge_access'], 'total': 2, 'image_url': "", "base_price": 280, 'name': 'Executive Suite', 'refundable': True, 'max_occupancy': 3},
-    "Junior Suite": {'amenities': ['garden_view', 'mini_fridge', 'coffee_maker'], 'total': 5, 'image_url': "", "base_price": 180, 'name': 'Junior Suite', 'refundable': True, 'max_occupancy': 2},
-    "Deluxe Room": {'amenities': ['city_view', 'work_desk', 'coffee_maker'], 'total': 8, 'image_url': "", "base_price": 140, 'name': 'Deluxe Room', 'refundable': False, 'max_occupancy': 2},
-    "Superior Room": {'amenities': ['wifi', 'tv', 'safe'], 'total': 12, 'image_url': "", "base_price": 110, 'name': 'Superior Room', 'refundable': False, 'max_occupancy': 2},
-    "Standard Room": {'amenities': ['wifi', 'tv'], 'total': 20, 'image_url': "", "base_price": 85, 'name': 'Standard Room', 'refundable': False, 'max_occupancy': 2},
-}
-
-# flight configurations
-FLIGHTS = {
-    "JFK-LAX-Economy": {'departure': {'time': '08:00', 'airport': 'JFK'}, 'arrival': {'time': '11:30', 'airport': 'LAX'}, 'duration': '5h 30m', 'stops': 0, 'cabin_class': 'economy', 'fare_rule': 'standard', 'refundable': False, 'total': 180, 'base_price': 250},
-    "JFK-LAX-Business": {'departure': {'time': '08:00', 'airport': 'JFK'}, 'arrival': {'time': '11:30', 'airport': 'LAX'}, 'duration': '5h 30m', 'stops': 0, 'cabin_class': 'business', 'fare_rule': 'flexible', 'refundable': True, 'total': 30, 'base_price': 850},
-    "ORD-MIA-Economy": {'departure': {'time': '14:15', 'airport': 'ORD'}, 'arrival': {'time': '18:45', 'airport': 'MIA'}, 'duration': '3h 30m', 'stops': 0, 'cabin_class': 'economy', 'fare_rule': 'basic', 'refundable': False, 'total': 200, 'base_price': 180},
-    "SFO-SEA-Premium": {'departure': {'time': '06:30', 'airport': 'SFO'}, 'arrival': {'time': '08:45', 'airport': 'SEA'}, 'duration': '2h 15m', 'stops': 0, 'cabin_class': 'premium', 'fare_rule': 'standard', 'refundable': False, 'total': 60, 'base_price': 420},
-    "ATL-DFW-First": {'departure': {'time': '16:00', 'airport': 'ATL'}, 'arrival': {'time': '17:30', 'airport': 'DFW'}, 'duration': '2h 30m', 'stops': 0, 'cabin_class': 'first', 'fare_rule': 'flexible', 'refundable': True, 'total': 12, 'base_price': 1600},
-    "LAX-SFO-Economy": {'departure': {'time': '10:00', 'airport': 'LAX'}, 'arrival': {'time': '11:30', 'airport': 'SFO'}, 'duration': '1h 30m', 'stops': 0, 'cabin_class': 'economy', 'fare_rule': 'standard', 'refundable': False, 'total': 150, 'base_price': 120},
-    "MIA-ATL-Premium": {'departure': {'time': '19:00', 'airport': 'MIA'}, 'arrival': {'time': '20:45', 'airport': 'ATL'}, 'duration': '1h 45m', 'stops': 0, 'cabin_class': 'premium', 'fare_rule': 'standard', 'refundable': True, 'total': 50, 'base_price': 380},
-    "DFW-ORD-Economy": {'departure': {'time': '07:30', 'airport': 'DFW'}, 'arrival': {'time': '10:15', 'airport': 'ORD'}, 'duration': '2h 45m', 'stops': 0, 'cabin_class': 'economy', 'fare_rule': 'basic', 'refundable': False, 'total': 190, 'base_price': 160},
-    "SEA-LAX-Business": {'departure': {'time': '13:00', 'airport': 'SEA'}, 'arrival': {'time': '15:30', 'airport': 'LAX'}, 'duration': '2h 30m', 'stops': 0, 'cabin_class': 'business', 'fare_rule': 'flexible', 'refundable': True, 'total': 40, 'base_price': 720},
-    "LAX-JFK-First": {'departure': {'time': '18:00', 'airport': 'LAX'}, 'arrival': {'time': '02:15', 'airport': 'JFK'}, 'duration': '5h 15m', 'stops': 0, 'cabin_class': 'first', 'fare_rule': 'flexible', 'refundable': True, 'total': 16, 'base_price': 1850},
-}
-
-def gen_hotel_products():
-    """generate hotel room products for next DAYS days"""
-    data = []
-    for day in range(DAYS):
-        for room_type, rdata in ROOMS.items():
-            data.append({
-                'room_type': room_type,
-                'date_index': day + 1,
-                'metadata': rdata,
-                'availability': random.randint(0, rdata['total'])
-            })
-    return data
-
-def gen_airline_products():
-    """generate flight products for next DAYS days"""
-    data = []
-    for day in range(DAYS):
-        for flight_type, fdata in FLIGHTS.items():
-            data.append({
-                'flight_type': flight_type,
-                'date_index': day + 1,
-                'metadata': fdata,
-                'availability': random.randint(0, fdata['total'])
-            })
-    return data
-
-def clear_table(table_name: str):
-    """clear all records from a table"""
-    try:
-        resp = supabase.table(table_name).select('id').execute()
-        if resp.data:
-            ids = [row['id'] for row in resp.data]
-            chunk_size = 100
-            for i in tqdm(range(0, len(ids), chunk_size), desc=f"Clearing {table_name}", unit="chunk"):
-                chunk = ids[i:i+chunk_size]
-                supabase.table(table_name).delete().in_('id', chunk).execute()
-            log.info(f"Deleted {len(ids)} records from {table_name}")
-        else:
-            log.info(f"{table_name} already empty")
-    except Exception as e:
-        log.error(f"Failed to clear {table_name}: {e}")
-        raise
-
-def seed_table(table_name: str, data: list[dict]):
-    """insert records into a table"""
-    try:
-        chunk_size = 100
-        total = len(data)
-        for i in tqdm(range(0, total, chunk_size), desc=f"Seeding {table_name}", unit="chunk"):
-            chunk = data[i:i+chunk_size]
-            supabase.table(table_name).insert(chunk).execute()
-        log.info(f"Inserted {total} records into {table_name}")
-    except Exception as e:
-        log.error(f"Failed to seed {table_name}: {e}")
-        raise
-
-def main():
-
-    log.info("Generating hotel products...")
-    hotel_products = gen_hotel_products()
-    log.info(f"Generated {len(hotel_products)} hotel products")
-
-    log.info("Generating airline products...")
-    airline_products = gen_airline_products()
-    log.info(f"Generated {len(airline_products)} airline products\n")
-
-    log.info("Clearing existing products...")
-    clear_table('hotel_products')
-    clear_table('airline_products')
-
-    log.info("Seeding products...")
-    seed_table('hotel_products', hotel_products)
-    seed_table('airline_products', airline_products)
-
-
-if __name__ == "__main__":
-    main()

lib/model_registry.py

@@ -1,226 +0,0 @@
-import redis
-import pickle
-import json
-import pandas as pd
-from typing import Optional, Dict, Any
-import os
-import logging
-log = logging.getLogger(__name__)
-
-class ModelRegistry:
-    """
-    Lightweight model registry using Redis for storing pricing models and elasticity data.
-    Models are serialized using pickle, metadata stored as JSON.
-    """
-
-    def __init__(self, redis_host: str = None, redis_port: int = None):
-        host = redis_host or os.getenv('REDIS_HOST', 'localhost')
-        port = redis_port or int(os.getenv('REDIS_PORT', '6378'))
-
-        self.redis_client = redis.Redis(
-            host=host,
-            port=port,
-            db=0,
-            decode_responses=False
-        )
-        self.metadata_prefix = "model:meta:"
-        self.data_prefix = "model:data:"
-        self.elasticity_prefix = "elasticity:"
-        self.prices_prefix = "prices:"
-
-    def publish_elasticity(self,
-                          elasticity_df: pd.DataFrame,
-                          model_name: str = 'latest',
-                          metadata: Optional[Dict[str, Any]] = None):
-        """
-        Store elasticity estimates in registry.
-
-        Args:
-            elasticity_df: df with [productId, elasticity, std_error, n_obs]
-            model_name: identifier for this elasticity snapshot
-            metadata: additional info (timestamp, window_size, etc)
-        """
-        key = f"{self.elasticity_prefix}{model_name}"
-
-        # serialize dataframe as JSON
-        data_json = elasticity_df.to_json(orient='records')
-
-        # store data
-        self.redis_client.set(key, data_json)
-
-        # store metadata
-        meta = metadata or {}
-        meta.update({
-            'n_products': len(elasticity_df),
-            'mean_elasticity': float(elasticity_df['elasticity'].mean()),
-            'model_type': 'elasticity_snapshot'
-        })
-
-        meta_key = f"{self.metadata_prefix}{model_name}"
-        self.redis_client.set(meta_key, json.dumps(meta))
-
-        log.info(f"Published elasticity model '{model_name}' with {len(elasticity_df)} products")
-
-    def get_elasticity(self, model_name: str = 'latest') -> Optional[pd.DataFrame]:
-        """Retrieve elasticity estimates from registry."""
-        key = f"{self.elasticity_prefix}{model_name}"
-        data_json = self.redis_client.get(key)
-
-        if data_json is None:
-            return None
-
-        # decode bytes to string if needed
-        if isinstance(data_json, bytes):
-            data_json = data_json.decode('utf-8')
-
-        return pd.read_json(data_json, orient='records')
-
-    def publish_pricing_model(self,
-                              pricing_function,
-                              model_name: str = 'latest',
-                              metadata: Optional[Dict[str, Any]] = None):
-        """
-        Store a fitted pricing function object.
-
-        Args:
-            pricing_function: fitted PricingFunction instance
-            model_name: identifier
-            metadata: additional info
-        """
-        key = f"{self.data_prefix}{model_name}"
-
-        # serialize object
-        model_bytes = pickle.dumps(pricing_function)
-        self.redis_client.set(key, model_bytes)
-
-        # store metadata
-        meta = metadata or {}
-        meta.update({
-            'model_class': pricing_function.__class__.__name__,
-            'model_type': 'pricing_function'
-        })
-
-        meta_key = f"{self.metadata_prefix}{model_name}"
-        self.redis_client.set(meta_key, json.dumps(meta))
-
-        log.info(f"Published pricing model '{model_name}' ({meta['model_class']})")
-
-    def get_pricing_model(self, model_name: str = 'latest'):
-        """Retrieve a pricing function from registry."""
-        key = f"{self.data_prefix}{model_name}"
-        model_bytes = self.redis_client.get(key)
-
-        if model_bytes is None:
-            return None
-
-        return pickle.loads(model_bytes)
-
-    def list_models(self) -> Dict[str, Any]:
-        """List all registered models with metadata."""
-        models = {}
-
-        for key in self.redis_client.scan_iter(f"{self.metadata_prefix}*"):
-            key_str = key.decode('utf-8') if isinstance(key, bytes) else key
-            model_name = key_str.replace(self.metadata_prefix, '')
-            meta_json = self.redis_client.get(key)
-
-            if meta_json:
-                if isinstance(meta_json, bytes):
-                    meta_json = meta_json.decode('utf-8')
-                models[model_name] = json.loads(meta_json)
-
-        return models
-
-    def publish_prices(self,
-                      prices_df: pd.DataFrame,
-                      model_name: str = 'latest',
-                      metadata: Optional[Dict[str, Any]] = None):
-        """Store predicted prices in registry.
-
-        Args:
-            prices_df: df with [productId, predicted_price, ...]
-            model_name: identifier for this price snapshot
-            metadata: additional info
-        """
-        key = f"{self.prices_prefix}{model_name}"
-        data_json = prices_df.to_json(orient='records')
-
-        self.redis_client.set(key, data_json)
-
-        meta = metadata or {}
-        meta.update({
-            'n_products': len(prices_df),
-            'model_type': 'predicted_prices'
-        })
-
-        meta_key = f"{self.metadata_prefix}prices_{model_name}"
-        self.redis_client.set(meta_key, json.dumps(meta))
-
-        log.info(f"Published prices '{model_name}' for {len(prices_df)} products")
-
-    def get_prices(self, model_name: str = 'latest') -> Optional[pd.DataFrame]:
-        """Retrieve predicted prices from registry."""
-        key = f"{self.prices_prefix}{model_name}"
-        data_json = self.redis_client.get(key)
-
-        if data_json is None:
-            return None
-
-        if isinstance(data_json, bytes):
-            data_json = data_json.decode('utf-8')
-
-        return pd.read_json(data_json, orient='records')
-
-    def health_check(self) -> bool:
-        """Check if Redis connection is alive."""
-        try:
-            self.redis_client.ping()
-            return True
-        except:
-            return False
-
-    def set_session_prices(self, session_id: str, prices: Dict[str, float], ttl: int = 1800):
-        """
-        Store prices for a specific session.
-        THIS is the write path for session-aware pricing.
-
-        Args:
-            session_id: session identifier
-            prices: dict of {productId: price}
-            ttl: time-to-live in seconds (default 30min)
-        """
-        if not prices:
-            return
-
-        key = f"session:{session_id}:prices"
-        # use Redis hash for O(1) lookup per product
-        self.redis_client.hset(key, mapping={k: str(v) for k, v in prices.items()})
-        self.redis_client.expire(key, ttl)
-
-    def get_session_price(self, session_id: str, product_id: str) -> Optional[float]:
-        """
-        Lookup price for (sessionId, productId).
-        THIS is the read path for fast provider lookup.
-
-        Returns: price or None if not found
-        """
-        key = f"session:{session_id}:prices"
-        price_str = self.redis_client.hget(key, product_id)
-
-        if price_str is None:
-            return None
-
-        return float(price_str.decode('utf-8') if isinstance(price_str, bytes) else price_str)
-
-    def get_session_all_prices(self, session_id: str) -> Dict[str, float]:
-        """Get all prices for a session."""
-        key = f"session:{session_id}:prices"
-        prices_raw = self.redis_client.hgetall(key)
-
-        if not prices_raw:
-            return {}
-
-        return {
-            (k.decode('utf-8') if isinstance(k, bytes) else k): float(v.decode('utf-8') if isinstance(v, bytes) else v)
-            for k, v in prices_raw.items()
-        }

paper/concat_code.sh

@@ -16,15 +16,11 @@ mkdir -p "$(dirname "$OUTPUT_FILE")"
 add_file() {
     local filepath="$1"
     local relpath="${filepath#$PROJECT_ROOT/}"
-    local escaped_path="${relpath//_/\\_}"
 
     # Add section header and code listing (no language-specific highlighting)
-    echo "\\subsection{${escaped_path}}" >> "$OUTPUT_FILE"
-    echo "\\begin{lstlisting}[caption={${escaped_path}}]" >> "$OUTPUT_FILE"
-    # Convert to ASCII: transliterate what's possible, drop the rest
-    # LC_ALL=C forces ASCII locale for consistent behavior across environments
-    LC_ALL=C iconv -f UTF-8 -t ASCII//TRANSLIT//IGNORE "$filepath" 2>/dev/null >> "$OUTPUT_FILE" || \
-        LC_ALL=C tr -cd '\11\12\15\40-\176' < "$filepath" >> "$OUTPUT_FILE"
+    echo "\\subsection{${relpath}}" >> "$OUTPUT_FILE"
+    echo "\\begin{lstlisting}[caption={${relpath}}]" >> "$OUTPUT_FILE"
+    cat "$filepath" >> "$OUTPUT_FILE"
     echo "" >> "$OUTPUT_FILE"
     echo "\\end{lstlisting}" >> "$OUTPUT_FILE"
     echo "" >> "$OUTPUT_FILE"

paper/src/auto/main.el

@@ -10,15 +10,11 @@
    (TeX-run-style-hooks
     "latex2e"
     "preamble"
-    "chapters/01-intro"
-    "chapters/02-literature-review"
-    "chapters/03-methodology"
-    "chapters/04-results"
-    "chapters/05-discussion"
-    "chapters/06-conclusion"
-    "../build/concatenated_code"
     "acmart"
     "acmart10")
    (TeX-add-symbols
-    '("footnotetextcopyrightpermission" 1)))
+    '("footnotetextcopyrightpermission" 1))
+   (LaTeX-add-labels
+    "research"))
  :latex)
+

paper/src/bib/references.bib

@@ -0,0 +1,106 @@
+@techReport{,
+   abstract = {We consider a single product revenue management problem where, given an initial inventory, the objective is to dynamically adjust prices over a finite sales horizon to maximize expected revenues. Realized demand is observed over time, but the underlying functional relationship between price and mean demand rate that governs these observations (otherwise known as the demand function or demand curve), is not known. We consider two instances of this problem: i.) a setting where the demand function is assumed to belong to a known parametric family with unknown parameter values; and ii.) a setting where the demand function is assumed to belong to a broad class of functions that need not admit any parametric representation. In each case we develop policies that learn the demand function "on the fly," and optimize prices based on that. The performance of these algorithms is measured in terms of the regret: the revenue loss relative to the maximal revenues that can be extracted when the demand function is known prior to the start of the selling season. We derive lower bounds on the regret that hold for any admissible pricing policy, and then show that our proposed algorithms achieve a regret that is "close" to this lower bound. The magnitude of the regret can be interpreted as the economic value of prior knowledge on the demand function; manifested as the revenue loss due to model uncertainty.},
+   author = {Omar Besbes and Assaf Zeevi},
+   journal = {Operations Research},
+   keywords = {Revenue management,asymptotic analysis,estimation,exploration-exploitation,learning,pricing,value of information},
+   title = {Dynamic Pricing Without Knowing the Demand Function: Risk Bounds and Near-Optimal Algorithms *}
+}
+
+@misc{Ghaffary,
+   author = {Shirin Ghaffary and Matt Day},
+   note = {Updated 2025-11-05},
+   title = {Amazon Sues to Stop Perplexity From Using AI Tool to Buy Stuff},
+   url = {https://www.bloomberg.com/news/articles/2025-11-04/amazon-demands-perplexity-stop-ai-agent-from-making-purchases}
+}
+@phdthesis{,
+   abstract = {Algorithmic pricing is an emerging business practice that uses computational algorithms to determine
+the prices of products and services based on a number of dynamic factors. The aim of this thesis is to
+draw attention to the existence of these business practices, and the ethical and social implications that
+derive from them, and then focus on what could be effective solutions to increase the well-being of
+the community.
+In Chapter 2 of the thesis, a general introduction to the topic will be made, starting from its history
+and its evolution over the years; Chapter 3 will examine the different types of pricing algorithms.
+Subsequently, in Chapter 4 we will analyze the sectors in which they are most applicable, and the
+relative advantages and disadvantages they bring with them, with a critical analysis of the trade-offs
+generated. The effect of algorithmic pricing on competition will be studied, considering how the
+ability of algorithms to adapt quickly to market conditions can foster anti-competitive practices, such
+as price discrimination. Later, in Chapter 5, we will look at the issue of price transparency and how
+the opacity of algorithms can make it difficult for consumers to understand the pricing process and
+assess whether they are receiving fair treatment.
+To address these ethical issues, several possible solutions will be brought to light, described in
+Chapter 6, which will focus on the role of the government, as a regulatory, of the end consumer, who
+must be encouraged to educate and inform himself about the use of these practices, and of the
+company, as responsible for making its customers aware and acting in compliance with government
+laws, for fair and non-discriminatory use.},
+   author = {Fabio Salassa and Paolo Pautassi},
+   school = {Politecnico di Torino},
+   title = {Politecnico di Torino Algorithmic Pricing in the digital age "Ethical considerations on its economic and social implications, and an analysis of possible solutions to overcome its critical issues" Tutor: Candidate},
+   url = {https://webthesis.biblio.polito.it/secure/31375/1/tesi.pdf}
+}
+@inproceedings{Mueller2019,
+   author = {Jonas W Mueller and Vasilis Syrgkanis and Matt Taddy},
+   booktitle = {Advances in Neural Information Processing Systems 32 (NeurIPS 2019)},
+   pages = {15442-15452},
+   title = {Low-Rank Bandit Methods for High-Dimensional Dynamic Pricing},
+   url = {https://proceedings.neurips.cc/paper/2019/file/0a3df70393993583a13c0dd6686f3f32-Paper.pdf},
+   year = {2019}
+}
+@article{Amjad2017,
+   abstract = { In this paper, the question of interest is estimating true demand of a product at a given store location and time period in the retail environment based on a single noisy and potentially censored observation. To address this question, we introduce a %non-parametric framework to make inference from multiple time series. Somewhat surprisingly, we establish that the algorithm introduced for the purpose of "matrix completion" can be used to solve the relevant inference problem. Specifically, using the Universal Singular Value Thresholding (USVT) algorithm [7], we show that our estimator is consistent: the average mean squared error of the estimated average demand with respect to the true average demand goes to 0 as the number of store locations and time intervals increase to $\infty$. We establish naturally appealing properties of the resulting estimator both analytically as well as through a sequence of instructive simulations. Using a real dataset in retail (Walmart), we argue for the practical relevance of our approach. },
+   author = {Muhammad J. Amjad and Devavrat Shah},
+   doi = {10.1145/3154489},
+   issue = {2},
+   journal = {Proceedings of the ACM on Measurement and Analysis of Computing Systems},
+   month = {12},
+   pages = {1-28},
+   publisher = {Association for Computing Machinery (ACM)},
+   title = {Censored Demand Estimation in Retail},
+   volume = {1},
+   url = {https://par.nsf.gov/servlets/purl/10066022},
+   year = {2017}
+}
+@article{Prez-Ricardo2025,
+   abstract = {The study aims to explore tourists' booking intentions by analyzing the price elasticity of demand in tourist accommodations. This analysis should reveal how changes in price affect booking behavior across different customer segments, using online booking records. A dataset was compiled from 106 hotels in Malaga, Spain, comprising 27,910 online bookings sourced exclusively from hotel websites. To understand the price elasticity of demand, a simple log-log regression was applied, segmenting the data based on key revenue-related variables. Subsequently, a cluster segmentation was performed using the Elbow method and K-means algorithm to identify distinct market segments. The findings highlighted that Family Travelers and Short Stay Travelers segments exhibited elastic demand, indicating higher sensitivity to price fluctuations. In contrast, Early Bookers and Mid-Season Long Stayers demonstrated inelastic demand, with lower responsiveness to changes in tourist accommodation prices. The number of variables analyzed in this study, along with the cluster analysis, represent a novelty and contribute to the existing literature on market segmentation and price elasticity of demand. This integration enriches both fields of research, offering mutual benefits and deeper insights that enhance the understanding of booking intention and pricing strategies.},
+   author = {Elizabeth del Carmen Pérez-Ricardo and Josefa García-Mestanza},
+   doi = {10.1016/j.iedeen.2025.100271},
+   issn = {24448834},
+   issue = {1},
+   journal = {European Research on Management and Business Economics},
+   keywords = {Booking intention,Price elasticity,Tourist segmentation},
+   month = {1},
+   publisher = {European Academy of Management and Business Economics},
+   title = {Exploring booking intentions through price elasticity of demand in tourism accommodations using large-scale data analytics},
+   volume = {31},
+   year = {2025}
+}
+@article{Iliou2021,
+   author = {Christos Iliou and Theodoros Kostoulas and Theodora Tsikrika and Vasilis Katos and Stefanos Vrochidis and Ioannis Kompatsiaris},
+   doi = {10.1145/3447815},
+   issue = {3},
+   journal = {Digital Threats: Research and Practice},
+   pages = {1-26},
+   title = {Detection of Advanced Web Bots by Combining Web Logs with Mouse Behavioural Biometrics},
+   volume = {2},
+   url = {https://dl.acm.org/doi/10.1145/3447815},
+   year = {2021}
+}
+@article{ArnoudVdenBoer2015,
+   author = {Arnoud V. den Boer},
+   doi = {10.1016/j.sorms.2015.03.001},
+   issue = {1},
+   journal = {Surveys in Operations Research and Management Science},
+   month = {6},
+   pages = {1-18},
+   title = {Dynamic pricing and learning: Historical origins, current research, and new directions},
+   volume = {20},
+   url = {https://www.sciencedirect.com/science/article/pii/S1876735415000021},
+   year = {2015}
+}
+@article{Calvano2018,
+   author = {Emilio Calvano and Giacomo Calzolari and Vincenzo Denicolo and Sergio Pastorello},
+   doi = {10.2139/ssrn.3304991},
+   journal = {SSRN Electronic Journal},
+   title = {Artificial Intelligence, Algorithmic Pricing and Collusion},
+   url = {https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3304991},
+   year = {2018}
+}

paper/src/main.tex

@@ -10,7 +10,7 @@
 
 \begin{document}
 
-\title{Pricing Heuristics Against Non-human Transaction Orchestration Mechanisms}
+\title{First Proposal: Pricing Heuristics Against Non-human Transaction Orchestration Mechanisms}
 
 \author{Daniel Rösel}
 \email{daniel@alves.world}
@@ -34,19 +34,60 @@ The primary objective of this thesis is to develop and validate pricing heuristi
 
 \maketitle
 
-\input{chapters/01-intro}
-\input{chapters/02-literature-review}
-\input{chapters/03-methodology}
-\input{chapters/04-results}
-\input{chapters/05-discussion}
-\input{chapters/06-conclusion}
+\section{Preliminary literature review}
+
+From very relevant news, the legal conflicts of agentic access to platforms have clearly indicated a need for prevention of secondary negative effects on ``legacy'' systems which power modern pricing systems \cite{Ghaffary}. Dynamic pricing algorithms rely on directly translating demand features $q$ to $\hat{p}$ new price assignments across a catalogue of products. This demand estimation does often take into account a small degree of error and noise from the data. However, adversarially introduced interactions, which are non-conducive to pricing optimization nor are a fully accurate representation of the driving human demand, have not been considered as part of the systems. Research such as \cite{Mueller2019} introduces very clear methodology for pricing algorithms backed by demand estimation for online pricing optimization which can be followed for proposing adjustments and improvements as highlighted in \ref{research}. Another often encountered demand distortion occurs through censored demand environments \cite{Amjad2017}.
+
+Other efforts such as \cite{Calvano2018} explore ways of modeling the interactions between multiple pricing algorithms or agents which in an effort to maximize their reward drive the market to supra-competitive pricing which leaves the boundaries of the market equilibrium, creating a harmful effect on the customers by this process of algorithmic collusion. This harm can be directly translated to our setting where through interactions between two learners there is a potential of market destabilization.
+
+
+\section{Research question or objective} \label{research}
+
+\begin{quote}
+How do agent-generated interactions contaminate demand functions in dynamic pricing algorithms, and how significantly does this contamination affect key performance indicators ($\Delta$)?
+\end{quote}
+The objectives are to gather data on how humans ($H$) and agents ($A$) interact with commerce platforms, and to identify the most reliable methodology for true demand estimation to fuel the dynamic pricing algorithm. This discrimination task can be accomplished through three distinct approaches:
+
+\begin{enumerate}
+\item \textbf{Explicit filtering approach:} Decompose pipeline components and employ an estimator $P(A|s)$ (where $s$ represents session interaction data) to explicitly filter agent-generated interactions from the processing stream.
+
+\item \textbf{Learned transformation approach:} Utilize a learned transformation on the product demand feature $B$, where $B = B_H + B_A$, with the goal of deriving a more representative demand feature $B_\text{clean} = B_H + W_\epsilon B_A$ that appropriately weights agent contributions.
+
+\item \textbf{Reinforcement learning approach:} Frame the problem as a reinforcement learning task where interactions are modeled as environmental components, guiding the algorithm to learn an appropriate pricing policy that implicitly accounts for genuine human demand ($B_H$).
+\end{enumerate}
+
+
+\section{Execution plan with approximate calendar}
+
+
+This is a tentative execution plan for this research, keeping in mind a more agile approach rather than a waterfall-like set of goals and targets:
+
+\begin{description}
+\item[November 2024:] Complete platform deployment for data collection and observations (70\% complete). Implement user authentication system with magic link invites to enable participant enrollment.
+
+\item[December 2024:] Gather initial interaction data and explore the separability of distributions between human and agentic interaction patterns. Begin testing online algorithms for session-based pricing optimizations.
+
+\item[January 2025:] Conduct controlled experiments comparing human versus agent execution of identical tasks. Establish behavioral signature models and quantify contamination impact ($\Delta$). Develop and validate the explicit filtering approach using $P(A|s)$ estimator.
+
+\item[February 2025:] Design and train the learned transformation model for demand feature adjustment ($B_\text{clean}$). Implement reinforcement learning framework and train pricing policy that implicitly accounts for genuine human demand.
+
+\item[March 2025:] Conduct comparative evaluation across all three proposed approaches. Finalize experimental results and perform statistical analysis of revenue recovery and KPI improvements.
+
+\item[April 2025:] Internal review, revisions, and thesis documentation finalization. Prepare for final submission.
+\end{description}
+
+\section{Desired measurable outcome or answer}
+
+The first step is measuring how well we can separate human from agent session data. We can start with standard accuracy metrics as a baseline.
+What really matters for the larger picture is the economic impact of accurate demand estimation. We measure this through revenue leakage and revenue recovery. For benchmarking, we need to compare scenarios under default pricing policies versus adjusted ones - this gives us lower and upper bounds for our performance.
+Since we're also concerned with human-centric outcomes, we need to collect user friction ratings that compare more radical solutions (like CAPTCHAs) against minimal or no defenses.
 
 
 \printbibliography
 
-\clearpage
-\onecolumn
-\appendix
-\input{../build/concatenated_code}
+% \clearpage
+% \onecolumn
+% \appendix
+
 
 \end{document}

pytest.ini

@@ -1,8 +0,0 @@
-[pytest]
-pythonpath = experiments
-testpaths = experiments
-python_files = test*.py
-python_classes = Test*
-python_functions = test_*
-asyncio_mode = auto
-asyncio_default_fixture_loop_scope = function

requirements.txt

@@ -5,10 +5,3 @@ jupyter
 ipykernel
 matplotlib
 graphviz
-browser-use
-pytest
-pytest-asyncio
-uv
-scikit-learn
-supabase
-pymc

sim/rl/behavior_loader/loader.py

@@ -1,63 +0,0 @@
-import os
-from pydantic import BaseModel as Base
-import json
-
-class PayloadModel(Base):
-    sessionId: str
-    experimentId: str | None
-    eventName: str
-    page: str | None
-    productId: str | None
-    metadata: dict
-    storeMode: str
-    userAgent: str
-    ts: str
-
-class ValueModel(Base):
-    payload: PayloadModel
-    encoding: str
-    isPayloadNull: bool
-    schemaId: int
-    size: int
-
-class InteractionModel(Base):
-    partitionID: int
-    offset: int
-    timestamp: int
-    compression: str
-    isTransactional: bool
-    headers: list
-    key: dict
-    value: ValueModel
-
-class Loader:
-    def __init__(self, src_dir: str):
-        self.src_dir = src_dir
-        self.entries = os.listdir(src_dir)
-        if not self.entries: raise ValueError("empty directory")
-        self.data = self._load_sessions()
-
-    def _is_admin_page(self, interaction: InteractionModel) -> bool:
-        page = interaction.value.payload.page
-        return page and page.startswith("/admin/")
-
-    def _load_sessions(self) -> dict:
-        sessions = {}
-        for entry in self.entries:
-            int_path = f"{self.src_dir}/{entry}/int.json"
-            raw = json.load(open(int_path))
-            ints = [InteractionModel(**i) for i in raw]
-            sessions[entry] = [i for i in ints if not self._is_admin_page(i)]
-        return sessions
-
-    def get_data(self) -> dict:
-        return self.data
-
-    def get_entries(self) -> tuple[list[str], int]:
-        return self.entries, len(self.entries)
-
-if __name__ == "__main__":
-    DIR = "/home/velocitatem/Documents/Projects/PHANTOM/experiments/collected_data/"
-    loader = Loader(DIR)
-    _, n = loader.get_entries()
-    print(f"Loaded {n} sessions from {DIR}")

sim/rl/behavior_loader/models.py

@@ -1,144 +0,0 @@
-from loader import Loader
-from collections import defaultdict
-from typing import Dict, List, Tuple, Set
-import numpy as np
-import graphviz
-
-DIR = "/home/velocitatem/Documents/Projects/PHANTOM/experiments/collected_data/"
-
-class BehaviorModel:
-    def __init__(self, src_dir: str = DIR):
-        self.loader = Loader(src_dir)
-        self.data = self.loader.get_data()
-        self.entries, self.num_entries = self.loader.get_entries()
-        self.mdp = None
-
-    def _state_repr(self, evt) -> str:
-        p = evt.value.payload
-        return f"{p.page or 'unk'}|{p.productId or 'none'}|{p.eventName}"
-
-    def _extract_sessions(self):
-        # transform raw events into sequential state trajectories per session
-        trajectories = []
-        for sid, evts in self.data.items():
-            if len(evts) < 2: continue
-            states = [self._state_repr(e) for e in sorted(evts, key=lambda x: x.timestamp)]
-            trajectories.append(states)
-        return trajectories
-
-    def _calc_transitions(self, trajectories: List[List[str]]) -> Tuple[Dict, Set]:
-        trans = defaultdict(lambda: defaultdict(int))
-        states = set()
-        for traj in trajectories:
-            for i in range(len(traj) - 1):
-                s, s_next = traj[i], traj[i+1]
-                trans[s][s_next] += 1
-                states.update([s, s_next])
-        return trans, states
-
-    def _calc_rewards(self, trajectories: List[List[str]]) -> Dict:
-        # reward based on session progression depth
-        rwd = defaultdict(list)
-        for traj in trajectories:
-            n = len(traj)
-            for i, s in enumerate(traj):
-                rwd[s].append(i / n)
-        return rwd
-
-    def _normalize_trans(self, counts: Dict) -> Dict:
-        return {s: {s_n: cnt/sum(nxt.values()) for s_n, cnt in nxt.items()}
-                for s, nxt in counts.items()}
-
-    def build_MDP(self) -> Dict:
-        trajs = self._extract_sessions()
-        trans_cnt, states = self._calc_transitions(trajs)
-        trans_prob = self._normalize_trans(trans_cnt)
-        state_rwd = self._calc_rewards(trajs)
-        state_val = {s: np.mean(r) for s, r in state_rwd.items()}
-
-        self.mdp = {
-            'states': sorted(list(states)),
-            'num_states': len(states),
-            'transitions': trans_prob,
-            'state_values': state_val,
-            'state_rewards': state_rwd,
-            'trans_counts': trans_cnt,
-        }
-        return self.mdp
-
-    def transition_prob(self, s: str, s_next: str) -> float:
-        if not self.mdp: raise ValueError("build MDP first")
-        return self.mdp['transitions'].get(s, {}).get(s_next, 0.0)
-
-    def state_value(self, s: str) -> float:
-        if not self.mdp: raise ValueError("build MDP first")
-        return self.mdp['state_values'].get(s, 0.0)
-
-    def sample_traj(self, start: str, max_len: int = 50) -> List[str]:
-        if not self.mdp: raise ValueError("build MDP first")
-        path = [start]
-        curr = start
-        for _ in range(max_len):
-            nxt = self.mdp['transitions'].get(curr, {})
-            if not nxt: break
-            curr = np.random.choice(list(nxt.keys()), p=list(nxt.values()))
-            path.append(curr)
-        return path
-
-def visualize_mdp(model: BehaviorModel, threshold: float = 0.05, output: str = "mdp_graph", fmt: str = "svg", view: bool = False, export_dot: bool = False):
-    """visualize MDP as directed graph using graphviz, aggregated by event type"""
-    if not model.mdp: raise ValueError("build MDP first")
-
-    # aggregate transitions by event type
-    evt_trans = defaultdict(lambda: defaultdict(float))
-    for s, trans in model.mdp['transitions'].items():
-        evt_src = s.split('|')[2]
-        for s_next, prob in trans.items():
-            evt_dst = s_next.split('|')[2]
-            evt_trans[evt_src][evt_dst] += prob
-
-    # normalize aggregated transitions
-    for evt_src in evt_trans:
-        total = sum(evt_trans[evt_src].values())
-        if total > 0:
-            for evt_dst in evt_trans[evt_src]:
-                evt_trans[evt_src][evt_dst] /= total
-
-    g = graphviz.Digraph(format=fmt)
-    g.attr(rankdir='LR', size='30')
-    g.attr('node', shape='circle', width='1', height='1')
-
-    # collect all event types
-    events = set(evt_trans.keys())
-    for trans in evt_trans.values():
-        events.update(trans.keys())
-
-    # add nodes for each event type
-    for evt in events:
-        g.node(evt)
-
-    # add edges above threshold
-    for evt_src in evt_trans:
-        for evt_dst, prob in evt_trans[evt_src].items():
-            if prob > threshold:
-                g.edge(evt_src, evt_dst, label=f'{prob:.2f}')
-
-    g.render(output, view=view, cleanup=True)
-    print(f"Saved MDP graph to {output}.{fmt}")
-
-    if export_dot:
-        dot_file = f"{output}.dot"
-        with open(dot_file, 'w') as f:
-            f.write(g.source)
-        print(f"Exported DOT source to {dot_file}")
-
-    return g
-
-if __name__ == "__main__":
-    model = BehaviorModel(DIR)
-    mdp = model.build_MDP()
-    print(f"Built MDP: {mdp['num_states']} states, {sum(len(t) for t in mdp['transitions'].values())} transitions")
-    if not mdp['states']:
-        print("No states found")
-        exit(1)
-    visualize_mdp(model, threshold=0.05, output="mdp_viz", fmt="pdf", export_dot=True)

sim/rl/engine.py

@@ -1,227 +0,0 @@
-from os import kill
-import numpy as np
-import pandas as pd
-from abc import ABC, abstractmethod
-from typing import Dict, Any
-from environment import BusinessLogicConstraints
-
-
-"""
-An angine by default should have its own demand estimation mechanism from the observed observations whihc are the computer feature.
-From these features we then follow the researc hstructure of q -> p with a testable and must be updatable mechanism.
-"""
-
-class BasePricingEngine(ABC):
-    """base interface for all pricing engines"""
-    def __init__(self, constraints: BusinessLogicConstraints, seed: int = 0):
-        self.c = constraints
-        self.rng = np.random.default_rng(seed)
-        self.step_count = 0
-
-
-    @abstractmethod
-    def compute_prices(self, current_prices: np.ndarray, observation: Dict[str, Any]) -> np.ndarray:
-        """compute new prices given current state and observation from environment
-
-        args:
-            current_prices: current price vector [N]
-            observation: dict containing 'price', 'demand', and possibly interaction data
-
-        returns:
-            new_prices: updated price vector [N]
-        """
-        pass
-
-    @abstractmethod
-    def update(obs, reward, done, info):
-        pass
-
-
-
-    def reset(self):
-        """reset engine state for new episode"""
-        self.step_count = 0
-
-
-class WildPricingEngine(BasePricingEngine):
-    """production-like pricing using online elasticity estimation via EWMA regression"""
-    def __init__(self, constraints: BusinessLogicConstraints, seed: int = 0):
-        super().__init__(constraints, seed)
-        # per-product unit costs (unknown to customers; known to platform)
-        self.unit_cost = self.rng.uniform(8.0, 40.0, size=self.c.product_catelogue_size).astype(np.float32)
-        # online elasticity estimate (start moderately elastic)
-        self.e_hat = np.full((self.c.product_catelogue_size,), -1.3, dtype=np.float32)
-        # EWMA state for log-log regression
-        self.mu_logp = np.zeros(self.c.product_catelogue_size, dtype=np.float32)
-        self.mu_logq = np.zeros(self.c.product_catelogue_size, dtype=np.float32)
-        self.cov_pq  = np.zeros(self.c.product_catelogue_size, dtype=np.float32)
-        self.var_p   = np.ones(self.c.product_catelogue_size, dtype=np.float32)
-        # knobs typical in production
-        self.lr = 0.08
-        self.ewma = 0.05
-        self.eps_explore = 0.03
-        self.explore_scale = 0.03
-
-    def _safe_elasticity(self, e: np.ndarray) -> np.ndarray:
-        return np.clip(e, -5.0, -1.05)
-
-    def reset(self):
-        super().reset()
-        self.e_hat = np.full((self.c.product_catelogue_size,), -1.3, dtype=np.float32)
-        self.mu_logp = np.zeros(self.c.product_catelogue_size, dtype=np.float32)
-        self.mu_logq = np.zeros(self.c.product_catelogue_size, dtype=np.float32)
-        self.cov_pq = np.zeros(self.c.product_catelogue_size, dtype=np.float32)
-        self.var_p = np.ones(self.c.product_catelogue_size, dtype=np.float32)
-
-    def compute_prices(self, current_prices: np.ndarray, observation: Dict[str, Any]) -> np.ndarray:
-        self.step_count += 1
-        # extract demand signal (from env observation) as proxy for sales
-        demand = observation.get('demand', np.zeros(self.c.product_catelogue_size, dtype=np.float32))
-        return self._update_from_demand(current_prices, demand)
-
-    def _update_from_demand(self, prices: np.ndarray, sold: np.ndarray) -> np.ndarray:
-        # log transforms (add 1 to handle zeros)
-        logp = np.log(np.clip(prices, 1e-3, None)).astype(np.float32)
-        logq = np.log(sold + 1.0).astype(np.float32)
-        # EWMA moments for per-product regression: logq ≈ a + e*logp
-        a = self.ewma
-        dp = logp - self.mu_logp
-        dq = logq - self.mu_logq
-        self.mu_logp = (1 - a) * self.mu_logp + a * logp
-        self.mu_logq = (1 - a) * self.mu_logq + a * logq
-        self.cov_pq = (1 - a) * self.cov_pq + a * (dp * dq)
-        self.var_p = (1 - a) * self.var_p + a * (dp * dp + 1e-6)
-        e_new = self.cov_pq / (self.var_p + 1e-6)
-        self.e_hat = self._safe_elasticity(0.9 * self.e_hat + 0.1 * e_new)
-        # profit-optimal price for isoelastic demand (if e < -1)
-        e = self.e_hat
-        p_star = self.unit_cost * (e / (e + 1.0))
-        # smooth toward p_star
-        new_prices = (1 - self.lr) * prices + self.lr * p_star
-        # exploration (small random perturbations)
-        if self.rng.random() < self.eps_explore:
-            noise = self.rng.normal(0.0, self.explore_scale, size=new_prices.shape).astype(np.float32)
-            new_prices = new_prices * (1.0 + noise)
-        # apply business guardrails (max change + bounds)
-        max_adj = self.c.max_price_adjustment
-        ratio = np.clip(new_prices / (prices + 1e-6), 1 - max_adj, 1 + max_adj)
-        new_prices = prices * ratio
-        new_prices = np.clip(new_prices, self.c.system_min_price, self.c.system_max_price).astype(np.float32)
-        return new_prices
-
-
-class StaticPricingEngine(BasePricingEngine):
-    """baseline: fixed prices throughout episode"""
-    def __init__(self, constraints: BusinessLogicConstraints, seed: int = 0):
-        super().__init__(constraints, seed)
-        self.fixed_prices = None
-
-    def reset(self):
-        super().reset()
-        self.fixed_prices = None
-
-    def compute_prices(self, current_prices: np.ndarray, observation: Dict[str, Any]) -> np.ndarray:
-        self.step_count += 1
-        if self.fixed_prices is None:
-            self.fixed_prices = current_prices.copy()
-        return self.fixed_prices.copy()
-
-
-class SimpleDemandEngine(BasePricingEngine):
-    """demand-driven pricing: increase price when demand rises, decrease when it falls"""
-    def __init__(self, constraints: BusinessLogicConstraints, seed: int = 0):
-        super().__init__(constraints, seed)
-        self.prev_demand = None
-        self.lr = 0.05
-
-    def reset(self):
-        super().reset()
-        self.prev_demand = None
-
-    def compute_prices(self, current_prices: np.ndarray, observation: Dict[str, Any]) -> np.ndarray:
-        self.step_count += 1
-        demand = observation.get('demand', np.zeros(self.c.product_catelogue_size, dtype=np.float32))
-        if self.prev_demand is None:
-            self.prev_demand = demand.copy()
-            return current_prices.copy()
-        # simple rule: if demand increases, raise price; if decreases, lower price
-        delta_d = demand - self.prev_demand
-        price_adj = self.lr * np.sign(delta_d) * np.abs(delta_d) / (np.abs(self.prev_demand) + 1.0)
-        new_prices = current_prices * (1.0 + price_adj)
-        self.prev_demand = demand.copy()
-        # apply constraints
-        max_adj = self.c.max_price_adjustment
-        ratio = np.clip(new_prices / (current_prices + 1e-6), 1 - max_adj, 1 + max_adj)
-        new_prices = current_prices * ratio
-        return np.clip(new_prices, self.c.system_min_price, self.c.system_max_price).astype(np.float32)
-
-
-class RandomWalkEngine(BasePricingEngine):
-    """random walk pricing with mean reversion"""
-    def __init__(self, constraints: BusinessLogicConstraints, seed: int = 0):
-        super().__init__(constraints, seed)
-        self.target_price = None
-        self.volatility = 0.02
-
-    def reset(self):
-        super().reset()
-        self.target_price = None
-
-    def compute_prices(self, current_prices: np.ndarray, observation: Dict[str, Any]) -> np.ndarray:
-        self.step_count += 1
-        if self.target_price is None:
-            self.target_price = current_prices.copy()
-        # random walk with mean reversion toward target
-        noise = self.rng.normal(0.0, self.volatility, size=current_prices.shape).astype(np.float32)
-        reversion = 0.01 * (self.target_price - current_prices)
-        new_prices = current_prices * (1.0 + noise) + reversion
-        # apply constraints
-        max_adj = self.c.max_price_adjustment
-        ratio = np.clip(new_prices / (current_prices + 1e-6), 1 - max_adj, 1 + max_adj)
-        new_prices = current_prices * ratio
-        return np.clip(new_prices, self.c.system_min_price, self.c.system_max_price).astype(np.float32)
-
-
-class ThompsonSamplingEngine(BasePricingEngine):
-    """bayesian bandit approach per product treating price as discrete action"""
-    def __init__(self, constraints: BusinessLogicConstraints, seed: int = 0):
-        super().__init__(constraints, seed)
-        self.n_price_levels = 5
-        self.alpha = np.ones((self.c.product_catelogue_size, self.n_price_levels), dtype=np.float32)
-        self.beta = np.ones((self.c.product_catelogue_size, self.n_price_levels), dtype=np.float32)
-        self.price_grid = None
-        self.last_actions = None
-
-    def reset(self):
-        super().reset()
-        self.alpha = np.ones((self.c.product_catelogue_size, self.n_price_levels), dtype=np.float32)
-        self.beta = np.ones((self.c.product_catelogue_size, self.n_price_levels), dtype=np.float32)
-        self.price_grid = None
-        self.last_actions = None
-
-    def compute_prices(self, current_prices: np.ndarray, observation: Dict[str, Any]) -> np.ndarray:
-        self.step_count += 1
-        if self.price_grid is None:
-            # define price grid per product
-            lo = current_prices * 0.7
-            hi = current_prices * 1.3
-            self.price_grid = np.linspace(lo, hi, self.n_price_levels).T
-        demand = observation.get('demand', np.zeros(self.c.product_catelogue_size, dtype=np.float32))
-        # update beliefs based on last action
-        if self.last_actions is not None:
-            for i in range(self.c.product_catelogue_size):
-                a = self.last_actions[i]
-                reward = demand[i]
-                if reward > 0.5:
-                    self.alpha[i, a] += reward
-                else:
-                    self.beta[i, a] += 1.0
-        # thompson sampling: sample from posterior, pick best
-        new_prices = np.zeros(self.c.product_catelogue_size, dtype=np.float32)
-        actions = np.zeros(self.c.product_catelogue_size, dtype=int)
-        for i in range(self.c.product_catelogue_size):
-            theta = self.rng.beta(self.alpha[i], self.beta[i]).astype(np.float32)
-            actions[i] = int(np.argmax(theta))
-            new_prices[i] = self.price_grid[i, actions[i]]
-        self.last_actions = actions
-        return np.clip(new_prices, self.c.system_min_price, self.c.system_max_price).astype(np.float32)

sim/rl/environment.py

@@ -1,320 +0,0 @@
-from sys import intern
-import gymnasium as gym
-from gymnasium import spaces
-from matplotlib import interactive
-import numpy as np
-from dataclasses import dataclass
-import pandas as pd
-from typing import Callable, Optional, Dict, Any, List
-
-# "learner"  agent learning to optimize pricing
-# "agent"  part of environment creating demand signals that learner processes
-
-@dataclass
-class BusinessLogicConstraints():
-    max_price_adjustment: float = 0.30
-    system_max_price: float = 500.0
-    system_min_price: float = 1.0
-    product_catelogue_size: int = 100
-    episode_length: int = 200
-    sessions_per_step: int = 250
-    agent_share: float = 0.25
-    agent_recon_multiplier: float = 6.0
-    agent_purchase_probability: float = 0.20
-    coi_strength: float = 0.25
-    coi_threshold: float = 4.0
-    coi_sigmoid_temp: float = 1.25
-    base_human_demand: float = 0.08
-    base_agent_demand: float = 0.05
-    human_price_elasticity: float = -1.2 # assumptions here
-    agent_price_elasticity: float = -0.6
-    w_agent_loss: float = 1.0
-    w_volatility: float = 5.0
-    w_estimation_error: float = 0.25
-    seed: int = 7
-
-
-def _sigmoid(x: np.ndarray) -> np.ndarray:
-    return 1.0 / (1.0 + np.exp(-x))
-
-class CommercePlatform:
-    """
-    This is just an extension of the state management for the environment, it does not implement anything dynamic just helps us simulate demand.
-    """
-    def __init__(self,
-                 product_catelogue_size: int,
-                 max_price: float,
-                 min_price: float,
-                 constraints: BusinessLogicConstraints):
-        self.product_catelogue_size = product_catelogue_size
-        self.product_supply = np.random.uniform(low=10, high=50, size=(self.product_catelogue_size,))
-        self.max_price = max_price
-        self.min_price = min_price
-        self.constraints = constraints
-        self.simulation_history: List[Dict[str, Any]] = []
-        self._rng = np.random.default_rng(constraints.seed)
-        self._last_interaction_df: pd.DataFrame = pd.DataFrame()
-
-
-    def setup_true_demand(self, prices: np.ndarray) -> Dict[str, np.ndarray]:
-        # ground truth purchase propensities
-        p = np.clip(prices, self.min_price, self.max_price)
-        pn = p / self.max_price
-        human_prob = self.constraints.base_human_demand * (pn ** self.constraints.human_price_elasticity)
-        agent_prob = self.constraints.base_agent_demand * (pn ** self.constraints.agent_price_elasticity)
-        return {
-            "human_purchase_prob": np.clip(human_prob, 0.0, 0.95),
-            "agent_purchase_prob": np.clip(agent_prob, 0.0, 0.95)
-        }
-
-    def _load_behavioral_profile(actor : str, demand_forcing):
-        """
-        This returns a markov chain with average weights which we get from interaction data of our experiments.
-        This defines transition probabilities between different events:
-        search -> view_item_price_binN: 0.7
-        view_item_price_binN -> add_to_cart: 0.2
-        we also must reweight with the demand_forcing vector or purchase probabilities per-product
-        """
-
-
-    def _simulate_sessions(self, base_prices: np.ndarray) -> pd.DataFrame:
-        demand = self.setup_true_demand(base_prices)
-        human_pprob = demand["human_purchase_prob"]
-        agent_pprob = demand["agent_purchase_prob"]
-        events: List[Dict[str, Any]] = []
-        T = self.constraints.sessions_per_step
-        n_agent_sessions = int(round(T * self.constraints.agent_share))
-        n_human_sessions = T - n_agent_sessions
-        n_agent_ids = max(1, n_agent_sessions // 2)
-        session_map = {
-            'humans': n_human_sessions,
-            'agents': n_agent_ids
-        }
-        pprob_map = {
-            'humans': human_pprob,
-            'agents': agent_pprob
-        }
-        joint_events = []
-        for actor, n_sessions in session_map.items():
-            bp = _load_behavioral_profile(actor, pprob_map[actor])
-            counter = 0
-            events = []
-            while counter < n_sessions:
-                session_events = []
-                while len(session_events) == 0 or session_events[-1]['action'] == 'checkout':
-                    interaction_event = bp.sample(self._rng)
-                    interaction_event['session_id'] = f'{actor}_{counter:06d}'
-                    # TODO any other assignments
-                    session_events.append(interaction_event)
-                events.extend(session_events)
-                counter += 1
-            joint_events.extend(events)
-
-        return pd.DataFrame(joint_events)
-
-    def compute_interaction_features(self, interaction_df: pd.DataFrame) -> Dict[str, float]:
-        if interaction_df.empty:
-            return {"mean_sale_price": 0.0, "look_to_book": 0.0}
-        purchases = interaction_df[interaction_df["action"] == "purchase"]
-        mean_sale_price = float(purchases["price_paid"].mean()) if not purchases.empty else 0.0
-        views = float((interaction_df["action"] == "view").sum())
-        buys = float((interaction_df["action"] == "purchase").sum())
-        return {"mean_sale_price": mean_sale_price, "look_to_book": float(views / (buys + 1e-6))}
-
-    def _session_feature_table(self, df: pd.DataFrame) -> pd.DataFrame:
-        # TODO: adapt this
-        if df.empty:
-            return pd.DataFrame()
-        g = df.groupby("session_id", sort=False)
-        session_duration = g["t"].max() - g["t"].min()
-        total_interactions = g.size()
-        avg_time_between = g["t"].apply(lambda x: float(np.diff(np.sort(x.to_numpy())).mean()) if len(x) > 1 else 0.0)
-        interaction_velocity = total_interactions / (session_duration + 1e-6)
-        views = g.apply(lambda x: int((x["action"] == "view").sum()), include_groups=False)
-        cart_adds = g.apply(lambda x: int((x["action"] == "cart").sum()), include_groups=False)
-        purchases = g.apply(lambda x: int((x["action"] == "purchase").sum()), include_groups=False)
-        conversion_rate = purchases / (views + 1e-6)
-        is_agent = g["actor"].apply(lambda s: bool((s == "agent").any()), include_groups=False)
-
-        return pd.DataFrame({
-            "session_duration_sec": session_duration.astype(float),
-            "avg_time_between_events": avg_time_between.astype(float),
-            "total_interactions": total_interactions.astype(int),
-            "interaction_velocity": interaction_velocity.astype(float),
-            "item_views": views.astype(int),
-            "cart_adds": cart_adds.astype(int),
-            "purchases": purchases.astype(int),
-            "conversion_rate": conversion_rate.astype(float),
-            "is_agent": is_agent.astype(bool),
-        }).reset_index()
-
-    def get_interaction_data(self) -> np.ndarray:
-        if self._last_interaction_df.empty:
-            return np.array([], dtype=object)
-        return self._last_interaction_df.to_dict(orient="records")
-
-
-class PHANTOMEnv(gym.Env):
-    metadata = {"render_modes": []}
-
-    def __init__(self, constraints):
-        super().__init__()
-        self.constraints = BusinessLogicConstraints()
-        self.action_space = spaces.Box(low=-self.constraints.max_price_adjustment,
-                                       high=self.constraints.max_price_adjustment,
-                                       shape=(self.constraints.product_catelogue_size,), dtype=np.float32)
-        self.observation_space = spaces.Dict({
-            "elasticity": spaces.Dict({
-                "price": spaces.Box(
-                    low=np.full((self.constraints.product_catelogue_size,), self.constraints.system_min_price, dtype=np.float32),
-                    high=np.full((self.constraints.product_catelogue_size,), self.constraints.system_max_price, dtype=np.float32),
-                    dtype=np.float32),
-                "demand": spaces.Box(
-                    low=np.zeros((self.constraints.product_catelogue_size,), dtype=np.float32),
-                    high=np.full((self.constraints.product_catelogue_size,), 1e6, dtype=np.float32),
-                    dtype=np.float32),
-            })
-            # TODO: define more features that we compute from the interaction data
-        })
-        self.commerce_platform = CommercePlatform(
-            product_catelogue_size=self.constraints.product_catelogue_size,
-            max_price=self.constraints.system_max_price,
-            min_price=self.constraints.system_min_price,
-            constraints=self.constraints)
-        self._rng = np.random.default_rng(self.constraints.seed)
-        self.t = 0
-        self._prev_prices: Optional[np.ndarray] = None
-        self.state: Dict[str, Any] = {}
-
-    def reset(self, seed: Optional[int] = None, options: Optional[dict] = None):
-        super().reset(seed=seed)
-        if seed is not None:
-            self._rng = np.random.default_rng(seed)
-            self.commerce_platform._rng = np.random.default_rng(seed)
-        self.t = 0
-        init_prices = self._rng.uniform(low=60.0, high=140.0, size=(self.constraints.product_catelogue_size,)).astype(np.float32)
-        self._prev_prices = init_prices.copy()
-        self.state = {
-            "elasticity": {
-                "price": init_prices,
-                "demand": np.zeros((self.constraints.product_catelogue_size,), dtype=np.float32),
-            }
-        }
-        return self.state, {}
-
-    def step(self, action: np.ndarray):
-        self.t += 1
-        base_prices = self.state["elasticity"]["price"].astype(np.float32)
-        new_prices = np.clip(base_prices * (1.0 + action.astype(np.float32)),
-                           self.constraints.system_min_price,
-                           self.constraints.system_max_price).astype(np.float32)
-
-        self.state["elasticity"]["price"] = new_prices
-        # TODO: use the commerce platform to simulate sessions
-        interactions_df = self.commerce_platform._simulate_sessions(new_prices)
-        result = self.commerce_platform.compute_interaction_features(interactions_df)
-        # TODO: implement COI computation to use in reward
-        COI = 0.0
-
-        volatility = 0.0 if self._prev_prices is None else \
-            float(np.mean(np.abs((new_prices - self._prev_prices) / (self._prev_prices + 1e-6))))
-        self._prev_prices = new_prices.copy()
-
-        revenue_observed = float(result["revenue_observed"])
-        agent_loss = float(result["agent_loss"])
-
-        reward = (revenue_observed
-                  - COI
-                  - self.constraints.w_agent_loss * agent_loss
-                  - self.constraints.w_volatility * volatility
-                  - self.constraints.w_estimation_error
-                  )
-
-        terminated = self.t >= self.constraints.episode_length
-        info = {
-            "t": self.t,
-            "revenue_observed": revenue_observed,
-            "revenue_oracle": float(result["revenue_oracle"]),
-            "agent_loss": agent_loss,
-            "ux_volatility": volatility,
-            "mean_internal_error": err_mean,
-            "look_to_book": float(result["interaction_features"].get("look_to_book", 0.0)),
-            "mean_sale_price": float(result["interaction_features"].get("mean_sale_price", 0.0)),
-            "true_human_purchases_total": float(np.sum(result["true_human_demand"])),
-            "true_agent_purchases_total": float(np.sum(result["true_agent_purchases"])),
-        }
-        return self.state, float(reward), terminated, False, info
-
-
-if __name__ == "__main__":
-    import matplotlib.pyplot as plt
-    from collections import defaultdict
-
-    runs = {}
-    for use_defense in (False, True):
-        env = PHANTOMEnv(use_defense=use_defense)
-        obs, _ = env.reset(seed=42)
-        metrics = defaultdict(list)
-        total_reward = 0.0
-        done = False
-
-        while not done:
-            action = env.action_space.sample()
-            obs, reward, done, _, info = env.step(action)
-            total_reward += reward
-            p_mean = float(np.mean(obs["elasticity"]["price"]))
-            q_mean = float(np.mean(obs["elasticity"]["demand"]))
-            p_std = float(np.std(obs["elasticity"]["price"]))
-
-            metrics['t'].append(info['t'])
-            metrics['price_mean'].append(p_mean)
-            metrics['price_std'].append(p_std)
-            metrics['demand_mean'].append(q_mean)
-            metrics['revenue_observed'].append(info['revenue_observed'])
-            metrics['revenue_oracle'].append(info['revenue_oracle'])
-            metrics['agent_loss'].append(info['agent_loss'])
-            metrics['ux_volatility'].append(info['ux_volatility'])
-            metrics['look_to_book'].append(info['look_to_book'])
-            metrics['reward'].append(reward)
-            metrics['human_purchases'].append(info['true_human_purchases_total'])
-            metrics['agent_purchases'].append(info['true_agent_purchases_total'])
-
-            if info['t'] % 20 == 0 or done:
-                print(f"defense={'ON ' if use_defense else 'OFF'} t={info['t']:03d} p={p_mean:6.2f}±{p_std:4.2f} "
-                      f"q={q_mean:6.2f} rev={info['revenue_observed']:7.2f} oracle={info['revenue_oracle']:7.2f} "
-                      f"loss={info['agent_loss']:6.2f} ux={info['ux_volatility']:.3f} "
-                      f"ltb={info['look_to_book']:5.2f} r={reward:7.2f}")
-
-        runs[use_defense] = metrics
-        print(f"defense={'ON ' if use_defense else 'OFF'} total_reward={total_reward:.2f}\n")
-
-    fig, axes = plt.subplots(3, 3, figsize=(15, 12))
-    fig.suptitle('PHANTOM Environment: Defense OFF vs ON', fontsize=14, fontweight='bold')
-
-    plot_configs = [
-        ('price_mean', 'Mean Price', 'Price'),
-        ('demand_mean', 'Mean Demand Estimate', 'Demand'),
-        ('revenue_observed', 'Revenue (Observed)', 'Revenue'),
-        ('agent_loss', 'Agent Loss (Oracle - Observed)', 'Loss'),
-        ('ux_volatility', 'UX Volatility (Price Change)', 'Volatility'),
-        ('look_to_book', 'Look-to-Book Ratio', 'Ratio'),
-        ('reward', 'Step Reward', 'Reward'),
-        ('human_purchases', 'Human Purchases', 'Count'),
-        ('agent_purchases', 'Agent Purchases', 'Count'),
-    ]
-
-    for idx, (key, title, ylabel) in enumerate(plot_configs):
-        ax = axes[idx // 3, idx % 3]
-        for use_defense, label, color in [(False, 'No Defense', 'red'), (True, 'With Defense', 'blue')]:
-            m = runs[use_defense]
-            ax.plot(m['t'], m[key], label=label, color=color, alpha=0.7, linewidth=1.5)
-        ax.set_xlabel('Step')
-        ax.set_ylabel(ylabel)
-        ax.set_title(title, fontsize=10, fontweight='bold')
-        ax.legend(loc='best', fontsize=8)
-        ax.grid(True, alpha=0.3)
-
-    plt.tight_layout()
-    plt.savefig('phantom_env_comparison.png', dpi=150, bbox_inches='tight')
-    print("Plot saved to phantom_env_comparison.png")
-    plt.show()

sim/rl/train.py

@@ -1,149 +0,0 @@
-import numpy as np
-import logging
-from pathlib import Path
-from typing import Dict, Type, Optional
-import pickle
-from torch import neg_
-from torch.utils.tensorboard import SummaryWriter
-from environment import PHANTOMEnv, FastTrainingConstraints, BusinessLogicConstraints
-from engine import (BasePricingEngine, WildPricingEngine, StaticPricingEngine,
-                   SimpleDemandEngine, RandomWalkEngine, ThompsonSamplingEngine)
-
-logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')
-logger = logging.getLogger(__name__)
-
-
-
-"""
-Target training loop:
-have base prices p0 from env reset and run the env step, collect reward and metrics
-pass this to the pricing engine which computes the price action to take based on previous reward by learning
-the new action gets passed to the step
-so we alternate, step -> reward -> engine (produces price delta) -> step with price delta -> reward
-to make sure the reinforcement learning inside the engine can learn we need to have trajectory of prices
-CURRENT SOLUTION BELOW does not implement correct learning or updates.
-"""
-
-class EngineTrainer:
-    """wrapper to run pricing engines through episodes and collect metrics"""
-    def __init__(self, engine: BasePricingEngine, env: PHANTOMEnv,
-                 tb_writer: Optional[SummaryWriter] = None):
-        self.engine = engine
-        self.env = env
-        self.episode_metrics = []
-        self.tb_writer = tb_writer
-        self.global_step = 0
-
-    def train(self, n_episodes: int, seed: int = 42):
-
-        obs, _ = self.env.reset(seed=seed)
-        prices = None
-        for ep in range(n_episodes):
-            prices = self.engine.compute_prices(prices, obs)
-            obs, reward, done, _, info = self.env.step(prices)
-            self.engine.update(obs, reward, done, info)
-        return self
-
-
-
-
-
-
-        return self.episode_metrics
-
-    def evaluate(self, n_episodes: int = 10, seed: int = 100) -> Dict:
-        """evaluate trained engine"""
-        results = {k: [] for k in ['total_reward', 'revenue_observed', 'revenue_oracle',
-                                   'agent_loss', 'ux_volatility', 'look_to_book']}
-        for ep in range(n_episodes):
-            metrics = self.run_episode(seed=seed + ep)
-            for k in results:                results[k].append(metrics[k])
-        return {k: (np.mean(v), np.std(v)) for k, v in results.items()}
-
-
-def make_env(fast: bool = True):
-    constraints = FastTrainingConstraints() if fast else BusinessLogicConstraints()
-    return PHANTOMEnv(constraints=constraints)
-
-
-def train_engine(engine_cls: Type[BasePricingEngine], env: PHANTOMEnv,
-                n_episodes: int, seed: int = 42,
-                tb_writer: Optional[SummaryWriter] = None) -> EngineTrainer:
-    constraints = env.constraints
-    engine = engine_cls(constraints=constraints, seed=seed)
-    trainer = EngineTrainer(engine, env, tb_writer=tb_writer)
-    trainer.train(n_episodes, seed=seed)
-    return trainer
-
-
-def save_trainer(trainer: EngineTrainer, path: Path):
-    """save engine state and metrics"""
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with open(path, 'wb') as f:
-        pickle.dump({
-            'engine': trainer.engine,
-            'metrics': trainer.episode_metrics
-        }, f)
-    logger.info(f"Saved trainer to {path}")
-
-
-def load_trainer(path: Path, env: PHANTOMEnv,
-                 tb_writer: Optional[SummaryWriter] = None) -> EngineTrainer:
-    """load saved engine"""
-    with open(path, 'rb') as f:
-        data = pickle.load(f)
-    trainer = EngineTrainer(data['engine'], env, tb_writer=tb_writer)
-    trainer.episode_metrics = data['metrics']
-    return trainer
-
-
-if __name__ == "__main__":
-    base_dir = Path("./runs")
-    base_dir.mkdir(exist_ok=True)
-
-    engines = {
-        "Wild": WildPricingEngine,
-        "Static": StaticPricingEngine,
-#        "SimpleDemand": SimpleDemandEngine,
-        "RandomWalk": RandomWalkEngine,
-        "ThompsonSampling": ThompsonSamplingEngine,
-    }
-    defenses = [False, True]
-    n_train_episodes = 50
-    n_eval_episodes = 10
-    seed = 42
-    fast_mode = True
-
-    logger.info(f"Training config: {n_train_episodes} episodes per engine, fast_mode={fast_mode}")
-
-    trained_trainers = {}
-
-    for engine_name, engine_cls in engines.items():
-        for use_defense in defenses:
-            defense_label = "defense_on" if use_defense else "defense_off"
-            run_name = f"{engine_name}_{defense_label}"
-            log_dir = base_dir / run_name
-            log_dir.mkdir(parents=True, exist_ok=True)
-
-            logger.info(f"Training {engine_name} with defense={use_defense}")
-            logger.info(f"Log directory: {log_dir}")
-
-            env = make_env(fast=fast_mode)
-            tb_writer = SummaryWriter(log_dir=str(log_dir))
-            trainer = train_engine(engine_cls, env, n_train_episodes, seed, tb_writer=tb_writer)
-            tb_writer.close()
-
-            save_path = log_dir / "trainer.pkl"
-            save_trainer(trainer, save_path)
-
-            trained_trainers[run_name] = (trainer, env)
-
-    logger.info("Starting evaluation")
-
-    for run_name, (trainer, env) in trained_trainers.items():
-        logger.info(f"Evaluating {run_name}")
-        results = trainer.evaluate(n_episodes=n_eval_episodes, seed=seed + 1000)
-        for metric, (mean, std) in results.items():
-            logger.info(f"  {metric:20s}: {mean:10.2f} ± {std:6.2f}")
-
-    logger.info(f"Results saved to: {base_dir}")

tests/e2e/__init__.py

@@ -1 +0,0 @@
-"""E2E test suite for PHANTOM dynamic pricing pipeline."""

tests/e2e/fixtures.ts

@@ -1,17 +0,0 @@
-import { test as base } from '@playwright/test';
-
-type TestFixtures = {
-  backendUrl: string;
-  pricingUrl: string;
-};
-
-export const test = base.extend<TestFixtures>({
-  backendUrl: async ({}, use) => {
-    await use(process.env.BACKEND_URL || 'http://localhost:5000');
-  },
-  pricingUrl: async ({}, use) => {
-    await use(process.env.PRICING_PROVIDER_URL || 'http://localhost:5001');
-  },
-});
-
-export { expect } from '@playwright/test';

tests/e2e/helpers/api.ts

@@ -1,69 +0,0 @@
-interface PriceResponse {
-  price: number;
-  base_price: number;
-  markup: number;
-  model_version?: string;
-}
-
-export async function fetchPrice(
-  baseUrl: string,
-  productId: string,
-  mode: string = 'simple_surge',
-  sessionId?: string
-): Promise<PriceResponse> {
-  const params = new URLSearchParams();
-  if (sessionId) params.set('sessionId', sessionId);
-
-  const url = `${baseUrl}/api/pricing?mode=${mode}&productId=${productId}&${params}`;
-  const resp = await fetch(url);
-
-  if (!resp.ok) {
-    throw new Error(`Price fetch failed: ${resp.status}`);
-  }
-
-  return resp.json();
-}
-
-export async function waitForPriceChange(
-  baseUrl: string,
-  productId: string,
-  baselinePrice: number,
-  mode: string,
-  sessionId?: string,
-  maxRetries: number = 10,
-  pollInterval: number = 500
-): Promise<PriceResponse> {
-  for (let i = 0; i < maxRetries; i++) {
-    const priceResp = await fetchPrice(baseUrl, productId, mode, sessionId);
-    if (Math.abs(priceResp.price - baselinePrice) > 0.01) {
-      return priceResp;
-    }
-    await new Promise(r => setTimeout(r, pollInterval));
-  }
-
-  throw new Error(`Price did not change after ${maxRetries} retries`);
-}
-
-export async function ingestEvent(
-  baseUrl: string,
-  sessionId: string,
-  event: string,
-  productId?: string,
-  metadata?: Record<string, any>
-): Promise<void> {
-  const resp = await fetch(`${baseUrl}/api/ingest`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      sessionId,
-      event,
-      productId,
-      timestamp: new Date().toISOString(),
-      metadata,
-    }),
-  });
-
-  if (!resp.ok) {
-    throw new Error(`Event ingest failed: ${resp.status}`);
-  }
-}

tests/e2e/helpers/interactions.ts

@@ -1,219 +0,0 @@
-import { Page } from '@playwright/test';
-
-export async function getSessionId(page: Page): Promise<string | null> {
-  const cookies = await page.context().cookies();
-  const sessionCookie = cookies.find(c => c.name === 'phantom_session_id');
-  return sessionCookie?.value || null;
-}
-
-export async function verifySessionConsistency(page: Page, expectedSessionId: string): Promise<boolean> {
-  const currentSessionId = await getSessionId(page);
-  return currentSessionId === expectedSessionId;
-}
-
-export async function createFreshSession(page: Page, storeType: 'hotel' | 'airline' = 'hotel'): Promise<string> {
-  await page.context().clearCookies();
-  await page.goto('/');
-  await page.waitForLoadState('networkidle');
-  await page.waitForTimeout(500);
-
-  const sid = await getSessionId(page);
-  if (!sid) throw new Error('Session not created');
-  return sid;
-}
-
-interface SearchParams {
-  destination?: string;
-  checkIn?: string;
-  guests?: number;
-  rooms?: number;
-  origin?: string;
-  departure?: string;
-  adults?: number;
-}
-
-export async function performSearch(page: Page, params: SearchParams, storeType: 'hotel' | 'airline' = 'hotel' ): Promise<void> {
-  await page.waitForLoadState('networkidle');
-
-  if (storeType === 'hotel') {
-    const destInput = page.locator('input#destination');
-    await destInput.fill(params.destination || 'New York');
-
-    const checkInInput = page.locator('input#checkIn');
-    const checkInDate = params.checkIn || new Date(Date.now() + 7 * 86400000).toISOString().split('T')[0];
-    await checkInInput.fill(checkInDate);
-
-    const searchBtn = page.locator('button:has-text("Search Rooms")');
-    await searchBtn.click();
-  } else {
-    const originDropdown = page.locator('button:has-text("Select origin")').or(
-      page.locator('[id="origin"]').locator('button').first()
-    );
-    await originDropdown.click();
-    await page.waitForTimeout(200);
-    const originOption = page.locator(`button:has-text("${params.origin || 'JFK'}")`).first();
-    await originOption.click();
-    await page.waitForTimeout(200);
-
-    const destDropdown = page.locator('button:has-text("Select destination")').or(
-      page.locator('[id="destination"]').locator('button').first()
-    );
-    await destDropdown.click();
-    await page.waitForTimeout(200);
-    const destOption = page.locator(`button:has-text("${params.destination || 'LAX'}")`).first();
-    await destOption.click();
-    await page.waitForTimeout(200);
-
-    const departInput = page.locator('input#departDate');
-    const departDate = params.departure || new Date(Date.now() + 7 * 86400000).toISOString().split('T')[0];
-    await departInput.fill(departDate);
-
-    const searchBtn = page.locator('button:has-text("Search Flights")');
-    await searchBtn.click();
-  }
-
-  await page.waitForLoadState('networkidle');
-}
-
-export async function selectRandomProduct(page: Page, storeType: 'hotel' | 'airline' = 'hotel'): Promise<string> {
-  await page.waitForLoadState('networkidle');
-
-  const cardClass = storeType === 'hotel' ? '.hotel-card' : '.flight-card';
-  const productCards = page.locator(cardClass);
-
-  const count = await productCards.count();
-  if (count === 0) throw new Error('No products found on listing page');
-
-  const randomIdx = Math.floor(Math.random() * count);
-  return randomIdx.toString();
-}
-
-export async function openProductFromListing(page: Page, productId?: string): Promise<string> {
-  await page.waitForLoadState('networkidle');
-
-  const hotelCards = page.locator('.hotel-card');
-  const flightCards = page.locator('.flight-card');
-
-  const hotelCount = await hotelCards.count();
-  const flightCount = await flightCards.count();
-
-  let productCards;
-  if (hotelCount > 0) {
-    productCards = hotelCards;
-  } else if (flightCount > 0) {
-    productCards = flightCards;
-  } else {
-    throw new Error('No products found on listing page');
-  }
-
-  const count = await productCards.count();
-  const randomIdx = productId ? 0 : Math.floor(Math.random() * count);
-  await productCards.nth(randomIdx).click();
-
-  await page.waitForLoadState('networkidle');
-
-  const url = page.url();
-  const match = url.match(/\/products\/([^/?]+)/);
-  if (!match) throw new Error('Cannot parse product ID from URL after navigation');
-
-  return match[1];
-}
-
-export async function getPriceFromDOM(page: Page): Promise<number> {
-  await page.waitForLoadState('networkidle');
-
-  await page.waitForSelector('.price-amount', { timeout: 15000 }).catch(() => null);
-
-  const priceSelectors = [
-    '.price-amount',
-    '.price-display',
-    '[data-testid="price"]',
-    '[data-price]',
-  ];
-
-  for (const selector of priceSelectors) {
-    const priceEl = page.locator(selector).first();
-    if (await priceEl.count() > 0) {
-      const text = await priceEl.textContent();
-      if (!text) continue;
-
-      const match = text.match(/[\$]?\s*([\d,]+(?:\.\d{2})?)/);
-      if (match) {
-        const priceStr = match[1].replace(/,/g, '');
-        return parseFloat(priceStr);
-      }
-    }
-  }
-
-  const dataPrice = await page.locator('[data-price]').first().getAttribute('data-price').catch(() => null);
-  if (dataPrice) return parseFloat(dataPrice);
-
-  throw new Error('Cannot extract price from DOM');
-}
-
-export async function navigateToProduct(page: Page,productId: string,storeType: 'hotel' | 'airline' = 'hotel'): Promise<void> {
-  await page.goto(`/products/${productId}`);
-  await page.waitForLoadState('networkidle');
-}
-
-export async function viewProductViaFlow(page: Page, storeType: 'hotel' | 'airline' = 'hotel', searchParams?: SearchParams): Promise<string> {
-  const params = new URLSearchParams();
-  params.set('dateIndex', '7');
-
-  if (storeType === 'hotel') {
-    params.set('destination', searchParams?.destination || 'New York');
-    params.set('adults', '2');
-    params.set('rooms', '1');
-  } else {
-    params.set('origin', searchParams?.origin || 'JFK');
-    params.set('destination', searchParams?.destination || 'LAX');
-    params.set('adults', '1');
-    params.set('children', '0');
-    params.set('infants', '0');
-  }
-
-  await page.goto(`/products?${params.toString()}`);
-  await page.waitForLoadState('networkidle');
-
-  const productId = await openProductFromListing(page);
-  await page.waitForTimeout(500);
-  return productId;
-}
-
-export async function rapidViewProductViaFlow(page: Page, count: number, delayMs: number = 100, storeType: 'hotel' | 'airline' = 'hotel'): Promise<string[]> {
-  const productIds: string[] = [];
-
-  for (let i = 0; i < count; i++) {
-    const productId = await viewProductViaFlow(page, storeType);
-    productIds.push(productId);
-
-    await page.waitForTimeout(delayMs);
-  }
-
-  return productIds;
-}
-
-export async function humanLikeViewProduct(page: Page, storeType: 'hotel' | 'airline' = 'hotel'
-): Promise<string> {
-  const productId = await viewProductViaFlow(page, storeType);
-
-  await page.hover('h1');
-  await page.waitForTimeout(800 + Math.random() * 400);
-
-  await page.mouse.wheel(0, 200);
-  await page.waitForTimeout(500 + Math.random() * 300);
-
-  const paragraphs = await page.locator('p').all();
-  if (paragraphs.length > 0) {
-    await paragraphs[0].hover();
-    await page.waitForTimeout(600 + Math.random() * 400);
-  }
-
-  return productId;
-}
-
-export async function addToCart(page: Page): Promise<void> {
-  const addBtn = page.locator('button:has-text("Add to Cart")');
-  await addBtn.click();
-  await page.waitForTimeout(500);
-}

tests/e2e/helpers/kafka.ts

@@ -1,39 +0,0 @@
-interface InteractionEvent {
-  sessionId: string;
-  event: string;
-  productId?: string;
-  timestamp: string;
-  metadata?: Record<string, any>;
-}
-
-const dumpKafkaTopic = async (backendUrl: string, topic: string) => {
-  const resp = await fetch(`${backendUrl}/api/kafka/dump?topic=${topic}`);
-  if (!resp.ok) throw new Error(`Kafka dump failed: ${resp.status}`);
-  const { data = [] } = await resp.json();
-  return data as any[];
-};
-
-export const waitForInteractionEvent = async (
-  backendUrl: string,
-  sessionId: string,
-  eventType: string,
-  maxRetries = 10,
-  pollInterval = 500
-): Promise<InteractionEvent | null> => {
-  for (let i = 0; i < maxRetries; i++) {
-    const msgs = await dumpKafkaTopic(backendUrl, "user-interactions");
-    const hit = msgs.find(m => m.sessionId === sessionId && m.event === eventType);
-    if (hit) return hit as InteractionEvent;
-    await new Promise<void>(r => setTimeout(r, pollInterval));
-  }
-  return null;
-};
-
-export const countProductViews = async (backendUrl: string, productId: string) =>
-  (await dumpKafkaTopic(backendUrl, "user-interactions")).reduce(
-    (n, m) => n + (m.productId === productId && m.event === "view_item_page" ? 1 : 0),
-    0
-  );
-
-export const getSessionEvents = async (backendUrl: string, sessionId: string) =>
-  (await dumpKafkaTopic(backendUrl, "user-interactions")).filter(m => m.sessionId === sessionId);

tests/e2e/package.json

@@ -1,19 +0,0 @@
-{
-  "name": "e2e",
-  "version": "1.0.0",
-  "main": "index.js",
-  "scripts": {
-    "test": "playwright test",
-    "test:ui": "playwright test --ui",
-    "test:debug": "playwright test --debug"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "description": "",
-  "devDependencies": {
-    "@playwright/test": "^1.57.0",
-    "@types/node": "^25.0.6",
-    "typescript": "^5.9.3"
-  }
-}

tests/e2e/playwright.config.ts

@@ -1,25 +0,0 @@
-import { defineConfig, devices } from '@playwright/test';
-
-export default defineConfig({
-  testDir: './scenarios',
-  fullyParallel: true,
-  forbidOnly: !!process.env.CI,
-  retries: 0,
-  workers: 1,
-  reporter: 'list',
-  use: {
-    baseURL: process.env.WEB_URL || 'http://localhost:3000',
-    trace: 'retain-on-failure',
-    screenshot: 'only-on-failure',
-  },
-  timeout: 180000,
-  expect: {
-    timeout: 10000,
-  },
-  projects: [
-    {
-      name: 'chromium',
-      use: { ...devices['Desktop Chrome'] },
-    },
-  ],
-});

tests/e2e/scenarios/session-aware.spec.ts

@@ -1,163 +0,0 @@
-import { test, expect } from '../fixtures';
-import {
-  createFreshSession,
-  viewProductViaFlow,
-  rapidViewProductViaFlow,
-  humanLikeViewProduct,
-  getPriceFromDOM,
-  verifySessionConsistency,
-  addToCart,
-} from '../helpers/interactions';
-import { getSessionEvents } from '../helpers/kafka';
-import { runSessionPricing } from '../helpers/airflow';
-
-test.describe('SessionAwarePricer E2E', () => {
-  const STORE_TYPE = 'hotel';
-
-  test('baseline: human-like behavior maintains base price', async ({ page, backendUrl }) => {
-    const sessionId = await createFreshSession(page, STORE_TYPE);
-
-    const productId1 = await humanLikeViewProduct(page, STORE_TYPE);
-    const baselinePrice = await getPriceFromDOM(page);
-    expect(await verifySessionConsistency(page, sessionId)).toBeTruthy();
-
-    await page.waitForTimeout(1500);
-
-    const productId2 = await humanLikeViewProduct(page, STORE_TYPE);
-
-    await runSessionPricing(STORE_TYPE);
-
-    const secondPrice = await getPriceFromDOM(page);
-    expect(await verifySessionConsistency(page, sessionId)).toBeTruthy();
-
-    expect(Math.abs(secondPrice - baselinePrice) / baselinePrice).toBeLessThan(0.1);
-  });
-
-  test('agent detection: rapid robot-like behavior increases price', async ({ page, backendUrl }) => {
-    const sessionId = await createFreshSession(page, STORE_TYPE);
-
-    const productId = await viewProductViaFlow(page, STORE_TYPE);
-    const baselinePrice = await getPriceFromDOM(page);
-
-    await page.waitForTimeout(500);
-
-    await rapidViewProductViaFlow(page, 8, 100, STORE_TYPE);
-    expect(await verifySessionConsistency(page, sessionId)).toBeTruthy();
-
-    await page.waitForTimeout(1000);
-
-    const events = await getSessionEvents(backendUrl, sessionId);
-    expect(events.length).toBeGreaterThanOrEqual(8);
-
-    await runSessionPricing(STORE_TYPE);
-
-    await page.goto(`/products/${productId}`);
-    await page.waitForLoadState('networkidle');
-    const agentPrice = await getPriceFromDOM(page);
-
-    expect(agentPrice).toBeGreaterThan(baselinePrice);
-    expect((agentPrice - baselinePrice) / baselinePrice).toBeGreaterThan(0.01);
-  });
-
-  test('velocity threshold: high event rate triggers detection', async ({ page, backendUrl }) => {
-    const sessionId = await createFreshSession(page, STORE_TYPE);
-
-    const productId = await viewProductViaFlow(page, STORE_TYPE);
-    const baselinePrice = await getPriceFromDOM(page);
-
-    await rapidViewProductViaFlow(page, 10, 80, STORE_TYPE);
-
-    const events = await getSessionEvents(backendUrl, sessionId);
-    expect(events.length).toBeGreaterThanOrEqual(10);
-
-    await runSessionPricing(STORE_TYPE);
-
-    await page.goto(`/products/${productId}`);
-    await page.waitForLoadState('networkidle');
-    const agentPrice = await getPriceFromDOM(page);
-
-    expect(agentPrice).toBeGreaterThan(baselinePrice);
-    expect(await verifySessionConsistency(page, sessionId)).toBeTruthy();
-  });
-
-  test('cart ratio: high cart/view ratio signals intent', async ({ page, backendUrl }) => {
-    const sessionId = await createFreshSession(page, STORE_TYPE);
-
-    const productId = await viewProductViaFlow(page, STORE_TYPE);
-    const baselinePrice = await getPriceFromDOM(page);
-
-    await page.waitForTimeout(500);
-    await addToCart(page);
-
-    await page.waitForTimeout(2000);
-
-    await page.goto(`/products/${productId}`);
-    await page.waitForLoadState('networkidle');
-    const cartPrice = await getPriceFromDOM(page);
-
-    expect(cartPrice).toBeGreaterThanOrEqual(baselinePrice);
-    expect(await verifySessionConsistency(page, sessionId)).toBeTruthy();
-  });
-
-  test('mixed behavior: occasional fast actions tolerated', async ({ page, backendUrl }) => {
-    const sessionId = await createFreshSession(page, STORE_TYPE);
-
-    const productId1 = await humanLikeViewProduct(page, STORE_TYPE);
-    const baselinePrice = await getPriceFromDOM(page);
-
-    await page.waitForTimeout(1200);
-
-    await rapidViewProductViaFlow(page, 2, 150, STORE_TYPE);
-
-    await page.waitForTimeout(1000);
-    await humanLikeViewProduct(page, STORE_TYPE);
-
-    await runSessionPricing(STORE_TYPE);
-
-    const finalPrice = await getPriceFromDOM(page);
-
-    expect(Math.abs(finalPrice - baselinePrice) / baselinePrice).toBeLessThan(0.3);
-    expect(await verifySessionConsistency(page, sessionId)).toBeTruthy();
-  });
-
-  test('session isolation: agent behavior in one session does not affect others', async ({
-    page,
-    context,
-    backendUrl,
-  }) => {
-    const sessionIdA = await createFreshSession(page, STORE_TYPE);
-    const productId = await viewProductViaFlow(page, STORE_TYPE);
-    const basePrice = await getPriceFromDOM(page);
-
-    await rapidViewProductViaFlow(page, 10, 100, STORE_TYPE);
-    await page.waitForTimeout(2000);
-
-    await page.goto(`/products/${productId}`);
-    await page.waitForLoadState('networkidle');
-    const agentPrice = await getPriceFromDOM(page);
-    expect(agentPrice).toBeGreaterThan(basePrice * 0.99);
-
-    const page2 = await context.newPage();
-    const sessionIdB = await createFreshSession(page2, STORE_TYPE);
-
-    await page2.goto(`/products/${productId}`);
-    await page2.waitForLoadState('networkidle');
-    const cleanPrice = await getPriceFromDOM(page2);
-
-    expect(Math.abs(cleanPrice - basePrice) / basePrice).toBeLessThan(0.1);
-    expect(sessionIdA).not.toBe(sessionIdB);
-  });
-
-  test('session persistence: session ID maintained across views', async ({ page }) => {
-    const sessionId = await createFreshSession(page, STORE_TYPE);
-
-    await viewProductViaFlow(page, STORE_TYPE);
-    expect(await verifySessionConsistency(page, sessionId)).toBeTruthy();
-
-    await viewProductViaFlow(page, STORE_TYPE);
-    expect(await verifySessionConsistency(page, sessionId)).toBeTruthy();
-
-    await viewProductViaFlow(page, STORE_TYPE);
-    expect(await verifySessionConsistency(page, sessionId)).toBeTruthy();
-  });
-});

tests/e2e/scenarios/surge-pricing.spec.ts

@@ -1,118 +0,0 @@
-import { test, expect } from '../fixtures';
-import {
-  createFreshSession,
-  viewProductViaFlow,
-  rapidViewProductViaFlow,
-  getPriceFromDOM,
-  verifySessionConsistency,
-} from '../helpers/interactions';
-import { waitForInteractionEvent, countProductViews } from '../helpers/kafka';
-import { runSurgePricing } from '../helpers/airflow';
-
-test.describe('SimpleSurgePricer E2E', () => {
-  const STORE_TYPE = 'hotel';
-
-  test('baseline: initial price equals base price', async ({ page, backendUrl }) => {
-    const sessionId = await createFreshSession(page, STORE_TYPE);
-
-    const productId = await viewProductViaFlow(page, STORE_TYPE);
-    const price = await getPriceFromDOM(page);
-
-    expect(price).toBeGreaterThan(0);
-    expect(await verifySessionConsistency(page, sessionId)).toBeTruthy();
-  });
-
-  test('surge: rapid views trigger price increase', async ({ page, backendUrl }) => {
-    const sessionId = await createFreshSession(page, STORE_TYPE);
-
-    const productId = await viewProductViaFlow(page, STORE_TYPE);
-    const baselinePrice = await getPriceFromDOM(page);
-
-    await rapidViewProductViaFlow(page, 5, 200, STORE_TYPE);
-
-    await page.waitForTimeout(1000);
-
-    const evt = await waitForInteractionEvent(backendUrl, sessionId, 'view_item_page');
-    expect(evt).not.toBeNull();
-
-    const viewCount = await countProductViews(backendUrl, productId);
-    expect(viewCount).toBeGreaterThanOrEqual(5);
-
-    await runSurgePricing(STORE_TYPE, 3, 1);
-
-    await page.goto(`/products/${productId}`);
-    await page.waitForLoadState('networkidle');
-    const surgedPrice = await getPriceFromDOM(page);
-
-    expect(surgedPrice).toBeGreaterThan(baselinePrice);
-    expect((surgedPrice - baselinePrice) / baselinePrice).toBeGreaterThan(0.01);
-    expect(await verifySessionConsistency(page, sessionId)).toBeTruthy();
-  });
-
-  test('threshold: price unchanged below threshold', async ({ page, backendUrl }) => {
-    const sessionId = await createFreshSession(page, STORE_TYPE);
-
-    const productId = await viewProductViaFlow(page, STORE_TYPE);
-    const baselinePrice = await getPriceFromDOM(page);
-
-    await rapidViewProductViaFlow(page, 2, 300, STORE_TYPE);
-
-    await page.waitForTimeout(1500);
-
-    await page.goto(`/products/${productId}`);
-    await page.waitForLoadState('networkidle');
-    const currentPrice = await getPriceFromDOM(page);
-
-    expect(Math.abs(currentPrice - baselinePrice) / baselinePrice).toBeLessThan(0.05);
-    expect(await verifySessionConsistency(page, sessionId)).toBeTruthy();
-  });
-
-  test('window: surge decays after window expires', async ({ page, backendUrl }) => {
-    const sessionId = await createFreshSession(page, STORE_TYPE);
-
-    const productId = await viewProductViaFlow(page, STORE_TYPE);
-    const baselinePrice = await getPriceFromDOM(page);
-
-    await rapidViewProductViaFlow(page, 5, 150, STORE_TYPE);
-
-    await page.waitForTimeout(1000);
-
-    await runSurgePricing(STORE_TYPE, 3, 1);
-
-    await page.goto(`/products/${productId}`);
-    await page.waitForLoadState('networkidle');
-    const surgedPrice = await getPriceFromDOM(page);
-    expect(surgedPrice).toBeGreaterThan(baselinePrice);
-
-    await page.waitForTimeout(12000);
-
-    await runSurgePricing(STORE_TYPE, 3, 1);
-
-    await page.goto(`/products/${productId}`);
-    await page.waitForLoadState('networkidle');
-    const decayedPrice = await getPriceFromDOM(page);
-    expect(decayedPrice).toBeLessThan(surgedPrice);
-    expect(await verifySessionConsistency(page, sessionId)).toBeTruthy();
-  });
-
-  test('isolation: different products have independent surge', async ({ page, backendUrl }) => {
-    const sessionId = await createFreshSession(page, STORE_TYPE);
-
-    const productIdA = await viewProductViaFlow(page, STORE_TYPE);
-    const basePriceA = await getPriceFromDOM(page);
-
-    await rapidViewProductViaFlow(page, 5, 200, STORE_TYPE);
-    await page.waitForTimeout(2000);
-
-    await page.goto(`/products/${productIdA}`);
-    await page.waitForLoadState('networkidle');
-    const surgedPriceA = await getPriceFromDOM(page);
-
-    const productIdB = await viewProductViaFlow(page, STORE_TYPE);
-    const priceB = await getPriceFromDOM(page);
-
-    expect(surgedPriceA).toBeGreaterThan(basePriceA * 0.99);
-    expect(productIdA).not.toBe(productIdB);
-    expect(await verifySessionConsistency(page, sessionId)).toBeTruthy();
-  });
-});

tests/e2e/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "commonjs",
-    "lib": ["ES2022"],
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "types": ["node", "@playwright/test"]
-  },
-  "include": ["**/*.ts"],
-  "exclude": ["node_modules"]
-}

web/package-lock.json

@@ -8,9 +8,7 @@
       "name": "web",
       "version": "0.1.0",
       "dependencies": {
-        "@supabase/ssr": "^0.7.0",
-        "@supabase/supabase-js": "^2.81.1",
-        "next": "^16.0.0",
+        "next": "16.0.0",
         "react": "19.2.0",
         "react-dom": "19.2.0",
         "zod": "^4.1.12"
@@ -526,15 +524,15 @@
       }
     },
     "node_modules/@next/env": {
-      "version": "16.0.7",
-      "resolved": "https://registry.npmjs.org/@next/env/-/env-16.0.7.tgz",
-      "integrity": "sha512-gpaNgUh5nftFKRkRQGnVi5dpcYSKGcZZkQffZ172OrG/XkrnS7UBTQ648YY+8ME92cC4IojpI2LqTC8sTDhAaw==",
+      "version": "16.0.0",
+      "resolved": "https://registry.npmjs.org/@next/env/-/env-16.0.0.tgz",
+      "integrity": "sha512-s5j2iFGp38QsG1LWRQaE2iUY3h1jc014/melHFfLdrsMJPqxqDQwWNwyQTcNoUSGZlCVZuM7t7JDMmSyRilsnA==",
       "license": "MIT"
     },
     "node_modules/@next/swc-darwin-arm64": {
-      "version": "16.0.7",
-      "resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-16.0.7.tgz",
-      "integrity": "sha512-LlDtCYOEj/rfSnEn/Idi+j1QKHxY9BJFmxx7108A6D8K0SB+bNgfYQATPk/4LqOl4C0Wo3LACg2ie6s7xqMpJg==",
+      "version": "16.0.0",
+      "resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-16.0.0.tgz",
+      "integrity": "sha512-/CntqDCnk5w2qIwMiF0a9r6+9qunZzFmU0cBX4T82LOflE72zzH6gnOjCwUXYKOBlQi8OpP/rMj8cBIr18x4TA==",
       "cpu": [
         "arm64"
       ],
@@ -548,9 +546,9 @@
       }
     },
     "node_modules/@next/swc-darwin-x64": {
-      "version": "16.0.7",
-      "resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-16.0.7.tgz",
-      "integrity": "sha512-rtZ7BhnVvO1ICf3QzfW9H3aPz7GhBrnSIMZyr4Qy6boXF0b5E3QLs+cvJmg3PsTCG2M1PBoC+DANUi4wCOKXpA==",
+      "version": "16.0.0",
+      "resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-16.0.0.tgz",
+      "integrity": "sha512-hB4GZnJGKa8m4efvTGNyii6qs76vTNl+3dKHTCAUaksN6KjYy4iEO3Q5ira405NW2PKb3EcqWiRaL9DrYJfMHg==",
       "cpu": [
         "x64"
       ],
@@ -564,9 +562,9 @@
       }
     },
     "node_modules/@next/swc-linux-arm64-gnu": {
-      "version": "16.0.7",
-      "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-16.0.7.tgz",
-      "integrity": "sha512-mloD5WcPIeIeeZqAIP5c2kdaTa6StwP4/2EGy1mUw8HiexSHGK/jcM7lFuS3u3i2zn+xH9+wXJs6njO7VrAqww==",
+      "version": "16.0.0",
+      "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-16.0.0.tgz",
+      "integrity": "sha512-E2IHMdE+C1k+nUgndM13/BY/iJY9KGCphCftMh7SXWcaQqExq/pJU/1Hgn8n/tFwSoLoYC/yUghOv97tAsIxqg==",
       "cpu": [
         "arm64"
       ],
@@ -580,9 +578,9 @@
       }
     },
     "node_modules/@next/swc-linux-arm64-musl": {
-      "version": "16.0.7",
-      "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-16.0.7.tgz",
-      "integrity": "sha512-+ksWNrZrthisXuo9gd1XnjHRowCbMtl/YgMpbRvFeDEqEBd523YHPWpBuDjomod88U8Xliw5DHhekBC3EOOd9g==",
+      "version": "16.0.0",
+      "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-16.0.0.tgz",
+      "integrity": "sha512-xzgl7c7BVk4+7PDWldU+On2nlwnGgFqJ1siWp3/8S0KBBLCjonB6zwJYPtl4MUY7YZJrzzumdUpUoquu5zk8vg==",
       "cpu": [
         "arm64"
       ],
@@ -596,9 +594,9 @@
       }
     },
     "node_modules/@next/swc-linux-x64-gnu": {
-      "version": "16.0.7",
-      "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-16.0.7.tgz",
-      "integrity": "sha512-4WtJU5cRDxpEE44Ana2Xro1284hnyVpBb62lIpU5k85D8xXxatT+rXxBgPkc7C1XwkZMWpK5rXLXTh9PFipWsA==",
+      "version": "16.0.0",
+      "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-16.0.0.tgz",
+      "integrity": "sha512-sdyOg4cbiCw7YUr0F/7ya42oiVBXLD21EYkSwN+PhE4csJH4MSXUsYyslliiiBwkM+KsuQH/y9wuxVz6s7Nstg==",
       "cpu": [
         "x64"
       ],
@@ -612,9 +610,9 @@
       }
     },
     "node_modules/@next/swc-linux-x64-musl": {
-      "version": "16.0.7",
-      "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-16.0.7.tgz",
-      "integrity": "sha512-HYlhqIP6kBPXalW2dbMTSuB4+8fe+j9juyxwfMwCe9kQPPeiyFn7NMjNfoFOfJ2eXkeQsoUGXg+O2SE3m4Qg2w==",
+      "version": "16.0.0",
+      "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-16.0.0.tgz",
+      "integrity": "sha512-IAXv3OBYqVaNOgyd3kxR4L3msuhmSy1bcchPHxDOjypG33i2yDWvGBwFD94OuuTjjTt/7cuIKtAmoOOml6kfbg==",
       "cpu": [
         "x64"
       ],
@@ -628,9 +626,9 @@
       }
     },
     "node_modules/@next/swc-win32-arm64-msvc": {
-      "version": "16.0.7",
-      "resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-16.0.7.tgz",
-      "integrity": "sha512-EviG+43iOoBRZg9deGauXExjRphhuYmIOJ12b9sAPy0eQ6iwcPxfED2asb/s2/yiLYOdm37kPaiZu8uXSYPs0Q==",
+      "version": "16.0.0",
+      "resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-16.0.0.tgz",
+      "integrity": "sha512-bmo3ncIJKUS9PWK1JD9pEVv0yuvp1KPuOsyJTHXTv8KDrEmgV/K+U0C75rl9rhIaODcS7JEb6/7eJhdwXI0XmA==",
       "cpu": [
         "arm64"
       ],
@@ -644,9 +642,9 @@
       }
     },
     "node_modules/@next/swc-win32-x64-msvc": {
-      "version": "16.0.7",
-      "resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-16.0.7.tgz",
-      "integrity": "sha512-gniPjy55zp5Eg0896qSrf3yB1dw4F/3s8VK1ephdsZZ129j2n6e1WqCbE2YgcKhW9hPB9TVZENugquWJD5x0ug==",
+      "version": "16.0.0",
+      "resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-16.0.0.tgz",
+      "integrity": "sha512-O1cJbT+lZp+cTjYyZGiDwsOjO3UHHzSqobkPNipdlnnuPb1swfcuY6r3p8dsKU4hAIEO4cO67ZCfVVH/M1ETXA==",
       "cpu": [
         "x64"
       ],
@@ -659,97 +657,6 @@
         "node": ">= 10"
       }
     },
-    "node_modules/@supabase/auth-js": {
-      "version": "2.81.1",
-      "resolved": "https://registry.npmjs.org/@supabase/auth-js/-/auth-js-2.81.1.tgz",
-      "integrity": "sha512-K20GgiSm9XeRLypxYHa5UCnybWc2K0ok0HLbqCej/wRxDpJxToXNOwKt0l7nO8xI1CyQ+GrNfU6bcRzvdbeopQ==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "2.8.1"
-      },
-      "engines": {
-        "node": ">=20.0.0"
-      }
-    },
-    "node_modules/@supabase/functions-js": {
-      "version": "2.81.1",
-      "resolved": "https://registry.npmjs.org/@supabase/functions-js/-/functions-js-2.81.1.tgz",
-      "integrity": "sha512-sYgSO3mlgL0NvBFS3oRfCK4OgKGQwuOWJLzfPyWg0k8MSxSFSDeN/JtrDJD5GQrxskP6c58+vUzruBJQY78AqQ==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "2.8.1"
-      },
-      "engines": {
-        "node": ">=20.0.0"
-      }
-    },
-    "node_modules/@supabase/postgrest-js": {
-      "version": "2.81.1",
-      "resolved": "https://registry.npmjs.org/@supabase/postgrest-js/-/postgrest-js-2.81.1.tgz",
-      "integrity": "sha512-DePpUTAPXJyBurQ4IH2e42DWoA+/Qmr5mbgY4B6ZcxVc/ZUKfTVK31BYIFBATMApWraFc8Q/Sg+yxtfJ3E0wSg==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "2.8.1"
-      },
-      "engines": {
-        "node": ">=20.0.0"
-      }
-    },
-    "node_modules/@supabase/realtime-js": {
-      "version": "2.81.1",
-      "resolved": "https://registry.npmjs.org/@supabase/realtime-js/-/realtime-js-2.81.1.tgz",
-      "integrity": "sha512-ViQ+Kxm8BuUP/TcYmH9tViqYKGSD1LBjdqx2p5J+47RES6c+0QHedM0PPAjthMdAHWyb2LGATE9PD2++2rO/tw==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/phoenix": "^1.6.6",
-        "@types/ws": "^8.18.1",
-        "tslib": "2.8.1",
-        "ws": "^8.18.2"
-      },
-      "engines": {
-        "node": ">=20.0.0"
-      }
-    },
-    "node_modules/@supabase/ssr": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/@supabase/ssr/-/ssr-0.7.0.tgz",
-      "integrity": "sha512-G65t5EhLSJ5c8hTCcXifSL9Q/ZRXvqgXeNo+d3P56f4U1IxwTqjB64UfmfixvmMcjuxnq2yGqEWVJqUcO+AzAg==",
-      "license": "MIT",
-      "dependencies": {
-        "cookie": "^1.0.2"
-      },
-      "peerDependencies": {
-        "@supabase/supabase-js": "^2.43.4"
-      }
-    },
-    "node_modules/@supabase/storage-js": {
-      "version": "2.81.1",
-      "resolved": "https://registry.npmjs.org/@supabase/storage-js/-/storage-js-2.81.1.tgz",
-      "integrity": "sha512-UNmYtjnZnhouqnbEMC1D5YJot7y0rIaZx7FG2Fv8S3hhNjcGVvO+h9We/tggi273BFkiahQPS/uRsapo1cSapw==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "2.8.1"
-      },
-      "engines": {
-        "node": ">=20.0.0"
-      }
-    },
-    "node_modules/@supabase/supabase-js": {
-      "version": "2.81.1",
-      "resolved": "https://registry.npmjs.org/@supabase/supabase-js/-/supabase-js-2.81.1.tgz",
-      "integrity": "sha512-KSdY7xb2L0DlLmlYzIOghdw/na4gsMcqJ8u4sD6tOQJr+x3hLujU9s4R8N3ob84/1bkvpvlU5PYKa1ae+OICnw==",
-      "license": "MIT",
-      "dependencies": {
-        "@supabase/auth-js": "2.81.1",
-        "@supabase/functions-js": "2.81.1",
-        "@supabase/postgrest-js": "2.81.1",
-        "@supabase/realtime-js": "2.81.1",
-        "@supabase/storage-js": "2.81.1"
-      },
-      "engines": {
-        "node": ">=20.0.0"
-      }
-    },
     "node_modules/@swc/helpers": {
       "version": "0.5.15",
       "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.15.tgz",
@@ -1034,17 +941,12 @@
       "version": "20.19.23",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.23.tgz",
       "integrity": "sha512-yIdlVVVHXpmqRhtyovZAcSy0MiPcYWGkoO4CGe/+jpP0hmNuihm4XhHbADpK++MsiLHP5MVlv+bcgdF99kSiFQ==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "undici-types": "~6.21.0"
       }
     },
-    "node_modules/@types/phoenix": {
-      "version": "1.6.6",
-      "resolved": "https://registry.npmjs.org/@types/phoenix/-/phoenix-1.6.6.tgz",
-      "integrity": "sha512-PIzZZlEppgrpoT2QgbnDU+MMzuR6BbCjllj0bM70lWoejMeNJAxCchxnv7J3XFkI8MpygtRpzXrIlmWUBclP5A==",
-      "license": "MIT"
-    },
     "node_modules/@types/react": {
       "version": "19.2.2",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.2.tgz",
@@ -1065,15 +967,6 @@
         "@types/react": "^19.2.0"
       }
     },
-    "node_modules/@types/ws": {
-      "version": "8.18.1",
-      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
-      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
-      "license": "MIT",
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
     "node_modules/caniuse-lite": {
       "version": "1.0.30001751",
       "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001751.tgz",
@@ -1100,15 +993,6 @@
       "integrity": "sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==",
       "license": "MIT"
     },
-    "node_modules/cookie": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.0.2.tgz",
-      "integrity": "sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      }
-    },
     "node_modules/csstype": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
@@ -1447,12 +1331,12 @@
       }
     },
     "node_modules/next": {
-      "version": "16.0.7",
-      "resolved": "https://registry.npmjs.org/next/-/next-16.0.7.tgz",
-      "integrity": "sha512-3mBRJyPxT4LOxAJI6IsXeFtKfiJUbjCLgvXO02fV8Wy/lIhPvP94Fe7dGhUgHXcQy4sSuYwQNcOLhIfOm0rL0A==",
+      "version": "16.0.0",
+      "resolved": "https://registry.npmjs.org/next/-/next-16.0.0.tgz",
+      "integrity": "sha512-nYohiNdxGu4OmBzggxy9rczmjIGI+TpR5vbKTsE1HqYwNm1B+YSiugSrFguX6omMOKnDHAmBPY4+8TNJk0Idyg==",
       "license": "MIT",
       "dependencies": {
-        "@next/env": "16.0.7",
+        "@next/env": "16.0.0",
         "@swc/helpers": "0.5.15",
         "caniuse-lite": "^1.0.30001579",
         "postcss": "8.4.31",
@@ -1465,14 +1349,14 @@
         "node": ">=20.9.0"
       },
       "optionalDependencies": {
-        "@next/swc-darwin-arm64": "16.0.7",
-        "@next/swc-darwin-x64": "16.0.7",
-        "@next/swc-linux-arm64-gnu": "16.0.7",
-        "@next/swc-linux-arm64-musl": "16.0.7",
-        "@next/swc-linux-x64-gnu": "16.0.7",
-        "@next/swc-linux-x64-musl": "16.0.7",
-        "@next/swc-win32-arm64-msvc": "16.0.7",
-        "@next/swc-win32-x64-msvc": "16.0.7",
+        "@next/swc-darwin-arm64": "16.0.0",
+        "@next/swc-darwin-x64": "16.0.0",
+        "@next/swc-linux-arm64-gnu": "16.0.0",
+        "@next/swc-linux-arm64-musl": "16.0.0",
+        "@next/swc-linux-x64-gnu": "16.0.0",
+        "@next/swc-linux-x64-musl": "16.0.0",
+        "@next/swc-win32-arm64-msvc": "16.0.0",
+        "@next/swc-win32-x64-msvc": "16.0.0",
         "sharp": "^0.34.4"
       },
       "peerDependencies": {
@@ -1721,29 +1605,9 @@
       "version": "6.21.0",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
       "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
       "license": "MIT"
     },
-    "node_modules/ws": {
-      "version": "8.18.3",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
-      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": ">=5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/zod": {
       "version": "4.1.12",
       "resolved": "https://registry.npmjs.org/zod/-/zod-4.1.12.tgz",

web/package.json

@@ -8,9 +8,7 @@
     "start": "next start"
   },
   "dependencies": {
-    "@supabase/ssr": "^0.7.0",
-    "@supabase/supabase-js": "^2.81.1",
-    "next": "^16.0.0",
+    "next": "16.0.0",
     "react": "19.2.0",
     "react-dom": "19.2.0",
     "zod": "^4.1.12"

web/src/app/admin/experiments/page.tsx

@@ -1,26 +1,20 @@
 'use client';
 
 import { useEffect, useState } from 'react';
-import { TaskManager } from '@/components/admin/TaskManager';
-import { ExperimentForm } from '@/components/admin/ExperimentForm';
+import { useSession } from '@/hooks/useSession';
 
 type Experiment = {
   id: string;
-  subject_name: string;
-  xp_human_only: boolean;
-  xp_market_mode: string;
-  created_at: string;
-  task?: {
-    id: string;
-    task_name: string;
-  };
+  status: 'active' | 'stopped';
+  sessionIds: string[];
+  createdAt: number;
 };
 
 export default function ExperimentsAdmin() {
+  const { sessionId, isLoading: sessionLoading } = useSession();
   const [exps, setExps] = useState<Experiment[]>([]);
-  const [selectedTaskId, setSelectedTaskId] = useState<string | undefined>();
+  const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
-  const [showForm, setShowForm] = useState(false);
 
   const fetchExps = async () => {
     try {
@@ -37,22 +31,86 @@ export default function ExperimentsAdmin() {
     fetchExps();
   }, []);
 
-  const handleExperimentCreated = async () => {
-    setShowForm(false);
-    setSelectedTaskId(undefined);
-    await fetchExps();
+  const handleStart = async () => {
+    if (!sessionId) {
+      setError('no session available');
+      return;
+    }
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const res = await fetch('/api/admin/experiments/start', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ sessionId }),
+      });
+
+      if (!res.ok) {
+        const data = await res.json();
+        throw new Error(data.error || 'start failed');
+      }
+
+      await fetchExps(); // refresh list
+    } catch (err: any) {
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
   };
 
+  const handleStop = async (expId: string) => {
+    setLoading(true);
+    setError(null);
+
+    try {
+      const res = await fetch('/api/admin/experiments/stop', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ experimentId: expId }),
+      });
+
+      if (!res.ok) {
+        const data = await res.json();
+        throw new Error(data.error || 'stop failed');
+      }
+
+      await fetchExps(); // refresh list
+    } catch (err: any) {
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  if (sessionLoading) {
+    return (
+      <div className="flex min-h-screen items-center justify-center bg-zinc-50 dark:bg-black">
+        <p className="text-zinc-600 dark:text-zinc-400">loading session...</p>
+      </div>
+    );
+  }
+
   return (
     <div className="min-h-screen bg-zinc-50 px-6 py-12 dark:bg-black">
-      <div className="mx-auto max-w-7xl">
-        <div className="mb-8">
-          <h1 className="text-3xl font-semibold tracking-tight text-black dark:text-zinc-50">
-            Experiment Management
-          </h1>
-          <p className="mt-2 text-sm text-zinc-600 dark:text-zinc-400">
-            configure tasks and run experiments
-          </p>
+      <div className="mx-auto max-w-5xl">
+        <div className="mb-8 flex items-center justify-between">
+          <div>
+            <h1 className="text-3xl font-semibold tracking-tight text-black dark:text-zinc-50">
+              Experiments
+            </h1>
+            <p className="mt-2 text-sm text-zinc-600 dark:text-zinc-400">
+              current session: {sessionId || 'none'}
+            </p>
+          </div>
+          <button
+            onClick={handleStart}
+            disabled={loading || !sessionId}
+            className="rounded-lg bg-black px-4 py-2 text-sm font-medium text-white transition-colors hover:bg-zinc-800 disabled:opacity-50 dark:bg-zinc-50 dark:text-black dark:hover:bg-zinc-200"
+          >
+            {loading ? 'starting...' : 'start experiment'}
+          </button>
         </div>
 
         {error && (
@@ -61,123 +119,79 @@ export default function ExperimentsAdmin() {
           </div>
         )}
 
-        <div className="grid grid-cols-1 gap-6 lg:grid-cols-3">
-          {/* left column: task manager */}
-          <div className="lg:col-span-1">
-            <TaskManager
-              onTaskSelect={setSelectedTaskId}
-              selectedTaskId={selectedTaskId}
-            />
-          </div>
-
-          {/* right column: experiment form + list */}
-          <div className="space-y-6 lg:col-span-2">
-            <div className="flex items-center justify-between">
-              <h2 className="text-lg font-semibold text-zinc-900 dark:text-zinc-100">
-                Experiments
-              </h2>
-              <button
-                onClick={() => setShowForm(!showForm)}
-                className="rounded-lg bg-black px-4 py-2 text-sm font-medium text-white transition-colors hover:bg-zinc-800 dark:bg-zinc-50 dark:text-black dark:hover:bg-zinc-200"
-              >
-                {showForm ? 'hide form' : 'new experiment'}
-              </button>
-            </div>
-
-            {showForm && (
-              <ExperimentForm
-                selectedTaskId={selectedTaskId}
-                onSuccess={handleExperimentCreated}
-              />
-            )}
-
-            <div className="overflow-hidden rounded-lg border border-zinc-200 bg-white dark:border-zinc-800 dark:bg-zinc-950">
-              <table className="w-full text-left text-sm">
-                <thead className="border-b border-zinc-200 bg-zinc-50 dark:border-zinc-800 dark:bg-zinc-900">
-                  <tr>
-                    <th className="px-4 py-3 font-medium text-zinc-900 dark:text-zinc-100">
-                      subject
-                    </th>
-                    <th className="px-4 py-3 font-medium text-zinc-900 dark:text-zinc-100">
-                      mode
-                    </th>
-                    <th className="px-4 py-3 font-medium text-zinc-900 dark:text-zinc-100">
-                      human
-                    </th>
-                    <th className="px-4 py-3 font-medium text-zinc-900 dark:text-zinc-100">
-                      task
-                    </th>
-                    <th className="px-4 py-3 font-medium text-zinc-900 dark:text-zinc-100">
-                      created
-                    </th>
-                    <th className="px-4 py-3 font-medium text-zinc-900 dark:text-zinc-100">
-                      link
-                    </th>
-                  </tr>
-                </thead>
-                <tbody className="divide-y divide-zinc-200 dark:divide-zinc-800">
-                  {exps.length === 0 ? (
-                    <tr>
-                      <td
-                        colSpan={6}
-                        className="px-4 py-8 text-center text-zinc-500 dark:text-zinc-400"
+        <div className="overflow-hidden rounded-lg border border-zinc-200 bg-white dark:border-zinc-800 dark:bg-zinc-950">
+          <table className="w-full text-left text-sm">
+            <thead className="border-b border-zinc-200 bg-zinc-50 dark:border-zinc-800 dark:bg-zinc-900">
+              <tr>
+                <th className="px-6 py-3 font-medium text-zinc-900 dark:text-zinc-100">
+                  experiment id
+                </th>
+                <th className="px-6 py-3 font-medium text-zinc-900 dark:text-zinc-100">
+                  status
+                </th>
+                <th className="px-6 py-3 font-medium text-zinc-900 dark:text-zinc-100">
+                  session count
+                </th>
+                <th className="px-6 py-3 font-medium text-zinc-900 dark:text-zinc-100">
+                  created
+                </th>
+                <th className="px-6 py-3 font-medium text-zinc-900 dark:text-zinc-100">
+                  action
+                </th>
+              </tr>
+            </thead>
+            <tbody className="divide-y divide-zinc-200 dark:divide-zinc-800">
+              {exps.length === 0 ? (
+                <tr>
+                  <td
+                    colSpan={5}
+                    className="px-6 py-8 text-center text-zinc-500 dark:text-zinc-400"
+                  >
+                    no experiments yet
+                  </td>
+                </tr>
+              ) : (
+                exps.map((exp) => (
+                  <tr
+                    key={exp.id}
+                    className="hover:bg-zinc-50 dark:hover:bg-zinc-900"
+                  >
+                    <td className="px-6 py-4 font-mono text-xs text-zinc-700 dark:text-zinc-300">
+                      {exp.id.slice(0, 8)}...
+                    </td>
+                    <td className="px-6 py-4">
+                      <span
+                        className={`inline-block rounded-full px-2 py-1 text-xs font-medium ${
+                          exp.status === 'active'
+                            ? 'bg-green-100 text-green-800 dark:bg-green-950 dark:text-green-200'
+                            : 'bg-zinc-100 text-zinc-800 dark:bg-zinc-800 dark:text-zinc-200'
+                        }`}
                       >
-                        no experiments yet
-                      </td>
-                    </tr>
-                  ) : (
-                    exps.map((exp) => {
-                      const baseUrl = exp.xp_market_mode === 'airline'
-                        ? 'https://phantom-airline.vercel.app'
-                        : 'https://phantom-hotel.vercel.app';
-                      const link = `${baseUrl}/start-task?uuid=${exp.id}`;
-
-                      return (
-                        <tr
-                          key={exp.id}
-                          className="hover:bg-zinc-50 dark:hover:bg-zinc-900"
+                        {exp.status}
+                      </span>
+                    </td>
+                    <td className="px-6 py-4 text-zinc-700 dark:text-zinc-300">
+                      {exp.sessionIds.length}
+                    </td>
+                    <td className="px-6 py-4 text-zinc-700 dark:text-zinc-300">
+                      {new Date(exp.createdAt).toLocaleString()}
+                    </td>
+                    <td className="px-6 py-4">
+                      {exp.status === 'active' && (
+                        <button
+                          onClick={() => handleStop(exp.id)}
+                          disabled={loading}
+                          className="text-sm font-medium text-red-600 hover:text-red-700 disabled:opacity-50 dark:text-red-400 dark:hover:text-red-300"
                         >
-                          <td className="px-4 py-3 font-medium text-zinc-900 dark:text-zinc-100">
-                            {exp.subject_name}
-                          </td>
-                          <td className="px-4 py-3">
-                            <span className="inline-block rounded-full bg-zinc-100 px-2 py-1 text-xs font-medium text-zinc-800 dark:bg-zinc-800 dark:text-zinc-200">
-                              {exp.xp_market_mode || 'none'}
-                            </span>
-                          </td>
-                          <td className="px-4 py-3">
-                            {exp.xp_human_only ? (
-                              <span className="text-xs text-green-600 dark:text-green-400">
-                                yes
-                              </span>
-                            ) : (
-                              <span className="text-xs text-zinc-500">no</span>
-                            )}
-                          </td>
-                          <td className="px-4 py-3 text-xs text-zinc-600 dark:text-zinc-400">
-                            {exp.task ? exp.task.task_name : '—'}
-                          </td>
-                          <td className="px-4 py-3 text-xs text-zinc-600 dark:text-zinc-400">
-                            {new Date(exp.created_at).toLocaleDateString()}
-                          </td>
-                          <td className="px-4 py-3">
-                            <button
-                              onClick={() => {
-                                navigator.clipboard.writeText(link);
-                              }}
-                              className="text-xs font-medium text-zinc-900 hover:text-zinc-600 dark:text-zinc-100 dark:hover:text-zinc-400"
-                            >
-                              copy link
-                            </button>
-                          </td>
-                        </tr>
-                      );
-                    })
-                  )}
-                </tbody>
-              </table>
-            </div>
-          </div>
+                          stop
+                        </button>
+                      )}
+                    </td>
+                  </tr>
+                ))
+              )}
+            </tbody>
+          </table>
         </div>
       </div>
     </div>

web/src/app/airline/checkout/page.tsx

@@ -1,11 +0,0 @@
-export default function AirlineCheckout() {
-  return (
-    <div className="min-h-screen flex items-center justify-center bg-gradient-to-br from-sky-50 to-blue-50">
-      <div className="text-center p-8">
-        <h1 className="text-4xl font-light text-gray-800 mb-4">
-          Thank you for flying with us
-        </h1>
-      </div>
-    </div>
-  );
-}

web/src/app/airline/products/[id]/page.tsx

@@ -1,106 +0,0 @@
-'use client';
-
-import { useState, useEffect } from 'react';
-import { useParams, useRouter } from 'next/navigation';
-import { Navigation } from '@/components/ui';
-import { useCart } from '@/contexts/CartContext';
-import AirlineDetails from '@/components/feats/airline/AirlineDetails';
-import { transformProduct, type Flight, type AirlineProduct } from '@/lib/airline-utils';
-import type { EventName } from '@/lib/events';
-
-const dispatchInteraction = (eventName: EventName, productId?: string, metadata?: Record<string, unknown>) => {
-    const e = new CustomEvent('definedInteraction', {
-        detail: { eventName, productId, metadata },
-    });
-    document.dispatchEvent(e);
-};
-
-export default function AirlineProductPage() {
-    const params = useParams();
-    const router = useRouter();
-    const { addItem } = useCart();
-    const [product, setProduct] = useState<Flight | null>(null);
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState<string | null>(null);
-    const [added, setAdded] = useState(false);
-
-    const productId = params.id as string;
-
-    useEffect(() => {
-        const fetchProduct = async () => {
-            try {
-                const res = await fetch(`/api/products/${productId}`);
-                if (!res.ok) throw new Error(`Failed to fetch: ${res.status}`);
-                const json = await res.json();
-                const transformed = transformProduct(json.data as AirlineProduct);
-                setProduct(transformed);
-
-                // fire learn_more_about_item event when product loads
-                dispatchInteraction('learn_more_about_item', productId, {
-                    type: 'airline',
-                    dateIndex: transformed.dateIndex,
-                    flightType: transformed.flightType,
-                });
-            } catch (e) {
-                setError(e instanceof Error ? e.message : 'Failed to load product');
-                console.error('[FETCH_FLIGHT_ERROR]', e);
-            } finally {
-                setLoading(false);
-            }
-        };
-        fetchProduct();
-    }, [productId]);
-
-    const handleAddToCart = () => {
-        if (!product) return;
-
-        addItem({
-            id: productId,
-            type: 'airline',
-            name: product.flightType,
-            price: product.basePrice,
-            metadata: {
-                departure: product.departure,
-                arrival: product.arrival,
-                duration: product.duration,
-                cabinClass: product.cabinClass,
-            },
-            dateIndex: product.dateIndex,
-        });
-
-        dispatchInteraction('add_item_to_cart', productId, {
-            type: 'airline',
-            price: product.basePrice,
-        });
-
-        setAdded(true);
-        setTimeout(() => setAdded(false), 2000);
-    };
-
-    return (
-        <>
-            <Navigation />
-            <main className="max-w-4xl mx-auto px-4 py-8">
-                {loading && <div className="text-center py-8">Loading flight details...</div>}
-                {error && <div className="text-red-500 text-center py-8">{error}</div>}
-
-                {!loading && !error && product && (
-                    <>
-                        <button
-                            onClick={() => router.back()}
-                            className="mt-6 text-blue-600 hover:underline"
-                        >
-                            ← Back to flights
-                        </button>
-                        <AirlineDetails
-                            product={product}
-                            onAddToCart={handleAddToCart}
-                            addedToCart={added}
-                        />
-
-                    </>
-                )}
-            </main>
-        </>
-    );
-}

web/src/app/airline/products/page.tsx

@@ -1,69 +1,73 @@
 'use client';
 
-import { useState, useEffect, Suspense } from 'react';
-import { useSearchParams } from 'next/navigation';
 import { Navigation } from '@/components/ui';
 import AirlineCard from '@/components/feats/airline/AirlineCard';
-import { transformProduct, type Flight, type AirlineProduct } from '@/lib/airline-utils';
 
-function FlightsList() {
-  const searchParams = useSearchParams();
-  const [flights, setFlights] = useState<Flight[]>([]);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
+type CabinClass = 'economy' | 'premium' | 'business' | 'first';
+type FareRule = 'flexible' | 'standard' | 'basic';
 
-  useEffect(() => {
-    const fetchFlights = async () => {
-      try {
-        const url = new URL('/api/products', window.location.origin);
-        url.searchParams.set('type', 'airline');
+interface Flight {
+  id: string;
+  departure: { time: string; airport: string };
+  arrival: { time: string; airport: string };
+  duration: string;
+  stops: number;
+  cabinClass: CabinClass;
+  fareRule: FareRule;
+  refundable: boolean;
+  basePrice: number;
+}
 
-        // forward all relevant search params to the API
-        const params = ['dateIndex', 'origin', 'destination', 'tripType', 'adults', 'children', 'infants'];
-        params.forEach(param => {
-          const val = searchParams.get(param);
-          if (val) url.searchParams.set(param, val);
-        });
+const genRandomFlights = (): Flight[] => {
+  const airports = ['JFK', 'LAX', 'ORD', 'ATL', 'DFW', 'SFO', 'SEA', 'MIA'];
+  const cabins: CabinClass[] = ['economy', 'premium', 'business', 'first'];
+  const fareRules: FareRule[] = ['flexible', 'standard', 'basic'];
 
-        const res = await fetch(url.toString());
-        if (!res.ok) throw new Error(`Failed to fetch: ${res.status}`);
-        const json = await res.json();
-        const transformed = json.data.map((p: AirlineProduct) => transformProduct(p));
-        setFlights(transformed);
-      } catch (e) {
-        setError(e instanceof Error ? e.message : 'Failed to load products');
-        console.error('[FETCH_ERROR]', e);
-      } finally {
-        setLoading(false);
-      }
+  return Array.from({ length: 12 }, (_, i) => {
+    const depHour = Math.floor(Math.random() * 24);
+    const arrHour = (depHour + Math.floor(Math.random() * 6) + 2) % 24;
+    const stops = Math.random() > 0.6 ? 0 : Math.floor(Math.random() * 2) + 1;
+    const cabin = cabins[Math.floor(Math.random() * cabins.length)];
+    const fareRule = fareRules[Math.floor(Math.random() * fareRules.length)];
+
+    const basePrice = Math.floor(
+      (cabin === 'economy' ? 200 : cabin === 'premium' ? 400 : cabin === 'business' ? 800 : 1500) +
+      Math.random() * 300
+    );
+
+    return {
+      id: `flt-${i}`,
+      departure: {
+        time: `${depHour.toString().padStart(2, '0')}:${Math.floor(Math.random() * 60).toString().padStart(2, '0')}`,
+        airport: airports[Math.floor(Math.random() * airports.length)],
+      },
+      arrival: {
+        time: `${arrHour.toString().padStart(2, '0')}:${Math.floor(Math.random() * 60).toString().padStart(2, '0')}`,
+        airport: airports[Math.floor(Math.random() * airports.length)],
+      },
+      duration: `${Math.floor(Math.random() * 5) + 2}h ${Math.floor(Math.random() * 60)}m`,
+      stops,
+      cabinClass: cabin,
+      fareRule,
+      refundable: Math.random() > 0.7,
+      basePrice,
     };
-    fetchFlights();
-  }, [searchParams]);
+  });
+};
+
+export default function AirlineProducts() {
+  const flights = genRandomFlights();
 
   return (
     <>
-      <h1 className="text-3xl font-bold mb-6">Available Flights</h1>
-      {loading && <div className="text-center py-8">Loading...</div>}
-      {error && <div className="text-red-500 text-center py-8">{error}</div>}
-      {!loading && !error && (
+      <Navigation />
+      <main className="max-w-7xl mx-auto px-4 py-8">
+        <h1 className="text-3xl font-bold mb-6">Available Flights</h1>
         <div className="space-y-4">
           {flights.map((f) => (
             <AirlineCard key={f.id} flight={f} />
           ))}
         </div>
-      )}
-    </>
-  );
-}
-
-export default function AirlineProducts() {
-  return (
-    <>
-      <Navigation />
-      <main className="max-w-7xl mx-auto px-4 py-8">
-        <Suspense fallback={<div className="text-center py-8">Loading...</div>}>
-          <FlightsList />
-        </Suspense>
       </main>
     </>
   );

web/src/app/api/admin/experiments/route.ts

@@ -1,40 +1,10 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { createClient } from '@/utils/supabase/server';
-import { cookies } from 'next/headers';
+import { NextResponse } from 'next/server';
+import { getAllExperiments } from '@/lib/sessionStore';
 
-export async function GET(req: NextRequest) {
+export async function GET() {
   try {
-    const cookieStore = await cookies();
-    const supabase = createClient(cookieStore);
-
-    const { searchParams } = new URL(req.url);
-    const id = searchParams.get('id');
-
-    if (id) {
-      const { data, error } = await supabase
-        .from('experiments')
-        .select(`
-          *,
-          task:tasks(*)
-        `)
-        .eq('id', id)
-        .single();
-
-      if (error) throw error;
-      return NextResponse.json({ experiment: data });
-    }
-
-    const { data, error } = await supabase
-      .from('experiments')
-      .select(`
-        *,
-        task:tasks(*)
-      `)
-      .order('created_at', { ascending: false });
-
-    if (error) throw error;
-
-    return NextResponse.json({ experiments: data || [] });
+    const exps = getAllExperiments();
+    return NextResponse.json({ experiments: exps });
   } catch (err: any) {
     console.error('experiments list error:', err);
     return NextResponse.json(
@@ -43,44 +13,3 @@ export async function GET(req: NextRequest) {
     );
   }
 }
-
-export async function POST(req: NextRequest) {
-  try {
-    const cookieStore = await cookies();
-    const supabase = createClient(cookieStore);
-    const body = await req.json();
-
-    const { subject_name, xp_human_only, xp_market_mode, xp_task_id } = body;
-
-    if (!subject_name) {
-      return NextResponse.json(
-        { error: 'subject_name is required' },
-        { status: 400 }
-      );
-    }
-
-    const { data, error } = await supabase
-      .from('experiments')
-      .insert([{
-        subject_name,
-        xp_human_only: xp_human_only ?? false,
-        xp_market_mode: xp_market_mode || null,
-        xp_task_id: xp_task_id || null,
-      }])
-      .select(`
-        *,
-        task:tasks(*)
-      `)
-      .single();
-
-    if (error) throw error;
-
-    return NextResponse.json({ experiment: data });
-  } catch (err: any) {
-    console.error('experiment creation error:', err);
-    return NextResponse.json(
-      { error: err.message || 'unknown error' },
-      { status: 500 }
-    );
-  }
-}

web/src/app/api/admin/tasks/route.ts

@@ -1,58 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { createClient } from '@/utils/supabase/server';
-import { cookies } from 'next/headers';
-
-export async function GET() {
-  try {
-    const cookieStore = await cookies();
-    const supabase = createClient(cookieStore);
-
-    const { data, error } = await supabase
-      .from('tasks')
-      .select('*')
-      .order('created_at', { ascending: false });
-
-    if (error) throw error;
-
-    return NextResponse.json({ tasks: data || [] });
-  } catch (err: any) {
-    console.error('tasks fetch error:', err);
-    return NextResponse.json(
-      { error: err.message || 'unknown error' },
-      { status: 500 }
-    );
-  }
-}
-
-export async function POST(req: NextRequest) {
-  try {
-    const cookieStore = await cookies();
-    const supabase = createClient(cookieStore);
-    const body = await req.json();
-
-    const { task_name, task_description, task_def_of_done } = body;
-
-    if (!task_name) {
-      return NextResponse.json(
-        { error: 'task_name is required' },
-        { status: 400 }
-      );
-    }
-
-    const { data, error } = await supabase
-      .from('tasks')
-      .insert([{ task_name, task_description, task_def_of_done }])
-      .select()
-      .single();
-
-    if (error) throw error;
-
-    return NextResponse.json({ task: data });
-  } catch (err: any) {
-    console.error('task creation error:', err);
-    return NextResponse.json(
-      { error: err.message || 'unknown error' },
-      { status: 500 }
-    );
-  }
-}

web/src/app/api/ingest/route.ts

@@ -7,7 +7,7 @@ export async function POST(req: NextRequest) {
   try {
     const body = await req.json();
 
-    const storeMode = process.env.NEXT_PUBLIC_STORE_MODE || process.env.STORE_MODE || 'hotel';
+    const storeMode = process.env.STORE_MODE || 'hotel';
     const userAgent = req.headers.get('user-agent') || undefined;
 
     const event: EventBase = {

web/src/app/api/pricing/route.ts

@@ -11,7 +11,18 @@ export async function GET(req: NextRequest) {
     const productId = searchParams.get('productId');
     const sessionId = searchParams.get('sessionId');
     const experimentId = searchParams.get('experimentId');
-    const storeMode = process.env.NEXT_PUBLIC_STORE_MODE || process.env.STORE_MODE || 'hotel';
+    const storeMode = process.env.NEXT_PUBLIC_STORE_MODE || 'shop';
+
+    // log in dev
+    if (process.env.NODE_ENV === 'development') {
+        console.log('[pricing-api]', {
+            productId,
+            sessionId,
+            experimentId,
+            storeMode,
+            timestamp: new Date().toISOString(),
+        });
+    }
 
     if (!productId) {
         return NextResponse.json(
@@ -20,76 +31,14 @@ export async function GET(req: NextRequest) {
         );
     }
 
-    const timestamp = new Date().toISOString();
-    let price: number;
-    let basePrice: number | undefined;
-    let markup: number | undefined;
-    let elasticity: number | undefined;
-
-    // call real pricing provider
-    const providerUrl = process.env.PRICING_PROVIDER_URL || 'http://localhost:5001';
-    try {
-        const queryParams = new URLSearchParams();
-        // THIS is our entry point into the dynamic pricing where we reference the context of the sesion and experiment and ask for a price to assign to the trajectory which is expressed
-        // The whole pipeline gets triggered from here.
-        if (sessionId) queryParams.append('sessionId', sessionId);
-        if (experimentId) queryParams.append('experimentId', experimentId);
-
-        const providerResponse = await fetch(
-            `${providerUrl}/api/${storeMode}/price/${productId}?${queryParams.toString()}`,
-            { headers: { 'Accept': 'application/json' }, cache: 'no-store' }
-        );
-
-        if (!providerResponse.ok) {
-            throw new Error(`Provider returned ${providerResponse.status}`);
-        }
-
-        const providerData = await providerResponse.json();
-        price = providerData.price;
-        basePrice = providerData.base_price;
-        markup = providerData.markup;
-        elasticity = providerData.elasticity;
-
-    } catch (err) {
-        console.error('[pricing-provider-error]', err);
-        // fallback to random pricing if provider unavailable
-        const randomBase = 100 + Math.random() * 900;
-        price = Math.round(randomBase * 100) / 100;
-    }
-
-    // log price to kafka asynchronously (non-blocking)
-    if (sessionId) {
-        const backendUrl = process.env.BACKEND_URL || 'http://localhost:5000';
-        // fire and forget - don't await to avoid blocking response
-        fetch(`${backendUrl}/api/kafka/price-log`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                productId,
-                price,
-                sessionId,
-                experimentId: experimentId || undefined,
-                storeMode,
-                ts: timestamp,
-            }),
-        }).catch(err => {
-            if (process.env.NODE_ENV === 'development') {
-                console.error('[price-log-error]', err);
-            }
-        });
-    }
-
-    if (process.env.NODE_ENV === 'development') {
-        console.log('[pricing-api]', {
-            productId, sessionId, experimentId, storeMode,
-            price, basePrice, markup, elasticity, timestamp,
-        });
-    }
+    // stub: call external pricing provider (random for now)
+    const basePrice = 100 + Math.random() * 900; // 100-1000 range
+    const price = Math.round(basePrice * 100) / 100;
 
     const response: PricingResponse = {
         price,
         currency: 'EUR',
-        cachedAt: timestamp,
+        cachedAt: new Date().toISOString(),
     };
 
     return NextResponse.json(response);

web/src/app/api/products/[id]/route.ts

@@ -1,35 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-
-export async function GET(
-  req: NextRequest,
-  { params }: { params: Promise<{ id: string }> }
-) {
-  const { id } = await params;
-
-  if (!id) {
-    return NextResponse.json(
-      { error: 'product id is required' },
-      { status: 400 }
-    );
-  }
-
-  try {
-    const backendUrl = process.env.BACKEND_URL || 'http://localhost:5000';
-    const url = new URL(`${backendUrl}/api/products/${id}`);
-
-    const res = await fetch(url.toString());
-
-    if (!res.ok) {
-      throw new Error(`Backend returned ${res.status}`);
-    }
-
-    const data = await res.json();
-    return NextResponse.json(data);
-  } catch (error) {
-    console.error('[PRODUCT_DETAIL_ERROR]', error);
-    return NextResponse.json(
-      { error: 'Failed to fetch product details' },
-      { status: 500 }
-    );
-  }
-}

web/src/app/api/products/route.ts

@@ -1,40 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-
-export async function GET(req: NextRequest) {
-  const { searchParams } = new URL(req.url);
-  const type = searchParams.get('type');
-
-  if (!type || !['hotel', 'airline'].includes(type)) {
-    return NextResponse.json(
-      { error: 'type parameter must be "hotel" or "airline"' },
-      { status: 400 }
-    );
-  }
-
-  try {
-    const backendUrl = process.env.BACKEND_URL || 'http://localhost:5000';
-    const url = new URL(`${backendUrl}/api/products/type/${type}`);
-
-    // forward all query params to backend (excluding 'type')
-    searchParams.forEach((value, key) => {
-      if (key !== 'type') {
-        url.searchParams.set(key, value);
-      }
-    });
-
-    const res = await fetch(url.toString());
-
-    if (!res.ok) {
-      throw new Error(`Backend returned ${res.status}`);
-    }
-
-    const data = await res.json();
-    return NextResponse.json(data);
-  } catch (error) {
-    console.error('[PRODUCTS_PROXY_ERROR]', error);
-    return NextResponse.json(
-      { error: 'Failed to fetch products' },
-      { status: 500 }
-    );
-  }
-}

web/src/app/api/session/route.ts

@@ -1,12 +1,13 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { randomUUID } from 'crypto';
-import { getSession, createSession, setExperiment } from '@/lib/sessionStore';
+import { getSession, createSession } from '@/lib/sessionStore';
 
 const COOKIE_NAME = 'phantom_session_id';
 const isProd = process.env.NODE_ENV === 'production';
 
 export async function GET(req: NextRequest) {
     try {
+        // check for existing session cookie
         const existingSession = req.cookies.get(COOKIE_NAME)?.value;
 
         if (existingSession) {
@@ -17,11 +18,13 @@ export async function GET(req: NextRequest) {
             });
         }
 
+        // mint new session id
         const sessionId = randomUUID();
         createSession(sessionId);
 
         const res = NextResponse.json({ sessionId, experimentId: undefined });
 
+        // set httpOnly cookie with security flags
         res.cookies.set({
             name: COOKIE_NAME,
             value: sessionId,
@@ -29,7 +32,7 @@ export async function GET(req: NextRequest) {
             sameSite: 'lax',
             secure: isProd,
             path: '/',
-            maxAge: 60 * 60 * 24 * 30,
+            maxAge: 60 * 60 * 24 * 30, // 30 days
         });
 
         return res;
@@ -41,52 +44,3 @@ export async function GET(req: NextRequest) {
         );
     }
 }
-
-export async function POST(req: NextRequest) {
-    try {
-        const body = await req.json();
-        const { experimentId } = body;
-
-        if (!experimentId) {
-            return NextResponse.json(
-                { error: 'experimentId is required' },
-                { status: 400 }
-            );
-        }
-
-        let sessionId = req.cookies.get(COOKIE_NAME)?.value;
-
-        if (!sessionId) {
-            sessionId = randomUUID();
-            createSession(sessionId);
-        }
-
-        setExperiment(sessionId, experimentId);
-
-        const res = NextResponse.json({
-            sessionId,
-            experimentId,
-            success: true
-        });
-
-        if (!req.cookies.get(COOKIE_NAME)) {
-            res.cookies.set({
-                name: COOKIE_NAME,
-                value: sessionId,
-                httpOnly: true,
-                sameSite: 'lax',
-                secure: isProd,
-                path: '/',
-                maxAge: 60 * 60 * 24 * 30,
-            });
-        }
-
-        return res;
-    } catch (err: any) {
-        console.error('session update error:', err);
-        return NextResponse.json(
-            { error: err.message || 'unknown error' },
-            { status: 500 }
-        );
-    }
-}

web/src/app/cart/page.tsx

@@ -1,111 +0,0 @@
-'use client';
-
-import { Navigation } from '@/components/ui';
-import { useCart } from '@/contexts/CartContext';
-import type { EventName } from '@/lib/events';
-
-const dispatchInteraction = (eventName: EventName, productId?: string, metadata?: Record<string, unknown>) => {
-    const e = new CustomEvent('definedInteraction', {
-        detail: { eventName, productId, metadata },
-    });
-    document.dispatchEvent(e);
-};
-
-export default function CartPage() {
-    const { items, removeItem, clearCart, itemCount } = useCart();
-
-    const handleRemove = (id: string, type: string) => {
-        removeItem(id);
-        dispatchInteraction('remove_item', id, { type });
-    };
-    let itemTypes = Array.from(new Set(items.map(item => item.type)))[0] || 'items';
-
-
-    const total = items.reduce((sum, item) => sum + item.price, 0);
-
-    return (
-        <>
-            <Navigation />
-            <main className="max-w-4xl mx-auto px-4 py-8">
-                <div className="flex justify-between items-center mb-6">
-                    <h1 className="text-3xl font-bold">Shopping Cart</h1>
-                    {itemCount > 0 && (
-                        <button
-                            onClick={clearCart}
-                            className="text-sm hover:underline"
-                            style={{ color: 'var(--accent-warning)' }}
-                        >
-                            Clear cart
-                        </button>
-                    )}
-                </div>
-
-                {itemCount === 0 ? (
-                    <div className="text-center py-12">
-                        <p className="text-gray-500 mb-4">Your cart is empty</p>
-                        <a href="/" className="hover:underline" style={{ color: 'var(--text-accent)' }}>Browse our selection</a>
-                    </div>
-                ) : (
-                    <>
-                        <div className="space-y-4 mb-8">
-                            {items.map(item => (
-                                <div
-                                    key={item.id}
-                                    className="flex justify-between items-start p-4 border rounded-lg hover:bg-gray-50"
-                                >
-                                    <div className="flex-1">
-                                        <div className="flex items-center gap-2 mb-1">
-                                            <h3 className="font-semibold">{item.name}</h3>
-                                        </div>
-
-                                        {item.type === 'hotel' && (
-                                            <div className="text-sm text-gray-600">
-                                                <p>{String(item.metadata.checkIn)} - {String(item.metadata.checkOut)}</p>
-                                                <p>{String(item.metadata.nights)} night{Number(item.metadata.nights) > 1 ? 's' : ''}</p>
-                                            </div>
-                                        )}
-
-                                        {item.type === 'airline' && (
-                                            <div className="text-sm text-gray-600">
-                                                <p>{String(item.metadata.cabinClass)} Class</p>
-                                                <p>{String((item.metadata.departure as any)?.airport)} → {String((item.metadata.arrival as any)?.airport)}</p>
-                                                <p>Duration: {String(item.metadata.duration)}</p>
-                                            </div>
-                                        )}
-                                    </div>
-
-                                    <div className="text-right ml-4">
-                                        <p className="text-xl font-bold mb-2">${item.price}</p>
-                                        <button
-                                            onClick={() => handleRemove(item.id, item.type)}
-                                            className="text-sm hover:underline"
-                                            style={{ color: 'var(--accent-warning)' }}
-                                        >
-                                            Remove
-                                        </button>
-                                    </div>
-                                </div>
-                            ))}
-                        </div>
-
-                        <div className="border-t pt-4">
-                            <div className="flex justify-between items-center mb-4">
-                                <span className="text-xl font-semibold">Total</span>
-                                <span className="text-3xl font-bold">${total.toFixed(2)}</span>
-                            </div>
-                            <button
-                                onClick={() => {
-                                    dispatchInteraction('checkout_start', undefined, { total, itemCount });
-                                    window.location.href = '/checkout';
-                                }}
-                                className="btn-primary w-full"
-                            >
-                                Proceed to Checkout
-                            </button>
-                        </div>
-                    </>
-                )}
-            </main>
-        </>
-    );
-}

web/src/app/globals.css

@@ -8,9 +8,6 @@
   --bg-secondary: #f5f5f5;
   --text-primary: #333333;
   --text-secondary: #666666;
-  --accent-primary: #007aff;
-  --accent-primary-hover: #0051d5;
-  --accent-primary-light: #e6f2ff;
   --spacing-sm: 8px;
   --spacing-md: 16px;
   --spacing-lg: 32px;

web/src/app/hotel/checkout/page.tsx

@@ -1,11 +0,0 @@
-export default function HotelCheckout() {
-  return (
-    <div className="min-h-screen flex items-center justify-center bg-gradient-to-br from-blue-50 to-indigo-50">
-      <div className="text-center p-8">
-        <h1 className="text-4xl font-light text-gray-800 mb-4">
-          Thank you for staying with us
-        </h1>
-      </div>
-    </div>
-  );
-}

web/src/app/hotel/products/[id]/page.tsx

@@ -1,106 +0,0 @@
-'use client';
-
-import { useState, useEffect } from 'react';
-import { useParams, useRouter } from 'next/navigation';
-import { Navigation } from '@/components/ui';
-import { useCart } from '@/contexts/CartContext';
-import HotelDetails from '@/components/feats/hotel/HotelDetails';
-import { transformProduct, type Hotel, type HotelProduct } from '@/lib/hotel-utils';
-import type { EventName } from '@/lib/events';
-
-const dispatchInteraction = (eventName: EventName, productId?: string, metadata?: Record<string, unknown>) => {
-    const e = new CustomEvent('definedInteraction', {
-        detail: { eventName, productId, metadata },
-    });
-    document.dispatchEvent(e);
-};
-
-export default function HotelProductPage() {
-    const params = useParams();
-    const router = useRouter();
-    const { addItem } = useCart();
-    const [product, setProduct] = useState<Hotel | null>(null);
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState<string | null>(null);
-    const [added, setAdded] = useState(false);
-
-    const productId = params.id as string;
-
-    useEffect(() => {
-        const fetchProduct = async () => {
-            try {
-                const res = await fetch(`/api/products/${productId}`);
-                if (!res.ok) throw new Error(`Failed to fetch: ${res.status}`);
-                const json = await res.json();
-                const transformed = transformProduct(json.data as HotelProduct);
-                setProduct(transformed);
-
-                // fire learn_more_about_item event when product loads
-                dispatchInteraction('learn_more_about_item', productId, {
-                    type: 'hotel',
-                    dateIndex: transformed.dateIndex,
-                    roomType: transformed.roomType,
-                });
-            } catch (e) {
-                setError(e instanceof Error ? e.message : 'Failed to load product');
-                console.error('[FETCH_HOTEL_ERROR]', e);
-            } finally {
-                setLoading(false);
-            }
-        };
-        fetchProduct();
-    }, [productId]);
-
-    const handleAddToCart = () => {
-        if (!product) return;
-
-        addItem({
-            id: productId,
-            type: 'hotel',
-            name: product.name,
-            price: product.pricePerNight,
-            metadata: {
-                roomType: product.roomType,
-                nights: product.nights,
-                checkIn: product.checkIn,
-                checkOut: product.checkOut,
-            },
-            dateIndex: product.dateIndex,
-        });
-
-        dispatchInteraction('add_item_to_cart', productId, {
-            type: 'hotel',
-            price: product.pricePerNight,
-        });
-
-        setAdded(true);
-        setTimeout(() => setAdded(false), 2000);
-    };
-
-    return (
-        <>
-            <Navigation />
-            <main className="max-w-4xl mx-auto px-4 py-8">
-                {loading && <div className="text-center py-8">Loading hotel details...</div>}
-                {error && <div className="text-red-500 text-center py-8">{error}</div>}
-
-                {!loading && !error && product && (
-                    <>
-                        <button
-                            onClick={() => router.back()}
-                            className="mt-6 text-blue-600 hover:underline"
-                        >
-                            ← Back to rooms
-                        </button>
-                        <HotelDetails
-                            product={product}
-                            onAddToCart={handleAddToCart}
-                            addedToCart={added}
-                        />
-
-                    </>
-                )}
-            </main>
-        </>
-    );
-}