diff --git a/notebooks/4_validate_gtfs_io.ipynb b/notebooks/4_validate_gtfs_io.ipynb
new file mode 100644
index 0000000..42ad173
--- /dev/null
+++ b/notebooks/4_validate_gtfs_io.ipynb
@@ -0,0 +1,646 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bb7b9949",
+   "metadata": {},
+   "source": [
+    "# GTFS I/O Encoding/Decoding Validation\n",
+    "This notebook demonstrates that the trip encoding logic in  correctly mirrors the trip generation logic back in , proving that the process does not suffer from service inflation or deflation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a691e35d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from transit_opt.preprocessing.prepare_gtfs import GTFSDataPreparator\n",
+    "from transit_opt.gtfs.gtfs import SolutionConverter"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "41db4092",
+   "metadata": {},
+   "source": [
+    "## 1. Load and Encode Original GTFS"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "cdc591c4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading and parsing original GTFS...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Route 73302: Round-trip 317.4min exceeds limit (240.0min), filtered out\n",
+      "Route 54721: Round-trip 366.8min exceeds limit (240.0min), filtered out\n",
+      "Route 30922: Round-trip 247.2min exceeds limit (240.0min), filtered out\n",
+      "Route 12490: Round-trip 416.3min exceeds limit (240.0min), filtered out\n",
+      "Route 37599: Round-trip 355.3min exceeds limit (240.0min), filtered out\n",
+      "Route 59129: Round-trip 396.7min exceeds limit (240.0min), filtered out\n",
+      "Route 73828: Round-trip 258.8min exceeds limit (240.0min), filtered out\n",
+      "Route 77159: Round-trip 954.5min exceeds limit (240.0min), filtered out\n",
+      "Route 74948: Round-trip 1069.5min exceeds limit (240.0min), filtered out\n",
+      "Route 57719: Round-trip 978.6min exceeds limit (240.0min), filtered out\n",
+      "Route 31952: Round-trip 284.6min exceeds limit (240.0min), filtered out\n",
+      "Route 77162: Round-trip 1207.5min exceeds limit (240.0min), filtered out\n",
+      "Route 47558: Round-trip 770.5min exceeds limit (240.0min), filtered out\n",
+      "Route 73397: Round-trip 586.5min exceeds limit (240.0min), filtered out\n",
+      "Route 63868: Round-trip 494.5min exceeds limit (240.0min), filtered out\n",
+      "Route 72083: Round-trip 1248.9min exceeds limit (240.0min), filtered out\n",
+      "Route 74356: Round-trip 437.0min exceeds limit (240.0min), filtered out\n",
+      "Route 16835: Round-trip 1219.0min exceeds limit (240.0min), filtered out\n",
+      "Route 19472: Round-trip 460.0min exceeds limit (240.0min), filtered out\n",
+      "Route 72084: Round-trip 678.5min exceeds limit (240.0min), filtered out\n",
+      "Route 76603: Round-trip 529.0min exceeds limit (240.0min), filtered out\n",
+      "Route 33496: Round-trip 856.7min exceeds limit (240.0min), filtered out\n",
+      "Route 31956: Round-trip 1075.2min exceeds limit (240.0min), filtered out\n",
+      "Route 72085: Round-trip 523.2min exceeds limit (240.0min), filtered out\n",
+      "Route 124: Round-trip 736.0min exceeds limit (240.0min), filtered out\n",
+      "Route 38189: Round-trip 828.0min exceeds limit (240.0min), filtered out\n",
+      "Route 72342: Round-trip 494.5min exceeds limit (240.0min), filtered out\n",
+      "Route 31957: Round-trip 960.2min exceeds limit (240.0min), filtered out\n",
+      "Route 13406: Round-trip 437.0min exceeds limit (240.0min), filtered out\n",
+      "Route 39851: Round-trip 609.5min exceeds limit (240.0min), filtered out\n",
+      "Route 16836: Round-trip 586.5min exceeds limit (240.0min), filtered out\n",
+      "Route 72090: Round-trip 270.2min exceeds limit (240.0min), filtered out\n",
+      "Route 18680: Round-trip 396.7min exceeds limit (240.0min), filtered out\n",
+      "Route 74362: Round-trip 460.0min exceeds limit (240.0min), filtered out\n",
+      "Route 67719: Round-trip 845.2min exceeds limit (240.0min), filtered out\n",
+      "Route 57312: Round-trip 276.0min exceeds limit (240.0min), filtered out\n",
+      "Route 76607: Round-trip 1230.5min exceeds limit (240.0min), filtered out\n",
+      "Route 54718: Round-trip 560.0min exceeds limit (240.0min), filtered out\n",
+      "Route 11963: Round-trip 259.9min exceeds limit (240.0min), filtered out\n",
+      "Filtered out 39 routes (excessive round-trip time)\n",
+      "Failed to process 1 routes (no valid data)\n",
+      "Found 12 cells with >10min mapping difference\n",
+      "Large discrepancy between raw and discretized fleet calculations!\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total original trips loaded: 13974\n"
+     ]
+    }
+   ],
+   "source": [
+    "gtfs_path = \"../data/external/study_area_gtfs_bus.zip\"\n",
+    "interval_hours = 4\n",
+    "allowed_headways = [5, 10, 15, 30, 60]\n",
+    "\n",
+    "print(\"Loading and parsing original GTFS...\")\n",
+    "prep = GTFSDataPreparator(gtfs_path=gtfs_path, interval_hours=interval_hours)\n",
+    "opt_data = prep.extract_optimization_data(allowed_headways)\n",
+    "\n",
+    "# Fix: Access the initial solution properly using the new dict keys\n",
+    "base_matrix = opt_data[\"initial_solution\"]\n",
+    "original_trips_df = prep.trips_df\n",
+    "print(f\"Total original trips loaded: {len(original_trips_df)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "300cfc25",
+   "metadata": {},
+   "source": [
+    "## 2. Decode using SolutionConverter\n",
+    "Now we generate trips using our mathematically adjusted  generation loop using the baseline integer solution values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "35900e19",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Re-generating GTFS from the encoded matrix...\n",
+      "Total successfully reconstructed trips: 10844\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Re-generating GTFS from the encoded matrix...\")\n",
+    "converter = SolutionConverter(opt_data)\n",
+    "\n",
+    "# 1. Convert integer matrix to mapped headways\n",
+    "headway_dict = converter.solution_to_headways(base_matrix)\n",
+    "\n",
+    "# 2. Extract templates directly from original feed base data\n",
+    "templates = converter.extract_route_templates()\n",
+    "\n",
+    "# 3. Generate exactly the new simulated trips\n",
+    "new_trips_df, new_stop_times_df = converter.generate_trips_and_stop_times(\n",
+    "    headways_dict=headway_dict, templates=templates\n",
+    ")\n",
+    "\n",
+    "print(f\"Total successfully reconstructed trips: {len(new_trips_df)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "77358acd",
+   "metadata": {},
+   "source": [
+    "## 3. Compare Reconstructed Trips vs Original trips per Route\n",
+    "To ensure exact volume matching, we loop over each route and compare the generated volume."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "079bea2b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total original trips for valid routes: 13374\n",
+      "Total reconstructed trips for valid routes: 10844\n",
+      "\n",
+      "Total discrepancy across all factored routes: -2530 trips\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Route</th>\n",
+       "      <th>Original_Trips</th>\n",
+       "      <th>Reconstructed_Trips</th>\n",
+       "      <th>Delta</th>\n",
+       "      <th>Abs_Delta</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>86</th>\n",
+       "      <td>30536</td>\n",
+       "      <td>450</td>\n",
+       "      <td>192</td>\n",
+       "      <td>-258</td>\n",
+       "      <td>258</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>85</th>\n",
+       "      <td>30542</td>\n",
+       "      <td>443</td>\n",
+       "      <td>216</td>\n",
+       "      <td>-227</td>\n",
+       "      <td>227</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>68</th>\n",
+       "      <td>30541</td>\n",
+       "      <td>463</td>\n",
+       "      <td>240</td>\n",
+       "      <td>-223</td>\n",
+       "      <td>223</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>34</th>\n",
+       "      <td>20990</td>\n",
+       "      <td>260</td>\n",
+       "      <td>120</td>\n",
+       "      <td>-140</td>\n",
+       "      <td>140</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>45</th>\n",
+       "      <td>12544</td>\n",
+       "      <td>326</td>\n",
+       "      <td>200</td>\n",
+       "      <td>-126</td>\n",
+       "      <td>126</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>36</th>\n",
+       "      <td>12657</td>\n",
+       "      <td>335</td>\n",
+       "      <td>216</td>\n",
+       "      <td>-119</td>\n",
+       "      <td>119</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>138</th>\n",
+       "      <td>12351</td>\n",
+       "      <td>225</td>\n",
+       "      <td>112</td>\n",
+       "      <td>-113</td>\n",
+       "      <td>113</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>70</th>\n",
+       "      <td>30527</td>\n",
+       "      <td>296</td>\n",
+       "      <td>184</td>\n",
+       "      <td>-112</td>\n",
+       "      <td>112</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>61</th>\n",
+       "      <td>39395</td>\n",
+       "      <td>174</td>\n",
+       "      <td>72</td>\n",
+       "      <td>-102</td>\n",
+       "      <td>102</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>60</th>\n",
+       "      <td>12627</td>\n",
+       "      <td>338</td>\n",
+       "      <td>240</td>\n",
+       "      <td>-98</td>\n",
+       "      <td>98</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     Route  Original_Trips  Reconstructed_Trips  Delta  Abs_Delta\n",
+       "86   30536             450                  192   -258        258\n",
+       "85   30542             443                  216   -227        227\n",
+       "68   30541             463                  240   -223        223\n",
+       "34   20990             260                  120   -140        140\n",
+       "45   12544             326                  200   -126        126\n",
+       "36   12657             335                  216   -119        119\n",
+       "138  12351             225                  112   -113        113\n",
+       "70   30527             296                  184   -112        112\n",
+       "61   39395             174                   72   -102        102\n",
+       "60   12627             338                  240    -98         98"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "summary = []\n",
+    "# Loop over the actual route IDs array\n",
+    "for route_id in opt_data[\"routes\"][\"ids\"]:\n",
+    "    orig_count = len(original_trips_df[original_trips_df[\"route_id\"] == route_id])\n",
+    "    new_count = len(new_trips_df[new_trips_df[\"route_id\"] == route_id])\n",
+    "    summary.append(\n",
+    "        {\n",
+    "            \"Route\": route_id,\n",
+    "            \"Original_Trips\": orig_count,\n",
+    "            \"Reconstructed_Trips\": new_count,\n",
+    "            \"Delta\": new_count - orig_count,\n",
+    "        }\n",
+    "    )\n",
+    "\n",
+    "summary_df = pd.DataFrame(summary)\n",
+    "total_delta = summary_df[\"Delta\"].sum()\n",
+    "\n",
+    "print(f\"Total original trips for valid routes: {summary_df['Original_Trips'].sum()}\")\n",
+    "print(f\"Total reconstructed trips for valid routes: {summary_df['Reconstructed_Trips'].sum()}\")\n",
+    "print(f\"\\nTotal discrepancy across all factored routes: {total_delta} trips\")\n",
+    "\n",
+    "summary_df[\"Abs_Delta\"] = summary_df[\"Delta\"].abs()\n",
+    "summary_df.sort_values(by=\"Abs_Delta\", ascending=False).head(10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a99bee6",
+   "metadata": {},
+   "source": [
+    "## 4. Deep Dive: Why are Trips Reconstructed Lower than Original?\n",
+    "Let's take a closer look at a high-frequency route with a large discrepancy, such as **30536**, to understand the impact of **Headway Snapping**.\n",
+    "\n",
+    "When the optimizer creates the `initial_solution` matrix, it matches the *actual* historical headway to the closest value in our `allowed_headways` list. If a high-density route comes every 2 minutes naturally, but our smallest allowed headway constraint is 5 minutes, we artificially truncate the maximum amount of service we can run on that route."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "6638e32d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- Route 30536 Snapping Analysis ---\n",
+      "Original Continuous Headways (Per 4-hour interval):\n",
+      "[ nan 7.62 4.36 4.07 4.47 8.  ]\n",
+      "\n",
+      "Optimizer's Discrete Allowed Headway List: [5, 10, 15, 30, 60]\n",
+      "\n",
+      "Mapped Matrix Headways (Truncated due to 5-min minimum constraint):\n",
+      "[nan, 10, 5, 5, 5, 10]\n",
+      "\n",
+      "--- Why we lose trips on this route ---\n"
+     ]
+    }
+   ],
+   "source": [
+    "# (b) Deep dive into example route 30536\n",
+    "target_route = \"30536\"\n",
+    "route_idx = opt_data[\"routes\"][\"ids\"].index(target_route)\n",
+    "raw_headways = opt_data[\"routes\"][\"current_headways\"][route_idx]\n",
+    "mapped_indices = opt_data[\"initial_solution\"][route_idx]\n",
+    "\n",
+    "# Map the solver indices back to discrete headways using the configured constraints\n",
+    "mapped_headways = [allowed_headways[idx] if idx < len(allowed_headways) else np.nan for idx in mapped_indices]\n",
+    "\n",
+    "print(f\"--- Route {target_route} Snapping Analysis ---\")\n",
+    "print(f\"Original Continuous Headways (Per {interval_hours}-hour interval):\")\n",
+    "print(np.round(raw_headways, 2))\n",
+    "print(f\"\\nOptimizer's Discrete Allowed Headway List: {allowed_headways}\")\n",
+    "print(f\"\\nMapped Matrix Headways (Truncated due to 5-min minimum constraint):\")\n",
+    "print(mapped_headways)\n",
+    "\n",
+    "# Show the mathematical trip loss for the first active interval\n",
+    "print(\"\\n--- Why we lose trips on this route ---\")\n",
+    "interval_0_raw = raw_headways[0]\n",
+    "interval_0_mapped = mapped_headways[0]\n",
+    "directions = len(templates[target_route].get(list(templates[target_route].keys())[0], {}).keys())\n",
+    "\n",
+    "if not np.isnan(interval_0_raw) and not np.isnan(interval_0_mapped):\n",
+    "    theoretical_raw_trips = (interval_hours * 60) / interval_0_raw * directions\n",
+    "    reconstructed_trips = (interval_hours * 60) / interval_0_mapped * directions\n",
+    "    print(f\"In Interval 0 ({interval_hours} hours):\")\n",
+    "    print(\n",
+    "        f\"  • A {interval_0_raw:.2f} min continuous aggregate headway generates ~{theoretical_raw_trips:.0f} service trips.\"\n",
+    "    )\n",
+    "    print(\n",
+    "        f\"  • Forcing that to a {interval_0_mapped} min aggregate headway generates exactly {reconstructed_trips:.0f} service trips.\"\n",
+    "    )\n",
+    "    print(f\"  • Net loss in just this interval alone: {theoretical_raw_trips - reconstructed_trips:.0f} trips.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b94cd4ff",
+   "metadata": {},
+   "source": [
+    "## 5. How Headway Snapping Actually Works (Nearest Neighbor)\n",
+    "\n",
+    "When `prepare_gtfs.py` builds the optimization matrix, it maps actual historical headways to the `allowed_headways` list using **Nearest Neighbor** rounding:\n",
+    "`idx = int(np.argmin(np.abs(np.array(allowed_headways) - headway_val)))`\n",
+    "\n",
+    "This means headways don't *always* snap upward. For example:\n",
+    "- **7 mins** snaps down to **5 mins** (more frequent $\\rightarrow$ slight trip **inflation**)\n",
+    "- **8 mins** snaps up to **10 mins** (less frequent $\\rightarrow$ slight trip **loss**)\n",
+    "- **12 mins** snaps down to **10 mins** (slight **inflation**)\n",
+    "- **13 mins** snaps up to **15 mins** (slight **loss**)\n",
+    "\n",
+    "Because the rounding goes both ways, the small trip inflations and deflations in the middle of the spectrum organically cancel each other out across the network. If we used strict `ceiling()` or `floor()`, we would artificially deflate or inflate your entire city's network baseline by tens of thousands of trips.\n",
+    "\n",
+    "**Lower Bound (Deflation):** The major trip losses occur severely at the lower boundary (< 5 mins). A dense route running every 2-4 minutes has no downward neighbor and is forced to snap steeply upward to 5 minutes, mathematically dropping dozens of trips per interval.\n",
+    "\n",
+    "**Upper Bound (Inflation):** Conversely, major trip inflation occurs at the upper boundary. If your maximum allowed headway is 60 minutes, any rural or fringe route that historically runs every 90, 120, or 180 minutes is forced to snap *down* to 60 minutes. This acts as a \"minimum service guarantee,\" forcibly running routes more frequently than their historical baseline and heavily increasing the fleet footprint for those specific routes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "8db79bae",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# (c) Calculate mean headways and prepare plot_df\n",
+    "mean_headways = []\n",
+    "\n",
+    "# Calculate mean active continuous headway for each row in our summary\n",
+    "for idx, row in summary_df.iterrows():\n",
+    "    r_idx = opt_data[\"routes\"][\"ids\"].index(row[\"Route\"])\n",
+    "    r_headways = opt_data[\"routes\"][\"current_headways\"][r_idx]\n",
+    "\n",
+    "    # Filter out NaNs to get the average operational frequency\n",
+    "    valid_h = r_headways[~np.isnan(r_headways)]\n",
+    "    mean_h = np.mean(valid_h) if len(valid_h) > 0 else np.nan\n",
+    "    mean_headways.append(mean_h)\n",
+    "\n",
+    "summary_df[\"Mean_Original_Headway\"] = mean_headways\n",
+    "\n",
+    "# Isolate routes that actually run (have valid headways)\n",
+    "plot_df = summary_df.dropna(subset=[\"Mean_Original_Headway\"]).copy()\n",
+    "\n",
+    "# Filter to only show routes with an original headway of maximum 150 minutes\n",
+    "# (This allows us to clearly see the upper bound effect without skewing the graph too far out)\n",
+    "plot_df = plot_df[plot_df[\"Mean_Original_Headway\"] <= 150]\n",
+    "\n",
+    "# Plot Original Headway vs Delta (Positive / Negative direction)\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "\n",
+    "# We use Delta here to show inflation vs deflation\n",
+    "plt.scatter(plot_df[\"Mean_Original_Headway\"], plot_df[\"Delta\"], alpha=0.7, edgecolors=\"w\", color=\"mediumseagreen\", s=80)\n",
+    "plt.title(\"Direction of Trip Changes (Delta) due to Snapping\", fontsize=14)\n",
+    "plt.xlabel(\"Original Continuous Headway (Minutes)\", fontsize=12)\n",
+    "plt.ylabel(\"Delta (Reconstructed - Original Trips)\", fontsize=12)\n",
+    "\n",
+    "# Highlight minimum and maximum allowed bounds\n",
+    "min_allowed = min(allowed_headways)\n",
+    "max_allowed = max(allowed_headways)\n",
+    "plt.axvline(x=min_allowed, color=\"red\", linestyle=\"--\", label=f\"Min Allowed ({min_allowed} min)\")\n",
+    "plt.axvline(x=max_allowed, color=\"purple\", linestyle=\"--\", label=f\"Max Allowed ({max_allowed} min)\")\n",
+    "plt.axhline(y=0, color=\"gray\", linestyle=\"-\", linewidth=2, alpha=0.8, label=\"Zero Delta Baseline\")\n",
+    "\n",
+    "# Annotate a few biggest variances\n",
+    "for _, row in pd.concat([plot_df.nlargest(2, \"Delta\"), plot_df.nsmallest(3, \"Delta\")]).iterrows():\n",
+    "    plt.annotate(\n",
+    "        f\"Route {row['Route']}\",\n",
+    "        (row[\"Mean_Original_Headway\"], row[\"Delta\"]),\n",
+    "        xytext=(10, -5 if row[\"Delta\"] < 0 else 5),\n",
+    "        textcoords=\"offset points\",\n",
+    "        fontsize=9,\n",
+    "        weight=\"bold\",\n",
+    "    )\n",
+    "\n",
+    "plt.legend()\n",
+    "plt.grid(True, alpha=0.3)\n",
+    "plt.xlim(0, 150)  # Focus on original headways up to 150 minutes\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "67188b79",
+   "metadata": {},
+   "source": [
+    "## 6. Interval-By-Interval Breakdown\n",
+    "By breaking down the data into distinct time intervals, we can see exactly when and where these mathematically snapped trip counts occur.\n",
+    "\n",
+    "**How to read the plots below:**\n",
+    "* **Each Blue Dot** represents a single route during that specific 4-hour time interval. Its position on the x-axis is its *actual* historical continuous headway, and the y-axis shows how many trips it gained (positive) or lost (negative) after snapping.\n",
+    "* **The Vertical Red Dashed Lines** represent the discrete `allowed_headways` constraints (e.g., 5, 10, 15, 30, 60 minutes). This denotes the \"rails\" the optimizer is forcing the schedules onto.\n",
+    "\n",
+    "Notice how data points tightly cluster around these constraints—inflation happens as points are pulled downward to the closest vertical line, and deflation happens as they are snapped upward."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "bde2e350",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1800x1000 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# (d) Faceted Scatter Plot by Time Interval\n",
+    "# Calculate interval-level deltas explicitly\n",
+    "intervals_list = []\n",
+    "n_intervals = opt_data[\"n_intervals\"]\n",
+    "\n",
+    "for r_idx, route_id in enumerate(opt_data[\"routes\"][\"ids\"]):\n",
+    "    # Retrieve number of outward/inward directions to compute theoretical trips\n",
+    "    route_templates = templates.get(route_id, {})\n",
+    "    if not route_templates:\n",
+    "        continue\n",
+    "\n",
+    "    first_key = list(route_templates.keys())[0] if len(route_templates) > 0 else None\n",
+    "    directions = len(route_templates.get(first_key, {}).keys()) if first_key else 1\n",
+    "    if directions == 0:\n",
+    "        directions = 1\n",
+    "\n",
+    "    for i in range(n_intervals):\n",
+    "        raw_h = opt_data[\"routes\"][\"current_headways\"][r_idx][i]\n",
+    "        if np.isnan(raw_h):\n",
+    "            continue\n",
+    "\n",
+    "        mapped_idx = opt_data[\"initial_solution\"][r_idx][i]\n",
+    "        # Make sure we gracefully skip 9999 (No Service mode)\n",
+    "        mapped_h = allowed_headways[mapped_idx] if mapped_idx < len(allowed_headways) else np.nan\n",
+    "\n",
+    "        orig_trips = (interval_hours * 60) / raw_h * directions if raw_h > 0 else 0\n",
+    "        new_trips = (interval_hours * 60) / mapped_h * directions if (not np.isnan(mapped_h) and mapped_h < 9999) else 0\n",
+    "\n",
+    "        intervals_list.append(\n",
+    "            {\"Route\": route_id, \"Interval\": i, \"Original_Headway\": raw_h, \"Delta\": new_trips - orig_trips}\n",
+    "        )\n",
+    "\n",
+    "int_df = pd.DataFrame(intervals_list)\n",
+    "\n",
+    "# Matplotlib Subplots Configuration (assuming 6 intervals for a 24-hr day in 4 hr intervals)\n",
+    "fig, axes = plt.subplots(2, 3, figsize=(18, 10), sharex=True, sharey=True)\n",
+    "axes = axes.flatten()\n",
+    "\n",
+    "for i in range(n_intervals):\n",
+    "    if i >= len(axes):\n",
+    "        break  # Ensure we don't crash if > 6 intervals exist\n",
+    "\n",
+    "    ax = axes[i]\n",
+    "    subset = int_df[int_df[\"Interval\"] == i]\n",
+    "\n",
+    "    # Bound to original headways under 120 for clearer visualization of the core snapping effect\n",
+    "    subset = subset[subset[\"Original_Headway\"] <= 120]\n",
+    "\n",
+    "    # Plot the route interval and add a label for the legend\n",
+    "    ax.scatter(\n",
+    "        subset[\"Original_Headway\"],\n",
+    "        subset[\"Delta\"],\n",
+    "        alpha=0.6,\n",
+    "        color=\"royalblue\",\n",
+    "        edgecolors=\"w\",\n",
+    "        label=\"Route Interval Record\",\n",
+    "    )\n",
+    "    ax.axhline(0, color=\"k\", linestyle=\"-\", alpha=0.5)\n",
+    "\n",
+    "    # Add vertical lines for ALL allowed discrete headway choices\n",
+    "    for h_val in sorted(allowed_headways):\n",
+    "        if h_val < 9999:  # Ignore No-Service marker\n",
+    "            ax.axvline(h_val, color=\"red\", linestyle=\"--\", alpha=0.3)\n",
+    "\n",
+    "    ax.set_title(f\"Interval {i} ({i * interval_hours:02d}:00 - {(i + 1) * interval_hours:02d}:00)\")\n",
+    "    ax.grid(True, alpha=0.3)\n",
+    "\n",
+    "    if i == 0:\n",
+    "        # Just use the first allowed headway for the legend label so it doesn't duplicate\n",
+    "        valid_headways = [h for h in allowed_headways if h < 9999]\n",
+    "        if valid_headways:\n",
+    "            ax.axvline(valid_headways[0], color=\"red\", linestyle=\"--\", alpha=0.3, label=\"Allowed Headway Constraint\")\n",
+    "        ax.legend()\n",
+    "\n",
+    "fig.supxlabel(\"Original Continuous Headway (Minutes)\", fontsize=14)\n",
+    "fig.supylabel(\"Delta (Reconstructed - Original Trips)\", fontsize=14)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".transit_opt_uv (3.12.10)",
+   "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.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/transit_opt/gtfs/gtfs.py b/src/transit_opt/gtfs/gtfs.py
index 89880a8..2821242 100644
--- a/src/transit_opt/gtfs/gtfs.py
+++ b/src/transit_opt/gtfs/gtfs.py
@@ -94,6 +94,15 @@ def extract_route_templates(self) -> dict[str, dict[str, Any]]:
         """
         Extract template trips for each route with time-of-day variation.
 
+        Crucially, if a route direction has multiple headsigns (branches/variations),
+        this method enforces a PROPORTIONAL ROUND-ROBIN structure. It analyzes the
+        historical trip frequency of each variation, finds the minimum common ratio,
+        and populates the returned `dir_templates` list with identically duplicated
+        templates matching those ratios. The `splitting_factor` is hardcoded to 1.0
+        because branch assignment is handled purely via sequentially iterating through this
+        weighted list during generation, inherently preserving the exact optimized headway
+        and preventing ANY fleet inflation or 'excess' trips.
+
         Returns:
             Dict mapping route_id -> interval_label -> template_data
             Format: {
@@ -146,54 +155,61 @@ def extract_route_templates(self) -> dict[str, dict[str, Any]]:
 
                 # Check if we have multiple headsigns
                 if len(unique_headsigns) > 1:
-                    # Calculate dominance
-                    total_trips_count = len(route_trips)
-                    top_2_count = unique_headsigns.iloc[:2].sum()
-                    coverage = top_2_count / total_trips_count if total_trips_count > 0 else 0
-
-                    splitting_factor = 1.0  # Default
-
-                    if coverage > 0.9:
-                        # Strategy A: Filter to top 2 dominant headsigns (noise reduction)
-                        top_headsigns = unique_headsigns.iloc[:2].index.tolist()
-                        headsign_map = {h: i for i, h in enumerate(top_headsigns)}
-
-                        # Filter route_trips to only include top 2
-                        route_trips = route_trips[route_trips["trip_headsign"].isin(top_headsigns)].copy()
-
-                        # Update splitting factor for multi-direction routes
-                        if len(top_headsigns) > 1:
-                            splitting_factor = float(len(top_headsigns))
-                            logger.info(
-                                f"Route {route_id}: Detected {len(top_headsigns)} dominant directions. Splitting factor: {splitting_factor}"
-                            )
-
-                        logger.info(
-                            f"Route {route_id}: Filtered to top {len(top_headsigns)} dominant headsigns (coverage {coverage:.1%})"
-                        )
-                    else:
-                        # Strategy C: Keep all headsigns but split frequency (messy route)
-                        # We map ALL headsigns to pseudo-directions
-                        all_headsigns = unique_headsigns.index.tolist()
-                        headsign_map = {h: i for i, h in enumerate(all_headsigns)}
-
-                        # Calculate splitting factor based on number of active branches
-                        splitting_factor = float(len(all_headsigns))
-
-                        logger.info(
-                            f"Route {route_id}: Messy route ({len(all_headsigns)} headsigns, coverage {coverage:.1%}). Splitting factor: {splitting_factor}"
-                        )
+                    # Spatial grouping into exactly TWO directions
+                    # 1. Determine first and last stops for each trip to infer direction
+                    route_trips = route_trips.copy()
+
+                    # Sort stop times to safely get first/last
+                    st_sorted = route_stop_times.sort_values(["trip_id", "stop_sequence"])
+
+                    first_stops = st_sorted.groupby("trip_id")["stop_id"].first()
+                    last_stops = st_sorted.groupby("trip_id")["stop_id"].last()
+
+                    route_trips["inferred_first_stop"] = route_trips["trip_id"].map(first_stops)
+                    route_trips["inferred_last_stop"] = route_trips["trip_id"].map(last_stops)
+
+                    # Determine the two most common origins across all trips
+                    first_stop_counts = route_trips["inferred_first_stop"].value_counts()
+                    anchor_0_orig = first_stop_counts.index[0] if len(first_stop_counts) > 0 else None
+                    anchor_1_orig = first_stop_counts.index[1] if len(first_stop_counts) > 1 else None
+
+                    headsign_map = {}
+                    for headsign in unique_headsigns.index:
+                        hs_trips = route_trips[route_trips["trip_headsign"] == headsign]
+
+                        f_stop = None
+                        l_stop = None
+                        if not hs_trips.empty and not hs_trips["inferred_first_stop"].isna().all():
+                            f_stop = hs_trips["inferred_first_stop"].mode().iloc[0]
+                        if not hs_trips.empty and not hs_trips["inferred_last_stop"].isna().all():
+                            l_stop = hs_trips["inferred_last_stop"].mode().iloc[0]
+
+                        # Use the user's origin-first grouping logic
+                        if f_stop == anchor_0_orig:
+                            headsign_map[headsign] = 0
+                        elif f_stop == anchor_1_orig:
+                            headsign_map[headsign] = 1
+                        elif l_stop == anchor_1_orig:
+                            # If it ends at Dir 1's start, it must be Dir 0
+                            headsign_map[headsign] = 0
+                        elif l_stop == anchor_0_orig:
+                            # If it ends at Dir 0's start, it must be Dir 1
+                            headsign_map[headsign] = 1
+                        else:
+                            # Fallback if logic fails to group
+                            headsign_map[headsign] = 0
+
+                    logger.info(
+                        f"Route {route_id}: Spatially grouping {len(unique_headsigns)} headsigns into 2 directions using origin anchors."
+                    )
 
                     # Apply mapping
                     if "direction_id" not in route_trips.columns:
                         route_trips = route_trips.copy()
 
                     route_trips["direction_id"] = route_trips["trip_headsign"].map(headsign_map)
-                    directions = list(headsign_map.values())
+                    directions = list(set(headsign_map.values()))
                     direction_source = "trip_headsign"
-
-                    # Store splitting factor temporarily on the object or pass it down?
-                    # Better to store it in the templates later
                 else:
                     # Only 1 headsign, treat as direction 0
                     pass
@@ -215,7 +231,6 @@ def extract_route_templates(self) -> dict[str, dict[str, Any]]:
                     try:
                         dir_trips = route_trips[route_trips["direction_id"] == direction_id]
                     except KeyError:
-                        # If direction_id column doesn't exist or other error, use all
                         dir_trips = route_trips
 
                     if dir_trips.empty:
@@ -223,67 +238,78 @@ def extract_route_templates(self) -> dict[str, dict[str, Any]]:
 
                     interval_trips = self._get_trips_in_interval(route_stop_times, dir_trips, start_hour, end_hour)
 
-                    if not interval_trips.empty:
-                        # Extract template for this specific interval and direction
-                        template = self._extract_interval_template(interval_trips, interval_label)
-                        # Store direction info in template
-                        template["direction_id"] = int(direction_id)
-
-                        # Store splitting factor for later headway calculation
-                        # If route is messy (many headsigns treated as directions), we split frequency
-                        # Splitting Factor = N_directions (so headway becomes N times larger)
-                        current_splitting_factor = 1.0
-                        if len(directions) > 1:
-                            if direction_source == "trip_headsign":
-                                # For inferred directions, always split if >1 (either 2 dominant or N messy)
-                                current_splitting_factor = float(len(directions))
-                            elif direction_source == "direction_id":
-                                # For valid GTFS directions, also split because optimization aggregates headway across all directions
-                                # If we don't split, we double the service (once for dir 0, once for dir 1)
-                                current_splitting_factor = float(len(directions))
+                    dir_templates = []
 
-                        logger.debug(
-                            "   Splitting factor for Route %s (Dir %s): %.1f (Source: %s, Directions: %d)",
-                            route_id,
-                            direction_id,
-                            current_splitting_factor,
-                            direction_source,
-                            len(directions),
-                        )
-
-                        template["splitting_factor"] = current_splitting_factor
-
-                        interval_templates[int(direction_id)] = template
-                        logger.debug(
-                            "   ✅ %s (Dir %s): %.1fmin template",
-                            interval_label,
-                            direction_id,
-                            template["duration_minutes"],
-                        )
-                    else:
-                        # No trips in this interval - use fallback from this direction
+                    if not interval_trips.empty:
+                        # Find unique variations (headsigns) in this direction/interval
+                        if "trip_headsign" in interval_trips.columns:
+                            # PROPORTIONAL ROUND-ROBIN LOGIC:
+                            # Instead of assigning a blanket template for all vehicles, we measure the
+                            # historical frequency of each branch (identified by headsign) in the base GTFS.
+                            # We then populate the `dir_templates` array with identical duplicates of branch
+                            # templates matching their historical proportion.
+                            # Example: If Branch A ran 10 times, and Branch B ran 2 times, the min_count is 2.
+                            # We append Template A 5 times (10/2) and Template B 1 time (2/2).
+                            # When trips are generated later, they cycle sequentially through this array,
+                            # guaranteeing Branch A gets 5 vehicles for every 1 vehicle on Branch B, WITHOUT
+                            # generating any extra / parallel trips or altering the aggregate headway.
+                            hs_groups = interval_trips.groupby("trip_headsign")
+                            total_dir_trips_count = len(interval_trips["trip_id"].unique())
+
+                            branch_counts = {}
+                            branch_templates = {}
+
+                            for hs, hs_trips in hs_groups:
+                                trip_count = len(hs_trips["trip_id"].unique())
+                                try:
+                                    template = self._extract_interval_template(hs_trips, interval_label)
+                                    template["direction_id"] = int(direction_id)
+                                    # Splitting factor is strictly 1.0! The total volume of vehicles is solely
+                                    # dictated by the base headway. We only divide which path they take.
+                                    template["splitting_factor"] = 1.0
+
+                                    branch_templates[hs] = template
+                                    branch_counts[hs] = trip_count
+                                except Exception as e:
+                                    # If a template cannot be extracted, it is dropped from branch_counts/templates.
+                                    # Because vehicle volume is strictly governed by the aggregate headway, the
+                                    # modulo selection array will just be smaller. The scheduled trips/vehicles for
+                                    # this dropped branch are thus automatically redistributed among the other branches!
+                                    logger.warning(
+                                        f"Failed to extract pattern for headsign '{hs}' on route {route_id}: {e}. "
+                                        f"Variation ignored. Its trips will be absorbed by other healthy variations."
+                                    )
+                                    pass
+
+                            if branch_counts:
+                                # Determine base denominator to scale down counts into integer ratios
+                                min_count = max(1, min(branch_counts.values()))
+
+                                for hs, count in branch_counts.items():
+                                    # Calculate proportional weight (e.g. 10 base trips / 2 minimum = ratio of 5)
+                                    ratio = max(1, round(count / min_count))
+
+                                    # Populate the variation pool. A ratio of 5 adds 5 adjacent identical templates.
+                                    for _ in range(ratio):
+                                        dir_templates.append(branch_templates[hs])
+                        else:
+                            template = self._extract_interval_template(interval_trips, interval_label)
+                            template["direction_id"] = int(direction_id)
+                            template["splitting_factor"] = 1.0
+                            dir_templates.append(template)
+
+                    if not dir_templates:
+                        # Fallback
                         try:
                             fallback_template = self._get_fallback_template(dir_trips, route_stop_times)
-
-                            # Store splitting factor
-                            current_splitting_factor = 1.0
-                            if len(directions) > 1:
-                                current_splitting_factor = float(len(directions))
-
-                            fallback_template["splitting_factor"] = current_splitting_factor
-
+                            fallback_template["splitting_factor"] = 1.0
                             fallback_template["direction_id"] = int(direction_id)
-                            interval_templates[int(direction_id)] = fallback_template
-                            logger.warning(
-                                "   ⚠️  Route %s, %s (Dir %s): No trips found, using fallback",
-                                route_id,
-                                interval_label,
-                                direction_id,
-                            )
+                            dir_templates.append(fallback_template)
                         except Exception:
-                            logger.warning(
-                                "   ❌ Route %s (Dir %s): Could not extract fallback", route_id, direction_id
-                            )
+                            pass
+
+                    if dir_templates:
+                        interval_templates[int(direction_id)] = dir_templates
 
                 if interval_templates:
                     route_templates[interval_label] = interval_templates
@@ -299,20 +325,21 @@ def extract_route_templates(self) -> dict[str, dict[str, Any]]:
         logger.info("Cleaning stop times data for all templates...")
         for route_id, route_templates in template_trips.items():
             for interval_label, dir_templates in route_templates.items():
-                for direction_id, template in dir_templates.items():
-                    original_count = len(template["stop_times"])
-                    template["stop_times"] = self._clean_stop_times(template["stop_times"])
-                    cleaned_count = len(template["stop_times"])
-
-                    if cleaned_count != original_count:
-                        logger.debug(
-                            "Cleaned stop times for %s %s (Dir %s): %d -> %d stops",
-                            route_id,
-                            interval_label,
-                            direction_id,
-                            original_count,
-                            cleaned_count,
-                        )
+                for direction_id, templates_list in dir_templates.items():
+                    for template in templates_list:
+                        original_count = len(template["stop_times"])
+                        template["stop_times"] = self._clean_stop_times(template["stop_times"])
+                        cleaned_count = len(template["stop_times"])
+
+                        if cleaned_count != original_count:
+                            logger.debug(
+                                "Cleaned stop times for %s %s (Dir %s): %d -> %d stops",
+                                route_id,
+                                interval_label,
+                                direction_id,
+                                original_count,
+                                cleaned_count,
+                            )
 
         logger.info("Extracted time-varying templates for %d routes", len(template_trips))
         return template_trips
@@ -323,6 +350,12 @@ def generate_trips_and_stop_times(
         """
         Generate new trips and stop_times based on optimized headways with time-of-day templates.
 
+        Crucially for branched routes, this function ensures that the AGGREGATE service frequency
+        exactly matches the `headway` generated by the solver. It simply divides those scheduled
+        dispatches proportionally among the various branches/headsigns using the scaled
+        round-robin template list generated in `extract_route_templates()`. No parallel or
+        additional subset trips are created.
+
         Args:
             headways_dict: Route headways by interval
             templates: Template data for each route (now with interval-specific templates)
@@ -375,37 +408,42 @@ def generate_trips_and_stop_times(
                     interval_templates = all_avail_templates_dict
 
                 # Iterate through DIRECTION TEMPLATES
-                for direction_id, template in interval_templates.items():
-                    template_stop_times = template["stop_times"]
-                    trip_duration_minutes = template["duration_minutes"]
+                for dir_index, (direction_id, templates_list) in enumerate(interval_templates.items()):
+                    if not templates_list:
+                        continue
 
-                    # Extract metadata from template if available
-                    route_info = template.get("route_info", {})
-                    template_headsign = route_info.get("trip_headsign", None)
-                    template_shape_id = route_info.get("shape_id", None)
+                    # We just use the first template for some base metadata (assuming they share a lot)
+                    base_template = templates_list[0]
+                    splitting_factor = base_template.get("splitting_factor", 1.0)
+                    effective_headway = headway * splitting_factor
 
-                    # Apply Splitting Factor
-                    splitting_factor = template.get("splitting_factor", 1.0)
-                    effective_headway = headway * splitting_factor  # Use user-supplied headway
+                    # Adjust explicit headway based on symmetrical direction division.
+                    # Because `interval_templates.items()` iterates through ALL directional branch routes, 
+                    # applying a single aggregate headway to every single direction duplicates service by D.
+                    # A 5-minute aggregate headway across 2 directions necessitates a 10-minute directional headway.
+                    num_dirs_in_interval = len(interval_templates.keys())
+                    directional_headway = effective_headway * num_dirs_in_interval
+
+                    # Calculate start offset to interleave departures
+                    # If directional_headway = 10, Dir 0 starts at 0, Dir 1 starts at 5
+                    start_offset = dir_index * effective_headway
 
                     if splitting_factor > 1.0:
                         logger.debug(
-                            f"Applying splitting factor {splitting_factor} to Route {route_id} Interval {interval_label} (Headway {headway} -> {effective_headway})"
+                            f"Applying splitting factor {splitting_factor} to Route {route_id}"
                         )
 
-                    # Generate trips for this interval/direction
+                    # Generate trips for this interval/direction using ALL templates (round-robin)
                     interval_trips, interval_stop_times = self._generate_interval_trips(
                         route_id=route_id,
-                        template_stop_times=template_stop_times,
+                        templates_list=templates_list,
                         start_hour=start_hour,
                         end_hour=end_hour,
-                        headway_minutes=effective_headway,
-                        trip_duration_minutes=trip_duration_minutes,
+                        headway_minutes=directional_headway,
                         trip_counter_start=trip_counter,
                         service_id=service_id,
                         direction_id=int(direction_id),  # EXPLICITLY pass direction_id
-                        trip_headsign=template_headsign,  # Pass template metadata
-                        shape_id=template_shape_id,  # Pass template metadata
+                        start_offset_minutes=start_offset,  # Interleaved departures
                     )
 
                     # Update trip IDs to include direction info to avoid collisions
@@ -781,19 +819,26 @@ def get_interval_time_bounds(self, interval_label: str) -> tuple[int, int]:
     def _generate_interval_trips(
         self,
         route_id: str,
-        template_stop_times: pd.DataFrame,
+        templates_list: list[dict],
         start_hour: int,
         end_hour: int,
         headway_minutes: float,
-        trip_duration_minutes: float,
         trip_counter_start: int,
         service_id: str = "optimized_service",
         direction_id: int = 0,
-        trip_headsign: str = None,
-        shape_id: str = None,
+        start_offset_minutes: float = 0.0,
     ) -> tuple[list, list]:
-        """Generate trips and stop times for a single route-interval combination."""
-
+        """
+        Generate trips and stop times for a single route/direction combination using templates.
+
+        This method executes the PROPORTIONAL ROUND-ROBIN selection. Every `headway_minutes`,
+        it generates exactly ONE new trip. It selects the path (branch template) for that trip
+        by cycling sequentially through `templates_list` using modulo (`trip_idx % len()`).
+        Because `extract_route_templates` pre-populated `templates_list` with properly weighted
+        duplicate branch templates (matching exactly their historical dispatch ratio), iterating
+        through this array natively distributes vehicles across variations. This absolutely guarantees
+        that no 'extra' trips are created, and the total aggregate frequency explicitly matches the solver's headway.
+        """
         trips = []
         stop_times = []
 
@@ -801,56 +846,59 @@ def _generate_interval_trips(
         original_gtfs = self.opt_data["reconstruction"]["gtfs_feed"]
         original_route_trips = original_gtfs.trips[original_gtfs.trips.route_id == route_id]
 
-        # Use first trip as template for fallback metadata
-        fallback_shape_id = ""
-        fallback_headsign = f"Route {route_id}"
-
-        if not original_route_trips.empty:
-            template_trip = original_route_trips.iloc[0]
-            fallback_shape_id = template_trip.get("shape_id", "")
-            # Need to handle potential NaN for headsign
-            th = template_trip.get("trip_headsign", f"Route {route_id}")
-            if pd.isna(th):
-                th = f"Route {route_id}"
-            fallback_headsign = th
-
-        # Use provided metadata or fallback
-        final_shape_id = shape_id if shape_id is not None else fallback_shape_id
-        final_headsign = trip_headsign if trip_headsign is not None else fallback_headsign
-
-        # Handle NaN headsign if it came from template
-        if pd.isna(final_headsign):
-            final_headsign = fallback_headsign
-
-        final_direction_id = direction_id  # Use passed direction_id (def 0)
-
         # Calculate trip start times
         interval_start_seconds = start_hour * 3600
         interval_end_seconds = end_hour * 3600
-        trip_duration_seconds = trip_duration_minutes * 60
         headway_seconds = headway_minutes * 60
 
-        # Latest possible start time (ensure trip completes within interval)
-        latest_start = interval_end_seconds - trip_duration_seconds
-
         # Generate trips every headway minutes
-        current_start = interval_start_seconds
+        current_start = interval_start_seconds + (start_offset_minutes * 60)
 
-        # Use trip_counter_start if provided to continue numbering,
-        # BUT for per-direction uniqueness in the ID string itself, we should include direction
+        # Iterate generating trips
         trip_idx = 0
 
-        while current_start <= latest_start:
+        while current_start < interval_end_seconds:
+            # Round-robin selection of template for variations
+            template = templates_list[trip_idx % len(templates_list)]
+            template_stop_times = template["stop_times"]
+            trip_duration_seconds = template["duration_minutes"] * 60
+
+            # Check if this specific trip completes before the interval ends
+            # We NO LONGER break here. prepare_gtfs.py encodes the volume of trips *departing* 
+            # within this interval boundary. If we stop generating them early because their 
+            # arrival time spills over the boundary, we will drastically under-assign service
+            # (especially for long route durations). We must let the trip finish.
+            # if (current_start + trip_duration_seconds) > interval_end_seconds:
+            #     break
+
+            # Extract specific metadata for THIS template
+            route_info = template.get("route_info", {})
+            template_headsign = route_info.get("trip_headsign", None)
+            template_shape_id = route_info.get("shape_id", None)
+
+            fallback_shape_id = ""
+            fallback_headsign = f"Route {route_id}"
+            if not original_route_trips.empty:
+                t_trip = original_route_trips.iloc[0]
+                fallback_shape_id = t_trip.get("shape_id", "")
+                th = t_trip.get("trip_headsign", fallback_headsign)
+                fallback_headsign = fallback_headsign if pd.isna(th) else th
+
+            final_shape_id = template_shape_id if template_shape_id is not None else fallback_shape_id
+            final_headsign = template_headsign if template_headsign is not None else fallback_headsign
+            if pd.isna(final_headsign):
+                final_headsign = fallback_headsign
+
             # Create trip ID - Include direction_id to ensure uniqueness
-            trip_id = f"opt_trip_{route_id}_{start_hour:02d}_{final_direction_id}_{trip_idx:03d}"
+            trip_id = f"opt_trip_{route_id}_{start_hour:02d}_{direction_id}_{trip_idx:03d}"
 
             # Create trip record
             trip_record = {
                 "trip_id": trip_id,
                 "route_id": route_id,
-                "service_id": service_id,  # Simplified service ID
+                "service_id": service_id,
                 "trip_headsign": final_headsign,
-                "direction_id": final_direction_id,
+                "direction_id": direction_id,
                 "shape_id": final_shape_id,
             }
             trips.append(trip_record)
diff --git a/src/transit_opt/optimisation/spatial/zoning.py b/src/transit_opt/optimisation/spatial/zoning.py
index 1938689..cc42782 100644
--- a/src/transit_opt/optimisation/spatial/zoning.py
+++ b/src/transit_opt/optimisation/spatial/zoning.py
@@ -101,10 +101,9 @@ def __init__(
         self._print_frequency = 50  # Print every N evaluations (TODO: make configurable)
 
         # reusable buffers for per-evaluation arrays to avoid repeated allocations
-        self._pt_vehicles_buffer = None   # shape: (n_intervals, n_zones) allocated on first use
+        self._pt_vehicles_buffer = None  # shape: (n_intervals, n_zones) allocated on first use
         self._drt_vehicles_buffer = None  # shape: (n_intervals, n_hex_zones) allocated on first use
 
-
         # Validate that CRS is metric
         self._validate_metric_crs()
 
@@ -114,9 +113,7 @@ def __init__(
         # Apply boundary filtering if provided
         if self.boundary is not None:
             logger.info("🎯 Applying boundary filter to %d stops...", len(self.stops_gdf))
-            self.stops_gdf = self.boundary.filter_points(
-                self.stops_gdf, output_crs=self.crs
-            )
+            self.stops_gdf = self.boundary.filter_points(self.stops_gdf, output_crs=self.crs)
             logger.info("✅ Filtered to %d stops within boundary", len(self.stops_gdf))
 
         # Generate hexagonal grid
@@ -125,16 +122,14 @@ def __init__(
         # Optionally filter grid to boundary as well
         if self.boundary is not None:
             logger.info("🎯 Applying boundary filter to %d grid cells...", len(self.hex_grid))
-            self.hex_grid = self.boundary.filter_grid(
-                self.hex_grid, predicate="intersects", output_crs=self.crs
-            )
+            self.hex_grid = self.boundary.filter_grid(self.hex_grid, predicate="intersects", output_crs=self.crs)
             logger.info("✅ Filtered to %d grid cells within boundary", len(self.hex_grid))
 
         # OPTIMIZED: Use spatial join instead of nested loops
         self.stop_zone_mapping = self._fast_map_stops_to_zones()
 
         # DRT zone mappings (if provided) - AFTER boundary filtering
-        if drt_config is not None and drt_config.get('enabled', False):
+        if drt_config is not None and drt_config.get("enabled", False):
             self._set_drt_zone_mappings(drt_config)
 
         # OPTIMIZED: Pre-compute route-stop mappings
@@ -154,12 +149,8 @@ def _validate_metric_crs(self):
             if hasattr(crs_info.axis_info[0], "unit_name"):
                 unit = crs_info.axis_info[0].unit_name.lower()
                 if "metre" not in unit and "meter" not in unit:
-                    logger.warning(
-                        f"⚠️  Warning: CRS {self.crs} may not be metric (units: {unit})"
-                    )
-                    logger.info(
-                        "   Consider using EPSG:3857 (Web Mercator) or a local UTM zone"
-                    )
+                    logger.warning(f"⚠️  Warning: CRS {self.crs} may not be metric (units: {unit})")
+                    logger.info("   Consider using EPSG:3857 (Web Mercator) or a local UTM zone")
 
         except ImportError:
             logger.warning("⚠️  pyproj not available - cannot validate CRS units")
@@ -171,10 +162,7 @@ def _create_stops_geodataframe(self) -> gpd.GeoDataFrame:
         stops = self.gtfs_feed.stops.copy()
 
         # Create geometry from lat/lon (EPSG:4326)
-        geometry = [
-            Point(lon, lat)
-            for lon, lat in zip(stops["stop_lon"], stops["stop_lat"], strict=False)
-        ]
+        geometry = [Point(lon, lat) for lon, lat in zip(stops["stop_lon"], stops["stop_lat"], strict=False)]
         stops_gdf = gpd.GeoDataFrame(stops, geometry=geometry, crs="EPSG:4326")
 
         # Reproject to target metric CRS
@@ -205,9 +193,7 @@ def _create_hexagonal_grid(self) -> gpd.GeoDataFrame:
         y_steps = int((maxy - miny) / hex_size_m) + 1
 
         logger.info(f"🔧 Creating {x_steps} × {y_steps} = {x_steps * y_steps} grid cells")
-        logger.info(
-            f"   Grid bounds: ({minx:.0f}, {miny:.0f}) to ({maxx:.0f}, {maxy:.0f}) meters"
-        )
+        logger.info(f"   Grid bounds: ({minx:.0f}, {miny:.0f}) to ({maxx:.0f}, {maxy:.0f}) meters")
         logger.info(f"   Cell size: {hex_size_m}m × {hex_size_m}m")
 
         zone_id = 0
@@ -232,9 +218,7 @@ def _create_hexagonal_grid(self) -> gpd.GeoDataFrame:
                 zone_ids.append(f"zone_{zone_id}")
                 zone_id += 1
 
-        hex_gdf = gpd.GeoDataFrame(
-            {"zone_id": zone_ids, "geometry": hex_polygons}, crs=self.crs
-        )
+        hex_gdf = gpd.GeoDataFrame({"zone_id": zone_ids, "geometry": hex_polygons}, crs=self.crs)
 
         logger.info("✅ Created %d hexagonal zones in %s", len(hex_gdf), self.crs)
         return hex_gdf
@@ -254,9 +238,7 @@ def _fast_map_stops_to_zones(self) -> dict[str, str]:
         # Rename to avoid conflicts in spatial join
         hex_grid_for_join = hex_grid_for_join.rename(columns={"zone_id": "hex_zone_id"})
 
-        stops_with_zones = gpd.sjoin(
-            self.stops_gdf, hex_grid_for_join, how="left", predicate="within"
-        )
+        stops_with_zones = gpd.sjoin(self.stops_gdf, hex_grid_for_join, how="left", predicate="within")
 
         # Convert to dictionary
         stop_zone_map = {}
@@ -268,9 +250,7 @@ def _fast_map_stops_to_zones(self) -> dict[str, str]:
                 stop_point = row.geometry
                 distances = self.hex_grid.geometry.distance(stop_point)
                 nearest_zone_idx = distances.idxmin()
-                stop_zone_map[row["stop_id"]] = self.hex_grid.loc[
-                    nearest_zone_idx, "zone_id"
-                ]
+                stop_zone_map[row["stop_id"]] = self.hex_grid.loc[nearest_zone_idx, "zone_id"]
 
         logger.info("✅ Mapped %d stops to zones", len(stop_zone_map))
         return stop_zone_map
@@ -283,14 +263,10 @@ def _precompute_route_stop_mappings(self):
         self.route_stops_cache = {}
 
         # Group trips by route_id instead of service_id
-        trips_by_route = (
-            self.gtfs_feed.trips.groupby("route_id")["trip_id"].apply(list).to_dict()
-        )
+        trips_by_route = self.gtfs_feed.trips.groupby("route_id")["trip_id"].apply(list).to_dict()
 
         # Group stop_times by trip_id once
-        stop_times_by_trip = (
-            self.gtfs_feed.stop_times.groupby("trip_id")["stop_id"].apply(set).to_dict()
-        )
+        stop_times_by_trip = self.gtfs_feed.stop_times.groupby("trip_id")["stop_id"].apply(set).to_dict()
 
         for route_id, trip_ids in trips_by_route.items():
             # Get all unique stops for this route
@@ -360,13 +336,11 @@ def _calculate_spatial_lag(self, vehicles_per_zone: np.ndarray) -> np.ndarray:
             • Spatial lag mean: {np.mean(spatial_lag):.2f}
             • Non-zero lags: {np.sum(spatial_lag > 0)}
             """
-            )
+        )
 
         return spatial_lag
 
-    def _calculate_accessibility_scores(
-        self, vehicles_per_zone: np.ndarray, alpha: float = 0.1
-    ) -> np.ndarray:
+    def _calculate_accessibility_scores(self, vehicles_per_zone: np.ndarray, alpha: float = 0.1) -> np.ndarray:
         """
         Calculate accessibility scores incorporating neighbor service levels.
 
@@ -453,26 +427,23 @@ def _vehicles_per_zone(
         # Increment counter for this evaluation
         self._evaluation_count += 1
 
-         # Determine if DRT is enabled
-        drt_enabled = optimization_data.get('drt_enabled', False)
+        # Determine if DRT is enabled
+        drt_enabled = optimization_data.get("drt_enabled", False)
 
         # Only print debug info every N evaluations
-        should_print = (self._evaluation_count % self._print_frequency == 0 or
-                    self._evaluation_count == 1)  # Always print first evaluation
+        should_print = (
+            self._evaluation_count % self._print_frequency == 0 or self._evaluation_count == 1
+        )  # Always print first evaluation
 
         # PT + DRT case
         if drt_enabled and isinstance(solution_matrix, dict):
             if should_print:
                 logger.debug("📊 Calculating PT+DRT vehicles per zone... (eval #%d)", self._evaluation_count)
             # Calculate PT vehicles
-            pt_vehicles_data = self._calculate_pt_vehicles_by_interval(
-                solution_matrix['pt'], optimization_data
-            )
+            pt_vehicles_data = self._calculate_pt_vehicles_by_interval(solution_matrix["pt"], optimization_data)
 
             # Calculate DRT vehicles
-            drt_vehicles_data = self._calculate_drt_vehicles_by_interval(
-                solution_matrix['drt'], optimization_data
-            )
+            drt_vehicles_data = self._calculate_drt_vehicles_by_interval(solution_matrix["drt"], optimization_data)
 
             # Combine PT and DRT data
             return self._combine_vehicle_data(pt_vehicles_data, drt_vehicles_data, should_print)
@@ -482,11 +453,10 @@ def _vehicles_per_zone(
                 logger.debug("📊 Calculating PT-only vehicles per zone... (eval #%d)", self._evaluation_count)
             if isinstance(solution_matrix, dict):
                 # Extract PT part if dict format used
-                solution_matrix = solution_matrix['pt']
+                solution_matrix = solution_matrix["pt"]
 
             return self._calculate_pt_vehicles_by_interval(solution_matrix, optimization_data)
 
-
     def _calculate_pt_vehicles_by_interval(
         self, pt_solution_matrix: np.ndarray, optimization_data: dict[str, Any]
     ) -> dict[str, np.ndarray]:
@@ -508,9 +478,9 @@ def _calculate_pt_vehicles_by_interval(
         # STEP 3: Extract data from optimization structure
         route_ids = optimization_data["routes"]["ids"]
         allowed_headways = optimization_data["allowed_headways"]
-        round_trip_times = optimization_data["routes"]["round_trip_times"]
         no_service_index = optimization_data["no_service_index"]
         interval_labels = optimization_data["intervals"]["labels"]
+        interval_duration_minutes = optimization_data["intervals"]["duration_minutes"]
 
         # STEP 4: Main computation loop (unchanged logic, different output location)
         for interval_idx in range(n_intervals):
@@ -529,8 +499,9 @@ def _calculate_pt_vehicles_by_interval(
                 headway = allowed_headways[choice_idx]
 
                 if headway < 9000:  # Valid service headway
-                    round_trip = round_trip_times[route_idx]
-                    vehicles_in_interval = max(1, int(np.ceil(round_trip / headway)))
+                    # Instead of fleet size (round_trip / headway), calculate trips/passes in interval
+                    # This ensures waiting time is based on service frequency, not vehicle bounds.
+                    vehicles_in_interval = max(1, int(np.ceil(interval_duration_minutes / headway)))
 
                     zones_served = {
                         self.stop_zone_mapping[stop_id]
@@ -601,20 +572,20 @@ def _calculate_drt_vehicles_by_interval(
             - 'sum': Array of shape (n_hex_zones,)
             - 'interval_labels': List of interval labels
         """
-        if not optimization_data.get('drt_enabled', False):
-            n_intervals = optimization_data['n_intervals']
+        if not optimization_data.get("drt_enabled", False):
+            n_intervals = optimization_data["n_intervals"]
             n_hex_zones = len(self.hex_grid)
             return {
-                'intervals': np.zeros((n_intervals, n_hex_zones)),
-                'average': np.zeros(n_hex_zones),
-                'peak': np.zeros(n_hex_zones),
-                'sum': np.zeros(n_hex_zones),
-                'interval_labels': optimization_data['intervals']['labels']
+                "intervals": np.zeros((n_intervals, n_hex_zones)),
+                "average": np.zeros(n_hex_zones),
+                "peak": np.zeros(n_hex_zones),
+                "sum": np.zeros(n_hex_zones),
+                "interval_labels": optimization_data["intervals"]["labels"],
             }
 
         # STEP 1: Allocate or reuse DRT buffer
-        drt_zones = optimization_data['drt_config']['zones']
-        n_intervals = optimization_data['n_intervals']
+        drt_zones = optimization_data["drt_config"]["zones"]
+        n_intervals = optimization_data["n_intervals"]
         n_hex_zones = len(self.hex_grid)
 
         if self._drt_vehicles_buffer is None or self._drt_vehicles_buffer.shape != (n_intervals, n_hex_zones):
@@ -633,25 +604,27 @@ def _calculate_drt_vehicles_by_interval(
         # STEP 3: Process each DRT zone and interval
         for drt_zone_idx, drt_zone in enumerate(drt_zones):
             # Get DRT speed for this zone
-            drt_speed_kmh = drt_zone.get('drt_speed_kmh')
+            drt_speed_kmh = drt_zone.get("drt_speed_kmh")
             if drt_speed_kmh is None:
-                drt_speed_kmh = optimization_data['drt_config'].get('default_drt_speed_kmh', 25.0)
-                logger.debug("Using default DRT speed %s km/h for zone %s", drt_speed_kmh, drt_zone.get('zone_id'))
+                drt_speed_kmh = optimization_data["drt_config"].get("default_drt_speed_kmh", 25.0)
+                logger.debug("Using default DRT speed %s km/h for zone %s", drt_speed_kmh, drt_zone.get("zone_id"))
 
             for interval_idx in range(n_intervals):
                 # Get fleet size for this DRT zone and interval
                 fleet_choice_idx = drt_solution_matrix[drt_zone_idx, interval_idx]
 
-                fleet_size = drt_zone['allowed_fleet_sizes'][int(fleet_choice_idx)]  # IndexError for out-of-range, negative
+                fleet_size = drt_zone["allowed_fleet_sizes"][
+                    int(fleet_choice_idx)
+                ]  # IndexError for out-of-range, negative
 
                 # Calculate vehicle activity
-                interval_length_minutes = optimization_data['intervals']['duration_minutes']
+                interval_length_minutes = optimization_data["intervals"]["duration_minutes"]
 
                 # Time to cross a STUDY AREA zone (not DRT service area)
                 time_to_cross_hours = study_area_zone_diameter_km / drt_speed_kmh
                 time_to_cross_minutes = time_to_cross_hours * 60
 
-                n_zones_in_drt_area = len(drt_zone.get('affected_hex_zones', []))
+                n_zones_in_drt_area = len(drt_zone.get("affected_hex_zones", []))
                 if n_zones_in_drt_area == 0:
                     continue
 
@@ -659,12 +632,14 @@ def _calculate_drt_vehicles_by_interval(
                 vehicle_activity = (interval_length_minutes / time_to_cross_minutes) * coverage
 
                 # Add to affected hexagonal zones for this interval
-                affected_hex_zones = drt_zone.get('affected_hex_zones', [])
+                affected_hex_zones = drt_zone.get("affected_hex_zones", [])
                 for hex_zone_idx in affected_hex_zones:
                     if 0 <= hex_zone_idx < n_hex_zones:  # Safety check for bounds
                         drt_vehicles_by_interval[interval_idx, hex_zone_idx] += vehicle_activity
                     else:
-                        logger.warning("Affected hex zone index %s out of bounds (0..%d); skipping", hex_zone_idx, n_hex_zones-1)
+                        logger.warning(
+                            "Affected hex zone index %s out of bounds (0..%d); skipping", hex_zone_idx, n_hex_zones - 1
+                        )
 
         # STEP 4: Identify time interval with peak total vehicles
         total_vehicles_by_interval = np.sum(drt_vehicles_by_interval, axis=1)
@@ -673,16 +648,15 @@ def _calculate_drt_vehicles_by_interval(
         # STEP 5: Return copies (not the buffer itself!)
         # This ensures callers can't accidentally keep the buffer alive
         return {
-            'intervals': drt_vehicles_by_interval.copy(),
-            'average': np.mean(drt_vehicles_by_interval, axis=0).copy(),
-            'peak': drt_vehicles_by_interval[peak_interval_idx, :].copy(),
-            'sum': np.sum(drt_vehicles_by_interval, axis=0).copy(),
-            'interval_labels': optimization_data['intervals']['labels']
+            "intervals": drt_vehicles_by_interval.copy(),
+            "average": np.mean(drt_vehicles_by_interval, axis=0).copy(),
+            "peak": drt_vehicles_by_interval[peak_interval_idx, :].copy(),
+            "sum": np.sum(drt_vehicles_by_interval, axis=0).copy(),
+            "interval_labels": optimization_data["intervals"]["labels"],
         }
 
     def _combine_vehicle_data(
-        self, pt_data: dict[str, np.ndarray], drt_data: dict[str, np.ndarray],
-        should_print: bool = False
+        self, pt_data: dict[str, np.ndarray], drt_data: dict[str, np.ndarray], should_print: bool = False
     ) -> dict[str, np.ndarray]:
         """
         Combine PT and DRT vehicle data with temporally consistent peak calculation.
@@ -693,62 +667,63 @@ def _combine_vehicle_data(
         - Ensures PT and DRT peak values represent the SAME interval/time period
         """
         # STEP 1: Combine interval data
-        combined_intervals = pt_data['intervals'] + drt_data['intervals']
+        combined_intervals = pt_data["intervals"] + drt_data["intervals"]
 
         # STEP 2: Find system-wide peak interval (when total vehicles needed is highest)
         total_vehicles_by_interval = np.sum(combined_intervals, axis=1)
         peak_interval_idx = int(np.argmax(total_vehicles_by_interval))
 
         if should_print:
-            logger.debug("🔄 Combined peak interval: %d (total vehicles: %.0f)",
-                        peak_interval_idx, total_vehicles_by_interval[peak_interval_idx])
+            logger.debug(
+                "🔄 Combined peak interval: %d (total vehicles: %.0f)",
+                peak_interval_idx,
+                total_vehicles_by_interval[peak_interval_idx],
+            )
 
         # STEP 3: Get peak vehicles from the system peak interval
         peak_combined = combined_intervals[peak_interval_idx, :].copy()
 
         # STEP 4: Return combined results
         return {
-            'intervals': combined_intervals,
-            'average': np.mean(combined_intervals, axis=0).copy(),
-            'peak': peak_combined,
-            'sum': np.sum(combined_intervals, axis=0).copy(),
-            'interval_labels': pt_data['interval_labels']
+            "intervals": combined_intervals,
+            "average": np.mean(combined_intervals, axis=0).copy(),
+            "peak": peak_combined,
+            "sum": np.sum(combined_intervals, axis=0).copy(),
+            "interval_labels": pt_data["interval_labels"],
         }
 
-
-
     def set_drt_zone_mappings(self, opt_data: dict):
         """Set DRT zone mappings from optimization data using efficient spatial operations."""
-        if not opt_data.get('drt_enabled', False):
+        if not opt_data.get("drt_enabled", False):
             return
 
         # Access DRT zones from existing location
-        drt_zones = opt_data['drt_config']['zones']
+        drt_zones = opt_data["drt_config"]["zones"]
 
         logger.info("🗺️ Computing spatial intersections for %d DRT zones...", len(drt_zones))
 
         for drt_zone in drt_zones:
             # Use vectorized spatial operations instead of loops
-            drt_geometry = drt_zone['geometry']  # Already in correct CRS
+            drt_geometry = drt_zone["geometry"]  # Already in correct CRS
 
             # Efficient spatial intersection using GeoPandas
             mask = self.hex_grid.geometry.intersects(drt_geometry)
             affected_hex_indices = self.hex_grid.index[mask].tolist()
 
-            drt_zone['affected_hex_zones'] = affected_hex_indices
-            logger.debug("   DRT zone %d affects %d hexagonal zones", drt_zone['zone_id'], len(affected_hex_indices))
+            drt_zone["affected_hex_zones"] = affected_hex_indices
+            logger.debug("   DRT zone %d affects %d hexagonal zones", drt_zone["zone_id"], len(affected_hex_indices))
 
     def _set_drt_zone_mappings(self, drt_config: dict):
         """Set DRT zone mappings from config during initialization (after boundary filtering)."""
-        if not drt_config.get('enabled', False):
+        if not drt_config.get("enabled", False):
             return
 
-        drt_zones = drt_config['zones']
+        drt_zones = drt_config["zones"]
         logger.info("🗺️ Computing DRT spatial intersections for %d zones...", len(drt_zones))
         logger.info("   Hexagonal grid size: %d zones", len(self.hex_grid))
 
         for drt_zone in drt_zones:
-            drt_geometry = drt_zone['geometry']  # Already in correct CRS
+            drt_geometry = drt_zone["geometry"]  # Already in correct CRS
 
             # Find intersections with the CURRENT (filtered) hexagonal grid
             mask = self.hex_grid.geometry.intersects(drt_geometry)
@@ -756,7 +731,7 @@ def _set_drt_zone_mappings(self, drt_config: dict):
             # Use positional indices (0-based sequential)
             affected_positions = np.where(mask)[0].tolist()
 
-            drt_zone['affected_hex_zones'] = affected_positions
+            drt_zone["affected_hex_zones"] = affected_positions
 
             # Validation check
             if affected_positions:
@@ -764,13 +739,13 @@ def _set_drt_zone_mappings(self, drt_config: dict):
                 if max_pos >= len(self.hex_grid):
                     logger.error("   ❌ ERROR: Position %d exceeds grid size %d", max_pos, len(self.hex_grid))
                     # Filter out invalid positions as safety net
-                    drt_zone['affected_hex_zones'] = [
-                        pos for pos in affected_positions
-                        if 0 <= pos < len(self.hex_grid)
+                    drt_zone["affected_hex_zones"] = [
+                        pos for pos in affected_positions if 0 <= pos < len(self.hex_grid)
                     ]
 
-            logger.debug("   Zone %s: affects %d hexagonal zones", drt_zone['zone_id'], len(drt_zone['affected_hex_zones']))
-
+            logger.debug(
+                "   Zone %s: affects %d hexagonal zones", drt_zone["zone_id"], len(drt_zone["affected_hex_zones"])
+            )
 
     def get_zone_statistics(
         self,
@@ -829,9 +804,7 @@ def visualize_zones_and_stops(self, figsize=(15, 10)):
         stops_geo = self.stops_gdf.to_crs("EPSG:4326")
         stops_geo.plot(ax=ax, color="red", markersize=1, alpha=0.7)
 
-        ax.set_title(
-            f"Transit System Zones: {len(self.hex_grid)} zones, {len(self.stops_gdf)} stops"
-        )
+        ax.set_title(f"Transit System Zones: {len(self.hex_grid)} zones, {len(self.stops_gdf)} stops")
         ax.set_xlabel("Longitude")
         ax.set_ylabel("Latitude")
 
@@ -864,7 +837,6 @@ def visualize_zones_and_stops(self, figsize=(15, 10)):
         plt.tight_layout()
         return fig, ax
 
-
     def _visualize_with_data(
         self,
         data_per_zone: np.ndarray,
@@ -941,7 +913,7 @@ def _visualize_with_data(
         """
         # Auto-detect DRT visualization if not specified
         if show_drt_zones is None:
-            show_drt_zones = optimization_data.get('drt_enabled', False)
+            show_drt_zones = optimization_data.get("drt_enabled", False)
 
         # Create zones with data
         zones_with_data = self.hex_grid.copy()
@@ -979,9 +951,7 @@ def _visualize_with_data(
                 },
             )
         else:
-            zones_geo.plot(
-                ax=ax, color="lightgray", alpha=0.5, edgecolor="black", linewidth=0.5
-            )
+            zones_geo.plot(ax=ax, color="lightgray", alpha=0.5, edgecolor="black", linewidth=0.5)
 
         # Add DRT zones (reuse existing logic from visualize_spatial_coverage)
         self._add_drt_zones_to_plot(ax, optimization_data, show_drt_zones)
@@ -993,7 +963,9 @@ def _visualize_with_data(
         # Add statistics text
         stats_text = self._create_data_stats_text(data_per_zone, data_label, optimization_data)
         ax.text(
-            0.02, 0.98, stats_text,
+            0.02,
+            0.98,
+            stats_text,
             transform=ax.transAxes,
             verticalalignment="top",
             bbox=dict(boxstyle="round", facecolor="white", alpha=0.8),
@@ -1013,37 +985,37 @@ def _add_drt_zones_to_plot(self, ax, optimization_data, show_drt_zones):
         """Add DRT zones to existing plot."""
         drt_legend_elements = []
 
-        if show_drt_zones and optimization_data.get('drt_enabled', False):
-            drt_zones = optimization_data.get('drt_config', {}).get('zones', [])
+        if show_drt_zones and optimization_data.get("drt_enabled", False):
+            drt_zones = optimization_data.get("drt_config", {}).get("zones", [])
 
             if drt_zones:
                 # Define colors for DRT zones
-                drt_colors = ['purple', 'cyan', 'green', 'orange', 'magenta', 'yellow']
+                drt_colors = ["purple", "cyan", "green", "orange", "magenta", "yellow"]
 
                 for i, drt_zone in enumerate(drt_zones):
-                    if 'geometry' in drt_zone:
+                    if "geometry" in drt_zone:
                         drt_gdf = gpd.GeoDataFrame(
-                            [{'zone_id': drt_zone['zone_id']}],
-                            geometry=[drt_zone['geometry']],
-                            crs=optimization_data['drt_config']['target_crs']
+                            [{"zone_id": drt_zone["zone_id"]}],
+                            geometry=[drt_zone["geometry"]],
+                            crs=optimization_data["drt_config"]["target_crs"],
                         )
                         drt_geo = drt_gdf.to_crs("EPSG:4326")
 
                         color = drt_colors[i % len(drt_colors)]
-                        drt_geo.plot(
-                            ax=ax,
-                            facecolor='none',
-                            edgecolor=color,
-                            linewidth=2.5,
-                            linestyle='--',
-                            alpha=0.8
-                        )
+                        drt_geo.plot(ax=ax, facecolor="none", edgecolor=color, linewidth=2.5, linestyle="--", alpha=0.8)
 
                         # Add to legend
                         from matplotlib.lines import Line2D
+
                         drt_legend_elements.append(
-                            Line2D([0], [0], color=color, linewidth=2.5, linestyle='--',
-                                label=f"DRT: {drt_zone.get('zone_name', drt_zone['zone_id'])}")
+                            Line2D(
+                                [0],
+                                [0],
+                                color=color,
+                                linewidth=2.5,
+                                linestyle="--",
+                                label=f"DRT: {drt_zone.get('zone_name', drt_zone['zone_id'])}",
+                            )
                         )
 
         # Add combined legend if we have DRT zones
@@ -1086,7 +1058,7 @@ def _create_data_stats_text(self, data_per_zone, data_label, optimization_data):
         ]
 
         # Add service type indicator
-        is_drt_enabled = optimization_data.get('drt_enabled', False)
+        is_drt_enabled = optimization_data.get("drt_enabled", False)
         if is_drt_enabled:
             stats.append("")
             stats.append("🚁 SERVICE TYPE: PT + DRT")
diff --git a/tests/test_gtfs.py b/tests/test_gtfs.py
index 48a2f53..d91ddd2 100644
--- a/tests/test_gtfs.py
+++ b/tests/test_gtfs.py
@@ -357,7 +357,7 @@ def test_extract_templates_structure(self, sample_optimization_data):
 
         # Get first direction template
         direction_id = list(interval_templates.keys())[0]
-        template = interval_templates[direction_id]
+        template = interval_templates[direction_id][0]
 
         required_keys = ["trip_id", "duration_minutes", "n_stops", "stop_times"]
         for key in required_keys:
@@ -383,14 +383,14 @@ def test_template_data_consistency(self, sample_optimization_data):
             for interval_label, interval_templates in route_templates.items():
                 for direction_id, template in interval_templates.items():
                     # Duration should be positive and reasonable
-                    assert template["duration_minutes"] > 0
-                    assert template["duration_minutes"] < 600  # Less than 10 hours
+                    assert template[0]["duration_minutes"] > 0
+                    assert template[0]["duration_minutes"] < 600  # Less than 10 hours
 
                     # Should have at least 2 stops
-                    assert template["n_stops"] >= 2
+                    assert template[0]["n_stops"] >= 2
 
                     # Stop times should be a DataFrame with required columns
-                    stop_times = template["stop_times"]
+                    stop_times = template[0]["stop_times"]
                     assert isinstance(stop_times, pd.DataFrame)
                     required_cols = ["stop_id", "stop_sequence"]
                     for col in required_cols:
@@ -465,9 +465,9 @@ def robust_test_data(sample_optimization_data, sample_solutions):
                 for direction_id, template in interval_templates.items():
                     # Only include templates with sufficient valid stop data
                     if (
-                        len(template["stop_times"]) >= 2
-                        and template["n_stops"] >= 2
-                        and template["duration_minutes"] > 0
+                        len(template[0]["stop_times"]) >= 2
+                        and template[0]["n_stops"] >= 2
+                        and template[0]["duration_minutes"] > 0
                     ):
                         valid_int_templates[direction_id] = template
 
@@ -754,8 +754,8 @@ def test_extract_templates_with_direction_id(self, sample_optimization_data):
                     # Keys should be integers (typically 0 or 1)
                     assert isinstance(dir_id, int)
                     # Template should preserve this info
-                    assert "direction_id" in template
-                    assert template["direction_id"] == dir_id
+                    assert "direction_id" in template[0]
+                    assert template[0]["direction_id"] == dir_id
 
     def test_extract_templates_without_direction_id(self, sample_optimization_data):
         """
@@ -806,7 +806,7 @@ def test_extract_templates_without_direction_id(self, sample_optimization_data):
                 # Verify structure
                 for dir_id, template in interval_templates.items():
                     assert isinstance(dir_id, int)
-                    assert template["direction_id"] == dir_id
+                    assert template[0]["direction_id"] == dir_id
 
     def test_gtfs_generation_preserves_direction(self, robust_test_data):
         """
@@ -824,163 +824,3 @@ def test_gtfs_generation_preserves_direction(self, robust_test_data):
         unique_dirs = trips_df["direction_id"].unique()
         for d in unique_dirs:
             assert isinstance(d, (int, np.integer))
-
-
-class TestHybridStrategy:
-    """Tests for the Hybrid Strategy (Dominant Filtering + Frequency Splitting)."""
-
-    @pytest.fixture
-    def mock_converter(self, sample_optimization_data):
-        """Fixture to provide a configured SolutionConverter with mocked GTFS feed."""
-        converter = SolutionConverter(sample_optimization_data)
-        # Mock the gtfs_feed object attributes we need
-        converter.gtfs_feed = MagicMock()
-        converter.gtfs_feed.trips = pd.DataFrame()
-        converter.gtfs_feed.stop_times = pd.DataFrame()
-
-        # Override route_ids to focus on our test route
-        converter.route_ids = ["test_route"]
-        return converter
-
-    def test_dominant_filtering(self, mock_converter):
-        """
-        Test Strategy A: If top 2 headsigns cover > 90% of trips,
-        filter to only those 2 and do NOT split frequency.
-        """
-        route_id = "test_route"
-
-        # Setup Data: 100 trips total
-        # 60 'A', 35 'B' -> 95/100 coverage (95%)
-        # 5 'C' -> Noise
-        trips_data = {
-            "route_id": [route_id] * 100,
-            "trip_id": [f"t_{i}" for i in range(100)],
-            "trip_headsign": ["A"] * 60 + ["B"] * 35 + ["C"] * 5,
-            # No direction_id to force inference
-        }
-        mock_converter.gtfs_feed.trips = pd.DataFrame(trips_data)
-
-        # Create Dummy Stop Times (minimal valid data)
-        # All trips at 10:00 AM (36000 seconds)
-        stops = []
-        for i, t_id in enumerate(trips_data["trip_id"]):
-            stops.append(
-                {
-                    "trip_id": t_id,
-                    "stop_id": "s1",
-                    "stop_sequence": 1,
-                    "arrival_seconds": 36000,
-                    "departure_seconds": 36000,
-                }
-            )
-            stops.append(
-                {
-                    "trip_id": t_id,
-                    "stop_id": "s2",
-                    "stop_sequence": 2,
-                    "arrival_seconds": 37000,
-                    "departure_seconds": 37000,
-                }
-            )
-        mock_converter.gtfs_feed.stop_times = pd.DataFrame(stops)
-
-        # Run Extraction
-        templates = mock_converter.extract_route_templates()
-
-        # Assertions
-        assert route_id in templates
-        route_templates = templates[route_id]
-
-        # Find interval covering 10:00 AM
-        valid_interval = None
-        for i, label in enumerate(mock_converter.interval_labels):
-            start, end = mock_converter.interval_hours[i]
-            if start <= 10 < end:
-                valid_interval = label
-                break
-
-        assert valid_interval in route_templates, "Should have extracted templates for 10:00 AM interval"
-        interval_temps = route_templates[valid_interval]
-
-        # Should have filtered out 'C', leaving only 2 directions (A and B)
-        assert len(interval_temps) == 2, f"Expected 2 dominant directions, found {len(interval_temps)}"
-
-        # Check splitting factor is 2.0 (since we have 2 directions)
-        # The new logic dictates that we always split frequency by N directions
-        # to ensure aggregate service matches the optimized headway.
-        for t in interval_temps.values():
-            sf = t.get("splitting_factor", 1.0)
-            assert sf == 2.0, f"Splitting factor should be 2.0 for dominant routes (2 directions), got {sf}"
-
-    def test_frequency_splitting(self, mock_converter):
-        """
-        Test Strategy C: If top 2 headsigns cover <= 90% of trips,
-        keep ALL headsigns and Set splitting_factor = N_headsigns.
-        """
-        route_id = "test_route"
-
-        # Setup Data: 100 trips total
-        # 4 Headsigns, 25 each -> Top 2 = 50% coverage (< 90%)
-        headsigns = ["A", "B", "C", "D"]
-        trip_ids = [f"t_{i}" for i in range(100)]
-        trip_headsigns = np.repeat(headsigns, 25)
-
-        trips_data = {
-            "route_id": [route_id] * 100,
-            "trip_id": trip_ids,
-            "trip_headsign": trip_headsigns,
-        }
-        mock_converter.gtfs_feed.trips = pd.DataFrame(trips_data)
-
-        # Create Dummy Stop Times
-        stops = []
-        for i, t_id in enumerate(trip_ids):
-            stops.append(
-                {
-                    "trip_id": t_id,
-                    "stop_id": "s1",
-                    "stop_sequence": 1,
-                    "arrival_seconds": 36000,
-                    "departure_seconds": 36000,
-                }
-            )
-            stops.append(
-                {
-                    "trip_id": t_id,
-                    "stop_id": "s2",
-                    "stop_sequence": 2,
-                    "arrival_seconds": 37000,
-                    "departure_seconds": 37000,
-                }
-            )
-        mock_converter.gtfs_feed.stop_times = pd.DataFrame(stops)
-
-        # Run Extraction
-        templates = mock_converter.extract_route_templates()
-
-        # Assertions
-        assert route_id in templates
-        route_templates = templates[route_id]
-
-        # Find interval covering 10:00 AM
-        valid_interval = None
-        for i, label in enumerate(mock_converter.interval_labels):
-            start, end = mock_converter.interval_hours[i]
-            if start <= 10 < end:
-                valid_interval = label
-                break
-
-        assert valid_interval in route_templates, "Should have extracted templates for 10:00 AM interval"
-        interval_temps = route_templates[valid_interval]
-
-        # Should have kept all 4 directions (A, B, C, D)
-        assert len(interval_temps) == 4, f"Expected 4 directions for messy route, found {len(interval_temps)}"
-
-        # Check splitting factor is 4.0
-        for t in interval_temps.values():
-            sf = t.get("splitting_factor", 1.0)
-            assert sf == 4.0, f"Splitting factor should be 4.0, got {sf}"
-            sf = t.get("splitting_factor", 1.0)
-            assert sf == 4.0, f"Splitting factor should be 4.0, got {sf}"
-            sf = t.get("splitting_factor", 1.0)
-            assert sf == 4.0, f"Splitting factor should be 4.0, got {sf}"