Normalize remaining non-database drift to slice 117

Author: jmsexton03

src/services/run_superfacility_tools.py

@@ -1505,7 +1505,6 @@ def monitor_job(
                     from sfapi_client.compute import Machine
                 except Exception:
                     method = "api"
-                    poll_method = "api"
                 else:
                     with Client(client_id=client_id, secret=secret) as client:
                         perlmutter = client.compute(Machine.perlmutter)
@@ -1528,7 +1527,6 @@ def monitor_job(
                             state = state.value
                         if state:
                             state_str = str(state).upper()
-                            poll_outcome = state_str
                             if state_str not in ["RUNNING", "PENDING"]:
                                 outcome = str(state)
                                 logger.info(
@@ -1561,19 +1559,9 @@ def monitor_job(
                         (time.perf_counter() - poll_start) * 1000.0,
                     )
                     if state not in ["RUNNING", "PENDING"]:
-                        logger.info(
-                            "Job poll %s/%s method=%s job_id=%s outcome=%s latency_ms=%.3f",
-                            poll_index,
-                            max_polls,
-                            poll_method,
-                            job_id,
-                            poll_outcome,
-                            (time.perf_counter() - poll_start) * 1000.0,
-                        )
                         return state
 
             else:
-                poll_method = "sbatch"
                 result = subprocess.run(
                     ["squeue", "-j", str(job_id), "-h", "-o", "%T"],
                     capture_output=True,
@@ -1598,29 +1586,10 @@ def monitor_job(
                     (time.perf_counter() - poll_start) * 1000.0,
                 )
                 if state not in ["RUNNING", "PENDING"]:
-                    logger.info(
-                        "Job poll %s/%s method=%s job_id=%s outcome=%s latency_ms=%.3f",
-                        poll_index,
-                        max_polls,
-                        poll_method,
-                        job_id,
-                        poll_outcome,
-                        (time.perf_counter() - poll_start) * 1000.0,
-                    )
                     return state
 
-        except Exception as exc:
-            poll_outcome = f"ERROR:{type(exc).__name__}"
-
-        logger.info(
-            "Job poll %s/%s method=%s job_id=%s outcome=%s latency_ms=%.3f",
-            poll_index,
-            max_polls,
-            poll_method,
-            job_id,
-            poll_outcome,
-            (time.perf_counter() - poll_start) * 1000.0,
-        )
+        except Exception:
+            pass
 
         time.sleep(poll_interval)
 

tests/unit/test_architect_node_history.py

@@ -1,5 +1,4 @@
 import importlib
-from types import MethodType, SimpleNamespace
 
 import pytest
 
@@ -8,7 +7,6 @@
 
 architect_node_module = importlib.import_module("src.nodes.architect_node")
 embedding_factory_module = importlib.import_module("src.services.embedding_service_factory")
-architect_service_module = importlib.import_module("src.services.architect")
 
 
 class DummyConfig:
@@ -43,9 +41,6 @@ def _plan(selected_case="PeleC/Exec/RegTests/PMF", selected_solver="PeleC"):
             ],
         },
         baseline_confidence=0.92,
-        level0_latency_per_query_ms=6.0,
-        level1_latency_per_query_ms=14.5,
-        level2_latency_per_query_ms=11.25,
         indexing_strategy="simple",
         case_candidates=[],
     )

tests/unit/test_level0_index.py

@@ -10,7 +10,6 @@
 - Integrates with Metadata Schema schema
 """
 import pytest
-import json
 from pathlib import Path
 from concurrent.futures import ThreadPoolExecutor
 from unittest.mock import Mock, MagicMock, patch
@@ -99,35 +98,6 @@ def test_level0_populated_with_solver_data(self, tmp_path):
             assert 'PeleLMeX' in indexed_codes, "Should index PeleLMeX"
 
             print(f"\n✅ Indexed {len(indexed_codes)} codes: {indexed_codes}")
-
-    def test_level0_emits_loc_savings_report(self, tmp_path):
-        """
-        Given: Config-driven Level 0 framework builder
-        When:  Building Level 0 indices
-        Then:  Should emit automated LOC-savings metrics for reuse reporting
-        """
-        from database.indexing.level0_builder import Level0Builder
-
-        mock_embedder = Mock()
-        mock_embedder.embed_texts.return_value = [[0.1] * 384] * 20
-        mock_embedder.expand_documents.side_effect = lambda documents, metadata: (documents, metadata)
-
-        builder = Level0Builder(embedder=mock_embedder)
-        output_dir = tmp_path / "level0"
-        builder.build(output_dir=output_dir)
-
-        report_path = output_dir / "level0_loc_savings_report.json"
-        assert report_path.exists(), "Missing automated LOC-savings report"
-
-        report = json.loads(report_path.read_text())
-        assert report["metric_name"] == "level0_framework_reuse_loc_savings"
-        assert report["solver_count"] >= 1
-        assert report["subindex_count"] == 4
-        assert report["baseline_manual_loc"] >= report["framework_loc"]
-        assert report["estimated_loc_saved"] == (
-            report["baseline_manual_loc"] - report["framework_loc"]
-        )
-        assert 0.0 <= report["savings_ratio"] <= 1.0
 
 
     def test_level0_includes_cross_cutting_guidance(self, tmp_path):
@@ -425,7 +395,7 @@ class TestLevel0PerformanceRequirements:
     """Validate performance/concurrency requirements from PRD Section 13."""
 
     @pytest.mark.performance
-    def test_level0_faiss_retrieval_p95_latency(self):
+    def test_level0_query_latency(self):
         """
         Given: Level 0 index with all 4 sub-indices
         When:  Executing search query
@@ -434,7 +404,6 @@ def test_level0_faiss_retrieval_p95_latency(self):
         PRD: Section 13 FAISS retrieval latency <500ms
         """
         import time
-        from statistics import quantiles
         from database.indexing.level0_searcher import Level0Searcher
 
         # Skip if indices don't exist