diff --git a/IMPLEMENTATION_PLAN.md b/IMPLEMENTATION_PLAN.md
index 2eb4771..b66a5fc 100644
--- a/IMPLEMENTATION_PLAN.md
+++ b/IMPLEMENTATION_PLAN.md
@@ -1,673 +1,260 @@
-# Implementation Plan — Reflex → Dash Migration
+# Implementation Plan — Dashboard Visualization Improvements
 
 ## Project Overview
 
-Migrate the Reflex web application to Dash (Plotly) + Dash Mantine Components. The backend (`src/`) is untouched — only the frontend changes.
+Comprehensive review and improvement of all Plotly charts in the Dash dashboard. Four tiers: bug fixes, visual polish, new analytics from existing data, and new analytics requiring backend work.
+
+**Primary file**: `src/visualization/plotly_generator.py`
+**Palette policy**: Broader than NHS brand (maximally-distinct colors for trust comparisons)
+**Constraint**: `python run_dash.py` must work after every task
 
 ### What Changes
-- `pathways_app/` (Reflex) → `dash_app/` (Dash + DMC)
-- `run_dash.py` entry point replaces `reflex run`
-- CSS extracted from `01_nhs_classic.html` → `dash_app/assets/nhs.css`
-- Drug/Directory/Indication filters consolidated into a right-side `dmc.Drawer`
+- `src/visualization/plotly_generator.py` — shared styling constants, bug fixes, new chart functions
+- `src/data_processing/pathway_queries.py` — new query functions for Tier 3 analytics
+- `dash_app/data/queries.py` — thin wrappers for new queries
+- `dash_app/callbacks/chart.py` — heatmap metric toggle, new tab support
+- `dash_app/callbacks/trust_comparison.py` — trust color palette, heatmap metric toggle
+- `dash_app/components/chart_card.py` — new tab definitions, metric toggle component
+- `dash_app/components/trust_comparison.py` — metric toggle component
 
-### What Stays (DO NOT MODIFY pipeline/analysis logic)
-- `data_processing/pathway_pipeline.py`, `transforms.py`, `diagnosis_lookup.py` (matching logic)
-- `analysis/pathway_analyzer.py`, `statistics.py`
-- `cli/refresh_pathways.py`
-- `data_processing/schema.py`, `reference_data.py`, `cache.py`, `data_source.py`
-- SQLite schema and `pathway_nodes` table
-- `data/` reference files (CSVs, pathways.db)
-
-### What CAN be edited in `src/` (shared utilities)
-- `visualization/plotly_generator.py` — add/refactor a function to accept list-of-dicts (what Dash produces) instead of only DataFrames
-- `data_processing/database.py` — add shared query functions for pathway node loading so both Reflex and Dash use the same queries
-- `core/config.py` — if path resolution needs adjusting
-
-### Dash App Structure
-```
-dash_app/
-├── __init__.py
-├── app.py                    # Entry point, layout root, dcc.Store components
-├── assets/
-│   └── nhs.css               # Extracted from 01_nhs_classic.html
-├── data/
-│   ├── queries.py             # SQLite queries (extracted from Reflex AppState)
-│   └── card_browser.py        # DimSearchTerm.csv → directorate tree
-├── components/
-│   ├── header.py              # Top header bar
-│   ├── sidebar.py             # Left navigation
-│   ├── kpi_row.py             # 4 KPI cards
-│   ├── filter_bar.py          # Chart type toggle + date dropdowns
-│   ├── chart_card.py          # Chart area with tabs + dcc.Graph
-│   ├── drawer.py              # dmc.Drawer with card browser
-│   └── footer.py              # Page footer
-├── callbacks/
-│   ├── __init__.py            # register_callbacks(app)
-│   ├── filters.py             # Date/chart-type → app-state store
-│   ├── chart.py               # chart-data → go.Icicle figure
-│   ├── drawer.py              # Drawer open/close + drug selection
-│   └── kpi.py                 # chart-data → KPI card values
-└── utils/
-    └── formatting.py          # Cost/patient display formatters
-```
-
-### State Management (3 dcc.Store components)
-- **app-state** (session): `chart_type`, `initiated`, `last_seen`, `selected_drugs`, `selected_directorates`, `date_filter_id`
-- **chart-data** (memory): `nodes[]`, `unique_patients`, `total_drugs`, `total_cost`
-- **reference-data** (session): `available_drugs`, `directorate_tree` (loaded once)
-
-### Callback Chain
-```
-Page Load → load_reference_data → reference-data store
-         → load_pathway_data → chart-data store
-                              ├→ update_kpis → KPI cards
-                              └→ update_chart → dcc.Graph
-
-Filter change → update_app_state → app-state store → load_pathway_data → (chain above)
-
-Drawer selection → update_drug_selection → app-state store → load_pathway_data → (chain above)
-```
-
-### Directorate Card Browser (dmc.Drawer)
-- Position: right, ~480px wide
-- **Top card**: "All Drugs" — flat list from `pathway_nodes` level 3. Pick one drug → see it across all directorates/indications.
-- **Below**: Cards per PrimaryDirectorate (from DimSearchTerm.csv). Each has `dmc.Accordion` with indication items → drug chips inside.
-- **Clear Filters** button resets all selections.
-- Data model: `DimSearchTerm.csv` grouped by PrimaryDirectorate → Search_Term → CleanedDrugName
+### What Stays (DO NOT MODIFY)
+- Pipeline/analysis logic: `pathway_pipeline.py`, `transforms.py`, `diagnosis_lookup.py`, `pathway_analyzer.py`
+- Database schema and `pathway_nodes` table
+- CLI refresh command
+- Existing callback chain architecture (app-state → chart-data → UI)
+- Two-view architecture (Patient Pathways + Trust Comparison)
 
 ---
 
-## Phase 0: Project Scaffolding
+## Phase A: Core Fixes + Shared Constants
 
-### 0.1 Create dash_app/ skeleton + update pyproject.toml
-- [x] Create `dash_app/` directory with `__init__.py`, `app.py`, subdirectories (`assets/`, `data/`, `components/`, `callbacks/`, `utils/`)
-- [x] Create `run_dash.py` at project root (simple `from dash_app.app import app; app.run(debug=True, port=8050)`)
-- [x] Update `pyproject.toml`: add `dash>=2.14.0`, `dash-mantine-components>=0.14.0` to dependencies (keep `reflex` temporarily)
-- [x] Create minimal `app.py` with `dash.Dash(__name__)`, DMC provider wrapper, and "Hello Dash" placeholder layout
-- **Checkpoint**: `python run_dash.py` starts, shows "Hello Dash" at localhost:8050 ✓
+### A.1 Extract shared styling constants + `_base_layout()` helper
+- [ ] Add module-level constants to top of `src/visualization/plotly_generator.py`:
+  ```python
+  CHART_FONT_FAMILY = "Source Sans 3, system-ui, sans-serif"
+  CHART_TITLE_SIZE = 18
+  CHART_TITLE_COLOR = "#1E293B"
+  GRID_COLOR = "#E2E8F0"
+  ANNOTATION_COLOR = "#768692"
 
-### 0.2 Extract CSS from 01_nhs_classic.html into dash_app/assets/nhs.css
-- [x] Copy the `<style>` block from `01_nhs_classic.html` (lines 8-314) into `dash_app/assets/nhs.css`
-- [x] Add Google Fonts `@import` for Source Sans 3 at top of CSS file
-- [x] Remove the mock icicle chart CSS (`.icicle`, `.icicle__row`, `.icicle__cell`, `.lvl-*` classes) — Plotly handles the real chart
-- [x] Verify CSS loads by checking browser dev tools when app starts
-- **Checkpoint**: `python run_dash.py` loads CSS (check font renders as Source Sans 3) ✓
+  TRUST_PALETTE = [
+      "#005EB8", "#DA291C", "#009639", "#ED8B00",
+      "#7C2855", "#00A499", "#330072",
+  ]
+
+  DRUG_PALETTE = [
+      "#005EB8", "#DA291C", "#009639", "#ED8B00", "#7C2855",
+      "#00A499", "#330072", "#E06666", "#6FA8DC", "#93C47D",
+      "#F6B26B", "#8E7CC3", "#C27BA0", "#76A5AF", "#FFD966",
+  ]
+  ```
+- [ ] Create `_base_layout(title, **overrides)` helper returning a dict with shared layout properties (title font, hoverlabel, paper/plot bgcolor, autosize, font family)
+- [ ] Apply `_base_layout()` to `create_icicle_from_nodes()` as a proof-of-concept (keep all existing behavior, just DRY the layout dict)
+- **Checkpoint**: `python run_dash.py` starts, icicle chart unchanged visually
+
+### A.2 Fix heatmap colorscale + cell annotations (Patient Pathways)
+- [ ] In `create_heatmap_figure()` (~L1189):
+  1. Replace non-linear colorscale with linear 5-stop: `[0.0 #E3F2FD, 0.25 #90CAF9, 0.5 #42A5F5, 0.75 #1E88E5, 1.0 #003087]`
+  2. Add `text=text_values, texttemplate="%{text}"` with formatted values per metric (patients: `"N"`, cost: `"£Nk"`, cost_pp_pa: `"£N"`)
+  3. Set `zmin=0` explicitly
+  4. Remove explicit `width`, use `autosize=True`
+  5. Replace `l=200` with `l=8` + `yaxis automargin=True`
+  6. Add subtitle annotation when 25-drug cap is hit: `"Showing top 25 of N drugs"`
+  7. Reduce `xgap/ygap` from 2→1 when >15 columns
+- [ ] Apply same fixes to `create_trust_heatmap_figure()` (~L1582)
+- [ ] Apply `_base_layout()` to both heatmap functions
+- **Checkpoint**: Heatmaps show linear color gradient, cell text visible, no fixed width overflow
+
+### A.3 Fix legend overflow in 4 charts
+- [ ] Create `_smart_legend(n_items)` helper that returns legend dict:
+  - When >15 items: vertical legend on right (`orientation="v", x=1.02, y=1, xanchor="left"`) with dynamic right margin
+  - When ≤15: horizontal legend with dynamic bottom margin based on estimated row count
+- [ ] Apply to `create_market_share_figure()` (~L350)
+- [ ] Apply to `create_trust_market_share_figure()` (~L1564)
+- [ ] Apply to `create_dosing_figure()` (~L913)
+- [ ] Apply to `create_trust_duration_figure()` (~L1771)
+- [ ] Apply `_base_layout()` to all 4 functions
+- **Checkpoint**: Legends don't overlap chart content with 42 drugs or 7 trusts
+
+### A.4 Fix trust comparison color differentiation
+- [ ] In `create_trust_duration_figure()`: replace `nhs_colours` list with `TRUST_PALETTE`
+- [ ] Add `is_trust_comparison=False` param to `create_cost_waterfall_figure()` — use `TRUST_PALETTE` when True
+- [ ] Update `tc_cost_waterfall` callback in `dash_app/callbacks/trust_comparison.py` (~L165) to pass `is_trust_comparison=True`
+- [ ] Fix `_dosing_by_drug()` blue→blue interpolation: replace with `plotly.colors.sample_colorscale("Viridis", ...)` for meaningful gradient
+- [ ] Replace `nhs_colours` in `create_trust_market_share_figure()` with `DRUG_PALETTE` for drug traces
+- [ ] Apply `_base_layout()` to all affected functions
+- **Checkpoint**: Trust Comparison charts have 7 visually distinct trust colors; dosing has meaningful gradient
 
 ---
 
-## Phase 1: Data Access Layer
+## Phase B: Visual Polish
 
-### 1.1 Create shared data access functions
-- [x] Add query functions to `src/data_processing/pathway_queries.py`:
-  - `load_initial_data(db_path) -> dict` — extracted from `AppState.load_data()` (pathways_app.py lines 407-488): returns `{"available_drugs": [...], "available_directorates": [...], "available_indications": [...], "total_records": int, "last_updated": str}`
-  - `load_pathway_nodes(db_path, filter_id, chart_type, selected_drugs=None, selected_directorates=None) -> dict` — extracted from `AppState.load_pathway_data()` (lines 490-642): returns `{"nodes": [...], "unique_patients": int, "total_drugs": int, "total_cost": float, "last_updated": str}`
-  - These are plain Python functions that accept `db_path` as a parameter (no Reflex state objects)
-- [x] Create thin `dash_app/data/queries.py` that imports and calls the shared functions with the correct `db_path`
-- [x] Return plain dicts/lists — JSON-serializable for dcc.Store
-- **Checkpoint**: `python -c "from dash_app.data.queries import load_initial_data; print(load_initial_data())"` returns valid data
+### B.1 Fix title inconsistencies across all charts
+- [ ] Sankey (~L817): title color `"#003087"` → `CHART_TITLE_COLOR`
+- [ ] Dosing (~L885): title color `"#003087"` → `CHART_TITLE_COLOR`
+- [ ] Patient Pathways heatmap (~L1300): title color `"#003087"` → `CHART_TITLE_COLOR`
+- [ ] Duration (~L1449): title color `"#003087"` → `CHART_TITLE_COLOR`
+- [ ] All Trust Comparison functions: title `size=16` → `CHART_TITLE_SIZE` (18)
+- [ ] Apply `_base_layout()` to all remaining chart functions not yet converted
+- **Checkpoint**: All chart titles use consistent font, size, and color
 
-### 1.2 Build directorate card tree from DimSearchTerm.csv
-- [x] Create `dash_app/data/card_browser.py` with:
-  - `build_directorate_tree()` → dict structured as `{PrimaryDirectorate: {Search_Term: [drug_fragment, ...]}}`
-  - Loads `data/DimSearchTerm.csv`, groups by PrimaryDirectorate → Search_Term → split CleanedDrugName by pipe
-  - Applies SEARCH_TERM_MERGE_MAP from `data_processing.diagnosis_lookup` (merge asthma variants)
-  - `get_all_drugs()` → sorted flat list of all unique drug labels from `pathway_nodes` level 3
-- **Checkpoint**: `python -c "from dash_app.data.card_browser import build_directorate_tree; import json; print(json.dumps(build_directorate_tree(), indent=2))"` returns valid tree ✓
+### B.2 Cost effectiveness smooth gradient
+- [ ] In `create_cost_effectiveness_figure()` (~L428-435):
+  - Replace 3-bin hard threshold (green/amber/red) with smooth RGB interpolation
+  - Green (#009639) → Amber (#ED8B00) for ratio 0–0.5
+  - Amber (#ED8B00) → Red (#DA291C) for ratio 0.5–1.0
+- [ ] Apply `_base_layout()` to the function
+- **Checkpoint**: Lollipop dots show smooth green→amber→red gradient
+
+### B.3 Sankey narrow-screen fix
+- [ ] In `create_sankey_figure()` (~L788):
+  - Change `arrangement="snap"` → `arrangement="freeform"`
+  - Increase `pad` from 20 → 25
+- **Checkpoint**: Sankey nodes don't overlap on narrow viewports
+
+### B.4 Heatmap metric toggle (both views)
+- [ ] Add `dmc.SegmentedControl` component next to Patient Pathways heatmap:
+  - Options: Patients, Cost, Cost p.a.
+  - ID: `heatmap-metric-toggle`
+  - Add to `dash_app/components/chart_card.py` (visible only when heatmap tab active)
+- [ ] Add `dmc.SegmentedControl` next to Trust Comparison heatmap:
+  - ID: `tc-heatmap-metric-toggle`
+  - Add to `dash_app/components/trust_comparison.py`
+- [ ] Update `_render_heatmap()` in `dash_app/callbacks/chart.py` (~L239) to read metric toggle value
+- [ ] Update `tc_heatmap` callback in `dash_app/callbacks/trust_comparison.py` (~L214) to read metric toggle value
+- **Checkpoint**: Heatmap metric toggles work in both views, switching between patients/cost/cost_pp_pa
 
 ---
 
-## Phase 2: Static Layout
+## Phase C: New Analytics (Existing Data)
 
-### 2.1 Header + sidebar components
-- [x] Create `dash_app/components/header.py` — `make_header()` function returning Dash HTML component
-  - NHS logo, title "HCD Analysis", breadcrumb, data freshness indicator (status dot + record count + last updated)
-  - Use CSS classes from `nhs.css`: `.top-header`, `.top-header__brand`, `.top-header__logo`, `.top-header__title`, etc.
-  - Record count and last updated are `html.Span` with IDs for callback updates: `id="header-record-count"`, `id="header-last-updated"`
-- [x] Create `dash_app/components/sidebar.py` — `make_sidebar()` function
-  - Navigation items matching 01_nhs_classic.html sidebar (Pathway Overview active, Drug Selection, Trust Selection, Directory Selection, Indications, Cost Analysis, Export Data)
-  - SVG icons via data URI img elements (Dash doesn't support inline SVGs natively)
-  - "Drug Selection" (`id="sidebar-drug-selection"`) and "Indications" (`id="sidebar-indications"`) items have IDs for drawer callbacks (Phase 4)
-  - Footer: "NHS Norfolk & Waveney ICB / High Cost Drugs Programme"
-- **Checkpoint**: Components render in browser with correct NHS styling ✓
+### C.1 Retention funnel chart
+- [ ] Create `get_retention_funnel()` in `src/data_processing/pathway_queries.py`:
+  - Query level 4+ nodes, aggregate patient counts by treatment line depth
+  - Return: `[{depth: 1, label: "1 drug", patients: N, pct: 100}, {depth: 2, ...}, ...]`
+- [ ] Add thin wrapper in `dash_app/data/queries.py`
+- [ ] Create `create_retention_funnel_figure(data, title)` in `src/visualization/plotly_generator.py`:
+  - Use `go.Funnel` with NHS blue gradient
+  - Show absolute patient count + percentage retained
+- [ ] Add "Funnel" tab to `TAB_DEFINITIONS` in `chart_card.py`
+- [ ] Add `_render_funnel()` helper and tab dispatch in `dash_app/callbacks/chart.py`
+- **Checkpoint**: Funnel tab shows retention by treatment line depth, responds to filters
 
-### 2.2 Main content area: KPI row + filter bar + chart card
-- [x] Create `dash_app/components/kpi_row.py` — `make_kpi_row()` function
-  - 4 KPI cards: Unique Patients, Drug Types, Total Cost, Indication Match Rate
-  - Each card value has an ID for callback updates: `id="kpi-patients"`, `id="kpi-drugs"`, `id="kpi-cost"`, `id="kpi-match"`
-  - CSS classes: `.kpi-row`, `.kpi-card`, `.kpi-card__label`, `.kpi-card__value`, `.kpi-card__sub`
-- [x] Create `dash_app/components/filter_bar.py` — `make_filter_bar()` function
-  - Chart type toggle pills ("By Directory" / "By Indication") — use `html.Button` with `.toggle-pill` CSS
-  - Initiated dropdown: All years, Last 2 years, Last 1 year — use `dcc.Dropdown` or `html.Select` with `.filter-select`
-  - Last seen dropdown: Last 6 months, Last 12 months
-  - NO drug/directorate dropdowns here (those are in the drawer)
-  - Component IDs: `id="chart-type-directory"`, `id="chart-type-indication"`, `id="filter-initiated"`, `id="filter-last-seen"`
-- [x] Create `dash_app/components/chart_card.py` — `make_chart_card()` function
-  - Card header with title + dynamic subtitle (hierarchy label: "Trust → Directorate → Drug → Pathway")
-  - Tab row: Icicle (active), Sankey (disabled placeholder), Timeline (disabled placeholder)
-  - `dcc.Graph(id="pathway-chart")` filling the card body
-  - CSS classes: `.chart-card`, `.chart-card__header`, `.chart-card__tabs`, `.chart-tab`
-- **Checkpoint**: All three components render with correct layout and styling
+### C.2 Pathway depth distribution chart
+- [ ] Create `get_pathway_depth_distribution()` in `src/data_processing/pathway_queries.py`:
+  - Aggregate patient counts at level 3 (1-drug), level 4 (2-drug), etc.
+  - Subtract child counts to get patients who STOPPED at each depth
+  - Return: `[{depth: 1, label: "1 drug only", patients: N}, ...]`
+- [ ] Add thin wrapper in `dash_app/data/queries.py`
+- [ ] Create `create_pathway_depth_figure(data, title)` in `src/visualization/plotly_generator.py`:
+  - Horizontal bar chart with NHS blue gradient by depth
+- [ ] Add "Depth" tab to `TAB_DEFINITIONS` in `chart_card.py`
+- [ ] Add `_render_depth()` helper and tab dispatch in `dash_app/callbacks/chart.py`
+- **Checkpoint**: Depth tab shows patient distribution by treatment line count
 
-### 2.3 Footer + full page assembly
-- [x] Create `dash_app/components/footer.py` — `make_footer()` function
-  - CSS class `.page-footer`, same text as 01_nhs_classic.html
-- [x] Update `dash_app/app.py` to assemble full page layout:
-  - `dmc.MantineProvider(children=[header, sidebar, main_content])`
-  - Main content: KPI row → filter bar → chart card → footer
-  - Add 3 `dcc.Store` components: `id="app-state"`, `id="chart-data"`, `id="reference-data"`
-  - Wrap main content in `html.Main(className="main")`
-- **Checkpoint**: Full page renders at localhost:8050, layout matches 01_nhs_classic.html visually
+### C.3 Duration vs Cost scatter plot
+- [ ] Create `get_duration_cost_scatter()` in `src/data_processing/pathway_queries.py`:
+  - Query level 3 nodes for drug-level data
+  - Return: `[{drug, directory, avg_days, cost_pp_pa, patients}, ...]`
+- [ ] Add thin wrapper in `dash_app/data/queries.py`
+- [ ] Create `create_duration_cost_scatter_figure(data, title)` in `src/visualization/plotly_generator.py`:
+  - Scatter: x=avg_days, y=cost_pp_pa, size=patients, color=directory
+  - Add quadrant lines at median values (4 quadrants: cheap/short, cheap/long, expensive/short, expensive/long)
+  - Hover shows drug name, directory, all values
+- [ ] Add "Scatter" tab to `TAB_DEFINITIONS` in `chart_card.py`
+- [ ] Add `_render_scatter()` helper and tab dispatch in `dash_app/callbacks/chart.py`
+- **Checkpoint**: Scatter tab shows drugs by duration vs cost with directorate coloring
+
+### C.4 Drug switching network graph
+- [ ] Create modified variant of `get_drug_transitions()` in pathway_queries.py that returns undirected edges without ordinal suffixes:
+  - `get_drug_network(db_path, filter_id, chart_type, directory, trust)` → `{nodes: [{name, total_patients}], edges: [{source, target, patients}]}`
+- [ ] Add thin wrapper in `dash_app/data/queries.py`
+- [ ] Create `create_drug_network_figure(data, title)` in `src/visualization/plotly_generator.py`:
+  - Use `go.Scatter` for nodes (circular layout) + edges (lines)
+  - Node size = total patients, edge width = switching flow
+  - `DRUG_PALETTE` for node colors
+- [ ] Add as sub-toggle within Sankey tab (e.g., "Flow" vs "Network" toggle) or as separate "Network" tab
+- **Checkpoint**: Network view shows drug switching as a graph alternative to Sankey
 
 ---
 
-## Phase 3: Core Callbacks
+## Phase D: New Analytics (Backend Work)
 
-### 3.1 Reference data loading + filter state management
-- [x] Create `dash_app/callbacks/filters.py`:
-  - `load_reference_data` callback: fires on page load, calls `queries.load_initial_data()`, populates `reference-data` store + header indicators
-  - `update_app_state` callback: fires when chart-type toggle or date dropdowns change, computes `date_filter_id` (e.g., `"all_6mo"`), updates `app-state` store
-  - Chart type toggle: use `callback_context` to determine which button was clicked, set active class via `className`
-- [x] Create `dash_app/callbacks/__init__.py` with `register_callbacks(app)` that imports and registers all callback modules
-- [x] Wire `register_callbacks(app)` in `app.py`
-- **Checkpoint**: Page loads reference data, filter dropdowns update app-state store (verify via browser dev tools → dcc.Store)
+### D.1 Temporal trend analysis
+- [ ] Design `pathway_trends` table schema in `src/data_processing/schema.py`:
+  - Columns: `snapshot_date, chart_type, directory, drug, patients, cost, cost_pp_pa`
+  - Stores quarterly aggregates from each refresh
+- [ ] Add migration for `pathway_trends` table in `data_processing/reference_data.py`
+- [ ] Extend `cli/refresh_pathways.py` to compute and insert trend data after main refresh
+- [ ] Create `get_trend_data()` query in `pathway_queries.py`
+- [ ] Add thin wrapper in `dash_app/data/queries.py`
+- [ ] Create `create_trend_figure(data, title, metric)` in plotly_generator.py:
+  - Line chart: x=date, y=metric, one line per drug (or directory)
+  - Metric selector: patients / cost / cost_pp_pa
+- [ ] Add "Trends" tab to `TAB_DEFINITIONS` in `chart_card.py`
+- [ ] Add callback wiring
+- **Checkpoint**: Trends tab shows drug usage over time (requires at least 2 refresh cycles for meaningful data)
 
-### 3.2 Pathway data loading callback
-- [x] Create `dash_app/callbacks/chart.py` (or add to filters.py):
-  - `load_pathway_data` callback: Input=`app-state` store, Output=`chart-data` store
-  - Calls `queries.load_pathway_data(filter_id, chart_type, selected_drugs, selected_directorates)`
-  - Runs on page load AND whenever `app-state` changes
-- **Checkpoint**: Changing date filter updates chart-data store with new pathway nodes ✓
+### D.2 Average administered doses analysis
+- [ ] Create `parse_average_administered(json_str)` parsing function in `src/data_processing/parsing.py`:
+  - Extract dose count arrays from the JSON `average_administered` column
+- [ ] Create `get_dosing_distribution()` query in `pathway_queries.py`:
+  - Level 3 nodes with parsed `average_administered` JSON
+- [ ] Create `create_dosing_distribution_figure(data, title)` in plotly_generator.py:
+  - Box/violin plot showing dose count distribution per drug
+- [ ] Add as sub-option within Dosing tab or as separate tab
+- **Checkpoint**: Dose distribution visible as box/violin plots
 
-### 3.3 KPI update callback
-- [x] Create `dash_app/callbacks/kpi.py`:
-  - `update_kpis` callback: Input=`chart-data` store, Output=KPI card values (4 outputs)
-  - Extracts `unique_patients`, `total_drugs`, `total_cost` from chart-data
-  - Formats numbers: patients with commas, cost as "£XXX.XM", drugs as plain number
-- **Checkpoint**: KPIs update when date filters change
+### D.3 Drug timeline (Gantt chart)
+- [ ] Create `get_drug_timeline()` query in `pathway_queries.py`:
+  - Level 3 nodes with `first_seen`, `last_seen`, `labels`, `value` per drug × directory
+- [ ] Create `create_drug_timeline_figure(data, title)` in plotly_generator.py:
+  - Gantt-style using `go.Bar` (horizontal bars from first_seen to last_seen)
+  - Grouped by directory, colored by patient count
+- [ ] Add "Timeline" tab to `TAB_DEFINITIONS` in `chart_card.py`
+- [ ] Add callback wiring
+- **Checkpoint**: Timeline tab shows when each drug cohort was active
 
-### 3.4 Icicle chart rendering callback
-- [x] Add a `create_icicle_from_nodes(nodes: list[dict], title: str) -> go.Figure` function to `src/visualization/plotly_generator.py`:
-  - Accepts list-of-dicts (the format stored in `chart-data` dcc.Store / returned by `load_pathway_data`)
-  - Same 10-field customdata, colorscale, texttemplate, hovertemplate as the existing Reflex `icicle_figure` (pathways_app.py lines 769-920)
-  - The existing `create_icicle_figure(ice_df)` stays untouched — the new function is an additional entry point for dict-based data
-  - Use the NHS blue gradient colorscale from the Reflex version: `[[0.0, "#003087"], [0.25, "#0066CC"], ...]`
-- [x] Add to `dash_app/callbacks/chart.py`:
-  - `update_chart` callback: Input=`chart-data` store, Output=`pathway-chart` figure
-  - Calls `create_icicle_from_nodes(chart_data["nodes"], title)` from the shared visualization module
-  - Dynamic title based on chart type and filters
-- **Checkpoint**: Real icicle chart renders with SQLite data, filters change the chart, hover shows full statistics
-
----
-
-## Phase 4: Directorate Card Browser
-
-### 4.1 dmc.Drawer layout
-- [x] Create `dash_app/components/drawer.py` — `make_drawer()` function:
-  - `dmc.Drawer(id="drug-drawer", position="right", size="480px")`
-  - **Top section**: "All Drugs" card — flat alphabetical list of all drug names from pathway_nodes level 3
-    - Each drug as a `dmc.Chip` or clickable badge, ID pattern: `{"type": "drug-chip", "index": drug_name}`
-  - **Below**: One `dmc.Card` per PrimaryDirectorate from DimSearchTerm.csv
-    - Card title = PrimaryDirectorate name
-    - Inside: `dmc.Accordion` with one item per Search_Term (indication)
-    - Inside each accordion item: drug fragment chips
-  - **Bottom**: `dmc.Button("Clear Filters", id="clear-drug-filters")` — full width
-- **Checkpoint**: Drawer opens with correct layout, all directorates and drugs visible
-
-### 4.2 Drawer callbacks
-- [x] Create `dash_app/callbacks/drawer.py`:
-  - Open/close drawer: sidebar "Drug Selection" or "Indications" click → open drawer
-  - Drug selection: ChipGroup value change → app-state.selected_drugs via update_app_state
-  - Drug fragment click: pattern-matching badge clicks → substring match → update chip selection
-  - Clear filters: resets chip selection → app-state.selected_drugs empties
-  - Fragment matching uses `drug.upper() in fragment.upper()` for substring match
-  - Toggle behavior: clicking already-selected fragment deselects matching drugs
-- **Checkpoint**: Select drug from drawer → chart filters to show that drug → clear resets
-
----
-
-## Phase 5: Polish & Cleanup
-
-### 5.1 Trust selection
-- [x] Add trust selection either:
-  - In the dmc.Drawer as a "Trusts" section (preferred — keeps all filters in one place), OR
-  - As sidebar checkboxes
-- [x] Wire trust selection to `selected_trusts` in `app-state` → pathway data reload
-- **Checkpoint**: Selecting trusts filters the chart correctly
-
-### 5.2 Loading/error/empty states + dynamic hierarchy label
-- [x] Add `dcc.Loading` wrapper around chart area
-- [x] Show "No data" message when chart-data is empty
-- [x] Show error feedback when database query fails
-- [x] Dynamic chart subtitle: "Trust → Directorate → Drug → Pathway" or "Trust → Indication → Drug → Pathway" based on chart type (done in Task 3.4)
-- **Checkpoint**: Loading spinner appears during data fetch, empty state shows message
-
-### 5.3 Data freshness indicator
-- [x] Header shows: green dot + "{N} patients" + "Last updated: {relative_time}"
-- [x] Pull from `pathway_refresh_log` via `queries.load_initial_data()` (uses total_patients from root node as fallback when source_row_count is 0)
-- [x] Format as relative time (e.g., "2h ago", "yesterday")
-- **Checkpoint**: Header shows correct data freshness
-
-### 5.4 Remove Reflex + final validation
-- [x] Remove `reflex` from `pyproject.toml` dependencies
-- [x] Delete or archive `pathways_app/` directory (move to `archive/`)
-- [x] Delete `pathways_app/styles.py` and any Reflex-specific files
-- [x] Update project `CLAUDE.md` to document Dash app structure, new run command, callback architecture
-- [x] Verify: `python run_dash.py` starts cleanly, full end-to-end workflow works
-- [x] Verify: No Reflex imports anywhere in `dash_app/`
-- **Checkpoint**: Full application works, no Reflex remnants, CLAUDE.md updated
-
-
-
-## Phase 6: Update all documentation
-- [x] Remove `reflex` references from all documentation
-- [x] Verify: No Reflex mentions of reflex in any md files (archive/ excluded — historical)
-- [x] Add documentation in readme re how to run dash app
-- [x] Update all claude.md files (CLAUDE.md was updated in Task 5.4)
-- **Checkpoint**: Full application works, no Reflex remnants, CLAUDE.md updated
----
-
----
-
-## Phase 7: Bug Fixes & UI Restructure
-
-### 7.1 Fix duplicate component ID error on first load
-- [x] **Bug**: `DuplicateIdError` for `{"index":"CARDIOLOGY|RIVAROXABAN","type":"drug-fragment"}` on first page load (works on refresh)
-- [x] **Root cause**: Same drug fragment (e.g. RIVAROXABAN) appears under multiple indications within the same directorate in DimSearchTerm.csv. The `{"type": "drug-fragment", "index": f"{directorate}|{frag}"}` ID in `drawer.py:66` is keyed by directorate+fragment, NOT directorate+indication+fragment. So if CARDIOLOGY has RIVAROXABAN under both "acute coronary syndrome" and "atrial fibrillation", two badges get the same ID.
-- [x] **Fix**: Changed badge ID to include search_term: `f"{directorate}|{search_term}|{frag}"`. Updated callback to use `rsplit("|", 1)[-1]` to extract the fragment from the 3-part key.
-- [x] **Also investigate**: First-load-only failure was because Dash validates layout IDs on initial render but `suppress_callback_exceptions=True` only suppresses callback-related ID checks, not layout duplication checks. After refresh, session store may short-circuit the check.
-- **Checkpoint**: `python run_dash.py` starts, first page load has no DuplicateIdError, drawer still works.
-
-### 7.2 Fix drug filter breaking the icicle chart ("multiple implied roots")
-- [x] **Bug**: Selecting a drug from the All Drugs chip list makes the chart go blank. Console error: `WARN: Multiple implied roots, cannot build icicle hierarchy of trace 0. These roots include: N&WICS - NORFOLK AND NORWICH... - RHEUMATOLOGY, ...RHEUMATOLOGY - RITUXIMAB, ...RHEUMATOLOGY - ADALIMUMAB - RITUXIMAB`
-- [x] **Root cause**: The drug filter in `pathway_queries.py:load_pathway_nodes()` uses `drug_sequence LIKE %DRUG%` which returns drug-level and pathway-level nodes, but drops ancestor nodes (root, trust, directory levels 0-2) that have `drug_sequence = ''` (empty string, not NULL). The `OR drug_sequence IS NULL` check doesn't match empty strings. Same bug existed for directorate filter (`directory = ''` at levels 0-1).
-- [x] **Fix**: Restructured WHERE clauses to use level-based gating: drug filter now uses `(level < 3 OR drug_sequence LIKE ...)` so levels 0-2 are always included. Directorate filter now uses `(level < 2 OR directory IN (...) OR directory IS NULL OR directory = '')` so levels 0-1 are always included. Trust filter was already correct (had `OR trust_name = ''`).
-- [x] **Note**: Trust filter was OK. Drug and directorate filters both had the bug. Both fixed.
-- [x] Verify: select a single drug → chart renders correctly with trust→directory→drug→pathway hierarchy intact. Select multiple drugs → works. Clear → full chart returns.
-- **Checkpoint**: Drug selection filters chart without "multiple implied roots" error.
-
-### 7.3 Restructure sidebar: move chart views to sidebar, remove placeholder items
-- [x] **Remove** from sidebar: "Cost Analysis" and "Export Data" items (no functionality behind them)
-- [x] **Remove** from sidebar: "Drug Selection", "Trust Selection", "Directory Selection", "Indications" items (filters moving to top bar — see 7.5)
-- [x] **Add** to sidebar: chart view buttons — "Icicle Chart" (active), "Sankey Diagram" (disabled), "Timeline" (disabled). These replace the tab row currently in chart_card.py.
-- [x] **Keep**: "Pathway Overview" as the top active item
-- [x] Update sidebar IDs and callback wiring. The chart type toggle pills (By Directory / By Indication) stay in the filter bar — they're data filters, not view selectors.
-- [x] Remove the tab row from `chart_card.py` since chart view selection moves to sidebar
-- **Checkpoint**: Sidebar shows chart view options, no placeholder items, app runs without errors.
-
-### 7.4 Replace dmc.Drawer with dmc.Modal for filter selection
-- [x] **Problem**: The single dmc.Drawer with drugs + trusts + directorates requires excessive scrolling and is confusing (multiple sidebar buttons all open the same drawer)
-- [x] **Solution**: Replace `dmc.Drawer` with `dmc.Modal` dialogs. Create separate modals:
-  - Drug Selection modal (contains the All Drugs ChipGroup)
-  - Trust Selection modal (contains the Trust ChipGroup)
-  - Directorate Browser modal (contains the nested directorate accordion with indication sub-items and drug fragment badges)
-- [x] Each modal is opened by its corresponding button in the filter bar (see 7.5)
-- [x] Modals should be appropriately sized (`size="lg"` or `size="xl"`) and use `dmc.Modal` with `centered=True`
-- [x] Preserve all existing selection logic: ChipGroup values, fragment matching, clear button
-- [x] Consider having a shared "Clear All Filters" mechanism accessible from each modal or from the filter bar
-- [x] Delete `dash_app/components/drawer.py` after modals are working, or refactor it into a `modals.py`
-- [x] **Use the frontend-developer agent** to determine optimal modal layout, sizing, and UX patterns. The agent should review the data shapes (42 drugs, 7 trusts, 19 directorates × 163 indications) and recommend the best modal organization.
-- **Checkpoint**: Each filter has its own modal, selection works, no excessive scrolling, chart updates correctly.
-
-### 7.5 Move filter triggers to the top filter bar
-- [x] **Problem**: Filter buttons are in the sidebar, which should be for navigation/views, not filters. Filters should be in the persistent top filter bar.
-- [x] **Add** to the filter bar (alongside existing chart-type toggle and date dropdowns):
-  - "Drugs" button that opens the Drug Selection modal (show count badge when drugs are selected, e.g. "Drugs (3)")
-  - "Trusts" button that opens the Trust Selection modal (show count badge)
-  - "Directorates" button that opens the Directorate Browser modal (show count badge)
-  - "Clear All" button to reset all filter selections
-- [x] The filter bar should remain static across all chart views (icicle, sankey, timeline) — it's the global filter control
-- [x] Update callback wiring: filter bar buttons → open corresponding modal; modal selections → app-state → chart-data → chart
-- [x] Remove drawer-related sidebar callbacks (`open_drawer` in `dash_app/callbacks/drawer.py`)
-- **Checkpoint**: Filter bar has drug/trust/directorate buttons with count badges, each opens correct modal, filter bar is visible across all views.
-
-
-## 8 - Additional notes
--  [x] When filtering drugs, ensure that any 2nd levels (e.g., directorate) with no children is hidden. For example, if Immunoglobulin is filtered, then directorates with no pathways such ar ophthalmology are hidden.
-- [x] ensure filters update the KPI cards at the top to reflect the icicle chart visible
----
-
-## Phase 9: Additional Analytics Charts
-
-### Design Approach
-- Replace sidebar chart view selection with a **tab bar inside `chart_card.py`**
-- Each tab renders its chart in the same `dcc.Graph` area
-- Only the active tab's chart is computed (lazy rendering)
-- Store `active_tab` in `app-state` (default: "icicle")
-- All new charts respond to existing filters (date, chart type, trust, drug, directorate)
-- New query functions go in `src/data_processing/pathway_queries.py` (shared, not in dash_app/)
-- New parsing utilities go in `src/data_processing/pathway_queries.py` (or a new `parsing.py` if large)
-- New figure-building functions go in `src/visualization/` (shared, callable from Dash callbacks)
-- New callback files in `dash_app/callbacks/` — one per chart type
-
-### 9.1 Parsing utilities + tab infrastructure
-- [x] Create parsing utility functions (in new `src/data_processing/parsing.py`):
-  - `parse_average_spacing(spacing_html: str) -> list[dict]` — extract drug_name, dose_count, weekly_interval, total_weeks from HTML string
-  - `parse_pathway_drugs(ids: str, level: int) -> list[str]` — extract ordered drug list from ids column at level 4+
-  - `calculate_retention_rate(nodes: list[dict]) -> dict` — for each N-drug pathway, calculate % not escalating to N+1 drugs
-- [x] Update `dash_app/components/chart_card.py`:
-  - Add tab bar with 8 tabs: Icicle, Market Share, Cost Effectiveness, Cost Waterfall, Sankey, Dosing, Heatmap, Duration
-  - Plain HTML buttons with existing `.chart-tab` / `.chart-tab--active` CSS classes
-  - Single `dcc.Graph` shared across all tabs (lazy rendering)
-  - `active_tab` stored in separate `dcc.Store(id="active-tab")`
-- [x] Update `dash_app/components/sidebar.py`:
-  - Remove "Chart Views" section (Icicle/Sankey/Timeline items) — chart selection moves to tab bar
-  - Keep "Overview" section with "Pathway Overview"
-- [x] Update `dash_app/callbacks/chart.py`:
-  - Tab switching callback: 8 tab button Inputs → `active-tab` store + CSS class Outputs
-  - `update_chart` checks `active-tab` store and dispatches to correct figure builder
-  - Icicle renders normally; other tabs show "coming soon" placeholder
-- **Checkpoint**: App starts, tab bar renders with all 8 tabs, icicle tab still works, other tabs show placeholder "Coming soon" messages ✓
-
-### 9.2 Query functions for all chart types
-- [x] Add to `src/data_processing/pathway_queries.py`:
-  - `get_drug_market_share(db_path, date_filter_id, chart_type, directory=None, trust=None)` — Level 3 nodes grouped by directory, returning drug, value, colour
-  - `get_pathway_costs(db_path, date_filter_id, chart_type, directory=None)` — Level 4+ nodes with cost_pp_pa, parsed pathway labels, patient counts
-  - `get_cost_waterfall(db_path, date_filter_id, chart_type, trust=None)` — Level 2 nodes with cost_pp_pa per directorate/indication
-  - `get_drug_transitions(db_path, date_filter_id, chart_type, directory=None)` — Level 3+ nodes parsed into source→target drug transitions with patient counts
-  - `get_dosing_intervals(db_path, date_filter_id, chart_type, drug=None)` — Level 3 nodes for a specific drug, parsed average_spacing by trust/directory
-  - `get_drug_directory_matrix(db_path, date_filter_id, chart_type)` — Level 3 nodes pivoted as directory × drug with value/cost metrics
-  - `get_treatment_durations(db_path, date_filter_id, chart_type, directory=None)` — Level 3 nodes with avg_days by drug within a directorate
-- [x] Add thin wrappers in `dash_app/data/queries.py` for each new function (resolve DB_PATH and delegate)
-- **Checkpoint**: All 7 query functions return correct data via manual Python tests (`python -c "..."`) ✓
-
-### 9.3 First-Line Market Share chart (Tab 2)
-- [x] Create market share chart rendering:
-  - Build horizontal stacked bar chart from `get_drug_market_share()` data
-  - One cluster per directorate/indication (sorted by total patients desc), bars = drugs, length = % of patients
-  - NHS colour palette, stacked bars with hover showing patients, share, cost, cost_pp_pa
-  - Responds to all existing filters (date, chart type, trust, directorate)
-- [x] Create figure function in `src/visualization/plotly_generator.py` — `create_market_share_figure(data, title)`
-- [x] Wire into tab switching in `update_chart` callback via `_render_market_share()` helper
-- **Checkpoint**: Market Share tab renders real data, responds to filters, icicle still works
-
-### 9.4 Pathway Cost Effectiveness chart (Tab 3)
-- [x] Create `dash_app/callbacks/pathway_costs.py`:
-  - Build horizontal lollipop chart from `get_pathway_costs()` data
-  - Y-axis = pathway label (e.g., "Adalimumab → Secukinumab → Rituximab"), X-axis = £ per patient per annum
-  - Dot size = patient count, colour gradient: green (cheap) → amber → red (expensive)
-  - Uses `parse_pathway_drugs()` to extract pathway labels
-- [x] Add retention rate annotations using `calculate_retention_rate()`
-  - Show as secondary annotation: "Drug B retains 72% of patients"
-- [x] Create figure function in `src/visualization/`
-- [x] Wire into tab switching
-- **Checkpoint**: Cost Effectiveness tab renders with lollipop dots and retention annotations ✓
-
-### 9.5 Cost Waterfall chart (Tab 4)
-- [x] Create `dash_app/callbacks/cost_waterfall.py`:
-  - Build Plotly waterfall chart from `get_cost_waterfall()` data
-  - Each bar = one directorate's average cost_pp_pa, sorted highest to lowest
-  - NHS colours, responds to chart_type toggle, date filter, trust filter
-- [x] Create figure function in `src/visualization/`
-- [x] Wire into tab switching
-- **Checkpoint**: Cost Waterfall tab renders real data, responds to filters ✓
-
-### 9.6 Drug Switching Sankey chart (Tab 5)
-- [x] Create `dash_app/callbacks/sankey.py`:
-  - Build Plotly Sankey diagram from `get_drug_transitions()` data
-  - Left nodes = 1st-line drugs, middle = 2nd-line, right = 3rd-line
-  - Link width = patient count, colour by drug or directorate
-  - Uses `parse_pathway_drugs()` to extract drug transitions from `ids` column
-- [x] Create figure function in `src/visualization/`
-- [x] Wire into tab switching
-- **Checkpoint**: Sankey tab renders real drug transition flows ✓
-
-### 9.7 Dosing Interval Comparison chart (Tab 6)
-- [x] Create `dash_app/callbacks/dosing.py`:
-  - Build horizontal grouped bar chart from `get_dosing_intervals()` data
-  - Uses `parse_average_spacing()` to extract weekly interval numbers
-  - Y-axis = trust or directorate, X-axis = weekly interval
-- [x] Create figure function in `src/visualization/`
-- [x] Wire into tab switching
-- **Checkpoint**: Dosing tab renders real data with parsed interval numbers ✓
-
-### 9.8 Directorate × Drug Heatmap chart (Tab 7)
-- [x] Create `dash_app/callbacks/heatmap.py`:
-  - Build Plotly heatmap from `get_drug_directory_matrix()` data
-  - Rows = directorates (sorted by total patients), columns = drugs (sorted by frequency)
-  - Cell colour = patient count or cost, hover shows details
-  - Toggle between patient count / cost / cost_pp_pa colouring (additional control in tab)
-- [x] Create figure function in `src/visualization/`
-- [x] Wire into tab switching
-- **Checkpoint**: Heatmap tab renders matrix with correct colour mapping ✓
-
-### 9.9 Treatment Duration chart (Tab 8)
-- [x] Create `dash_app/callbacks/duration.py`:
-  - Build horizontal bar chart from `get_treatment_durations()` data
-  - Y-axis = drug, X-axis = average days, colour intensity by patient count
-  - Directorate filter drives which drugs are shown
-- [x] Create figure function in `src/visualization/`
-- [x] Wire into tab switching
-- **Checkpoint**: Duration tab renders real data, responds to directorate filter
-
-### 9.10 Final integration + polish
-- [x] Verify all 8 tabs switch smoothly with no unnecessary recomputation
-- [x] Verify each chart responds to filter changes (date, chart type, trust, directorate, drug)
-- [x] Test with both "directory" and "indication" chart types
-- [x] Verify icicle chart still works correctly (no regressions)
-- [x] Update CLAUDE.md with new chart types, callback files, and query functions
-- **Checkpoint**: All tabs work, all filters work, no regressions, documentation updated ✓
-
----
-
-## Phase 10: Two-View Architecture + Header Redesign
-
-### Context
-Phase 9 delivered 8 chart tabs in a single view. User feedback: comparing drugs across directorates is "apples and oranges" — e.g., Remicade (ophthalmology) vs Adalimumab (multi-directorate) isn't useful. The new architecture splits charts into two views with distinct perspectives:
-- **Patient Pathways**: Pathway-focused analysis (Icicle + Sankey) with drug/trust/directorate filters
-- **Trust Comparison**: Per-directorate analysis comparing drugs across trusts (6 charts for a selected directorate)
-
-Additionally: KPI row removed, fraction KPIs moved to header, global filter sub-header added.
-
-### 10.1 Design consultation via frontend-design skill
-- [x] Use the `/frontend-design` skill to design the following layouts:
-  1. **Header redesign**: Fraction KPIs (X/X patients, X/X drugs, £X/£X cost) integrated into the header bar. Data freshness info stays right. Title stays left.
-  2. **Global filter sub-header**: Date filter dropdowns (Initiated, Last Seen) + chart type toggle pills (By Directory / By Indication). Styled as a prominent, permanent fixture directly below the main blue header — visually distinct (semi-light blue or similar). Constant across both views.
-  3. **Trust Comparison landing page**: ~14 directorate buttons (or ~32 indication buttons when "By Indication" active). Clickable cards/buttons that lead to the 6-chart dashboard for that directorate.
-  4. **Trust Comparison 6-chart dashboard**: Market Share, Cost Waterfall, Dosing, Heatmap, Duration, Cost Effectiveness — all for one selected directorate, comparing drugs across trusts. Layout optimized for 6 charts on one screen.
-  5. **Patient Pathways filter placement**: Drug/trust/directorate filter buttons (only visible on Patient Pathways, not Trust Comparison). Design appropriate placement — could be inline with content, or in a secondary bar.
-- [x] Capture design decisions (component structure, CSS classes, layout approach) for subsequent tasks
-- **Checkpoint**: Design mockups/specifications ready for all 5 areas above
-
-### 10.2 State management + sidebar restructure
-- [x] Add `active_view` to `app-state`: `"patient-pathways"` (default) or `"trust-comparison"`
-- [x] Add `selected_comparison_directorate` to `app-state`: `null` (landing page) or directorate name
-- [x] Update `dash_app/components/sidebar.py`:
-  - Rename "Pathway Overview" → "Patient Pathways"
-  - Add "Trust Comparison" nav item below it
-  - Active state tracks `active_view`
-- [x] Add callback: sidebar clicks → update `active_view` in app-state
-- [x] Main content area switches between Patient Pathways view and Trust Comparison view based on `active_view`
-- [x] Date filter + chart type toggle remain in global sub-header (visible in both views)
-- **Checkpoint**: Sidebar switches between two views, active state highlights correctly, app starts without errors ✓
-
-### 10.3 Header redesign — remove KPI row, add fraction KPIs
-- [x] Remove `dash_app/components/kpi_row.py` (or gut it)
-- [x] Remove KPI row from `app.py` layout
-- [x] Update `dash_app/components/header.py`:
-  - Add fraction KPI display: "X / X patients", "X / X drugs", "£X / £X cost"
-  - Numerator = filtered values (from chart-data store), denominator = global totals (from reference-data store)
-  - Position: right side of header, alongside existing data freshness indicator
-  - Remove indication match rate KPI entirely
-- [x] Update header callbacks to receive both filtered and total values
-- [x] Update CSS in `dash_app/assets/nhs.css` for new header layout
-- [x] Apply design from 10.1
-- **Checkpoint**: Header shows fraction KPIs, KPI row is gone, header looks clean with design from 10.1 ✓
-
-### 10.4 Global filter sub-header bar
-- [x] Extract date filter dropdowns + chart type toggle from `filter_bar.py` into a new sub-header component (or restyle existing filter_bar)
-- [x] Style as a prominent bar directly below the main header — visually distinct per design from 10.1
-- [x] Remove drug/trust/directorate filter buttons from this bar (they move to Patient Pathways view only — see 10.7)
-- [x] Ensure sub-header is constant across both views (Patient Pathways and Trust Comparison)
-- [x] Date filter and chart type toggle changes update `app-state` globally (triggering updates in whichever view is active)
-- [x] Update CSS per design from 10.1
-- **Checkpoint**: Global sub-header renders below main header, date/chart-type controls work, visible in both views ✓
-
-### 10.5 Patient Pathways view — reduce to Icicle + Sankey
-- [x] Create a Patient Pathways view component (or update chart_card.py) with only 2 tabs: Icicle, Sankey
-- [x] Remove Market Share, Cost Waterfall, Dosing, Heatmap, Duration, Cost Effectiveness from this view's tab bar
-- [x] Existing filter → chart-data → chart callback pipeline stays for these 2 tabs
-- [x] This view is shown when `active_view == "patient-pathways"`
-- **Checkpoint**: Patient Pathways shows only Icicle + Sankey tabs, both still work with all existing filters
-
-### 10.6 Trust Comparison query functions
-- [x] Add new/modified query functions to `src/data_processing/pathway_queries.py` for per-trust-within-directorate perspective:
-  - `get_trust_market_share(db_path, filter_id, chart_type, directory)` — drugs by trust within a single directorate (stacked bars per trust instead of per directorate)
-  - `get_trust_cost_waterfall(db_path, filter_id, chart_type, directory)` — one bar per trust showing cost_pp within that directorate
-  - `get_trust_dosing(db_path, filter_id, chart_type, directory)` — drug dosing intervals broken down by trust within a directorate
-  - `get_trust_heatmap(db_path, filter_id, chart_type, directory)` — trust × drug matrix for one directorate (rows=trusts, cols=drugs)
-  - `get_trust_durations(db_path, filter_id, chart_type, directory)` — drug durations by trust within a directorate
-  - `get_directorate_pathway_costs(db_path, filter_id, chart_type, directory)` — verified existing `get_pathway_costs(directory=X)` works correctly (no new function needed)
-- [x] Add thin wrappers in `dash_app/data/queries.py`
-- [x] Verify all queries return correct data for both "directory" and "indication" chart types
-- **Checkpoint**: All 6 query functions return correct per-trust data for sample directorates
-
-### 10.7 Trust Comparison landing page + directorate selector
-- [x] Create Trust Comparison view component with two states:
-  - **Landing**: Grid of directorate/indication buttons (source: reference-data store)
-  - **Dashboard**: 6-chart layout for selected directorate (see 10.8)
-- [x] Directorate buttons: ~14 for "By Directory" mode, ~32 for "By Indication" mode (from chart type toggle)
-- [x] Clicking a button sets `selected_comparison_directorate` in app-state, switching to dashboard view
-- [x] Back button to return to landing page (clears `selected_comparison_directorate`)
-- [x] Apply layout design from 10.1
-- [x] This view is shown when `active_view == "trust-comparison"`
-- **Checkpoint**: Landing page shows directorate buttons, clicking one transitions to dashboard state, back button works
-
-### 10.8 Trust Comparison 6-chart dashboard
-- [x] Build 6-chart dashboard layout per design from 10.1
-- [x] All 6 charts scoped to the selected directorate:
-  1. **Market Share**: Drug breakdown per trust (using `get_trust_market_share`)
-  2. **Cost Waterfall**: Per-trust cost within directorate (using `get_trust_cost_waterfall`)
-  3. **Dosing**: Drug dosing intervals by trust (using `get_trust_dosing`)
-  4. **Heatmap**: Trust × drug matrix (using `get_trust_heatmap`)
-  5. **Duration**: Drug durations by trust (using `get_trust_durations`)
-  6. **Cost Effectiveness**: Pathway costs within directorate, NOT split by trust (using `get_directorate_pathway_costs`)
-- [x] Create new visualization functions in `src/visualization/plotly_generator.py` where existing ones don't fit the trust-comparison perspective (may need `create_trust_market_share_figure`, `create_trust_heatmap_figure`, etc., or parameterize existing functions)
-- [x] All 6 charts respond to date filter and chart type toggle (global filters)
-- [x] Dashboard title shows selected directorate name
-- [x] Use `dcc.Loading` wrappers for each chart
-- **Checkpoint**: All 6 charts render for a selected directorate, comparing drugs across trusts. Charts update when date filter or chart type changes.
-
-### 10.9 Patient Pathways filter relocation
-- [x] Drug/trust/directorate filter buttons (with count badges) only visible when on Patient Pathways view
-- [x] Hidden when on Trust Comparison view
-- [x] Placement per design from 10.1 (could be below the global sub-header, or inline with Patient Pathways content)
-- [x] Filter modals still work as before (drug modal, trust modal, directorate modal)
-- [x] "Clear All Filters" still works
-- **Checkpoint**: Filters visible on Patient Pathways, hidden on Trust Comparison, all filter functionality preserved
-
-### 10.10 CSS updates + polish
-- [x] Global filter sub-header styling per design from 10.1
-- [x] Trust Comparison landing page styling (directorate buttons grid)
-- [x] Trust Comparison dashboard grid styling (6-chart layout)
-- [x] Header fraction KPI styling
-- [x] Remove or repurpose `.kpi-row` / `.kpi-card` CSS
-- [x] Ensure responsive behavior
-- [x] Update `01_nhs_classic.html` if it serves as an ongoing design reference (or note that Phase 10 diverges)
-- **Checkpoint**: All new components styled consistently with NHS design system
-
-### 10.11 Final integration + documentation
-- [x] Verify all views work: Patient Pathways (Icicle + Sankey), Trust Comparison (landing + 6-chart dashboard)
-- [x] Verify global filters (date, chart type) affect both views
-- [x] Verify Patient Pathways filters (drug, trust, directorate) only affect Patient Pathways
-- [x] Verify Trust Comparison directorate selector works for all directorates and indications
-- [x] Verify no regressions in Icicle and Sankey charts
-- [x] Test with both "directory" and "indication" chart types
-- [x] Update CLAUDE.md with new architecture (two views, state management, callback chains)
-- [x] `python run_dash.py` starts cleanly
-- **Checkpoint**: Full application works end-to-end, documentation updated ✓
+### D.4 NICE TA compliance dashboard
+- [ ] Parse `data/ta-recommendations.xlsx` into a reference table
+- [ ] Create schema and migration for TA compliance reference data
+- [ ] Create compliance scoring: cross-reference pathway data with TA recommendations
+- [ ] Create `create_ta_compliance_figure(data, title)` — traffic-light matrix
+- [ ] Add "Compliance" tab or separate Trust Comparison sub-view
+- **Checkpoint**: Compliance matrix shows alignment with NICE guidance
 
 ---
 
 ## Completion Criteria
 
-All tasks marked `[x]` AND:
-- [x] `python run_dash.py` starts cleanly at localhost:8050
-- [x] Layout matches 01_nhs_classic.html (header, sidebar, KPIs, filter bar, chart card, footer)
-- [x] Icicle chart renders with real SQLite data (pathway_nodes)
-- [x] Date filters + chart type toggle update chart correctly
-- [x] Filter modals open correctly for drugs, trusts, and directorates
-- [x] Selecting a drug filters the chart correctly (no "multiple implied roots" error)
-- [x] "All Drugs" card allows selecting any drug across all contexts
-- [x] "Clear Filters" resets all selections
-- [x] KPIs update dynamically (patients, drugs, cost)
-- [x] No Reflex imports in `dash_app/`
-- [x] No duplicate component ID errors on first load
-- [x] Sidebar shows chart views (icicle/sankey/timeline), not filter triggers
-- [x] Filter bar has drug/trust/directorate trigger buttons with selection count badges
+### Phase A
+- [ ] All charts use `_base_layout()` for consistent styling
+- [ ] Heatmaps have linear colorscale + cell annotations + autosize
+- [ ] Legends don't overflow at any drug/trust count
+- [ ] Trust Comparison charts use 7 maximally-distinct colors
+- [ ] `python run_dash.py` starts cleanly
 
-### Phase 9 Completion Criteria
-- [x] 8 chart tabs render in the chart card (Icicle + 7 new)
-- [x] Tab switching is smooth — only active tab's chart is computed
-- [x] All 7 new charts render real data from SQLite
-- [x] All charts respond to existing filters (date, chart type, trust, drug, directorate)
-- [x] Market Share shows grouped bars by directorate with drug breakdown
-- [x] Cost Effectiveness shows lollipop chart with retention annotations
-- [x] Cost Waterfall shows directorate cost_pp_pa bars
-- [x] Sankey shows drug switching flows across treatment lines
-- [x] Dosing shows parsed interval comparisons
-- [x] Heatmap shows directorate × drug matrix
-- [x] Treatment Duration shows avg_days bars
-- [x] Icicle chart has no regressions
-- [x] `python run_dash.py` starts cleanly with all tabs
+### Phase B
+- [ ] All chart titles use `CHART_TITLE_SIZE` and `CHART_TITLE_COLOR`
+- [ ] Cost effectiveness uses smooth gradient
+- [ ] Sankey handles narrow viewports
+- [ ] Heatmap metric toggle works in both views
+- [ ] `python run_dash.py` starts cleanly
 
-### Phase 10 Completion Criteria
-- [x] Sidebar has "Patient Pathways" + "Trust Comparison" navigation items
-- [x] Patient Pathways view shows Icicle + Sankey tabs only
-- [x] Trust Comparison landing page shows directorate/indication buttons
-- [x] Trust Comparison dashboard renders 6 charts for selected directorate (Market Share, Cost Waterfall, Dosing, Heatmap, Duration, Cost Effectiveness)
-- [x] All 6 Trust Comparison charts show per-trust breakdown within selected directorate (except Cost Effectiveness which is directorate-scoped, no trust split)
-- [x] KPI row removed — fraction KPIs (X/X patients, drugs, cost) in header
-- [x] Global filter sub-header (date + chart type) is prominent and constant across both views
-- [x] Drug/trust/directorate filters only visible on Patient Pathways
-- [x] Chart type toggle affects Trust Comparison (indication mode shows indication buttons)
-- [x] Date filter changes update both views
-- [x] Icicle + Sankey have no regressions
-- [x] `python run_dash.py` starts cleanly
+### Phase C
+- [ ] Retention funnel renders with real data
+- [ ] Pathway depth distribution renders with real data
+- [ ] Duration vs cost scatter renders with quadrant lines
+- [ ] Drug network graph renders as Sankey alternative
+- [ ] All new tabs respond to existing filters
+- [ ] `python run_dash.py` starts cleanly
 
----
-
-## Phase 11: UI Polish — Layout & Aesthetics Fixes
-
-### Context
-User feedback after Phase 10 completion. Four layout/aesthetics issues on both Patient Pathways and Trust Comparison views. All are additive CSS/component fixes — no existing work needs reverting.
-
-### 11.1 Move "Clear All Filters" button to left side
-- [x] In `dash_app/components/filter_bar.py`, move the "Clear All" button into the `.pathway-filters__buttons` div (alongside Drugs, Trusts, Directorates buttons) instead of being a separate sibling
-- [x] In `dash_app/assets/nhs.css`, update `.pathway-filters` to remove `justify-content: space-between` (no longer needed — all items grouped left). Add a small left margin or separator to visually distinguish Clear All from the filter buttons.
-- [x] Verify: "Clear All" button appears immediately after the Directorates button, left-aligned
-- **Checkpoint**: Clear All button is next to the filter buttons on the left ✓
-
-### 11.2 Trust Comparison charts — fix overspill and increase chart size
-- [x] In `dash_app/components/trust_comparison.py`, increase the `dcc.Graph` height from `320px` to a larger value (e.g., `450px` or use `calc()` / viewport units). Charts are currently too cramped and overspilling their containers.
-- [x] In `dash_app/assets/nhs.css`, review `.tc-dashboard__grid` and `.tc-chart-cell` — ensure charts don't overflow. Consider whether the 2×3 grid should scroll vertically rather than cramming all 6 charts into the viewport. Each chart should be comfortably readable.
-- [x] The user explicitly wants BIGGER charts, not smaller. Prioritize readability over fitting everything in the viewport.
-- [x] Verify: Trust Comparison dashboard charts are large enough to read, no text/axis overspill, scrolling is acceptable if needed
-- **Checkpoint**: All 6 Trust Comparison charts render at a readable size without overspill ✓
-
-### 11.3 Patient Pathways chart — fill available screen height
-- [x] In `dash_app/components/chart_card.py`, update the `dcc.Graph` style to fill all available vertical space below the tab bar / chart header. Use CSS `calc(100vh - ...)` or `flex: 1` patterns to make the chart stretch to the bottom of the viewport.
-- [x] In `dash_app/assets/nhs.css`, ensure `.chart-card` and its children use flex layout to fill remaining height. The `.main` container already has `min-height: calc(100vh - var(--header-total-h))` — the chart card should consume all of that minus the filter bar height.
-- [x] The Patient Pathways view (`#patient-pathways-view`) should also be a flex column that fills height, so the chart card can stretch.
-- [x] Verify: Icicle/Sankey charts fill the available viewport height, not just a fixed 500px minimum
-- **Checkpoint**: Patient Pathways chart uses all available vertical space below the filter bar ✓
-
-### 11.4 Filter modals — improve aesthetics for large screens
-- [x] In `dash_app/components/modals.py`:
-  - Drug modal: chip `size` "xs" → "sm", modal `size` "lg" → "70%", added `dmc.SimpleGrid(cols=4)` layout
-  - Trust modal: chip `size` "xs" → "md", modal `size` "sm" → "lg", added `dmc.Stack(gap="xs")` vertical layout
-  - Directorate modal: modal `size` "xl" → "70%", drug fragment badge "sm" → "md", directorate text "sm" → "md", count badge "xs" → "sm"
-- [x] In `dash_app/assets/nhs.css`: padding-right on scroll container, white-space: nowrap on chip labels, .mantine-Modal-title width: 100%
-- [x] **Used frontend-developer agent** for UX review: recommended 4-col SimpleGrid for drugs, Stack for trusts, percentage-based modal widths, specific size bumps per component
-- [x] Verify: App starts cleanly, 20 callbacks, no regressions
-- **Checkpoint**: All three filter modals are visually polished and proportionally sized for large screens ✓
-
-### Phase 11 Completion Criteria
-- [x] "Clear All Filters" button is left-aligned next to filter buttons
-- [x] Trust Comparison charts are readable with no overspill
-- [x] Patient Pathways chart fills available viewport height
-- [x] Filter modals are aesthetically polished with readable chip sizes
-- [x] `python run_dash.py` starts cleanly
-- [x] No regressions in existing functionality
+### Phase D
+- [ ] Temporal trends show data over time (if >1 refresh cycle)
+- [ ] Dose distribution shows box/violin plots
+- [ ] Drug timeline shows Gantt-style cohort activity
+- [ ] NICE TA compliance matrix shows traffic-light scoring
+- [ ] `python run_dash.py` starts cleanly
 
 ---
 
@@ -675,37 +262,42 @@ User feedback after Phase 10 completion. Four layout/aesthetics issues on both P
 
 | File | Purpose |
 |------|---------|
-| `01_nhs_classic.html` | Design reference — CSS classes, layout structure, visual targets |
-| `pathways_app/pathways_app.py` | Source of truth for data loading logic (lines 407-642) and icicle chart (lines 769-920) |
-| `data/pathways.db` | SQLite database with pre-computed pathway_nodes |
-| `data/DimSearchTerm.csv` | Directorate → Search_Term → drug mapping for card browser |
-| `src/data_processing/diagnosis_lookup.py` | SEARCH_TERM_MERGE_MAP constant for asthma normalization |
+| `src/visualization/plotly_generator.py` | PRIMARY — all chart generation functions |
+| `src/data_processing/pathway_queries.py` | All SQLite query functions |
+| `src/data_processing/parsing.py` | HTML/JSON parsing utilities |
+| `dash_app/callbacks/chart.py` | Patient Pathways tab dispatch + chart rendering |
+| `dash_app/callbacks/trust_comparison.py` | Trust Comparison 6-chart callbacks |
+| `dash_app/components/chart_card.py` | Tab definitions + chart card component |
+| `dash_app/components/trust_comparison.py` | TC landing + dashboard layout |
+| `dash_app/data/queries.py` | Thin wrappers around shared query functions |
 
-## Key Data Patterns
+## Key Patterns
 
-### Date Filter IDs
-| ID | Initiated | Last Seen |
-|----|-----------|-----------|
-| `all_6mo` | All years | Last 6 months (DEFAULT) |
-| `all_12mo` | All years | Last 12 months |
-| `1yr_6mo` | Last 1 year | Last 6 months |
-| `1yr_12mo` | Last 1 year | Last 12 months |
-| `2yr_6mo` | Last 2 years | Last 6 months |
-| `2yr_12mo` | Last 2 years | Last 12 months |
+### plotly_generator.py structure
+- Module-level palettes: `TRUST_PALETTE` (7 colors), `DRUG_PALETTE` (15 colors)
+- `_base_layout(title, **overrides)` helper for DRY layout dicts
+- `_smart_legend(n_items)` helper for adaptive legend positioning
+- Each `create_*_figure()` function accepts list-of-dicts, returns `go.Figure`
 
-### Pathway Node Columns (from SQLite)
-`parents, ids, labels, level, value, cost, costpp, cost_pp_pa, colour, first_seen, last_seen, first_seen_parent, last_seen_parent, average_spacing, average_administered, avg_days, trust_name, directory, drug_sequence, chart_type, date_filter_id`
+### Adding a new chart tab (Patient Pathways)
+1. Add query function to `src/data_processing/pathway_queries.py`
+2. Add thin wrapper to `dash_app/data/queries.py`
+3. Add figure function to `src/visualization/plotly_generator.py`
+4. Add tab to `TAB_DEFINITIONS` in `dash_app/components/chart_card.py`
+5. Add `_render_*()` helper in `dash_app/callbacks/chart.py`
+6. Add dispatch case in `update_chart()` callback
 
-### Icicle Chart Customdata (10 fields)
-```
-[0] value          — patient count
-[1] colour         — proportion of parent
-[2] cost           — total cost
-[3] costpp         — cost per patient
-[4] first_seen     — first intervention date
-[5] last_seen      — last intervention date
-[6] first_seen_parent  — earliest date in parent group
-[7] last_seen_parent   — latest date in parent group
-[8] average_spacing    — dosing information string
-[9] cost_pp_pa         — cost per patient per annum
-```
+### Existing chart functions in plotly_generator.py
+- `create_icicle_from_nodes(nodes, title)` — L113
+- `create_market_share_figure(data, title)` — L247
+- `create_cost_effectiveness_figure(data, retention, title)` — L384
+- `create_cost_waterfall_figure(data, title)` — L562
+- `create_sankey_figure(data, title)` — L706
+- `create_dosing_figure(data, title, group_by)` — L837
+- `_dosing_by_drug(data, colours)` — L926
+- `_dosing_by_trust(data, colours)` — L1007
+- `create_heatmap_figure(data, title, metric)` — L1189
+- `create_duration_figure(data, title, show_directory)` — L1329
+- `create_trust_market_share_figure(data, title)` — L1481
+- `create_trust_heatmap_figure(data, title, metric)` — L1582
+- `create_trust_duration_figure(data, title)` — L1689
diff --git a/RALPH_PROMPT.md b/RALPH_PROMPT.md
index e501d14..13b9c7d 100644
--- a/RALPH_PROMPT.md
+++ b/RALPH_PROMPT.md
@@ -1,8 +1,8 @@
-# Ralph Wiggum Loop — Dash Application: Additional Analytics Charts
+# Ralph Wiggum Loop — Dashboard Visualization Improvements
 
-You are operating inside an automated loop adding analytics charts to an NHS patient pathway analysis tool built with Dash (Plotly) + Dash Mantine Components. Each iteration you receive fresh context — you have NO memory of previous iterations. Your only memory is the filesystem.
+You are operating inside an automated loop improving Plotly charts in an NHS patient pathway analysis Dash application. Each iteration you receive fresh context — you have NO memory of previous iterations. Your only memory is the filesystem.
 
-**Current Focus**: Phase 9 — Add 7 new analytics chart tabs alongside the existing icicle chart. Tab bar in chart_card.py, lazy rendering, shared query/figure functions in `src/`. See IMPLEMENTATION_PLAN.md Phase 9 for full task list.
+**Current Focus**: Fix chart bugs, improve visual polish, add new analytics charts. See IMPLEMENTATION_PLAN.md for the full task list organized into Phases A–D.
 
 ## First Actions Every Iteration
 
@@ -15,35 +15,31 @@ Read these files in this order before doing anything else:
 
 Then run `git log --oneline -5` to see recent commits.
 
-## Reading the Design Reference
+## Key Files for This Phase
 
-**When building ANY UI component**, read `01_nhs_classic.html` first:
-- It contains the exact CSS classes, HTML structure, and visual layout you must replicate
-- CSS lives in the `<style>` block (lines 8-314) — this becomes `dash_app/assets/nhs.css`
-- HTML structure (lines 316-480+) shows the component hierarchy and class usage
-- Match the design as closely as possible — `className` in Dash = `class` in HTML
+**When modifying chart functions**, always read first:
+- `src/visualization/plotly_generator.py` — PRIMARY file. All chart generation functions live here (~1782 lines).
+- `dash_app/callbacks/chart.py` — Patient Pathways tab dispatch and chart rendering helpers.
+- `dash_app/callbacks/trust_comparison.py` — Trust Comparison 6-chart callbacks.
 
-**When building data loading or chart callbacks**, reference the shared functions in `src/`:
-- `src/data_processing/pathway_queries.py`: `load_initial_data()`, `load_pathway_nodes()`, and 7 new chart-specific query functions (Phase 9)
-- `src/visualization/plotly_generator.py`: `create_icicle_from_nodes()` — icicle chart from list-of-dicts. Add new figure functions here for each chart type.
-- `dash_app/data/queries.py`: Thin wrapper calling shared functions with correct DB path
-- The original logic is archived in `archive/pathways_app/pathways_app.py` for reference.
+**When adding new analytics charts**, also read:
+- `src/data_processing/pathway_queries.py` — All SQLite query functions. New queries go here.
+- `dash_app/data/queries.py` — Thin wrappers. Add wrapper for each new query.
+- `dash_app/components/chart_card.py` — TAB_DEFINITIONS for Patient Pathways tabs.
 
-**When building new analytics charts (Phase 9)**, also read:
-- `AdditionalAnalytics.md` — Full specification for each chart: data source, visualization type, interaction, parsing requirements
-- `src/data_processing/pathway_queries.py` — Existing query patterns to follow. All new queries go here.
-- Key data columns: `level` (0=root, 1=trust, 2=directory, 3=drug, 4+=pathway), `ids` (hierarchy path), `cost_pp_pa`, `avg_days`, `average_spacing`, `average_administered`
+**When modifying UI components**, read:
+- `dash_app/components/trust_comparison.py` — TC landing + dashboard layout.
+- `dash_app/assets/nhs.css` — All CSS styles.
 
 ## Narration
 
 Narrate your work as you go. Your output is the only visibility the operator has into what's happening. For every significant action, explain what you're doing and why:
 
-- **Reading files**: "Reading 01_nhs_classic.html to get CSS classes for the header component..."
-- **Creating code**: "Creating dash_app/components/header.py with make_header() function..."
-- **Debugging**: "Import error for dmc.Drawer — checking dash-mantine-components version..."
+- **Reading files**: "Reading plotly_generator.py to locate the heatmap colorscale..."
+- **Creating code**: "Adding _base_layout() helper to DRY shared layout properties..."
+- **Debugging**: "Chart title color is #003087 instead of CHART_TITLE_COLOR..."
 - **Testing**: "Running python run_dash.py to verify the app starts..."
-- **Making decisions**: "The guardrails say to use className from nhs.css, not inline styles."
-- **Committing**: "Committing header and sidebar components."
+- **Committing**: "Committing heatmap fixes."
 
 Do NOT just output a summary at the end. Narrate throughout.
 
@@ -53,8 +49,8 @@ Do NOT just output a summary at the end. Narrate throughout.
 2. Skip any marked `[x]` (complete) or `[B]` (blocked)
 3. Check progress.txt for guidance — the previous iteration may have recommendations
 4. **Choose a task** based on:
-   - Dependencies (scaffolding before components, components before callbacks)
-   - Logical flow (Phase 0 → 1 → 2 → 3 → 4 → 5)
+   - Dependencies (A.1 shared constants before A.2-A.4 which use them)
+   - Phase ordering (Phase A before B, B before C, C before D)
    - Previous iteration's recommendations
 5. **Document your reasoning**: Before starting, explain WHY you chose this task
 6. Mark your chosen task `[~]` (in progress) in IMPLEMENTATION_PLAN.md
@@ -70,54 +66,60 @@ Work on ONE task per iteration. Build incrementally and verify as you go.
 
 ### Key Technologies
 
-- **Dash 2.x**: `from dash import Dash, html, dcc, Input, Output, State, callback_context, ALL`
-- **Dash Mantine Components 0.14.x**: `import dash_mantine_components as dmc` — needs `dmc.MantineProvider` wrapping the layout
-- **Plotly**: `import plotly.graph_objects as go` — for the icicle chart
+- **Dash 4.0.0**: `from dash import Dash, html, dcc, Input, Output, State, ctx, ALL`
+- **Dash Mantine Components 2.5.1**: `import dash_mantine_components as dmc` — `MantineProvider` wraps layout
+- **Plotly**: `import plotly.graph_objects as go` — all chart figures
 - **SQLite**: `import sqlite3` — read-only access to `data/pathways.db`
 - **CSS**: All in `dash_app/assets/nhs.css` — auto-served by Dash
 
-### Dash Component Patterns
+### plotly_generator.py Patterns
 
+All chart functions follow the same pattern:
 ```python
-# HTML elements use dash.html
-from dash import html
-html.Div(className="top-header", children=[...])
+def create_CHART_figure(data: list[dict], title: str = "", ...) -> go.Figure:
+    """Create CHART from prepared data."""
+    if not data:
+        return go.Figure()
 
-# Mantine components for rich UI
-import dash_mantine_components as dmc
-dmc.Modal(id="drug-modal", opened=False, centered=True, size="lg", children=[...])
-dmc.Accordion(children=[dmc.AccordionItem(...)])
-dmc.ChipGroup(id="all-drugs-chips", multiple=True, children=[dmc.Chip(...)])
+    # Build traces from data
+    fig = go.Figure(data=traces)
 
-# State management
-dcc.Store(id="app-state", storage_type="session", data={})
+    # Apply layout
+    layout = _base_layout(display_title)
+    layout.update({...chart-specific overrides...})
+    fig.update_layout(**layout)
 
-# Callbacks
-@app.callback(
-    Output("chart-data", "data"),
-    Input("app-state", "data"),
-)
-def load_pathway_data(app_state):
-    ...
+    return fig
 ```
 
-### Important: Use frontend-developer agent for UX decisions
-When building modals, filter bar layout, or other UX-sensitive components, spawn the `frontend-developer` agent to review data shapes and recommend optimal patterns. Data shapes: 42 drugs, 7 trusts, 19 directorates × 163 indications.
+### Adding a New Chart Tab
+
+1. Add query function to `src/data_processing/pathway_queries.py` (accept `db_path` param)
+2. Add thin wrapper to `dash_app/data/queries.py` (resolve DB_PATH and delegate)
+3. Add figure function to `src/visualization/plotly_generator.py`
+4. Add tab to `TAB_DEFINITIONS` in `dash_app/components/chart_card.py`
+5. Add `_render_*()` helper in `dash_app/callbacks/chart.py`
+6. Add elif case in `update_chart()` callback
 
 ### Database Access Pattern
 
 ```python
-from pathlib import Path
-import sqlite3
+# In src/data_processing/pathway_queries.py
+def get_something(db_path: Path, filter_id: str, chart_type: str, ...) -> list[dict]:
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    cursor = conn.cursor()
+    cursor.execute("SELECT ... WHERE date_filter_id = ? AND chart_type = ?", [filter_id, chart_type])
+    rows = [dict(row) for row in cursor.fetchall()]
+    conn.close()
+    return rows
 
+# In dash_app/data/queries.py (thin wrapper)
+from data_processing.pathway_queries import get_something as _get_something
 DB_PATH = Path(__file__).resolve().parents[2] / "data" / "pathways.db"
 
-def load_pathway_data(filter_id, chart_type, selected_drugs=None, selected_directorates=None):
-    conn = sqlite3.connect(str(DB_PATH))
-    conn.row_factory = sqlite3.Row
-    # ... query with parameterized WHERE ...
-    conn.close()
-    return result_dict
+def get_something(filter_id="all_6mo", chart_type="directory", ...):
+    return _get_something(DB_PATH, filter_id, chart_type, ...)
 ```
 
 ### Verification Steps
@@ -126,8 +128,8 @@ After writing code, ALWAYS verify:
 
 1. **Import check**: `python -c "from dash_app.app import app"` (or specific module)
 2. **App starts**: `python run_dash.py` — must start without errors
-3. **Visual check** (when building UI): describe what you expect to see at localhost:8050
-4. **For callbacks**: verify the callback chain fires correctly (add temporary `print()` statements if needed)
+3. **Visual check** (when modifying charts): describe what you expect to see at localhost:8050
+4. **For callbacks**: verify the callback chain fires correctly
 
 If any step fails, fix the issue before proceeding.
 
@@ -140,15 +142,15 @@ Every task MUST pass validation before being marked complete:
 - Imports work without errors
 - `python run_dash.py` starts without exceptions
 
-### Tier 2: Layout Validation (for UI component tasks)
-- Component renders in the browser
-- CSS classes match 01_nhs_classic.html
-- Layout structure matches the HTML concept
+### Tier 2: Visual Validation (for chart modification tasks)
+- Chart renders in the browser
+- Colors, labels, legend layout match expectations
+- No overflow or overlap issues
 
-### Tier 3: Functional Validation (for callback tasks)
+### Tier 3: Functional Validation (for callback/toggle tasks)
 - Callbacks fire when inputs change
-- Data flows correctly through dcc.Store chain
-- Chart renders with real data from SQLite
+- Metric toggles switch correctly
+- New tabs appear and render data
 
 ### Validation Failure
 
@@ -183,13 +185,13 @@ After completing your work, append to progress.txt using this format:
 - [Specific actions taken]
 ### Validation results:
 - Tier 1 (Code): [import check, app starts]
-- Tier 2 (Layout): [renders correctly, CSS matches]
-- Tier 3 (Functional): [callbacks fire, data flows]
+- Tier 2 (Visual): [chart renders, colors correct]
+- Tier 3 (Functional): [callbacks fire, toggles work]
 ### Files changed:
 - [list of files created/modified]
 ### Committed: [git hash] "[commit message]"
 ### Patterns discovered:
-- [Any reusable learnings — Dash patterns, DMC quirks, CSS gotchas]
+- [Any reusable learnings — Plotly quirks, layout gotchas, Dash patterns]
 ### Next iteration should:
 - [Explicit guidance for what the next fresh instance should do first]
 - [Note any context that would be lost without writing it here]
@@ -202,7 +204,7 @@ If you discover a failure pattern, add it to `guardrails.md`.
 ## Commit Changes
 
 1. Stage changed files
-2. Use a descriptive commit message referencing the task (e.g., "feat: create dash_app skeleton with nhs.css (Task 0.1 + 0.2)")
+2. Use a descriptive commit message referencing the task (e.g., "fix: heatmap colorscale + cell annotations (Task A.2)")
 3. Commit after your task is validated and complete
 4. If you updated progress.txt with a blocked status, commit that too
 
@@ -225,17 +227,14 @@ DO NOT output it if any task is still `[ ]` or `[B]` or `[~]`.
 
 - Complete ONE task per iteration, then update progress and stop
 - ALWAYS read progress.txt, guardrails.md before starting work
-- **Read 01_nhs_classic.html** when building ANY visual component
-- **Read src/data_processing/pathway_queries.py and src/visualization/plotly_generator.py** when building data logic or chart callbacks
+- **Read plotly_generator.py** when modifying ANY chart function (line numbers shift!)
 - **DO NOT modify pipeline/analysis logic** in src/ (pathway_pipeline, transforms, diagnosis_lookup, pathway_analyzer, refresh_pathways)
-- **DO add shared utilities** to src/ (visualization/plotly_generator.py, data_processing/database.py) rather than duplicating logic in dash_app/
-- **Use className from nhs.css** — not inline styles
-- **dcc.Store for state** — no server-side globals
-- **Unidirectional callbacks** — app-state → chart-data → UI
-- **Port icicle_figure exactly** — same customdata, colorscale, templates
-- **Lazy tab rendering** — only compute the active tab's chart, not all 8
+- **DO add/modify** chart functions in `src/visualization/plotly_generator.py`
+- **DO add** new query functions in `src/data_processing/pathway_queries.py`
 - **New figure functions** go in `src/visualization/`, not in `dash_app/callbacks/`
 - **New query functions** go in `src/data_processing/pathway_queries.py` with thin wrappers in `dash_app/data/queries.py`
+- **dcc.Store for state** — no server-side globals
+- **Lazy tab rendering** — only compute the active tab's chart
 - Keep commits atomic and well-described
 - If stuck for 2+ attempts, document in progress.txt and move on
 - `python run_dash.py` must work after every task
diff --git a/guardrails.md b/guardrails.md
index fcd003b..9acffc5 100644
--- a/guardrails.md
+++ b/guardrails.md
@@ -8,7 +8,7 @@ If you discover a new failure pattern during your work, add it to this file.
 ## Backend Isolation
 
 ### Do NOT modify pipeline/analysis logic in src/
-- **When**: Building Dash integration
+- **When**: Improving charts or adding analytics
 - **Rule**: Do NOT change the logic in these files — they are the data pipeline and must stay as-is:
   - `data_processing/pathway_pipeline.py`, `transforms.py`, `diagnosis_lookup.py` (matching/query logic)
   - `analysis/pathway_analyzer.py`, `statistics.py`
@@ -17,36 +17,49 @@ If you discover a new failure pattern during your work, add it to this file.
 - **Why**: The pipeline is complete and tested. Changing it risks breaking the data refresh workflow.
 
 ### DO use shared utilities in src/ rather than duplicating
-- **When**: The Dash app needs data loading or figure construction
-- **Rule**: Dash callbacks should CALL INTO `src/`, not duplicate the code. Shared functions:
-  - `data_processing/pathway_queries.py` — `load_initial_data()` and `load_pathway_nodes()` for all SQLite queries
-  - `visualization/plotly_generator.py` — `create_icicle_from_nodes()` for icicle chart from list-of-dicts
-  - `dash_app/data/queries.py` — thin wrapper that resolves DB path and delegates to shared functions
-- **Why**: Duplicating SQL queries and figure logic creates copies that drift apart. Shared code in `src/` is the cleaner architecture.
+- **When**: Adding chart functions or query functions
+- **Rule**: Chart figure functions go in `src/visualization/plotly_generator.py`. Query functions go in `src/data_processing/pathway_queries.py`. Dash callbacks should CALL INTO `src/`, not duplicate the code.
+- **Why**: Duplicating SQL queries and figure logic creates copies that drift apart.
 
 ### Do NOT modify pathways.db schema or data
 - **When**: Querying the database from Dash callbacks
 - **Rule**: Read-only access. Use `sqlite3.connect(db_path)` with SELECT queries only. Never INSERT, UPDATE, DELETE, or ALTER.
+- **Exception**: Phase D tasks (D.1 trends) may add new tables — this requires explicit planning.
 - **Why**: pathways.db is populated by `python -m cli.refresh_pathways`. The Dash app is a read-only consumer.
 
 ---
 
-## CSS & Design Fidelity
+## Chart Generation (plotly_generator.py)
 
-### Use className matching 01_nhs_classic.html, not inline styles
-- **When**: Building any Dash HTML component
-- **Rule**: Use `className="css-class-name"` referencing classes from `dash_app/assets/nhs.css`. Do NOT use inline `style={}` dicts for layout/visual styling. Only use inline styles for truly dynamic values (e.g., `style={"flex": patient_count}` for proportional widths).
-- **Why**: CSS fidelity to the HTML concept is a primary goal. Inline styles drift from the design and are harder to maintain.
+### Use _base_layout() for all chart functions
+- **When**: Modifying or creating any chart function after Task A.1
+- **Rule**: Call `_base_layout(title)` to get shared layout properties, then update with chart-specific overrides. Do NOT hardcode font family, title font size, bgcolor, hoverlabel, or autosize in individual functions.
+- **Why**: DRY principle. Inconsistent styling was a bug category (Tier 2 fix).
 
-### nhs.css is the single source of CSS truth
-- **When**: Adding or modifying styles
-- **Rule**: All styles go in `dash_app/assets/nhs.css`. If the concept HTML doesn't have a class for something, add it to nhs.css with the same naming convention (`.component__element--modifier`).
-- **Why**: Dash auto-serves files from `assets/`. Keeping CSS in one file matches the design source (01_nhs_classic.html) and avoids style fragmentation.
+### Use module-level palette constants
+- **When**: Assigning colors to traces in any chart function
+- **Rule**: Use `TRUST_PALETTE` (7 colors) for trust-comparison charts where bars/traces represent trusts. Use `DRUG_PALETTE` (15 colors) for charts where bars/traces represent drugs. Do NOT define local `nhs_colours` lists.
+- **Why**: Local blue-heavy palettes made trusts indistinguishable (a reported bug).
 
-### Read 01_nhs_classic.html when building UI components
-- **When**: Creating any component in `dash_app/components/`
-- **Rule**: Read `01_nhs_classic.html` first to see the exact HTML structure, CSS classes, and element hierarchy for that component. Match it as closely as possible.
-- **Why**: The HTML concept IS the design spec. Deviating creates visual inconsistency.
+### Heatmaps must have cell text annotations
+- **When**: Modifying `create_heatmap_figure()` or `create_trust_heatmap_figure()`
+- **Rule**: Always include `text=text_values, texttemplate="%{text}"` on the heatmap trace. Format text per metric: patients → `"N"`, cost → `"£Nk"`, cost_pp_pa → `"£N"`.
+- **Why**: Without cell text, users must hover every cell to read values — a reported usability bug.
+
+### Heatmaps must use linear colorscale
+- **When**: Setting colorscale on heatmap traces
+- **Rule**: Use linear 5-stop colorscale: `[0.0 #E3F2FD, 0.25 #90CAF9, 0.5 #42A5F5, 0.75 #1E88E5, 1.0 #003087]`. Always set `zmin=0`. Do NOT use non-linear stops like `[0.01, 0.1, 0.3, ...]`.
+- **Why**: Non-linear stops compressed 99% of the value range into identical blues.
+
+### Charts must use autosize, not fixed width
+- **When**: Setting chart dimensions
+- **Rule**: Use `autosize=True` instead of explicit `width=...`. Dynamic height is fine (calculated from data). Use `yaxis automargin=True` instead of fixed left margins.
+- **Why**: Fixed widths overflow their containers on different screen sizes.
+
+### Legends must adapt to item count
+- **When**: Setting legend layout on charts with variable trace counts
+- **Rule**: Use `_smart_legend(n_items)` helper (once created in Task A.3). >15 items = vertical right legend. ≤15 items = horizontal with dynamic bottom margin.
+- **Why**: Horizontal legends with 42 drugs wrap 5+ rows and overlap chart content.
 
 ---
 
@@ -55,95 +68,41 @@ If you discover a new failure pattern during your work, add it to this file.
 ### No circular callback dependencies
 - **When**: Writing Dash callbacks
 - **Rule**: Callbacks must flow unidirectionally: filter inputs → `app-state` store → `chart-data` store → UI components. Never have a component that is both Input and Output in the same callback chain without an intermediate store.
-- **Why**: Dash raises `DuplicateCallback` errors for circular dependencies, and they're extremely hard to debug.
+- **Why**: Dash raises `DuplicateCallback` errors for circular dependencies.
 
 ### Use dcc.Store for all state, not server-side globals
-- **When**: Managing application state (selected filters, chart data, reference data)
-- **Rule**: ALL state lives in `dcc.Store` components. Never use module-level globals, class variables, or `flask.g` for state. The 3 stores are: `app-state` (session), `chart-data` (memory), `reference-data` (session).
-- **Why**: Dash is stateless per request. Server-side state breaks with multiple users and causes subtle bugs during development.
+- **When**: Managing application state
+- **Rule**: ALL state lives in `dcc.Store` components. Never use module-level globals or class variables for state. The 4 stores: `app-state` (session), `chart-data` (memory), `reference-data` (session), `active-tab` (memory).
+- **Why**: Dash is stateless per request. Server-side state breaks with multiple users.
 
-### Use callback_context for multi-input callbacks
-- **When**: A callback has multiple Inputs and needs to know which one triggered it
-- **Rule**: Use `dash.callback_context.triggered` (or `ctx.triggered_id` in Dash 2.x) to determine the triggering input.
-- **Why**: Without this, the callback runs for every input change and you can't distinguish which filter changed.
+### Only render the active tab's chart
+- **When**: Building tab switching or chart rendering callbacks
+- **Rule**: Check `active-tab` store and ONLY compute the figure for the active tab. Return `no_update` or placeholder for inactive tabs.
+- **Why**: Computing all charts on every filter change would be extremely slow.
 
-### Pattern-matching callbacks for dynamic drug chips
-- **When**: Building the card browser drawer with clickable drug chips
-- **Rule**: Use `{"type": "drug-chip", "index": drug_name}` pattern for chip IDs. Register callbacks with `Input({"type": "drug-chip", "index": ALL}, "n_clicks")`. Access triggered chip via `ctx.triggered_id["index"]`.
-- **Why**: The number of drug chips is dynamic (changes per directorate/indication). Pattern-matching callbacks handle this without hardcoding IDs.
+### Chart figure functions go in src/visualization/, not dash_app/
+- **When**: Creating new chart figures
+- **Rule**: Create figure builder functions in `src/visualization/plotly_generator.py`. Dash callbacks call these shared functions. Do NOT put Plotly figure construction logic directly in `dash_app/callbacks/`.
+- **Why**: Shared figure functions can be tested independently and reused.
+
+### New query functions use same pattern as existing ones
+- **When**: Adding query functions to `src/data_processing/pathway_queries.py`
+- **Rule**: Follow the same pattern as `load_pathway_nodes()`: accept `db_path` parameter, use `sqlite3.connect()` with `row_factory = sqlite3.Row`, parameterized queries, return JSON-serializable dicts/lists. Add thin wrappers in `dash_app/data/queries.py`.
+- **Why**: Consistency with existing code. The thin wrapper pattern ensures DB path resolution is centralized.
 
 ---
 
-## Plotly Figure
-
-### Preserve create_icicle_from_nodes() in src/visualization/plotly_generator.py
-- **When**: Modifying the icicle chart
-- **Rule**: `create_icicle_from_nodes(nodes, title)` in `src/visualization/plotly_generator.py` is the shared icicle chart function. It accepts list-of-dicts from dcc.Store. Key properties:
-  - 10-field customdata structure (value, colour, cost, costpp, first_seen, last_seen, first_seen_parent, last_seen_parent, average_spacing, cost_pp_pa)
-  - NHS colorscale: `[[0.0, "#003087"], [0.25, "#0066CC"], [0.5, "#1E88E5"], [0.75, "#4FC3F7"], [1.0, "#E3F2FD"]]`
-  - `maxdepth=3`, `branchvalues="total"`, `sort=False`
-  - Layout: transparent background, reduced margins, autosize
-- **Why**: The icicle chart is tested and correct. The Dash callback in `dash_app/callbacks/chart.py` calls this function.
-
-### Chart data is a list of dicts
-- **When**: Passing data between `chart-data` store and chart callback
-- **Rule**: `chart-data` store holds `{"nodes": [...], "unique_patients": int, "total_drugs": int, "total_cost": float}`. Each node is a dict with keys matching the SQLite columns needed for the figure: `parents, ids, labels, value, cost, costpp, colour, first_seen, last_seen, first_seen_parent, last_seen_parent, average_spacing, cost_pp_pa`.
-- **Why**: `dcc.Store` serializes to JSON. Keep the same dict structure that `pathways_app.py` uses for `chart_data` so the figure callback works identically.
-
----
-
-## Data Extraction
-
-### Keep data logic in shared src/ functions, not dash_app/ duplicates
-- **When**: Adding or modifying data loading functions
-- **Rule**: SQL queries and data logic live in `src/data_processing/pathway_queries.py`. The `dash_app/data/queries.py` is a thin wrapper that resolves the DB path and delegates. Do not duplicate queries in `dash_app/`.
-- **Why**: Shared code in `src/` prevents query drift and keeps the single source of truth for data access.
-
-### DimSearchTerm.csv fragments are substrings
-- **When**: Building the card browser or matching drugs to indications
-- **Rule**: `CleanedDrugName` values in DimSearchTerm.csv are drug name FRAGMENTS (e.g., "ADALIMUMAB", "PEGYLATED", "INHALED"). They're matched against full drug names using `drug_name.upper().contains(fragment)`. Don't assume exact match.
-- **Why**: Some fragments are partial (INHALED matches "INHALED BECLOMETASONE", "INHALED FLUTICASONE", etc.).
-
-### Apply SEARCH_TERM_MERGE_MAP when loading DimSearchTerm.csv
-- **When**: Building the directorate tree in `card_browser.py`
-- **Rule**: Import and apply `SEARCH_TERM_MERGE_MAP` from `data_processing.diagnosis_lookup` to normalize "allergic asthma" → "asthma" and "severe persistent allergic asthma" → "asthma". Keep "urticaria" separate.
-- **Why**: The Snowflake query and pathway processing already use merged Search_Terms. The card browser must match.
-
----
-
-## SQLite Queries
+## Data Patterns
 
 ### Use parameterized queries for all filters
 - **When**: Building WHERE clauses with user-selected values
 - **Rule**: Use `?` placeholders and pass params as a list. Never use f-strings or string interpolation for filter values.
 - **Why**: Prevents SQL injection and handles special characters in drug/directory names (e.g., "CROHN'S DISEASE").
 
-### Database path resolution
-- **When**: Connecting to pathways.db from dash_app/
-- **Rule**: Use `Path(__file__).resolve().parents[2] / "data" / "pathways.db"` from files in `dash_app/data/`. This resolves from `dash_app/data/queries.py` → project root → `data/pathways.db`.
-- **Why**: Relative paths break depending on the working directory. Absolute path resolution is reliable.
-
----
-
-## Dash Framework
-
-### Wrap layout in dmc.MantineProvider
-- **When**: Setting up the app layout in `app.py`
-- **Rule**: The outermost layout element must be `dmc.MantineProvider(children=[...])`. Without this, DMC components (Drawer, Accordion, Chip, etc.) won't render.
-- **Why**: Dash Mantine Components requires the Provider context to function.
-
-### dcc.Store storage_type matters
-- **When**: Creating the 3 store components
-- **Rule**:
-  - `app-state`: `storage_type="session"` — persists across page refreshes within a tab
-  - `chart-data`: `storage_type="memory"` — cleared on page refresh (reloaded from SQLite)
-  - `reference-data`: `storage_type="session"` — loaded once, persists across refreshes
-- **Why**: Wrong storage type causes stale data bugs (memory clears too often) or wasted queries (session persists when it shouldn't).
-
-### Dash assets directory is auto-served
-- **When**: Placing CSS, JS, or images
-- **Rule**: Put static assets in `dash_app/assets/`. Dash serves them automatically. Reference CSS via `className`, not `<link>` tags.
-- **Why**: Dash's asset pipeline handles caching and serving. Manual `<link>` tags are unnecessary and may not work.
+### Parsing utilities must handle missing/null data gracefully
+- **When**: Parsing `average_spacing` HTML strings, `average_administered` JSON, or `ids` column values
+- **Rule**: Always handle `None`, empty string `""`, and malformed data. Return sensible defaults rather than raising exceptions.
+- **Why**: Not all nodes have statistics populated. Level 0-2 nodes have no drug-level statistics.
 
 ---
 
@@ -169,92 +128,10 @@ If you discover a new failure pattern during your work, add it to this file.
 - **Rule**: Run `python run_dash.py` (or `python -c "from dash_app.app import app"` for import checks). The app must start without errors after EVERY task.
 - **Why**: Broken imports or circular dependencies compound across tasks. Catch them immediately.
 
----
-
-## Icicle Chart Hierarchy Integrity
-
-### Drug/trust/directorate filters must preserve ancestor nodes
-- **When**: Building WHERE clauses in `pathway_queries.py:load_pathway_nodes()` that filter by drug, trust, or directorate
-- **Rule**: Ancestor nodes (levels 0, 1, 2) must ALWAYS be included in query results regardless of drug/trust/directorate filters. Only apply those filters to level 3+ nodes. The icicle chart requires an unbroken parent→child chain from a single root node. If you filter out the root, trust, or directory-level nodes, Plotly will report "Multiple implied roots" and the chart will be blank.
-- **Why**: The drug filter `drug_sequence LIKE %DRUG%` was applied to all levels, dropping level 0-2 nodes that have NULL drug_sequence. This broke the icicle hierarchy.
-
-### Pattern-matching IDs must be globally unique
-- **When**: Creating components with pattern-matching IDs like `{"type": "drug-fragment", "index": "..."}`
-- **Rule**: The `index` value must be globally unique across the ENTIRE layout, not just within a section. If the same entity (e.g., a drug fragment name) can appear in multiple contexts (e.g., multiple indications within a directorate), the ID must include ALL distinguishing context. Use `f"{directorate}|{search_term}|{fragment}"` not just `f"{directorate}|{fragment}"`.
-- **Why**: RIVAROXABAN appeared under multiple indications within CARDIOLOGY, causing `DuplicateIdError` on first page load.
-
----
-
-## UI Structure
-
-### Sidebar is for views, filter bar is for filters
-- **When**: Deciding where to place UI controls
-- **Rule**: The sidebar should contain chart VIEW selectors (Icicle, Sankey, Timeline) and navigation. Filter controls (drug selection, trust selection, date range, chart type toggle) belong in the top filter bar. Do NOT put filter triggers in the sidebar.
-- **Why**: Having 3-4 sidebar buttons that all open the same drawer was confusing. Filters should be grouped together in the persistent filter bar.
-
-### Use dmc.Modal for filter selection, not dmc.Drawer
-- **When**: Building filter selection UI (drugs, trusts, directorates)
-- **Rule**: Use `dmc.Modal` (centered popup) for filter selection, not `dmc.Drawer` (slide-in panel). Each filter type gets its own modal. Trigger buttons go in the filter bar with selection count badges (e.g., "Drugs (3)").
-- **Why**: A single drawer with all filters required excessive scrolling and was confusing. Modals provide focused, per-filter selection with clear open/close behavior.
-
-### Use frontend-developer agent for UX decisions
-- **When**: Designing modal layouts, filter bar organization, or other UX-sensitive components
-- **Rule**: Spawn the `frontend-developer` agent to review the data shapes and recommend optimal layout, sizing, and interaction patterns before building.
-- **Why**: Good UX requires considering the data (42 drugs, 7 trusts, 19 directorates × 163 indications) and choosing appropriate patterns for each.
-
-## Tab Architecture (Phase 9)
-
-### Only render the active tab's chart
-- **When**: Building the tab switching callback in `chart.py`
-- **Rule**: Check `app-state.active_tab` and ONLY compute the figure for the active tab. Return `no_update` or a cached placeholder for inactive tabs. Do NOT render all 8 charts on every filter change.
-- **Why**: Computing 8 Plotly figures on every filter change would be extremely slow. Lazy rendering is essential — only the visible chart needs computation.
-
-### Chart figure functions go in src/visualization/, not dash_app/
-- **When**: Creating new chart figures (market share, lollipop, waterfall, Sankey, etc.)
-- **Rule**: Create figure builder functions in `src/visualization/` (e.g., `plotly_generator.py` or new files). Dash callbacks call these shared functions. Do NOT put Plotly figure construction logic directly in `dash_app/callbacks/`.
-- **Why**: Shared figure functions can be tested independently and reused outside Dash. Same pattern as `create_icicle_from_nodes()`.
-
-### New query functions use same pattern as existing ones
-- **When**: Adding query functions to `src/data_processing/pathway_queries.py`
-- **Rule**: Follow the same pattern as `load_pathway_nodes()`: accept `db_path` parameter, use `sqlite3.connect()` with `row_factory = sqlite3.Row`, parameterized queries, return JSON-serializable dicts/lists. Add thin wrappers in `dash_app/data/queries.py`.
-- **Why**: Consistency with existing code. The thin wrapper pattern ensures DB path resolution is centralized.
-
-### Parsing utilities must handle missing/null data gracefully
-- **When**: Parsing `average_spacing` HTML strings or `ids` column values
-- **Rule**: Always handle `None`, empty string `""`, and malformed data. Return sensible defaults (empty dict, empty list) rather than raising exceptions. The pathway_nodes data has NULLs at ancestor levels and some nodes may have empty statistics.
-- **Why**: Not all nodes have `average_spacing` or `average_administered` populated. Level 0-2 nodes have no drug-level statistics.
-
-### Tab bar replaces sidebar chart views
-- **When**: Implementing tab infrastructure in Task 9.1
-- **Rule**: Add the tab bar INSIDE `chart_card.py`. Remove the "Chart Views" section from `sidebar.py` (Icicle/Sankey/Timeline items). The sidebar should only have the "Overview" section after this change.
-- **Why**: Tabs are the standard UI pattern for switching between chart views in the same content area. The sidebar was a temporary placeholder.
-
-## Two-View Architecture (Phase 10)
-
-### Patient Pathways and Trust Comparison are separate views with separate state
-- **When**: Building the two-view navigation (sidebar switching between Patient Pathways and Trust Comparison)
-- **Rule**: `active_view` in app-state controls which view is shown. Patient Pathways has `active_tab` (icicle/sankey) + drug/trust/directorate filters. Trust Comparison has `selected_comparison_directorate` (null = landing page, string = dashboard). Drug/trust/directorate filters do NOT affect Trust Comparison. Date filter + chart type toggle are GLOBAL and affect both views.
-- **Why**: The whole point of the restructure is that these views have different analytical perspectives. Leaking Patient Pathways filters into Trust Comparison would break the directorate-focused comparison.
-
-### Trust Comparison queries must break down BY trust, not aggregate across trusts
-- **When**: Writing query functions for Trust Comparison charts (Task 10.6)
-- **Rule**: Existing Phase 9 query functions (e.g., `get_drug_market_share`) aggregate across trusts for same (directory, drug) pair. Trust Comparison needs the OPPOSITE — show per-trust breakdown within a single directorate. Create NEW query functions (`get_trust_market_share`, `get_trust_cost_waterfall`, etc.) rather than modifying existing ones. Existing functions are still used by Patient Pathways.
-- **Why**: Modifying existing queries would break Patient Pathways charts. The trust-comparison perspective is fundamentally different from the existing aggregate perspective.
-
-### Cost Effectiveness in Trust Comparison is directorate-scoped but NOT trust-split
-- **When**: Building the Cost Effectiveness chart in the Trust Comparison 6-chart dashboard
-- **Rule**: Cost Effectiveness shows pathway costs for the selected directorate only. It does NOT split by trust — it's a single chart showing pathways within the directorate. Use existing `get_pathway_costs(directory=selected)` query, not a new trust-split variant.
-- **Why**: Splitting pathway costs by trust muddies the water — pathway analysis is more meaningful at the directorate level.
-
-### Use /frontend-design skill for UX design, not frontend-developer agent
-- **When**: Designing layouts for header, sub-header, landing page, dashboard, filter placement (Task 10.1)
-- **Rule**: Use the `/frontend-design` skill (invoked via the Skill tool) for design consultation. Do NOT spawn a `frontend-developer` Task agent.
-- **Why**: User explicitly requested the frontend-design skill for design work.
-
-### Trust Comparison landing page respects chart type toggle
-- **When**: Building the directorate/indication selector buttons (Task 10.7)
-- **Rule**: When chart type is "By Directory", show ~14 directorate buttons. When "By Indication", show ~32 indication buttons. The button list comes from reference-data store (available_directorates or available_indications). Changing the chart type toggle while on the landing page should refresh the button list. If a directorate was selected and user switches to indication mode, clear `selected_comparison_directorate` and return to landing page.
-- **Why**: The chart type toggle is global and the Trust Comparison view must respect it.
+### Re-read plotly_generator.py before editing
+- **When**: Starting any task that modifies chart functions
+- **Rule**: Always re-read `src/visualization/plotly_generator.py` at the start of the iteration. Line numbers in IMPLEMENTATION_PLAN.md are approximate and shift as edits accumulate. Search for function names, not line numbers.
+- **Why**: Previous iterations may have changed the file, shifting all line numbers.
 
 <!--
 ADD NEW GUARDRAILS BELOW as failures are observed during the loop.
diff --git a/progress.txt b/progress.txt
index 535e9f8..aae6d9b 100644
--- a/progress.txt
+++ b/progress.txt
@@ -1,2704 +1,76 @@
-# Progress Log — Reflex → Dash Migration
+# Progress Log — Dashboard Visualization Improvements
 
 ## Project Context
 
-Migrating the HCD Analysis frontend from Reflex to Dash (Plotly) + Dash Mantine Components. Pipeline/analysis logic in `src/` is untouched, but shared utilities (data queries, figure construction) should be added TO `src/` so Dash callbacks call into them rather than duplicating code.
+Working Dash application with 2 views (Patient Pathways + Trust Comparison), 13 chart functions in `plotly_generator.py`, and a complete callback chain. Now improving chart quality: bug fixes, visual polish, and new analytics.
 
-**Previous state**: Fully working Reflex app with pre-computed pathway architecture (SQLite), dual chart types (directory + indication), drug-aware indication matching. All pipeline work is done.
+**Current state**: Fully functional Dash app at http://localhost:8050 with icicle, Sankey, market share, cost effectiveness, cost waterfall, dosing, heatmap, and duration charts. Trust Comparison has 6 dedicated charts. All filters work.
 
-**New goal**: Replace Reflex with Dash for better control over layout, CSS, and component behavior. Add a dmc.Drawer-based "card browser" for drug/indication selection organized by clinical directorate.
+**New goal**: Fix chart bugs (heatmap colorscale, legend overflow, trust color differentiation), add visual polish (consistent styling, smooth gradients), add new analytics (retention funnel, pathway depth, scatter, network), and new backend analytics (trends, dose distribution, timeline, NICE compliance).
 
-## Key Data Patterns
+## Key Architecture Patterns
 
-### SQLite pathway_nodes table
-- ~3,600 rows across 12 datasets (6 date filters × 2 chart types)
-- Key columns: `parents, ids, labels, level, value, cost, costpp, cost_pp_pa, colour, first_seen, last_seen, first_seen_parent, last_seen_parent, average_spacing, trust_name, directory, drug_sequence, chart_type, date_filter_id`
-- Level 0 = Root, Level 1 = Trust, Level 2 = Directory/Indication, Level 3 = Drug, Level 4+ = Pathway
-- `chart_type`: "directory" or "indication"
-- `date_filter_id`: "all_6mo" (default), "all_12mo", "1yr_6mo", "1yr_12mo", "2yr_6mo", "2yr_12mo"
-- UNIQUE constraint: (date_filter_id, chart_type, ids)
+### plotly_generator.py (PRIMARY target file)
+- 13 chart functions, all accept list-of-dicts, return `go.Figure`
+- Located at `src/visualization/plotly_generator.py` (~1782 lines)
+- Key functions and approximate line numbers:
+  - `create_icicle_from_nodes(nodes, title)` — L113
+  - `create_market_share_figure(data, title)` — L247
+  - `create_cost_effectiveness_figure(data, retention, title)` — L384
+  - `create_cost_waterfall_figure(data, title)` — L562
+  - `create_sankey_figure(data, title)` — L706
+  - `create_dosing_figure(data, title, group_by)` — L837
+  - `_dosing_by_drug(data, colours)` — L926
+  - `_dosing_by_trust(data, colours)` — L1007
+  - `create_heatmap_figure(data, title, metric)` — L1189
+  - `create_duration_figure(data, title, show_directory)` — L1329
+  - `create_trust_market_share_figure(data, title)` — L1481
+  - `create_trust_heatmap_figure(data, title, metric)` — L1582
+  - `create_trust_duration_figure(data, title)` — L1689
+- NOTE: Line numbers will shift as you edit. Re-read the file each iteration.
 
-### DimSearchTerm.csv (for card browser)
-- Located at `data/DimSearchTerm.csv`
-- Columns: Search_Term, CleanedDrugName (pipe-separated drug fragments), PrimaryDirectorate
-- ~165 rows; some Search_Terms appear twice (e.g., "diabetes" under DIABETIC MEDICINE and OPHTHALMOLOGY)
-- Drug fragments are UPPERCASE substrings matched against standardized drug names
-- SEARCH_TERM_MERGE_MAP in `src/data_processing/diagnosis_lookup.py` merges asthma variants: {"allergic asthma": "asthma", "severe persistent allergic asthma": "asthma"}
+### Callback chain
+- `dash_app/callbacks/chart.py` — Patient Pathways tab dispatch (`_render_*` helpers → `update_chart`)
+- `dash_app/callbacks/trust_comparison.py` — 6 Trust Comparison chart callbacks
+- Tab switching: `active-tab` dcc.Store, tab IDs = `"tab-{short_id}"`
+- TAB_DEFINITIONS in `chart_card.py` — currently: icicle, sankey
 
-### Data loading logic to extract
-- `pathways_app/pathways_app.py` lines 407-488: `load_data()` — loads available drugs, directorates, indications, total records, last updated from SQLite
-- `pathways_app/pathways_app.py` lines 490-642: `load_pathway_data()` — queries pathway_nodes with date_filter_id + chart_type + optional drug/directory filters
-- `pathways_app/pathways_app.py` lines 769-920: `icicle_figure` — builds go.Icicle with 10-field customdata, NHS colorscale, texttemplate, hovertemplate
+### Adding a new Patient Pathways tab
+1. Query function in `src/data_processing/pathway_queries.py` (accept `db_path` param)
+2. Thin wrapper in `dash_app/data/queries.py` (resolve DB_PATH)
+3. Figure function in `src/visualization/plotly_generator.py`
+4. Add to `TAB_DEFINITIONS` in `dash_app/components/chart_card.py`
+5. Add `_render_*()` helper in `dash_app/callbacks/chart.py`
+6. Add elif case in `update_chart()` dispatch
 
-### CSS from 01_nhs_classic.html
-- Lines 8-314 contain the full CSS (copy to dash_app/assets/nhs.css)
-- Google Fonts: `Source Sans 3` weights 300,400,600,700,900
-- CSS variables: `--nhs-blue: #005EB8`, `--nhs-dark-blue: #003087`, `--nhs-light-blue: #41B6E6`, etc.
-- Key classes: `.top-header`, `.sidebar`, `.main`, `.kpi-row`, `.kpi-card`, `.filter-bar`, `.toggle-pill`, `.chart-card`, `.chart-tab`, `.page-footer`
-- Remove `.icicle`, `.icicle__row`, `.icicle__cell`, `.lvl-*` classes — those are mock chart CSS, Plotly handles the real chart
+### State management
+- 4 `dcc.Store` components: app-state, chart-data, reference-data, active-tab
+- Unidirectional: filter inputs → app-state → chart-data → UI
+- 20 registered callbacks total
 
-### Dash-specific patterns
-- State via `dcc.Store`: 3 stores (app-state, chart-data, reference-data)
-- Callbacks: unidirectional flow (filter change → app-state → chart-data → UI components)
-- DMC components: `dmc.MantineProvider` wraps everything, `dmc.Drawer` for card browser
-- Pattern-matching callbacks: `{"type": "drug-chip", "index": drug_name}` for dynamic drug chip selection
-- Assets auto-served from `dash_app/assets/` directory
+### DMC version
+- Dash 4.0.0 + DMC 2.5.1 (Mantine v7 based)
+- `dmc.MantineProvider` wraps layout
+- `dmc.SegmentedControl` available for metric toggles
 
-### Database path from dash_app/
-- From `dash_app/data/queries.py`: `Path(__file__).resolve().parents[2] / "data" / "pathways.db"`
-- From `dash_app/data/card_browser.py`: same pattern for `data/DimSearchTerm.csv`
+### Flex chain for chart filling viewport
+- Full flex chain: `.main` → `#view-container` → `#patient-pathways-view` → `.chart-card` → loading wrapper → `#chart-container` → `#pathway-chart`
+- `responsive=True` on dcc.Graph + `autosize=True` in figure layout
+- `dcc.Loading` wraps children in `.dash-loading-callback > div` — CSS must propagate flex through both
 
-### Existing src/ code to build on (not duplicate)
-- `src/visualization/plotly_generator.py` already has `create_icicle_figure(ice_df, title)` that takes a DataFrame with columns like `"First seen"`, `"Last seen (Parent)"` (with spaces). The Reflex AppState `icicle_figure` (pathways_app.py:769) takes list-of-dicts with keys like `first_seen`, `last_seen_parent` (underscores). For Dash, add a NEW function `create_icicle_from_nodes(nodes, title)` that accepts list-of-dicts. Don't modify the existing DataFrame-based function.
-- `src/data_processing/database.py` has `DatabaseManager` class. Add standalone query functions here (or a new `pathway_queries.py`) so Dash and Reflex share the same SQL.
-- The existing `create_icicle_figure` uses Viridis colorscale; the Reflex version uses NHS blue gradient. The Dash version should use the NHS blue gradient from pathways_app.py.
+### Known heatmap bugs (to fix)
+- Non-linear colorscale compresses 99% of range into identical blues
+- No cell text — must hover every cell
+- Light end (#F0F4F8) invisible against transparent background
+- Fixed width can overflow container
+- Fixed l=200 left margin wastes space
 
-### Architecture decision: shared code in src/
-- Pipeline/analysis logic is OFF LIMITS: pathway_pipeline.py, transforms.py, diagnosis_lookup.py (matching), pathway_analyzer.py, statistics.py, refresh_pathways.py
-- Shared utilities are ENCOURAGED to add to src/: plotly_generator.py (new dict-based function), database.py (query functions)
-- dash_app/data/queries.py should be a thin wrapper that calls into src/
+### Known legend bugs (to fix)
+- Horizontal legends at y=-0.15 with fixed bottom margins overflow with 42 drugs
+- Affects: market_share, trust_market_share, dosing, trust_duration
+
+### Known color bugs (to fix)
+- First 6 of 10 trust palette colors are blue variants — nearly indistinguishable
+- _dosing_by_drug interpolates from one blue to another blue
 
 ## Iteration Log
-
-## Iteration 1 — 2026-02-06
-### Task: Phase 0 — Tasks 0.1 + 0.2 (Project Scaffolding + CSS Extraction)
-### Why this task:
-- This is the first iteration. Phase 0 scaffolding is the foundation everything else depends on.
-- Tasks 0.1 and 0.2 are tightly coupled (CSS needs the assets dir from 0.1), so both done together.
-### Status: COMPLETE
-### What was done:
-- Created `dash_app/` directory with subdirectories: `assets/`, `data/`, `components/`, `callbacks/`, `utils/`
-- Created `__init__.py` in all packages
-- Created `run_dash.py` entry point at project root
-- Updated `pyproject.toml` with `dash>=2.14.0` and `dash-mantine-components>=0.14.0`
-- Ran `uv sync` — installed Dash 4.0.0 and DMC 2.5.1 (newer than plan expected)
-- Created `dash_app/app.py` with `MantineProvider` wrapper, 3 `dcc.Store` components (app-state, chart-data, reference-data), and placeholder layout
-- Extracted CSS from `01_nhs_classic.html` into `dash_app/assets/nhs.css` (7.5KB)
-  - Added Google Fonts `@import` for Source Sans 3
-  - Removed mock icicle chart CSS (`.icicle`, `.icicle__row`, `.icicle__cell`, `.lvl-*`)
-  - Kept all real component CSS: header, sidebar, KPI, filter bar, chart card, footer, responsive
-### Validation results:
-- Tier 1 (Code): `python -c "from dash_app.app import app"` — OK, layout type is MantineProvider
-- Tier 1 (App starts): `python run_dash.py` — serves at http://127.0.0.1:8050/
-- CSS: nhs.css (7,491 bytes) found in Dash assets folder, auto-served
-### Files changed:
-- `pyproject.toml` — added dash + dmc dependencies
-- `run_dash.py` — new entry point
-- `dash_app/__init__.py` — new package
-- `dash_app/app.py` — new app with MantineProvider + stores + placeholder
-- `dash_app/assets/nhs.css` — extracted from 01_nhs_classic.html
-- `dash_app/data/__init__.py` — empty package
-- `dash_app/components/__init__.py` — empty package
-- `dash_app/callbacks/__init__.py` — empty package
-- `dash_app/utils/__init__.py` — empty package
-### Committed: 1c3ece6 "feat: create dash_app skeleton with nhs.css and MantineProvider (Phase 0)"
-### Patterns discovered:
-- Dash 4.0.0 and DMC 2.5.1 installed (plan said 2.x and 0.14.x). The API is compatible — `MantineProvider`, `Drawer`, `Accordion`, `Chip` all available. DMC 2.x is based on Mantine v7.
-- `dmc.MantineProvider(children=[...])` works for wrapping the layout in both DMC versions.
-- `suppress_callback_exceptions=True` needed in Dash app since callbacks reference IDs not yet in layout during phased development.
-### Next iteration should:
-- Start Phase 1: Task 1.1 — Create shared data access functions
-- Read `pathways_app/pathways_app.py` lines 407-642 to extract `load_data()` and `load_pathway_data()` logic
-- Create shared functions in `src/data_processing/pathway_queries.py` (database.py is already used for DatabaseManager)
-- Create thin wrapper `dash_app/data/queries.py` that calls the shared functions
-- Verify with `python -c "from dash_app.data.queries import load_initial_data; print(load_initial_data())"`
-### Blocked items:
-- None
-
-## Iteration 2 — 2026-02-06
-### Task: Phase 1 — Task 1.1 (Create shared data access functions)
-### Why this task:
-- Phase 0 complete in iteration 1; Phase 1 is next in dependency order
-- progress.txt from iteration 1 explicitly recommended this task
-- All UI components and callbacks (Phases 2-5) depend on having data access working
-### Status: COMPLETE
-### What was done:
-- Created `src/data_processing/pathway_queries.py` with two shared functions:
-  - `load_initial_data(db_path)` — returns available drugs (42), directorates (14), indications (32), total_records, last_updated
-  - `load_pathway_nodes(db_path, filter_id, chart_type, selected_drugs, selected_directorates)` — returns nodes list, unique_patients, total_drugs, total_cost, last_updated
-- Both functions extracted directly from AppState methods in pathways_app.py (lines 407-642), with Reflex `self.*` references replaced by function parameters
-- All return values are plain dicts/lists — JSON-serializable for dcc.Store
-- Created thin wrapper `dash_app/data/queries.py` that resolves DB_PATH and delegates to shared functions
-- Used separate file (pathway_queries.py) rather than adding to database.py because database.py is connection management (240 lines), queries are a distinct concern
-### Validation results:
-- Tier 1 (Code): `python -c "from dash_app.data.queries import load_initial_data"` — OK (requires uv run for .pth file)
-- Tier 1 (App starts): `from dash_app.app import app` — OK, layout type is MantineProvider
-- Tier 3 (Functional):
-  - `load_initial_data()`: 42 drugs, 14 directorates, 32 indications, last_updated=2026-02-06T00:08:55
-  - `load_pathway_data("all_6mo", "directory")`: 293 nodes, 11,118 patients, 39 drugs, £130.5M cost
-  - `load_pathway_data("all_6mo", "indication")`: 438 nodes, 11,252 patients
-  - `load_pathway_data("all_6mo", "directory", selected_drugs=["ADALIMUMAB"])`: 70 nodes (drug filter works)
-### Files changed:
-- `src/data_processing/pathway_queries.py` — NEW: shared query functions
-- `dash_app/data/queries.py` — NEW: thin Dash wrapper with DB_PATH resolution
-- `IMPLEMENTATION_PLAN.md` — Task 1.1 marked [x]
-### Committed: b71748f "feat: add shared pathway query functions for Dash data access (Task 1.1)"
-### Patterns discovered:
-- `src/` is on sys.path only when using `uv run` (via .pth file created by setup_dev.py). Running `python` directly won't find `data_processing` module. Always use `uv run python` for testing.
-- `total_records` from `pathway_refresh_log` returns 0 — the refresh log's `source_row_count` field appears empty despite `completed_at` having a value. This is cosmetic — the KPI can use `unique_patients` from chart-data instead.
-- Drug filtering correctly includes nodes with NULL drug_sequence (root, trust, directory levels) alongside matching drug nodes. Root node patient count becomes 0 when drug filter is active — this matches Reflex behavior.
-### Next iteration should:
-- Start Task 1.2 — Build directorate card tree from DimSearchTerm.csv
-- Create `dash_app/data/card_browser.py` with `build_directorate_tree()` and `get_all_drugs()`
-- Read `data/DimSearchTerm.csv` to understand the data format
-- Import SEARCH_TERM_MERGE_MAP from `data_processing.diagnosis_lookup` for asthma normalization
-- Remember: drug fragments in CleanedDrugName are UPPERCASE substrings, not exact matches
-### Blocked items:
-- None
-
-## Iteration 3 — 2026-02-06
-### Task: Phase 1 — Task 1.2 (Build directorate card tree from DimSearchTerm.csv)
-### Why this task:
-- Phase 1 data access layer needs both query functions (done in 1.1) AND the card browser data (this task)
-- Progress.txt from iteration 2 explicitly recommended this task
-- The drawer component (Phase 4) depends on this data structure
-### Status: COMPLETE
-### What was done:
-- Created `dash_app/data/card_browser.py` with two functions:
-  - `build_directorate_tree()` — reads DimSearchTerm.csv, applies SEARCH_TERM_MERGE_MAP, returns nested dict: {PrimaryDirectorate: {Search_Term: [drug_fragment, ...]}}
-  - `get_all_drugs()` — delegates to `load_initial_data()` from queries.py (no SQL duplication)
-- SEARCH_TERM_MERGE_MAP correctly imported from `data_processing.diagnosis_lookup`
-- Asthma variants ("allergic asthma", "severe persistent allergic asthma") merge into single "asthma" entry with combined/deduplicated drug fragments
-- Tree uses sets during construction to deduplicate drug fragments from merged terms, then converts to sorted lists
-### Validation results:
-- Tier 1 (Code): `from dash_app.data.card_browser import build_directorate_tree` — OK
-- Tier 1 (App starts): `from dash_app.app import app` — OK, layout type is MantineProvider
-- Tier 3 (Functional):
-  - `build_directorate_tree()`: 19 directorates, correctly nested dict
-  - CARDIOLOGY has 10 indications, CLINICAL HAEMATOLOGY has many more
-  - Asthma merge verified: only "asthma" present (not "allergic asthma" or "severe persistent allergic asthma"), OMALIZUMAB included in merged drug list
-  - `get_all_drugs()`: 42 drugs from pathway_nodes level 3
-### Files changed:
-- `dash_app/data/card_browser.py` — NEW: directorate tree builder + drug list accessor
-- `IMPLEMENTATION_PLAN.md` — Task 1.2 marked [x]
-### Committed: 7654942 "feat: add directorate card tree builder for drug browser drawer (Task 1.2)"
-### Patterns discovered:
-- `get_all_drugs()` uses a lazy import (`from dash_app.data.queries import load_initial_data`) to avoid circular imports since both modules are in `dash_app/data/`
-- Drug fragments in DimSearchTerm.csv are already UPPERCASE in the CSV, but `.upper()` is applied defensively
-- "diabetes" appears twice in DimSearchTerm.csv (DIABETIC MEDICINE and OPHTHALMOLOGY) — this is handled naturally by the directorate grouping (same search_term under two different directorates)
-### Next iteration should:
-- Start Phase 2: Task 2.1 — Header + sidebar components
-- Read `01_nhs_classic.html` to get the exact HTML structure, CSS classes, and SVG icons
-- Create `dash_app/components/header.py` with `make_header()` function
-- Create `dash_app/components/sidebar.py` with `make_sidebar()` function
-- Use CSS classes from nhs.css (`.top-header`, `.sidebar`, etc.) — NOT inline styles
-- Header needs placeholder `html.Span` with IDs for callback updates: `id="header-record-count"`, `id="header-last-updated"`
-- Sidebar needs click targets for drawer open (Drug Selection, Indications items)
-### Blocked items:
-- None
-
-## Iteration 4 — 2026-02-06
-### Task: Phase 2 — Task 2.1 (Header + sidebar components)
-### Why this task:
-- Phases 0 and 1 complete. Phase 2 is the static layout phase, and 2.1 is the first task.
-- Previous iteration (3) explicitly recommended this as the next task.
-- Header and sidebar are foundational layout components — everything else renders inside this shell.
-### Status: COMPLETE
-### What was done:
-- Created `dash_app/components/header.py` with `make_header()` function:
-  - Top bar with `.top-header` class, NHS logo badge, "HCD Analysis" title, breadcrumb
-  - Data freshness indicators: green status dot + `html.Span(id="header-record-count")` + `html.Span(id="header-last-updated")` for callback updates
-  - Structure matches `01_nhs_classic.html` lines 319-333 exactly
-- Created `dash_app/components/sidebar.py` with `make_sidebar()` function:
-  - 7 navigation items across 2 sections (Analysis: 5 items, Reports: 2 items)
-  - SVG icons from the HTML concept, embedded via data URI `html.Img` elements (Dash lacks inline SVG support)
-  - Added `.sidebar__icon` CSS class matching `.sidebar__item svg` sizing (18x18px)
-  - "Drug Selection" (`id="sidebar-drug-selection"`) and "Indications" (`id="sidebar-indications"`) have IDs + `n_clicks=0` for drawer callbacks in Phase 4
-  - Footer: "NHS Norfolk & Waveney ICB / High Cost Drugs Programme"
-- Updated `dash_app/app.py`:
-  - Imports and uses `make_header()` and `make_sidebar()`
-  - Layout: MantineProvider → [3 stores, Header, Nav(sidebar), Main(placeholder)]
-  - Main content area uses `html.Main(className="main")` — ready for KPIs/filter bar/chart card in Task 2.2
-### Validation results:
-- Tier 1 (Code): All imports OK — `from dash_app.components.header import make_header`, sidebar, app all pass
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 2 (Layout): Programmatic check confirms structure: MantineProvider with 6 children (3 stores + Header(top-header) + Nav(sidebar) + Main(main))
-### Files changed:
-- `dash_app/components/header.py` — NEW: header component
-- `dash_app/components/sidebar.py` — NEW: sidebar component with SVG icons
-- `dash_app/app.py` — Updated to import and assemble header + sidebar
-- `dash_app/assets/nhs.css` — Added `.sidebar__icon` rule
-- `IMPLEMENTATION_PLAN.md` — Task 2.1 marked [x]
-### Committed: bdc1690 "feat: add header and sidebar components for Dash layout (Task 2.1)"
-### Patterns discovered:
-- Dash doesn't support inline SVG elements natively (no `html.Svg` or similar). Workaround: embed SVG as data URI in `html.Img` elements using `urllib.parse.quote()`. Limitation: `stroke="currentColor"` doesn't inherit from parent CSS, so icons appear in their default SVG color (black) rather than inheriting the sidebar item color. This is cosmetic and acceptable for now.
-- Dash serves a minimal HTML shell; all React components render client-side. Don't test for CSS classes in the HTTP response — use programmatic layout inspection instead.
-- `html.A` elements in Dash accept `n_clicks=0` property, making them callback-compatible for click events (needed for sidebar drawer triggers).
-### Next iteration should:
-- Start Task 2.2 — Main content area: KPI row + filter bar + chart card
-- Create three component files:
-  - `dash_app/components/kpi_row.py` with `make_kpi_row()` — 4 KPI cards with IDs for callback updates
-  - `dash_app/components/filter_bar.py` with `make_filter_bar()` — chart type toggle pills + date dropdowns
-  - `dash_app/components/chart_card.py` with `make_chart_card()` — chart area with tabs + `dcc.Graph(id="pathway-chart")`
-- Read `01_nhs_classic.html` lines 377-516 for the exact structure
-- Use CSS classes: `.kpi-row`, `.kpi-card`, `.filter-bar`, `.toggle-pill`, `.chart-card`, `.chart-tab`
-- Filter bar needs: chart type toggle pills (By Directory / By Indication), Initiated dropdown, Last seen dropdown
-- Chart card needs: title, dynamic subtitle (hierarchy label), tab row (Icicle active, Sankey/Timeline disabled), `dcc.Graph`
-- KPI card IDs: `id="kpi-patients"`, `id="kpi-drugs"`, `id="kpi-cost"`, `id="kpi-match"`
-- Toggle pill IDs: `id="chart-type-directory"`, `id="chart-type-indication"`
-- Filter IDs: `id="filter-initiated"`, `id="filter-last-seen"`
-### Blocked items:
-- None
-
-## Iteration 5 — 2026-02-06
-### Task: Phase 2 — Task 2.2 (Main content area: KPI row + filter bar + chart card)
-### Why this task:
-- Phase 2.1 (header + sidebar) complete. Task 2.2 fills the main content area with actual components.
-- Previous iteration (4) explicitly recommended this as the next task.
-- The main area was a placeholder — this task adds the three core content sections.
-### Status: COMPLETE
-### What was done:
-- Created `dash_app/components/kpi_row.py` with `make_kpi_row()`:
-  - 4 KPI cards in a grid: Unique Patients, Drug Types, Total Cost, Indication Match
-  - Fourth card has `.kpi-card--green` modifier for green top border
-  - Each value has an ID for callback updates: `kpi-patients`, `kpi-drugs`, `kpi-cost`, `kpi-match`
-  - Default value is "—" (em dash) — populated by callbacks in Phase 3
-  - Helper `_kpi_card()` builds individual cards with CSS classes from nhs.css
-- Created `dash_app/components/filter_bar.py` with `make_filter_bar()`:
-  - Chart type toggle pills: "By Directory" (active) / "By Indication" with `.toggle-pill` CSS
-  - Button IDs: `chart-type-directory`, `chart-type-indication` with `n_clicks=0` for callbacks
-  - Initiated dropdown via `dcc.Dropdown`: All years (default), Last 2 years, Last 1 year
-  - Last seen dropdown via `dcc.Dropdown`: Last 6 months (default), Last 12 months
-  - Used `dcc.Dropdown` (not `html.Select`) for native Dash callback compatibility
-  - Drug/directorate dropdowns omitted — those go in the drawer (Phase 4)
-  - Added `.filter-dropdown` CSS to nhs.css for dcc.Dropdown sizing within filter bar
-- Created `dash_app/components/chart_card.py` with `make_chart_card()`:
-  - Card header with title "Patient Pathway Visualization" and dynamic subtitle (`id="chart-subtitle"`)
-  - Default subtitle: "Trust → Directorate → Drug → Patient Pathway"
-  - Tab row: Icicle (active), Sankey (disabled), Timeline (disabled)
-  - `dcc.Graph(id="pathway-chart")` with min-height 500px and display config
-  - Sankey/Timeline tabs are `disabled=True` placeholders for future expansion
-- Updated `dash_app/app.py`:
-  - Added imports for `make_kpi_row`, `make_filter_bar`, `make_chart_card`
-  - Main content area now: `[make_kpi_row(), make_filter_bar(), make_chart_card()]`
-  - Removed placeholder text
-### Validation results:
-- Tier 1 (Code): All imports pass — kpi_row, filter_bar, chart_card, app all import OK
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 2 (Layout): Verified programmatically:
-  - MantineProvider has 6 children (3 stores + header + sidebar + main)
-  - Main has 3 children: Section(kpi-row), Section(filter-bar), Section(chart-card)
-  - All 13 expected IDs found: app-state, chart-data, reference-data, kpi-patients, kpi-drugs, kpi-cost, kpi-match, chart-type-directory, chart-type-indication, filter-initiated, filter-last-seen, pathway-chart, chart-subtitle
-### Files changed:
-- `dash_app/components/kpi_row.py` — NEW: 4 KPI cards with callback-updatable values
-- `dash_app/components/filter_bar.py` — NEW: toggle pills + date filter dropdowns
-- `dash_app/components/chart_card.py` — NEW: chart header + tabs + dcc.Graph
-- `dash_app/app.py` — Updated: imports and assembles new components in main area
-- `dash_app/assets/nhs.css` — Added: `.filter-dropdown` CSS for dcc.Dropdown styling
-- `IMPLEMENTATION_PLAN.md` — Task 2.2 items marked [x]
-### Committed: 307563b "feat: add KPI row, filter bar, and chart card components (Task 2.2)"
-### Patterns discovered:
-- `dcc.Dropdown` must be used instead of `html.Select` for Dash callback compatibility. `html.Select` doesn't have a `value` property that triggers callbacks. `dcc.Dropdown` renders its own React-Select widget that needs CSS customization to match the `.filter-select` styling from the HTML concept.
-- `html.Button` with `n_clicks=0` works for toggle pills — callbacks can use `callback_context.triggered_id` to determine which button was clicked.
-- `dcc.Graph` accepts a `config` dict for mode bar customization (removing lasso/select, hiding logo).
-- Unicode arrow `\u2192` (→) used in chart subtitle for cross-platform compatibility.
-### Next iteration should:
-- Start Task 2.3 — Footer + full page assembly
-- Create `dash_app/components/footer.py` with `make_footer()` using `.page-footer` CSS class
-- Add footer to the main content area in `app.py` (below chart card)
-- Verify full page layout matches `01_nhs_classic.html` visually
-- The 3 dcc.Store components are already in place (added in Phase 0), so 2.3's store bullet is already done
-- After 2.3, Phase 2 will be complete — Phase 3 (Core Callbacks) is next
-- Phase 3.1 will need: reference data loading callback (on page load), filter state management callback (toggle pills + dropdowns → app-state), and `register_callbacks(app)` wiring
-### Blocked items:
-- None
-
-## Iteration 6 — 2026-02-06
-### Task: Phase 2 — Task 2.3 (Footer + full page assembly)
-### Why this task:
-- Tasks 2.1 and 2.2 complete. Task 2.3 is the final piece of Phase 2.
-- Previous iteration (5) explicitly recommended this as the next task.
-- Completing this marks Phase 2 done, enabling Phase 3 (Core Callbacks).
-### Status: COMPLETE
-### What was done:
-- Created `dash_app/components/footer.py` with `make_footer()`:
-  - Returns `html.Footer(className="page-footer")` matching 01_nhs_classic.html line 520
-  - Text: "NHS Norfolk and Waveney ICB — High Cost Drugs Analysis"
-- Updated `dash_app/app.py`:
-  - Added `make_footer` import
-  - Added `make_footer()` as 4th child in main content area (after chart card)
-- Full page layout now complete: MantineProvider → [3 stores, Header, Sidebar, Main(KPIs, Filter bar, Chart card, Footer)]
-- Note: dcc.Store components and page assembly were already done in earlier iterations. Task 2.3 effectively just needed the footer component.
-### Validation results:
-- Tier 1 (Code): `from dash_app.components.footer import make_footer` — OK, returns Footer with className="page-footer"
-- Tier 1 (App starts): `from dash_app.app import app` — OK, no errors
-- Tier 2 (Layout): Verified programmatically:
-  - MantineProvider: 6 children (3 stores + Header(top-header) + Nav(sidebar) + Main(main))
-  - Main: 4 children (Section(kpi-row), Section(filter-bar), Section(chart-card), Footer(page-footer))
-  - All component IDs present and correct
-### Files changed:
-- `dash_app/components/footer.py` — NEW: footer component
-- `dash_app/app.py` — Updated: import + added footer to main area
-- `IMPLEMENTATION_PLAN.md` — Task 2.3 marked [x]
-### Committed: 3568e03 "feat: add footer component and complete Phase 2 static layout (Task 2.3)"
-### Patterns discovered:
-- Phase 2 was incrementally built across iterations 4-6. The layout assembly (app.py) evolved naturally — each iteration added its components. No "big bang" assembly step was needed.
-### Next iteration should:
-- Start Phase 3: Task 3.1 — Reference data loading + filter state management
-- Create `dash_app/callbacks/filters.py` with two callbacks:
-  1. `load_reference_data`: fires on page load, calls `queries.load_initial_data()`, populates `reference-data` store + header record count + header last updated
-  2. `update_app_state`: fires when chart-type toggle buttons or date dropdowns change, computes `date_filter_id` from initiated+last_seen combo, updates `app-state` store, manages toggle pill active classes
-- Create `dash_app/callbacks/__init__.py` with `register_callbacks(app)` function
-- Wire `register_callbacks(app)` call in `app.py` after layout definition
-- Key IDs to use as inputs: `chart-type-directory`, `chart-type-indication` (n_clicks), `filter-initiated` (value), `filter-last-seen` (value)
-- Key IDs to use as outputs: `app-state` (data), `reference-data` (data), `header-record-count` (children), `header-last-updated` (children)
-- Date filter ID mapping: initiated "all"/"2yr"/"1yr" + last_seen "6mo"/"12mo" → e.g. "all_6mo", "1yr_12mo"
-- For toggle pills, use Output for className to toggle `toggle-pill--active` class
-- Read pathways_app/pathways_app.py lines 407-488 to understand the reference data structure
-### Blocked items:
-- None
-
-## Iteration 7 — 2026-02-06
-### Task: Phase 3 — Task 3.1 (Reference data loading + filter state management)
-### Why this task:
-- Phases 0-2 complete. Phase 3 is next in dependency order.
-- Previous iteration (6) explicitly recommended this as the next task.
-- All subsequent callbacks (3.2 chart data, 3.3 KPIs, 3.4 icicle chart) depend on filter state management from 3.1.
-### Status: COMPLETE
-### What was done:
-- Created `dash_app/callbacks/filters.py` with two callbacks:
-  1. `load_reference_data`: fires on page load via `dcc.Location` pathname Input, calls `queries.load_initial_data()`, populates `reference-data` store + header record count ("Data loaded" or "N records") + header last updated (date string)
-  2. `update_app_state`: fires on chart-type toggle clicks (n_clicks) + date dropdown changes (value), uses `ctx.triggered_id` to determine chart type, computes `date_filter_id` from `{initiated}_{last_seen}`, updates `app-state` store, toggles `toggle-pill--active` CSS class on pills
-- Created `dash_app/callbacks/__init__.py` with `register_callbacks(app)` function that imports and registers all callback modules
-- Wired `register_callbacks(app)` in `app.py` after layout definition
-- Added `dcc.Location(id="url", refresh=False)` to layout for page-load trigger
-- Initially used `app-state` as Input for `load_reference_data` but changed to `dcc.Location` to avoid re-firing on every filter change (would cause circular updates)
-### Validation results:
-- Tier 1 (Code): All imports pass — `filters.py`, `callbacks/__init__.py`, `app.py` all OK
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional):
-  - Both callbacks registered in `app.callback_map`: reference-data.data, app-state.data
-  - Reference data loads correctly: 42 drugs, 14 directorates, 32 indications, last updated 2026-02-06
-  - Date filter ID computation: all 6 combinations verified correct
-  - Toggle pill class toggling: active = "toggle-pill toggle-pill--active", inactive = "toggle-pill"
-### Files changed:
-- `dash_app/callbacks/filters.py` — NEW: load_reference_data + update_app_state callbacks
-- `dash_app/callbacks/__init__.py` — Updated: register_callbacks(app) with filter callback registration
-- `dash_app/app.py` — Updated: added dcc.Location, import + call register_callbacks(app)
-- `IMPLEMENTATION_PLAN.md` — Task 3.1 items marked [x]
-### Committed: eda35c7 "feat: add reference data loading and filter state callbacks (Task 3.1)"
-### Patterns discovered:
-- Dash 4.0.0 uses `ctx.triggered_id` (direct string) rather than the older `callback_context.triggered[0]["prop_id"]` parsing pattern. Simpler and more reliable.
-- Using `app-state` as Input for reference data loading creates circular updates: `update_app_state` writes app-state → `load_reference_data` fires → queries DB unnecessarily. Use `dcc.Location(id="url")` pathname as the page-load trigger instead.
-- `dcc.Location(refresh=False)` fires once on page load with `pathname="/"` — perfect for initialization callbacks.
-- `total_records` from `pathway_refresh_log.source_row_count` is still 0 (known since iteration 2). The header shows "Data loaded" as fallback text instead of "0 records".
-### Next iteration should:
-- Start Task 3.2 — Pathway data loading callback
-- Create the callback in `dash_app/callbacks/chart.py`:
-  - Input: `app-state` store (fires when filters change)
-  - Output: `chart-data` store
-  - Calls `queries.load_pathway_data(filter_id, chart_type, selected_drugs, selected_directorates)`
-  - Must handle initial page load (when app-state has default values) AND subsequent filter changes
-- Register in `dash_app/callbacks/__init__.py` alongside filter callbacks
-- Verify: changing date filter dropdown → app-state updates → chart-data store gets new pathway nodes
-- This is the bridge between filter state and chart rendering — 3.3 (KPIs) and 3.4 (icicle chart) both depend on chart-data being populated
-### Blocked items:
-- None
-
-## Iteration 8 — 2026-02-06
-### Task: Phase 3 — Task 3.2 (Pathway data loading callback)
-### Why this task:
-- Phase 3.1 (filter state management) is complete. Task 3.2 is the next dependency in the callback chain.
-- Previous iteration (7) explicitly recommended this task.
-- Tasks 3.3 (KPIs) and 3.4 (icicle chart) both depend on chart-data being populated by this callback.
-### Status: COMPLETE
-### What was done:
-- Created `dash_app/callbacks/chart.py` with `register_chart_callbacks(app)`:
-  - `load_pathway_data` callback: Input=`app-state` store, Output=`chart-data` store
-  - Extracts `date_filter_id`, `chart_type`, `selected_drugs`, `selected_directorates` from app-state
-  - Converts empty lists to None (so query function skips WHERE clause for unfiltered state)
-  - Lazy imports `queries.load_pathway_data` to avoid circular import at module level
-  - Returns `no_update` when app-state is empty (prevents query on initial empty state)
-- Registered in `dash_app/callbacks/__init__.py` alongside filter callbacks
-- Callback chain now complete: filter change → app-state → chart-data
-### Validation results:
-- Tier 1 (Code): `from dash_app.callbacks.chart import register_chart_callbacks` — OK
-- Tier 1 (App starts): `from dash_app.app import app` — OK, all 3 callbacks registered
-- Tier 3 (Functional): Verified callback chain with real data:
-  - Default (all_6mo, directory): 293 nodes, 11,118 patients, 39 drugs, £130.6M
-  - Indication chart: 438 nodes, 11,252 patients
-  - Drug filter (ADALIMUMAB): 70 nodes
-  - Date filter (2yr_12mo): 147 nodes, 5,104 patients
-  - JSON serialization verified — dcc.Store compatible
-### Files changed:
-- `dash_app/callbacks/chart.py` — NEW: pathway data loading callback
-- `dash_app/callbacks/__init__.py` — Updated: registers chart callback
-- `IMPLEMENTATION_PLAN.md` — Task 3.2 marked [x]
-### Committed: ad9fa1c "feat: add pathway data loading callback bridging filters to chart-data (Task 3.2)"
-### Patterns discovered:
-- Empty list `[]` from app-state needs conversion to `None` before passing to `load_pathway_nodes()`. The query function treats `None` as "no filter" (skips WHERE clause) but `[]` would create an empty IN clause returning zero results.
-- `no_update` is the correct return for when app-state is not yet populated (rather than returning an empty dict), since it prevents downstream callbacks from firing unnecessarily.
-### Next iteration should:
-- Start Task 3.3 — KPI update callback
-- Create `dash_app/callbacks/kpi.py`:
-  - Input: `chart-data` store
-  - Output: 4 KPI card values (`kpi-patients`, `kpi-drugs`, `kpi-cost`, `kpi-match`)
-  - Extract `unique_patients`, `total_drugs`, `total_cost` from chart-data
-  - Format: patients with commas (e.g., "11,118"), cost as "£130.6M", drugs as plain number
-  - Indication match rate: could be "~93%" (from CLAUDE.md) or computed from data — check if chart-data has match info
-- Register in callbacks/__init__.py
-- After 3.3, move to Task 3.4 (icicle chart rendering) — the final core callback
-- Task 3.4 requires reading `pathways_app/pathways_app.py` lines 769-920 for the icicle figure construction, then adding `create_icicle_from_nodes()` to `src/visualization/plotly_generator.py`
-### Blocked items:
-- None
-
-## Iteration 9 — 2026-02-06
-### Task: Phase 3 — Task 3.3 (KPI update callback)
-### Why this task:
-- Phase 3.2 (pathway data loading) is complete. Task 3.3 is next in the callback chain.
-- Previous iteration (8) explicitly recommended this task.
-- KPI cards currently show "—" placeholders — this callback populates them with real data.
-### Status: COMPLETE
-### What was done:
-- Created `dash_app/callbacks/kpi.py` with `register_kpi_callbacks(app)`:
-  - `update_kpis` callback: Input=`chart-data` + `app-state`, Output=4 KPI card values
-  - Formats: patients with commas (11,118), drugs as plain number (39), cost as £130.6M
-  - `_format_cost()` helper handles M/K/plain thresholds
-  - 4th KPI (Indication Match): shows "~93%" when chart_type is "indication", "—" otherwise
-  - Returns `no_update` when chart-data is empty (prevents clearing KPIs during load)
-- Registered in `dash_app/callbacks/__init__.py` — now 4 callbacks total
-- Decision: Indication match rate is static "~93%" because:
-  - Reflex app's `indication_match_rate` was never dynamically computed (always 0.0 → "—")
-  - Computing from nodes would require detecting "(no GP dx)" labels, adding complexity for marginal value
-  - ~93% is the documented rate from the SNOMED cluster matching pipeline
-### Validation results:
-- Tier 1 (Code): `from dash_app.callbacks.kpi import register_kpi_callbacks` — OK
-- Tier 1 (App starts): `from dash_app.app import app` — OK, 4 callbacks registered
-- Tier 3 (Functional):
-  - Cost formatting: 130.5M → £130.5M, 50K → £50.0K, 999 → £999
-  - Directory chart: 11,118 patients, 39 drugs, £130.6M, Match = —
-  - Indication chart: Match = ~93%
-  - All 4 KPI output IDs registered: kpi-patients, kpi-drugs, kpi-cost, kpi-match
-### Files changed:
-- `dash_app/callbacks/kpi.py` — NEW: KPI update callback with formatting
-- `dash_app/callbacks/__init__.py` — Updated: registers kpi callback
-- `IMPLEMENTATION_PLAN.md` — Task 3.3 marked [x]
-### Committed: 9c971c0 "feat: add KPI update callback with formatted patient/drug/cost display (Task 3.3)"
-### Patterns discovered:
-- `\u00a3` (£) is the safe way to embed the pound sign in Python strings — avoids encoding issues with source files
-- `no_update` tuple must match the number of outputs: `return no_update, no_update, no_update, no_update` for 4 outputs
-- The `app-state` is used as a secondary Input (not just `chart-data`) to get `chart_type` for the indication match KPI — this is fine since `app-state` changes trigger `chart-data` changes which also trigger this callback
-### Next iteration should:
-- Start Task 3.4 — Icicle chart rendering callback (the final core callback)
-- Two sub-tasks:
-  1. Add `create_icicle_from_nodes(nodes, title)` to `src/visualization/plotly_generator.py`
-     - Read `pathways_app/pathways_app.py` lines 769-920 for the exact Plotly go.Icicle construction
-     - Extract the 10-field customdata, NHS blue colorscale, texttemplate, hovertemplate
-     - Keep existing `create_icicle_figure(ice_df)` untouched — add new function alongside
-  2. Add `update_chart` callback to `dash_app/callbacks/chart.py`
-     - Input: `chart-data` store, Output: `pathway-chart` figure
-     - Calls `create_icicle_from_nodes(chart_data["nodes"], title)`
-     - Dynamic title based on chart type
-- IMPORTANT: Read the guardrails about the icicle figure — must use NHS blue gradient, not Viridis
-- After 3.4, Phase 3 is complete — Phase 4 (Drawer) is next
-### Blocked items:
-- None
-
-## Iteration 10 — 2026-02-06
-### Task: Phase 3 — Task 3.4 (Icicle chart rendering callback)
-### Why this task:
-- Tasks 3.1-3.3 complete. Task 3.4 is the final task in Phase 3.
-- Previous iteration (9) explicitly recommended this task.
-- This is the most critical callback — it renders the actual Plotly icicle chart from pathway data.
-### Status: COMPLETE
-### What was done:
-- Added `create_icicle_from_nodes(nodes, title)` to `src/visualization/plotly_generator.py`:
-  - Accepts list-of-dicts (the JSON format from dcc.Store / load_pathway_nodes)
-  - Same 10-field customdata structure as Reflex icicle_figure (value, colour, cost, costpp, first_seen, last_seen, first_seen_parent, last_seen_parent, average_spacing, cost_pp_pa)
-  - NHS blue gradient colorscale: Heritage Blue #003087 → Pale Blue #E3F2FD (5 stops)
-  - Same texttemplate and hovertemplate strings as Reflex version
-  - maxdepth=3, branchvalues="total", sort=False
-  - Layout: transparent background, reduced margins (t:40, l:8, r:8, b:24), autosize
-  - Font: Source Sans 3 (matching nhs.css) instead of Inter (Reflex used Inter)
-  - Existing `create_icicle_figure(ice_df)` left completely untouched
-- Added `update_chart` callback to `dash_app/callbacks/chart.py`:
-  - Input: chart-data store + app-state store
-  - Output: pathway-chart figure + chart-subtitle children
-  - Calls `create_icicle_from_nodes(chart_data["nodes"], title)`
-  - Dynamic subtitle: "Trust → Directorate → Drug → Pathway" or "Trust → Indication → Drug → Pathway"
-- Added `_generate_chart_title()` helper mirroring Reflex `_generate_pathway_chart_title()`:
-  - Formats: "By Directory | All years / Last 6 months" (default)
-  - Handles drug/directorate selections in title
-### Validation results:
-- Tier 1 (Code): `from visualization.plotly_generator import create_icicle_from_nodes` — OK
-- Tier 1 (Code): `from dash_app.callbacks.chart import register_chart_callbacks` — OK
-- Tier 1 (App starts): `from dash_app.app import app` — OK, 5 callbacks registered
-- Tier 3 (Functional):
-  - Directory chart: 293 nodes → Figure with 1 icicle trace, 293 labels, 10-field customdata
-  - Indication chart: 438 nodes → Figure renders correctly
-  - Colorscale starts at (0.0, '#003087') — NHS Heritage Blue confirmed
-  - Title: "Patient Pathways — By Directory | All years / Last 6 months"
-  - All 14 expected layout IDs present
-### Files changed:
-- `src/visualization/plotly_generator.py` — Added: create_icicle_from_nodes() function (115 lines)
-- `dash_app/callbacks/chart.py` — Rewritten: added update_chart callback + _generate_chart_title helper
-- `IMPLEMENTATION_PLAN.md` — Task 3.4 items marked [x]
-### Committed: 40ce7fc "feat: add icicle chart rendering with NHS colorscale and dynamic titles (Task 3.4)"
-### Patterns discovered:
-- The Reflex version uses "Inter" font; switched to "Source Sans 3" to match the nhs.css design reference. This is the only intentional deviation from the Reflex code.
-- `\u00a3` (£) works in Plotly template strings for the pound sign — no encoding issues.
-- The `update_chart` callback uses both `chart-data` (for nodes) and `app-state` (for chart_type to determine subtitle) as Inputs. Both fire when filters change, but Dash deduplicates — the callback runs once with both updated values.
-- `_generate_chart_title()` is a module-level function (not inside `register_chart_callbacks`) so it can be tested independently.
-### Next iteration should:
-- Start Phase 4: Task 4.1 — dmc.Drawer layout
-- Create `dash_app/components/drawer.py` with `make_drawer()` function:
-  - `dmc.Drawer(id="drug-drawer", position="right", size="480px")`
-  - Top section: "All Drugs" card with flat alphabetical drug list from pathway_nodes level 3
-  - Below: one card per PrimaryDirectorate from DimSearchTerm.csv with dmc.Accordion per Search_Term
-  - Drug chips with pattern-matching IDs: `{"type": "drug-chip", "index": drug_name}`
-  - Bottom: "Clear Filters" button
-- Read `01_nhs_classic.html` for drawer styling if applicable (though drawer is mostly DMC-styled)
-- Use `build_directorate_tree()` from `dash_app/data/card_browser.py` (already built in Task 1.2)
-- Use `get_all_drugs()` from `dash_app/data/card_browser.py` for the flat drug list
-- Add drawer to the app layout in `app.py`
-- IMPORTANT: DMC version is 2.5.1 (Mantine v7 based). Check DMC 2.x API for Drawer, Accordion, Chip — prop names may differ from 0.14.x. E.g., `dmc.Drawer` may use `opened` instead of `open`, `onClose` instead of `on_close`.
-### Blocked items:
-- None
-
-## Iteration 11 — 2026-02-06
-### Task: Phase 4 — Task 4.1 (dmc.Drawer layout)
-### Why this task:
-- Phases 0-3 are complete. Phase 4 (Directorate Card Browser) is next in dependency order.
-- Iteration 10 explicitly recommended this as the next task.
-- The drawer layout is needed before drawer callbacks (Task 4.2) can be built.
-### Status: COMPLETE
-### What was done:
-- Created `dash_app/components/drawer.py` with `make_drawer()` function:
-  - `dmc.Drawer(id="drug-drawer", position="right", size="480px", opened=False)`
-  - Title: "Drug & Indication Browser" via `dmc.Text`
-  - ScrollArea wrapping all content for vertical overflow
-  - **All Drugs section**: `dmc.ChipGroup(id="all-drugs-chips", multiple=True)` with 42 drug chips from pathway_nodes level 3
-  - **Directorate section**: Nested `dmc.Accordion` with 19 directorates, each containing an inner accordion of indications (163 total). Drug fragments shown as `dmc.Badge` with pattern-match IDs `{"type": "drug-fragment", "index": "DIRECTORATE|FRAGMENT"}`
-  - **Clear button**: `dmc.Button("Clear All Filters", id="clear-drug-filters", variant="outline", color="red")`
-- Added drawer CSS to `dash_app/assets/nhs.css`:
-  - `.drawer-section`, `.drawer-section-title`, `.drawer-chips-wrap`, `.drawer-drug-badge`, `.drawer-directorate-accordion`, `.drawer-clear-btn`
-  - Chip font-family override to Source Sans 3
-  - Badge hover effect for drug fragments
-- Updated `dash_app/app.py`:
-  - Added `make_drawer()` import and placed drawer in MantineProvider children (after sidebar, before main)
-### Validation results:
-- Tier 1 (Code): `from dash_app.components.drawer import make_drawer` — OK
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 2 (Layout): Verified programmatically:
-  - MantineProvider: 8 children (4 stores/location + Header + Nav + Drawer + Main)
-  - Drawer: position=right, size=480px, opened=False
-  - All Drugs ChipGroup: 42 chips, multiple=True
-  - Directorate Accordion: 19 directorates, 163 indications
-  - 433 IDs in layout (mostly drug-fragment pattern-match IDs)
-  - Key IDs present: drug-drawer, all-drugs-chips, clear-drug-filters
-  - App has 5 callbacks registered (same as before — no new callbacks in this layout-only task)
-### Files changed:
-- `dash_app/components/drawer.py` — NEW: drawer component with drug chips and directorate cards
-- `dash_app/app.py` — Updated: imports and adds drawer to layout
-- `dash_app/assets/nhs.css` — Added: drawer-specific CSS classes
-- `IMPLEMENTATION_PLAN.md` — Task 4.1 marked [x]
-### Committed: 5dc552f "feat: add dmc.Drawer drug browser with directorate cards and drug chips (Task 4.1)"
-### Patterns discovered:
-- DMC 2.5.1 `dmc.Chip` doesn't expose `n_clicks`. It's a controlled component that works through `dmc.ChipGroup` with `value` prop (list of selected values when `multiple=True`). This is simpler than pattern-matching callbacks for drug selection — a single callback on `all-drugs-chips.value` replaces N individual chip click handlers.
-- DMC 2.5.1 `dmc.Drawer` uses `opened` (not `open`), consistent with Mantine v7 API.
-- `dmc.AccordionControl` + `dmc.AccordionPanel` inside `dmc.AccordionItem` is the DMC 2.x pattern. Nesting accordions works — directorate accordion → indication accordion inside.
-- Drug fragments use `dmc.Badge` (not `dmc.Chip`) because they're informational/action triggers, not multi-select toggles. Badge IDs use pattern-matching format `{"type": "drug-fragment", "index": "DIR|FRAG"}` for callback handling in 4.2.
-- The drawer data is loaded at layout time (module-level `make_drawer()` call during app import), not lazily. This is fine since the data is small (~165 CSV rows + 42 drugs from SQLite) and only runs once at app startup.
-### Next iteration should:
-- Start Task 4.2 — Drawer callbacks
-- Create `dash_app/callbacks/drawer.py` with `register_drawer_callbacks(app)`:
-  1. **Open/close drawer**: sidebar "Drug Selection" (`id="sidebar-drug-selection"`, n_clicks) or "Indications" (`id="sidebar-indications"`, n_clicks) click → set `drug-drawer.opened=True`. Drawer's built-in close (X button, overlay click) handles closing via `opened` prop.
-  2. **Drug chip selection**: `all-drugs-chips.value` (ChipGroup value change) → update `app-state.selected_drugs` → triggers chain: app-state → chart-data → KPIs + chart
-  3. **Drug fragment click**: `{"type": "drug-fragment", "index": ALL}.n_clicks` → match fragment against full drug names → select matching drugs in `all-drugs-chips.value` + `app-state.selected_drugs`
-  4. **Clear filters**: `clear-drug-filters.n_clicks` → reset `app-state.selected_drugs=[]` + `all-drugs-chips.value=[]`
-- Register in `dash_app/callbacks/__init__.py`
-- Key consideration: The `all-drugs-chips` ChipGroup value must stay in sync with `app-state.selected_drugs`. Consider whether to use `all-drugs-chips.value` as the source of truth (simpler) or `app-state.selected_drugs` (needed for other callbacks). May need a two-way sync or just derive one from the other.
-- IMPORTANT: Clicking a drug fragment badge should filter to drugs whose FULL names contain that fragment (substring match). The fragment "PEGYLATED" would match "PEGYLATED INTERFERON ALFA-2A" for example. The matching logic should use `drug_name.upper().find(fragment) >= 0`.
-### Blocked items:
-- None
-
-## Iteration 12 — 2026-02-06
-### Task: Phase 4 — Task 4.2 (Drawer callbacks)
-### Why this task:
-- Phase 4.1 (drawer layout) complete. Task 4.2 adds the interactivity to the drawer.
-- Iteration 11 explicitly recommended this as the next task.
-- Without callbacks, the drawer can't open or affect the chart — it's just a static component.
-### Status: COMPLETE
-### What was done:
-- Created `dash_app/callbacks/drawer.py` with `register_drawer_callbacks(app)`:
-  1. `open_drawer`: Input = sidebar-drug-selection + sidebar-indications n_clicks → Output = drug-drawer.opened = True. Drawer's built-in close (X / overlay) handles closing.
-  2. `handle_fragment_or_clear`: Input = drug-fragment badges (pattern-matching ALL) n_clicks + clear-drug-filters n_clicks → Output = all-drugs-chips.value
-     - Fragment click: extracts fragment from `{"type": "drug-fragment", "index": "DIR|FRAG"}`, finds all drugs containing the fragment (substring match), toggles them in chip selection
-     - Clear click: sets chip value to empty list `[]`
-     - Toggle behavior: if all matching drugs already selected, deselects them; otherwise adds them
-- Modified `dash_app/callbacks/filters.py` `update_app_state`:
-  - Added `all-drugs-chips.value` as 5th Input (after date filter dropdowns)
-  - When chip selection changes, `selected_drugs` in app-state is updated
-  - This completes the callback chain: chip change → app-state → chart-data → chart + KPIs
-- Registered drawer callbacks in `dash_app/callbacks/__init__.py` — now 7 callbacks total
-- Design decision: `all-drugs-chips.value` (ChipGroup) is the visual source of truth for drug selection. The drawer callbacks write to it, and `update_app_state` reads from it to sync into `app-state.selected_drugs`. No `allow_duplicate` needed — clean unidirectional flow.
-### Validation results:
-- Tier 1 (Code): All imports pass — drawer.py, filters.py, callbacks/__init__.py, app.py
-- Tier 1 (App starts): MantineProvider layout, 7 callbacks registered, app ready to serve
-- Tier 3 (Functional):
-  - Callback chain verified: sidebar clicks → drawer opens (drug-drawer.opened Output)
-  - Fragment matching: "ADALIMUMAB" → matches ["ADALIMUMAB"], "RITUXI" → matches ["RITUXIMAB"]
-  - Some fragments (PEGYLATED, INHALED) match 0 drugs in pathway_nodes — returns no_update (correct behavior: those fragments may reference drugs not in current data)
-  - Clear button → empty chip list → app-state.selected_drugs = [] → full chart reload
-  - update_app_state Input list confirmed: 5 Inputs (2 toggle pills + 2 dropdowns + 1 ChipGroup)
-### Files changed:
-- `dash_app/callbacks/drawer.py` — NEW: open_drawer + handle_fragment_or_clear callbacks
-- `dash_app/callbacks/__init__.py` — Updated: registers drawer callbacks
-- `dash_app/callbacks/filters.py` — Updated: added all-drugs-chips.value as Input to update_app_state
-- `IMPLEMENTATION_PLAN.md` — Task 4.2 marked [x]
-### Committed: fe76e5a "feat: add drawer callbacks for drug selection, fragment matching, and clear (Task 4.2)"
-### Patterns discovered:
-- `dmc.ChipGroup.value` is the cleanest way to manage multi-select drug state. The ChipGroup handles visual selection state internally; callbacks only need to update the `value` prop (list of selected values). No per-chip n_clicks tracking needed.
-- Fragment badge IDs use format `{"type": "drug-fragment", "index": "DIRECTORATE|FRAGMENT"}`. The directorate prefix is stripped with `split("|", 1)[-1]` to get the pure fragment for substring matching.
-- Pattern-matching `Input({"type": "drug-fragment", "index": ALL}, "n_clicks")` with `prevent_initial_call=True` is essential — without it, the callback fires on page load with all n_clicks as None/0, which would trigger `no_update`.
-- The toggle behavior (click fragment → select matching drugs; click again → deselect) is implemented by checking if all matching drugs are already in the current selection.
-- `allow_duplicate=True` was avoided by routing all drug selection through `all-drugs-chips.value` → `update_app_state`. Only one callback writes to each Output.
-### Next iteration should:
-- Start Phase 5: Task 5.1 — Trust selection
-- Options for trust selection:
-  - Add a "Trusts" section to the drawer (preferred — keeps all filters together)
-  - OR add trust checkboxes in the sidebar
-- Implementation: add `dmc.ChipGroup(id="trust-chips", multiple=True)` to the drawer with available trusts from reference-data
-- Wire trust selection similarly to drug selection: trust-chips.value → update_app_state → app-state.selected_trusts → chart reload
-- Check `src/data_processing/pathway_queries.py` `load_pathway_nodes()` — does it support a `selected_trusts` parameter? If not, add trust filtering to the query.
-- Read `pathways_app/pathways_app.py` for how trust filtering was handled in Reflex
-- ALTERNATIVE: Skip 5.1 for now and do 5.2 (loading/error/empty states) which is more impactful for UX polish. Trust selection is less critical since there are few trusts.
-### Blocked items:
-- None
-
-## Iteration 13 — 2026-02-06
-### Task: Phase 5 — Task 5.1 (Trust selection)
-### Why this task:
-- Phases 0-4 complete. Phase 5 is the final polish phase.
-- Task 5.1 is the first task in Phase 5 and adds the last major filter dimension (trust).
-- Previous iteration (12) recommended this as the next task.
-### Status: COMPLETE
-### What was done:
-- Added `available_trusts` to `load_initial_data()` in `src/data_processing/pathway_queries.py`:
-  - Queries `SELECT DISTINCT trust_name FROM pathway_nodes WHERE level = 1` — returns 7 trusts
-  - Updated both error return paths to include `available_trusts: []`
-- Added `selected_trusts` parameter to `load_pathway_nodes()`:
-  - Trust WHERE clause: `trust_name IN (...) OR trust_name IS NULL OR trust_name = ''`
-  - The NULL/empty check keeps root nodes (level 0) which have no trust_name
-- Updated `dash_app/data/queries.py` wrapper to pass `selected_trusts` through
-- Added `get_all_trusts()` to `dash_app/data/card_browser.py` (same pattern as `get_all_drugs()`)
-- Added trust ChipGroup to drawer (`dash_app/components/drawer.py`):
-  - `dmc.ChipGroup(id="trust-chips", multiple=True)` with 7 trust chips
-  - New "Trusts" section between "All Drugs" and "By Directorate" with dividers
-- Updated sidebar (`dash_app/components/sidebar.py`):
-  - "Trust Selection" item now has `item_id="sidebar-trust-selection"` for drawer open callback
-- Updated callbacks:
-  - `drawer.py`: Added `sidebar-trust-selection` as Input to `open_drawer`; added `trust-chips.value` as second Output to `handle_fragment_or_clear` (clear button resets both drug and trust chips)
-  - `filters.py`: Added `trust-chips.value` as 6th Input to `update_app_state`; added `selected_trusts` to app-state dict
-  - `chart.py`: Passes `selected_trusts` to query function; includes trusts in chart title
-- Updated `app.py`: Added `selected_trusts: []` to default app-state
-### Validation results:
-- Tier 1 (Code): All imports pass, 7 callbacks registered
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional):
-  - `load_initial_data()`: 7 trusts returned
-  - Unfiltered: 293 nodes, 11,118 patients
-  - One trust (NNUH): 107 nodes, 33 drugs — correct reduction
-  - Two trusts: 181 nodes — correct intermediate reduction
-  - Indication + trust filter: 158 nodes — works across chart types
-  - Chart figure renders correctly from filtered nodes (107 labels)
-  - Trust chips in drawer: 7 chips, multiple=True
-### Files changed:
-- `src/data_processing/pathway_queries.py` — Added: available_trusts query + selected_trusts filter
-- `dash_app/data/queries.py` — Updated: pass selected_trusts parameter
-- `dash_app/data/card_browser.py` — Added: get_all_trusts()
-- `dash_app/components/drawer.py` — Added: trust ChipGroup section
-- `dash_app/components/sidebar.py` — Updated: Trust Selection gets item_id for drawer open
-- `dash_app/callbacks/drawer.py` — Updated: trust sidebar opens drawer; clear resets trust chips
-- `dash_app/callbacks/filters.py` — Updated: trust-chips.value as Input + selected_trusts in state
-- `dash_app/callbacks/chart.py` — Updated: pass selected_trusts to query; trusts in chart title
-- `dash_app/app.py` — Updated: selected_trusts in default app-state
-- `IMPLEMENTATION_PLAN.md` — Task 5.1 marked [x]
-### Committed: f0505ee "feat: add trust selection to drawer with filter wiring (Task 5.1)"
-### Patterns discovered:
-- Trust filtering needs `trust_name IS NULL OR trust_name = ''` in the WHERE clause to keep root nodes (level 0) and the "Total" parent that have empty trust_name. Without this, the icicle chart would lose its root.
-- Adding a second Output (`trust-chips.value`) to `handle_fragment_or_clear` requires returning `no_update` for the trust output on fragment clicks (only the clear button affects trusts). All return paths must return a tuple of 2 values.
-- The `get_all_trusts()` / `get_all_drugs()` pattern delegates to `load_initial_data()` to avoid duplicating SQL queries. This means only one SQLite connection for all reference data.
-### Next iteration should:
-- Start Task 5.2 — Loading/error/empty states + dynamic hierarchy label
-- Add `dcc.Loading` wrapper around the chart card's `dcc.Graph` component
-- Show a "No data" message when chart-data has no nodes (e.g., after filtering to a trust with no matching drugs)
-- Show error feedback when database query fails
-- Note: Dynamic chart subtitle is ALREADY implemented (Task 3.4 added `chart-subtitle` Output). Check if 5.2's subtitle bullet can be marked done.
-- Consider: `dcc.Loading(type="circle", color="#005EB8")` wrapping the `dcc.Graph` for a loading spinner during SQLite queries
-### Blocked items:
-- None
-
-## Iteration 14 — 2026-02-06
-### Task: Phase 5 — Task 5.2 (Loading/error/empty states + dynamic hierarchy label)
-### Why this task:
-- Task 5.1 complete. Task 5.2 is the next incomplete task in Phase 5.
-- Iteration 13 explicitly recommended this task.
-- Adds UX polish: loading spinner during data fetch, empty state when filters match nothing, error handling for database failures.
-### Status: COMPLETE
-### What was done:
-- Added `dcc.Loading(type="circle", color="#005EB8")` wrapper around `dcc.Graph` in `chart_card.py`:
-  - Wraps a `html.Div(id="chart-container")` containing the `dcc.Graph(id="pathway-chart")`
-  - NHS blue spinner appears while chart data is loading
-- Added `_empty_figure(message)` helper in `dash_app/callbacks/chart.py`:
-  - Returns a blank Plotly figure with a centered annotation message
-  - Uses `#768692` (NHS mid-grey) for text color, Source Sans 3 font
-  - Used for both empty state and error state
-- Modified `update_chart` callback to handle three states:
-  1. **Error**: `chart_data.get("error")` → shows error message in empty figure
-  2. **Empty**: `not chart_data.get("nodes")` → shows "No matching pathways found. Try adjusting your filters."
-  3. **Normal**: renders icicle chart as before
-  - Subtitle is always computed (even for empty/error states) to keep the hierarchy label consistent
-- Added error handling to `load_pathway_data` callback:
-  - `try/except Exception` wraps the query call
-  - On failure, logs the exception and returns `{"nodes": [], "error": "Database query failed. Check logs for details."}`
-  - Downstream callbacks (KPIs, chart) gracefully handle empty data
-- Dynamic chart subtitle was already implemented in Task 3.4 — marked as done in IMPLEMENTATION_PLAN.md
-### Validation results:
-- Tier 1 (Code): All imports pass — chart.py, chart_card.py, app.py
-- Tier 1 (App starts): `from dash_app.app import app` — OK, 7 callbacks registered
-- Tier 2 (Layout): dcc.Loading found in chart card: type=circle, color=#005EB8, wrapping chart-container → pathway-chart
-- Tier 3 (Functional):
-  - Empty figure renders annotation: "No matching pathways found.\nTry adjusting your filters."
-  - Error figure renders annotation: "Database query failed. Check logs for details."
-  - KPIs show em-dash for all values when data is empty (0 patients, 0 drugs, £0)
-### Files changed:
-- `dash_app/components/chart_card.py` — Updated: added dcc.Loading wrapper around dcc.Graph
-- `dash_app/callbacks/chart.py` — Updated: added _empty_figure helper, error handling in load_pathway_data, empty/error states in update_chart
-- `IMPLEMENTATION_PLAN.md` — Task 5.2 marked [x]
-### Committed: 5593d08 "feat: add loading spinner, empty state, and error handling to chart area (Task 5.2)"
-### Patterns discovered:
-- `_empty_figure()` uses Plotly annotations on a blank figure (no traces) for empty/error states. This is cleaner than returning an empty `go.Figure()` (which shows grid lines) because `xaxis.visible=False, yaxis.visible=False` hides all axes.
-- `dcc.Loading` wraps children — when any Output inside changes, the spinner appears. Wrapping `dcc.Graph` directly in `dcc.Loading` is sufficient since `pathway-chart.figure` is the Output that triggers loading state.
-- The `update_chart` callback now computes subtitle BEFORE checking for empty/error data. This ensures the hierarchy label stays consistent even when showing empty state (previously `no_update` was returned for both figure and subtitle, which could leave a stale subtitle).
-### Next iteration should:
-- Start Task 5.3 — Data freshness indicator
-- The header already has `id="header-record-count"` and `id="header-last-updated"` spans (created in Task 2.1)
-- The `load_reference_data` callback in `dash_app/callbacks/filters.py` already populates these on page load
-- Check what the current values show — may just need formatting improvements (relative time like "2h ago")
-- `load_initial_data()` returns `last_updated` as an ISO datetime string and `total_records` (which is 0 from pathway_refresh_log)
-- Consider using `datetime` to compute relative time from `last_updated`, or just show the date
-- After 5.3, only 5.4 (Remove Reflex + final validation) remains
-### Blocked items (iter 14):
-- None
-
-## Iteration 15 — 2026-02-06
-### Task: Phase 5 — Task 5.3 (Data freshness indicator)
-### Why this task:
-- Task 5.2 complete. Task 5.3 is the next incomplete task in Phase 5.
-- Iteration 14 explicitly recommended this task.
-- The header already had placeholder spans for record count and last updated — this task makes them useful.
-### Status: COMPLETE
-### What was done:
-- Added `_format_relative_time(iso_timestamp)` helper to `dash_app/callbacks/filters.py`:
-  - Parses ISO timestamp and returns relative time: "just now", "15m ago", "3h ago", "yesterday", "4d ago", "1w ago", or "23 Dec 2025" for older dates
-  - Handles empty strings, invalid dates gracefully
-- Added `total_patients` field to `load_initial_data()` in `src/data_processing/pathway_queries.py`:
-  - Queries root node (level 0) value from default filter (all_6mo, directory) as patient count
-  - Only runs when `total_records` is 0 (source_row_count empty in refresh log — known issue)
-  - Returns 11,118 patients for current data
-- Updated `load_reference_data` callback to use both improvements:
-  - Record text: "11,118 patients" (comma-formatted, falls back to "Data loaded" if no data)
-  - Updated text: "14h ago" (relative time from last_updated ISO timestamp)
-  - Matches design reference in 01_nhs_classic.html: green dot + "{N} records" + "Last updated: 2h ago"
-### Validation results:
-- Tier 1 (Code): All imports pass, app starts, 7 callbacks registered
-- Tier 1 (App starts): `from dash_app.app import app` — OK
-- Tier 3 (Functional):
-  - Relative time formatting: tested 10 cases (just now, minutes, hours, yesterday, days, weeks, months, empty, invalid, actual value) — all correct
-  - Record text: "11,118 patients" — correct
-  - Updated text: "14h ago" — correct (refresh was at 2026-02-06T00:08:55)
-### Files changed:
-- `src/data_processing/pathway_queries.py` — Added: total_patients query from root node
-- `dash_app/callbacks/filters.py` — Added: _format_relative_time helper, updated load_reference_data
-- `IMPLEMENTATION_PLAN.md` — Task 5.3 marked [x]
-### Committed: e877268 "feat: add data freshness indicator with relative time and patient count (Task 5.3)"
-### Patterns discovered:
-- `total_records` from `pathway_refresh_log.source_row_count` is always 0 for this project. The `total_patients` field from the root node's `value` is a better alternative for the header display.
-- `datetime.fromisoformat()` handles the SQLite timestamp format (`2026-02-06T00:08:55.812828`) natively in Python 3.10+.
-- The relative time helper is a standalone function (not inside `register_filter_callbacks`) for testability.
-### Next iteration should:
-- Start Task 5.4 — Remove Reflex + final validation
-- This is the FINAL task. Sub-items:
-  1. Remove `reflex` from `pyproject.toml` dependencies
-  2. Move `pathways_app/` to `archive/` (don't delete — keep for reference)
-  3. Delete `pathways_app/styles.py` and any Reflex-specific files
-  4. Update `CLAUDE.md` to document the Dash app structure, new run command (`python run_dash.py`), callback architecture
-  5. Run `python run_dash.py` — verify app starts cleanly
-  6. Verify no Reflex imports in `dash_app/`
-  7. Run `uv sync` after removing reflex dependency
-- IMPORTANT: Read the completion criteria at bottom of IMPLEMENTATION_PLAN.md — all must be satisfied
-- After 5.4, check if ALL tasks are [x] and output the COMPLETE signal
-### Blocked items:
-- None
-
-## Iteration 16 — 2026-02-06
-### Task: Phase 5 — Task 5.4 (Remove Reflex + final validation)
-### Why this task:
-- Tasks 5.1-5.3 complete. Task 5.4 is the FINAL task in the entire implementation plan.
-- Iteration 15 explicitly recommended this task.
-- This removes the Reflex dependency, archives the old app, updates documentation, and validates everything.
-### Status: COMPLETE
-### What was done:
-- Removed `reflex>=0.6.0` from `pyproject.toml` dependencies
-- Ran `uv sync` — removed ~30 Reflex-related packages (reflex, starlette, uvicorn, sqlalchemy, etc.)
-- Moved `pathways_app/` to `archive/pathways_app/` via `git mv` (preserves git history)
-- Moved `rxconfig.py` to `archive/rxconfig.py` via `git mv`
-- Verified zero Reflex imports in `dash_app/` (grep returned no matches)
-- Updated `CLAUDE.md` comprehensively:
-  - "Reflex framework" → "Dash (Plotly) + Dash Mantine Components"
-  - Run command: `reflex run` → `python run_dash.py`, port 3000 → 8050
-  - Package structure: `pathways_app/` section replaced with full `dash_app/` tree
-  - New sections: Shared Data Queries (pathway_queries.py), Dash Application state/callbacks/components
-  - Data flow diagram: Reflex AppState → Dash callback chain
-  - Updated all "Reflex" references to "Dash" throughout
-  - Visualization module: documented `create_icicle_from_nodes()` alongside existing function
-- Ran comprehensive validation — all 10 completion criteria PASS:
-  1. App starts cleanly at localhost:8050
-  2. Layout matches design (MantineProvider → stores + header + sidebar + drawer + main)
-  3. Icicle chart renders 293 nodes with NHS blue gradient and 10-field customdata
-  4. Callback chain fires correctly through all 7 callbacks
-  5. Drawer contains 19 directorates, 163 indications, drug fragment badges
-  6. Drug selection filters chart (ADALIMUMAB: 293 → 70 nodes)
-  7. ChipGroup with 42 drugs, multiple=True
-  8. Clear button resets drug and trust chips → full chart reload
-  9. KPIs update: 11,118 patients, 39 drugs, £130.6M
-  10. Zero Reflex imports in dash_app/
-### Validation results:
-- Tier 1 (Code): All imports pass, app starts, 7 callbacks registered
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional): All 10 completion criteria pass (validated by subagent)
-### Files changed:
-- `pyproject.toml` — Removed: reflex dependency
-- `uv.lock` — Updated: removed Reflex packages
-- `pathways_app/` → `archive/pathways_app/` — Archived via git mv
-- `rxconfig.py` → `archive/rxconfig.py` — Archived via git mv
-- `CLAUDE.md` — Rewritten: Reflex → Dash documentation
-- `IMPLEMENTATION_PLAN.md` — Task 5.4 marked [x], all completion criteria marked [x]
-### Committed: fe8642d "feat: remove Reflex, archive old app, update docs for Dash migration (Task 5.4)"
-### Patterns discovered:
-- `uv sync` after removing a large dependency (reflex) cleanly removes all transitive dependencies (~30 packages). No manual cleanup needed.
-- `git mv` preserves rename history — `git log --follow archive/pathways_app/pathways_app.py` shows the full commit history.
-- `.web/` (Reflex's generated frontend) is gitignored so doesn't need archiving. Can be manually deleted.
-### Next iteration should:
-- ALL TASKS COMPLETE. No next iteration needed.
-### Blocked items (iter 16):
-- None
-
-## Iteration 17 — 2026-02-06
-### Task: Phase 6 — Update all documentation
-### Why this task:
-- Phases 0-5 complete. Phase 6 (documentation cleanup) was the only remaining work.
-- All non-archive .md files still referenced Reflex (commands, architecture, deployment).
-### Status: COMPLETE
-### What was done:
-- **README.md**: Complete rewrite — replaced `reflex run` with `python run_dash.py`, updated features list (dual charts, pre-computed pathways, drug browser), updated project structure (dash_app/ instead of pathways_app/), updated quick start, usage, troubleshooting
-- **docs/USER_GUIDE.md**: Complete rewrite — new single-page Dash UI guide covering header, sidebar, KPI row, filter bar, chart card, drawer, drug browser, indication matching
-- **docs/DEPLOYMENT.md**: Complete rewrite — Dash/Gunicorn deployment replacing Reflex/FastAPI/Next.js, Docker examples, nginx config, systemd service, single port 8050
-- **docs/DESIGN_SYSTEM.md**: Updated "Reflex Implementation" section → "Dash Implementation" with correct CSS/component references
-- **RALPH_PROMPT.md**: Updated title ("Dash Application Maintenance" not "Reflex → Dash Migration"), updated data reference section to point to src/ shared functions instead of pathways_app/
-- **guardrails.md**: Updated 3 rules to reflect current Dash architecture (shared utilities exist, icicle function exists, data queries exist) instead of migration instructions
-- **IMPLEMENTATION_PLAN.md**: Phase 6 tasks marked [x]
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 7 callbacks registered
-- Grep for Reflex in non-archive .md files: only CLAUDE.md line 140 (archive description — accurate) and IMPLEMENTATION_PLAN.md (historical migration log — accurate)
-### Files changed:
-- README.md — Rewritten for Dash
-- docs/USER_GUIDE.md — Rewritten for Dash
-- docs/DEPLOYMENT.md — Rewritten for Dash
-- docs/DESIGN_SYSTEM.md — Updated implementation section
-- RALPH_PROMPT.md — Updated title and references
-- guardrails.md — Updated 3 rules
-- IMPLEMENTATION_PLAN.md — Phase 6 marked [x]
-- progress.txt — This entry
-### Patterns discovered:
-- archive/ files (IMPROVEMENT_RECOMMENDATIONS.md) retain Reflex references intentionally — they're historical
-- IMPLEMENTATION_PLAN.md retains Reflex references in completed task descriptions — these are accurate migration history
-### Next iteration should:
-- Phase 6 is complete. All tasks across all phases are now [x].
-### Blocked items:
-- None
-
-## Phases 0-6 COMPLETE (17 iterations)
-- Phase 0: Scaffolding (2 tasks) — iteration 1
-- Phase 1: Data Access (2 tasks) — iterations 2-3
-- Phase 2: Static Layout (3 tasks) — iterations 4-6
-- Phase 3: Core Callbacks (4 tasks) — iterations 7-10
-- Phase 4: Drawer (2 tasks) — iterations 11-12
-- Phase 5: Polish & Cleanup (4 tasks) — iterations 13-16
-- Phase 6: Documentation (4 tasks) — iteration 17
-
----
-
-## Phase 7: Bug Fixes & UI Restructure (NEW)
-
-User testing revealed 2 bugs and several UX issues. Phase 7 addresses all of them.
-
-### Known Bugs
-
-**Bug 1 — Duplicate ID on first load:**
-`DuplicateIdError: Duplicate component id found in the initial layout: {"index":"CARDIOLOGY|RIVAROXABAN","type":"drug-fragment"}`
-- Only happens on first `python run_dash.py` load. Subsequent refreshes are fine.
-- Root cause: In `drawer.py:66`, badge IDs are `f"{directorate}|{frag}"` but the same fragment can appear under multiple indications within the same directorate. E.g., RIVAROXABAN appears under both "acute coronary syndrome" and "atrial fibrillation" within CARDIOLOGY.
-- Fix: Include search_term in the ID: `f"{directorate}|{search_term}|{frag}"`. Update callback parsing in `drawer.py` to handle the 3-part key.
-
-**Bug 2 — Drug filter breaks icicle chart ("multiple implied roots"):**
-Console error: `WARN: Multiple implied roots, cannot build icicle hierarchy of trace 0`
-- Happens when selecting ANY drug from the All Drugs chip group — chart goes blank.
-- Root cause: `pathway_queries.py:load_pathway_nodes()` applies the `drug_sequence LIKE` filter to ALL levels. This drops ancestor nodes (root, trust, directory levels 0-2) that don't have a drug_sequence matching the filter. Without ancestors, the icicle chart sees disconnected subtrees.
-- Fix: Restructure the WHERE clause so drug/directorate/trust filters only apply to the appropriate levels. Ancestor nodes (level 0-2) must ALWAYS be included. The WHERE logic should be: `WHERE date_filter_id = ? AND chart_type = ? AND (level < 3 OR drug_sequence LIKE ?)` — or similar approach that preserves the parent chain.
-- IMPORTANT: Check if the same issue affects trust and directorate filters too.
-
-### UX Issues
-
-**UX 1 — Sidebar has wrong items:**
-- "Cost Analysis" and "Export Data" have no functionality — remove them.
-- Drug/Trust/Directory/Indication items open the same drawer — confusing. These filter triggers should move to the filter bar.
-- Sidebar should contain chart VIEW selectors (Icicle, Sankey, Timeline) instead.
-
-**UX 2 — Single drawer for all filters doesn't work:**
-- Too much scrolling, confusing that 3-4 buttons open the same panel.
-- Replace `dmc.Drawer` with `dmc.Modal` dialogs — one per filter type (Drugs, Trusts, Directorates).
-- Each modal opened by a button in the filter bar (with selection count badge).
-
-### Task Dependency Order for Phase 7
-
-1. **Task 7.1** (duplicate ID fix) — standalone, no dependencies. Do this first.
-2. **Task 7.2** (filter query fix) — standalone, no dependencies. Can be done right after 7.1.
-3. **Task 7.3** (sidebar restructure) — remove items, add chart view buttons. No modal dependency.
-4. **Task 7.4** (replace drawer with modals) — depends on 7.3 (sidebar items removed). This is the biggest task. **Use the frontend-developer agent** to design the modal UX.
-5. **Task 7.5** (filter triggers in filter bar) — depends on 7.4 (modals exist to open).
-
-### Next iteration should:
-- Start with Task 7.1 (duplicate ID fix) — it's the simplest and most isolated.
-- Read `dash_app/components/drawer.py` line 66 — the badge ID construction.
-- Read `dash_app/callbacks/drawer.py` line 48 — the fragment key parsing.
-- Read `dash_app/data/card_browser.py` — `build_directorate_tree()` to understand the data shape and where duplicates come from.
-- Fix the ID to include search_term, update the callback parsing, verify no DuplicateIdError on first load.
-
-## Iteration 18 — 2026-02-06
-### Task: Phase 7 — Task 7.1 (Fix duplicate component ID error on first load)
-### Why this task:
-- First task in Phase 7, simplest and most isolated bug fix
-- Progress.txt from Phase 7 setup explicitly recommended starting here
-- No dependencies on other Phase 7 tasks
-### Status: COMPLETE
-### What was done:
-- Changed badge ID format in `drawer.py:66` from `f"{directorate}|{frag}"` to `f"{directorate}|{search_term}|{frag}"`
-- Updated callback fragment parsing in `callbacks/drawer.py:48` from `split("|", 1)[-1]` to `rsplit("|", 1)[-1]` (split from right to extract just the fragment from the 3-part key)
-- Verified 544 IDs in drawer component — all unique, zero duplicates
-- Confirmed 90+ duplicate fragments existed across directorates (CARDIOLOGY, CLINICAL HAEMATOLOGY, MEDICAL ONCOLOGY, RHEUMATOLOGY, etc.)
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 7 callbacks registered
-- Tier 1 (App starts): Layout access succeeds, no DuplicateIdError
-- Tier 3 (Functional): Fragment parsing verified for 3-part key ("CARDIOLOGY|acute coronary syndrome|RIVAROXABAN" → "RIVAROXABAN"), 2-part key fallback, and standalone key
-### Files changed:
-- `dash_app/components/drawer.py` — Updated: badge ID includes search_term (line 66)
-- `dash_app/callbacks/drawer.py` — Updated: fragment parsing uses rsplit (line 48)
-- `IMPLEMENTATION_PLAN.md` — Task 7.1 marked [x]
-### Committed: 7be136a "fix: resolve DuplicateIdError by including search_term in drug-fragment badge IDs (Task 7.1)"
-### Patterns discovered:
-- `rsplit("|", 1)[-1]` is the correct way to extract the last segment from a multi-part key. `split("|", 1)[-1]` would return everything after the first pipe, which fails for 3+ part keys.
-- The DuplicateIdError only occurred on first load because Dash validates layout IDs during initial render. `suppress_callback_exceptions=True` only suppresses callback-related ID checks, not layout duplication.
-- Over 90 drug fragments are shared across multiple indications within the same directorate — this is expected because drugs are prescribed for multiple conditions.
-### Next iteration should:
-- Start Task 7.2 — Fix drug filter breaking the icicle chart ("multiple implied roots")
-- Read `src/data_processing/pathway_queries.py` — the `load_pathway_nodes()` function
-- The WHERE clause applies `drug_sequence LIKE %DRUG%` to ALL levels, dropping ancestor nodes (root, trust, directory levels 0-2) that have NULL drug_sequence
-- Fix: restructure WHERE so levels 0-2 are always included, drug filter only applies to level >= 3
-- Also check if trust/directorate filters have the same issue (ancestor nodes dropping)
-- Verify: select a drug → chart renders correctly with full hierarchy intact
-### Blocked items:
-- None
-
-## Iteration 19 — 2026-02-06
-### Task: Phase 7 — Task 7.2 (Fix drug filter breaking icicle chart)
-### Why this task:
-- Task 7.1 complete in iteration 18. Task 7.2 is next in Phase 7 dependency order.
-- Progress.txt from iteration 18 explicitly recommended this task.
-- Critical bug — selecting ANY drug made the chart go blank with "multiple implied roots" error.
-### Status: COMPLETE
-### What was done:
-- Diagnosed root cause in `src/data_processing/pathway_queries.py:load_pathway_nodes()`:
-  - Levels 0-2 have `drug_sequence = ''` (empty string), NOT `drug_sequence IS NULL`
-  - The drug filter's `OR drug_sequence IS NULL` check didn't match empty strings
-  - Same bug existed for directorate filter: `directory = ''` at levels 0-1, but check was `OR directory IS NULL`
-  - Trust filter was already correct (had `OR trust_name = ''`)
-- Fixed drug filter: `(level < 3 OR drug_sequence LIKE ...)` — levels 0-2 always included
-- Fixed directorate filter: `(level < 2 OR directory IN (...) OR directory IS NULL OR directory = '')` — levels 0-1 always included
-- Verified all filter combinations preserve single-root hierarchy:
-  - Drug only (ADALIMUMAB): 120 nodes, root present
-  - Directorate only (RHEUMATOLOGY): 94 nodes, root present
-  - Trust only (NNUH): 107 nodes, root present
-  - Drug + Trust combined: 45 nodes, root present
-  - Indication chart + drug: 195 nodes, root present
-- Verified icicle charts render correctly from all filtered datasets
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 7 callbacks registered
-- Tier 1 (App starts): `python run_dash.py` — serves at http://127.0.0.1:8050/ — no errors
-- Tier 3 (Functional): All 5 filter combinations produce valid hierarchy with single root node; icicle charts render correctly
-### Files changed:
-- `src/data_processing/pathway_queries.py` — Fixed: drug and directorate WHERE clauses use level-based gating
-- `IMPLEMENTATION_PLAN.md` — Task 7.2 marked [x], completion criterion for drug filter marked [x]
-### Committed: 00627a7 "fix: preserve ancestor nodes in drug/directorate filters to prevent broken icicle hierarchy (Task 7.2)"
-### Patterns discovered:
-- `drug_sequence` and `directory` columns use empty string `''` (not NULL) for ancestor nodes (levels 0-2). The `IS NULL` check is insufficient — must use level-based gating (`level < N`) to unconditionally include ancestor nodes.
-- Level-based gating is cleaner than checking for NULL/empty: `(level < 3 OR drug_filter_condition)` clearly expresses the intent that ancestors are always kept.
-- Trust filter already worked because it had `OR trust_name = ''` in addition to `OR trust_name IS NULL`.
-### Next iteration should:
-- Start Task 7.3 — Restructure sidebar: remove placeholder items, add chart view buttons
-- Read `dash_app/components/sidebar.py` to see current items
-- Remove: "Cost Analysis", "Export Data" (no functionality)
-- Remove: "Drug Selection", "Trust Selection", "Directory Selection", "Indications" (these become filter bar buttons in Task 7.5)
-- Add: chart view buttons — "Icicle Chart" (active), "Sankey Diagram" (disabled), "Timeline" (disabled)
-- Keep: "Pathway Overview" as the top active item
-- Remove the tab row from `dash_app/components/chart_card.py` (chart view selection moves to sidebar)
-- Update sidebar IDs and any callbacks that reference removed IDs (e.g., `sidebar-drug-selection`, `sidebar-trust-selection`, `sidebar-indications` are used in drawer.py `open_drawer` callback)
-### Blocked items:
-- None
-
-## Iteration 20 — 2026-02-06
-### Task: Phase 7 — Task 7.3 (Restructure sidebar: chart views, remove placeholder items)
-### Why this task:
-- Tasks 7.1 and 7.2 (bug fixes) complete. Task 7.3 is next in Phase 7 dependency order.
-- Progress.txt from iteration 19 explicitly recommended this task.
-- Tasks 7.4 (modals) and 7.5 (filter bar triggers) depend on the sidebar being cleaned up first.
-### Status: COMPLETE
-### What was done:
-- **Sidebar restructured** (`dash_app/components/sidebar.py`):
-  - Removed 6 items: Drug Selection, Trust Selection, Directory Selection, Indications, Cost Analysis, Export Data
-  - Renamed "Analysis" section to "Overview" (now contains only "Pathway Overview")
-  - Added "Chart Views" section with: "Icicle Chart" (active), "Sankey Diagram" (disabled), "Timeline" (disabled)
-  - New SVG icons for chart views: icicle (stacked bars), sankey (flow lines), timeline (dots on line)
-  - Sidebar footer preserved
-- **Chart card tab row removed** (`dash_app/components/chart_card.py`):
-  - Removed the 3-tab row (Icicle/Sankey/Timeline) — chart view selection is now in the sidebar
-  - Chart card now contains only header (title + subtitle) and the loading-wrapped dcc.Graph
-- **Drawer open callback removed** (`dash_app/callbacks/drawer.py`):
-  - Removed `open_drawer` callback that referenced removed sidebar IDs (`sidebar-drug-selection`, `sidebar-indications`, `sidebar-trust-selection`)
-  - Fragment matching and clear callbacks preserved (still functional via drawer component in layout)
-  - Callback count dropped from 7 to 6
-- **CSS updated** (`dash_app/assets/nhs.css`):
-  - Added `.sidebar__item--disabled` class (opacity 0.4, cursor not-allowed, pointer-events none)
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 6 callbacks registered
-- Tier 2 (Layout):
-  - Sidebar: 2 sections (Overview: 1 item, Chart Views: 3 items), footer present
-  - Icicle Chart: active, Sankey/Timeline: disabled
-  - Chart card: no tab row, header + graph only
-  - Removed IDs confirmed absent: sidebar-drug-selection, sidebar-indications, sidebar-trust-selection
-  - Drawer still in layout (will be replaced in Task 7.4): drug-drawer, all-drugs-chips, trust-chips all present
-### Files changed:
-- `dash_app/components/sidebar.py` — Rewritten: removed filter items, added chart views
-- `dash_app/components/chart_card.py` — Updated: removed tab row
-- `dash_app/callbacks/drawer.py` — Updated: removed open_drawer callback
-- `dash_app/assets/nhs.css` — Added: .sidebar__item--disabled CSS
-- `IMPLEMENTATION_PLAN.md` — Task 7.3 marked [x], completion criteria updated
-### Committed: 7aa49b0 "refactor: restructure sidebar with chart views, remove placeholder items (Task 7.3)"
-### Patterns discovered:
-- When removing sidebar items that are referenced by callbacks (e.g., `sidebar-drug-selection` as Input to `open_drawer`), the callback must also be removed or updated. Dash will error on startup if a callback references an ID not in the layout and `suppress_callback_exceptions=False`, but with `suppress_callback_exceptions=True` it would silently fail. Removing the callback is cleaner.
-- The drawer component (and its drug/trust chips) can remain in the layout even after removing the way to open it. The `all-drugs-chips` and `trust-chips` IDs are still referenced by `update_app_state`, so they must remain until the modals replace them in Task 7.4.
-### Next iteration should:
-- Start Task 7.4 — Replace dmc.Drawer with dmc.Modal for filter selection
-- This is the biggest remaining task. Sub-steps:
-  1. **Use the frontend-developer agent** to design the modal UX: 42 drugs, 7 trusts, 19 directorates × 163 indications. Agent should recommend optimal modal layout, sizing, and interaction patterns.
-  2. Create `dash_app/components/modals.py` (or separate files per modal) with:
-     - Drug Selection modal (`dmc.Modal`, contains current `all-drugs-chips` ChipGroup)
-     - Trust Selection modal (`dmc.Modal`, contains current `trust-chips` ChipGroup)
-     - Directorate Browser modal (`dmc.Modal`, contains nested directorate accordion)
-  3. Remove `dash_app/components/drawer.py` and the `make_drawer()` call from `app.py`
-  4. Update callback wiring — `update_app_state` Inputs change from chip IDs in drawer to chip IDs in modals (or keep same IDs if modal components use the same IDs)
-  5. Modal IDs: `drug-modal`, `trust-modal`, `directorate-modal` (each needs `opened` state)
-- Read `dash_app/components/drawer.py` to understand the current chip/accordion structure
-- Read `dash_app/callbacks/drawer.py` to understand fragment matching logic
-- The simplest approach: move the same ChipGroup and accordion components from the drawer into modals with the SAME IDs, avoiding any callback rewiring
-- After 7.4, Task 7.5 adds trigger buttons in the filter bar to open each modal
-### Blocked items:
-- None
-
-## Iteration 21 — 2026-02-06
-### Task: Phase 7 — Tasks 7.4 + 7.5 (Replace drawer with modals + filter bar triggers)
-### Why this task:
-- Tasks 7.1-7.3 complete. Task 7.4 is next in Phase 7 dependency order.
-- Progress.txt from iteration 20 explicitly recommended this task.
-- Tasks 7.4 and 7.5 are tightly coupled — modals (7.4) need trigger buttons (7.5) to open them, so both done together.
-### Status: COMPLETE
-### What was done:
-- **Used frontend-developer agent** to design modal UX for 3 filter types:
-  - Drug Selection: `size="lg"`, centered, with selection count badge in title
-  - Trust Selection: `size="sm"`, centered, minimal layout for 7 items
-  - Directorate Browser: `size="xl"`, centered, with nested accordion
-  - Live filtering (no "Apply" button) — matches existing behavior
-  - Per-modal and global "Clear" buttons
-- **Created `dash_app/components/modals.py`**:
-  - `make_drug_modal()`: dmc.Modal with ChipGroup (id=all-drugs-chips, same as drawer), count badge, clear button
-  - `make_trust_modal()`: dmc.Modal with ChipGroup (id=trust-chips, same as drawer), count badge, clear button
-  - `make_directorate_modal()`: dmc.Modal with nested accordion (same structure as drawer), drug fragment badges with pattern-matching IDs, clear button
-  - `make_modals()`: returns all three modals in a wrapper div
-  - Component IDs preserved from drawer — no callback rewiring needed
-- **Updated `dash_app/components/filter_bar.py`**:
-  - Added 3 filter trigger buttons: "Drugs", "Trusts", "Directorates" with count badge spans
-  - Added "Clear All" button for global filter reset
-  - Buttons use new `.filter-btn` CSS class
-- **Created `dash_app/callbacks/modals.py`**:
-  - 3 modal open callbacks (one per modal, triggered by filter bar buttons)
-  - `handle_selection_actions`: unified callback for fragment matching + 4 clear triggers (per-drug, per-trust, directorate modal, global)
-  - `update_count_badges`: updates both filter bar badges and modal header badges
-- **Updated `dash_app/app.py`**: replaced `make_drawer()` with `make_modals()`
-- **Updated `dash_app/callbacks/__init__.py`**: registers modal callbacks instead of drawer
-- **Deleted `dash_app/components/drawer.py`** and **`dash_app/callbacks/drawer.py`** (dead code after modal replacement)
-- **Updated `dash_app/assets/nhs.css`**: replaced drawer CSS with filter-btn and modal CSS classes
-- **Removed search inputs** from drug and directorate modals — dynamic chip filtering conflicts with Dash's callback architecture (ChipGroup children can't be both layout-defined and callback-output). 42 drugs is scannable without search.
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 10 callbacks registered
-- Tier 1 (App starts): `python run_dash.py` — "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 2 (Layout):
-  - 3 modals in layout: drug-modal, trust-modal, directorate-modal (all centered, correctly sized)
-  - 32 string IDs, 540 pattern-match IDs — zero duplicates
-  - All key IDs present: modal IDs, trigger buttons, count badges, chip groups
-  - Filter bar has: toggle pills + date dropdowns + divider + Drugs/Trusts/Directorates buttons + Clear All
-- Tier 3 (Functional):
-  - Callback chain verified: open-drug-modal → drug-modal.opened, etc.
-  - Fragment matching preserved: drug-fragment badges → all-drugs-chips.value
-  - Clear buttons: clear-drug-selection → drugs only, clear-trust-selection → trusts only, clear-all-filters → both
-  - Count badges: all-drugs-chips.value + trust-chips.value → filter-btn badges + modal header badges
-  - App-state chain: chip values → update_app_state → chart-data → chart + KPIs (unchanged)
-### Files changed:
-- `dash_app/components/modals.py` — NEW: 3 filter modals (drug, trust, directorate)
-- `dash_app/callbacks/modals.py` — NEW: modal open/close, selection actions, count badges
-- `dash_app/components/filter_bar.py` — Updated: added trigger buttons + clear all
-- `dash_app/app.py` — Updated: replaced drawer with modals
-- `dash_app/callbacks/__init__.py` — Updated: registers modal callbacks
-- `dash_app/assets/nhs.css` — Updated: replaced drawer CSS with filter-btn + modal CSS
-- `dash_app/components/drawer.py` — DELETED (replaced by modals.py)
-- `dash_app/callbacks/drawer.py` — DELETED (replaced by modals.py)
-- `IMPLEMENTATION_PLAN.md` — Tasks 7.4, 7.5 marked [x], all completion criteria marked [x]
-### Committed: f2c5b26 "refactor: replace dmc.Drawer with dmc.Modal for filter selection (Task 7.4 + 7.5)"
-### Patterns discovered:
-- Reusing the same component IDs (all-drugs-chips, trust-chips, drug-fragment pattern) when migrating from drawer to modals means zero callback rewiring. The callbacks don't care whether the component is inside a Drawer or Modal — they reference by ID.
-- dmc.Modal title prop can contain components with IDs (e.g., dmc.Badge with id="drug-modal-count"). Dash finds these during callback resolution even though they're in the title prop, not children.
-- dmc.Modal with `centered=True` and `overlayProps={"backgroundOpacity": 0.55, "blur": 3}` gives a clean modern feel.
-- Dynamic chip filtering in Dash is architecturally difficult because ChipGroup children are set at layout time and can't easily be toggled without making children an Output (which conflicts with value already being an Output). Search input deferred to future enhancement.
-- Filter bar button count badges use CSS class toggling (hidden/visible) rather than conditional rendering — simpler with Dash's callback model.
-### All tasks COMPLETE:
-- ALL tasks in IMPLEMENTATION_PLAN.md are now marked [x]
-- ALL completion criteria are satisfied
-### Next iteration should:
-- ALL TASKS COMPLETE. No next iteration needed.
-- Run final validation: `python run_dash.py`, verify all 13 completion criteria at bottom of IMPLEMENTATION_PLAN.md.
-### Blocked items:
-- None
-
-## Iteration 22 — 2026-02-06
-### Task: Section 8 — Both tasks (prune empty ancestors + KPIs reflect filters)
-### Why this task:
-- All Phase 7 tasks complete. Section 8 had 2 remaining unchecked items.
-- Task 8.1 (hide empty directorates when filtering drugs) is a visible UX issue: filtering by Immunoglobulin showed 42 empty directorate boxes.
-- Task 8.2 (KPIs reflect filtered data) was partially working but KPIs showed unfiltered root node totals (11,118 patients / £130.5M) even when a single drug was selected.
-- Both tasks are in the same file (`pathway_queries.py`) so done together.
-### Status: COMPLETE
-### What was done:
-- **Empty ancestor pruning** (`_prune_empty_ancestors()`):
-  - Added after row fetch in `load_pathway_nodes()`, activated when drug or directorate filters are present
-  - Two-pass algorithm: first keeps root (L0), leaves (L3+), and nodes referenced as parents; second pass rechecks L1 nodes still have L2 children
-  - IMMUNOGLOBULIN filter: 54 nodes → 10 nodes (1 root, 1 trust, 4 directorates, 4 drugs)
-  - All filter combinations tested: single root, zero level 1-2 orphans, icicle charts render correctly
-  - Pre-existing level 3+ orphans (pathway sequences like INFLIXIMAB→ADALIMUMAB where parent drug doesn't match filter) are unrelated to this change and don't affect chart rendering
-- **Filtered KPI values**:
-  - When any entity filter (drug, directorate, trust) is active, `unique_patients` and `total_cost` are summed from level-3 drug nodes instead of using root node's pre-computed totals
-  - IMMUNOGLOBULIN: 78 patients, £3.8M (was 11,118 / £130.5M)
-  - ADALIMUMAB: 3,236 patients, £29.2M
-  - NNUH trust: 5,887 patients, £74.5M
-  - No filter: unchanged (11,118 / £130.6M — uses root node as before)
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 10 callbacks registered
-- Tier 1 (App starts): `python run_dash.py` — "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional):
-  - 8 filter combinations tested: no filter, IMMUNOGLOBULIN, ADALIMUMAB, multi-drug, directorate, trust, drug+trust, indication+drug
-  - All produce valid icicle hierarchy (single root, zero level 1-2 orphans)
-  - All icicle charts render via create_icicle_from_nodes()
-  - KPI values reflect filtered data in all cases
-### Files changed:
-- `src/data_processing/pathway_queries.py` — Added: _prune_empty_ancestors(), filtered KPI summation
-- `IMPLEMENTATION_PLAN.md` — Section 8 tasks marked [x]
-### Committed: de08d4b "fix: prune empty ancestor nodes and update KPIs for filtered views (Section 8)"
-### Patterns discovered:
-- `_prune_empty_ancestors` uses a two-pass approach: first pass identifies nodes referenced as parents, second pass verifies L1 nodes still have L2 children after the first prune. This handles cascading (trust with no kept directorates → trust removed).
-- Level 3+ orphans in drug-filtered results are expected: pathway sequences like INFLIXIMAB→ADALIMUMAB have a parent drug node (INFLIXIMAB) that doesn't match the ADALIMUMAB filter. Plotly silently drops these orphaned leaf nodes, which is correct behavior for displaying filtered pathways.
-- KPI summation at level 3 (drug nodes) is the right level because drug nodes represent the total patients/cost for that drug under a directorate. Summing level 4+ (pathway nodes) would double-count.
-### All tasks COMPLETE:
-- ALL tasks in IMPLEMENTATION_PLAN.md are now marked [x], including Section 8
-- ALL completion criteria are satisfied
-### Next iteration should:
-- ALL TASKS COMPLETE. No next iteration needed.
-### Blocked items:
-- None
-
----
-
-## Manual Intervention — 2026-02-06
-### Reason: Add 7 new analytics chart tabs (Phase 9)
-### Changes made:
-- IMPLEMENTATION_PLAN.md: Added Phase 9 with tasks 9.1–9.10 (10 tasks covering infrastructure, queries, 7 charts, and polish)
-- progress.txt: Added this intervention entry with context for next iteration
-- guardrails.md: Added tab architecture guardrails (lazy rendering, single dcc.Graph, active_tab in app-state)
-- RALPH_PROMPT.md: Updated focus description to reference Phase 9 analytics charts
-### Tasks reset: none (all previous work valid — this is purely additive)
-### Tasks added:
-- 9.1: Parsing utilities + tab infrastructure (tabs in chart_card.py, remove sidebar chart views)
-- 9.2: Query functions for all 7 chart types (in src/data_processing/pathway_queries.py)
-- 9.3: First-Line Market Share — horizontal grouped bar chart
-- 9.4: Pathway Cost Effectiveness — lollipop/dot plot with retention annotations
-- 9.5: Cost Waterfall — Plotly waterfall chart by directorate
-- 9.6: Drug Switching Sankey — Sankey diagram of treatment line transitions
-- 9.7: Dosing Interval Comparison — grouped bars from parsed average_spacing
-- 9.8: Directorate × Drug Heatmap — matrix chart with count/cost toggle
-- 9.9: Treatment Duration — horizontal bars of avg_days by drug
-- 9.10: Final integration, polish, documentation
-### Context for next iteration:
-- Previous 22 iterations completed the full Dash migration (Phases 0–8). The app runs at http://localhost:8050 with icicle chart, filters, KPIs.
-- Phase 9 adds 7 new chart tabs alongside the existing icicle chart.
-- **Architecture**: Tab bar goes INSIDE `chart_card.py` (replacing the sidebar chart view items). Use `dmc.Tabs` or `dcc.Tabs`. Store `active_tab` in `app-state`.
-- **Sidebar changes**: Remove "Chart Views" section from sidebar.py. Keep "Overview" section.
-- **Lazy rendering**: Only compute the active tab's chart. Check `active_tab` in the chart callback and dispatch to the correct figure builder.
-- **Shared code**: New query functions in `src/data_processing/pathway_queries.py`. New figure functions in `src/visualization/`. Thin wrappers in `dash_app/data/queries.py`.
-- **Parsing**: `ids` column at level 4+ has format `"TRUST - DIRECTORY - DRUG_A - DRUG_A|DRUG_B"`. Split by ` - `, take level 3+ segments, split by `|` for drug sequence.
-- **average_spacing**: HTML string like `"given X times with Y weekly interval"` — needs regex parsing.
-- **Existing chart callback**: `dash_app/callbacks/chart.py:update_chart()` currently renders icicle only. Needs conditional dispatch based on `active_tab`.
-- **Start with Task 9.1** (parsing utilities + tab infrastructure) — it's the foundation for all other tasks.
-### New guardrails added:
-- Tab architecture: lazy rendering, single dcc.Graph, active_tab in app-state
-- Chart figure functions: shared in src/visualization/, not duplicated in dash_app/
-- Parsing utilities: shared in src/data_processing/, tested independently
-
-## Iteration 23 — 2026-02-06
-### Task: Phase 9 — Task 9.1 (Parsing utilities + tab infrastructure)
-### Why this task:
-- First task in Phase 9, foundation for all other analytics chart tasks
-- Progress.txt explicitly recommends starting here
-- No dependencies — pure infrastructure
-### Status: COMPLETE
-### What was done:
-- **Created `src/data_processing/parsing.py`** with 3 shared parsing functions:
-  1. `parse_average_spacing(html)` — regex extracts drug_name, dose_count, weekly_interval, total_weeks from HTML strings. Returns list of dicts (supports multi-drug entries). Tested with real data.
-  2. `parse_pathway_drugs(ids, level)` — splits `ids` column by ` - ` and returns drug names from index 3 onwards. Returns empty list for level < 3.
-  3. `calculate_retention_rate(nodes)` — for each level 4+ pathway, calculates what % of patients do NOT escalate to the next treatment line. Tested with real RHEUMATOLOGY data (e.g., ADALIMUMAB→ETANERCEPT: 82.6% retained).
-- **Updated `dash_app/components/chart_card.py`**:
-  - Added `TAB_DEFINITIONS` list of 8 (id, label) tuples exported for use by callbacks
-  - Tab bar uses plain `html.Button` elements with existing `.chart-tab` / `.chart-tab--active` CSS classes
-  - Single `dcc.Graph` shared across all tabs (lazy rendering)
-- **Updated `dash_app/components/sidebar.py`**:
-  - Removed "Chart Views" section (Icicle/Sankey/Timeline items) — chart selection is now in the tab bar
-  - Only "Overview" section with "Pathway Overview" remains
-  - Removed unused icon definitions (icicle, sankey, timeline SVGs)
-- **Updated `dash_app/callbacks/chart.py`**:
-  - Added `switch_tab` callback: 8 tab button Inputs → `active-tab` store + 8 CSS class Outputs
-  - Modified `update_chart` to read `active-tab` store and dispatch: icicle renders via `create_icicle_from_nodes()`; other tabs show "coming soon" placeholder
-  - `_empty_figure()` and `_generate_chart_title()` preserved unchanged
-- **Updated `dash_app/app.py`**:
-  - Added `dcc.Store(id="active-tab", storage_type="memory", data="icicle")` — separate store for tab state, avoids `allow_duplicate` conflicts with `app-state`
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 2 (Layout):
-  - 8 tab IDs present: tab-icicle, tab-market-share, tab-cost-effectiveness, tab-cost-waterfall, tab-sankey, tab-dosing, tab-heatmap, tab-duration
-  - active-tab store present with default "icicle"
-  - Sidebar: "Chart Views" section removed, only "Overview" remains
-  - 11 callbacks registered (was 10, +1 for switch_tab)
-- Tier 3 (Functional):
-  - Icicle chart still renders: 293 nodes, 11,118 patients, correct figure
-  - Parsing utilities: all 3 functions tested with real SQLite data
-  - Tab label lookup works for all 8 tabs
-  - Placeholder figures render with correct "coming soon" message
-### Files changed:
-- `src/data_processing/parsing.py` — NEW: 3 shared parsing functions
-- `dash_app/components/chart_card.py` — Updated: 8-tab bar with TAB_DEFINITIONS
-- `dash_app/components/sidebar.py` — Updated: removed Chart Views section
-- `dash_app/callbacks/chart.py` — Updated: switch_tab callback + tab-based dispatch
-- `dash_app/app.py` — Updated: added active-tab dcc.Store
-- `IMPLEMENTATION_PLAN.md` — Task 9.1 marked [x]
-### Committed: fe2d048 "feat: add parsing utilities and 8-tab chart infrastructure (Task 9.1)"
-### Patterns discovered:
-- `active_tab` stored in a SEPARATE `dcc.Store(id="active-tab")` rather than inside `app-state`. This avoids `allow_duplicate=True` (since `app-state` is already Output of `update_app_state` in filters.py). Tab switching doesn't trigger pathway data reload — only visual switching.
-- Tab buttons use plain `html.Button` with existing `.chart-tab` CSS classes from nhs.css. This matches the design reference exactly, unlike DMC Tabs or dcc.Tabs which would need CSS overrides.
-- `TAB_DEFINITIONS` exported from `chart_card.py` as a module-level constant, imported by `chart.py` for callback Input/Output construction. Keeps tab names defined in one place.
-- `switch_tab` callback uses `*tab_outputs` and `*tab_inputs` unpacking to dynamically wire all 8 tabs. Adding a new tab only requires adding to `TAB_DEFINITIONS`.
-- `parse_average_spacing` returns a LIST of dicts (not a single dict) because level 4+ nodes can have multi-drug entries in the average_spacing HTML.
-### Next iteration should:
-- Start Task 9.2 — Query functions for all 7 chart types
-- Add 7 new query functions to `src/data_processing/pathway_queries.py`:
-  - `get_drug_market_share()` — Level 3 nodes grouped by directory
-  - `get_pathway_costs()` — Level 4+ nodes with cost_pp_pa
-  - `get_cost_waterfall()` — Level 2 nodes with cost_pp_pa
-  - `get_drug_transitions()` — Level 3+ for Sankey transitions
-  - `get_dosing_intervals()` — Level 3 nodes with parsed average_spacing
-  - `get_drug_directory_matrix()` — Level 3 pivoted as directory × drug
-  - `get_treatment_durations()` — Level 3 with avg_days
-- Add thin wrappers in `dash_app/data/queries.py`
-- Follow same pattern as existing `load_pathway_nodes()`: accept db_path, use sqlite3.Row, parameterized queries, return JSON-serializable data
-- Read `src/data_processing/pathway_queries.py` first to understand existing patterns
-- Read `AdditionalAnalytics.md` for each chart's data requirements
-- Test each query with `python -c "..."` against real data
-### Blocked items:
-- None
-
-## Iteration 24 — 2026-02-06
-### Task: Phase 9 — Task 9.2 (Query functions for all 7 chart types)
-### Why this task:
-- Task 9.1 (parsing + tab infrastructure) complete in iteration 23
-- Progress.txt explicitly recommended this task next
-- All 7 chart implementations (9.3–9.9) depend on these query functions
-### Status: COMPLETE
-### What was done:
-- **Added 7 query functions to `src/data_processing/pathway_queries.py`**:
-  1. `get_drug_market_share()` — Level 3 nodes aggregated across trusts by directory+drug, with computed proportions. 63 rows for directory chart, 111 for indication.
-  2. `get_pathway_costs()` — Level 4+ nodes with pathway labels (drug_sequence joined with →). 38 pathways for RHEUMATOLOGY.
-  3. `get_cost_waterfall()` — Aggregates level 3 cost/patients by directory (level 2 cost_pp_pa is always "N/A"). 12 directorates sorted by cost_pp desc.
-  4. `get_drug_transitions()` — Parses drug_sequence into source→target transitions with ordinal line labels (e.g., "ADALIMUMAB (1st)" → "ETANERCEPT (2nd)"). Returns {nodes, links} for Sankey. 49 nodes, 65 links.
-  5. `get_dosing_intervals()` — Uses `parse_average_spacing()` to extract weekly_interval/dose_count/total_weeks. 124 rows for all drugs.
-  6. `get_drug_directory_matrix()` — Pivots level 3 into directory × drug matrix with patients/cost/cost_pp_pa. 12×39 matrix, 63 non-empty cells.
-  7. `get_treatment_durations()` — Weighted avg of avg_days by patients across trusts. 59 entries unfiltered.
-- **Added helpers**: `_safe_float()` for None/N/A handling, `_ordinal()` for Sankey node labels
-- **Added 7 thin wrappers** to `dash_app/data/queries.py` (resolve DB_PATH, delegate to src/)
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 11 callbacks registered
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional): All 7 queries tested with real data, both chart types
-### Files changed:
-- `src/data_processing/pathway_queries.py` — Added: 7 query functions + 2 helpers
-- `dash_app/data/queries.py` — Added: 7 thin wrapper functions
-- `IMPLEMENTATION_PLAN.md` — Task 9.2 marked [x]
-### Committed: d98cd4f "feat: add 7 analytics chart query functions (Task 9.2)"
-### Patterns discovered:
-- `cost_pp_pa` at level 2 is always "N/A". Waterfall must compute from level 3 aggregation.
-- `cost_pp_pa` at level 3 is a string (including "N/A"). Use `_safe_float()`.
-- Sankey ordinal suffix ("1st", "2nd") prevents self-loops for same-drug transitions.
-- Treatment duration uses weighted average for cross-trust aggregation.
-- All queries work seamlessly with both "directory" and "indication" chart types.
-### Next iteration should:
-- Start Task 9.3 — First-Line Market Share chart (Tab 2)
-- Sub-steps:
-  1. Create figure function in `src/visualization/` — `create_market_share_figure(data)` for horizontal grouped bar chart
-  2. Wire into `update_chart` in `dash_app/callbacks/chart.py` — dispatch on active_tab="market-share"
-  3. The query `get_drug_market_share()` returns [{directory, drug, patients, proportion, cost, cost_pp_pa}] sorted by total desc
-  4. Use NHS blue palette, one cluster per directorate, drugs as bars within
-- Read `dash_app/callbacks/chart.py` to understand the tab dispatch pattern
-- Read `src/visualization/plotly_generator.py` to see existing figure function pattern
-### Blocked items (iter 24):
-- None
-
-## Iteration 25 — 2026-02-06
-### Task: Phase 9 — Task 9.3 (First-Line Market Share chart — Tab 2)
-### Why this task:
-- Tasks 9.1 (tab infra) and 9.2 (query functions) complete. Task 9.3 is the first actual chart.
-- Progress.txt from iteration 24 explicitly recommended this task.
-- Simplest chart — validates the tab-switching + figure-building pattern for all subsequent charts.
-### Status: COMPLETE
-### What was done:
-- **Created `create_market_share_figure(data, title)` in `src/visualization/plotly_generator.py`**:
-  - Horizontal stacked bar chart: one row per directorate (sorted by total patients desc), drugs stacked within
-  - NHS colour palette (15 colours cycling for different drugs)
-  - Hover shows drug name, directorate, patient count, share %, cost, cost p.p.p.a.
-  - Dynamic height based on number of directorates (60px per row + margins)
-  - Legend positioned below chart in horizontal orientation
-  - Transparent backgrounds, Source Sans 3 font, matching NHS design aesthetic
-- **Added `_render_market_share(app_state, title)` helper in `dash_app/callbacks/chart.py`**:
-  - Extracts filter params from app-state (date_filter_id, chart_type, directory, trust)
-  - Calls `get_drug_market_share()` wrapper then `create_market_share_figure()`
-  - Handles empty data and exceptions gracefully
-  - For single-directory filter: passes to query as `directory=` param. For multi: shows all.
-  - For single-trust filter: passes to query as `trust=` param. For multi: shows all.
-- **Updated `update_chart` dispatch**: `active_tab == "market-share"` → `_render_market_share()`
-- **Architecture note**: Separate `dash_app/callbacks/market_share.py` file not needed — the dispatch pattern uses a single `update_chart` callback with helper functions. This avoids `allow_duplicate=True` on `Output("pathway-chart", "figure")`.
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 11 callbacks registered
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional):
-  - Directory chart: 63 rows, 12 directories, 39 drugs, 39 traces — renders correctly
-  - Indication chart: 111 rows, 39 traces — renders correctly
-  - Trust filter (NNUH): 45 rows — filters correctly
-  - Date filter (2yr_12mo): 47 rows — filters correctly
-  - Empty data: returns empty figure — handled correctly
-  - Icicle still works: 293 nodes, 11,118 patients — no regression
-### Files changed:
-- `src/visualization/plotly_generator.py` — Added: `create_market_share_figure()` (120 lines)
-- `dash_app/callbacks/chart.py` — Added: `_render_market_share()` helper + dispatch branch
-- `IMPLEMENTATION_PLAN.md` — Task 9.3 marked [x]
-### Committed: f8960a3 "feat: add First-Line Market Share chart (Task 9.3)"
-### Patterns discovered:
-- Market share chart uses `barmode="stack"` for cleaner visualization — stacked bars show proportion within each directorate clearly
-- The `_render_X()` helper pattern (query + figure builder in one function) is clean and reusable for all subsequent chart types
-- Market share query returns data sorted by directory total patients desc — reversed for horizontal bars so highest total is at top
-- 39 unique drugs creates many traces, but most drugs only appear in 1-2 directorates so visual complexity is manageable
-- `get_drug_market_share()` accepts single directory/trust — for multi-select, pass None to show all
-### Next iteration should:
-- Start Task 9.4 — Pathway Cost Effectiveness chart (Tab 3)
-- Sub-steps:
-  1. Create figure function in `src/visualization/plotly_generator.py` — `create_cost_effectiveness_figure(data, retention)`
-  2. Build horizontal lollipop/dot chart: Y-axis = pathway label, X-axis = £ per patient per annum
-  3. Dot size = patient count, colour gradient: green (cheap) → amber → red (expensive)
-  4. Add retention rate annotations using `calculate_retention_rate()` from `src/data_processing/parsing.py`
-  5. Wire into `update_chart` via `_render_cost_effectiveness()` helper
-  6. The query `get_pathway_costs()` returns [{ids, pathway_label, cost_pp_pa, patients, directory, drug_sequence}]
-  7. Use `parse_pathway_drugs()` if needed for pathway labels
-- Read `src/data_processing/parsing.py` for `calculate_retention_rate()` signature
-- Read `get_pathway_costs()` data shape
-### Blocked items:
-- None
-
-## Iteration 26 — 2026-02-06
-### Task: Phase 9 — Task 9.4 (Pathway Cost Effectiveness chart — Tab 3)
-### Why this task:
-- Tasks 9.1 (tab infra), 9.2 (queries), 9.3 (market share) complete. Task 9.4 is next in sequence.
-- Progress.txt from iteration 25 explicitly recommended this task.
-- This is the user's key insight chart — shows cost effectiveness of different treatment pathways with retention annotations.
-### Status: COMPLETE
-### What was done:
-- **Fixed `calculate_retention_rate()` in `src/data_processing/parsing.py`**:
-  - Added `_get_patients()` helper that accepts either `"value"` or `"patients"` key
-  - Bug: function returned 0 entries because `get_pathway_costs()` returns data with `"patients"` key, not `"value"`. The original function only checked `node.get("value", 0)`.
-  - Now works with both chart data nodes (`value`) and pathway cost data (`patients`).
-- **Created `create_cost_effectiveness_figure(data, retention, title)` in `src/visualization/plotly_generator.py`**:
-  - Horizontal lollipop chart: stick lines from 0 to cost, dot at cost value
-  - Y-axis = pathway label (e.g., "Adalimumab → Secukinumab → Rituximab"), X-axis = £ per patient per annum
-  - Dot size scaled by patient count (min 8px, max 30px)
-  - Colour gradient: green (#009639) for cheap, amber (#ED8B00) for mid, red (#DA291C) for expensive
-  - Hover shows: pathway name, cost p.p.p.a., patients, total cost, avg duration, directorate, treatment lines, retention rate
-  - Retention annotations for pathways with <90% retention and ≥10 patients (up to 8 annotations)
-  - Caps at top 40 pathways by cost for readability
-  - Dynamic height based on pathway count
-  - NHS design aesthetic: Source Sans 3, transparent backgrounds, clean gridlines
-- **Added `_render_cost_effectiveness(app_state, chart_data, title)` helper in `dash_app/callbacks/chart.py`**:
-  - Extracts filter params (date_filter_id, chart_type, single directory/trust)
-  - Calls `get_pathway_costs()` → `calculate_retention_rate()` → `create_cost_effectiveness_figure()`
-  - Handles empty data and exceptions gracefully
-- **Wired into `update_chart` dispatch**: `active_tab == "cost-effectiveness"` → `_render_cost_effectiveness()`
-- **Architecture note**: Like market share, uses the `_render_X()` helper pattern within the single `update_chart` callback. No separate callback file needed.
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 11 callbacks registered
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional):
-  - Directory chart: 111 pathways, 111 retention entries, 41 traces — renders correctly
-  - Indication chart: 92 pathways, 92 retention entries — renders correctly
-  - RHEUMATOLOGY filter: 38 pathways, 39 traces — filters correctly
-  - NNUH trust filter: 50 pathways — filters correctly
-  - Empty filter (nonexistent directory): 0 pathways — returns empty figure
-  - Date filter (2yr_12mo): 17 pathways — filters correctly
-  - Icicle still works: 293 nodes, 11,118 patients — no regression
-  - Market share still works — no regression
-### Files changed:
-- `src/data_processing/parsing.py` — Fixed: calculate_retention_rate() accepts both 'value' and 'patients' keys
-- `src/visualization/plotly_generator.py` — Added: create_cost_effectiveness_figure() (~170 lines)
-- `dash_app/callbacks/chart.py` — Added: _render_cost_effectiveness() helper + dispatch branch
-- `IMPLEMENTATION_PLAN.md` — Task 9.4 marked [x]
-### Committed: 4ef7239 "feat: add Pathway Cost Effectiveness lollipop chart (Task 9.4)"
-### Patterns discovered:
-- `get_pathway_costs()` returns `"patients"` as the key while chart data nodes use `"value"`. Shared parsing functions that operate on either data format need to handle both keys.
-- Lollipop chart pattern: separate `go.Scatter` with `mode="lines"` for sticks + one `go.Scatter` with `mode="markers"` for dots. Each stick is its own trace (40 pathways = 41 total traces).
-- Retention annotation threshold: `rate < 90% AND patients >= 10` avoids annotating trivial pathways. Cap of 8 annotations prevents visual clutter.
-- The `_render_X(app_state, chart_data, title)` pattern differs slightly from market share (`_render_market_share(app_state, title)`) by accepting `chart_data` — this is because cost effectiveness queries directly from SQLite rather than using chart-data nodes. Future charts may also use this pattern.
-### Next iteration should:
-- Start Task 9.5 — Cost Waterfall chart (Tab 4)
-- Sub-steps:
-  1. Create figure function in `src/visualization/plotly_generator.py` — `create_cost_waterfall_figure(data, title)`
-  2. Build Plotly waterfall chart from `get_cost_waterfall()` data
-  3. Each bar = one directorate's average cost_pp_pa, sorted highest to lowest
-  4. NHS colours, responds to chart_type toggle, date filter, trust filter
-  5. Wire into `update_chart` via `_render_cost_waterfall()` helper
-- The query `get_cost_waterfall()` returns [{directory, cost_pp, patients, total_cost}] sorted by cost_pp desc
-- Read `get_cost_waterfall()` in pathway_queries.py for exact data shape
-### Blocked items:
-- None
-
-## Iteration 28 — 2026-02-06
-### Task: Phase 9 — Task 9.6 (Drug Switching Sankey chart — Tab 5)
-### Why this task:
-- Tasks 9.1–9.5 complete. Task 9.6 is next in sequence.
-- Progress.txt from iteration 27 explicitly recommended this task.
-- Sankey is a well-defined chart type with pre-existing query function (`get_drug_transitions()`).
-### Status: COMPLETE
-### What was done:
-- **Created `create_sankey_figure(data, title)` in `src/visualization/plotly_generator.py`** (~130 lines):
-  - Plotly `go.Sankey` diagram: nodes = drugs with ordinal suffixes (e.g., "ADALIMUMAB (1st)"), links = patient transitions
-  - Nodes coloured by base drug name — same drug gets same colour across treatment lines (1st, 2nd, 3rd)
-  - Link colours use source node colour at 40% opacity for visual flow
-  - NHS colour palette (15 colours cycling), Source Sans 3 font
-  - Custom hover: node shows drug name + total patients, link shows source → target + patient count
-  - Dynamic height: scales with number of unique drug bases
-  - `arrangement="snap"` for clean node positioning
-- **Added `_render_sankey(app_state, title)` helper in `dash_app/callbacks/chart.py`**:
-  - Extracts filter params (date_filter_id, chart_type, single directory/trust)
-  - Calls `get_drug_transitions()` wrapper then `create_sankey_figure()`
-  - Handles empty data and exceptions gracefully
-- **Wired into `update_chart` dispatch**: `active_tab == "sankey"` → `_render_sankey()`
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional):
-  - Directory chart: 49 nodes, 65 links — renders correctly
-  - Indication chart: 34 nodes, 35 links — renders correctly
-  - RHEUMATOLOGY filter: 24 nodes, 27 links — filters correctly
-  - NNUH trust filter: 38 nodes, 47 links — filters correctly
-  - Date filter (2yr_12mo): 13 nodes, 12 links — filters correctly
-  - Empty data: returns empty figure — handled correctly
-  - Icicle, market share, cost effectiveness, cost waterfall — no regressions
-### Files changed:
-- `src/visualization/plotly_generator.py` — Added: `create_sankey_figure()` (~130 lines)
-- `dash_app/callbacks/chart.py` — Added: `_render_sankey()` helper + dispatch branch
-- `IMPLEMENTATION_PLAN.md` — Task 9.6 marked [x]
-### Committed: 4ffcdf4 "feat: add Drug Switching Sankey diagram (Task 9.6)"
-### Patterns discovered:
-- Sankey node colouring by base drug name (stripping ordinal suffix) provides visual continuity — users can track the same drug across treatment lines by colour.
-- `hex_to_rgba()` helper for link transparency is a reusable pattern. Using 35% opacity keeps links readable without obscuring overlapping flows.
-- `arrangement="snap"` works better than "perpendicular" for this data shape — it allows Plotly to optimally position nodes vertically.
-- The `_render_sankey(app_state, title)` pattern matches `_render_market_share()` and `_render_cost_waterfall()` — all take app_state and title, query independently from SQLite.
-### Next iteration should:
-- Start Task 9.7 — Dosing Interval Comparison chart (Tab 6)
-- Sub-steps:
-  1. Create figure function in `src/visualization/plotly_generator.py` — `create_dosing_figure(data, title)`
-  2. Build horizontal grouped bar chart from `get_dosing_intervals()` data
-  3. Uses `parse_average_spacing()` to extract weekly interval numbers from HTML strings
-  4. Y-axis = trust or directorate, X-axis = weekly interval, grouped by drug
-  5. Wire into `update_chart` via `_render_dosing()` helper
-  6. Responds to drug filter, date filter, chart type toggle
-- Read `get_dosing_intervals()` in pathway_queries.py for exact data shape
-- Read `parse_average_spacing()` in `src/data_processing/parsing.py` for HTML parsing logic
-### Blocked items:
-- None
-
-## Iteration 27 — 2026-02-06
-### Task: Phase 9 — Task 9.5 (Cost Waterfall chart — Tab 4)
-### Why this task:
-- Tasks 9.1 (tab infra), 9.2 (queries), 9.3 (market share), 9.4 (cost effectiveness) complete. Task 9.5 is next in sequence.
-- Progress.txt from iteration 26 explicitly recommended this task.
-- Cost Waterfall is a straightforward bar chart — validates the pattern for remaining charts.
-### Status: COMPLETE
-### What was done:
-- **Created `create_cost_waterfall_figure(data, title)` in `src/visualization/plotly_generator.py`**:
-  - Vertical bar chart: one bar per directorate, sorted by cost_pp (cost per patient) descending
-  - NHS colour palette cycling through 12 colours for visual distinction
-  - Text labels above bars showing £ values, patient count annotations below
-  - Weighted average reference line (dashed red) across all directorates
-  - Hover shows: directorate name, cost per patient, patient count, total cost
-  - Auto tick angle rotation for >6 bars, dynamic sizing
-  - NHS design aesthetic: Source Sans 3, transparent backgrounds, clean gridlines
-- **Added `_render_cost_waterfall(app_state, title)` helper in `dash_app/callbacks/chart.py`**:
-  - Extracts filter params (date_filter_id, chart_type, single trust)
-  - Calls `get_cost_waterfall()` wrapper then `create_cost_waterfall_figure()`
-  - Handles empty data and exceptions gracefully
-- **Wired into `update_chart` dispatch**: `active_tab == "cost-waterfall"` → `_render_cost_waterfall()`
-- **Architecture note**: Uses `go.Bar` (not `go.Waterfall`) for cleaner control — each bar shows absolute cost_pp for a directorate. The weighted average reference line gives the "running total" context that a true waterfall would provide.
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 11 callbacks registered
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional):
-  - Directory chart: 12 bars (directorates), sorted by cost_pp desc — renders correctly
-  - Indication chart: 39 bars (indications) — renders correctly
-  - Trust filter (NNUH): 10 bars — filters correctly
-  - Date filter (2yr_12mo): 12 bars — filters correctly
-  - Empty data: returns empty figure — handled correctly
-  - Icicle still works: 293 nodes, 11,118 patients — no regression
-  - Market share still works: 63 rows, 39 traces — no regression
-  - Cost effectiveness still works — no regression
-### Files changed:
-- `src/visualization/plotly_generator.py` — Added: `create_cost_waterfall_figure()` (~130 lines)
-- `dash_app/callbacks/chart.py` — Added: `_render_cost_waterfall()` helper + dispatch branch
-- `IMPLEMENTATION_PLAN.md` — Task 9.5 marked [x]
-### Committed: 73a8d1a "feat: add Cost Waterfall bar chart (Task 9.5)"
-### Patterns discovered:
-- `go.Bar` is better than `go.Waterfall` for this use case — we want absolute values per directorate, not cumulative increments. Waterfall would show how each directorate adds to a running total, but the spec asks for comparing cost_pp across directorates independently.
-- The weighted average reference line (`fig.add_hline()`) provides the "big picture" context — users can quickly see which directorates are above/below average cost per patient.
-- Patient count annotations below bars (`yshift=-18`) give context on sample size without cluttering the main bars.
-- The `_render_cost_waterfall(app_state, title)` pattern matches `_render_market_share()` — both take app_state and title, query independently from SQLite (not from chart-data nodes).
-### Next iteration should:
-- Start Task 9.6 — Drug Switching Sankey chart (Tab 5)
-- Sub-steps:
-  1. Create figure function in `src/visualization/plotly_generator.py` — `create_sankey_figure(data, title)`
-  2. Build Plotly Sankey diagram from `get_drug_transitions()` data
-  3. The query returns `{nodes: [{label, colour}], links: [{source, target, value, source_label, target_label}]}`
-  4. Left nodes = 1st-line drugs, middle = 2nd-line, right = 3rd-line. Link width = patient count.
-  5. Wire into `update_chart` via `_render_sankey()` helper
-  6. Responds to all existing filters (directory, trust, date, chart type)
-- Read `get_drug_transitions()` in pathway_queries.py for exact data shape
-- Note: Sankey has ordinal suffixes (e.g., "ADALIMUMAB (1st)") to prevent self-loops
-### Blocked items:
-- None
-
-## Iteration 29 — 2026-02-06
-### Task: Phase 9 — Task 9.7 (Dosing Interval Comparison chart — Tab 6)
-### Why this task:
-- Tasks 9.1–9.6 complete. Task 9.7 is next in sequence.
-- Progress.txt from iteration 28 explicitly recommended this task.
-- Uses existing `get_dosing_intervals()` query and `parse_average_spacing()` parsing.
-### Status: COMPLETE
-### What was done:
-- **Created `create_dosing_figure(data, title, group_by)` in `src/visualization/plotly_generator.py`** (~180 lines):
-  - Two modes via `group_by` parameter:
-    - **"drug" (overview)**: Weighted average weekly interval per drug, one horizontal bar per drug sorted by patient count. Bars coloured by interval (NHS blue gradient — darker = more frequent dosing). Patient count annotations on right side.
-    - **"trust" (per-drug comparison)**: Grouped horizontal bars per trust, one trace per directory. Enables cross-trust dosing comparison for a specific drug.
-  - Hover shows: drug/trust, interval, avg doses, avg treatment weeks, patient count
-  - Dynamic height, NHS design aesthetic (Source Sans 3, transparent, clean grid)
-  - Helper functions: `_dosing_by_drug()` and `_dosing_by_trust()` for clean separation
-- **Added `_render_dosing(app_state, title)` helper in `dash_app/callbacks/chart.py`**:
-  - Extracts filter params (date_filter_id, chart_type, single drug/trust)
-  - Auto-selects `group_by`: "trust" when single drug selected, "drug" for overview
-  - Calls `get_dosing_intervals()` wrapper then `create_dosing_figure()`
-  - Handles empty data and exceptions gracefully
-- **Wired into `update_chart` dispatch**: `active_tab == "dosing"` → `_render_dosing()`
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 11 callbacks registered
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional):
-  - Directory chart overview: 124 rows → 36 drugs, intervals 4.3–52.4 weeks — renders correctly
-  - Indication chart: 219 rows → 37 drugs — renders correctly
-  - ADALIMUMAB single drug: 14 rows → 4 directory traces, per-trust comparison — renders correctly
-  - NNUH trust filter: single trust reduces data — filters correctly
-  - Date filter (2yr_12mo): 89 rows → 29 drugs — filters correctly
-  - Empty data: returns empty figure — handled correctly
-  - Icicle still works: 293 nodes, 11,118 patients — no regression
-  - Market share, cost effectiveness, cost waterfall, Sankey — no regressions
-### Files changed:
-- `src/visualization/plotly_generator.py` — Added: `create_dosing_figure()`, `_dosing_by_drug()`, `_dosing_by_trust()` (~180 lines)
-- `dash_app/callbacks/chart.py` — Added: `_render_dosing()` helper + dispatch branch
-- `IMPLEMENTATION_PLAN.md` — Task 9.7 marked [x]
-### Committed: 02fe4b4 "feat: add Dosing Interval Comparison chart (Task 9.7)"
-### Patterns discovered:
-- Dosing chart benefits from two distinct modes: overview (all drugs, weighted averages) and comparison (single drug, per-trust). The `group_by` parameter makes this clean without separate figure functions.
-- Trust names are very long (e.g., "NORFOLK AND NORWICH UNIVERSITY HOSPITALS NHS FOUNDATION TRUST") — stripping " NHS FOUNDATION TRUST" and " HOSPITALS" suffixes greatly improves y-axis readability.
-- Weighted average by patient count is the right aggregation for dosing intervals — it prevents small patient groups from skewing the displayed interval.
-- Bar colour gradient by interval value provides immediate visual cue: darker blue = more frequent dosing, lighter = less frequent.
-### Next iteration should:
-- Start Task 9.8 — Directorate × Drug Heatmap chart (Tab 7)
-- Sub-steps:
-  1. Create figure function in `src/visualization/plotly_generator.py` — `create_heatmap_figure(data, title, metric)`
-  2. Build Plotly heatmap from `get_drug_directory_matrix()` data
-  3. Rows = directorates (sorted by total patients), Columns = drugs (sorted by frequency)
-  4. Cell colour = patient count (default), with possible toggle for cost or cost_pp_pa
-  5. Wire into `update_chart` via `_render_heatmap()` helper
-  6. Responds to trust filter, date filter, chart type toggle
-- Read `get_drug_directory_matrix()` in pathway_queries.py for exact data shape
-- Data returns: `{directories: [...], drugs: [...], matrix: {dir: {drug: {patients, cost, cost_pp_pa}}}}`
-### Blocked items:
-- None
-
-## Iteration 30 — 2026-02-06
-### Task: Phase 9 — Task 9.8 (Directorate × Drug Heatmap chart — Tab 7)
-### Why this task:
-- Tasks 9.1–9.7 complete. Task 9.8 is next in sequence.
-- Progress.txt from iteration 29 explicitly recommended this task.
-- Uses existing `get_drug_directory_matrix()` query which returns pre-aggregated matrix data.
-### Status: COMPLETE
-### What was done:
-- **Created `create_heatmap_figure(data, title, metric)` in `src/visualization/plotly_generator.py`** (~120 lines):
-  - Accepts matrix data from `get_drug_directory_matrix()` with `directories`, `drugs`, `matrix` keys
-  - `metric` parameter supports "patients" (default), "cost", and "cost_pp_pa" for switching cell colouring
-  - Caps at top 25 drugs for readability (drugs sorted by patient count desc from query)
-  - NHS blue colorscale: pale grey (#F0F4F8) → deep NHS blue (#003087)
-  - Rich hover text: drug name, directorate, patients, total cost, cost per patient p.a.
-  - Dynamic sizing: width/height scales with matrix dimensions
-  - Gap between cells (xgap=2, ygap=2) for visual clarity
-  - Directorate y-axis reversed (most patients at top)
-  - Drug x-axis at 45° angle for readability
-- **Added `_render_heatmap(app_state, title)` helper in `dash_app/callbacks/chart.py`**:
-  - Extracts filter params (date_filter_id, chart_type, single trust)
-  - Calls `get_drug_directory_matrix()` wrapper then `create_heatmap_figure()`
-  - Handles empty data and exceptions gracefully
-- **Wired into `update_chart` dispatch**: `active_tab == "heatmap"` → `_render_heatmap()`
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional):
-  - Directory chart: 12 rows × 25 cols — renders correctly
-  - Indication chart: 39 rows × 25 cols — renders correctly
-  - NNUH trust filter: 10 rows × 25 cols — filters correctly
-  - Date filter (2yr_12mo): 12 rows × 25 cols — filters correctly
-  - All three metrics (patients, cost, cost_pp_pa) — titles/colorbar correct
-  - Empty data: returns empty figure — handled correctly
-  - Icicle still works: 293 nodes, 11,118 patients — no regression
-  - Market share, cost waterfall, Sankey, dosing — no regressions
-### Files changed:
-- `src/visualization/plotly_generator.py` — Added: `create_heatmap_figure()` (~120 lines)
-- `dash_app/callbacks/chart.py` — Added: `_render_heatmap()` helper + dispatch branch
-- `IMPLEMENTATION_PLAN.md` — Task 9.8 marked [x]
-### Committed: 0af76e6 "feat: add Directorate × Drug Heatmap chart (Task 9.8)"
-### Patterns discovered:
-- Capping at 25 columns is important for readability — the query returns up to 39 drugs but many have minimal presence. The top 25 by patient count covers all meaningful data.
-- `go.Heatmap` with `xgap`/`ygap` of 2 pixels creates clear cell separation that makes the matrix much more readable.
-- NHS blue colorscale starting from near-white (#F0F4F8) for zero values prevents the heatmap from looking washed out, while the dark NHS blue (#003087) for high values provides strong contrast.
-- `yaxis autorange="reversed"` ensures the most popular directorate is at the top (matching the query's desc sort order).
-### Next iteration should:
-- Start Task 9.9 — Treatment Duration chart (Tab 8)
-- Sub-steps:
-  1. Create figure function in `src/visualization/plotly_generator.py` — `create_duration_figure(data, title)`
-  2. Build Plotly horizontal bar chart from `get_treatment_durations()` data
-  3. Y-axis = drug, X-axis = average days, colour intensity by patient count
-  4. Wire into `update_chart` via `_render_duration()` helper
-  5. Responds to directorate filter, trust filter, date filter, chart type toggle
-- Read `get_treatment_durations()` in pathway_queries.py for exact data shape
-- Data returns: list of dicts with `drug`, `directory`, `trust_name`, `avg_days`, `patients`, `cost_pp_pa`
-### Blocked items:
-- None
-
-## Iteration 31 — 2026-02-06
-### Task: Phase 9 — Task 9.9 (Treatment Duration chart — Tab 8)
-### Why this task:
-- Tasks 9.1–9.8 complete. Task 9.9 is the last chart to implement before final integration (9.10).
-- Progress.txt from iteration 30 explicitly recommended this task.
-- Uses existing `get_treatment_durations()` query which returns avg_days per drug.
-### Status: COMPLETE
-### What was done:
-- **Created `create_duration_figure(data, title, show_directory)` in `src/visualization/plotly_generator.py`** (~120 lines):
-  - Horizontal bar chart: Y-axis = drug names, X-axis = average duration in days
-  - Colour gradient by patient count: light NHS blue (#41B6E6) → dark NHS blue (#003087)
-  - When `show_directory=False` (default), aggregates same drug across directorates (weighted avg by patients)
-  - When `show_directory=True` (indication mode without directory filter), shows directory in label
-  - Caps at 40 entries for readability (keeps highest patient count entries, then re-sorts by avg_days)
-  - Rich hover: drug name, days + years, patient count
-  - Patient count annotations (n=X) at bar end
-  - Dynamic height: 40 + n_bars * 28 pixels (minimum 400)
-  - NHS styling: Source Sans 3, transparent bg, left margin 200 for drug labels
-- **Added `_render_duration(app_state, title)` helper in `dash_app/callbacks/chart.py`**:
-  - Extracts filter params: date_filter_id, chart_type, single directory, single trust
-  - Calls `get_treatment_durations()` wrapper then `create_duration_figure()`
-  - Sets `show_directory=True` for indication mode without a directory filter
-  - Handles empty data and exceptions gracefully
-- **Wired into `update_chart` dispatch**: `active_tab == "duration"` → `_render_duration()`
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional):
-  - Directory mode (no filter): 36 bars (aggregated across directorates)
-  - Directory mode + RHEUMATOLOGY filter: 16 bars
-  - Directory mode + DERMATOLOGY filter: 11 bars
-  - Indication mode (no filter): 40 bars (capped from 108)
-  - Trust filter (NNUH): 28 bars
-  - Date filter (2yr_12mo): responds correctly
-  - Empty data: returns empty figure — handled correctly
-  - Icicle, market share, cost waterfall, Sankey, dosing, heatmap — no regressions
-### Files changed:
-- `src/visualization/plotly_generator.py` — Added: `create_duration_figure()` (~120 lines)
-- `dash_app/callbacks/chart.py` — Added: `_render_duration()` helper + dispatch branch
-- `IMPLEMENTATION_PLAN.md` — Task 9.9 marked [x]
-### Committed: 965fc8c "feat: add Treatment Duration bar chart (Task 9.9)"
-### Patterns discovered:
-- Aggregation across directorates is needed when no directory filter is applied — same drug can appear in multiple directorates with different avg_days. Weighted average by patient count is the correct aggregation.
-- Capping at 40 entries (by patient count, then re-sorted by avg_days) keeps charts readable while preserving clinically significant entries.
-- For indication mode, `show_directory=True` helps distinguish the same drug in different contexts (e.g., "USTEKINUMAB (psoriasis)" vs "USTEKINUMAB (Crohn's disease)").
-- Colour interpolation from light (#41B6E6) to dark (#003087) provides immediate visual cue: darker bars = more patients = more statistically reliable duration data.
-### Next iteration should:
-- Start Task 9.10 — Final integration + polish
-- All 8 chart tabs are now implemented (Tasks 9.1–9.9 complete)
-- Sub-steps for 9.10:
-  1. Verify all 8 tabs switch smoothly with no unnecessary recomputation
-  2. Verify each chart responds to filter changes (date, chart type, trust, directorate, drug)
-  3. Test with both "directory" and "indication" chart types
-  4. Verify icicle chart still works correctly (no regressions)
-  5. Update CLAUDE.md with new chart types, callback files, and query functions
-- Key checks: tab switching should dispatch only to the active tab's figure builder, no "coming soon" placeholders should remain
-- Review all Phase 9 completion criteria in IMPLEMENTATION_PLAN.md
-### Blocked items:
-- None
-
-## Iteration 32 — 2026-02-06
-### Task: Phase 9 — Task 9.10 (Final integration + polish)
-### Why this task:
-- Tasks 9.1–9.9 all complete. Task 9.10 is the final integration and verification task.
-- Progress.txt from iteration 31 explicitly recommended this task.
-- All 8 chart tabs are implemented; this iteration validates everything works together.
-### Status: COMPLETE
-### What was done:
-- **Verified all 8 tabs dispatch correctly** — tested each tab's render function with default app_state in both directory and indication modes. All produce valid Plotly figures.
-- **Verified query functions with filters** — tested trust filter (NNUH), directorate filter (RHEUMATOLOGY), date filter (2yr_12mo), and indication mode. All return correct filtered data.
-- **Verified all figure builders** — all 8 figure builders produce valid traces (icicle: 1, market share: 39, cost effectiveness: 41, cost waterfall: 1, Sankey: 1, dosing: 1, heatmap: 1, duration: 1).
-- **App starts cleanly** — `python run_dash.py` runs without errors.
-- **No regressions** — icicle chart renders 293 nodes (directory) / 438 nodes (indication).
-- **Updated CLAUDE.md** with:
-  - `parsing.py` in package structure tree
-  - All 8 figure functions in Visualization Module section
-  - All 9 query functions in Shared Data Queries section
-  - Tab-based callback chain diagram
-  - Updated chart_card, sidebar, and callbacks descriptions
-  - Updated Output section listing all 8 chart tabs
-- **Marked Phase 9 Completion Criteria** all `[x]` in IMPLEMENTATION_PLAN.md
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional):
-  - All 8 tabs dispatch to correct figure builders — verified programmatically
-  - Directory mode: all 8 charts render with valid data
-  - Indication mode: all 8 charts render with valid data
-  - Trust filter (NNUH): icicle 107 nodes, market share 45 entries — filtered correctly
-  - Directorate filter (RHEUMATOLOGY): icicle 93 nodes, pathway costs 38 entries — filtered correctly
-  - Date filter (2yr_12mo): icicle 147 nodes — filtered correctly
-  - No "coming soon" placeholders remain — all tabs fully implemented
-### Files changed:
-- `CLAUDE.md` — Updated visualization, queries, parsing, callback chain, output sections
-- `IMPLEMENTATION_PLAN.md` — Task 9.10 marked [x], Phase 9 Completion Criteria all [x]
-### Committed: ca74be1 "docs: complete Phase 9 final integration (Task 9.10)"
-### Patterns discovered:
-- Programmatic verification of all 8 tab dispatch functions is more thorough than manual browser testing — catches data shape issues across all chart types simultaneously.
-- The full callback dispatch for 8 charts × 2 modes × multiple filter combinations runs in under 5 seconds, confirming lazy rendering is effective.
-### Next iteration should:
-- Phase 9 is COMPLETE. All tasks 9.1–9.10 are done.
-- All Phase 9 Completion Criteria are satisfied.
-- The completion signal should be output if all tasks in IMPLEMENTATION_PLAN.md are marked [x].
-### Blocked items:
-- None
-
-## Manual Intervention — 2026-02-06
-### Reason: Major UI restructure — split 8-tab single view into two-view architecture (Patient Pathways + Trust Comparison)
-### Changes made:
-- IMPLEMENTATION_PLAN.md — Added Phase 10 (Tasks 10.1–10.11) for two-view architecture + header redesign
-- IMPLEMENTATION_PLAN.md — Added Phase 10 Completion Criteria
-- guardrails.md — Added guardrails for two-view architecture, trust comparison queries, and frontend-design skill usage
-- progress.txt — This manual intervention entry
-### Tasks reset: None (Phase 9 work is still valid as foundation)
-### Tasks added:
-- 10.1: Design consultation via /frontend-design skill (header, sub-header, landing page, dashboard, filter placement)
-- 10.2: State management + sidebar restructure (active_view, selected_comparison_directorate)
-- 10.3: Header redesign — remove KPI row, add fraction KPIs
-- 10.4: Global filter sub-header bar (date + chart type, prominent, constant across views)
-- 10.5: Patient Pathways view — reduce to Icicle + Sankey only
-- 10.6: Trust Comparison query functions (6 per-trust-within-directorate queries)
-- 10.7: Trust Comparison landing page + directorate selector
-- 10.8: Trust Comparison 6-chart dashboard
-- 10.9: Patient Pathways filter relocation (drug/trust/directorate only on Patient Pathways)
-- 10.10: CSS updates + polish
-- 10.11: Final integration + documentation
-### Context for next iteration:
-- Phase 10 is entirely NEW work. No Phase 9 tasks were reset. The existing 8 chart implementations (query functions + visualization functions) are reusable foundations.
-- Task 10.1 MUST come first — use the `/frontend-design` skill (not the frontend-developer agent) to design all layouts before building them.
-- The key conceptual shift: Phase 9 charts compared all drugs across all directorates. Phase 10 Trust Comparison charts compare drugs WITHIN a single directorate ACROSS trusts.
-- Existing query functions (get_drug_market_share, get_cost_waterfall, etc.) may need NEW variants or parameters for the trust-comparison perspective. The existing functions aggregate across trusts; the new ones must break down BY trust.
-- Date filter + chart type toggle are GLOBAL (shared across both views). Drug/trust/directorate filters are PATIENT PATHWAYS ONLY.
-- Trust Comparison has its own filter: a directorate selector (landing page buttons). When chart type is "By Indication", the buttons show indications instead of directorates.
-- Cost Effectiveness moves to Trust Comparison but is NOT split by trust — it just filters pathways to the selected directorate.
-- KPI row is removed. 3 KPIs move to header as fractions: "X / X patients", "X / X drugs", "£X / £X cost" where numerator = filtered, denominator = global total.
-- The global filter sub-header (date + chart type) should be styled as a prominent, permanent fixture below the main header.
-### New guardrails added:
-- Two-view architecture: Patient Pathways vs Trust Comparison state isolation
-- Trust Comparison queries: per-trust-within-directorate perspective
-- Frontend-design skill: use /frontend-design skill, not frontend-developer agent
-
-## Iteration 33 — 2026-02-06
-### Task: Phase 10 — Task 10.1 (Design consultation via frontend-design skill)
-### Why this task:
-- First task in Phase 10, explicitly required to come before all other Phase 10 tasks
-- Guardrails mandate using /frontend-design skill for design work
-- All subsequent Phase 10 tasks depend on design decisions made here
-### Status: COMPLETE
-### What was done:
-- Read all current components (header.py, filter_bar.py, sidebar.py, kpi_row.py, chart_card.py, app.py, nhs.css) to understand existing layout
-- Used /frontend-design skill to design all 5 layout areas
-- Created comprehensive design specification document: `docs/PHASE10_DESIGN.md`
-- Design decisions for each area:
-
-**1. Header Redesign:**
-- Remove breadcrumb (redundant — sidebar shows location)
-- Add 3 inline fraction KPIs in center: `X / X patients`, `X / X drugs`, `£X / £X cost`
-- Numerator = filtered (bold white), denominator = muted, label = uppercase tiny
-- New CSS classes: `.top-header__kpis`, `.header-kpi`, `.header-kpi__num/sep/den/label`
-- 6 new callback output IDs: `kpi-filtered-patients/drugs/cost`, `kpi-total-patients/drugs/cost`
-
-**2. Global Filter Sub-Header:**
-- Fixed 44px bar below header, right of sidebar (`left: var(--sidebar-w)`)
-- Background: `#E8F0FE` (light blue tint) with `#C5D4E8` bottom border
-- Contains ONLY: chart type toggle pills + date filter dropdowns
-- New CSS classes: `.sub-header`, `.sub-header__group/label/divider`
-- `.main` margin-top increases from 56px to 100px (56 + 44)
-
-**3. Trust Comparison Landing Page:**
-- Responsive grid of directorate cards (3-col for ~14 directorates, 4-col for ~32 indications)
-- Each card: directorate name + patient count + drug count, blue left border on hover
-- Pattern-matching IDs: `{"type": "tc-selector", "index": "CARDIOLOGY"}`
-- New CSS classes: `.tc-landing`, `.tc-card`, `.tc-card__name/stats/stat/dot`
-
-**4. Trust Comparison 6-Chart Dashboard:**
-- 2×3 grid of chart cells, each with title bar + dcc.Graph (320px height)
-- Back button + directorate name title at top
-- 6 graph IDs: `tc-chart-market-share`, `tc-chart-cost-waterfall`, `tc-chart-dosing`, `tc-chart-heatmap`, `tc-chart-duration`, `tc-chart-cost-effectiveness`
-- New CSS classes: `.tc-dashboard`, `.tc-dashboard__grid`, `.tc-chart-cell`
-
-**5. Patient Pathways Filter Placement:**
-- Secondary filter strip below sub-header, ONLY visible on Patient Pathways view
-- Not fixed — scrolls with content (rendered inside view container)
-- Blue bottom border (2px) connects it visually to chart content below
-- New CSS class: `.pathway-filters`, `.pathway-filters__buttons`
-- Reuses existing `.filter-btn` and `.filter-btn__badge` classes
-
-**Layout summary:**
-- Header 56px → Sub-header 44px → Content at 100px from top
-- Sidebar unchanged at 240px
-- Two views: Patient Pathways (filter strip + chart card with Icicle + Sankey) and Trust Comparison (landing/dashboard)
-- View switching via sidebar nav items with IDs `nav-patient-pathways`, `nav-trust-comparison`
-
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, no code changes (design doc only)
-- Tier 2 (Design): Comprehensive spec document with exact CSS classes, HTML structure, callback IDs
-### Files changed:
-- `docs/PHASE10_DESIGN.md` — New: comprehensive design specification for all 5 areas
-- `IMPLEMENTATION_PLAN.md` — Task 10.1 marked [x]
-### Committed: 89f5b09 "docs: design specification for Phase 10 two-view architecture (Task 10.1)"
-### Patterns discovered:
-- The sub-header at 44px + header at 56px = 100px total fixed height. Using CSS variables (`--header-total-h: 100px`) makes this maintainable.
-- Trust Comparison landing cards should show patient/drug counts to help users choose which directorate to explore — pure directorate names are insufficient context.
-- The pathway filters strip (view-specific) should NOT be fixed-position — it scrolls with content, unlike the global sub-header which is fixed.
-- For ~32 indications, 4-column grid prevents excessive vertical scrolling. For ~14 directorates, 3 columns provides better card sizing.
-### Next iteration should:
-- Start Task 10.2 — State management + sidebar restructure
-- Key sub-steps:
-  1. Add `active_view` and `selected_comparison_directorate` to app-state store defaults
-  2. Update sidebar.py: rename "Pathway Overview" → "Patient Pathways", add "Trust Comparison" nav item with IDs from design doc
-  3. Add "compare" icon to _ICONS dict in sidebar.py
-  4. Add sidebar click callback → update `active_view` in app-state
-  5. Add view switching callback: show/hide patient-pathways-view vs trust-comparison-view based on active_view
-  6. Restructure app.py layout with view-container pattern from design doc
-- Read `docs/PHASE10_DESIGN.md` "Page Structure Summary" section for exact layout assembly
-- IMPORTANT: The sub-header component doesn't exist yet (that's Task 10.4). For 10.2, just restructure the state + sidebar + view switching. The existing filter_bar stays temporarily until 10.4 refactors it.
-### Blocked items:
-- None
-
-## Iteration 34 — 2026-02-06
-### Task: 10.2 — State management + sidebar restructure
-### Why this task:
-- Explicit recommendation from iteration 33 (10.1 design spec complete)
-- Foundation for all Phase 10 tasks — active_view state and view switching must exist before header redesign, sub-header, or Trust Comparison views can be built
-### Status: COMPLETE
-### What was done:
-- Added `active_view` ("patient-pathways" default) and `selected_comparison_directorate` (null) to app-state defaults in both app.py and the fallback in filters.py callback
-- Updated sidebar.py: renamed section from "Overview" to "Analysis", nav items "Patient Pathways" (id=nav-patient-pathways) and "Trust Comparison" (id=nav-trust-comparison) with bar-chart compare icon
-- Added sidebar nav clicks as Inputs to existing `update_app_state` callback in filters.py — sets active_view based on triggered_id
-- Created `dash_app/callbacks/navigation.py` with `switch_view` callback: reads app-state.active_view, outputs show/hide styles for patient-pathways-view and trust-comparison-view divs, plus sidebar active CSS classes
-- Registered navigation callbacks in callbacks/__init__.py
-- Restructured app.py layout: main content now has a view-container div with two child view divs (patient-pathways-view and trust-comparison-view). Trust Comparison view starts hidden, contains a placeholder tc-landing structure matching the design doc
-- Existing KPI row, filter bar, and chart card remain inside patient-pathways-view (no changes to those components)
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK. `python run_dash.py` starts on port 8050 — OK.
-- Tier 2 (Layout): Sidebar renders with 2 nav items. View container has 2 view divs. Trust Comparison hidden by default.
-- Tier 3 (Functional): 12 callbacks registered total. Navigation callback correctly outputs to 4 IDs (2 view styles + 2 sidebar classNames). App-state callback has sidebar nav as Inputs. No duplicate output conflicts.
-### Files changed:
-- `dash_app/app.py` — Restructured layout with view-container pattern, added active_view + selected_comparison_directorate to app-state defaults
-- `dash_app/components/sidebar.py` — Two nav items with IDs, "compare" icon, renamed section
-- `dash_app/callbacks/filters.py` — Added nav-patient-pathways and nav-trust-comparison as Inputs, active_view logic
-- `dash_app/callbacks/navigation.py` — New: switch_view callback for view visibility + sidebar active state
-- `dash_app/callbacks/__init__.py` — Register navigation callbacks
-- `IMPLEMENTATION_PLAN.md` — Task 10.2 marked [x]
-### Committed: 7d51efc "feat: add two-view architecture with sidebar navigation (Task 10.2)"
-### Patterns discovered:
-- Sidebar nav clicks must go through the EXISTING update_app_state callback (which already owns app-state Output). Can't have a second callback writing to the same Output. Added nav clicks as additional Inputs to the same callback.
-- The view switching callback is separate and reads FROM app-state — this is fine because it only reads (Input), doesn't write to app-state.
-### Next iteration should:
-- Start Task 10.3 — Header redesign (remove KPI row, add fraction KPIs to header)
-- Key sub-steps:
-  1. Read `docs/PHASE10_DESIGN.md` Section 1 for exact HTML structure and CSS classes
-  2. Update header.py: remove breadcrumb, add 3 fraction KPI divs with IDs (kpi-filtered-patients, kpi-total-patients, etc.)
-  3. Remove kpi_row.py component (or gut it) and remove make_kpi_row() from the patient-pathways-view in app.py
-  4. Update kpi.py callback: change Outputs from old KPI card IDs to new header KPI IDs. Need both filtered values (from chart-data) and total values (from reference-data) as Inputs.
-  5. Add new CSS classes to nhs.css: .top-header__kpis, .header-kpi, .header-kpi__num/sep/den/label (from design doc)
-  6. Remove .top-header__breadcrumb usage from header.py
-- The existing `register_kpi_callbacks` in kpi.py will need to be refactored to output to the new header KPI element IDs
-- CSS for the Trust Comparison landing page will come in Task 10.10, don't worry about it now
-### Blocked items:
-- None
-
-## Iteration 35 — 2026-02-06
-### Task: Phase 10 — Task 10.3 (Header redesign — remove KPI row, add fraction KPIs)
-### Why this task:
-- Task 10.2 (state management + sidebar restructure) complete in iteration 34
-- Progress.txt from iteration 34 explicitly recommended Task 10.3 as next
-- Header fraction KPIs are needed before sub-header (10.4) — they establish the new header layout
-### Status: COMPLETE
-### What was done:
-- **Updated `dash_app/components/header.py`**:
-  - Removed breadcrumb div (was "Dashboard › Pathway Analysis")
-  - Added 3 fraction KPI divs in center: patients, drugs, cost
-  - Each KPI has 4 spans: numerator (filtered, bold white), separator (/), denominator (total, muted), label (uppercase tiny)
-  - 6 new callback IDs: `kpi-filtered-patients`, `kpi-total-patients`, `kpi-filtered-drugs`, `kpi-total-drugs`, `kpi-filtered-cost`, `kpi-total-cost`
-  - Right section (data freshness) unchanged
-- **Removed KPI row from `app.py`**:
-  - Removed `from dash_app.components.kpi_row import make_kpi_row` import
-  - Removed `make_kpi_row()` from patient-pathways-view children
-  - `kpi_row.py` file kept but not imported (dead code, can be deleted later)
-- **Refactored `dash_app/callbacks/kpi.py`**:
-  - Old: 4 outputs to KPI card IDs (kpi-patients, kpi-drugs, kpi-cost, kpi-match)
-  - New: 6 outputs — 3 filtered (from chart-data) + 3 total (from reference-data)
-  - Inputs: `chart-data` (filtered values) and `reference-data` (totals)
-  - Total patients from `reference-data.total_patients`, total drugs from `len(reference-data.available_drugs)`, total cost from `reference-data.total_cost`
-  - Removed indication match rate KPI entirely
-- **Updated `src/data_processing/pathway_queries.py`**:
-  - `load_initial_data()` now also returns `total_cost` from the default root node (alongside `total_patients`)
-  - Query changed from `SELECT value` to `SELECT value, cost` for root node
-  - Always fetches root node (removed the `if not total_records` gate — total_patients and total_cost always needed)
-- **Added CSS to `dash_app/assets/nhs.css`**:
-  - `.top-header__kpis` — flex container centered in header
-  - `.header-kpi` — flex row with baseline alignment, muted white text
-  - `.header-kpi__num` — bold white 16px with tabular-nums
-  - `.header-kpi__sep` — dim separator "/"
-  - `.header-kpi__den` — muted 13px denominator
-  - `.header-kpi__label` — uppercase 11px label (patients/drugs/cost)
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 2 (Layout):
-  - 6 header KPI IDs in layout: kpi-filtered-patients/drugs/cost, kpi-total-patients/drugs/cost — all FOUND
-  - Breadcrumb removed from layout — confirmed
-  - `top-header__kpis` and `header-kpi` CSS classes in layout — confirmed
-- Tier 3 (Functional):
-  - 12 callbacks registered (same count — old KPI callback replaced with new one)
-  - Reference data: total_patients=11,118, total_cost=£130.6M, 42 drugs
-  - Chart data unfiltered: 11,118 patients, 39 drugs, £130.6M
-  - Chart data ADALIMUMAB: 3,236 patients, 17 drugs, £29.2M (fractions work correctly)
-### Files changed:
-- `dash_app/components/header.py` — Rewritten: breadcrumb removed, 3 fraction KPIs added
-- `dash_app/app.py` — Removed: kpi_row import and make_kpi_row() call
-- `dash_app/callbacks/kpi.py` — Refactored: 6 header KPI outputs (3 filtered + 3 total)
-- `dash_app/assets/nhs.css` — Added: header KPI CSS classes (~42 lines)
-- `src/data_processing/pathway_queries.py` — Updated: load_initial_data() returns total_cost
-- `IMPLEMENTATION_PLAN.md` — Task 10.3 marked [x]
-### Committed: 11b5cc5 "feat: header fraction KPIs replacing KPI row (Task 10.3)"
-### Patterns discovered:
-- The reference-data store lacked `total_cost` — had to add it to `load_initial_data()` by expanding the root node query from `SELECT value` to `SELECT value, cost`. This is a safe addition to the shared utility (not pipeline logic).
-- The `if not total_records` gate on the root node query was wrong — we always need total_patients and total_cost for the header KPIs regardless of whether source_row_count is populated. Removed the gate.
-- `kpi_row.py` file kept but unused. Could be deleted in cleanup but doesn't hurt.
-- The `_format_cost` helper was preserved in kpi.py — it's reused for both filtered and total cost formatting.
-### Next iteration should:
-- Start Task 10.4 — Global filter sub-header bar
-- Key sub-steps:
-  1. Read `docs/PHASE10_DESIGN.md` Section 2 for exact HTML structure and CSS classes
-  2. Extract date filter dropdowns + chart type toggle from `filter_bar.py` into a new sub-header component
-  3. The sub-header is a fixed 44px bar below the main header, full width minus sidebar
-  4. Background: `#E8F0FE` with `#C5D4E8` bottom border
-  5. Contains ONLY: chart type toggle pills + date filter dropdowns (no drug/trust/directorate buttons)
-  6. Drug/trust/directorate filter buttons stay in filter_bar.py but move to Patient Pathways view only (Task 10.9)
-  7. Update `.main` margin-top from 56px to 100px (56 header + 44 sub-header)
-  8. Sub-header must be constant across both views (fixed position, not inside view container)
-- The existing filter_bar.py has both global controls (chart type, dates) and view-specific controls (drug/trust/directorate buttons). Task 10.4 extracts the global controls into a sub-header; the view-specific buttons stay temporarily until Task 10.9 relocates them.
-### Blocked items:
-- None
-
-## Iteration 36 — 2026-02-06
-### Task: Phase 10 — Task 10.4 (Global filter sub-header bar)
-### Why this task:
-- Task 10.3 (header fraction KPIs) complete in iteration 35
-- Progress.txt from iteration 35 explicitly recommended Task 10.4 as next
-- The sub-header is a prerequisite for proper two-view layout — global controls must be separated from view-specific controls
-### Status: COMPLETE
-### What was done:
-- **Created `dash_app/components/sub_header.py`**:
-  - New `make_sub_header()` function returning a fixed-position bar below the header
-  - Contains chart type toggle pills (By Directory / By Indication) and date filter dropdowns (Initiated, Last Seen)
-  - Uses CSS classes from design spec: `.sub-header`, `.sub-header__group`, `.sub-header__label`, `.sub-header__divider`
-  - Same component IDs as before: `chart-type-directory`, `chart-type-indication`, `filter-initiated`, `filter-last-seen`
-- **Updated `dash_app/components/filter_bar.py`**:
-  - Removed chart type toggle, date filter dropdowns, and associated dividers
-  - Now contains ONLY: drug/trust/directorate filter buttons + "Clear All" button
-  - Removed `dcc` import (no longer needed — only `html` used)
-- **Updated `dash_app/app.py`**:
-  - Added `from dash_app.components.sub_header import make_sub_header`
-  - Inserted `make_sub_header()` between `make_header()` and `make_sidebar()` in layout
-  - Sub-header is outside the view container — constant across both views
-- **Added CSS to `dash_app/assets/nhs.css`**:
-  - `.sub-header` — fixed position, top: 56px (below header), left: sidebar width, z-index: 150, height: 44px, background: #E8F0FE, border-bottom: #C5D4E8
-  - `.sub-header__group`, `.sub-header__label`, `.sub-header__divider` — layout/typography per design spec
-  - Updated `.main` margin-top from 56px → 100px (56px header + 44px sub-header)
-  - Updated `.main` min-height from calc(100vh - 56px) → calc(100vh - 100px)
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 2 (Layout):
-  - 11 critical IDs verified in layout: chart-type-directory, chart-type-indication, filter-initiated, filter-last-seen, open-drug-modal, open-trust-modal, open-directorate-modal, clear-all-filters, drug-count-badge, trust-count-badge, directorate-count-badge — all FOUND
-  - Sub-header component renders between header and sidebar in layout tree
-- Tier 3 (Functional):
-  - 12 callbacks registered (same count as before — no regression)
-  - All callback chains intact: app-state, chart-data, reference-data, KPIs, navigation
-  - Toggle pill IDs and date filter IDs unchanged — callbacks reference them by ID regardless of parent container
-### Files changed:
-- `dash_app/components/sub_header.py` — NEW: global filter sub-header component
-- `dash_app/components/filter_bar.py` — Stripped to drug/trust/directorate buttons only
-- `dash_app/app.py` — Added sub_header import and make_sub_header() call
-- `dash_app/assets/nhs.css` — Added sub-header CSS, updated .main margin-top to 100px
-- `IMPLEMENTATION_PLAN.md` — Task 10.4 marked [x]
-### Committed: 7e0c851 "feat: add global filter sub-header bar (Task 10.4)"
-### Patterns discovered:
-- Moving components between containers doesn't break Dash callbacks — IDs are resolved globally, not by parent hierarchy. As long as the component IDs stay the same, callbacks just work.
-- The sub-header uses `position: fixed` with `left: var(--sidebar-w)` to sit right of the sidebar. The `.main` content area pushes down with `margin-top: 100px` to avoid overlap.
-### Next iteration should:
-- Start Task 10.5 — Patient Pathways view: reduce to Icicle + Sankey tabs only
-- Key sub-steps:
-  1. Read `dash_app/components/chart_card.py` to see current 8-tab structure
-  2. Remove 6 tabs from Patient Pathways view: Market Share, Cost Waterfall, Cost Effectiveness, Dosing, Heatmap, Duration
-  3. Keep only Icicle and Sankey tabs in the tab bar
-  4. The 6 removed chart types will reappear in Trust Comparison (Task 10.8)
-  5. Update the chart callback in `dash_app/callbacks/chart.py` to only handle icicle and sankey for Patient Pathways view
-  6. Verify icicle and sankey still work with all existing filters
-- Important: the removed tabs' callback logic should NOT be deleted — it will be reused in Task 10.8 (Trust Comparison 6-chart dashboard). Just remove them from the Patient Pathways tab bar. The chart callback may need a guard to only render icicle/sankey when active_view is patient-pathways.
-### Blocked items:
-- None
-
-## Iteration 37 — 2026-02-06
-### Task: Phase 10 — Task 10.5 (Patient Pathways view — reduce to Icicle + Sankey)
-### Why this task:
-- Task 10.4 (global filter sub-header) complete in iteration 36
-- Progress.txt from iteration 36 explicitly recommended Task 10.5 as next
-- Logical prerequisite: before building Trust Comparison (10.7/10.8), the Patient Pathways view needs its tab set trimmed
-### Status: COMPLETE
-### What was done:
-- **Updated `dash_app/components/chart_card.py`**:
-  - Reduced `TAB_DEFINITIONS` from 8 tabs to 2: Icicle + Sankey
-  - Added `ALL_TAB_DEFINITIONS` list preserving all 8 tab definitions for Trust Comparison reuse (Task 10.8)
-  - `make_chart_card()` now renders only 2 tab buttons
-- **Updated `dash_app/callbacks/chart.py`**:
-  - `_TAB_IDS` now derives from the reduced `TAB_DEFINITIONS` (2 tabs)
-  - `switch_tab` callback only registers Inputs/Outputs for `tab-icicle` and `tab-sankey`
-  - All 8 `_render_*` helper functions preserved intact for Trust Comparison reuse
-  - Added module-level docstring explaining the preservation strategy
-  - `update_chart` dispatch still has all 8 branches (graceful fallback for any unexpected tab value)
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 2 (Layout):
-  - Only 2 tab buttons found in layout: `tab-icicle`, `tab-sankey`
-  - All 6 removed tab IDs confirmed absent: tab-market-share, tab-cost-effectiveness, tab-cost-waterfall, tab-dosing, tab-heatmap, tab-duration
-  - All critical IDs present: pathway-chart, chart-data, app-state, reference-data, active-tab, chart-subtitle
-- Tier 3 (Functional):
-  - 12 callbacks registered (same count as before — no regression)
-  - switch_tab callback outputs to tab-icicle.className and tab-sankey.className only
-### Files changed:
-- `dash_app/components/chart_card.py` — Reduced TAB_DEFINITIONS to 2 tabs, added ALL_TAB_DEFINITIONS
-- `dash_app/callbacks/chart.py` — Updated _TAB_IDS, added docstring about render helper preservation
-- `IMPLEMENTATION_PLAN.md` — Task 10.5 marked [x]
-### Committed: 979b797 "feat: reduce Patient Pathways to Icicle + Sankey tabs only (Task 10.5)"
-### Patterns discovered:
-- Since `_TAB_IDS` is derived from `TAB_DEFINITIONS` at import time, reducing the source list automatically cascades to the callback registration. No manual callback editing needed.
-- Keeping `ALL_TAB_DEFINITIONS` in chart_card.py means Task 10.8 can import it to build the Trust Comparison tab bar without recreating the list.
-- The `_render_*` helpers are pure functions (input → figure) with no dependency on the tab infrastructure. They just need `app_state` and a title. This makes them trivially reusable from any callback.
-### Next iteration should:
-- Start Task 10.6 — Trust Comparison query functions
-- Key sub-steps:
-  1. Read existing query functions in `src/data_processing/pathway_queries.py` to understand patterns
-  2. Create 5 NEW trust-comparison query functions (NOT modify existing ones):
-     - `get_trust_market_share(db_path, filter_id, chart_type, directory)` — drugs by trust within a single directorate
-     - `get_trust_cost_waterfall(db_path, filter_id, chart_type, directory)` — one bar per trust showing cost_pp
-     - `get_trust_dosing(db_path, filter_id, chart_type, directory)` — drug dosing by trust within directorate
-     - `get_trust_heatmap(db_path, filter_id, chart_type, directory)` — trust × drug matrix for one directorate
-     - `get_trust_durations(db_path, filter_id, chart_type, directory)` — drug durations by trust
-  3. Verify `get_pathway_costs(directory=X)` already works correctly for directorate-scoped Cost Effectiveness (6th chart uses existing function)
-  4. Add thin wrappers in `dash_app/data/queries.py`
-  5. Test all queries with `python -c "..."` using sample directorates
-- Important: Per guardrails, Trust Comparison queries must break down BY trust, not aggregate across trusts. Existing Phase 9 functions aggregate across trusts. Create NEW functions, don't modify existing ones.
-- Refer to `AdditionalAnalytics.md` for chart specifications and data requirements
-### Blocked items:
-- None
-
-## Iteration 38 — 2026-02-06
-### Task: 10.6 — Trust Comparison query functions
-### Why this task:
-- Task 10.5 (Patient Pathways 2-tab view) was completed in iteration 37
-- Progress.txt from iteration 37 explicitly recommended Task 10.6 as next
-- These query functions are the data layer prerequisite for Tasks 10.7 (landing page) and 10.8 (6-chart dashboard)
-### Status: COMPLETE
-### What was done:
-- **Added 5 new trust-comparison query functions** to `src/data_processing/pathway_queries.py`:
-  1. `get_trust_market_share(db_path, filter_id, chart_type, directory)` — drugs by trust within a single directorate, with per-trust proportions
-  2. `get_trust_cost_waterfall(db_path, filter_id, chart_type, directory)` — cost per patient by trust within a directorate
-  3. `get_trust_dosing(db_path, filter_id, chart_type, directory)` — drug dosing intervals by trust, uses `parse_average_spacing()`
-  4. `get_trust_heatmap(db_path, filter_id, chart_type, directory)` — trust x drug matrix for one directorate (rows=trusts, cols=drugs)
-  5. `get_trust_durations(db_path, filter_id, chart_type, directory)` — per-trust drug durations, no aggregation
-- **Verified existing `get_pathway_costs(directory=X)` works** for directorate-scoped Cost Effectiveness (38 RHEUMATOLOGY pathway records returned correctly). No new `get_directorate_pathway_costs` function needed — the existing function already handles this.
-- **Added thin wrappers** in `dash_app/data/queries.py` for all 5 new functions
-- **Tested all queries** with both chart types:
-  - `directory` chart type with RHEUMATOLOGY: 42 market share rows, 6 trusts in waterfall, 40 dosing records, 6x17 heatmap, 40 duration records
-  - `indication` chart type with "asthma": 3 market share rows, 2 trusts, 2x2 heatmap, 3 duration records
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK
-- Tier 1 (App starts): `python run_dash.py` — "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 1 (Imports): All 5 new wrappers import successfully via `dash_app.data.queries`
-- Tier 3 (Functional): All 5 queries return correct per-trust data for both chart types
-### Files changed:
-- `src/data_processing/pathway_queries.py` — Added 5 trust-comparison query functions + section comment
-- `dash_app/data/queries.py` — Added 5 thin wrappers + imports
-- `IMPLEMENTATION_PLAN.md` — Task 10.6 marked [x]
-### Committed: 9d4e329 "feat: add 5 trust-comparison query functions for Phase 10.6"
-### Patterns discovered:
-- Trust Comparison queries are simpler than Phase 9 equivalents because they DON'T aggregate across trusts — each row in pathway_nodes is already per-trust. The Phase 9 functions had aggregation logic (dictionaries, weighted averages) that these don't need.
-- `directory` parameter is required (not optional) for all trust-comparison functions, since Trust Comparison always operates within a single directorate/indication.
-- The indication chart type uses the same `directory` column as directory charts — e.g., "asthma", "crohn's disease" as directory values. The column name is the same, just the content differs.
-- Existing `get_pathway_costs` already has `directory` and `trust` params. For Trust Comparison Cost Effectiveness (directorate-scoped, no trust split), call it with `directory=selected` and no trust filter. Works out of the box.
-### Next iteration should:
-- Start Task 10.7 — Trust Comparison landing page + directorate selector
-- Key sub-steps:
-  1. Create a new `dash_app/components/trust_comparison.py` with two rendering modes:
-     - Landing page: grid of directorate/indication buttons (from reference-data store)
-     - Dashboard: placeholder for 6-chart layout (filled in Task 10.8)
-  2. Read the design from Task 10.1 (iteration 33) to match layout approach — the /frontend-design skill output was captured there
-  3. Wire button clicks to set `selected_comparison_directorate` in app-state
-  4. Add a "Back" button to return to landing (clears `selected_comparison_directorate`)
-  5. Respect chart_type toggle: "By Directory" shows ~14 directorate buttons, "By Indication" shows ~32 indication buttons
-  6. The view should be visible when `active_view == "trust-comparison"` in app-state
-- The query functions for the 6-chart dashboard are now ready (5 new + existing get_pathway_costs)
-- Reference-data store already has `available_directorates` (14) and `available_indications` (32+) from `load_initial_data()`
-### Blocked items:
-- None
-
-## Iteration 39 — 2026-02-06
-### Task: 10.7 — Trust Comparison landing page + directorate selector
-### Why this task:
-- Task 10.6 (trust-comparison query functions) was completed in iteration 38
-- Progress.txt from iteration 38 explicitly recommended Task 10.7 as next
-- This builds the UI for the Trust Comparison view landing page (directorate selector grid + dashboard shell)
-### Status: COMPLETE
-### What was done:
-- **Added `get_directorate_summary()` query function** to `src/data_processing/pathway_queries.py`:
-  - Queries level 2 nodes for patient counts and level 3 for drug counts per directorate/indication
-  - Returns sorted list of dicts: `[{"name": "OPHTHALMOLOGY", "patients": 4042, "drugs": 8}, ...]`
-  - Works for both chart types: 13 directorates (directory mode), 39 indications (indication mode)
-  - Added thin wrapper in `dash_app/data/queries.py`
-- **Created `dash_app/components/trust_comparison.py`** with two layout functions:
-  - `make_tc_landing()` — landing page with header, description, and dynamically-populated grid of directorate cards
-  - `make_tc_dashboard()` — 6-chart dashboard with back button, title, and 2×3 grid of `dcc.Graph` cells (initially hidden)
-  - Helper `_tc_chart_cell()` for each chart cell (title + `dcc.Loading` + `dcc.Graph`)
-- **Updated `dash_app/app.py`** — replaced inline TC placeholder with `make_tc_landing()` + `make_tc_dashboard()` components
-- **Updated `dash_app/callbacks/filters.py`** — added pattern-matching `tc-selector` clicks and `tc-back-btn` as Inputs to `update_app_state`:
-  - TC card click → sets `selected_comparison_directorate` to the card's directorate name
-  - Back button → clears `selected_comparison_directorate` (returns to landing)
-  - Chart type toggle change → clears `selected_comparison_directorate` (per guardrails)
-- **Created `dash_app/callbacks/trust_comparison.py`** with 3 callback groups:
-  1. `populate_landing_grid` — reads app-state, calls `get_directorate_summary()`, generates card buttons with patient/drug stats, adapts grid class (3-col for directory, 4-col for indication)
-  2. `toggle_tc_subviews` — shows landing or dashboard based on `selected_comparison_directorate` in app-state
-  3. 6 placeholder chart callbacks — return empty figures with "Chart will be implemented in Task 10.8" annotation
-- **Added CSS** to `dash_app/assets/nhs.css`:
-  - `.tc-landing`, `.tc-landing__header/title/desc/grid`, `.tc-landing__grid--wide`
-  - `.tc-card`, `.tc-card:hover`, `.tc-card__name/stats/stat/dot`
-  - `.tc-dashboard`, `.tc-dashboard__header/back/title`, `.tc-dashboard__grid`
-  - `.tc-chart-cell`, `.tc-chart-cell__title`
-  - Responsive: 2-col grid at 1200px, 1-col at 768px
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK
-- Tier 1 (App starts): `python run_dash.py` — "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 1 (Callbacks): 20 callbacks registered total (6 TC chart placeholders + 2 TC nav + existing)
-- Tier 3 (Functional): `get_directorate_summary()` returns 13 directorates (directory) and 39 indications (indication). All card IDs unique in both modes. Pattern-matching IDs for tc-selector correctly integrated into update_app_state.
-### Files changed:
-- `src/data_processing/pathway_queries.py` — Added `get_directorate_summary()` function
-- `dash_app/data/queries.py` — Added thin wrapper + import
-- `dash_app/components/trust_comparison.py` — New: `make_tc_landing()` + `make_tc_dashboard()`
-- `dash_app/app.py` — Replaced inline TC placeholder with component functions
-- `dash_app/callbacks/filters.py` — Added tc-selector and tc-back-btn as Inputs, chart type change clears directorate
-- `dash_app/callbacks/trust_comparison.py` — New: landing grid population, subview toggle, 6 placeholder charts
-- `dash_app/callbacks/__init__.py` — Register trust_comparison callbacks
-- `dash_app/assets/nhs.css` — Added TC landing + dashboard CSS
-- `IMPLEMENTATION_PLAN.md` — Task 10.7 marked [x]
-### Committed: 10739ca "feat: Trust Comparison landing page + directorate selector (Task 10.7)"
-### Patterns discovered:
-- The indication list in `ref_drug_indication_clusters` uses title case (e.g., "Rheumatoid arthritis") but pathway_nodes level 2 uses lowercase (e.g., "rheumatoid arthritis") and includes fallback labels like "RHEUMATOLOGY (no GP dx)". The landing page cards should use data from pathway_nodes (via `get_directorate_summary`) not from reference-data, since those are the actual values the trust-comparison queries will filter on.
-- The `SUM(value)` for level 2 is needed because multiple trusts can have the same directorate — the level 2 node is per-trust-per-directorate (parent is a trust node). This means "RHEUMATOLOGY" appears once per trust at level 2.
-- Pattern-matching callbacks with `ALL` work fine for dynamically-created components when `suppress_callback_exceptions=True` is set. The `update_app_state` callback receives `_tc_selector_clicks` as a list, but `ctx.triggered_id` gives the specific dict ID that fired.
-- Dashboard charts use `prevent_initial_call=True` to avoid rendering on page load when no directorate is selected.
-### Next iteration should:
-- Start Task 10.8 — Trust Comparison 6-chart dashboard
-- Key sub-steps:
-  1. Replace the 6 placeholder chart callbacks in `trust_comparison.py` with real implementations
-  2. Each chart calls the corresponding trust-comparison query wrapper (from `dash_app/data/queries.py`) and visualization function (from `src/visualization/plotly_generator.py`)
-  3. May need new visualization functions for trust-comparison perspective (e.g., `create_trust_market_share_figure`, `create_trust_heatmap_figure`) or parameterize existing ones
-  4. All 6 charts should respond to date_filter_id and chart_type from app-state
-  5. Cost Effectiveness uses existing `get_pathway_costs(directory=selected)` — not trust-split
-  6. Read `AdditionalAnalytics.md` for chart specifications
-  7. Read `src/visualization/plotly_generator.py` for existing figure functions to understand patterns
-- The query wrappers are ready: `get_trust_market_share`, `get_trust_cost_waterfall`, `get_trust_dosing`, `get_trust_heatmap`, `get_trust_durations`, and existing `get_pathway_costs`
-### Blocked items:
-- None
-
-## Iteration 41 — 2026-02-06
-### Task: 10.9 — Patient Pathways filter relocation
-### Why this task:
-- Task 10.8 (TC 6-chart dashboard) was completed in iteration 40
-- Progress.txt from iteration 40 explicitly recommended Task 10.9 as next
-- This task ensures drug/trust/directorate filter buttons are only visible on Patient Pathways, hidden on Trust Comparison
-### Status: COMPLETE
-### What was done:
-- **Verified filter bar placement**: `make_filter_bar()` was already inside `patient-pathways-view` div in `app.py` (line 54). When the navigation callback hides `patient-pathways-view` via `display: none`, the filter buttons are automatically hidden on Trust Comparison. No structural relocation needed.
-- **Updated `dash_app/components/filter_bar.py`**:
-  - Changed wrapper from `html.Section(className="filter-bar")` to `html.Div(className="pathway-filters", id="pathway-filters")`
-  - Changed inner group from `filter-bar__group` to `pathway-filters__buttons`
-  - Matches design spec from `docs/PHASE10_DESIGN.md` Section 5 exactly
-  - Updated module docstring to clarify view-specific scope
-- **Updated `dash_app/assets/nhs.css`**:
-  - Replaced `.filter-bar`, `.filter-bar__group`, `.filter-bar__divider`, `.filter-bar__label` classes with `.pathway-filters` and `.pathway-filters__buttons`
-  - New styling: white background, 1px border with `2px solid var(--nhs-blue)` bottom border, 8px padding, `justify-content: space-between`
-  - Blue bottom border visually connects the filter strip to the chart content below (per design spec)
-- **Verified no remaining references** to old `.filter-bar` class in any code or CSS
-- All component IDs unchanged: `open-drug-modal`, `open-trust-modal`, `open-directorate-modal`, `clear-all-filters`, `drug-count-badge`, `trust-count-badge`, `directorate-count-badge`
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 20 callbacks registered
-- Tier 1 (App starts): `python run_dash.py` — "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 2 (Layout):
-  - `pathway-filters` inside `patient-pathways-view` — confirmed
-  - `trust-comparison-view` has NO filter components — confirmed
-  - All 8 key IDs present in layout: pathway-filters, open-drug-modal, open-trust-modal, open-directorate-modal, clear-all-filters, drug-count-badge, trust-count-badge, directorate-count-badge
-- Tier 3 (Functional):
-  - Modal open callbacks still wired: open-drug-modal → drug-modal.opened, etc.
-  - Count badge callback still wired: all-drugs-chips + trust-chips → badge children/className
-  - View switching: patient-pathways-view shown/hidden via switch_view callback — filter bar hidden when Trust Comparison active
-### Files changed:
-- `dash_app/components/filter_bar.py` — Updated CSS classes from .filter-bar to .pathway-filters per design spec
-- `dash_app/assets/nhs.css` — Replaced .filter-bar CSS with .pathway-filters CSS (blue bottom border, space-between layout)
-- `IMPLEMENTATION_PLAN.md` — Task 10.9 marked [x]
-### Committed: f1eecf8 "feat: scope pathway filters to Patient Pathways view with design-spec CSS (Task 10.9)"
-### Patterns discovered:
-- The filter bar was already correctly placed inside `patient-pathways-view` since Task 10.2 restructured the layout. The view switching callback hides the entire view div, so all children (including the filter bar) are automatically hidden. No conditional visibility logic needed.
-- Renaming CSS classes (filter-bar → pathway-filters) without changing component IDs means zero callback changes. Dash callbacks reference components by ID, not by CSS class.
-### Next iteration should:
-- Start Task 10.10 — CSS updates + polish
-- Key sub-steps:
-  1. Review all Phase 10 CSS to ensure consistency with design spec
-  2. Check sub-header styling (already done in 10.4 but verify against design spec)
-  3. Trust Comparison landing page styling (already done in 10.7 but verify)
-  4. Trust Comparison dashboard grid styling (already done in 10.8 but verify)
-  5. Header fraction KPI styling (already done in 10.3 but verify)
-  6. Remove or repurpose `.kpi-row` / `.kpi-card` CSS that is no longer used
-  7. Ensure responsive behavior for both views
-  8. Consider whether `01_nhs_classic.html` needs updating or noting that Phase 10 diverges
-- Much of this CSS work was already done in previous tasks (10.3, 10.4, 10.7, 10.8). The main remaining items are cleanup (removing dead CSS) and ensuring responsive behavior.
-- Read `dash_app/assets/nhs.css` fully to identify dead CSS classes
-### Blocked items:
-- None
-
-## Iteration 40 — 2026-02-06
-### Task: 10.8 — Trust Comparison 6-chart dashboard
-### Why this task:
-- Task 10.7 (TC landing page + directorate selector) was completed in iteration 39
-- Progress.txt from iteration 39 explicitly recommended Task 10.8 as next
-- This is the core data visualization task for Trust Comparison — replacing 6 placeholder charts with real implementations
-### Status: COMPLETE
-### What was done:
-- **Added 3 new visualization functions** to `src/visualization/plotly_generator.py`:
-  1. `create_trust_market_share_figure(data, title)` — horizontal stacked bars grouped by trust (drugs as segments), short trust names for readability
-  2. `create_trust_heatmap_figure(data, title, metric)` — trust × drug matrix with NHS blue colorscale, shortened trust names on y-axis
-  3. `create_trust_duration_figure(data, title)` — grouped horizontal bars with one trace per trust, drugs on y-axis
-- **Replaced 6 placeholder callbacks** in `dash_app/callbacks/trust_comparison.py`:
-  1. **Market Share**: `get_trust_market_share` → `create_trust_market_share_figure` (new function)
-  2. **Cost Waterfall**: `get_trust_cost_waterfall` → mapped `trust_name→directory` key → reused `create_cost_waterfall_figure`
-  3. **Dosing**: `get_trust_dosing` + directory field injection → reused `create_dosing_figure(group_by="trust")`
-  4. **Heatmap**: `get_trust_heatmap` → `create_trust_heatmap_figure` (new function)
-  5. **Duration**: `get_trust_durations` → `create_trust_duration_figure` (new function)
-  6. **Cost Effectiveness**: existing `get_pathway_costs(directory=selected)` + `calculate_retention_rate` → reused `create_cost_effectiveness_figure`
-- Added helper functions: `_tc_empty()` for empty state messages, `_tc_title()` for chart title generation
-- All 6 callbacks respond to `selected_comparison_directorate`, `date_filter_id`, and `chart_type` from app-state
-- All use `prevent_initial_call=True` to avoid rendering when no directorate selected
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 20 callbacks registered
-- Tier 1 (App starts): `python run_dash.py` → "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional — directory mode, RHEUMATOLOGY):
-  - Market Share: 42 rows, 17 traces (drug traces across 6 trusts)
-  - Cost Waterfall: 6 trusts, 1 trace (bars)
-  - Dosing: 40 entries, 1 trace (grouped by trust)
-  - Heatmap: 6 trusts × 17 drugs
-  - Duration: 40 entries, 6 traces (one per trust)
-  - Cost Effectiveness: 38 pathways, 39 traces (sticks + dots)
-- Tier 3 (Functional — indication mode, asthma):
-  - Market Share: 3 rows, 2 traces
-  - Cost Waterfall: 2 trusts
-  - Dosing: 3 entries
-  - Heatmap: 2 trusts × 2 drugs
-  - Duration: 3 entries, 2 traces
-  - Cost Effectiveness: 0 pathways (expected — no multi-drug pathways for asthma)
-### Files changed:
-- `src/visualization/plotly_generator.py` — Added 3 trust-comparison figure functions (~306 new lines)
-- `dash_app/callbacks/trust_comparison.py` — Replaced 6 placeholders with real chart callbacks
-- `IMPLEMENTATION_PLAN.md` — Task 10.8 marked [x]
-### Committed: ea6b906 "feat: Trust Comparison 6-chart dashboard with real data (Task 10.8)"
-### Patterns discovered:
-- Reusing existing visualization functions by mapping data keys (e.g., `trust_name` → `directory`) is cleaner than creating entirely new functions for identical chart types. Cost Waterfall and Dosing both reused existing functions.
-- The `_dosing_by_trust` helper in `create_dosing_figure` expects a `directory` key even when data is already scoped to one directory. Adding the field in the callback is the simplest fix.
-- Trust names are long ("CAMBRIDGE UNIVERSITY HOSPITALS NHS FOUNDATION TRUST") — `short_trust()` helper strips common suffixes for chart readability.
-- Cost Effectiveness for indication mode with narrow indications (like "asthma") may return 0 pathways at level 4+ since patients are on single drugs. The empty state handler covers this gracefully.
-### Next iteration should:
-- Start Task 10.9 — Patient Pathways filter relocation
-- Key sub-steps:
-  1. Drug/trust/directorate filter buttons (with count badges) should only be visible on Patient Pathways view
-  2. They should be hidden when on Trust Comparison view
-  3. The filter bar currently lives inside `dash_app/components/filter_bar.py` and is placed inside the patient-pathways-view container in `app.py` — check if it's already correctly scoped
-  4. If filter_bar is already ONLY in patient-pathways-view, this may be largely done. Verify the filter modals still work and "Clear All Filters" still works
-  5. Read `dash_app/app.py` to see current layout structure — is filter_bar inside patient-pathways-view or outside?
-  6. Read `docs/PHASE10_DESIGN.md` Section 5 for the design spec on pathway filter placement
-- If filter_bar is already in the right place, this task may just need verification and minor CSS adjustments per the design spec
-### Blocked items:
-- None
-
-## Iteration 42 — 2026-02-06
-### Task: 10.10 — CSS updates + polish
-### Why this task:
-- Task 10.9 (pathway filter relocation) was completed in iteration 41
-- Progress.txt from iteration 41 explicitly recommended Task 10.10 as next
-- This is a cleanup/polish task: remove dead CSS, add CSS variables, improve responsive behavior
-### Status: COMPLETE
-### What was done:
-- **Removed dead CSS classes** from `dash_app/assets/nhs.css`:
-  - `.kpi-row`, `.kpi-card`, `.kpi-card--green`, `.kpi-card__label`, `.kpi-card__value`, `.kpi-card__sub` (28 lines) — KPI row replaced by header fraction KPIs in Task 10.3
-  - `.top-header__breadcrumb` (4 lines) — breadcrumb removed in Task 10.3
-  - `.filter-select` and `.filter-select:focus` (8 lines) — replaced by dcc.Dropdown with `.filter-dropdown` class
-  - `.sidebar__item--disabled` (4 lines) — disabled sidebar items removed when restructured to 2-item nav
-- **Deleted dead file** `dash_app/components/kpi_row.py` — not imported anywhere since Task 10.3 removed the KPI row
-- **Added CSS variables** to `:root`:
-  - `--sub-header-h: 44px`
-  - `--header-total-h: 100px` (56px header + 44px sub-header)
-- **Updated `.main`** to use `var(--header-total-h)` instead of hardcoded `100px`
-- **Updated `.sub-header`** to use `var(--sub-header-h)` instead of hardcoded `44px`
-- **Improved responsive rules**:
-  - `@media (max-width: 1200px)`: tighten header KPI gap, hide KPI labels (numbers-only)
-  - `@media (max-width: 768px)`: hide header KPIs entirely, wrap pathway-filters, stack TC grids
-  - Removed dead `.kpi-row` responsive rules at 1024px and 768px breakpoints
-- **Verified against design spec** (`docs/PHASE10_DESIGN.md`): all Phase 10 CSS matches spec
-- **Note on `01_nhs_classic.html`**: Phase 10 diverges from the original HTML concept. The original file is retained as historical reference but `docs/PHASE10_DESIGN.md` is the current spec.
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK
-- Tier 1 (App starts): `python run_dash.py` — OK, no errors
-- Tier 2 (Layout): CSS reduced from 542 to 493 lines. All remaining classes actively used.
-### Files changed:
-- `dash_app/assets/nhs.css` — Removed 5 dead CSS blocks, added 2 CSS variables, updated responsive rules
-- `dash_app/components/kpi_row.py` — Deleted (dead code)
-- `IMPLEMENTATION_PLAN.md` — Task 10.10 marked [x]
-### Committed: c5b6191 "style: clean up dead CSS, add CSS variables, improve responsive rules (Task 10.10)"
-### Patterns discovered:
-- CSS variable indirection (`--header-total-h`) makes layout math more maintainable than hardcoded pixel values
-- Dead CSS accumulates across iterations. Cleanup pass: check every CSS class against `grep -r "classname" dash_app/ --include="*.py"` to find orphans.
-### Next iteration should:
-- Start Task 10.11 — Final integration + documentation
-- Key sub-steps:
-  1. Verify all views work: Patient Pathways (Icicle + Sankey), Trust Comparison (landing + 6-chart dashboard)
-  2. Verify global filters (date, chart type) affect both views
-  3. Verify Patient Pathways filters (drug, trust, directorate) only affect Patient Pathways
-  4. Verify Trust Comparison directorate selector works for all directorates and indications
-  5. Verify no regressions in Icicle and Sankey charts
-  6. Test with both "directory" and "indication" chart types
-  7. Update CLAUDE.md with new architecture (two views, state management, callback chains)
-  8. `python run_dash.py` starts cleanly
-- This is the FINAL task — if all checks pass, the project is complete
-### Blocked items:
-- None
-
-## Iteration 43 — 2026-02-06
-### Task: 10.11 — Final integration + documentation
-### Why this task:
-- This is the ONLY remaining task — all others are marked [x]
-- Task 10.10 (CSS cleanup + polish) was completed in iteration 42
-- Progress.txt from iteration 42 explicitly recommended Task 10.11 as the FINAL task
-### Status: COMPLETE
-### What was done:
-- **Programmatic verification of Patient Pathways view**:
-  - Reference data loads: 42 drugs, 14 directorates, 32 indications, 7 trusts
-  - Directory mode (all_6mo): 293 nodes, 11,118 patients, 39 drugs, ~£130.6M
-  - Indication mode (all_6mo): 438 nodes, 11,252 patients
-  - Icicle figure renders: 1 trace, type=icicle
-  - Sankey figure renders: 2 drug transitions, 1 trace
-  - Drug filter (ADALIMUMAB): 91 nodes, levels [0,1,2,3,4,5] — hierarchy intact
-  - Trust filter (Cambridge): 15 nodes, levels [0,1,2,3,4] — hierarchy intact
-- **Programmatic verification of Trust Comparison view**:
-  - Trust Market Share (RHEUMATOLOGY): 42 rows, 6 trusts, 17 drugs
-  - Trust Cost Waterfall: 6 rows (one per trust)
-  - Trust Dosing: 40 rows
-  - Trust Heatmap: 6 trusts × 17 drugs
-  - Trust Durations: 40 rows
-  - Cost Effectiveness (RHEUMATOLOGY): 38 pathway rows
-  - Indication mode (asthma): 3 rows, 2 trusts, 2 drugs
-  - All 3 trust-specific figure builders render correctly
-- **Callback/layout verification**:
-  - 20 callbacks registered (correct)
-  - 2 sidebar nav items: Patient Pathways, Trust Comparison
-  - 2 chart tabs: Icicle, Sankey
-  - 4 dcc.Store components: app-state, chart-data, reference-data, active-tab
-  - All 6 date filter IDs return data (all_6mo through 2yr_12mo)
-- **Both chart types verified**: directory and indication modes work for both views
-- **CLAUDE.md updated** with two-view architecture:
-  - Package structure updated (removed kpi_row.py, drawer.py; added modals.py, sub_header.py, trust_comparison.py, navigation.py, trust_comparison callbacks)
-  - State management updated to 4 stores with active_view and selected_comparison_directorate
-  - Callback chain updated with two-view flow diagram
-  - Key components updated (header fraction KPIs, 2-item sidebar, sub-header, filter bar, modals, trust comparison)
-  - Output section updated to describe two-view architecture
-  - Added trust-comparison visualization and query functions
-- **All Phase 10 completion criteria marked [x]** in IMPLEMENTATION_PLAN.md
-- **All tasks in IMPLEMENTATION_PLAN.md are [x]** — no remaining [ ], [~], or [B] items
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 20 callbacks
-- Tier 1 (App starts): `python run_dash.py` — "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 3 (Functional): All data queries verified programmatically for both views, both chart types, drug/trust filters
-### Files changed:
-- `CLAUDE.md` — Updated with two-view architecture
-- `IMPLEMENTATION_PLAN.md` — Task 10.11 and Phase 10 completion criteria marked [x]
-### Committed: 5f890f2 "docs: final integration verification + CLAUDE.md update for two-view architecture (Task 10.11)"
-### Patterns discovered:
-- Programmatic verification (running queries and figure builders via `python -c`) is more reliable than manual browser testing for an amnesiac loop
-- The final integration task is primarily verification + documentation — no code changes needed when previous iterations were thorough
-### Next iteration should:
-- N/A — ALL TASKS COMPLETE. The project is finished.
-### Blocked items:
-- None
-
-## Manual Intervention — 2026-02-07
-### Reason: User feedback on 4 layout/aesthetics issues after reviewing the completed app
-### Changes made:
-- `IMPLEMENTATION_PLAN.md` — Added Phase 11 with 4 new tasks (11.1–11.4)
-- `progress.txt` — Added this intervention entry with context for next iteration
-### Tasks reset: None (all additive changes)
-### Tasks added:
-- 11.1: Move "Clear All Filters" button to left side (next to filter buttons, not right-aligned)
-- 11.2: Trust Comparison charts — fix overspill and increase chart size (currently 320px, text/axes overflow)
-- 11.3: Patient Pathways chart — fill available screen height (currently only uses 500px min-height)
-- 11.4: Filter modals — improve aesthetics for large screens (chips too small at xs, broken text spacing, modals too small)
-### Context for next iteration:
-- Phase 10 is fully complete (iteration 43). Phase 11 is entirely NEW tasks — no regressions to worry about.
-- All 4 tasks are independent CSS/layout changes. They can be done in any order.
-- Key files to modify: `dash_app/components/filter_bar.py`, `dash_app/components/trust_comparison.py`, `dash_app/components/chart_card.py`, `dash_app/components/modals.py`, `dash_app/assets/nhs.css`, possibly `dash_app/app.py` (for flex layout on view containers)
-- User has a large screen (likely 1920px+) — modals and charts should be proportionally sized
-- Task 11.4 instructs using the frontend-developer agent for modal UX review
-- The `.pathway-filters` CSS currently uses `justify-content: space-between` which pushes Clear All to the right — fix by grouping all buttons together
-- Trust Comparison `dcc.Graph` has inline `style={"height": "320px"}` — increase this
-- Patient Pathways `dcc.Graph` has `style={"minHeight": "500px", "flex": "1"}` but the parent containers aren't flex, so `flex: 1` doesn't work. Need to make `#patient-pathways-view` and `.chart-card` proper flex columns.
-- Chip sizes in modals are `"xs"` — increase to `"sm"` or `"md"`. Drug modal is `size="lg"`, trust is `size="sm"` — both too small for large screens.
-### New guardrails added:
-- None
-
-## Iteration 44 — 2026-02-07
-### Task: 11.1 — Move "Clear All Filters" button to left side
-### Why this task:
-- Phase 11 has 4 independent tasks (11.1–11.4), all CSS/layout fixes from user feedback
-- 11.1 is the simplest and most self-contained — a good first task for Phase 11
-- No dependencies on other Phase 11 tasks
-### Status: COMPLETE
-### What was done:
-- **filter_bar.py**: Moved the "Clear All" button from a separate sibling of `.pathway-filters__buttons` into the div, so it now sits alongside Drugs, Trusts, Directorates buttons
-- Added a `.pathway-filters__separator` span (thin vertical line) between Directorates and Clear All for visual distinction
-- **nhs.css**: Removed `justify-content: space-between` from `.pathway-filters` (no longer needed — all items grouped left)
-- Added `.pathway-filters__separator` rule: 1px wide × 24px tall, pale grey background, 4px horizontal margin
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 20 callbacks
-- Tier 1 (App starts): `python run_dash.py` — "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 2 (Layout): Clear All button is now inside the button group, left-aligned with a separator
-### Files changed:
-- `dash_app/components/filter_bar.py` — moved Clear All into pathway-filters__buttons, added separator span
-- `dash_app/assets/nhs.css` — removed space-between, added separator style
-- `IMPLEMENTATION_PLAN.md` — Task 11.1 marked [x]
-### Committed: 99ccddb "style: move Clear All button to left side next to filter buttons (Task 11.1)"
-### Patterns discovered:
-- None new — straightforward CSS/layout change
-### Next iteration should:
-- Pick any of the 3 remaining Phase 11 tasks (11.2, 11.3, 11.4) — all independent
-- 11.2 (Trust Comparison chart sizing) and 11.3 (Patient Pathways height) are pure CSS
-- 11.4 (modal aesthetics) is the most involved — requires frontend-developer agent review
-- Recommend 11.2 or 11.3 next as they're CSS-only changes
-### Blocked items:
-- None
-
-## Iteration 45 — 2026-02-07
-### Task: 11.2 — Trust Comparison charts: fix overspill and increase chart size
-### Why this task:
-- Progress.txt from iteration 44 recommended 11.2 or 11.3 as CSS-only changes
-- 11.2 is a clear readability fix — charts at 320px were too cramped, text/axes overspilling
-- Independent of other Phase 11 tasks
-### Status: COMPLETE
-### What was done:
-- **Updated `dash_app/components/trust_comparison.py`**: Changed `dcc.Graph` height from `320px` to `500px` across all 6 chart cells (56% increase)
-- **Updated `dash_app/assets/nhs.css`**: Added `overflow: hidden` and `min-height: 0` to `.tc-chart-cell` to prevent content leaking outside cells
-- **Height analysis**: Plotly figure functions generate dynamic heights:
-  - Market Share: 560px, Heatmap: 380px, Duration: 760px
-  - At 500px container, Plotly scales figures to fit. Heatmap fits perfectly, Market Share and Duration are slightly compressed but readable
-  - Dashboard scrolls vertically (3 rows × ~540px = ~1620px total) which is acceptable per the task requirements
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK
-- Tier 1 (App starts): `python run_dash.py` — "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 2 (Layout): 6 chart cells now 500px (no 320px references remain), overflow: hidden in CSS
-- Tier 3 (Functional): 20 callbacks registered (no regression), all 6 TC charts render with real data
-### Files changed:
-- `dash_app/components/trust_comparison.py` — Changed dcc.Graph height from 320px to 500px
-- `dash_app/assets/nhs.css` — Added overflow: hidden + min-height: 0 to .tc-chart-cell
-- `IMPLEMENTATION_PLAN.md` — Task 11.2 marked [x]
-### Committed: a4059b5 "style: increase Trust Comparison chart height from 320px to 500px (Task 11.2)"
-### Patterns discovered:
-- Plotly `dcc.Graph` with a fixed CSS height will scale the figure's `layout.height` to fit the container. This means 500px container works for figures that compute 380px–760px layout heights — Plotly compresses/stretches to fit.
-- `overflow: hidden` on the chart cell prevents any edge-case spillover while `min-height: 0` prevents flex child overflow issues.
-### Next iteration should:
-- Pick either 11.3 (Patient Pathways chart fill height) or 11.4 (modal aesthetics)
-- 11.3 is CSS-only: make chart card + patient-pathways-view flex columns so dcc.Graph's `flex: 1` works. Currently `flex: 1` has no effect because parent isn't a flex container.
-- 11.4 is more involved: increase chip sizes, increase modal widths, use frontend-developer agent for UX review
-- Recommend 11.3 next as it's a smaller CSS change
-
-## Iteration 46 — 2026-02-07
-### Task: 11.3 — Patient Pathways chart fill available screen height
-### Why this task:
-- Recommended by iteration 45 as the next logical step
-- CSS-only change (smaller scope than 11.4)
-- Independent of 11.4
-- The issue: `flex: 1` on the dcc.Graph had no effect because parent containers weren't flex columns
-### Status: COMPLETE
-### What was done:
-- **nhs.css**: Changed `.main` from `min-height` to `height: calc(100vh - var(--header-total-h))` + `overflow-y: auto`
-  - `height` (not `min-height`) constrains the container so `flex: 1` children fill exactly the viewport
-  - `overflow-y: auto` allows Trust Comparison view to scroll when content exceeds viewport
-- **nhs.css**: Added flex chain CSS for `#view-container` and `#patient-pathways-view` — both get `flex: 1; display: flex; flex-direction: column; min-height: 0`
-- **nhs.css**: Added `.chart-card { min-height: 0 }` to allow proper flex shrinking
-- **nhs.css**: Added `#chart-container { flex: 1; display: flex; flex-direction: column; min-height: 0 }` for the chart wrapper div
-- **nhs.css**: Added `#pathway-chart { flex: 1; min-height: 0 }` for the dcc.Graph element itself
-- **nhs.css**: Added `.chart-card > .dash-loading-callback` and nested `> div` selectors to propagate flex through the dcc.Loading wrapper
-- **chart_card.py**: Changed `dcc.Graph` style from `{"minHeight": "500px", "flex": "1"}` to `{"flex": "1", "minHeight": "0"}` + added `responsive=True`
-  - `responsive=True` makes Plotly auto-resize to fill its container
-  - `minHeight: "0"` is the standard CSS flex idiom for allowing flex items to shrink below their content size
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 20 callbacks
-- Tier 1 (App starts): `uv run python run_dash.py` — "Dash is running on http://127.0.0.1:8050/" — no errors
-- Tier 2 (Layout): Full flex chain from `.main` → `#view-container` → `#patient-pathways-view` → `.chart-card` → loading wrapper → `#chart-container` → `#pathway-chart`
-- Tier 3 (Functional): Icicle figure has `autosize=True` with no hardcoded height — will fill container. Sankey has dynamic height which acts as minimum; responsive=True allows Plotly to stretch.
-### Files changed:
-- `dash_app/assets/nhs.css` — Added flex chain CSS, changed .main to fixed height + overflow
-- `dash_app/components/chart_card.py` — dcc.Graph responsive=True, minHeight 0
-- `IMPLEMENTATION_PLAN.md` — Task 11.3 marked [x]
-### Committed: 10d47d6 "style: make Patient Pathways chart fill available viewport height (Task 11.3)"
-### Patterns discovered:
-- The full flex chain for a dcc.Graph to fill remaining viewport height requires: every ancestor in the flex chain must have `display: flex; flex-direction: column; flex: 1; min-height: 0`. Missing any one element breaks the chain.
-- `dcc.Loading` wraps children in a `.dash-loading-callback > div` structure. These generated wrappers must also participate in the flex chain (via CSS selectors targeting `.chart-card > .dash-loading-callback` and its nested div).
-- Using `height` instead of `min-height` on the main container is essential — `min-height` doesn't constrain the container, so `flex: 1` children grow beyond the viewport instead of filling it.
-- `responsive=True` on dcc.Graph makes Plotly fill its container dimensions. Combined with `autosize=True` in the figure layout (already set in icicle figure), the chart scales to any container size.
-- `overflow-y: auto` on `.main` handles the Trust Comparison case where 6 charts (500px each) exceed the viewport — content scrolls naturally.
-### Next iteration should:
-- Work on Task 11.4 — Filter modals aesthetics for large screens
-- This is the last remaining Phase 11 task
-- Key sub-steps:
-  1. Spawn frontend-developer agent to review modal layout for 42 drugs, 7 trusts, 19 directorates × 163 indications
-  2. Increase chip sizes from "xs" to "sm" or "md"
-  3. Increase drug modal size from "lg" to "xl" or fixed width (900px+)
-  4. Increase trust modal size from "sm" to "md"
-  5. Add responsive modal sizing for large screens
-  6. Review accordion spacing in directorate modal
-  7. Update CSS for modal chips and layout
-- Files to modify: `dash_app/components/modals.py`, `dash_app/assets/nhs.css`
-
-## Iteration 47 — 2026-02-07
-### Task: 11.4 — Filter modals — improve aesthetics for large screens
-### Why this task:
-- Last remaining task in the entire implementation plan (Phase 11.4)
-- Recommended by iteration 46 as the next logical step
-- User-facing polish — modals had tiny xs-sized chips and undersized modal widths
-### Status: COMPLETE
-### What was done:
-- **Spawned frontend-developer agent** for UX review — agent analyzed data shapes (42 drugs, 7 trusts, 19 directorates × 163 indications) and recommended specific sizing, layout patterns, and CSS additions
-- **Drug modal**: size "lg" → "70%", chips "xs" → "sm", added SimpleGrid(cols=4) layout
-- **Trust modal**: size "sm" → "lg", chips "xs" → "md", added Stack(gap="xs") vertical layout
-- **Directorate modal**: size "xl" → "70%", drug badges "sm" → "md", text "sm" → "md", count badge "xs" → "sm"
-- **CSS**: padding-right on scroll container, white-space: nowrap on chip labels, .mantine-Modal-title width: 100%
-### Validation results:
-- Tier 1 (Code): `from dash_app.app import app` — OK, 20 callbacks
-- Tier 1 (App starts): `uv run python run_dash.py` — OK, no errors
-- Tier 2 (Layout): Percentage-based widths, readable chip sizes, grid/stack layouts
-- Tier 3 (Functional): 20 callbacks (no regression), ChipGroup state works with SimpleGrid/Stack wrappers
-### Files changed:
-- `dash_app/components/modals.py` — All three modals updated
-- `dash_app/assets/nhs.css` — Modal CSS additions
-- `IMPLEMENTATION_PLAN.md` — Task 11.4 [x], Phase 11 criteria all [x]
-### Committed: caf7ada "style: improve filter modal aesthetics for large screens (Task 11.4)"
-### Patterns discovered:
-- SimpleGrid/Stack inside ChipGroup works in DMC 0.14.x — ChipGroup uses React context, not direct children
-- .mantine-Modal-title { width: 100% } needed for Group justify="space-between" in modal titles
-- Percentage modal sizes ("70%") scale well on large screens
-
-### ALL TASKS COMPLETE
-All tasks in IMPLEMENTATION_PLAN.md are marked [x]. All phase completion criteria satisfied.
-Phase 0 (Scaffolding) ✓ | Phase 1 (Data access) ✓ | Phase 2 (Layout) ✓ | Phase 3 (Callbacks) ✓
-Phase 4 (Modals) ✓ | Phase 9 (Analytics charts) ✓ | Phase 10 (Two-view) ✓ | Phase 11 (Polish) ✓
diff --git a/ralph.ps1 b/ralph.ps1
index 6f5a1b2..bcede68 100644
--- a/ralph.ps1
+++ b/ralph.ps1
@@ -1,9 +1,9 @@
 <#
 .SYNOPSIS
-    Ralph Wiggum Loop - Dash Migration variant.
+    Ralph Wiggum Loop - Visualization Improvements variant.
 
 .DESCRIPTION
-    Outer loop for iterative Dash frontend development (Reflex -> Dash migration).
+    Outer loop for iterative chart improvement (bug fixes, polish, new analytics).
     Each iteration spawns a fresh `claude --print` invocation.
     Memory persists via filesystem only: git commits, progress.txt, IMPLEMENTATION_PLAN.md, guardrails.md.
 
@@ -141,7 +141,7 @@ if (Test-Path $progressFile) {
 }
 
 Write-Host ""
-Write-Host "===== Ralph Wiggum Loop (Dash Migration) =====" -ForegroundColor Cyan
+Write-Host "===== Ralph Wiggum Loop (Visualization Improvements) =====" -ForegroundColor Cyan
 Write-Host "Model: $Model | Runs until COMPLETE" -ForegroundColor Cyan
 Write-Host "Circuit breakers: no-progress=$MaxNoProgress, same-error=$MaxSameError" -ForegroundColor Cyan
 if ($BranchName) { Write-Host "Branch: $BranchName" -ForegroundColor Cyan }
@@ -328,7 +328,7 @@ while ($true) {
     if ($outputString -match "<promise>COMPLETE</promise>") {
         Write-Host ""
         Write-Host "===== COMPLETE =====" -ForegroundColor Green
-        Write-Host "Dash migration finished after $i iteration(s) this run ($totalIteration total)." -ForegroundColor Green
+        Write-Host "Visualization improvements finished after $i iteration(s) this run ($totalIteration total)." -ForegroundColor Green
         exit 0
     }