parishad 0.1.6__tar.gz → 0.1.8__tar.gz

{parishad-0.1.6 → parishad-0.1.8}/.gitignore

@@ -88,6 +88,7 @@ parishad_traces/
 benchmark_traces/
 gaia_benchmark.log
 gaia_results.jsonl
+requirements.txt
 
 # API keys and secrets
 secrets.yaml
@@ -158,3 +159,5 @@ local_config.yaml
 config.local.yaml
 pipeline.*.local.yaml
 
+
+

{parishad-0.1.6 → parishad-0.1.8}/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to the **Parishad** project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.8] - 2026-02-04
+
+### Fixed
+- **TUI Freeze on Windows**: Resolved GIL blocking issue that caused the TUI to freeze during llama-cpp inference by moving model execution to a separate subprocess.
+- **File Spam Prevention**: Added smart filtering to prevent unwanted file creation during general queries and math problems. Files are now only created when explicitly requested.
+- **Output Persistence**: Implemented automatic `output.json` updates with final answers for every query execution.
+
+## [0.1.7] - 2026-01-26
+
+### Fixed
+- **Memory Optimization**: Reduced default context length from 8192 to 4096 tokens to prevent VRAM saturation and freezing on 4GB GPUs (like RTX 3050).
+- **Windows TUI Rendering**: Fixed "garbage characters" in loading spinner by switching to ASCII-safe animation on Windows.
+
 ## [0.1.6] - 2026-01-26
 
 ### Fixed

{parishad-0.1.6 → parishad-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parishad
-Version: 0.1.6
+Version: 0.1.8
 Summary: A cost-aware, local-first council of heterogeneous LLMs for reliable reasoning, coding, and factual correctness
 Project-URL: Homepage, https://github.com/parishad-council/parishad
 Project-URL: Documentation, https://github.com/parishad-council/parishad#readme

parishad-0.1.8/docs/TUI_FREEZE_WINDOWS.md

@@ -0,0 +1,143 @@
+# TUI Freeze Issue on Windows - Technical Documentation
+
+> **Status: RESOLVED** ✅  
+> **Solution: Subprocess-based inference isolation**
+
+## Problem Summary
+
+The Parishad TUI froze on Windows during LLM inference when using `llama-cpp-python`. The UI would become completely unresponsive even though model inference completed successfully in the background.
+
+### Symptoms
+- TUI freezes immediately after submitting a query
+- Model inference completes (GPU usage spikes then drops)
+- Output files are generated correctly
+- TUI remains frozen until force-quit
+- **Works fine on macOS, only affects Windows**
+
+---
+
+## Root Cause
+
+### Python's Global Interpreter Lock (GIL)
+
+The `llama-cpp-python` library holds Python's GIL during C-level inference operations. This blocks **all Python threads**, including Textual's event loop.
+
+Even when inference runs in a separate thread:
+1. Main thread (Textual TUI) waits for timer callbacks
+2. Worker thread (llama-cpp) acquires GIL for C extension
+3. C extension doesn't release GIL during computation
+4. Main thread cannot execute any Python code
+5. **TUI freezes completely**
+
+### Proof
+
+Debug logging showed a 31-second gap where the TUI's timer stopped firing entirely:
+
+```
+[16:04:33.134] POLL: Timer fired...    ← LAST TIMER CALLBACK
+                                        
+     ⚠️ 31 SECONDS - NO TIMER CALLBACKS ⚠️
+                                        
+[16:05:04.329] === INFERENCE COMPLETE ===
+```
+
+This proves the GIL was held continuously during inference.
+
+---
+
+## Solution: Process Isolation
+
+Since threads share the GIL, the only solution is **true process isolation** using `subprocess.Popen`.
+
+### Architecture
+
+```
+┌─────────────────────────┐      FILE IPC      ┌─────────────────────────┐
+│    MAIN PROCESS         │  ←─────────────→  │    SUBPROCESS           │
+│    (TUI - Textual)      │                    │    (Inference)          │
+│                         │                    │                         │
+│  • Timers work ✓        │  query.txt →       │  • Loads Parishad       │
+│  • UI responsive ✓      │  ← result.json     │  • Runs council.run()   │
+│  • Polls every 500ms    │                    │  • Saves JSON result    │
+│                         │                    │                         │
+│  OWN GIL (free)         │                    │  OWN GIL (busy)         │
+└─────────────────────────┘                    └─────────────────────────┘
+```
+
+### Implementation
+
+1. Save query to `~/.parishad/temp_query.txt`
+2. Generate Python script that imports Parishad and runs inference
+3. Launch subprocess with `subprocess.Popen()` (hidden window on Windows)
+4. Poll for `temp_result.json` every 500ms
+5. Display result when file appears
+
+### Key Code
+
+```python
+# Launch subprocess - SEPARATE PROCESS = SEPARATE GIL
+self._subprocess = subprocess.Popen(
+    [python_exe, str(script_file)],
+    stdout=subprocess.PIPE,
+    stderr=subprocess.PIPE,
+    startupinfo=startupinfo,  # Hidden window on Windows
+    cwd=str(self.cwd),
+)
+
+# Poll for result (TUI stays responsive!)
+def poll_subprocess_result():
+    if result_file.exists():
+        result = json.loads(result_file.read_text())
+        display_result(result)
+    else:
+        self.set_timer(0.5, poll_subprocess_result)
+```
+
+---
+
+## Tradeoffs
+
+| Aspect | Before (Threading) | After (Subprocess) |
+|--------|-------------------|-------------------|
+| TUI responsiveness | **FROZEN** | **RESPONSIVE** |
+| GIL blocking | Yes | No |
+| Model reload per query | No | Yes (~10-15s) |
+| Memory usage | Shared | Doubled |
+| IPC complexity | Low | Medium (file-based) |
+
+The model reload overhead is acceptable because the TUI now remains usable during inference.
+
+---
+
+## Files Modified
+
+- `src/parishad/cli/code.py` - Replaced threading with subprocess-based inference
+
+---
+
+## Testing
+
+1. Run `parishad code`
+2. Submit any query
+3. Verify TUI remains responsive (can scroll, etc.)
+4. Result appears after inference completes
+
+---
+
+## Related Issues
+
+This is a known pattern in LLM TUI applications:
+
+- `anomalyco/opencode` - Issues #9269, #8229
+- `ggerganov/llama.cpp` - Issues #3135, #1793
+- `Textualize/textual` - Issues #2167, #4552
+
+All report similar symptoms: TUI freezes during LLM inference on Windows due to GIL contention.
+
+---
+
+## Future Improvements
+
+1. **Persistent subprocess** - Keep model loaded between queries
+2. **Named pipes** - Faster IPC than file polling
+3. **Model caching** - Reduce reload time

{parishad-0.1.6 → parishad-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "parishad"
-version = "0.1.6"
+version = "0.1.8"
 description = "A cost-aware, local-first council of heterogeneous LLMs for reliable reasoning, coding, and factual correctness"
 readme = "README.md"
 license = "MIT"

parishad-0.1.8/src/main.py

@@ -0,0 +1 @@
+def add_numbers(a, b):

{parishad-0.1.6 → parishad-0.1.8}/src/parishad/__init__.py

@@ -5,7 +5,7 @@ Parishad orchestrates multiple local language models into a structured "council"
 that achieves higher reliability than a single model under strict compute budgets.
 """
 
-__version__ = "0.1.6"
+__version__ = "0.1.7"
 
 from .orchestrator.engine import Parishad, ParishadEngine, PipelineConfig
 from .models.runner import ModelRunner, ModelConfig