churnkit 0.75.0a1__py3-none-any.whl

churnkit-0.75.0a1.data/data/share/churnkit/exploration_notebooks/01c_temporal_patterns.ipynb

@@ -0,0 +1,3305 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b520cf17",
+   "metadata": {
+    "papermill": {
+     "duration": 0.005229,
+     "end_time": "2026-02-02T13:01:08.982002",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:08.976773",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Chapter 1c: Temporal Pattern Analysis (Event Bronze Track)\n",
+    "\n",
+    "**Purpose:** Discover temporal patterns in event-level data that inform feature engineering and model design.\n",
+    "\n",
+    "**When to use this notebook:**\n",
+    "- After completing 01a and 01b (temporal deep dive and quality checks)\n",
+    "- Your dataset is EVENT_LEVEL granularity\n",
+    "- You want to understand time-based patterns before aggregation\n",
+    "\n",
+    "**What you'll learn:**\n",
+    "- How to detect long-term trends in your data\n",
+    "- How to identify seasonality patterns (weekly, monthly)\n",
+    "- How cohort analysis reveals customer lifecycle patterns\n",
+    "- How recency relates to target outcomes\n",
+    "\n",
+    "**Pattern Categories:**\n",
+    "\n",
+    "| Pattern | Description | Feature Engineering Impact |\n",
+    "|---------|-------------|---------------------------|\n",
+    "| **Trend** | Long-term direction (up/down) | Detrend features, add trend slope |\n",
+    "| **Seasonality** | Periodic patterns (weekly, monthly) | Add cyclical encodings, seasonal indicators |\n",
+    "| **Cohort Effects** | Behavior varies by join date | Add cohort features, stratify models |\n",
+    "| **Recency Effects** | Recent activity predicts outcomes | Prioritize recent time windows |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "60ff56d9",
+   "metadata": {
+    "papermill": {
+     "duration": 0.004298,
+     "end_time": "2026-02-02T13:01:08.991551",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:08.987253",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.1 Load Findings and Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bad2476c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:09.001140Z",
+     "iopub.status.busy": "2026-02-02T13:01:09.000972Z",
+     "iopub.status.idle": "2026-02-02T13:01:10.816526Z",
+     "shell.execute_reply": "2026-02-02T13:01:10.815331Z"
+    },
+    "papermill": {
+     "duration": 1.821681,
+     "end_time": "2026-02-02T13:01:10.817446",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:08.995765",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.analysis.notebook_progress import track_and_export_previous\n",
+    "track_and_export_previous(\"01c_temporal_patterns.ipynb\")\n",
+    "\n",
+    "from customer_retention.analysis.auto_explorer import ExplorationFindings\n",
+    "from customer_retention.analysis.visualization import ChartBuilder, display_figure, display_table\n",
+    "from customer_retention.core.config.column_config import ColumnType, DatasetGranularity\n",
+    "from customer_retention.stages.profiling import (\n",
+    "    TemporalPatternAnalyzer, TemporalPatternAnalysis,\n",
+    "    TrendResult, TrendDirection, SeasonalityResult, RecencyResult,\n",
+    "    TemporalFeatureAnalyzer, VelocityResult, MomentumResult,\n",
+    "    LagCorrelationResult, PredictivePowerResult, FeatureRecommendation,\n",
+    "    CategoricalTargetAnalyzer\n",
+    ")\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import plotly.graph_objects as go\n",
+    "import plotly.express as px\n",
+    "from plotly.subplots import make_subplots\n",
+    "from scipy import stats\n",
+    "from customer_retention.core.config.experiments import FINDINGS_DIR, EXPERIMENTS_DIR, OUTPUT_DIR, setup_experiments_structure\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "19b4e63f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:10.827670Z",
+     "iopub.status.busy": "2026-02-02T13:01:10.827523Z",
+     "iopub.status.idle": "2026-02-02T13:01:10.856634Z",
+     "shell.execute_reply": "2026-02-02T13:01:10.855878Z"
+    },
+    "papermill": {
+     "duration": 0.035888,
+     "end_time": "2026-02-02T13:01:10.857491",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:10.821603",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# === CONFIGURATION ===\n",
+    "from pathlib import Path\n",
+    "\n",
+    "# FINDINGS_DIR imported from customer_retention.core.config.experiments\n",
+    "\n",
+    "findings_files = [f for f in FINDINGS_DIR.glob(\"*_findings.yaml\") if \"multi_dataset\" not in f.name]\n",
+    "if not findings_files:\n",
+    "    raise FileNotFoundError(f\"No findings files found in {FINDINGS_DIR}. Run notebook 01 first.\")\n",
+    "\n",
+    "findings_files.sort(key=lambda f: f.stat().st_mtime, reverse=True)\n",
+    "FINDINGS_PATH = str(findings_files[0])\n",
+    "\n",
+    "print(f\"Using: {FINDINGS_PATH}\")\n",
+    "findings = ExplorationFindings.load(FINDINGS_PATH)\n",
+    "print(f\"Loaded findings for {findings.column_count} columns\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9dffc317",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:10.866594Z",
+     "iopub.status.busy": "2026-02-02T13:01:10.866471Z",
+     "iopub.status.idle": "2026-02-02T13:01:10.869429Z",
+     "shell.execute_reply": "2026-02-02T13:01:10.868628Z"
+    },
+    "papermill": {
+     "duration": 0.00852,
+     "end_time": "2026-02-02T13:01:10.870225",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:10.861705",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Get time series configuration\n",
+    "ts_meta = findings.time_series_metadata\n",
+    "ENTITY_COLUMN = ts_meta.entity_column if ts_meta else None\n",
+    "TIME_COLUMN = ts_meta.time_column if ts_meta else None\n",
+    "\n",
+    "print(f\"Entity column: {ENTITY_COLUMN}\")\n",
+    "print(f\"Time column: {TIME_COLUMN}\")\n",
+    "\n",
+    "# Note: Target column configuration is handled in section 1c.2 below\n",
+    "# This allows for event-level to entity-level aggregation when needed"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dd209a65",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:10.879383Z",
+     "iopub.status.busy": "2026-02-02T13:01:10.879231Z",
+     "iopub.status.idle": "2026-02-02T13:01:11.570935Z",
+     "shell.execute_reply": "2026-02-02T13:01:11.570426Z"
+    },
+    "papermill": {
+     "duration": 0.697139,
+     "end_time": "2026-02-02T13:01:11.571589",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:10.874450",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.stages.temporal import load_data_with_snapshot_preference, TEMPORAL_METADATA_COLS\n",
+    "\n",
+    "# Load source data (prefers snapshots over raw files)\n",
+    "df, data_source = load_data_with_snapshot_preference(findings, output_dir=str(FINDINGS_DIR))\n",
+    "charts = ChartBuilder()\n",
+    "\n",
+    "# Parse time column\n",
+    "df[TIME_COLUMN] = pd.to_datetime(df[TIME_COLUMN])\n",
+    "\n",
+    "print(f\"Loaded {len(df):,} rows x {len(df.columns)} columns\")\n",
+    "print(f\"Data source: {data_source}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d7bff166",
+   "metadata": {
+    "papermill": {
+     "duration": 0.003697,
+     "end_time": "2026-02-02T13:01:11.579477",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.575780",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.2 Target Column Configuration\n",
+    "\n",
+    "**📖 Event-Level vs Entity-Level Targets:**\n",
+    "\n",
+    "In time series data, targets can be defined at different granularities:\n",
+    "\n",
+    "| Target Level | Example | Usage |\n",
+    "|--------------|---------|-------|\n",
+    "| **Event-level** | \"Did this email get clicked?\" | Exists in raw data |\n",
+    "| **Entity-level** | \"Did this customer churn?\" | Need to join from entity table |\n",
+    "\n",
+    "If your target is entity-level, you may need to join it or configure it manually."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9e9c32ab",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:11.589468Z",
+     "iopub.status.busy": "2026-02-02T13:01:11.589238Z",
+     "iopub.status.idle": "2026-02-02T13:01:11.613692Z",
+     "shell.execute_reply": "2026-02-02T13:01:11.613146Z"
+    },
+    "papermill": {
+     "duration": 0.02988,
+     "end_time": "2026-02-02T13:01:11.614340",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.584460",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# === TARGET CONFIGURATION ===\n",
+    "# Override target column if needed (None = auto-detect, \"DEFER_TO_MULTI_DATASET\" = skip)\n",
+    "TARGET_COLUMN_OVERRIDE = None\n",
+    "TARGET_AGGREGATION = \"max\"  # Options: \"max\", \"mean\", \"sum\", \"last\", \"first\"\n",
+    "\n",
+    "# Detect and analyze target\n",
+    "from customer_retention.stages.profiling import (\n",
+    "    TargetLevelAnalyzer, TargetColumnDetector, AggregationMethod\n",
+    ")\n",
+    "\n",
+    "detector = TargetColumnDetector()\n",
+    "target_col, method = detector.detect(findings, df, override=TARGET_COLUMN_OVERRIDE)\n",
+    "detector.print_detection(target_col, method)\n",
+    "\n",
+    "TARGET_COLUMN = target_col\n",
+    "if TARGET_COLUMN and TARGET_COLUMN in df.columns and ENTITY_COLUMN:\n",
+    "    analyzer = TargetLevelAnalyzer()\n",
+    "    agg_method = AggregationMethod(TARGET_AGGREGATION)\n",
+    "    df, result = analyzer.aggregate_to_entity(df, TARGET_COLUMN, ENTITY_COLUMN, TIME_COLUMN, agg_method)\n",
+    "    analyzer.print_analysis(result)\n",
+    "    \n",
+    "    # Update TARGET_COLUMN to entity-level version if aggregated\n",
+    "    if result.entity_target_column:\n",
+    "        ORIGINAL_TARGET = TARGET_COLUMN\n",
+    "        TARGET_COLUMN = result.entity_target_column\n",
+    "\n",
+    "print(\"\\n\" + \"─\"*70)\n",
+    "print(f\"Final configuration:\")\n",
+    "print(f\"   ENTITY_COLUMN: {ENTITY_COLUMN}\")\n",
+    "print(f\"   TIME_COLUMN: {TIME_COLUMN}\")\n",
+    "print(f\"   TARGET_COLUMN: {TARGET_COLUMN}\")\n",
+    "print(\"─\"*70)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3fb8f311",
+   "metadata": {
+    "papermill": {
+     "duration": 0.003734,
+     "end_time": "2026-02-02T13:01:11.622150",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.618416",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.3 Aggregation Window Configuration\n",
+    "\n",
+    "**⚙️ Central Configuration for All Pattern Analysis**\n",
+    "\n",
+    "Windows are loaded from 01a findings and used consistently throughout this notebook for:\n",
+    "- Velocity analysis (shortest window)\n",
+    "- Momentum analysis (window pairs)\n",
+    "- Rolling statistics\n",
+    "- Feature engineering recommendations\n",
+    "\n",
+    "Override below if needed for your specific analysis.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0e8069c1",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:11.630971Z",
+     "iopub.status.busy": "2026-02-02T13:01:11.630852Z",
+     "iopub.status.idle": "2026-02-02T13:01:11.634574Z",
+     "shell.execute_reply": "2026-02-02T13:01:11.633796Z"
+    },
+    "papermill": {
+     "duration": 0.008656,
+     "end_time": "2026-02-02T13:01:11.635049",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.626393",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# === AGGREGATION WINDOW CONFIGURATION ===\n",
+    "# These windows were recommended by 01a based on your data's temporal coverage.\n",
+    "# They are used consistently for velocity, momentum, rolling stats, and feature engineering.\n",
+    "\n",
+    "# Override: Set to a list like [\"7d\", \"30d\", \"90d\"] to use custom windows\n",
+    "# Set to None to use 01a recommendations\n",
+    "WINDOW_OVERRIDE = None\n",
+    "\n",
+    "from customer_retention.stages.profiling import PatternAnalysisConfig\n",
+    "\n",
+    "pattern_config = PatternAnalysisConfig.from_findings(\n",
+    "    findings,\n",
+    "    target_column=TARGET_COLUMN,\n",
+    "    window_override=WINDOW_OVERRIDE,\n",
+    ")\n",
+    "\n",
+    "# Display configuration\n",
+    "print(\"=\"*70)\n",
+    "print(\"AGGREGATION WINDOW CONFIGURATION\")\n",
+    "print(\"=\"*70)\n",
+    "print(f\"\\nSource: {'Manual override' if WINDOW_OVERRIDE else '01a findings (recommended)'}\")\n",
+    "print(f\"\\nWindows: {pattern_config.aggregation_windows}\")\n",
+    "print(f\"\\nDerived settings used throughout this notebook:\")\n",
+    "print(f\"   • Velocity/Rolling window: {pattern_config.velocity_window_days} days\")\n",
+    "print(f\"   • Momentum pairs: {pattern_config.get_momentum_pairs()}\")\n",
+    "print(f\"\\n💡 To override, set WINDOW_OVERRIDE = ['7d', '30d', '90d'] above and re-run\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5070c63e",
+   "metadata": {
+    "papermill": {
+     "duration": 0.00372,
+     "end_time": "2026-02-02T13:01:11.643084",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.639364",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.4 Configure Value Column for Analysis\n",
+    "\n",
+    "Temporal patterns are analyzed on aggregated metrics. Choose the primary metric to analyze."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c6cc58ef",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:11.652297Z",
+     "iopub.status.busy": "2026-02-02T13:01:11.652178Z",
+     "iopub.status.idle": "2026-02-02T13:01:11.656977Z",
+     "shell.execute_reply": "2026-02-02T13:01:11.656499Z"
+    },
+    "papermill": {
+     "duration": 0.01026,
+     "end_time": "2026-02-02T13:01:11.657923",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.647663",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Find numeric columns for pattern analysis\n",
+    "numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()\n",
+    "numeric_cols = [c for c in numeric_cols if c not in [ENTITY_COLUMN] and c not in TEMPORAL_METADATA_COLS]\n",
+    "\n",
+    "# Separate target columns from feature columns\n",
+    "target_cols = [c for c in numeric_cols if c.lower() in ['target', 'target_entity', 'label'] \n",
+    "               or (TARGET_COLUMN and c.lower() == TARGET_COLUMN.lower())]\n",
+    "feature_cols = [c for c in numeric_cols if c not in target_cols]\n",
+    "\n",
+    "print(\"Numeric columns for pattern analysis:\")\n",
+    "print(\"\\n  FEATURE COLUMNS (can derive features from):\")\n",
+    "for col in feature_cols:\n",
+    "    print(f\"    - {col}\")\n",
+    "\n",
+    "if target_cols:\n",
+    "    print(\"\\n  TARGET COLUMNS (analysis only - never derive features):\")\n",
+    "    for col in target_cols:\n",
+    "        print(f\"    - {col} [TARGET]\")\n",
+    "\n",
+    "# Default: use event count (most common for pattern detection)\n",
+    "# Change this to analyze patterns in a specific metric\n",
+    "VALUE_COLUMN = \"_event_count\"  # Special: will aggregate event counts"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8107373c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:11.668478Z",
+     "iopub.status.busy": "2026-02-02T13:01:11.668364Z",
+     "iopub.status.idle": "2026-02-02T13:01:11.685862Z",
+     "shell.execute_reply": "2026-02-02T13:01:11.685471Z"
+    },
+    "papermill": {
+     "duration": 0.023666,
+     "end_time": "2026-02-02T13:01:11.686495",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.662829",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Prepare data for pattern analysis\n",
+    "# Aggregate to daily level for trend/seasonality detection\n",
+    "\n",
+    "if VALUE_COLUMN == \"_event_count\":\n",
+    "    # Aggregate event counts by day\n",
+    "    daily_data = df.groupby(df[TIME_COLUMN].dt.date).size().reset_index()\n",
+    "    daily_data.columns = [TIME_COLUMN, \"value\"]\n",
+    "    daily_data[TIME_COLUMN] = pd.to_datetime(daily_data[TIME_COLUMN])\n",
+    "    analysis_col = \"value\"\n",
+    "    print(\"Analyzing: Daily event counts\")\n",
+    "else:\n",
+    "    # Aggregate specific column by day\n",
+    "    daily_data = df.groupby(df[TIME_COLUMN].dt.date)[VALUE_COLUMN].sum().reset_index()\n",
+    "    daily_data.columns = [TIME_COLUMN, \"value\"]\n",
+    "    daily_data[TIME_COLUMN] = pd.to_datetime(daily_data[TIME_COLUMN])\n",
+    "    analysis_col = \"value\"\n",
+    "    print(f\"Analyzing: Daily sum of {VALUE_COLUMN}\")\n",
+    "\n",
+    "print(f\"\\nDaily data points: {len(daily_data)}\")\n",
+    "print(f\"Date range: {daily_data[TIME_COLUMN].min()} to {daily_data[TIME_COLUMN].max()}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c4b5039",
+   "metadata": {
+    "papermill": {
+     "duration": 0.003749,
+     "end_time": "2026-02-02T13:01:11.694447",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.690698",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.5 Trend Detection\n",
+    "\n",
+    "**📖 Understanding Trends:**\n",
+    "- **Increasing**: Metric growing over time (e.g., expanding customer base)\n",
+    "- **Decreasing**: Metric shrinking (e.g., declining engagement)\n",
+    "- **Stationary**: No significant trend (stable business)\n",
+    "\n",
+    "**Impact on ML:**\n",
+    "- Strong trends can cause data leakage if not handled\n",
+    "- Consider detrending or adding trend as explicit feature"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1ca5d928",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:11.703538Z",
+     "iopub.status.busy": "2026-02-02T13:01:11.703416Z",
+     "iopub.status.idle": "2026-02-02T13:01:11.742499Z",
+     "shell.execute_reply": "2026-02-02T13:01:11.741897Z"
+    },
+    "papermill": {
+     "duration": 0.04516,
+     "end_time": "2026-02-02T13:01:11.744013",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.698853",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Trend Analysis - computation and visualization\n",
+    "from customer_retention.stages.profiling import generate_trend_recommendations\n",
+    "\n",
+    "analyzer = TemporalPatternAnalyzer(time_column=TIME_COLUMN)\n",
+    "trend_result = analyzer.detect_trend(daily_data, value_column=analysis_col)\n",
+    "trend_recs = generate_trend_recommendations(trend_result, mean_value=daily_data[analysis_col].mean())\n",
+    "\n",
+    "# Visualization\n",
+    "direction_emoji = {\"increasing\": \"📈\", \"decreasing\": \"📉\", \"stable\": \"➡️\", \"unknown\": \"❓\"}\n",
+    "print(f\"Trend: {direction_emoji.get(trend_result.direction.value, '')} {trend_result.direction.value.upper()} (R²={trend_result.strength:.2f})\")\n",
+    "\n",
+    "fig = go.Figure()\n",
+    "fig.add_trace(go.Scatter(\n",
+    "    x=daily_data[TIME_COLUMN], y=daily_data[analysis_col],\n",
+    "    mode=\"lines\", name=\"Daily Values\", line=dict(color=\"steelblue\", width=1), opacity=0.7\n",
+    "))\n",
+    "\n",
+    "if trend_result.slope is not None:\n",
+    "    x_numeric = (daily_data[TIME_COLUMN] - daily_data[TIME_COLUMN].min()).dt.days\n",
+    "    y_trend = trend_result.slope * x_numeric + (daily_data[analysis_col].mean() - trend_result.slope * x_numeric.mean())\n",
+    "    trend_color = {TrendDirection.INCREASING: \"green\", TrendDirection.DECREASING: \"red\"}.get(trend_result.direction, \"gray\")\n",
+    "    fig.add_trace(go.Scatter(\n",
+    "        x=daily_data[TIME_COLUMN], y=y_trend, mode=\"lines\",\n",
+    "        name=f\"Trend ({trend_result.direction.value})\", line=dict(color=trend_color, width=3, dash=\"dash\")\n",
+    "    ))\n",
+    "\n",
+    "rolling_avg = daily_data[analysis_col].rolling(window=pattern_config.rolling_window, center=True).mean()\n",
+    "fig.add_trace(go.Scatter(\n",
+    "    x=daily_data[TIME_COLUMN], y=rolling_avg, mode=\"lines\",\n",
+    "    name=f\"{pattern_config.rolling_window}-day Rolling Avg\", line=dict(color=\"orange\", width=2)\n",
+    "))\n",
+    "\n",
+    "fig.update_layout(\n",
+    "    title=f\"Trend Analysis: {trend_result.direction.value.title()} (R²={trend_result.strength:.2f})\",\n",
+    "    xaxis_title=\"Date\", yaxis_title=\"Value\", template=\"plotly_white\", height=400,\n",
+    "    legend=dict(yanchor=\"top\", y=0.99, xanchor=\"left\", x=0.01)\n",
+    ")\n",
+    "display_figure(fig)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1c5ac864",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:11.764953Z",
+     "iopub.status.busy": "2026-02-02T13:01:11.764827Z",
+     "iopub.status.idle": "2026-02-02T13:01:11.768446Z",
+     "shell.execute_reply": "2026-02-02T13:01:11.767984Z"
+    },
+    "papermill": {
+     "duration": 0.014974,
+     "end_time": "2026-02-02T13:01:11.768924",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.753950",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Trend details and recommendations\n",
+    "print(\"📈 TREND ANALYSIS DETAILS\")\n",
+    "print(\"=\"*50)\n",
+    "print(f\"\\n   Direction: {trend_result.direction.value.upper()}\")\n",
+    "print(f\"   Strength (R²): {trend_result.strength:.3f}\")\n",
+    "print(f\"   Confidence: {trend_result.confidence.upper()}\")\n",
+    "\n",
+    "if trend_result.slope is not None:\n",
+    "    mean_val = daily_data[analysis_col].mean()\n",
+    "    daily_pct = (trend_result.slope / mean_val * 100) if mean_val else 0\n",
+    "    print(f\"   Slope: {trend_result.slope:.4f} per day ({daily_pct:+.3f}%/day)\")\n",
+    "if trend_result.p_value is not None:\n",
+    "    print(f\"   P-value: {trend_result.p_value:.4f}\")\n",
+    "\n",
+    "print(\"\\n📋 RECOMMENDATIONS:\")\n",
+    "for rec in trend_recs:\n",
+    "    priority_icon = {\"high\": \"🔴\", \"medium\": \"🟡\", \"low\": \"🟢\"}.get(rec.priority, \"⚪\")\n",
+    "    print(f\"   {priority_icon} [{rec.priority.upper()}] {rec.action}\")\n",
+    "    print(f\"      {rec.reason}\")\n",
+    "    if rec.features:\n",
+    "        print(f\"      Features: {', '.join(rec.features)}\")\n",
+    "\n",
+    "TREND_RECOMMENDATIONS = [{\"action\": r.action, \"priority\": r.priority, \"reason\": r.reason, \n",
+    "                          \"features\": r.features} for r in trend_recs]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8f32dd60",
+   "metadata": {
+    "papermill": {
+     "duration": 0.009373,
+     "end_time": "2026-02-02T13:01:11.788414",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.779041",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.6 Seasonality Detection\n",
+    "\n",
+    "**📖 Understanding Seasonality:**\n",
+    "- **Weekly** (period=7): Higher activity on certain days\n",
+    "- **Monthly** (period~30): End-of-month patterns, billing cycles\n",
+    "- **Quarterly** (period~90): Business cycles, seasonal products\n",
+    "\n",
+    "**📊 Interpreting Strength (Autocorrelation):**\n",
+    "\n",
+    "Strength measures how well values at a given lag correlate with current values.\n",
+    "\n",
+    "| Strength | Interpretation | Random Data Baseline |\n",
+    "|----------|----------------|---------------------|\n",
+    "| 0.0 | No pattern (random noise) | ≈ 0.0 |\n",
+    "| 0.1–0.3 | Weak pattern | Barely above random |\n",
+    "| 0.3–0.5 | Moderate pattern | 3–5× lift over random |\n",
+    "| 0.5–0.7 | Strong pattern | Clear repeating cycle |\n",
+    "| > 0.7 | Very strong pattern | Near-deterministic cycle |\n",
+    "\n",
+    "*Lift interpretation: A strength of 0.4 means the pattern explains ~40% of variance at that lag, vs ~0% for random data.*\n",
+    "\n",
+    "**🎯 Window-Aligned Pattern Detection:**\n",
+    "\n",
+    "We check two types of patterns:\n",
+    "- **Natural periods** (7, 14, 21, 30 days): Calendar-driven cycles\n",
+    "- **Aggregation windows** (from findings): Patterns at your selected feature windows (e.g., 180d, 365d)\n",
+    "\n",
+    "If a pattern aligns with your aggregation window, features computed over that window may capture the full cycle — consider this when interpreting aggregated features.\n",
+    "\n",
+    "**Impact on ML:**\n",
+    "- Add day-of-week, month features for detected periods\n",
+    "- Consider seasonal decomposition for strong patterns\n",
+    "- Use cyclical encodings (sin/cos) for neural networks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6daf881c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:11.808863Z",
+     "iopub.status.busy": "2026-02-02T13:01:11.808744Z",
+     "iopub.status.idle": "2026-02-02T13:01:11.863490Z",
+     "shell.execute_reply": "2026-02-02T13:01:11.862982Z"
+    },
+    "papermill": {
+     "duration": 0.06617,
+     "end_time": "2026-02-02T13:01:11.864375",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.798205",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Seasonality Analysis - Temporal Pattern Grid + Autocorrelation\n",
+    "from plotly.subplots import make_subplots\n",
+    "\n",
+    "# Prepare temporal columns\n",
+    "daily_data[\"day_of_week\"] = daily_data[TIME_COLUMN].dt.day_name()\n",
+    "daily_data[\"month\"] = daily_data[TIME_COLUMN].dt.month_name()\n",
+    "daily_data[\"quarter\"] = \"Q\" + daily_data[TIME_COLUMN].dt.quarter.astype(str)\n",
+    "daily_data[\"year\"] = daily_data[TIME_COLUMN].dt.year.astype(str)\n",
+    "\n",
+    "dow_order = [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"]\n",
+    "month_order = [\"January\", \"February\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\"]\n",
+    "daily_data[\"day_of_week\"] = pd.Categorical(daily_data[\"day_of_week\"], categories=[d for d in dow_order if d in daily_data[\"day_of_week\"].values], ordered=True)\n",
+    "daily_data[\"month\"] = pd.Categorical(daily_data[\"month\"], categories=[m for m in month_order if m in daily_data[\"month\"].values], ordered=True)\n",
+    "daily_data[\"quarter\"] = pd.Categorical(daily_data[\"quarter\"], categories=[q for q in [\"Q1\",\"Q2\",\"Q3\",\"Q4\"] if q in daily_data[\"quarter\"].values], ordered=True)\n",
+    "\n",
+    "# Compute statistics\n",
+    "dow_stats = daily_data.groupby(\"day_of_week\", observed=True)[analysis_col].agg([\"mean\", \"std\"]).reset_index()\n",
+    "monthly_stats = daily_data.groupby(\"month\", observed=True)[analysis_col].agg([\"mean\", \"std\"]).reset_index()\n",
+    "quarterly_stats = daily_data.groupby(\"quarter\", observed=True)[analysis_col].agg([\"mean\", \"std\"]).reset_index()\n",
+    "yearly_stats = daily_data.groupby(\"year\", observed=True)[analysis_col].agg([\"mean\", \"std\"]).reset_index()\n",
+    "overall_mean = daily_data[analysis_col].mean()\n",
+    "\n",
+    "# Get aggregation window lags for seasonality detection\n",
+    "window_lags = []\n",
+    "if findings.time_series_metadata and findings.time_series_metadata.suggested_aggregations:\n",
+    "    for w in findings.time_series_metadata.suggested_aggregations:\n",
+    "        if w != \"all_time\":\n",
+    "            days = int(w.replace(\"d\", \"\").replace(\"h\", \"\")) if \"d\" in w else int(w.replace(\"h\", \"\")) // 24\n",
+    "            if days > 30:\n",
+    "                window_lags.append(days)\n",
+    "\n",
+    "# Run seasonality detection\n",
+    "seasonality_results = analyzer.detect_seasonality(daily_data, value_column=analysis_col, additional_lags=window_lags)\n",
+    "\n",
+    "# Create 2x2 visualization grid\n",
+    "fig = make_subplots(rows=2, cols=2, subplot_titles=[\"Day of Week\", \"Monthly\", \"Quarterly\", \"Yearly\"],\n",
+    "                    horizontal_spacing=0.1, vertical_spacing=0.12)\n",
+    "\n",
+    "colors_dow = [\"lightgray\" if d in [\"Saturday\", \"Sunday\"] else \"steelblue\" for d in dow_stats[\"day_of_week\"]]\n",
+    "fig.add_trace(go.Bar(x=dow_stats[\"day_of_week\"], y=dow_stats[\"mean\"], error_y=dict(type=\"data\", array=dow_stats[\"std\"]),\n",
+    "                     marker_color=colors_dow, showlegend=False), row=1, col=1)\n",
+    "fig.add_trace(go.Bar(x=monthly_stats[\"month\"], y=monthly_stats[\"mean\"], error_y=dict(type=\"data\", array=monthly_stats[\"std\"]),\n",
+    "                     marker_color=\"mediumpurple\", showlegend=False), row=1, col=2)\n",
+    "fig.add_trace(go.Bar(x=quarterly_stats[\"quarter\"], y=quarterly_stats[\"mean\"], error_y=dict(type=\"data\", array=quarterly_stats[\"std\"]),\n",
+    "                     marker_color=\"teal\", showlegend=False), row=2, col=1)\n",
+    "fig.add_trace(go.Bar(x=yearly_stats[\"year\"], y=yearly_stats[\"mean\"], error_y=dict(type=\"data\", array=yearly_stats[\"std\"]),\n",
+    "                     marker_color=\"coral\", showlegend=False), row=2, col=2)\n",
+    "\n",
+    "for row, col in [(1, 1), (1, 2), (2, 1), (2, 2)]:\n",
+    "    fig.add_hline(y=overall_mean, line_dash=\"dot\", line_color=\"red\", opacity=0.5, row=row, col=col)\n",
+    "\n",
+    "fig.update_layout(title={\"text\": \"📅 Temporal Pattern Analysis<br><sup>Gray = weekends | Red line = overall mean</sup>\",\n",
+    "                         \"x\": 0.5, \"xanchor\": \"center\"}, template=\"plotly_white\", height=700)\n",
+    "fig.update_yaxes(title_text=\"Avg Value\", row=1, col=1)\n",
+    "fig.update_yaxes(title_text=\"Avg Value\", row=2, col=1)\n",
+    "display_figure(fig)\n",
+    "\n",
+    "# Combined Pattern Analysis\n",
+    "print(\"📊 SEASONALITY & TEMPORAL PATTERN ANALYSIS\")\n",
+    "print(\"=\"*60)\n",
+    "\n",
+    "# Variation analysis\n",
+    "def calc_var(stats): return (stats[\"mean\"].max() - stats[\"mean\"].min()) / overall_mean * 100 if len(stats) > 1 else 0\n",
+    "variations = {\"day_of_week\": calc_var(dow_stats), \"month\": calc_var(monthly_stats), \n",
+    "              \"quarter\": calc_var(quarterly_stats), \"year\": calc_var(yearly_stats)}\n",
+    "\n",
+    "print(f\"\\n📈 Pattern Variation (% from mean):\")\n",
+    "print(f\"   Day of Week: {variations['day_of_week']:.1f}%\")\n",
+    "print(f\"   Monthly:     {variations['month']:.1f}%\")\n",
+    "print(f\"   Quarterly:   {variations['quarter']:.1f}%\")\n",
+    "print(f\"   Yearly:      {variations['year']:.1f}%\")\n",
+    "\n",
+    "# Autocorrelation seasonality\n",
+    "print(f\"\\n🔁 Autocorrelation Seasonality (threshold > 0.3):\")\n",
+    "if seasonality_results:\n",
+    "    for sr in seasonality_results:\n",
+    "        strength = \"Strong\" if sr.strength > 0.5 else \"Moderate\"\n",
+    "        aligned = \" [aggregation window]\" if sr.period in window_lags else \"\"\n",
+    "        print(f\"   • {sr.period_name or f'{sr.period}d'}: {sr.strength:.3f} ({strength}){aligned}\")\n",
+    "else:\n",
+    "    print(\"   No significant autocorrelation patterns detected\")\n",
+    "\n",
+    "# Generate recommendations\n",
+    "SEASONALITY_RECOMMENDATIONS = []\n",
+    "for pattern, var_pct in variations.items():\n",
+    "    priority = \"high\" if var_pct > 20 else \"medium\" if var_pct > 10 else \"low\"\n",
+    "    \n",
+    "    if pattern == \"day_of_week\" and var_pct > 10:\n",
+    "        SEASONALITY_RECOMMENDATIONS.append({\"pattern\": pattern, \"variation\": var_pct, \"priority\": priority,\n",
+    "            \"features\": [\"dow_sin\", \"dow_cos\", \"is_weekend\"], \"reason\": f\"{var_pct:.1f}% variation - add cyclical encoding\"})\n",
+    "    elif pattern == \"month\" and var_pct > 10:\n",
+    "        SEASONALITY_RECOMMENDATIONS.append({\"pattern\": pattern, \"variation\": var_pct, \"priority\": priority,\n",
+    "            \"features\": [\"month_sin\", \"month_cos\"], \"reason\": f\"{var_pct:.1f}% variation - add cyclical encoding\"})\n",
+    "    elif pattern == \"quarter\" and var_pct > 10:\n",
+    "        SEASONALITY_RECOMMENDATIONS.append({\"pattern\": pattern, \"variation\": var_pct, \"priority\": priority,\n",
+    "            \"features\": [\"quarter_sin\", \"quarter_cos\"], \"reason\": f\"{var_pct:.1f}% variation - add cyclical encoding\"})\n",
+    "    elif pattern == \"year\" and var_pct > 20:\n",
+    "        trend_explains = 'trend_result' in dir() and trend_result.strength > 0.3 and trend_result.has_direction\n",
+    "        if trend_explains:\n",
+    "            SEASONALITY_RECOMMENDATIONS.append({\"pattern\": pattern, \"variation\": var_pct, \"priority\": priority,\n",
+    "                \"features\": [\"year_trend\"], \"reason\": f\"{var_pct:.1f}% variation aligned with trend\"})\n",
+    "        else:\n",
+    "            SEASONALITY_RECOMMENDATIONS.append({\"pattern\": pattern, \"variation\": var_pct, \"priority\": priority,\n",
+    "                \"features\": [\"year_categorical\"], \"reason\": f\"{var_pct:.1f}% variation but NO linear trend - use categorical\",\n",
+    "                \"warning\": \"Stepwise changes or non-linear cycles suspected\"})\n",
+    "\n",
+    "# For autocorrelation-detected patterns\n",
+    "for sr in seasonality_results:\n",
+    "    if sr.period in [7, 14, 21, 30] and sr.strength > 0.3:\n",
+    "        SEASONALITY_RECOMMENDATIONS.append({\"pattern\": f\"{sr.period}d_cycle\", \"variation\": sr.strength * 100, \n",
+    "            \"priority\": \"medium\", \"features\": [f\"lag_{sr.period}d_ratio\"], \n",
+    "            \"reason\": f\"Autocorrelation {sr.strength:.2f} at {sr.period}d - add lag ratio feature\"})\n",
+    "\n",
+    "print(\"\\n\" + \"─\"*60)\n",
+    "print(\"📋 SEASONALITY RECOMMENDATIONS:\")\n",
+    "print(\"─\"*60)\n",
+    "if SEASONALITY_RECOMMENDATIONS:\n",
+    "    for rec in SEASONALITY_RECOMMENDATIONS:\n",
+    "        icon = {\"high\": \"🔴\", \"medium\": \"🟡\", \"low\": \"🟢\"}.get(rec[\"priority\"], \"⚪\")\n",
+    "        print(f\"\\n{icon} [{rec['priority'].upper()}] {rec['pattern'].replace('_', ' ').title()}\")\n",
+    "        print(f\"   {rec['reason']}\")\n",
+    "        if rec.get(\"warning\"):\n",
+    "            print(f\"   ⚠️  {rec['warning']}\")\n",
+    "        if rec.get(\"features\"):\n",
+    "            print(f\"   → Features: {', '.join(rec['features'])}\")\n",
+    "else:\n",
+    "    print(\"\\n   No significant patterns - seasonal features unlikely to help\")\n",
+    "\n",
+    "TEMPORAL_PATTERN_RECOMMENDATIONS = SEASONALITY_RECOMMENDATIONS"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "beb4cf26",
+   "metadata": {
+    "papermill": {
+     "duration": 0.012246,
+     "end_time": "2026-02-02T13:01:11.888736",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.876490",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.7 Cohort Analysis\n",
+    "\n",
+    "**📖 Understanding Cohorts:**\n",
+    "- Group entities by when they first appeared (signup cohort)\n",
+    "- Compare behavior across cohorts\n",
+    "- Identify if acquisition quality changed over time\n",
+    "\n",
+    "**Cohorts vs Segments:** Cohorts are time-bound groups (when entities joined), while segments are attribute-based groups (what entities are). Cohorts are fixed at signup; segments can change over time.\n",
+    "\n",
+    "**Other time-based cohort ideas:**\n",
+    "- First purchase date (not just signup)\n",
+    "- First feature usage (e.g., \"first mobile app use\")\n",
+    "- Campaign/promotion exposure date\n",
+    "- Onboarding completion date\n",
+    "- Product version or pricing plan at signup time\n",
+    "\n",
+    "These can be derived as custom features if your data contains the relevant timestamps."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "97db3bdb",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:11.914469Z",
+     "iopub.status.busy": "2026-02-02T13:01:11.914351Z",
+     "iopub.status.idle": "2026-02-02T13:01:11.976413Z",
+     "shell.execute_reply": "2026-02-02T13:01:11.975921Z"
+    },
+    "papermill": {
+     "duration": 0.076105,
+     "end_time": "2026-02-02T13:01:11.977184",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.901079",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Cohort Analysis - computation and visualization\n",
+    "from customer_retention.stages.profiling import analyze_cohort_distribution, generate_cohort_recommendations\n",
+    "\n",
+    "COHORT_RECOMMENDATIONS = []\n",
+    "cohort_dist = None\n",
+    "\n",
+    "if ENTITY_COLUMN:\n",
+    "    first_events = df.groupby(ENTITY_COLUMN)[TIME_COLUMN].min().reset_index()\n",
+    "    first_events.columns = [ENTITY_COLUMN, \"first_event\"]\n",
+    "    cohort_dist = analyze_cohort_distribution(first_events, \"first_event\")\n",
+    "    \n",
+    "    cohort_result = analyzer.analyze_cohorts(\n",
+    "        df, entity_column=ENTITY_COLUMN, cohort_column=TIME_COLUMN,\n",
+    "        target_column=TARGET_COLUMN, period=\"M\"\n",
+    "    )\n",
+    "    \n",
+    "    print(\"👥 COHORT ANALYSIS\")\n",
+    "    print(\"=\"*50)\n",
+    "    print(f\"\\nEntity Onboarding: {cohort_dist.dominant_pct:.0f}% in {cohort_dist.dominant_year}, {cohort_dist.num_years} years total\")\n",
+    "    \n",
+    "    if len(cohort_result) > 0:\n",
+    "        cohort_sorted = cohort_result.sort_values(\"cohort\")\n",
+    "        has_retention = \"retention_rate\" in cohort_sorted.columns\n",
+    "        \n",
+    "        fig = make_subplots(specs=[[{\"secondary_y\": True}]]) if has_retention else go.Figure()\n",
+    "        \n",
+    "        fig.add_trace(go.Bar(\n",
+    "            x=cohort_sorted[\"cohort\"].astype(str), y=cohort_sorted[\"entity_count\"],\n",
+    "            name=\"Entities (sign-up cohort)\", marker_color=\"steelblue\", opacity=0.7\n",
+    "        ), secondary_y=False) if has_retention else fig.add_trace(go.Bar(\n",
+    "            x=cohort_sorted[\"cohort\"].astype(str), y=cohort_sorted[\"entity_count\"],\n",
+    "            name=\"Entities (sign-up cohort)\", marker_color=\"steelblue\", opacity=0.7\n",
+    "        ))\n",
+    "        \n",
+    "        if has_retention:\n",
+    "            fig.add_trace(go.Scatter(\n",
+    "                x=cohort_sorted[\"cohort\"].astype(str), y=cohort_sorted[\"retention_rate\"] * 100,\n",
+    "                mode=\"lines+markers\", name=\"Retention Rate %\",\n",
+    "                line=dict(color=\"coral\", width=3), marker=dict(size=8)\n",
+    "            ), secondary_y=True)\n",
+    "            fig.update_yaxes(title_text=\"Retention Rate %\", secondary_y=True)\n",
+    "        \n",
+    "        fig.update_layout(\n",
+    "            title=\"Cohort Analysis: Entity Count by Sign-up Month (cohort = first event period)\",\n",
+    "            xaxis_title=\"Cohort (First Event Month)\", template=\"plotly_white\", height=400\n",
+    "        )\n",
+    "        fig.update_yaxes(title_text=\"Entity Count\", secondary_y=False) if has_retention else fig.update_yaxes(title_text=\"Entity Count\")\n",
+    "        display_figure(fig)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "95eeb3e7",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:12.006223Z",
+     "iopub.status.busy": "2026-02-02T13:01:12.006075Z",
+     "iopub.status.idle": "2026-02-02T13:01:12.013450Z",
+     "shell.execute_reply": "2026-02-02T13:01:12.012005Z"
+    },
+    "papermill": {
+     "duration": 0.022947,
+     "end_time": "2026-02-02T13:01:12.014216",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:11.991269",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Cohort details and recommendations\n",
+    "if ENTITY_COLUMN and cohort_dist:\n",
+    "    retention_var = None\n",
+    "    if \"retention_rate\" in cohort_result.columns:\n",
+    "        retention_var = cohort_result[\"retention_rate\"].max() - cohort_result[\"retention_rate\"].min()\n",
+    "    \n",
+    "    cohort_recs = generate_cohort_recommendations(cohort_dist, retention_variation=retention_var)\n",
+    "    \n",
+    "    print(\"📊 COHORT DETAILS\")\n",
+    "    print(\"=\"*50)\n",
+    "    print(f\"\\nEntity Onboarding Distribution by Year:\")\n",
+    "    print(\"─\" * 40)\n",
+    "    for year, count in sorted(cohort_dist.year_counts.items()):\n",
+    "        pct = count / cohort_dist.total_entities * 100\n",
+    "        bar = \"█\" * int(pct / 3)\n",
+    "        print(f\"   {year}: {count:>5,} entities ({pct:>5.1f}%) {bar}\")\n",
+    "    \n",
+    "    print(f\"\\n   Total entities: {cohort_dist.total_entities:,}\")\n",
+    "    print(f\"   Data spans: {df[TIME_COLUMN].min().date()} to {df[TIME_COLUMN].max().date()}\")\n",
+    "    \n",
+    "    print(\"\\n📋 RECOMMENDATIONS:\")\n",
+    "    for rec in cohort_recs:\n",
+    "        priority_icon = {\"high\": \"🔴\", \"medium\": \"🟡\", \"low\": \"🟢\"}.get(rec.priority, \"⚪\")\n",
+    "        print(f\"   {priority_icon} [{rec.priority.upper()}] {rec.action}\")\n",
+    "        print(f\"      {rec.reason}\")\n",
+    "        if rec.features:\n",
+    "            print(f\"      Features: {', '.join(rec.features)}\")\n",
+    "        if rec.insight:\n",
+    "            print(f\"      💡 {rec.insight}\")\n",
+    "    \n",
+    "    COHORT_RECOMMENDATIONS = [{\"action\": r.action, \"priority\": r.priority, \"reason\": r.reason,\n",
+    "                               \"features\": getattr(r, 'features', []), \n",
+    "                               \"insight\": getattr(r, 'insight', None)} for r in cohort_recs]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0f0f0294",
+   "metadata": {
+    "papermill": {
+     "duration": 0.037269,
+     "end_time": "2026-02-02T13:01:12.065822",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:12.028553",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.8 Correlation Matrix Analysis\n",
+    "\n",
+    "**📊 Understanding Feature Relationships:**\n",
+    "\n",
+    "This section shows feature-feature relationships in two complementary ways:\n",
+    "- **Correlation Matrix**: Numerical summary (r values)\n",
+    "- **Scatter Matrix**: Visual relationships with cohort overlay\n",
+    "\n",
+    "| Correlation | Interpretation | Action |\n",
+    "|-------------|----------------|--------|\n",
+    "| `\\|r\\|` > 0.9 | Near-duplicate features | Remove one |\n",
+    "| `\\|r\\|` > 0.7 | Strong relationship | Consider combining |\n",
+    "| `\\|r\\|` < 0.3 | Weak/no relationship | Independent features |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "65121cc6",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:12.100581Z",
+     "iopub.status.busy": "2026-02-02T13:01:12.100463Z",
+     "iopub.status.idle": "2026-02-02T13:01:12.118903Z",
+     "shell.execute_reply": "2026-02-02T13:01:12.118553Z"
+    },
+    "papermill": {
+     "duration": 0.034505,
+     "end_time": "2026-02-02T13:01:12.119780",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:12.085275",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Correlation matrix for numeric event attributes\n",
+    "# Define analysis columns - exclude entity, time, target, and temporal metadata\n",
+    "numeric_event_cols = [c for c in df.select_dtypes(include=[np.number]).columns \n",
+    "                      if c not in [ENTITY_COLUMN, TIME_COLUMN, TARGET_COLUMN]\n",
+    "                      and c not in TEMPORAL_METADATA_COLS\n",
+    "                      and 'target' not in c.lower()]\n",
+    "\n",
+    "excluded_cols = [c for c in df.select_dtypes(include=[np.number]).columns if c not in numeric_event_cols]\n",
+    "\n",
+    "print(f\"Correlation Analysis (event-level, n={len(df):,})\")\n",
+    "print(f\"  Included ({len(numeric_event_cols)}): {numeric_event_cols}\")\n",
+    "print(f\"  Excluded ({len(excluded_cols)}): {excluded_cols}\")\n",
+    "\n",
+    "if len(numeric_event_cols) >= 2:\n",
+    "    corr_matrix = df[numeric_event_cols].corr()\n",
+    "    fig = charts.heatmap(\n",
+    "        corr_matrix.values, x_labels=numeric_event_cols, y_labels=numeric_event_cols,\n",
+    "        title=\"Feature Correlation Matrix (Event-Level)\"\n",
+    "    )\n",
+    "    display_figure(fig)\n",
+    "    \n",
+    "    # High correlation pairs\n",
+    "    high_corr = []\n",
+    "    for i in range(len(numeric_event_cols)):\n",
+    "        for j in range(i+1, len(numeric_event_cols)):\n",
+    "            corr_val = corr_matrix.iloc[i, j]\n",
+    "            if abs(corr_val) > 0.7:\n",
+    "                high_corr.append((numeric_event_cols[i], numeric_event_cols[j], corr_val))\n",
+    "    \n",
+    "    if high_corr:\n",
+    "        print(\"\\n⚠️ Highly correlated pairs (|r| > 0.7):\")\n",
+    "        for c1, c2, r in sorted(high_corr, key=lambda x: abs(x[2]), reverse=True)[:5]:\n",
+    "            print(f\"   {c1} ↔ {c2}: r={r:.2f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1b884449",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:12.164433Z",
+     "iopub.status.busy": "2026-02-02T13:01:12.164116Z",
+     "iopub.status.idle": "2026-02-02T13:01:12.287514Z",
+     "shell.execute_reply": "2026-02-02T13:01:12.287030Z"
+    },
+    "papermill": {
+     "duration": 0.153277,
+     "end_time": "2026-02-02T13:01:12.288406",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:12.135129",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Scatter Matrix: Entity-level features (mixed aggregation types)\n",
+    "if len(numeric_event_cols) >= 2 and ENTITY_COLUMN and TARGET_COLUMN and TARGET_COLUMN in df.columns:\n",
+    "    # Create entity-level aggregations (mean, sum, std) - like original\n",
+    "    agg_dict = {col: ['mean', 'sum', 'std'] for col in numeric_event_cols}\n",
+    "    entity_aggs = df.groupby(ENTITY_COLUMN).agg(agg_dict)\n",
+    "    entity_aggs.columns = ['_'.join(col).strip() for col in entity_aggs.columns]\n",
+    "    entity_aggs = entity_aggs.reset_index()\n",
+    "    \n",
+    "    # Get all numeric aggregated columns\n",
+    "    all_agg_cols = [c for c in entity_aggs.columns if c != ENTITY_COLUMN]\n",
+    "    \n",
+    "    # Select top 4 by variance across ALL aggregation types\n",
+    "    variances = entity_aggs[all_agg_cols].var().sort_values(ascending=False)\n",
+    "    top_features = variances.head(4).index.tolist()\n",
+    "    \n",
+    "    # Sample if needed\n",
+    "    sample_size = min(1000, len(entity_aggs))\n",
+    "    scatter_sample = entity_aggs.sample(sample_size, random_state=42) if sample_size < len(entity_aggs) else entity_aggs\n",
+    "    \n",
+    "    print(f\"Scatter Matrix (n={len(scatter_sample):,} entities)\")\n",
+    "    print(f\"  Total aggregated features: {len(all_agg_cols)}\")\n",
+    "    print(f\"  Selected (top 4 by variance): {top_features}\")\n",
+    "    \n",
+    "    # Short labels for x-axis (no line breaks)\n",
+    "    short_labels = [f.replace('_', ' ') for f in top_features]\n",
+    "    \n",
+    "    scatter_data = scatter_sample[top_features].copy()\n",
+    "    scatter_data.columns = short_labels\n",
+    "    \n",
+    "    fig = charts.scatter_matrix(scatter_data, height=500)\n",
+    "    fig.update_traces(marker=dict(opacity=0.5, size=4))\n",
+    "    \n",
+    "    # Update y-axis labels to be multirow, keep x-axis single row\n",
+    "    n_features = len(short_labels)\n",
+    "    for i in range(n_features):\n",
+    "        # Y-axis: multirow\n",
+    "        yaxis_name = f'yaxis{i+1}' if i > 0 else 'yaxis'\n",
+    "        y_label = top_features[i].replace('_', '<br>')\n",
+    "        fig.update_layout(**{yaxis_name: dict(title=dict(text=y_label))})\n",
+    "        \n",
+    "        # X-axis: single row (spaces instead of underscores)\n",
+    "        xaxis_name = f'xaxis{i+1}' if i > 0 else 'xaxis'\n",
+    "        x_label = top_features[i].replace('_', ' ')\n",
+    "        fig.update_layout(**{xaxis_name: dict(title=dict(text=x_label))})\n",
+    "    \n",
+    "    fig.update_layout(\n",
+    "        title=\"Feature Relationships (Top 4 by Variance)\",\n",
+    "        margin=dict(l=100, r=20, t=50, b=60)\n",
+    "    )\n",
+    "    \n",
+    "    display_figure(fig)\n",
+    "    \n",
+    "    print(\"\\n📈 Scatter Matrix Insights:\")\n",
+    "    print(\"   • Different aggregation types create different patterns/bands\")\n",
+    "    print(\"   • sum features often show exponential-like distributions\")\n",
+    "    print(\"   • std features reveal variability clusters\")\n",
+    "    print(\"   • mean features show central tendency patterns\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7e6d123b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:12.323675Z",
+     "iopub.status.busy": "2026-02-02T13:01:12.323562Z",
+     "iopub.status.idle": "2026-02-02T13:01:12.326223Z",
+     "shell.execute_reply": "2026-02-02T13:01:12.325830Z"
+    },
+    "papermill": {
+     "duration": 0.021938,
+     "end_time": "2026-02-02T13:01:12.326774",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:12.304836",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Correlation Analysis: Interpretation\n",
+    "print(\"\\n\" + \"=\"*70)\n",
+    "print(\"CORRELATION ANALYSIS SUMMARY\")\n",
+    "print(\"=\"*70)\n",
+    "\n",
+    "if 'high_corr' in dir() and high_corr:\n",
+    "    print(f\"\\n📊 Found {len(high_corr)} highly correlated pairs (|r| > 0.7):\")\n",
+    "    for c1, c2, r in sorted(high_corr, key=lambda x: abs(x[2]), reverse=True)[:5]:\n",
+    "        print(f\"   • {c1} ↔ {c2}: r={r:.2f}\")\n",
+    "    print(\"\\n💡 RECOMMENDATIONS:\")\n",
+    "    print(\"   → Remove redundant features to reduce multicollinearity\")\n",
+    "    print(\"   → Or create composite features from correlated groups\")\n",
+    "else:\n",
+    "    print(\"\\n✅ No highly correlated pairs detected\")\n",
+    "    print(\"   → Features appear independent, good for modeling\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57364526",
+   "metadata": {
+    "papermill": {
+     "duration": 0.017321,
+     "end_time": "2026-02-02T13:01:12.360755",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:12.343434",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.9 Temporal Sparklines\n",
+    "\n",
+    "**📈 Understanding Temporal Trends:**\n",
+    "\n",
+    "Sparklines show how numeric features evolve over time:\n",
+    "\n",
+    "| Pattern | What It Means | Implication |\n",
+    "|---------|--------------|-------------|\n",
+    "| Upward trend | Metric increasing | Growth or engagement |\n",
+    "| Downward trend | Metric decreasing | Decline or churn signal |\n",
+    "| Flat line | Stable metric | Consistent behavior |\n",
+    "| Spikes | Sudden changes | Events or anomalies |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c1b4a86",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:12.395184Z",
+     "iopub.status.busy": "2026-02-02T13:01:12.395066Z",
+     "iopub.status.idle": "2026-02-02T13:01:12.659614Z",
+     "shell.execute_reply": "2026-02-02T13:01:12.659019Z"
+    },
+    "papermill": {
+     "duration": 0.282742,
+     "end_time": "2026-02-02T13:01:12.660385",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:12.377643",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Temporal Sparklines - Cohort × Time Period per feature with analysis\n",
+    "if len(numeric_event_cols) >= 2:\n",
+    "    variances = df[numeric_event_cols].var().sort_values(ascending=False)\n",
+    "    sparkline_cols = variances.index.tolist()\n",
+    "    \n",
+    "    print(\"\\n\" + \"=\"*70)\n",
+    "    print(\"TEMPORAL SPARKLINES - COHORT × TIME PERIOD\")\n",
+    "    print(\"=\"*70)\n",
+    "    print(f\"\\n{len(sparkline_cols)} features analyzed across Weekly/Monthly/Yearly periods\")\n",
+    "    \n",
+    "    if ENTITY_COLUMN and TIME_COLUMN:\n",
+    "        df_spark = df.copy()\n",
+    "        df_spark['_week'] = pd.to_datetime(df_spark[TIME_COLUMN]).dt.to_period('W').dt.start_time\n",
+    "        df_spark['_month'] = pd.to_datetime(df_spark[TIME_COLUMN]).dt.to_period('M').dt.start_time\n",
+    "        df_spark['_year'] = pd.to_datetime(df_spark[TIME_COLUMN]).dt.to_period('Y').dt.start_time\n",
+    "        \n",
+    "        has_target = TARGET_COLUMN and TARGET_COLUMN in df.columns\n",
+    "        all_actions = []\n",
+    "        \n",
+    "        for col in sparkline_cols:\n",
+    "            if col not in df_spark.columns:\n",
+    "                continue\n",
+    "            \n",
+    "            feature_data = {}\n",
+    "            cohort_masks = ([(\"retained\", df_spark[TARGET_COLUMN] == 1),\n",
+    "                            (\"churned\", df_spark[TARGET_COLUMN] == 0),\n",
+    "                            (\"overall\", slice(None))] if has_target \n",
+    "                           else [(\"overall\", slice(None))])\n",
+    "            \n",
+    "            for cohort, mask in cohort_masks:\n",
+    "                cohort_df = df_spark[mask] if isinstance(mask, pd.Series) else df_spark\n",
+    "                feature_data[cohort] = {\n",
+    "                    \"weekly\": cohort_df.groupby('_week')[col].mean().dropna().tolist(),\n",
+    "                    \"monthly\": cohort_df.groupby('_month')[col].mean().dropna().tolist(),\n",
+    "                    \"yearly\": cohort_df.groupby('_year')[col].mean().dropna().tolist(),\n",
+    "                }\n",
+    "            \n",
+    "            period_effects = None\n",
+    "            if has_target:\n",
+    "                analysis = charts.analyze_cohort_trends(feature_data, col)\n",
+    "                period_effects = {p: analysis[\"periods\"][p][\"effect_size\"] \n",
+    "                                  for p in analysis[\"periods\"]}\n",
+    "                all_actions.extend(analysis.get(\"actions\", []))\n",
+    "            \n",
+    "            fig = charts.cohort_sparklines(feature_data, feature_name=col, period_effects=period_effects)\n",
+    "            display_figure(fig)\n",
+    "        \n",
+    "        if has_target and all_actions:\n",
+    "            print(\"\\n\" + \"=\"*70)\n",
+    "            print(\"TREND & VARIANCE RECOMMENDATIONS\")\n",
+    "            print(\"=\"*70)\n",
+    "            \n",
+    "            BOLD, RESET = \"\\033[1m\", \"\\033[0m\"\n",
+    "            \n",
+    "            type_labels = {\n",
+    "                \"add_trend_feature\": \"📈 Add Trend Features (opposite cohort trends)\",\n",
+    "                \"add_time_indicator\": \"📅 Add Time Indicators (seasonality detected)\",\n",
+    "                \"robust_scale\": \"🔧 Apply Robust Scaling (high variance ratio)\",\n",
+    "                \"normalize\": \"📊 Apply Normalization (high variance)\",\n",
+    "            }\n",
+    "            \n",
+    "            by_type = {}\n",
+    "            for action in all_actions:\n",
+    "                action_type = action[\"action_type\"]\n",
+    "                if action_type not in by_type:\n",
+    "                    by_type[action_type] = []\n",
+    "                by_type[action_type].append(action)\n",
+    "            \n",
+    "            for action_type, actions in by_type.items():\n",
+    "                print(f\"\\n{type_labels.get(action_type, action_type)}:\")\n",
+    "                for a in actions:\n",
+    "                    params_str = \", \".join(f\"{k}={v}\" for k, v in a.get(\"params\", {}).items())\n",
+    "                    print(f\"   • {BOLD}{a['feature']}{RESET}: {a['reason']}\")\n",
+    "                    if params_str:\n",
+    "                        print(f\"     params: {{{params_str}}}\")\n",
+    "else:\n",
+    "    print(\"Insufficient numeric columns for sparkline visualization\")\n",
+    "# Store sparkline recommendations for pattern_summary\n",
+    "SPARKLINE_RECOMMENDATIONS = [\n",
+    "    {\"action\": a[\"action_type\"], \"feature\": a[\"feature\"], \"reason\": a[\"reason\"],\n",
+    "     \"params\": a.get(\"params\", {}), \"priority\": \"high\" if a[\"action_type\"] == \"add_trend_feature\" else \"medium\",\n",
+    "     \"features\": [f\"{a['feature']}_{a['action_type']}\"]}\n",
+    "    for a in all_actions\n",
+    "] if 'all_actions' in dir() and all_actions else []\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8e5da120",
+   "metadata": {
+    "papermill": {
+     "duration": 0.034263,
+     "end_time": "2026-02-02T13:01:12.729612",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:12.695349",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.10 Entity-Level Feature Analysis (Effect Sizes)\n",
+    "\n",
+    "This section uses **three complementary approaches** to understand feature separation:\n",
+    "\n",
+    "| Approach | What It Measures | Output |\n",
+    "|----------|------------------|--------|\n",
+    "| **Cohen's d** | Standardized mean difference | Single number per feature |\n",
+    "| **Correlation** | Linear relationship with target | Single number per feature |\n",
+    "| **Box Plots** | Full distribution by cohort | Visual comparison |\n",
+    "\n",
+    "**📊 Cohen's d Interpretation:**\n",
+    "\n",
+    "| `\\|d\\|` Value | Effect Size | Predictive Value |\n",
+    "|----------|-------------|------------------|\n",
+    "| ≥ 0.8 | Large | Strong differentiator |\n",
+    "| 0.5-0.8 | Medium | Useful signal |\n",
+    "| 0.2-0.5 | Small | Weak signal |\n",
+    "| < 0.2 | Negligible | Not predictive |\n",
+    "\n",
+    "**Connection to Sparklines (1c.9):** The d values shown in the sparkline column headers are per-period effect sizes. Here we compute entity-level effect sizes across all aggregated features.\n",
+    "\n",
+    "**See also:** Section 1c.8 for scatter matrix showing feature relationships with cohort overlay."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2b01ed4f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:12.799852Z",
+     "iopub.status.busy": "2026-02-02T13:01:12.799733Z",
+     "iopub.status.idle": "2026-02-02T13:01:12.840137Z",
+     "shell.execute_reply": "2026-02-02T13:01:12.839478Z"
+    },
+    "papermill": {
+     "duration": 0.077605,
+     "end_time": "2026-02-02T13:01:12.841471",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:12.763866",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Aggregate event data to entity level for effect size analysis\n",
+    "if ENTITY_COLUMN and TARGET_COLUMN and TARGET_COLUMN in df.columns:\n",
+    "    # Build entity-level aggregations\n",
+    "    entity_aggs = df.groupby(ENTITY_COLUMN).agg({\n",
+    "        TIME_COLUMN: ['count', 'min', 'max'],\n",
+    "        **{col: ['mean', 'sum', 'std'] for col in numeric_event_cols if col != TARGET_COLUMN}\n",
+    "    })\n",
+    "    entity_aggs.columns = ['_'.join(col).strip() for col in entity_aggs.columns]\n",
+    "    entity_aggs = entity_aggs.reset_index()\n",
+    "    \n",
+    "    # Add target\n",
+    "    entity_target = df.groupby(ENTITY_COLUMN)[TARGET_COLUMN].first().reset_index()\n",
+    "    entity_df = entity_aggs.merge(entity_target, on=ENTITY_COLUMN)\n",
+    "    \n",
+    "    # Add derived features\n",
+    "    entity_df['tenure_days'] = (entity_df[f'{TIME_COLUMN}_max'] - entity_df[f'{TIME_COLUMN}_min']).dt.days\n",
+    "    entity_df['event_count'] = entity_df[f'{TIME_COLUMN}_count']\n",
+    "    \n",
+    "    # Calculate effect sizes (Cohen's d) for entity-level features\n",
+    "    # Exclude entity, target, and temporal metadata columns\n",
+    "    effect_feature_cols = [c for c in entity_df.select_dtypes(include=[np.number]).columns\n",
+    "                          if c not in [ENTITY_COLUMN, TARGET_COLUMN]\n",
+    "                          and c not in TEMPORAL_METADATA_COLS]\n",
+    "    \n",
+    "    print(\"=\"*80)\n",
+    "    print(\"ENTITY-LEVEL FEATURE EFFECT SIZES (Cohen's d)\")\n",
+    "    print(\"=\"*80)\n",
+    "    print(f\"\\nAnalyzing {len(effect_feature_cols)} aggregated features at entity level\")\n",
+    "    print(f\"Entities: {len(entity_df):,} (Retained: {(entity_df[TARGET_COLUMN]==1).sum():,}, Churned: {(entity_df[TARGET_COLUMN]==0).sum():,})\\n\")\n",
+    "    \n",
+    "    effect_sizes = []\n",
+    "    for col in effect_feature_cols:\n",
+    "        churned = entity_df[entity_df[TARGET_COLUMN] == 0][col].dropna()\n",
+    "        retained = entity_df[entity_df[TARGET_COLUMN] == 1][col].dropna()\n",
+    "        \n",
+    "        if len(churned) > 0 and len(retained) > 0:\n",
+    "            pooled_std = np.sqrt(((len(churned)-1)*churned.std()**2 + (len(retained)-1)*retained.std()**2) / \n",
+    "                                 (len(churned) + len(retained) - 2))\n",
+    "            d = (retained.mean() - churned.mean()) / pooled_std if pooled_std > 0 else 0\n",
+    "            \n",
+    "            abs_d = abs(d)\n",
+    "            if abs_d >= 0.8:\n",
+    "                interp, emoji = \"Large effect\", \"🔴\"\n",
+    "            elif abs_d >= 0.5:\n",
+    "                interp, emoji = \"Medium effect\", \"🟡\"\n",
+    "            elif abs_d >= 0.2:\n",
+    "                interp, emoji = \"Small effect\", \"🟢\"\n",
+    "            else:\n",
+    "                interp, emoji = \"Negligible\", \"⚪\"\n",
+    "            \n",
+    "            effect_sizes.append({\n",
+    "                \"feature\": col, \"cohens_d\": d, \"abs_d\": abs_d, \n",
+    "                \"interpretation\": interp, \"emoji\": emoji,\n",
+    "                \"retained_mean\": retained.mean(), \"churned_mean\": churned.mean()\n",
+    "            })\n",
+    "    \n",
+    "    # Sort and display\n",
+    "    effect_df = pd.DataFrame(effect_sizes).sort_values(\"abs_d\", ascending=False)\n",
+    "    \n",
+    "    print(f\"{'Feature':<35} {'d':>8} {'Effect':<15} {'Direction':<20}\")\n",
+    "    print(\"-\" * 80)\n",
+    "    for _, row in effect_df.head(15).iterrows():\n",
+    "        direction = \"↑ Higher in retained\" if row[\"cohens_d\"] > 0 else \"↓ Lower in retained\"\n",
+    "        print(f\"{row['emoji']} {row['feature'][:33]:<33} {row['cohens_d']:>+8.3f} {row['interpretation']:<15} {direction:<20}\")\n",
+    "    \n",
+    "    # Categorize features\n",
+    "    large_effect = effect_df[effect_df[\"abs_d\"] >= 0.8][\"feature\"].tolist()\n",
+    "    medium_effect = effect_df[(effect_df[\"abs_d\"] >= 0.5) & (effect_df[\"abs_d\"] < 0.8)][\"feature\"].tolist()\n",
+    "    small_effect = effect_df[(effect_df[\"abs_d\"] >= 0.2) & (effect_df[\"abs_d\"] < 0.5)][\"feature\"].tolist()\n",
+    "    \n",
+    "    # INTERPRETATION\n",
+    "    print(\"\\n\" + \"─\"*80)\n",
+    "    print(\"📖 INTERPRETATION & RECOMMENDATIONS\")\n",
+    "    print(\"─\"*80)\n",
+    "    \n",
+    "    if large_effect:\n",
+    "        print(f\"\\n🔴 LARGE EFFECT (|d| ≥ 0.8) - Priority Features:\")\n",
+    "        for f in large_effect[:5]:\n",
+    "            row = effect_df[effect_df[\"feature\"] == f].iloc[0]\n",
+    "            direction = \"higher\" if row[\"cohens_d\"] > 0 else \"lower\"\n",
+    "            print(f\"   • {f}: Retained customers have {direction} values\")\n",
+    "            print(f\"     Mean: Retained={row['retained_mean']:.2f}, Churned={row['churned_mean']:.2f}\")\n",
+    "        print(\"   → MUST include in predictive model\")\n",
+    "    \n",
+    "    if medium_effect:\n",
+    "        print(f\"\\n🟡 MEDIUM EFFECT (0.5 ≤ |d| < 0.8) - Useful Features:\")\n",
+    "        for f in medium_effect[:3]:\n",
+    "            print(f\"   • {f}\")\n",
+    "        print(\"   → Should include in model\")\n",
+    "    \n",
+    "    if small_effect:\n",
+    "        print(f\"\\n🟢 SMALL EFFECT (0.2 ≤ |d| < 0.5) - Supporting Features:\")\n",
+    "        print(f\"   {', '.join(small_effect[:5])}\")\n",
+    "        print(\"   → May help in combination with other features\")\n",
+    "    \n",
+    "    negligible = effect_df[effect_df[\"abs_d\"] < 0.2][\"feature\"].tolist()\n",
+    "    if negligible:\n",
+    "        print(f\"\\n⚪ NEGLIGIBLE EFFECT (|d| < 0.2): {len(negligible)} features\")\n",
+    "        print(\"   → Consider engineering or dropping from model\")\n",
+    "else:\n",
+    "    print(\"Entity column or target not available for effect size analysis\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08b6ce74",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:12.914564Z",
+     "iopub.status.busy": "2026-02-02T13:01:12.914442Z",
+     "iopub.status.idle": "2026-02-02T13:01:12.947896Z",
+     "shell.execute_reply": "2026-02-02T13:01:12.947462Z"
+    },
+    "papermill": {
+     "duration": 0.069708,
+     "end_time": "2026-02-02T13:01:12.949169",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:12.879461",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Box Plots: Entity-level feature distributions by target\n",
+    "if ENTITY_COLUMN and TARGET_COLUMN and 'entity_df' in dir() and len(effect_df) > 0:\n",
+    "    # Select top features by effect size for visualization\n",
+    "    top_features = effect_df.head(6)[\"feature\"].tolist()\n",
+    "    n_features = len(top_features)\n",
+    "    \n",
+    "    if n_features > 0:\n",
+    "        print(\"=\"*70)\n",
+    "        print(\"DISTRIBUTION COMPARISON: Retained vs Churned (Box Plots)\")\n",
+    "        print(\"=\"*70)\n",
+    "        print(\"\\n📊 Showing top 6 features by effect size\")\n",
+    "        print(\"   🟢 Green = Retained | 🔴 Red = Churned\\n\")\n",
+    "        \n",
+    "        fig = make_subplots(rows=1, cols=n_features, subplot_titles=top_features, horizontal_spacing=0.05)\n",
+    "        \n",
+    "        for i, col in enumerate(top_features):\n",
+    "            col_num = i + 1\n",
+    "            \n",
+    "            # Retained (1) - Green\n",
+    "            retained_data = entity_df[entity_df[TARGET_COLUMN] == 1][col].dropna()\n",
+    "            fig.add_trace(go.Box(y=retained_data, name='Retained',\n",
+    "                fillcolor='rgba(46, 204, 113, 0.7)', line=dict(color='#1e8449', width=2),\n",
+    "                boxpoints='outliers', width=0.35, showlegend=(i == 0), legendgroup='retained',\n",
+    "                marker=dict(color='rgba(46, 204, 113, 0.5)', size=4)), row=1, col=col_num)\n",
+    "            \n",
+    "            # Churned (0) - Red\n",
+    "            churned_data = entity_df[entity_df[TARGET_COLUMN] == 0][col].dropna()\n",
+    "            fig.add_trace(go.Box(y=churned_data, name='Churned',\n",
+    "                fillcolor='rgba(231, 76, 60, 0.7)', line=dict(color='#922b21', width=2),\n",
+    "                boxpoints='outliers', width=0.35, showlegend=(i == 0), legendgroup='churned',\n",
+    "                marker=dict(color='rgba(231, 76, 60, 0.5)', size=4)), row=1, col=col_num)\n",
+    "        \n",
+    "        fig.update_layout(height=450, title_text=\"Top Features: Retained (Green) vs Churned (Red)\",\n",
+    "            template='plotly_white', showlegend=True, boxmode='group',\n",
+    "            legend=dict(orientation=\"h\", yanchor=\"bottom\", y=1.05, xanchor=\"center\", x=0.5))\n",
+    "        fig.update_xaxes(showticklabels=False)\n",
+    "        display_figure(fig)\n",
+    "        \n",
+    "        # INTERPRETATION\n",
+    "        print(\"─\"*70)\n",
+    "        print(\"📖 HOW TO READ BOX PLOTS\")\n",
+    "        print(\"─\"*70)\n",
+    "        print(\"\"\"\n",
+    "Box Plot Elements:\n",
+    "  • Box = Middle 50% of data (IQR: 25th to 75th percentile)\n",
+    "  • Line inside box = Median (50th percentile)\n",
+    "  • Whiskers = 1.5 × IQR from box edges\n",
+    "  • Dots outside = Outliers\n",
+    "\n",
+    "What makes a good predictor:\n",
+    "  ✓ Clear SEPARATION between green and red boxes\n",
+    "  ✓ Different MEDIANS (center lines at different heights)\n",
+    "  ✓ Minimal OVERLAP between boxes\n",
+    "\n",
+    "Patterns to look for:\n",
+    "  • Green box entirely above red → Retained have higher values\n",
+    "  • Green box entirely below red → Retained have lower values\n",
+    "  • Overlapping boxes → Feature alone may not discriminate well\n",
+    "  • Many outliers in one group → Subpopulations worth investigating\n",
+    "\"\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "58ee08bc",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:13.024026Z",
+     "iopub.status.busy": "2026-02-02T13:01:13.023843Z",
+     "iopub.status.idle": "2026-02-02T13:01:13.041333Z",
+     "shell.execute_reply": "2026-02-02T13:01:13.040834Z"
+    },
+    "papermill": {
+     "duration": 0.055619,
+     "end_time": "2026-02-02T13:01:13.041926",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:12.986307",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Feature-Target Correlation Ranking\n",
+    "if ENTITY_COLUMN and TARGET_COLUMN and 'entity_df' in dir():\n",
+    "    print(\"=\"*70)\n",
+    "    print(\"FEATURE-TARGET CORRELATIONS (Entity-Level)\")\n",
+    "    print(\"=\"*70)\n",
+    "    \n",
+    "    correlations = []\n",
+    "    for col in effect_feature_cols:\n",
+    "        if col != TARGET_COLUMN:\n",
+    "            corr = entity_df[[col, TARGET_COLUMN]].corr().iloc[0, 1]\n",
+    "            if not np.isnan(corr):\n",
+    "                correlations.append({\"Feature\": col, \"Correlation\": corr})\n",
+    "    \n",
+    "    if correlations:\n",
+    "        corr_df = pd.DataFrame(correlations).sort_values(\"Correlation\", key=abs, ascending=False)\n",
+    "        \n",
+    "        fig = charts.bar_chart(\n",
+    "            corr_df[\"Feature\"].head(12).tolist(),\n",
+    "            corr_df[\"Correlation\"].head(12).tolist(),\n",
+    "            title=f\"Feature Correlations with {TARGET_COLUMN}\"\n",
+    "        )\n",
+    "        display_figure(fig)\n",
+    "        \n",
+    "        print(\"\\n📊 Correlation Rankings:\")\n",
+    "        print(f\"{'Feature':<35} {'Correlation':>12} {'Strength':<15} {'Direction'}\")\n",
+    "        print(\"-\" * 75)\n",
+    "        \n",
+    "        for _, row in corr_df.head(10).iterrows():\n",
+    "            abs_corr = abs(row[\"Correlation\"])\n",
+    "            if abs_corr >= 0.5:\n",
+    "                strength = \"Strong\"\n",
+    "            elif abs_corr >= 0.3:\n",
+    "                strength = \"Moderate\"\n",
+    "            elif abs_corr >= 0.1:\n",
+    "                strength = \"Weak\"\n",
+    "            else:\n",
+    "                strength = \"Very weak\"\n",
+    "            \n",
+    "            direction = \"Positive\" if row[\"Correlation\"] > 0 else \"Negative\"\n",
+    "            print(f\"{row['Feature'][:34]:<35} {row['Correlation']:>+12.3f} {strength:<15} {direction}\")\n",
+    "        \n",
+    "        # INTERPRETATION\n",
+    "        print(\"\\n\" + \"─\"*70)\n",
+    "        print(\"📖 INTERPRETING CORRELATIONS WITH TARGET\")\n",
+    "        print(\"─\"*70)\n",
+    "        print(\"\"\"\n",
+    "Correlation with binary target (retained=1, churned=0):\n",
+    "\n",
+    "  Positive correlation (+): Higher values → more likely RETAINED\n",
+    "  Negative correlation (-): Higher values → more likely CHURNED\n",
+    "\n",
+    "Strength guide:\n",
+    "  |r| > 0.5:  Strong - prioritize this feature\n",
+    "  |r| 0.3-0.5: Moderate - useful predictor\n",
+    "  |r| 0.1-0.3: Weak - may help in combination\n",
+    "  |r| < 0.1:  Very weak - limited predictive value\n",
+    "\n",
+    "Note: Correlation captures LINEAR relationships only.\n",
+    "Non-linear relationships may have low correlation but still be predictive.\n",
+    "\"\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cf266d12",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:13.166795Z",
+     "iopub.status.busy": "2026-02-02T13:01:13.166685Z",
+     "iopub.status.idle": "2026-02-02T13:01:13.172173Z",
+     "shell.execute_reply": "2026-02-02T13:01:13.171764Z"
+    },
+    "papermill": {
+     "duration": 0.045238,
+     "end_time": "2026-02-02T13:01:13.173037",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:13.127799",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Entity-Level Analysis: Summary\n",
+    "print(\"\\n\" + \"=\"*70)\n",
+    "print(\"ENTITY-LEVEL FEATURE SUMMARY\")\n",
+    "print(\"=\"*70)\n",
+    "\n",
+    "if 'effect_df' in dir() and len(effect_df) > 0:\n",
+    "    large_effects = effect_df[effect_df['cohens_d'].abs() >= 0.5]\n",
+    "    print(f\"\\n📊 Effect Size Summary:\")\n",
+    "    print(f\"   • Total features analyzed: {len(effect_df)}\")\n",
+    "    print(f\"   • Features with |d| ≥ 0.5 (medium+): {len(large_effects)}\")\n",
+    "    print(f\"   • Features with |d| < 0.2 (negligible): {(effect_df['cohens_d'].abs() < 0.2).sum()}\")\n",
+    "    \n",
+    "    if len(large_effects) > 0:\n",
+    "        print(\"\\n   Top differentiators:\")\n",
+    "        for _, row in large_effects.head(5).iterrows():\n",
+    "            direction = \"↑ higher in retained\" if row['cohens_d'] > 0 else \"↓ lower in retained\"\n",
+    "            print(f\"   • \\033[1m{row['feature']}\\033[0m: d={row['cohens_d']:+.2f} ({direction})\")\n",
+    "    \n",
+    "    print(\"\\n📋 What the Three Approaches Showed:\")\n",
+    "    print(\"   • Cohen's d → identified features with strongest mean separation\")\n",
+    "    print(\"   • Correlation → confirmed linear relationship direction\")\n",
+    "    print(\"   • Box plots → revealed distribution shapes and outliers\")\n",
+    "    \n",
+    "    print(\"\\n💡 RECOMMENDATIONS:\")\n",
+    "    print(\"   → Prioritize features with |d| > 0.5 in model\")\n",
+    "    print(\"   → Consider dropping features with |d| < 0.2\")\n",
+    "    print(\"   → Check box plots for non-normal distributions that may need transformation\")\n",
+    "else:\n",
+    "    print(\"\\n⚠️ Effect size analysis not performed\")\n",
+    "\n",
+    "# Store effect size recommendations for pattern_summary\n",
+    "EFFECT_SIZE_RECOMMENDATIONS = []\n",
+    "if 'effect_df' in dir() and len(effect_df) > 0:\n",
+    "    for _, row in effect_df.iterrows():\n",
+    "        abs_d = abs(row['cohens_d'])\n",
+    "        if abs_d >= 0.5:\n",
+    "            EFFECT_SIZE_RECOMMENDATIONS.append({\n",
+    "                \"action\": \"prioritize_feature\", \"feature\": row['feature'],\n",
+    "                \"effect_size\": row['cohens_d'], \"priority\": \"high\" if abs_d >= 0.8 else \"medium\",\n",
+    "                \"reason\": f\"Cohen's d={row['cohens_d']:.2f} shows {'large' if abs_d >= 0.8 else 'medium'} effect\",\n",
+    "                \"features\": [row['feature']]\n",
+    "            })\n",
+    "        elif abs_d < 0.2:\n",
+    "            EFFECT_SIZE_RECOMMENDATIONS.append({\n",
+    "                \"action\": \"consider_dropping\", \"feature\": row['feature'],\n",
+    "                \"effect_size\": row['cohens_d'], \"priority\": \"low\",\n",
+    "                \"reason\": f\"Cohen's d={row['cohens_d']:.2f} shows negligible effect\",\n",
+    "                \"features\": []  # No feature to add, just informational\n",
+    "            })\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5743176c",
+   "metadata": {
+    "papermill": {
+     "duration": 0.039847,
+     "end_time": "2026-02-02T13:01:13.251004",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:13.211157",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.11 Recency Analysis\n",
+    "\n",
+    "**📖 What is Recency?**\n",
+    "Days since each entity's last event. A key predictor in churn models.\n",
+    "\n",
+    "**📊 How to Read the Panel:**\n",
+    "- **Top Row**: Distribution histograms for Retained vs Churned\n",
+    "  - Compare shapes: Similar = weak signal, Different = strong signal\n",
+    "  - Compare medians: Large gap = recency discriminates well\n",
+    "- **Bottom Left**: Target rate by recency bucket\n",
+    "  - Look for: Monotonic decline, sharp thresholds, or flat patterns\n",
+    "  - Inflection points suggest where to create binary flags\n",
+    "\n",
+    "**✅ Pattern Interpretation:**\n",
+    "| Pattern | Meaning | Feature Strategy |\n",
+    "|---------|---------|------------------|\n",
+    "| Monotonic decline | Gradual disengagement | Use continuous recency |\n",
+    "| Threshold/step | Clear activity boundary | Create binary is_active_Nd flag |\n",
+    "| Flat | Recency not predictive | May omit or use only in combination |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a8057048",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:13.328727Z",
+     "iopub.status.busy": "2026-02-02T13:01:13.328616Z",
+     "iopub.status.idle": "2026-02-02T13:01:13.444922Z",
+     "shell.execute_reply": "2026-02-02T13:01:13.444409Z"
+    },
+    "papermill": {
+     "duration": 0.15618,
+     "end_time": "2026-02-02T13:01:13.445729",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:13.289549",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Recency Analysis - Combined visualization and insights\n",
+    "from customer_retention.analysis.visualization import console\n",
+    "from customer_retention.stages.profiling import compare_recency_by_target\n",
+    "\n",
+    "recency_comparison = None\n",
+    "recency_result = None\n",
+    "RECENCY_RECOMMENDATIONS = []\n",
+    "\n",
+    "if ENTITY_COLUMN:\n",
+    "    reference_date = df[TIME_COLUMN].max()\n",
+    "    \n",
+    "    # Compute recency_result for use in summary cells\n",
+    "    recency_result = analyzer.analyze_recency(df, ENTITY_COLUMN, TARGET_COLUMN, reference_date)\n",
+    "    \n",
+    "    if TARGET_COLUMN and TARGET_COLUMN in df.columns:\n",
+    "        recency_comparison = compare_recency_by_target(\n",
+    "            df, ENTITY_COLUMN, TIME_COLUMN, TARGET_COLUMN, reference_date\n",
+    "        )\n",
+    "    \n",
+    "    if recency_comparison:\n",
+    "        # Combined visualization panel\n",
+    "        entity_last = df.groupby(ENTITY_COLUMN)[TIME_COLUMN].max().reset_index()\n",
+    "        entity_last[\"recency_days\"] = (reference_date - entity_last[TIME_COLUMN]).dt.days\n",
+    "        entity_target = df.groupby(ENTITY_COLUMN)[TARGET_COLUMN].first().reset_index()\n",
+    "        entity_recency = entity_last.merge(entity_target, on=ENTITY_COLUMN)\n",
+    "        cap = entity_recency[\"recency_days\"].quantile(0.99)\n",
+    "        entity_capped = entity_recency[entity_recency[\"recency_days\"] <= cap]\n",
+    "        \n",
+    "        retained = entity_capped[entity_capped[TARGET_COLUMN] == 1][\"recency_days\"].values\n",
+    "        churned = entity_capped[entity_capped[TARGET_COLUMN] == 0][\"recency_days\"].values\n",
+    "        \n",
+    "        fig = charts.recency_analysis_panel(\n",
+    "            retained_recency=retained,\n",
+    "            churned_recency=churned,\n",
+    "            bucket_stats=recency_comparison.bucket_stats,\n",
+    "            retained_median=recency_comparison.retained_stats.median,\n",
+    "            churned_median=recency_comparison.churned_stats.median,\n",
+    "            cap_value=cap\n",
+    "        )\n",
+    "        display_figure(fig)\n",
+    "        \n",
+    "        # Key Findings\n",
+    "        console.start_section()\n",
+    "        console.header(\"Key Findings\")\n",
+    "        for insight in recency_comparison.key_findings:\n",
+    "            console.info(insight.finding)\n",
+    "        console.end_section()\n",
+    "        \n",
+    "        # Statistics\n",
+    "        ret, churn = recency_comparison.retained_stats, recency_comparison.churned_stats\n",
+    "        console.start_section()\n",
+    "        console.header(\"Detailed Statistics\")\n",
+    "        console.metric(\"Retained (n)\", f\"{ret.count:,}\")\n",
+    "        console.metric(\"Churned (n)\", f\"{churn.count:,}\")\n",
+    "        print(f\"{'Metric':<15} {'Retained':>12} {'Churned':>12} {'Diff':>12}\")\n",
+    "        print(\"-\" * 52)\n",
+    "        for name, r, c in [(\"Mean\", ret.mean, churn.mean), (\"Median\", ret.median, churn.median), \n",
+    "                           (\"Std Dev\", ret.std, churn.std)]:\n",
+    "            print(f\"{name:<15} {r:>12.1f} {c:>12.1f} {c-r:>+12.1f}\")\n",
+    "        console.metric(\"Effect Size\", f\"{recency_comparison.cohens_d:+.2f} ({recency_comparison.effect_interpretation})\")\n",
+    "        console.metric(\"Pattern\", recency_comparison.distribution_pattern.replace(\"_\", \" \").title())\n",
+    "        if recency_comparison.inflection_bucket:\n",
+    "            console.metric(\"Inflection\", recency_comparison.inflection_bucket)\n",
+    "        console.end_section()\n",
+    "        \n",
+    "        # Actionable Recommendations\n",
+    "        console.start_section()\n",
+    "        console.header(\"Actionable Recommendations\")\n",
+    "        RECENCY_RECOMMENDATIONS = recency_comparison.recommendations\n",
+    "        for rec in RECENCY_RECOMMENDATIONS:\n",
+    "            priority = rec.get(\"priority\", \"medium\")\n",
+    "            priority_icon = {\"high\": \"🔴\", \"medium\": \"🟡\", \"low\": \"🟢\"}.get(priority, \"⚪\")\n",
+    "            console.info(f\"{priority_icon} [{priority.upper()}] {rec['action'].replace('_', ' ').title()}\")\n",
+    "            console.info(f\"   {rec['reason']}\")\n",
+    "            if rec.get(\"features\"):\n",
+    "                console.metric(\"Features\", \", \".join(rec[\"features\"]))\n",
+    "        console.end_section()\n",
+    "    else:\n",
+    "        # No target - show basic recency distribution\n",
+    "        entity_last = df.groupby(ENTITY_COLUMN)[TIME_COLUMN].max().reset_index()\n",
+    "        entity_last[\"recency_days\"] = (reference_date - entity_last[TIME_COLUMN]).dt.days\n",
+    "        median_recency = entity_last[\"recency_days\"].median()\n",
+    "        cap = entity_last[\"recency_days\"].quantile(0.99)\n",
+    "        capped = entity_last[entity_last[\"recency_days\"] <= cap]\n",
+    "        \n",
+    "        fig = go.Figure()\n",
+    "        fig.add_trace(go.Histogram(x=capped[\"recency_days\"], nbinsx=50, marker_color=\"coral\", opacity=0.7))\n",
+    "        fig.add_vline(x=median_recency, line_dash=\"solid\", line_color=\"green\", annotation_text=f\"Median: {median_recency:.0f} days\")\n",
+    "        fig.update_layout(title=f\"Recency Distribution (capped at {cap:.0f} days)\", xaxis_title=\"Days Since Last Event\", yaxis_title=\"Count\", template=\"plotly_white\", height=400)\n",
+    "        display_figure(fig)\n",
+    "        \n",
+    "        console.start_section()\n",
+    "        console.header(\"Recency Statistics\")\n",
+    "        console.metric(\"Median\", f\"{median_recency:.0f} days\")\n",
+    "        console.metric(\"Mean\", f\"{entity_last['recency_days'].mean():.0f} days\")\n",
+    "        console.info(\"No target column - cannot compare retained vs churned\")\n",
+    "        console.end_section()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a214f94",
+   "metadata": {
+    "papermill": {
+     "duration": 0.039497,
+     "end_time": "2026-02-02T13:01:13.525285",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:13.485788",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.12 Velocity & Acceleration Analysis\n",
+    "\n",
+    "**📖 Why Velocity and Acceleration Matter:**\n",
+    "\n",
+    "| Metric | Formula | Interpretation |\n",
+    "|--------|---------|----------------|\n",
+    "| **Velocity** | Δ(value) / Δt | Rate of change - is activity speeding up or slowing down? |\n",
+    "| **Acceleration** | Δ(velocity) / Δt | Change in rate - is the slowdown accelerating? |\n",
+    "\n",
+    "**📊 Analysis Approach:**\n",
+    "\n",
+    "1. **Signal Heatmap**: Effect sizes (Cohen's d) across variable × time window combinations\n",
+    "   - Shows cohort separation strength at each time scale\n",
+    "   - Higher |d| = stronger individual signal, but low |d| features may still help in combinations\n",
+    "   \n",
+    "2. **Detailed Sparklines**: For top features (ranked by max |d| across windows)\n",
+    "   - Shows ALL time windows for each feature - different scales capture different dynamics\n",
+    "   - Retained vs churned velocity/acceleration side by side\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5614a91",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:13.606846Z",
+     "iopub.status.busy": "2026-02-02T13:01:13.606731Z",
+     "iopub.status.idle": "2026-02-02T13:01:13.974618Z",
+     "shell.execute_reply": "2026-02-02T13:01:13.974193Z"
+    },
+    "papermill": {
+     "duration": 0.410128,
+     "end_time": "2026-02-02T13:01:13.976884",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:13.566756",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Velocity & Acceleration Cohort Analysis with Effect Size Heatmap\n",
+    "if ENTITY_COLUMN and TARGET_COLUMN and sparkline_cols:\n",
+    "    continuous_cols = [c for c in sparkline_cols if df[c].nunique() > 2][:6]\n",
+    "    \n",
+    "    if not continuous_cols:\n",
+    "        print(\"⚠️ No continuous numeric columns found for velocity analysis.\")\n",
+    "    else:\n",
+    "        print(\"=\"*70)\n",
+    "        print(\"VELOCITY & ACCELERATION SIGNAL ANALYSIS\")\n",
+    "        print(\"=\"*70)\n",
+    "        \n",
+    "        if 'feature_analyzer' not in dir():\n",
+    "            feature_analyzer = TemporalFeatureAnalyzer(time_column=TIME_COLUMN, entity_column=ENTITY_COLUMN)\n",
+    "        \n",
+    "        windows = [7, 14, 30, 90, 180, 365]\n",
+    "        print(f\"Analyzing {len(continuous_cols)} features across windows: {windows} days\")\n",
+    "        \n",
+    "        all_results = {}\n",
+    "        heatmap_data = {\"velocity\": {}, \"acceleration\": {}}\n",
+    "        \n",
+    "        for col in continuous_cols:\n",
+    "            results = feature_analyzer.compute_cohort_velocity_signals(\n",
+    "                df, [col], TARGET_COLUMN, windows=windows\n",
+    "            )\n",
+    "            all_results[col] = results[col]\n",
+    "            heatmap_data[\"velocity\"][col] = {f\"{r.window_days}d\": r.velocity_effect_size for r in results[col]}\n",
+    "            heatmap_data[\"acceleration\"][col] = {f\"{r.window_days}d\": r.accel_effect_size for r in results[col]}\n",
+    "        \n",
+    "        fig = charts.velocity_signal_heatmap(heatmap_data, title=\"Cohort Separation: Velocity & Acceleration Effect Sizes (Cohen's d)\")\n",
+    "        display_figure(fig)\n",
+    "        \n",
+    "        print(\"\\n\" + \"=\"*70)\n",
+    "        print(\"DETAILED SPARKLINES (top features)\")\n",
+    "        print(\"=\"*70)\n",
+    "        \n",
+    "        feature_max_d = [(col, max(abs(r.velocity_effect_size) for r in results)) \n",
+    "                         for col, results in all_results.items()]\n",
+    "        feature_max_d.sort(key=lambda x: -x[1])\n",
+    "        \n",
+    "        top_features = [col for col, _ in feature_max_d[:3]]\n",
+    "        for col in top_features:\n",
+    "            fig = charts.cohort_velocity_sparklines(all_results[col], feature_name=col)\n",
+    "            display_figure(fig)\n",
+    "        \n",
+    "        print(\"\\n\" + \"─\"*70)\n",
+    "        print(\"📖 INTERPRETATION\")\n",
+    "        print(\"─\"*70)\n",
+    "        print(\"\\nVelocity measures rate of change; acceleration measures change in rate.\")\n",
+    "        print(\"Positive d: retained > churned | Negative d: churned > retained\")\n",
+    "        print(\"|d| ≥ 0.8: large effect | ≥ 0.5: medium | ≥ 0.2: small\\n\")\n",
+    "        \n",
+    "        interpretation_notes = feature_analyzer.generate_velocity_interpretation(all_results)\n",
+    "        for note in interpretation_notes:\n",
+    "            print(note)\n",
+    "        \n",
+    "        print(\"\\n\" + \"─\"*70)\n",
+    "        print(\"🎯 FEATURE RECOMMENDATIONS\")\n",
+    "        print(\"─\"*70)\n",
+    "        \n",
+    "        velocity_recs = feature_analyzer.generate_velocity_recommendations(all_results)\n",
+    "        if velocity_recs:\n",
+    "            for rec in velocity_recs:\n",
+    "                priority_marker = \"🔴\" if rec.priority == 1 else \"🟡\"\n",
+    "                print(f\"\\n{priority_marker} {rec.action.upper()}\")\n",
+    "                print(f\"   Column: {rec.source_column}\")\n",
+    "                print(f\"   {rec.description}\")\n",
+    "                print(f\"   Params: {rec.params}\")\n",
+    "        else:\n",
+    "            print(\"\\nNo velocity/acceleration features recommended (no strong signals found).\")\n",
+    "\n",
+    "# Store velocity recommendations for pattern_summary\n",
+    "VELOCITY_RECOMMENDATIONS = [{\"action\": r.action, \"source_column\": r.source_column, \n",
+    "                              \"description\": r.description, \"priority\": r.priority,\n",
+    "                              \"effect_size\": r.effect_size, \"params\": r.params,\n",
+    "                              \"features\": [f\"{r.source_column}_velocity_{r.params.get('window_days', 7)}d\"]}\n",
+    "                             for r in velocity_recs] if velocity_recs else []\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0c9b429a",
+   "metadata": {
+    "papermill": {
+     "duration": 0.062233,
+     "end_time": "2026-02-02T13:01:14.099423",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:14.037190",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.13 Momentum Analysis (Window Ratios)\n",
+    "\n",
+    "**📖 What is Momentum?**\n",
+    "\n",
+    "Momentum compares recent activity to historical activity for each customer:\n",
+    "\n",
+    "```\n",
+    "Momentum = mean(value over last N days) / mean(value over last M days)\n",
+    "```\n",
+    "\n",
+    "Where N < M (e.g., 7d/30d compares last week to last month).\n",
+    "\n",
+    "| Momentum Value | Interpretation |\n",
+    "|----------------|----------------|\n",
+    "| > 1.0 | Recent activity higher than historical → engagement increasing |\n",
+    "| < 1.0 | Recent activity lower than historical → potential churn signal |\n",
+    "| ≈ 1.0 | Stable behavior |\n",
+    "\n",
+    "**Window Pairs Analyzed:**\n",
+    "- **Natural pairs** (week/month/quarter): 7d/30d, 30d/90d, 7d/90d\n",
+    "- **Recommended pairs** from `pattern_config` (based on 01a aggregation windows)\n",
+    "- **Accumulation pair**: recent activity vs all-time behavior\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e67f9f86",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:14.221835Z",
+     "iopub.status.busy": "2026-02-02T13:01:14.221717Z",
+     "iopub.status.idle": "2026-02-02T13:01:14.612203Z",
+     "shell.execute_reply": "2026-02-02T13:01:14.611709Z"
+    },
+    "papermill": {
+     "duration": 0.453371,
+     "end_time": "2026-02-02T13:01:14.613097",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:14.159726",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Momentum Analysis - Cohort Comparison\n",
+    "if ENTITY_COLUMN and TARGET_COLUMN and sparkline_cols:\n",
+    "    print(\"=\"*70)\n",
+    "    print(\"MOMENTUM ANALYSIS (Window Ratios)\")\n",
+    "    print(\"=\"*70)\n",
+    "    \n",
+    "    if 'feature_analyzer' not in dir():\n",
+    "        feature_analyzer = TemporalFeatureAnalyzer(time_column=TIME_COLUMN, entity_column=ENTITY_COLUMN)\n",
+    "    \n",
+    "    # Use sparkline_cols directly (includes all numeric features ranked by variance)\n",
+    "    momentum_cols = sparkline_cols[:6]\n",
+    "    \n",
+    "    # Build comprehensive window pairs from multiple sources:\n",
+    "    # 1. Standard natural pairs (week/month/quarter)\n",
+    "    natural_pairs = [(7, 30), (30, 90), (7, 90)]\n",
+    "    \n",
+    "    # 2. Recommended pairs from pattern_config (based on 01a aggregation windows)\n",
+    "    recommended_pairs = pattern_config.get_momentum_pairs()\n",
+    "    \n",
+    "    # 3. Accumulation pair: shortest window vs all-time\n",
+    "    max_days = (df[TIME_COLUMN].max() - df[TIME_COLUMN].min()).days\n",
+    "    all_windows = [w for pair in natural_pairs + recommended_pairs for w in pair]\n",
+    "    shortest_window = min(all_windows) if all_windows else 7\n",
+    "    accumulation_pair = (shortest_window, max_days)\n",
+    "    \n",
+    "    # Combine and deduplicate (preserve order: natural first, then recommended, then accumulation)\n",
+    "    seen = set()\n",
+    "    window_pairs = []\n",
+    "    for pair in natural_pairs + recommended_pairs + [accumulation_pair]:\n",
+    "        if pair not in seen:\n",
+    "            window_pairs.append(pair)\n",
+    "            seen.add(pair)\n",
+    "    \n",
+    "    print(f\"Analyzing {len(momentum_cols)} features across {len(window_pairs)} window pairs:\")\n",
+    "    print(f\"  Natural pairs (week/month/quarter): {natural_pairs}\")\n",
+    "    print(f\"  Recommended pairs (from 01a): {recommended_pairs}\")\n",
+    "    print(f\"  Accumulation pair: {shortest_window}d vs all-time ({max_days}d)\")\n",
+    "    print(f\"  Combined (deduplicated): {len(window_pairs)} pairs\")\n",
+    "    \n",
+    "    all_momentum_results = {}\n",
+    "    for col in momentum_cols:\n",
+    "        results = feature_analyzer.compute_cohort_momentum_signals(\n",
+    "            df, [col], TARGET_COLUMN, window_pairs=window_pairs\n",
+    "        )\n",
+    "        all_momentum_results[col] = results[col]\n",
+    "    \n",
+    "    print(\"\\n📊 Momentum by Cohort:\")\n",
+    "    print(f\"{'Feature':<18} {'Window':<12} {'Retained':>10} {'Churned':>10} {'Effect d':>10}\")\n",
+    "    print(\"-\" * 62)\n",
+    "    for col, col_results in all_momentum_results.items():\n",
+    "        for r in col_results:\n",
+    "            label = r.window_label if r.long_window < 1000 else f\"{r.short_window}d/all\"\n",
+    "            print(f\"{col[:17]:<18} {label:<12} {r.retained_momentum:>10.2f} {r.churned_momentum:>10.2f} {r.effect_size:>10.2f}\")\n",
+    "    \n",
+    "    # Bar chart for best window pair per feature - with window labels above bars\n",
+    "    best_pair_data = {}\n",
+    "    best_window_labels = {}  # Track which window was best\n",
+    "    for col, col_results in all_momentum_results.items():\n",
+    "        best = max(col_results, key=lambda r: abs(r.effect_size))\n",
+    "        best_pair_data[col] = {\"retained\": best.retained_momentum, \"churned\": best.churned_momentum}\n",
+    "        best_window_labels[col] = best.window_label if best.long_window < 1000 else f\"{best.short_window}d/all\"\n",
+    "    \n",
+    "    if best_pair_data:\n",
+    "        import plotly.graph_objects as go\n",
+    "        columns = list(best_pair_data.keys())\n",
+    "        col_labels = [c[:15] for c in columns]\n",
+    "        \n",
+    "        # Find max y value for positioning labels above bars\n",
+    "        max_y = max(max(best_pair_data[c][\"retained\"], best_pair_data[c][\"churned\"]) for c in columns)\n",
+    "        \n",
+    "        fig = go.Figure()\n",
+    "        fig.add_trace(go.Bar(\n",
+    "            name=\"🟢 Retained\", x=col_labels,\n",
+    "            y=[best_pair_data[c][\"retained\"] for c in columns],\n",
+    "            marker_color=charts.colors[\"success\"],\n",
+    "        ))\n",
+    "        fig.add_trace(go.Bar(\n",
+    "            name=\"🔴 Churned\", x=col_labels,\n",
+    "            y=[best_pair_data[c][\"churned\"] for c in columns],\n",
+    "            marker_color=charts.colors[\"danger\"],\n",
+    "        ))\n",
+    "        fig.add_hline(y=1.0, line_dash=\"dash\", line_color=\"gray\",\n",
+    "                     annotation_text=\"baseline\", annotation_position=\"right\")\n",
+    "        \n",
+    "        # Add window labels as annotations above each bar group\n",
+    "        for i, col in enumerate(columns):\n",
+    "            window_lbl = best_window_labels[col]\n",
+    "            fig.add_annotation(\n",
+    "                x=i, y=max_y * 1.08,\n",
+    "                text=f\"<b>{window_lbl}</b>\",\n",
+    "                showarrow=False,\n",
+    "                font=dict(size=10, color=\"#555\"),\n",
+    "                xref=\"x\", yref=\"y\",\n",
+    "            )\n",
+    "        \n",
+    "        fig.update_layout(\n",
+    "            title=\"Momentum Comparison (Best Window per Feature)\",\n",
+    "            xaxis_title=\"Feature\",\n",
+    "            yaxis_title=\"Momentum Ratio\",\n",
+    "            barmode=\"group\",\n",
+    "            height=400,\n",
+    "            yaxis=dict(range=[0, max_y * 1.15]),  # Extra headroom for labels\n",
+    "        )\n",
+    "        display_figure(fig)\n",
+    "    \n",
+    "    print(\"\\n\" + \"─\"*70)\n",
+    "    print(\"📖 INTERPRETATION\")\n",
+    "    print(\"─\"*70)\n",
+    "    print(\"\\nMomentum = recent_mean / historical_mean (per entity, then averaged)\")\n",
+    "    print(\"> 1.0 = accelerating | < 1.0 = decelerating | ≈ 1.0 = stable\")\n",
+    "    print(\"|d| measures how differently retained vs churned customers behave\\n\")\n",
+    "    \n",
+    "    interpretation_notes = feature_analyzer.generate_momentum_interpretation(all_momentum_results)\n",
+    "    for note in interpretation_notes:\n",
+    "        print(note)\n",
+    "    \n",
+    "    print(\"\\n\" + \"─\"*70)\n",
+    "    print(\"🎯 FEATURE RECOMMENDATIONS\")\n",
+    "    print(\"─\"*70)\n",
+    "    \n",
+    "    momentum_recs = feature_analyzer.generate_momentum_recommendations(all_momentum_results)\n",
+    "    if momentum_recs:\n",
+    "        for rec in momentum_recs:\n",
+    "            priority_marker = \"🔴\" if rec.priority == 1 else \"🟡\"\n",
+    "            print(f\"\\n{priority_marker} {rec.action.upper()}\")\n",
+    "            print(f\"   Column: {rec.source_column}\")\n",
+    "            print(f\"   {rec.description}\")\n",
+    "            print(f\"   Params: {rec.params}\")\n",
+    "    else:\n",
+    "        print(\"\\nNo momentum features recommended (no strong cohort separation found).\")\n",
+    "\n",
+    "# Store momentum recommendations for pattern_summary\n",
+    "MOMENTUM_RECOMMENDATIONS = [{\"action\": r.action, \"source_column\": r.source_column, \n",
+    "                              \"description\": r.description, \"priority\": r.priority,\n",
+    "                              \"effect_size\": r.effect_size, \"params\": r.params,\n",
+    "                              \"features\": [f\"{r.source_column}_momentum_{r.params['short_window']}_{r.params['long_window']}\"]}\n",
+    "                             for r in momentum_recs] if momentum_recs else []\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e0317dd",
+   "metadata": {
+    "papermill": {
+     "duration": 0.059994,
+     "end_time": "2026-02-02T13:01:14.768128",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:14.708134",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.14 Lag Correlation Analysis\n",
+    "\n",
+    "**📖 Why Lag Correlations Matter:**\n",
+    "\n",
+    "Lag correlations show how a metric relates to itself over time:\n",
+    "- High lag-1 correlation: Today's value predicts tomorrow's\n",
+    "- Decaying correlations: Effect diminishes over time\n",
+    "- Periodic spikes: Seasonality (e.g., spike at lag 7 = weekly pattern)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a47c073c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:14.892352Z",
+     "iopub.status.busy": "2026-02-02T13:01:14.892235Z",
+     "iopub.status.idle": "2026-02-02T13:01:14.987790Z",
+     "shell.execute_reply": "2026-02-02T13:01:14.987365Z"
+    },
+    "papermill": {
+     "duration": 0.157473,
+     "end_time": "2026-02-02T13:01:14.988366",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:14.830893",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Lag Correlation Analysis using TemporalFeatureAnalyzer\n",
+    "if ENTITY_COLUMN and sparkline_cols:\n",
+    "    lag_cols = sparkline_cols[:6]\n",
+    "    max_lag = 14\n",
+    "    \n",
+    "    print(\"=\"*70)\n",
+    "    print(\"LAG CORRELATION ANALYSIS\")\n",
+    "    print(\"=\"*70)\n",
+    "    \n",
+    "    if 'feature_analyzer' not in dir():\n",
+    "        feature_analyzer = TemporalFeatureAnalyzer(time_column=TIME_COLUMN, entity_column=ENTITY_COLUMN)\n",
+    "    \n",
+    "    # Calculate lag correlations using framework\n",
+    "    lag_results = feature_analyzer.calculate_lag_correlations(df, lag_cols, max_lag=max_lag)\n",
+    "    \n",
+    "    # Build data for heatmap\n",
+    "    lag_corr_data = {col: result.correlations for col, result in lag_results.items()}\n",
+    "    \n",
+    "    # Use ChartBuilder for visualization\n",
+    "    fig = charts.lag_correlation_heatmap(\n",
+    "        lag_corr_data,\n",
+    "        max_lag=max_lag,\n",
+    "        title=\"Autocorrelation by Lag (days)\"\n",
+    "    )\n",
+    "    display_figure(fig)\n",
+    "    \n",
+    "    # Display framework results\n",
+    "    print(\"\\n📊 Best Lag per Variable:\")\n",
+    "    for col, result in lag_results.items():\n",
+    "        best_lag_info = f\"best lag={result.best_lag}d (r={result.best_correlation:.2f})\"\n",
+    "        weekly_info = \" [Weekly pattern]\" if result.has_weekly_pattern else \"\"\n",
+    "        print(f\"   {col[:25]}: {best_lag_info}{weekly_info}\")\n",
+    "    \n",
+    "    # INTERPRETATION SECTION\n",
+    "    print(\"\\n\" + \"─\"*70)\n",
+    "    print(\"📖 INTERPRETATION\")\n",
+    "    print(\"─\"*70)\n",
+    "    print(\"\\nLag correlation shows how a variable relates to its PAST values:\")\n",
+    "    print(\"  • r > 0.5: Strong memory - today predicts tomorrow well\")\n",
+    "    print(\"  • r 0.3-0.5: Moderate predictability from past\")\n",
+    "    print(\"  • r < 0.3: Weak autocorrelation - lag features less useful\\n\")\n",
+    "    \n",
+    "    interpretation_notes = feature_analyzer.generate_lag_interpretation(lag_results)\n",
+    "    for note in interpretation_notes:\n",
+    "        print(note)\n",
+    "    \n",
+    "    # RECOMMENDATIONS SECTION\n",
+    "    print(\"\\n\" + \"─\"*70)\n",
+    "    print(\"🎯 FEATURE RECOMMENDATIONS\")\n",
+    "    print(\"─\"*70)\n",
+    "    \n",
+    "    lag_recs = feature_analyzer.generate_lag_recommendations(lag_results)\n",
+    "    if lag_recs:\n",
+    "        for rec in lag_recs:\n",
+    "            priority_marker = \"🔴\" if rec.priority == 1 else \"🟡\"\n",
+    "            print(f\"\\n{priority_marker} {rec.action.upper()}\")\n",
+    "            print(f\"   Column: {rec.source_column}\")\n",
+    "            print(f\"   {rec.description}\")\n",
+    "            print(f\"   Params: {rec.params}\")\n",
+    "    else:\n",
+    "        print(\"\\nNo lag features recommended (no strong autocorrelation found).\")\n",
+    "\n",
+    "# Store lag recommendations for pattern_summary\n",
+    "LAG_RECOMMENDATIONS = [{\"action\": r.action, \"source_column\": r.source_column, \n",
+    "                         \"description\": r.description, \"priority\": r.priority,\n",
+    "                         \"features\": [f\"{r.source_column}_lag_{r.params.get('lag_days', 7)}d\"],\n",
+    "                         \"params\": r.params}\n",
+    "                        for r in lag_recs] if lag_recs else []\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c5ea7432",
+   "metadata": {
+    "papermill": {
+     "duration": 0.061178,
+     "end_time": "2026-02-02T13:01:15.113943",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:15.052765",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.15 Predictive Power Analysis (IV & KS Statistics)\n",
+    "\n",
+    "**📖 Information Value (IV) and KS Statistics:**\n",
+    "\n",
+    "These metrics measure how well features predict the target at entity level:\n",
+    "\n",
+    "| Metric | What It Measures | Interpretation |\n",
+    "|--------|------------------|----------------|\n",
+    "| **IV** | Predictive strength across bins | <0.02 weak, 0.02-0.1 medium, 0.1-0.3 strong, >0.3 very strong |\n",
+    "| **KS** | Maximum separation between distributions | Higher = better class separation |\n",
+    "\n",
+    "**How These Relate to Other Sections:**\n",
+    "\n",
+    "| Section | Metric | Relationship to IV/KS |\n",
+    "|---------|--------|----------------------|\n",
+    "| **1c.10** | Cohen's d | Should correlate - both measure cohort separation. d assumes normality, IV handles non-linear. |\n",
+    "| **1c.12** | Velocity effect sizes | High velocity d → feature changes differently by cohort → may show high IV |\n",
+    "| **1c.13** | Momentum effect sizes | High momentum d → behavioral change patterns differ → may show high IV |\n",
+    "| **1c.16** | Cramér's V | For categorical features (IV/KS is for numeric) |\n",
+    "\n",
+    "**Validation:** Features with high Cohen's d (1c.10) should generally show high IV here. Disagreements may indicate non-linear relationships (IV captures) or outlier effects (KS captures).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7377af73",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:15.243351Z",
+     "iopub.status.busy": "2026-02-02T13:01:15.243235Z",
+     "iopub.status.idle": "2026-02-02T13:01:15.373581Z",
+     "shell.execute_reply": "2026-02-02T13:01:15.372631Z"
+    },
+    "papermill": {
+     "duration": 0.196582,
+     "end_time": "2026-02-02T13:01:15.374301",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:15.177719",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Predictive Power Analysis (IV & KS)\n",
+    "if ENTITY_COLUMN and TARGET_COLUMN and sparkline_cols:\n",
+    "    print(\"=\"*70)\n",
+    "    print(\"PREDICTIVE POWER ANALYSIS (IV & KS Statistics)\")\n",
+    "    print(\"=\"*70)\n",
+    "    \n",
+    "    if 'feature_analyzer' not in dir():\n",
+    "        feature_analyzer = TemporalFeatureAnalyzer(time_column=TIME_COLUMN, entity_column=ENTITY_COLUMN)\n",
+    "    \n",
+    "    analysis_cols = [c for c in sparkline_cols[:8] if c in df.columns]\n",
+    "    \n",
+    "    # Method handles aggregation to entity level internally\n",
+    "    iv_results = feature_analyzer.calculate_predictive_power(df, analysis_cols, TARGET_COLUMN)\n",
+    "    \n",
+    "    n_retained = df.groupby(ENTITY_COLUMN)[TARGET_COLUMN].first().sum()\n",
+    "    n_churned = df[ENTITY_COLUMN].nunique() - n_retained\n",
+    "    print(f\"Analyzing {len(analysis_cols)} features\")\n",
+    "    print(f\"Entities: {df[ENTITY_COLUMN].nunique():,} (Retained: {n_retained:,}, Churned: {n_churned:,})\")\n",
+    "    \n",
+    "    # Build visualization data\n",
+    "    iv_data = {col: {\"iv\": r.information_value, \"ks\": r.ks_statistic} for col, r in iv_results.items()}\n",
+    "    \n",
+    "    # Create IV/KS comparison chart\n",
+    "    import plotly.graph_objects as go\n",
+    "    from plotly.subplots import make_subplots\n",
+    "    \n",
+    "    features = list(iv_data.keys())\n",
+    "    ivs = [iv_data[f][\"iv\"] for f in features]\n",
+    "    kss = [iv_data[f][\"ks\"] for f in features]\n",
+    "    \n",
+    "    # Sort by IV\n",
+    "    sorted_idx = sorted(range(len(ivs)), key=lambda i: ivs[i], reverse=True)\n",
+    "    features = [features[i] for i in sorted_idx]\n",
+    "    ivs = [ivs[i] for i in sorted_idx]\n",
+    "    kss = [kss[i] for i in sorted_idx]\n",
+    "    \n",
+    "    fig = make_subplots(rows=1, cols=2, subplot_titles=[\"Information Value (IV)\", \"KS Statistic\"])\n",
+    "    \n",
+    "    # IV bars with threshold colors\n",
+    "    iv_colors = [\"#27ae60\" if v >= 0.1 else \"#f39c12\" if v >= 0.02 else \"#95a5a6\" for v in ivs]\n",
+    "    fig.add_trace(go.Bar(y=features, x=ivs, orientation=\"h\", marker_color=iv_colors, \n",
+    "                         showlegend=False, hovertemplate=\"%{y}: IV=%{x:.3f}<extra></extra>\"), row=1, col=1)\n",
+    "    fig.add_vline(x=0.1, line_dash=\"dash\", line_color=\"#27ae60\", annotation_text=\"Strong\", row=1, col=1)\n",
+    "    fig.add_vline(x=0.02, line_dash=\"dash\", line_color=\"#f39c12\", annotation_text=\"Medium\", row=1, col=1)\n",
+    "    \n",
+    "    # KS bars\n",
+    "    ks_colors = [\"#3498db\" if v >= 0.3 else \"#85c1e9\" for v in kss]\n",
+    "    fig.add_trace(go.Bar(y=features, x=kss, orientation=\"h\", marker_color=ks_colors,\n",
+    "                         showlegend=False, hovertemplate=\"%{y}: KS=%{x:.3f}<extra></extra>\"), row=1, col=2)\n",
+    "    \n",
+    "    fig.update_layout(height=400, title=\"Predictive Power: IV & KS Statistics\")\n",
+    "    fig.update_xaxes(title_text=\"IV\", row=1, col=1)\n",
+    "    fig.update_xaxes(title_text=\"KS\", row=1, col=2)\n",
+    "    display_figure(fig)\n",
+    "    \n",
+    "    # Details table\n",
+    "    print(\"\\n📊 Predictive Power Details:\")\n",
+    "    print(f\"{'Feature':<25} {'IV':>8} {'IV Strength':<12} {'KS':>8} {'KS Strength':<12}\")\n",
+    "    print(\"-\" * 70)\n",
+    "    for col in features:\n",
+    "        r = iv_results[col]\n",
+    "        print(f\"{col[:24]:<25} {r.information_value:>8.3f} {r.iv_interpretation:<12} {r.ks_statistic:>8.3f} {r.ks_interpretation:<12}\")\n",
+    "    \n",
+    "    # INTERPRETATION with cross-references\n",
+    "    print(\"\\n\" + \"─\"*70)\n",
+    "    print(\"📖 INTERPRETATION\")\n",
+    "    print(\"─\"*70)\n",
+    "    \n",
+    "    strong_iv = [col for col, r in iv_results.items() if r.information_value >= 0.1]\n",
+    "    medium_iv = [col for col, r in iv_results.items() if 0.02 <= r.information_value < 0.1]\n",
+    "    weak_iv = [col for col, r in iv_results.items() if r.information_value < 0.02]\n",
+    "    \n",
+    "    if strong_iv:\n",
+    "        print(f\"\\nStrong predictors (IV >= 0.1): {', '.join(strong_iv)}\")\n",
+    "        print(\"  → High predictive value, prioritize in model\")\n",
+    "    if medium_iv:\n",
+    "        print(f\"\\nMedium predictors (IV 0.02-0.1): {', '.join(medium_iv)}\")\n",
+    "        print(\"  → Useful signal, include in model\")\n",
+    "    if weak_iv:\n",
+    "        print(f\"\\nWeak predictors (IV < 0.02): {', '.join(weak_iv)}\")\n",
+    "        print(\"  → Limited predictive value alone\")\n",
+    "    \n",
+    "    # Cross-reference with 1c.10 Cohen's d if available\n",
+    "    if 'effect_df' in dir() and len(effect_df) > 0:\n",
+    "        print(\"\\n📎 Cross-reference with 1c.10 (Cohen's d):\")\n",
+    "        common_cols = [c for c in features if any(c in ec for ec in effect_df['feature'].tolist())]\n",
+    "        if common_cols:\n",
+    "            for col in common_cols[:3]:\n",
+    "                matching = effect_df[effect_df['feature'].str.contains(col, na=False)]\n",
+    "                if len(matching) > 0:\n",
+    "                    d_val = matching.iloc[0]['cohens_d']\n",
+    "                    iv_val = iv_results.get(col, None)\n",
+    "                    if iv_val:\n",
+    "                        agreement = \"✓ agree\" if (abs(d_val) >= 0.5 and iv_val.information_value >= 0.1) or \\\n",
+    "                                                  (abs(d_val) < 0.2 and iv_val.information_value < 0.02) else \"~ partial\"\n",
+    "                        print(f\"  {col}: d={d_val:+.2f}, IV={iv_val.information_value:.3f} {agreement}\")\n",
+    "        else:\n",
+    "            print(\"  (No overlapping features to compare)\")\n",
+    "    \n",
+    "    # RECOMMENDATIONS\n",
+    "    print(\"\\n\" + \"─\"*70)\n",
+    "    print(\"🎯 FEATURE RECOMMENDATIONS\")\n",
+    "    print(\"─\"*70)\n",
+    "    \n",
+    "    if strong_iv:\n",
+    "        print(\"\\n🔴 INCLUDE (Strong IV)\")\n",
+    "        for col in strong_iv:\n",
+    "            r = iv_results[col]\n",
+    "            print(f\"   • {col}: IV={r.information_value:.3f}, KS={r.ks_statistic:.3f}\")\n",
+    "    \n",
+    "    if medium_iv:\n",
+    "        print(\"\\n🟡 INCLUDE (Medium IV)\")\n",
+    "        for col in medium_iv[:5]:\n",
+    "            r = iv_results[col]\n",
+    "            print(f\"   • {col}: IV={r.information_value:.3f}\")\n",
+    "    \n",
+    "    if not strong_iv and not medium_iv:\n",
+    "        print(\"\\nNo features with strong predictive power found.\")\n",
+    "        print(\"   → See 1c.12 (velocity) and 1c.13 (momentum) for derived features\")\n",
+    "        print(\"   → See 1c.16 for categorical feature analysis\")\n",
+    "else:\n",
+    "    print(\"Skipped: Requires entity column, target column, and numeric features\")\n",
+    "\n",
+    "# Store predictive power recommendations for pattern_summary\n",
+    "PREDICTIVE_POWER_RECOMMENDATIONS = []\n",
+    "if 'iv_results' in dir():\n",
+    "    for col, r in iv_results.items():\n",
+    "        if r.information_value >= 0.1:\n",
+    "            PREDICTIVE_POWER_RECOMMENDATIONS.append({\n",
+    "                \"action\": \"include_feature\", \"feature\": col,\n",
+    "                \"iv\": r.information_value, \"ks\": r.ks_statistic, \"priority\": \"high\",\n",
+    "                \"reason\": f\"Strong IV={r.information_value:.3f}, KS={r.ks_statistic:.3f}\",\n",
+    "                \"features\": [col]\n",
+    "            })\n",
+    "        elif r.information_value >= 0.02:\n",
+    "            PREDICTIVE_POWER_RECOMMENDATIONS.append({\n",
+    "                \"action\": \"include_feature\", \"feature\": col,\n",
+    "                \"iv\": r.information_value, \"ks\": r.ks_statistic, \"priority\": \"medium\",\n",
+    "                \"reason\": f\"Medium IV={r.information_value:.3f}\",\n",
+    "                \"features\": [col]\n",
+    "            })\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c8e8363",
+   "metadata": {
+    "papermill": {
+     "duration": 0.065203,
+     "end_time": "2026-02-02T13:01:15.505779",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:15.440576",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.16 Categorical Feature Analysis\n",
+    "\n",
+    "**📖 What This Measures:**\n",
+    "\n",
+    "For each categorical feature, we analyze how its categories relate to the target (retention/churn):\n",
+    "\n",
+    "| Metric | What It Measures | How to Read |\n",
+    "|--------|-----------------|-------------|\n",
+    "| **Cramér's V** | Overall association strength (0-1) | Higher = categories strongly predict target |\n",
+    "| **High-Risk Categories** | Categories with target rate < 90% of average | These segments churn more |\n",
+    "| **Low-Risk Categories** | Categories with target rate > 110% of average | These segments retain better |\n",
+    "\n",
+    "**Panel Guide:**\n",
+    "\n",
+    "| Panel | What It Shows | Color Scheme |\n",
+    "|-------|---------------|--------------|\n",
+    "| **Top-Left** | Feature ranking by Cramér's V | 🔴 Strong ≥0.3 / 🟠 Moderate ≥0.1 / 🔵 Weak |\n",
+    "| **Top-Right** | Count of features per effect bucket | 🟣 Purple gradient (darker = more significant bucket) |\n",
+    "| **Bottom-Left** | High/low risk category counts | 🔴 High-risk (churn) / 🟢 Low-risk (retain) |\n",
+    "| **Bottom-Right** | Category breakdown (top feature) | 🔴 Below avg / 🟢 Above avg / 🔵 Near avg |\n",
+    "\n",
+    "**Effect Strength Thresholds:**\n",
+    "| Cramér's V | Strength | Action |\n",
+    "|------------|----------|--------|\n",
+    "| ≥ 0.3 | Strong | Priority feature - include and consider interactions |\n",
+    "| 0.15–0.3 | Moderate | Include in model |\n",
+    "| 0.05–0.15 | Weak | May add noise, test impact |\n",
+    "| < 0.05 | Negligible | Consider dropping |\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "89ba3170",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:15.637541Z",
+     "iopub.status.busy": "2026-02-02T13:01:15.637431Z",
+     "iopub.status.idle": "2026-02-02T13:01:17.189978Z",
+     "shell.execute_reply": "2026-02-02T13:01:17.189424Z"
+    },
+    "papermill": {
+     "duration": 1.619747,
+     "end_time": "2026-02-02T13:01:17.191361",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:15.571614",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Categorical Feature Analysis\n",
+    "from customer_retention.stages.profiling import analyze_categorical_features\n",
+    "\n",
+    "if ENTITY_COLUMN and TARGET_COLUMN:\n",
+    "    print(\"=\"*70)\n",
+    "    print(\"CATEGORICAL FEATURE ANALYSIS\")\n",
+    "    print(\"=\"*70)\n",
+    "    \n",
+    "    # Aggregate to entity level (take mode for categorical columns)\n",
+    "    cat_cols = [c for c in df.select_dtypes(include=['object', 'category']).columns \n",
+    "                if c not in [ENTITY_COLUMN, TIME_COLUMN, TARGET_COLUMN]]\n",
+    "    \n",
+    "    if cat_cols:\n",
+    "        entity_cats_df = df.groupby(ENTITY_COLUMN).agg(\n",
+    "            {c: lambda x: x.mode().iloc[0] if len(x.mode()) > 0 else None for c in cat_cols}\n",
+    "        ).reset_index()\n",
+    "        entity_target = df.groupby(ENTITY_COLUMN)[TARGET_COLUMN].first().reset_index()\n",
+    "        entity_data = entity_cats_df.merge(entity_target, on=ENTITY_COLUMN)\n",
+    "        \n",
+    "        cat_result = analyze_categorical_features(entity_data, ENTITY_COLUMN, TARGET_COLUMN)\n",
+    "        \n",
+    "        print(f\"Features analyzed: {len(cat_result.feature_insights)}\")\n",
+    "        print(f\"Features filtered: {len(cat_result.filtered_columns)}\")\n",
+    "        print(f\"Overall target rate: {cat_result.overall_target_rate:.1%}\")\n",
+    "        \n",
+    "        if cat_result.feature_insights:\n",
+    "            # VISUALS\n",
+    "            fig = charts.categorical_analysis_panel(cat_result.feature_insights, cat_result.overall_target_rate)\n",
+    "            display_figure(fig)\n",
+    "            \n",
+    "            # DETAILS TABLE\n",
+    "            print(\"\\n📊 Feature Details:\")\n",
+    "            print(f\"{'Feature':<20} {'Cramér V':>10} {'Effect':>12} {'#Cats':>7} {'High Risk':>10} {'Low Risk':>10}\")\n",
+    "            print(\"-\" * 75)\n",
+    "            for insight in cat_result.feature_insights:\n",
+    "                print(f\"{insight.feature_name[:19]:<20} {insight.cramers_v:>10.3f} {insight.effect_strength:>12} \"\n",
+    "                      f\"{insight.n_categories:>7} {len(insight.high_risk_categories):>10} {len(insight.low_risk_categories):>10}\")\n",
+    "            \n",
+    "            # INTERPRETATION\n",
+    "            print(\"\\n\" + \"─\"*70)\n",
+    "            print(\"📖 INTERPRETATION\")\n",
+    "            print(\"─\"*70)\n",
+    "            \n",
+    "            strong = [i for i in cat_result.feature_insights if i.effect_strength == \"strong\"]\n",
+    "            moderate = [i for i in cat_result.feature_insights if i.effect_strength == \"moderate\"]\n",
+    "            weak = [i for i in cat_result.feature_insights if i.effect_strength in (\"weak\", \"negligible\")]\n",
+    "            \n",
+    "            if strong:\n",
+    "                print(f\"\\nStrong predictors ({len(strong)}): {', '.join(i.feature_name for i in strong)}\")\n",
+    "                print(\"  → These features have clear category-target relationships\")\n",
+    "                print(\"  → Include in model, consider one-hot encoding\")\n",
+    "            \n",
+    "            if moderate:\n",
+    "                print(f\"\\nModerate predictors ({len(moderate)}): {', '.join(i.feature_name for i in moderate)}\")\n",
+    "                print(\"  → Some predictive power, include if cardinality is reasonable\")\n",
+    "            \n",
+    "            if weak:\n",
+    "                print(f\"\\nWeak/negligible ({len(weak)}): {', '.join(i.feature_name for i in weak)}\")\n",
+    "                print(\"  → Limited predictive value, may add noise\")\n",
+    "            \n",
+    "            # High-risk category insights\n",
+    "            all_high_risk = [(i.feature_name, c) for i in cat_result.feature_insights for c in i.high_risk_categories[:2]]\n",
+    "            if all_high_risk:\n",
+    "                print(\"\\nHigh-risk segments (below-average retention):\")\n",
+    "                for feat, cat in all_high_risk[:5]:\n",
+    "                    print(f\"  • {feat} = '{cat}'\")\n",
+    "            \n",
+    "            # RECOMMENDATIONS\n",
+    "            print(\"\\n\" + \"─\"*70)\n",
+    "            print(\"🎯 FEATURE RECOMMENDATIONS\")\n",
+    "            print(\"─\"*70)\n",
+    "            \n",
+    "            if cat_result.recommendations:\n",
+    "                for rec in cat_result.recommendations:\n",
+    "                    priority_marker = \"🔴\" if rec.get('priority') == 'high' else \"🟡\"\n",
+    "                    print(f\"\\n{priority_marker} {rec.get('action', 'RECOMMENDATION').upper()}\")\n",
+    "                    print(f\"   {rec.get('reason', '')}\")\n",
+    "            else:\n",
+    "                # Generate recommendations based on analysis\n",
+    "                if strong:\n",
+    "                    print(\"\\n🔴 INCLUDE STRONG PREDICTORS\")\n",
+    "                    for i in strong:\n",
+    "                        print(f\"   • {i.feature_name}: V={i.cramers_v:.3f}, {i.n_categories} categories\")\n",
+    "                \n",
+    "                if any(i.n_categories > 20 for i in cat_result.feature_insights):\n",
+    "                    high_card = [i for i in cat_result.feature_insights if i.n_categories > 20]\n",
+    "                    print(\"\\n🟡 HIGH CARDINALITY - CONSIDER GROUPING\")\n",
+    "                    for i in high_card:\n",
+    "                        print(f\"   • {i.feature_name}: {i.n_categories} categories → group rare categories\")\n",
+    "                \n",
+    "                if not strong and not moderate:\n",
+    "                    print(\"\\nNo strong categorical predictors found.\")\n",
+    "                    print(\"   • Consider creating derived features (e.g., category combinations)\")\n",
+    "                    print(\"   • Or focus on numeric/temporal features\")\n",
+    "        else:\n",
+    "            print(\"\\nNo categorical features passed filtering criteria.\")\n",
+    "            if cat_result.filtered_columns:\n",
+    "                print(\"Filtered out:\")\n",
+    "                for col in cat_result.filtered_columns[:5]:\n",
+    "                    reason = cat_result.filter_reasons.get(col, \"unknown\")\n",
+    "                    print(f\"  • {col}: {reason}\")\n",
+    "    else:\n",
+    "        print(\"No categorical columns found in dataset.\")\n",
+    "else:\n",
+    "    print(\"Skipped: Requires both entity and target columns\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9c426663",
+   "metadata": {
+    "papermill": {
+     "duration": 0.066164,
+     "end_time": "2026-02-02T13:01:17.361718",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:17.295554",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.17 Feature Engineering Summary\n",
+    "\n",
+    "**📋 Feature Types with Configured Windows:**\n",
+    "\n",
+    "The table below shows feature formulas using windows derived from 01a findings.\n",
+    "Run the next cell to see actual values for your data.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "30ee4efd",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:01:17.498129Z",
+     "iopub.status.busy": "2026-02-02T13:01:17.497998Z",
+     "iopub.status.idle": "2026-02-02T13:02:46.116785Z",
+     "shell.execute_reply": "2026-02-02T13:02:46.116423Z"
+    },
+    "papermill": {
+     "duration": 88.753341,
+     "end_time": "2026-02-02T13:02:46.183612",
+     "exception": false,
+     "start_time": "2026-02-02T13:01:17.430271",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Feature Engineering Recommendations\n",
+    "print(\"=\"*80)\n",
+    "print(\"FEATURE ENGINEERING RECOMMENDATIONS\")\n",
+    "print(\"=\"*80)\n",
+    "\n",
+    "# Display configured windows from pattern_config\n",
+    "momentum_pairs = pattern_config.get_momentum_pairs()\n",
+    "short_w = momentum_pairs[0][0] if momentum_pairs else 7\n",
+    "long_w = momentum_pairs[0][1] if momentum_pairs else 30\n",
+    "\n",
+    "print(f\"\"\"\n",
+    "┌─────────────────┬────────────────────────────────────────────────────┐\n",
+    "│ Feature Type    │ Formula (using configured windows)                 │\n",
+    "├─────────────────┼────────────────────────────────────────────────────┤\n",
+    "│ Velocity        │ (value_now - value_{short_w}d_ago) / {short_w}                 │\n",
+    "│ Acceleration    │ velocity_now - velocity_{short_w}d_ago                   │\n",
+    "│ Momentum        │ mean_{short_w}d / mean_{long_w}d                              │\n",
+    "│ Lag             │ df[col].shift(N)                                   │\n",
+    "│ Rolling Mean    │ df[col].rolling({short_w}).mean()                        │\n",
+    "│ Rolling Std     │ df[col].rolling({long_w}).std()                         │\n",
+    "│ Ratio           │ sum_{long_w}d / sum_all_time                            │\n",
+    "└─────────────────┴────────────────────────────────────────────────────┘\n",
+    "\n",
+    "Windows derived from 01a findings: {pattern_config.aggregation_windows}\n",
+    "Velocity window: {pattern_config.velocity_window_days}d\n",
+    "Momentum pairs: {momentum_pairs}\n",
+    "\"\"\")\n",
+    "\n",
+    "# Framework recommendations (without target - event-level data)\n",
+    "if 'feature_analyzer' in dir() and sparkline_cols:\n",
+    "    recommendations = feature_analyzer.get_feature_recommendations(\n",
+    "        df, value_columns=sparkline_cols, target_column=None\n",
+    "    )\n",
+    "    if recommendations:\n",
+    "        print(\"🎯 Framework Recommendations (based on temporal patterns):\")\n",
+    "        for rec in recommendations[:5]:\n",
+    "            print(f\"   • {rec.feature_type.value}: {rec.source_column} → {rec.feature_name}\")\n",
+    "            print(f\"     Formula: {rec.formula}\")\n",
+    "            print(f\"     Rationale: {rec.rationale}\")\n",
+    "        print(\"\"\"\n",
+    "💡 Note: Target-based recommendations require entity-level data.\n",
+    "   Run notebook 01d first to aggregate, then 02 for target analysis.\n",
+    "\"\"\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f2d68de1",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:02:46.317914Z",
+     "iopub.status.busy": "2026-02-02T13:02:46.317801Z",
+     "iopub.status.idle": "2026-02-02T13:02:46.322153Z",
+     "shell.execute_reply": "2026-02-02T13:02:46.321771Z"
+    },
+    "papermill": {
+     "duration": 0.071965,
+     "end_time": "2026-02-02T13:02:46.322701",
+     "exception": false,
+     "start_time": "2026-02-02T13:02:46.250736",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "print(\"\\n\" + \"=\"*70)\n",
+    "print(\"TEMPORAL PATTERN SUMMARY\")\n",
+    "print(\"=\"*70)\n",
+    "\n",
+    "# Windows used\n",
+    "print(f\"\\n⚙️ CONFIGURED WINDOWS: {pattern_config.aggregation_windows}\")\n",
+    "print(f\"   Velocity: {pattern_config.velocity_window_days}d | Momentum: {pattern_config.get_momentum_pairs()}\")\n",
+    "\n",
+    "# Trend summary\n",
+    "print(f\"\\n📈 TREND:\")\n",
+    "print(f\"   Direction: {trend_result.direction.value}\")\n",
+    "print(f\"   Confidence: {trend_result.confidence}\")\n",
+    "\n",
+    "# Seasonality summary\n",
+    "print(f\"\\n🔁 SEASONALITY:\")\n",
+    "if seasonality_results:\n",
+    "    for sr in seasonality_results[:2]:\n",
+    "        period_name = sr.period_name or f\"{sr.period}-day\"\n",
+    "        print(f\"   {period_name.title()} pattern (strength: {sr.strength:.2f})\")\n",
+    "else:\n",
+    "    print(\"   No significant seasonality detected\")\n",
+    "\n",
+    "# Recency summary\n",
+    "if ENTITY_COLUMN:\n",
+    "    print(f\"\\n⏱️ RECENCY:\")\n",
+    "    print(f\"   Median: {recency_result.median_recency_days:.0f} days\")\n",
+    "    if recency_result.target_correlation:\n",
+    "        corr = recency_result.target_correlation\n",
+    "        print(f\"   Target correlation: {corr:.3f} {'(strong signal)' if abs(corr) > 0.3 else ''}\")\n",
+    "\n",
+    "# Velocity summary (if computed)\n",
+    "if 'velocity_summary' in dir() and velocity_summary:\n",
+    "    print(f\"\\n🚀 VELOCITY ({pattern_config.velocity_window_days}d window):\")\n",
+    "    divergent = [col for col, v in velocity_summary.items() if v.get('divergent')]\n",
+    "    if divergent:\n",
+    "        print(f\"   Divergent columns (retained vs churned): {divergent}\")\n",
+    "    else:\n",
+    "        print(\"   No significant divergence between cohorts\")\n",
+    "\n",
+    "# Momentum summary (if computed)\n",
+    "if 'momentum_data' in dir() and momentum_data:\n",
+    "    print(f\"\\n📊 MOMENTUM ({pattern_config.get_momentum_pairs()[0] if pattern_config.get_momentum_pairs() else 'N/A'}):\")\n",
+    "    if 'divergent_cols' in dir() and divergent_cols:\n",
+    "        # Filter out target to prevent misleading metadata\n",
+    "        filtered_divergent = [c for c in divergent_cols if c.lower() != TARGET_COLUMN.lower()] if TARGET_COLUMN else divergent_cols\n",
+    "        if filtered_divergent:\n",
+    "            print(f\"   High-signal columns: {filtered_divergent}\")\n",
+    "        else:\n",
+    "            print(\"   No significant momentum differences detected (target excluded)\")\n",
+    "    else:\n",
+    "        print(\"   No significant momentum differences detected\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "09773d2b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:02:46.455210Z",
+     "iopub.status.busy": "2026-02-02T13:02:46.455104Z",
+     "iopub.status.idle": "2026-02-02T13:02:46.458067Z",
+     "shell.execute_reply": "2026-02-02T13:02:46.457726Z"
+    },
+    "papermill": {
+     "duration": 0.070553,
+     "end_time": "2026-02-02T13:02:46.458653",
+     "exception": false,
+     "start_time": "2026-02-02T13:02:46.388100",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Feature engineering recommendations based on patterns\n",
+    "print(\"\\n\" + \"=\"*70)\n",
+    "print(\"RECOMMENDED TEMPORAL FEATURES\")\n",
+    "print(\"=\"*70)\n",
+    "\n",
+    "print(\"\\n\\U0001f6e0\\ufe0f Based on detected patterns, consider these features:\\n\")\n",
+    "\n",
+    "print(\"1. RECENCY FEATURES:\")\n",
+    "print(\"   - days_since_last_event\")\n",
+    "print(\"   - log_days_since_last_event (if right-skewed)\")\n",
+    "print(\"   - recency_bucket (categorical: 0-7d, 8-30d, etc.)\")\n",
+    "\n",
+    "if seasonality_results:\n",
+    "    weekly = any(6 <= sr.period <= 8 for sr in seasonality_results)\n",
+    "    monthly = any(28 <= sr.period <= 32 for sr in seasonality_results)\n",
+    "    \n",
+    "    print(\"\\n2. SEASONALITY FEATURES:\")\n",
+    "    if weekly:\n",
+    "        print(\"   - is_weekend (binary)\")\n",
+    "        print(\"   - day_of_week_sin, day_of_week_cos (cyclical encoding)\")\n",
+    "    if monthly:\n",
+    "        print(\"   - day_of_month\")\n",
+    "        print(\"   - is_month_start, is_month_end\")\n",
+    "\n",
+    "print(\"\\n3. TREND-ADJUSTED FEATURES:\")\n",
+    "if trend_result.direction in [TrendDirection.INCREASING, TrendDirection.DECREASING]:\n",
+    "    print(\"   - event_count_recent_vs_overall (ratio)\")\n",
+    "    print(\"   - activity_trend_direction (for each entity)\")\n",
+    "else:\n",
+    "    print(\"   - Standard time-window aggregations should work well\")\n",
+    "\n",
+    "print(\"\\n4. COHORT FEATURES:\")\n",
+    "print(\"   - cohort_month (categorical or ordinal)\")\n",
+    "print(\"   - tenure_days (days since first event)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "532bcc5b",
+   "metadata": {
+    "papermill": {
+     "duration": 0.067259,
+     "end_time": "2026-02-02T13:02:46.591399",
+     "exception": false,
+     "start_time": "2026-02-02T13:02:46.524140",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1c.18 Save Pattern Analysis Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "31e14ee3",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:02:46.757514Z",
+     "iopub.status.busy": "2026-02-02T13:02:46.757379Z",
+     "iopub.status.idle": "2026-02-02T13:02:46.788737Z",
+     "shell.execute_reply": "2026-02-02T13:02:46.788264Z"
+    },
+    "papermill": {
+     "duration": 0.09925,
+     "end_time": "2026-02-02T13:02:46.789508",
+     "exception": false,
+     "start_time": "2026-02-02T13:02:46.690258",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Store pattern analysis results in findings with actionable recommendations\n",
+    "pattern_summary = {\n",
+    "    \"windows_used\": {\n",
+    "        # Note: aggregation_windows already stored in ts_metadata.suggested_aggregations\n",
+    "        \"velocity_window\": pattern_config.velocity_window_days,\n",
+    "        \"momentum_pairs\": pattern_config.get_momentum_pairs(),\n",
+    "    },\n",
+    "    \"trend\": {\n",
+    "        \"direction\": trend_result.direction.value,\n",
+    "        \"strength\": trend_result.strength,\n",
+    "        \"confidence\": trend_result.confidence,\n",
+    "        \"recommendations\": TREND_RECOMMENDATIONS if 'TREND_RECOMMENDATIONS' in dir() else [],\n",
+    "    },\n",
+    "    \"seasonality\": {\n",
+    "        \"patterns\": [\n",
+    "            {\"period\": sr.period, \"name\": sr.period_name, \"strength\": sr.strength,\n",
+    "             \"window_aligned\": sr.period in window_lags if 'window_lags' in dir() else False}\n",
+    "            for sr in seasonality_results\n",
+    "        ],\n",
+    "        \"recommendations\": [],\n",
+    "    },\n",
+    "}\n",
+    "\n",
+    "# Generate seasonality recommendations\n",
+    "seasonality_recs = []\n",
+    "if seasonality_results:\n",
+    "    strong_patterns = [sr for sr in seasonality_results if sr.strength > 0.5]\n",
+    "    moderate_patterns = [sr for sr in seasonality_results if 0.3 < sr.strength <= 0.5]\n",
+    "    \n",
+    "    for sr in seasonality_results:\n",
+    "        if sr.period == 7:\n",
+    "            seasonality_recs.append({\n",
+    "                \"action\": \"add_cyclical_feature\", \"feature\": \"day_of_week\", \"encoding\": \"sin_cos\",\n",
+    "                \"reason\": f\"Weekly pattern detected (strength={sr.strength:.2f})\"\n",
+    "            })\n",
+    "        elif sr.period in [28, 30, 31]:\n",
+    "            seasonality_recs.append({\n",
+    "                \"action\": \"add_cyclical_feature\", \"feature\": \"day_of_month\", \"encoding\": \"sin_cos\",\n",
+    "                \"reason\": f\"Monthly pattern detected (strength={sr.strength:.2f})\"\n",
+    "            })\n",
+    "        elif sr.period in [90, 91, 92]:\n",
+    "            seasonality_recs.append({\n",
+    "                \"action\": \"add_cyclical_feature\", \"feature\": \"quarter\", \"encoding\": \"sin_cos\",\n",
+    "                \"reason\": f\"Quarterly pattern detected (strength={sr.strength:.2f})\"\n",
+    "            })\n",
+    "    \n",
+    "    if strong_patterns:\n",
+    "        seasonality_recs.append({\n",
+    "            \"action\": \"consider_deseasonalization\", \"periods\": [sr.period for sr in strong_patterns],\n",
+    "            \"reason\": \"Strong seasonal patterns may dominate signal\"\n",
+    "        })\n",
+    "    \n",
+    "    if 'window_lags' in dir() and window_lags:\n",
+    "        aligned = [sr for sr in seasonality_results if sr.period in window_lags]\n",
+    "        if aligned:\n",
+    "            seasonality_recs.append({\n",
+    "                \"action\": \"window_captures_cycle\", \"windows\": [sr.period for sr in aligned],\n",
+    "                \"reason\": \"Aggregation window aligns with seasonal cycle\"\n",
+    "            })\n",
+    "        else:\n",
+    "            seasonality_recs.append({\n",
+    "                \"action\": \"window_partial_cycle\",\n",
+    "                \"detected_periods\": [sr.period for sr in seasonality_results], \"windows\": window_lags,\n",
+    "                \"reason\": \"Aggregation windows don't align with detected cycles\"\n",
+    "            })\n",
+    "\n",
+    "pattern_summary[\"seasonality\"][\"recommendations\"] = seasonality_recs\n",
+    "\n",
+    "# Add temporal pattern recommendations\n",
+    "if 'TEMPORAL_PATTERN_RECOMMENDATIONS' in dir() and TEMPORAL_PATTERN_RECOMMENDATIONS:\n",
+    "    pattern_summary[\"temporal_patterns\"] = {\n",
+    "        \"patterns\": [{\"name\": r[\"pattern\"], \"variation\": r.get(\"variation\", 0), \"priority\": r[\"priority\"]} for r in TEMPORAL_PATTERN_RECOMMENDATIONS],\n",
+    "        \"recommendations\": [{\"pattern\": r[\"pattern\"], \"features\": r[\"features\"], \"priority\": r[\"priority\"], \"reason\": r[\"reason\"]} for r in TEMPORAL_PATTERN_RECOMMENDATIONS if r.get(\"features\")],\n",
+    "    }\n",
+    "\n",
+    "# Add recency analysis with recommendations\n",
+    "if ENTITY_COLUMN:\n",
+    "    recency_data = {\n",
+    "        \"median_days\": recency_result.median_recency_days,\n",
+    "        \"target_correlation\": recency_result.target_correlation,\n",
+    "    }\n",
+    "    if recency_comparison:\n",
+    "        recency_data.update({\n",
+    "            \"effect_size\": recency_comparison.cohens_d,\n",
+    "            \"effect_interpretation\": recency_comparison.effect_interpretation,\n",
+    "            \"distribution_pattern\": recency_comparison.distribution_pattern,\n",
+    "            \"inflection_bucket\": recency_comparison.inflection_bucket,\n",
+    "            \"retained_median\": recency_comparison.retained_stats.median,\n",
+    "            \"churned_median\": recency_comparison.churned_stats.median,\n",
+    "            \"key_findings\": [{\"finding\": f.finding, \"metric\": f.metric_name, \"value\": f.metric_value} for f in recency_comparison.key_findings],\n",
+    "            \"recommendations\": RECENCY_RECOMMENDATIONS,\n",
+    "        })\n",
+    "    pattern_summary[\"recency\"] = recency_data\n",
+    "\n",
+    "# Add velocity results\n",
+    "if 'velocity_summary' in dir() and velocity_summary:\n",
+    "    pattern_summary[\"velocity\"] = {col: {\"mean_velocity\": v[\"mean_velocity\"], \"direction\": v[\"direction\"]} for col, v in velocity_summary.items()}\n",
+    "\n",
+    "# Add momentum results\n",
+    "if 'momentum_data' in dir() and momentum_data:\n",
+    "    pattern_summary[\"momentum\"] = {col: {\"retained\": v[\"retained\"], \"churned\": v[\"churned\"]} for col, v in momentum_data.items()}\n",
+    "    if 'divergent_cols' in dir():\n",
+    "        pattern_summary[\"momentum\"][\"_divergent_columns\"] = [c for c in divergent_cols if c.lower() != TARGET_COLUMN.lower()] if TARGET_COLUMN else divergent_cols\n",
+    "\n",
+    "# Add cohort analysis results\n",
+    "if 'COHORT_RECOMMENDATIONS' in dir() and COHORT_RECOMMENDATIONS:\n",
+    "    pattern_summary[\"cohort\"] = {\"recommendations\": COHORT_RECOMMENDATIONS}\n",
+    "\n",
+    "\n",
+    "# Add categorical analysis results\n",
+    "if 'cat_result' in dir() and cat_result.feature_insights:\n",
+    "    pattern_summary[\"categorical\"] = {\n",
+    "        \"overall_target_rate\": cat_result.overall_target_rate,\n",
+    "        \"features_analyzed\": len(cat_result.feature_insights),\n",
+    "        \"columns_filtered\": len(cat_result.filtered_columns),\n",
+    "        \"insights\": [\n",
+    "            {\"feature\": i.feature_name, \"cramers_v\": i.cramers_v, \"effect_strength\": i.effect_strength,\n",
+    "             \"high_risk\": i.high_risk_categories[:3], \"low_risk\": i.low_risk_categories[:3]}\n",
+    "            for i in cat_result.feature_insights[:10]\n",
+    "        ],\n",
+    "        \"recommendations\": cat_result.recommendations,\n",
+    "        \"key_findings\": cat_result.key_findings,\n",
+    "    }\n",
+    "\n",
+    "# Add velocity analysis results and recommendations\n",
+    "if 'VELOCITY_RECOMMENDATIONS' in dir() and VELOCITY_RECOMMENDATIONS:\n",
+    "    pattern_summary[\"velocity\"][\"recommendations\"] = VELOCITY_RECOMMENDATIONS\n",
+    "\n",
+    "# Add momentum recommendations (separate from momentum data which is already stored)\n",
+    "if 'MOMENTUM_RECOMMENDATIONS' in dir() and MOMENTUM_RECOMMENDATIONS:\n",
+    "    if \"momentum\" not in pattern_summary:\n",
+    "        pattern_summary[\"momentum\"] = {}\n",
+    "    pattern_summary[\"momentum\"][\"recommendations\"] = MOMENTUM_RECOMMENDATIONS\n",
+    "\n",
+    "# Add lag correlation recommendations\n",
+    "if 'LAG_RECOMMENDATIONS' in dir() and LAG_RECOMMENDATIONS:\n",
+    "    pattern_summary[\"lag\"] = {\"recommendations\": LAG_RECOMMENDATIONS}\n",
+    "\n",
+    "# Add sparkline analysis recommendations (trend, seasonality, scaling)\n",
+    "if 'SPARKLINE_RECOMMENDATIONS' in dir() and SPARKLINE_RECOMMENDATIONS:\n",
+    "    pattern_summary[\"sparkline\"] = {\"recommendations\": SPARKLINE_RECOMMENDATIONS}\n",
+    "\n",
+    "# Add effect size recommendations (feature prioritization)\n",
+    "if 'EFFECT_SIZE_RECOMMENDATIONS' in dir() and EFFECT_SIZE_RECOMMENDATIONS:\n",
+    "    pattern_summary[\"effect_size\"] = {\"recommendations\": EFFECT_SIZE_RECOMMENDATIONS}\n",
+    "\n",
+    "# Add predictive power recommendations (IV/KS based)\n",
+    "if 'PREDICTIVE_POWER_RECOMMENDATIONS' in dir() and PREDICTIVE_POWER_RECOMMENDATIONS:\n",
+    "    pattern_summary[\"predictive_power\"] = {\"recommendations\": PREDICTIVE_POWER_RECOMMENDATIONS}\n",
+    "\n",
+    "# Generate feature flags for 01d aggregation\n",
+    "# These flags tell 01d which optional features to include based on analysis results\n",
+    "pattern_summary[\"feature_flags\"] = {\n",
+    "    \"include_recency\": (\n",
+    "        recency_comparison.cohens_d > 0.2 \n",
+    "        if 'recency_comparison' in dir() and recency_comparison \n",
+    "        else True\n",
+    "    ),\n",
+    "    \"include_tenure\": True,  # Default on; could be derived from tenure analysis if available\n",
+    "    \"include_lifecycle_quadrant\": ts_meta.temporal_segmentation_recommendation is not None if 'ts_meta' in dir() else False,\n",
+    "    \"include_trend_features\": bool(pattern_summary.get(\"trend\", {}).get(\"recommendations\")),\n",
+    "    \"include_seasonality_features\": bool(pattern_summary.get(\"seasonality\", {}).get(\"recommendations\")),\n",
+    "    \"include_cohort_features\": not any(\n",
+    "        r.get(\"action\") == \"skip_cohort_features\"\n",
+    "        for r in pattern_summary.get(\"cohort\", {}).get(\"recommendations\", [])\n",
+    "    ),\n",
+    "}\n",
+    "\n",
+    "# Save to findings\n",
+    "if not findings.metadata:\n",
+    "    findings.metadata = {}\n",
+    "findings.metadata[\"temporal_patterns\"] = pattern_summary\n",
+    "findings.save(FINDINGS_PATH)\n",
+    "\n",
+    "print(f\"Pattern analysis saved to: {FINDINGS_PATH}\")\n",
+    "print(f\"Saved sections: {list(pattern_summary.keys())}\")\n",
+    "\n",
+    "# Print recency recommendations\n",
+    "if pattern_summary.get(\"recency\", {}).get(\"recommendations\"):\n",
+    "    recency_recs = pattern_summary[\"recency\"][\"recommendations\"]\n",
+    "    print(f\"\\n⏱️ RECENCY FEATURES TO ADD ({len(recency_recs)}):\")\n",
+    "    for rec in recency_recs:\n",
+    "        priority_icon = {\"high\": \"🔴\", \"medium\": \"🟡\", \"low\": \"🟢\"}.get(rec.get(\"priority\", \"medium\"), \"⚪\")\n",
+    "        features = rec.get(\"features\", [])\n",
+    "        if features:\n",
+    "            print(f\"   {priority_icon} [{rec['priority'].upper()}] {', '.join(features)}\")\n",
+    "            print(f\"      {rec['reason']}\")\n",
+    "\n",
+    "# Print cohort recommendations\n",
+    "if \"cohort\" in pattern_summary:\n",
+    "    cohort_recs = pattern_summary[\"cohort\"].get(\"recommendations\", [])\n",
+    "    feature_recs = [r for r in cohort_recs if r.get(\"features\")]\n",
+    "    skip_recs = [r for r in cohort_recs if r.get(\"action\") == \"skip_cohort_features\"]\n",
+    "    if skip_recs:\n",
+    "        print(f\"\\n👥 COHORT: Skip cohort features ({skip_recs[0]['reason']})\")\n",
+    "    elif feature_recs:\n",
+    "        print(f\"\\n👥 COHORT FEATURES TO ADD:\")\n",
+    "        for rec in feature_recs:\n",
+    "            print(f\"   • {', '.join(rec['features'])} ({rec['priority']} priority)\")\n",
+    "\n",
+    "# Print trend recommendations\n",
+    "if pattern_summary.get(\"trend\", {}).get(\"recommendations\"):\n",
+    "    trend_recs = [r for r in pattern_summary[\"trend\"][\"recommendations\"] if r.get(\"features\")]\n",
+    "    if trend_recs:\n",
+    "        print(f\"\\n📈 TREND FEATURES TO ADD ({len(trend_recs)}):\")\n",
+    "        for rec in trend_recs:\n",
+    "            print(f\"   • {', '.join(rec['features'])} ({rec['priority']} priority)\")\n",
+    "\n",
+    "# Print temporal pattern recommendations\n",
+    "if \"temporal_patterns\" in pattern_summary:\n",
+    "    tp_recs = pattern_summary[\"temporal_patterns\"].get(\"recommendations\", [])\n",
+    "    if tp_recs:\n",
+    "        print(f\"\\n📅 TEMPORAL PATTERN FEATURES TO ADD ({len(tp_recs)}):\")\n",
+    "        for rec in tp_recs:\n",
+    "            print(f\"   • {rec['pattern']}: {', '.join(rec['features'])} ({rec['priority']} priority)\")\n",
+    "\n",
+    "\n",
+    "# Print categorical recommendations\n",
+    "if pattern_summary.get(\"categorical\", {}).get(\"recommendations\"):\n",
+    "    cat_recs = pattern_summary[\"categorical\"][\"recommendations\"]\n",
+    "    print(f\"\\n🏷️ CATEGORICAL FEATURE RECOMMENDATIONS ({len(cat_recs)}):\")\n",
+    "    for rec in cat_recs:\n",
+    "        priority_icon = {\"high\": \"🔴\", \"medium\": \"🟡\", \"low\": \"🟢\"}.get(rec.get(\"priority\", \"medium\"), \"⚪\")\n",
+    "        features = rec.get(\"features\", [])\n",
+    "        if features:\n",
+    "            print(f\"   {priority_icon} [{rec['priority'].upper()}] {rec['action']}\")\n",
+    "            print(f\"      {rec['reason']}\")\n",
+    "# Print seasonality recommendations\n",
+    "if seasonality_recs:\n",
+    "    print(f\"\\n🔁 SEASONALITY RECOMMENDATIONS ({len(seasonality_recs)}):\")\n",
+    "    for rec in seasonality_recs:\n",
+    "        action = rec[\"action\"].replace(\"_\", \" \").title()\n",
+    "        print(f\"   • {action}: {rec['reason']}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "773f3e64",
+   "metadata": {
+    "papermill": {
+     "duration": 0.067772,
+     "end_time": "2026-02-02T13:02:46.924911",
+     "exception": false,
+     "start_time": "2026-02-02T13:02:46.857139",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## Summary: What We Learned\n",
+    "\n",
+    "In this notebook, we analyzed temporal patterns:\n",
+    "\n",
+    "1. **Trend Detection** - Identified long-term direction in data\n",
+    "2. **Seasonality** - Found periodic patterns (weekly, monthly)\n",
+    "3. **Cohort Analysis** - Compared behavior by entity join date\n",
+    "4. **Recency Analysis** - Measured how recent activity relates to outcomes\n",
+    "5. **Feature Recommendations** - Generated feature engineering suggestions\n",
+    "\n",
+    "## Pattern Summary\n",
+    "\n",
+    "| Pattern | Status | Recommendation |\n",
+    "|---------|--------|----------------|\n",
+    "| Trend | Check findings | Detrend if strong |\n",
+    "| Seasonality | Check findings | Add cyclical features |\n",
+    "| Cohort Effects | Check findings | Add cohort indicators |\n",
+    "| Recency Effects | Check findings | Prioritize recent windows |\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Next Steps\n",
+    "\n",
+    "**Complete the Event Bronze Track:**\n",
+    "- **01d_event_aggregation.ipynb** - Aggregate events to entity-level (produces new dataset)\n",
+    "\n",
+    "After 01d produces the aggregated dataset, continue with:\n",
+    "- **02_column_deep_dive.ipynb** - Profile aggregated feature distributions\n",
+    "- **03_quality_assessment.ipynb** - Quality checks on aggregated data\n",
+    "- **04_relationship_analysis.ipynb** - Feature correlations and relationships\n",
+    "\n",
+    "The aggregated data from 01d becomes the input for the Entity Bronze Track."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aaab3af5",
+   "metadata": {
+    "papermill": {
+     "duration": 0.068901,
+     "end_time": "2026-02-02T13:02:47.115122",
+     "exception": false,
+     "start_time": "2026-02-02T13:02:47.046221",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "> **Save Reminder:** Save this notebook (Ctrl+S / Cmd+S) before running the next one.\n",
+    "> The next notebook will automatically export this notebook's HTML documentation from the saved file."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.4"
+  },
+  "papermill": {
+   "default_parameters": {},
+   "duration": 99.332892,
+   "end_time": "2026-02-02T13:02:47.701993",
+   "environment_variables": {},
+   "exception": null,
+   "input_path": "/Users/Vital/python/CustomerRetention/exploration_notebooks/01c_temporal_patterns.ipynb",
+   "output_path": "/Users/Vital/python/CustomerRetention/exploration_notebooks/01c_temporal_patterns.ipynb",
+   "parameters": {},
+   "start_time": "2026-02-02T13:01:08.369101",
+   "version": "2.6.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}