churnkit 0.75.0a1__py3-none-any.whl

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

@@ -0,0 +1,1690 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b25b3276",
+   "metadata": {
+    "papermill": {
+     "duration": 0.004672,
+     "end_time": "2026-02-02T13:00:43.539546",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:43.534874",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Chapter 1a: Temporal Deep Dive (Event Bronze Track)\n",
+    "\n",
+    "**Purpose:** Analyze event-level (time series) datasets with focus on temporal patterns, entity lifecycles, and event frequency distributions.\n",
+    "\n",
+    "**When to use this notebook:**\n",
+    "- Your dataset was detected as `EVENT_LEVEL` granularity in notebook 01\n",
+    "- You have multiple rows per entity (customer, user, etc.)\n",
+    "- Each row represents an event with a timestamp\n",
+    "\n",
+    "**What you'll learn:**\n",
+    "- How to profile entity lifecycles (first event, last event, duration)\n",
+    "- Understanding event frequency distributions per entity\n",
+    "- Inter-event timing patterns and their implications\n",
+    "- Time series-specific feature engineering opportunities\n",
+    "\n",
+    "**Outputs:**\n",
+    "- Entity lifecycle visualizations\n",
+    "- Event frequency distribution analysis\n",
+    "- Inter-event timing statistics\n",
+    "- Updated exploration findings with time series metadata\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Understanding Time Series Profiling\n",
+    "\n",
+    "| Metric | Description | Why It Matters |\n",
+    "|--------|-------------|----------------|\n",
+    "| **Events per Entity** | Distribution of event counts | Identifies power users vs. one-time users |\n",
+    "| **Entity Lifecycle** | Duration from first to last event | Reveals customer tenure patterns |\n",
+    "| **Inter-event Time** | Time between consecutive events | Indicates engagement patterns |\n",
+    "| **Time Span** | Overall data period coverage | Helps plan time window aggregations |\n",
+    "\n",
+    "**Aggregation Windows (used in notebook 01d):**\n",
+    "- 24h: Very recent activity\n",
+    "- 7d: Weekly patterns\n",
+    "- 30d: Monthly patterns\n",
+    "- 90d: Quarterly trends\n",
+    "- 180d: Semi-annual patterns\n",
+    "- 365d: Annual patterns\n",
+    "- all-time: Historical totals"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b77d73c3",
+   "metadata": {
+    "papermill": {
+     "duration": 0.00563,
+     "end_time": "2026-02-02T13:00:43.560252",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:43.554622",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1a.1 Load Previous Findings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f637550c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:43.566424Z",
+     "iopub.status.busy": "2026-02-02T13:00:43.566300Z",
+     "iopub.status.idle": "2026-02-02T13:00:45.358347Z",
+     "shell.execute_reply": "2026-02-02T13:00:45.357703Z"
+    },
+    "papermill": {
+     "duration": 1.796066,
+     "end_time": "2026-02-02T13:00:45.359167",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:43.563101",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.analysis.notebook_progress import track_and_export_previous\n",
+    "track_and_export_previous(\"01a_temporal_deep_dive.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",
+    "    TimeSeriesProfiler, TimeSeriesProfile,\n",
+    "    TypeDetector,\n",
+    "    DistributionAnalyzer, TransformationType,\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 customer_retention.core.config.experiments import FINDINGS_DIR, EXPERIMENTS_DIR, OUTPUT_DIR, setup_experiments_structure\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ec0ff3ea",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:45.365797Z",
+     "iopub.status.busy": "2026-02-02T13:00:45.365667Z",
+     "iopub.status.idle": "2026-02-02T13:00:45.391020Z",
+     "shell.execute_reply": "2026-02-02T13:00:45.390535Z"
+    },
+    "papermill": {
+     "duration": 0.02932,
+     "end_time": "2026-02-02T13:00:45.391503",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:45.362183",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# === CONFIGURATION ===\n",
+    "# Option 1: Set the exact path from notebook 01 output\n",
+    "# FINDINGS_PATH = \"../experiments/findings/transactions_abc123_findings.yaml\"\n",
+    "\n",
+    "# Option 2: Auto-discover findings files\n",
+    "from pathlib import Path\n",
+    "\n",
+    "# FINDINGS_DIR imported from customer_retention.core.config.experiments\n",
+    "\n",
+    "# Find all findings files\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",
+    "# Sort by modification time (most recent first)\n",
+    "findings_files.sort(key=lambda f: f.stat().st_mtime, reverse=True)\n",
+    "FINDINGS_PATH = str(findings_files[0])\n",
+    "\n",
+    "print(f\"Found {len(findings_files)} findings file(s)\")\n",
+    "print(f\"Using: {FINDINGS_PATH}\")\n",
+    "if len(findings_files) > 1:\n",
+    "    print(f\"Other available: {[str(f.name) for f in findings_files[1:3]]}\")\n",
+    "\n",
+    "findings = ExplorationFindings.load(FINDINGS_PATH)\n",
+    "print(f\"\\nLoaded findings for {findings.column_count} columns from {findings.source_path}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1cb51799",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:45.397630Z",
+     "iopub.status.busy": "2026-02-02T13:00:45.397531Z",
+     "iopub.status.idle": "2026-02-02T13:00:45.399987Z",
+     "shell.execute_reply": "2026-02-02T13:00:45.399515Z"
+    },
+    "papermill": {
+     "duration": 0.006267,
+     "end_time": "2026-02-02T13:00:45.400468",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:45.394201",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Verify this is a time series dataset\n",
+    "if findings.is_time_series:\n",
+    "    ts_meta = findings.time_series_metadata\n",
+    "    temporal_pattern = (ts_meta.temporal_pattern or \"unknown\").upper()\n",
+    "    print(f\"\\u2705 Dataset confirmed as {temporal_pattern} (event-level)\")\n",
+    "    print(f\"   Entity column: {ts_meta.entity_column}\")\n",
+    "    print(f\"   Time column: {ts_meta.time_column}\")\n",
+    "    print(f\"   Avg events per entity: {ts_meta.avg_events_per_entity:.1f}\" if ts_meta.avg_events_per_entity else \"\")\n",
+    "else:\n",
+    "    print(\"\\u26a0\\ufe0f This dataset was NOT detected as time series.\")\n",
+    "    print(\"   Consider using 02_column_deep_dive.ipynb instead.\")\n",
+    "    print(\"   Or manually specify entity and time columns below.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "da320551",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002516,
+     "end_time": "2026-02-02T13:00:45.405745",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:45.403229",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1a.2 Load Source Data & Configure Columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf93640f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:45.411398Z",
+     "iopub.status.busy": "2026-02-02T13:00:45.411286Z",
+     "iopub.status.idle": "2026-02-02T13:00:46.049065Z",
+     "shell.execute_reply": "2026-02-02T13:00:46.048415Z"
+    },
+    "papermill": {
+     "duration": 0.641436,
+     "end_time": "2026-02-02T13:00:46.049611",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:45.408175",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.stages.temporal import load_data_with_snapshot_preference, TEMPORAL_METADATA_COLS\n",
+    "\n",
+    "df, data_source = load_data_with_snapshot_preference(findings, output_dir=str(FINDINGS_DIR))\n",
+    "charts = ChartBuilder()\n",
+    "\n",
+    "print(f\"Loaded {len(df):,} rows x {len(df.columns)} columns\")\n",
+    "print(f\"Data source: {data_source}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "096fd6ce",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:46.056341Z",
+     "iopub.status.busy": "2026-02-02T13:00:46.056051Z",
+     "iopub.status.idle": "2026-02-02T13:00:46.059051Z",
+     "shell.execute_reply": "2026-02-02T13:00:46.058443Z"
+    },
+    "papermill": {
+     "duration": 0.007123,
+     "end_time": "2026-02-02T13:00:46.059703",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:46.052580",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# === COLUMN CONFIGURATION ===\n",
+    "# These will be auto-populated from findings if available\n",
+    "# Override manually if needed\n",
+    "\n",
+    "if findings.is_time_series and findings.time_series_metadata:\n",
+    "    ENTITY_COLUMN = findings.time_series_metadata.entity_column\n",
+    "    TIME_COLUMN = findings.time_series_metadata.time_column\n",
+    "else:\n",
+    "    # Manual configuration - uncomment and set if auto-detection failed\n",
+    "    # ENTITY_COLUMN = \"customer_id\"\n",
+    "    # TIME_COLUMN = \"event_date\"\n",
+    "    \n",
+    "    # Try auto-detection\n",
+    "    detector = TypeDetector()\n",
+    "    granularity = detector.detect_granularity(df)\n",
+    "    ENTITY_COLUMN = granularity.entity_column\n",
+    "    TIME_COLUMN = granularity.time_column\n",
+    "\n",
+    "print(f\"Entity column: {ENTITY_COLUMN}\")\n",
+    "print(f\"Time column: {TIME_COLUMN}\")\n",
+    "\n",
+    "if not ENTITY_COLUMN or not TIME_COLUMN:\n",
+    "    raise ValueError(\"Please set ENTITY_COLUMN and TIME_COLUMN manually above\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "699bc20a",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002487,
+     "end_time": "2026-02-02T13:00:46.064992",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:46.062505",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1a.3 Time Series Profile Overview\n",
+    "\n",
+    "**What we analyze:**\n",
+    "- Total events and unique entities\n",
+    "- Time span coverage\n",
+    "- Events per entity distribution\n",
+    "- Entity lifecycle metrics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "50d5d2c0",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:46.071065Z",
+     "iopub.status.busy": "2026-02-02T13:00:46.070953Z",
+     "iopub.status.idle": "2026-02-02T13:00:47.135766Z",
+     "shell.execute_reply": "2026-02-02T13:00:47.135154Z"
+    },
+    "papermill": {
+     "duration": 1.068734,
+     "end_time": "2026-02-02T13:00:47.136462",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:46.067728",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Create the time series profiler and run analysis\n",
+    "profiler = TimeSeriesProfiler(entity_column=ENTITY_COLUMN, time_column=TIME_COLUMN)\n",
+    "ts_profile = profiler.profile(df)\n",
+    "\n",
+    "print(\"=\"*70)\n",
+    "print(\"TIME SERIES PROFILE SUMMARY\")\n",
+    "print(\"=\"*70)\n",
+    "print(f\"\\n\\U0001f4ca Dataset Overview:\")\n",
+    "print(f\"   Total Events: {ts_profile.total_events:,}\")\n",
+    "print(f\"   Unique Entities: {ts_profile.unique_entities:,}\")\n",
+    "print(f\"   Avg Events/Entity: {ts_profile.events_per_entity.mean:.1f}\")\n",
+    "print(f\"   Time Span: {ts_profile.time_span_days:,} days ({ts_profile.time_span_days/365:.1f} years)\")\n",
+    "\n",
+    "print(f\"\\n\\U0001f4c5 Date Range:\")\n",
+    "print(f\"   First Event: {ts_profile.first_event_date}\")\n",
+    "print(f\"   Last Event: {ts_profile.last_event_date}\")\n",
+    "\n",
+    "print(f\"\\n\\u23f1\\ufe0f  Inter-Event Timing:\")\n",
+    "if ts_profile.avg_inter_event_days is not None:\n",
+    "    print(f\"   Avg Days Between Events: {ts_profile.avg_inter_event_days:.1f}\")\n",
+    "else:\n",
+    "    print(\"   Not enough data to compute inter-event timing\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae15eee5",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002416,
+     "end_time": "2026-02-02T13:00:47.141577",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:47.139161",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1a.4 Events per Entity Distribution\n",
+    "\n",
+    "**Goal:** Understand how event volume varies across entities to guide feature engineering and identify modeling challenges.\n",
+    "\n",
+    "| Segment | Definition | Why It Matters for Modeling |\n",
+    "|---------|------------|---------------------------|\n",
+    "| **One-time** | Exactly 1 event | No temporal features possible; cold-start problem |\n",
+    "| **Low Activity** | Below Q25 | Sparse features, many zeros; log-transform counts |\n",
+    "| **Medium Activity** | Q25 to Q75 | Core population; standard aggregation windows work |\n",
+    "| **High Activity** | Above Q75 | Rich features; watch for training set dominance |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "80e24681",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:47.147535Z",
+     "iopub.status.busy": "2026-02-02T13:00:47.147412Z",
+     "iopub.status.idle": "2026-02-02T13:00:47.180702Z",
+     "shell.execute_reply": "2026-02-02T13:00:47.180158Z"
+    },
+    "papermill": {
+     "duration": 0.037113,
+     "end_time": "2026-02-02T13:00:47.181315",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:47.144202",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.stages.profiling import classify_activity_segments\n",
+    "\n",
+    "segment_result = classify_activity_segments(ts_profile.entity_lifecycles)\n",
+    "\n",
+    "segment_order = [\"One-time\", \"Low Activity\", \"Medium Activity\", \"High Activity\"]\n",
+    "segment_colors = {\n",
+    "    \"One-time\": \"#d62728\", \"Low Activity\": \"#ff7f0e\",\n",
+    "    \"Medium Activity\": \"#2ca02c\", \"High Activity\": \"#1f77b4\",\n",
+    "}\n",
+    "\n",
+    "event_counts = segment_result.lifecycles[\"event_count\"]\n",
+    "x_max = event_counts.quantile(0.99)\n",
+    "bins = np.linspace(0, x_max, 31)\n",
+    "bin_centers = (bins[:-1] + bins[1:]) / 2\n",
+    "\n",
+    "lc = segment_result.lifecycles\n",
+    "bin_indices = np.digitize(lc[\"event_count\"], bins) - 1\n",
+    "bin_indices = bin_indices.clip(0, len(bin_centers) - 1)\n",
+    "lc_binned = lc.assign(_bin=bin_indices)\n",
+    "\n",
+    "fig = go.Figure()\n",
+    "for seg in segment_order:\n",
+    "    subset = lc_binned[lc_binned[\"activity_segment\"] == seg]\n",
+    "    if subset.empty:\n",
+    "        continue\n",
+    "    counts_per_bin = subset.groupby(\"_bin\").size().reindex(range(len(bin_centers)), fill_value=0)\n",
+    "    fig.add_trace(go.Bar(\n",
+    "        x=bin_centers, y=counts_per_bin.values, name=seg,\n",
+    "        marker_color=segment_colors[seg], opacity=0.85,\n",
+    "    ))\n",
+    "\n",
+    "fig.add_vline(\n",
+    "    x=event_counts.median(), line_dash=\"solid\", line_color=\"gray\",\n",
+    "    annotation_text=f\"Median: {event_counts.median():.0f}\",\n",
+    "    annotation_position=\"top left\",\n",
+    ")\n",
+    "\n",
+    "use_log_y = event_counts.value_counts().max() > event_counts.value_counts().median() * 50\n",
+    "\n",
+    "log_note = (\"<br><sub>Log Y-axis: bar heights compress large differences — \"\n",
+    "            \"see table below for actual segment shares</sub>\" if use_log_y else \"\")\n",
+    "\n",
+    "fig.update_layout(\n",
+    "    barmode=\"stack\", template=\"plotly_white\", height=420,\n",
+    "    title=\"Events per Entity by Activity Segment\" + log_note,\n",
+    "    xaxis_title=\"Number of Events\",\n",
+    "    yaxis_title=\"Entities\",\n",
+    "    yaxis_type=\"log\" if use_log_y else \"linear\",\n",
+    "    legend=dict(orientation=\"h\", yanchor=\"top\", y=-0.15, xanchor=\"center\", x=0.5),\n",
+    "    margin=dict(b=70),\n",
+    ")\n",
+    "display_figure(fig)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cb2c1433",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:47.191417Z",
+     "iopub.status.busy": "2026-02-02T13:00:47.191286Z",
+     "iopub.status.idle": "2026-02-02T13:00:47.196159Z",
+     "shell.execute_reply": "2026-02-02T13:00:47.195708Z"
+    },
+    "papermill": {
+     "duration": 0.011037,
+     "end_time": "2026-02-02T13:00:47.196670",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:47.185633",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "print(f\"Segment thresholds: Q25 = {segment_result.q25_threshold:.0f} events, \"\n",
+    "      f\"Q75 = {segment_result.q75_threshold:.0f} events\\n\")\n",
+    "display_table(segment_result.recommendations)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9edcbf88",
+   "metadata": {
+    "papermill": {
+     "duration": 0.004159,
+     "end_time": "2026-02-02T13:00:47.206083",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:47.201924",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1a.5 Entity Lifecycle Analysis\n",
+    "\n",
+    "**Goal:** Classify entities by their engagement pattern to inform feature engineering and modeling strategy.\n",
+    "\n",
+    "We combine two dimensions — **tenure** (days from first to last event) and **intensity** (events per day of tenure) — to identify four lifecycle quadrants:\n",
+    "\n",
+    "| Quadrant | Tenure | Intensity | Meaning | Feature Implication |\n",
+    "|----------|--------|-----------|---------|---------------------|\n",
+    "| **Intense & Brief** | Short | High | Burst engagement, then gone | Recency features critical |\n",
+    "| **Steady & Loyal** | Long | High | Consistent power users | Trend/seasonality features valuable |\n",
+    "| **Occasional & Loyal** | Long | Low | Infrequent but persistent | Wider time windows needed |\n",
+    "| **One-shot** | Short | Low | Single/few interactions | May lack enough history for features |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b6c52e77",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:47.215136Z",
+     "iopub.status.busy": "2026-02-02T13:00:47.215018Z",
+     "iopub.status.idle": "2026-02-02T13:00:47.221586Z",
+     "shell.execute_reply": "2026-02-02T13:00:47.221133Z"
+    },
+    "papermill": {
+     "duration": 0.011923,
+     "end_time": "2026-02-02T13:00:47.222065",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:47.210142",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.stages.profiling import classify_lifecycle_quadrants\n",
+    "\n",
+    "quadrant_result = classify_lifecycle_quadrants(ts_profile.entity_lifecycles)\n",
+    "lifecycles = quadrant_result.lifecycles\n",
+    "\n",
+    "quadrant_order = [\"Steady & Loyal\", \"Occasional & Loyal\", \"Intense & Brief\", \"One-shot\"]\n",
+    "quadrant_colors = {\n",
+    "    \"Steady & Loyal\": \"#2ca02c\", \"Occasional & Loyal\": \"#1f77b4\",\n",
+    "    \"Intense & Brief\": \"#ff7f0e\", \"One-shot\": \"#d62728\",\n",
+    "}\n",
+    "tenure_median = quadrant_result.tenure_threshold\n",
+    "\n",
+    "print(f\"Split thresholds: Tenure median = {quadrant_result.tenure_threshold:.0f} days, \"\n",
+    "      f\"Intensity median = {quadrant_result.intensity_threshold:.4f} events/day\\n\")\n",
+    "display_table(quadrant_result.recommendations)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a3ba015d",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:47.232407Z",
+     "iopub.status.busy": "2026-02-02T13:00:47.232297Z",
+     "iopub.status.idle": "2026-02-02T13:00:47.287294Z",
+     "shell.execute_reply": "2026-02-02T13:00:47.286736Z"
+    },
+    "papermill": {
+     "duration": 0.061037,
+     "end_time": "2026-02-02T13:00:47.288051",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:47.227014",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Combined panel: small multiples (top 2x2) + tenure histogram (bottom)\n",
+    "fig = make_subplots(\n",
+    "    rows=3, cols=2,\n",
+    "    subplot_titles=[*quadrant_order, \"Tenure Distribution by Quadrant\", \"\"],\n",
+    "    specs=[[{}, {}], [{}, {}], [{\"colspan\": 2}, None]],\n",
+    "    vertical_spacing=0.08, horizontal_spacing=0.10,\n",
+    "    row_heights=[0.28, 0.28, 0.44],\n",
+    ")\n",
+    "\n",
+    "# Top 2x2: scatter per quadrant\n",
+    "positions = [(1, 1), (1, 2), (2, 1), (2, 2)]\n",
+    "for (row, col), q in zip(positions, quadrant_order):\n",
+    "    subset = lifecycles[lifecycles[\"lifecycle_quadrant\"] == q]\n",
+    "    fig.add_trace(go.Scatter(\n",
+    "        x=subset[\"duration_days\"], y=subset[\"intensity\"],\n",
+    "        mode=\"markers\", marker=dict(color=quadrant_colors[q], opacity=0.4, size=3),\n",
+    "        showlegend=False,\n",
+    "    ), row=row, col=col)\n",
+    "    fig.update_xaxes(title_text=\"Tenure (d)\", title_font_size=10, row=row, col=col)\n",
+    "    fig.update_yaxes(title_text=\"Ev/day\", title_font_size=10, row=row, col=col)\n",
+    "\n",
+    "# Bottom: overlaid tenure histograms\n",
+    "for q in quadrant_order:\n",
+    "    subset = lifecycles[lifecycles[\"lifecycle_quadrant\"] == q]\n",
+    "    fig.add_trace(go.Histogram(\n",
+    "        x=subset[\"duration_days\"], nbinsx=40, name=q,\n",
+    "        marker_color=quadrant_colors[q], opacity=0.6,\n",
+    "    ), row=3, col=1)\n",
+    "\n",
+    "fig.add_vline(x=tenure_median, line_dash=\"dot\", line_color=\"gray\", opacity=0.5,\n",
+    "              row=3, col=1, annotation_text=f\"Median: {tenure_median:.0f}d\",\n",
+    "              annotation_position=\"top left\")\n",
+    "\n",
+    "fig.update_layout(\n",
+    "    barmode=\"overlay\", template=\"plotly_white\", height=900,\n",
+    "    title=\"Entity Lifecycle Quadrants\",\n",
+    "    legend=dict(orientation=\"h\", yanchor=\"top\", y=-0.05, xanchor=\"center\", x=0.5),\n",
+    "    margin=dict(b=80),\n",
+    ")\n",
+    "fig.update_xaxes(title_text=\"Tenure (days)\", row=3, col=1)\n",
+    "fig.update_yaxes(title_text=\"Entities\", row=3, col=1)\n",
+    "display_figure(fig)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3d2820d4",
+   "metadata": {
+    "papermill": {
+     "duration": 0.007238,
+     "end_time": "2026-02-02T13:00:47.302328",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:47.295090",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1a.6 Temporal Coverage Analysis\n",
+    "\n",
+    "**Why this matters for modeling:**\n",
+    "\n",
+    "| Question | Impact |\n",
+    "|----------|--------|\n",
+    "| **Data gaps?** | Gaps produce misleading aggregation features — zeros that mean \"no data\" not \"no activity\" |\n",
+    "| **Volume trend?** | Growing volume means older entities have sparser history; declining means recent windows are underpopulated |\n",
+    "| **Entity coverage by window?** | Shows which aggregation windows will produce meaningful features vs. mostly zeros |\n",
+    "| **Entity arrival pattern?** | Concentrated arrivals = cohort effects; steady arrivals = stable population |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8a57d827",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:47.318548Z",
+     "iopub.status.busy": "2026-02-02T13:00:47.318439Z",
+     "iopub.status.idle": "2026-02-02T13:00:47.359092Z",
+     "shell.execute_reply": "2026-02-02T13:00:47.358688Z"
+    },
+    "papermill": {
+     "duration": 0.049921,
+     "end_time": "2026-02-02T13:00:47.359838",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:47.309917",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.stages.profiling import analyze_temporal_coverage\n",
+    "\n",
+    "df_temp = df.copy()\n",
+    "df_temp[TIME_COLUMN] = pd.to_datetime(df_temp[TIME_COLUMN])\n",
+    "\n",
+    "coverage_result = analyze_temporal_coverage(df_temp, ENTITY_COLUMN, TIME_COLUMN)\n",
+    "\n",
+    "# Events over time with gap highlighting\n",
+    "fig = go.Figure()\n",
+    "fig.add_trace(go.Scatter(\n",
+    "    x=coverage_result.events_over_time.index,\n",
+    "    y=coverage_result.events_over_time.values,\n",
+    "    mode=\"lines\", fill=\"tozeroy\", name=\"Events\", line_color=\"steelblue\",\n",
+    "))\n",
+    "\n",
+    "for gap in coverage_result.gaps:\n",
+    "    color = {\"minor\": \"rgba(255,165,0,0.15)\", \"moderate\": \"rgba(255,100,0,0.25)\",\n",
+    "             \"major\": \"rgba(255,0,0,0.25)\"}[gap.severity]\n",
+    "    fig.add_vrect(\n",
+    "        x0=gap.start, x1=gap.end, fillcolor=color, line_width=0,\n",
+    "        annotation_text=f\"{gap.duration_days:.0f}d gap\",\n",
+    "        annotation_position=\"top left\", annotation_font_size=10,\n",
+    "    )\n",
+    "\n",
+    "trend_label = f\"{coverage_result.volume_trend} ({coverage_result.volume_change_pct:+.0%})\"\n",
+    "fig.update_layout(\n",
+    "    title=f\"Event Volume Over Time<br><sub>Trend: {trend_label}\"\n",
+    "          + (f\" | {len(coverage_result.gaps)} gap(s) highlighted\" if coverage_result.gaps else \"\")\n",
+    "          + \"</sub>\",\n",
+    "    xaxis_title=\"Date\", yaxis_title=\"Events per Period\",\n",
+    "    template=\"plotly_white\", height=380,\n",
+    ")\n",
+    "display_figure(fig)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0434f9b0",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:47.378950Z",
+     "iopub.status.busy": "2026-02-02T13:00:47.378814Z",
+     "iopub.status.idle": "2026-02-02T13:00:47.398377Z",
+     "shell.execute_reply": "2026-02-02T13:00:47.397715Z"
+    },
+    "papermill": {
+     "duration": 0.029693,
+     "end_time": "2026-02-02T13:00:47.399039",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:47.369346",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "fig = make_subplots(\n",
+    "    rows=1, cols=2, subplot_titles=[\"New Entities Over Time\", \"Entity Coverage by Window\"],\n",
+    "    column_widths=[0.6, 0.4], horizontal_spacing=0.12,\n",
+    ")\n",
+    "\n",
+    "# Left: new entities over time\n",
+    "fig.add_trace(go.Bar(\n",
+    "    x=coverage_result.new_entities_over_time.index,\n",
+    "    y=coverage_result.new_entities_over_time.values,\n",
+    "    marker_color=\"mediumseagreen\", opacity=0.8, showlegend=False,\n",
+    "), row=1, col=1)\n",
+    "fig.update_xaxes(title_text=\"First Event Date\", row=1, col=1)\n",
+    "fig.update_yaxes(title_text=\"New Entities\", row=1, col=1)\n",
+    "\n",
+    "# Right: entity window coverage bar chart\n",
+    "cov_data = [(c.window, c.coverage_pct, c.active_entities) for c in coverage_result.entity_window_coverage]\n",
+    "windows_labels = [c[0] for c in cov_data]\n",
+    "coverage_pcts = [c[1] * 100 for c in cov_data]\n",
+    "active_counts = [c[2] for c in cov_data]\n",
+    "\n",
+    "bar_colors = [\"#2ca02c\" if p >= 50 else \"#ff7f0e\" if p >= 10 else \"#d62728\" for p in coverage_pcts]\n",
+    "fig.add_trace(go.Bar(\n",
+    "    x=windows_labels, y=coverage_pcts, showlegend=False,\n",
+    "    marker_color=bar_colors, opacity=0.85,\n",
+    "    text=[f\"{p:.0f}%<br>({n:,})\" for p, n in zip(coverage_pcts, active_counts)],\n",
+    "    textposition=\"outside\", textfont_size=9,\n",
+    "), row=1, col=2)\n",
+    "fig.update_xaxes(title_text=\"Window\", row=1, col=2)\n",
+    "fig.update_yaxes(title_text=\"% Entities Active\", range=[0, 115], row=1, col=2)\n",
+    "\n",
+    "fig.update_layout(\n",
+    "    template=\"plotly_white\", height=380,\n",
+    "    title=\"Entity Arrival & Window Coverage\"\n",
+    "          + f\"<br><sub>Reference date: {coverage_result.last_event.strftime('%Y-%m-%d')}</sub>\",\n",
+    "    margin=dict(b=50),\n",
+    ")\n",
+    "display_figure(fig)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "236521ff",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:47.420663Z",
+     "iopub.status.busy": "2026-02-02T13:00:47.420508Z",
+     "iopub.status.idle": "2026-02-02T13:00:47.423477Z",
+     "shell.execute_reply": "2026-02-02T13:00:47.422897Z"
+    },
+    "papermill": {
+     "duration": 0.01449,
+     "end_time": "2026-02-02T13:00:47.424096",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:47.409606",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "print(f\"Coverage Summary:\")\n",
+    "print(f\"  Time span: {coverage_result.time_span_days:,} days \"\n",
+    "      f\"({coverage_result.first_event.strftime('%Y-%m-%d')} to {coverage_result.last_event.strftime('%Y-%m-%d')})\")\n",
+    "print(f\"  Volume trend: {coverage_result.volume_trend} ({coverage_result.volume_change_pct:+.0%})\")\n",
+    "print(f\"  Data gaps: {len(coverage_result.gaps)} detected\"\n",
+    "      + (f\" ({sum(g.duration_days for g in coverage_result.gaps):.0f} total days)\" if coverage_result.gaps else \"\"))\n",
+    "\n",
+    "if coverage_result.recommendations:\n",
+    "    print(f\"\\nRecommendations:\")\n",
+    "    for rec in coverage_result.recommendations:\n",
+    "        print(f\"  -> {rec}\")\n",
+    "else:\n",
+    "    print(f\"\\nNo coverage issues detected — data is suitable for all candidate windows.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a66b47f7",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:47.444695Z",
+     "iopub.status.busy": "2026-02-02T13:00:47.444576Z",
+     "iopub.status.idle": "2026-02-02T13:00:47.447904Z",
+     "shell.execute_reply": "2026-02-02T13:00:47.447448Z"
+    },
+    "papermill": {
+     "duration": 0.014214,
+     "end_time": "2026-02-02T13:00:47.448412",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:47.434198",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.stages.profiling import derive_drift_implications\n",
+    "\n",
+    "drift = derive_drift_implications(coverage_result)\n",
+    "\n",
+    "risk_colors = {\"low\": \"\\033[92m\", \"moderate\": \"\\033[93m\", \"high\": \"\\033[91m\"}\n",
+    "reset = \"\\033[0m\"\n",
+    "color = risk_colors.get(drift.risk_level, \"\")\n",
+    "\n",
+    "print(f\"Parameter Drift Assessment: {color}{drift.risk_level.upper()}{reset}\")\n",
+    "print(f\"  Volume drift risk: {drift.volume_drift_risk}\")\n",
+    "print(f\"  Population stability: {drift.population_stability:.2f}\")\n",
+    "print(f\"  Data regimes: {drift.regime_count}\")\n",
+    "if drift.recommended_training_start:\n",
+    "    print(f\"  Recommended training start: {drift.recommended_training_start.strftime('%Y-%m-%d')}\")\n",
+    "\n",
+    "print(f\"\\nRationale:\")\n",
+    "for r in drift.rationale:\n",
+    "    print(f\"  -> {r}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5fe41a6c",
+   "metadata": {
+    "papermill": {
+     "duration": 0.010352,
+     "end_time": "2026-02-02T13:00:47.468456",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:47.458104",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1a.7 Inter-Event Timing Analysis\n",
+    "\n",
+    "**📖 Understanding Inter-Event Time:**\n",
+    "- Time between consecutive events for each entity\n",
+    "- Short inter-event time: Frequent engagement\n",
+    "- Long inter-event time: Sporadic usage or churn risk"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7fd6154f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:47.488399Z",
+     "iopub.status.busy": "2026-02-02T13:00:47.488285Z",
+     "iopub.status.idle": "2026-02-02T13:00:48.452937Z",
+     "shell.execute_reply": "2026-02-02T13:00:48.452317Z"
+    },
+    "papermill": {
+     "duration": 0.976266,
+     "end_time": "2026-02-02T13:00:48.454313",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:47.478047",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Compute inter-event times for all entities with >1 event\n",
+    "inter_event_times = []\n",
+    "\n",
+    "for entity, group in df_temp.groupby(ENTITY_COLUMN):\n",
+    "    if len(group) < 2:\n",
+    "        continue\n",
+    "    sorted_times = group[TIME_COLUMN].sort_values()\n",
+    "    diffs = sorted_times.diff().dropna()\n",
+    "    inter_event_times.extend(diffs.dt.total_seconds() / 86400)  # Convert to days\n",
+    "\n",
+    "if inter_event_times:\n",
+    "    inter_event_series = pd.Series(inter_event_times)\n",
+    "    \n",
+    "    print(\"\\u23f1\\ufe0f  Inter-Event Time Distribution (days):\")\n",
+    "    print(f\"   Min: {inter_event_series.min():.2f}\")\n",
+    "    print(f\"   25th percentile: {inter_event_series.quantile(0.25):.2f}\")\n",
+    "    print(f\"   Median: {inter_event_series.median():.2f}\")\n",
+    "    print(f\"   Mean: {inter_event_series.mean():.2f}\")\n",
+    "    print(f\"   75th percentile: {inter_event_series.quantile(0.75):.2f}\")\n",
+    "    print(f\"   Max: {inter_event_series.max():.2f}\")\n",
+    "    \n",
+    "    # Histogram\n",
+    "    fig = go.Figure()\n",
+    "    \n",
+    "    # Cap at 99th percentile for visualization\n",
+    "    cap = inter_event_series.quantile(0.99)\n",
+    "    display_data = inter_event_series[inter_event_series <= cap]\n",
+    "    \n",
+    "    fig.add_trace(go.Histogram(\n",
+    "        x=display_data,\n",
+    "        nbinsx=50,\n",
+    "        name=\"Inter-Event Time\",\n",
+    "        marker_color=\"coral\",\n",
+    "        opacity=0.7\n",
+    "    ))\n",
+    "    \n",
+    "    fig.add_vline(x=inter_event_series.median(), line_dash=\"solid\", line_color=\"green\",\n",
+    "                  annotation_text=f\"Median: {inter_event_series.median():.1f} days\",\n",
+    "                  annotation_position=\"top right\")\n",
+    "    \n",
+    "    fig.update_layout(\n",
+    "        title=f\"Inter-Event Time Distribution (capped at {cap:.0f} days = 99th percentile)\",\n",
+    "        xaxis_title=\"Days Between Events\",\n",
+    "        yaxis_title=\"Frequency\",\n",
+    "        template=\"plotly_white\",\n",
+    "        height=400\n",
+    "    )\n",
+    "    display_figure(fig)\n",
+    "else:\n",
+    "    print(\"Not enough multi-event entities to analyze inter-event timing\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9ff4ef83",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:48.495793Z",
+     "iopub.status.busy": "2026-02-02T13:00:48.495373Z",
+     "iopub.status.idle": "2026-02-02T13:00:48.505291Z",
+     "shell.execute_reply": "2026-02-02T13:00:48.504775Z"
+    },
+    "papermill": {
+     "duration": 0.037445,
+     "end_time": "2026-02-02T13:00:48.505957",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:48.468512",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "if inter_event_times:\n",
+    "    median_iet = inter_event_series.median()\n",
+    "    mean_iet = inter_event_series.mean()\n",
+    "    q25 = inter_event_series.quantile(0.25)\n",
+    "    q75 = inter_event_series.quantile(0.75)\n",
+    "    iqr = q75 - q25\n",
+    "    skew_ratio = mean_iet / median_iet if median_iet > 0 else 1.0\n",
+    "\n",
+    "    print(\"Interpretation:\")\n",
+    "    if skew_ratio > 1.5:\n",
+    "        print(f\"  Distribution is heavily right-skewed (mean/median = {skew_ratio:.2f})\")\n",
+    "        print(f\"  -> Most entities engage frequently (median {median_iet:.0f}d between events)\")\n",
+    "        print(f\"  -> A long tail of entities has very infrequent engagement\")\n",
+    "    elif skew_ratio > 1.2:\n",
+    "        print(f\"  Distribution is moderately right-skewed (mean/median = {skew_ratio:.2f})\")\n",
+    "        print(f\"  -> Typical engagement every {median_iet:.0f} days, with some long gaps\")\n",
+    "    else:\n",
+    "        print(f\"  Distribution is approximately symmetric (mean/median = {skew_ratio:.2f})\")\n",
+    "        print(f\"  -> Consistent engagement pattern around {median_iet:.0f} days\")\n",
+    "\n",
+    "    print(f\"\\n  Spread: IQR = {iqr:.0f} days (Q25={q25:.0f}d to Q75={q75:.0f}d)\")\n",
+    "    if iqr > median_iet:\n",
+    "        print(f\"  -> High variability (IQR > median) — entities have inconsistent timing\")\n",
+    "    else:\n",
+    "        print(f\"  -> Moderate variability — most entities follow a similar cadence\")\n",
+    "\n",
+    "    print(f\"\\nRecommendations:\")\n",
+    "    # Window alignment\n",
+    "    window_map = [(1, \"24h\"), (7, \"7d\"), (14, \"14d\"), (30, \"30d\"),\n",
+    "                  (90, \"90d\"), (180, \"180d\"), (365, \"365d\")]\n",
+    "    aligned = [(d, w) for d, w in window_map if 0.5 * median_iet <= d <= 2 * median_iet]\n",
+    "    if aligned:\n",
+    "        aligned_str = \", \".join(w for _, w in aligned)\n",
+    "        print(f\"  -> Windows aligned with median inter-event time: {aligned_str}\")\n",
+    "        print(f\"     These capture ~2 events per entity on average\")\n",
+    "    else:\n",
+    "        print(f\"  -> Median inter-event ({median_iet:.0f}d) does not align with standard windows\")\n",
+    "\n",
+    "    events_in_30d = 30.0 / median_iet if median_iet > 0 else 0\n",
+    "    events_in_90d = 90.0 / median_iet if median_iet > 0 else 0\n",
+    "    if events_in_30d < 2:\n",
+    "        print(f\"  -> 30d window captures only ~{events_in_30d:.1f} events/entity — \"\n",
+    "              f\"consider longer windows (90d+) for meaningful aggregations\")\n",
+    "    if median_iet < 7:\n",
+    "        print(f\"  -> High frequency engagement — 7d and 24h windows will be rich with signal\")\n",
+    "\n",
+    "    if skew_ratio > 1.5:\n",
+    "        print(f\"  -> Consider log-transforming inter-event time as a feature \"\n",
+    "              f\"(reduces right-skew impact on models)\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a8736668",
+   "metadata": {
+    "papermill": {
+     "duration": 0.015171,
+     "end_time": "2026-02-02T13:00:48.535261",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:48.520090",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1a.8 Column Distributions\n",
+    "\n",
+    "Standard column profiling applied to event-level data - distributions, outliers, transformation needs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "83644d1f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:48.564797Z",
+     "iopub.status.busy": "2026-02-02T13:00:48.564671Z",
+     "iopub.status.idle": "2026-02-02T13:00:48.583852Z",
+     "shell.execute_reply": "2026-02-02T13:00:48.583026Z"
+    },
+    "papermill": {
+     "duration": 0.035159,
+     "end_time": "2026-02-02T13:00:48.584649",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:48.549490",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Use framework's DistributionAnalyzer for comprehensive analysis\n",
+    "analyzer = DistributionAnalyzer()\n",
+    "\n",
+    "numeric_cols = [n for n, c in findings.columns.items() \n",
+    "                if c.inferred_type.value in ('numeric_continuous', 'numeric_discrete')\n",
+    "                and n not in [ENTITY_COLUMN, TIME_COLUMN] and n not in TEMPORAL_METADATA_COLS]\n",
+    "\n",
+    "# Analyze all numeric columns using the framework\n",
+    "analyses = analyzer.analyze_dataframe(df, numeric_cols)\n",
+    "recommendations = {col: analyzer.recommend_transformation(analysis) \n",
+    "                   for col, analysis in analyses.items()}\n",
+    "\n",
+    "# Human-readable transformation names\n",
+    "TRANSFORM_DISPLAY_NAMES = {\n",
+    "    'none': 'None needed',\n",
+    "    'log': 'Log transform',\n",
+    "    'log1p': 'Log(1+x) transform',\n",
+    "    'sqrt': 'Square root',\n",
+    "    'box_cox': 'Box-Cox power transform',\n",
+    "    'yeo_johnson': 'Yeo-Johnson power transform',\n",
+    "    'quantile': 'Quantile normalization',\n",
+    "    'robust_scale': 'Robust scaling (median/IQR)',\n",
+    "    'standard_scale': 'Standard scaling (z-score)',\n",
+    "    'minmax_scale': 'Min-Max scaling',\n",
+    "}\n",
+    "\n",
+    "print(\"=\"*70)\n",
+    "print(\"NUMERIC COLUMN PROFILES\")\n",
+    "print(\"=\"*70)\n",
+    "\n",
+    "for col_name in numeric_cols:\n",
+    "    col_info = findings.columns[col_name]\n",
+    "    analysis = analyses.get(col_name)\n",
+    "    rec = recommendations.get(col_name)\n",
+    "    \n",
+    "    print(f\"\\n{'='*70}\")\n",
+    "    print(f\"Column: {col_name}\")\n",
+    "    print(f\"Type: {col_info.inferred_type.value} (Confidence: {col_info.confidence:.0%})\")\n",
+    "    print(f\"-\" * 70)\n",
+    "    \n",
+    "    if analysis:\n",
+    "        print(f\"📊 Distribution Statistics:\")\n",
+    "        print(f\"   Mean: {analysis.mean:.3f}  |  Median: {analysis.median:.3f}  |  Std: {analysis.std:.3f}\")\n",
+    "        print(f\"   Range: [{analysis.min_value:.3f}, {analysis.max_value:.3f}]\")\n",
+    "        print(f\"   Percentiles: 1%={analysis.percentiles['p1']:.3f}, 25%={analysis.q1:.3f}, 75%={analysis.q3:.3f}, 99%={analysis.percentiles['p99']:.3f}\")\n",
+    "        print(f\"\\n📈 Shape Analysis:\")\n",
+    "        skew_label = '(Right-skewed)' if analysis.skewness > 0.5 else '(Left-skewed)' if analysis.skewness < -0.5 else '(Symmetric)'\n",
+    "        print(f\"   Skewness: {analysis.skewness:.2f} {skew_label}\")\n",
+    "        kurt_label = '(Heavy tails/outliers)' if analysis.kurtosis > 3 else '(Light tails)'\n",
+    "        print(f\"   Kurtosis: {analysis.kurtosis:.2f} {kurt_label}\")\n",
+    "        print(f\"   Zeros: {analysis.zero_count:,} ({analysis.zero_percentage:.1f}%)\")\n",
+    "        print(f\"   Outliers (IQR): {analysis.outlier_count_iqr:,} ({analysis.outlier_percentage:.1f}%)\")\n",
+    "        \n",
+    "        if rec:\n",
+    "            transform_display = TRANSFORM_DISPLAY_NAMES.get(rec.recommended_transform.value, rec.recommended_transform.value)\n",
+    "            print(f\"\\n🔧 Recommended Transformation: {transform_display}\")\n",
+    "            print(f\"   Reason: {rec.reason}\")\n",
+    "            print(f\"   Priority: {rec.priority}\")\n",
+    "            if rec.warnings:\n",
+    "                for warn in rec.warnings:\n",
+    "                    print(f\"   ⚠️ {warn}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "394f68c4",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:48.614739Z",
+     "iopub.status.busy": "2026-02-02T13:00:48.614603Z",
+     "iopub.status.idle": "2026-02-02T13:00:48.651049Z",
+     "shell.execute_reply": "2026-02-02T13:00:48.650385Z"
+    },
+    "papermill": {
+     "duration": 0.052606,
+     "end_time": "2026-02-02T13:00:48.651826",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:48.599220",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Per-column distribution visualizations with transformation recommendations\n",
+    "for col_name in numeric_cols:\n",
+    "    analysis = analyses.get(col_name)\n",
+    "    rec = recommendations.get(col_name)\n",
+    "    if not analysis:\n",
+    "        continue\n",
+    "    \n",
+    "    data = df[col_name].dropna()\n",
+    "    fig = go.Figure()\n",
+    "    \n",
+    "    fig.add_trace(go.Histogram(x=data, nbinsx=50, name='Distribution',\n",
+    "                                marker_color='steelblue', opacity=0.7))\n",
+    "    \n",
+    "    mean_val = data.mean()\n",
+    "    median_val = data.median()\n",
+    "    \n",
+    "    # Position labels on opposite sides to avoid overlap\n",
+    "    mean_position = \"top right\" if mean_val >= median_val else \"top left\"\n",
+    "    median_position = \"top left\" if mean_val >= median_val else \"top right\"\n",
+    "    \n",
+    "    fig.add_vline(\n",
+    "        x=mean_val, line_dash=\"dash\", line_color=\"red\",\n",
+    "        annotation_text=f\"Mean: {mean_val:.2f}\",\n",
+    "        annotation_position=mean_position,\n",
+    "        annotation_font_color=\"red\",\n",
+    "        annotation_bgcolor=\"rgba(255,255,255,0.8)\"\n",
+    "    )\n",
+    "    \n",
+    "    fig.add_vline(\n",
+    "        x=median_val, line_dash=\"solid\", line_color=\"green\",\n",
+    "        annotation_text=f\"Median: {median_val:.2f}\",\n",
+    "        annotation_position=median_position,\n",
+    "        annotation_font_color=\"green\",\n",
+    "        annotation_bgcolor=\"rgba(255,255,255,0.8)\"\n",
+    "    )\n",
+    "    \n",
+    "    # Add 99th percentile marker if there are outliers\n",
+    "    if analysis.outlier_percentage > 5:\n",
+    "        fig.add_vline(x=analysis.percentiles['p99'], line_dash=\"dot\", line_color=\"orange\",\n",
+    "                      annotation_text=f\"99th: {analysis.percentiles['p99']:.2f}\",\n",
+    "                      annotation_position=\"top right\",\n",
+    "                      annotation_font_color=\"orange\",\n",
+    "                      annotation_bgcolor=\"rgba(255,255,255,0.8)\")\n",
+    "    \n",
+    "    transform_key = rec.recommended_transform.value if rec else \"none\"\n",
+    "    transform_label = TRANSFORM_DISPLAY_NAMES.get(transform_key, transform_key)\n",
+    "    fig.update_layout(\n",
+    "        title=f\"Distribution: {col_name}<br><sub>Skew: {analysis.skewness:.2f} | Kurt: {analysis.kurtosis:.2f} | Strategy: {transform_label}</sub>\",\n",
+    "        xaxis_title=col_name,\n",
+    "        yaxis_title=\"Count\",\n",
+    "        template='plotly_white',\n",
+    "        height=400\n",
+    "    )\n",
+    "    display_figure(fig)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "717daeed",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:48.690400Z",
+     "iopub.status.busy": "2026-02-02T13:00:48.690274Z",
+     "iopub.status.idle": "2026-02-02T13:00:48.769460Z",
+     "shell.execute_reply": "2026-02-02T13:00:48.768110Z"
+    },
+    "papermill": {
+     "duration": 0.100477,
+     "end_time": "2026-02-02T13:00:48.770667",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:48.670190",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "print(\"\\n\" + \"=\"*70)\n",
+    "print(\"CATEGORICAL COLUMN PROFILES\")\n",
+    "print(\"=\"*70)\n",
+    "\n",
+    "categorical_cols = [n for n, c in findings.columns.items()\n",
+    "                    if c.inferred_type.value in ('categorical_nominal', 'categorical_ordinal', 'binary', 'categorical_cyclical')\n",
+    "                    and c.inferred_type != ColumnType.TEXT  # TEXT columns processed separately in 01a_a\n",
+    "                    and n not in [ENTITY_COLUMN, TIME_COLUMN] and n not in TEMPORAL_METADATA_COLS]\n",
+    "\n",
+    "for col_name in categorical_cols:\n",
+    "    col_info = findings.columns[col_name]\n",
+    "    cardinality = col_info.universal_metrics.get('distinct_count', df[col_name].nunique())\n",
+    "    \n",
+    "    print(f\"\\n{'='*50}\")\n",
+    "    print(f\"Column: {col_name}\")\n",
+    "    print(f\"Type: {col_info.inferred_type.value} (Confidence: {col_info.confidence:.0%})\")\n",
+    "    print(f\"Distinct Values: {cardinality}\")\n",
+    "    \n",
+    "    # Encoding recommendation based on type and cardinality\n",
+    "    if col_info.inferred_type.value == 'categorical_cyclical':\n",
+    "        encoding_rec = \"Sin/Cos encoding (cyclical)\"\n",
+    "    elif cardinality <= 5:\n",
+    "        encoding_rec = \"One-hot encoding (low cardinality)\"\n",
+    "    elif cardinality <= 20:\n",
+    "        encoding_rec = \"One-hot or Target encoding\"\n",
+    "    else:\n",
+    "        encoding_rec = \"Target encoding or Frequency encoding (high cardinality)\"\n",
+    "    print(f\"Recommended Encoding: {encoding_rec}\")\n",
+    "    \n",
+    "    # Value counts visualization\n",
+    "    value_counts = df[col_name].value_counts().head(10)\n",
+    "    fig = charts.bar_chart(value_counts.index.tolist(), value_counts.values.tolist(),\n",
+    "                           title=f\"Top Categories: {col_name}\")\n",
+    "    display_figure(fig)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4b247183",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:48.840537Z",
+     "iopub.status.busy": "2026-02-02T13:00:48.840361Z",
+     "iopub.status.idle": "2026-02-02T13:00:48.845994Z",
+     "shell.execute_reply": "2026-02-02T13:00:48.844563Z"
+    },
+    "papermill": {
+     "duration": 0.039378,
+     "end_time": "2026-02-02T13:00:48.846750",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:48.807372",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "print(\"\\n\" + \"=\"*70)\n",
+    "print(\"TRANSFORMATION SUMMARY\")\n",
+    "print(\"=\"*70)\n",
+    "\n",
+    "# Human-readable transformation names\n",
+    "TRANSFORM_DISPLAY_NAMES = {\n",
+    "    'none': 'None needed',\n",
+    "    'log': 'Log transform',\n",
+    "    'log1p': 'Log(1+x) transform',\n",
+    "    'sqrt': 'Square root',\n",
+    "    'box_cox': 'Box-Cox power transform',\n",
+    "    'yeo_johnson': 'Yeo-Johnson power transform',\n",
+    "    'quantile': 'Quantile normalization',\n",
+    "    'robust_scale': 'Robust scaling (median/IQR)',\n",
+    "    'standard_scale': 'Standard scaling (z-score)',\n",
+    "    'minmax_scale': 'Min-Max scaling',\n",
+    "}\n",
+    "\n",
+    "transformations = []\n",
+    "for col_name, rec in recommendations.items():\n",
+    "    if rec and rec.recommended_transform != TransformationType.NONE:\n",
+    "        transform_key = rec.recommended_transform.value\n",
+    "        display_name = TRANSFORM_DISPLAY_NAMES.get(transform_key, transform_key)\n",
+    "        transformations.append({\n",
+    "            'column': col_name,\n",
+    "            'transform': display_name,\n",
+    "            'reason': rec.reason,\n",
+    "            'priority': rec.priority\n",
+    "        })\n",
+    "\n",
+    "if transformations:\n",
+    "    print(\"\\nRecommended transformations:\")\n",
+    "    # Sort by priority\n",
+    "    priority_order = {'high': 0, 'medium': 1, 'low': 2}\n",
+    "    transformations.sort(key=lambda x: priority_order.get(x['priority'], 3))\n",
+    "    \n",
+    "    for t in transformations:\n",
+    "        priority_marker = \"🔴\" if t['priority'] == 'high' else \"🟡\" if t['priority'] == 'medium' else \"🟢\"\n",
+    "        print(f\"\\n   {priority_marker} {t['column']}: {t['transform']}\")\n",
+    "        print(f\"      Reason: {t['reason']}\")\n",
+    "else:\n",
+    "    print(\"\\nNo transformations needed - columns are well-behaved\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5e4d9111",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:48.903633Z",
+     "iopub.status.busy": "2026-02-02T13:00:48.903517Z",
+     "iopub.status.idle": "2026-02-02T13:00:48.924603Z",
+     "shell.execute_reply": "2026-02-02T13:00:48.924101Z"
+    },
+    "papermill": {
+     "duration": 0.051964,
+     "end_time": "2026-02-02T13:00:48.925517",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:48.873553",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Aggregation perspective: which windows preserve temporal signal per column?\n",
+    "if numeric_cols and inter_event_times:\n",
+    "    median_iet = inter_event_series.median()\n",
+    "    print(\"=\"*70)\n",
+    "    print(\"TEMPORAL AGGREGATION PERSPECTIVE\")\n",
+    "    print(\"=\"*70)\n",
+    "    print(f\"\\nMedian inter-event time: {median_iet:.0f} days\")\n",
+    "    print(f\"Expected events per window (at median cadence):\")\n",
+    "    windows_days = [(\"7d\", 7), (\"30d\", 30), (\"90d\", 90), (\"180d\", 180), (\"365d\", 365)]\n",
+    "    for label, days in windows_days:\n",
+    "        expected = days / median_iet if median_iet > 0 else 0\n",
+    "        marker = \"\\u2705\" if expected >= 2 else \"\\u26a0\\ufe0f\" if expected >= 1 else \"\\u274c\"\n",
+    "        print(f\"   {marker} {label}: ~{expected:.1f} events/entity\")\n",
+    "\n",
+    "    # Within-entity vs between-entity variance per column\n",
+    "    print(f\"\\nColumn Temporal Variability (within-entity CV vs between-entity CV):\")\n",
+    "    print(f\"{'Column':<25} {'Within-CV':<12} {'Between-CV':<12} {'Ratio':<8} {'Aggregation Guidance'}\")\n",
+    "    print(\"-\" * 90)\n",
+    "\n",
+    "    for col in numeric_cols:\n",
+    "        col_data = df_temp.groupby(ENTITY_COLUMN)[col]\n",
+    "        entity_means = col_data.mean()\n",
+    "        entity_stds = col_data.std()\n",
+    "\n",
+    "        within_cv = (entity_stds / entity_means.abs().clip(lower=1e-10)).median()\n",
+    "        between_cv = entity_means.std() / entity_means.abs().mean() if entity_means.abs().mean() > 1e-10 else 0.0\n",
+    "\n",
+    "        if between_cv > 0:\n",
+    "            ratio = within_cv / between_cv\n",
+    "        else:\n",
+    "            ratio = float(\"inf\") if within_cv > 0 else 0.0\n",
+    "\n",
+    "        if within_cv < 0.3:\n",
+    "            guidance = \"Stable per entity -> all_time mean sufficient\"\n",
+    "        elif ratio > 1.5:\n",
+    "            guidance = \"High temporal dynamics -> shorter windows preserve signal\"\n",
+    "        elif ratio > 0.5:\n",
+    "            guidance = \"Mixed -> both short and long windows add value\"\n",
+    "        else:\n",
+    "            guidance = \"Entity-driven -> between-entity differences dominate\"\n",
+    "\n",
+    "        within_str = f\"{within_cv:.2f}\" if not np.isinf(within_cv) else \"inf\"\n",
+    "        ratio_str = f\"{ratio:.2f}\" if not np.isinf(ratio) else \">10\"\n",
+    "        print(f\"{col:<25} {within_str:<12} {between_cv:<12.2f} {ratio_str:<8} {guidance}\")\n",
+    "\n",
+    "    print(f\"\\nInterpretation:\")\n",
+    "    print(f\"  Within-CV: how much each entity\\'s values vary across their events\")\n",
+    "    print(f\"  Between-CV: how much entity averages differ from each other\")\n",
+    "    print(f\"  Ratio > 1: temporal variation dominates -> shorter windows capture dynamics\")\n",
+    "    print(f\"  Ratio < 1: entity identity dominates -> longer windows (or all_time) sufficient\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0b74dd72",
+   "metadata": {
+    "papermill": {
+     "duration": 0.026472,
+     "end_time": "2026-02-02T13:00:49.019319",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:48.992847",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1a.9 Update Findings with Time Series Metadata"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1b8e715c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:49.079024Z",
+     "iopub.status.busy": "2026-02-02T13:00:49.078908Z",
+     "iopub.status.idle": "2026-02-02T13:00:49.097323Z",
+     "shell.execute_reply": "2026-02-02T13:00:49.096468Z"
+    },
+    "papermill": {
+     "duration": 0.05005,
+     "end_time": "2026-02-02T13:00:49.098029",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:49.047979",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.analysis.auto_explorer.findings import TimeSeriesMetadata\n",
+    "from customer_retention.stages.profiling import WindowRecommendationCollector\n",
+    "\n",
+    "# Build window recommendations from data coverage analysis\n",
+    "window_collector = WindowRecommendationCollector(coverage_threshold=0.10)\n",
+    "window_collector.add_segment_context(segment_result)\n",
+    "window_collector.add_quadrant_context(quadrant_result)\n",
+    "\n",
+    "# Add inter-event timing context if available\n",
+    "if inter_event_times:\n",
+    "    window_collector.add_inter_event_context(\n",
+    "        median_days=inter_event_series.median(),\n",
+    "        mean_days=inter_event_series.mean(),\n",
+    "    )\n",
+    "\n",
+    "window_result = window_collector.compute_union(\n",
+    "    lifecycles=quadrant_result.lifecycles,\n",
+    "    time_span_days=ts_profile.time_span_days,\n",
+    "    value_columns=len(numeric_cols),\n",
+    "    agg_funcs=4,\n",
+    ")\n",
+    "\n",
+    "print(f\"Selected windows: {window_result.windows}\")\n",
+    "print(f\"Total features per entity: ~{window_result.feature_count_estimate}\\n\")\n",
+    "\n",
+    "explanation = window_result.explanation.drop(columns=[\"window_days\"]).copy()\n",
+    "explanation[\"coverage_pct\"] = (explanation[\"coverage_pct\"] * 100).round(1).astype(str) + \"%\"\n",
+    "explanation[\"meaningful_pct\"] = (explanation[\"meaningful_pct\"] * 100).round(1).astype(str) + \"%\"\n",
+    "display_table(explanation)\n",
+    "\n",
+    "print(f\"\\nCoverage: % of entities with enough tenure AND expected >=2 events in that window\")\n",
+    "print(f\"Meaningful: among entities with enough tenure, % that have sufficient event density\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "06cab0fb",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:49.170783Z",
+     "iopub.status.busy": "2026-02-02T13:00:49.170665Z",
+     "iopub.status.idle": "2026-02-02T13:00:49.175737Z",
+     "shell.execute_reply": "2026-02-02T13:00:49.175087Z"
+    },
+    "papermill": {
+     "duration": 0.049936,
+     "end_time": "2026-02-02T13:00:49.176343",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:49.126407",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "h = window_result.heterogeneity\n",
+    "\n",
+    "print(\"Temporal Heterogeneity (eta-squared):\")\n",
+    "print(f\"  eta² measures the fraction of variance in a metric explained by lifecycle quadrant grouping.\")\n",
+    "print(f\"  Scale: 0 = no group differences, 1 = all variance is between groups.\")\n",
+    "print(f\"  Thresholds: <0.06 = low | 0.06-0.14 = moderate | >0.14 = high effect size\\n\")\n",
+    "\n",
+    "eta_max = max(h.eta_squared_intensity, h.eta_squared_event_count)\n",
+    "print(f\"  Intensity eta²:   {h.eta_squared_intensity:.3f}  {'<-- dominant' if h.eta_squared_intensity >= h.eta_squared_event_count else ''}\")\n",
+    "print(f\"  Event count eta²: {h.eta_squared_event_count:.3f}  {'<-- dominant' if h.eta_squared_event_count > h.eta_squared_intensity else ''}\")\n",
+    "print(f\"  Overall level:    {h.heterogeneity_level.upper()} (max eta² = {eta_max:.3f})\\n\")\n",
+    "\n",
+    "advisory_labels = {\n",
+    "    \"single_model\": \"Single model with union windows is appropriate\",\n",
+    "    \"consider_segment_feature\": \"Add lifecycle_quadrant as a categorical feature to the model\",\n",
+    "    \"consider_separate_models\": \"Consider separate models for entities with vs without history\",\n",
+    "}\n",
+    "advisory_text = advisory_labels.get(h.segmentation_advisory, h.segmentation_advisory)\n",
+    "\n",
+    "print(f\"Recommendation: {advisory_text}\")\n",
+    "for r in h.advisory_rationale:\n",
+    "    print(f\"  -> {r}\")\n",
+    "print()\n",
+    "display_table(h.coverage_table)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6483b029",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:49.232605Z",
+     "iopub.status.busy": "2026-02-02T13:00:49.232481Z",
+     "iopub.status.idle": "2026-02-02T13:00:49.248795Z",
+     "shell.execute_reply": "2026-02-02T13:00:49.248116Z"
+    },
+    "papermill": {
+     "duration": 0.045594,
+     "end_time": "2026-02-02T13:00:49.249286",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:49.203692",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "advisory_labels = {\n",
+    "    \"single_model\": \"Single model with union windows is appropriate\",\n",
+    "    \"consider_segment_feature\": \"Add lifecycle_quadrant as a categorical feature to the model\",\n",
+    "    \"consider_separate_models\": \"Consider separate models for entities with vs without history\",\n",
+    "}\n",
+    "\n",
+    "# Preserve temporal_pattern from original findings if available\n",
+    "existing_pattern = findings.time_series_metadata.temporal_pattern if findings.time_series_metadata else None\n",
+    "\n",
+    "ts_metadata = TimeSeriesMetadata(\n",
+    "    granularity=DatasetGranularity.EVENT_LEVEL,\n",
+    "    temporal_pattern=existing_pattern,\n",
+    "    entity_column=ENTITY_COLUMN,\n",
+    "    time_column=TIME_COLUMN,\n",
+    "    avg_events_per_entity=ts_profile.events_per_entity.mean,\n",
+    "    time_span_days=ts_profile.time_span_days,\n",
+    "    unique_entities=ts_profile.unique_entities,\n",
+    "    suggested_aggregations=window_result.windows,\n",
+    "    window_coverage_threshold=window_result.coverage_threshold,\n",
+    "    heterogeneity_level=window_result.heterogeneity.heterogeneity_level,\n",
+    "    eta_squared_intensity=window_result.heterogeneity.eta_squared_intensity,\n",
+    "    eta_squared_event_count=window_result.heterogeneity.eta_squared_event_count,\n",
+    "    temporal_segmentation_advisory=window_result.heterogeneity.segmentation_advisory,\n",
+    "    temporal_segmentation_recommendation=advisory_labels.get(\n",
+    "        window_result.heterogeneity.segmentation_advisory,\n",
+    "        window_result.heterogeneity.segmentation_advisory,\n",
+    "    ),\n",
+    "    drift_risk_level=drift.risk_level,\n",
+    "    volume_drift_risk=drift.volume_drift_risk,\n",
+    "    population_stability=drift.population_stability,\n",
+    "    regime_count=drift.regime_count,\n",
+    "    recommended_training_start=(\n",
+    "        drift.recommended_training_start.isoformat() if drift.recommended_training_start else None\n",
+    "    ),\n",
+    ")\n",
+    "\n",
+    "findings.time_series_metadata = ts_metadata\n",
+    "findings.save(FINDINGS_PATH)\n",
+    "\n",
+    "print(f\"Updated findings saved to: {FINDINGS_PATH}\")\n",
+    "print(f\"  Suggested aggregations: {ts_metadata.suggested_aggregations}\")\n",
+    "print(f\"  Heterogeneity: {ts_metadata.heterogeneity_level}\")\n",
+    "print(f\"  Recommendation: {ts_metadata.temporal_segmentation_recommendation}\")\n",
+    "print(f\"  Drift risk: {ts_metadata.drift_risk_level}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0a8eeb4c",
+   "metadata": {
+    "papermill": {
+     "duration": 0.032613,
+     "end_time": "2026-02-02T13:00:49.307825",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:49.275212",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "\n",
+    "## Summary: What We Learned\n",
+    "\n",
+    "In this notebook, we performed a deep dive on time series data:\n",
+    "\n",
+    "1. **Event Distribution** - Analyzed how events are distributed across entities\n",
+    "2. **Activity Segments** - Categorized entities by activity level (one-time, low, medium, high)\n",
+    "3. **Lifecycle Analysis** - Examined entity tenure and duration patterns\n",
+    "4. **Temporal Coverage** - Visualized data volume over time\n",
+    "5. **Inter-Event Timing** - Understood engagement frequency patterns\n",
+    "6. **Feature Opportunities** - Identified time-window aggregations and recency features\n",
+    "\n",
+    "## Key Metrics for This Dataset\n",
+    "\n",
+    "| Metric | Value |\n",
+    "|--------|-------|\n",
+    "| Unique Entities | Fill from ts_profile |\n",
+    "| Avg Events/Entity | Fill from ts_profile |\n",
+    "| Median Lifecycle | Fill from analysis |\n",
+    "| Median Inter-Event Days | Fill from analysis |\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## Next Steps\n",
+    "\n",
+    "Continue with the **Event Bronze Track**:\n",
+    "\n",
+    "1. **01b_temporal_quality.ipynb** - Check for duplicate events, temporal gaps, future dates\n",
+    "2. **01c_temporal_patterns.ipynb** - Detect trends, seasonality, cohort analysis\n",
+    "3. **01d_event_aggregation.ipynb** - Aggregate events to entity-level (produces new dataset)\n",
+    "\n",
+    "After completing 01d, continue with the **Entity Bronze Track** (02 → 03 → 04) on the aggregated data."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20a706ed",
+   "metadata": {
+    "papermill": {
+     "duration": 0.027747,
+     "end_time": "2026-02-02T13:00:49.364696",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:49.336949",
+     "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": 9.174603,
+   "end_time": "2026-02-02T13:00:52.007930",
+   "environment_variables": {},
+   "exception": null,
+   "input_path": "/Users/Vital/python/CustomerRetention/exploration_notebooks/01a_temporal_deep_dive.ipynb",
+   "output_path": "/Users/Vital/python/CustomerRetention/exploration_notebooks/01a_temporal_deep_dive.ipynb",
+   "parameters": {},
+   "start_time": "2026-02-02T13:00:42.833327",
+   "version": "2.6.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}