mcp-stata 1.13.0__py3-none-any.whl → 1.16.6__py3-none-any.whl

mcp_stata/stata_client.py

@@ -1,4 +1,5 @@
 import asyncio
+import io
 import inspect
 import json
 import logging
@@ -11,7 +12,7 @@ import tempfile
 import threading
 import time
 import uuid
-from contextlib import contextmanager
+from contextlib import contextmanager, redirect_stdout, redirect_stderr
 from importlib.metadata import PackageNotFoundError, version
 from io import StringIO
 from typing import Any, Awaitable, Callable, Dict, Generator, List, Optional, Tuple
@@ -158,12 +159,28 @@ class StataClient:
     MAX_CACHE_BYTES = 500 * 1024 * 1024  # Maximum cache size in bytes (~500MB)
     LIST_GRAPHS_TTL = 0.075  # TTL for list_graphs cache (75ms)
 
+    def __init__(self):
+        self._exec_lock = threading.RLock()
+        self._is_executing = False
+        self._command_idx = 0  # Counter for user-initiated commands
+        self._initialized = False
+        from .graph_detector import GraphCreationDetector
+        self._graph_detector = GraphCreationDetector(self)
+
     def __new__(cls):
         inst = super(StataClient, cls).__new__(cls)
         inst._exec_lock = threading.RLock()
         inst._is_executing = False
+        inst._command_idx = 0
+        from .graph_detector import GraphCreationDetector
+        inst._graph_detector = GraphCreationDetector(inst)
         return inst
 
+    def _increment_command_idx(self) -> int:
+        """Increment and return the command counter."""
+        self._command_idx += 1
+        return self._command_idx
+
     @contextmanager
     def _redirect_io(self, out_buf, err_buf):
         """Safely redirect stdout/stderr for the duration of a Stata call."""
@@ -204,9 +221,16 @@ class StataClient:
         except Exception:
             pass
 
-    def _create_smcl_log_path(self, *, prefix: str = "mcp_smcl_", max_hex: Optional[int] = None) -> str:
+    def _create_smcl_log_path(
+        self,
+        *,
+        prefix: str = "mcp_smcl_",
+        max_hex: Optional[int] = None,
+        base_dir: Optional[str] = None,
+    ) -> str:
         hex_id = uuid.uuid4().hex if max_hex is None else uuid.uuid4().hex[:max_hex]
-        smcl_path = os.path.join(tempfile.gettempdir(), f"{prefix}{hex_id}.smcl")
+        base = os.path.realpath(tempfile.gettempdir())
+        smcl_path = os.path.join(base, f"{prefix}{hex_id}.smcl")
         self._safe_unlink(smcl_path)
         return smcl_path
 
@@ -215,19 +239,110 @@ class StataClient:
         return f"_mcp_smcl_{uuid.uuid4().hex[:8]}"
 
     def _open_smcl_log(self, smcl_path: str, log_name: str, *, quiet: bool = False) -> bool:
-        cmd = f"{'quietly ' if quiet else ''}log using \"{smcl_path}\", replace smcl name({log_name})"
+        path_for_stata = smcl_path.replace("\\", "/")
+        base_cmd = f"log using \"{path_for_stata}\", replace smcl name({log_name})"
+        unnamed_cmd = f"log using \"{path_for_stata}\", replace smcl"
         for attempt in range(4):
             try:
-                self.stata.run(cmd, echo=False)
-                return True
-            except Exception:
+                logger.debug(
+                    "_open_smcl_log attempt=%s log_name=%s path=%s",
+                    attempt + 1,
+                    log_name,
+                    smcl_path,
+                )
+                logger.warning(
+                    "SMCL open attempt %s cwd=%s path=%s",
+                    attempt + 1,
+                    os.getcwd(),
+                    smcl_path,
+                )
+                logger.debug(
+                    "SMCL open attempt=%s cwd=%s path=%s cmd=%s",
+                    attempt + 1,
+                    os.getcwd(),
+                    smcl_path,
+                    base_cmd,
+                )
+                try:
+                    close_ret = self.stata.run("capture log close _all", echo=False)
+                    if close_ret:
+                        logger.warning("SMCL close_all output: %s", close_ret)
+                except Exception:
+                    pass
+                cmd = f"{'quietly ' if quiet else ''}{base_cmd}"
+                try:
+                    output_buf = StringIO()
+                    with redirect_stdout(output_buf), redirect_stderr(output_buf):
+                        self.stata.run(cmd, echo=False)
+                    ret = output_buf.getvalue().strip()
+                    if ret:
+                        logger.warning("SMCL log open output: %s", ret)
+                except Exception as e:
+                    logger.warning("SMCL log open failed (attempt %s): %s", attempt + 1, e)
+                    logger.warning("SMCL log open failed: %r", e)
+                    try:
+                        retry_buf = StringIO()
+                        with redirect_stdout(retry_buf), redirect_stderr(retry_buf):
+                            self.stata.run(base_cmd, echo=False)
+                        ret = retry_buf.getvalue().strip()
+                        if ret:
+                            logger.warning("SMCL log open output (no quiet): %s", ret)
+                    except Exception as inner:
+                        logger.warning("SMCL log open retry failed: %s", inner)
+                query_buf = StringIO()
+                try:
+                    with redirect_stdout(query_buf), redirect_stderr(query_buf):
+                        self.stata.run("log query", echo=False)
+                except Exception as query_err:
+                    query_buf.write(f"log query failed: {query_err!r}")
+                query_ret = query_buf.getvalue().strip()
+                logger.warning("SMCL log query output: %s", query_ret)
+
+                if query_ret:
+                    query_lower = query_ret.lower()
+                    log_confirmed = "log:" in query_lower and "smcl" in query_lower and " on" in query_lower
+                    if log_confirmed:
+                        self._last_smcl_log_named = True
+                        logger.info("SMCL log confirmed: %s", path_for_stata)
+                        return True
+                logger.warning("SMCL log not confirmed after open; query_ret=%s", query_ret)
+                try:
+                    unnamed_output = StringIO()
+                    with redirect_stdout(unnamed_output), redirect_stderr(unnamed_output):
+                        self.stata.run(unnamed_cmd, echo=False)
+                    unnamed_ret = unnamed_output.getvalue().strip()
+                    if unnamed_ret:
+                        logger.warning("SMCL log open output (unnamed): %s", unnamed_ret)
+                except Exception as e:
+                    logger.warning("SMCL log open failed (unnamed, attempt %s): %s", attempt + 1, e)
+                unnamed_query_buf = StringIO()
+                try:
+                    with redirect_stdout(unnamed_query_buf), redirect_stderr(unnamed_query_buf):
+                        self.stata.run("log query", echo=False)
+                except Exception as query_err:
+                    unnamed_query_buf.write(f"log query failed: {query_err!r}")
+                unnamed_query = unnamed_query_buf.getvalue().strip()
+                if unnamed_query:
+                    unnamed_lower = unnamed_query.lower()
+                    unnamed_confirmed = "log:" in unnamed_lower and "smcl" in unnamed_lower and " on" in unnamed_lower
+                    if unnamed_confirmed:
+                        self._last_smcl_log_named = False
+                        logger.info("SMCL log confirmed (unnamed): %s", path_for_stata)
+                        return True
+            except Exception as e:
+                logger.warning("Failed to open SMCL log (attempt %s): %s", attempt + 1, e)
                 if attempt < 3:
                     time.sleep(0.1)
+        logger.warning("Failed to open SMCL log with cmd: %s", cmd)
         return False
 
     def _close_smcl_log(self, log_name: str) -> None:
         try:
-            self.stata.run(f"capture log close {log_name}", echo=False)
+            use_named = getattr(self, "_last_smcl_log_named", None)
+            if use_named is False:
+                self.stata.run("capture log close", echo=False)
+            else:
+                self.stata.run(f"capture log close {log_name}", echo=False)
         except Exception:
             pass
 
@@ -281,6 +396,9 @@ class StataClient:
     ) -> Optional[dict[str, str]]:
         # Capture initial graph state BEFORE execution starts
         if graph_cache:
+            # Clear detection state for the new command (detected/removed sets)
+            # but preserve _last_graph_state signatures for modification detection.
+            graph_cache.detector.clear_detection_state()
             try:
                 graph_cache._initial_graphs = set(self.list_graphs(force_refresh=True))
                 logger.debug(f"Initial graph state captured: {graph_cache._initial_graphs}")
@@ -312,14 +430,21 @@ class StataClient:
             return
         try:
             cached_graphs = []
-            initial_graphs = getattr(graph_cache, "_initial_graphs", set())
-            current_graphs = set(self.list_graphs(force_refresh=True))
-            new_graphs = current_graphs - initial_graphs - graph_cache._cached_graphs
-
-            if new_graphs:
-                logger.info(f"Detected {len(new_graphs)} new graph(s): {sorted(new_graphs)}")
+            # Use detector to find new OR modified graphs
+            pystata_detected = await anyio.to_thread.run_sync(graph_cache.detector._detect_graphs_via_pystata)
+            
+            # Combine with any pending graphs in queue
+            with graph_cache._lock:
+                to_process = set(pystata_detected) | set(graph_cache._graphs_to_cache)
+                graph_cache._graphs_to_cache.clear()
+            
+            if to_process:
+                logger.info(f"Detected {len(to_process)} new or modified graph(s): {sorted(to_process)}")
 
-            for graph_name in new_graphs:
+            for graph_name in to_process:
+                if graph_name in graph_cache._cached_graphs:
+                    continue
+                    
                 try:
                     cache_result = await anyio.to_thread.run_sync(
                         self.cache_graph_on_creation,
@@ -379,7 +504,8 @@ class StataClient:
         on_chunk: Optional[Callable[[str], Awaitable[None]]] = None,
     ) -> None:
         last_pos = 0
-        # Wait for Stata to create the SMCL file (placeholder removed to avoid locks)
+        emitted_debug_chunks = 0
+        # Wait for Stata to create the SMCL file
         while not done.is_set() and not os.path.exists(smcl_path):
             await anyio.sleep(0.05)
 
@@ -399,7 +525,7 @@ class StataClient:
                             return ""
                         except Exception:
                             return ""
-                    raise
+                    return ""
                 except FileNotFoundError:
                     return ""
 
@@ -407,17 +533,32 @@ class StataClient:
                 chunk = await anyio.to_thread.run_sync(_read_content)
                 if chunk:
                     last_pos += len(chunk)
-                    await notify_log(chunk)
+                    try:
+                        await notify_log(chunk)
+                    except Exception as exc:
+                        logger.debug("notify_log failed: %s", exc)
                     if on_chunk is not None:
-                        await on_chunk(chunk)
+                        try:
+                            await on_chunk(chunk)
+                        except Exception as exc:
+                            logger.debug("on_chunk callback failed: %s", exc)
                 await anyio.sleep(0.05)
 
             chunk = await anyio.to_thread.run_sync(_read_content)
+            if on_chunk is not None:
+                # Final check even if last chunk is empty, to ensure 
+                # graphs created at the very end are detected.
+                try:
+                    await on_chunk(chunk or "")
+                except Exception as exc:
+                    logger.debug("final on_chunk check failed: %s", exc)
+            
             if chunk:
                 last_pos += len(chunk)
-                await notify_log(chunk)
-                if on_chunk is not None:
-                    await on_chunk(chunk)
+                try:
+                    await notify_log(chunk)
+                except Exception as exc:
+                    logger.debug("notify_log failed: %s", exc)
 
         except Exception as e:
             logger.warning(f"Log streaming failed: {e}")
@@ -442,9 +583,21 @@ class StataClient:
             try:
                 from sfi import Scalar, SFIToolkit  # Import SFI tools
                 with self._temp_cwd(cwd):
-                    log_opened = self._open_smcl_log(smcl_path, smcl_log_name)
+                    logger.debug(
+                        "opening SMCL log name=%s path=%s cwd=%s",
+                        smcl_log_name,
+                        smcl_path,
+                        os.getcwd(),
+                    )
+                    try:
+                        log_opened = self._open_smcl_log(smcl_path, smcl_log_name, quiet=True)
+                    except Exception as e:
+                        log_opened = False
+                        logger.warning("_open_smcl_log raised: %r", e)
+                    logger.info("SMCL log_opened=%s path=%s", log_opened, smcl_path)
                     if require_smcl_log and not log_opened:
                         exc = RuntimeError("Failed to open SMCL log")
+                        logger.error("SMCL log open failed for %s", smcl_path)
                         rc = 1
                     if exc is None:
                         try:
@@ -452,7 +605,10 @@ class StataClient:
                                 try:
                                     if trace:
                                         self.stata.run("set trace on")
+                                    logger.debug("running Stata command echo=%s: %s", echo, command)
                                     ret = self.stata.run(command, echo=echo)
+                                    if ret:
+                                        logger.debug("stata.run output: %s", ret)
 
                                     setattr(self, hold_attr, f"mcp_hold_{uuid.uuid4().hex[:8]}")
                                     self.stata.run(
@@ -471,6 +627,7 @@ class StataClient:
                                         pass
                                 except Exception as e:
                                     exc = e
+                                    logger.error("stata.run failed: %r", e)
                                     if rc in (-1, 0):
                                         rc = 1
                                 finally:
@@ -688,7 +845,15 @@ class StataClient:
             return None
         try:
             with self._cache_lock:
-                return self._preemptive_cache.get(graph_name)
+                cache_path = self._preemptive_cache.get(graph_name)
+                if not cache_path:
+                    return None
+                
+                # Double-check validity (e.g. signature match for current command)
+                if not self._is_cache_valid(graph_name, cache_path):
+                    return None
+                    
+                return cache_path
         except Exception:
             return None
 
@@ -743,13 +908,16 @@ class StataClient:
         graph_ready_format: str,
         graph_ready_initial: Optional[dict[str, str]],
         last_check: List[float],
+        force: bool = False,
     ) -> None:
         if not graph_cache or not graph_cache.auto_cache:
             return
-        if self._is_executing:
+        if self._is_executing and not force:
+            # Skip polling if Stata is busy; it will block on _exec_lock anyway.
+            # During final check (force=True), we know it's safe because _run_streaming_blocking has finished.
             return
         now = time.monotonic()
-        if last_check and now - last_check[0] < 0.25:
+        if not force and last_check and now - last_check[0] < 0.25:
             return
         if last_check:
             last_check[0] = now
@@ -789,9 +957,14 @@ class StataClient:
             if previous is not None and previous == signature:
                 continue
             try:
-                export_path = await anyio.to_thread.run_sync(
-                    lambda: self.export_graph(graph_name, format=export_format)
-                )
+                export_path = None
+                if export_format == "svg":
+                    export_path = self._get_cached_graph_path(graph_name)
+                
+                if not export_path:
+                    export_path = await anyio.to_thread.run_sync(
+                        lambda: self.export_graph(graph_name, format=export_format)
+                    )
                 payload = {
                     "event": "graph_ready",
                     "task_id": task_id,
@@ -807,17 +980,18 @@ class StataClient:
                 logger.warning("graph_ready export failed for %s: %s", graph_name, e)
 
     def _get_graph_signature(self, graph_name: str) -> str:
+        """
+        Get a stable signature for a graph without calling Stata.
+        Consistent with GraphCreationDetector implementation.
+        """
         if not graph_name:
             return ""
-        try:
-            response = self.exec_lightweight(f"graph describe {graph_name}")
-            if response.success and response.stdout:
-                return response.stdout
-            if response.stderr:
-                return response.stderr
-        except Exception:
-            return ""
-        return ""
+        cmd_idx = getattr(self, "_command_idx", 0)
+        # Only include command index for default 'Graph' to detect modifications.
+        # For named graphs, we only want to detect them when they are new or renamed.
+        if graph_name.lower() == "graph":
+            return f"{graph_name}_{cmd_idx}"
+        return graph_name
 
     def _request_break_in(self) -> None:
         """
@@ -924,6 +1098,10 @@ class StataClient:
             
             # Get discovered Stata paths (cached from first call)
             discovery_candidates = _get_discovery_candidates()
+            if not discovery_candidates:
+                raise RuntimeError("No Stata candidates found during discovery")
+            
+            logger.info("Initializing Stata engine (attempting up to %d candidate binaries)...", len(discovery_candidates))
 
             # Diagnostic: force faulthandler to output to stderr for C crashes
             import faulthandler
@@ -952,13 +1130,16 @@ class StataClient:
                     curr = parent
 
                 ordered_candidates = []
-                if bin_dir:
-                    ordered_candidates.append(bin_dir)
                 if app_bundle:
-                    ordered_candidates.append(app_bundle)
+                    # On macOS, the parent of the .app is often the correct install path
+                    # (e.g., /Applications/StataNow containing StataMP.app)
                     parent_dir = os.path.dirname(app_bundle)
-                    if parent_dir not in ordered_candidates:
+                    if parent_dir and parent_dir != "/":
                         ordered_candidates.append(parent_dir)
+                    ordered_candidates.append(app_bundle)
+                
+                if bin_dir:
+                    ordered_candidates.append(bin_dir)
                 
                 # Deduplicate preserving order
                 seen = set()
@@ -982,7 +1163,8 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
     try:
         stata_setup.config({repr(path)}, {repr(edition)})
         from pystata import stata
-        stata.run('about', echo=True)
+        # Minimal verification of engine health
+        stata.run('display 1', echo=False)
         print('PREFLIGHT_OK')
     except Exception as e:
         print(f'PREFLIGHT_FAIL: {{e}}', file=sys.stderr)
@@ -990,9 +1172,11 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
 """
                         
                         try:
+                            # Use shorter timeout for pre-flight if feasible, 
+                            # but keep it safe for slow environments. 15s is usually enough for a ping.
                             res = subprocess.run(
                                 [sys.executable, "-c", preflight_code],
-                                capture_output=True, text=True, timeout=30
+                                capture_output=True, text=True, timeout=20
                             )
                             if res.returncode != 0:
                                 sys.stderr.write(f"[mcp_stata] Pre-flight failed (rc={res.returncode}) for '{path}'\n")
@@ -1435,6 +1619,7 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
         if not self._initialized:
             self.init()
 
+        self._increment_command_idx()
         # Rewrite graph names with special characters to internal aliases
         code = self._maybe_rewrite_graph_name_in_command(code)
 
@@ -1452,7 +1637,7 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
                 with self._temp_cwd(cwd):
                     # Create SMCL log for authoritative output capture
                     # Use shorter unique path to avoid Windows path issues
-                    smcl_path = self._create_smcl_log_path(prefix="mcp_", max_hex=16)
+                    smcl_path = self._create_smcl_log_path(prefix="mcp_", max_hex=16, base_dir=cwd)
                     log_name = self._make_smcl_log_name()
                     self._open_smcl_log(smcl_path, log_name)
                     
@@ -1598,6 +1783,57 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
             error=error,
         )
 
+    def _exec_no_capture_silent(self, code: str, echo: bool = False, trace: bool = False) -> CommandResponse:
+        """Execute Stata code while suppressing stdout/stderr output."""
+        if not self._initialized:
+            self.init()
+
+        exc: Optional[Exception] = None
+        ret_text: Optional[str] = None
+        rc = 0
+
+        with self._exec_lock:
+            try:
+                from sfi import Scalar  # Import SFI tools
+                if trace:
+                    self.stata.run("set trace on")
+                output_buf = StringIO()
+                with redirect_stdout(output_buf), redirect_stderr(output_buf):
+                    ret = self.stata.run(code, echo=echo)
+                if isinstance(ret, str) and ret:
+                    ret_text = ret
+            except Exception as e:
+                exc = e
+                rc = 1
+            finally:
+                if trace:
+                    try:
+                        self.stata.run("set trace off")
+                    except Exception as e:
+                        logger.warning("Failed to turn off Stata trace mode: %s", e)
+
+        stdout = ""
+        stderr = ""
+        success = rc == 0 and exc is None
+        error = None
+        if not success:
+            msg = str(exc) if exc else f"Stata error r({rc})"
+            error = ErrorEnvelope(
+                message=msg,
+                rc=rc,
+                command=code,
+                stdout=ret_text,
+            )
+
+        return CommandResponse(
+            command=code,
+            rc=rc,
+            stdout=stdout,
+            stderr=None,
+            success=success,
+            error=error,
+        )
+
     def exec_lightweight(self, code: str) -> CommandResponse:
         """
         Executes a command using simple stdout redirection (no SMCL logs).
@@ -1682,7 +1918,7 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
         _log_file, log_path, tail, tee = self._create_streaming_log(trace=trace)
 
         # Create SMCL log path for authoritative output capture
-        smcl_path = self._create_smcl_log_path()
+        smcl_path = self._create_smcl_log_path(base_dir=cwd)
         smcl_log_name = self._make_smcl_log_name()
 
         # Inform the MCP client immediately where to read/tail the output.
@@ -1693,80 +1929,94 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
         command = f'{path_for_stata}'
 
         graph_ready_initial = self._capture_graph_state(graph_cache, emit_graph_ready)
+        
+        # Increment AFTER capture so detected modifications are based on state BEFORE this command
+        self._increment_command_idx()
+
         graph_poll_state = [0.0]
 
         async def on_chunk_for_graphs(_chunk: str) -> None:
-            await self._maybe_cache_graphs_on_chunk(
-                graph_cache=graph_cache,
-                emit_graph_ready=emit_graph_ready,
-                notify_log=notify_log,
-                graph_ready_task_id=graph_ready_task_id,
-                graph_ready_format=graph_ready_format,
-                graph_ready_initial=graph_ready_initial,
-                last_check=graph_poll_state,
-            )
-
-        done = anyio.Event()
-
-        async with anyio.create_task_group() as tg:
-            async def stream_smcl() -> None:
-                await self._stream_smcl_log(
-                    smcl_path=smcl_path,
+            # Background the graph check so we don't block SMCL streaming or task completion
+            asyncio.create_task(
+                self._maybe_cache_graphs_on_chunk(
+                    graph_cache=graph_cache,
+                    emit_graph_ready=emit_graph_ready,
                     notify_log=notify_log,
-                    done=done,
-                    on_chunk=on_chunk_for_graphs if graph_cache else None,
+                    graph_ready_task_id=graph_ready_task_id,
+                    graph_ready_format=graph_ready_format,
+                    graph_ready_initial=graph_ready_initial,
+                    last_check=graph_poll_state,
                 )
+            )
 
-            tg.start_soon(stream_smcl)
+        done = anyio.Event()
 
-            if notify_progress is not None:
-                if total_lines > 0:
-                    await notify_progress(0, float(total_lines), f"Executing command: 0/{total_lines}")
-                else:
-                    await notify_progress(0, None, "Running command")
+        try:
+            async with anyio.create_task_group() as tg:
+                async def stream_smcl() -> None:
+                    try:
+                        await self._stream_smcl_log(
+                            smcl_path=smcl_path,
+                            notify_log=notify_log,
+                            done=done,
+                            on_chunk=on_chunk_for_graphs if graph_cache else None,
+                        )
+                    except Exception as exc:
+                        logger.debug("SMCL streaming failed: %s", exc)
+
+                tg.start_soon(stream_smcl)
+
+                if notify_progress is not None:
+                    if total_lines > 0:
+                        await notify_progress(0, float(total_lines), f"Executing command: 0/{total_lines}")
+                    else:
+                        await notify_progress(0, None, "Running command")
 
-            try:
-                run_blocking = lambda: self._run_streaming_blocking(
-                    command=command,
-                    tee=tee,
-                    cwd=cwd,
-                    trace=trace,
-                    echo=echo,
-                    smcl_path=smcl_path,
-                    smcl_log_name=smcl_log_name,
-                    hold_attr="_hold_name_stream",
-                )
                 try:
-                    rc, exc = await anyio.to_thread.run_sync(
-                        run_blocking,
-                        abandon_on_cancel=True,
+                    run_blocking = lambda: self._run_streaming_blocking(
+                        command=command,
+                        tee=tee,
+                        cwd=cwd,
+                        trace=trace,
+                        echo=echo,
+                        smcl_path=smcl_path,
+                        smcl_log_name=smcl_log_name,
+                        hold_attr="_hold_name_stream",
+                        require_smcl_log=True,
                     )
-                except TypeError:
-                    rc, exc = await anyio.to_thread.run_sync(run_blocking)
-            except get_cancelled_exc_class():
-                self._request_break_in()
-                await self._wait_for_stata_stop()
-                raise
-            finally:
-                done.set()
-                tee.close()
+                    try:
+                        rc, exc = await anyio.to_thread.run_sync(
+                            run_blocking,
+                            abandon_on_cancel=True,
+                        )
+                    except TypeError:
+                        rc, exc = await anyio.to_thread.run_sync(run_blocking)
+                except Exception as e:
+                    exc = e
+                    if rc in (-1, 0):
+                        rc = 1
+                except get_cancelled_exc_class():
+                    self._request_break_in()
+                    await self._wait_for_stata_stop()
+                    raise
+                finally:
+                    done.set()
+                    tee.close()
+        except* Exception as exc_group:
+            logger.debug("SMCL streaming task group failed: %s", exc_group)
 
         # Read SMCL content as the authoritative source
         smcl_content = self._read_smcl_file(smcl_path)
 
-        await self._cache_new_graphs(
-            graph_cache,
-            notify_progress=notify_progress,
-            total_lines=total_lines,
-            completed_label="Command",
-        )
-        self._emit_graph_ready_task(
-            emit_graph_ready=emit_graph_ready,
-            graph_ready_initial=graph_ready_initial,
-            notify_log=notify_log,
-            graph_ready_task_id=graph_ready_task_id,
-            graph_ready_format=graph_ready_format,
-        )
+        if graph_cache:
+            asyncio.create_task(
+                self._cache_new_graphs(
+                    graph_cache,
+                    notify_progress=notify_progress,
+                    total_lines=total_lines,
+                    completed_label="Command",
+                )
+            )
 
         combined = self._build_combined_log(tail, smcl_path, rc, trace, exc)
         
@@ -1888,7 +2138,8 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
         graph_cache = self._init_streaming_graph_cache(auto_cache_graphs, on_graph_cached, notify_log)
         _log_file, log_path, tail, tee = self._create_streaming_log(trace=trace)
 
-        smcl_path = self._create_smcl_log_path()
+        base_dir = cwd or os.path.dirname(effective_path)
+        smcl_path = self._create_smcl_log_path(base_dir=base_dir)
         smcl_log_name = self._make_smcl_log_name()
 
         # Inform the MCP client immediately where to read/tail the output.
@@ -1896,17 +2147,24 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
 
         rc = -1
         graph_ready_initial = self._capture_graph_state(graph_cache, emit_graph_ready)
+        
+        # Increment AFTER capture
+        self._increment_command_idx()
+        
         graph_poll_state = [0.0]
 
         async def on_chunk_for_graphs(_chunk: str) -> None:
-            await self._maybe_cache_graphs_on_chunk(
-                graph_cache=graph_cache,
-                emit_graph_ready=emit_graph_ready,
-                notify_log=notify_log,
-                graph_ready_task_id=graph_ready_task_id,
-                graph_ready_format=graph_ready_format,
-                graph_ready_initial=graph_ready_initial,
-                last_check=graph_poll_state,
+            # Background the graph check so we don't block SMCL streaming or task completion
+            asyncio.create_task(
+                self._maybe_cache_graphs_on_chunk(
+                    graph_cache=graph_cache,
+                    emit_graph_ready=emit_graph_ready,
+                    notify_log=notify_log,
+                    graph_ready_task_id=graph_ready_task_id,
+                    graph_ready_format=graph_ready_format,
+                    graph_ready_initial=graph_ready_initial,
+                    last_check=graph_poll_state,
+                )
             )
 
         on_chunk_callback = on_chunk_for_progress
@@ -1917,65 +2175,72 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
 
         done = anyio.Event()
 
-        async with anyio.create_task_group() as tg:
-            async def stream_smcl() -> None:
-                await self._stream_smcl_log(
-                    smcl_path=smcl_path,
-                    notify_log=notify_log,
-                    done=done,
-                    on_chunk=on_chunk_callback,
-                )
-
-            tg.start_soon(stream_smcl)
-
-            if notify_progress is not None:
-                if total_lines > 0:
-                    await notify_progress(0, float(total_lines), f"Executing do-file: 0/{total_lines}")
-                else:
-                    await notify_progress(0, None, "Running do-file")
+        try:
+            async with anyio.create_task_group() as tg:
+                async def stream_smcl() -> None:
+                    try:
+                        await self._stream_smcl_log(
+                            smcl_path=smcl_path,
+                            notify_log=notify_log,
+                            done=done,
+                            on_chunk=on_chunk_callback,
+                        )
+                    except Exception as exc:
+                        logger.debug("SMCL streaming failed: %s", exc)
+
+                tg.start_soon(stream_smcl)
+
+                if notify_progress is not None:
+                    if total_lines > 0:
+                        await notify_progress(0, float(total_lines), f"Executing do-file: 0/{total_lines}")
+                    else:
+                        await notify_progress(0, None, "Running do-file")
 
-            try:
-                run_blocking = lambda: self._run_streaming_blocking(
-                    command=command,
-                    tee=tee,
-                    cwd=cwd,
-                    trace=trace,
-                    echo=echo,
-                    smcl_path=smcl_path,
-                    smcl_log_name=smcl_log_name,
-                    hold_attr="_hold_name_do",
-                )
                 try:
-                    rc, exc = await anyio.to_thread.run_sync(
-                        run_blocking,
-                        abandon_on_cancel=True,
+                    run_blocking = lambda: self._run_streaming_blocking(
+                        command=command,
+                        tee=tee,
+                        cwd=cwd,
+                        trace=trace,
+                        echo=echo,
+                        smcl_path=smcl_path,
+                        smcl_log_name=smcl_log_name,
+                        hold_attr="_hold_name_do",
+                        require_smcl_log=True,
                     )
-                except TypeError:
-                    rc, exc = await anyio.to_thread.run_sync(run_blocking)
-            except get_cancelled_exc_class():
-                self._request_break_in()
-                await self._wait_for_stata_stop()
-                raise
-            finally:
-                done.set()
-                tee.close()
+                    try:
+                        rc, exc = await anyio.to_thread.run_sync(
+                            run_blocking,
+                            abandon_on_cancel=True,
+                        )
+                    except TypeError:
+                        rc, exc = await anyio.to_thread.run_sync(run_blocking)
+                except Exception as e:
+                    exc = e
+                    if rc in (-1, 0):
+                        rc = 1
+                except get_cancelled_exc_class():
+                    self._request_break_in()
+                    await self._wait_for_stata_stop()
+                    raise
+                finally:
+                    done.set()
+                    tee.close()
+        except* Exception as exc_group:
+            logger.debug("SMCL streaming task group failed: %s", exc_group)
 
         # Read SMCL content as the authoritative source
         smcl_content = self._read_smcl_file(smcl_path)
 
-        await self._cache_new_graphs(
-            graph_cache,
-            notify_progress=notify_progress,
-            total_lines=total_lines,
-            completed_label="Do-file",
-        )
-        self._emit_graph_ready_task(
-            emit_graph_ready=emit_graph_ready,
-            graph_ready_initial=graph_ready_initial,
-            notify_log=notify_log,
-            graph_ready_task_id=graph_ready_task_id,
-            graph_ready_format=graph_ready_format,
-        )
+        if graph_cache:
+            asyncio.create_task(
+                self._cache_new_graphs(
+                    graph_cache,
+                    notify_progress=notify_progress,
+                    total_lines=total_lines,
+                    completed_label="Do-file",
+                )
+            )
 
         combined = self._build_combined_log(tail, log_path, rc, trace, exc)
         
@@ -2064,17 +2329,18 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
         if count > self.MAX_DATA_ROWS:
             count = self.MAX_DATA_ROWS
 
-        try:
-            # Use pystata integration to retrieve data
-            df = self.stata.pdataframe_from_data()
+        with self._exec_lock:
+            try:
+                # Use pystata integration to retrieve data
+                df = self.stata.pdataframe_from_data()
 
-            # Slice
-            sliced = df.iloc[start : start + count]
+                # Slice
+                sliced = df.iloc[start : start + count]
 
-            # Convert to dict
-            return sliced.to_dict(orient="records")
-        except Exception as e:
-            return [{"error": f"Failed to retrieve data: {e}"}]
+                # Convert to dict
+                return sliced.to_dict(orient="records")
+            except Exception as e:
+                return [{"error": f"Failed to retrieve data: {e}"}]
 
     def list_variables(self) -> List[Dict[str, str]]:
         """Returns list of variables with labels."""
@@ -2084,17 +2350,18 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
         # We can use sfi to be efficient
         from sfi import Data  # type: ignore[import-not-found]
         vars_info = []
-        for i in range(Data.getVarCount()):
-            var_index = i # 0-based
-            name = Data.getVarName(var_index)
-            label = Data.getVarLabel(var_index)
-            type_str = Data.getVarType(var_index) # Returns int
-
-            vars_info.append({
-                "name": name,
-                "label": label,
-                "type": str(type_str),
-            })
+        with self._exec_lock:
+            for i in range(Data.getVarCount()):
+                var_index = i # 0-based
+                name = Data.getVarName(var_index)
+                label = Data.getVarLabel(var_index)
+                type_str = Data.getVarType(var_index) # Returns int
+
+                vars_info.append({
+                    "name": name,
+                    "label": label,
+                    "type": str(type_str),
+                })
         return vars_info
 
     def get_dataset_state(self) -> Dict[str, Any]:
@@ -2104,27 +2371,28 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
 
         from sfi import Data, Macro  # type: ignore[import-not-found]
 
-        n = int(Data.getObsTotal())
-        k = int(Data.getVarCount())
+        with self._exec_lock:
+            n = int(Data.getObsTotal())
+            k = int(Data.getVarCount())
 
-        frame = "default"
-        sortlist = ""
-        changed = False
-        try:
-            frame = str(Macro.getGlobal("frame") or "default")
-        except Exception:
-            logger.debug("Failed to get 'frame' macro", exc_info=True)
             frame = "default"
-        try:
-            sortlist = str(Macro.getGlobal("sortlist") or "")
-        except Exception:
-            logger.debug("Failed to get 'sortlist' macro", exc_info=True)
             sortlist = ""
-        try:
-            changed = bool(int(float(Macro.getGlobal("changed") or "0")))
-        except Exception:
-            logger.debug("Failed to get 'changed' macro", exc_info=True)
             changed = False
+            try:
+                frame = str(Macro.getGlobal("frame") or "default")
+            except Exception:
+                logger.debug("Failed to get 'frame' macro", exc_info=True)
+                frame = "default"
+            try:
+                sortlist = str(Macro.getGlobal("sortlist") or "")
+            except Exception:
+                logger.debug("Failed to get 'sortlist' macro", exc_info=True)
+                sortlist = ""
+            try:
+                changed = bool(int(float(Macro.getGlobal("changed") or "0")))
+            except Exception:
+                logger.debug("Failed to get 'changed' macro", exc_info=True)
+                changed = False
 
         return {"frame": frame, "n": n, "k": k, "sortlist": sortlist, "changed": changed}
 
@@ -2138,11 +2406,12 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
         from sfi import Data  # type: ignore[import-not-found]
 
         out: Dict[str, int] = {}
-        for i in range(int(Data.getVarCount())):
-            try:
-                out[str(Data.getVarName(i))] = i
-            except Exception:
-                continue
+        with self._exec_lock:
+            for i in range(int(Data.getVarCount())):
+                try:
+                    out[str(Data.getVarName(i))] = i
+                except Exception:
+                    continue
         return out
 
     def list_variables_rich(self) -> List[Dict[str, Any]]:
@@ -2549,45 +2818,46 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
                 return self._list_graphs_cache
 
         # Cache miss or expired, fetch fresh data
-        try:
-            # Preservation of r() results is critical because this can be called
-            # automatically after every user command (e.g., during streaming).
-            import time
-            hold_name = f"_mcp_ghold_{int(time.time() * 1000 % 1000000)}"
-            self.stata.run(f"capture _return hold {hold_name}", echo=False)
-            
+        with self._exec_lock:
             try:
-                self.stata.run("macro define mcp_graph_list \"\"", echo=False)
-                self.stata.run("quietly graph dir, memory", echo=False)
-                from sfi import Macro  # type: ignore[import-not-found]
-                self.stata.run("macro define mcp_graph_list `r(list)'", echo=False)
-                graph_list_str = Macro.getGlobal("mcp_graph_list")
-            finally:
-                self.stata.run(f"capture _return restore {hold_name}", echo=False)
+                # Preservation of r() results is critical because this can be called
+                # automatically after every user command (e.g., during streaming).
+                import time
+                hold_name = f"_mcp_ghold_{int(time.time() * 1000 % 1000000)}"
+                self.stata.run(f"capture _return hold {hold_name}", echo=False)
+                
+                try:
+                    self.stata.run("macro define mcp_graph_list \"\"", echo=False)
+                    self.stata.run("quietly graph dir, memory", echo=False)
+                    from sfi import Macro  # type: ignore[import-not-found]
+                    self.stata.run("macro define mcp_graph_list `r(list)'", echo=False)
+                    graph_list_str = Macro.getGlobal("mcp_graph_list")
+                finally:
+                    self.stata.run(f"capture _return restore {hold_name}", echo=False)
 
-            raw_list = graph_list_str.split() if graph_list_str else []
+                raw_list = graph_list_str.split() if graph_list_str else []
 
-            # Map internal Stata names back to user-facing names when we have an alias.
-            reverse = getattr(self, "_graph_name_reverse", {})
-            graph_list = [reverse.get(n, n) for n in raw_list]
+                # Map internal Stata names back to user-facing names when we have an alias.
+                reverse = getattr(self, "_graph_name_reverse", {})
+                graph_list = [reverse.get(n, n) for n in raw_list]
 
-            result = graph_list
+                result = graph_list
 
-            # Update cache
-            with self._list_graphs_cache_lock:
-                self._list_graphs_cache = result
-                self._list_graphs_cache_time = time.time()
-            
-            return result
-            
-        except Exception as e:
-            # On error, return cached result if available, otherwise empty list
-            with self._list_graphs_cache_lock:
-                if self._list_graphs_cache is not None:
-                    logger.warning(f"list_graphs failed, returning cached result: {e}")
-                    return self._list_graphs_cache
-            logger.warning(f"list_graphs failed, no cache available: {e}")
-            return []
+                # Update cache
+                with self._list_graphs_cache_lock:
+                    self._list_graphs_cache = result
+                    self._list_graphs_cache_time = time.time()
+                
+                return result
+                
+            except Exception as e:
+                # On error, return cached result if available, otherwise empty list
+                with self._list_graphs_cache_lock:
+                    if self._list_graphs_cache is not None:
+                        logger.warning(f"list_graphs failed, returning cached result: {e}")
+                        return self._list_graphs_cache
+                logger.warning(f"list_graphs failed, no cache available: {e}")
+                return []
 
     def list_graphs_structured(self) -> GraphListResponse:
         names = self.list_graphs()
@@ -2614,6 +2884,7 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
         if fmt not in {"pdf", "png", "svg"}:
             raise ValueError(f"Unsupported graph export format: {format}. Allowed: pdf, png, svg.")
 
+
         if not filename:
             suffix = f".{fmt}"
             with tempfile.NamedTemporaryFile(prefix="mcp_stata_", suffix=suffix, delete=False) as tmp:
@@ -2636,9 +2907,9 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
             gph_path_for_stata = gph_path.replace("\\", "/")
             # Make the target graph current, then save without name() (which isn't accepted there)
             if graph_name:
-                self._exec_no_capture(f'graph display "{graph_name}"', echo=False)
-            save_cmd = f'graph save "{gph_path_for_stata}", replace'
-            save_resp = self._exec_no_capture(save_cmd, echo=False)
+                self._exec_no_capture_silent(f'quietly graph display "{graph_name}"', echo=False)
+            save_cmd = f'quietly graph save "{gph_path_for_stata}", replace'
+            save_resp = self._exec_no_capture_silent(save_cmd, echo=False)
             if not save_resp.success:
                 msg = save_resp.error.message if save_resp.error else f"graph save failed (rc={save_resp.rc})"
                 raise RuntimeError(msg)
@@ -2646,8 +2917,8 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
             # 2) Prepare a do-file to export PNG externally
             user_filename_fwd = user_filename.replace("\\", "/")
             do_lines = [
-                f'graph use "{gph_path_for_stata}"',
-                f'graph export "{user_filename_fwd}", replace as(png)',
+                f'quietly graph use "{gph_path_for_stata}"',
+                f'quietly graph export "{user_filename_fwd}", replace as(png)',
                 "exit",
             ]
             with tempfile.NamedTemporaryFile(prefix="mcp_stata_export_", suffix=".do", delete=False, mode="w", encoding="ascii") as do_tmp:
@@ -2698,20 +2969,21 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
             # Stata prefers forward slashes in its command parser on Windows
             filename_for_stata = user_filename.replace("\\", "/")
 
-            cmd = "graph export"
             if graph_name:
                 resolved = self._resolve_graph_name_for_stata(graph_name)
-                cmd += f' "{filename_for_stata}", name("{resolved}") replace as({fmt})'
-            else:
-                cmd += f' "{filename_for_stata}", replace as({fmt})'
+                # Use display + export without name() for maximum compatibility.
+                # name(NAME) often fails in PyStata for non-active graphs (r(693)).
+                self._exec_no_capture_silent(f'quietly graph display "{resolved}"', echo=False)
+            
+            cmd = f'quietly graph export "{filename_for_stata}", replace as({fmt})'
 
             # Avoid stdout/stderr redirection for graph export because PyStata's
             # output thread can crash on Windows when we swap stdio handles.
-            resp = self._exec_no_capture(cmd, echo=False)
+            resp = self._exec_no_capture_silent(cmd, echo=False)
             if not resp.success:
                 # Retry once after a short pause in case Stata had a transient file handle issue
                 time.sleep(0.2)
-                resp_retry = self._exec_no_capture(cmd, echo=False)
+                resp_retry = self._exec_no_capture_silent(cmd, echo=False)
                 if not resp_retry.success:
                     msg = resp_retry.error.message if resp_retry.error else f"graph export failed (rc={resp_retry.rc})"
                     raise RuntimeError(msg)
@@ -2744,14 +3016,15 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
         if not self._initialized:
             self.init()
 
-        # Try to locate the .sthlp help file
-        # We use 'capture' to avoid crashing if not found
-        self.stata.run(f"capture findfile {topic}.sthlp")
+        with self._exec_lock:
+            # Try to locate the .sthlp help file
+            # We use 'capture' to avoid crashing if not found
+            self.stata.run(f"capture findfile {topic}.sthlp")
 
-        # Retrieve the found path from r(fn)
-        from sfi import Macro  # type: ignore[import-not-found]
-        self.stata.run("global mcp_help_file `r(fn)'")
-        fn = Macro.getGlobal("mcp_help_file")
+            # Retrieve the found path from r(fn)
+            from sfi import Macro  # type: ignore[import-not-found]
+            self.stata.run("global mcp_help_file `r(fn)'")
+            fn = Macro.getGlobal("mcp_help_file")
 
         if fn and os.path.exists(fn):
             try:
@@ -2985,47 +3258,32 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
             
             # Additional validation by attempting to display the graph
             resolved = self._resolve_graph_name_for_stata(graph_name)
-            cmd = f'graph display {resolved}'
-            resp = self._exec_no_capture(cmd, echo=False)
+            cmd = f'quietly graph display {resolved}'
+            resp = self._exec_no_capture_silent(cmd, echo=False)
             return resp.success
         except Exception:
             return False
     
     def _is_cache_valid(self, graph_name: str, cache_path: str) -> bool:
-        """Check if cached content is still valid."""
+        """Check if cached content is still valid using internal signatures."""
         try:
-            # Get current graph content hash
-            import tempfile
-            import os
-            
-            temp_dir = tempfile.gettempdir()
-            temp_file = os.path.join(temp_dir, f"temp_{graph_name}_{os.getpid()}.svg")
-
-            resolved = self._resolve_graph_name_for_stata(graph_name)
-            export_cmd = f'graph export "{temp_file.replace("\\\\", "/")}", name({resolved}) replace as(svg)'
-            resp = self._exec_no_capture(export_cmd, echo=False)
-            
-            if resp.success and os.path.exists(temp_file):
-                with open(temp_file, 'rb') as f:
-                    current_data = f.read()
-                os.remove(temp_file)
+            if not os.path.exists(cache_path) or os.path.getsize(cache_path) == 0:
+                return False
                 
-                current_hash = self._get_content_hash(current_data)
-                cached_hash = self._preemptive_cache.get(f"{graph_name}_hash")
+            current_sig = self._get_graph_signature(graph_name)
+            cached_sig = self._preemptive_cache.get(f"{graph_name}_sig")
+            
+            # If we have a signature match, it's valid for the current command session
+            if cached_sig and cached_sig == current_sig:
+                return True
                 
-                return cached_hash == current_hash
+            # Otherwise it's invalid (needs refresh for new command)
+            return False
         except Exception:
-            pass
-        
-        return False  # Assume invalid if we can't verify
-
-    def export_graphs_all(self, use_base64: bool = False) -> GraphExportResponse:
-        """Exports all graphs to file paths (default) or base64-encoded strings.
+            return False
 
-        Args:
-            use_base64: If True, returns base64-encoded images. If False (default),
-                       returns file paths to exported SVG files.
-        """
+    def export_graphs_all(self) -> GraphExportResponse:
+        """Exports all graphs to file paths."""
         exports: List[GraphExport] = []
         graph_names = self.list_graphs(force_refresh=True)
         
@@ -3035,7 +3293,6 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
         import tempfile
         import os
         import threading
-        import base64
         import uuid
         import time
         import logging
@@ -3059,15 +3316,15 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
             svg_path_for_stata = svg_path.replace("\\", "/")
 
             try:
-                export_cmd = f'graph export "{svg_path_for_stata}", name({resolved}) replace as(svg)'
-                export_resp = self._exec_no_capture(export_cmd, echo=False)
+                export_cmd = f'quietly graph export "{svg_path_for_stata}", name({resolved}) replace as(svg)'
+                export_resp = self._exec_no_capture_silent(export_cmd, echo=False)
 
                 if not export_resp.success:
-                    display_cmd = f'graph display {resolved}'
-                    display_resp = self._exec_no_capture(display_cmd, echo=False)
+                    display_cmd = f'quietly graph display {resolved}'
+                    display_resp = self._exec_no_capture_silent(display_cmd, echo=False)
                     if display_resp.success:
-                        export_cmd2 = f'graph export "{svg_path_for_stata}", replace as(svg)'
-                        export_resp = self._exec_no_capture(export_cmd2, echo=False)
+                        export_cmd2 = f'quietly graph export "{svg_path_for_stata}", replace as(svg)'
+                        export_resp = self._exec_no_capture_silent(export_cmd2, echo=False)
                     else:
                         export_resp = display_resp
 
@@ -3109,12 +3366,7 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
         
         for name, cached_path in cached_graphs.items():
             try:
-                if use_base64:
-                    with open(cached_path, "rb") as f:
-                        svg_b64 = base64.b64encode(f.read()).decode("ascii")
-                    exports.append(GraphExport(name=name, image_base64=svg_b64))
-                else:
-                    exports.append(GraphExport(name=name, file_path=cached_path))
+                exports.append(GraphExport(name=name, file_path=cached_path))
             except Exception as e:
                 cache_errors.append(f"Failed to read cached graph {name}: {e}")
                 # Fall back to uncached processing
@@ -3157,24 +3409,16 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
                         self._cache_sizes[name] = item_size
                         self._total_cache_size += item_size
                     
-                    if use_base64:
-                        svg_b64 = base64.b64encode(result).decode("ascii")
-                        exports.append(GraphExport(name=name, image_base64=svg_b64))
-                    else:
-                        exports.append(GraphExport(name=name, file_path=cache_path))
+                    exports.append(GraphExport(name=name, file_path=cache_path))
                 except Exception as e:
                     cache_errors.append(f"Failed to cache graph {name}: {e}")
                     # Still return the result even if caching fails
-                    if use_base64:
-                        svg_b64 = base64.b64encode(result).decode("ascii")
-                        exports.append(GraphExport(name=name, image_base64=svg_b64))
-                    else:
-                        # Create temp file for immediate use
-                        safe_name = self._sanitize_filename(name)
-                        temp_path = os.path.join(tempfile.gettempdir(), f"{safe_name}_{uuid.uuid4().hex[:8]}.svg")
-                        with open(temp_path, 'wb') as f:
-                            f.write(result)
-                        exports.append(GraphExport(name=name, file_path=temp_path))
+                    # Create temp file for immediate use
+                    safe_name = self._sanitize_filename(name)
+                    temp_path = os.path.join(tempfile.gettempdir(), f"{safe_name}_{uuid.uuid4().hex[:8]}.svg")
+                    with open(temp_path, 'wb') as f:
+                        f.write(result)
+                    exports.append(GraphExport(name=name, file_path=temp_path))
         
         # Log errors if any occurred
         if cache_errors:
@@ -3229,29 +3473,21 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
                             del self._preemptive_cache[hash_key]
         
         try:
-            # Sanitize graph name for file system
-            safe_name = self._sanitize_filename(graph_name)
+            # Include signature in filename to force client-side refresh
+            sig = self._get_graph_signature(graph_name)
+            safe_name = self._sanitize_filename(sig)
             cache_path = os.path.join(self._preemptive_cache_dir, f"{safe_name}.svg")
             cache_path_for_stata = cache_path.replace("\\", "/")
 
             resolved_graph_name = self._resolve_graph_name_for_stata(graph_name)
-            graph_name_q = self._stata_quote(resolved_graph_name)
+            # Use display + export without name() for maximum compatibility.
+            # name(NAME) often fails in PyStata for non-active graphs (r(693)).
+            # Quoting the name helps with spaces/special characters.
+            display_cmd = f'quietly graph display "{resolved_graph_name}"'
+            self._exec_no_capture_silent(display_cmd, echo=False)
             
-            export_cmd = f'graph export "{cache_path_for_stata}", name({graph_name_q}) replace as(svg)'
-            resp = self._exec_no_capture(export_cmd, echo=False)
-
-            # Fallback: some graph names (spaces, slashes, backslashes) can confuse
-            # Stata's parser in name() even when the graph exists. In that case,
-            # make the graph current, then export without name().
-            if not resp.success:
-                try:
-                    display_cmd = f'graph display {graph_name_q}'
-                    display_resp = self._exec_no_capture(display_cmd, echo=False)
-                    if display_resp.success:
-                        export_cmd2 = f'graph export "{cache_path_for_stata}", replace as(svg)'
-                        resp = self._exec_no_capture(export_cmd2, echo=False)
-                except Exception:
-                    pass
+            export_cmd = f'quietly graph export "{cache_path_for_stata}", replace as(svg)'
+            resp = self._exec_no_capture_silent(export_cmd, echo=False)
             
             if resp.success and os.path.exists(cache_path) and os.path.getsize(cache_path) > 0:
                 # Read the data to compute hash
@@ -3264,9 +3500,20 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
                 self._evict_cache_if_needed(item_size)
                 
                 with self._cache_lock:
+                    # Clear any old versions of this graph from the path cache
+                    # (Optional but keeps it clean)
+                    old_path = self._preemptive_cache.get(graph_name)
+                    if old_path and old_path != cache_path:
+                         try:
+                             os.remove(old_path)
+                         except Exception:
+                             pass
+
                     self._preemptive_cache[graph_name] = cache_path
                     # Store content hash for validation
                     self._preemptive_cache[f"{graph_name}_hash"] = self._get_content_hash(data)
+                    # Store signature for fast validation
+                    self._preemptive_cache[f"{graph_name}_sig"] = self._get_graph_signature(graph_name)
                     # Update tracking
                     self._cache_access_times[graph_name] = time.time()
                     self._cache_sizes[graph_name] = item_size
@@ -3298,7 +3545,8 @@ with redirect_stdout(sys.stderr), redirect_stderr(sys.stderr):
         smcl_path = None
 
         _log_file, log_path, tail, tee = self._create_streaming_log(trace=trace)
-        smcl_path = self._create_smcl_log_path()
+        base_dir = cwd or os.path.dirname(effective_path)
+        smcl_path = self._create_smcl_log_path(base_dir=base_dir)
         smcl_log_name = self._make_smcl_log_name()
 
         rc = -1