fix: strict_gates defaults to false, remove dead code

- Set strict_gates=False in orchestrator constructor and both frontend pages
- Move docker/eqy from required_bins to optional_bins in startup_self_check
- Remove dead files: debug_llm.py (broken import), .streamlit/ (superseded),
golden_lib/verilator_coverage.py (never imported, superseded by vlsi_tools)
- Fix stale Nemotron/GLM5 references in api.py comments

.streamlit/config.toml

@@ -1,14 +0,0 @@
-[theme]
-primaryColor = "#00FF88"
-backgroundColor = "#000000"
-secondaryBackgroundColor = "#0E1117"
-textColor = "#E0E0E0"
-font = "sans serif"
-
-[server]
-headless = true
-enableCORS = false
-enableXsrfProtection = false
-
-[deprecation]
-showPyplotGlobalUse = false

debug_llm.py

@@ -1,52 +0,0 @@
-import os
-import sys
-
-# Add src to path to import config
-sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
-from agentic.config import NVIDIA_CONFIG, GLM5_CONFIG, LOCAL_CONFIG
-from crewai import LLM
-
-print(f"--- Debugging LLM Flow ---")
-
-def try_model(name, config):
-    print(f"\nTesting {name}...")
-    print(f"Model:    {config['model']}")
-    print(f"Base URL: {config['base_url']}")
-    masked_key = '*' * 5 + config['api_key'][-4:] if config['api_key'] and len(config['api_key']) > 4 else 'None'
-    print(f"API Key:  {masked_key}")
-
-    if not config['api_key'] or config['api_key'] == "NA":
-        print(f"⏭ Skipping {name}: No API Key found.")
-        return False
-
-    try:
-        llm = LLM(
-            model=config['model'],
-            base_url=config['base_url'],
-            api_key=config['api_key']
-        )
-        resp = llm.call(
-            messages=[{"role": "user", "content": "Return the word 'CONNECTED' if you hear me."}]
-        )
-        print(f"✅ {name} Success! Response:\n{resp}")
-        return True
-    except Exception as e:
-        print(f"❌ {name} Failed: {e}")
-        return False
-
-# 1. Try NVIDIA
-if try_model("NVIDIA (Primary)", NVIDIA_CONFIG):
-    print("\n🎉 Verification Complete: Using NVIDIA.")
-    sys.exit(0)
-
-# 2. Try GLM5
-if try_model("GLM5 (Backup)", GLM5_CONFIG):
-    print("\n🎉 Verification Complete: Using GLM5.")
-    sys.exit(0)
-
-# 3. Try Local
-if try_model("Local (Default)", LOCAL_CONFIG):
-    print("\n🎉 Verification Complete: Using Local LLM.")
-    sys.exit(0)
-
-print("\n🔥 All LLM connections failed.")

server/api.py

@@ -93,7 +93,7 @@ STAGE_META: Dict[str, Dict[str, str]] = {
 
 def _get_llm(byok_api_key: str = None):
     """Tries cloud backends first, then local Ollama.
-    Priority: NVIDIA Nemotron → Groq LLaMA-3.3 → VeriReason Local
+    Priority: NVIDIA Cloud → Groq LLaMA-3.3 → Local Ollama
 
     If byok_api_key is provided (BYOK plan), it overrides the cloud config key.
     """
@@ -344,7 +344,7 @@ def _run_agentic_build(job_id: str, req: BuildRequest):
                 thought_type = _infer_thought_type(message)
                 _emit_agent_thought(job_id, agent_name, thought_type, message, state)
 
-        # Use smart LLM selection: Cloud first (Nemotron → GLM5) → Local fallback
+        # Use smart LLM selection: Cloud first (NVIDIA → Groq) → Local fallback
         byok_key = JOB_STORE[job_id].get("byok_key")
         llm, llm_name = _get_llm(byok_api_key=byok_key)
         _emit_event(job_id, "checkpoint", "INIT", f"🤖 Compute engine ready", step=1)

src/agentic/golden_lib/verilator_coverage.py

@@ -1,213 +0,0 @@
-"""Verilator Real Coverage Integration.
-
-Provides actual code coverage using Verilator's --coverage flag,
-replacing the heuristic-based coverage estimate in vlsi_tools.py.
-"""
-
-import os
-import re
-import subprocess
-from ..config import OPENLANE_ROOT
-
-
-def run_verilator_coverage(design_name: str) -> tuple:
-    """Compiles and runs simulation with Verilator's real coverage instrumentation.
-    
-    Uses Verilator to compile the design with --coverage flag, runs the
-    simulation binary, then parses the coverage output.
-    
-    Returns:
-        tuple: (success: bool, report: str, coverage_data: dict)
-               coverage_data = {'line': float, 'branch': float, 'toggle': float, 'overall': float}
-    """
-    src_dir = f"{OPENLANE_ROOT}/designs/{design_name}/src"
-    rtl_file = f"{src_dir}/{design_name}.v"
-    tb_file = f"{src_dir}/{design_name}_tb.v"
-    obj_dir = f"{src_dir}/verilator_cov_obj"
-    cov_dat = f"{src_dir}/coverage.dat"
-    
-    if not os.path.exists(rtl_file):
-        return False, f"RTL file not found: {rtl_file}", {}
-    if not os.path.exists(tb_file):
-        return False, f"Testbench file not found: {tb_file}", {}
-    
-    # Step 1: Compile with Verilator --coverage
-    compile_cmd = [
-        "verilator", "--binary", "--coverage",
-        "--coverage-line", "--coverage-toggle",
-        "-Wno-fatal",
-        "--timing",
-        f"--Mdir", obj_dir,
-        "-o", f"V{design_name}",
-        "--top-module", f"{design_name}_tb",
-        rtl_file, tb_file
-    ]
-    
-    try:
-        result = subprocess.run(
-            compile_cmd,
-            capture_output=True, text=True,
-            timeout=180
-        )
-        if result.returncode != 0:
-            # Fallback: Verilator couldn't compile (common with iverilog-style TBs)
-            return False, f"Verilator compilation failed (this is normal for iverilog-style testbenches):\n{result.stderr[:500]}", {}
-    except FileNotFoundError:
-        return False, "Verilator not installed. Falling back to heuristic coverage.", {}
-    except subprocess.TimeoutExpired:
-        return False, "Verilator compilation timed out.", {}
-    
-    # Step 2: Run the simulation
-    sim_binary = f"{obj_dir}/V{design_name}"
-    if not os.path.exists(sim_binary):
-        return False, f"Simulation binary not found: {sim_binary}", {}
-    
-    try:
-        sim_result = subprocess.run(
-            [sim_binary, f"+verilator+coverage+file+{cov_dat}"],
-            capture_output=True, text=True,
-            timeout=300,
-            cwd=src_dir
-        )
-    except subprocess.TimeoutExpired:
-        return False, "Simulation timed out.", {}
-    
-    sim_output = (sim_result.stdout or "") + ("\n" + sim_result.stderr if sim_result.stderr else "")
-    sim_passed = "TEST PASSED" in sim_output
-    
-    # Step 3: Parse coverage data
-    coverage_data = parse_verilator_coverage(cov_dat, src_dir)
-    
-    report = f"Simulation: {'PASSED' if sim_passed else 'FAILED'}\n"
-    report += f"Coverage: line={coverage_data.get('line', 0):.1f}% "
-    report += f"toggle={coverage_data.get('toggle', 0):.1f}% "
-    report += f"overall={coverage_data.get('overall', 0):.1f}%"
-    
-    return sim_passed, report, coverage_data
-
-
-def parse_verilator_coverage(cov_dat_path: str, output_dir: str) -> dict:
-    """Parse Verilator coverage.dat file into coverage percentages.
-    
-    Args:
-        cov_dat_path: Path to coverage.dat file
-        output_dir: Directory for annotated output
-    
-    Returns:
-        dict with 'line', 'toggle', 'branch', 'overall' percentages
-    """
-    result = {
-        'line': 0.0,
-        'toggle': 0.0, 
-        'branch': 0.0,
-        'overall': 0.0,
-        'total_points': 0,
-        'hit_points': 0
-    }
-    
-    if not os.path.exists(cov_dat_path):
-        result['error'] = 'coverage.dat not found'
-        return result
-    
-    # Use verilator_coverage tool to get summary
-    annotate_dir = f"{output_dir}/cov_annotate"
-    
-    try:
-        # Get annotated output
-        subprocess.run(
-            ["verilator_coverage", "--annotate", annotate_dir, cov_dat_path],
-            capture_output=True, text=True, timeout=30
-        )
-        
-        # Parse annotated files for line coverage
-        line_total = 0
-        line_hit = 0
-        toggle_total = 0
-        toggle_hit = 0
-        
-        if os.path.exists(annotate_dir):
-            for root, dirs, files in os.walk(annotate_dir):
-                for fname in files:
-                    if fname.endswith('.v') or fname.endswith('.sv'):
-                        fpath = os.path.join(root, fname)
-                        with open(fpath, 'r') as f:
-                            for line in f:
-                                line = line.strip()
-                                # Verilator annotates with coverage counts
-                                cov_match = re.match(r'^(\d+)\s+(.+)', line)
-                                if cov_match:
-                                    count = int(cov_match.group(1))
-                                    line_total += 1
-                                    if count > 0:
-                                        line_hit += 1
-                                elif line.startswith('%'):
-                                    # Toggle coverage annotations
-                                    toggle_total += 1
-                                    pct_match = re.match(r'%0*(\d+)', line)
-                                    if pct_match and int(pct_match.group(1)) > 0:
-                                        toggle_hit += 1
-        
-        if line_total > 0:
-            result['line'] = round((line_hit / line_total) * 100, 1)
-        if toggle_total > 0:
-            result['toggle'] = round((toggle_hit / toggle_total) * 100, 1)
-        
-        result['total_points'] = line_total + toggle_total
-        result['hit_points'] = line_hit + toggle_hit
-        
-        # Branch coverage estimate (Verilator doesn't separate this well)
-        result['branch'] = round(result['line'] * 0.85, 1) if result['line'] > 0 else 0.0
-        
-        # Overall
-        if result['total_points'] > 0:
-            result['overall'] = round((result['hit_points'] / result['total_points']) * 100, 1)
-        
-    except FileNotFoundError:
-        result['error'] = 'verilator_coverage tool not found'
-    except Exception as e:
-        result['error'] = str(e)
-    
-    # Also try to get summary directly from coverage.dat
-    try:
-        with open(cov_dat_path, 'r') as f:
-            cov_text = f.read()
-        
-        # Count coverage points
-        point_matches = re.findall(r"'(\d+)'", cov_text)
-        if point_matches:
-            total = len(point_matches)
-            hit = sum(1 for p in point_matches if int(p) > 0)
-            if total > 0 and result['overall'] == 0:
-                result['line'] = round((hit / total) * 100, 1)
-                result['overall'] = result['line']
-                result['total_points'] = total
-                result['hit_points'] = hit
-    except Exception:
-        pass
-    
-    return result
-
-
-def get_coverage_summary(design_name: str) -> str:
-    """Get a human-readable coverage summary for a design.
-    
-    Returns:
-        str: Formatted coverage summary
-    """
-    src_dir = f"{OPENLANE_ROOT}/designs/{design_name}/src"
-    cov_dat = f"{src_dir}/coverage.dat"
-    
-    data = parse_verilator_coverage(cov_dat, src_dir)
-    
-    if data.get('error'):
-        return f"Coverage data unavailable: {data['error']}"
-    
-    return (
-        f"📊 Coverage Report for {design_name}\n"
-        f"{'='*40}\n"
-        f"  Line Coverage:   {data['line']:.1f}%\n"
-        f"  Toggle Coverage: {data['toggle']:.1f}%\n"
-        f"  Branch Coverage: {data['branch']:.1f}% (estimated)\n"
-        f"  Overall:         {data['overall']:.1f}%\n"
-        f"  Points: {data['hit_points']}/{data['total_points']} hit\n"
-    )

src/agentic/orchestrator.py

@@ -172,7 +172,7 @@ class BuildOrchestrator:
         skip_coverage: bool = False,
         full_signoff: bool = False,
         min_coverage: float = 80.0,
-        strict_gates: bool = True,
+        strict_gates: bool = False,
         pdk_profile: str = "sky130",
         max_pivots: int = 2,
         congestion_threshold: float = 10.0,

src/agentic/tools/vlsi_tools.py

@@ -220,12 +220,12 @@ def startup_self_check() -> Dict[str, Any]:
         "verilator": "verilator",
         "iverilog": "iverilog",
         "vvp": "vvp",
-        "docker": "docker",
         "yosys": YOSYS_BIN,
         "sby": SBY_BIN,
-        "eqy": EQY_BIN,
     }
     optional_bins = {
+        "docker": "docker",
+        "eqy": EQY_BIN,
         "verilator_coverage": "verilator_coverage",
     }
     all_pass = True

web/src/pages/DesignStudio.tsx

@@ -52,7 +52,7 @@ export const DesignStudio = () => {
     const [maxRetries, setMaxRetries] = useState(5);
     const [showThinking, setShowThinking] = useState(false);
     const [minCoverage, setMinCoverage] = useState(80.0);
-    const [strictGates, setStrictGates] = useState(true);
+    const [strictGates, setStrictGates] = useState(false);
     const [pdkProfile, setPdkProfile] = useState("sky130");
     const [maxPivots, setMaxPivots] = useState(2);
     const [congestionThreshold, setCongestionThreshold] = useState(10.0);

web/src/pages/HumanInLoopBuild.tsx

@@ -125,7 +125,7 @@ export const HumanInLoopBuild = () => {
     const [maxRetries, setMaxRetries] = useState(5);
     const [showThinking, setShowThinking] = useState(false);
     const [minCoverage, setMinCoverage] = useState(80.0);
-    const [strictGates, setStrictGates] = useState(true);
+    const [strictGates, setStrictGates] = useState(false);
     const [pdkProfile, setPdkProfile] = useState("sky130");
 
     // Build mode & stage skipping (Improvement 2)