parishad 0.1.7__tar.gz → 0.1.8__tar.gz

{parishad-0.1.7 → 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.7 → parishad-0.1.8}/CHANGELOG.md

@@ -5,6 +5,13 @@ 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parishad
-Version: 0.1.7
+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.7 → parishad-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "parishad"
-version = "0.1.7"
+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.7 → parishad-0.1.8}/src/parishad/cli/code.py

@@ -16,6 +16,8 @@ import sys
 import subprocess
 import socket
 import shutil
+import threading
+import queue
 from pathlib import Path
 from typing import Optional, Dict, List, Tuple
 
@@ -2187,6 +2189,40 @@ class ParishadApp(App):
         """Message to open setup screen from worker thread."""
         pass
     
+    # Custom messages for non-blocking thread worker communication
+    class LogMessage(Message):
+        """Non-blocking log message from worker thread."""
+        def __init__(self, text: str) -> None:
+            self.text = text
+            super().__init__()
+    
+    class SabhaResultReady(Message):
+        """Non-blocking message when Sabha result is ready."""
+        def __init__(self, trace) -> None:
+            self.trace = trace
+            super().__init__()
+    
+    class SabhaError(Message):
+        """Non-blocking message when Sabha encounters an error."""
+        def __init__(self, error: Exception, traceback_str: str) -> None:
+            self.error = error
+            self.traceback_str = traceback_str
+            super().__init__()
+    
+    class CouncilReady(Message):
+        """Non-blocking message when council initialization completes."""
+        def __init__(self, success: bool, profile: str = "", error_msg: str = "") -> None:
+            self.success = success
+            self.profile = profile
+            self.error_msg = error_msg
+            super().__init__()
+    
+    class WorkerComplete(Message):
+        """Non-blocking message when any worker completes."""
+        def __init__(self, worker_type: str) -> None:
+            self.worker_type = worker_type
+            super().__init__()
+    
     CSS = CSS
     SCREENS = {"setup": SetupScreen}
     BINDINGS = [
@@ -2204,6 +2240,12 @@ class ParishadApp(App):
         self._initializing = False  # Prevent concurrent initialization
         self._processing_query = False  # Prevent concurrent query processing
         
+        # CRITICAL FOR WINDOWS: Thread-safe result queue for native threading
+        # This bypasses Textual's worker system which causes freezes on Windows
+        self._result_queue = queue.Queue()
+        self._worker_thread = None
+        self._subprocess = None  # For subprocess-based inference
+        
         # Load config from disk
         self.config = load_parishad_config()
         
@@ -2306,8 +2348,9 @@ class ParishadApp(App):
         if self._initializing:
             return
         
-        # Run model loading asynchronously to avoid freezing UI
-        self.run_worker(self._async_initialize_council(), exclusive=True)
+        # Run model loading in a thread worker to avoid freezing UI on Windows
+        # CRITICAL: Using thread=True ensures blocking model loading doesn't freeze the TUI
+        self.run_worker(self._initialize_council_thread_worker, thread=True, exclusive=True)
     
     async def _async_initialize_council(self) -> None:
         """Async worker to initialize Sabha council without blocking UI."""
@@ -2442,6 +2485,117 @@ class ParishadApp(App):
         finally:
             self._initializing = False
     
+    def _initialize_council_thread_worker(self) -> None:
+        """
+        Initialize Sabha council in a dedicated thread worker.
+        
+        CRITICAL FOR WINDOWS: This method runs in a real OS thread (not an asyncio executor)
+        which prevents the TUI from freezing during blocking model loading.
+        
+        UI updates are sent via non-blocking post_message to prevent deadlock.
+        """
+        if self._initializing:
+            self.post_message(self.LogMessage("[yellow]Already initializing...[/yellow]\n"))
+            return
+        
+        self._initializing = True
+        
+        try:
+            from parishad.orchestrator.engine import Parishad
+            from parishad.config.user_config import load_user_config
+            
+            self.post_message(self.LogMessage("[cyan]🔄 Initializing Sabha council...[/cyan]\n"))
+            
+            # Load user config for profile (same as CLI run does)
+            user_cfg = load_user_config()
+            profile = user_cfg.default_profile
+            mode = user_cfg.default_mode
+            
+            self.post_message(self.LogMessage(f"[dim]  • Profile: {profile}[/dim]\n"))
+            self.post_message(self.LogMessage(f"[dim]  • Mode: {mode}[/dim]\n"))
+            
+            # Get pipeline config from Sabha selection
+            if self.config:
+                config_name = self.config.get_pipeline_config()
+                self.post_message(self.LogMessage(f"[dim]  • Pipeline: {config_name}[/dim]\n"))
+            else:
+                config_name = "core"  # Default fallback
+                self.post_message(self.LogMessage(f"[dim]  • Pipeline: {config_name} (default)[/dim]\n"))
+            
+            self.post_message(self.LogMessage(f"[yellow]⏳ Loading models (this may take 30-60 seconds)...[/yellow]\n"))
+            self.post_message(self.LogMessage(f"[dim]  • Creating Parishad engine...[/dim]\n"))
+            
+            # Build user_forced_config from model_map
+            user_forced_config = {}
+            if self.config and self.config.model_map:
+                # Initialize manager to resolve paths
+                from parishad.models.downloader import ModelManager
+                model_manager = ModelManager()
+                
+                msg_backend = self.config.backend or "ollama"
+                
+                for slot, model_id in self.config.model_map.items():
+                    # Default to current config backend
+                    current_backend = msg_backend
+                    model_file = None
+                    
+                    # Check if it's a known model to resolve backend/path
+                    model_info = model_manager.registry.get(model_id)
+                    if model_info:
+                        # Handle Enum comparison correctly
+                        source = model_info.source.value if hasattr(model_info.source, "value") else str(model_info.source)
+                        
+                        if source == "local":
+                            current_backend = "llama_cpp"
+                            model_file = str(model_info.path)
+                        elif source == "ollama":
+                            current_backend = "ollama"
+                        elif source == "mlx":
+                            current_backend = "mlx"
+                    else:
+                        # Fallback heuristics if not in registry
+                        if model_id.startswith("local:"):
+                            current_backend = "llama_cpp"
+                        elif model_id.startswith("ollama:") or ":" in model_id:
+                            current_backend = "ollama"
+
+                    user_forced_config[slot] = {
+                        "model_id": model_id,
+                        "backend_type": current_backend
+                    }
+                    if model_file:
+                        user_forced_config[slot]["model_file"] = model_file
+
+            # Create the Parishad engine (blocking call in this thread)
+            self.council = Parishad(
+                config=config_name,
+                model_config_path=None,  # Let engine use profiles + models.yaml
+                profile=profile,
+                pipeline_config_path=None,
+                trace_dir=None,
+                mock=False,
+                stub=False,
+                mode=mode,
+                user_forced_config=user_forced_config or None,
+                no_retry=False,
+            )
+            
+            if self.council:
+                self.post_message(self.CouncilReady(success=True, profile=profile))
+            else:
+                self.post_message(self.CouncilReady(success=False, error_msg="Council initialization returned None"))
+            
+        except Exception as e:
+            import traceback
+            tb = traceback.format_exc()
+            self.post_message(self.CouncilReady(
+                success=False, 
+                error_msg=f"{type(e).__name__}: {e}\n{tb}"
+            ))
+            self.council = None
+        finally:
+            self._initializing = False
+    
     # DEPRECATED: TUI now uses same engine setup as CLI 'parishad run'
     # This method is no longer called
     # def _create_model_config_from_tui(self):
@@ -2626,8 +2780,145 @@ class ParishadApp(App):
             self.log_message("[yellow]⚠ Already processing a query, please wait...[/yellow]")
             return
         
-        # Run Sabha execution asynchronously to prevent UI freezing
-        self.run_worker(self._async_run_sabha(final_prompt, progress), exclusive=True)
+        # CRITICAL FOR WINDOWS: The GIL blocks Textual's event loop during llama-cpp inference
+        # even when using threads. We use subprocess.Popen to spawn a SEPARATE Python process.
+        # This is the only way to keep the TUI responsive on Windows with llama-cpp-python.
+        # See: docs/TUI_FREEZE_WINDOWS.md for full technical explanation.
+        self._processing_query = True
+        
+        # Save query to temp file for subprocess to read
+        query_file = Path.home() / ".parishad" / "temp_query.txt"
+        result_file = Path.home() / ".parishad" / "temp_result.json"
+        status_file = Path.home() / ".parishad" / "temp_status.txt"
+        
+        # Clean up old files
+        for f in [result_file, status_file]:
+            if f.exists():
+                f.unlink()
+        
+        query_file.write_text(final_prompt, encoding="utf-8")
+        
+        # Get the Python executable path
+        python_exe = sys.executable
+        
+        # Build inline script that runs inference and saves result
+        inline_script = f'''
+import sys
+import json
+from pathlib import Path
+
+query_file = Path(r"{query_file}")
+result_file = Path(r"{result_file}")
+status_file = Path(r"{status_file}")
+
+try:
+    status_file.write_text("starting", encoding="utf-8")
+    
+    query = query_file.read_text(encoding="utf-8")
+    
+    status_file.write_text("loading", encoding="utf-8")
+    
+    # Import and run inference
+    from parishad.orchestrator.engine import Parishad
+    from parishad.config.user_config import load_user_config
+    
+    user_cfg = load_user_config()
+    
+    council = Parishad(
+        config="core",
+        profile=user_cfg.default_profile,
+        mode=user_cfg.default_mode,
+    )
+    
+    status_file.write_text("running", encoding="utf-8")
+    
+    trace = council.run(query)
+    
+    status_file.write_text("complete", encoding="utf-8")
+    
+    # Save result as JSON
+    result = {{
+        "success": True,
+        "roles": len(trace.roles),
+        "tokens": trace.total_tokens,
+        "final_answer": trace.final_answer.final_answer if trace.final_answer else None,
+        "error": trace.error,
+    }}
+    result_file.write_text(json.dumps(result, indent=2), encoding="utf-8")
+    
+except Exception as e:
+    import traceback
+    result = {{
+        "success": False,
+        "error": str(e),
+        "traceback": traceback.format_exc()
+    }}
+    result_file.write_text(json.dumps(result, indent=2), encoding="utf-8")
+    status_file.write_text("error", encoding="utf-8")
+'''
+        
+        # Write script to temp file
+        script_file = Path.home() / ".parishad" / "temp_inference_script.py"
+        script_file.write_text(inline_script, encoding="utf-8")
+        
+        # Launch subprocess - runs in a COMPLETELY SEPARATE PROCESS (no GIL sharing!)
+        # Use CREATE_NO_WINDOW on Windows to avoid console popup
+        startupinfo = None
+        if sys.platform == "win32":
+            startupinfo = subprocess.STARTUPINFO()
+            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+            startupinfo.wShowWindow = 0  # SW_HIDE
+        
+        self._subprocess = subprocess.Popen(
+            [python_exe, str(script_file)],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            startupinfo=startupinfo,
+            cwd=str(self.cwd),
+        )
+        
+        # Poll for result file
+        def poll_subprocess_result():
+            # Check if result file exists (inference complete)
+            if result_file.exists():
+                try:
+                    result = json.loads(result_file.read_text(encoding="utf-8"))
+                    
+                    if result.get("success"):
+                        # Display the result
+                        self.log_message(f"\n[dim]━━━ Sabha Activity ({result.get('roles')} roles, {result.get('tokens')} tokens) ━━━[/dim]")
+                        
+                        if result.get("final_answer"):
+                            self.log_message(f"\n[bold]👑 Raja's Answer:[/bold]\n{result['final_answer']}\n")
+                        elif result.get("error"):
+                            self.log_message(f"\n[red]Error: {result['error']}[/red]")
+                        else:
+                            self.log_message("\n[green]Query completed successfully![/green]")
+                    else:
+                        self.log_message(f"\n[red]Error: {result.get('error')}[/red]\n[dim]{result.get('traceback', '')[:500]}...[/dim]")
+                    
+                    # Cleanup temp files
+                    for f in [result_file, status_file, script_file]:
+                        try:
+                            f.unlink()
+                        except:
+                            pass
+                    
+                    self._processing_query = False
+                    try:
+                        self.query_one("#prompt-input", Input).focus()
+                    except:
+                        pass
+                    
+                except Exception:
+                    self._processing_query = False
+            else:
+                # Keep polling until result is ready
+                if self._processing_query:
+                    self.set_timer(0.5, poll_subprocess_result)
+        
+        # Start polling for result
+        self.set_timer(0.5, poll_subprocess_result)
     
     async def _async_run_sabha(self, query: str, progress: RoleProgressBar) -> None:
         """Execute Sabha council asynchronously to prevent UI freezing."""
@@ -2740,6 +3031,315 @@ class ParishadApp(App):
             except:
                 pass
     
+    def _native_sabha_worker(self, query: str) -> None:
+        """
+        Native Python thread worker for Sabha execution.
+        
+        CRITICAL FOR WINDOWS: This uses a regular Python thread and a thread-safe
+        queue instead of Textual's worker system which causes freezes on Windows.
+        """
+        debug_log(">>> WORKER THREAD STARTED <<<")
+        debug_log(f"Worker thread ID: {threading.current_thread().ident}")
+        debug_log(f"Query to process: {query[:100]}...")
+        
+        try:
+            # Run the blocking inference in this native thread
+            debug_log("Calling self.council.run()... (this will block)")
+            debug_log("=== INFERENCE START ===")
+            
+            trace = self.council.run(query)
+            
+            debug_log("=== INFERENCE COMPLETE ===")
+            debug_log(f"Trace received: {trace is not None}")
+            if trace:
+                debug_log(f"Trace roles: {len(trace.roles)}, tokens: {trace.total_tokens}")
+            
+            # Put result in queue (thread-safe, non-blocking)
+            debug_log("Putting result in queue...")
+            self._result_queue.put(("success", trace))
+            debug_log("Result queued successfully!")
+            
+        except Exception as e:
+            import traceback
+            tb = traceback.format_exc()
+            debug_log(f"!!! WORKER ERROR: {type(e).__name__}: {e}")
+            debug_log(f"Traceback: {tb[:500]}")
+            # Put error in queue
+            self._result_queue.put(("error", (e, tb)))
+            debug_log("Error queued.")
+        
+        debug_log(">>> WORKER THREAD EXITING <<<")
+    
+    def _poll_result_queue(self) -> None:
+        """
+        Timer callback to poll the result queue for Sabha results.
+        
+        This is called by a Textual timer and runs on the main event loop thread,
+        so it's safe to update the UI directly.
+        """
+        debug_log("POLL: Timer fired, checking queue...")
+        
+        try:
+            # Non-blocking check for results
+            result_type, result_data = self._result_queue.get_nowait()
+            
+            debug_log(f"POLL: Got result from queue! Type: {result_type}")
+            
+            # Process the result on the main thread (safe for UI updates)
+            if result_type == "success":
+                debug_log("POLL: Processing success result, calling _display_sabha_result_direct...")
+                self._display_sabha_result_direct(result_data)
+                debug_log("POLL: Display complete!")
+            else:
+                debug_log("POLL: Processing error result...")
+                error, tb = result_data
+                self.log_message(f"\n[red]Error ({type(error).__name__}): {error}[/red]\n[dim]{tb[:500]}...[/dim]")
+            
+            # Clean up
+            debug_log("POLL: Cleaning up, setting _processing_query = False")
+            self._processing_query = False
+            try:
+                self.query_one("#prompt-input", Input).focus()
+                debug_log("POLL: Input refocused!")
+            except Exception:
+                debug_log("POLL: Could not refocus input")
+            
+            debug_log("=== QUERY EXECUTION COMPLETE ===")
+            
+        except queue.Empty:
+            # No result yet, keep polling
+            if self._processing_query:
+                # Don't log every tick to avoid log spam, just every 10th
+                self.set_timer(0.1, self._poll_result_queue)
+    
+    def _display_sabha_result_direct(self, trace) -> None:
+        """Display Sabha result directly (called from main thread via poll timer)."""
+        # Update progress bar based on trace
+        try:
+            progress = self.query_one("#role-progress", RoleProgressBar)
+            for role_output in trace.roles:
+                role_name = role_output.role.lower()
+                progress.mark_complete(role_name)
+        except Exception:
+            pass  # Progress bar update is non-critical
+        
+        # Display role activity summary (collapsible style)
+        self.log_message(f"\n[dim]━━━ Sabha Activity ({len(trace.roles)} roles, {trace.total_tokens} tokens) ━━━[/dim]")
+        
+        for role_output in trace.roles:
+            role_name = role_output.role.lower()
+            info = ROLE_INFO.get(role_name, {"emoji": "❓", "name": role_name.title()})
+            status_icon = "[green]✓[/green]" if role_output.status == "success" else "[red]✗[/red]"
+            
+            # Brief summary of what the role did
+            summary = ""
+            if role_name == "darbari" and role_output.core_output:
+                task_type = role_output.core_output.get("task_type", "unknown")
+                summary = f"→ Task: {task_type}"
+            elif role_name == "majumdar" and role_output.core_output:
+                steps = role_output.core_output.get("steps", [])
+                summary = f"→ {len(steps)} step plan"
+            elif role_name == "prerak" and role_output.core_output:
+                flags = role_output.core_output.get("flags", [])
+                if not flags:
+                    summary = "→ No issues"
+                else:
+                    summary = f"→ {len(flags)} issue(s)"
+            elif role_name == "raja" and role_output.core_output:
+                conf = role_output.core_output.get("confidence", 0)
+                summary = f"→ Confidence: {int(conf*100)}%"
+            
+            # Show model used
+            model_str = ""
+            if role_output.metadata and role_output.metadata.model_id:
+                mid = role_output.metadata.model_id
+                if "/" in mid:
+                    mid = mid.split("/")[-1]
+                if mid.endswith(".gguf"):
+                    mid = mid[:-5]
+                model_str = f"[dim]({mid})[/dim]"
+
+            if role_output.status == "error":
+                err_msg = role_output.error or "Unknown error"
+                summary = f"[red]{err_msg}[/red]"
+
+            self.log_message(f"  {info['emoji']} {info['name']} {model_str}: {status_icon} {summary}")
+        
+        self.log_message(f"[dim]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/dim]\n")
+        
+        # Check for file generation
+        for role_output in trace.roles:
+            if role_output.core_output and role_output.core_output.get("target_file"):
+                fpath = role_output.core_output.get("target_file")
+                self.log_message(f"\n[bold blue]📁 File Generated:[/bold blue] {fpath}")
+
+        # Display the final answer from Raja
+        if trace.final_answer:
+            answer = trace.final_answer.final_answer
+            self.log_message(f"\n[bold]👑 Raja's Answer:[/bold]\n{answer}\n")
+        elif trace.error:
+            self.log_message(f"\n[red]Error: {trace.error}[/red]")
+        else:
+            file_gen = any(r.core_output and r.core_output.get("target_file") for r in trace.roles)
+            if not file_gen:
+                self.log_message("\n[yellow]No answer generated[/yellow]")
+    
+    def _run_sabha_thread_worker(self, query: str) -> None:
+        """
+        Execute Sabha council in a dedicated thread worker.
+        
+        CRITICAL FOR WINDOWS: This method runs in a real OS thread (not an asyncio executor)
+        which prevents the TUI from freezing during blocking llama-cpp inference.
+        
+        UI updates are sent via non-blocking post_message to prevent deadlock.
+        """
+        if self._processing_query:
+            return
+        
+        self._processing_query = True
+        
+        try:
+            # Run the blocking inference in this thread
+            # This won't freeze the UI because it's a real thread worker
+            trace = self.council.run(query)
+            
+            # Send non-blocking message with result (won't deadlock!)
+            self.post_message(self.SabhaResultReady(trace))
+            
+        except Exception as e:
+            import traceback
+            tb = traceback.format_exc()
+            # Send non-blocking error message
+            self.post_message(self.SabhaError(e, tb))
+        finally:
+            self._processing_query = False
+            # Send non-blocking completion message
+            self.post_message(self.WorkerComplete("sabha"))
+    
+    def on_parishad_app_log_message(self, message: LogMessage) -> None:
+        """Handle non-blocking log messages from worker threads."""
+        self.log_message(message.text)
+    
+    def on_parishad_app_sabha_result_ready(self, message: SabhaResultReady) -> None:
+        """Handle Sabha result from worker thread (non-blocking)."""
+        trace = message.trace
+        
+        # Update progress bar based on trace
+        try:
+            progress = self.query_one("#role-progress", RoleProgressBar)
+            for role_output in trace.roles:
+                role_name = role_output.role.lower()
+                progress.mark_complete(role_name)
+        except Exception:
+            pass  # Progress bar update is non-critical
+        
+        # Display role activity summary (collapsible style)
+        self.log_message(f"\n[dim]━━━ Sabha Activity ({len(trace.roles)} roles, {trace.total_tokens} tokens) ━━━[/dim]")
+        
+        for role_output in trace.roles:
+            role_name = role_output.role.lower()
+            info = ROLE_INFO.get(role_name, {"emoji": "❓", "name": role_name.title()})
+            status_icon = "[green]✓[/green]" if role_output.status == "success" else "[red]✗[/red]"
+            
+            # Brief summary of what the role did
+            summary = ""
+            if role_name == "darbari" and role_output.core_output:
+                task_type = role_output.core_output.get("task_type", "unknown")
+                summary = f"→ Task: {task_type}"
+            elif role_name == "majumdar" and role_output.core_output:
+                steps = role_output.core_output.get("steps", [])
+                summary = f"→ {len(steps)} step plan"
+            elif role_name == "prerak" and role_output.core_output:
+                flags = role_output.core_output.get("flags", [])
+                if not flags:
+                    summary = "→ No issues"
+                else:
+                    summary = f"→ {len(flags)} issue(s)"
+            elif role_name == "raja" and role_output.core_output:
+                conf = role_output.core_output.get("confidence", 0)
+                summary = f"→ Confidence: {int(conf*100)}%"
+            
+            # Show model used
+            model_str = ""
+            if role_output.metadata and role_output.metadata.model_id:
+                mid = role_output.metadata.model_id
+                # Strip path
+                if "/" in mid:
+                    mid = mid.split("/")[-1]
+                # Strip extension (optional but cleaner)
+                if mid.endswith(".gguf"):
+                    mid = mid[:-5]
+                model_str = f"[dim]({mid})[/dim]"
+
+            if role_output.status == "error":
+                err_msg = role_output.error or "Unknown error"
+                # Show full error
+                summary = f"[red]{err_msg}[/red]"
+
+            self.log_message(f"  {info['emoji']} {info['name']} {model_str}: {status_icon} {summary}")
+        
+        self.log_message(f"[dim]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/dim]\n")
+        
+        # Check for silent file generation (common source of confusion)
+        for role_output in trace.roles:
+            if role_output.core_output and role_output.core_output.get("target_file"):
+                fpath = role_output.core_output.get("target_file")
+                self.log_message(f"\n[bold blue]📁 File Generated:[/bold blue] {fpath}")
+
+        # Display the final answer from Raja
+        if trace.final_answer:
+            answer = trace.final_answer.final_answer
+            self.log_message(f"\n[bold]👑 Raja's Answer:[/bold]\n{answer}\n")
+        elif trace.error:
+            self.log_message(f"\n[red]Error: {trace.error}[/red]")
+        else:
+            # Check if we generated a file but no text answer
+            file_gen = any(r.core_output and r.core_output.get("target_file") for r in trace.roles)
+            if not file_gen:
+                self.log_message("\n[yellow]No answer generated[/yellow]")
+    
+    def on_parishad_app_sabha_error(self, message: SabhaError) -> None:
+        """Handle Sabha error from worker thread (non-blocking)."""
+        self.log_message(f"\n[red]Error ({type(message.error).__name__}): {message.error}[/red]\n[dim]{message.traceback_str[:500]}...[/dim]")
+    
+    def on_parishad_app_worker_complete(self, message: WorkerComplete) -> None:
+        """Handle worker completion - refocus input."""
+        try:
+            self.query_one("#prompt-input", Input).focus()
+        except Exception:
+            pass
+    
+    def on_parishad_app_council_ready(self, message: CouncilReady) -> None:
+        """Handle council initialization completion (non-blocking)."""
+        if message.success:
+            self.log_message(
+                f"[green]✅ Sabha council ready![/green]\n"
+                f"[dim]Models loaded from profile '{message.profile}'[/dim]\n"
+                f"[dim]You can now start asking questions.[/dim]\n"
+            )
+        else:
+            self.log_message(
+                f"[red]✗ Error loading Sabha council:[/red]\n"
+                f"[dim]{message.error_msg}[/dim]\n"
+            )
+    
+    # Keep these for backward compatibility but they are no longer used for thread workers
+    def _display_sabha_result(self, trace) -> None:
+        """Display Sabha result on main thread (DEPRECATED - use message handlers now)."""
+        # Delegate to message handler
+        self.on_parishad_app_sabha_result_ready(self.SabhaResultReady(trace))
+    
+    def _display_sabha_error(self, error: Exception, tb: str) -> None:
+        """Display Sabha error on main thread (DEPRECATED - use message handlers now)."""
+        self.on_parishad_app_sabha_error(self.SabhaError(error, tb))
+    
+    def _refocus_input(self) -> None:
+        """Refocus input widget after query completion (DEPRECATED - use message handlers now)."""
+        try:
+            self.query_one("#prompt-input", Input).focus()
+        except Exception:
+            pass
+    
     def handle_command(self, parsed: ParsedInput) -> None:
         """Handle slash commands with ParsedInput."""
         cmd = parsed.command_name

{parishad-0.1.7 → parishad-0.1.8}/src/parishad/orchestrator/engine.py

@@ -656,23 +656,47 @@ class ParishadEngine:
              content = output.core_output.get("content")
              
              if target_file and content:
-                 try:
-                     # Use FS tool to write
-                     logger.info(f"Writing file {target_file} via Sainik")
-                     
-                     # Simple content write
-                     result = self.fs_tool.run("write", path=target_file, content=content)
-                     
-                     if not result.success:
-                         logger.error(f"Failed to write file {target_file}: {result.error}")
-                         output.error = f"File write failed: {result.error}"
-                         # Optionally mark partial success?
-                     else:
-                         logger.info(f"Successfully wrote {target_file}")
+                 # Smart filter: Only write files if user explicitly requested it
+                 # Check if the query contains file-related keywords
+                 query_lower = ctx.user_query.lower()
+                 file_keywords = [
+                     'create', 'write', 'save', 'generate', 'make', 'update', 'modify',
+                     'file', 'script', '.py', '.txt', '.md', '.json', '.yaml', '.yml',
+                     'to file', 'in file', 'save to', 'write to'
+                 ]
+                 
+                 # Check if any file keyword is in the query
+                 should_write_file = any(keyword in query_lower for keyword in file_keywords)
+                 
+                 # Also check for specific file path mentions (e.g., "src/main.py")
+                 import re
+                 file_path_pattern = r'\b[\w/\\]+\.\w+\b'
+                 if re.search(file_path_pattern, ctx.user_query):
+                     should_write_file = True
+                 
+                 if should_write_file:
+                     try:
+                         # Use FS tool to write
+                         logger.info(f"Writing file {target_file} via Sainik")
                          
-                 except Exception as e:
-                     logger.error(f"Error handling file write for {target_file}: {e}")
-                     output.error = f"File write exception: {str(e)}"
+                         # Simple content write
+                         result = self.fs_tool.run("write", path=target_file, content=content)
+                         
+                         if not result.success:
+                             logger.error(f"Failed to write file {target_file}: {result.error}")
+                             output.error = f"File write failed: {result.error}"
+                             # Optionally mark partial success?
+                         else:
+                             logger.info(f"Successfully wrote {target_file}")
+                             
+                     except Exception as e:
+                         logger.error(f"Error handling file write for {target_file}: {e}")
+                         output.error = f"File write exception: {str(e)}"
+                 else:
+                     logger.info(f"Skipping file write for {target_file} - no file creation keyword detected in query")
+                     # Clear the target_file from output to prevent confusion
+                     if "target_file" in output.core_output:
+                         output.core_output["target_file"] = None
 
         # Phase 13: General Tool Execution (Agentic)
         if role_name == "sainik" and output.status == "success":
@@ -884,6 +908,9 @@ class ParishadEngine:
         if self.trace_dir:
             self._save_trace(trace)
         
+        # Save final answer to output.json in workspace root
+        self._save_output_json(trace)
+        
         logger.info(
             f"Parishad run complete: {ctx.query_id} "
             f"(tokens: {ctx.tokens_used}/{budget}, success: {success})"
@@ -965,6 +992,31 @@ class ParishadEngine:
             f.write(trace.to_json())
         
         logger.debug(f"Trace saved: {filepath}")
+    
+    def _save_output_json(self, trace: Trace) -> None:
+        """Save final answer to output.json in workspace root."""
+        try:
+            import json
+            from pathlib import Path
+            
+            # Get the workspace root (current working directory)
+            output_path = Path.cwd() / "output.json"
+            
+            # Extract the final answer text
+            if trace.final_answer:
+                output_content = trace.final_answer.final_answer
+            else:
+                output_content = "No answer generated"
+            
+            # Write the output to output.json
+            with open(output_path, "w", encoding="utf-8") as f:
+                json.dump(output_content, f, indent=2, ensure_ascii=False)
+            
+            logger.debug(f"Output saved to: {output_path}")
+            
+        except Exception as e:
+            logger.warning(f"Failed to save output.json: {e}")
+
 
 
 class Parishad:

{parishad-0.1.7 → parishad-0.1.8}/src/parishad/roles/sainik.py

@@ -52,8 +52,12 @@ You must ALWAYS respond with a valid JSON object in the following format:
 Guidelines:
 - If writing code, put the COMPLETE runnable code in "content".
 - If writing text, put the clear explanation in "content".
-- If the user asked to change/create a file, you MUST specify "target_file".
-- IMPORTANT: Do NOT create files unless explicitly asked! For general questions/explanations, keep "target_file": null.
+- **CRITICAL: ONLY set "target_file" if the user EXPLICITLY asks to create/save/write a file with a specific filename.**
+- Examples where you SHOULD set target_file: "create a script called math_utils.py", "save this to config.json", "write code in src/main.py"
+- Examples where you should NOT set target_file: "what is 2+2", "write code to add numbers", "how do I calculate X", "solve this math problem", "explain Y"
+- For math problems, explanations, and general questions: Put the answer in "content" and set "target_file": null
+- NEVER write to docs/ directory unless explicitly instructed to do so by the user.
+- NEVER create files just because you're writing code - only if the user wants to SAVE it to a file.
 - "target_file" should be relative to the current directory (e.g., "src/main.py").
 - If "target_file" is a text/markdown/json file (not executable code), put the RAW content in "content". DO NOT write a Python script to create it.
 - If you need to Use a tool, add it to `tool_calls`. Available tools will be listed in the prompt.