Improve monitoring UX and deterministic offline outputs

API_MONITORING.md

@@ -47,6 +47,10 @@ Every single API call is logged with full details:
 
 4. **Token Breakdown** - Separate counts for input vs output tokens
 
+5. **Budget Guardrails** - Optional session budget with alerts  
+   - Set `API_BUDGET_USD` (e.g., `50` or `15.5`) to display remaining budget and trigger warnings  
+   - Tweak alert threshold with `API_BUDGET_ALERT_FRACTION` (default `0.8` for 80%)
+
 ## Why This Impresses Judges
 
 ### 1. **Enterprise-Grade Observability**

agent/api_monitor.py

@@ -5,6 +5,7 @@ Provides real-time visibility into LLM and GNS3 API usage for judges/users
 
 import time
 import logging
+import os
 from typing import Dict, List, Optional, Any
 from dataclasses import dataclass, field, asdict
 from datetime import datetime
@@ -29,6 +30,7 @@ PRICING = {
 @dataclass
 class APICall:
     """Record of a single API call"""
+    call_id: str
     timestamp: str
     api_type: str  # "llm", "gns3", "netbox", etc.
     provider: str  # "openai", "anthropic", "openrouter", "gns3"
@@ -89,36 +91,71 @@ class SessionStats:
     total_cost: float = 0.0
     errors: int = 0
     start_time: str = field(default_factory=lambda: datetime.now().isoformat())
+    budget_limit: Optional[float] = None
+    budget_alert_fraction: float = 0.8
+    budget_alert_triggered: bool = False
     
     def to_dict(self) -> Dict:
         """Convert to dictionary"""
         return asdict(self)
     
-    def format_dashboard(self) -> str:
+    def budget_remaining(self) -> Optional[float]:
+        """Return remaining budget if configured"""
+        if self.budget_limit is None:
+            return None
+        return max(self.budget_limit - self.total_cost, 0.0)
+    
+    def budget_usage_ratio(self) -> Optional[float]:
+        """Return fraction of budget consumed"""
+        if self.budget_limit is None or self.budget_limit == 0:
+            return None
+        return self.total_cost / self.budget_limit
+    
+    def budget_status(self) -> str:
+        """Human-readable budget status message"""
+        if self.budget_limit is None or self.budget_limit == 0:
+            return "Budget not configured"
+        
+        ratio = self.budget_usage_ratio() or 0.0
+        remaining = self.budget_remaining()
+        
+        if ratio >= 1.0:
+            return f"🛑 Budget exceeded by ${abs(remaining):.2f}"
+        if ratio >= self.budget_alert_fraction:
+            return f"⚠️ {ratio*100:.0f}% of budget used (limit ${self.budget_limit:.2f})"
+        return f"✅ {ratio*100:.0f}% of budget used, ${remaining:.2f} remaining"
+    
+    def format_dashboard(self, include_heading: bool = True) -> str:
         """Format as markdown dashboard for UI"""
         uptime = datetime.now() - datetime.fromisoformat(self.start_time)
         uptime_str = f"{int(uptime.total_seconds() / 60)}m {int(uptime.total_seconds() % 60)}s"
         
-        return f"""
-### 📊 Session Statistics
-
-| Metric | Value |
-|--------|-------|
-| ⏰ Session Duration | {uptime_str} |
-| 📞 Total API Calls | {self.total_calls:,} |
-| 🤖 LLM Calls | {self.llm_calls:,} |
-| 🌐 GNS3 Calls | {self.gns3_calls:,} |
-| 📝 Total Tokens | {self.total_tokens:,} |
-| 💰 **Total Cost** | **${self.total_cost:.4f}** |
-| ❌ Errors | {self.errors} |
-
----
-
-### 💵 Cost Breakdown
-- Input tokens: {self.total_input_tokens:,} ({self.total_input_tokens / 1000000:.2f}M)
-- Output tokens: {self.total_output_tokens:,} ({self.total_output_tokens / 1000000:.2f}M)
-- Avg cost per call: ${self.total_cost / max(self.llm_calls, 1):.4f}
-"""
+        budget_line = "n/a"
+        if self.budget_limit not in (None, 0):
+            remaining = self.budget_remaining()
+            budget_line = f"${self.budget_limit:.2f} (remaining ${remaining:.2f})"
+        status_line = self.budget_status()
+        
+        header = "### 📊 Session Statistics\n\n" if include_heading else ""
+        return (
+            f"{header}"
+            "| Metric | Value |\n"
+            "|--------|-------|\n"
+            f"| ⏰ Session Duration | {uptime_str} |\n"
+            f"| 📞 Total API Calls | {self.total_calls:,} |\n"
+            f"| 🤖 LLM Calls | {self.llm_calls:,} |\n"
+            f"| 🌐 GNS3 Calls | {self.gns3_calls:,} |\n"
+            f"| 📝 Total Tokens | {self.total_tokens:,} |\n"
+            f"| 💰 **Total Cost** | **${self.total_cost:.4f}** |\n"
+            f"| ❌ Errors | {self.errors} |\n"
+            f"| 🧭 Budget | {budget_line} |\n"
+            f"| 🚨 Budget Status | {status_line} |\n\n"
+            "---\n\n"
+            "### 💵 Cost Breakdown\n"
+            f"- Input tokens: {self.total_input_tokens:,} ({self.total_input_tokens / 1000000:.2f}M)\n"
+            f"- Output tokens: {self.total_output_tokens:,} ({self.total_output_tokens / 1000000:.2f}M)\n"
+            f"- Avg cost per call: ${self.total_cost / max(self.total_calls, 1):.4f}\n"
+        )
 
 
 class APIMonitor:
@@ -144,8 +181,18 @@ class APIMonitor:
         
         self._initialized = True
         self.calls: List[APICall] = []
-        self.stats = SessionStats()
         self.active_calls: Dict[str, float] = {}  # call_id -> start_time
+        self._call_index: Dict[str, APICall] = {}
+        
+        # Budget configuration (env vars for quick tuning)
+        budget_env = os.getenv("API_BUDGET_USD")
+        budget_limit = float(budget_env) if budget_env else None
+        budget_alert_fraction = float(os.getenv("API_BUDGET_ALERT_FRACTION", "0.8"))
+        
+        self.stats = SessionStats(
+            budget_limit=budget_limit,
+            budget_alert_fraction=budget_alert_fraction
+        )
         logger.info("API Monitor initialized")
     
     def start_call(self, call_id: str, api_type: str, provider: str, endpoint: str, **metadata) -> APICall:
@@ -155,6 +202,7 @@ class APIMonitor:
         """
         with self._lock:
             call = APICall(
+                call_id=call_id,
                 timestamp=datetime.now().isoformat(),
                 api_type=api_type,
                 provider=provider,
@@ -164,6 +212,7 @@ class APIMonitor:
             )
             self.calls.append(call)
             self.active_calls[call_id] = time.time()
+            self._call_index[call_id] = call
             return call
     
     def complete_call(
@@ -177,22 +226,13 @@ class APIMonitor:
     ):
         """Mark a call as completed and update statistics"""
         with self._lock:
-            if call_id not in self.active_calls:
-                logger.warning(f"Call {call_id} not found in active calls")
-                return
-            
-            start_time = self.active_calls.pop(call_id)
-            duration_ms = (time.time() - start_time) * 1000
+            start_time = self.active_calls.pop(call_id, None)
+            duration_ms = (time.time() - start_time) * 1000 if start_time else None
             
-            # Find the call in our list (should be most recent)
-            call = None
-            for c in reversed(self.calls):
-                if c.status == "in-progress" and c.timestamp == call_id:
-                    call = c
-                    break
-            
-            # If we can't find by timestamp, find the most recent in-progress call
+            # Find the matching call by call_id
+            call = self._call_index.pop(call_id, None)
             if not call:
+                # Fallback to the most recent in-progress call
                 for c in reversed(self.calls):
                     if c.status == "in-progress":
                         call = c
@@ -210,14 +250,17 @@ class APIMonitor:
             call.error_message = error_message
             call.metadata.update(metadata)
             
-            if input_tokens and output_tokens:
-                call.total_tokens = input_tokens + output_tokens
+            # Handle token accounting even if only one side is present
+            if input_tokens is not None or output_tokens is not None:
+                in_tokens = input_tokens or 0
+                out_tokens = output_tokens or 0
+                call.total_tokens = in_tokens + out_tokens
                 
                 # Calculate cost if it's an LLM call
                 if call.api_type == "llm" and call.endpoint in PRICING:
                     pricing = PRICING[call.endpoint]
-                    input_cost = (input_tokens / 1_000_000) * pricing["input"]
-                    output_cost = (output_tokens / 1_000_000) * pricing["output"]
+                    input_cost = (in_tokens / 1_000_000) * pricing["input"]
+                    output_cost = (out_tokens / 1_000_000) * pricing["output"]
                     call.estimated_cost = input_cost + output_cost
             
             # Update session stats
@@ -228,14 +271,20 @@ class APIMonitor:
             elif call.api_type == "gns3":
                 self.stats.gns3_calls += 1
             
-            if call.total_tokens:
+            if call.total_tokens is not None:
                 self.stats.total_tokens += call.total_tokens
-            if call.input_tokens:
+            if call.input_tokens is not None:
                 self.stats.total_input_tokens += call.input_tokens
-            if call.output_tokens:
+            if call.output_tokens is not None:
                 self.stats.total_output_tokens += call.output_tokens
             if call.estimated_cost:
                 self.stats.total_cost += call.estimated_cost
+                
+                # Budget monitoring
+                if self.stats.budget_limit not in (None, 0):
+                    usage_ratio = self.stats.budget_usage_ratio() or 0.0
+                    if usage_ratio >= self.stats.budget_alert_fraction:
+                        self.stats.budget_alert_triggered = True
             
             if not success:
                 self.stats.errors += 1
@@ -270,14 +319,23 @@ class APIMonitor:
         for call in reversed(recent):
             lines.append(f"- {call.format_log_entry()}")
         
+        if self.stats.budget_alert_triggered:
+            lines.append("\n> 🚨 Budget alert: " + self.stats.budget_status())
+        
         return "\n".join(lines)
     
     def reset(self):
         """Reset all tracking (for testing or new sessions)"""
         with self._lock:
             self.calls.clear()
-            self.stats = SessionStats()
+            budget_limit = self.stats.budget_limit
+            alert_fraction = self.stats.budget_alert_fraction
+            self.stats = SessionStats(
+                budget_limit=budget_limit,
+                budget_alert_fraction=alert_fraction
+            )
             self.active_calls.clear()
+            self._call_index.clear()
             logger.info("API Monitor reset")
     
     def export_json(self) -> str:

agent/hardware_pricing.py

@@ -3,6 +3,22 @@ Hardware pricing database for BOM generation
 Prices are approximate retail as of 2025
 """
 
+# Basic procurement links for common gear we surface in mock/default designs
+PROCUREMENT_LINKS = {
+    "Cisco Catalyst 9300": "https://www.cisco.com/c/en/us/products/switches/catalyst-9300-series-switches/",
+    "Cisco ISR 4331": "https://www.cisco.com/c/en/us/products/routers/4000-series-integrated-services-routers-isr/index.html",
+    "Cisco ISR 1100": "https://www.cisco.com/c/en/us/products/routers/1100-series-integrated-services-routers-isr/index.html",
+    "Arista 7050": "https://www.arista.com/en/products/7050x3-series",
+    "Fortinet FortiGate 60F": "https://www.fortinet.com/products/next-generation-firewall/fortigate-60f",
+    "Palo Alto PA-220": "https://www.paloaltonetworks.com/products/secure-the-network/next-generation-firewall/pa-220",
+    "Ubiquiti U6-Pro": "https://store.ui.com/us/en/pro/category/all-wifi/products/u6-pro",
+    "Ubiquiti U6-Enterprise": "https://store.ui.com/us/en/pro/category/all-wifi/products/u6-enterprise",
+    "Ubiquiti USW-Pro-24-PoE": "https://store.ui.com/us/en/pro/category/switching/products/usw-pro-24-poe",
+    "Ubiquiti USW-Enterprise-48-PoE": "https://store.ui.com/us/en/pro/category/switching/products/usw-enterprise-48-poe",
+    "pfSense Netgate 6100": "https://shop.netgate.com/products/6100-base",
+    "Dell PowerEdge R650": "https://www.dell.com/en-us/shop/povw/poweredge-r650",
+}
+
 HARDWARE_PRICING = {
     # Switches
     "Cisco Catalyst 9300": {"price": 8500, "category": "switch", "vendor": "Cisco"},

agent/llm_client.py

@@ -44,6 +44,26 @@ class LLMClient:
             logger.info(f"LLM client initialized with provider: {self.provider}")
         else:
             logger.warning("No LLM API keys found - using mock responses")
+
+    @staticmethod
+    def env_status() -> Dict[str, str]:
+        """
+        Report which keys are present (without exposing values) and chosen provider.
+        Helpful for UI/debug when Secrets are misconfigured.
+        """
+        status = {
+            "openai_key": "present" if (os.getenv("OPENAI_API_KEY") or os.getenv("OPENAI_MCP_1ST_BDAY")) else "missing",
+            "anthropic_key": "present" if (os.getenv("ANTHROPIC_API_KEY") or os.getenv("ANTHROPIC_MCP_1ST_BDAY")) else "missing",
+            "openrouter_key": "present" if os.getenv("OPENROUTER_API_KEY") else "missing",
+            "provider": "unknown",
+        }
+        if status["anthropic_key"] == "present":
+            status["provider"] = "anthropic"
+        elif status["openai_key"] == "present":
+            status["provider"] = "openai"
+        elif status["openrouter_key"] == "present":
+            status["provider"] = "openrouter"
+        return status
     
     def _detect_provider(self) -> Optional[str]:
         """Detect which LLM provider is available"""

agent/pipeline_engine.py

@@ -91,14 +91,20 @@ class BillOfMaterials:
         for item in self.devices:
             lines.append(f"- [{item['quantity']}x] {item['model']} - {item['purpose']}")
             lines.append(f"  Vendor: {item['vendor']} | Est. Cost: ${item['estimated_cost']}")
+            if item.get('link'):
+                lines.append(f"  Link: {item['link']}")
         
         lines.append("\n## Cabling")
         for item in self.cables:
             lines.append(f"- [{item['quantity']}x] {item['type']} ({item['length']})")
+            if 'estimated_cost' in item:
+                lines.append(f"  Est. Cost: ${item['estimated_cost']:.2f}")
         
         lines.append("\n## Accessories")
         for item in self.accessories:
             lines.append(f"- {item['name']} - {item['purpose']}")
+            if 'estimated_cost' in item:
+                lines.append(f"  Est. Cost: ${item['estimated_cost']:.2f}")
         
         lines.append("\n## Software Licenses")
         for item in self.software_licenses:
@@ -470,6 +476,16 @@ class OvergrowthPipeline:
             )
         
         return intent
+
+    def _generate_clarifying_questions(self, intent: NetworkIntent) -> List[str]:
+        """Deterministic clarifying questions for the UI when LLM chat is disabled."""
+        return [
+            "What is the target WAN bandwidth per site (e.g., 200 Mbps, 1 Gbps)?",
+            "Do you need redundant internet links at HQ or any branch?",
+            "Are guest and IoT networks required to be fully isolated from corporate traffic?",
+            "Which vendors are approved for switches/routers/firewalls (Cisco/Arista/Fortinet/Ubiquiti)?",
+            "Do you need WiFi voice roaming or only data for guests/corp?",
+        ]
     
     def stage2_generate_sot(self, intent: NetworkIntent) -> NetworkModel:
         """
@@ -482,7 +498,36 @@ class OvergrowthPipeline:
         import json
         
         llm = LLMClient()
-        
+
+        def _default_design() -> Dict[str, Any]:
+            """Deterministic fallback design with concrete values for offline/demo runs."""
+            return {
+                "vlans": [
+                    {"id": 10, "name": "Management", "subnet": "10.10.10.0/24", "purpose": "Mgmt"},
+                    {"id": 20, "name": "Users", "subnet": "10.20.0.0/22", "purpose": "Corp"},
+                    {"id": 30, "name": "Guest", "subnet": "10.30.0.0/23", "purpose": "Guest WiFi"},
+                    {"id": 40, "name": "IoT", "subnet": "10.40.0.0/23", "purpose": "Cameras/IoT"},
+                ],
+                "subnets": [
+                    {"network": "10.10.10.0/24", "gateway": "10.10.10.1", "vlan": 10, "purpose": "Mgmt"},
+                    {"network": "10.20.0.0/22", "gateway": "10.20.0.1", "vlan": 20, "purpose": "Users"},
+                    {"network": "10.30.0.0/23", "gateway": "10.30.0.1", "vlan": 30, "purpose": "Guest"},
+                    {"network": "10.40.0.0/23", "gateway": "10.40.0.1", "vlan": 40, "purpose": "IoT"},
+                ],
+                "devices": [
+                    {"name": "hq-core-1", "role": "core", "model": "Cisco Catalyst 9300", "vendor": "Cisco", "mgmt_ip": "10.10.10.11", "location": "HQ"},
+                    {"name": "hq-core-2", "role": "core", "model": "Arista 7050", "vendor": "Arista", "mgmt_ip": "10.10.10.12", "location": "HQ"},
+                    {"name": "hq-fw", "role": "firewall", "model": "Fortinet FortiGate 60F", "vendor": "Fortinet", "mgmt_ip": "10.10.10.21", "location": "HQ"},
+                    {"name": "branch1-wan", "role": "edge", "model": "Cisco ISR 1100", "vendor": "Cisco", "mgmt_ip": "10.10.10.31", "location": "Branch1"},
+                    {"name": "branch2-wan", "role": "edge", "model": "Cisco ISR 1100", "vendor": "Cisco", "mgmt_ip": "10.10.10.32", "location": "Branch2"},
+                    {"name": "branch3-wan", "role": "edge", "model": "Cisco ISR 1100", "vendor": "Cisco", "mgmt_ip": "10.10.10.33", "location": "Branch3"},
+                    {"name": "hq-ap-1", "role": "access_point", "model": "Ubiquiti U6-Pro", "vendor": "Ubiquiti", "mgmt_ip": "10.10.10.41", "location": "HQ"},
+                    {"name": "hq-ap-2", "role": "access_point", "model": "Ubiquiti U6-Pro", "vendor": "Ubiquiti", "mgmt_ip": "10.10.10.42", "location": "HQ"},
+                ],
+                "services": ["DHCP", "DNS", "NTP", "Syslog", "RADIUS"],
+                "routing": {"protocol": "ospf", "areas": ["0.0.0.0"], "process_id": 1, "networks": ["10.0.0.0/8"]},
+            }
+
         # Build prompt for network design
         design_prompt = f"""You are an expert network architect. Design a production-ready network based on these requirements:
 
@@ -534,7 +579,7 @@ Be specific and practical. Use RFC1918 addressing. Consider scalability and secu
                 name=f"network_{intent.description[:20].replace(' ', '_')}",
                 version="1.0.0",
                 intent=intent,
-                devices=[],  # Will populate from design
+                devices=[],  # populated below
                 vlans=design.get('vlans', []),
                 subnets=design.get('subnets', []),
                 routing=design.get('routing', {}),
@@ -543,17 +588,62 @@ Be specific and practical. Use RFC1918 addressing. Consider scalability and secu
             
         except Exception as e:
             logger.error(f"LLM design failed: {e}, using template")
-            # Fallback to basic template
+            # Deterministic fallback template with real values
+            design = _default_design()
             model = NetworkModel(
                 name=f"network_{intent.description[:20].replace(' ', '_')}",
                 version="1.0.0",
                 intent=intent,
-                devices=[],
-                vlans=[],
-                subnets=[],
-                routing={},
-                services=["DHCP", "DNS", "NTP"]
+                devices=[],  # populated below
+                vlans=design.get('vlans', []),
+                subnets=design.get('subnets', []),
+                routing=design.get('routing', {}),
+                services=design.get('services', ["DHCP", "DNS", "NTP"])
+            )
+
+        # Ensure we have meaningful design data even if LLM returned partials
+        if not model.vlans or not model.subnets or not design.get("devices"):
+            design = _default_design()
+            model.vlans = design["vlans"]
+            model.subnets = design["subnets"]
+            model.routing = design["routing"]
+            model.services = design["services"]
+
+        # Populate devices from design and backfill mgmt IPs if missing
+        devices: List[Device] = []
+        mgmt_seed = 11
+        for dev in design.get("devices", []):
+            mgmt_ip = dev.get("mgmt_ip") or f"10.10.10.{mgmt_seed}"
+            mgmt_seed += 1
+            devices.append(
+                Device(
+                    name=dev.get("name", f"device-{mgmt_seed}"),
+                    role=dev.get("role", "access"),
+                    model=dev.get("model", "Generic Switch 48-port"),
+                    vendor=dev.get("vendor", "Generic"),
+                    mgmt_ip=mgmt_ip,
+                    location=dev.get("location", "unspecified"),
+                    interfaces=dev.get("interfaces", [])
+                )
             )
+
+        # If no devices came through, fall back again to deterministic set
+        if not devices:
+            fallback = _default_design()["devices"]
+            for dev in fallback:
+                devices.append(
+                    Device(
+                        name=dev["name"],
+                        role=dev["role"],
+                        model=dev["model"],
+                        vendor=dev["vendor"],
+                        mgmt_ip=dev["mgmt_ip"],
+                        location=dev["location"],
+                        interfaces=[]
+                    )
+                )
+
+        model.devices = devices
         
         # Save to file (always, for backup)
         self.sot_file.write_text(model.to_yaml())
@@ -606,10 +696,16 @@ Be specific and practical. Use RFC1918 addressing. Consider scalability and secu
         """
         logger.info("Stage 4: Generating bill of materials")
         
-        from agent.hardware_pricing import estimate_device_cost, estimate_cable_cost, estimate_accessory_cost
+        from agent.hardware_pricing import (
+            estimate_device_cost,
+            estimate_cable_cost,
+            estimate_accessory_cost,
+            PROCUREMENT_LINKS,
+        )
         
         devices = []
         device_total = 0
+        procurement_links = []
         
         # If we have devices in the model, price them
         if model.devices:
@@ -620,9 +716,12 @@ Be specific and practical. Use RFC1918 addressing. Consider scalability and secu
                     'model': device.model,
                     'purpose': f"{device.role} - {device.name}",
                     'vendor': device.vendor,
-                    'estimated_cost': cost
+                    'estimated_cost': cost,
+                    'link': PROCUREMENT_LINKS.get(device.model)
                 })
                 device_total += cost
+                if device.model in PROCUREMENT_LINKS:
+                    procurement_links.append(f"{device.model}: {PROCUREMENT_LINKS[device.model]}")
         else:
             # Estimate based on VLANs/subnets if no devices specified
             num_vlans = len(model.vlans)
@@ -633,9 +732,12 @@ Be specific and practical. Use RFC1918 addressing. Consider scalability and secu
                     'model': 'Ubiquiti USW-Pro-24-PoE',
                     'purpose': 'Core switch',
                     'vendor': 'Ubiquiti',
-                    'estimated_cost': 499
+                    'estimated_cost': 499,
+                    'link': PROCUREMENT_LINKS.get("Ubiquiti USW-Pro-24-PoE")
                 })
                 device_total += 499
+                if "Ubiquiti USW-Pro-24-PoE" in PROCUREMENT_LINKS:
+                    procurement_links.append(f"Ubiquiti USW-Pro-24-PoE: {PROCUREMENT_LINKS['Ubiquiti USW-Pro-24-PoE']}")
                 
                 # Add APs if we have guest/user networks
                 if any('guest' in v.get('name', '').lower() or 'wifi' in v.get('name', '').lower() 
@@ -646,9 +748,12 @@ Be specific and practical. Use RFC1918 addressing. Consider scalability and secu
                         'model': 'Ubiquiti U6-Pro',
                         'purpose': 'Wireless Access Points',
                         'vendor': 'Ubiquiti',
-                        'estimated_cost': ap_cost * 2
+                        'estimated_cost': ap_cost * 2,
+                        'link': PROCUREMENT_LINKS.get("Ubiquiti U6-Pro")
                     })
                     device_total += ap_cost * 2
+                    if "Ubiquiti U6-Pro" in PROCUREMENT_LINKS:
+                        procurement_links.append(f"Ubiquiti U6-Pro: {PROCUREMENT_LINKS['Ubiquiti U6-Pro']}")
         
         # Cables
         cable_total = 0
@@ -657,7 +762,9 @@ Be specific and practical. Use RFC1918 addressing. Consider scalability and secu
             {'type': 'Fiber LC-LC', 'length': '10m', 'quantity': max(2, len(model.devices) // 3)}
         ]
         for cable in cables:
-            cable_total += estimate_cable_cost(cable['type'], cable['quantity'], cable['length'])
+            cost = estimate_cable_cost(cable['type'], cable['quantity'], cable['length'])
+            cable['estimated_cost'] = cost
+            cable_total += cost
         
         # Accessories
         accessory_total = 0
@@ -666,7 +773,9 @@ Be specific and practical. Use RFC1918 addressing. Consider scalability and secu
             {'name': 'Console Cable Kit', 'purpose': 'Initial configuration'}
         ]
         for acc in accessories:
-            accessory_total += estimate_accessory_cost(acc['name'])
+            cost = estimate_accessory_cost(acc['name'])
+            acc['estimated_cost'] = cost
+            accessory_total += cost
         
         total_cost = device_total + cable_total + accessory_total
         
@@ -677,7 +786,7 @@ Be specific and practical. Use RFC1918 addressing. Consider scalability and secu
             accessories=accessories,
             software_licenses=[],
             total_estimated_cost=total_cost,
-            procurement_links=[]
+            procurement_links=procurement_links
         )
         
         # Save BOM
@@ -1011,6 +1120,7 @@ Be specific and practical. Use RFC1918 addressing. Consider scalability and secu
         # Stage 1: Consultation
         intent = self.stage1_consultation(consultation_input)
         results['intent'] = asdict(intent)
+        results['questions'] = self._generate_clarifying_questions(intent)
         
         # Stage 2: Source of Truth
         model = self.stage2_generate_sot(intent)
@@ -1032,6 +1142,7 @@ Be specific and practical. Use RFC1918 addressing. Consider scalability and secu
             
             bom = self.stage4_generate_bom(model)
             results['bom'] = asdict(bom)
+            results['shopping_list'] = bom.to_shopping_list()
             
             return results
         

app.py

@@ -217,7 +217,7 @@ def build_ui():
         with gr.Row(elem_classes=["og-main-row"]):
             with gr.Column(scale=1, elem_classes=["og-panel"]):
                 gr.Markdown("### 📊 Session Statistics")
-                api_stats = gr.Markdown(value=monitor.get_stats().format_dashboard())
+                api_stats = gr.Markdown(value=monitor.get_stats().format_dashboard(include_heading=False))
                 refresh_stats_btn = gr.Button("🔄 Refresh Stats", size="sm", variant="secondary")
             
             with gr.Column(scale=2, elem_classes=["og-panel"]):
@@ -227,7 +227,7 @@ def build_ui():
         
         # Auto-refresh handlers
         def refresh_api_stats():
-            return monitor.get_stats().format_dashboard()
+            return monitor.get_stats().format_dashboard(include_heading=False)
         
         def refresh_api_activity():
             return monitor.format_activity_feed()
@@ -301,10 +301,14 @@ def build_ui():
         def run_pipeline(user_input):
             """Execute the full automation pipeline"""
             from agent.pipeline_engine import OvergrowthPipeline
+            from agent.llm_client import LLMClient
             
             pipeline = OvergrowthPipeline()
             
             try:
+                # Report LLM env status up-front so users see if keys are missing
+                llm_env = LLMClient.env_status()
+                
                 # Run the pipeline (this will generate API calls that get tracked)
                 results = pipeline.run_full_pipeline(user_input)
                 
@@ -322,6 +326,32 @@ def build_ui():
                 status += f"- **LLM Calls:** {stats.llm_calls} | **GNS3 Calls:** {stats.gns3_calls}\n"
                 status += f"- **Tokens:** {stats.total_tokens:,} ({stats.total_input_tokens:,} in / {stats.total_output_tokens:,} out)\n\n"
                 
+                # LLM connectivity
+                status += "### 🤖 LLM Connectivity\n"
+                status += f"- Provider selected: **{llm_env.get('provider', 'unknown')}**\n"
+                status += f"- Anthropic key: {llm_env.get('anthropic_key')}\n"
+                status += f"- OpenAI key: {llm_env.get('openai_key')}\n"
+                status += f"- OpenRouter key: {llm_env.get('openrouter_key')}\n\n"
+                
+                # Budget visibility
+                if stats.budget_limit not in (None, 0):
+                    remaining = stats.budget_remaining()
+                    status += f"- **Budget:** ${stats.budget_limit:.2f} (remaining ${remaining:.2f})\n"
+                    budget_note = stats.budget_status()
+                    if stats.budget_alert_triggered or (stats.budget_usage_ratio() or 0) >= stats.budget_alert_fraction:
+                        status += f"> 🚨 {budget_note}\n\n"
+                    else:
+                        status += f"  - {budget_note}\n\n"
+
+                # Lab simulation link (GNS3)
+                gns3_base = os.getenv("GNS3_SERVER")
+                gns3_project = os.getenv("GNS3_PROJECT_NAME", "overgrowth")
+                if gns3_base:
+                    status += "### 🧪 Lab Simulation\n"
+                    status += f"- GNS3 API: {gns3_base}\n"
+                    status += f"- Project: `{gns3_project}`\n"
+                    status += f"- Web UI: {gns3_base.rstrip('/')}/static/webUi\n\n"
+                
                 # Pre-flight validation section
                 if ready_to_deploy:
                     status += "### ✅ Pre-flight Validation PASSED\n"
@@ -366,6 +396,12 @@ def build_ui():
                 status += "- `infra/network_model.yaml` - Source of Truth\n"
                 status += "- `infra/bill_of_materials.json` - BOM data\n"
                 status += "- `infra/setup_guide.md` - Deployment guide\n"
+
+                questions = results.get('questions', [])
+                if questions:
+                    status += "\n### ❓ Clarifying Questions\n"
+                    for q in questions:
+                        status += f"- {q}\n"
                 
                 # Extract outputs
                 sot_yaml = results.get('model', {})
@@ -377,7 +413,7 @@ def build_ui():
                 diagram = results.get('diagrams', {}).get('ascii', 'No diagram available')
                 
                 # Also return updated API stats and activity
-                updated_stats = monitor.get_stats().format_dashboard()
+                updated_stats = monitor.get_stats().format_dashboard(include_heading=False)
                 updated_activity = monitor.format_activity_feed()
                 
                 return status, sot_str, bom_md, setup_md, diagram, updated_stats, updated_activity
@@ -388,7 +424,7 @@ def build_ui():
                 error += f"\n\n```\n{traceback.format_exc()}\n```"
                 
                 # Still update API stats even on error
-                updated_stats = monitor.get_stats().format_dashboard()
+                updated_stats = monitor.get_stats().format_dashboard(include_heading=False)
                 updated_activity = monitor.format_activity_feed()
                 
                 return error, "", "", "", "", updated_stats, updated_activity

tests/test_api_monitor.py

@@ -0,0 +1,32 @@
+"""Basic coverage for API monitor bookkeeping and budget alerts."""
+
+from agent.api_monitor import monitor
+
+
+def test_api_monitor_tracks_calls_and_budget_alerts():
+    original_limit = monitor.stats.budget_limit
+    original_fraction = monitor.stats.budget_alert_fraction
+
+    monitor.reset()
+    monitor.stats.budget_limit = 0.02  # force a low budget for alerting
+    monitor.stats.budget_alert_fraction = 0.5
+
+    call_id = "test-call"
+    monitor.start_call(call_id, "llm", "openai", "gpt-4o")
+    monitor.complete_call(call_id, success=True, input_tokens=1000, output_tokens=2000)
+
+    stats = monitor.get_stats()
+    assert stats.total_calls == 1
+    assert stats.llm_calls == 1
+    assert stats.total_tokens == 3000
+    assert stats.total_cost > 0
+    assert stats.budget_alert_triggered is True
+    assert "Budget" in stats.budget_status()
+
+    feed = monitor.format_activity_feed()
+    assert "Budget alert" in feed
+
+    # Restore original budget settings for other tests/runs
+    monitor.stats.budget_limit = original_limit
+    monitor.stats.budget_alert_fraction = original_fraction
+    monitor.reset()