Update src/temporal_data.py

Refactor temporal_data: CLI-driven runs, edge collapsing, and aligned node features

Replace the hardcoded CONFIG panel with an argparse CLI and rework the
structural-edge and node-feature handling.

Interface & config
- Drop the top-of-file CONFIG dict in favor of argparse:
--start_date (default 2014-01-01), --include_structural_edges /
--no_structural_edges, --skip_node_features, --trades_csv
(default data/processed/ml_dataset_continuous.csv), --snapshot_date.
- Fix the boolean-flag bug: the old "--include_structural_edges False"
evaluated truthy (any non-empty string); now a proper store_true/
store_false pair.
- Restore trade edges as the primary supervised edge type (event_type 0);
structural edges (lobbying/campaign/geo) are on by default and gated by
the flag pair rather than a per-file CONFIG toggle.

Input paths
- Read trades from data/processed/ml_dataset_continuous.csv and crosswalks/
company_sic from data/raw/ (was data/cropped/ across the board).

Structural-edge collapsing (new)
- Add collapse_structural: dedupe repeated (src, dst) structural edges into
one weighted edge per type, summing amount columns, adding edge_count,
keeping the earliest event as `time` (relationship start) and the most
recent as `last_seen` (recency).
- Thread last_seen through base_cols, the Phase-4 tensors, and the saved
TemporalData object so days-since/recency features can be computed at
load time. Trades are intentionally left un-collapsed.

Node features
- Replace the inline process_node_features (committee/SEC/SIC/CBP -> three
parquets) with delegation to src.data_prep.node_features.build_node_features,
which aligns the node tensors to the Phase-4 src_id_map/dst_id_map and saves
node_features_static.pt (+ meta json).
- Run Phase 3 AFTER Phase 4 so it can align to the node-id maps that Phase 4
writes.
- Adds dependencies on node_features.py and feature_lookups.py.

Cleanup
- Remove the duplicated SEC_FACTS / map_sic_to_division / process_node_features
blocks, the double lobbying read, and the hardcoded CBP_RELEASE_DATES /
STATE_ABBREV tables. Drops the "_CB_esurvey.csv" path (the survey-year files
are handled in build_geographical_edges.py).

src/temporal_data.py

@@ -16,37 +16,6 @@ try:
 except ImportError:
     print("[WARNING] torch_geometric not found. Phase 4 will fail without PyG installed.")
 
-# --- CONFIGURATION PANEL ---
-CONFIG = {
-    # 1. Base Directories
-    "DATA_DIR": "data",
-    "PROCESSED_DIR": "data/processed",
-    "EDGE_OUT_DIR": "data/processed/master_edges_parquet",
-    "PYG_OUT_DIR": "data/processed/pyg_graph",
-
-    # 2. Input File Paths (Relative to DATA_DIR)
-    "FILES": {
-        "trades": "cropped/ml_dataset_continuous.csv",
-        "lobbying": "processed/events_lobbying.csv",
-        "camp_fin": "processed/events_campaign_finance.csv",
-        "geo": "processed/events_geographical_industry.csv",
-        "company_sic": "cropped/company_sic_data.csv",
-        "committee": "cropped/committee_assignments.csv",
-        "sec_financials": "cropped/sec_quarterly_financials.csv"
-    },
-
-    # 3. Graph Assembly Toggles
-    "INCLUDE_EDGES": {
-        "trades": False,      
-        "lobbying": True,
-        "camp_fin": True,
-        "geo": True
-    },
-    
-    "START_DATE": "2021-01-01"
-}
-# ---------------------------
-
 # --- Helper for Strict Schema Validation ---
 def validate_columns(df: pd.DataFrame, required_columns: list, dataset_name: str):
     """Raises a clear ValueError if expected columns are missing."""
@@ -67,7 +36,7 @@ def load_and_standardize_events(data_dir="data"):
     # ---------------------------------------------------------
     # 1.1 TARGET EDGES (Trades)
     # ---------------------------------------------------------
-    path_trades = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["trades"])
+    path_trades = os.path.join(data_dir, "processed", "ml_dataset_continuous.csv")
     print(f"Loading Trades from: {path_trades}")
     df_trades = pd.read_csv(path_trades)
     
@@ -102,92 +71,76 @@ def load_and_standardize_events(data_dir="data"):
     # ---------------------------------------------------------
     # 1.2 LOBBYING EVENTS
     # ---------------------------------------------------------
-    if CONFIG["INCLUDE_EDGES"].get("lobbying", True):
-        path_lobbying = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["lobbying"])
-        df_lobbying = pd.read_csv(path_lobbying)
-
-        path_lobbying = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["lobbying"])
-        print(f"Loading Lobbying from: {path_lobbying}")
-        df_lobbying = pd.read_csv(path_lobbying)
-        
-        # Depending on how it was saved, the time column might be 'estimated_filing_date' or 'date'
-        time_col_lobby = 'estimated_filing_date' if 'estimated_filing_date' in df_lobbying.columns else 'date'
-        
-        validate_columns(df_lobbying, ['bioguide_id', 'ticker', time_col_lobby, 'event_type'], "Lobbying")
+    path_lobbying = os.path.join(data_dir, "processed", "events_lobbying.csv")
+    print(f"Loading Lobbying from: {path_lobbying}")
+    df_lobbying = pd.read_csv(path_lobbying)
+    
+    # Depending on how it was saved, the time column might be 'estimated_filing_date' or 'date'
+    time_col_lobby = 'estimated_filing_date' if 'estimated_filing_date' in df_lobbying.columns else 'date'
+    
+    validate_columns(df_lobbying, ['bioguide_id', 'ticker', time_col_lobby, 'event_type'], "Lobbying")
 
-        df_lobbying = df_lobbying.rename(columns={
-            'bioguide_id': 'src',
-            'ticker': 'dst',
-            time_col_lobby: 'time'
-        })
-        
-        # Extract structural flags
-        df_lobbying['is_sponsorship'] = (df_lobbying['event_type'] == 'LOBBY_STRONG').astype(float)
-        df_lobbying['voted_yea'] = (df_lobbying['event_type'] == 'LOBBY_WEAK').astype(float)
-        df_lobbying['event_type'] = 1 # Override with integer event code
-        
-        print(f" -> Lobbying loaded successfully. Shape: {df_lobbying.shape}")
+    df_lobbying = df_lobbying.rename(columns={
+        'bioguide_id': 'src',
+        'ticker': 'dst',
+        time_col_lobby: 'time'
+    })
     
-    else:
-        print(" -> [CONFIG] Skipping Lobbying edges...")
-        df_lobbying = pd.DataFrame()
+    # Extract structural flags
+    df_lobbying['is_sponsorship'] = (df_lobbying['event_type'] == 'LOBBY_STRONG').astype(float)
+    df_lobbying['voted_yea'] = (df_lobbying['event_type'] == 'LOBBY_WEAK').astype(float)
+    df_lobbying['event_type'] = 1 # Override with integer event code
+    
+    print(f" -> Lobbying loaded successfully. Shape: {df_lobbying.shape}")
 
     # ---------------------------------------------------------
     # 1.3 CAMPAIGN FINANCE EVENTS
     # ---------------------------------------------------------
-    # ---------------------------------------------------------
-    if CONFIG["INCLUDE_EDGES"].get("camp_fin", True):
-        path_camp_fin = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["camp_fin"])
-        df_camp_fin = pd.read_csv(path_camp_fin)
-    
-        time_col_cf = 'estimated_filing_date' if 'estimated_filing_date' in df_camp_fin.columns else 'date'
-        validate_columns(df_camp_fin, ['bioguide_id', 'industry_code', time_col_cf, 'weight'], "Campaign Finance")
-
-        df_camp_fin = df_camp_fin.rename(columns={
-            'bioguide_id': 'src',
-            'industry_code': 'dst_temp', # Needs broadcasting
-            time_col_cf: 'time',
-            'weight': 'Fin_Amt' # Assuming donation amount
-        })
-        df_camp_fin['event_type'] = 2
-
-        print(f" -> Campaign Finance loaded successfully. Shape: {df_camp_fin.shape}")
-    
-    else:
-        print(" -> [CONFIG] Skipping Campaign Finance edges...")
-        df_camp_fin = pd.DataFrame()
+    path_camp_fin = os.path.join(data_dir, "processed", "events_campaign_finance.csv")
+    print(f"Loading Campaign Finance from: {path_camp_fin}")
+    df_camp_fin = pd.read_csv(path_camp_fin)
+    
+    time_col_cf = 'estimated_filing_date' if 'estimated_filing_date' in df_camp_fin.columns else 'date'
+    validate_columns(df_camp_fin, ['bioguide_id', 'industry_code', time_col_cf, 'weight'], "Campaign Finance")
+
+    df_camp_fin = df_camp_fin.rename(columns={
+        'bioguide_id': 'src',
+        'industry_code': 'dst_temp', # Needs broadcasting
+        time_col_cf: 'time',
+        'weight': 'Fin_Amt' # Assuming donation amount
+    })
+    df_camp_fin['event_type'] = 2
+
+    print(f" -> Campaign Finance loaded successfully. Shape: {df_camp_fin.shape}")
 
-    # 1.4 GEO-INDUSTRIAL EDGES
     # ---------------------------------------------------------
-    if CONFIG["INCLUDE_EDGES"].get("geo", True):
-        path_geo = os.path.join(CONFIG["DATA_DIR"], CONFIG["FILES"]["geo"])
-        df_geo = pd.read_csv(path_geo)
+    # 1.4 GEO-INDUSTRIAL EVENTS
+    # ---------------------------------------------------------
+    path_geo = os.path.join(data_dir, "processed", "events_geographical_industry.csv")
+    print(f"Loading Geo-Industrial from: {path_geo}")
+    df_geo = pd.read_csv(path_geo)
     
-        validate_columns(df_geo, ['bioguide_id', 'sic_code', 'release_date', 'establishments', 'employment', 'annual_payroll'], "Geo-Industrial")
-
-        df_geo = df_geo.rename(columns={
-            'bioguide_id': 'src',
-            'sic_code': 'dst_temp', # Needs broadcasting
-            'release_date': 'time'
-        })
-        
-        # Normalizing economic weight (log-scaling as per Appendix B.2.3)
-        df_geo['Geo_Weight'] = np.log1p(df_geo['employment'].fillna(0))
-        df_geo['event_type'] = 3
+    validate_columns(df_geo, ['bioguide_id', 'sic_code', 'release_date', 'establishments', 'employment', 'annual_payroll'], "Geo-Industrial")
 
-        print(f" -> Geo-Industrial loaded successfully. Shape: {df_geo.shape}")
+    df_geo = df_geo.rename(columns={
+        'bioguide_id': 'src',
+        'sic_code': 'dst_temp', # Needs broadcasting
+        'release_date': 'time'
+    })
+    
+    # Normalizing raw economic weight (log-scaling as per Appendix B.2.3)
+    df_geo['Geo_Weight'] = np.log1p(df_geo['employment'].fillna(0))
+    df_geo['event_type'] = 3
 
-    else:
-        print(" -> [CONFIG] Skipping Geo-Industrial edges...")
-        df_geo = pd.DataFrame()
+    print(f" -> Geo-Industrial loaded successfully. Shape: {df_geo.shape}")
 
     # ---------------------------------------------------------
     # 1.5 LOAD DICTIONARIES FOR BROADCASTING (Phase 2 Prep)
     # ---------------------------------------------------------
     print("Loading Crosswalk Dictionaries...")
-    path_cw_2012 = os.path.join(data_dir, "cropped", "industry_codes_NAICS", "2012-NAICS-to-SIC-crosswalk.csv")
-    path_cw_2017 = os.path.join(data_dir, "cropped", "industry_codes_NAICS", "2017-NAICS-to-SIC-crosswalk.csv")
-    path_cw_cat = os.path.join(data_dir, "cropped", "industry_codes_NAICS", "2013-CAT_to_SIC_to_NAICS_mappings.csv")
+    path_cw_2012 = os.path.join(data_dir, "raw", "industry_codes_NAICS", "2012-NAICS-to-SIC-crosswalk.csv")
+    path_cw_2017 = os.path.join(data_dir, "raw", "industry_codes_NAICS", "2017-NAICS-to-SIC-crosswalk.csv")
+    path_cw_cat = os.path.join(data_dir, "raw", "industry_codes_NAICS", "2013-CAT_to_SIC_to_NAICS_mappings.csv")
     
     cw_2012 = pd.read_csv(path_cw_2012)
     cw_2017 = pd.read_csv(path_cw_2017)
@@ -208,7 +161,7 @@ def broadcast_and_pad_edges(df_trades, df_lobbying, df_camp_fin, df_geo, cw_cat,
     print("==================================================")
 
     # 1. Load and Clean Company SIC Master List
-    path_company_sic = os.path.join(data_dir, "cropped", "company_sic_data.csv")
+    path_company_sic = os.path.join(data_dir, "raw", "company_sic_data.csv")
     df_comp_sic = pd.read_csv(path_company_sic)
     df_comp_sic = df_comp_sic.drop_duplicates(subset=['ticker', 'sic'])
     df_comp_sic['sic'] = df_comp_sic['sic'].astype(str).str.replace(r'\.0$', '', regex=True).str.strip().str.zfill(4)
@@ -233,7 +186,87 @@ def broadcast_and_pad_edges(df_trades, df_lobbying, df_camp_fin, df_geo, cw_cat,
                                    left_on='SICcode', right_on='sic', how='inner')
     df_camp_fin = df_camp_fin.rename(columns={'ticker': 'dst'}).drop(columns=['dst_temp', 'OpenSecretsCatcode', 'SICcode', 'sic'])
 
-    print(f" -> Geo edges: {len(df_geo)} | Fin edges: {len(df_camp_fin)}")
+    print(f" -> Geo edges (pre-dedup): {len(df_geo)} | Fin edges (pre-dedup): {len(df_camp_fin)}")
+
+    # ---------------------------------------------------------
+    # 2.1b COLLAPSE REPEATED STRUCTURAL EDGES INTO ONE WEIGHTED EDGE
+    # ---------------------------------------------------------
+    # Broadcasting (and the raw event streams themselves) emit many duplicate
+    # (politician, company) pairs of the same type -- e.g. the same company
+    # lobbying on several of a legislator's bills, or one industry signal fanned
+    # across every ticker in that industry. Rather than carry each as its own
+    # edge (which is what blows the edge count into the tens of millions), we keep
+    # ONE edge per (src, dst, event_type) and accumulate weight onto it:
+    #
+    #   weight        = number of collapsed events (interaction count / intensity)
+    #   <amount cols> = summed across the collapsed events
+    #   time          = EARLIEST event (when the relationship began; this is also
+    #                   what the chronological sort + shard `t` tensor key on)
+    #   last_seen     = MOST RECENT event (carried separately so recency features
+    #                   like days-since can be computed independently of edge age)
+    #
+    # Trades are intentionally NOT touched here -- each trade is a distinct
+    # supervised event with its own label and market features.
+    def collapse_structural(df, name, amount_cols):
+        """Dedup to one edge per (src, dst), summing amount_cols, keeping BOTH the
+        earliest event (as 'time') and the most recent (as 'last_seen').
+        Adds an 'edge_count' column recording how many events were merged."""
+        if df.empty:
+            df['edge_count'] = pd.Series(dtype='float32')
+            df['last_seen'] = pd.Series(dtype='object')
+            return df
+
+        before = len(df)
+        df = df.dropna(subset=['src', 'dst', 'time']).copy()
+
+        # Earliest -> time, latest -> last_seen. 'time' is min so the downstream
+        # chronological sort anchors the edge to the start of the relationship;
+        # 'last_seen' preserves recency for days-since at load time.
+        df['__last_seen'] = df['time']
+        agg = {c: 'sum' for c in amount_cols if c in df.columns}
+        agg['time'] = 'min'              # earliest event in the pair
+        agg['__last_seen'] = 'max'       # most recent event in the pair
+        agg['__count'] = 'sum'           # how many events collapsed into this edge
+        df['__count'] = 1.0
+
+        # Carry through any remaining base/identity columns (event_type, y, ...) that
+        # we are NOT explicitly aggregating. These are constant within a stream
+        # (event_type is set per-stream in Phase 1; y is -1 on all structural edges),
+        # so 'first' is exact. Without this, groupby.agg silently drops them and the
+        # later df_chunk[base_cols + all_msg_cols] selection raises KeyError.
+        carry_cols = [c for c in ('event_type', 'y')
+                      if c in df.columns and c not in agg]
+        for c in carry_cols:
+            agg[c] = 'first'
+
+        merged = df.groupby(['src', 'dst'], sort=False, as_index=False).agg(agg)
+        merged = merged.rename(columns={'__count': 'edge_count', '__last_seen': 'last_seen'})
+
+        after = len(merged)
+        print(f" -> {name}: collapsed {before:,} broadcast edges -> {after:,} "
+              f"unique (src, dst) edges ({before / max(after, 1):.1f}x reduction).")
+        return merged
+
+    # Each stream's "amount" columns are the numeric msg fields it actually carries.
+    # Anything not listed is left to the schema-alignment step to zero-fill.
+    df_lobbying = collapse_structural(
+        df_lobbying, "Lobbying", amount_cols=['is_sponsorship', 'voted_yea'])
+    df_camp_fin = collapse_structural(
+        df_camp_fin, "Campaign Finance", amount_cols=['Fin_Amt'])
+    df_geo = collapse_structural(
+        df_geo, "Geo-Industrial", amount_cols=['Geo_Weight'])
+
+    # Surface the collapsed-event tally to the model as a weight feature. We fold it
+    # into Fin_Amt for campaign (already an amount) and leave it as the standalone
+    # 'edge_count' for the others; node_features.aggregate_pair_edges recomputes its
+    # own per-pair counts at load time, so this is primarily for inspection/QA, but
+    # it also means an un-aggregated downstream consumer still sees the intensity.
+    for _df in (df_lobbying, df_camp_fin, df_geo):
+        if 'edge_count' not in _df.columns:
+            _df['edge_count'] = 1.0
+
+    print(f" -> Geo edges (post-dedup): {len(df_geo)} | Fin edges (post-dedup): {len(df_camp_fin)} "
+          f"| Lobbying edges (post-dedup): {len(df_lobbying)}")
 
     # ---------------------------------------------------------
     # 2.2 UNIFIED EDGE ATTRIBUTE TENSOR (msg)
@@ -300,11 +333,16 @@ def broadcast_and_pad_edges(df_trades, df_lobbying, df_camp_fin, df_geo, cw_cat,
     import pyarrow as pa
     import pyarrow.parquet as pq
 
-    output_dir = CONFIG["EDGE_OUT_DIR"]
+    output_dir = os.path.join(data_dir, "processed", "master_edges_parquet")
     os.makedirs(output_dir, exist_ok=True)
     print(f"Writing chunks directly to Parquet at: {output_dir}")
 
-    base_cols = ['src', 'dst', 'time', 'event_type', 'y']
+    base_cols = ['src', 'dst', 'time', 'last_seen', 'event_type', 'y']
+
+    # Trades are not deduped, so they have no 'last_seen'. For an un-collapsed edge
+    # the relationship's first and last touch are the same instant, so last_seen == time.
+    if 'last_seen' not in df_trades.columns:
+        df_trades['last_seen'] = df_trades['time']
 
     # Load unpadded, "skinny" dataframes into the queue
     datasets = [
@@ -335,6 +373,7 @@ def broadcast_and_pad_edges(df_trades, df_lobbying, df_camp_fin, df_geo, cw_cat,
             # --- MOVED INSIDE THE CHUNK LOOP ---
             # Convert to datetime and sort LOCALLY in this 5M row chunk
             df_chunk['time'] = pd.to_datetime(df_chunk['time'])
+            df_chunk['last_seen'] = pd.to_datetime(df_chunk['last_seen'])
             df_chunk = df_chunk.sort_values(by='time').reset_index(drop=True)
             # -----------------------------------
             
@@ -378,282 +417,10 @@ def broadcast_and_pad_edges(df_trades, df_lobbying, df_camp_fin, df_geo, cw_cat,
 # PHASE 3: NODE FEATURE EXTRACTION
 # ==========================================
 
-SEC_FACTS = [
-    "NetIncomeLoss", "StockholdersEquity", "EarningsPerShareBasic", 
-    "EarningsPerShareDiluted", "IncomeTaxExpenseBenefit", 
-    "CashAndCashEquivalentsAtCarryingValue", "WeightedAverageNumberOfSharesOutstandingBasic", 
-    "OperatingIncomeLoss", "WeightedAverageNumberOfDilutedSharesOutstanding", 
-    "Assets", "LiabilitiesAndStockholdersEquity", "InterestExpense", 
-    "RetainedEarningsAccumulatedDeficit", "NetCashProvidedByUsedInOperatingActivities", 
-    "NetCashProvidedByUsedInFinancingActivities", "NetCashProvidedByUsedInInvestingActivities", 
-    "Liabilities", "CommonStockValue", "AccumulatedOtherComprehensiveIncomeLossNetOfTax", 
-    "PropertyPlantAndEquipmentNet", "Revenues", "AssetsCurrent", 
-    "LiabilitiesCurrent", "OperatingExpenses", "GrossProfit", 
-    "PaymentsToAcquirePropertyPlantAndEquipment", "Goodwill", 
-    "AmortizationOfIntangibleAssets", "SellingGeneralAndAdministrativeExpense", 
-    "AccountsPayableCurrent", "CommonStockDividendsPerShareDeclared", 
-    "NonoperatingIncomeExpense", "OtherAssetsNoncurrent", 
-    "AdditionalPaidInCapital", "AccountsReceivableNetCurrent", 
-    "ResearchAndDevelopmentExpense"
-]
-
-def map_sic_to_division(sic_code):
-    """Maps a 4-digit SIC code to its 10 parent divisions (0-9)."""
-    try:
-        sic = int(sic_code)
-        if sic < 1000: return 0   # Agriculture
-        elif sic < 1500: return 1  # Mining
-        elif sic < 1800: return 2  # Construction
-        elif sic < 4000: return 3  # Manufacturing
-        elif sic < 5000: return 4  # Transportation/Utilities
-        elif sic < 5200: return 5  # Wholesale Trade
-        elif sic < 6000: return 6  # Retail Trade
-        elif sic < 6800: return 7  # Finance, Insurance, RE
-        elif sic < 9000: return 8  # Services
-        else: return 9             # Public Admin
-    except:
-        return 9 
-
-def process_node_features(data_dir="data/", processed_dir="data/processed/"):
-    """
-    Phase 3: Generate and save temporally aligned node features for politicians and companies.
-    """
-    pol_parquet_path = os.path.join(processed_dir, "politician_features.parquet")
-    comp_parquet_path = os.path.join(processed_dir, "company_features.parquet")
+# Phase 3 lives in src/data_prep/node_features.py (build_node_features), which
+# replicates the deprecated graph_builder composition and aligns the node tensors
+# to the Phase-4 node-id maps. It is invoked from __main__ after Phase 4 below.
 
-    if os.path.exists(pol_parquet_path) and os.path.exists(comp_parquet_path):
-        print(" -> Found existing node feature parquets. Skipping Phase 3 generation...")
-        return pol_parquet_path, comp_parquet_path
-
-    print("==================================================")
-    print("PHASE 3: NODE FEATURE EXTRACTION")
-    print("==================================================")
-
-    # --- Politician Snapshots (x_src) ---
-    print(" -> Processing Politician Features...")
-    df_com = pd.read_csv(os.path.join(data_dir, "cropped/committee_assignments.csv"))
-    df_com['Committees'] = df_com['Committees'].fillna('').astype(str).str.split(r';\s*')
-    
-    mlb = MultiLabelBinarizer()
-    encoded_com = mlb.fit_transform(df_com['Committees'])
-    df_com_encoded = pd.DataFrame(encoded_com, columns=[f"Com_{c}" for c in mlb.classes_])
-    df_pol = pd.concat([df_com.drop('Committees', axis=1), df_com_encoded], axis=1)
-
-    # --- Company Snapshots (x_dst) ---
-    print(" -> Processing Company Features (SEC & SIC)...")
-    df_sec = pd.read_csv(os.path.join(data_dir, "cropped/sec_quarterly_financials.csv"))
-    df_sec['FiledDate'] = pd.to_datetime(df_sec['FiledDate'])
-    
-    df_sec = df_sec[df_sec['Fact'].isin(SEC_FACTS)]
-    df_sec = df_sec.drop_duplicates(subset=['Ticker', 'FiledDate', 'Fact'], keep='last')
-    
-    df_comp = df_sec.pivot(index=['Ticker', 'FiledDate'], columns='Fact', values='Value').reset_index()
-    for fact in SEC_FACTS:
-        if fact not in df_comp.columns:
-            df_comp[fact] = np.nan
-            
-    df_comp = df_comp[['Ticker', 'FiledDate'] + SEC_FACTS].sort_values(['Ticker', 'FiledDate'])
-    df_comp = df_comp.groupby('Ticker').ffill().fillna(0.0)
-    
-    for col in SEC_FACTS:
-        df_comp[col] = np.sign(df_comp[col]) * np.log1p(np.abs(df_comp[col]))
-
-    df_sic = pd.read_csv(os.path.join(data_dir, "cropped/company_sic_data.csv"))
-    df_sic['sic_division'] = df_sic['sic'].apply(map_sic_to_division)
-    sic_dummies = pd.get_dummies(df_sic['sic_division'], prefix='SIC_Div')
-    
-    for i in range(10):
-        if f'SIC_Div_{i}' not in sic_dummies.columns:
-            sic_dummies[f'SIC_Div_{i}'] = 0
-            
-    df_sic = pd.concat([df_sic[['ticker']], sic_dummies[[f'SIC_Div_{i}' for i in range(10)]].astype(np.float32)], axis=1)
-    df_sic = df_sic.rename(columns={'ticker': 'Ticker'})
-    
-    df_comp = df_comp.merge(df_sic, on='Ticker', how='left')
-    sic_cols = [f'SIC_Div_{i}' for i in range(10)]
-    df_comp[sic_cols] = df_comp[sic_cols].fillna(0.0)
-
-    print(" -> Saving Phase 3 Parquets...")
-    df_pol.to_parquet(pol_parquet_path)
-    df_comp.to_parquet(comp_parquet_path)
-    
-    return pol_parquet_path, comp_parquet_path
-
-# ==========================================
-# PHASE 3: NODE FEATURE EXTRACTION
-# ==========================================
-
-SEC_FACTS = [
-    "NetIncomeLoss", "StockholdersEquity", "EarningsPerShareBasic", 
-    "EarningsPerShareDiluted", "IncomeTaxExpenseBenefit", 
-    "CashAndCashEquivalentsAtCarryingValue", "WeightedAverageNumberOfSharesOutstandingBasic", 
-    "OperatingIncomeLoss", "WeightedAverageNumberOfDilutedSharesOutstanding", 
-    "Assets", "LiabilitiesAndStockholdersEquity", "InterestExpense", 
-    "RetainedEarningsAccumulatedDeficit", "NetCashProvidedByUsedInOperatingActivities", 
-    "NetCashProvidedByUsedInFinancingActivities", "NetCashProvidedByUsedInInvestingActivities", 
-    "Liabilities", "CommonStockValue", "AccumulatedOtherComprehensiveIncomeLossNetOfTax", 
-    "PropertyPlantAndEquipmentNet", "Revenues", "AssetsCurrent", 
-    "LiabilitiesCurrent", "OperatingExpenses", "GrossProfit", 
-    "PaymentsToAcquirePropertyPlantAndEquipment", "Goodwill", 
-    "AmortizationOfIntangibleAssets", "SellingGeneralAndAdministrativeExpense", 
-    "AccountsPayableCurrent", "CommonStockDividendsPerShareDeclared", 
-    "NonoperatingIncomeExpense", "OtherAssetsNoncurrent", 
-    "AdditionalPaidInCapital", "AccountsReceivableNetCurrent", 
-    "ResearchAndDevelopmentExpense"
-]
-
-def map_sic_to_division(sic_code):
-    """Maps a 4-digit SIC code to its 10 parent divisions (0-9)."""
-    try:
-        sic = int(sic_code)
-        if sic < 1000: return 0   # Agriculture
-        elif sic < 1500: return 1  # Mining
-        elif sic < 1800: return 2  # Construction
-        elif sic < 4000: return 3  # Manufacturing
-        elif sic < 5000: return 4  # Transportation/Utilities
-        elif sic < 5200: return 5  # Wholesale Trade
-        elif sic < 6000: return 6  # Retail Trade
-        elif sic < 6800: return 7  # Finance, Insurance, RE
-        elif sic < 9000: return 8  # Services
-        else: return 9             # Public Admin
-    except:
-        return 9 
-
-# --- Constants & Configurations ---
-CBP_RELEASE_DATES = {
-    2023: "2025-06-26", 2022: "2024-06-27", 2021: "2023-04-20", 
-    2020: "2022-04-28", 2019: "2021-04-22", 2018: "2020-06-25", 
-    2017: "2019-11-21", 2016: "2018-04-19", 2015: "2017-04-20", 
-    2014: "2016-04-24", 2013: "2015-04-23", 2012: "2014-05-29", 
-    2011: "2013-04-30", 2010: "2012-06-26"
-}
-
-STATE_ABBREV = {
-    'Alabama': 'AL', 'Alaska': 'AK', 'Arizona': 'AZ', 'Arkansas': 'AR', 'California': 'CA',
-    'Colorado': 'CO', 'Connecticut': 'CT', 'Delaware': 'DE', 'Florida': 'FL', 'Georgia': 'GA',
-    'Hawaii': 'HI', 'Idaho': 'ID', 'Illinois': 'IL', 'Indiana': 'IN', 'Iowa': 'IA',
-    'Kansas': 'KS', 'Kentucky': 'KY', 'Louisiana': 'LA', 'Maine': 'ME', 'Maryland': 'MD',
-    'Massachusetts': 'MA', 'Michigan': 'MI', 'Minnesota': 'MN', 'Mississippi': 'MS',
-    'Missouri': 'MO', 'Montana': 'MT', 'Nebraska': 'NE', 'Nevada': 'NV', 'New Hampshire': 'NH',
-    'New Jersey': 'NJ', 'New Mexico': 'NM', 'New York': 'NY', 'North Carolina': 'NC',
-    'North Dakota': 'ND', 'Ohio': 'OH', 'Oklahoma': 'OK', 'Oregon': 'OR', 'Pennsylvania': 'PA',
-    'Rhode Island': 'RI', 'South Carolina': 'SC', 'South Dakota': 'SD', 'Tennessee': 'TN',
-    'Texas': 'TX', 'Utah': 'UT', 'Vermont': 'VT', 'Virginia': 'VA', 'Washington': 'WA',
-    'West Virginia': 'WV', 'Wisconsin': 'WI', 'Wyoming': 'WY', 'District of Columbia': 'DC'
-}
-
-# (Keep SEC_FACTS list and map_sic_to_division helper exactly as you had them)
-
-def process_node_features(data_dir="data/", processed_dir="data/processed/"):
-    """Phase 3: Generate and save standardized node features."""
-    import re
-    pol_path = os.path.join(processed_dir, "politician_features.parquet")
-    comp_path = os.path.join(processed_dir, "company_features.parquet")
-    cbp_out_path = os.path.join(processed_dir, "district_economics_cbp.parquet")
-
-    if all(os.path.exists(p) for p in [pol_path, comp_path, cbp_out_path]):
-        print(" -> Found all node feature parquets. Skipping Phase 3...")
-        return pol_path, comp_path
-
-    print("==================================================")
-    print("PHASE 3: NODE FEATURE EXTRACTION")
-    print("==================================================")
-
-    # --- 1. POLITICIAN STATIC (Committees & Party) ---
-    print(" -> Processing Politician Static Features...")
-    df_com = pd.read_csv(os.path.join(data_dir, "cropped/committee_assignments.csv"))
-    df_com['Committees'] = df_com['Committees'].fillna('').astype(str).str.split(r';\s*')
-    mlb = MultiLabelBinarizer()
-    encoded_com = mlb.fit_transform(df_com['Committees'])
-    df_pol_static = pd.concat([df_com.drop('Committees', axis=1), 
-                               pd.DataFrame(encoded_com, columns=[f"Com_{c}" for c in mlb.classes_])], axis=1)
-    df_pol_static['District_Num'] = df_pol_static['District'].astype(str).str.extract(r'(\d+)').fillna('0')
-
-    # --- 2. DISTRICT ECONOMICS (NAICS Schema-Agnostic) ---
-    print(" -> Processing CBP District Economics (Handling 2012/2017 NAICS Schema)...")
-    cbp_dir = os.path.join(data_dir, "cropped/district_industries")
-    cbp_dfs = []
-    
-    # Nested helper to parse "Congressional District 1 (119th Congress), Alabama"
-    def _parse_geo(name):
-        try:
-            match = re.search(r'(?:District\s|at Large)(\d+)?.*?,\s*(.*)', str(name))
-            if match:
-                dist = match.group(1) if match.group(1) else '0'
-                state = STATE_ABBREV.get(match.group(2).strip(), 'XX')
-                return state, str(int(dist))
-        except: pass
-        return "XX", "-1"
-
-    for year, release_date in CBP_RELEASE_DATES.items():
-        file_name = f"{year}_CB_estimates.csv" if year <= 2012 else f"{year}_CB_esurvey.csv"
-        file_path = os.path.join(cbp_dir, file_name)
-        if not os.path.exists(file_path): continue
-            
-        df_year = pd.read_csv(file_path, low_memory=False)
-        df_year.columns = [c.split('(')[-1].replace(')', '').strip() if '(' in c else c for c in df_year.columns]
-        
-        # Dynamically grabs NAICS2012 or NAICS2017
-        naics_col = next((c for c in df_year.columns if 'NAICS' in c), None)
-        if not naics_col: continue
-            
-        df_year = df_year[['NAME', naics_col, 'EMP']].copy()
-        df_year.rename(columns={naics_col: 'Sector_Raw'}, inplace=True)
-        df_year['EMP'] = pd.to_numeric(df_year['EMP'], errors='coerce').fillna(0)
-        df_year['ReleaseDate'] = pd.to_datetime(release_date)
-        
-        # Explicitly call the nested _parse_geo function
-        df_year[['State', 'District']] = pd.DataFrame(df_year['NAME'].apply(_parse_geo).tolist(), index=df_year.index)
-        df_year['Sector'] = df_year['Sector_Raw'].astype(str).str[:2]
-        cbp_dfs.append(df_year)
-
-    if cbp_dfs:
-        df_cbp = pd.concat(cbp_dfs, ignore_index=True)
-        df_cbp_pivot = df_cbp.pivot_table(index=['State', 'District', 'ReleaseDate'], 
-                                          columns='Sector', values='EMP', aggfunc='sum').reset_index()
-        
-        # Forward fill 24-dim economics vector
-        df_cbp_pivot = df_cbp_pivot.sort_values(['State', 'District', 'ReleaseDate'])
-        sector_cols = [c for c in df_cbp_pivot.columns if c not in ['State', 'District', 'ReleaseDate']]
-        
-        # Prefix the NAICS columns for clarity
-        df_cbp_pivot.rename(columns={c: f"NAICS_EMP_{c}" for c in sector_cols}, inplace=True)
-        naics_prefixed = [f"NAICS_EMP_{c}" for c in sector_cols]
-        
-        df_cbp_pivot[naics_prefixed] = df_cbp_pivot.groupby(['State', 'District'])[naics_prefixed].ffill().fillna(0.0)
-        
-        df_cbp_pivot.to_parquet(cbp_out_path)
-        print(f"   -> Saved District Economics (Dims: {len(naics_prefixed)})")
-
-    # --- 3. COMPANY SNAPSHOTS (SEC & SIC) ---
-    print(" -> Processing Company Features (SEC & SIC)...")
-    df_sec = pd.read_csv(os.path.join(data_dir, "cropped/sec_quarterly_financials.csv"))
-    df_sec['FiledDate'] = pd.to_datetime(df_sec['FiledDate'])
-    df_sec = df_sec[df_sec['Fact'].isin(SEC_FACTS)].drop_duplicates(subset=['Ticker', 'FiledDate', 'Fact'], keep='last')
-    
-    df_comp = df_sec.pivot(index=['Ticker', 'FiledDate'], columns='Fact', values='Value').reset_index()
-    for fact in SEC_FACTS:
-        if fact not in df_comp.columns: df_comp[fact] = np.nan
-    df_comp = df_comp[['Ticker', 'FiledDate'] + SEC_FACTS].sort_values(['Ticker', 'FiledDate'])
-    
-    df_comp[SEC_FACTS] = df_comp.groupby('Ticker')[SEC_FACTS].ffill().fillna(0.0)
-    for col in SEC_FACTS:
-        df_comp[col] = np.sign(df_comp[col]) * np.log1p(np.abs(df_comp[col]))
-
-    df_sic = pd.read_csv(os.path.join(data_dir, "cropped/company_sic_data.csv"))
-    df_sic['sic_division'] = df_sic['sic'].apply(map_sic_to_division)
-    sic_dummies = pd.get_dummies(df_sic['sic_division'], prefix='SIC_Div')
-    for i in range(10):
-        if f'SIC_Div_{i}' not in sic_dummies.columns: sic_dummies[f'SIC_Div_{i}'] = 0
-    df_sic_proc = pd.concat([df_sic[['ticker']], sic_dummies[[f'SIC_Div_{i}' for i in range(10)]]], axis=1).rename(columns={'ticker': 'Ticker'})
-    df_comp = df_comp.merge(df_sic_proc, on='Ticker', how='left').fillna(0.0)
-
-    # SAVE ALL
-    print(" -> Saving Phase 3 Parquets...")
-    df_pol_static.to_parquet(pol_path)
-    df_comp.to_parquet(comp_path)
-    
-    return pol_path, comp_path
 
 # ==========================================
 # PHASE 4: ASSEMBLY & PYG VALIDATION
@@ -685,27 +452,14 @@ def generate_hillstreet_dataset(edge_dir="data/processed/master_edges_parquet",
     ]
 
     valid_files = []
-    # Map filenames to their config keys
-    edge_map = {
-        "edges_trades.parquet": "trades",
-        "edges_lobbying.parquet": "lobbying",
-        "edges_camp_fin.parquet": "camp_fin",
-        "edges_geo.parquet": "geo"
-    }
-
     for file in edge_files:
-        config_key = edge_map[file]
-        
-        # Check the toggle in CONFIG
-        if not CONFIG["INCLUDE_EDGES"].get(config_key, True):
-            print(f" -> Skipping '{config_key}' edge file per config.")
-            continue
-            
         file_path = os.path.join(edge_dir, file)
         if not os.path.exists(file_path):
             print(f" -> [WARNING] Expected edge chunk not found: {file}")
             continue
-            
+        if not include_structural_edges and "trades" not in file:
+            print(f" -> Skipping structural edge file per config: {file}")
+            continue
         valid_files.append(file_path)
 
     files_sql = "[" + ", ".join([f"'{f}'" for f in valid_files]) + "]"
@@ -787,8 +541,15 @@ def generate_hillstreet_dataset(edge_dir="data/processed/master_edges_parquet",
         time_array = master_table['time'].to_numpy().astype('datetime64[s]').astype(np.int64)
         t_tensor = torch.from_numpy(time_array).to(torch.long)
 
+        # Recency endpoint: epoch-seconds of the most recent event in each (collapsed)
+        # edge. For trades and any un-deduped edge this equals `t`. Kept as its own
+        # tensor (NOT in msg) so the load path can compute days-since from recency
+        # while `t` continues to anchor the edge to the start of the relationship.
+        last_seen_array = master_table['last_seen'].to_numpy().astype('datetime64[s]').astype(np.int64)
+        last_seen_tensor = torch.from_numpy(last_seen_array).to(torch.long)
+
         # Message Attribute Tensor (D=24)
-        base_cols = ['src', 'dst', 'time', 'y', 'event_type']
+        base_cols = ['src', 'dst', 'time', 'last_seen', 'y', 'event_type']
         msg_cols = [c for c in master_table.column_names if c not in base_cols]
         
         msg_tensor = torch.empty((num_rows, len(msg_cols)), dtype=torch.float)
@@ -806,6 +567,7 @@ def generate_hillstreet_dataset(edge_dir="data/processed/master_edges_parquet",
             y=y_tensor
         )
         data.event_type = event_type_tensor
+        data.last_seen = last_seen_tensor
         
         # Audit
         is_sorted = torch.all(t_tensor[1:] >= t_tensor[:-1]).item()
@@ -818,7 +580,7 @@ def generate_hillstreet_dataset(edge_dir="data/processed/master_edges_parquet",
         print(f" -> Shard saved successfully: {shard_path}")
 
         # Memory Cleanup
-        del master_table, src_tensor, dst_tensor, y_tensor, event_type_tensor, t_tensor, msg_tensor, data
+        del master_table, src_tensor, dst_tensor, y_tensor, event_type_tensor, t_tensor, last_seen_tensor, msg_tensor, data
         gc.collect()
 
     print("\n==================================================")
@@ -831,19 +593,36 @@ def generate_hillstreet_dataset(edge_dir="data/processed/master_edges_parquet",
 # ==========================================
 
 if __name__ == "__main__":
-    # 1. Setup Directories from CONFIG
-    EDGE_DIR = CONFIG["EDGE_OUT_DIR"]
-    os.makedirs(EDGE_DIR, exist_ok=True)
-    
-    # Check which edges are required based on the toggle panel
-    REQUIRED_EDGES = []
-    if CONFIG["INCLUDE_EDGES"].get("trades", True): REQUIRED_EDGES.append("edges_trades.parquet")
-    if CONFIG["INCLUDE_EDGES"].get("lobbying", True): REQUIRED_EDGES.append("edges_lobbying.parquet")
-    if CONFIG["INCLUDE_EDGES"].get("camp_fin", True): REQUIRED_EDGES.append("edges_camp_fin.parquet")
-    if CONFIG["INCLUDE_EDGES"].get("geo", True): REQUIRED_EDGES.append("edges_geo.parquet")
+    parser = argparse.ArgumentParser(description="HillStreet Graph Generation Pipeline")
+    parser.add_argument("--start_date", type=str, default="2014-01-01", help="Date to start graph inclusion (YYYY-MM-DD)")
+    # NOTE: previously type=bool, which made "--include_structural_edges False" evaluate
+    # to True (any non-empty string is truthy). Use a proper boolean flag pair instead.
+    parser.add_argument("--include_structural_edges", dest="include_structural_edges",
+                        action="store_true", default=True,
+                        help="Include Lobbying, PACs, Geo-Economics (default: on)")
+    parser.add_argument("--no_structural_edges", dest="include_structural_edges",
+                        action="store_false",
+                        help="Exclude structural edges; keep only trade edges")
+    # --- Phase 3 node-feature options ---
+    parser.add_argument("--skip_node_features", action="store_true",
+                        help="Skip Phase 3 node-feature generation (edges/shards only)")
+    parser.add_argument("--trades_csv", type=str,
+                        default="data/processed/ml_dataset_continuous.csv",
+                        help="Transactions CSV used for performance stats & categorical embeddings")
+    parser.add_argument("--snapshot_date", type=str, default=None,
+                        help="As-of date for time-varying node features (YYYY-MM-DD). "
+                             "Defaults to the latest event date in the transactions CSV.")
+    args = parser.parse_args()
+
+    # 1. Setup Directories
+    EDGE_DIR = "data/processed/master_edges_parquet"
+    REQUIRED_EDGES = [
+        "edges_trades.parquet", "edges_lobbying.parquet", 
+        "edges_camp_fin.parquet", "edges_geo.parquet"
+    ]
     
     # 2. Check for Phase 1 & 2 Persistence
-    phase2_done = all(os.path.exists(os.path.join(EDGE_DIR, f)) for f in REQUIRED_EDGES) and len(REQUIRED_EDGES) > 0
+    phase2_done = all(os.path.exists(os.path.join(EDGE_DIR, f)) for f in REQUIRED_EDGES)
     
     if phase2_done:
         print(f" -> Found existing edge parquets in {EDGE_DIR}. Skipping Phases 1 & 2.")
@@ -854,12 +633,37 @@ if __name__ == "__main__":
         df_trades, df_lobbying, df_camp_fin, df_geo, cw_2012, cw_2017, cw_cat = load_and_standardize_events()
         EDGE_DIR, all_msg_cols = broadcast_and_pad_edges(df_trades, df_lobbying, df_camp_fin, df_geo, cw_cat)
 
-    # 3. Process Node Features
-    pol_feat_path, comp_feat_path = process_node_features()
-    
-    # 4. Generate Final PyG Dataset using the START_DATE from CONFIG
-    shards_generated = generate_hillstreet_dataset(
-        start_date=CONFIG["START_DATE"], 
+    # 3. Assembly & PyG Sharding (Phase 4)
+    #    Must run before node features: build_node_features aligns to the node-id maps
+    #    (src_id_map.npy / dst_id_map.npy) that this step writes.
+    shard_paths = generate_hillstreet_dataset(
+        edge_dir=EDGE_DIR,
+        start_date=args.start_date,
+        include_structural_edges=args.include_structural_edges
     )
-    
-    print(f"Successfully generated the following shards:\n{shards_generated}")
+
+    # 4. Phase 3: Static node features aligned to the Phase-4 maps
+    if args.skip_node_features:
+        print("\n -> Skipping Phase 3 node-feature generation (--skip_node_features).")
+    else:
+        # Ensure the project root is on sys.path regardless of how this script was
+        # launched (python src/temporal_data.py vs python -m src.temporal_data).
+        # __file__ is .../src/temporal_data.py, so two .parent calls reach the root.
+        import sys
+        from pathlib import Path as _Path
+        _project_root = str(_Path(__file__).resolve().parent.parent)
+        if _project_root not in sys.path:
+            sys.path.insert(0, _project_root)
+        from src.data_prep.node_features import build_node_features
+        build_node_features(
+            map_dir="data/processed/pyg_graph",
+            trades_csv=args.trades_csv,
+            processed_dir="data/processed",
+            snapshot_date=args.snapshot_date,
+        )
+
+    print(f"\nSUCCESS: HillStreet Generation Pipeline Fully Complete.")
+    print(f" -> Graph timeline starts: {args.start_date}")
+    print(f" -> Shards: {len(shard_paths)} files saved to data/processed/pyg_graph/")
+    if not args.skip_node_features:
+        print(f" -> Node features: data/processed/node_features_static.pt")