churnkit 0.76.1a1__py3-none-any.whl → 0.76.1a2__py3-none-any.whl

{churnkit-0.76.1a1.data → churnkit-0.76.1a2.data}/data/share/churnkit/exploration_notebooks/01c_temporal_patterns.ipynb

@@ -79,25 +79,24 @@
    "outputs": [],
    "source": [
     "from customer_retention.analysis.notebook_progress import track_and_export_previous\n",
+    "\n",
     "track_and_export_previous(\"01c_temporal_patterns.ipynb\")\n",
     "\n",
-    "from customer_retention.analysis.auto_explorer import ExplorationFindings\n",
-    "from customer_retention.analysis.visualization import ChartBuilder, display_figure, display_table\n",
-    "from customer_retention.core.config.column_config import ColumnType, DatasetGranularity\n",
-    "from customer_retention.stages.profiling import (\n",
-    "    TemporalPatternAnalyzer, TemporalPatternAnalysis,\n",
-    "    TrendResult, TrendDirection, SeasonalityResult, RecencyResult,\n",
-    "    TemporalFeatureAnalyzer, VelocityResult, MomentumResult,\n",
-    "    LagCorrelationResult, PredictivePowerResult, FeatureRecommendation,\n",
-    "    CategoricalTargetAnalyzer\n",
-    ")\n",
-    "import pandas as pd\n",
     "import numpy as np\n",
+    "import pandas as pd\n",
     "import plotly.graph_objects as go\n",
-    "import plotly.express as px\n",
     "from plotly.subplots import make_subplots\n",
-    "from scipy import stats\n",
-    "from customer_retention.core.config.experiments import FINDINGS_DIR, EXPERIMENTS_DIR, OUTPUT_DIR, setup_experiments_structure\n"
+    "\n",
+    "from customer_retention.analysis.auto_explorer import ExplorationFindings\n",
+    "from customer_retention.analysis.visualization import ChartBuilder, display_figure\n",
+    "from customer_retention.core.config.experiments import (\n",
+    "    FINDINGS_DIR,\n",
+    ")\n",
+    "from customer_retention.stages.profiling import (\n",
+    "    TemporalFeatureAnalyzer,\n",
+    "    TemporalPatternAnalyzer,\n",
+    "    TrendDirection,\n",
+    ")\n"
    ]
   },
   {
@@ -123,7 +122,6 @@
    "outputs": [],
    "source": [
     "# === CONFIGURATION ===\n",
-    "from pathlib import Path\n",
     "\n",
     "# FINDINGS_DIR imported from customer_retention.core.config.experiments\n",
     "\n",
@@ -195,7 +193,7 @@
    },
    "outputs": [],
    "source": [
-    "from customer_retention.stages.temporal import load_data_with_snapshot_preference, TEMPORAL_METADATA_COLS\n",
+    "from customer_retention.stages.temporal import TEMPORAL_METADATA_COLS, load_data_with_snapshot_preference\n",
     "\n",
     "# Load source data (prefers snapshots over raw files)\n",
     "df, data_source = load_data_with_snapshot_preference(findings, output_dir=str(FINDINGS_DIR))\n",
@@ -264,9 +262,7 @@
     "TARGET_AGGREGATION = \"max\"  # Options: \"max\", \"mean\", \"sum\", \"last\", \"first\"\n",
     "\n",
     "# Detect and analyze target\n",
-    "from customer_retention.stages.profiling import (\n",
-    "    TargetLevelAnalyzer, TargetColumnDetector, AggregationMethod\n",
-    ")\n",
+    "from customer_retention.stages.profiling import AggregationMethod, TargetColumnDetector, TargetLevelAnalyzer\n",
     "\n",
     "detector = TargetColumnDetector()\n",
     "target_col, method = detector.detect(findings, df, override=TARGET_COLUMN_OVERRIDE)\n",
@@ -278,14 +274,14 @@
     "    agg_method = AggregationMethod(TARGET_AGGREGATION)\n",
     "    df, result = analyzer.aggregate_to_entity(df, TARGET_COLUMN, ENTITY_COLUMN, TIME_COLUMN, agg_method)\n",
     "    analyzer.print_analysis(result)\n",
-    "    \n",
+    "\n",
     "    # Update TARGET_COLUMN to entity-level version if aggregated\n",
     "    if result.entity_target_column:\n",
     "        ORIGINAL_TARGET = TARGET_COLUMN\n",
     "        TARGET_COLUMN = result.entity_target_column\n",
     "\n",
     "print(\"\\n\" + \"─\"*70)\n",
-    "print(f\"Final configuration:\")\n",
+    "print(\"Final configuration:\")\n",
     "print(f\"   ENTITY_COLUMN: {ENTITY_COLUMN}\")\n",
     "print(f\"   TIME_COLUMN: {TIME_COLUMN}\")\n",
     "print(f\"   TARGET_COLUMN: {TARGET_COLUMN}\")\n",
@@ -363,10 +359,10 @@
     "print(\"=\"*70)\n",
     "print(f\"\\nSource: {'Manual override' if WINDOW_OVERRIDE else '01a findings (recommended)'}\")\n",
     "print(f\"\\nWindows: {pattern_config.aggregation_windows}\")\n",
-    "print(f\"\\nDerived settings used throughout this notebook:\")\n",
+    "print(\"\\nDerived settings used throughout this notebook:\")\n",
     "print(f\"   • Velocity/Rolling window: {pattern_config.velocity_window_days} days\")\n",
     "print(f\"   • Momentum pairs: {pattern_config.get_momentum_pairs()}\")\n",
-    "print(f\"\\n💡 To override, set WINDOW_OVERRIDE = ['7d', '30d', '90d'] above and re-run\")\n"
+    "print(\"\\n💡 To override, set WINDOW_OVERRIDE = ['7d', '30d', '90d'] above and re-run\")\n"
    ]
   },
   {
@@ -415,7 +411,7 @@
     "numeric_cols = [c for c in numeric_cols if c not in [ENTITY_COLUMN] and c not in TEMPORAL_METADATA_COLS]\n",
     "\n",
     "# Separate target columns from feature columns\n",
-    "target_cols = [c for c in numeric_cols if c.lower() in ['target', 'target_entity', 'label'] \n",
+    "target_cols = [c for c in numeric_cols if c.lower() in ['target', 'target_entity', 'label']\n",
     "               or (TARGET_COLUMN and c.lower() == TARGET_COLUMN.lower())]\n",
     "feature_cols = [c for c in numeric_cols if c not in target_cols]\n",
     "\n",
@@ -610,7 +606,7 @@
     "    if rec.features:\n",
     "        print(f\"      Features: {', '.join(rec.features)}\")\n",
     "\n",
-    "TREND_RECOMMENDATIONS = [{\"action\": r.action, \"priority\": r.priority, \"reason\": r.reason, \n",
+    "TREND_RECOMMENDATIONS = [{\"action\": r.action, \"priority\": r.priority, \"reason\": r.reason,\n",
     "                          \"features\": r.features} for r in trend_recs]"
    ]
   },
@@ -686,7 +682,6 @@
    "outputs": [],
    "source": [
     "# Seasonality Analysis - Temporal Pattern Grid + Autocorrelation\n",
-    "from plotly.subplots import make_subplots\n",
     "\n",
     "# Prepare temporal columns\n",
     "daily_data[\"day_of_week\"] = daily_data[TIME_COLUMN].dt.day_name()\n",
@@ -748,17 +743,17 @@
     "\n",
     "# Variation analysis\n",
     "def calc_var(stats): return (stats[\"mean\"].max() - stats[\"mean\"].min()) / overall_mean * 100 if len(stats) > 1 else 0\n",
-    "variations = {\"day_of_week\": calc_var(dow_stats), \"month\": calc_var(monthly_stats), \n",
+    "variations = {\"day_of_week\": calc_var(dow_stats), \"month\": calc_var(monthly_stats),\n",
     "              \"quarter\": calc_var(quarterly_stats), \"year\": calc_var(yearly_stats)}\n",
     "\n",
-    "print(f\"\\n📈 Pattern Variation (% from mean):\")\n",
+    "print(\"\\n📈 Pattern Variation (% from mean):\")\n",
     "print(f\"   Day of Week: {variations['day_of_week']:.1f}%\")\n",
     "print(f\"   Monthly:     {variations['month']:.1f}%\")\n",
     "print(f\"   Quarterly:   {variations['quarter']:.1f}%\")\n",
     "print(f\"   Yearly:      {variations['year']:.1f}%\")\n",
     "\n",
     "# Autocorrelation seasonality\n",
-    "print(f\"\\n🔁 Autocorrelation Seasonality (threshold > 0.3):\")\n",
+    "print(\"\\n🔁 Autocorrelation Seasonality (threshold > 0.3):\")\n",
     "if seasonality_results:\n",
     "    for sr in seasonality_results:\n",
     "        strength = \"Strong\" if sr.strength > 0.5 else \"Moderate\"\n",
@@ -771,7 +766,7 @@
     "SEASONALITY_RECOMMENDATIONS = []\n",
     "for pattern, var_pct in variations.items():\n",
     "    priority = \"high\" if var_pct > 20 else \"medium\" if var_pct > 10 else \"low\"\n",
-    "    \n",
+    "\n",
     "    if pattern == \"day_of_week\" and var_pct > 10:\n",
     "        SEASONALITY_RECOMMENDATIONS.append({\"pattern\": pattern, \"variation\": var_pct, \"priority\": priority,\n",
     "            \"features\": [\"dow_sin\", \"dow_cos\", \"is_weekend\"], \"reason\": f\"{var_pct:.1f}% variation - add cyclical encoding\"})\n",
@@ -794,8 +789,8 @@
     "# For autocorrelation-detected patterns\n",
     "for sr in seasonality_results:\n",
     "    if sr.period in [7, 14, 21, 30] and sr.strength > 0.3:\n",
-    "        SEASONALITY_RECOMMENDATIONS.append({\"pattern\": f\"{sr.period}d_cycle\", \"variation\": sr.strength * 100, \n",
-    "            \"priority\": \"medium\", \"features\": [f\"lag_{sr.period}d_ratio\"], \n",
+    "        SEASONALITY_RECOMMENDATIONS.append({\"pattern\": f\"{sr.period}d_cycle\", \"variation\": sr.strength * 100,\n",
+    "            \"priority\": \"medium\", \"features\": [f\"lag_{sr.period}d_ratio\"],\n",
     "            \"reason\": f\"Autocorrelation {sr.strength:.2f} at {sr.period}d - add lag ratio feature\"})\n",
     "\n",
     "print(\"\\n\" + \"─\"*60)\n",
@@ -881,22 +876,22 @@
     "    first_events = df.groupby(ENTITY_COLUMN)[TIME_COLUMN].min().reset_index()\n",
     "    first_events.columns = [ENTITY_COLUMN, \"first_event\"]\n",
     "    cohort_dist = analyze_cohort_distribution(first_events, \"first_event\")\n",
-    "    \n",
+    "\n",
     "    cohort_result = analyzer.analyze_cohorts(\n",
     "        df, entity_column=ENTITY_COLUMN, cohort_column=TIME_COLUMN,\n",
     "        target_column=TARGET_COLUMN, period=\"M\"\n",
     "    )\n",
-    "    \n",
+    "\n",
     "    print(\"👥 COHORT ANALYSIS\")\n",
     "    print(\"=\"*50)\n",
     "    print(f\"\\nEntity Onboarding: {cohort_dist.dominant_pct:.0f}% in {cohort_dist.dominant_year}, {cohort_dist.num_years} years total\")\n",
-    "    \n",
+    "\n",
     "    if len(cohort_result) > 0:\n",
     "        cohort_sorted = cohort_result.sort_values(\"cohort\")\n",
     "        has_retention = \"retention_rate\" in cohort_sorted.columns\n",
-    "        \n",
+    "\n",
     "        fig = make_subplots(specs=[[{\"secondary_y\": True}]]) if has_retention else go.Figure()\n",
-    "        \n",
+    "\n",
     "        fig.add_trace(go.Bar(\n",
     "            x=cohort_sorted[\"cohort\"].astype(str), y=cohort_sorted[\"entity_count\"],\n",
     "            name=\"Entities (sign-up cohort)\", marker_color=\"steelblue\", opacity=0.7\n",
@@ -904,7 +899,7 @@
     "            x=cohort_sorted[\"cohort\"].astype(str), y=cohort_sorted[\"entity_count\"],\n",
     "            name=\"Entities (sign-up cohort)\", marker_color=\"steelblue\", opacity=0.7\n",
     "        ))\n",
-    "        \n",
+    "\n",
     "        if has_retention:\n",
     "            fig.add_trace(go.Scatter(\n",
     "                x=cohort_sorted[\"cohort\"].astype(str), y=cohort_sorted[\"retention_rate\"] * 100,\n",
@@ -912,7 +907,7 @@
     "                line=dict(color=\"coral\", width=3), marker=dict(size=8)\n",
     "            ), secondary_y=True)\n",
     "            fig.update_yaxes(title_text=\"Retention Rate %\", secondary_y=True)\n",
-    "        \n",
+    "\n",
     "        fig.update_layout(\n",
     "            title=\"Cohort Analysis: Entity Count by Sign-up Month (cohort = first event period)\",\n",
     "            xaxis_title=\"Cohort (First Event Month)\", template=\"plotly_white\", height=400\n",
@@ -948,21 +943,21 @@
     "    retention_var = None\n",
     "    if \"retention_rate\" in cohort_result.columns:\n",
     "        retention_var = cohort_result[\"retention_rate\"].max() - cohort_result[\"retention_rate\"].min()\n",
-    "    \n",
+    "\n",
     "    cohort_recs = generate_cohort_recommendations(cohort_dist, retention_variation=retention_var)\n",
-    "    \n",
+    "\n",
     "    print(\"📊 COHORT DETAILS\")\n",
     "    print(\"=\"*50)\n",
-    "    print(f\"\\nEntity Onboarding Distribution by Year:\")\n",
+    "    print(\"\\nEntity Onboarding Distribution by Year:\")\n",
     "    print(\"─\" * 40)\n",
     "    for year, count in sorted(cohort_dist.year_counts.items()):\n",
     "        pct = count / cohort_dist.total_entities * 100\n",
     "        bar = \"█\" * int(pct / 3)\n",
     "        print(f\"   {year}: {count:>5,} entities ({pct:>5.1f}%) {bar}\")\n",
-    "    \n",
+    "\n",
     "    print(f\"\\n   Total entities: {cohort_dist.total_entities:,}\")\n",
     "    print(f\"   Data spans: {df[TIME_COLUMN].min().date()} to {df[TIME_COLUMN].max().date()}\")\n",
-    "    \n",
+    "\n",
     "    print(\"\\n📋 RECOMMENDATIONS:\")\n",
     "    for rec in cohort_recs:\n",
     "        priority_icon = {\"high\": \"🔴\", \"medium\": \"🟡\", \"low\": \"🟢\"}.get(rec.priority, \"⚪\")\n",
@@ -972,9 +967,9 @@
     "            print(f\"      Features: {', '.join(rec.features)}\")\n",
     "        if rec.insight:\n",
     "            print(f\"      💡 {rec.insight}\")\n",
-    "    \n",
+    "\n",
     "    COHORT_RECOMMENDATIONS = [{\"action\": r.action, \"priority\": r.priority, \"reason\": r.reason,\n",
-    "                               \"features\": getattr(r, 'features', []), \n",
+    "                               \"features\": getattr(r, 'features', []),\n",
     "                               \"insight\": getattr(r, 'insight', None)} for r in cohort_recs]"
    ]
   },
@@ -1031,7 +1026,7 @@
    "source": [
     "# Correlation matrix for numeric event attributes\n",
     "# Define analysis columns - exclude entity, time, target, and temporal metadata\n",
-    "numeric_event_cols = [c for c in df.select_dtypes(include=[np.number]).columns \n",
+    "numeric_event_cols = [c for c in df.select_dtypes(include=[np.number]).columns\n",
     "                      if c not in [ENTITY_COLUMN, TIME_COLUMN, TARGET_COLUMN]\n",
     "                      and c not in TEMPORAL_METADATA_COLS\n",
     "                      and 'target' not in c.lower()]\n",
@@ -1049,7 +1044,7 @@
     "        title=\"Feature Correlation Matrix (Event-Level)\"\n",
     "    )\n",
     "    display_figure(fig)\n",
-    "    \n",
+    "\n",
     "    # High correlation pairs\n",
     "    high_corr = []\n",
     "    for i in range(len(numeric_event_cols)):\n",
@@ -1057,7 +1052,7 @@
     "            corr_val = corr_matrix.iloc[i, j]\n",
     "            if abs(corr_val) > 0.7:\n",
     "                high_corr.append((numeric_event_cols[i], numeric_event_cols[j], corr_val))\n",
-    "    \n",
+    "\n",
     "    if high_corr:\n",
     "        print(\"\\n⚠️ Highly correlated pairs (|r| > 0.7):\")\n",
     "        for c1, c2, r in sorted(high_corr, key=lambda x: abs(x[2]), reverse=True)[:5]:\n",
@@ -1093,31 +1088,31 @@
     "    entity_aggs = df.groupby(ENTITY_COLUMN).agg(agg_dict)\n",
     "    entity_aggs.columns = ['_'.join(col).strip() for col in entity_aggs.columns]\n",
     "    entity_aggs = entity_aggs.reset_index()\n",
-    "    \n",
+    "\n",
     "    # Get all numeric aggregated columns\n",
     "    all_agg_cols = [c for c in entity_aggs.columns if c != ENTITY_COLUMN]\n",
-    "    \n",
+    "\n",
     "    # Select top 4 by variance across ALL aggregation types\n",
     "    variances = entity_aggs[all_agg_cols].var().sort_values(ascending=False)\n",
     "    top_features = variances.head(4).index.tolist()\n",
-    "    \n",
+    "\n",
     "    # Sample if needed\n",
     "    sample_size = min(1000, len(entity_aggs))\n",
     "    scatter_sample = entity_aggs.sample(sample_size, random_state=42) if sample_size < len(entity_aggs) else entity_aggs\n",
-    "    \n",
+    "\n",
     "    print(f\"Scatter Matrix (n={len(scatter_sample):,} entities)\")\n",
     "    print(f\"  Total aggregated features: {len(all_agg_cols)}\")\n",
     "    print(f\"  Selected (top 4 by variance): {top_features}\")\n",
-    "    \n",
+    "\n",
     "    # Short labels for x-axis (no line breaks)\n",
     "    short_labels = [f.replace('_', ' ') for f in top_features]\n",
-    "    \n",
+    "\n",
     "    scatter_data = scatter_sample[top_features].copy()\n",
     "    scatter_data.columns = short_labels\n",
-    "    \n",
+    "\n",
     "    fig = charts.scatter_matrix(scatter_data, height=500)\n",
     "    fig.update_traces(marker=dict(opacity=0.5, size=4))\n",
-    "    \n",
+    "\n",
     "    # Update y-axis labels to be multirow, keep x-axis single row\n",
     "    n_features = len(short_labels)\n",
     "    for i in range(n_features):\n",
@@ -1125,19 +1120,19 @@
     "        yaxis_name = f'yaxis{i+1}' if i > 0 else 'yaxis'\n",
     "        y_label = top_features[i].replace('_', '<br>')\n",
     "        fig.update_layout(**{yaxis_name: dict(title=dict(text=y_label))})\n",
-    "        \n",
+    "\n",
     "        # X-axis: single row (spaces instead of underscores)\n",
     "        xaxis_name = f'xaxis{i+1}' if i > 0 else 'xaxis'\n",
     "        x_label = top_features[i].replace('_', ' ')\n",
     "        fig.update_layout(**{xaxis_name: dict(title=dict(text=x_label))})\n",
-    "    \n",
+    "\n",
     "    fig.update_layout(\n",
     "        title=\"Feature Relationships (Top 4 by Variance)\",\n",
     "        margin=dict(l=100, r=20, t=50, b=60)\n",
     "    )\n",
-    "    \n",
+    "\n",
     "    display_figure(fig)\n",
-    "    \n",
+    "\n",
     "    print(\"\\n📈 Scatter Matrix Insights:\")\n",
     "    print(\"   • Different aggregation types create different patterns/bands\")\n",
     "    print(\"   • sum features often show exponential-like distributions\")\n",
@@ -1238,31 +1233,31 @@
     "if len(numeric_event_cols) >= 2:\n",
     "    variances = df[numeric_event_cols].var().sort_values(ascending=False)\n",
     "    sparkline_cols = variances.index.tolist()\n",
-    "    \n",
+    "\n",
     "    print(\"\\n\" + \"=\"*70)\n",
     "    print(\"TEMPORAL SPARKLINES - COHORT × TIME PERIOD\")\n",
     "    print(\"=\"*70)\n",
     "    print(f\"\\n{len(sparkline_cols)} features analyzed across Weekly/Monthly/Yearly periods\")\n",
-    "    \n",
+    "\n",
     "    if ENTITY_COLUMN and TIME_COLUMN:\n",
     "        df_spark = df.copy()\n",
     "        df_spark['_week'] = pd.to_datetime(df_spark[TIME_COLUMN]).dt.to_period('W').dt.start_time\n",
     "        df_spark['_month'] = pd.to_datetime(df_spark[TIME_COLUMN]).dt.to_period('M').dt.start_time\n",
     "        df_spark['_year'] = pd.to_datetime(df_spark[TIME_COLUMN]).dt.to_period('Y').dt.start_time\n",
-    "        \n",
+    "\n",
     "        has_target = TARGET_COLUMN and TARGET_COLUMN in df.columns\n",
     "        all_actions = []\n",
-    "        \n",
+    "\n",
     "        for col in sparkline_cols:\n",
     "            if col not in df_spark.columns:\n",
     "                continue\n",
-    "            \n",
+    "\n",
     "            feature_data = {}\n",
     "            cohort_masks = ([(\"retained\", df_spark[TARGET_COLUMN] == 1),\n",
     "                            (\"churned\", df_spark[TARGET_COLUMN] == 0),\n",
-    "                            (\"overall\", slice(None))] if has_target \n",
+    "                            (\"overall\", slice(None))] if has_target\n",
     "                           else [(\"overall\", slice(None))])\n",
-    "            \n",
+    "\n",
     "            for cohort, mask in cohort_masks:\n",
     "                cohort_df = df_spark[mask] if isinstance(mask, pd.Series) else df_spark\n",
     "                feature_data[cohort] = {\n",
@@ -1270,38 +1265,38 @@
     "                    \"monthly\": cohort_df.groupby('_month')[col].mean().dropna().tolist(),\n",
     "                    \"yearly\": cohort_df.groupby('_year')[col].mean().dropna().tolist(),\n",
     "                }\n",
-    "            \n",
+    "\n",
     "            period_effects = None\n",
     "            if has_target:\n",
     "                analysis = charts.analyze_cohort_trends(feature_data, col)\n",
-    "                period_effects = {p: analysis[\"periods\"][p][\"effect_size\"] \n",
+    "                period_effects = {p: analysis[\"periods\"][p][\"effect_size\"]\n",
     "                                  for p in analysis[\"periods\"]}\n",
     "                all_actions.extend(analysis.get(\"actions\", []))\n",
-    "            \n",
+    "\n",
     "            fig = charts.cohort_sparklines(feature_data, feature_name=col, period_effects=period_effects)\n",
     "            display_figure(fig)\n",
-    "        \n",
+    "\n",
     "        if has_target and all_actions:\n",
     "            print(\"\\n\" + \"=\"*70)\n",
     "            print(\"TREND & VARIANCE RECOMMENDATIONS\")\n",
     "            print(\"=\"*70)\n",
-    "            \n",
+    "\n",
     "            BOLD, RESET = \"\\033[1m\", \"\\033[0m\"\n",
-    "            \n",
+    "\n",
     "            type_labels = {\n",
     "                \"add_trend_feature\": \"📈 Add Trend Features (opposite cohort trends)\",\n",
     "                \"add_time_indicator\": \"📅 Add Time Indicators (seasonality detected)\",\n",
     "                \"robust_scale\": \"🔧 Apply Robust Scaling (high variance ratio)\",\n",
     "                \"normalize\": \"📊 Apply Normalization (high variance)\",\n",
     "            }\n",
-    "            \n",
+    "\n",
     "            by_type = {}\n",
     "            for action in all_actions:\n",
     "                action_type = action[\"action_type\"]\n",
     "                if action_type not in by_type:\n",
     "                    by_type[action_type] = []\n",
     "                by_type[action_type].append(action)\n",
-    "            \n",
+    "\n",
     "            for action_type, actions in by_type.items():\n",
     "                print(f\"\\n{type_labels.get(action_type, action_type)}:\")\n",
     "                for a in actions:\n",
@@ -1389,37 +1384,37 @@
     "    })\n",
     "    entity_aggs.columns = ['_'.join(col).strip() for col in entity_aggs.columns]\n",
     "    entity_aggs = entity_aggs.reset_index()\n",
-    "    \n",
+    "\n",
     "    # Add target\n",
     "    entity_target = df.groupby(ENTITY_COLUMN)[TARGET_COLUMN].first().reset_index()\n",
     "    entity_df = entity_aggs.merge(entity_target, on=ENTITY_COLUMN)\n",
-    "    \n",
+    "\n",
     "    # Add derived features\n",
     "    entity_df['tenure_days'] = (entity_df[f'{TIME_COLUMN}_max'] - entity_df[f'{TIME_COLUMN}_min']).dt.days\n",
     "    entity_df['event_count'] = entity_df[f'{TIME_COLUMN}_count']\n",
-    "    \n",
+    "\n",
     "    # Calculate effect sizes (Cohen's d) for entity-level features\n",
     "    # Exclude entity, target, and temporal metadata columns\n",
     "    effect_feature_cols = [c for c in entity_df.select_dtypes(include=[np.number]).columns\n",
     "                          if c not in [ENTITY_COLUMN, TARGET_COLUMN]\n",
     "                          and c not in TEMPORAL_METADATA_COLS]\n",
-    "    \n",
+    "\n",
     "    print(\"=\"*80)\n",
     "    print(\"ENTITY-LEVEL FEATURE EFFECT SIZES (Cohen's d)\")\n",
     "    print(\"=\"*80)\n",
     "    print(f\"\\nAnalyzing {len(effect_feature_cols)} aggregated features at entity level\")\n",
     "    print(f\"Entities: {len(entity_df):,} (Retained: {(entity_df[TARGET_COLUMN]==1).sum():,}, Churned: {(entity_df[TARGET_COLUMN]==0).sum():,})\\n\")\n",
-    "    \n",
+    "\n",
     "    effect_sizes = []\n",
     "    for col in effect_feature_cols:\n",
     "        churned = entity_df[entity_df[TARGET_COLUMN] == 0][col].dropna()\n",
     "        retained = entity_df[entity_df[TARGET_COLUMN] == 1][col].dropna()\n",
-    "        \n",
+    "\n",
     "        if len(churned) > 0 and len(retained) > 0:\n",
-    "            pooled_std = np.sqrt(((len(churned)-1)*churned.std()**2 + (len(retained)-1)*retained.std()**2) / \n",
+    "            pooled_std = np.sqrt(((len(churned)-1)*churned.std()**2 + (len(retained)-1)*retained.std()**2) /\n",
     "                                 (len(churned) + len(retained) - 2))\n",
     "            d = (retained.mean() - churned.mean()) / pooled_std if pooled_std > 0 else 0\n",
-    "            \n",
+    "\n",
     "            abs_d = abs(d)\n",
     "            if abs_d >= 0.8:\n",
     "                interp, emoji = \"Large effect\", \"🔴\"\n",
@@ -1429,52 +1424,52 @@
     "                interp, emoji = \"Small effect\", \"🟢\"\n",
     "            else:\n",
     "                interp, emoji = \"Negligible\", \"⚪\"\n",
-    "            \n",
+    "\n",
     "            effect_sizes.append({\n",
-    "                \"feature\": col, \"cohens_d\": d, \"abs_d\": abs_d, \n",
+    "                \"feature\": col, \"cohens_d\": d, \"abs_d\": abs_d,\n",
     "                \"interpretation\": interp, \"emoji\": emoji,\n",
     "                \"retained_mean\": retained.mean(), \"churned_mean\": churned.mean()\n",
     "            })\n",
-    "    \n",
+    "\n",
     "    # Sort and display\n",
     "    effect_df = pd.DataFrame(effect_sizes).sort_values(\"abs_d\", ascending=False)\n",
-    "    \n",
+    "\n",
     "    print(f\"{'Feature':<35} {'d':>8} {'Effect':<15} {'Direction':<20}\")\n",
     "    print(\"-\" * 80)\n",
     "    for _, row in effect_df.head(15).iterrows():\n",
     "        direction = \"↑ Higher in retained\" if row[\"cohens_d\"] > 0 else \"↓ Lower in retained\"\n",
     "        print(f\"{row['emoji']} {row['feature'][:33]:<33} {row['cohens_d']:>+8.3f} {row['interpretation']:<15} {direction:<20}\")\n",
-    "    \n",
+    "\n",
     "    # Categorize features\n",
     "    large_effect = effect_df[effect_df[\"abs_d\"] >= 0.8][\"feature\"].tolist()\n",
     "    medium_effect = effect_df[(effect_df[\"abs_d\"] >= 0.5) & (effect_df[\"abs_d\"] < 0.8)][\"feature\"].tolist()\n",
     "    small_effect = effect_df[(effect_df[\"abs_d\"] >= 0.2) & (effect_df[\"abs_d\"] < 0.5)][\"feature\"].tolist()\n",
-    "    \n",
+    "\n",
     "    # INTERPRETATION\n",
     "    print(\"\\n\" + \"─\"*80)\n",
     "    print(\"📖 INTERPRETATION & RECOMMENDATIONS\")\n",
     "    print(\"─\"*80)\n",
-    "    \n",
+    "\n",
     "    if large_effect:\n",
-    "        print(f\"\\n🔴 LARGE EFFECT (|d| ≥ 0.8) - Priority Features:\")\n",
+    "        print(\"\\n🔴 LARGE EFFECT (|d| ≥ 0.8) - Priority Features:\")\n",
     "        for f in large_effect[:5]:\n",
     "            row = effect_df[effect_df[\"feature\"] == f].iloc[0]\n",
     "            direction = \"higher\" if row[\"cohens_d\"] > 0 else \"lower\"\n",
     "            print(f\"   • {f}: Retained customers have {direction} values\")\n",
     "            print(f\"     Mean: Retained={row['retained_mean']:.2f}, Churned={row['churned_mean']:.2f}\")\n",
     "        print(\"   → MUST include in predictive model\")\n",
-    "    \n",
+    "\n",
     "    if medium_effect:\n",
-    "        print(f\"\\n🟡 MEDIUM EFFECT (0.5 ≤ |d| < 0.8) - Useful Features:\")\n",
+    "        print(\"\\n🟡 MEDIUM EFFECT (0.5 ≤ |d| < 0.8) - Useful Features:\")\n",
     "        for f in medium_effect[:3]:\n",
     "            print(f\"   • {f}\")\n",
     "        print(\"   → Should include in model\")\n",
-    "    \n",
+    "\n",
     "    if small_effect:\n",
-    "        print(f\"\\n🟢 SMALL EFFECT (0.2 ≤ |d| < 0.5) - Supporting Features:\")\n",
+    "        print(\"\\n🟢 SMALL EFFECT (0.2 ≤ |d| < 0.5) - Supporting Features:\")\n",
     "        print(f\"   {', '.join(small_effect[:5])}\")\n",
     "        print(\"   → May help in combination with other features\")\n",
-    "    \n",
+    "\n",
     "    negligible = effect_df[effect_df[\"abs_d\"] < 0.2][\"feature\"].tolist()\n",
     "    if negligible:\n",
     "        print(f\"\\n⚪ NEGLIGIBLE EFFECT (|d| < 0.2): {len(negligible)} features\")\n",
@@ -1510,39 +1505,39 @@
     "    # Select top features by effect size for visualization\n",
     "    top_features = effect_df.head(6)[\"feature\"].tolist()\n",
     "    n_features = len(top_features)\n",
-    "    \n",
+    "\n",
     "    if n_features > 0:\n",
     "        print(\"=\"*70)\n",
     "        print(\"DISTRIBUTION COMPARISON: Retained vs Churned (Box Plots)\")\n",
     "        print(\"=\"*70)\n",
     "        print(\"\\n📊 Showing top 6 features by effect size\")\n",
     "        print(\"   🟢 Green = Retained | 🔴 Red = Churned\\n\")\n",
-    "        \n",
+    "\n",
     "        fig = make_subplots(rows=1, cols=n_features, subplot_titles=top_features, horizontal_spacing=0.05)\n",
-    "        \n",
+    "\n",
     "        for i, col in enumerate(top_features):\n",
     "            col_num = i + 1\n",
-    "            \n",
+    "\n",
     "            # Retained (1) - Green\n",
     "            retained_data = entity_df[entity_df[TARGET_COLUMN] == 1][col].dropna()\n",
     "            fig.add_trace(go.Box(y=retained_data, name='Retained',\n",
     "                fillcolor='rgba(46, 204, 113, 0.7)', line=dict(color='#1e8449', width=2),\n",
     "                boxpoints='outliers', width=0.35, showlegend=(i == 0), legendgroup='retained',\n",
     "                marker=dict(color='rgba(46, 204, 113, 0.5)', size=4)), row=1, col=col_num)\n",
-    "            \n",
+    "\n",
     "            # Churned (0) - Red\n",
     "            churned_data = entity_df[entity_df[TARGET_COLUMN] == 0][col].dropna()\n",
     "            fig.add_trace(go.Box(y=churned_data, name='Churned',\n",
     "                fillcolor='rgba(231, 76, 60, 0.7)', line=dict(color='#922b21', width=2),\n",
     "                boxpoints='outliers', width=0.35, showlegend=(i == 0), legendgroup='churned',\n",
     "                marker=dict(color='rgba(231, 76, 60, 0.5)', size=4)), row=1, col=col_num)\n",
-    "        \n",
+    "\n",
     "        fig.update_layout(height=450, title_text=\"Top Features: Retained (Green) vs Churned (Red)\",\n",
     "            template='plotly_white', showlegend=True, boxmode='group',\n",
     "            legend=dict(orientation=\"h\", yanchor=\"bottom\", y=1.05, xanchor=\"center\", x=0.5))\n",
     "        fig.update_xaxes(showticklabels=False)\n",
     "        display_figure(fig)\n",
-    "        \n",
+    "\n",
     "        # INTERPRETATION\n",
     "        print(\"─\"*70)\n",
     "        print(\"📖 HOW TO READ BOX PLOTS\")\n",
@@ -1594,28 +1589,28 @@
     "    print(\"=\"*70)\n",
     "    print(\"FEATURE-TARGET CORRELATIONS (Entity-Level)\")\n",
     "    print(\"=\"*70)\n",
-    "    \n",
+    "\n",
     "    correlations = []\n",
     "    for col in effect_feature_cols:\n",
     "        if col != TARGET_COLUMN:\n",
     "            corr = entity_df[[col, TARGET_COLUMN]].corr().iloc[0, 1]\n",
     "            if not np.isnan(corr):\n",
     "                correlations.append({\"Feature\": col, \"Correlation\": corr})\n",
-    "    \n",
+    "\n",
     "    if correlations:\n",
     "        corr_df = pd.DataFrame(correlations).sort_values(\"Correlation\", key=abs, ascending=False)\n",
-    "        \n",
+    "\n",
     "        fig = charts.bar_chart(\n",
     "            corr_df[\"Feature\"].head(12).tolist(),\n",
     "            corr_df[\"Correlation\"].head(12).tolist(),\n",
     "            title=f\"Feature Correlations with {TARGET_COLUMN}\"\n",
     "        )\n",
     "        display_figure(fig)\n",
-    "        \n",
+    "\n",
     "        print(\"\\n📊 Correlation Rankings:\")\n",
     "        print(f\"{'Feature':<35} {'Correlation':>12} {'Strength':<15} {'Direction'}\")\n",
     "        print(\"-\" * 75)\n",
-    "        \n",
+    "\n",
     "        for _, row in corr_df.head(10).iterrows():\n",
     "            abs_corr = abs(row[\"Correlation\"])\n",
     "            if abs_corr >= 0.5:\n",
@@ -1626,10 +1621,10 @@
     "                strength = \"Weak\"\n",
     "            else:\n",
     "                strength = \"Very weak\"\n",
-    "            \n",
+    "\n",
     "            direction = \"Positive\" if row[\"Correlation\"] > 0 else \"Negative\"\n",
     "            print(f\"{row['Feature'][:34]:<35} {row['Correlation']:>+12.3f} {strength:<15} {direction}\")\n",
-    "        \n",
+    "\n",
     "        # INTERPRETATION\n",
     "        print(\"\\n\" + \"─\"*70)\n",
     "        print(\"📖 INTERPRETING CORRELATIONS WITH TARGET\")\n",
@@ -1680,22 +1675,22 @@
     "\n",
     "if 'effect_df' in dir() and len(effect_df) > 0:\n",
     "    large_effects = effect_df[effect_df['cohens_d'].abs() >= 0.5]\n",
-    "    print(f\"\\n📊 Effect Size Summary:\")\n",
+    "    print(\"\\n📊 Effect Size Summary:\")\n",
     "    print(f\"   • Total features analyzed: {len(effect_df)}\")\n",
     "    print(f\"   • Features with |d| ≥ 0.5 (medium+): {len(large_effects)}\")\n",
     "    print(f\"   • Features with |d| < 0.2 (negligible): {(effect_df['cohens_d'].abs() < 0.2).sum()}\")\n",
-    "    \n",
+    "\n",
     "    if len(large_effects) > 0:\n",
     "        print(\"\\n   Top differentiators:\")\n",
     "        for _, row in large_effects.head(5).iterrows():\n",
     "            direction = \"↑ higher in retained\" if row['cohens_d'] > 0 else \"↓ lower in retained\"\n",
     "            print(f\"   • \\033[1m{row['feature']}\\033[0m: d={row['cohens_d']:+.2f} ({direction})\")\n",
-    "    \n",
+    "\n",
     "    print(\"\\n📋 What the Three Approaches Showed:\")\n",
     "    print(\"   • Cohen's d → identified features with strongest mean separation\")\n",
     "    print(\"   • Correlation → confirmed linear relationship direction\")\n",
     "    print(\"   • Box plots → revealed distribution shapes and outliers\")\n",
-    "    \n",
+    "\n",
     "    print(\"\\n💡 RECOMMENDATIONS:\")\n",
     "    print(\"   → Prioritize features with |d| > 0.5 in model\")\n",
     "    print(\"   → Consider dropping features with |d| < 0.2\")\n",
@@ -1791,15 +1786,15 @@
     "\n",
     "if ENTITY_COLUMN:\n",
     "    reference_date = df[TIME_COLUMN].max()\n",
-    "    \n",
+    "\n",
     "    # Compute recency_result for use in summary cells\n",
     "    recency_result = analyzer.analyze_recency(df, ENTITY_COLUMN, TARGET_COLUMN, reference_date)\n",
-    "    \n",
+    "\n",
     "    if TARGET_COLUMN and TARGET_COLUMN in df.columns:\n",
     "        recency_comparison = compare_recency_by_target(\n",
     "            df, ENTITY_COLUMN, TIME_COLUMN, TARGET_COLUMN, reference_date\n",
     "        )\n",
-    "    \n",
+    "\n",
     "    if recency_comparison:\n",
     "        # Combined visualization panel\n",
     "        entity_last = df.groupby(ENTITY_COLUMN)[TIME_COLUMN].max().reset_index()\n",
@@ -1808,10 +1803,10 @@
     "        entity_recency = entity_last.merge(entity_target, on=ENTITY_COLUMN)\n",
     "        cap = entity_recency[\"recency_days\"].quantile(0.99)\n",
     "        entity_capped = entity_recency[entity_recency[\"recency_days\"] <= cap]\n",
-    "        \n",
+    "\n",
     "        retained = entity_capped[entity_capped[TARGET_COLUMN] == 1][\"recency_days\"].values\n",
     "        churned = entity_capped[entity_capped[TARGET_COLUMN] == 0][\"recency_days\"].values\n",
-    "        \n",
+    "\n",
     "        fig = charts.recency_analysis_panel(\n",
     "            retained_recency=retained,\n",
     "            churned_recency=churned,\n",
@@ -1821,14 +1816,14 @@
     "            cap_value=cap\n",
     "        )\n",
     "        display_figure(fig)\n",
-    "        \n",
+    "\n",
     "        # Key Findings\n",
     "        console.start_section()\n",
     "        console.header(\"Key Findings\")\n",
     "        for insight in recency_comparison.key_findings:\n",
     "            console.info(insight.finding)\n",
     "        console.end_section()\n",
-    "        \n",
+    "\n",
     "        # Statistics\n",
     "        ret, churn = recency_comparison.retained_stats, recency_comparison.churned_stats\n",
     "        console.start_section()\n",
@@ -1837,7 +1832,7 @@
     "        console.metric(\"Churned (n)\", f\"{churn.count:,}\")\n",
     "        print(f\"{'Metric':<15} {'Retained':>12} {'Churned':>12} {'Diff':>12}\")\n",
     "        print(\"-\" * 52)\n",
-    "        for name, r, c in [(\"Mean\", ret.mean, churn.mean), (\"Median\", ret.median, churn.median), \n",
+    "        for name, r, c in [(\"Mean\", ret.mean, churn.mean), (\"Median\", ret.median, churn.median),\n",
     "                           (\"Std Dev\", ret.std, churn.std)]:\n",
     "            print(f\"{name:<15} {r:>12.1f} {c:>12.1f} {c-r:>+12.1f}\")\n",
     "        console.metric(\"Effect Size\", f\"{recency_comparison.cohens_d:+.2f} ({recency_comparison.effect_interpretation})\")\n",
@@ -1845,7 +1840,7 @@
     "        if recency_comparison.inflection_bucket:\n",
     "            console.metric(\"Inflection\", recency_comparison.inflection_bucket)\n",
     "        console.end_section()\n",
-    "        \n",
+    "\n",
     "        # Actionable Recommendations\n",
     "        console.start_section()\n",
     "        console.header(\"Actionable Recommendations\")\n",
@@ -1865,13 +1860,13 @@
     "        median_recency = entity_last[\"recency_days\"].median()\n",
     "        cap = entity_last[\"recency_days\"].quantile(0.99)\n",
     "        capped = entity_last[entity_last[\"recency_days\"] <= cap]\n",
-    "        \n",
+    "\n",
     "        fig = go.Figure()\n",
     "        fig.add_trace(go.Histogram(x=capped[\"recency_days\"], nbinsx=50, marker_color=\"coral\", opacity=0.7))\n",
     "        fig.add_vline(x=median_recency, line_dash=\"solid\", line_color=\"green\", annotation_text=f\"Median: {median_recency:.0f} days\")\n",
     "        fig.update_layout(title=f\"Recency Distribution (capped at {cap:.0f} days)\", xaxis_title=\"Days Since Last Event\", yaxis_title=\"Count\", template=\"plotly_white\", height=400)\n",
     "        display_figure(fig)\n",
-    "        \n",
+    "\n",
     "        console.start_section()\n",
     "        console.header(\"Recency Statistics\")\n",
     "        console.metric(\"Median\", f\"{median_recency:.0f} days\")\n",
@@ -1939,23 +1934,23 @@
     "# Velocity & Acceleration Cohort Analysis with Effect Size Heatmap\n",
     "if ENTITY_COLUMN and TARGET_COLUMN and sparkline_cols:\n",
     "    continuous_cols = [c for c in sparkline_cols if df[c].nunique() > 2][:6]\n",
-    "    \n",
+    "\n",
     "    if not continuous_cols:\n",
     "        print(\"⚠️ No continuous numeric columns found for velocity analysis.\")\n",
     "    else:\n",
     "        print(\"=\"*70)\n",
     "        print(\"VELOCITY & ACCELERATION SIGNAL ANALYSIS\")\n",
     "        print(\"=\"*70)\n",
-    "        \n",
+    "\n",
     "        if 'feature_analyzer' not in dir():\n",
     "            feature_analyzer = TemporalFeatureAnalyzer(time_column=TIME_COLUMN, entity_column=ENTITY_COLUMN)\n",
-    "        \n",
+    "\n",
     "        windows = [7, 14, 30, 90, 180, 365]\n",
     "        print(f\"Analyzing {len(continuous_cols)} features across windows: {windows} days\")\n",
-    "        \n",
+    "\n",
     "        all_results = {}\n",
     "        heatmap_data = {\"velocity\": {}, \"acceleration\": {}}\n",
-    "        \n",
+    "\n",
     "        for col in continuous_cols:\n",
     "            results = feature_analyzer.compute_cohort_velocity_signals(\n",
     "                df, [col], TARGET_COLUMN, windows=windows\n",
@@ -1963,38 +1958,38 @@
     "            all_results[col] = results[col]\n",
     "            heatmap_data[\"velocity\"][col] = {f\"{r.window_days}d\": r.velocity_effect_size for r in results[col]}\n",
     "            heatmap_data[\"acceleration\"][col] = {f\"{r.window_days}d\": r.accel_effect_size for r in results[col]}\n",
-    "        \n",
+    "\n",
     "        fig = charts.velocity_signal_heatmap(heatmap_data, title=\"Cohort Separation: Velocity & Acceleration Effect Sizes (Cohen's d)\")\n",
     "        display_figure(fig)\n",
-    "        \n",
+    "\n",
     "        print(\"\\n\" + \"=\"*70)\n",
     "        print(\"DETAILED SPARKLINES (top features)\")\n",
     "        print(\"=\"*70)\n",
-    "        \n",
-    "        feature_max_d = [(col, max(abs(r.velocity_effect_size) for r in results)) \n",
+    "\n",
+    "        feature_max_d = [(col, max(abs(r.velocity_effect_size) for r in results))\n",
     "                         for col, results in all_results.items()]\n",
     "        feature_max_d.sort(key=lambda x: -x[1])\n",
-    "        \n",
+    "\n",
     "        top_features = [col for col, _ in feature_max_d[:3]]\n",
     "        for col in top_features:\n",
     "            fig = charts.cohort_velocity_sparklines(all_results[col], feature_name=col)\n",
     "            display_figure(fig)\n",
-    "        \n",
+    "\n",
     "        print(\"\\n\" + \"─\"*70)\n",
     "        print(\"📖 INTERPRETATION\")\n",
     "        print(\"─\"*70)\n",
     "        print(\"\\nVelocity measures rate of change; acceleration measures change in rate.\")\n",
     "        print(\"Positive d: retained > churned | Negative d: churned > retained\")\n",
     "        print(\"|d| ≥ 0.8: large effect | ≥ 0.5: medium | ≥ 0.2: small\\n\")\n",
-    "        \n",
+    "\n",
     "        interpretation_notes = feature_analyzer.generate_velocity_interpretation(all_results)\n",
     "        for note in interpretation_notes:\n",
     "            print(note)\n",
-    "        \n",
+    "\n",
     "        print(\"\\n\" + \"─\"*70)\n",
     "        print(\"🎯 FEATURE RECOMMENDATIONS\")\n",
     "        print(\"─\"*70)\n",
-    "        \n",
+    "\n",
     "        velocity_recs = feature_analyzer.generate_velocity_recommendations(all_results)\n",
     "        if velocity_recs:\n",
     "            for rec in velocity_recs:\n",
@@ -2007,7 +2002,7 @@
     "            print(\"\\nNo velocity/acceleration features recommended (no strong signals found).\")\n",
     "\n",
     "# Store velocity recommendations for pattern_summary\n",
-    "VELOCITY_RECOMMENDATIONS = [{\"action\": r.action, \"source_column\": r.source_column, \n",
+    "VELOCITY_RECOMMENDATIONS = [{\"action\": r.action, \"source_column\": r.source_column,\n",
     "                              \"description\": r.description, \"priority\": r.priority,\n",
     "                              \"effect_size\": r.effect_size, \"params\": r.params,\n",
     "                              \"features\": [f\"{r.source_column}_velocity_{r.params.get('window_days', 7)}d\"]}\n",
@@ -2079,26 +2074,26 @@
     "    print(\"=\"*70)\n",
     "    print(\"MOMENTUM ANALYSIS (Window Ratios)\")\n",
     "    print(\"=\"*70)\n",
-    "    \n",
+    "\n",
     "    if 'feature_analyzer' not in dir():\n",
     "        feature_analyzer = TemporalFeatureAnalyzer(time_column=TIME_COLUMN, entity_column=ENTITY_COLUMN)\n",
-    "    \n",
+    "\n",
     "    # Use sparkline_cols directly (includes all numeric features ranked by variance)\n",
     "    momentum_cols = sparkline_cols[:6]\n",
-    "    \n",
+    "\n",
     "    # Build comprehensive window pairs from multiple sources:\n",
     "    # 1. Standard natural pairs (week/month/quarter)\n",
     "    natural_pairs = [(7, 30), (30, 90), (7, 90)]\n",
-    "    \n",
+    "\n",
     "    # 2. Recommended pairs from pattern_config (based on 01a aggregation windows)\n",
     "    recommended_pairs = pattern_config.get_momentum_pairs()\n",
-    "    \n",
+    "\n",
     "    # 3. Accumulation pair: shortest window vs all-time\n",
     "    max_days = (df[TIME_COLUMN].max() - df[TIME_COLUMN].min()).days\n",
     "    all_windows = [w for pair in natural_pairs + recommended_pairs for w in pair]\n",
     "    shortest_window = min(all_windows) if all_windows else 7\n",
     "    accumulation_pair = (shortest_window, max_days)\n",
-    "    \n",
+    "\n",
     "    # Combine and deduplicate (preserve order: natural first, then recommended, then accumulation)\n",
     "    seen = set()\n",
     "    window_pairs = []\n",
@@ -2106,20 +2101,20 @@
     "        if pair not in seen:\n",
     "            window_pairs.append(pair)\n",
     "            seen.add(pair)\n",
-    "    \n",
+    "\n",
     "    print(f\"Analyzing {len(momentum_cols)} features across {len(window_pairs)} window pairs:\")\n",
     "    print(f\"  Natural pairs (week/month/quarter): {natural_pairs}\")\n",
     "    print(f\"  Recommended pairs (from 01a): {recommended_pairs}\")\n",
     "    print(f\"  Accumulation pair: {shortest_window}d vs all-time ({max_days}d)\")\n",
     "    print(f\"  Combined (deduplicated): {len(window_pairs)} pairs\")\n",
-    "    \n",
+    "\n",
     "    all_momentum_results = {}\n",
     "    for col in momentum_cols:\n",
     "        results = feature_analyzer.compute_cohort_momentum_signals(\n",
     "            df, [col], TARGET_COLUMN, window_pairs=window_pairs\n",
     "        )\n",
     "        all_momentum_results[col] = results[col]\n",
-    "    \n",
+    "\n",
     "    print(\"\\n📊 Momentum by Cohort:\")\n",
     "    print(f\"{'Feature':<18} {'Window':<12} {'Retained':>10} {'Churned':>10} {'Effect d':>10}\")\n",
     "    print(\"-\" * 62)\n",
@@ -2127,7 +2122,7 @@
     "        for r in col_results:\n",
     "            label = r.window_label if r.long_window < 1000 else f\"{r.short_window}d/all\"\n",
     "            print(f\"{col[:17]:<18} {label:<12} {r.retained_momentum:>10.2f} {r.churned_momentum:>10.2f} {r.effect_size:>10.2f}\")\n",
-    "    \n",
+    "\n",
     "    # Bar chart for best window pair per feature - with window labels above bars\n",
     "    best_pair_data = {}\n",
     "    best_window_labels = {}  # Track which window was best\n",
@@ -2135,15 +2130,15 @@
     "        best = max(col_results, key=lambda r: abs(r.effect_size))\n",
     "        best_pair_data[col] = {\"retained\": best.retained_momentum, \"churned\": best.churned_momentum}\n",
     "        best_window_labels[col] = best.window_label if best.long_window < 1000 else f\"{best.short_window}d/all\"\n",
-    "    \n",
+    "\n",
     "    if best_pair_data:\n",
     "        import plotly.graph_objects as go\n",
     "        columns = list(best_pair_data.keys())\n",
     "        col_labels = [c[:15] for c in columns]\n",
-    "        \n",
+    "\n",
     "        # Find max y value for positioning labels above bars\n",
     "        max_y = max(max(best_pair_data[c][\"retained\"], best_pair_data[c][\"churned\"]) for c in columns)\n",
-    "        \n",
+    "\n",
     "        fig = go.Figure()\n",
     "        fig.add_trace(go.Bar(\n",
     "            name=\"🟢 Retained\", x=col_labels,\n",
@@ -2157,7 +2152,7 @@
     "        ))\n",
     "        fig.add_hline(y=1.0, line_dash=\"dash\", line_color=\"gray\",\n",
     "                     annotation_text=\"baseline\", annotation_position=\"right\")\n",
-    "        \n",
+    "\n",
     "        # Add window labels as annotations above each bar group\n",
     "        for i, col in enumerate(columns):\n",
     "            window_lbl = best_window_labels[col]\n",
@@ -2168,7 +2163,7 @@
     "                font=dict(size=10, color=\"#555\"),\n",
     "                xref=\"x\", yref=\"y\",\n",
     "            )\n",
-    "        \n",
+    "\n",
     "        fig.update_layout(\n",
     "            title=\"Momentum Comparison (Best Window per Feature)\",\n",
     "            xaxis_title=\"Feature\",\n",
@@ -2178,22 +2173,22 @@
     "            yaxis=dict(range=[0, max_y * 1.15]),  # Extra headroom for labels\n",
     "        )\n",
     "        display_figure(fig)\n",
-    "    \n",
+    "\n",
     "    print(\"\\n\" + \"─\"*70)\n",
     "    print(\"📖 INTERPRETATION\")\n",
     "    print(\"─\"*70)\n",
     "    print(\"\\nMomentum = recent_mean / historical_mean (per entity, then averaged)\")\n",
     "    print(\"> 1.0 = accelerating | < 1.0 = decelerating | ≈ 1.0 = stable\")\n",
     "    print(\"|d| measures how differently retained vs churned customers behave\\n\")\n",
-    "    \n",
+    "\n",
     "    interpretation_notes = feature_analyzer.generate_momentum_interpretation(all_momentum_results)\n",
     "    for note in interpretation_notes:\n",
     "        print(note)\n",
-    "    \n",
+    "\n",
     "    print(\"\\n\" + \"─\"*70)\n",
     "    print(\"🎯 FEATURE RECOMMENDATIONS\")\n",
     "    print(\"─\"*70)\n",
-    "    \n",
+    "\n",
     "    momentum_recs = feature_analyzer.generate_momentum_recommendations(all_momentum_results)\n",
     "    if momentum_recs:\n",
     "        for rec in momentum_recs:\n",
@@ -2206,7 +2201,7 @@
     "        print(\"\\nNo momentum features recommended (no strong cohort separation found).\")\n",
     "\n",
     "# Store momentum recommendations for pattern_summary\n",
-    "MOMENTUM_RECOMMENDATIONS = [{\"action\": r.action, \"source_column\": r.source_column, \n",
+    "MOMENTUM_RECOMMENDATIONS = [{\"action\": r.action, \"source_column\": r.source_column,\n",
     "                              \"description\": r.description, \"priority\": r.priority,\n",
     "                              \"effect_size\": r.effect_size, \"params\": r.params,\n",
     "                              \"features\": [f\"{r.source_column}_momentum_{r.params['short_window']}_{r.params['long_window']}\"]}\n",
@@ -2263,20 +2258,20 @@
     "if ENTITY_COLUMN and sparkline_cols:\n",
     "    lag_cols = sparkline_cols[:6]\n",
     "    max_lag = 14\n",
-    "    \n",
+    "\n",
     "    print(\"=\"*70)\n",
     "    print(\"LAG CORRELATION ANALYSIS\")\n",
     "    print(\"=\"*70)\n",
-    "    \n",
+    "\n",
     "    if 'feature_analyzer' not in dir():\n",
     "        feature_analyzer = TemporalFeatureAnalyzer(time_column=TIME_COLUMN, entity_column=ENTITY_COLUMN)\n",
-    "    \n",
+    "\n",
     "    # Calculate lag correlations using framework\n",
     "    lag_results = feature_analyzer.calculate_lag_correlations(df, lag_cols, max_lag=max_lag)\n",
-    "    \n",
+    "\n",
     "    # Build data for heatmap\n",
     "    lag_corr_data = {col: result.correlations for col, result in lag_results.items()}\n",
-    "    \n",
+    "\n",
     "    # Use ChartBuilder for visualization\n",
     "    fig = charts.lag_correlation_heatmap(\n",
     "        lag_corr_data,\n",
@@ -2284,14 +2279,14 @@
     "        title=\"Autocorrelation by Lag (days)\"\n",
     "    )\n",
     "    display_figure(fig)\n",
-    "    \n",
+    "\n",
     "    # Display framework results\n",
     "    print(\"\\n📊 Best Lag per Variable:\")\n",
     "    for col, result in lag_results.items():\n",
     "        best_lag_info = f\"best lag={result.best_lag}d (r={result.best_correlation:.2f})\"\n",
     "        weekly_info = \" [Weekly pattern]\" if result.has_weekly_pattern else \"\"\n",
     "        print(f\"   {col[:25]}: {best_lag_info}{weekly_info}\")\n",
-    "    \n",
+    "\n",
     "    # INTERPRETATION SECTION\n",
     "    print(\"\\n\" + \"─\"*70)\n",
     "    print(\"📖 INTERPRETATION\")\n",
@@ -2300,16 +2295,16 @@
     "    print(\"  • r > 0.5: Strong memory - today predicts tomorrow well\")\n",
     "    print(\"  • r 0.3-0.5: Moderate predictability from past\")\n",
     "    print(\"  • r < 0.3: Weak autocorrelation - lag features less useful\\n\")\n",
-    "    \n",
+    "\n",
     "    interpretation_notes = feature_analyzer.generate_lag_interpretation(lag_results)\n",
     "    for note in interpretation_notes:\n",
     "        print(note)\n",
-    "    \n",
+    "\n",
     "    # RECOMMENDATIONS SECTION\n",
     "    print(\"\\n\" + \"─\"*70)\n",
     "    print(\"🎯 FEATURE RECOMMENDATIONS\")\n",
     "    print(\"─\"*70)\n",
-    "    \n",
+    "\n",
     "    lag_recs = feature_analyzer.generate_lag_recommendations(lag_results)\n",
     "    if lag_recs:\n",
     "        for rec in lag_recs:\n",
@@ -2322,7 +2317,7 @@
     "        print(\"\\nNo lag features recommended (no strong autocorrelation found).\")\n",
     "\n",
     "# Store lag recommendations for pattern_summary\n",
-    "LAG_RECOMMENDATIONS = [{\"action\": r.action, \"source_column\": r.source_column, \n",
+    "LAG_RECOMMENDATIONS = [{\"action\": r.action, \"source_column\": r.source_column,\n",
     "                         \"description\": r.description, \"priority\": r.priority,\n",
     "                         \"features\": [f\"{r.source_column}_lag_{r.params.get('lag_days', 7)}d\"],\n",
     "                         \"params\": r.params}\n",
@@ -2393,56 +2388,56 @@
     "    print(\"=\"*70)\n",
     "    print(\"PREDICTIVE POWER ANALYSIS (IV & KS Statistics)\")\n",
     "    print(\"=\"*70)\n",
-    "    \n",
+    "\n",
     "    if 'feature_analyzer' not in dir():\n",
     "        feature_analyzer = TemporalFeatureAnalyzer(time_column=TIME_COLUMN, entity_column=ENTITY_COLUMN)\n",
-    "    \n",
+    "\n",
     "    analysis_cols = [c for c in sparkline_cols[:8] if c in df.columns]\n",
-    "    \n",
+    "\n",
     "    # Method handles aggregation to entity level internally\n",
     "    iv_results = feature_analyzer.calculate_predictive_power(df, analysis_cols, TARGET_COLUMN)\n",
-    "    \n",
+    "\n",
     "    n_retained = df.groupby(ENTITY_COLUMN)[TARGET_COLUMN].first().sum()\n",
     "    n_churned = df[ENTITY_COLUMN].nunique() - n_retained\n",
     "    print(f\"Analyzing {len(analysis_cols)} features\")\n",
     "    print(f\"Entities: {df[ENTITY_COLUMN].nunique():,} (Retained: {n_retained:,}, Churned: {n_churned:,})\")\n",
-    "    \n",
+    "\n",
     "    # Build visualization data\n",
     "    iv_data = {col: {\"iv\": r.information_value, \"ks\": r.ks_statistic} for col, r in iv_results.items()}\n",
-    "    \n",
+    "\n",
     "    # Create IV/KS comparison chart\n",
     "    import plotly.graph_objects as go\n",
     "    from plotly.subplots import make_subplots\n",
-    "    \n",
+    "\n",
     "    features = list(iv_data.keys())\n",
     "    ivs = [iv_data[f][\"iv\"] for f in features]\n",
     "    kss = [iv_data[f][\"ks\"] for f in features]\n",
-    "    \n",
+    "\n",
     "    # Sort by IV\n",
     "    sorted_idx = sorted(range(len(ivs)), key=lambda i: ivs[i], reverse=True)\n",
     "    features = [features[i] for i in sorted_idx]\n",
     "    ivs = [ivs[i] for i in sorted_idx]\n",
     "    kss = [kss[i] for i in sorted_idx]\n",
-    "    \n",
+    "\n",
     "    fig = make_subplots(rows=1, cols=2, subplot_titles=[\"Information Value (IV)\", \"KS Statistic\"])\n",
-    "    \n",
+    "\n",
     "    # IV bars with threshold colors\n",
     "    iv_colors = [\"#27ae60\" if v >= 0.1 else \"#f39c12\" if v >= 0.02 else \"#95a5a6\" for v in ivs]\n",
-    "    fig.add_trace(go.Bar(y=features, x=ivs, orientation=\"h\", marker_color=iv_colors, \n",
+    "    fig.add_trace(go.Bar(y=features, x=ivs, orientation=\"h\", marker_color=iv_colors,\n",
     "                         showlegend=False, hovertemplate=\"%{y}: IV=%{x:.3f}<extra></extra>\"), row=1, col=1)\n",
     "    fig.add_vline(x=0.1, line_dash=\"dash\", line_color=\"#27ae60\", annotation_text=\"Strong\", row=1, col=1)\n",
     "    fig.add_vline(x=0.02, line_dash=\"dash\", line_color=\"#f39c12\", annotation_text=\"Medium\", row=1, col=1)\n",
-    "    \n",
+    "\n",
     "    # KS bars\n",
     "    ks_colors = [\"#3498db\" if v >= 0.3 else \"#85c1e9\" for v in kss]\n",
     "    fig.add_trace(go.Bar(y=features, x=kss, orientation=\"h\", marker_color=ks_colors,\n",
     "                         showlegend=False, hovertemplate=\"%{y}: KS=%{x:.3f}<extra></extra>\"), row=1, col=2)\n",
-    "    \n",
+    "\n",
     "    fig.update_layout(height=400, title=\"Predictive Power: IV & KS Statistics\")\n",
     "    fig.update_xaxes(title_text=\"IV\", row=1, col=1)\n",
     "    fig.update_xaxes(title_text=\"KS\", row=1, col=2)\n",
     "    display_figure(fig)\n",
-    "    \n",
+    "\n",
     "    # Details table\n",
     "    print(\"\\n📊 Predictive Power Details:\")\n",
     "    print(f\"{'Feature':<25} {'IV':>8} {'IV Strength':<12} {'KS':>8} {'KS Strength':<12}\")\n",
@@ -2450,16 +2445,16 @@
     "    for col in features:\n",
     "        r = iv_results[col]\n",
     "        print(f\"{col[:24]:<25} {r.information_value:>8.3f} {r.iv_interpretation:<12} {r.ks_statistic:>8.3f} {r.ks_interpretation:<12}\")\n",
-    "    \n",
+    "\n",
     "    # INTERPRETATION with cross-references\n",
     "    print(\"\\n\" + \"─\"*70)\n",
     "    print(\"📖 INTERPRETATION\")\n",
     "    print(\"─\"*70)\n",
-    "    \n",
+    "\n",
     "    strong_iv = [col for col, r in iv_results.items() if r.information_value >= 0.1]\n",
     "    medium_iv = [col for col, r in iv_results.items() if 0.02 <= r.information_value < 0.1]\n",
     "    weak_iv = [col for col, r in iv_results.items() if r.information_value < 0.02]\n",
-    "    \n",
+    "\n",
     "    if strong_iv:\n",
     "        print(f\"\\nStrong predictors (IV >= 0.1): {', '.join(strong_iv)}\")\n",
     "        print(\"  → High predictive value, prioritize in model\")\n",
@@ -2469,7 +2464,7 @@
     "    if weak_iv:\n",
     "        print(f\"\\nWeak predictors (IV < 0.02): {', '.join(weak_iv)}\")\n",
     "        print(\"  → Limited predictive value alone\")\n",
-    "    \n",
+    "\n",
     "    # Cross-reference with 1c.10 Cohen's d if available\n",
     "    if 'effect_df' in dir() and len(effect_df) > 0:\n",
     "        print(\"\\n📎 Cross-reference with 1c.10 (Cohen's d):\")\n",
@@ -2486,24 +2481,24 @@
     "                        print(f\"  {col}: d={d_val:+.2f}, IV={iv_val.information_value:.3f} {agreement}\")\n",
     "        else:\n",
     "            print(\"  (No overlapping features to compare)\")\n",
-    "    \n",
+    "\n",
     "    # RECOMMENDATIONS\n",
     "    print(\"\\n\" + \"─\"*70)\n",
     "    print(\"🎯 FEATURE RECOMMENDATIONS\")\n",
     "    print(\"─\"*70)\n",
-    "    \n",
+    "\n",
     "    if strong_iv:\n",
     "        print(\"\\n🔴 INCLUDE (Strong IV)\")\n",
     "        for col in strong_iv:\n",
     "            r = iv_results[col]\n",
     "            print(f\"   • {col}: IV={r.information_value:.3f}, KS={r.ks_statistic:.3f}\")\n",
-    "    \n",
+    "\n",
     "    if medium_iv:\n",
     "        print(\"\\n🟡 INCLUDE (Medium IV)\")\n",
     "        for col in medium_iv[:5]:\n",
     "            r = iv_results[col]\n",
     "            print(f\"   • {col}: IV={r.information_value:.3f}\")\n",
-    "    \n",
+    "\n",
     "    if not strong_iv and not medium_iv:\n",
     "        print(\"\\nNo features with strong predictive power found.\")\n",
     "        print(\"   → See 1c.12 (velocity) and 1c.13 (momentum) for derived features\")\n",
@@ -2604,29 +2599,29 @@
     "    print(\"=\"*70)\n",
     "    print(\"CATEGORICAL FEATURE ANALYSIS\")\n",
     "    print(\"=\"*70)\n",
-    "    \n",
+    "\n",
     "    # Aggregate to entity level (take mode for categorical columns)\n",
-    "    cat_cols = [c for c in df.select_dtypes(include=['object', 'category']).columns \n",
+    "    cat_cols = [c for c in df.select_dtypes(include=['object', 'category']).columns\n",
     "                if c not in [ENTITY_COLUMN, TIME_COLUMN, TARGET_COLUMN]]\n",
-    "    \n",
+    "\n",
     "    if cat_cols:\n",
     "        entity_cats_df = df.groupby(ENTITY_COLUMN).agg(\n",
     "            {c: lambda x: x.mode().iloc[0] if len(x.mode()) > 0 else None for c in cat_cols}\n",
     "        ).reset_index()\n",
     "        entity_target = df.groupby(ENTITY_COLUMN)[TARGET_COLUMN].first().reset_index()\n",
     "        entity_data = entity_cats_df.merge(entity_target, on=ENTITY_COLUMN)\n",
-    "        \n",
+    "\n",
     "        cat_result = analyze_categorical_features(entity_data, ENTITY_COLUMN, TARGET_COLUMN)\n",
-    "        \n",
+    "\n",
     "        print(f\"Features analyzed: {len(cat_result.feature_insights)}\")\n",
     "        print(f\"Features filtered: {len(cat_result.filtered_columns)}\")\n",
     "        print(f\"Overall target rate: {cat_result.overall_target_rate:.1%}\")\n",
-    "        \n",
+    "\n",
     "        if cat_result.feature_insights:\n",
     "            # VISUALS\n",
     "            fig = charts.categorical_analysis_panel(cat_result.feature_insights, cat_result.overall_target_rate)\n",
     "            display_figure(fig)\n",
-    "            \n",
+    "\n",
     "            # DETAILS TABLE\n",
     "            print(\"\\n📊 Feature Details:\")\n",
     "            print(f\"{'Feature':<20} {'Cramér V':>10} {'Effect':>12} {'#Cats':>7} {'High Risk':>10} {'Low Risk':>10}\")\n",
@@ -2634,41 +2629,41 @@
     "            for insight in cat_result.feature_insights:\n",
     "                print(f\"{insight.feature_name[:19]:<20} {insight.cramers_v:>10.3f} {insight.effect_strength:>12} \"\n",
     "                      f\"{insight.n_categories:>7} {len(insight.high_risk_categories):>10} {len(insight.low_risk_categories):>10}\")\n",
-    "            \n",
+    "\n",
     "            # INTERPRETATION\n",
     "            print(\"\\n\" + \"─\"*70)\n",
     "            print(\"📖 INTERPRETATION\")\n",
     "            print(\"─\"*70)\n",
-    "            \n",
+    "\n",
     "            strong = [i for i in cat_result.feature_insights if i.effect_strength == \"strong\"]\n",
     "            moderate = [i for i in cat_result.feature_insights if i.effect_strength == \"moderate\"]\n",
     "            weak = [i for i in cat_result.feature_insights if i.effect_strength in (\"weak\", \"negligible\")]\n",
-    "            \n",
+    "\n",
     "            if strong:\n",
     "                print(f\"\\nStrong predictors ({len(strong)}): {', '.join(i.feature_name for i in strong)}\")\n",
     "                print(\"  → These features have clear category-target relationships\")\n",
     "                print(\"  → Include in model, consider one-hot encoding\")\n",
-    "            \n",
+    "\n",
     "            if moderate:\n",
     "                print(f\"\\nModerate predictors ({len(moderate)}): {', '.join(i.feature_name for i in moderate)}\")\n",
     "                print(\"  → Some predictive power, include if cardinality is reasonable\")\n",
-    "            \n",
+    "\n",
     "            if weak:\n",
     "                print(f\"\\nWeak/negligible ({len(weak)}): {', '.join(i.feature_name for i in weak)}\")\n",
     "                print(\"  → Limited predictive value, may add noise\")\n",
-    "            \n",
+    "\n",
     "            # High-risk category insights\n",
     "            all_high_risk = [(i.feature_name, c) for i in cat_result.feature_insights for c in i.high_risk_categories[:2]]\n",
     "            if all_high_risk:\n",
     "                print(\"\\nHigh-risk segments (below-average retention):\")\n",
     "                for feat, cat in all_high_risk[:5]:\n",
     "                    print(f\"  • {feat} = '{cat}'\")\n",
-    "            \n",
+    "\n",
     "            # RECOMMENDATIONS\n",
     "            print(\"\\n\" + \"─\"*70)\n",
     "            print(\"🎯 FEATURE RECOMMENDATIONS\")\n",
     "            print(\"─\"*70)\n",
-    "            \n",
+    "\n",
     "            if cat_result.recommendations:\n",
     "                for rec in cat_result.recommendations:\n",
     "                    priority_marker = \"🔴\" if rec.get('priority') == 'high' else \"🟡\"\n",
@@ -2680,13 +2675,13 @@
     "                    print(\"\\n🔴 INCLUDE STRONG PREDICTORS\")\n",
     "                    for i in strong:\n",
     "                        print(f\"   • {i.feature_name}: V={i.cramers_v:.3f}, {i.n_categories} categories\")\n",
-    "                \n",
+    "\n",
     "                if any(i.n_categories > 20 for i in cat_result.feature_insights):\n",
     "                    high_card = [i for i in cat_result.feature_insights if i.n_categories > 20]\n",
     "                    print(\"\\n🟡 HIGH CARDINALITY - CONSIDER GROUPING\")\n",
     "                    for i in high_card:\n",
     "                        print(f\"   • {i.feature_name}: {i.n_categories} categories → group rare categories\")\n",
-    "                \n",
+    "\n",
     "                if not strong and not moderate:\n",
     "                    print(\"\\nNo strong categorical predictors found.\")\n",
     "                    print(\"   • Consider creating derived features (e.g., category combinations)\")\n",
@@ -2824,12 +2819,12 @@
     "print(f\"   Velocity: {pattern_config.velocity_window_days}d | Momentum: {pattern_config.get_momentum_pairs()}\")\n",
     "\n",
     "# Trend summary\n",
-    "print(f\"\\n📈 TREND:\")\n",
+    "print(\"\\n📈 TREND:\")\n",
     "print(f\"   Direction: {trend_result.direction.value}\")\n",
     "print(f\"   Confidence: {trend_result.confidence}\")\n",
     "\n",
     "# Seasonality summary\n",
-    "print(f\"\\n🔁 SEASONALITY:\")\n",
+    "print(\"\\n🔁 SEASONALITY:\")\n",
     "if seasonality_results:\n",
     "    for sr in seasonality_results[:2]:\n",
     "        period_name = sr.period_name or f\"{sr.period}-day\"\n",
@@ -2839,7 +2834,7 @@
     "\n",
     "# Recency summary\n",
     "if ENTITY_COLUMN:\n",
-    "    print(f\"\\n⏱️ RECENCY:\")\n",
+    "    print(\"\\n⏱️ RECENCY:\")\n",
     "    print(f\"   Median: {recency_result.median_recency_days:.0f} days\")\n",
     "    if recency_result.target_correlation:\n",
     "        corr = recency_result.target_correlation\n",
@@ -2905,7 +2900,7 @@
     "if seasonality_results:\n",
     "    weekly = any(6 <= sr.period <= 8 for sr in seasonality_results)\n",
     "    monthly = any(28 <= sr.period <= 32 for sr in seasonality_results)\n",
-    "    \n",
+    "\n",
     "    print(\"\\n2. SEASONALITY FEATURES:\")\n",
     "    if weekly:\n",
     "        print(\"   - is_weekend (binary)\")\n",
@@ -2993,7 +2988,7 @@
     "if seasonality_results:\n",
     "    strong_patterns = [sr for sr in seasonality_results if sr.strength > 0.5]\n",
     "    moderate_patterns = [sr for sr in seasonality_results if 0.3 < sr.strength <= 0.5]\n",
-    "    \n",
+    "\n",
     "    for sr in seasonality_results:\n",
     "        if sr.period == 7:\n",
     "            seasonality_recs.append({\n",
@@ -3010,13 +3005,13 @@
     "                \"action\": \"add_cyclical_feature\", \"feature\": \"quarter\", \"encoding\": \"sin_cos\",\n",
     "                \"reason\": f\"Quarterly pattern detected (strength={sr.strength:.2f})\"\n",
     "            })\n",
-    "    \n",
+    "\n",
     "    if strong_patterns:\n",
     "        seasonality_recs.append({\n",
     "            \"action\": \"consider_deseasonalization\", \"periods\": [sr.period for sr in strong_patterns],\n",
     "            \"reason\": \"Strong seasonal patterns may dominate signal\"\n",
     "        })\n",
-    "    \n",
+    "\n",
     "    if 'window_lags' in dir() and window_lags:\n",
     "        aligned = [sr for sr in seasonality_results if sr.period in window_lags]\n",
     "        if aligned:\n",
@@ -3119,8 +3114,8 @@
     "# These flags tell 01d which optional features to include based on analysis results\n",
     "pattern_summary[\"feature_flags\"] = {\n",
     "    \"include_recency\": (\n",
-    "        recency_comparison.cohens_d > 0.2 \n",
-    "        if 'recency_comparison' in dir() and recency_comparison \n",
+    "        recency_comparison.cohens_d > 0.2\n",
+    "        if 'recency_comparison' in dir() and recency_comparison\n",
     "        else True\n",
     "    ),\n",
     "    \"include_tenure\": True,  # Default on; could be derived from tenure analysis if available\n",
@@ -3161,7 +3156,7 @@
     "    if skip_recs:\n",
     "        print(f\"\\n👥 COHORT: Skip cohort features ({skip_recs[0]['reason']})\")\n",
     "    elif feature_recs:\n",
-    "        print(f\"\\n👥 COHORT FEATURES TO ADD:\")\n",
+    "        print(\"\\n👥 COHORT FEATURES TO ADD:\")\n",
     "        for rec in feature_recs:\n",
     "            print(f\"   • {', '.join(rec['features'])} ({rec['priority']} priority)\")\n",
     "\n",