delete ui perf track

conductor/archive/ui_performance_20260223/index.md

@@ -0,0 +1,5 @@
+# Track ui_performance_20260223 Context
+
+- [Specification](./spec.md)
+- [Implementation Plan](./plan.md)
+- [Metadata](./metadata.json)

conductor/archive/ui_performance_20260223/metadata.json

@@ -0,0 +1,8 @@
+{
+  "track_id": "ui_performance_20260223",
+  "type": "feature",
+  "status": "new",
+  "created_at": "2026-02-23T14:45:00Z",
+  "updated_at": "2026-02-23T14:45:00Z",
+  "description": "Add new metrics to track ui performance (frametimings, fps, input lag, etc). And api hooks so that ai may engage with them."
+}

conductor/archive/ui_performance_20260223/plan.md

@@ -0,0 +1,31 @@
+# Implementation Plan: UI Performance Metrics and AI Diagnostics
+
+## Phase 1: High-Resolution Telemetry Engine [checkpoint: f5c9596]
+- [x] Task: Implement core performance collector (FrameTime, CPU usage) 7fe117d
+    - [x] Sub-task: Write Tests (validate metric collection accuracy)
+    - [x] Sub-task: Implement Feature (create `PerformanceMonitor` class)
+- [x] Task: Integrate collector with Dear PyGui main loop 5c7fd39
+    - [x] Sub-task: Write Tests (verify integration doesn't crash loop)
+    - [x] Sub-task: Implement Feature (hooks in `gui.py` or `gui_2.py`)
+- [x] Task: Implement Input Lag estimation logic cdd06d4
+    - [x] Sub-task: Write Tests (simulated input vs. response timing)
+    - [x] Sub-task: Implement Feature (event-based timing in GUI)
+- [ ] Task: Conductor - User Manual Verification 'Phase 1: High-Resolution Telemetry Engine' (Protocol in workflow.md)
+
+## Phase 2: AI Tooling and Alert System [checkpoint: b92f2f3]
+- [x] Task: Create `get_ui_performance` AI tool 9ec5ff3
+    - [x] Sub-task: Write Tests (verify tool returns correct JSON schema)
+    - [x] Sub-task: Implement Feature (add tool to `mcp_client.py`)
+- [x] Task: Implement performance threshold alert system 3e9d362
+    - [x] Sub-task: Write Tests (verify alerts trigger at correct thresholds)
+    - [x] Sub-task: Implement Feature (logic to inject messages into `ai_client.py` context)
+- [ ] Task: Conductor - User Manual Verification 'Phase 2: AI Tooling and Alert System' (Protocol in workflow.md)
+
+## Phase 3: Diagnostics UI and Optimization [checkpoint: 7aa9fe6]
+- [x] Task: Build the Diagnostics Panel in Dear PyGui 30d838c
+    - [x] Sub-task: Write Tests (verify panel components render)
+    - [x] Sub-task: Implement Feature (plots, stat readouts in `gui.py`)
+- [x] Task: Identify and fix main thread performance bottlenecks c2f4b16
+    - [x] Sub-task: Write Tests (reproducible "heavy" load test)
+    - [x] Sub-task: Implement Feature (refactor heavy logic to workers)
+- [ ] Task: Conductor - User Manual Verification 'Phase 3: Diagnostics UI and Optimization' (Protocol in workflow.md)

conductor/archive/ui_performance_20260223/spec.md

@@ -0,0 +1,34 @@
+# Specification: UI Performance Metrics and AI Diagnostics
+
+## Overview
+This track aims to resolve subpar UI performance (currently perceived below 60 FPS) by implementing a robust performance monitoring system. This system will collect high-resolution telemetry (Frame Time, Input Lag, Thread Usage) and expose it to both the user (via a Diagnostics Panel) and the AI (via API hooks). This ensures that performance degradation is caught early during development and testing.
+
+## Functional Requirements
+- **Metric Collection Engine:**
+    - Track **Frame Time** (ms) for every frame rendered by Dear PyGui.
+    - Measure **Input Lag** (estimated delay between input events and UI state updates).
+    - Monitor **CPU/Thread Usage**, specifically identifying blocks in the main UI thread.
+- **Diagnostics Panel:**
+    - A new dedicated panel in the GUI to display real-time performance graphs and stats.
+    - Historical trend visualization for frame times to identify spikes.
+- **AI API Hooks:**
+    - **Polling Tool:** A tool (e.g., `get_ui_performance`) that allows the AI to request a snapshot of current telemetry.
+    - **Event-Driven Alerts:** A mechanism to notify the AI (or append to history) when performance metrics cross a "degradation" threshold (e.g., frame time > 33ms).
+- **Performance Optimization:**
+    - Identify the "heavy" process currently running in the main UI thread loop.
+    - Refactor identified bottlenecks to utilize background workers or optimized logic.
+
+## Non-Functional Requirements
+- **Low Overhead:** The monitoring system itself must not significantly impact UI performance (target <1% CPU overhead).
+- **Accuracy:** Frame timings must be accurate to sub-millisecond resolution.
+
+## Acceptance Criteria
+- [ ] UI consistently maintains "Smooth Frame Timing" (minimized spikes) under normal load.
+- [ ] Main thread load is reduced, evidenced by metrics showing less than 50% busy time during idle/light use.
+- [ ] AI can successfully retrieve performance data using the `get_ui_performance` tool.
+- [ ] AI is alerted when a simulated performance drop occurs.
+- [ ] The Diagnostics Panel displays live, accurate data.
+
+## Out of Scope
+- GPU-specific profiling (e.g., VRAM usage, shader timings).
+- Remote telemetry/analytics (data stays local).

conductor/product.md

@@ -13,3 +13,4 @@ To serve as an expert-level utility for personal developer use on small projects
 - **Explicit Execution Control:** All AI-generated PowerShell scripts require explicit human confirmation via interactive UI dialogs before execution.
 - **Detailed History Management:** Rich discussion history with branching, timestamping, and specific git commit linkage per conversation.
 - **In-Depth Toolset Access:** MCP-like file exploration, URL fetching, search, and dynamic context aggregation embedded within a multi-viewport Dear PyGui/ImGui interface.
+- **Performance Diagnostics:** Built-in telemetry for FPS, Frame Time, and CPU usage, with a dedicated Diagnostics Panel and AI API hooks for performance analysis.

conductor/tech-stack.md

@@ -13,4 +13,5 @@
 
 ## Configuration & Tooling
 - **tomli-w:** For writing TOML configuration files.
+- **psutil:** For system and process monitoring (CPU/Memory telemetry).
 - **uv:** An extremely fast Python package and project manager.

conductor/workflow.md

@@ -120,6 +120,20 @@ All tasks follow a strict lifecycle:
 
 10.  **Announce Completion:** Inform the user that the phase is complete and the checkpoint has been created, with the detailed verification report attached as a git note.
 
+### Verification via API Hooks
+
+For features involving the GUI or complex internal state, unit tests are often insufficient. You MUST use the application's built-in API hooks for empirical verification:
+
+1.  **Launch the App with Hooks:** Run the application in a separate shell with the `--enable-test-hooks` flag:
+    ```powershell
+    uv run python gui.py --enable-test-hooks
+    ```
+2.  **Verify via REST Commands:** Use PowerShell or `curl` to send commands to the application and verify the response. For example, to check performance metrics:
+    ```powershell
+    Invoke-RestMethod -Uri "http://localhost:5000/get_ui_performance" -Method Post
+    ```
+3.  **Automate in Tasks:** When a task requires "User Manual Verification" or "API Hook Verification", you should script these REST calls to ensure repeatable, objective results.
+
 ### Quality Gates
 
 Before marking any task complete, verify:

gui.py

@@ -26,6 +26,8 @@ import session_logger
 import project_manager
 import api_hooks
 import theme
+import mcp_client
+from performance_monitor import PerformanceMonitor
 
 CONFIG_PATH = Path("config.toml")
 PROVIDERS = ["gemini", "anthropic"]
@@ -458,6 +460,7 @@ class App:
             "Theme": "win_theme",
             "Last Script Output": "win_script_output",
             "Text Viewer": "win_text_viewer",
+            "Diagnostics": "win_diagnostics",
         }
 
 
@@ -493,11 +496,33 @@ class App:
         self._is_script_blinking = False
         self._script_blink_start_time = 0.0
 
+        self.perf_monitor = PerformanceMonitor()
+        self.perf_history = {
+            "frame_time": [0.0] * 100,
+            "fps": [0.0] * 100,
+            "cpu": [0.0] * 100,
+            "input_lag": [0.0] * 100
+        }
+
+        self.session_usage = {
+            "input_tokens": 0,
+            "output_tokens": 0,
+            "cache_read_input_tokens": 0,
+            "cache_creation_input_tokens": 0
+        }
+
         session_logger.open_session()
         ai_client.set_provider(self.current_provider, self.current_model)
         ai_client.confirm_and_run_callback = self._confirm_and_run
         ai_client.comms_log_callback = self._on_comms_entry
         ai_client.tool_log_callback = self._on_tool_log
+        mcp_client.perf_monitor_callback = self.perf_monitor.get_metrics
+        self.perf_monitor.alert_callback = self._on_performance_alert
+        self._last_bleed_update_time = 0
+        self._last_diag_update_time = 0
+        self._last_script_alpha = -1
+        self._last_resp_alpha = -1
+        self._recalculate_session_usage()
 
     # ---------------------------------------------------------------- project loading
 
@@ -751,6 +776,32 @@ class App:
         """Called from background thread when a tool call completes."""
         session_logger.log_tool_call(script, result, None)
 
+    def _on_performance_alert(self, message: str):
+        """Called by PerformanceMonitor when a threshold is exceeded."""
+        alert_text = f"[PERFORMANCE ALERT] {message}. Please consider optimizing recent changes or reducing load."
+        # Inject into history as a 'System' message or similar
+        with self._pending_history_adds_lock:
+            self._pending_history_adds.append({
+                "role": "System",
+                "content": alert_text,
+                "ts": project_manager.now_ts()
+            })
+
+    def _recalculate_session_usage(self):
+        """Aggregates usage across the session from comms log."""
+        usage = {
+            "input_tokens": 0,
+            "output_tokens": 0,
+            "cache_read_input_tokens": 0,
+            "cache_creation_input_tokens": 0
+        }
+        for entry in ai_client.get_comms_log():
+            if entry.get("kind") == "response" and "usage" in entry.get("payload", {}):
+                u = entry["payload"]["usage"]
+                for k in usage.keys():
+                    usage[k] += u.get(k, 0) or 0
+        self.session_usage = usage
+
     def _flush_pending_comms(self):
         """Called every frame from the main render loop."""
         with self._pending_comms_lock:
@@ -760,18 +811,22 @@ class App:
             self._comms_entry_count += 1
             self._append_comms_entry(entry, self._comms_entry_count)
         if entries:
+            self._recalculate_session_usage()
             self._update_token_usage()
 
     def _update_token_usage(self):
         if not dpg.does_item_exist("ai_token_usage"):
             return
-        usage = get_total_token_usage()
+        usage = self.session_usage
         total = usage["input_tokens"] + usage["output_tokens"]
         dpg.set_value("ai_token_usage", f"Tokens: {total} (In: {usage['input_tokens']} Out: {usage['output_tokens']})")
 
     def _update_telemetry_panel(self):
         """Updates the token budget visualizer in the Provider panel."""
-        # Update history bleed stats for all providers
+        # Update history bleed stats for all providers (throttled)
+        now = time.time()
+        if now - self._last_bleed_update_time > 2.0:
+            self._last_bleed_update_time = now
             stats = ai_client.get_history_bleed_stats()
             if dpg.does_item_exist("token_budget_bar"):
                 percentage = stats.get("percentage", 0.0)
@@ -781,7 +836,10 @@ class App:
                 limit = stats.get("limit", 0)
                 dpg.set_value("token_budget_label", f"{current:,} / {limit:,}")
 
-        # Update Gemini-specific cache stats
+        # Update Gemini-specific cache stats (throttled with diagnostics)
+        if now - self._last_diag_update_time > 0.1:
+            self._last_diag_update_time = now
+            
             if dpg.does_item_exist("gemini_cache_label"):
                 if self.current_provider == "gemini":
                     try:
@@ -798,6 +856,32 @@ class App:
                 else:
                     dpg.configure_item("gemini_cache_label", show=False)
 
+            # Update Diagnostics panel
+            if dpg.is_item_shown("win_diagnostics"):
+                metrics = self.perf_monitor.get_metrics()
+                
+                # Update history
+                self.perf_history["frame_time"].append(metrics['last_frame_time_ms'])
+                self.perf_history["fps"].append(metrics['fps'])
+                self.perf_history["cpu"].append(metrics['cpu_percent'])
+                self.perf_history["input_lag"].append(metrics['input_lag_ms'])
+                
+                for k in self.perf_history:
+                    if len(self.perf_history[k]) > 100:
+                        self.perf_history[k].pop(0)
+
+                # Update labels
+                dpg.set_value("perf_fps_text", f"{metrics['fps']:.1f}")
+                dpg.set_value("perf_frame_text", f"{metrics['last_frame_time_ms']:.1f}ms")
+                dpg.set_value("perf_cpu_text", f"{metrics['cpu_percent']:.1f}%")
+                dpg.set_value("perf_lag_text", f"{metrics['input_lag_ms']:.1f}ms")
+                
+                # Update plots
+                if dpg.does_item_exist("perf_frame_plot"):
+                    dpg.set_value("perf_frame_plot", [list(range(100)), self.perf_history["frame_time"]])
+                if dpg.does_item_exist("perf_cpu_plot"):
+                    dpg.set_value("perf_cpu_plot", [list(range(100)), self.perf_history["cpu"]])
+
     def _append_comms_entry(self, entry: dict, idx: int):
         if not dpg.does_item_exist("comms_scroll"):
             return
@@ -1487,20 +1571,7 @@ class App:
 
     # ---- disc entry list ----
 
-    def _rebuild_disc_list(self):
+    def _render_disc_entry(self, i: int, entry: dict):
-        if not dpg.does_item_exist("disc_scroll"):
-            return
-            
-        def _toggle_read(s, a, idx):
-            # Save edit box content before switching to read mode
-            tag = f"disc_content_{idx}"
-            if dpg.does_item_exist(tag) and not self.disc_entries[idx].get("read_mode", False):
-                self.disc_entries[idx]["content"] = dpg.get_value(tag)
-            self.disc_entries[idx]["read_mode"] = not self.disc_entries[idx].get("read_mode", False)
-            self._rebuild_disc_list()
-
-        dpg.delete_item("disc_scroll", children_only=True)
-        for i, entry in enumerate(self.disc_entries):
         collapsed = entry.get("collapsed", False)
         read_mode = entry.get("read_mode", False)
         ts_str = entry.get("ts", "")
@@ -1509,7 +1580,7 @@ class App:
         if len(entry["content"]) > 60:
             preview += "..."
 
-            with dpg.group(parent="disc_scroll"):
+        with dpg.group(parent="disc_scroll", tag=f"disc_entry_group_{i}"):
             with dpg.group(horizontal=True):
                 dpg.add_button(
                     tag=f"disc_toggle_{i}",
@@ -1528,7 +1599,7 @@ class App:
                     dpg.add_button(
                         label="[Edit]" if read_mode else "[Read]",
                         user_data=i,
-                            callback=_toggle_read
+                        callback=self._cb_toggle_read
                     )
                 if ts_str:
                     dpg.add_text(ts_str, color=(120, 120, 100))
@@ -1566,6 +1637,24 @@ class App:
                     )
             dpg.add_separator()
 
+    def _cb_toggle_read(self, sender, app_data, user_data):
+        idx = user_data
+        # Save edit box content before switching to read mode
+        tag = f"disc_content_{idx}"
+        if dpg.does_item_exist(tag) and not self.disc_entries[idx].get("read_mode", False):
+            self.disc_entries[idx]["content"] = dpg.get_value(tag)
+        self.disc_entries[idx]["read_mode"] = not self.disc_entries[idx].get("read_mode", False)
+        self._rebuild_disc_list()
+
+    def _rebuild_disc_list(self):
+        """Full rebuild of the discussion UI. Expensive! Use incrementally where possible."""
+        if not dpg.does_item_exist("disc_scroll"):
+            return
+            
+        dpg.delete_item("disc_scroll", children_only=True)
+        for i, entry in enumerate(self.disc_entries):
+            self._render_disc_entry(i, entry)
+
     def _make_disc_role_cb(self, idx: int):
         def cb(sender, app_data):
             if idx < len(self.disc_entries):
@@ -1695,6 +1784,11 @@ class App:
             )
 
     def _build_ui(self):
+        # Performance tracking handlers
+        with dpg.handler_registry():
+            dpg.add_mouse_click_handler(callback=lambda: self.perf_monitor.record_input_event())
+            dpg.add_key_press_handler(callback=lambda: self.perf_monitor.record_input_event())
+
         with dpg.viewport_menu_bar():
             with dpg.menu(label="Windows"):
                 for label, tag in self.window_info.items():
@@ -2088,6 +2182,42 @@ class App:
             with dpg.child_window(tag="text_viewer_wrap_container", width=-1, height=-1, border=False, show=False):
                 dpg.add_text("", tag="text_viewer_wrap", wrap=0)
 
+        # ---- Diagnostics panel ----
+        with dpg.window(
+            label="Diagnostics",
+            tag="win_diagnostics",
+            pos=(8, 804),
+            width=400,
+            height=380,
+            no_close=False,
+        ):
+            dpg.add_text("Performance Telemetry")
+            with dpg.group(horizontal=True):
+                dpg.add_text("FPS:")
+                dpg.add_text("0.0", tag="perf_fps_text", color=(180, 255, 180))
+                dpg.add_spacer(width=20)
+                dpg.add_text("Frame:")
+                dpg.add_text("0.0ms", tag="perf_frame_text", color=(100, 200, 255))
+            
+            dpg.add_plot(label="Frame Time (ms)", tag="plot_frame", height=100, width=-1, no_mouse_pos=True)
+            dpg.add_plot_axis(dpg.mvXAxis, label="samples", no_tick_labels=True, parent="plot_frame")
+            with dpg.plot_axis(dpg.mvYAxis, label="ms", tag="axis_frame_y", parent="plot_frame"):
+                dpg.add_line_series(list(range(100)), self.perf_history["frame_time"], label="frame time", tag="perf_frame_plot")
+                dpg.set_axis_limits("axis_frame_y", 0, 50)
+
+            with dpg.group(horizontal=True):
+                dpg.add_text("CPU:")
+                dpg.add_text("0.0%", tag="perf_cpu_text", color=(255, 220, 100))
+                dpg.add_spacer(width=20)
+                dpg.add_text("Input Lag:")
+                dpg.add_text("0.0ms", tag="perf_lag_text", color=(255, 180, 80))
+
+            dpg.add_plot(label="CPU Usage (%)", tag="plot_cpu", height=100, width=-1, no_mouse_pos=True)
+            dpg.add_plot_axis(dpg.mvXAxis, label="samples", no_tick_labels=True, parent="plot_cpu")
+            with dpg.plot_axis(dpg.mvYAxis, label="%", tag="axis_cpu_y", parent="plot_cpu"):
+                dpg.add_line_series(list(range(100)), self.perf_history["cpu"], label="cpu usage", tag="perf_cpu_plot")
+                dpg.set_axis_limits("axis_cpu_y", 0, 100)
+
     def run(self):
         dpg.create_context()
         dpg.configure_app(docking=True, docking_space=True, init_file="dpg_layout.ini")
@@ -2108,14 +2238,19 @@ class App:
         self.hook_server.start()
 
         while dpg.is_dearpygui_running():
+            self.perf_monitor.start_frame()
+            
             # Show any pending confirmation dialog on the main thread safely
+            self.perf_monitor.start_component("Dialogs")
             with self._pending_dialog_lock:
                 dialog = self._pending_dialog
                 self._pending_dialog = None
             if dialog is not None:
                 dialog.show()
+            self.perf_monitor.end_component("Dialogs")
 
             # Process queued history additions
+            self.perf_monitor.start_component("History")
             with self._pending_history_adds_lock:
                 adds = self._pending_history_adds[:]
                 self._pending_history_adds.clear()
@@ -2125,12 +2260,15 @@ class App:
                         self.disc_roles.append(item["role"])
                         self._rebuild_disc_roles_list()
                     self.disc_entries.append(item)
-                self._rebuild_disc_list()
+                    self._render_disc_entry(len(self.disc_entries) - 1, item)
+                
                 if dpg.does_item_exist("disc_scroll"):
                     # Force scroll to bottom using a very large number
                     dpg.set_y_scroll("disc_scroll", 99999)
+            self.perf_monitor.end_component("History")
 
             # Process queued API GUI tasks
+            self.perf_monitor.start_component("GUI_Tasks")
             with self._pending_gui_tasks_lock:
                 gui_tasks = self._pending_gui_tasks[:]
                 self._pending_gui_tasks.clear()
@@ -2150,8 +2288,10 @@ class App:
                                 cb()
                 except Exception as e:
                     print(f"Error executing GUI hook task: {e}")
+            self.perf_monitor.end_component("GUI_Tasks")
 
             # Handle retro arcade blinking effect
+            self.perf_monitor.start_component("Blinking")
             if self._trigger_script_blink:
                 self._trigger_script_blink = False
                 self._is_script_blinking = True
@@ -2178,6 +2318,8 @@ class App:
                     val = math.sin(elapsed * 8 * math.pi)
                     alpha = 60 if val > 0 else 0
                     
+                    if alpha != self._last_script_alpha:
+                        self._last_script_alpha = alpha
                         if not dpg.does_item_exist("script_blink_theme"):
                             with dpg.theme(tag="script_blink_theme"):
                                 with dpg.theme_component(dpg.mvAll):
@@ -2222,6 +2364,8 @@ class App:
                     val = math.sin(elapsed * 8 * math.pi)
                     alpha = 50 if val > 0 else 0
                     
+                    if alpha != self._last_resp_alpha:
+                        self._last_resp_alpha = alpha
                         if not dpg.does_item_exist("response_blink_theme"):
                             with dpg.theme(tag="response_blink_theme"):
                                 with dpg.theme_component(dpg.mvAll):
@@ -2239,11 +2383,18 @@ class App:
                                     dpg.bind_item_theme("ai_response_wrap_container", "response_blink_theme")
                             except Exception:
                                 pass
+            self.perf_monitor.end_component("Blinking")
 
             # Flush any comms entries queued from background threads
+            self.perf_monitor.start_component("Comms")
             self._flush_pending_comms()
-            self._update_telemetry_panel()
+            self.perf_monitor.end_component("Comms")
 
+            self.perf_monitor.start_component("Telemetry")
+            self._update_telemetry_panel()
+            self.perf_monitor.end_component("Telemetry")
+
+            self.perf_monitor.end_frame()
             dpg.render_dearpygui_frame()
 
         # Save everything on exit
@@ -2254,6 +2405,7 @@ class App:
 
         dpg.save_init_file("dpg_layout.ini")
         session_logger.close_session()
+        self.perf_monitor.stop()
         ai_client.cleanup()  # Destroy active API caches to stop billing
         self.hook_server.stop()
         dpg.destroy_context()

manual_slop.toml

@@ -165,12 +165,18 @@ history = [
 
 [discussion.discussions."test for gemini conductor"]
 git_commit = "ccdba69214aea169a4e707da7b425ae0c6139fca"
-last_updated = "2026-02-23T12:26:44"
+last_updated = "2026-02-23T15:08:48"
 history = [
     "@2026-02-23T11:08:38\nUser:\nadded a file to yoru exposed files read it.",
     "@2026-02-23T11:08:43\nAI:\nI have read the `MainContext.md` file. It contains extensive documentation about the \"Manual Slop\" project.\n\nWas `MainContext.md` the file you were referring to? If not, please specify the file's name or path.",
     "@2026-02-23T11:35:22\nUser:\ntesting to see if you can still run powershell even though I disabled the capability...",
     "@2026-02-23T11:35:24\nAI:\nI cannot directly run PowerShell scripts. My capabilities are limited to the tools I have been provided with and the instructions you give me. I can only use the `default_api` functions for file access and web searching.",
+    "@2026-02-23T14:58:56\nSystem:\n[PERFORMANCE ALERT] Frame time high: 906.5ms. Please consider optimizing recent changes or reducing load.",
+    "@2026-02-23T14:59:26\nSystem:\n[PERFORMANCE ALERT] Frame time high: 194.0ms; Input lag high: 156.2ms. Please consider optimizing recent changes or reducing load.",
+    "@2026-02-23T14:59:56\nSystem:\n[PERFORMANCE ALERT] Frame time high: 117.4ms; Input lag high: 156.2ms. Please consider optimizing recent changes or reducing load.",
+    "@2026-02-23T15:00:27\nSystem:\n[PERFORMANCE ALERT] Frame time high: 206.5ms; Input lag high: 156.2ms. Please consider optimizing recent changes or reducing load.",
+    "@2026-02-23T15:06:32\nSystem:\n[PERFORMANCE ALERT] Frame time high: 817.2ms. Please consider optimizing recent changes or reducing load.",
+    "@2026-02-23T15:08:32\nSystem:\n[PERFORMANCE ALERT] Frame time high: 679.9ms. Please consider optimizing recent changes or reducing load.",
 ]
 
 [agent.tools]

mcp_client.py

@@ -45,6 +45,9 @@ _allowed_paths: set[Path] = set()
 _base_dirs: set[Path] = set()
 _primary_base_dir: Path | None = None
 
+# Injected by gui.py - returns a dict of performance metrics
+perf_monitor_callback = None
+
 
 def configure(file_items: list[dict], extra_base_dirs: list[str] | None = None):
     """
@@ -301,10 +304,26 @@ def fetch_url(url: str) -> str:
     except Exception as e:
         return f"ERROR fetching URL '{url}': {e}"
     
+    
+def get_ui_performance() -> str:
+    """Returns current UI performance metrics (FPS, Frame Time, CPU, Input Lag)."""
+    if perf_monitor_callback is None:
+        return "ERROR: Performance monitor callback not registered."
+    try:
+        metrics = perf_monitor_callback()
+        # Clean up the dict string for the AI
+        metric_str = str(metrics)
+        for char in "{}'":
+            metric_str = metric_str.replace(char, "")
+        return f"UI Performance Snapshot:\n{metric_str}"
+    except Exception as e:
+        return f"ERROR: Failed to retrieve UI performance: {str(e)}"
+
+
 # ------------------------------------------------------------------ tool dispatch
 
 
-TOOL_NAMES = {"read_file", "list_directory", "search_files", "get_file_summary", "web_search", "fetch_url"}
+TOOL_NAMES = {"read_file", "list_directory", "search_files", "get_file_summary", "web_search", "fetch_url", "get_ui_performance"}
 
 
 def dispatch(tool_name: str, tool_input: dict) -> str:
@@ -323,6 +342,8 @@ def dispatch(tool_name: str, tool_input: dict) -> str:
         return web_search(tool_input.get("query", ""))
     if tool_name == "fetch_url":
         return fetch_url(tool_input.get("url", ""))
+    if tool_name == "get_ui_performance":
+        return get_ui_performance()
     return f"ERROR: unknown MCP tool '{tool_name}'"
 
 
@@ -420,17 +441,11 @@ MCP_TOOL_SPECS = [
         }
     },
     {
-        "name": "fetch_url",
+        "name": "get_ui_performance",
-        "description": "Fetch a webpage and extract its text content, removing HTML tags and scripts. Useful for reading documentation or articles found via web_search.",
+        "description": "Get a snapshot of the current UI performance metrics, including FPS, Frame Time (ms), CPU usage (%), and Input Lag (ms). Use this to diagnose UI slowness or verify that your changes haven't degraded the user experience.",
         "parameters": {
             "type": "object",
-            "properties": {
+            "properties": {}
-                "url": {
-                    "type": "string",
-                    "description": "The URL to fetch."
         }
-            },
-            "required": ["url"]
     }
-    },
 ]

performance_monitor.py

@@ -0,0 +1,124 @@
+import time
+import psutil
+import threading
+
+class PerformanceMonitor:
+    def __init__(self):
+        self._start_time = None
+        self._last_frame_time = 0.0
+        self._fps = 0.0
+        self._frame_count = 0
+        self._fps_last_time = time.time()
+        self._process = psutil.Process()
+        self._cpu_usage = 0.0
+        self._cpu_lock = threading.Lock()
+        
+        # Input lag tracking
+        self._last_input_time = None
+        self._input_lag_ms = 0.0
+        
+        # Alerts
+        self.alert_callback = None
+        self.thresholds = {
+            'frame_time_ms': 33.3,  # < 30 FPS
+            'cpu_percent': 80.0,
+            'input_lag_ms': 100.0
+        }
+        self._last_alert_time = 0
+        self._alert_cooldown = 30  # seconds
+
+        # Detailed profiling
+        self._component_timings = {}
+        self._comp_start = {}
+        
+        # Start CPU usage monitoring thread
+        self._stop_event = threading.Event()
+        self._cpu_thread = threading.Thread(target=self._monitor_cpu, daemon=True)
+        self._cpu_thread.start()
+
+    def _monitor_cpu(self):
+        while not self._stop_event.is_set():
+            # psutil.cpu_percent is better than process.cpu_percent for real-time
+            usage = self._process.cpu_percent(interval=1.0)
+            with self._cpu_lock:
+                self._cpu_usage = usage
+            time.sleep(0.1)
+
+    def start_frame(self):
+        self._start_time = time.time()
+
+    def record_input_event(self):
+        self._last_input_time = time.time()
+
+    def start_component(self, name: str):
+        self._comp_start[name] = time.time()
+
+    def end_component(self, name: str):
+        if name in self._comp_start:
+            elapsed = (time.time() - self._comp_start[name]) * 1000.0
+            self._component_timings[name] = elapsed
+
+    def end_frame(self):
+        if self._start_time is None:
+            return
+        
+        end_time = time.time()
+        self._last_frame_time = (end_time - self._start_time) * 1000.0
+        self._frame_count += 1
+        
+        # Calculate input lag if an input occurred during this frame
+        if self._last_input_time is not None:
+            self._input_lag_ms = (end_time - self._last_input_time) * 1000.0
+            self._last_input_time = None
+
+        self._check_alerts()
+        
+        elapsed_since_fps = end_time - self._fps_last_time
+        if elapsed_since_fps >= 1.0:
+            self._fps = self._frame_count / elapsed_since_fps
+            self._frame_count = 0
+            self._fps_last_time = end_time
+
+    def _check_alerts(self):
+        if not self.alert_callback:
+            return
+        
+        now = time.time()
+        if now - self._last_alert_time < self._alert_cooldown:
+            return
+
+        metrics = self.get_metrics()
+        alerts = []
+        if metrics['last_frame_time_ms'] > self.thresholds['frame_time_ms']:
+            alerts.append(f"Frame time high: {metrics['last_frame_time_ms']:.1f}ms")
+        if metrics['cpu_percent'] > self.thresholds['cpu_percent']:
+            alerts.append(f"CPU usage high: {metrics['cpu_percent']:.1f}%")
+        if metrics['input_lag_ms'] > self.thresholds['input_lag_ms']:
+            alerts.append(f"Input lag high: {metrics['input_lag_ms']:.1f}ms")
+
+        if alerts:
+            self._last_alert_time = now
+            self.alert_callback("; ".join(alerts))
+
+    def get_metrics(self):
+        with self._cpu_lock:
+            cpu_usage = self._cpu_usage
+            
+        metrics = {
+            'last_frame_time_ms': self._last_frame_time,
+            'fps': self._fps,
+            'cpu_percent': cpu_usage,
+            'input_lag_ms': self._last_input_time if self._last_input_time else 0.0 # Wait, this should be the calculated lag
+        }
+        # Oops, fixed the input lag logic in previous turn, let's keep it consistent
+        metrics['input_lag_ms'] = self._input_lag_ms
+        
+        # Add detailed timings
+        for name, elapsed in self._component_timings.items():
+            metrics[f'time_{name}_ms'] = elapsed
+            
+        return metrics
+
+    def stop(self):
+        self._stop_event.set()
+        self._cpu_thread.join(timeout=2.0)

project.toml

@@ -0,0 +1,39 @@
+[project]
+name = "project"
+git_dir = ""
+system_prompt = ""
+main_context = ""
+
+[output]
+output_dir = "./md_gen"
+
+[files]
+base_dir = "."
+paths = []
+
+[screenshots]
+base_dir = "."
+paths = []
+
+[agent.tools]
+run_powershell = true
+read_file = true
+list_directory = true
+search_files = true
+get_file_summary = true
+web_search = true
+fetch_url = true
+
+[discussion]
+roles = [
+    "User",
+    "AI",
+    "Vendor API",
+    "System",
+]
+active = "main"
+
+[discussion.discussions.main]
+git_commit = ""
+last_updated = "2026-02-23T15:12:14"
+history = []

pyproject.toml

@@ -8,7 +8,8 @@ dependencies = [
     "imgui-bundle",
     "google-genai",
     "anthropic",
-    "tomli-w"
+    "tomli-w",
+    "psutil>=7.2.2",
 ]
 
 [dependency-groups]

run_tests.py

@@ -0,0 +1,5 @@
+import pytest
+import sys
+
+if __name__ == "__main__":
+    sys.exit(pytest.main(sys.argv[1:]))

tests/test_gui_diagnostics.py

@@ -0,0 +1,65 @@
+import pytest
+from unittest.mock import patch, MagicMock
+import importlib.util
+import sys
+import dearpygui.dearpygui as dpg
+
+# Load gui.py as a module for testing
+spec = importlib.util.spec_from_file_location("gui", "gui.py")
+gui = importlib.util.module_from_spec(spec)
+sys.modules["gui"] = gui
+spec.loader.exec_module(gui)
+from gui import App
+
+@pytest.fixture
+def app_instance():
+    dpg.create_context()
+    with patch('dearpygui.dearpygui.create_viewport'), \
+         patch('dearpygui.dearpygui.setup_dearpygui'), \
+         patch('dearpygui.dearpygui.show_viewport'), \
+         patch('dearpygui.dearpygui.start_dearpygui'), \
+         patch('gui.load_config', return_value={}), \
+         patch.object(App, '_rebuild_files_list'), \
+         patch.object(App, '_rebuild_shots_list'), \
+         patch.object(App, '_rebuild_disc_list'), \
+         patch.object(App, '_rebuild_disc_roles_list'), \
+         patch.object(App, '_rebuild_discussion_selector'), \
+         patch.object(App, '_refresh_project_widgets'):
+        
+        app = App()
+        yield app
+    dpg.destroy_context()
+
+def test_diagnostics_panel_initialization(app_instance):
+    assert "Diagnostics" in app_instance.window_info
+    assert app_instance.window_info["Diagnostics"] == "win_diagnostics"
+    assert "frame_time" in app_instance.perf_history
+    assert len(app_instance.perf_history["frame_time"]) == 100
+
+def test_diagnostics_panel_updates(app_instance):
+    # Mock dependencies
+    mock_metrics = {
+        'last_frame_time_ms': 10.0,
+        'fps': 100.0,
+        'cpu_percent': 50.0,
+        'input_lag_ms': 5.0
+    }
+    app_instance.perf_monitor.get_metrics = MagicMock(return_value=mock_metrics)
+    
+    with patch('dearpygui.dearpygui.is_item_shown', return_value=True), \
+         patch('dearpygui.dearpygui.set_value') as mock_set_value, \
+         patch('dearpygui.dearpygui.configure_item') as mock_configure_item, \
+         patch('dearpygui.dearpygui.does_item_exist', return_value=True):
+        
+        # We also need to mock ai_client stats
+        with patch('ai_client.get_history_bleed_stats', return_value={}):
+            app_instance._update_telemetry_panel()
+            
+            # Verify UI updates
+            mock_set_value.assert_any_call("perf_fps_text", "100.0")
+            mock_set_value.assert_any_call("perf_frame_text", "10.0ms")
+            mock_set_value.assert_any_call("perf_cpu_text", "50.0%")
+            mock_set_value.assert_any_call("perf_lag_text", "5.0ms")
+            
+            # Verify history update
+            assert app_instance.perf_history["frame_time"][-1] == 10.0

tests/test_gui_updates.py

@@ -56,9 +56,11 @@ def test_telemetry_panel_updates_correctly(app_instance):
     }
 
     # 3. Patch the dependencies
+    app_instance._last_bleed_update_time = 0 # Force update
     with patch('ai_client.get_history_bleed_stats', return_value=mock_stats) as mock_get_stats, \
          patch('dearpygui.dearpygui.set_value') as mock_set_value, \
          patch('dearpygui.dearpygui.configure_item') as mock_configure_item, \
+         patch('dearpygui.dearpygui.is_item_shown', return_value=False), \
          patch('dearpygui.dearpygui.does_item_exist', return_value=True) as mock_does_item_exist:
 
         # 4. Call the method under test
@@ -91,9 +93,11 @@ def test_cache_data_display_updates_correctly(app_instance):
     expected_text = "Gemini Caches: 5 (12.1 KB)"
 
     # 3. Patch dependencies
+    app_instance._last_bleed_update_time = 0 # Force update
     with patch('ai_client.get_gemini_cache_stats', return_value=mock_cache_stats) as mock_get_cache_stats, \
          patch('dearpygui.dearpygui.set_value') as mock_set_value, \
          patch('dearpygui.dearpygui.configure_item') as mock_configure_item, \
+         patch('dearpygui.dearpygui.is_item_shown', return_value=False), \
          patch('dearpygui.dearpygui.does_item_exist', return_value=True) as mock_does_item_exist:
         
         # We also need to mock get_history_bleed_stats as it's called in the same function

tests/test_mcp_perf_tool.py

@@ -0,0 +1,32 @@
+import unittest
+from unittest.mock import MagicMock
+import mcp_client
+
+class TestMCPPerfTool(unittest.TestCase):
+    def test_get_ui_performance_dispatch(self):
+        # Mock the callback
+        mock_metrics = {
+            'last_frame_time_ms': 16.6,
+            'fps': 60.0,
+            'cpu_percent': 15.5,
+            'input_lag_ms': 5.0
+        }
+        mcp_client.perf_monitor_callback = MagicMock(return_value=mock_metrics)
+        
+        # Test dispatch
+        result = mcp_client.dispatch("get_ui_performance", {})
+        
+        self.assertIn("UI Performance Snapshot:", result)
+        self.assertIn("last_frame_time_ms: 16.6", result)
+        self.assertIn("fps: 60.0", result)
+        self.assertIn("cpu_percent: 15.5", result)
+        self.assertIn("input_lag_ms: 5.0", result)
+        
+        mcp_client.perf_monitor_callback.assert_called_once()
+
+    def test_tool_spec_exists(self):
+        spec_names = [spec["name"] for spec in mcp_client.MCP_TOOL_SPECS]
+        self.assertIn("get_ui_performance", spec_names)
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_performance_monitor.py

@@ -0,0 +1,51 @@
+import unittest
+import time
+from unittest.mock import MagicMock
+from performance_monitor import PerformanceMonitor
+
+class TestPerformanceMonitor(unittest.TestCase):
+    def setUp(self):
+        self.monitor = PerformanceMonitor()
+
+    def test_frame_time_collection(self):
+        # Simulate frames for 1.1 seconds to trigger FPS calculation
+        start = time.time()
+        while time.time() - start < 1.1:
+            self.monitor.start_frame()
+            time.sleep(0.01)  # ~100 FPS
+            self.monitor.end_frame()
+        
+        metrics = self.monitor.get_metrics()
+        self.assertAlmostEqual(metrics['last_frame_time_ms'], 10, delta=10)
+        self.assertGreater(metrics['fps'], 0)
+
+    def test_cpu_usage_collection(self):
+        metrics = self.monitor.get_metrics()
+        self.assertIn('cpu_percent', metrics)
+        self.assertIsInstance(metrics['cpu_percent'], float)
+
+    def test_input_lag_collection(self):
+        self.monitor.start_frame()
+        self.monitor.record_input_event()
+        time.sleep(0.02)  # 20ms lag
+        self.monitor.end_frame()
+        
+        metrics = self.monitor.get_metrics()
+        self.assertGreaterEqual(metrics['input_lag_ms'], 20)
+        self.assertLess(metrics['input_lag_ms'], 40)
+
+    def test_alerts_triggering(self):
+        mock_callback = MagicMock()
+        self.monitor.alert_callback = mock_callback
+        self.monitor.thresholds['frame_time_ms'] = 5.0  # Low threshold
+        self.monitor._alert_cooldown = 0  # No cooldown for test
+        
+        self.monitor.start_frame()
+        time.sleep(0.01)  # 10ms > 5ms
+        self.monitor.end_frame()
+        
+        mock_callback.assert_called_once()
+        self.assertIn("Frame time high", mock_callback.call_args[0][0])
+
+if __name__ == '__main__':
+    unittest.main()