churnkit 0.75.0a1__py3-none-any.whl

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

@@ -0,0 +1,1165 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "cell-0",
+   "metadata": {
+    "papermill": {
+     "duration": 0.00294,
+     "end_time": "2026-02-02T13:00:36.292705",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:36.289765",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Start Here: Data Discovery\n",
+    "\n",
+    "**Purpose:** Create a point-in-time snapshot and understand your dataset's structure through automatic profiling.\n",
+    "\n",
+    "**What you'll learn:**\n",
+    "- How to create temporally-safe training snapshots\n",
+    "- How automatic type inference works and when to override it\n",
+    "- How to identify entity-level vs event-level data\n",
+    "- How to set up your target column for downstream analysis\n",
+    "\n",
+    "**Outputs:**\n",
+    "- Point-in-time training snapshot (Parquet)\n",
+    "- Dataset overview (rows, columns, memory, format, structure)\n",
+    "- Automatic column type inference with confidence scores\n",
+    "- Saved exploration findings (YAML)\n",
+    "\n",
+    "---\n",
+    "\n",
+    "## How to Read This Notebook\n",
+    "\n",
+    "Each section includes:\n",
+    "- **📊 Charts** - Interactive Plotly visualizations\n",
+    "- **📖 Interpretation Guide** - How to read and understand the output\n",
+    "- **✅ Actions** - What to do based on the findings"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-1",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002082,
+     "end_time": "2026-02-02T13:00:36.297433",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:36.295351",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1.1 Configuration\n",
+    "\n",
+    "Configure your data source and target column **before** running the notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-2",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:36.302181Z",
+     "iopub.status.busy": "2026-02-02T13:00:36.302053Z",
+     "iopub.status.idle": "2026-02-02T13:00:38.169709Z",
+     "shell.execute_reply": "2026-02-02T13:00:38.168998Z"
+    },
+    "papermill": {
+     "duration": 1.871147,
+     "end_time": "2026-02-02T13:00:38.170509",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:36.299362",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from customer_retention.analysis.notebook_progress import track_and_export_previous\n",
+    "track_and_export_previous(\"01_data_discovery.ipynb\")\n",
+    "\n",
+    "from datetime import datetime\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import pandas as pd\n",
+    "\n",
+    "from customer_retention.analysis.auto_explorer import DataExplorer\n",
+    "from customer_retention.analysis.auto_explorer.findings import TimeSeriesMetadata\n",
+    "from customer_retention.analysis.visualization import ChartBuilder, console, display_figure, display_table\n",
+    "from customer_retention.core.config.column_config import DatasetGranularity\n",
+    "from customer_retention.core.config.experiments import (\n",
+    "    EXPERIMENTS_DIR,\n",
+    "    FINDINGS_DIR,  # noqa: F401 - required for test validation\n",
+    "    OUTPUT_DIR,\n",
+    "    setup_experiments_structure,\n",
+    ")\n",
+    "from customer_retention.stages.profiling import TypeDetector\n",
+    "from customer_retention.stages.temporal import (\n",
+    "    TEMPORAL_METADATA_COLS,\n",
+    "    CutoffAnalyzer,\n",
+    "    PointInTimeRegistry,\n",
+    "    ScenarioDetector,\n",
+    "    UnifiedDataPreparer,\n",
+    ")\n",
+    "from customer_retention.stages.validation import TimeSeriesDetector"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-3",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:38.175150Z",
+     "iopub.status.busy": "2026-02-02T13:00:38.175032Z",
+     "iopub.status.idle": "2026-02-02T13:00:38.178565Z",
+     "shell.execute_reply": "2026-02-02T13:00:38.178104Z"
+    },
+    "papermill": {
+     "duration": 0.006562,
+     "end_time": "2026-02-02T13:00:38.179180",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:38.172618",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# CONFIGURATION - Set these before running\n",
+    "# =============================================================================\n",
+    "\n",
+    "# DATA_PATH: Path to your data file (CSV, Parquet, or Delta)\n",
+    "DATA_PATH = \"../tests/fixtures/customer_retention_retail.csv\"\n",
+    "\n",
+    "# TARGET_COLUMN: Your prediction target (set to None for auto-detection)\n",
+    "TARGET_COLUMN = \"unsubscribed\"\n",
+    "\n",
+    "# ENTITY_COLUMN: Customer/user ID column (set to None for auto-detection)\n",
+    "ENTITY_COLUMN = None\n",
+    "\n",
+    "# LABEL_WINDOW_DAYS: Days after last activity to derive label timestamp\n",
+    "# Used when no explicit label timestamp column exists (e.g., churn_date)\n",
+    "# Default: 180 days (6 months observation window)\n",
+    "LABEL_WINDOW_DAYS = 180\n",
+    "\n",
+    "# TIMESTAMP_CONFIG: Override auto-detection if needed (set to None for auto-detection)\n",
+    "# Example manual override:\n",
+    "# TIMESTAMP_CONFIG = TimestampConfig(\n",
+    "#     strategy=TimestampStrategy.PRODUCTION,\n",
+    "#     feature_timestamp_column=\"observation_date\",\n",
+    "#     label_timestamp_column=\"churn_date\",\n",
+    "# )\n",
+    "TIMESTAMP_CONFIG = None\n",
+    "\n",
+    "# =============================================================================\n",
+    "# SAMPLE DATASETS (for learning/testing only)\n",
+    "# =============================================================================\n",
+    "# ENTITY-LEVEL (one row per customer):\n",
+    "# DATA_PATH = \"../tests/fixtures/customer_retention_retail.csv\"\n",
+    "# DATA_PATH = \"../tests/fixtures/bank_customer_churn.csv\"\n",
+    "# DATA_PATH = \"../tests/fixtures/netflix_customer_churn.csv\"\n",
+    "#\n",
+    "# EVENT-LEVEL (multiple rows per customer):\n",
+    "# DATA_PATH = \"../tests/fixtures/customer_transactions.csv\"\n",
+    "DATA_PATH = \"../tests/fixtures/customer_emails.csv\"\n",
+    "# =============================================================================\n",
+    "\n",
+    "# OUTPUT_DIR: All outputs go here (gitignored)\n",
+    "# OUTPUT_DIR imported from customer_retention.core.config.experiments\n",
+    "setup_experiments_structure()  # Creates all experiment directories\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-4",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001804,
+     "end_time": "2026-02-02T13:00:38.182826",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:38.181022",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1.2 Load Data & Create Point-in-Time Snapshot\n",
+    "\n",
+    "**This is the critical first step.** We:\n",
+    "1. Load raw data\n",
+    "2. Detect temporal scenario (production timestamps, derived, or synthetic)\n",
+    "3. Create a versioned snapshot with `feature_timestamp` and `label_timestamp`\n",
+    "4. All subsequent analysis uses the snapshot data\n",
+    "\n",
+    "This ensures temporal integrity and prevents data leakage."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-5",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:38.187106Z",
+     "iopub.status.busy": "2026-02-02T13:00:38.186994Z",
+     "iopub.status.idle": "2026-02-02T13:00:38.358866Z",
+     "shell.execute_reply": "2026-02-02T13:00:38.358388Z"
+    },
+    "papermill": {
+     "duration": 0.175034,
+     "end_time": "2026-02-02T13:00:38.359612",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:38.184578",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Load raw data\n",
+    "raw_df = pd.read_csv(DATA_PATH) if DATA_PATH.endswith('.csv') else pd.read_parquet(DATA_PATH)\n",
+    "\n",
+    "console.start_section()\n",
+    "console.header(\"Raw Data Loaded\")\n",
+    "console.metric(\"Source\", DATA_PATH)\n",
+    "console.metric(\"Rows\", f\"{len(raw_df):,}\")\n",
+    "console.metric(\"Columns\", len(raw_df.columns))\n",
+    "console.end_section()\n",
+    "\n",
+    "# Detect granularity and entity column\n",
+    "type_detector = TypeDetector()\n",
+    "granularity_result = type_detector.detect_granularity(raw_df)\n",
+    "entity_column = ENTITY_COLUMN or granularity_result.entity_column\n",
+    "\n",
+    "# Detect or use provided timestamp configuration\n",
+    "if TIMESTAMP_CONFIG:\n",
+    "    ts_config = TIMESTAMP_CONFIG\n",
+    "    scenario = \"MANUAL_OVERRIDE\"\n",
+    "    discovery_result = None\n",
+    "    console.info(f\"Using manual timestamp config: {ts_config.strategy.value}\")\n",
+    "else:\n",
+    "    detector = ScenarioDetector(label_window_days=LABEL_WINDOW_DAYS)\n",
+    "    scenario, ts_config, discovery_result = detector.detect(raw_df, TARGET_COLUMN)\n",
+    "\n",
+    "console.start_section()\n",
+    "console.header(\"Temporal Scenario Detection\")\n",
+    "console.metric(\"Scenario\", scenario)\n",
+    "console.metric(\"Strategy\", ts_config.strategy.value)\n",
+    "console.metric(\"Label Window\", f\"{LABEL_WINDOW_DAYS} days\")\n",
+    "\n",
+    "if discovery_result:\n",
+    "    if discovery_result.feature_timestamp:\n",
+    "        source_col = discovery_result.feature_timestamp.column_name\n",
+    "        if discovery_result.feature_timestamp.is_derived:\n",
+    "            console.metric(\"Feature Timestamp\", f\"derived from {discovery_result.feature_timestamp.source_columns}\")\n",
+    "        else:\n",
+    "            was_promoted = \"promoted\" in discovery_result.feature_timestamp.notes.lower()\n",
+    "            if was_promoted:\n",
+    "                console.metric(\"Feature Timestamp\", f\"{source_col} (auto-selected as latest activity)\")\n",
+    "            else:\n",
+    "                console.metric(\"Feature Timestamp\", f\"{source_col} (explicit match)\")\n",
+    "\n",
+    "    if discovery_result.label_timestamp:\n",
+    "        if discovery_result.label_timestamp.is_derived:\n",
+    "            console.metric(\"Label Timestamp\", f\"derived: {discovery_result.label_timestamp.derivation_formula}\")\n",
+    "        else:\n",
+    "            console.metric(\"Label Timestamp\", f\"{discovery_result.label_timestamp.column_name} (explicit match)\")\n",
+    "\n",
+    "    if \"datetime_ordering\" in discovery_result.discovery_report:\n",
+    "        ordering = discovery_result.discovery_report[\"datetime_ordering\"]\n",
+    "        if ordering:\n",
+    "            console.info(f\"Datetime column ordering: {' → '.join(ordering)}\")\n",
+    "\n",
+    "console.end_section()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "jlzs6bfy2z",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002056,
+     "end_time": "2026-02-02T13:00:38.363922",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:38.361866",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### Cutoff Date Selection\n",
+    "\n",
+    "The chart below shows the temporal distribution of your data. Use it to select an appropriate cutoff date:\n",
+    "\n",
+    "- **Top chart**: Records per time bin and cumulative count\n",
+    "- **Bottom chart**: Train/Score split percentage at each potential cutoff date\n",
+    "- **Suggested cutoff** (blue dashed): Achieves ~90% train / 10% score split\n",
+    "\n",
+    "**Final data allocation:**\n",
+    "- Cutoff: 90% train, 10% score (holdout for final evaluation)\n",
+    "- Train/Test split: 89% train, 11% test (from the 90%)\n",
+    "- **Result: ~80% training, ~10% test, ~10% score**\n",
+    "\n",
+    "Adjust `CUTOFF_DATE` below if the suggested date doesn't fit your needs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "lfuwm8yytw",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:38.368471Z",
+     "iopub.status.busy": "2026-02-02T13:00:38.368352Z",
+     "iopub.status.idle": "2026-02-02T13:00:38.411174Z",
+     "shell.execute_reply": "2026-02-02T13:00:38.410774Z"
+    },
+    "papermill": {
+     "duration": 0.046024,
+     "end_time": "2026-02-02T13:00:38.411683",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:38.365659",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Analyze temporal distribution for cutoff selection\n",
+    "from customer_retention.stages.temporal import DatetimeOrderAnalyzer\n",
+    "\n",
+    "cutoff_analyzer = CutoffAnalyzer()\n",
+    "cutoff_analysis = None\n",
+    "\n",
+    "# Derive last_action_date by coalescing all datetime columns (latest-median first)\n",
+    "datetime_order_analyzer = DatetimeOrderAnalyzer()\n",
+    "last_action_series = datetime_order_analyzer.derive_last_action_date(raw_df)\n",
+    "\n",
+    "# Fallback to feature_timestamp column if no datetime columns found\n",
+    "timestamp_col = None\n",
+    "if last_action_series is None:\n",
+    "    if discovery_result and discovery_result.feature_timestamp:\n",
+    "        if not discovery_result.feature_timestamp.is_derived:\n",
+    "            timestamp_col = discovery_result.feature_timestamp.column_name\n",
+    "\n",
+    "# Check registry for existing cutoff\n",
+    "pit_registry = PointInTimeRegistry(OUTPUT_DIR)\n",
+    "registry_cutoff = pit_registry.check_consistency().reference_cutoff\n",
+    "\n",
+    "if last_action_series is not None:\n",
+    "    cutoff_analysis = cutoff_analyzer.analyze(raw_df, timestamp_series=last_action_series, n_bins=50)\n",
+    "    data_suggested_cutoff = cutoff_analysis.suggest_cutoff(train_ratio=0.9)\n",
+    "\n",
+    "    console.start_section()\n",
+    "    console.header(\"Cutoff Date Analysis\")\n",
+    "    console.metric(\"Timestamp Source\", \"last_action_date (coalesced)\")\n",
+    "    console.metric(\"Coverage\", f\"{cutoff_analysis.covered_rows:,} / {cutoff_analysis.source_rows:,} rows ({cutoff_analysis.coverage_ratio:.1%})\")\n",
+    "    if cutoff_analysis.coverage_ratio < 0.95:\n",
+    "        console.warning(\"Low timestamp coverage — consider filling missing dates\")\n",
+    "    console.metric(\"Date Range\", f\"{cutoff_analysis.date_range[0].strftime('%Y-%m-%d')} to {cutoff_analysis.date_range[1].strftime('%Y-%m-%d')}\")\n",
+    "    console.metric(\"Data-Suggested Cutoff\", data_suggested_cutoff.strftime(\"%Y-%m-%d\"))\n",
+    "    split = cutoff_analysis.get_split_at_date(data_suggested_cutoff)\n",
+    "    console.metric(\"At Suggested Split\", f\"{split['train_pct']:.0f}% train / {split['score_pct']:.0f}% score\")\n",
+    "\n",
+    "    if registry_cutoff:\n",
+    "        console.warning(f\"Registry has cutoff: {registry_cutoff.date()} (may be stale)\")\n",
+    "        console.info(\"To clear: pit_registry.clear_registry()\")\n",
+    "\n",
+    "    # Show milestones for reference\n",
+    "    milestones = cutoff_analysis.get_percentage_milestones(step=10)\n",
+    "    if milestones:\n",
+    "        console.subheader(\"Reference Dates (10% intervals)\")\n",
+    "        for m in milestones:\n",
+    "            console.info(f\"  {m['train_pct']:.0f}% train: {m['date'].strftime('%Y-%m-%d')}\")\n",
+    "    console.end_section()\n",
+    "elif timestamp_col:\n",
+    "    cutoff_analysis = cutoff_analyzer.analyze(raw_df, timestamp_column=timestamp_col, n_bins=50)\n",
+    "    data_suggested_cutoff = cutoff_analysis.suggest_cutoff(train_ratio=0.9)\n",
+    "\n",
+    "    console.start_section()\n",
+    "    console.header(\"Cutoff Date Analysis\")\n",
+    "    console.metric(\"Timestamp Column\", timestamp_col)\n",
+    "    console.metric(\"Coverage\", f\"{cutoff_analysis.covered_rows:,} / {cutoff_analysis.source_rows:,} rows ({cutoff_analysis.coverage_ratio:.1%})\")\n",
+    "    if cutoff_analysis.coverage_ratio < 0.95:\n",
+    "        console.warning(\"Low timestamp coverage — consider filling missing dates\")\n",
+    "    console.metric(\"Date Range\", f\"{cutoff_analysis.date_range[0].strftime('%Y-%m-%d')} to {cutoff_analysis.date_range[1].strftime('%Y-%m-%d')}\")\n",
+    "    console.metric(\"Data-Suggested Cutoff\", data_suggested_cutoff.strftime(\"%Y-%m-%d\"))\n",
+    "    split = cutoff_analysis.get_split_at_date(data_suggested_cutoff)\n",
+    "    console.metric(\"At Suggested Split\", f\"{split['train_pct']:.0f}% train / {split['score_pct']:.0f}% score\")\n",
+    "\n",
+    "    if registry_cutoff:\n",
+    "        console.warning(f\"Registry has cutoff: {registry_cutoff.date()} (may be stale)\")\n",
+    "        console.info(\"To clear: pit_registry.clear_registry()\")\n",
+    "\n",
+    "    milestones = cutoff_analysis.get_percentage_milestones(step=10)\n",
+    "    if milestones:\n",
+    "        console.subheader(\"Reference Dates (10% intervals)\")\n",
+    "        for m in milestones:\n",
+    "            console.info(f\"  {m['train_pct']:.0f}% train: {m['date'].strftime('%Y-%m-%d')}\")\n",
+    "    console.end_section()\n",
+    "else:\n",
+    "    data_suggested_cutoff = datetime.now()\n",
+    "    console.start_section()\n",
+    "    console.header(\"Cutoff Date Analysis\")\n",
+    "    console.warning(\"No timestamp column detected\")\n",
+    "    console.metric(\"Default Cutoff\", data_suggested_cutoff.strftime(\"%Y-%m-%d\"))\n",
+    "    if registry_cutoff:\n",
+    "        console.info(f\"Registry cutoff: {registry_cutoff.date()}\")\n",
+    "    console.end_section()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ls2ezi1t5ag",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:38.416642Z",
+     "iopub.status.busy": "2026-02-02T13:00:38.416549Z",
+     "iopub.status.idle": "2026-02-02T13:00:38.546887Z",
+     "shell.execute_reply": "2026-02-02T13:00:38.546376Z"
+    },
+    "papermill": {
+     "duration": 0.133635,
+     "end_time": "2026-02-02T13:00:38.547468",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:38.413833",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# CUTOFF DATE SELECTION - Set your preferred cutoff date\n",
+    "# =============================================================================\n",
+    "# Options:\n",
+    "#   None = use data-suggested cutoff (~90/10 split)\n",
+    "#   datetime(YYYY, M, D) = use specific date\n",
+    "#\n",
+    "# To clear stale registry: pit_registry.clear_registry()\n",
+    "# =============================================================================\n",
+    "CUTOFF_DATE = None  # e.g., datetime(2017, 7, 1)\n",
+    "\n",
+    "# Compute final selected cutoff\n",
+    "selected_cutoff = CUTOFF_DATE or data_suggested_cutoff\n",
+    "\n",
+    "console.start_section()\n",
+    "console.header(\"Selected Cutoff Date\")\n",
+    "if CUTOFF_DATE:\n",
+    "    console.info(f\"Manual override: {CUTOFF_DATE.strftime('%Y-%m-%d')}\")\n",
+    "else:\n",
+    "    console.info(f\"Using data-suggested: {selected_cutoff.strftime('%Y-%m-%d')}\")\n",
+    "\n",
+    "if cutoff_analysis:\n",
+    "    split = cutoff_analysis.get_split_at_date(selected_cutoff)\n",
+    "    console.metric(\"Train/Score Split\", f\"{split['train_pct']:.0f}% / {split['score_pct']:.0f}%\")\n",
+    "    console.metric(\"Train Records\", f\"{split['train_count']:,}\")\n",
+    "    console.metric(\"Score Records\", f\"{split['score_count']:,}\")\n",
+    "console.end_section()\n",
+    "\n",
+    "# Display chart with selected cutoff\n",
+    "if cutoff_analysis:\n",
+    "    chart_builder = ChartBuilder()\n",
+    "    display_figure(chart_builder.cutoff_selection_chart(\n",
+    "        cutoff_analysis,\n",
+    "        suggested_cutoff=selected_cutoff,\n",
+    "        current_cutoff=registry_cutoff\n",
+    "    ))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-6",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:38.555852Z",
+     "iopub.status.busy": "2026-02-02T13:00:38.555746Z",
+     "iopub.status.idle": "2026-02-02T13:00:39.496304Z",
+     "shell.execute_reply": "2026-02-02T13:00:39.495731Z"
+    },
+    "papermill": {
+     "duration": 0.945295,
+     "end_time": "2026-02-02T13:00:39.496802",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:38.551507",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# pit_registry already initialized in cutoff analysis cell\n",
+    "dataset_name = Path(DATA_PATH).stem\n",
+    "\n",
+    "# Use the user's selected cutoff (not forced by registry)\n",
+    "cutoff_date = selected_cutoff\n",
+    "\n",
+    "# Warn if overriding registry\n",
+    "if registry_cutoff and registry_cutoff.date() != selected_cutoff.date():\n",
+    "    console.start_section()\n",
+    "    console.header(\"Registry Update\")\n",
+    "    console.warning(f\"Overriding registry cutoff ({registry_cutoff.date()}) with {selected_cutoff.date()}\")\n",
+    "    console.info(\"All datasets in this project should use the same cutoff date\")\n",
+    "    console.end_section()\n",
+    "\n",
+    "preparer = UnifiedDataPreparer(OUTPUT_DIR, ts_config)\n",
+    "df = preparer.prepare_from_raw(raw_df, target_column=TARGET_COLUMN, entity_column=entity_column or \"entity_id\")\n",
+    "\n",
+    "# Use the same last_action_series from cutoff analysis for snapshot splitting\n",
+    "# (do NOT re-derive on prepared df, which has extra timestamp columns)\n",
+    "snapshot_df, snapshot_metadata = preparer.create_training_snapshot(\n",
+    "    df, cutoff_date, timestamp_series=last_action_series\n",
+    ")\n",
+    "\n",
+    "pit_registry.register_snapshot(\n",
+    "    dataset_name=dataset_name,\n",
+    "    snapshot_id=snapshot_metadata['snapshot_id'],\n",
+    "    cutoff_date=cutoff_date,\n",
+    "    source_path=DATA_PATH,\n",
+    "    row_count=snapshot_metadata['row_count']\n",
+    ")\n",
+    "\n",
+    "console.start_section()\n",
+    "console.header(\"Point-in-Time Snapshot Created\")\n",
+    "console.metric(\"Dataset\", dataset_name)\n",
+    "console.metric(\"Snapshot ID\", snapshot_metadata['snapshot_id'])\n",
+    "console.metric(\"Rows\", f\"{snapshot_metadata['row_count']:,}\")\n",
+    "console.metric(\"Features\", len(snapshot_metadata['feature_columns']))\n",
+    "console.metric(\"Cutoff Date\", str(cutoff_date.date()))\n",
+    "console.metric(\"Data Hash\", snapshot_metadata['data_hash'][:16] + \"...\")\n",
+    "\n",
+    "# Sanity check: snapshot size should be consistent with cutoff analysis\n",
+    "if cutoff_analysis:\n",
+    "    expected_split = cutoff_analysis.get_split_at_date(cutoff_date)\n",
+    "    expected_train = expected_split['train_count']\n",
+    "    actual_ratio = snapshot_metadata['row_count'] / len(df) * 100\n",
+    "    console.metric(\"Split Ratio\", f\"{actual_ratio:.0f}% train / {100 - actual_ratio:.0f}% score\")\n",
+    "    if abs(actual_ratio - expected_split['train_pct']) > 10:\n",
+    "        console.error(\n",
+    "            f\"SPLIT MISMATCH: snapshot has {snapshot_metadata['row_count']:,} rows \"\n",
+    "            f\"({actual_ratio:.0f}%) but analysis expected {expected_train:,} ({expected_split['train_pct']:.0f}%)\"\n",
+    "        )\n",
+    "\n",
+    "if \"feature_timestamp\" in df.columns:\n",
+    "    console.success(\"Temporal columns added: feature_timestamp, label_timestamp\")\n",
+    "else:\n",
+    "    console.warning(\"No temporal columns added (synthetic strategy)\")\n",
+    "\n",
+    "updated_report = pit_registry.check_consistency()\n",
+    "if updated_report.is_consistent:\n",
+    "    console.success(f\"All {len(pit_registry.snapshots)} datasets use cutoff: {cutoff_date.date()}\")\n",
+    "else:\n",
+    "    console.error(\"INCONSISTENT CUTOFF DATES DETECTED\")\n",
+    "    console.warning(f\"Out of sync: {', '.join(updated_report.inconsistent_datasets)}\")\n",
+    "    console.info(\"Re-run notebook 01 for out-of-sync datasets to align cutoff dates\")\n",
+    "\n",
+    "console.end_section()\n",
+    "\n",
+    "df = snapshot_df"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-7",
+   "metadata": {
+    "papermill": {
+     "duration": 0.003621,
+     "end_time": "2026-02-02T13:00:39.504319",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:39.500698",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1.3 Dataset Exploration\n",
+    "\n",
+    "Now we explore the **snapshot data** (not raw data). This ensures all visualizations and metrics reflect the actual training data with temporal integrity."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-8",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:39.512718Z",
+     "iopub.status.busy": "2026-02-02T13:00:39.512483Z",
+     "iopub.status.idle": "2026-02-02T13:00:40.268036Z",
+     "shell.execute_reply": "2026-02-02T13:00:40.267613Z"
+    },
+    "papermill": {
+     "duration": 0.760707,
+     "end_time": "2026-02-02T13:00:40.268855",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:39.508148",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Explore the snapshot data\n",
+    "# Note: UnifiedDataPreparer renames the target column to \"target\" in the snapshot\n",
+    "# So we use \"target\" as the hint, not the original TARGET_COLUMN name\n",
+    "explorer = DataExplorer(visualize=False, save_findings=True, output_dir=str(OUTPUT_DIR))\n",
+    "findings = explorer.explore(df, target_hint=\"target\", name=dataset_name)\n",
+    "findings.source_path = DATA_PATH\n",
+    "\n",
+    "# Store snapshot info in findings\n",
+    "findings.snapshot_id = snapshot_metadata['snapshot_id']\n",
+    "findings.snapshot_path = str(OUTPUT_DIR / \"snapshots\" / f\"{snapshot_metadata['snapshot_id']}.parquet\")\n",
+    "findings.timestamp_scenario = scenario\n",
+    "findings.timestamp_strategy = ts_config.strategy.value\n",
+    "\n",
+    "# Also store the original target column name for reference\n",
+    "findings.metadata[\"original_target_column\"] = TARGET_COLUMN\n",
+    "\n",
+    "granularity = \"event\" if granularity_result.granularity == DatasetGranularity.EVENT_LEVEL else \"entity\"\n",
+    "\n",
+    "# Display dataset overview\n",
+    "chart_builder = ChartBuilder()\n",
+    "display_figure(chart_builder.dataset_at_a_glance(\n",
+    "    df, findings,\n",
+    "    source_path=f\"Snapshot: {snapshot_metadata['snapshot_id']}\",\n",
+    "    granularity=granularity,\n",
+    "    max_columns=15,\n",
+    "    columns_per_row=5\n",
+    "))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-9",
+   "metadata": {
+    "papermill": {
+     "duration": 0.008723,
+     "end_time": "2026-02-02T13:00:40.285925",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:40.277202",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1.4 Column Summary Table"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-10",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:40.304451Z",
+     "iopub.status.busy": "2026-02-02T13:00:40.304338Z",
+     "iopub.status.idle": "2026-02-02T13:00:40.309685Z",
+     "shell.execute_reply": "2026-02-02T13:00:40.309252Z"
+    },
+    "papermill": {
+     "duration": 0.015804,
+     "end_time": "2026-02-02T13:00:40.310226",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:40.294422",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Exclude temporal metadata columns from summary\n",
+    "\n",
+    "summary_data = []\n",
+    "for name, col in findings.columns.items():\n",
+    "    if name in TEMPORAL_METADATA_COLS:\n",
+    "        continue\n",
+    "    null_pct = col.universal_metrics.get(\"null_percentage\", 0)\n",
+    "    distinct = col.universal_metrics.get(\"distinct_count\", \"N/A\")\n",
+    "    summary_data.append({\n",
+    "        \"Column\": name,\n",
+    "        \"Type\": col.inferred_type.value,\n",
+    "        \"Confidence\": f\"{col.confidence:.0%}\",\n",
+    "        \"Nulls %\": f\"{null_pct:.1f}%\",\n",
+    "        \"Distinct\": distinct,\n",
+    "        \"Evidence\": col.evidence[0] if col.evidence else \"\"\n",
+    "    })\n",
+    "\n",
+    "summary_df = pd.DataFrame(summary_data)\n",
+    "display_table(summary_df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-11",
+   "metadata": {
+    "papermill": {
+     "duration": 0.008735,
+     "end_time": "2026-02-02T13:00:40.327637",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:40.318902",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1.5 Target Column Verification"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-12",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:40.345703Z",
+     "iopub.status.busy": "2026-02-02T13:00:40.345579Z",
+     "iopub.status.idle": "2026-02-02T13:00:40.349522Z",
+     "shell.execute_reply": "2026-02-02T13:00:40.348868Z"
+    },
+    "papermill": {
+     "duration": 0.014034,
+     "end_time": "2026-02-02T13:00:40.350273",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:40.336239",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "console.start_section()\n",
+    "console.header(\"Target Column\")\n",
+    "\n",
+    "if findings.target_column and findings.target_column in df.columns:\n",
+    "    console.success(f\"Target: {findings.target_column}\")\n",
+    "    target_counts = df[findings.target_column].value_counts()\n",
+    "    for val, count in target_counts.items():\n",
+    "        pct = (count / len(df)) * 100\n",
+    "        console.metric(f\"Class {val}\", f\"{count:,} ({pct:.1f}%)\")\n",
+    "    if granularity_result.granularity == DatasetGranularity.EVENT_LEVEL:\n",
+    "        console.info(\"Note: Event-level distribution (per row, not per entity)\")\n",
+    "else:\n",
+    "    console.warning(\"No target column configured\")\n",
+    "    console.info(\"Set TARGET_COLUMN in the configuration cell above\")\n",
+    "\n",
+    "console.end_section()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-13",
+   "metadata": {
+    "papermill": {
+     "duration": 0.009232,
+     "end_time": "2026-02-02T13:00:40.368298",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:40.359066",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1.6 Dataset Structure Detection"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-14",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:40.400815Z",
+     "iopub.status.busy": "2026-02-02T13:00:40.400689Z",
+     "iopub.status.idle": "2026-02-02T13:00:40.754947Z",
+     "shell.execute_reply": "2026-02-02T13:00:40.754559Z"
+    },
+    "papermill": {
+     "duration": 0.363804,
+     "end_time": "2026-02-02T13:00:40.755594",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:40.391790",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "ts_detector = TimeSeriesDetector()\n",
+    "valid_entity_col = entity_column if entity_column and entity_column in df.columns else None\n",
+    "if not valid_entity_col:\n",
+    "    for col in df.columns:\n",
+    "        if any(p in col.lower() for p in [\"customer\", \"user\", \"entity\", \"account\"]) and \"id\" in col.lower():\n",
+    "            if df[col].nunique() < len(df):\n",
+    "                valid_entity_col = col\n",
+    "                break\n",
+    "\n",
+    "detected_ts_col = \"feature_timestamp\" if \"feature_timestamp\" in df.columns else None\n",
+    "ts_characteristics = ts_detector.detect(df, entity_column=valid_entity_col, timestamp_column=detected_ts_col)\n",
+    "\n",
+    "console.start_section()\n",
+    "console.header(\"Dataset Structure\")\n",
+    "console.metric(\"Granularity\", granularity_result.granularity.value.upper())\n",
+    "if ts_characteristics.dataset_type.value != \"unknown\":\n",
+    "    console.metric(\"Temporal Pattern\", ts_characteristics.dataset_type.value.upper())\n",
+    "console.metric(\"Entity Column\", valid_entity_col or entity_column or \"N/A\")\n",
+    "\n",
+    "if granularity_result.unique_entities:\n",
+    "    console.metric(\"Unique Entities\", f\"{granularity_result.unique_entities:,}\")\n",
+    "if granularity_result.avg_events_per_entity:\n",
+    "    console.metric(\"Avg Events/Entity\", f\"{granularity_result.avg_events_per_entity:.1f}\")\n",
+    "\n",
+    "is_event_level = granularity_result.granularity == DatasetGranularity.EVENT_LEVEL\n",
+    "if is_event_level:\n",
+    "    console.info(\"EVENT-LEVEL DATA - Use Event Bronze Track:\")\n",
+    "    console.info(\"  -> 01a_temporal_deep_dive.ipynb\")\n",
+    "    console.info(\"  -> 01b_temporal_quality.ipynb\")\n",
+    "    console.info(\"  -> 01c_temporal_patterns.ipynb\")\n",
+    "    console.info(\"  -> 01d_event_aggregation.ipynb\")\n",
+    "else:\n",
+    "    console.info(\"ENTITY-LEVEL DATA - Use standard flow:\")\n",
+    "    console.info(\"  -> 02_column_deep_dive.ipynb\")\n",
+    "    console.info(\"  -> 03_quality_assessment.ipynb\")\n",
+    "\n",
+    "console.end_section()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5x5ypzy4cqg",
+   "metadata": {
+    "papermill": {
+     "duration": 0.008912,
+     "end_time": "2026-02-02T13:00:40.773089",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:40.764177",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1.7 Feature Availability Analysis\n",
+    "\n",
+    "**Detect tracking changes over time:**\n",
+    "- **New tracking**: Variables that only exist from a certain date (new IT system introduced)\n",
+    "- **Retired tracking**: Variables that stop being tracked (system decommissioned)\n",
+    "- **Partial window**: Variables available only during a specific period\n",
+    "\n",
+    "This affects modeling because train/test splits should not cross availability boundaries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9wdocsw3wzj",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:40.791006Z",
+     "iopub.status.busy": "2026-02-02T13:00:40.790895Z",
+     "iopub.status.idle": "2026-02-02T13:00:40.815884Z",
+     "shell.execute_reply": "2026-02-02T13:00:40.815234Z"
+    },
+    "papermill": {
+     "duration": 0.035005,
+     "end_time": "2026-02-02T13:00:40.816633",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:40.781628",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Feature Availability Analysis - detect tracking changes\n",
+    "from customer_retention.analysis.auto_explorer.findings import FeatureAvailabilityInfo, FeatureAvailabilityMetadata\n",
+    "from customer_retention.stages.profiling import analyze_feature_availability\n",
+    "\n",
+    "time_col = detected_ts_col or ts_characteristics.timestamp_column\n",
+    "if time_col and time_col in df.columns:\n",
+    "    exclude_cols = list(TEMPORAL_METADATA_COLS) + ([valid_entity_col] if valid_entity_col else [])\n",
+    "    availability = analyze_feature_availability(df, time_col, exclude_columns=exclude_cols)\n",
+    "    \n",
+    "    console.start_section()\n",
+    "    console.header(\"Feature Availability\")\n",
+    "    console.metric(\"Data Span\", f\"{availability.data_start.date()} to {availability.data_end.date()} ({availability.time_span_days} days)\")\n",
+    "    \n",
+    "    if availability.new_tracking or availability.retired_tracking or availability.partial_window:\n",
+    "        if availability.new_tracking:\n",
+    "            console.warning(f\"New tracking ({len(availability.new_tracking)}): {', '.join(availability.new_tracking[:5])}\" + \n",
+    "                          (f\" +{len(availability.new_tracking)-5} more\" if len(availability.new_tracking) > 5 else \"\"))\n",
+    "        if availability.retired_tracking:\n",
+    "            console.warning(f\"Retired tracking ({len(availability.retired_tracking)}): {', '.join(availability.retired_tracking[:5])}\" +\n",
+    "                          (f\" +{len(availability.retired_tracking)-5} more\" if len(availability.retired_tracking) > 5 else \"\"))\n",
+    "        if availability.partial_window:\n",
+    "            console.warning(f\"Partial window ({len(availability.partial_window)}): {', '.join(availability.partial_window[:5])}\" +\n",
+    "                          (f\" +{len(availability.partial_window)-5} more\" if len(availability.partial_window) > 5 else \"\"))\n",
+    "        \n",
+    "        console.subheader(\"Recommendations\")\n",
+    "        for rec in availability.recommendations[:5]:\n",
+    "            if rec[\"column\"] != \"_general_\":\n",
+    "                console.info(f\"{rec['column']}: {rec['reason']}\")\n",
+    "        general_recs = [r for r in availability.recommendations if r[\"column\"] == \"_general_\"]\n",
+    "        if general_recs:\n",
+    "            console.warning(\"Train/test split should not cross feature availability boundaries\")\n",
+    "    else:\n",
+    "        console.success(\"All features have full temporal coverage\")\n",
+    "    console.end_section()\n",
+    "    \n",
+    "    # Store structured availability metadata for downstream use\n",
+    "    features_info = {\n",
+    "        feat.column: FeatureAvailabilityInfo(\n",
+    "            first_valid_date=feat.first_valid_date.isoformat()[:10] if feat.first_valid_date else None,\n",
+    "            last_valid_date=feat.last_valid_date.isoformat()[:10] if feat.last_valid_date else None,\n",
+    "            coverage_pct=feat.coverage_pct,\n",
+    "            availability_type=feat.availability_type,\n",
+    "            days_from_start=feat.days_from_start,\n",
+    "            days_before_end=feat.days_before_end,\n",
+    "        )\n",
+    "        for feat in availability.features\n",
+    "    }\n",
+    "    findings.feature_availability = FeatureAvailabilityMetadata(\n",
+    "        data_start=availability.data_start.isoformat()[:10],\n",
+    "        data_end=availability.data_end.isoformat()[:10],\n",
+    "        time_span_days=availability.time_span_days,\n",
+    "        new_tracking=availability.new_tracking,\n",
+    "        retired_tracking=availability.retired_tracking,\n",
+    "        partial_window=availability.partial_window,\n",
+    "        features=features_info,\n",
+    "    )\n",
+    "else:\n",
+    "    console.info(\"No timestamp column detected - skipping feature availability analysis\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-15",
+   "metadata": {
+    "papermill": {
+     "duration": 0.009128,
+     "end_time": "2026-02-02T13:00:40.834570",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:40.825442",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1.8 Type Override (Optional)\n",
+    "\n",
+    "Override any incorrectly inferred column types before saving findings."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-16",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:40.853044Z",
+     "iopub.status.busy": "2026-02-02T13:00:40.852915Z",
+     "iopub.status.idle": "2026-02-02T13:00:40.856702Z",
+     "shell.execute_reply": "2026-02-02T13:00:40.856113Z"
+    },
+    "papermill": {
+     "duration": 0.014054,
+     "end_time": "2026-02-02T13:00:40.857405",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:40.843351",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# === TYPE OVERRIDES ===\n",
+    "TYPE_OVERRIDES = {\n",
+    "    # \"column_name\": ColumnType.NEW_TYPE,\n",
+    "}\n",
+    "\n",
+    "console.start_section()\n",
+    "console.header(\"Type Override Review\")\n",
+    "\n",
+    "low_conf = [(name, col.inferred_type.value, col.confidence)\n",
+    "            for name, col in findings.columns.items()\n",
+    "            if col.confidence < 0.8 and name not in TEMPORAL_METADATA_COLS]\n",
+    "if low_conf:\n",
+    "    console.subheader(\"Low Confidence Detections\")\n",
+    "    for col_name, col_type, conf in sorted(low_conf, key=lambda x: x[2]):\n",
+    "        console.warning(f\"{col_name}: {col_type} ({conf:.0%})\")\n",
+    "else:\n",
+    "    console.success(\"All type detections have high confidence (>=80%)\")\n",
+    "\n",
+    "if TYPE_OVERRIDES:\n",
+    "    console.subheader(\"Applying Overrides\")\n",
+    "    for col_name, new_type in TYPE_OVERRIDES.items():\n",
+    "        if col_name in findings.columns:\n",
+    "            old_type = findings.columns[col_name].inferred_type.value\n",
+    "            findings.columns[col_name].inferred_type = new_type\n",
+    "            findings.columns[col_name].confidence = 1.0\n",
+    "            console.success(f\"{col_name}: {old_type} -> {new_type.value}\")\n",
+    "\n",
+    "console.end_section()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-17",
+   "metadata": {
+    "papermill": {
+     "duration": 0.008987,
+     "end_time": "2026-02-02T13:00:40.874685",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:40.865698",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1.9 Save Findings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cell-18",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-02-02T13:00:40.892705Z",
+     "iopub.status.busy": "2026-02-02T13:00:40.892582Z",
+     "iopub.status.idle": "2026-02-02T13:00:40.907134Z",
+     "shell.execute_reply": "2026-02-02T13:00:40.906616Z"
+    },
+    "papermill": {
+     "duration": 0.024129,
+     "end_time": "2026-02-02T13:00:40.907614",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:40.883485",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Populate time series metadata if event-level\n",
+    "if is_event_level:\n",
+    "    # Use feature_timestamp if available (coalesced column), otherwise fall back to detected column\n",
+    "    snapshot_time_col = \"feature_timestamp\" if \"feature_timestamp\" in df.columns else (\n",
+    "        granularity_result.time_column or ts_characteristics.timestamp_column\n",
+    "    )\n",
+    "    findings.time_series_metadata = TimeSeriesMetadata(\n",
+    "        granularity=DatasetGranularity.EVENT_LEVEL,\n",
+    "        temporal_pattern=ts_characteristics.dataset_type.value,\n",
+    "        entity_column=entity_column,\n",
+    "        time_column=snapshot_time_col,\n",
+    "        avg_events_per_entity=granularity_result.avg_events_per_entity,\n",
+    "        time_span_days=int(ts_characteristics.time_span_days) if ts_characteristics.time_span_days else None,\n",
+    "        unique_entities=granularity_result.unique_entities,\n",
+    "        suggested_aggregations=[\"24h\", \"7d\", \"30d\", \"90d\", \"all_time\"]\n",
+    "    )\n",
+    "\n",
+    "FINDINGS_PATH = explorer.last_findings_path\n",
+    "findings.save(FINDINGS_PATH)\n",
+    "\n",
+    "console.start_section()\n",
+    "console.header(\"Findings Saved\")\n",
+    "console.success(f\"Findings: {FINDINGS_PATH}\")\n",
+    "console.success(f\"Snapshot: {findings.snapshot_path}\")\n",
+    "console.metric(\"Columns\", findings.column_count)\n",
+    "console.metric(\"Target\", findings.target_column or \"Not set\")\n",
+    "console.metric(\"Snapshot ID\", findings.snapshot_id)\n",
+    "console.metric(\"Timestamp Strategy\", findings.timestamp_strategy)\n",
+    "console.end_section()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-19",
+   "metadata": {
+    "papermill": {
+     "duration": 0.008551,
+     "end_time": "2026-02-02T13:00:40.925353",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:40.916802",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1.10 Summary\n",
+    "\n",
+    "**What was created:**\n",
+    "- Point-in-time snapshot with `feature_timestamp` and `label_timestamp`\n",
+    "- Exploration findings with column types and metrics\n",
+    "\n",
+    "**All downstream notebooks load the snapshot**, ensuring:\n",
+    "- Temporal integrity (no data leakage)\n",
+    "- Reproducibility (SHA256 hash verification)\n",
+    "- Consistency (same data across all analysis)\n",
+    "\n",
+    "**Next steps:**\n",
+    "- Entity-level data: `02_column_deep_dive.ipynb`\n",
+    "- Event-level data: `01a_temporal_deep_dive.ipynb`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c15f6a9",
+   "metadata": {
+    "papermill": {
+     "duration": 0.008746,
+     "end_time": "2026-02-02T13:00:40.942103",
+     "exception": false,
+     "start_time": "2026-02-02T13:00:40.933357",
+     "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": 5.708346,
+   "end_time": "2026-02-02T13:00:41.468599",
+   "environment_variables": {},
+   "exception": null,
+   "input_path": "/Users/Vital/python/CustomerRetention/exploration_notebooks/01_data_discovery.ipynb",
+   "output_path": "/Users/Vital/python/CustomerRetention/exploration_notebooks/01_data_discovery.ipynb",
+   "parameters": {},
+   "start_time": "2026-02-02T13:00:35.760253",
+   "version": "2.6.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}