project toml

# Conflicts:
#	config.toml
#	manual_slop.toml

MainContext.md

@@ -12,16 +12,16 @@ Is a local GUI tool for manually curating and sending context to AI APIs. It agg
 - `uv` - package/env management
 
 **Files:**
-- `gui.py` - main GUI, `App` class, all panels, all callbacks, confirmation dialog, layout persistence, rich comms rendering; `[+ Maximize]` buttons in `ConfirmDialog` and `win_script_output` now pass text directly as `user_data` / read from `self._last_script` / `self._last_output` instance vars instead of `dpg.get_value(tag)` — fixes glitch when word-wrap is ON or dialog is dismissed before viewer opens
-- `ai_client.py` - unified provider wrapper, model listing, session management, send, tool/function-call loop, comms log, provider error classification, token estimation, and aggressive history truncation
-- `aggregate.py` - reads config, collects files/screenshots/discussion, builds `file_items` with `mtime` for cache optimization, writes numbered `.md` files to `output_dir` using `build_markdown_from_items` to avoid double I/O; `run()` returns `(markdown_str, path, file_items)` tuple; `summary_only=False` by default (full file contents sent, not heuristic summaries)
+- `gui.py` - main GUI, `App` class, all panels, all callbacks, confirmation dialog, layout persistence, rich comms rendering
+- `ai_client.py` - unified provider wrapper, model listing, session management, send, tool/function-call loop, comms log, provider error classification
+- `aggregate.py` - reads config, collects files/screenshots/discussion, writes numbered `.md` files to `output_dir`
 - `shell_runner.py` - subprocess wrapper that runs PowerShell scripts sandboxed to `base_dir`, returns stdout/stderr/exit code as a string
 - `session_logger.py` - opens timestamped log files at session start; writes comms entries as JSON-L and tool calls as markdown; saves each AI-generated script as a `.ps1` file
 - `project_manager.py` - per-project .toml load/save, entry serialisation (entry_to_str/str_to_entry with @timestamp support), default_project/default_discussion factories, migrate_from_legacy_config, flat_config for aggregate.run(), git helpers (get_git_commit, get_git_log)
 - `theme.py` - palette definitions, font loading, scale, load_from_config/save_to_config
 - `gemini.py` - legacy standalone Gemini wrapper (not used by the main GUI; superseded by `ai_client.py`)
 - `file_cache.py` - stub; Anthropic Files API path removed; kept so stale imports don't break
-- `mcp_client.py` - MCP-style tools (read_file, list_directory, search_files, get_file_summary, web_search, fetch_url); allowlist enforced against project file_items + base_dirs for file tools; web tools are unrestricted; dispatched by ai_client tool-use loop for both Anthropic and Gemini
+- `mcp_client.py` - MCP-style read-only file tools (read_file, list_directory, search_files, get_file_summary); allowlist enforced against project file_items + base_dirs; dispatched by ai_client tool-use loop for both Anthropic and Gemini
 - `summarize.py` - local heuristic summariser (no AI); .py via AST, .toml via regex, .md headings, generic preview; used by mcp_client.get_file_summary and aggregate.build_summary_section
 - `config.toml` - global-only settings: [ai] provider+model+system_prompt, [theme] palette+font+scale, [projects] paths array + active path
 - `manual_slop.toml` - per-project file: [project] name+git_dir+system_prompt+main_context, [output] namespace+output_dir, [files] base_dir+paths, [screenshots] base_dir+paths, [discussion] roles+active+[discussion.discussions.<name>] git_commit+last_updated+history
@@ -87,7 +87,7 @@ Is a local GUI tool for manually curating and sending context to AI APIs. It agg
 - All tool calls (script + result/rejection) are appended to `_tool_log` and displayed in the Tool Calls panel
 
 **Dynamic file context refresh (ai_client.py):**
-- After the last tool call in each round, project files from `file_items` are checked via `_reread_file_items()`. It uses `mtime` to only re-read modified files, returning only the `changed` files to build a minimal `[FILES UPDATED]` block.
+- After the last tool call in each round, all project files from `file_items` are re-read from disk via `_reread_file_items()`. The `file_items` variable is reassigned so subsequent rounds see fresh content.
 - For Anthropic: the refreshed file contents are injected as a `text` block appended to the `tool_results` user message, prefixed with `[FILES UPDATED]` and an instruction not to re-read them.
 - For Gemini: refreshed file contents are appended to the last function response's `output` string as a `[SYSTEM: FILES UPDATED]` block. On the next tool round, stale `[FILES UPDATED]` blocks are stripped from history and old tool outputs are truncated to `_history_trunc_limit` characters to control token growth.
 - `_build_file_context_text(file_items)` formats the refreshed files as markdown code blocks (same format as the original context)
@@ -141,12 +141,10 @@ Entry layout: index + timestamp + direction + kind + provider/model header row,
 - `log_tool_call(script, result, script_path)` writes the script to `scripts/generated/<ts>_<seq:04d>.ps1` and appends a markdown record to the toolcalls log without the script body (just the file path + result); uses a `threading.Lock` for the sequence counter
 - `close_session()` flushes and closes both file handles; called just before `dpg.destroy_context()`
 
-**Anthropic prompt caching & history management:**
+**Anthropic prompt caching:**
 - System prompt + context are combined into one string, chunked into <=120k char blocks, and sent as the `system=` parameter array. Only the LAST chunk gets `cache_control: ephemeral`, so the entire system prefix is cached as one unit.
 - Last tool in `_ANTHROPIC_TOOLS` (`run_powershell`) has `cache_control: ephemeral`; this means the tools prefix is cached together with the system prefix after the first request.
 - The user message is sent as a plain `[{"type": "text", "text": user_message}]` block with NO cache_control. The context lives in `system=`, not in the first user message.
-- `_add_history_cache_breakpoint` places `cache_control:ephemeral` on the last content block of the second-to-last user message, using the 4th cache breakpoint to cache the conversation history prefix.
-- `_trim_anthropic_history` uses token estimation (`_CHARS_PER_TOKEN = 3.5`) to keep the prompt under `_ANTHROPIC_MAX_PROMPT_TOKENS = 180_000`. It strips stale file refreshes from old turns, and drops oldest turn pairs if still over budget.
 - The tools list is built once per session via `_get_anthropic_tools()` and reused across all API calls within the tool loop, avoiding redundant Python-side reconstruction.
 - `_strip_cache_controls()` removes stale `cache_control` markers from all history entries before each API call, ensuring only the stable system/tools prefix consumes cache breakpoint slots.
 - Cache stats (creation tokens, read tokens) are surfaced in the comms log usage dict and displayed in the Comms History panel
@@ -182,15 +180,13 @@ Entry layout: index + timestamp + direction + kind + provider/model header row,
 **MCP file tools (mcp_client.py + ai_client.py):**
 - Four read-only tools exposed to the AI as native function/tool declarations: `read_file`, `list_directory`, `search_files`, `get_file_summary`
 - Access control: `mcp_client.configure(file_items, extra_base_dirs)` is called before each send; builds an allowlist of resolved absolute paths from the project's `file_items` plus the `base_dir`; any path that is not explicitly in the list or not under one of the allowed directories returns `ACCESS DENIED`
-- `mcp_client.dispatch(tool_name, tool_input)` is the single dispatch entry point used by both Anthropic and Gemini tool-use loops; `TOOL_NAMES` set now includes all six tool names
+- `mcp_client.dispatch(tool_name, tool_input)` is the single dispatch entry point used by both Anthropic and Gemini tool-use loops
 - Anthropic: MCP tools appear before `run_powershell` in the tools list (no `cache_control` on them; only `run_powershell` carries `cache_control: ephemeral`)
 - Gemini: MCP tools are included in the `FunctionDeclaration` list alongside `run_powershell`
 - `get_file_summary` uses `summarize.summarise_file()` — same heuristic used for the initial `<context>` block, so the AI gets the same compact structural view it already knows
 - `list_directory` sorts dirs before files; shows name, type, and size
 - `search_files` uses `Path.glob()` with the caller-supplied pattern (supports `**/*.py` style)
 - `read_file` returns raw UTF-8 text; errors (not found, access denied, decode error) are returned as error strings rather than exceptions, so the AI sees them as tool results
-- `web_search(query)` queries DuckDuckGo HTML endpoint and returns the top 5 results (title, URL, snippet) as a formatted string; uses a custom `_DDGParser` (HTMLParser subclass)
-- `fetch_url(url)` fetches a URL, strips HTML tags/scripts via `_TextExtractor` (HTMLParser subclass), collapses whitespace, and truncates to 40k chars to prevent context blowup; handles DuckDuckGo redirect links automatically
 - `summarize.py` heuristics: `.py` → AST imports + ALL_CAPS constants + classes+methods + top-level functions; `.toml` → table headers + top-level keys; `.md` → h1–h3 headings with indentation; all others → line count + first 8 lines preview
 - Comms log: MCP tool calls log `OUT/tool_call` with `{"name": ..., "args": {...}}` and `IN/tool_result` with `{"name": ..., "output": ...}`; rendered in the Comms History panel via `_render_payload_tool_call` (shows each arg key/value) and `_render_payload_tool_result` (shows output)
 
@@ -203,9 +199,7 @@ Entry layout: index + timestamp + direction + kind + provider/model header row,
 
 ### Gemini Context Management
 - Gemini uses explicit caching via `client.caches.create()` to store the `system_instruction` + tools as an immutable cached prefix with a 1-hour TTL. The cache is created once per chat session.
-- Proactively rebuilds cache at 90% of `_GEMINI_CACHE_TTL = 3600` to avoid stale-reference errors.
 - When context changes (detected via `md_content` hash), the old cache is deleted, a new cache is created, and chat history is migrated to a fresh chat session pointing at the new cache.
-- Trims history by dropping oldest pairs if input tokens exceed `_GEMINI_MAX_INPUT_TOKENS = 900_000`.
 - If cache creation fails (e.g., content is under the minimum token threshold — 1024 for Flash, 4096 for Pro), the system falls back to inline `system_instruction` in the chat config. Implicit caching may still provide cost savings in this case.
 - The `<context>` block lives inside `system_instruction`, NOT in user messages, preventing history bloat across turns.
 - On cleanup/exit, active caches are deleted via `ai_client.cleanup()` to prevent orphaned billing.
@@ -251,33 +245,22 @@ Documentation has been completely rewritten matching the strict, structural form
 - `docs/Readme.md`: The core interface manual.
 - `docs/guide_tools.md`: Security architecture for `_is_allowed` paths and definitions of the read-only vs destructive tool pipeline.
 
+## Branch Analysis: master vs not_sure (2026-02-22)
 
+### Summary
+The `not_sure` branch introduces a static/dynamic context split in the `send()` API signature, separating files+screenshots (cacheable, stable) from discussion history (changes every turn). This improves cache hit rates for both Anthropic and Gemini.
 
+### Current master branch API correctness
+- **Anthropic**: Correct. System blocks with cache_control, SDK content block serialisation, history repair, stale file refresh stripping all work properly.
+- **Gemini**: Correct after `patch_gemini_history.py` was applied. Uses `_get_gemini_history_list()` for safe SDK access, drops history in pairs to maintain alternating roles, explicit caching via `caches.create()`.
 
-## Updates (2026-02-22 — ai_client.py & aggregate.py)
+### not_sure branch improvements
+- **Anthropic**: Puts discussion history as a separate uncached system block after the cached static context. Better cache hit rates when discussion changes between turns.
+- **Gemini**: Wraps discussion in `<discussion>` tags in user messages and strips old ones from history via regex. Prevents discussion duplication across turns.
 
-### mcp_client.py — Web Tools Added
-- `web_search(query)` and `fetch_url(url)` added as two new MCP tools alongside the existing four file tools.
-- `TOOL_NAMES` set updated to include all six tool names for dispatch routing.
-- `MCP_TOOL_SPECS` list extended with full JSON schema definitions for both web tools.
-- Both tools are declared in `_build_anthropic_tools()` and `_gemini_tool_declaration()` so they are available to both providers.
-- Web tools bypass the `_is_allowed` path check (no filesystem access); file tools retain the allowlist enforcement.
+### not_sure branch bugs (not merged from master)
+- Uses `_gemini_chat.history` directly instead of `_get_gemini_history_list()` — will crash on newer google-genai SDK versions where `.history` was removed.
+- Missing the pair-wise history dropping fix (drops single messages, breaking Gemini's alternating role requirement).
 
-### aggregate.py — run() double-I/O elimination
-- `run()` now calls `build_file_items()` once, then passes the result to `build_markdown_from_items()` instead of calling `build_files_section()` separately. This avoids reading every file twice per send.
-- `build_markdown_from_items()` accepts a `summary_only` flag (default `False`); when `False` it inlines full file content; when `True` it delegates to `summarize.build_summary_markdown()` for compact structural summaries.
-- `run()` returns a 3-tuple `(markdown_str, output_path, file_items)` — the `file_items` list is passed through to `gui.py` as `self.last_file_items` for dynamic context refresh after tool calls.
-
-
-## Updates (2026-02-22 — gui.py [+ Maximize] bug fix)
-
-### Problem
-Three `[+ Maximize]` buttons were reading their text content via `dpg.get_value(tag)` at click time:
-1. `ConfirmDialog.show()` — passed `f"{self._tag}_script"` as `user_data` and called `dpg.get_value(u)` in the lambda. If the dialog was dismissed before the viewer opened, the item no longer existed and the call would fail silently or crash.
-2. `win_script_output` Script `[+ Maximize]` — used `user_data="last_script_text"` and `dpg.get_value(u)`. When word-wrap is ON, `last_script_text` is hidden (`show=False`); in some DPG versions `dpg.get_value` on a hidden `input_text` returns `""`.
-3. `win_script_output` Output `[+ Maximize]` — same issue with `"last_script_output"`.
-
-### Fix
-- `ConfirmDialog.show()`: changed `user_data` to `self._script` (the actual text string captured at button-creation time) and the callback to `lambda s, a, u: _show_text_viewer("Confirm Script", u)`. The text is now baked in at dialog construction, not read from a potentially-deleted widget.
-- `App._append_tool_log()`: added `self._last_script = script` and `self._last_output = result` assignments so the latest values are always available as instance state.
-- `win_script_output` buttons: both `[+ Maximize]` buttons now use `lambda s, a, u: _show_text_viewer("...", self._last_script/output)` directly, bypassing DPG widget state entirely.
+### Recommended merge path
+Cherry-pick the static/dynamic split from `not_sure` into `master` while keeping master's SDK safety fixes (`_get_gemini_history_list`, pair-wise dropping, `_content_block_to_dict`).

aggregate.py

@@ -98,28 +98,24 @@ def build_file_items(base_dir: Path, files: list[str]) -> list[dict]:
         entry    : str   (original config entry string)
         content  : str   (file text, or error string)
         error    : bool
-        mtime    : float (last modification time, for skip-if-unchanged optimization)
     """
     items = []
     for entry in files:
         paths = resolve_paths(base_dir, entry)
         if not paths:
-            items.append({"path": None, "entry": entry, "content": f"ERROR: no files matched: {entry}", "error": True, "mtime": 0.0})
+            items.append({"path": None, "entry": entry, "content": f"ERROR: no files matched: {entry}", "error": True})
             continue
         for path in paths:
             try:
                 content = path.read_text(encoding="utf-8")
-                mtime = path.stat().st_mtime
                 error = False
             except FileNotFoundError:
                 content = f"ERROR: file not found: {path}"
-                mtime = 0.0
                 error = True
             except Exception as e:
                 content = f"ERROR: {e}"
-                mtime = 0.0
                 error = True
-            items.append({"path": path, "entry": entry, "content": content, "error": error, "mtime": mtime})
+            items.append({"path": path, "entry": entry, "content": content, "error": error})
     return items
 
 def build_summary_section(base_dir: Path, files: list[str]) -> str:
@@ -130,39 +126,23 @@ def build_summary_section(base_dir: Path, files: list[str]) -> str:
     items = build_file_items(base_dir, files)
     return summarize.build_summary_markdown(items)
 
-def _build_files_section_from_items(file_items: list[dict]) -> str:
-    """Build the files markdown section from pre-read file items (avoids double I/O)."""
-    sections = []
-    for item in file_items:
-        path = item.get("path")
-        entry = item.get("entry", "unknown")
-        content = item.get("content", "")
-        if path is None:
-            sections.append(f"### `{entry}`\n\n```text\n{content}\n```")
-            continue
-        suffix = path.suffix.lstrip(".") if hasattr(path, "suffix") else "text"
-        lang = suffix if suffix else "text"
-        original = entry if "*" not in entry else str(path)
-        sections.append(f"### `{original}`\n\n```{lang}\n{content}\n```")
-    return "\n\n---\n\n".join(sections)
-
-
-def build_markdown_from_items(file_items: list[dict], screenshot_base_dir: Path, screenshots: list[str], history: list[str], summary_only: bool = False) -> str:
-    """Build markdown from pre-read file items instead of re-reading from disk."""
+def build_static_markdown(base_dir: Path, files: list[str], screenshot_base_dir: Path, screenshots: list[str], summary_only: bool = False) -> str:
+    """Build the static (cacheable) portion of the context: files + screenshots."""
     parts = []
-    # STATIC PREFIX: Files and Screenshots must go first to maximize Cache Hits
-    if file_items:
+    if files:
         if summary_only:
-            parts.append("## Files (Summary)\n\n" + summarize.build_summary_markdown(file_items))
+            parts.append("## Files (Summary)\n\n" + build_summary_section(base_dir, files))
         else:
-            parts.append("## Files\n\n" + _build_files_section_from_items(file_items))
+            parts.append("## Files\n\n" + build_files_section(base_dir, files))
     if screenshots:
         parts.append("## Screenshots\n\n" + build_screenshots_section(screenshot_base_dir, screenshots))
-    # DYNAMIC SUFFIX: History changes every turn, must go last
-    if history:
-        parts.append("## Discussion History\n\n" + build_discussion_section(history))
     return "\n\n---\n\n".join(parts)
 
+def build_dynamic_markdown(history: list[str]) -> str:
+    """Build the dynamic (changes every turn) portion: discussion history."""
+    if history:
+        return "## Discussion History\n\n" + build_discussion_section(history)
+    return ""
 
 def build_markdown(base_dir: Path, files: list[str], screenshot_base_dir: Path, screenshots: list[str], history: list[str], summary_only: bool = False) -> str:
     parts = []
@@ -179,7 +159,7 @@ def build_markdown(base_dir: Path, files: list[str], screenshot_base_dir: Path,
         parts.append("## Discussion History\n\n" + build_discussion_section(history))
     return "\n\n---\n\n".join(parts)
 
-def run(config: dict) -> tuple[str, Path, list[dict]]:
+def run(config: dict) -> tuple[str, Path, list]:
     namespace = config.get("project", {}).get("name")
     if not namespace:
         namespace = config.get("output", {}).get("namespace", "project")
@@ -193,18 +173,20 @@ def run(config: dict) -> tuple[str, Path, list[dict]]:
     output_dir.mkdir(parents=True, exist_ok=True)
     increment = find_next_increment(output_dir, namespace)
     output_file = output_dir / f"{namespace}_{increment:03d}.md"
-    # Build file items once, then construct markdown from them (avoids double I/O)
-    file_items = build_file_items(base_dir, files)
-    markdown = build_markdown_from_items(file_items, screenshot_base_dir, screenshots, history,
-                                         summary_only=False)
+    # Build static (files+screenshots) and dynamic (discussion) portions separately for better caching
+    static_md = build_static_markdown(base_dir, files, screenshot_base_dir, screenshots, summary_only=False)
+    dynamic_md = build_dynamic_markdown(history)
+    # Write combined markdown to disk for archival
+    markdown = f"{static_md}\n\n---\n\n{dynamic_md}" if static_md and dynamic_md else static_md or dynamic_md
     output_file.write_text(markdown, encoding="utf-8")
-    return markdown, output_file, file_items
+    file_items = build_file_items(base_dir, files)
+    return static_md, dynamic_md, output_file, file_items
 
 def main():
     with open("config.toml", "rb") as f:
         import tomllib
         config = tomllib.load(f)
-    markdown, output_file, _ = run(config)
+    static_md, dynamic_md, output_file, _ = run(config)
     print(f"Written: {output_file}")
 
 if __name__ == "__main__":

ai_client.py

@@ -13,7 +13,6 @@ during chat creation to avoid massive history bloat.
 # ai_client.py
 import tomllib
 import json
-import time
 import datetime
 from pathlib import Path
 import file_cache
@@ -35,12 +34,6 @@ def set_model_params(temp: float, max_tok: int, trunc_limit: int = 8000):
 _gemini_client = None
 _gemini_chat = None
 _gemini_cache = None
-_gemini_cache_md_hash: int | None = None
-_gemini_cache_created_at: float | None = None
-
-# Gemini cache TTL in seconds. Caches are created with this TTL and
-# proactively rebuilt at 90% of this value to avoid stale-reference errors.
-_GEMINI_CACHE_TTL = 3600
 
 _anthropic_client = None
 _anthropic_history: list[dict] = []
@@ -223,7 +216,6 @@ def cleanup():
 
 def reset_session():
     global _gemini_client, _gemini_chat, _gemini_cache
-    global _gemini_cache_md_hash, _gemini_cache_created_at
     global _anthropic_client, _anthropic_history
     global _CACHED_ANTHROPIC_TOOLS
     if _gemini_client and _gemini_cache:
@@ -234,8 +226,6 @@ def reset_session():
     _gemini_client = None
     _gemini_chat = None
     _gemini_cache = None
-    _gemini_cache_md_hash = None
-    _gemini_cache_created_at = None
     _anthropic_client = None
     _anthropic_history = []
     _CACHED_ANTHROPIC_TOOLS = None
@@ -393,15 +383,12 @@ def _run_script(script: str, base_dir: str) -> str:
 
 # ------------------------------------------------------------------ dynamic file context refresh
 
-def _reread_file_items(file_items: list[dict]) -> tuple[list[dict], list[dict]]:
+def _reread_file_items(file_items: list[dict]) -> list[dict]:
     """
-    Re-read file_items from disk, but only files whose mtime has changed.
-    Returns (all_items, changed_items) — all_items is the full refreshed list,
-    changed_items contains only the files that were actually modified since
-    the last read (used to build a minimal [FILES UPDATED] block).
+    Re-read every file in file_items from disk, returning a fresh list.
+    This is called after tool calls so the AI sees updated file contents.
     """
     refreshed = []
-    changed = []
     for item in file_items:
         path = item.get("path")
         if path is None:
@@ -410,20 +397,11 @@ def _reread_file_items(file_items: list[dict]) -> tuple[list[dict], list[dict]]:
         from pathlib import Path as _P
         p = _P(path) if not isinstance(path, _P) else path
         try:
-            current_mtime = p.stat().st_mtime
-            prev_mtime = item.get("mtime", 0.0)
-            if current_mtime == prev_mtime:
-                refreshed.append(item)  # unchanged — skip re-read
-                continue
             content = p.read_text(encoding="utf-8")
-            new_item = {**item, "content": content, "error": False, "mtime": current_mtime}
-            refreshed.append(new_item)
-            changed.append(new_item)
+            refreshed.append({**item, "content": content, "error": False})
         except Exception as e:
-            err_item = {**item, "content": f"ERROR re-reading {p}: {e}", "error": True, "mtime": 0.0}
-            refreshed.append(err_item)
-            changed.append(err_item)
-    return refreshed, changed
+            refreshed.append({**item, "content": f"ERROR re-reading {p}: {e}", "error": True})
+    return refreshed
 
 
 def _build_file_context_text(file_items: list[dict]) -> str:
@@ -487,40 +465,26 @@ def _get_gemini_history_list(chat):
         return chat.get_history()
     return []
 
-def _send_gemini(md_content: str, user_message: str, base_dir: str, file_items: list[dict] | None = None) -> str:
-    global _gemini_chat, _gemini_cache, _gemini_cache_md_hash, _gemini_cache_created_at
+def _send_gemini(static_md: str, dynamic_md: str, user_message: str, base_dir: str, file_items: list[dict] | None = None) -> str:
+    global _gemini_chat, _gemini_cache
     from google.genai import types
     try:
         _ensure_gemini_client(); mcp_client.configure(file_items or [], [base_dir])
-        sys_instr = f"{_get_combined_system_prompt()}\n\n<context>\n{md_content}\n</context>"
+        sys_instr = f"{_get_combined_system_prompt()}\n\n<context>\n{static_md}\n</context>"
         tools_decl = [_gemini_tool_declaration()]
-
+        
         # DYNAMIC CONTEXT: Check if files/context changed mid-session
-        current_md_hash = hash(md_content)
+        current_md_hash = hash(static_md)
         old_history = None
-        if _gemini_chat and _gemini_cache_md_hash != current_md_hash:
+        if _gemini_chat and getattr(_gemini_chat, "_last_md_hash", None) != current_md_hash:
             old_history = list(_get_gemini_history_list(_gemini_chat)) if _get_gemini_history_list(_gemini_chat) else []
             if _gemini_cache:
                 try: _gemini_client.caches.delete(name=_gemini_cache.name)
                 except: pass
             _gemini_chat = None
             _gemini_cache = None
-            _gemini_cache_created_at = None
             _append_comms("OUT", "request", {"message": "[CONTEXT CHANGED] Rebuilding cache and chat session..."})
 
-        # CACHE TTL: Proactively rebuild before the cache expires server-side.
-        # If we don't, send_message() will reference a deleted cache and fail.
-        if _gemini_chat and _gemini_cache and _gemini_cache_created_at:
-            elapsed = time.time() - _gemini_cache_created_at
-            if elapsed > _GEMINI_CACHE_TTL * 0.9:
-                old_history = list(_get_gemini_history_list(_gemini_chat)) if _get_gemini_history_list(_gemini_chat) else []
-                try: _gemini_client.caches.delete(name=_gemini_cache.name)
-                except: pass
-                _gemini_chat = None
-                _gemini_cache = None
-                _gemini_cache_created_at = None
-                _append_comms("OUT", "request", {"message": f"[CACHE TTL] Rebuilding cache (expired after {int(elapsed)}s)..."})
-
         if not _gemini_chat:
             chat_config = types.GenerateContentConfig(
                 system_instruction=sys_instr,
@@ -536,10 +500,9 @@ def _send_gemini(md_content: str, user_message: str, base_dir: str, file_items:
                     config=types.CreateCachedContentConfig(
                         system_instruction=sys_instr,
                         tools=tools_decl,
-                        ttl=f"{_GEMINI_CACHE_TTL}s",
+                        ttl="3600s",
                     )
                 )
-                _gemini_cache_created_at = time.time()
                 chat_config = types.GenerateContentConfig(
                     cached_content=_gemini_cache.name,
                     temperature=_temperature,
@@ -548,38 +511,45 @@ def _send_gemini(md_content: str, user_message: str, base_dir: str, file_items:
                 )
                 _append_comms("OUT", "request", {"message": f"[CACHE CREATED] {_gemini_cache.name}"})
             except Exception as e:
-                _gemini_cache = None
-                _gemini_cache_created_at = None
-                _append_comms("OUT", "request", {"message": f"[CACHE FAILED] {type(e).__name__}: {e} — falling back to inline system_instruction"})
-
+                _gemini_cache = None  # Ensure clean state on failure
+                
             kwargs = {"model": _model, "config": chat_config}
             if old_history:
                 kwargs["history"] = old_history
-
+            
             _gemini_chat = _gemini_client.chats.create(**kwargs)
-            _gemini_cache_md_hash = current_md_hash
+            _gemini_chat._last_md_hash = current_md_hash
+        
+        # Build user message: prepend dynamic context (discussion) so it's NOT cached in system_instruction
+        full_user_msg = f"<discussion>\n{dynamic_md}\n</discussion>\n\n{user_message}" if dynamic_md.strip() else user_message
+        _append_comms("OUT", "request", {"message": f"[ctx {len(static_md)} static + {len(dynamic_md)} dynamic + msg {len(user_message)}]"})
+        payload, all_text = full_user_msg, []
         
-        _append_comms("OUT", "request", {"message": f"[ctx {len(md_content)} + msg {len(user_message)}]"})
-        payload, all_text = user_message, []
-
-        # Strip stale file refreshes and truncate old tool outputs ONCE before
-        # entering the tool loop (not per-round — history entries don't change).
-        if _gemini_chat and _get_gemini_history_list(_gemini_chat):
-            for msg in _get_gemini_history_list(_gemini_chat):
-                if msg.role == "user" and hasattr(msg, "parts"):
-                    for p in msg.parts:
-                        if hasattr(p, "function_response") and p.function_response and hasattr(p.function_response, "response"):
-                            r = p.function_response.response
-                            if isinstance(r, dict) and "output" in r:
-                                val = r["output"]
-                                if isinstance(val, str):
-                                    if "[SYSTEM: FILES UPDATED]" in val:
-                                        val = val.split("[SYSTEM: FILES UPDATED]")[0].strip()
-                                    if _history_trunc_limit > 0 and len(val) > _history_trunc_limit:
-                                        val = val[:_history_trunc_limit] + "\n\n... [TRUNCATED BY SYSTEM TO SAVE TOKENS.]"
-                                    r["output"] = val
-
         for r_idx in range(MAX_TOOL_ROUNDS + 2):
+            # Strip stale <discussion> blocks from old user messages so they don't accumulate
+            import re as _re
+            if _gemini_chat and _get_gemini_history_list(_gemini_chat):
+                for msg in _get_gemini_history_list(_gemini_chat):
+                    if msg.role == "user" and hasattr(msg, "parts"):
+                        for p in msg.parts:
+                            if hasattr(p, "text") and p.text and "<discussion>" in p.text:
+                                p.text = _re.sub(r"<discussion>.*?</discussion>\n\n", "", p.text, flags=_re.DOTALL)
+            # Strip stale file refreshes and truncate old tool outputs in Gemini history
+            if _gemini_chat and _get_gemini_history_list(_gemini_chat):
+                for msg in _get_gemini_history_list(_gemini_chat):
+                    if msg.role == "user" and hasattr(msg, "parts"):
+                        for p in msg.parts:
+                            if hasattr(p, "function_response") and p.function_response and hasattr(p.function_response, "response"):
+                                r = p.function_response.response
+                                if isinstance(r, dict) and "output" in r:
+                                    val = r["output"]
+                                    if isinstance(val, str):
+                                        if "[SYSTEM: FILES UPDATED]" in val:
+                                            val = val.split("[SYSTEM: FILES UPDATED]")[0].strip()
+                                        if _history_trunc_limit > 0 and len(val) > _history_trunc_limit:
+                                            val = val[:_history_trunc_limit] + "\n\n... [TRUNCATED BY SYSTEM TO SAVE TOKENS.]"
+                                        r["output"] = val
+
             resp = _gemini_chat.send_message(payload)
             txt = "\n".join(p.text for c in resp.candidates if getattr(c, "content", None) for p in c.content.parts if hasattr(p, "text") and p.text)
             if txt: all_text.append(txt)
@@ -633,12 +603,12 @@ def _send_gemini(md_content: str, user_message: str, base_dir: str, file_items:
 
                 if i == len(calls) - 1:
                     if file_items:
-                        file_items, changed = _reread_file_items(file_items)
-                        ctx = _build_file_context_text(changed)
+                        file_items = _reread_file_items(file_items)
+                        ctx = _build_file_context_text(file_items)
                         if ctx:
                             out += f"\n\n[SYSTEM: FILES UPDATED]\n\n{ctx}"
                     if r_idx == MAX_TOOL_ROUNDS: out += "\n\n[SYSTEM: MAX ROUNDS. PROVIDE FINAL ANSWER.]"
-
+                
                 f_resps.append(types.Part.from_function_response(name=name, response={"output": out}))
                 log.append({"tool_use_id": name, "content": out})
             
@@ -670,15 +640,7 @@ _FILE_REFRESH_MARKER = "[FILES UPDATED"
 
 
 def _estimate_message_tokens(msg: dict) -> int:
-    """
-    Rough token estimate for a single Anthropic message dict.
-    Caches the result on the dict as '_est_tokens' so repeated calls
-    (e.g., from _trim_anthropic_history) don't re-scan unchanged messages.
-    Call _invalidate_token_estimate() when a message's content is modified.
-    """
-    cached = msg.get("_est_tokens")
-    if cached is not None:
-        return cached
+    """Rough token estimate for a single Anthropic message dict."""
     total_chars = 0
     content = msg.get("content", "")
     if isinstance(content, str):
@@ -696,14 +658,7 @@ def _estimate_message_tokens(msg: dict) -> int:
                     total_chars += len(_json.dumps(inp, ensure_ascii=False))
             elif isinstance(block, str):
                 total_chars += len(block)
-    est = max(1, int(total_chars / _CHARS_PER_TOKEN))
-    msg["_est_tokens"] = est
-    return est
-
-
-def _invalidate_token_estimate(msg: dict):
-    """Remove the cached token estimate so the next call recalculates."""
-    msg.pop("_est_tokens", None)
+    return max(1, int(total_chars / _CHARS_PER_TOKEN))
 
 
 def _estimate_prompt_tokens(system_blocks: list[dict], history: list[dict]) -> int:
@@ -715,7 +670,7 @@ def _estimate_prompt_tokens(system_blocks: list[dict], history: list[dict]) -> i
         total += max(1, int(len(text) / _CHARS_PER_TOKEN))
     # Tool definitions (rough fixed estimate — they're ~2k tokens for our set)
     total += 2500
-    # History messages (uses cached estimates for unchanged messages)
+    # History messages
     for msg in history:
         total += _estimate_message_tokens(msg)
     return total
@@ -750,7 +705,6 @@ def _strip_stale_file_refreshes(history: list[dict]):
             cleaned.append(block)
         if len(cleaned) < len(content):
             msg["content"] = cleaned
-            _invalidate_token_estimate(msg)
 
 
 def _trim_anthropic_history(system_blocks: list[dict], history: list[dict]):
@@ -842,28 +796,6 @@ def _strip_cache_controls(history: list[dict]):
                 if isinstance(block, dict):
                     block.pop("cache_control", None)
 
-def _add_history_cache_breakpoint(history: list[dict]):
-    """
-    Place cache_control:ephemeral on the last content block of the
-    second-to-last user message. This uses one of the 4 allowed Anthropic
-    cache breakpoints to cache the conversation prefix so the full history
-    isn't reprocessed on every request.
-    """
-    user_indices = [i for i, m in enumerate(history) if m.get("role") == "user"]
-    if len(user_indices) < 2:
-        return  # Only one user message (the current turn) — nothing stable to cache
-    target_idx = user_indices[-2]
-    content = history[target_idx].get("content")
-    if isinstance(content, list) and content:
-        last_block = content[-1]
-        if isinstance(last_block, dict):
-            last_block["cache_control"] = {"type": "ephemeral"}
-    elif isinstance(content, str):
-        history[target_idx]["content"] = [
-            {"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}
-        ]
-
-
 def _repair_anthropic_history(history: list[dict]):
     """
     If history ends with an assistant message that contains tool_use blocks
@@ -896,46 +828,36 @@ def _repair_anthropic_history(history: list[dict]):
     })
 
 
-def _send_anthropic(md_content: str, user_message: str, base_dir: str, file_items: list[dict] | None = None) -> str:
+def _send_anthropic(static_md: str, dynamic_md: str, user_message: str, base_dir: str, file_items: list[dict] | None = None) -> str:
     try:
         _ensure_anthropic_client()
         mcp_client.configure(file_items or [], [base_dir])
 
-        # Split system into two cache breakpoints:
-        # 1. Stable system prompt (never changes — always a cache hit)
-        # 2. Dynamic file context (invalidated only when files change)
-        stable_prompt = _get_combined_system_prompt()
-        stable_blocks = [{"type": "text", "text": stable_prompt, "cache_control": {"type": "ephemeral"}}]
-        context_text = f"\n\n<context>\n{md_content}\n</context>"
-        context_blocks = _build_chunked_context_blocks(context_text)
-        system_blocks = stable_blocks + context_blocks
+        system_text = _get_combined_system_prompt() + f"\n\n<context>\n{static_md}\n</context>"
+        system_blocks = _build_chunked_context_blocks(system_text)
+        # Dynamic context (discussion history) goes after the cached static prefix, without cache_control
+        if dynamic_md.strip():
+            system_blocks.append({"type": "text", "text": f"<discussion>\n{dynamic_md}\n</discussion>"})
 
         user_content = [{"type": "text", "text": user_message}]
 
         # COMPRESS HISTORY: Truncate massive tool outputs from previous turns
         for msg in _anthropic_history:
             if msg.get("role") == "user" and isinstance(msg.get("content"), list):
-                modified = False
                 for block in msg["content"]:
                     if isinstance(block, dict) and block.get("type") == "tool_result":
                         t_content = block.get("content", "")
                         if _history_trunc_limit > 0 and isinstance(t_content, str) and len(t_content) > _history_trunc_limit:
                             block["content"] = t_content[:_history_trunc_limit] + "\n\n... [TRUNCATED BY SYSTEM TO SAVE TOKENS. Original output was too large.]"
-                            modified = True
-                if modified:
-                    _invalidate_token_estimate(msg)
 
         _strip_cache_controls(_anthropic_history)
         _repair_anthropic_history(_anthropic_history)
         _anthropic_history.append({"role": "user", "content": user_content})
-        # Use the 4th cache breakpoint to cache the conversation history prefix.
-        # This is placed on the second-to-last user message (the last stable one).
-        _add_history_cache_breakpoint(_anthropic_history)
 
         n_chunks = len(system_blocks)
         _append_comms("OUT", "request", {
             "message": (
-                f"[system {n_chunks} chunk(s), {len(md_content)} chars context] "
+                f"[system {n_chunks} chunk(s), {len(static_md)} static + {len(dynamic_md)} dynamic chars] "
                 f"{user_message[:200]}{'...' if len(user_message) > 200 else ''}"
             ),
         })
@@ -955,16 +877,13 @@ def _send_anthropic(md_content: str, user_message: str, base_dir: str, file_item
                     ),
                 })
 
-            def _strip_private_keys(history):
-                return [{k: v for k, v in m.items() if not k.startswith("_")} for m in history]
-
             response = _anthropic_client.messages.create(
                 model=_model,
                 max_tokens=_max_tokens,
                 temperature=_temperature,
                 system=system_blocks,
                 tools=_get_anthropic_tools(),
-                messages=_strip_private_keys(_anthropic_history),
+                messages=_anthropic_history,
             )
 
             # Convert SDK content block objects to plain dicts before storing in history
@@ -1047,10 +966,10 @@ def _send_anthropic(md_content: str, user_message: str, base_dir: str, file_item
                         "content":     output,
                     })
 
-            # Refresh file context after tool calls — only inject CHANGED files
+            # Refresh file context after tool calls and inject into tool result message
             if file_items:
-                file_items, changed = _reread_file_items(file_items)
-                refreshed_ctx = _build_file_context_text(changed)
+                file_items = _reread_file_items(file_items)
+                refreshed_ctx = _build_file_context_text(file_items)
                 if refreshed_ctx:
                     tool_results.append({
                         "type": "text",
@@ -1091,7 +1010,8 @@ def _send_anthropic(md_content: str, user_message: str, base_dir: str, file_item
 # ------------------------------------------------------------------ unified send
 
 def send(
-    md_content: str,
+    static_md: str,
+    dynamic_md: str,
     user_message: str,
     base_dir: str = ".",
     file_items: list[dict] | None = None,
@@ -1099,14 +1019,15 @@ def send(
     """
     Send a message to the active provider.
 
-    md_content  : aggregated markdown string from aggregate.run()
+    static_md   : cacheable context (files + screenshots) from aggregate.run()
+    dynamic_md  : volatile context (discussion history) that changes every turn
     user_message: the user question / instruction
     base_dir    : project base directory (for PowerShell tool calls)
     file_items  : list of file dicts from aggregate.build_file_items() for
                   dynamic context refresh after tool calls
     """
     if _provider == "gemini":
-        return _send_gemini(md_content, user_message, base_dir, file_items)
+        return _send_gemini(static_md, dynamic_md, user_message, base_dir, file_items)
     elif _provider == "anthropic":
-        return _send_anthropic(md_content, user_message, base_dir, file_items)
+        return _send_anthropic(static_md, dynamic_md, user_message, base_dir, file_items)
     raise ValueError(f"unknown provider: {_provider}")

config.toml

@@ -1,6 +1,6 @@
 [ai]
-provider = "anthropic"
-model = "claude-sonnet-4-6"
+provider = "gemini"
+model = "gemini-2.5-pro"
 temperature = 0.6000000238418579
 max_tokens = 12000
 history_trunc_limit = 8000
@@ -10,7 +10,7 @@ system_prompt = "DO NOT EVER make a shell script unless told to. DO NOT EVER mak
 palette = "10x Dark"
 font_path = "C:/Users/Ed/AppData/Local/uv/cache/archive-v0/WSthkYsQ82b_ywV6DkiaJ/pygame_gui/data/FiraCode-Regular.ttf"
 font_size = 18.0
-scale = 1.25
+scale = 1.1
 
 [projects]
 paths = [

docs/Readme.md

@@ -29,7 +29,7 @@ Controls what is explicitly fed into the context compiler.
 
 - **Base Dir:** Defines the root for path resolution and tool constraints.
 - **Paths:** Explicit files or wildcard globs (e.g., src/**/*.rs). 
-- When generating a request, full file contents are inlined into the context by default (`summary_only=False`). The AI can also call `get_file_summary` via its MCP tools to get a compact structural view of any file on demand.
+- When generating a request, these files are summarized symbolically (summarize.py) to conserve tokens, unless the AI explicitly decides to read their full contents via its internal tools.
 
 ## Interaction Panels
 
@@ -46,9 +46,8 @@ Switch between API backends (Gemini, Anthropic) on the fly. Clicking "Fetch Mode
 
 ### Global Text Viewer & Script Outputs
 
-- **Last Script Output:** Whenever the AI executes a background script, this window pops up, flashing blue. It contains both the executed script and the stdout/stderr. The `[+ Maximize]` buttons read directly from stored instance variables (`_last_script`, `_last_output`) rather than DPG widget tags, so they work correctly regardless of word-wrap state.
+- **Last Script Output:** Whenever the AI executes a background script, this window pops up, flashing blue. It contains both the executed script and the stdout/stderr.
 - **Text Viewer:** A large, resizable global popup invoked anytime you click a [+] or [+ Maximize] button in the UI. Used for deep-reading long logs, discussion entries, or script bodies.
-- **Confirm Dialog:** The `[+ Maximize]` button in the script approval modal passes the script text directly as `user_data` at button-creation time, so it remains safe to click even after the dialog has been dismissed.
 
 ## System Prompts
 

docs/guide_architecture.md

@@ -1,4 +1,4 @@
-# Guide: Architecture
+# Guide: Architecture
 
 Overview of the package design, state management, and code-path layout.
 
@@ -33,9 +33,10 @@ This occurs inside aggregate.run.
 If using the default workflow, aggregate.py hashes through the following process:
 
 1. **Glob Resolution:** Iterates through config["files"]["paths"] and unpacks any wildcards (e.g., src/**/*.rs) against the designated base_dir.
-2. **File Item Build:** `build_file_items()` reads each resolved file once, storing path, content, and `mtime`. This list is returned alongside the markdown so `ai_client.py` can use it for dynamic context refresh after tool calls without re-reading from disk.
-3. **Markdown Generation:** `build_markdown_from_items()` assembles the final `<project>_00N.md` string. By default (`summary_only=False`) it inlines full file contents. If `summary_only=True`, it delegates to `summarize.build_summary_markdown()` which uses AST-based heuristics to produce compact structural summaries instead.
-4. The Markdown file is persisted to disk (`./md_gen/` by default) for auditing. `run()` returns a 3-tuple `(markdown_str, output_path, file_items)`.
+2. **Summarization Pass:** Instead of concatenating raw file bodies (which would quickly overwhelm the ~200k token limit over multiple rounds), the files are passed to summarize.py.
+3. **AST Parsing:** summarize.py runs a heuristic pass. For Python files, it uses the standard ast module to read structural nodes (Classes, Methods, Imports, Constants). It outputs a compact Markdown table.
+4. **Markdown Generation:** The final <project>_00N.md string is constructed, comprising the truncated AST summaries, the user's current project system prompt, and the active discussion branch. 
+5. The Markdown file is persisted to disk (./md_gen/ by default) for auditing.
 
 ### AI Communication & The Tool Loop
 
@@ -84,4 +85,3 @@ All I/O bound session data is recorded sequentially. session_logger.py hooks int
 - logs/comms_<ts>.log: A JSON-L structured timeline of every raw payload sent/received.
 - logs/toolcalls_<ts>.log: A sequential markdown record detailing every AI tool invocation and its exact stdout result.
 - scripts/generated/: Every .ps1 script approved and executed by the shell runner is physically written to disk for version control transparency.
-

docs/guide_tools.md

@@ -12,22 +12,17 @@ Implemented in mcp_client.py. These tools allow the AI to selectively expand its
 
 ### Security & Scope
 
-Every **filesystem** MCP tool passes its arguments through `_resolve_and_check`. This function ensures that the requested path falls under one of the allowed directories defined in the GUI's Base Dir configurations.
+Every filesystem MCP tool passes its arguments through _resolve_and_check. This function ensures that the requested path falls under one of the allowed directories defined in the GUI's Base Dir configurations. 
 If the AI attempts to read or search a path outside the project bounds, the tool safely catches the constraint violation and returns ACCESS DENIED.
 
-The two **web tools** (`web_search`, `fetch_url`) bypass this check entirely — they have no filesystem access and are unrestricted.
-
 ### Supplied Tools:
 
-**Filesystem tools** (access-controlled via `_resolve_and_check`):
-* `read_file(path)`: Returns the raw UTF-8 text of a file.
-* `list_directory(path)`: Returns a formatted table of a directory's contents, showing file vs dir and byte sizes.
-* `search_files(path, pattern)`: Executes a glob search (e.g., `**/*.py`) within an allowed directory.
-* `get_file_summary(path)`: Invokes the local `summarize.py` heuristic parser to get the AST structure of a file without reading the whole body.
-
-**Web tools** (unrestricted — no filesystem access):
-* `web_search(query)`: Queries DuckDuckGo's raw HTML endpoint and returns the top 5 results (title, URL, snippet) using a native `_DDGParser` (HTMLParser subclass) to avoid heavy dependencies.
-* `fetch_url(url)`: Downloads a target webpage and strips out all scripts, styling, and structural HTML via `_TextExtractor`, returning only the raw prose content (clamped to 40,000 characters). Automatically resolves DuckDuckGo redirect links.
+* read_file(path): Returns the raw UTF-8 text of a file.
+* list_directory(path): Returns a formatted table of a directory's contents, showing file vs dir and byte sizes.
+* search_files(path, pattern): Executes an absolute glob search (e.g., **/*.py) to find specific files.
+* get_file_summary(path): Invokes the local summarize.py heuristic parser to get the AST structure of a file without reading the whole body.
+* web_search(query): Queries DuckDuckGo's raw HTML endpoint and returns the top 5 results (Titles, URLs, Snippets) using a native HTMLParser to avoid heavy dependencies.
+* fetch_url(url): Downloads a target webpage and strips out all scripts, styling, and structural HTML, returning only the raw prose content (clamped to 40,000 characters).
 
 ## 2. Destructive Execution (run_powershell)
 

gemini.py

@@ -1,35 +0,0 @@
-# gemini.py
-import tomllib
-from pathlib import Path
-from google import genai
-from google.genai import types
-
-_client = None
-_chat = None
-
-def _load_key() -> str:
-    with open("credentials.toml", "rb") as f:
-        return tomllib.load(f)["gemini"]["api_key"]
-
-def _ensure_client():
-    global _client
-    if _client is None:
-        _client = genai.Client(api_key=_load_key())
-
-def _ensure_chat():
-    global _chat
-    if _chat is None:
-        _ensure_client()
-        _chat = _client.chats.create(model="gemini-2.0-flash")
-
-def send(md_content: str, user_message: str) -> str:
-    global _chat
-    _ensure_chat()
-    full_message = f"<context>\n{md_content}\n</context>\n\n{user_message}"
-    response = _chat.send_message(full_message)
-    return response.text
-
-def reset_session():
-    global _client, _chat
-    _client = None
-    _chat = None

gui.py

@@ -1,4 +1,4 @@
-# gui.py
+# gui.py
 """
 Note(Gemini):
 The main DearPyGui interface orchestrator.
@@ -301,9 +301,9 @@ class ConfirmDialog:
                 with dpg.group(horizontal=True):
                     dpg.add_text("Script:")
                     dpg.add_button(
-                        label="[+ Maximize]",
-                        user_data=self._script,
-                        callback=lambda s, a, u: _show_text_viewer("Confirm Script", u)
+                        label="[+ Maximize]", 
+                        user_data=f"{self._tag}_script",
+                        callback=lambda s, a, u: _show_text_viewer("Confirm Script", dpg.get_value(u))
                     )
                 dpg.add_input_text(
                     tag=f"{self._tag}_script",
@@ -432,8 +432,6 @@ class App:
         self._pending_dialog_lock = threading.Lock()
 
         self._tool_log: list[tuple[str, str]] = []
-        self._last_script: str = ""
-        self._last_output: str = ""
 
         # Comms log entries queued from background thread for main-thread rendering
         self._pending_comms: list[dict] = []
@@ -750,8 +748,6 @@ class App:
         return output
 
     def _append_tool_log(self, script: str, result: str):
-        self._last_script = script
-        self._last_output = result
         self._tool_log.append((script, result))
         self._rebuild_tool_log()
         
@@ -1114,8 +1110,16 @@ class App:
 
     def cb_md_only(self):
         try:
-            md, path, _file_items = self._do_generate()
-            self.last_md = md
+            result_from_do_generate = self._do_generate()
+            if not isinstance(result_from_do_generate, (list, tuple)):
+                self._update_status(f"generate error: _do_generate returned a non-tuple ({type(result_from_do_generate)})")
+                return
+            num_values = len(result_from_do_generate)
+            if num_values != 4:
+                self._update_status(f"generate error: _do_generate returned {num_values} values, expected 4")
+                return
+            static_md, dynamic_md, path, _file_items = result_from_do_generate
+            self.last_md = f"{static_md}\n\n---\n\n{dynamic_md}" if static_md and dynamic_md else static_md or dynamic_md
             self.last_md_path = path
             self._update_status(f"md written: {path.name}")
         except Exception as e:
@@ -1138,8 +1142,16 @@ class App:
         if self.send_thread and self.send_thread.is_alive():
             return
         try:
-            md, path, file_items = self._do_generate()
-            self.last_md = md
+            result_from_do_generate = self._do_generate()
+            if not isinstance(result_from_do_generate, (list, tuple)):
+                self._update_status(f"generate error: _do_generate returned a non-tuple ({type(result_from_do_generate)})")
+                return
+            num_values = len(result_from_do_generate)
+            if num_values != 4:
+                self._update_status(f"generate error: _do_generate returned {num_values} values, expected 4")
+                return
+            static_md, dynamic_md, path, file_items = result_from_do_generate
+            self.last_md = static_md
             self.last_md_path = path
             self.last_file_items = file_items
         except Exception as e:
@@ -1921,7 +1933,8 @@ class App:
                 dpg.add_text("Script:")
                 dpg.add_button(
                     label="[+ Maximize]",
-                    callback=lambda s, a, u: _show_text_viewer("Last Script", self._last_script),
+                    user_data="last_script_text",
+                    callback=lambda s, a, u: _show_text_viewer("Last Script", dpg.get_value(u))
                 )
             dpg.add_input_text(
                 tag="last_script_text",
@@ -1937,7 +1950,8 @@ class App:
                 dpg.add_text("Output:")
                 dpg.add_button(
                     label="[+ Maximize]",
-                    callback=lambda s, a, u: _show_text_viewer("Last Output", self._last_output),
+                    user_data="last_script_output",
+                    callback=lambda s, a, u: _show_text_viewer("Last Output", dpg.get_value(u))
                 )
             dpg.add_input_text(
                 tag="last_script_output",
@@ -2123,6 +2137,3 @@ def main():
 if __name__ == "__main__":
     main()
 
-
-
-