fix(gui): fix missing thinking_segments parameter persistence across sessions

.opencode/agents/tier2-tech-lead.md

@@ -1,6 +1,7 @@
 ---
 description: Tier 2 Tech Lead for architectural design and track execution with persistent memory
 mode: primary
+model: MiniMax-M2.5
 temperature: 0.4
 permission:
   edit: ask
@@ -13,9 +14,9 @@ ONLY output the requested text. No pleasantries.
 
 ## Context Management
 
-**MANUAL COMPACTION ONLY** <EFBFBD> Never rely on automatic context summarization.
+**MANUAL COMPACTION ONLY** — Never rely on automatic context summarization.
 Use `/compact` command explicitly when context needs reduction.
-You maintain PERSISTENT MEMORY throughout track execution <EFBFBD> do NOT apply Context Amnesia to your own session.
+You maintain PERSISTENT MEMORY throughout track execution — do NOT apply Context Amnesia to your own session.
 
 ## CRITICAL: MCP Tools Only (Native Tools Banned)
 
@@ -133,14 +134,14 @@ Before implementing:
 - Zero-assertion ban: Tests MUST have meaningful assertions
 - Delegate test creation to Tier 3 Worker via Task tool
 - Run tests and confirm they FAIL as expected
-- **CONFIRM FAILURE** <EFBFBD> this is the Red phase
+- **CONFIRM FAILURE** — this is the Red phase
 
 ### 3. Green Phase: Implement to Pass
 
 - **Pre-delegation checkpoint**: Stage current progress (`git add .`)
 - Delegate implementation to Tier 3 Worker via Task tool
 - Run tests and confirm they PASS
-- **CONFIRM PASS** <EFBFBD> this is the Green phase
+- **CONFIRM PASS** — this is the Green phase
 
 ### 4. Refactor Phase (Optional)
 

conductor/archive/frosted_glass_20260313/index.md

@@ -1,6 +1,5 @@
-# Track frosted_glass_20260313 Context (REPAIR)
+# Track frosted_glass_20260313 Context
 
-- [Debrief](./debrief.md)
 - [Specification](./spec.md)
 - [Implementation Plan](./plan.md)
 - [Metadata](./metadata.json)

conductor/archive/frosted_glass_20260313/metadata.json

@@ -0,0 +1,8 @@
+{
+  "track_id": "frosted_glass_20260313",
+  "type": "feature",
+  "status": "new",
+  "created_at": "2026-03-13T14:39:00Z",
+  "updated_at": "2026-03-13T14:39:00Z",
+  "description": "Add 'frosted glass' bg for transparency on panels and popups. This blurring effect will allow drop downs and other elements of these panels to not get hard to discern from background text or elements behind the panel."
+}

conductor/archive/frosted_glass_20260313/plan.md

@@ -0,0 +1,26 @@
+# Implementation Plan: Frosted Glass Background Effect
+
+## Phase 1: Shader Development & Integration
+- [ ] Task: Audit `src/shader_manager.py` to identify existing background/post-process integration points.
+- [ ] Task: Write Tests: Verify `ShaderManager` can compile and bind a multi-pass blur shader.
+- [ ] Task: Implement: Add `FrostedGlassShader` (GLSL) to `src/shader_manager.py`.
+- [ ] Task: Implement: Integrate the blur shader into the `ShaderManager` lifecycle.
+- [ ] Task: Conductor - User Manual Verification 'Phase 1: Shader Development & Integration' (Protocol in workflow.md)
+
+## Phase 2: Framebuffer Capture Pipeline
+- [ ] Task: Write Tests: Verify the FBO capture mechanism correctly samples the back buffer and stores it in a texture.
+- [ ] Task: Implement: Update `src/shader_manager.py` or `src/gui_2.py` to handle "pre-rendering" of the background into a texture for blurring.
+- [ ] Task: Implement: Ensure the blurred texture is updated every frame or on window move events.
+- [ ] Task: Conductor - User Manual Verification 'Phase 2: Framebuffer Capture Pipeline' (Protocol in workflow.md)
+
+## Phase 3: GUI Integration & Rendering
+- [ ] Task: Write Tests: Verify that a mocked ImGui window successfully calls the frosted glass rendering logic.
+- [ ] Task: Implement: Create a `_render_frosted_background(self, pos, size)` helper in `src/gui_2.py`.
+- [ ] Task: Implement: Update panel rendering loops (e.g. `_gui_func`) to inject the frosted background before calling `imgui.begin()` for major panels.
+- [ ] Task: Conductor - User Manual Verification 'Phase 3: GUI Integration & Rendering' (Protocol in workflow.md)
+
+## Phase 4: UI Controls & Configuration
+- [ ] Task: Write Tests: Verify that modifying blur uniforms via the Live Editor updates the shader state.
+- [ ] Task: Implement: Add "Frosted Glass" sliders (Blur, Tint, Opacity) to the **Shader Editor** in `src/gui_2.py`.
+- [ ] Task: Implement: Update `src/theme.py` to parse and store frosted glass settings from `config.toml`.
+- [ ] Task: Conductor - User Manual Verification 'Phase 4: UI Controls & Configuration' (Protocol in workflow.md)

conductor/archive/frosted_glass_20260313/spec.md

@@ -0,0 +1,34 @@
+# Specification: Frosted Glass Background Effect
+
+## Overview
+Implement a high-fidelity "frosted glass" (acrylic) background effect for all GUI panels and popups within the Manual Slop interface. This effect will use a GPU-resident shader to blur the content behind active windows, improving readability and visual depth while preventing background text from clashing with foreground UI elements.
+
+## Functional Requirements
+- **GPU-Accelerated Blur:**
+  - Implement a GLSL fragment shader (e.g., Gaussian or Kawase blur) within the existing `ShaderManager` pipeline.
+  - The shader must sample the current frame buffer background and render a blurred version behind the active window's background.
+- **Global Integration:**
+  - The effect must automatically apply to all standard ImGui panels and popups.
+  - Integrate with `imgui.begin()` and `imgui.begin_popup()` (or via a reusable wrapper helper).
+- **Real-Time Tuning:**
+  - Add controls to the **Live Shader Editor** to adjust the following parameters:
+    - **Blur Radius:** Control the intensity of the Gaussian blur.
+    - **Tint Intensity:** Control the strength of the "frost" overlay color.
+    - **Base Opacity:** Control the overall transparency of the frosted layer.
+- **Persistence:**
+  - Save frosted glass parameters to `config.toml` under the `theme` or `shader` section.
+
+## Technical Implementation
+- **Shader Pipeline:** Use `PyOpenGL` to manage a dedicated background texture/FBO for sampling.
+- **Coordinate Mapping:** Ensure the blur shader correctly maps screen coordinates to the region behind the current ImGui window.
+- **State Integration:** Store tuning parameters in `App.shader_uniforms` and ensure they are updated every frame.
+
+## Acceptance Criteria
+- [ ] Panels and popups have a distinct, blurred background that clearly separates them from the content behind them.
+- [ ] Changing the "Blur Radius" slider in the Shader Editor immediately updates the visual frostiness.
+- [ ] The effect remains stable during window dragging and resizing.
+- [ ] No significant performance degradation (maintaining target FPS).
+
+## Out of Scope
+- Implementing different blur types (e.g., motion blur, radial blur).
+- Per-panel unique blur settings (initially global only).

conductor/tracks.md

@@ -35,7 +35,7 @@ This file tracks all major tracks for the project. Each track has its own detail
 7. [ ] **Track: Optimization pass for Data-Oriented Python heuristics**
     *Link: [./tracks/data_oriented_optimization_20260312/](./tracks/data_oriented_optimization_20260312/)*
 
-8. [ ] **Track: Rich Thinking Trace Handling**
+8. [x] **Track: Rich Thinking Trace Handling** - *Parse and display AI thinking/reasoning traces*
    *Link: [./tracks/thinking_trace_handling_20260313/](./tracks/thinking_trace_handling_20260313/)*
 
 ---
@@ -60,7 +60,7 @@ This file tracks all major tracks for the project. Each track has its own detail
 
 5. [x] **Track: NERV UI Theme Integration** (Archived 2026-03-09)
 
-6. [x] **Track: Custom Shader and Window Frame Support** 
+6. [X] **Track: Custom Shader and Window Frame Support** 
    *Link: [./tracks/custom_shaders_20260309/](./tracks/custom_shaders_20260309/)*
 
 7. [x] **Track: UI/UX Improvements - Presets and AI Settings**
@@ -82,10 +82,6 @@ This file tracks all major tracks for the project. Each track has its own detail
 11. [ ] **Track: Advanced Text Viewer with Syntax Highlighting**
     *Link: [./tracks/text_viewer_rich_rendering_20260313/](./tracks/text_viewer_rich_rendering_20260313/)*
 
-12. [ ] ~~**Track: Frosted Glass Background Effect**~~ THIS IS A LOST CAUSE DON'T BOTHER.
-    *Link: [./tracks/frosted_glass_20260313/](./tracks/frosted_glass_20260313/)*
-    
-
 ---
 
 ### Additional Language Support
@@ -165,6 +161,10 @@ This file tracks all major tracks for the project. Each track has its own detail
 
 ### Completed / Archived
 
+-. [ ] ~~**Track: Frosted Glass Background Effect**~~ ***NOT WORTH THE PAIN***
+    *Link: [./tracks/frosted_glass_20260313/](./tracks/frosted_glass_20260313/)*
+
+
 - [x] **Track: External MCP Server Support** (Archived 2026-03-12)
 - [x] **Track: Project-Specific Conductor Directory** (Archived 2026-03-12)
 - [x] **Track: GUI Path Configuration in Context Hub** (Archived 2026-03-12)

conductor/tracks/frosted_glass_20260313/debrief.md

@@ -1,28 +0,0 @@
-# Debrief: Failed Frosted Glass Implementation (Attempt 1)
-
-## 1. Post-Mortem Summary
-The initial implementation of the Frosted Glass effect was a catastrophic failure resulting in application crashes (`RecursionError`, `AttributeError`, `RuntimeError`) and visual non-functionality (black backgrounds or invisible blurs).
-
-## 2. Root Causes
-
-### A. Architectural Blindness (ImGui Timing)
-I attempted to use `glCopyTexImage2D` to capture the "backbuffer" during the `_gui_func` execution. In an immediate-mode GUI (ImGui), the backbuffer is cleared at the start of the frame and draw commands are only recorded during `_gui_func`. The actual GPU rendering happens **after** `_gui_func` finishes. Consequently, I was capturing and blurring an empty black screen every frame.
-
-### B. Sub-Agent Fragmentation (Class Scope Breaks)
-By delegating massive file refactors to the `generalist` sub-agent, I lost control over the strict 1-space indentation required by this project. The sub-agent introduced unindented blocks that silently closed the `App` class scope, causing all subsequent methods to become global functions. This lead to the avalanche of `AttributeError: 'App' object has no attribute '_render_operations_hub_contents'` and similar errors.
-
-### C. Style Stack Imbalance
-The implementation of `_begin_window` and `_end_window` wrappers failed to account for mid-render state changes. Toggling the "Frosted Glass" checkbox mid-frame resulted in mismatched `PushStyleColor` and `PopStyleColor` calls, triggering internal ImGui assertions and hard crashes.
-
-### D. High-DPI Math Errors
-The UV coordinate math failed to correctly account for `display_framebuffer_scale`. On high-resolution screens, the blur sampling was offset by thousands of pixels, rendering the effect physically invisible or distorted.
-
-TODO:
-
-LOOK AT THIS SHIT:
-https://www.unknowncheats.me/forum/general-programming-and-reversing/617284-blurring-imgui-basically-window-using-acrylic-blur.html
-https://github.com/Speykious/opengl-playground/blob/main/src/scenes/blurring.rs
-https://www.intel.com/content/www/us/en/developer/articles/technical/an-investigation-of-fast-real-time-gpu-based-image-blur-algorithms.html
-https://github.com/cofenberg/unrimp/blob/45aa431286ce597c018675c1a9730d98e6ccfc64/Renderer/RendererRuntime/src/DebugGui/DebugGuiManager.cpp
-https://github.com/cofenberg/unrimp/blob/45aa431286ce597c018675c1a9730d98e6ccfc64/Renderer/RendererRuntime/src/DebugGui/Detail/Shader/DebugGui_GLSL_410.h
-https://github.com/itsRythem/ImGui-Blur

conductor/tracks/frosted_glass_20260313/metadata.json

@@ -1,8 +0,0 @@
-{
-  "track_id": "frosted_glass_20260313",
-  "type": "feature",
-  "status": "new",
-  "created_at": "2026-03-13T14:39:00Z",
-  "updated_at": "2026-03-13T18:55:00Z",
-  "description": "REPAIR: Implement stable frosted glass using native Windows DWM APIs."
-}

conductor/tracks/frosted_glass_20260313/plan.md

@@ -1,19 +0,0 @@
-# Implementation Plan: Frosted Glass Background Effect (REPAIR - TRUE GPU)
-
-## Phase 1: Robust Shader & FBO Foundation
-- [x] Task: Implement: Create `ShaderManager` methods for downsampled FBO setup (scene, temp, blur). [d9148ac]
-- [x] Task: Implement: Develop the "Deep Sea" background shader and integrate it as the FBO source. [d85dc3a]
-- [x] Task: Implement: Develop the 2-pass Gaussian blur shaders with a wide tap distribution. [c8b7fca]
-- [x] Task: Conductor - User Manual Verification 'Phase 1: Robust Foundation' (Protocol in workflow.md)
-
-## Phase 2: High-Performance Blur Pipeline
-- [x] Task: Implement: Create the `prepare_global_blur` method that renders the background and blurs it at 1/4 resolution. [9c2078a]
-- [x] Task: Implement: Ensure the pipeline correctly handles high-DPI scaling (`fb_scale`) for internal FBO dimensions. [9c2078a]
-- [x] Task: Conductor - User Manual Verification 'Phase 2: High-Performance Pipeline' (Protocol in workflow.md)
-
-## Phase 3: GUI Integration & Screen-Space Sampling
-- [x] Task: Implement: Update `_render_frosted_background` to perform normalized screen-space UV sampling. [926318f]
-- [x] Task: Fix crash when display_size is invalid at startup. [db00fba]
-## Phase 3: GUI Integration & Screen-Space Sampling
-- [x] Task: Implement: Update `_render_frosted_background` to perform normalized screen-space UV sampling. [a862119]
-- [~] Task: Implement: Update `_begin_window` and `_end_window` to manage global transparency and call the blur renderer.

conductor/tracks/frosted_glass_20260313/spec.md

@@ -1,30 +0,0 @@
-# Specification: Frosted Glass Background Effect (REPAIR - TRUE GPU)
-
-## Overview
-Implement a high-fidelity "frosted glass" (acrylic) background effect using a dedicated OpenGL pipeline. This implementation follows professional rendering patterns (downsampling, multi-pass blurring, and screen-space sampling) to ensure a smooth, milky look that remains performant on high-DPI displays.
-
-## Functional Requirements
-- **Dedicated Background Pipeline:**
-  - Render the animated "Deep Sea" background shader to an off-screen `SceneFBO` once per frame.
-- **Multi-Scale Downsampled Blur:**
-  - Downsample the `SceneFBO` texture to 1/4 or 1/8 resolution.
-  - Perform 2-pass Gaussian blurring on the downsampled texture to achieve a creamy "milky" aesthetic.
-- **ImGui Panel Integration:**
-  - Each ImGui panel must sample its background from the blurred texture using screen-space UV coordinates.
-  - Automatically force window transparency (`alpha 0.0`) when the effect is active.
-- **Real-Time Shader Tuning:**
-  - Control blur radius, tint intensity, and opacity via the Live Shader Editor.
-- **Stability:**
-  - Balanced style-stack management to prevent ImGui assertion crashes.
-  - Strict 1-space indentation and class scope protection.
-
-## Technical Implementation
-- **FBO Management:** Persistent FBOs for scene, temp, and blur textures.
-- **UV Math:** `(window_pos / screen_res)` mapping to handle high-DPI scaling and vertical flipping.
-- **DrawList Callbacks:** (If necessary) use callbacks to ensure the background is ready before panels draw.
-
-## Acceptance Criteria
-- [ ] Toggling the effect does not crash the app.
-- [ ] Windows show a deep, high-quality blur of the background shader.
-- [ ] Blur follows windows perfectly during drag/resize.
-- [ ] The "Milky" look is highly visible even at low radii.

conductor/tracks/thinking_trace_handling_20260313/plan.md

@@ -1,26 +1,23 @@
 # Implementation Plan: Rich Thinking Trace Handling
 
-## Phase 1: Core Parsing & Model Update
-- [ ] Task: Audit `src/models.py` and `src/project_manager.py` to identify current message serialization schemas.
-- [ ] Task: Write Tests: Verify that raw AI responses with `<thinking>`, `<thought>`, and `Thinking:` markers are correctly parsed into segmented data structures (Thinking vs. Response).
-- [ ] Task: Implement: Add `ThinkingSegment` model and update `ChatMessage` schema in `src/models.py` to support optional thinking traces.
-- [ ] Task: Implement: Update parsing logic in `src/ai_client.py` or a dedicated utility to extract segments from raw provider responses.
-- [ ] Task: Conductor - User Manual Verification 'Phase 1: Core Parsing & Model Update' (Protocol in workflow.md)
+## Status: COMPLETE (2026-03-14)
 
-## Phase 2: Persistence & History Integration
-- [ ] Task: Write Tests: Verify that `ProjectManager` correctly serializes and deserializes messages with thinking segments to/from TOML history files.
-- [ ] Task: Implement: Update `src/project_manager.py` to handle the new `ChatMessage` schema during session save/load.
-- [ ] Task: Implement: Ensure `src/aggregate.py` or relevant context builders include thinking traces in the "Discussion History" sent back to the AI.
-- [ ] Task: Conductor - User Manual Verification 'Phase 2: Persistence & History Integration' (Protocol in workflow.md)
+## Summary
+Implemented thinking trace parsing, model, persistence, and GUI rendering for AI responses containing `<thinking>`, `<thought>`, and `Thinking:` markers.
 
-## Phase 3: GUI Rendering - Comms & Discussion
-- [ ] Task: Write Tests: Verify the GUI rendering logic correctly handles messages with and without thinking segments.
-- [ ] Task: Implement: Create a reusable `_render_thinking_trace` helper in `src/gui_2.py` using a collapsible header (e.g., `imgui.collapsing_header`).
-- [ ] Task: Implement: Integrate the thinking trace renderer into the **Comms History** panel in `src/gui_2.py`.
-- [ ] Task: Implement: Integrate the thinking trace renderer into the **Discussion Hub** message loop in `src/gui_2.py`.
-- [ ] Task: Conductor - User Manual Verification 'Phase 3: GUI Rendering - Comms & Discussion' (Protocol in workflow.md)
+## Files Created/Modified:
+- `src/thinking_parser.py` - Parser for thinking traces
+- `src/models.py` - ThinkingSegment model
+- `src/gui_2.py` - _render_thinking_trace helper + integration
+- `tests/test_thinking_trace.py` - 7 parsing tests
+- `tests/test_thinking_persistence.py` - 4 persistence tests  
+- `tests/test_thinking_gui.py` - 4 GUI tests
 
-## Phase 4: Final Polish & Theming
-- [ ] Task: Implement: Apply specialized styling (e.g., tinted background or italicized text) to expanded thinking traces to distinguish them from direct responses.
-- [ ] Task: Implement: Ensure thinking trace headers show a "Calculating..." or "Monologue" indicator while an agent is active.
-- [ ] Task: Conductor - User Manual Verification 'Phase 4: Final Polish & Theming' (Protocol in workflow.md)
+## Implementation Details:
+- **Parser**: Extracts thinking segments from `<thinking>`, `<thought>`, `Thinking:` markers
+- **Model**: `ThinkingSegment` dataclass with content and marker fields
+- **GUI**: `_render_thinking_trace` with collapsible "Monologue" header
+- **Styling**: Tinted background (dark brown), gold/amber text
+- **Indicator**: Existing "THINKING..." in Discussion Hub
+
+## Total Tests: 15 passing

config.toml

@@ -23,23 +23,23 @@ active = "C:/projects/gencpp/gencpp_sloppy.toml"
 separate_message_panel = false
 separate_response_panel = false
 separate_tool_calls_panel = false
-bg_shader_enabled = false
+bg_shader_enabled = true
 crt_filter_enabled = false
 separate_task_dag = false
-separate_usage_analytics = true
+separate_usage_analytics = false
 separate_tier1 = false
 separate_tier2 = false
 separate_tier3 = false
 separate_tier4 = false
-separate_external_tools = true
+separate_external_tools = false
 
 [gui.show_windows]
 "Context Hub" = true
 "Files & Media" = true
 "AI Settings" = true
-"MMA Dashboard" = true
+"MMA Dashboard" = false
 "Task DAG" = false
-"Usage Analytics" = true
+"Usage Analytics" = false
 "Tier 1" = false
 "Tier 2" = false
 "Tier 3" = false
@@ -51,21 +51,21 @@ separate_external_tools = true
 "Discussion Hub" = true
 "Operations Hub" = true
 Message = false
-Response = true
+Response = false
 "Tool Calls" = false
 Theme = true
-"Log Management" = true
+"Log Management" = false
 Diagnostics = false
 "External Tools" = false
-"Shader Editor" = true
+"Shader Editor" = false
 
 [theme]
 palette = "Nord Dark"
 font_path = "C:/projects/manual_slop/assets/fonts/MapleMono-Regular.ttf"
 font_size = 18.0
 scale = 1.0
-transparency = 0.4399999976158142
-child_transparency = 0.5099999904632568
+transparency = 1.0
+child_transparency = 1.0
 
 [mma]
 max_workers = 4

manualslop_layout.ini

@@ -49,8 +49,8 @@ Size=716,455
 Collapsed=0
 
 [Window][Response]
-Pos=2437,925
-Size=1111,773
+Pos=2258,1377
+Size=1102,575
 Collapsed=0
 
 [Window][Tool Calls]
@@ -74,8 +74,8 @@ Collapsed=0
 DockId=0xAFC85805,2
 
 [Window][Theme]
-Pos=0,543
-Size=387,737
+Pos=0,1423
+Size=579,737
 Collapsed=0
 DockId=0x00000002,2
 
@@ -91,8 +91,8 @@ Collapsed=0
 DockId=0x00000010,2
 
 [Window][Context Hub]
-Pos=0,543
-Size=387,737
+Pos=0,1423
+Size=579,737
 Collapsed=0
 DockId=0x00000002,1
 
@@ -103,26 +103,26 @@ Collapsed=0
 DockId=0x0000000D,0
 
 [Window][Discussion Hub]
-Pos=1169,26
-Size=950,1254
+Pos=2230,26
+Size=1610,2134
 Collapsed=0
 DockId=0x00000013,0
 
 [Window][Operations Hub]
-Pos=389,26
-Size=778,1254
+Pos=581,26
+Size=1647,2134
 Collapsed=0
 DockId=0x00000005,0
 
 [Window][Files & Media]
-Pos=0,543
-Size=387,737
+Pos=0,1423
+Size=579,737
 Collapsed=0
 DockId=0x00000002,0
 
 [Window][AI Settings]
 Pos=0,26
-Size=387,515
+Size=579,1395
 Collapsed=0
 DockId=0x00000001,0
 
@@ -132,16 +132,16 @@ Size=416,325
 Collapsed=0
 
 [Window][MMA Dashboard]
-Pos=2121,26
-Size=653,1254
+Pos=3360,26
+Size=480,2134
 Collapsed=0
 DockId=0x00000010,0
 
 [Window][Log Management]
-Pos=2121,26
-Size=653,1254
+Pos=3360,26
+Size=480,2134
 Collapsed=0
-DockId=0x00000010,1
+DockId=0x00000010,0
 
 [Window][Track Proposal]
 Pos=709,326
@@ -167,7 +167,7 @@ Collapsed=0
 Pos=2822,1717
 Size=1018,420
 Collapsed=0
-DockId=0x00000011,0
+DockId=0x0000000C,0
 
 [Window][Approve PowerShell Command]
 Pos=649,435
@@ -175,7 +175,7 @@ Size=381,329
 Collapsed=0
 
 [Window][Last Script Output]
-Pos=2810,265
+Pos=927,1365
 Size=800,562
 Collapsed=0
 
@@ -220,7 +220,7 @@ Size=900,700
 Collapsed=0
 
 [Window][Text Viewer - text]
-Pos=60,60
+Pos=1297,550
 Size=900,700
 Collapsed=0
 
@@ -330,9 +330,10 @@ Size=967,499
 Collapsed=0
 
 [Window][Usage Analytics]
-Pos=1627,680
-Size=480,343
+Pos=1739,1107
+Size=586,269
 Collapsed=0
+DockId=0x0000000F,0
 
 [Window][Tool Preset Manager]
 Pos=1301,302
@@ -350,7 +351,7 @@ Size=1000,800
 Collapsed=0
 
 [Window][External Tools]
-Pos=1968,516
+Pos=531,376
 Size=616,409
 Collapsed=0
 
@@ -365,7 +366,7 @@ Size=900,700
 Collapsed=0
 
 [Window][Text Viewer - Entry #4]
-Pos=1127,922
+Pos=1247,1182
 Size=900,700
 Collapsed=0
 
@@ -380,8 +381,8 @@ Size=900,700
 Collapsed=0
 
 [Window][Shader Editor]
-Pos=998,497
-Size=493,369
+Pos=457,710
+Size=493,252
 Collapsed=0
 
 [Table][0xFB6E3870,4]
@@ -497,21 +498,23 @@ Column 1  Weight=1.0000
 DockNode            ID=0x00000008 Pos=3125,170 Size=593,1157 Split=Y
   DockNode          ID=0x00000009 Parent=0x00000008 SizeRef=1029,147 Selected=0x0469CA7A
   DockNode          ID=0x0000000A Parent=0x00000008 SizeRef=1029,145 Selected=0xDF822E02
-DockSpace           ID=0xAFC85805 Window=0x079D3A04 Pos=0,26 Size=2774,1254 Split=X
-  DockNode          ID=0x00000003 Parent=0xAFC85805 SizeRef=1980,1183 Split=X
+DockSpace           ID=0xAFC85805 Window=0x079D3A04 Pos=0,26 Size=3840,2134 Split=X
+  DockNode          ID=0x00000003 Parent=0xAFC85805 SizeRef=3358,1183 Split=X
     DockNode        ID=0x0000000B Parent=0x00000003 SizeRef=404,1186 Split=X Selected=0xF4139CA2
-      DockNode      ID=0x00000007 Parent=0x0000000B SizeRef=680,858 Split=Y Selected=0x8CA2375C
+      DockNode      ID=0x00000007 Parent=0x0000000B SizeRef=579,858 Split=Y Selected=0x8CA2375C
         DockNode    ID=0x00000001 Parent=0x00000007 SizeRef=824,525 CentralNode=1 Selected=0x7BD57D6A
         DockNode    ID=0x00000002 Parent=0x00000007 SizeRef=824,737 Selected=0x8CA2375C
-      DockNode      ID=0x0000000E Parent=0x0000000B SizeRef=1730,858 Split=X Selected=0x418C7449
-        DockNode    ID=0x00000012 Parent=0x0000000E SizeRef=778,402 Split=Y Selected=0x418C7449
+      DockNode      ID=0x0000000E Parent=0x0000000B SizeRef=3259,858 Split=X Selected=0x418C7449
+        DockNode    ID=0x00000012 Parent=0x0000000E SizeRef=1647,402 Split=Y Selected=0x418C7449
           DockNode  ID=0x00000005 Parent=0x00000012 SizeRef=876,1749 Selected=0x418C7449
           DockNode  ID=0x00000006 Parent=0x00000012 SizeRef=876,362 Selected=0x1D56B311
-        DockNode    ID=0x00000013 Parent=0x0000000E SizeRef=950,402 Selected=0x6F2B5B04
+        DockNode    ID=0x00000013 Parent=0x0000000E SizeRef=1610,402 Selected=0x6F2B5B04
     DockNode        ID=0x0000000D Parent=0x00000003 SizeRef=435,1186 Selected=0x363E93D6
-  DockNode          ID=0x00000004 Parent=0xAFC85805 SizeRef=653,1183 Split=Y Selected=0x3AEC3498
+  DockNode          ID=0x00000004 Parent=0xAFC85805 SizeRef=480,1183 Split=Y Selected=0x3AEC3498
     DockNode        ID=0x00000010 Parent=0x00000004 SizeRef=1199,1689 Selected=0x2C0206CE
-    DockNode        ID=0x00000011 Parent=0x00000004 SizeRef=1199,420 Selected=0xDEB547B6
+    DockNode        ID=0x00000011 Parent=0x00000004 SizeRef=1199,420 Split=X Selected=0xDEB547B6
+      DockNode      ID=0x0000000C Parent=0x00000011 SizeRef=916,380 Selected=0x655BC6E9
+      DockNode      ID=0x0000000F Parent=0x00000011 SizeRef=281,380 Selected=0xDEB547B6
 
 ;;;<<<Layout_655921752_Default>>>;;;
 ;;;<<<HelloImGui_Misc>>>;;;

src/app_controller.py

@@ -25,6 +25,7 @@ from src import project_manager
 from src import performance_monitor
 from src import models
 from src import presets
+from src import thinking_parser
 from src.file_cache import ASTParser
 from src import ai_client
 from src import shell_runner
@@ -610,16 +611,6 @@ class AppController:
       self._token_stats_dirty = True
       if not is_streaming:
        self._autofocus_response_tab = True
-      # ONLY add to history when turn is complete
-     if self.ui_auto_add_history and not stream_id and not is_streaming:
-      role = payload.get("role", "AI")
-      with self._pending_history_adds_lock:
-       self._pending_history_adds.append({
-         "role": role, 
-         "content": self.ai_response, 
-         "collapsed": True, 
-         "ts": project_manager.now_ts()
-        })
     elif action in ("mma_stream", "mma_stream_append"):
     # Some events might have these at top level, some in a 'payload' dict
      stream_id = task.get("stream_id") or task.get("payload", {}).get("stream_id")
@@ -1467,9 +1458,22 @@ class AppController:
   
   if kind == "response" and "usage" in payload:
    u = payload["usage"]
-   for k in ["input_tokens", "output_tokens", "cache_read_input_tokens", "cache_creation_input_tokens", "total_tokens"]:
-    if k in u:
-     self.session_usage[k] += u.get(k, 0) or 0
+   inp = u.get("input_tokens", u.get("prompt_tokens", 0))
+   out = u.get("output_tokens", u.get("completion_tokens", 0))
+   cache_read = u.get("cache_read_input_tokens", 0)
+   cache_create = u.get("cache_creation_input_tokens", 0)
+   total = u.get("total_tokens", 0)
+
+   # Store normalized usage back in payload for history rendering
+   u["input_tokens"] = inp
+   u["output_tokens"] = out
+   u["cache_read_input_tokens"] = cache_read
+
+   self.session_usage["input_tokens"] += inp
+   self.session_usage["output_tokens"] += out
+   self.session_usage["cache_read_input_tokens"] += cache_read
+   self.session_usage["cache_creation_input_tokens"] += cache_create
+   self.session_usage["total_tokens"] += total
    input_t = u.get("input_tokens", 0)
    output_t = u.get("output_tokens", 0)
    model = payload.get("model", "unknown")
@@ -1490,7 +1494,27 @@ class AppController:
       "ts": entry.get("ts", project_manager.now_ts())
      })
 
+  if kind == "response":
+   if self.ui_auto_add_history:
+    role = payload.get("role", "AI")
+    text_content = payload.get("text", "")
+    if text_content.strip():
+     segments, parsed_response = thinking_parser.parse_thinking_trace(text_content)
+     entry_obj = {
+      "role": role,
+      "content": parsed_response.strip() if parsed_response else "",
+      "collapsed": True,
+      "ts": entry.get("ts", project_manager.now_ts())
+     }
+     if segments:
+      entry_obj["thinking_segments"] = [{"content": s.content, "marker": s.marker} for s in segments]
+     
+     if entry_obj["content"] or segments:
+      with self._pending_history_adds_lock:
+       self._pending_history_adds.append(entry_obj)
+
   if kind in ("tool_result", "tool_call"):
+   if self.ui_auto_add_history:
     role = "Tool" if kind == "tool_result" else "Vendor API"
     content = ""
     if kind == "tool_result":

src/gui_2.py

@@ -28,6 +28,8 @@ from src import app_controller
 from src import mcp_client
 from src import markdown_helper
 from src import bg_shader
+from src import thinking_parser
+from src import thinking_parser
 import re
 import subprocess
 if sys.platform == "win32":
@@ -39,7 +41,6 @@ else:
 
 from pydantic import BaseModel
 from imgui_bundle import imgui, hello_imgui, immapp, imgui_node_editor as ed
-from src.shader_manager import BlurPipeline
 
 PROVIDERS: list[str] = ["gemini", "anthropic", "gemini_cli", "deepseek", "minimax"]
 COMMS_CLAMP_CHARS: int = 300
@@ -213,33 +214,6 @@ class App:
   self.ui_tool_filter_category = "All"
   self.ui_discussion_split_h = 300.0
   self.shader_uniforms = {'crt': 1.0, 'scanline': 0.5, 'bloom': 0.8}
-  self.ui_frosted_glass_enabled = False
-  self._blur_pipeline: BlurPipeline | None = None
-  self.ui_frosted_glass_enabled = False
-  self._blur_pipeline = None
-
- def _pre_render_blur(self):
-  if not self.ui_frosted_glass_enabled:
-   return
-  if not self._blur_pipeline:
-   return
-  ws = imgui.get_io().display_size
-  fb_scale = imgui.get_io().display_framebuffer_scale.x
-  import time
-  t = time.time()
-  self._blur_pipeline.prepare_global_blur(int(ws.x), int(ws.y), t, fb_scale)
-
- def _render_custom_background(self):
-  return  # DISABLED - imgui-bundle can't sample OpenGL textures
-
- def _draw_blurred_rect(self, dl, p_min, p_max, tex_id, uv_min, uv_max):
-  import OpenGL.GL as gl
-  gl.glEnable(gl.GL_BLEND)
-  gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
-  imgui.push_texture_id(tex_id)
-  dl.add_image_quad(p_min, p_max, uv_min, uv_max, imgui.get_color_u32((1, 1, 1, 1)))
-  imgui.pop_texture_id()
-  gl.glDisable(gl.GL_BLEND)
 
  def _handle_approve_tool(self, user_data=None) -> None:
   """UI-level wrapper for approving a pending tool execution ask."""
@@ -332,21 +306,57 @@ class App:
   if is_nerv: imgui.push_style_color(imgui.Col_.text, vec4(80, 255, 80))
 
   if len(content) > COMMS_CLAMP_CHARS:
-   imgui.begin_child(f"heavy_text_child_{label}_{id_suffix}", imgui.ImVec2(0, 80), True)
    if is_md:
+    imgui.begin_child(f"heavy_text_child_{label}_{id_suffix}", imgui.ImVec2(0, 180), True, imgui.WindowFlags_.always_vertical_scrollbar)
     markdown_helper.render(content, context_id=ctx_id)
-   else:
-    markdown_helper.render_code(content, context_id=ctx_id)
     imgui.end_child()
+   else:
+    imgui.input_text_multiline(f"##heavy_text_input_{label}_{id_suffix}", content, imgui.ImVec2(-1, 180), imgui.InputTextFlags_.read_only)
   else:
    if is_md:
     markdown_helper.render(content, context_id=ctx_id)
    else:
-    markdown_helper.render_code(content, context_id=ctx_id)
+    if self.ui_word_wrap:
+     imgui.push_text_wrap_pos(imgui.get_content_region_avail().x)
+     imgui.text(content)
+     imgui.pop_text_wrap_pos()
+    else:
+     imgui.text(content)
   
   if is_nerv: imgui.pop_style_color()
     # ---------------------------------------------------------------- gui
 
+ def _render_thinking_trace(self, segments: list[dict], entry_index: int, is_standalone: bool = False) -> None:
+  if not segments:
+   return
+  imgui.push_style_color(imgui.Col_.child_bg, vec4(40, 35, 25, 180))
+  imgui.push_style_color(imgui.Col_.text, vec4(200, 200, 150))
+  imgui.indent()
+  show_content = True
+  if not is_standalone:
+   header_label = f"Monologue ({len(segments)} traces)###thinking_header_{entry_index}"
+   show_content = imgui.collapsing_header(header_label)
+  
+  if show_content:
+   h = 150 if is_standalone else 100
+   imgui.begin_child(f"thinking_content_{entry_index}", imgui.ImVec2(0, h), True)
+   for idx, seg in enumerate(segments):
+    content = seg.get("content", "")
+    marker = seg.get("marker", "thinking")
+    imgui.push_id(f"think_{entry_index}_{idx}")
+    imgui.text_colored(vec4(180, 150, 80), f"[{marker}]")
+    if self.ui_word_wrap:
+     imgui.push_text_wrap_pos(imgui.get_content_region_avail().x)
+     imgui.text_colored(vec4(200, 200, 150), content)
+     imgui.pop_text_wrap_pos()
+    else:
+     imgui.text_colored(vec4(200, 200, 150), content)
+    imgui.pop_id()
+    imgui.separator()
+   imgui.end_child()
+  imgui.unindent()
+  imgui.pop_style_color(2)
+
 
  def _render_selectable_label(self, label: str, value: str, width: float = 0.0, multiline: bool = False, height: float = 0.0, color: Optional[imgui.ImVec4] = None) -> None:
   imgui.push_id(label + str(hash(value)))
@@ -465,8 +475,6 @@ class App:
    exp, opened = imgui.begin('Shader Editor', self.show_windows['Shader Editor'])
    self.show_windows['Shader Editor'] = bool(opened)
    if exp:
-    _, self.ui_frosted_glass_enabled = imgui.checkbox('Frosted Glass', self.ui_frosted_glass_enabled)
-    imgui.separator()
     changed_crt, self.shader_uniforms['crt'] = imgui.slider_float('CRT Curvature', self.shader_uniforms['crt'], 0.0, 2.0)
     changed_scan, self.shader_uniforms['scanline'] = imgui.slider_float('Scanline Intensity', self.shader_uniforms['scanline'], 0.0, 1.0)
     changed_bloom, self.shader_uniforms['bloom'] = imgui.slider_float('Bloom Threshold', self.shader_uniforms['bloom'], 0.0, 1.0)
@@ -2281,10 +2289,19 @@ def hello():
       imgui.same_line()
       preview = entry["content"].replace("\\n", " ")[:60]
       if len(entry["content"]) > 60: preview += "..."
+      if not preview.strip() and entry.get("thinking_segments"):
+       preview = entry["thinking_segments"][0]["content"].replace("\\n", " ")[:60]
+       if len(entry["thinking_segments"][0]["content"]) > 60: preview += "..."
       imgui.text_colored(vec4(160, 160, 150), preview)
      if not collapsed:
+      thinking_segments = entry.get("thinking_segments", [])
+      has_content = bool(entry.get("content", "").strip())
+      is_standalone = bool(thinking_segments) and not has_content
+      if thinking_segments:
+       self._render_thinking_trace(thinking_segments, i, is_standalone=is_standalone)
       if read_mode:
        content = entry["content"]
+       if content.strip():
         pattern = re.compile(r"\[Definition: (.*?) from (.*?) \(line (\d+)\)\](\s+```[\s\S]*?```)?")
         matches = list(pattern.finditer(content))
         is_nerv = theme.is_nerv_active()
@@ -2313,7 +2330,6 @@ def hello():
              self.text_viewer_content = res
              self.show_text_viewer = True
            if code_block:
-           # Render code block with highlighting
             if is_nerv: imgui.push_style_color(imgui.Col_.text, vec4(80, 255, 80))
             markdown_helper.render(code_block, context_id=f'disc_{i}_c_{m_idx}')
             if is_nerv: imgui.pop_style_color()
@@ -2326,6 +2342,7 @@ def hello():
          if self.ui_word_wrap: imgui.pop_text_wrap_pos()
          imgui.end_child()
       else:
+       if not is_standalone:
         ch, entry["content"] = imgui.input_text_multiline("##content", entry["content"], imgui.ImVec2(-1, 150))
      imgui.separator()
      imgui.pop_id()
@@ -2760,14 +2777,24 @@ def hello():
   imgui.begin_child("response_scroll_area", imgui.ImVec2(0, -40), True)
   is_nerv = theme.is_nerv_active()
   if is_nerv: imgui.push_style_color(imgui.Col_.text, vec4(80, 255, 80))
-  markdown_helper.render(self.ai_response, context_id="response")
+  
+  segments, parsed_response = thinking_parser.parse_thinking_trace(self.ai_response)
+  if segments:
+   self._render_thinking_trace([{"content": s.content, "marker": s.marker} for s in segments], 9999)
+  
+  markdown_helper.render(parsed_response, context_id="response")
+  
   if is_nerv: imgui.pop_style_color()
   imgui.end_child()
   
   imgui.separator()
   if imgui.button("-> History"):
    if self.ai_response:
-    self.disc_entries.append({"role": "AI", "content": self.ai_response, "collapsed": True, "ts": project_manager.now_ts()})
+    segments, response = thinking_parser.parse_thinking_trace(self.ai_response)
+    entry = {"role": "AI", "content": response, "collapsed": True, "ts": project_manager.now_ts()}
+    if segments:
+     entry["thinking_segments"] = [{"content": s.content, "marker": s.marker} for s in segments]
+    self.disc_entries.append(entry)
   if is_blinking:
    imgui.pop_style_color(2)
   if self.perf_profiling_enabled: self.perf_monitor.end_component("_render_response_panel")
@@ -2883,6 +2910,12 @@ def hello():
     imgui.text_colored(C_LBL, f"#{i_display}")
     imgui.same_line()
     imgui.text_colored(vec4(160, 160, 160), ts)
+    
+    latency = entry.get("latency") or entry.get("metadata", {}).get("latency")
+    if latency:
+     imgui.same_line()
+     imgui.text_colored(C_SUB, f" ({latency:.2f}s)")
+
     ticket_id = entry.get("mma_ticket_id")
     if ticket_id:
      imgui.same_line()
@@ -2901,14 +2934,34 @@ def hello():
     # Optimized content rendering using _render_heavy_text logic
     idx_str = str(i)
     if kind == "request":
+     usage = payload.get("usage", {})
+     if usage:
+      inp = usage.get("input_tokens", 0)
+      imgui.text_colored(C_LBL, f" tokens in:{inp}")
      self._render_heavy_text("message", payload.get("message", ""), idx_str)
      if payload.get("system"):
       self._render_heavy_text("system", payload.get("system", ""), idx_str)
     elif kind == "response":
      r = payload.get("round", 0)
      sr = payload.get("stop_reason", "STOP")
-     imgui.text_colored(C_LBL, f"round: {r} stop_reason: {sr}")
-     self._render_heavy_text("text", payload.get("text", ""), idx_str)
+     usage = payload.get("usage", {})
+     usage_str = ""
+     if usage:
+      inp = usage.get("input_tokens", 0)
+      out = usage.get("output_tokens", 0)
+      cache = usage.get("cache_read_input_tokens", 0)
+      usage_str = f" in:{inp} out:{out}"
+      if cache:
+       usage_str += f" cache:{cache}"
+     imgui.text_colored(C_LBL, f"round: {r} stop_reason: {sr}{usage_str}")
+     
+     text_content = payload.get("text", "")
+     segments, parsed_response = thinking_parser.parse_thinking_trace(text_content)
+     if segments:
+      self._render_thinking_trace([{"content": s.content, "marker": s.marker} for s in segments], i, is_standalone=not bool(parsed_response.strip()))
+     if parsed_response:
+      self._render_heavy_text("text", parsed_response, idx_str)
+     
      tcs = payload.get("tool_calls", [])
      if tcs:
       self._render_heavy_text("tool_calls", json.dumps(tcs, indent=1), idx_str)
@@ -4024,36 +4077,6 @@ def hello():
  def _post_init(self) -> None:
   theme.apply_current()
 
- def _init_blur_pipeline(self):
-  if self._blur_pipeline is None:
-   self._blur_pipeline = BlurPipeline()
-  ws = imgui.get_io().display_size
-  fb_scale = imgui.get_io().display_framebuffer_scale.x
-  if ws.x <= 0 or ws.y <= 0:
-   return False
-  if fb_scale <= 0:
-   fb_scale = 1.0
-  self._blur_pipeline.setup_fbos(int(ws.x), int(ws.y), fb_scale)
-  self._blur_pipeline.compile_deepsea_shader()
-  self._blur_pipeline.compile_blur_shaders()
-  return True
-
- def _pre_new_frame(self) -> None:
-  if not self.ui_frosted_glass_enabled:
-   return
-  ws = imgui.get_io().display_size
-  fb_scale = imgui.get_io().display_framebuffer_scale.x
-  if ws.x <= 0 or ws.y <= 0:
-   return
-  if fb_scale <= 0:
-   fb_scale = 1.0
-  if self._blur_pipeline is None:
-   if not self._init_blur_pipeline():
-    return
-  import time
-  t = time.time()
-  self._blur_pipeline.prepare_global_blur(int(ws.x), int(ws.y), t, fb_scale)
-
  def run(self) -> None:
   """Initializes the ImGui runner and starts the main application loop."""
   if "--headless" in sys.argv:
@@ -4109,8 +4132,6 @@ def hello():
    self.runner_params.callbacks.load_additional_fonts = self._load_fonts
    self.runner_params.callbacks.setup_imgui_style = theme.apply_current
    self.runner_params.callbacks.post_init = self._post_init
-   self.runner_params.callbacks.pre_new_frame = self._pre_new_frame
-   self.runner_params.callbacks.custom_background = self._render_custom_background
    self._fetch_models(self.current_provider)
    md_options = markdown_helper.get_renderer().options
    immapp.run(self.runner_params, add_ons_params=immapp.AddOnsParams(with_markdown_options=md_options))

src/models.py

@@ -111,6 +111,7 @@ DEFAULT_TOOL_CATEGORIES: Dict[str, List[str]] = {
 
 def parse_history_entries(history_strings: list[str], roles: list[str]) -> list[dict[str, Any]]:
  import re
+ from src import thinking_parser
  entries = []
  for raw in history_strings:
   ts = ""
@@ -128,11 +129,30 @@ def parse_history_entries(history_strings: list[str], roles: list[str]) -> list[
    content = rest[match.end():].strip()
   else:
    content = rest
-  entries.append({"role": role, "content": content, "collapsed": True, "ts": ts})
+   
+  entry_obj = {"role": role, "content": content, "collapsed": True, "ts": ts}
+  if role == "AI" and ("<thinking>" in content or "<thought>" in content or "Thinking:" in content):
+   segments, parsed_content = thinking_parser.parse_thinking_trace(content)
+   if segments:
+    entry_obj["content"] = parsed_content
+    entry_obj["thinking_segments"] = [{"content": s.content, "marker": s.marker} for s in segments]
+    
+  entries.append(entry_obj)
  return entries
 
 @dataclass
-@dataclass
+class ThinkingSegment:
+ content: str
+ marker: str # 'thinking', 'thought', or 'Thinking:'
+
+ def to_dict(self) -> Dict[str, Any]:
+  return {"content": self.content, "marker": self.marker}
+
+ @classmethod
+ def from_dict(cls, data: Dict[str, Any]) -> "ThinkingSegment":
+  return cls(content=data["content"], marker=data["marker"])
+
+
 @dataclass
 class Ticket:
  id: str
@@ -239,8 +259,6 @@ class Track:
   )
 
 
-@dataclass
-@dataclass
 @dataclass
 class WorkerContext:
  ticket_id: str

src/project_manager.py

@@ -33,6 +33,14 @@ def entry_to_str(entry: dict[str, Any]) -> str:
  ts = entry.get("ts", "")
  role = entry.get("role", "User")
  content = entry.get("content", "")
+ 
+ segments = entry.get("thinking_segments")
+ if segments:
+  for s in segments:
+   marker = s.get("marker", "thinking")
+   s_content = s.get("content", "")
+   content = f"<{marker}>\n{s_content}\n</{marker}>\n{content}"
+   
  if ts:
   return f"@{ts}\n{role}:\n{content}"
  return f"{role}:\n{content}"

src/shader_manager.py

@@ -150,325 +150,4 @@ void main() {
    gl.glUniform1f(u_time_loc, float(time))
   gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4)
   gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
-
-class BlurPipeline:
- def __init__(self):
-  self.scene_fbo: int | None = None
-  self.scene_tex: int | None = None
-  self.blur_fbo_a: int | None = None
-  self.blur_tex_a: int | None = None
-  self.blur_fbo_b: int | None = None
-  self.blur_tex_b: int | None = None
-  self.h_blur_program: int | None = None
-  self.v_blur_program: int | None = None
-  self.deepsea_program: int | None = None
-  self._quad_vao: int | None = None
-  self._fb_width: int = 0
-  self._fb_height: int = 0
-  self._fb_scale: int = 1
-
- def _compile_shader(self, vertex_src: str, fragment_src: str) -> int:
-  program = gl.glCreateProgram()
-  def _compile(src, shader_type):
-   shader = gl.glCreateShader(shader_type)
-   gl.glShaderSource(shader, src)
-   gl.glCompileShader(shader)
-   if not gl.glGetShaderiv(shader, gl.GL_COMPILE_STATUS):
-    info_log = gl.glGetShaderInfoLog(shader)
-    if hasattr(info_log, "decode"):
-     info_log = info_log.decode()
-    raise RuntimeError(f"Shader compilation failed: {info_log}")
-   return shader
-  vert_shader = _compile(vertex_src, gl.GL_VERTEX_SHADER)
-  frag_shader = _compile(fragment_src, gl.GL_FRAGMENT_SHADER)
-  gl.glAttachShader(program, vert_shader)
-  gl.glAttachShader(program, frag_shader)
-  gl.glLinkProgram(program)
-  if not gl.glGetProgramiv(program, gl.GL_LINK_STATUS):
-   info_log = gl.glGetProgramInfoLog(program)
-   if hasattr(info_log, "decode"):
-    info_log = info_log.decode()
-   raise RuntimeError(f"Program linking failed: {info_log}")
-  gl.glDeleteShader(vert_shader)
-  gl.glDeleteShader(frag_shader)
-  return program
-
- def _create_fbo(self, width: int, height: int) -> tuple[int, int]:
-  if width <= 0 or height <= 0:
-   raise ValueError(f"Invalid FBO dimensions: {width}x{height}")
-  tex = gl.glGenTextures(1)
-  gl.glBindTexture(gl.GL_TEXTURE_2D, tex)
-  gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA8, width, height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, None)
-  gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
-  gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
-  gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE)
-  gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE)
-  fbo = gl.glGenFramebuffers(1)
-  gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo)
-  gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, tex, 0)
-  gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
-  gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
-  return fbo, tex
-
- def _create_quad_vao(self) -> int:
-  import ctypes
-  vao = gl.glGenVertexArrays(1)
-  gl.glBindVertexArray(vao)
-  vertices = (ctypes.c_float * 16)(
-   -1.0, -1.0, 0.0, 0.0,
-    1.0, -1.0, 1.0, 0.0,
-   -1.0,  1.0, 0.0, 1.0,
-    1.0,  1.0, 1.0, 1.0
-  )
-  vbo = gl.glGenBuffers(1)
-  gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
-  gl.glBufferData(gl.GL_ARRAY_BUFFER, ctypes.sizeof(vertices), vertices, gl.GL_STATIC_DRAW)
-  gl.glEnableVertexAttribArray(0)
-  gl.glVertexAttribPointer(0, 2, gl.GL_FLOAT, gl.GL_FALSE, 16, None)
-  gl.glEnableVertexAttribArray(1)
-  gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT, gl.GL_FALSE, 16, ctypes.c_void_p(8))
-  gl.glBindVertexArray(0)
-  return vao
-
- def setup_fbos(self, width: int, height: int, fb_scale: float = 1.0):
-  scale = max(1, int(fb_scale))
-  blur_w = max(1, (width * scale) // 4)
-  blur_h = max(1, (height * scale) // 4)
-  self._fb_width = blur_w
-  self._fb_height = blur_h
-  self._fb_scale = scale
-  scene_w = width * scale
-  scene_h = height * scale
-  self.scene_fbo, self.scene_tex = self._create_fbo(scene_w, scene_h)
-  self.blur_fbo_a, self.blur_tex_a = self._create_fbo(blur_w, blur_h)
-  self.blur_fbo_b, self.blur_tex_b = self._create_fbo(blur_w, blur_h)
-
- def compile_blur_shaders(self):
-  vert_src = """
-#version 330 core
-layout(location = 0) in vec2 a_position;
-layout(location = 1) in vec2 a_texcoord;
-out vec2 v_uv;
-void main() {
- gl_Position = vec4(a_position, 0.0, 1.0);
- v_uv = a_texcoord;
-}
-"""
-  h_frag_src = """
-#version 330 core
-in vec2 v_uv;
-uniform sampler2D u_texture;
-uniform vec2 u_texel_size;
-out vec4 FragColor;
-void main() {
- vec2 offset = vec2(u_texel_size.x, 0.0);
- vec4 sum = vec4(0.0);
- sum += texture(u_texture, v_uv - offset * 6.0) * 0.0152;
- sum += texture(u_texture, v_uv - offset * 5.0) * 0.0300;
- sum += texture(u_texture, v_uv - offset * 4.0) * 0.0525;
- sum += texture(u_texture, v_uv - offset * 3.0) * 0.0812;
- sum += texture(u_texture, v_uv - offset * 2.0) * 0.1110;
- sum += texture(u_texture, v_uv - offset * 1.0) * 0.1342;
- sum += texture(u_texture, v_uv) * 0.1432;
- sum += texture(u_texture, v_uv + offset * 1.0) * 0.1342;
- sum += texture(u_texture, v_uv + offset * 2.0) * 0.1110;
- sum += texture(u_texture, v_uv + offset * 3.0) * 0.0812;
- sum += texture(u_texture, v_uv + offset * 4.0) * 0.0525;
- sum += texture(u_texture, v_uv + offset * 5.0) * 0.0300;
- sum += texture(u_texture, v_uv + offset * 6.0) * 0.0152;
- FragColor = sum;
-}
-"""
-  v_frag_src = """
-#version 330 core
-in vec2 v_uv;
-uniform sampler2D u_texture;
-uniform vec2 u_texel_size;
-out vec4 FragColor;
-void main() {
- vec2 offset = vec2(0.0, u_texel_size.y);
- vec4 sum = vec4(0.0);
- sum += texture(u_texture, v_uv - offset * 6.0) * 0.0152;
- sum += texture(u_texture, v_uv - offset * 5.0) * 0.0300;
- sum += texture(u_texture, v_uv - offset * 4.0) * 0.0525;
- sum += texture(u_texture, v_uv - offset * 3.0) * 0.0812;
- sum += texture(u_texture, v_uv - offset * 2.0) * 0.1110;
- sum += texture(u_texture, v_uv - offset * 1.0) * 0.1342;
- sum += texture(u_texture, v_uv) * 0.1432;
- sum += texture(u_texture, v_uv + offset * 1.0) * 0.1342;
- sum += texture(u_texture, v_uv + offset * 2.0) * 0.1110;
- sum += texture(u_texture, v_uv + offset * 3.0) * 0.0812;
- sum += texture(u_texture, v_uv + offset * 4.0) * 0.0525;
- sum += texture(u_texture, v_uv + offset * 5.0) * 0.0300;
- sum += texture(u_texture, v_uv + offset * 6.0) * 0.0152;
- FragColor = sum;
-}
-"""
-  self.h_blur_program = self._compile_shader(vert_src, h_frag_src)
-  self.v_blur_program = self._compile_shader(vert_src, v_frag_src)
-
- def compile_deepsea_shader(self):
-  vert_src = """
-#version 330 core
-layout(location = 0) in vec2 a_position;
-layout(location = 1) in vec2 a_texcoord;
-out vec2 v_uv;
-void main() {
- gl_Position = vec4(a_position, 0.0, 1.0);
- v_uv = a_texcoord;
-}
-"""
-  frag_src = """
-#version 330 core
-in vec2 v_uv;
-uniform float u_time;
-uniform vec2 u_resolution;
-out vec4 FragColor;
-
-float hash(vec2 p) {
- return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
-}
-
-float noise(vec2 p) {
- vec2 i = floor(p);
- vec2 f = fract(p);
- f = f * f * (3.0 - 2.0 * f);
- float a = hash(i);
- float b = hash(i + vec2(1.0, 0.0));
- float c = hash(i + vec2(0.0, 1.0));
- float d = hash(i + vec2(1.0, 1.0));
- return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
-}
-
-float fbm(vec2 p) {
- float v = 0.0;
- float a = 0.5;
- for (int i = 0; i < 4; i++) {
-  v += a * noise(p);
-  p *= 2.0;
-  a *= 0.5;
- }
- return v;
-}
-
-void main() {
- vec2 uv = v_uv;
- float t = u_time * 0.3;
- vec3 col = vec3(0.01, 0.05, 0.12);
- for (int i = 0; i < 3; i++) {
-  float phase = t * (0.1 + float(i) * 0.05);
-  vec2 blob_uv = uv + vec2(sin(phase), cos(phase * 0.8)) * 0.3;
-  float blob = fbm(blob_uv * 3.0 + t * 0.2);
-  col = mix(col, vec3(0.02, 0.20, 0.40), blob * 0.4);
- }
- float line_alpha = 0.0;
- for (int i = 0; i < 12; i++) {
-  float fi = float(i);
-  float offset = mod(t * 15.0 + fi * (u_resolution.x / 12.0), u_resolution.x);
-  float line_x = offset / u_resolution.x;
-  float dist = abs(uv.x - line_x);
-  float alpha = smoothstep(0.02, 0.0, dist) * (0.1 + 0.05 * sin(t + fi));
-  line_alpha += alpha;
- }
- col += vec3(0.04, 0.35, 0.55) * line_alpha;
- float vignette = 1.0 - length(uv - 0.5) * 0.8;
- col *= vignette;
- FragColor = vec4(col, 1.0);
-}
-"""
-  self.deepsea_program = self._compile_shader(vert_src, frag_src)
-  self._quad_vao = self._create_quad_vao()
-
- def render_deepsea_to_fbo(self, width: int, height: int, time: float):
-  if not self.deepsea_program or not self.scene_fbo or not self._quad_vao:
-   return
-  scene_w = width * self._fb_scale
-  scene_h = height * self._fb_scale
-  gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.scene_fbo)
-  gl.glViewport(0, 0, scene_w, scene_h)
-  gl.glClearColor(0.01, 0.05, 0.12, 1.0)
-  gl.glClear(gl.GL_COLOR_BUFFER_BIT)
-  gl.glUseProgram(self.deepsea_program)
-  u_time_loc = gl.glGetUniformLocation(self.deepsea_program, "u_time")
-  if u_time_loc != -1:
-   gl.glUniform1f(u_time_loc, time)
-  u_res_loc = gl.glGetUniformLocation(self.deepsea_program, "u_resolution")
-  if u_res_loc != -1:
-   gl.glUniform2f(u_res_loc, float(scene_w), float(scene_h))
-  gl.glBindVertexArray(self._quad_vao)
-  gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4)
-  gl.glBindVertexArray(0)
   gl.glUseProgram(0)
-  gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
-
- def _render_quad(self, program: int, src_tex: int, texel_size: tuple[float, float]):
-  gl.glUseProgram(program)
-  gl.glActiveTexture(gl.GL_TEXTURE0)
-  gl.glBindTexture(gl.GL_TEXTURE_2D, src_tex)
-  u_tex = gl.glGetUniformLocation(program, "u_texture")
-  if u_tex != -1:
-   gl.glUniform1i(u_tex, 0)
-  u_ts = gl.glGetUniformLocation(program, "u_texel_size")
-  if u_ts != -1:
-   gl.glUniform2f(u_ts, texel_size[0], texel_size[1])
-  gl.glBindVertexArray(self._quad_vao)
-  gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4)
-  gl.glBindVertexArray(0)
-  gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
-  gl.glUseProgram(0)
-
- def prepare_blur(self, width: int, height: int, time: float):
-  if not self.h_blur_program or not self.v_blur_program:
-   return
-  if not self.blur_fbo_a or not self.blur_fbo_b:
-   return
-  blur_w = max(1, self._fb_width)
-  blur_h = max(1, self._fb_height)
-  texel_x = 1.0 / float(blur_w)
-  texel_y = 1.0 / float(blur_h)
-  gl.glViewport(0, 0, blur_w, blur_h)
-  gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.blur_fbo_a)
-  gl.glClearColor(0.0, 0.0, 0.0, 0.0)
-  gl.glClear(gl.GL_COLOR_BUFFER_BIT)
-  self._render_quad(self.h_blur_program, self.scene_tex, (texel_x, texel_y))
-  gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.blur_fbo_b)
-  gl.glClear(gl.GL_COLOR_BUFFER_BIT)
-  self._render_quad(self.v_blur_program, self.blur_tex_a, (texel_x, texel_y))
-  gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
-  restore_w = width * self._fb_scale
-  restore_h = height * self._fb_scale
-  gl.glViewport(0, 0, restore_w, restore_h)
-
- def prepare_global_blur(self, width: int, height: int, time: float, fb_scale: float = 1.0):
-  if not self.scene_fbo:
-   if self._fb_scale != int(fb_scale):
-    self.setup_fbos(width, height, fb_scale)
-  self.render_deepsea_to_fbo(width, height, time)
-  self.prepare_blur(width, height, time)
-
- def get_blur_texture(self) -> int | None:
-  return self.blur_tex_b
-
- def cleanup(self):
-  fbos = [f for f in [self.scene_fbo, self.blur_fbo_a, self.blur_fbo_b] if f is not None]
-  texs = [t for t in [self.scene_tex, self.blur_tex_a, self.blur_tex_b] if t is not None]
-  progs = [p for p in [self.h_blur_program, self.v_blur_program, self.deepsea_program] if p is not None]
-  if fbos:
-   gl.glDeleteFramebuffers(len(fbos), fbos)
-  if texs:
-   gl.glDeleteTextures(len(texs), texs)
-  if progs:
-   for p in progs:
-    gl.glDeleteProgram(p)
-  if self._quad_vao:
-   gl.glDeleteVertexArrays(1, [self._quad_vao])
-  self.scene_fbo = None
-  self.scene_tex = None
-  self.blur_fbo_a = None
-  self.blur_tex_a = None
-  self.blur_fbo_b = None
-  self.blur_tex_b = None
-  self.h_blur_program = None
-  self.v_blur_program = None
-  self.deepsea_program = None
-  self._quad_vao = None

src/thinking_parser.py

@@ -0,0 +1,53 @@
+import re
+from typing import List, Tuple
+from src.models import ThinkingSegment
+
+def parse_thinking_trace(text: str) -> Tuple[List[ThinkingSegment], str]:
+ """
+ Parses thinking segments from text and returns (segments, response_content).
+ Support extraction of thinking traces from <thinking>...</thinking>, <thought>...</thought>,
+ and blocks prefixed with Thinking:.
+ """
+ segments = []
+ 
+ # 1. Extract <thinking> and <thought> tags
+ current_text = text
+ 
+ # Combined pattern for tags
+ tag_pattern = re.compile(r'<(thinking|thought)>(.*?)</\1>', re.DOTALL | re.IGNORECASE)
+ 
+ def extract_tags(txt: str) -> Tuple[List[ThinkingSegment], str]:
+  found_segments = []
+  
+  def replace_func(match):
+   marker = match.group(1).lower()
+   content = match.group(2).strip()
+   found_segments.append(ThinkingSegment(content=content, marker=marker))
+   return ""
+  
+  remaining = tag_pattern.sub(replace_func, txt)
+  return found_segments, remaining
+
+ tag_segments, remaining = extract_tags(current_text)
+ segments.extend(tag_segments)
+ 
+ # 2. Extract Thinking: prefix
+ # This usually appears at the start of a block and ends with a double newline or a response marker.
+ thinking_colon_pattern = re.compile(r'(?:^|\n)Thinking:\s*(.*?)(?:\n\n|\nResponse:|\nAnswer:|$)', re.DOTALL | re.IGNORECASE)
+ 
+ def extract_colon_blocks(txt: str) -> Tuple[List[ThinkingSegment], str]:
+  found_segments = []
+  
+  def replace_func(match):
+   content = match.group(1).strip()
+   if content:
+    found_segments.append(ThinkingSegment(content=content, marker="Thinking:"))
+   return "\n\n"
+  
+  res = thinking_colon_pattern.sub(replace_func, txt)
+  return found_segments, res
+
+ colon_segments, final_remaining = extract_colon_blocks(remaining)
+ segments.extend(colon_segments)
+ 
+ return segments, final_remaining.strip()

tests/test_frosted_glass.py

@@ -1,26 +0,0 @@
-import pytest
-from unittest.mock import patch, MagicMock
-from src.gui_2 import App
-
-
-def test_frosted_glass_disabled():
-    with patch("src.gui_2.imgui") as mock_imgui:
-        with patch("src.gui_2.gl") as mock_gl:
-            app = App()
-            app.ui_frosted_glass_enabled = False
-            app._render_frosted_background((0, 0), (100, 100))
-            assert app._blur_pipeline is None
-            mock_gl.glEnable.assert_not_called()
-            mock_gl.glBlendFunc.assert_not_called()
-            mock_gl.glBindTexture.assert_not_called()
-            mock_gl.glBegin.assert_not_called()
-            mock_gl.glEnd.assert_not_called()
-            mock_gl.glDisable.assert_not_called()
-            mock_imgui.get_io().display_size.assert_not_called()
-            mock_imgui.get_io().display_framebuffer_scale.assert_not_called()
-            mock_imgui.get_window_draw_list.assert_not_called()
-            mock_imgui.get_window_pos.assert_not_called()
-            mock_imgui.get_window_size.assert_not_called()
-            mock_imgui.get_color_u32.assert_not_called()
-            mock_imgui.push_texture_id.assert_not_called()
-            mock_imgui.pop_texture_id.assert_not_called()

tests/test_gui2_layout.py

@@ -26,84 +26,5 @@ def test_gui2_old_windows_removed_from_show_windows(app_instance: App) -> None:
   "Provider", "System Prompts",
   "Comms History"
  ]
- for old_win in old_windows:
-from src.gui_2 import App
-
-def test_gui2_hubs_exist_in_show_windows(app_instance: App) -> None:
- expected_hubs = [
-  "Context Hub",
-  "AI Settings",
-  "Discussion Hub",
-  "Operations Hub",
-  "Files & Media",
-  "Theme",
- ]
- for hub in expected_hubs:
-  assert hub in app_instance.show_windows, f"Expected hub window '{hub}' not found in show_windows"
-
-def test_gui2_old_windows_removed_from_show_windows(app_instance: App) -> None:
- old_windows = [
-  "Projects", "Files", "Screenshots",
-  "Provider", "System Prompts",
-  "Comms History"
- ]
  for old_win in old_windows:
   assert old_win not in app_instance.show_windows, f"Old window '{old_win}' should have been removed from show_windows"
-
-def test_frosted_glass_disabled():
- with patch("src.gui_2.imgui"):
-  app = App()
-  app.ui_frosted_glass_enabled = False
-  app._render_frosted_background((0, 0), (100, 100))
-  assert not app._blur_pipeline is None or not app._blur_pipeline.prepare_global_blur.called
-  imgui.get_io().display_size.assert_not_called()
-  imgui.get_io().display_framebuffer_scale.assert_not_called()
-  imgui.get_window_draw_list.assert_not_called()
-  imgui.get_window_pos.assert_not_called()
-  imgui.get_window_size.assert_not_called()
-  imgui.get_color_u32.assert_not_called()
-  imgui.push_texture_id.assert_not_called()
-  imgui.pop_texture_id.assert_not_called()
-  dl.add_image_quad.assert_not_called()
-  imgui.pop_texture_id.assert_not_called()
-  gl.glEnable.assert_not_called()
-  gl.glBlendFunc.assert_not_called()
-  gl.glBindTexture.assert_not_called()
-  gl.glBegin.assert_not_called()
-  gl.glEnd.assert_not_called()
-  gl.glDisable.assert_not_called()
-  gl.glUnbindTexture.assert_not_called()
-  gl.glDeleteTexture.assert_not_called()
-  gl.glDisable.assert_not_called()
-
-def test_frosted_glass_enabled():
- with patch("src.gui_2.imgui"):
-  with patch("src.gui_2.BlurPipeline") as mock_blur:
-   app = App()
-   app.ui_frosted_glass_enabled = True
-   app._blur_pipeline = mock_blur
-   mock_blur.return_value = BlurPipeline()
-   mock_blur.prepare_global_blur.return_value = None
-   mock_blur.get_blur_texture.return_value = 123
-   imgui.get_io().display_size = MagicMock(x=800.0, y=600.0)
-   imgui.get_io().display_framebuffer_scale = MagicMock(x=1.0, y=1.0)
-   imgui.get_window_draw_list.return_value = MagicMock()
-   imgui.get_window_pos.return_value = (100, 200)
-   imgui.get_window_size.return_value = (300, 400)
-   imgui.get_color_u32.return_value = 0xFFFFFFFF
-   dl = MagicMock()
-   imgui.get_window_draw_list.return_value = dl
-   app._render_frosted_background((100, 200), (300, 400))
-   mock_blur.get_blur_texture.assert_called_once()
-   assert dl.add_callback_texture_id.called
-   assert dl.add_callback_quadsDrawElements.called
-   imgui.push_texture_id.assert_called()
-   imgui.pop_texture_id.assert_called()
-   gl.glEnable.assert_called()
-   gl.glBlendFunc.assert_called()
-   gl.glBindTexture.assert_called()
-   gl.glBegin.assert_called()
-   gl.glEnd.assert_called()
-   gl.glDisable.assert_called()
-   gl.glUnbindTexture.assert_called()
-   gl.glDeleteTexture.assert_not_called()

tests/test_shader_manager.py

@@ -1,172 +1,6 @@
 import pytest
 from unittest.mock import patch, MagicMock
 
-def test_blur_pipeline_import():
- with patch("src.shader_manager.gl") as mock_gl:
-  from src.shader_manager import BlurPipeline
-  pipeline = BlurPipeline()
-  assert pipeline is not None
-  assert pipeline.scene_fbo is None
-  assert pipeline.blur_fbo_a is None
-  assert pipeline.blur_fbo_b is None
-  assert pipeline.scene_tex is None
-  assert pipeline.blur_tex_a is None
-  assert pipeline.blur_tex_b is None
-  assert pipeline.h_blur_program is None
-  assert pipeline.v_blur_program is None
-
-def test_blur_pipeline_setup_fbos():
- with patch("src.shader_manager.gl") as mock_gl:
-  tex_counter = iter([10, 20, 30])
-  fbo_counter = iter([1, 2, 3])
-  mock_gl.glGenTextures.side_effect = lambda n: next(tex_counter)
-  mock_gl.glGenFramebuffers.side_effect = lambda n: next(fbo_counter)
-  from src.shader_manager import BlurPipeline
-  pipeline = BlurPipeline()
-  pipeline.setup_fbos(800, 600)
-  assert mock_gl.glGenFramebuffers.called
-  assert mock_gl.glGenTextures.called
-  assert pipeline.scene_fbo is not None
-  assert pipeline.blur_fbo_a is not None
-  assert pipeline.blur_fbo_b is not None
-
-def test_blur_pipeline_compile_shaders():
- with patch("src.shader_manager.gl") as mock_gl:
-  mock_gl.glCreateProgram.return_value = 100
-  mock_gl.glCreateShader.return_value = 200
-  mock_gl.glGetShaderiv.return_value = mock_gl.GL_TRUE
-  mock_gl.glGetProgramiv.return_value = mock_gl.GL_TRUE
-  from src.shader_manager import BlurPipeline
-  pipeline = BlurPipeline()
-  pipeline.compile_blur_shaders()
-  assert mock_gl.glCreateProgram.called
-  assert pipeline.h_blur_program is not None
-  assert pipeline.v_blur_program is not None
-
-def test_blur_pipeline_wide_tap_distribution():
- with patch("src.shader_manager.gl") as mock_gl:
-  mock_gl.glCreateProgram.return_value = 100
-  mock_gl.glCreateShader.return_value = 200
-  mock_gl.glGetShaderiv.return_value = mock_gl.GL_TRUE
-  mock_gl.glGetProgramiv.return_value = mock_gl.GL_TRUE
-  from src.shader_manager import BlurPipeline
-  pipeline = BlurPipeline()
-  pipeline.compile_blur_shaders()
-  assert mock_gl.glShaderSource.called
-  shader_sources = [call.args[1] for call in mock_gl.glShaderSource.call_args_list]
-  frag_sources = [s for s in shader_sources if 'texture(' in s and 'offset' in s]
-  assert len(frag_sources) >= 2
-  for src in frag_sources:
-   texture_calls = src.count('texture(u_texture')
-   assert texture_calls >= 11, f"Expected at least 11 texture samples for wide tap distribution, got {texture_calls}"
-
-def test_blur_pipeline_render_deepsea_to_fbo():
- with patch("src.shader_manager.gl") as mock_gl:
-  tex_counter = iter([10, 20, 30])
-  fbo_counter = iter([1, 2, 3])
-  mock_gl.glGenTextures.side_effect = lambda n: next(tex_counter)
-  mock_gl.glGenFramebuffers.side_effect = lambda n: next(fbo_counter)
-  mock_gl.glCreateProgram.return_value = 300
-  mock_gl.glCreateShader.return_value = 400
-  mock_gl.glGetShaderiv.return_value = mock_gl.GL_TRUE
-  mock_gl.glGetProgramiv.return_value = mock_gl.GL_TRUE
-  from src.shader_manager import BlurPipeline
-  pipeline = BlurPipeline()
-  pipeline.setup_fbos(800, 600)
-  pipeline.compile_deepsea_shader()
-  pipeline.render_deepsea_to_fbo(800, 600, 0.0)
-  assert mock_gl.glBindFramebuffer.called
-  assert mock_gl.glUseProgram.called
-  assert mock_gl.glDrawArrays.called
-
-def test_blur_pipeline_deepsea_shader_compilation():
- with patch("src.shader_manager.gl") as mock_gl:
-  mock_gl.glCreateProgram.return_value = 500
-  mock_gl.glCreateShader.return_value = 600
-  mock_gl.glGetShaderiv.return_value = mock_gl.GL_TRUE
-  mock_gl.glGetProgramiv.return_value = mock_gl.GL_TRUE
-  from src.shader_manager import BlurPipeline
-  pipeline = BlurPipeline()
-  pipeline.compile_deepsea_shader()
-  assert mock_gl.glCreateProgram.called
-  assert pipeline.deepsea_program is not None
-
-def test_blur_pipeline_prepare_blur():
- with patch("src.shader_manager.gl") as mock_gl:
-  mock_gl.glGenFramebuffers.return_value = None
-  mock_gl.glGenTextures.return_value = None
-  from src.shader_manager import BlurPipeline
-  pipeline = BlurPipeline()
-  pipeline.scene_fbo = 1
-  pipeline.scene_tex = 10
-  pipeline.blur_fbo_a = 2
-  pipeline.blur_tex_a = 20
-  pipeline.blur_fbo_b = 3
-  pipeline.blur_tex_b = 30
-  pipeline.h_blur_program = 100
-  pipeline.v_blur_program = 101
-  pipeline.prepare_blur(800, 600, 0.0)
-  assert mock_gl.glBindFramebuffer.called
-  assert mock_gl.glUseProgram.called
-
-def test_blur_pipeline_prepare_global_blur():
- with patch("src.shader_manager.gl") as mock_gl:
-  tex_counter = iter([10, 20, 30])
-  fbo_counter = iter([1, 2, 3])
-  mock_gl.glGenTextures.side_effect = lambda n: next(tex_counter)
-  mock_gl.glGenFramebuffers.side_effect = lambda n: next(fbo_counter)
-  mock_gl.glCreateProgram.return_value = 100
-  mock_gl.glCreateShader.return_value = 200
-  mock_gl.glGetShaderiv.return_value = mock_gl.GL_TRUE
-  mock_gl.glGetProgramiv.return_value = mock_gl.GL_TRUE
-  from src.shader_manager import BlurPipeline
-  pipeline = BlurPipeline()
-  pipeline.setup_fbos(800, 600)
-  pipeline.compile_deepsea_shader()
-  pipeline.compile_blur_shaders()
-  pipeline.prepare_global_blur(800, 600, 0.0)
-  assert mock_gl.glBindFramebuffer.called
-  assert mock_gl.glUseProgram.called
-  assert mock_gl.glViewport.called
-  blur_tex = pipeline.get_blur_texture()
-  assert blur_tex is not None
-  assert blur_tex == 30
-
-def test_blur_pipeline_high_dpi_scaling():
- with patch("src.shader_manager.gl") as mock_gl:
-  tex_counter = iter([10, 20, 30])
-  fbo_counter = iter([1, 2, 3])
-  mock_gl.glGenTextures.side_effect = lambda n: next(tex_counter)
-  mock_gl.glGenFramebuffers.side_effect = lambda n: next(fbo_counter)
-  mock_gl.glCreateProgram.return_value = 100
-  mock_gl.glCreateShader.return_value = 200
-  mock_gl.glGetShaderiv.return_value = mock_gl.GL_TRUE
-  mock_gl.glGetProgramiv.return_value = mock_gl.GL_TRUE
-  from src.shader_manager import BlurPipeline
-  pipeline = BlurPipeline()
-  fb_scale = 2.0
-  pipeline.setup_fbos(800, 600, fb_scale)
-  assert pipeline._fb_width == (800 * int(fb_scale)) // 4
-  assert pipeline._fb_height == (600 * int(fb_scale)) // 4
-  assert pipeline._fb_scale == int(fb_scale)
-
-def test_blur_pipeline_cleanup():
- with patch("src.shader_manager.gl") as mock_gl:
-  from src.shader_manager import BlurPipeline
-  pipeline = BlurPipeline()
-  pipeline.scene_fbo = 1
-  pipeline.blur_fbo_a = 2
-  pipeline.blur_fbo_b = 3
-  pipeline.scene_tex = 10
-  pipeline.blur_tex_a = 20
-  pipeline.blur_tex_b = 30
-  pipeline.h_blur_program = 100
-  pipeline.v_blur_program = 101
-  pipeline.cleanup()
-  assert mock_gl.glDeleteFramebuffers.called
-  assert mock_gl.glDeleteTextures.called
-  assert mock_gl.glDeleteProgram.called
-
 def test_shader_manager_initialization_and_compilation():
  # Import inside test to allow patching OpenGL before import if needed
  # In this case, we patch the OpenGL.GL functions used by ShaderManager

tests/test_thinking_gui.py

@@ -0,0 +1,53 @@
+import pytest
+
+
+def test_render_thinking_trace_helper_exists():
+    from src.gui_2 import App
+
+    assert hasattr(App, "_render_thinking_trace"), (
+        "_render_thinking_trace helper should exist in App class"
+    )
+
+
+def test_discussion_entry_with_thinking_segments():
+    entry = {
+        "role": "AI",
+        "content": "Here's my response",
+        "thinking_segments": [
+            {"content": "Let me analyze this step by step...", "marker": "thinking"},
+            {"content": "I should consider edge cases...", "marker": "thought"},
+        ],
+        "ts": "2026-03-13T10:00:00",
+        "collapsed": False,
+    }
+    assert "thinking_segments" in entry
+    assert len(entry["thinking_segments"]) == 2
+
+
+def test_discussion_entry_without_thinking():
+    entry = {
+        "role": "User",
+        "content": "Hello",
+        "ts": "2026-03-13T10:00:00",
+        "collapsed": False,
+    }
+    assert "thinking_segments" not in entry
+
+
+def test_thinking_segment_model_compatibility():
+    from src.models import ThinkingSegment
+
+    segment = ThinkingSegment(content="test", marker="thinking")
+    assert segment.content == "test"
+    assert segment.marker == "thinking"
+    d = segment.to_dict()
+    assert d["content"] == "test"
+    assert d["marker"] == "thinking"
+
+
+if __name__ == "__main__":
+    test_render_thinking_trace_helper_exists()
+    test_discussion_entry_with_thinking_segments()
+    test_discussion_entry_without_thinking()
+    test_thinking_segment_model_compatibility()
+    print("All GUI thinking trace tests passed!")

tests/test_thinking_persistence.py

@@ -0,0 +1,94 @@
+import pytest
+import tempfile
+import os
+from pathlib import Path
+from src import project_manager
+from src.models import ThinkingSegment
+
+
+def test_save_and_load_history_with_thinking_segments():
+    with tempfile.TemporaryDirectory() as tmpdir:
+        project_path = Path(tmpdir) / "test_project"
+        project_path.mkdir()
+
+        project_file = project_path / "test_project.toml"
+        project_file.write_text("[project]\nname = 'test'\n")
+
+        history_data = {
+            "entries": [
+                {
+                    "role": "AI",
+                    "content": "Here's the response",
+                    "thinking_segments": [
+                        {"content": "Let me think about this...", "marker": "thinking"}
+                    ],
+                    "ts": "2026-03-13T10:00:00",
+                    "collapsed": False,
+                },
+                {
+                    "role": "User",
+                    "content": "Hello",
+                    "ts": "2026-03-13T09:00:00",
+                    "collapsed": False,
+                },
+            ]
+        }
+
+        project_manager.save_project(
+            {"project": {"name": "test"}}, project_file, disc_data=history_data
+        )
+
+        loaded = project_manager.load_history(project_file)
+
+        assert "entries" in loaded
+        assert len(loaded["entries"]) == 2
+
+        ai_entry = loaded["entries"][0]
+        assert ai_entry["role"] == "AI"
+        assert ai_entry["content"] == "Here's the response"
+        assert "thinking_segments" in ai_entry
+        assert len(ai_entry["thinking_segments"]) == 1
+        assert (
+            ai_entry["thinking_segments"][0]["content"] == "Let me think about this..."
+        )
+
+        user_entry = loaded["entries"][1]
+        assert user_entry["role"] == "User"
+        assert "thinking_segments" not in user_entry
+
+
+def test_entry_to_str_with_thinking():
+    entry = {
+        "role": "AI",
+        "content": "Response text",
+        "thinking_segments": [{"content": "Thinking...", "marker": "thinking"}],
+        "ts": "2026-03-13T10:00:00",
+    }
+    result = project_manager.entry_to_str(entry)
+    assert "@2026-03-13T10:00:00" in result
+    assert "AI:" in result
+    assert "Response text" in result
+
+
+def test_str_to_entry_with_thinking():
+    raw = "@2026-03-13T10:00:00\nAI:\nResponse text"
+    roles = ["User", "AI", "Vendor API", "System", "Reasoning"]
+    result = project_manager.str_to_entry(raw, roles)
+    assert result["role"] == "AI"
+    assert result["content"] == "Response text"
+    assert "ts" in result
+
+
+def test_clean_nones_removes_thinking():
+    entry = {"role": "AI", "content": "Test", "thinking_segments": None, "ts": None}
+    cleaned = project_manager.clean_nones(entry)
+    assert "thinking_segments" not in cleaned
+    assert "ts" not in cleaned
+
+
+if __name__ == "__main__":
+    test_save_and_load_history_with_thinking_segments()
+    test_entry_to_str_with_thinking()
+    test_str_to_entry_with_thinking()
+    test_clean_nones_removes_thinking()
+    print("All project_manager thinking tests passed!")

tests/test_thinking_trace.py

@@ -0,0 +1,68 @@
+from src.thinking_parser import parse_thinking_trace
+
+
+def test_parse_xml_thinking_tag():
+    raw = "<thinking>\nLet me analyze this problem step by step.\n</thinking>\nHere is the answer."
+    segments, response = parse_thinking_trace(raw)
+    assert len(segments) == 1
+    assert segments[0].content == "Let me analyze this problem step by step."
+    assert segments[0].marker == "thinking"
+    assert response == "Here is the answer."
+
+
+def test_parse_xml_thought_tag():
+    raw = "<thought>This is my reasoning process</thought>\nFinal response here."
+    segments, response = parse_thinking_trace(raw)
+    assert len(segments) == 1
+    assert segments[0].content == "This is my reasoning process"
+    assert segments[0].marker == "thought"
+    assert response == "Final response here."
+
+
+def test_parse_text_thinking_prefix():
+    raw = "Thinking:\nThis is a text-based thinking trace.\n\nNow for the actual response."
+    segments, response = parse_thinking_trace(raw)
+    assert len(segments) == 1
+    assert segments[0].content == "This is a text-based thinking trace."
+    assert segments[0].marker == "Thinking:"
+    assert response == "Now for the actual response."
+
+
+def test_parse_no_thinking():
+    raw = "This is a normal response without any thinking markers."
+    segments, response = parse_thinking_trace(raw)
+    assert len(segments) == 0
+    assert response == raw
+
+
+def test_parse_empty_response():
+    segments, response = parse_thinking_trace("")
+    assert len(segments) == 0
+    assert response == ""
+
+
+def test_parse_multiple_markers():
+    raw = "<thinking>First thinking</thinking>\n<thought>Second thought</thought>\nResponse"
+    segments, response = parse_thinking_trace(raw)
+    assert len(segments) == 2
+    assert segments[0].content == "First thinking"
+    assert segments[1].content == "Second thought"
+
+
+def test_parse_thinking_with_empty_response():
+    raw = "<thinking>Just thinking, no response</thinking>"
+    segments, response = parse_thinking_trace(raw)
+    assert len(segments) == 1
+    assert segments[0].content == "Just thinking, no response"
+    assert response == ""
+
+
+if __name__ == "__main__":
+    test_parse_xml_thinking_tag()
+    test_parse_xml_thought_tag()
+    test_parse_text_thinking_prefix()
+    test_parse_no_thinking()
+    test_parse_empty_response()
+    test_parse_multiple_markers()
+    test_parse_thinking_with_empty_response()
+    print("All thinking trace tests passed!")