chore: cleaning shitty code

* feat: training pipeline + tensorboard

* tesnorboard forgot

* chore: ml basic boilerplate

* feat: naive architecture as start

* eval setup

* chore: parquet exporting of data

* chore: updating requirements necesary

* feat: separating modules and adding training logs paths

* Update experiments/ml/train.py

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

* fix: new path for runs

* fix: undoing ai slop code

* chore: modules and reqs

---------

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

.gitignore

@@ -11,3 +11,6 @@ paper/src/bib/auto
 experiments/airflow/logs/*
 experiments/airflow/logs/scheduler/
 experiments/airflow/logs/dag_processor_manager/
+tests/e2e/node_modules/**
+**/auto/*.el
+*.old

Makefile

@@ -11,46 +11,72 @@ PYTEST    := $(VENV)/bin/pytest
 
 .DEFAULT_GOAL := help
 
-all: pdf
-
-run.webapp:
-	@cd web && npm install && npm run dev
+.PHONY: help
+help:
+	@echo "pdf.build pdf.watch pdf.clean | test.backend test.e2e test.all | web.dev | install | stats.lines"
 
 $(BUILDDIR):
 	mkdir -p paper/$(BUILDDIR)
 
-pdf: $(BUILDDIR)
-	@echo "Concatenating source code..."
+.PHONY: pdf.build
+pdf.build: $(BUILDDIR)
 	@bash paper/concat_code.sh
 	@cd $(SRCDIR) && \
 	$(LATEXMK) -pdf -jobname=$(JOBNAME) \
 		-interaction=nonstopmode -file-line-error \
 		-outdir=../$(BUILDDIR) $(TEX)
 
-watch: $(BUILDDIR)
+.PHONY: pdf.watch
+pdf.watch: $(BUILDDIR)
 	@cd $(SRCDIR) && \
 	$(LATEXMK) -pvc -pdf -jobname=$(JOBNAME) \
 		-interaction=nonstopmode -file-line-error \
 		-r ../.latexmkrc \
 		-outdir=../$(BUILDDIR) $(TEX)
 
-clean:
+.PHONY: pdf.clean
+pdf.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
+	@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)
+	@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
 
-test: $(VENV)
-	$(PYTEST) -v
-
-count-lines:
+.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: all pdf clean watch run.webapp install test
+.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

README.md

@@ -1,5 +1,12 @@
+<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

@@ -19,11 +19,11 @@ from procesing.pricers import (
     ElasticityBasedPricer
 )
 from procesing.steps import (
-    StateSpace,
     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
@@ -53,20 +53,12 @@ def get_price(mode: Literal['hotel', 'airline'], productId: str, sessionId: Opti
     metadata = product['metadata']
     base_price = metadata.get('base_price', 100.0)
 
-    class Provider(SupabaseProvider, BackendAPIProvider):
-        def __init__(self, backend_url: str):
-            SupabaseProvider.__init__(self)
-            BackendAPIProvider.__init__(self, backend_url=backend_url)
-
-    context = PipelineContext(
-        provider=Provider(backend_url=os.getenv("BACKEND_URL")),
-        store_mode=mode
-    )
-
-    pricing_model = registry.get_pricing_model('latest')
+    # fetch pre-computed prices from registry
+    prices_df = registry.get_prices('latest')
     elasticity_df = registry.get_elasticity('latest')
 
-    if pricing_model is None or elasticity_df is None:
+    if prices_df is None:
+        # fallback: no pre-computed prices available
         return PriceResponse(
             productId=productId,
             price=base_price,
@@ -75,87 +67,26 @@ def get_price(mode: Literal['hotel', 'airline'], productId: str, sessionId: Opti
             elasticity=None
         )
 
-    products = context.products
-    if products.empty:
-        raise HTTPException(500, "No products available in catalog")
-
-    # merge elasticity with product base prices
-    products_with_meta = products.copy()
-    products_with_meta['base_price'] = products_with_meta['metadata'].apply(
-        lambda m: m.get('base_price', 100.0) if isinstance(m, dict) else 100.0
-    )
-
-    merged = products_with_meta[['id', 'base_price']].rename(
-        columns={'id': 'productId'}
-    ).merge(
-        elasticity_df[['productId', 'elasticity']],
-        on='productId',
-        how='left'
-    ).fillna({'elasticity': 0.0})
-
-    # compute demand: use pricer's mean_demand if available, else default
-    demand_values = (pricing_model.mean_demand
-                    if hasattr(pricing_model, 'mean_demand') and pricing_model.mean_demand is not None
-                    else np.ones(len(merged)) * 10.0)
-
-    # build state space with session features if sessionId provided
-    session_features = pd.DataFrame()
-    if sessionId:
-        try:
-            # fetch recent session interactions from backend
-            from procesing.steps.session import ExtractSessionFeaturesStep
-            import requests
-            from datetime import datetime, timedelta
-
-            t_end = datetime.utcnow()
-            t_start = t_end - timedelta(hours=1)
-            backend_url = os.getenv("BACKEND_URL")
-            print(backend_url)
-
-            resp = requests.get(
-                f"{os.getenv('BACKEND_URL')}/api/kafka/dump", # TODO: THIS IS SHIT, must fix this
-                params={'topic': 'user-interactions', 't_start': t_start.isoformat(), 't_end': t_end.isoformat()},
-                timeout=2
-            )
-
-            if resp.ok:
-                msgs = resp.json().get('messages', [])
-                interactions_df = pd.DataFrame(msgs)
-
-                if not interactions_df.empty and 'sessionId' in interactions_df.columns:
-                    session_interactions = interactions_df[interactions_df['sessionId'] == sessionId]
-
-                    if not session_interactions.empty:
-                        extractor = ExtractSessionFeaturesStep(context=context)
-                        session_features_df = extractor.transform(session_interactions)
-
-                        if not session_features_df.empty:
-                            session_features = session_features_df.drop(columns=['sessionId'])
-        except Exception as e:
-            print(f"[session-features-error] {e}")
-            # continue without session features
-
-    state = StateSpace(
-        demand=demand_values,
-        prices=merged['base_price'].values,
-        session_features=session_features,
-        product_ids=merged['productId'].values,
-        elasticity=merged['elasticity'].values,
-        metadata={'sessionId': sessionId, 'experimentId': experimentId}
-    )
-
-    oracle = PredictPricesStep(context=context)
-    prices_df = oracle.transform((pricing_model, state))
-
+    # lookup pre-computed price for this product
     product_price_row = prices_df[prices_df['productId'] == productId]
     if product_price_row.empty:
-        raise HTTPException(404, f"No pricing available for product {productId}")
+        # product not in pre-computed prices, fallback to base
+        return PriceResponse(
+            productId=productId,
+            price=base_price,
+            base_price=base_price,
+            markup=1.0,
+            elasticity=None
+        )
 
-    optimal_price = float(product_price_row['predicted_price'].iloc[0])
+    optimal_price = float(product_price_row['optimal_price'].iloc[0]) # TODO: use optimal_price everywhere as  aresult
 
-    product_elasticity_row = elasticity_df[elasticity_df['productId'] == productId]
-    product_elasticity = (float(product_elasticity_row['elasticity'].iloc[0])
-                         if not product_elasticity_row.empty else None)
+    # get elasticity if available
+    product_elasticity = None
+    if elasticity_df is not None:
+        product_elasticity_row = elasticity_df[elasticity_df['productId'] == productId]
+        if not product_elasticity_row.empty:
+            product_elasticity = float(product_elasticity_row['elasticity'].iloc[0])
 
     return PriceResponse(
         productId=productId,

backend/provider/requirements.txt

@@ -12,4 +12,5 @@ graphviz
 python-dotenv>=1.0.0
 requests>=2.31.0
 typing-extensions>=4.8.0
-pickle5>=0.0.11; python_version < '3.8'
+pypickle
+pymc

backend/server/app.py

@@ -290,6 +290,7 @@ async def get_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)
 

docker-compose.yml

@@ -1,4 +1,15 @@
 services:
+
+  tensorboard:
+    image: tensorflow/tensorflow:latest
+    container_name: "PHANTOM-tensorboard"
+    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:
@@ -103,12 +114,6 @@ services:
       - _AIRFLOW_WWW_USER_PASSWORD=admin
       - REDIS_HOST=redis
       - REDIS_PORT=6379
-    volumes:
-      - ./experiments/airflow/dags:/opt/airflow/dags
-      - ./experiments/airflow/logs:/opt/airflow/logs
-      - ./experiments/airflow/plugins:/opt/airflow/plugins
-      - ./experiments/procesing:/opt/airflow/procesing
-      - ./lib:/opt/airflow/lib
     command: version
     restart: "no"
 
@@ -129,6 +134,7 @@ services:
       - AIRFLOW__CORE__LOAD_EXAMPLES=false
       - AIRFLOW__CORE__ENABLE_XCOM_PICKLING=true
       - AIRFLOW__WEBSERVER__EXPOSE_CONFIG=true
+      - AIRFLOW__WEBSERVER__SECRET_KEY=${AIRFLOW_SECRET_KEY}
       - KAFKA_HOST=kafka
       - KAFKA_PORT=29092
       - BACKEND_URL=http://backend:5000
@@ -138,12 +144,6 @@ services:
       - REDIS_PORT=6379
     ports:
       - "${AIRFLOW_WEBSERVER_PORT:-8085}:8080"
-    volumes:
-      - ./experiments/airflow/dags:/opt/airflow/dags:ro
-      - ./experiments/airflow/logs:/opt/airflow/logs
-      - ./experiments/airflow/plugins:/opt/airflow/plugins:ro
-      - ./experiments/procesing:/opt/airflow/procesing:ro
-      - ./lib:/opt/airflow/lib:ro
     command: webserver
     restart: unless-stopped
     healthcheck:
@@ -170,6 +170,7 @@ services:
       - AIRFLOW__CORE__DAGS_ARE_PAUSED_AT_CREATION=true
       - AIRFLOW__CORE__LOAD_EXAMPLES=false
       - AIRFLOW__CORE__ENABLE_XCOM_PICKLING=true
+      - AIRFLOW__WEBSERVER__SECRET_KEY=${AIRFLOW_SECRET_KEY}
       - KAFKA_HOST=kafka
       - KAFKA_PORT=29092
       - BACKEND_URL=http://backend:5000
@@ -177,12 +178,6 @@ services:
       - NEXT_PUBLIC_SUPABASE_ANON_KEY=${NEXT_PUBLIC_SUPABASE_ANON_KEY}
       - REDIS_HOST=redis
       - REDIS_PORT=6379
-    volumes:
-      - ./experiments/airflow/dags:/opt/airflow/dags:ro
-      - ./experiments/airflow/logs:/opt/airflow/logs
-      - ./experiments/airflow/plugins:/opt/airflow/plugins:ro
-      - ./experiments/procesing:/opt/airflow/procesing:ro
-      - ./lib:/opt/airflow/lib:ro
     command: scheduler
     restart: unless-stopped
     healthcheck:
@@ -208,13 +203,9 @@ services:
       - 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"
-    volumes:
-      - ./lib:/app/lib:ro
-      - ./experiments/procesing:/app/procesing:ro
-      - ./backend/provider:/app/provider:ro
-    command: python -m uvicorn provider.app:app --host 0.0.0.0 --port 5001
     restart: unless-stopped
 
 volumes:

docker/Airflow.dockerfile

@@ -21,3 +21,10 @@ RUN pip install --no-cache-dir \
 
 # 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

@@ -0,0 +1,41 @@
+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

@@ -14,11 +14,13 @@ RUN apt-get update && apt-get install -y \
 COPY backend/provider/requirements.txt /app/
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Structure will be mounted via volumes:
-# /app/lib -> lib/
-# /app/procesing -> experiments/procesing/
-# /app/provider -> backend/provider/
+# 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
 
-CMD ["python", "-m", "uvicorn", "provider.app:app", "--host", "0.0.0.0", "--port", "5001"]
+WORKDIR /app/provider
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "5001"]

docker/airflow-railway-entrypoint.sh

@@ -0,0 +1,20 @@
+#!/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/airflow/dags/elasticity_pricing_dag.py

@@ -1,346 +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,
-    CreatePriceBucketsStep,
-    AugmentEventNamesStep,
-    ChunkByTimeWindowStep,
-    ComputeDemandForChunksStep,
-    AggregatePriceLogsStep,
-    ComputeElasticityStep,
-    BuildStateSpaceStep,
-    FitPricingFunctionStep,
-    PredictPricesStep,
-)
-
-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):
-        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'),
-        window_size=dag_conf.get('window_size', '30s'),
-        n_price_buckets=dag_conf.get('n_price_buckets', 5),
-        elasticity_method=dag_conf.get('elasticity_method', 'point'),
-        min_observations=dag_conf.get('min_observations', 2),
-    )
-
-# 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 create_price_buckets(**kwargs):
-    """Task: Create price buckets for interactions"""
-    ti = kwargs['ti']
-    df = pickle.loads(ti.xcom_pull(key='interactions_raw'))
-
-    context = get_context(**kwargs)
-    step = CreatePriceBucketsStep(context)
-    df = step.transform(df)
-
-    ti.xcom_push(key='interactions_bucketed', value=pickle.dumps(df))
-    logging.info(f"Created price buckets for {len(df)} interactions")
-    return len(df)
-
-def augment_event_names(**kwargs):
-    """Task: Augment event names with product and price schema"""
-    ti = kwargs['ti']
-    df = pickle.loads(ti.xcom_pull(key='interactions_bucketed'))
-
-    context = get_context(**kwargs)
-    step = AugmentEventNamesStep(context)
-    df = step.transform(df)
-
-    ti.xcom_push(key='interactions_final', value=pickle.dumps(df))
-    logging.info(f"Augmented event names for {len(df)} interactions")
-    return len(df)
-
-def chunk_interactions(**kwargs):
-    """Task: Chunk interactions into time windows"""
-    ti = kwargs['ti']
-    df = pickle.loads(ti.xcom_pull(key='interactions_final'))
-
-    context = get_context(**kwargs)
-    step = ChunkByTimeWindowStep(context)
-    chunks = step.transform(df)
-
-    ti.xcom_push(key='interaction_chunks', value=pickle.dumps(chunks))
-    logging.info(f"Generated {len(chunks)} interaction chunks")
-    return len(chunks)
-
-def compute_demand(**kwargs):
-    """Task: Compute demand vectors for all chunks"""
-    ti = kwargs['ti']
-    chunks = pickle.loads(ti.xcom_pull(key='interaction_chunks'))
-
-    context = get_context(**kwargs)
-    step = ComputeDemandForChunksStep(context)
-    demand_chunks = step.transform(chunks)
-
-    ti.xcom_push(key='demand_chunks', value=pickle.dumps(demand_chunks))
-    logging.info(f"Computed demand for {len(demand_chunks)} chunks")
-    return len(demand_chunks)
-
-def aggregate_price_logs(**kwargs):
-    """Task: Aggregate price logs into time windows """
-    ti = kwargs['ti']
-    df = pickle.loads(ti.xcom_pull(key='price_logs_raw'))
-
-    context = get_context(**kwargs)
-    step = AggregatePriceLogsStep(context)
-    price_chunks = step.transform(df)
-
-    ti.xcom_push(key='price_chunks', value=pickle.dumps(price_chunks))
-    logging.info(f"Aggregated {len(price_chunks)} price chunks")
-    return len(price_chunks)
-
-def compute_elasticity(**kwargs):
-    """Task: Compute price elasticity from demand and price chunks"""
-    ti = kwargs['ti']
-    demand_chunks = pickle.loads(ti.xcom_pull(key='demand_chunks'))
-    price_chunks = pickle.loads(ti.xcom_pull(key='price_chunks'))
-
-    context = get_context(**kwargs)
-    step = ComputeElasticityStep(context)
-    elasticity_df = step.transform((demand_chunks, price_chunks))
-
-    ti.xcom_push(key='elasticity_results', value=pickle.dumps(elasticity_df))
-    logging.info(f"Computed elasticity for {len(elasticity_df)} products")
-
-    return {
-        'n_products': len(elasticity_df),
-        'mean_elasticity': float(elasticity_df['elasticity'].mean()),
-        'median_elasticity': float(elasticity_df['elasticity'].median())
-    }
-
-def build_state_space(**kwargs):
-    """Task: Build state space from elasticity"""
-    ti = kwargs['ti']
-    elasticity_df = pickle.loads(ti.xcom_pull(key='elasticity_results'))
-
-    context = get_context(**kwargs)
-    step = BuildStateSpaceStep(context)
-    state_space = step.transform(elasticity_df)
-
-    ti.xcom_push(key='state_space', value=pickle.dumps(state_space))
-    logging.info("Built state space for pricing")
-    return True
-
-def fit_pricing_function(**kwargs):
-    """Task: Fit pricing function using elasticity"""
-    ti = kwargs['ti']
-    elasticity_df = pickle.loads(ti.xcom_pull(key='elasticity_results'))
-
-    context = get_context(**kwargs)
-    step = FitPricingFunctionStep(context)
-    pricer = step.transform(elasticity_df)
-
-    ti.xcom_push(key='pricer', value=pickle.dumps(pricer))
-    logging.info("Fitted pricing function")
-    return True
-
-def predict_prices(**kwargs):
-    """Task: Predict optimal prices"""
-    ti = kwargs['ti']
-    pricer = pickle.loads(ti.xcom_pull(key='pricer'))
-    state_space = pickle.loads(ti.xcom_pull(key='state_space'))
-
-    context = get_context(**kwargs)
-    step = PredictPricesStep(context)
-    prices_df = step.transform((pricer, state_space))
-
-    ti.xcom_push(key='predicted_prices', value=pickle.dumps(prices_df))
-    logging.info(f"Predicted prices for {len(prices_df)} products")
-    return len(prices_df)
-
-def publish_results(**kwargs):
-    """Task: Publish elasticity and pricing results to model registry"""
-    ti = kwargs['ti']
-    elasticity_df = pickle.loads(ti.xcom_pull(key='elasticity_results'))
-    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(),
-        'window_size': dag_conf.get('window_size', '30s'),
-        'store_mode': dag_conf.get('store_mode', 'hotel'),
-        'dag_run_id': kwargs['dag_run'].run_id if kwargs.get('dag_run') else 'manual'
-    }
-
-    registry.publish_elasticity(elasticity_df, model_name='latest', metadata=metadata)
-
-    # get fitted pricer from XCom
-    pricer = pickle.loads(ti.xcom_pull(key='pricer'))
-    registry.publish_pricing_model(
-        pricer,
-        model_name='latest',
-        metadata={**metadata, 'model_type': type(pricer).__name__}
-    )
-
-    logging.info(f"Published elasticity + pricing for {len(elasticity_df)} products")
-
-    return {
-        'n_products': len(elasticity_df),
-        'registry_status': 'success',
-        'elasticity_mean': float(elasticity_df['elasticity'].mean())
-    }
-
-
-# DAG definition
-with DAG(
-    'elasticity_pricing_pipeline',
-    default_args=default_args,
-    description='E2E refactored pipeline: atomic steps with proper separation',
-    schedule_interval='*/15 * * * *',
-    start_date=days_ago(1),
-    catchup=False,
-    max_active_runs=1,
-    tags=['pricing', 'elasticity', 'research', 'refactored'],
-) 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,
-    )
-
-    # interaction processing branch
-    t_create_buckets = PythonOperator(
-        task_id='create_price_buckets',
-        python_callable=create_price_buckets,
-        provide_context=True,
-    )
-
-    t_augment_events = PythonOperator(
-        task_id='augment_event_names',
-        python_callable=augment_event_names,
-        provide_context=True,
-    )
-
-    t_chunk_interactions = PythonOperator(
-        task_id='chunk_interactions',
-        python_callable=chunk_interactions,
-        provide_context=True,
-    )
-
-    t_compute_demand = PythonOperator(
-        task_id='compute_demand',
-        python_callable=compute_demand,
-        provide_context=True,
-    )
-
-    # price processing branch (VECTORIZED)
-    t_aggregate_prices = PythonOperator(
-        task_id='aggregate_price_logs',
-        python_callable=aggregate_price_logs,
-        provide_context=True,
-    )
-
-    # convergence: compute elasticity
-    t_compute_elasticity = PythonOperator(
-        task_id='compute_elasticity',
-        python_callable=compute_elasticity,
-        provide_context=True,
-    )
-
-    # pricing tasks
-    t_build_state = PythonOperator(
-        task_id='build_state_space',
-        python_callable=build_state_space,
-        provide_context=True,
-    )
-
-    t_fit_pricer = PythonOperator(
-        task_id='fit_pricing_function',
-        python_callable=fit_pricing_function,
-        provide_context=True,
-    )
-
-    t_predict_prices = PythonOperator(
-        task_id='predict_prices',
-        python_callable=predict_prices,
-        provide_context=True,
-    )
-
-    # publish to registry
-    t_publish = PythonOperator(
-        task_id='publish_results',
-        python_callable=publish_results,
-        provide_context=True,
-    )
-
-    # dependency graph (clear atomic flow)
-    # parallel fetches
-    [t_fetch_interactions, t_fetch_price_logs]
-
-    # interaction branch: fetch -> bucket -> augment -> chunk -> demand
-    t_fetch_interactions >> t_create_buckets >> t_augment_events >> t_chunk_interactions >> t_compute_demand
-
-    # price branch: fetch -> aggregate (vectorized)
-    t_fetch_price_logs >> t_aggregate_prices
-
-    # convergence: both branches -> elasticity
-    [t_compute_demand, t_aggregate_prices] >> t_compute_elasticity
-
-    # pricing: elasticity -> state + fit -> predict -> publish
-    t_compute_elasticity >> [t_build_state, t_fit_pricer] >> t_predict_prices >> t_publish

experiments/airflow/dags/ml_training_pipeline.py

@@ -0,0 +1,115 @@
+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

@@ -0,0 +1,210 @@
+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')

experiments/airflow/dags/surge_pricing_pipeline.py

@@ -0,0 +1,237 @@
+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'})
+
+    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"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

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

experiments/ml/arch.py

@@ -0,0 +1,122 @@
+# 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

@@ -0,0 +1,103 @@
+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

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

experiments/ml/train.py

@@ -0,0 +1,137 @@
+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

@@ -12,16 +12,14 @@ from procesing.steps import (
     ComputeDemandStep,
     ComputeDemandForChunksStep,
     AggregatePriceLogsStep,
-    ComputeElasticityStep,
-    StateSpace,
-    BuildStateSpaceStep,
+    # StateSpace,
+    # BuildStateSpaceStep,
     FitPricingFunctionStep,
     PredictPricesStep,
 )
 from procesing.pipelines import (
     interaction_extraction_pipeline,
     price_extraction_pipeline,
-    elasticity_computation_pipeline,
     pricing_pipeline,
     full_pipeline,
 )
@@ -42,14 +40,12 @@ __all__ = [
     'ComputeDemandStep',
     'ComputeDemandForChunksStep',
     'AggregatePriceLogsStep',
-    'ComputeElasticityStep',
-    'StateSpace',
-    'BuildStateSpaceStep',
+    # 'StateSpace',
+    # 'BuildStateSpaceStep',
     'FitPricingFunctionStep',
     'PredictPricesStep',
     'interaction_extraction_pipeline',
     'price_extraction_pipeline',
-    'elasticity_computation_pipeline',
     'pricing_pipeline',
     'full_pipeline',
 ]

experiments/procesing/pipelines.py

@@ -2,7 +2,7 @@ from sklearn.pipeline import Pipeline
 import pandas as pd
 from procesing.context import PipelineContext
 from procesing.providers import SupabaseProvider, BackendAPIProvider
-from typing import Union
+import os
 from procesing.steps import (
     FetchInteractionsStep,
     FetchPriceLogsStep,
@@ -13,11 +13,15 @@ from procesing.steps import (
     ChunkByTimeWindowStep,
     ComputeDemandForChunksStep,
     AggregatePriceLogsStep,
-    ComputeElasticityStep,
-    BuildStateSpaceStep,
     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"""
@@ -35,104 +39,136 @@ def price_extraction_pipeline(context: PipelineContext):
     ])
 
 
-def elasticity_computation_pipeline(context: PipelineContext,
+def product_features_pipeline(context: PipelineContext,
                                     interactions_df: pd.DataFrame,
                                     price_logs_df: pd.DataFrame):
-    """
-    Compute elasticity from interactions and price logs.
-    Manual orchestration needed for branching logic.
-    """
-    # branch 1: chunk interactions and compute demand
-    chunk_step = ChunkByTimeWindowStep(context)
-    interaction_chunks = chunk_step.transform(interactions_df)
-
-    demand_step = ComputeDemandForChunksStep(context)
-    demand_chunks = demand_step.transform(interaction_chunks)
-
-    # branch 2: aggregate price logs
+    demand_step = ComputeDemandStep(context)
     price_step = AggregatePriceLogsStep(context)
-    price_chunks = price_step.transform(price_logs_df)
-
-    # convergence: compute elasticity
-    elasticity_step = ComputeElasticityStep(context)
-    elasticity_df = elasticity_step.transform((demand_chunks, price_chunks))
-
-    return elasticity_df
+    join_step = JoinProductFeaturesStep(context)
 
 
-def pricing_pipeline(context: PipelineContext, elasticity_df: pd.DataFrame):
+    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):
     """
-    Generate optimal prices from elasticity estimates.
+    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]
     """
-    # build state space
-    state_step = BuildStateSpaceStep(context)
-    state_space = state_step.transform(elasticity_df)
-
-    # fit pricing function
-    fit_step = FitPricingFunctionStep(context)
-    pricer = fit_step.transform(elasticity_df)
-
-    # predict prices
-    predict_step = PredictPricesStep(context)
-    prices_df = predict_step.transform((pricer, state_space))
-
-    return prices_df
-
-
-def full_pipeline(context: PipelineContext):
-    """
-    Complete end-to-end pipeline: data extraction -> elasticity -> pricing
-    Returns: (elasticity_df, prices_df)
-    """
-    # extract interactions
     interaction_pipe = interaction_extraction_pipeline(context)
-    interactions_df = interaction_pipe.fit_transform(None)
-
-    # extract price logs
     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())
 
-    if interactions_df.empty or price_logs_df.empty:
-        return None, None
+    # 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)
 
-    # compute elasticity
-    elasticity_df = elasticity_computation_pipeline(
-        context,
-        interactions_df,
-        price_logs_df
-    )
+    return product_features_df, optimal_prices_df
 
-    if elasticity_df is None or elasticity_df.empty:
-        return elasticity_df, None
 
-    # generate prices
-    prices_df = pricing_pipeline(context, elasticity_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
+
 
-    return elasticity_df, prices_df
 
 
 if __name__ == '__main__':
 
-    class Provider(SupabaseProvider, BackendAPIProvider):
-        def __init__(self, backend_url: str):
-            SupabaseProvider.__init__(self)
-            BackendAPIProvider.__init__(self, backend_url=backend_url)
-    # example run
-    context = PipelineContext(
-        provider=Provider(backend_url="http://localhost:5000"),
-        store_mode='hotel',
-    )
+    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()
 
-    elasticity_df, prices_df = full_pipeline(context)
+            files = {"user-interactions": "int.json", "price-logs": "price.json"}
+            file_to_read = files.get(topic, files["user-interactions"])
+            frames = []
 
-    if elasticity_df is not None and not elasticity_df.empty:
-        print("Elasticity Estimates:")
-        print(elasticity_df.to_string(index=False))
-    else:
-        print("No elasticity estimates computed.")
+            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}")
 
-    if prices_df is not None and not prices_df.empty:
-        print("\nPredicted Prices:")
-        print(prices_df.to_string(index=False))
-    else:
-        print("No prices predicted.")
+            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,6 +1,6 @@
 from procesing.pricers.base import PricingFunction
 from procesing.pricers.elasticity import ElasticityBasedPricer
-from procesing.pricers.simple import StaticPricer, RandomPricer
+from procesing.pricers.simple import StaticPricer, RandomPricer, SimpleSurgePricer
 from procesing.pricers.session_aware import SessionAwarePricer, ProductSpecificSessionPricer
 
 __all__ = [
@@ -8,6 +8,7 @@ __all__ = [
     'ElasticityBasedPricer',
     'StaticPricer',
     'RandomPricer',
+    'SimpleSurgePricer',
     'SessionAwarePricer',
     'ProductSpecificSessionPricer'
 ]

experiments/procesing/pricers/base.py

@@ -25,7 +25,7 @@ class PricingFunction(ABC):
     """
 
     @abstractmethod
-    def fit(self, historical_data: pd.DataFrame, **kwargs):
+    def fit(self, *kwargs):
         """
         Offline training on historical data.
 
@@ -36,7 +36,7 @@ class PricingFunction(ABC):
         pass
 
     @abstractmethod
-    def predict(self, state_space) -> np.ndarray:
+    def predict(self, *kwargs) -> np.ndarray:
         """
         Generate optimal prices given current state.
 

experiments/procesing/pricers/simple.py

@@ -46,3 +46,46 @@ class RandomPricer(PricingFunction):
         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)
+
+
+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
+        self.demand_history = market_data['demand'].to_numpy() if 'demand' in market_data.columns else np.zeros_like(self.base_prices)
+
+    def predict(self) -> np.ndarray:
+        """
+        Adjust prices based on current demand using surge rules.
+        state_space.demand: demand counts per product
+        state_space.prices: current prices (fallback if base_prices not set)
+        """
+        current_prices = self.base_prices if self.base_prices is not None else np.ones_like(demand_vector) * 99.99
+        demand = self.demand_history if self.demand_history is not None else np.zeros_like(current_prices)
+        new_prices = current_prices.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

experiments/procesing/providers/supabase.py

@@ -18,10 +18,17 @@ class SupabaseProvider(DataProvider):
         self.supabase: Client = create_client(self.supabase_url, self.supabase_key)
 
     def fetch_products(self, store_mode: str) -> pd.DataFrame:
-        resp = self.supabase.table(f'{store_mode}_products').select(
-            "id, room_type, date_index, metadata, availability"
-        ).execute()
-        return pd.DataFrame(resp.data) if resp.data else 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:

experiments/procesing/steps/__init__.py

@@ -1,11 +1,16 @@
 from procesing.steps.base import BaseContextStep
 from procesing.steps.fetch import FetchInteractionsStep, FetchPriceLogsStep, FetchExperimentsStep
-from procesing.steps.join import JoinExperimentsStep
-from procesing.steps.augment import CreatePriceBucketsStep, AugmentEventNamesStep
+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, ComputeElasticityStep
-from procesing.steps.pricing import StateSpace, BuildStateSpaceStep, FitPricingFunctionStep, PredictPricesStep
+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',
@@ -13,15 +18,22 @@ __all__ = [
     'FetchPriceLogsStep',
     'FetchExperimentsStep',
     'JoinExperimentsStep',
+    'JoinProductFeaturesStep',
     'CreatePriceBucketsStep',
     'AugmentEventNamesStep',
+    'AugmentInteractionsStep',
     'ChunkByTimeWindowStep',
     'ComputeDemandStep',
     'ComputeDemandForChunksStep',
     'AggregatePriceLogsStep',
-    'ComputeElasticityStep',
-    'StateSpace',
-    'BuildStateSpaceStep',
     'FitPricingFunctionStep',
     'PredictPricesStep',
+    'ExtractSessionFeaturesStep',
+    'JoinLabelsStep',
+    'ValidateDataStep',
+    'TemporalFeatureStep',
+    'BehavioralFeatureStep',
+    'ProductFeatureStep',
+    'UserAgentFeatureStep',
+    '_extract_features_for_session',
 ]

experiments/procesing/steps/augment.py

@@ -2,6 +2,93 @@ 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"""
 

experiments/procesing/steps/base.py

@@ -1,6 +1,7 @@
 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):
     """
@@ -16,7 +17,7 @@ class BaseContextStep(BaseEstimator, TransformerMixin, ABC):
         return self
 
     @abstractmethod
-    def transform(self, X):
+    def transform(self, X) -> Any:
         """Transform input using context. Must be implemented by subclass."""
         pass
 

experiments/procesing/steps/elasticity.py

@@ -7,16 +7,16 @@ class AggregatePriceLogsStep(BaseContextStep):
     """
     Aggregate price logs into time windows using VECTORIZED operations.
     Input: price_logs_df
-    Output: list of price chunks with [productId, price]
+    Output: DataFrame with columns [productId, price]
     """
 
     def transform(self, price_logs_df: pd.DataFrame):
         if price_logs_df.empty:
-            return []
+            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
+        #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]):
@@ -24,230 +24,19 @@ class AggregatePriceLogsStep(BaseContextStep):
 
         df = df.sort_values([ts_col, 'productId'])
         products = self.context.products
-        unique_products = products['id'].unique()
-
-        # VECTORIZED: group by product, resample by time window, compute mean
-        df_indexed = df.set_index(ts_col)
-
-        windowed = (
-            df_indexed
-            .groupby('productId')['price']
-            .resample(window_size)
-            .mean()
-            .reset_index()
+        # 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
         )
 
-        # forward fill missing windows (carry last known price)
-        windowed = windowed.sort_values([ts_col, 'productId'])
-        windowed['price'] = windowed.groupby('productId')['price'].ffill()
-        windowed = windowed.dropna(subset=['price'])
+        unique_products = products['id'].unique()
 
-        # group into chunks by window
-        chunks = []
-        for window_start, group in windowed.groupby(ts_col):
-            price_vector = group[['productId', 'price']].copy()
-
-            # fill missing products with last known price before this window
-            missing_products = set(unique_products) - set(price_vector['productId'])
-            if missing_products:
-                for pid in missing_products:
-                    last_price = df_indexed[
-                        (df_indexed['productId'] == pid) &
-                        (df_indexed.index < window_start)
-                    ]['price']
-
-                    if not last_price.empty:
-                        price_vector = pd.concat([
-                            price_vector,
-                            pd.DataFrame({'productId': [pid], 'price': [last_price.iloc[-1]]})
-                        ], ignore_index=True)
-
-            if not price_vector.empty:
-                chunks.append({
-                    'window_start': window_start,
-                    'window_end': window_start + pd.Timedelta(window_size),
-                    'price_vector': price_vector
-                })
-
-        return chunks
-
-
-class ComputeElasticityStep(BaseContextStep):
-    """
-    Compute price elasticity from demand and price chunks.
-    Input: (demand_chunks, price_chunks)
-    Output: elasticity_df [productId, elasticity, std_error, n_obs]
-    """
-
-    def transform(self, chunk_tuple: tuple):
-        demand_chunks, price_chunks = chunk_tuple
-
-        method = self.context.config.get('elasticity_method', 'point')
-        min_obs = self.context.config.get('min_observations', 2)
-
-        products = self.context.products
-        all_product_ids = products['id'].unique()
-
-        # align chunks by window_start
-        aligned = self._align_chunks(demand_chunks, price_chunks)
-
-        if not aligned:
-            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_timeseries(aligned)
-
-        # compute elasticity per product
-        elasticities = []
-        for pid, series in product_series.items():
-            if len(series) < min_obs:
-                elasticities.append({
-                    'productId': pid,
-                    'elasticity': 0.0,
-                    'std_error': 0.0,
-                    'n_obs': len(series)
-                })
-                continue
-
-            elast = self._compute_elasticity(series, method)
-            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 missing products with zero elasticity
-        observed_pids = set(result_df['productId'])
-        missing_pids = [p for p in all_product_ids if p 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: List[Dict], price_chunks: List[Dict]):
-        """Align demand and price chunks by window_start"""
-        price_lookup = {c['window_start']: c for c in price_chunks}
-        aligned = []
-
-        for dc in demand_chunks:
-            ws = dc['window_start']
-            if ws in price_lookup:
-                aligned.append({
-                    'window_start': ws,
-                    'window_end': dc['window_end'],
-                    'demand': dc['demand_vector'],
-                    'prices': price_lookup[ws]['price_vector']
-                })
-
-        return aligned
-
-    def _build_timeseries(self, aligned: List[Dict]):
-        """Build time series [timestamp, price, quantity] per product"""
-        series_by_product = {}
-
-        for chunk in aligned:
-            merged = chunk['demand'].merge(chunk['prices'], on='productId', how='inner')
-
-            for _, row in merged.iterrows():
-                pid = row['productId']
-                if pid not in series_by_product:
-                    series_by_product[pid] = []
-
-                series_by_product[pid].append({
-                    'timestamp': chunk['window_start'],
-                    'price': row['price'],
-                    'quantity': row['demand_score']
-                })
-
-        return series_by_product
-
-    def _compute_elasticity(self, series: List[Dict], method: str):
-        """Compute point or arc elasticity"""
-        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 method == 'point':
-            return self._point_elasticity(prices, quantities)
-        elif method == 'arc':
-            return self._arc_elasticity(prices, quantities)
-        else:
-            raise ValueError(f"Unknown elasticity method: {method}")
-
-    def _point_elasticity(self, prices: np.ndarray, quantities: np.ndarray):
-        """Point elasticity via 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)
-
-        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
-        if len(prices) > 2:
-            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))
-        else:
-            se_b = 0.0
-
-        return {'value': b, 'std_error': se_b}
-
-    def _arc_elasticity(self, prices: np.ndarray, quantities: np.ndarray):
-        """Arc elasticity: average period-over-period elasticity"""
-        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 {'value': 0.0, 'std_error': 0.0}
-
-        return {
-            'value': np.mean(elasticities),
-            'std_error': np.std(elasticities) / np.sqrt(len(elasticities))
-        }
+        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

@@ -2,7 +2,11 @@ import pandas as pd
 from procesing.steps.base import BaseContextStep
 
 class FetchInteractionsStep(BaseContextStep):
-    """Fetch raw interaction data from Kafka topic"""
+    """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')
@@ -17,19 +21,50 @@ class FetchInteractionsStep(BaseContextStep):
             )
 
         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"""
+    """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):
-        return self.context.provider.fetch_kafka_topic('price-logs')
+        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):

experiments/procesing/steps/join.py

@@ -32,3 +32,27 @@ class JoinExperimentsStep(BaseContextStep):
         })
 
         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

@@ -2,128 +2,34 @@ 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
 
-@dataclass
-class StateSpace:
-    """
-    State representation for pricing functions.
+class State:
+    def __init__(self,
+                 last_action : str,
+                 last_productId : str,
+                 last_price : float,
+                 session_features : np.ndarray
+                 ):
+        pass
 
-    Components:
-        Q_t: demand ∈ R^n (current demand signal per product)
-        P_t: prices ∈ R^n (current/base prices)
-        S_t: session_features (behavioral signals, interaction data)
-        H_t: history = {Q_{t-k}, P_{t-k}, S_{t-k}} for k in [1, history_length]
-
-    Additionally stores:
-        - product_ids: product identifiers (n,)
-        - elasticity: price elasticity per product (n,)
-        - metadata: arbitrary context (experiment_id, timestamp, etc.)
-    """
-    demand: np.ndarray  # Q_t ∈ R^n
-    prices: np.ndarray  # P_t ∈ R^n
-    session_features: pd.DataFrame = field(default_factory=pd.DataFrame)  # S_t
-
-    # augmented state components
-    product_ids: Optional[np.ndarray] = None
-    elasticity: Optional[np.ndarray] = None
-
-    # historical trajectory H_t = {(Q_{t-k}, P_{t-k}, S_{t-k})}
-    history: List[Dict[str, Any]] = field(default_factory=list)
-
-    # metadata for context
-    metadata: Dict[str, Any] = field(default_factory=dict)
-
-    def __post_init__(self):
-        """Validate dimensions."""
-        n = len(self.demand)
-        assert len(self.prices) == n, "demand and prices must have same dimension"
-        if self.elasticity is not None:
-            assert len(self.elasticity) == n, "elasticity must match dimension"
-        if self.product_ids is not None:
-            assert len(self.product_ids) == n, "product_ids must match dimension"
-
-    @property
-    def n_products(self) -> int:
-        """Number of products in state space."""
-        return len(self.demand)
-
-    def add_history(self, q: np.ndarray, p: np.ndarray, s: pd.DataFrame, max_length: int = 10):
-        """Append historical state to trajectory H_t."""
-        self.history.append({'demand': q, 'prices': p, 'session_features': s})
-        if len(self.history) > max_length:
-            self.history.pop(0)
-
-    def get_history_window(self, k: int = 5) -> List[Dict[str, Any]]:
-        """Retrieve last k historical states."""
-        return self.history[-k:] if len(self.history) >= k else self.history
-
-
-class BuildStateSpaceStep(BaseContextStep):
-    """
-    Build state space from elasticity, demand, and price data.
-
-    Input: elasticity_df [productId, elasticity, ...], optional demand_df
-    Output: StateSpace instance with Q_t, P_t, elasticity, product_ids
-    """
-
-    def transform(self, elasticity_df: pd.DataFrame, demand_df: Optional[pd.DataFrame] = None):
-        products = self.context.products
-
-        # extract base prices from product metadata
-        products_with_prices = products.copy()
-        if 'metadata' in products_with_prices.columns:
-            products_with_prices['base_price'] = products_with_prices['metadata'].apply(
-                lambda m: m.get('base_price', 0) if isinstance(m, dict) else 0
-            )
-        else:
-            products_with_prices['base_price'] = 0
-
-        # merge with elasticity
-        merged = products_with_prices[['id', 'base_price']].rename(
-            columns={'id': 'productId'}
-        ).merge(
-            elasticity_df[['productId', 'elasticity']],
-            on='productId',
-            how='left'
-        ).fillna({'elasticity': 0.0, 'base_price': 0.0})
-
-        # merge with demand if provided, else use default
-        if demand_df is not None and 'demand' in demand_df.columns:
-            merged = merged.merge(
-                demand_df[['productId', 'demand']],
-                on='productId',
-                how='left'
-            ).fillna({'demand': 0.0})
-            demand_vector = merged['demand'].values
-        else:
-            # default: uniform demand or use elasticity as proxy
-            demand_vector = np.ones(len(merged)) * 10.0
-
-        return StateSpace(
-            demand=demand_vector,
-            prices=merged['base_price'].values,
-            session_features=pd.DataFrame(),
-            product_ids=merged['productId'].values,
-            elasticity=merged['elasticity'].values,
-            metadata={'timestamp': pd.Timestamp.now().isoformat()}
-        )
 
 
 class FitPricingFunctionStep(BaseContextStep):
     """
-    Fit pricing function using elasticity data.
-    Input: elasticity_df
+    Fit pricing function using data.
+    Input: pricing_data
     Output: fitted pricing function instance
     """
 
-    def transform(self, elasticity_df: pd.DataFrame):
-        pricing_class = self.context.config.get('pricing_function_class', ElasticityBasedPricer)
+    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(elasticity_df)
+        pricer.fit(pricing_data)
 
         return pricer
 

experiments/procesing/steps/session.py

@@ -1,114 +1,261 @@
 """
-Session feature extraction for S_t component of state space.
-Computes behavioral signals from interaction data already in pipeline.
+Session feature extraction for ML training pipeline.
 """
 import pandas as pd
 import numpy as np
-from typing import Optional, Dict, Any
-from collections import Counter
+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):
     """
-    Extract session-level behavioral features from interaction logs.
-
-    Input: interactions_df (user-interactions from earlier pipeline step)
-    Output: session_features DataFrame [sessionId, feature_1, feature_2, ...]
-
-    Features computed:
-        - total_interactions: count of all events
-        - page_views, item_views, searches, cart_adds: event type counts
-        - hovers: hover event counts
-        - unique_products_viewed: distinct product IDs
-        - interaction_velocity: events per minute
-        - session_duration_sec: time span of session
-        - avg_time_between_events: mean inter-event time
-        - product_view_depth: max views for single product (attention signal)
+    Vectorized session feature extraction - replaces O(n^2) per-row loop.
+    Input: interactions_df
+    Output: session-level feature matrix
     """
 
-    def transform(self, interactions_df: pd.DataFrame) -> pd.DataFrame:
-        if interactions_df.empty:
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        if X.empty:
             return pd.DataFrame()
+        df = X.copy()
 
-        # ensure timestamp column
-        if 'ts' in interactions_df.columns:
-            interactions_df = interactions_df.copy()
-            interactions_df['ts'] = pd.to_datetime(interactions_df['ts'])
+        # 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)
 
-        # group by session and compute features
-        session_features = []
-        for session_id, session_df in interactions_df.groupby('sessionId'):
-            features = self._extract_features_for_session(session_id, session_df)
-            session_features.append(features)
+        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')
 
-        return pd.DataFrame(session_features)
+        # 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')
 
-    def _extract_features_for_session(self, session_id: str, session_df: pd.DataFrame) -> Dict[str, Any]:
-        """Compute features for single session."""
-        features = {'sessionId': session_id}
-
-        # basic counts
-        features['total_interactions'] = len(session_df)
-
-        event_counts = session_df['eventName'].value_counts().to_dict()
-        features['page_views'] = event_counts.get('page_view', 0) + event_counts.get('view_item_page', 0)
-        features['item_views'] = event_counts.get('view_item_page', 0)
-        features['searches'] = event_counts.get('search', 0)
-        features['cart_adds'] = event_counts.get('add_item_to_cart', 0)
-
-        # hover events
-        hover_events = ['hover_over_title', 'hover_over_paragraph', 'hover_over_link', 'hover_over_button']
-        features['hovers'] = sum(event_counts.get(ev, 0) for ev in hover_events)
-
-        # product-level signals
-        product_ids = session_df['productId'].dropna()
-        features['unique_products_viewed'] = product_ids.nunique()
-
-        if len(product_ids) > 0:
-            product_view_counts = Counter(product_ids)
-            features['product_view_depth'] = max(product_view_counts.values())
-        else:
-            features['product_view_depth'] = 0
-
-        # temporal features
-        if 'ts' in session_df.columns:
-            timestamps = session_df['ts'].sort_values()
-            features['session_duration_sec'] = (timestamps.max() - timestamps.min()).total_seconds()
-
-            if features['session_duration_sec'] > 0:
-                features['interaction_velocity'] = (features['total_interactions'] / features['session_duration_sec']) * 60
-            else:
-                features['interaction_velocity'] = 0.0
-
-            # inter-event timing
-            if len(timestamps) > 1:
-                time_diffs = timestamps.diff().dropna().dt.total_seconds()
-                features['avg_time_between_events'] = time_diffs.mean()
-                features['std_time_between_events'] = time_diffs.std()
-            else:
-                features['avg_time_between_events'] = 0.0
-                features['std_time_between_events'] = 0.0
-        else:
-            features['session_duration_sec'] = 0.0
-            features['interaction_velocity'] = 0.0
-            features['avg_time_between_events'] = 0.0
-            features['std_time_between_events'] = 0.0
-
-        # cart/conversion signals
-        features['cart_to_view_ratio'] = features['cart_adds'] / features['item_views'] if features['item_views'] > 0 else 0.0
-
-        return features
+        return result
 
 
-class FilterSessionInteractionsStep(BaseContextStep):
+class JoinLabelsStep(BaseContextStep):
     """
-    Filter interactions DataFrame to specific session.
-
-    Input: (interactions_df, session_id)
-    Output: interactions_df filtered to session_id
+    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, data: tuple) -> pd.DataFrame:
-        interactions_df, session_id = data
-        return interactions_df[interactions_df['sessionId'] == session_id].copy()
+    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

@@ -144,7 +144,7 @@ def mock_price_logs_raw_kafka():
                     'price': 162.47,
                     'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
                     'experimentId': '53aefd07-f66a-4d7f-ba8b-7ea1fc562d35',
-                    'storeMode': 'shop',
+                    'storeMode': 'hotel',
                     'ts': '2025-11-25T21:05:57.967Z'
                 }
             }
@@ -157,7 +157,7 @@ def mock_price_logs_raw_kafka():
                     'price': 743.49,
                     'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
                     'experimentId': '53aefd07-f66a-4d7f-ba8b-7ea1fc562d35',
-                    'storeMode': 'shop',
+                    'storeMode': 'hotel',
                     'ts': '2025-11-25T21:05:57.993Z'
                 }
             }
@@ -170,7 +170,7 @@ def mock_price_logs_raw_kafka():
                     'price': 163.87,
                     'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
                     'experimentId': '53aefd07-f66a-4d7f-ba8b-7ea1fc562d35',
-                    'storeMode': 'shop',
+                    'storeMode': 'hotel',
                     'ts': '2025-11-25T21:05:58.009Z'
                 }
             }
@@ -183,7 +183,7 @@ def mock_price_logs_raw_kafka():
                     'price': 397.46,
                     'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
                     'experimentId': '53aefd07-f66a-4d7f-ba8b-7ea1fc562d35',
-                    'storeMode': 'shop',
+                    'storeMode': 'hotel',
                     'ts': '2025-11-25T21:05:58.049Z'
                 }
             }
@@ -196,7 +196,7 @@ def mock_price_logs_raw_kafka():
                     'price': 401.66,
                     'sessionId': 'd423ce8a-77aa-4c9a-94d4-d1adddcc3472',
                     'experimentId': '53aefd07-f66a-4d7f-ba8b-7ea1fc562d35',
-                    'storeMode': 'shop',
+                    'storeMode': 'hotel',
                     'ts': '2025-11-25T21:06:08.864Z'
                 }
             }
@@ -222,7 +222,7 @@ def mock_experiments():
         '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', 'shop'],
+        'xp_market_mode': ['hotel', 'airline'],
         'xp_task_id': [None, None]
     })
 
@@ -269,3 +269,13 @@ def empty_context(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_elasticity.py

@@ -1,353 +0,0 @@
-import pytest
-import pandas as pd
-import numpy as np
-from procesing.steps import (
-    AggregatePriceLogsStep,
-    ComputeElasticityStep
-)
-
-
-def test_aggregate_price_logs_basic(pipeline_context):
-    """Test basic price aggregation into time windows"""
-    step = AggregatePriceLogsStep(pipeline_context)
-
-    # Create price logs with known window structure
-    df = pd.DataFrame({
-        'ts': pd.date_range(start='2023-01-01 10:00:00', periods=100, freq='10s'),
-        'productId': np.tile([
-            'd018efc1-25e9-4284-b276-80386e048b25',
-            '51266ddb-5b07-47b7-89ee-5b5cae94bb11',
-            '2cd7f756-fc65-4ba0-ab01-74521c1fff43'
-        ], 34)[:100],
-        'price': np.random.uniform(100, 200, 100)
-    })
-
-    result = step.transform(df)
-    assert isinstance(result, list)
-    assert len(result) > 0
-    # each chunk should have window metadata and price vector
-    for chunk in result:
-        assert 'window_start' in chunk
-        assert 'window_end' in chunk
-        assert 'price_vector' in chunk
-        assert isinstance(chunk['price_vector'], pd.DataFrame)
-        assert 'productId' in chunk['price_vector'].columns
-        assert 'price' in chunk['price_vector'].columns
-
-
-def test_aggregate_price_logs_handles_gaps(pipeline_context):
-    """Test that price aggregation forward-fills missing windows"""
-    step = AggregatePriceLogsStep(pipeline_context)
-
-    # create sparse data with gaps
-    df = pd.DataFrame({
-        'ts': pd.to_datetime([
-            '2023-01-01 10:00:00',
-            '2023-01-01 10:00:05',
-            '2023-01-01 10:02:00',  # gap of ~2 mins
-            '2023-01-01 10:02:30'
-        ]),
-        'productId': [
-            'd018efc1-25e9-4284-b276-80386e048b25',
-            'd018efc1-25e9-4284-b276-80386e048b25',
-            '51266ddb-5b07-47b7-89ee-5b5cae94bb11',
-            '51266ddb-5b07-47b7-89ee-5b5cae94bb11'
-        ],
-        'price': [100, 102, 150, 153]
-    })
-
-    result = step.transform(df)
-    assert isinstance(result, list)
-    # should have multiple windows despite gaps
-    assert len(result) >= 2
-
-
-def test_compute_elasticity_with_known_relationship(pipeline_context):
-    """Test elasticity computation with known price-demand relationship"""
-    step = ComputeElasticityStep(pipeline_context)
-
-    # simulate elastic demand: when price ↑10%, demand ↓15% (elasticity ~ -1.5)
-    base_price = 100
-    base_demand = 50
-
-    demand_chunks = [
-        {
-            'window_start': pd.Timestamp('2023-01-01 10:00:00'),
-            'window_end': pd.Timestamp('2023-01-01 10:00:30'),
-            'demand_vector': pd.DataFrame({
-                'productId': ['d018efc1-25e9-4284-b276-80386e048b25'],
-                'demand_score': [base_demand]
-            })
-        },
-        {
-            'window_start': pd.Timestamp('2023-01-01 10:00:30'),
-            'window_end': pd.Timestamp('2023-01-01 10:01:00'),
-            'demand_vector': pd.DataFrame({
-                'productId': ['d018efc1-25e9-4284-b276-80386e048b25'],
-                'demand_score': [base_demand * 0.85]  # 15% decrease
-            })
-        },
-        {
-            'window_start': pd.Timestamp('2023-01-01 10:01:00'),
-            'window_end': pd.Timestamp('2023-01-01 10:01:30'),
-            'demand_vector': pd.DataFrame({
-                'productId': ['d018efc1-25e9-4284-b276-80386e048b25'],
-                'demand_score': [base_demand * 0.70]  # further decrease
-            })
-        }
-    ]
-
-    price_chunks = [
-        {
-            'window_start': pd.Timestamp('2023-01-01 10:00:00'),
-            'window_end': pd.Timestamp('2023-01-01 10:00:30'),
-            'price_vector': pd.DataFrame({
-                'productId': ['d018efc1-25e9-4284-b276-80386e048b25'],
-                'price': [base_price]
-            })
-        },
-        {
-            'window_start': pd.Timestamp('2023-01-01 10:00:30'),
-            'window_end': pd.Timestamp('2023-01-01 10:01:00'),
-            'price_vector': pd.DataFrame({
-                'productId': ['d018efc1-25e9-4284-b276-80386e048b25'],
-                'price': [base_price * 1.10]  # 10% increase
-            })
-        },
-        {
-            'window_start': pd.Timestamp('2023-01-01 10:01:00'),
-            'window_end': pd.Timestamp('2023-01-01 10:01:30'),
-            'price_vector': pd.DataFrame({
-                'productId': ['d018efc1-25e9-4284-b276-80386e048b25'],
-                'price': [base_price * 1.20]  # 20% increase
-            })
-        }
-    ]
-
-    result = step.transform((demand_chunks, price_chunks))
-    assert isinstance(result, pd.DataFrame)
-    assert not result.empty
-    assert 'productId' in result.columns
-    assert 'elasticity' in result.columns
-    assert 'n_obs' in result.columns
-
-    # check elasticity is negative (normal good)
-    product_elast = result[result['productId'] == 'd018efc1-25e9-4284-b276-80386e048b25']
-    assert len(product_elast) == 1
-    assert product_elast.iloc[0]['elasticity'] < 0
-    # should be roughly elastic (< -1)
-    assert product_elast.iloc[0]['n_obs'] == 3
-
-
-def test_compute_elasticity_inelastic_product(pipeline_context):
-    """Test with inelastic demand: price changes, demand barely moves"""
-    step = ComputeElasticityStep(pipeline_context)
-
-    base_price = 150
-    base_demand = 40
-
-    demand_chunks = [
-        {
-            'window_start': pd.Timestamp('2023-01-01 10:00:00'),
-            'window_end': pd.Timestamp('2023-01-01 10:00:30'),
-            'demand_vector': pd.DataFrame({
-                'productId': ['51266ddb-5b07-47b7-89ee-5b5cae94bb11'],
-                'demand_score': [base_demand]
-            })
-        },
-        {
-            'window_start': pd.Timestamp('2023-01-01 10:00:30'),
-            'window_end': pd.Timestamp('2023-01-01 10:01:00'),
-            'demand_vector': pd.DataFrame({
-                'productId': ['51266ddb-5b07-47b7-89ee-5b5cae94bb11'],
-                'demand_score': [base_demand * 0.98]  # tiny 2% decrease
-            })
-        }
-    ]
-
-    price_chunks = [
-        {
-            'window_start': pd.Timestamp('2023-01-01 10:00:00'),
-            'window_end': pd.Timestamp('2023-01-01 10:00:30'),
-            'price_vector': pd.DataFrame({
-                'productId': ['51266ddb-5b07-47b7-89ee-5b5cae94bb11'],
-                'price': [base_price]
-            })
-        },
-        {
-            'window_start': pd.Timestamp('2023-01-01 10:00:30'),
-            'window_end': pd.Timestamp('2023-01-01 10:01:00'),
-            'price_vector': pd.DataFrame({
-                'productId': ['51266ddb-5b07-47b7-89ee-5b5cae94bb11'],
-                'price': [base_price * 1.20]  # 20% increase
-            })
-        }
-    ]
-
-    result = step.transform((demand_chunks, price_chunks))
-    product_elast = result[result['productId'] == '51266ddb-5b07-47b7-89ee-5b5cae94bb11']
-    assert len(product_elast) == 1
-    # inelastic: elasticity between 0 and -1
-    assert -1 < product_elast.iloc[0]['elasticity'] < 0
-
-
-def test_compute_elasticity_multiple_products(pipeline_context):
-    """Test elasticity computation across multiple products simultaneously"""
-    step = ComputeElasticityStep(pipeline_context)
-
-    products = [
-        'd018efc1-25e9-4284-b276-80386e048b25',
-        '51266ddb-5b07-47b7-89ee-5b5cae94bb11',
-        '2cd7f756-fc65-4ba0-ab01-74521c1fff43'
-    ]
-
-    # create 5 time windows with all 3 products
-    demand_chunks = []
-    price_chunks = []
-
-    for i in range(5):
-        ts = pd.Timestamp('2023-01-01 10:00:00') + pd.Timedelta(f'{i*30}s')
-
-        demand_chunks.append({
-            'window_start': ts,
-            'window_end': ts + pd.Timedelta('30s'),
-            'demand_vector': pd.DataFrame({
-                'productId': products,
-                'demand_score': [
-                    50 * (0.9 ** i),  # elastic: decreases as price rises
-                    40 * (0.98 ** i), # inelastic: barely changes
-                    30 * (0.85 ** i)  # very elastic
-                ]
-            })
-        })
-
-        price_chunks.append({
-            'window_start': ts,
-            'window_end': ts + pd.Timedelta('30s'),
-            'price_vector': pd.DataFrame({
-                'productId': products,
-                'price': [
-                    100 * (1.05 ** i),
-                    150 * (1.10 ** i),
-                    120 * (1.08 ** i)
-                ]
-            })
-        })
-
-    result = step.transform((demand_chunks, price_chunks))
-    assert isinstance(result, pd.DataFrame)
-    assert len(result) == 3  # all products should have elasticity
-    assert set(result['productId']) == set(products)
-    assert all(result['n_obs'] == 5)
-    assert all(result['elasticity'] < 0)  # all normal goods
-
-
-def test_compute_elasticity_insufficient_data(pipeline_context):
-    """Test behavior with insufficient observations"""
-    step = ComputeElasticityStep(pipeline_context)
-
-    # only 1 observation
-    demand_chunks = [{
-        'window_start': pd.Timestamp('2023-01-01 10:00:00'),
-        'window_end': pd.Timestamp('2023-01-01 10:00:30'),
-        'demand_vector': pd.DataFrame({
-            'productId': ['d018efc1-25e9-4284-b276-80386e048b25'],
-            'demand_score': [50]
-        })
-    }]
-
-    price_chunks = [{
-        'window_start': pd.Timestamp('2023-01-01 10:00:00'),
-        'window_end': pd.Timestamp('2023-01-01 10:00:30'),
-        'price_vector': pd.DataFrame({
-            'productId': ['d018efc1-25e9-4284-b276-80386e048b25'],
-            'price': [100]
-        })
-    }]
-
-    result = step.transform((demand_chunks, price_chunks))
-    # should still return result but with low n_obs
-    product_elast = result[result['productId'] == 'd018efc1-25e9-4284-b276-80386e048b25']
-    assert len(product_elast) == 1
-    assert product_elast.iloc[0]['n_obs'] == 1
-    assert product_elast.iloc[0]['elasticity'] == 0.0  # not enough data
-
-
-def test_compute_elasticity_misaligned_chunks(pipeline_context):
-    """Test with non-overlapping demand and price windows"""
-    step = ComputeElasticityStep(pipeline_context)
-
-    demand_chunks = [{
-        'window_start': pd.Timestamp('2023-01-01 10:00:00'),
-        'window_end': pd.Timestamp('2023-01-01 10:00:30'),
-        'demand_vector': pd.DataFrame({
-            'productId': ['d018efc1-25e9-4284-b276-80386e048b25'],
-            'demand_score': [50]
-        })
-    }]
-
-    price_chunks = [{
-        'window_start': pd.Timestamp('2023-01-01 11:00:00'),  # different time
-        'window_end': pd.Timestamp('2023-01-01 11:00:30'),
-        'price_vector': pd.DataFrame({
-            'productId': ['d018efc1-25e9-4284-b276-80386e048b25'],
-            'price': [100]
-        })
-    }]
-
-    result = step.transform((demand_chunks, price_chunks))
-    # should handle gracefully with no aligned data
-    assert isinstance(result, pd.DataFrame)
-    assert all(result['n_obs'] == 0)
-
-
-def test_elasticity_arc_method(pipeline_context):
-    """Test arc elasticity computation method"""
-    # configure context for arc method
-    pipeline_context.config['elasticity_method'] = 'arc'
-    step = ComputeElasticityStep(pipeline_context)
-
-    demand_chunks = [
-        {
-            'window_start': pd.Timestamp('2023-01-01 10:00:00'),
-            'window_end': pd.Timestamp('2023-01-01 10:00:30'),
-            'demand_vector': pd.DataFrame({
-                'productId': ['d018efc1-25e9-4284-b276-80386e048b25'],
-                'demand_score': [100]
-            })
-        },
-        {
-            'window_start': pd.Timestamp('2023-01-01 10:00:30'),
-            'window_end': pd.Timestamp('2023-01-01 10:01:00'),
-            'demand_vector': pd.DataFrame({
-                'productId': ['d018efc1-25e9-4284-b276-80386e048b25'],
-                'demand_score': [80]
-            })
-        }
-    ]
-
-    price_chunks = [
-        {
-            'window_start': pd.Timestamp('2023-01-01 10:00:00'),
-            'window_end': pd.Timestamp('2023-01-01 10:00:30'),
-            'price_vector': pd.DataFrame({
-                'productId': ['d018efc1-25e9-4284-b276-80386e048b25'],
-                'price': [100]
-            })
-        },
-        {
-            'window_start': pd.Timestamp('2023-01-01 10:00:30'),
-            'window_end': pd.Timestamp('2023-01-01 10:01:00'),
-            'price_vector': pd.DataFrame({
-                'productId': ['d018efc1-25e9-4284-b276-80386e048b25'],
-                'price': [110]
-            })
-        }
-    ]
-
-    result = step.transform((demand_chunks, price_chunks))
-    product_elast = result[result['productId'] == 'd018efc1-25e9-4284-b276-80386e048b25']
-    assert len(product_elast) == 1
-    assert product_elast.iloc[0]['elasticity'] < 0
-    # reset config
-    pipeline_context.config['elasticity_method'] = 'point'

lib/model_registry.py

@@ -26,6 +26,7 @@ class ModelRegistry:
         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,
@@ -130,6 +131,46 @@ class ModelRegistry:
 
         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:

requirements.txt

@@ -11,3 +11,4 @@ pytest-asyncio
 uv
 scikit-learn
 supabase
+pymc

tests/e2e/__init__.py

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

tests/e2e/fixtures.ts

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,219 @@
+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

@@ -0,0 +1,39 @@
+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 { messages = [] } = await resp.json();
+  return messages 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

@@ -0,0 +1,19 @@
+{
+  "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

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

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

@@ -0,0 +1,156 @@
+import { test, expect } from '../fixtures';
+import {
+  createFreshSession,
+  viewProductViaFlow,
+  rapidViewProductViaFlow,
+  humanLikeViewProduct,
+  getPriceFromDOM,
+  verifySessionConsistency,
+  addToCart,
+} from '../helpers/interactions';
+import { getSessionEvents } from '../helpers/kafka';
+
+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);
+    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(2500);
+
+    const events = await getSessionEvents(backendUrl, sessionId);
+    expect(events.length).toBeGreaterThanOrEqual(8);
+
+    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);
+
+    const startTime = Date.now();
+    await rapidViewProductViaFlow(page, 10, 80, STORE_TYPE);
+    const duration = (Date.now() - startTime) / 1000;
+
+    const eventsPerSec = 10 / duration;
+    expect(eventsPerSec).toBeGreaterThan(2.0);
+
+    await page.waitForTimeout(2000);
+
+    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(1500);
+    await humanLikeViewProduct(page, 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

@@ -0,0 +1,111 @@
+import { test, expect } from '../fixtures';
+import {
+  createFreshSession,
+  viewProductViaFlow,
+  rapidViewProductViaFlow,
+  getPriceFromDOM,
+  verifySessionConsistency,
+} from '../helpers/interactions';
+import { waitForInteractionEvent, countProductViews } from '../helpers/kafka';
+
+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(2000);
+
+    const evt = await waitForInteractionEvent(backendUrl, sessionId, 'view_item_page');
+    expect(evt).not.toBeNull();
+
+    const viewCount = await countProductViews(backendUrl, productId);
+    expect(viewCount).toBeGreaterThanOrEqual(5);
+
+    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(1500);
+
+    await page.goto(`/products/${productId}`);
+    await page.waitForLoadState('networkidle');
+    const surgedPrice = await getPriceFromDOM(page);
+    expect(surgedPrice).toBeGreaterThan(baselinePrice);
+
+    await page.waitForTimeout(12000);
+
+    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

@@ -0,0 +1,15 @@
+{
+  "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

@@ -10,7 +10,7 @@
       "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 +526,15 @@
       }
     },
     "node_modules/@next/env": {
-      "version": "16.0.0",
-      "resolved": "https://registry.npmjs.org/@next/env/-/env-16.0.0.tgz",
-      "integrity": "sha512-s5j2iFGp38QsG1LWRQaE2iUY3h1jc014/melHFfLdrsMJPqxqDQwWNwyQTcNoUSGZlCVZuM7t7JDMmSyRilsnA==",
+      "version": "16.0.7",
+      "resolved": "https://registry.npmjs.org/@next/env/-/env-16.0.7.tgz",
+      "integrity": "sha512-gpaNgUh5nftFKRkRQGnVi5dpcYSKGcZZkQffZ172OrG/XkrnS7UBTQ648YY+8ME92cC4IojpI2LqTC8sTDhAaw==",
       "license": "MIT"
     },
     "node_modules/@next/swc-darwin-arm64": {
-      "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==",
+      "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==",
       "cpu": [
         "arm64"
       ],
@@ -548,9 +548,9 @@
       }
     },
     "node_modules/@next/swc-darwin-x64": {
-      "version": "16.0.0",
-      "resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-16.0.0.tgz",
-      "integrity": "sha512-hB4GZnJGKa8m4efvTGNyii6qs76vTNl+3dKHTCAUaksN6KjYy4iEO3Q5ira405NW2PKb3EcqWiRaL9DrYJfMHg==",
+      "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==",
       "cpu": [
         "x64"
       ],
@@ -564,9 +564,9 @@
       }
     },
     "node_modules/@next/swc-linux-arm64-gnu": {
-      "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==",
+      "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==",
       "cpu": [
         "arm64"
       ],
@@ -580,9 +580,9 @@
       }
     },
     "node_modules/@next/swc-linux-arm64-musl": {
-      "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==",
+      "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==",
       "cpu": [
         "arm64"
       ],
@@ -596,9 +596,9 @@
       }
     },
     "node_modules/@next/swc-linux-x64-gnu": {
-      "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==",
+      "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==",
       "cpu": [
         "x64"
       ],
@@ -612,9 +612,9 @@
       }
     },
     "node_modules/@next/swc-linux-x64-musl": {
-      "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==",
+      "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==",
       "cpu": [
         "x64"
       ],
@@ -628,9 +628,9 @@
       }
     },
     "node_modules/@next/swc-win32-arm64-msvc": {
-      "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==",
+      "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==",
       "cpu": [
         "arm64"
       ],
@@ -644,9 +644,9 @@
       }
     },
     "node_modules/@next/swc-win32-x64-msvc": {
-      "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==",
+      "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==",
       "cpu": [
         "x64"
       ],
@@ -1447,12 +1447,12 @@
       }
     },
     "node_modules/next": {
-      "version": "16.0.0",
-      "resolved": "https://registry.npmjs.org/next/-/next-16.0.0.tgz",
-      "integrity": "sha512-nYohiNdxGu4OmBzggxy9rczmjIGI+TpR5vbKTsE1HqYwNm1B+YSiugSrFguX6omMOKnDHAmBPY4+8TNJk0Idyg==",
+      "version": "16.0.7",
+      "resolved": "https://registry.npmjs.org/next/-/next-16.0.7.tgz",
+      "integrity": "sha512-3mBRJyPxT4LOxAJI6IsXeFtKfiJUbjCLgvXO02fV8Wy/lIhPvP94Fe7dGhUgHXcQy4sSuYwQNcOLhIfOm0rL0A==",
       "license": "MIT",
       "dependencies": {
-        "@next/env": "16.0.0",
+        "@next/env": "16.0.7",
         "@swc/helpers": "0.5.15",
         "caniuse-lite": "^1.0.30001579",
         "postcss": "8.4.31",
@@ -1465,14 +1465,14 @@
         "node": ">=20.9.0"
       },
       "optionalDependencies": {
-        "@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",
+        "@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",
         "sharp": "^0.34.4"
       },
       "peerDependencies": {

web/package.json

@@ -10,7 +10,7 @@
   "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/airline/checkout/page.tsx

@@ -0,0 +1,11 @@
+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/api/ingest/route.ts

@@ -7,7 +7,7 @@ export async function POST(req: NextRequest) {
   try {
     const body = await req.json();
 
-    const storeMode = process.env.STORE_MODE || 'hotel';
+    const storeMode = process.env.NEXT_PUBLIC_STORE_MODE || 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,7 @@ 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 || 'shop';
+    const storeMode = process.env.NEXT_PUBLIC_STORE_MODE || process.env.STORE_MODE || 'hotel';
 
     if (!productId) {
         return NextResponse.json(

web/src/app/cart/page.tsx

@@ -96,7 +96,10 @@ export default function CartPage() {
                                 <span className="text-3xl font-bold">${total.toFixed(2)}</span>
                             </div>
                             <button
-                                onClick={() => dispatchInteraction('checkout_start', undefined, { total, itemCount })}
+                                onClick={() => {
+                                    dispatchInteraction('checkout_start', undefined, { total, itemCount });
+                                    window.location.href = '/checkout';
+                                }}
                                 className="w-full py-3 bg-blue-600 hover:bg-blue-700 text-white rounded-lg font-medium transition-colors"
                             >
                                 Proceed to Checkout

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

@@ -0,0 +1,11 @@
+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/components/feats/airline/AirlineHero.tsx

@@ -2,10 +2,20 @@
 
 import { useState, FormEvent } from 'react';
 import { useRouter } from 'next/navigation';
-import { Button, Label, Input, DateInput, RadioGroup, Dropdown, DropdownCounter } from '@/components/ui';
+import { Button, Label, DateInput, Dropdown, DropdownCounter, SelectDropdown, SelectOption } from '@/components/ui';
 import { dateToDaysFromToday } from '@/lib/airline-utils';
 
-type TripType = 'roundtrip' | 'oneway' | 'multicity';
+const CITIES: SelectOption[] = [
+  { value: 'JFK', label: 'New York (JFK)', sublabel: 'John F. Kennedy International' },
+  { value: 'LAX', label: 'Los Angeles (LAX)', sublabel: 'Los Angeles International' },
+  { value: 'ORD', label: 'Chicago (ORD)', sublabel: "O'Hare International" },
+  { value: 'MIA', label: 'Miami (MIA)', sublabel: 'Miami International' },
+  { value: 'SFO', label: 'San Francisco (SFO)', sublabel: 'San Francisco International' },
+  { value: 'SEA', label: 'Seattle (SEA)', sublabel: 'Seattle-Tacoma International' },
+  { value: 'ATL', label: 'Atlanta (ATL)', sublabel: 'Hartsfield-Jackson International' },
+  { value: 'DFW', label: 'Dallas (DFW)', sublabel: 'Dallas/Fort Worth International' },
+];
+
 
 const PlaneIcon = () => (
   <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
@@ -22,11 +32,9 @@ const LocationIcon = () => (
 
 export default function AirlineHero() {
   const router = useRouter();
-  const [tripType, setTripType] = useState<TripType>('roundtrip');
   const [origin, setOrigin] = useState('');
   const [destination, setDestination] = useState('');
   const [departDate, setDepartDate] = useState('');
-  const [returnDate, setReturnDate] = useState('');
   const [passengers, setPassengers] = useState({ adults: 1, children: 0, infants: 0 });
 
   const handleSearch = (e: FormEvent) => {
@@ -40,8 +48,6 @@ export default function AirlineHero() {
 
     if (origin) params.set('origin', origin);
     if (destination) params.set('destination', destination);
-    if (tripType !== 'roundtrip') params.set('tripType', tripType);
-    if (returnDate && tripType === 'roundtrip') params.set('returnDate', returnDate);
 
     params.set('adults', passengers.adults.toString());
     params.set('children', passengers.children.toString());
@@ -66,28 +72,15 @@ export default function AirlineHero() {
 
         <div className="search-form">
           <form onSubmit={handleSearch}>
-            <div className="mb-6">
-              <RadioGroup
-                name="tripType"
-                value={tripType}
-                onChange={setTripType}
-                options={[
-                  { value: 'roundtrip', label: 'Round-trip' },
-                  { value: 'oneway', label: 'One-way' },
-                  { value: 'multicity', label: 'Multi-city' },
-                ]}
-              />
-            </div>
-
-            <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4">
+            <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4">
               <div>
                 <Label htmlFor="origin">From</Label>
-                <Input
-                  type="text"
+                <SelectDropdown
                   id="origin"
                   value={origin}
-                  onChange={(e) => setOrigin(e.target.value)}
-                  placeholder="Airport or city"
+                  onChange={setOrigin}
+                  options={CITIES}
+                  placeholder="Select origin"
                   icon={<PlaneIcon />}
                   required
                 />
@@ -95,12 +88,12 @@ export default function AirlineHero() {
 
               <div>
                 <Label htmlFor="destination">To</Label>
-                <Input
-                  type="text"
+                <SelectDropdown
                   id="destination"
                   value={destination}
-                  onChange={(e) => setDestination(e.target.value)}
-                  placeholder="Airport or city"
+                  onChange={setDestination}
+                  options={CITIES}
+                  placeholder="Select destination"
                   icon={<LocationIcon />}
                   required
                 />
@@ -115,20 +108,6 @@ export default function AirlineHero() {
                   required
                 />
               </div>
-
-              <div>
-                <Label htmlFor="returnDate">Return</Label>
-                {tripType === 'roundtrip' ? (
-                  <DateInput
-                    id="returnDate"
-                    value={returnDate}
-                    onChange={(e) => setReturnDate(e.target.value)}
-                    required
-                  />
-                ) : (
-                  <DateInput id="returnDate" disabled />
-                )}
-              </div>
             </div>
 
             <div className="grid grid-cols-4 sm:grid-cols-3 lg:grid-cols-4 gap-4 mt-4">

web/src/components/feats/hotel/HotelCard.tsx

@@ -21,7 +21,7 @@ const AmenityIcon = ({ name }: { name: string }) => {
         breakfast: 'Breakfast',
         spa: 'Spa',
     };
-    return <span className="feature-tag">{iconMap[name.toLowerCase()] || name}</span>;
+    return <span className="feature-tag">{iconMap[name.toLowerCase()] || name.replaceAll("_", " ")}</span>;
 };
 
 export default function HotelCard({ hotel }: { hotel: Hotel }) {
@@ -47,18 +47,31 @@ export default function HotelCard({ hotel }: { hotel: Hotel }) {
         window.location.href = `/hotel/products/${hotel.id}`;
     };
 
+    const imageUrl = `https://images.unsplash.com/photo-1551882547-ff40c63fe5fa?w=400&h=300&fit=crop`;
+
     return (
         <div
             className="hotel-card cursor-pointer"
             onClick={handleCardClick}
         >
-            <div className="hotel-image bg-gray-200 flex items-center justify-center">
-                <span className="text-gray-400 text-sm">Image</span>
+            <div className="hotel-image relative overflow-hidden">
+                <img
+                    src={imageUrl}
+                    alt={hotel.name}
+                    className="w-full h-full object-cover"
+                    onError={(e) => {
+                        e.currentTarget.style.display = 'none';
+                        const fallback = e.currentTarget.nextElementSibling as HTMLElement;
+                        if (fallback) fallback.style.display = 'flex';
+                    }}
+                />
+                <div className="absolute inset-0 bg-gray-200 flex items-center justify-center" style={{ display: 'none' }}>
+                    <span className="text-gray-400 text-sm">Image</span>
+                </div>
             </div>
 
             <div className="hotel-info">
                 <h3 ref={titleRef} className="hotel-name">{hotel.name}</h3>
-                <div className="hotel-location text-sm mb-2">{hotel.roomType}</div>
                 <div className="text-sm text-[var(--text-secondary)] mb-2">
                     {hotel.checkIn} - {hotel.checkOut}
                 </div>
@@ -67,9 +80,6 @@ export default function HotelCard({ hotel }: { hotel: Hotel }) {
                         <AmenityIcon key={a} name={a} />
                     ))}
                 </div>
-                {hotel.refundable && (
-                    <div className="free-cancellation mt-2">Free cancellation</div>
-                )}
             </div>
 
             <div className="hotel-pricing">

web/src/components/feats/hotel/HotelDetails.tsx

@@ -1,6 +1,8 @@
 'use client';
 
+import { useState, useEffect } from 'react';
 import type { Hotel } from '@/lib/hotel-utils';
+import PriceDisplay from '@/components/ui/PriceDisplay';
 
 interface HotelDetailsProps {
   product: Hotel;
@@ -8,19 +10,63 @@ interface HotelDetailsProps {
   addedToCart: boolean;
 }
 
+const PriceTotalDisplay = ({ productId, nights }: { productId: string; nights: number }) => {
+  const [price, setPrice] = useState<number | null>(null);
+
+  useEffect(() => {
+    const fetchPrice = async () => {
+      try {
+        const sessionRes = await fetch('/api/session');
+        const sessionData = await sessionRes.json();
+        const params = new URLSearchParams({
+          productId,
+          sessionId: sessionData.sessionId || '',
+          experimentId: sessionData.experimentId || '',
+        });
+        const res = await fetch(`/api/pricing?${params.toString()}`);
+        const data = await res.json();
+        setPrice(data.price);
+      } catch (err) {
+        console.error('failed to fetch price for total:', err);
+      }
+    };
+    fetchPrice();
+  }, [productId]);
+
+  if (!price) return <span className="text-4xl font-bold text-gray-900">Loading...</span>;
+
+  return (
+    <span className="text-4xl font-bold text-gray-900">
+      ${(price * nights).toFixed(2)}
+    </span>
+  );
+};
+
 export default function HotelDetails({ product, onAddToCart, addedToCart }: HotelDetailsProps) {
+  const imageUrl = `https://images.unsplash.com/photo-1566073771259-6a8506099945?w=800&h=600&fit=crop`;
+
   return (
     <div className="w-full flex flex-col lg:flex-row gap-12 py-8">
-      {/* Image Section - Larger and cleaner */}
-      <div className="w-full lg:w-1/2 bg-gray-100 rounded-lg aspect-[4/3] flex items-center justify-center shrink-0">
-        <span className="text-gray-400 text-lg font-medium">Hotel Image</span>
+      <div className="w-full lg:w-1/2 rounded-lg aspect-[4/3] overflow-hidden shrink-0">
+        <img
+          src={imageUrl}
+          alt={product.name}
+          className="w-full h-full object-cover"
+          onError={(e) => {
+            e.currentTarget.style.display = 'none';
+            if (e.currentTarget.nextElementSibling) {
+              (e.currentTarget.nextElementSibling as HTMLElement).style.display = 'flex';
+            }
+          }}
+        />
+        <div className="w-full h-full bg-gray-100 rounded-lg flex items-center justify-center" style={{ display: 'none' }}>
+          <span className="text-gray-400 text-lg font-medium">Hotel Image</span>
+        </div>
       </div>
 
-      {/* Details Section - Full height/width usage */}
       <div className="flex-1 flex flex-col">
         <div className="border-b pb-6 mb-6">
           <h1 className="text-4xl font-bold text-gray-900 mb-2">{product.name}</h1>
-          <p className="text-xl text-gray-500">{product.roomType}</p>
         </div>
 
         <div className="grid grid-cols-2 gap-8 mb-8">
@@ -39,24 +85,17 @@ export default function HotelDetails({ product, onAddToCart, addedToCart }: Hote
           <div className="flex flex-wrap gap-3">
             {product.amenities.map(a => (
               <span key={a} className="px-3 py-1.5 bg-gray-100 text-gray-700 rounded-md text-sm font-medium">
-                {a}
+                  {a.replaceAll('_', ' ')}
               </span>
             ))}
           </div>
         </div>
 
-        {product.refundable && (
-          <div className="mb-8 p-4 bg-green-50 text-green-800 rounded-md inline-block">
-            <span className="font-medium">Free cancellation available</span>
-          </div>
-        )}
-
         <div className="mt-auto pt-6 border-t flex items-center justify-between">
           <div>
-            <p className="text-sm text-gray-500 mb-1">Total for {product.nights} night{product.nights > 1 ? 's' : ''}</p>
-            <div className="flex items-baseline gap-2">
-              <span className="text-4xl font-bold text-gray-900">${product.pricePerNight * product.nights}</span>
-              <span className="text-gray-500">/ {product.nights} nights</span>
+            <p className="text-sm text-gray-500 mb-1">Price per night</p>
+            <div className="mb-3">
+              <PriceDisplay productId={product.id} className="!text-2xl" />
             </div>
           </div>
 

web/src/components/ui/DateInput.tsx

@@ -1,7 +1,29 @@
-import { InputHTMLAttributes } from 'react';
+import { InputHTMLAttributes, useMemo } from 'react';
 
 interface DateInpProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type'> {}
 
 export default function DateInput({ className = '', ...props }: DateInpProps) {
-  return <input type="date" className={`input-field ${className}`.trim()} {...props} />;
+  const { minDate, maxDate } = useMemo(() => {
+    const today = new Date();
+    const tomorrow = new Date(today);
+    tomorrow.setDate(today.getDate() + 1);
+
+    const tenDaysOut = new Date(tomorrow);
+    tenDaysOut.setDate(tomorrow.getDate() + 9); // tomorrow + 9 = 10 days total
+
+    return {
+      minDate: tomorrow.toISOString().split('T')[0],
+      maxDate: tenDaysOut.toISOString().split('T')[0]
+    };
+  }, []);
+
+  return (
+    <input
+      type="date"
+      className={`input-field ${className}`.trim()}
+      min={minDate}
+      max={maxDate}
+      {...props}
+    />
+  );
 }

web/src/components/ui/Navigation.tsx

@@ -20,7 +20,7 @@ const NavLink = ({ href, children }: { href: string; children: React.ReactNode }
       href={href}
       className={`px-4 py-2 rounded-md transition-colors ${
         isActive
-          ? 'bg-[var(--accent-primary)] text-white font-semibold'
+          ? 'bg-[var(--accent-primary)] font-semibold'
           : 'hover:bg-[var(--accent-primary-light)] text-[var(--text-primary)]'
       }`}
     >
@@ -37,9 +37,7 @@ export default function Navigation() {
           <div className="flex items-center space-x-1">
             <NavLink href="/">Home</NavLink>
             <NavLink href="/products">Products</NavLink>
-            <NavLink href="/search">Search</NavLink>
             <NavLink href="/cart">Cart</NavLink>
-            <NavLink href="/checkout">Checkout</NavLink>
           </div>
         </div>
       </div>

web/src/components/ui/SelectDropdown.tsx

@@ -0,0 +1,119 @@
+'use client';
+
+import { useState, useRef, useEffect, ReactNode } from 'react';
+
+export interface SelectOption {
+  value: string;
+  label: string;
+  sublabel?: string;
+}
+
+interface SelectDropdownProps {
+  value: string;
+  onChange: (value: string) => void;
+  options: SelectOption[];
+  placeholder?: string;
+  icon?: ReactNode;
+  required?: boolean;
+  id?: string;
+}
+
+export default function SelectDropdown({
+  value,
+  onChange,
+  options,
+  placeholder = 'Select...',
+  icon,
+  required,
+  id,
+}: SelectDropdownProps) {
+  const [open, setOpen] = useState(false);
+  const [filter, setFilter] = useState('');
+  const ref = useRef<HTMLDivElement>(null);
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  useEffect(() => {
+    const handleClick = (e: MouseEvent) => {
+      if (ref.current && !ref.current.contains(e.target as Node)) {
+        setOpen(false);
+        setFilter('');
+      }
+    };
+    document.addEventListener('mousedown', handleClick);
+    return () => document.removeEventListener('mousedown', handleClick);
+  }, []);
+
+  const selectedOption = options.find((o) => o.value === value);
+  const filtered = options.filter(
+    (o) =>
+      o.label.toLowerCase().includes(filter.toLowerCase()) ||
+      o.value.toLowerCase().includes(filter.toLowerCase()) ||
+      o.sublabel?.toLowerCase().includes(filter.toLowerCase())
+  );
+
+  const handleSelect = (opt: SelectOption) => {
+    onChange(opt.value);
+    setOpen(false);
+    setFilter('');
+  };
+
+  return (
+    <div className="relative" ref={ref}>
+      <div
+        className="input-field flex items-center gap-2 cursor-pointer box-border"
+        onClick={() => {
+          setOpen(true);
+          setTimeout(() => inputRef.current?.focus(), 0);
+        }}
+      >
+        {icon && <span className="text-[var(--text-secondary)]">{icon}</span>}
+        {open ? (
+          <input
+            ref={inputRef}
+            type="text"
+            id={id}
+            value={filter}
+            onChange={(e) => setFilter(e.target.value)}
+            placeholder={placeholder}
+            className="flex-1 bg-transparent outline-none text-sm text-[var(--text-primary)]"
+          />
+        ) : (
+          <span className={`flex-1 text-sm ${value ? 'text-[var(--text-primary)]' : 'text-[var(--text-secondary)]'}`}>
+            {selectedOption ? selectedOption.label : placeholder}
+          </span>
+        )}
+        <svg
+          className={`w-4 h-4 text-[var(--text-secondary)] transition-transform ${open ? 'rotate-180' : ''}`}
+          fill="none"
+          stroke="currentColor"
+          viewBox="0 0 24 24"
+        >
+          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 9l-7 7-7-7" />
+        </svg>
+      </div>
+      {open && (
+        <div className="absolute z-20 mt-1 w-full bg-[var(--bg-primary)] border-2 border-[var(--accent-primary)] rounded-md shadow-lg max-h-60 overflow-y-auto">
+          {filtered.length === 0 ? (
+            <div className="px-4 py-3 text-sm text-[var(--text-secondary)]">No results</div>
+          ) : (
+            filtered.map((opt) => (
+              <div
+                key={opt.value}
+                onClick={() => handleSelect(opt)}
+                className={`px-4 py-2 cursor-pointer transition-colors hover:bg-[var(--accent-primary-light)] ${
+                  opt.value === value ? 'bg-[var(--accent-primary-light)]' : ''
+                }`}
+              >
+                <div className="text-sm font-medium text-[var(--text-primary)]">{opt.label}</div>
+                {opt.sublabel && <div className="text-xs text-[var(--text-secondary)]">{opt.sublabel}</div>}
+              </div>
+            ))
+          )}
+        </div>
+      )}
+      {required && !value && (
+        <input type="text" required className="sr-only" tabIndex={-1} value="" onChange={() => {}} />
+      )}
+    </div>
+  );
+}

web/src/components/ui/index.ts

@@ -5,3 +5,5 @@ export { default as DateInput } from './DateInput';
 export { default as RadioGroup } from './RadioGroup';
 export { default as Dropdown, DropdownCounter } from './Dropdown';
 export { default as Navigation } from './Navigation';
+export { default as SelectDropdown } from './SelectDropdown';
+export type { SelectOption } from './SelectDropdown';

web/src/lib/config.ts

@@ -16,7 +16,7 @@ const envSchema = z.object({
 // parse and validate env at module load, fail fast with descriptive errors
 const parseEnv = (): Env => {
     const result = envSchema.safeParse({
-        STORE_MODE: process.env.STORE_MODE,
+        STORE_MODE: process.env.NEXT_PUBLIC_STORE_MODE || process.env.STORE_MODE,
         NEXT_PUBLIC_API_BASE: process.env.NEXT_PUBLIC_API_BASE,
         NEXT_PUBLIC_APP_ENV: process.env.NEXT_PUBLIC_APP_ENV,
     });

web/src/lib/hotel-utils.ts

@@ -21,7 +21,6 @@ export interface Hotel {
   checkOut: string;
   dateIndex: number;
   amenities: string[];
-  refundable: boolean;
   pricePerNight: number;
   nights: number;
 }
@@ -30,19 +29,37 @@ const EPOCH = new Date(0);
 
 export const transformProduct = (p: HotelProduct): Hotel => {
   const { id, room_type, date_index, metadata } = p;
-  const checkIn = new Date(EPOCH.getTime() + date_index * 86400000);
+
+  // DB stores date_index as days since epoch
+  // but if value is small (<1000), treat as days from today for backward compat
+  let checkIn: Date;
+  if (date_index < 1000) {
+    // legacy: treat as offset from today
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    checkIn = new Date(today.getTime() + date_index * 86400000);
+  } else {
+    // proper: days since epoch
+    checkIn = new Date(EPOCH.getTime() + date_index * 86400000);
+  }
+
   const nights = 1;
   const checkOut = new Date(checkIn.getTime() + nights * 86400000);
 
+  const formatOpts: Intl.DateTimeFormatOptions = {
+    month: 'short',
+    day: 'numeric',
+    year: checkIn.getFullYear() !== new Date().getFullYear() ? 'numeric' : undefined
+  };
+
   return {
     id,
     name: metadata?.name || room_type,
     roomType: room_type,
-    checkIn: checkIn.toLocaleDateString('en-US', { month: 'short', day: 'numeric' }),
-    checkOut: checkOut.toLocaleDateString('en-US', { month: 'short', day: 'numeric' }),
+    checkIn: checkIn.toLocaleDateString('en-US', formatOpts),
+    checkOut: checkOut.toLocaleDateString('en-US', formatOpts),
     dateIndex: date_index,
     amenities: metadata?.amenities || [],
-    refundable: metadata?.refundable || false,
     pricePerNight: metadata?.base_price || 100,
     nights,
   };

web/src/styles/airline.css

@@ -278,6 +278,8 @@
   padding: 12px;
   transition: border-color 0.2s ease;
   width: 100%;
+  min-height: 48px;
+  box-sizing: border-box;
 }
 
 [data-mode="airline"] .input-field:focus {