feat: Release v1.9.0 - Accuracy, Context, and Interaction Overhaul

- Native Token Counting: Integrated Gemini countTokens API for 100% accuracy.
- Proactive Context: Automatic 90% threshold pruning with background summarization.
- Deep Reasoning: Native support for reasoning_content (DeepSeek/OpenRouter) and configurable UI transparency.
- Interactive Queue: New 'unroll-to-edit' logic for pending messages.
- Session Isolation: transitioned scratchpad to session-scoped storage.
- UI & Stability: Hardened background workers and thread-safe modal handling.

Author: Pomilon

README.md

@@ -4,39 +4,40 @@
 
 ![Plexir UI](assets/image.png)
 
-[![Version](https://img.shields.io/badge/version-1.8.0-blue.svg)](https://github.com/pomilon/plexir)
+[![Version](https://img.shields.io/badge/version-1.9.0-blue.svg)](https://github.com/pomilon/plexir)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 ---
 
 ## Features
 
 - **Multi-Provider Failover**: Seamlessly switch between Gemini, Groq, Cerebras, and OpenAI-compatible APIs. If one model hits a quota, Plexir automatically fails over to the next in your priority list.
-- **Economics & Metrics**: Real-time **Token Tracking** and **Cost Estimation** in the sidebar. Set a session budget via `/config budget` to prevent runaway costs.
-- **Advanced Reasoning Support**: Automatically filters model "thinking" blocks into collapsible widgets and provides a **Live Status Spinner** during reasoning.
+- **Accuracy & Economics**: 
+    - **Native Token Counting**: Integrated Gemini native token counting API for 100% accurate measurement.
+    - **Proactive Context Management**: Automatic pruning/summarization when context reaches 90% capacity to prevent truncation errors.
+    - **Cost Estimation**: Real-time tracking in the sidebar. Set a session budget via `/config budget`.
+- **Deep Reasoning Support**: Native support for `reasoning_content` (DeepSeek/OpenRouter) with configurable transparency (toggle blocks with `/config reasoning`).
+- **Responsive Interaction**:
+    - **Message Queuing**: Submit messages while the AI is busy; they appear in a "queued" state and process sequentially.
+    - **Interactive Queue Management**: Click a queued message to "unroll" the queue and pull messages back to the input for editing.
 - **Coherent Memory**:
     - **Persistent Memory Bank**: Semantic storage (`chromadb`) for long-term facts using `/memory save`.
+    - **Session-Scoped Scratchpad**: Isolated planning space (`scratchpad` tool) that persists within a session but doesn't pollute global history.
     - **Rolling Summarization**: Automatically condenses long histories.
     - **Message Pinning**: `/session pin` ensures critical context is never lost.
-    - **Context Window Management**: Intelligent token counting and history pruning ensures conversations never exceed model limits, preventing failover loops.
 - **Persistent Docker Sandbox**: Launch with `--sandbox` to give the AI its own persistent Linux "computer." All tools (file system, git, shell) are automatically redirected inside the container.
-- **Deep MCP Integration**: Fully supports **Model Context Protocol (MCP)**, including dynamic discovery of tools, **Resources**, **Resource Templates**, and **Prompts** from MCP servers.
+- **Deep MCP Integration**: Fully supports **Model Context Protocol (MCP)**, including dynamic discovery of tools, **Resources**, and **Prompts**.
 - **Smart Agent Capabilities**:
     - **Delegation**: `delegate_to_agent` allows spawning specialized sub-agents for complex tasks.
-    - **RAG & Context**: `codebase_search` allows natural language queries across your codebase. `get_definitions` quickly maps file structures.
-    - **Planning**: Built-in `scratchpad` memory for long-term planning and note-taking.
-    - **Visual Safety**: Critical actions like writing files show a **Rich Visual Diff** (Red/Green) in the confirmation modal before execution.
+    - **RAG & Context**: `codebase_search` allows natural language queries across your codebase.
+    - **Visual Safety**: Critical actions like writing files show a **Rich Visual Diff** (Red/Green) in the confirmation modal.
 - **Advanced Agentic Tools**:
     - **Filesystem**: `read_file`, `write_file`, `list_directory`, `edit_file` (precise patching).
-    - **Git Suite**: `git_status`, `git_diff`, `git_add`, `git_commit`, `git_checkout`, `git_branch`.
-    - **Enhanced Web Capabilities**: API-backed `web_search` (Tavily, Serper) with DuckDuckGo fallback and clean content extraction via `browse_url`.
-    - **Code Execution**: `python_sandbox` for isolated logic testing.
-- **Human-in-the-Loop (HITL)**: Safety first. Critical actions require explicit user confirmation.
-    - **Visual Diffs**: Review changes before they happen.
-    - **Skip/Stop**: Granular control to skip a specific tool or stop the entire process.
+    - **Dynamic Verbosity**: Level-based control over tool output detail via `/config verbosity`.
+    - **Git Suite**: Fully featured git integration including diffs and commits.
+    - **Web Capabilities**: API-backed `web_search` and clean extraction via `browse_url`.
 - **Modern TUI**: Built with [Textual](https://textual.textualize.io/), featuring:
     - **Collapsible Tool Outputs**: Keep your chat clean while preserving execution details.
-    - **Dynamic Themes**: `tokyo-night`, `hacker`, `plexir-light`.
     - **Live Workspace**: Real-time file tree updates.
     - **Command Palette**: `Ctrl+P` for quick actions.
 - **Macros & Sessions**: Record complex workflows into macros and persist chat histories across sessions.

ROADMAP.md

@@ -111,7 +111,25 @@ We have successfully implemented the core foundation and advanced agentic capabi
 
 ---
 
-## 🔮 Long Term Vision (v2.0)
+## ✅ Completed Milestones (v1.9)
+
+### 🧠 Intelligence & Context
+- [x] **Native Token Counting**: Integrated Gemini native token counting API for 100% accurate measurement.
+- [x] **Proactive Context Management**: Automatic pruning/summarization when context reaches 90% capacity.
+- [x] **Deep Reasoning Support**: Native support for `reasoning_content` (DeepSeek/OpenRouter) and tag normalization.
+- [x] **Configurable Reasoning**: Standalone `/config reasoning <on|off>` to control UI transparency of thinking blocks.
+- [x] **Session-Scoped Scratchpad**: Isolated planning space that persists within a session but doesn't pollute global history.
+
+### 🖥️ UI & Interaction
+- [x] **Interactive Message Queue**: Real-time visualization of pending messages with "queued" styling.
+- [x] **Queue "Unroll" Logic**: Interactive click-to-edit behavior that pulls queued messages back into the main input.
+- [x] **Dynamic Verbosity**: Level-based control over tool output detail via `/config verbosity`.
+
+### 🛡️ Stability & Core
+- [x] **Modal Result Pattern**: Standardized `push_screen_wait` for robust human-in-the-loop flows.
+- [x] **Race-Condition Hardening**: Improved widget composition to handle rapid LLM streaming and UI updates.
+
+---
 
 ### 1. True "IDE-Like" UI
 - [ ] **Multi-Tab Interface**: Support multiple open chat buffers or file editors simultaneously.

docs/COMMANDS.md

@@ -43,6 +43,17 @@ Sets a maximum dollar amount for the current session to prevent runaway costs.
 - **Example**: `/config budget 0.50`
 - **Example**: `/config budget 0` (disables limit)
 
+#### `/config verbosity <0|1|2>`
+Sets the application verbosity level for tool outputs.
+- **`0`**: Normal (truncated tool outputs, concise logs).
+- **`1`**: Verbose (full tool outputs, more detailed logs).
+- **`2`**: Debug (maximum detail for troubleshooting).
+- **Example**: `/config verbosity 1`
+
+#### `/config reasoning <on|off>`
+Toggles whether "Thinking" blocks (reasoning process) are expanded or collapsed by default in the chat.
+- **Example**: `/config reasoning off`
+
 #### `/config tool <domain> <key> <value>`
 Sets a configuration value for a specific tool suite. This is how you provide tokens for external services.
 - **`<domain>`**: The tool domain (e.g., `git`, `github`).
@@ -80,11 +91,13 @@ Saves and loads chat histories.
 Lists all saved session files.
 
 #### `/session save [name]`
-Saves the current conversation history to a file. If `[name]` is omitted, a timestamp is used.
+Saves the current conversation history to a file. If `[name]` is omitted, a timestamp is used. 
+*Note: This also saves the current `scratchpad` state associated with this session name.*
 - **Example**: `/session save my-feature-dev`
 
 #### `/session load <name>`
-Clears the current chat and loads a saved session.
+Clears the current chat and loads a saved session. 
+*Note: This also loads the `scratchpad` associated with the session name, ensuring planning continuity.*
 - **Example**: `/session load my-feature-dev`
 
 #### `/session delete <name>`

docs/configuration.md

@@ -30,22 +30,21 @@ Instead of plain text, you can use:
 
 Plexir automatically manages the context window to prevent model errors when conversations get too long.
 
-### Automatic Limits
-Plexir comes with pre-configured token limits for popular models (e.g., 2M tokens for Gemini 1.5 Pro, 128k for GPT-4o). When the conversation history exceeds this limit, Plexir will:
-1.  **Preserve** the most recent messages.
-2.  **Preserve** system instructions.
-3.  **Summarize/Distill** the older parts of the conversation to save space while retaining context.
+### Native Token Counting (Gemini)
+For Gemini providers, Plexir uses the **native `countTokens` API** to ensure 100% accurate token measurement. For other providers, it uses a word-based heuristic (1.3 tokens per word) to estimate usage.
+
+### Proactive Pruning
+When the current conversation history reaches **90% of the provider's context limit**, Plexir will proactively:
+1.  **Summarize/Distill** older messages (using the active LLM) to save space while retaining critical facts.
+2.  **Notify** the user with a system message in the chat.
+3.  **Accumulate** the summary at the top of the history to ensure continuity.
 
 ### Manual Configuration (`context_limit`)
-You can override the default limit for any provider. This is useful for:
-- Testing how models behave with shorter context.
-- Forcing stricter limits on "Preview" models to save costs.
+You can override the default limit for any provider. This is useful for testing shorter windows or managing costs on preview models.
+- **Example**: `/config set "Gemini Primary" context_limit 50000`
+- **Example**: `/config set "Groq Backup" context_limit 8000`
 
-To set a strict 50,000 token limit on a provider:
-```bash
-/config set "Gemini Primary" context_limit 50000
-```
-*Set to `0` or `null` to use the model's default.*
+*Setting to `0` or `null` will use the model's default limit.*
 
 ## Failover & Retries
 

docs/memory.md

@@ -20,9 +20,18 @@ You can prompt the agent to remember things directly:
 Or ask it to recall:
 > "Where did I say my keys were?"
 
-## Rolling Summarization
+## Session-Scoped Scratchpad (New in v1.9)
 
-When a conversation history becomes too large (exceeding 40 messages), Plexir automatically triggers **Rolling Summarization**. 
+For tasks that require multi-step planning and temporary note-taking, Plexir provides a `scratchpad` tool. 
+
+Unlike the global Memory Bank, the scratchpad is **session-scoped**. This means:
+- **Isolation**: Each session (started with a new run or loaded via `/session load`) has its own unique scratchpad file.
+- **Plan Continuity**: Plans made in the scratchpad are saved alongside your session. If you load a session tomorrow, the agent will see exactly where it left off in its plan.
+- **No Global Noise**: Content in one session's scratchpad won't confuse the agent in a different project or session.
+
+The agent uses the `scratchpad` tool automatically for complex tasks, but you can also view it manually in `~/.plexir/sessions/<session_id>_scratchpad.md`.
+
+## Rolling Summarization & Proactive Pruning
 
 1. **How it works**: Plexir identifies older, unpinned messages and uses the primary LLM to condense them into a concise "BACKGROUND SUMMARY."
 2. **Context Preservation**: This summary is injected at the start of the conversation, allowing the model to remember high-level decisions and context while clearing out detailed token-heavy noise.

docs/tools.md

@@ -33,7 +33,7 @@ Plexir agents are equipped with a powerful set of tools to interact with the sys
 | `save_memory` | Saves a specific fact or piece of information to long-term storage (`chromadb`). | No |
 | `search_memory` | Retrieves relevant memories based on a semantic query. | No |
 | `codebase_search` | Semantically searches code using natural language keywords. | No |
-| `scratchpad` | Reads/Writes/Clears a persistent memory file for planning. | No |
+| `scratchpad` | Reads/Writes/Clears a session-scoped memory file for planning and note-taking. | No |
 
 ## MCP & Extensibility
 

plexir/__init__.py

@@ -1 +1 @@
-__version__ = "1.8.0"
+__version__ = "1.9.0"

plexir/core/commands.py

@@ -235,6 +235,10 @@ async def _config(self, args: List[str]) -> str:
                 return await self._config_reorder(sub_args)
             elif subcommand == "debug":
                 return self._config_debug(sub_args)
+            elif subcommand == "verbosity":
+                return self._config_verbosity(sub_args)
+            elif subcommand == "reasoning":
+                return self._config_reasoning(sub_args)
             elif subcommand == "budget":
                 return self._config_budget(sub_args)
             elif subcommand == "tool":
@@ -265,6 +269,8 @@ def _config_help(self) -> str:
 - `/config delete <name>`: Delete a provider.
 - `/config reorder <name> <up|down>`: Change failover order.
 - `/config debug <on|off>`: Toggle debug mode.
+- `/config verbosity <0|1|2>`: Set verbosity level (0=Normal, 1=Verbose Tools).
+- `/config reasoning <on|off>`: Toggle expanded reasoning blocks by default.
 - `/config budget <value>`: Set session cost limit (e.g. 0.50). 0 for no limit.
 """
 
@@ -290,6 +296,8 @@ def _config_list(self) -> str:
         msg += "\n--- Application Settings ---\n"
         msg += f"Theme: `{config_manager.config.theme}`\n"
         msg += f"Debug Mode: `{'On' if config_manager.config.debug_mode else 'Off'}`\n"
+        msg += f"Verbosity: `{config_manager.config.verbosity}`\n"
+        msg += f"Expanded Reasoning: `{'On' if config_manager.config.expanded_reasoning else 'Off'}`\n"
         msg += f"Session Budget: `${config_manager.config.session_budget:.2f}`\n"
 
         # Tool specific configs
@@ -325,6 +333,11 @@ async def _config_set(self, args: List[str]) -> str:
             if value not in ("auto", "api_key", "oauth"):
                 return f"Error: Invalid auth_mode '{value}'. Use: auto, api_key, oauth."
             p_config.auth_mode = value
+        elif key == "context_limit":
+            try:
+                p_config.context_limit = int(value)
+            except ValueError:
+                return "Error: context_limit must be a number."
         else:
             return f"Error: Unknown property '{key}'."
 
@@ -375,14 +388,36 @@ async def _config_reorder(self, args: List[str]) -> str:
             return f"Error: {e}"
 
     def _config_debug(self, args: List[str]) -> str:
-        """Toggles debug mode on or off."""
+        """Toggles debug mode."""
         if not args: return "Usage: `/config debug <on|off>`"
         state = args[0].lower()
         if state in ("on", "off"):
             config_manager.update_app_setting("debug_mode", state == "on")
             return f"Debug mode set to {state}."
         return "Error: State must be 'on' or 'off'."
 
+    def _config_verbosity(self, args: List[str]) -> str:
+        """Sets the application verbosity level."""
+        if not args: return "Usage: `/config verbosity <0|1|2>`"
+        try:
+            val = int(args[0])
+            if val not in (0, 1, 2):
+                return "Error: Verbosity must be 0, 1, or 2."
+            config_manager.update_app_setting("verbosity", val)
+            return f"Verbosity level set to {val}."
+        except ValueError:
+            return "Error: Verbosity must be a number."
+
+    def _config_reasoning(self, args: List[str]) -> str:
+        """Toggles expanded reasoning process blocks."""
+        if not args: return "Usage: `/config reasoning <on|off>`"
+        state = args[0].lower()
+        if state in ("on", "off"):
+            config_manager.update_app_setting("expanded_reasoning", state == "on")
+            return f"Expanded reasoning set to {state}."
+        return "Error: State must be 'on' or 'off'."
+
+
     # --- Session Management ---
 
     async def _session(self, args: List[str]) -> str:
@@ -395,11 +430,19 @@ async def _session(self, args: List[str]) -> str:
 
         try:
             if subcommand == "save":
-                return await self.session_manager.save_session_async(self.app.history, sub_args[0] if sub_args else None)
+                name = sub_args[0] if sub_args else datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+                res = await self.session_manager.save_session_async(self.app.history, name)
+                # Update router session_id to match saved session
+                self.app.router.session_id = name
+                await self.app.router.reload_providers()
+                return res
             elif subcommand == "load":
                 if not sub_args: return "Usage: `/session load <name>`"
                 name = sub_args[0]
                 self.app.history = self.session_manager.load_session(name)
+                # Update router session_id to match loaded session for scratchpad consistency
+                self.app.router.session_id = name
+                await self.app.router.reload_providers()
                 return f"Session '{name}' loaded. Chat history updated."
             elif subcommand == "list":
                 sessions = self.session_manager.list_sessions()

plexir/core/config_manager.py

@@ -91,6 +91,8 @@ class AppConfig(BaseModel):
     mcp_servers: Dict[str, MCPServerConfig] = Field(default_factory=dict, description="Configured MCP servers.")
     theme: str = "tokyo-night"
     debug_mode: bool = False
+    verbosity: int = 0
+    expanded_reasoning: bool = False
     session_budget: float = 0.0 # 0.0 means no limit
     pricing: Dict[str, tuple[float, float]] = Field(
         default_factory=lambda: {