From c6a871bffdf47776f753debbeab7e7e83a6e3add Mon Sep 17 00:00:00 2001
From: Burhan Abdullah <131237388+BurhanAbdullah@users.noreply.github.com>
Date: Sat, 31 Oct 2026 01:00:46 +0530
Subject: [PATCH 01/12] fix(runner): restore temporary import paths after
 launch

---
 powermcp/runner.py | 82 ++++++++++++++++++++++++----------------------
 1 file changed, 42 insertions(+), 40 deletions(-)

diff --git a/powermcp/runner.py b/powermcp/runner.py
index 13ba81f3..39dfc2b3 100644
--- a/powermcp/runner.py
+++ b/powermcp/runner.py
@@ -5,15 +5,15 @@
 standalone from a checkout. Three launch styles (declared per tool in the
 registry):
 
-- ``script``: run the entry .py as ``__main__`` (its own ``mcp.run(...)`` fires),
-  after putting the server dir and its parent on ``sys.path`` so existing
-  relative imports (PyPSA's ``sys.path.append`` parent, OpenDSS's
-  ``from core.server import ...``) resolve exactly as in standalone use.
-- ``module``: put the module root on ``sys.path`` and ``runpy.run_module`` the
-  package's ``__main__`` (PSCAD's ``pscad_mcp.main``, HOPE's ``hope_mcp_server``).
-- ``package``: ``runpy.run_module`` a server that ships in its own distribution
-  and is already importable (powerio's ``powerio.mcp``). Nothing goes on
-  ``sys.path`` and this repo bundles no copy of that server.
+- ``script``: run the entry .py as ``__main__`` after temporarily putting
+  the server dir on ``sys.path``.
+- ``module``: put the module root on ``sys.path`` and run its package.
+- ``package``: run a server shipped in its own distribution; no path changes.
+
+All temporary import-path changes are restored when execution returns or
+raises. This matters when PowerMCP is embedded in another Python process;
+standalone CLI execution exits shortly afterwards, but tests and host
+applications may continue importing modules.
 """
 
 from __future__ import annotations
@@ -21,6 +21,8 @@
 import importlib.util
 import runpy
 import sys
+from contextlib import contextmanager
+from collections.abc import Iterator
 
 from .registry import Tool, get_tool, install_hint
 
@@ -29,19 +31,33 @@ class LaunchError(RuntimeError):
     """Raised with an actionable message when a server cannot be launched."""
 
 
-def probe_installed(probe: str | None) -> bool:
-    """True if ``probe`` resolves to a real (importable) module/package.
-
-    Uses find_spec on the FULL dotted name (no module execution). Two cases this
-    must get right:
-    - ``surge`` (top-level): the repo's ``surge/`` folder is a PEP 420 namespace
-      portion (origin None) and must NOT be mistaken for the installed library —
-      so we require a real ``origin``.
-    - ``mhi.pscad`` (subpackage of a namespace): ``mhi`` itself is a namespace
-      package shared by the ``mhi-pscad``/``mhi-psout`` distributions, so probing
-      the top-level ``mhi`` would wrongly look "missing". Probing the full
-      ``mhi.pscad`` resolves the real subpackage (which has an origin).
+@contextmanager
+def _temporary_sys_path(*paths: str) -> Iterator[None]:
+    """Expose paths for one launch and restore the caller's import path.
+
+    Remove only entries introduced by this context, preserving any existing
+    caller entries (including their original order). A finally block guarantees
+    restoration when import or server startup raises.
     """
+    added: list[str] = []
+    try:
+        for path in paths:
+            if path not in sys.path:
+                sys.path.insert(0, path)
+                added.append(path)
+        yield
+    finally:
+        for path in reversed(added):
+            try:
+                sys.path.remove(path)
+            except ValueError:
+                # A server may have removed its own temporary path. Do not
+                # mask the original launch exception while restoring state.
+                pass
+
+
+def probe_installed(probe: str | None) -> bool:
+    """True if ``probe`` resolves to a real (importable) module/package."""
     if not probe:
         return True
     try:
@@ -67,44 +83,30 @@ def _preflight(tool: Tool) -> None:
         raise LaunchError(
             f"{tool.display} requires Windows-only software and cannot run on '{sys.platform}'."
         )
-    # Every server imports the MCP SDK at module scope, so without this the
-    # failure is a raw ImportError traceback rather than an actionable message.
     if not probe_installed("mcp"):
         raise LaunchError(
             "The MCP SDK is not installed; every server needs it.\n"
             "  Install it with:  pip install powermcp"
         )
-    # Only probe pip-provided linchpins. Vendor engines (PSS/E psspy, PSLF) have
-    # probe=None: they live behind a captured path and report their own
-    # actionable error from the server's lazy init.
     if tool.probe and not probe_installed(tool.probe):
         raise LaunchError(
             f"{tool.display}: required package '{tool.probe.split('.')[0]}' is not installed.\n"
-            f"  Install it with:  {install_hint(tool.extra)}"
+            f"  Install it with: {install_hint(tool.extra)}"
         )
 
 
 def _launch_script(tool: Tool) -> None:
     script = tool.resolve_entry_script()
-    # Emulate `python <script>`: only the script's own directory goes on sys.path
-    # (runpy.run_path does not add it). We deliberately do NOT add the parent —
-    # the parent holds dirs named exactly like libraries (pandapower/, surge/),
-    # and each server temporarily exposes the repo root only while importing
-    # shared powermcp modules (OpenDSS also inserts its root for `core`).
     server_dir = str(script.parent)
-    if server_dir not in sys.path:
-        sys.path.insert(0, server_dir)
-    runpy.run_path(str(script), run_name="__main__")
+    with _temporary_sys_path(server_dir):
+        runpy.run_path(str(script), run_name="__main__")
 
 
 def _launch_module(tool: Tool) -> None:
     root = str(tool.resolve_module_root())
-    if root not in sys.path:
-        sys.path.insert(0, root)
-    runpy.run_module(tool.module, run_name="__main__", alter_sys=True)
+    with _temporary_sys_path(root):
+        runpy.run_module(tool.module, run_name="__main__", alter_sys=True)
 
 
 def _launch_package(tool: Tool) -> None:
-    # The server is a dependency, already on sys.path wherever pip put it, so
-    # there is no directory to resolve and nothing of ours to shadow it with.
     runpy.run_module(tool.module, run_name="__main__", alter_sys=True)

From a32dc04f376ab2be351f4681ada68f4560d53285 Mon Sep 17 00:00:00 2001
From: Burhan Abdullah <131237388+BurhanAbdullah@users.noreply.github.com>
Date: Sat, 31 Oct 2026 01:00:59 +0530
Subject: [PATCH 02/12] test(runner): cover import path cleanup across launch
 modes

---
 tests/test_runner.py | 74 ++++++++++++++++++++++++++++++++++++--------
 1 file changed, 61 insertions(+), 13 deletions(-)

diff --git a/tests/test_runner.py b/tests/test_runner.py
index 8ae57b0e..0803c4b1 100644
--- a/tests/test_runner.py
+++ b/tests/test_runner.py
@@ -7,10 +7,12 @@
 from __future__ import annotations
 
 import sys
+from types import SimpleNamespace
 
 import pytest
 
 from powermcp import runner
+from powermcp.registry import Tool
 
 
 @pytest.fixture()
@@ -37,8 +39,6 @@ def test_launch_pypsa_runs_once(record_mcp_run):
 
 
 def test_launch_does_not_shadow_installed_library(record_mcp_run):
-    # After launching, `import pandapower` must still resolve to the installed
-    # library (a real package with pandapowerNet), not the server directory.
     runner.launch("pandapower")
     import pandapower as pp
 
@@ -46,7 +46,6 @@ def test_launch_does_not_shadow_installed_library(record_mcp_run):
 
 
 def test_preflight_missing_pip_dep_raises():
-    # andes is an opt-in extra and is not installed in the test venv.
     with pytest.raises(runner.LaunchError) as exc:
         runner.launch("andes")
     assert "powermcp[andes]" in str(exc.value)
@@ -65,17 +64,14 @@ def test_unknown_tool_raises():
 
 
 def test_probe_installed_handles_namespace_parent(tmp_path, monkeypatch):
-    # Reproduces the mhi.pscad case: `ns` is a PEP 420 namespace (no __init__),
-    # `ns.sub` is a real package. Probing the full dotted name must succeed even
-    # though the top-level parent is a namespace; a bare namespace must not.
     (tmp_path / "ns" / "sub").mkdir(parents=True)
     (tmp_path / "ns" / "sub" / "__init__.py").write_text("")
     monkeypatch.syspath_prepend(str(tmp_path))
     for m in ("ns", "ns.sub"):
         sys.modules.pop(m, None)
     try:
-        assert runner.probe_installed("ns.sub") is True   # real subpackage (like mhi.pscad)
-        assert runner.probe_installed("ns") is False       # bare namespace (like the surge shadow)
+        assert runner.probe_installed("ns.sub") is True
+        assert runner.probe_installed("ns") is False
         assert runner.probe_installed("definitely_absent_pkg_xyz") is False
     finally:
         for m in ("ns", "ns.sub"):
@@ -83,8 +79,6 @@ def test_probe_installed_handles_namespace_parent(tmp_path, monkeypatch):
 
 
 def test_python_dash_m_powermcp_works():
-    # Regression: MCP client configs launch via `python -m powermcp run <tool>`,
-    # which requires powermcp/__main__.py. Exercise that exact entry path.
     import subprocess
 
     r = subprocess.run(
@@ -96,9 +90,6 @@ def test_python_dash_m_powermcp_works():
 
 
 def test_preflight_missing_sdk_raises(monkeypatch):
-    # Every server imports the MCP SDK at module scope, and a server that dies
-    # during import hands its MCP client nothing at all — the traceback goes to
-    # a stderr the client never reads. So the SDK is checked before launch.
     real = runner.probe_installed
     monkeypatch.setattr(
         runner, "probe_installed", lambda p: False if p == "mcp" else real(p)
@@ -120,3 +111,60 @@ def spy(mod, **kwargs):
     runner.launch("powerio")
     assert seen == ["powerio.mcp"]
     assert len(record_mcp_run) == 1
+
+
+def _tool(kind: str, *, server_dir: str = "example", module_root_rel: str | None = None) -> Tool:
+    return Tool(
+        name=f"test-{kind}", display="test", kind="open-source",
+        windows_only=False, extra=None, server_dir=server_dir,
+        run_kind=kind, entry_rel="server.py" if kind == "script" else None,
+        module="example.main" if kind == "module" else ("powerio.mcp" if kind == "package" else None),
+        module_root_rel=module_root_rel,
+    )
+
+
+@pytest.mark.parametrize("kind", ["script", "module", "package"])
+def test_temporary_import_paths_are_restored_after_success(monkeypatch, kind, tmp_path):
+    original = list(sys.path)
+    temp = str(tmp_path)
+    monkeypatch.setattr(runner, "get_tool", lambda _name: _tool(kind))
+    monkeypatch.setattr(runner, "_preflight", lambda _tool: None)
+    monkeypatch.setattr(runner.Tool, "resolve_entry_script", lambda _self: SimpleNamespace(parent=tmp_path))
+    monkeypatch.setattr(runner.Tool, "resolve_module_root", lambda _self: tmp_path)
+    monkeypatch.setattr(runner.runpy, "run_path", lambda *_a, **_k: None)
+    monkeypatch.setattr(runner.runpy, "run_module", lambda *_a, **_k: None)
+
+    runner.launch("ignored")
+    assert sys.path == original
+    if kind == "package":
+        assert temp not in sys.path
+
+
+@pytest.mark.parametrize("kind", ["script", "module"])
+def test_temporary_import_paths_are_restored_when_launch_raises(monkeypatch, kind, tmp_path):
+    original = list(sys.path)
+    monkeypatch.setattr(runner, "get_tool", lambda _name: _tool(kind))
+    monkeypatch.setattr(runner, "_preflight", lambda _tool: None)
+    monkeypatch.setattr(runner.Tool, "resolve_entry_script", lambda _self: SimpleNamespace(parent=tmp_path))
+    monkeypatch.setattr(runner.Tool, "resolve_module_root", lambda _self: tmp_path)
+
+    def fail(*_args, **_kwargs):
+        raise RuntimeError("simulated startup failure")
+
+    monkeypatch.setattr(runner.runpy, "run_path", fail)
+    monkeypatch.setattr(runner.runpy, "run_module", fail)
+    with pytest.raises(RuntimeError, match="simulated startup failure"):
+        runner.launch("ignored")
+    assert sys.path == original
+
+
+def test_temporary_sys_path_preserves_preexisting_entries(tmp_path):
+    entry = str(tmp_path)
+    original = list(sys.path)
+    sys.path.insert(0, entry)
+    try:
+        with runner._temporary_sys_path(entry):
+            assert sys.path.count(entry) == 1
+        assert sys.path == [entry, *original]
+    finally:
+        sys.path[:] = original

From 4ea28a5936236f602f3ab9999bb6d89b23d4d132 Mon Sep 17 00:00:00 2001
From: Burhan Abdullah <131237388+BurhanAbdullah@users.noreply.github.com>
Date: Sat, 31 Oct 2026 01:05:32 +0530
Subject: [PATCH 03/12] fix(runner): restore exact import path after server
 launch

---
 powermcp/runner.py | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/powermcp/runner.py b/powermcp/runner.py
index 39dfc2b3..11f27dae 100644
--- a/powermcp/runner.py
+++ b/powermcp/runner.py
@@ -39,21 +39,17 @@ def _temporary_sys_path(*paths: str) -> Iterator[None]:
     caller entries (including their original order). A finally block guarantees
     restoration when import or server startup raises.
     """
-    added: list[str] = []
+    original = sys.path[:]
     try:
         for path in paths:
             if path not in sys.path:
                 sys.path.insert(0, path)
-                added.append(path)
         yield
     finally:
-        for path in reversed(added):
-            try:
-                sys.path.remove(path)
-            except ValueError:
-                # A server may have removed its own temporary path. Do not
-                # mask the original launch exception while restoring state.
-                pass
+        # sys.path is process-global and servers may reorder, remove, or append
+        # entries while importing. Restore the caller's exact contents in place
+        # so references to the sys.path list remain valid.
+        sys.path[:] = original
 
 
 def probe_installed(probe: str | None) -> bool:

From 1506738af6a3c4cee63f7f19a945dd71a554d293 Mon Sep 17 00:00:00 2001
From: Burhan Abdullah <131237388+BurhanAbdullah@users.noreply.github.com>
Date: Sat, 31 Oct 2026 01:05:35 +0530
Subject: [PATCH 04/12] test(runner): verify exact sys.path restoration after
 mutations

---
 tests/test_runner.py | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/tests/test_runner.py b/tests/test_runner.py
index 0803c4b1..ee5d7438 100644
--- a/tests/test_runner.py
+++ b/tests/test_runner.py
@@ -158,6 +158,26 @@ def fail(*_args, **_kwargs):
     assert sys.path == original
 
 
+@pytest.mark.parametrize(
+    "mutation",
+    [
+        lambda path: sys.path.append("server-added-entry"),
+        lambda path: sys.path.remove(path),
+        lambda path: sys.path.insert(0, "server-reordered-entry"),
+        lambda path: sys.path.append(path),
+    ],
+)
+def test_temporary_sys_path_restores_exact_state_after_server_mutation(tmp_path, mutation):
+    original = sys.path[:]
+    entry = str(tmp_path)
+    try:
+        with runner._temporary_sys_path(entry):
+            mutation(entry)
+        assert sys.path == original
+    finally:
+        sys.path[:] = original
+
+
 def test_temporary_sys_path_preserves_preexisting_entries(tmp_path):
     entry = str(tmp_path)
     original = list(sys.path)

From 62e1b3226be0c078724a88eb377b226caef5bab2 Mon Sep 17 00:00:00 2001
From: Burhan Abdullah <131237388+BurhanAbdullah@users.noreply.github.com>
Date: Sat, 31 Oct 2026 01:05:56 +0530
Subject: [PATCH 05/12] fix(runner): serialize temporary import path changes

---
 powermcp/runner.py | 29 ++++++++++++++++++-----------
 1 file changed, 18 insertions(+), 11 deletions(-)

diff --git a/powermcp/runner.py b/powermcp/runner.py
index 11f27dae..d27cbffd 100644
--- a/powermcp/runner.py
+++ b/powermcp/runner.py
@@ -21,6 +21,7 @@
 import importlib.util
 import runpy
 import sys
+import threading
 from contextlib import contextmanager
 from collections.abc import Iterator
 
@@ -31,6 +32,9 @@ class LaunchError(RuntimeError):
     """Raised with an actionable message when a server cannot be launched."""
 
 
+_SYS_PATH_LOCK = threading.RLock()
+
+
 @contextmanager
 def _temporary_sys_path(*paths: str) -> Iterator[None]:
     """Expose paths for one launch and restore the caller's import path.
@@ -39,17 +43,20 @@ def _temporary_sys_path(*paths: str) -> Iterator[None]:
     caller entries (including their original order). A finally block guarantees
     restoration when import or server startup raises.
     """
-    original = sys.path[:]
-    try:
-        for path in paths:
-            if path not in sys.path:
-                sys.path.insert(0, path)
-        yield
-    finally:
-        # sys.path is process-global and servers may reorder, remove, or append
-        # entries while importing. Restore the caller's exact contents in place
-        # so references to the sys.path list remain valid.
-        sys.path[:] = original
+    # sys.path is process-global. Serialize PowerMCP launches so overlapping
+    # contexts cannot restore snapshots over one another.
+    with _SYS_PATH_LOCK:
+        original = sys.path[:]
+        try:
+            for path in paths:
+                if path not in sys.path:
+                    sys.path.insert(0, path)
+            yield
+        finally:
+            # Servers may reorder, remove, or append entries while importing.
+            # Restore the caller's exact contents in place so references to the
+            # sys.path list remain valid.
+            sys.path[:] = original
 
 
 def probe_installed(probe: str | None) -> bool:

From 6962eac29ccc56d32954b41df93463b6118c3ff4 Mon Sep 17 00:00:00 2001
From: Burhan Abdullah <131237388+BurhanAbdullah@users.noreply.github.com>
Date: Sat, 31 Oct 2026 01:06:10 +0530
Subject: [PATCH 06/12] test(runner): cover concurrent launch path isolation

---
 tests/test_runner.py | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/tests/test_runner.py b/tests/test_runner.py
index ee5d7438..1aaf18b3 100644
--- a/tests/test_runner.py
+++ b/tests/test_runner.py
@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import sys
+import threading
 from types import SimpleNamespace
 
 import pytest
@@ -178,6 +179,46 @@ def test_temporary_sys_path_restores_exact_state_after_server_mutation(tmp_path,
         sys.path[:] = original
 
 
+def test_temporary_sys_path_serializes_overlapping_launches(tmp_path):
+    original = sys.path[:]
+    first_entered = threading.Event()
+    release_first = threading.Event()
+    second_entered = threading.Event()
+    first_path = str(tmp_path / "first")
+    second_path = str(tmp_path / "second")
+
+    def first():
+        with runner._temporary_sys_path(first_path):
+            first_entered.set()
+            assert release_first.wait(timeout=2)
+
+    def second():
+        assert first_entered.wait(timeout=2)
+        with runner._temporary_sys_path(second_path):
+            second_entered.set()
+
+    first_thread = threading.Thread(target=first)
+    second_thread = threading.Thread(target=second)
+    try:
+        first_thread.start()
+        assert first_entered.wait(timeout=2)
+        second_thread.start()
+        assert not second_entered.wait(timeout=0.05)
+        release_first.set()
+        first_thread.join(timeout=2)
+        second_thread.join(timeout=2)
+        assert not first_thread.is_alive()
+        assert not second_thread.is_alive()
+        assert second_entered.is_set()
+        assert sys.path == original
+    finally:
+        release_first.set()
+        first_thread.join(timeout=2)
+        if second_thread.ident is not None:
+            second_thread.join(timeout=2)
+        sys.path[:] = original
+
+
 def test_temporary_sys_path_preserves_preexisting_entries(tmp_path):
     entry = str(tmp_path)
     original = list(sys.path)

From 57f7761a8120e3a7c1bf586ad684dde7418dfc7b Mon Sep 17 00:00:00 2001
From: Burhan Abdullah <131237388+BurhanAbdullah@users.noreply.github.com>
Date: Sat, 31 Oct 2026 01:06:32 +0530
Subject: [PATCH 07/12] docs(runner): clarify exact import path restoration

---
 powermcp/runner.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/powermcp/runner.py b/powermcp/runner.py
index d27cbffd..cce8e52c 100644
--- a/powermcp/runner.py
+++ b/powermcp/runner.py
@@ -39,9 +39,9 @@ class LaunchError(RuntimeError):
 def _temporary_sys_path(*paths: str) -> Iterator[None]:
     """Expose paths for one launch and restore the caller's import path.
 
-    Remove only entries introduced by this context, preserving any existing
-    caller entries (including their original order). A finally block guarantees
-    restoration when import or server startup raises.
+    Restore the exact caller list contents in place, even if server startup
+    reorders or mutates it. A finally block guarantees restoration when import
+    or server startup raises.
     """
     # sys.path is process-global. Serialize PowerMCP launches so overlapping
     # contexts cannot restore snapshots over one another.

From e4218c7f38a79ef928924504fd89aa99207e4422 Mon Sep 17 00:00:00 2001
From: Burhan Abdullah <131237388+BurhanAbdullah@users.noreply.github.com>
Date: Sat, 31 Oct 2026 01:07:05 +0530
Subject: [PATCH 08/12] test(runner): make launch serialization assertion
 deterministic

---
 tests/test_runner.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/test_runner.py b/tests/test_runner.py
index 1aaf18b3..2ba98380 100644
--- a/tests/test_runner.py
+++ b/tests/test_runner.py
@@ -183,6 +183,7 @@ def test_temporary_sys_path_serializes_overlapping_launches(tmp_path):
     original = sys.path[:]
     first_entered = threading.Event()
     release_first = threading.Event()
+    second_started = threading.Event()
     second_entered = threading.Event()
     first_path = str(tmp_path / "first")
     second_path = str(tmp_path / "second")
@@ -194,6 +195,7 @@ def first():
 
     def second():
         assert first_entered.wait(timeout=2)
+        second_started.set()
         with runner._temporary_sys_path(second_path):
             second_entered.set()
 
@@ -203,6 +205,7 @@ def second():
         first_thread.start()
         assert first_entered.wait(timeout=2)
         second_thread.start()
+        assert second_started.wait(timeout=2)
         assert not second_entered.wait(timeout=0.05)
         release_first.set()
         first_thread.join(timeout=2)

From 7b56b30c3e78de5b57f834afc8a6fd83dcebcbc9 Mon Sep 17 00:00:00 2001
From: Burhan Abdullah <131237388+BurhanAbdullah@users.noreply.github.com>
Date: Sat, 31 Oct 2026 01:11:38 +0530
Subject: [PATCH 09/12] fix(pscad): tolerate coarse output filesystem
 timestamps

---
 PSCAD/pscad_mcp/tools/project_tools.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/PSCAD/pscad_mcp/tools/project_tools.py b/PSCAD/pscad_mcp/tools/project_tools.py
index 32924b12..19822061 100644
--- a/PSCAD/pscad_mcp/tools/project_tools.py
+++ b/PSCAD/pscad_mcp/tools/project_tools.py
@@ -74,6 +74,13 @@ async def _snapshot_project_outputs(project: Any) -> Optional[Dict[str, tuple]]:
         return None
 
 
+# Filesystem timestamp clocks can be coarser than time.time_ns() (for example,
+# FAT timestamps have 2-second granularity). The baseline comparison proves
+# the output changed during this run; bounded slack avoids rejecting a fresh
+# output solely because its timestamp was quantized down.
+_OUTPUT_MTIME_SLACK_NS = 2_000_000_000
+
+
 async def _project_output_changed(
     project: Any,
     baseline: Optional[Dict[str, tuple]],
@@ -87,7 +94,7 @@ async def _project_output_changed(
         return False
     return any(
         metadata[1] > 0
-        and metadata[0] >= run_started_ns
+        and metadata[0] >= run_started_ns - _OUTPUT_MTIME_SLACK_NS
         and (path not in baseline or baseline[path] != metadata)
         for path, metadata in current.items()
     )

From a984462501f6103e45f55d10a008ce912ff739ba Mon Sep 17 00:00:00 2001
From: Burhan Abdullah <131237388+BurhanAbdullah@users.noreply.github.com>
Date: Sat, 31 Oct 2026 01:11:47 +0530
Subject: [PATCH 10/12] test(pscad): cover coarse and stale output timestamps

---
 PSCAD/tests/test_tools.py | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/PSCAD/tests/test_tools.py b/PSCAD/tests/test_tools.py
index 8a3028e7..1ffe43f7 100644
--- a/PSCAD/tests/test_tools.py
+++ b/PSCAD/tests/test_tools.py
@@ -4,6 +4,7 @@
 import os
 from pathlib import Path
 import tempfile
+import time
 from pscad_mcp.tools.project_tools import (
     register_project_tools,
     run_project,
@@ -228,6 +229,42 @@ async def test_run_to_completion_accepts_short_run_between_polls(self):
         self.assertEqual(result["errors"], [])
         self.assertIn("output file was created or updated", result["message"])
 
+    async def _run_short_run_with_output_mtime_offset(self, offset_ns):
+        with tempfile.TemporaryDirectory() as output_dir:
+            mock_project = MagicMock()
+            mock_project.temp_folder = output_dir
+            output_file = Path(output_dir) / "short.psout"
+
+            def start():
+                output_file.write_text("fresh output")
+                mtime_ns = time.time_ns() + offset_ns
+                os.utime(output_file, ns=(mtime_ns, mtime_ns))
+
+            mock_project.start.side_effect = start
+            mock_project.run_status.side_effect = [
+                (None, None),  # preflight idle
+                ("Build", None),
+                ("Build", None),
+                (None, None),  # Run completed between status samples
+            ]
+            mock_project.messages.side_effect = [[], []]
+            self.mock_pscad.project.return_value = mock_project
+            ctx = MagicMock()
+            ctx.report_progress = AsyncMock()
+
+            with patch.dict(os.environ, {"POWERIO_MCP_ALLOWED_ROOTS": output_dir}):
+                with patch("pscad_mcp.tools.project_tools.asyncio.sleep", new_callable=AsyncMock):
+                    return await run_project_to_completion("test", ctx)
+
+    async def test_run_to_completion_tolerates_coarse_filesystem_mtime(self):
+        result = await self._run_short_run_with_output_mtime_offset(-1_000_000_000)
+        self.assertEqual(result["status"], "completed")
+        self.assertIn("output file was created or updated", result["message"])
+
+    async def test_run_to_completion_rejects_output_far_older_than_run(self):
+        result = await self._run_short_run_with_output_mtime_offset(-3600 * 1_000_000_000)
+        self.assertEqual(result["status"], "not_completed")
+
     async def test_run_to_completion_does_not_accept_empty_output_as_completion(self):
         with tempfile.TemporaryDirectory() as output_dir:
             mock_project = MagicMock()

From 0e6f6f85b72502c2854b425ed3824783c9d00860 Mon Sep 17 00:00:00 2001
From: Burhan Abdullah <131237388+BurhanAbdullah@users.noreply.github.com>
Date: Sat, 31 Oct 2026 23:59:14 +0530
Subject: [PATCH 11/12] chore: remove duplicate PSCAD mtime fix from PR 144

---
 PSCAD/pscad_mcp/tools/project_tools.py | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/PSCAD/pscad_mcp/tools/project_tools.py b/PSCAD/pscad_mcp/tools/project_tools.py
index 19822061..32924b12 100644
--- a/PSCAD/pscad_mcp/tools/project_tools.py
+++ b/PSCAD/pscad_mcp/tools/project_tools.py
@@ -74,13 +74,6 @@ async def _snapshot_project_outputs(project: Any) -> Optional[Dict[str, tuple]]:
         return None
 
 
-# Filesystem timestamp clocks can be coarser than time.time_ns() (for example,
-# FAT timestamps have 2-second granularity). The baseline comparison proves
-# the output changed during this run; bounded slack avoids rejecting a fresh
-# output solely because its timestamp was quantized down.
-_OUTPUT_MTIME_SLACK_NS = 2_000_000_000
-
-
 async def _project_output_changed(
     project: Any,
     baseline: Optional[Dict[str, tuple]],
@@ -94,7 +87,7 @@ async def _project_output_changed(
         return False
     return any(
         metadata[1] > 0
-        and metadata[0] >= run_started_ns - _OUTPUT_MTIME_SLACK_NS
+        and metadata[0] >= run_started_ns
         and (path not in baseline or baseline[path] != metadata)
         for path, metadata in current.items()
     )

From 45de5ba7f93a1c6e53373f3dc0ad2a69e44caba1 Mon Sep 17 00:00:00 2001
From: Burhan Abdullah <131237388+BurhanAbdullah@users.noreply.github.com>
Date: Sat, 31 Oct 2026 23:59:19 +0530
Subject: [PATCH 12/12] chore: remove duplicate PSCAD mtime fix from PR 144

---
 PSCAD/tests/test_tools.py | 37 -------------------------------------
 1 file changed, 37 deletions(-)

diff --git a/PSCAD/tests/test_tools.py b/PSCAD/tests/test_tools.py
index 1ffe43f7..8a3028e7 100644
--- a/PSCAD/tests/test_tools.py
+++ b/PSCAD/tests/test_tools.py
@@ -4,7 +4,6 @@
 import os
 from pathlib import Path
 import tempfile
-import time
 from pscad_mcp.tools.project_tools import (
     register_project_tools,
     run_project,
@@ -229,42 +228,6 @@ async def test_run_to_completion_accepts_short_run_between_polls(self):
         self.assertEqual(result["errors"], [])
         self.assertIn("output file was created or updated", result["message"])
 
-    async def _run_short_run_with_output_mtime_offset(self, offset_ns):
-        with tempfile.TemporaryDirectory() as output_dir:
-            mock_project = MagicMock()
-            mock_project.temp_folder = output_dir
-            output_file = Path(output_dir) / "short.psout"
-
-            def start():
-                output_file.write_text("fresh output")
-                mtime_ns = time.time_ns() + offset_ns
-                os.utime(output_file, ns=(mtime_ns, mtime_ns))
-
-            mock_project.start.side_effect = start
-            mock_project.run_status.side_effect = [
-                (None, None),  # preflight idle
-                ("Build", None),
-                ("Build", None),
-                (None, None),  # Run completed between status samples
-            ]
-            mock_project.messages.side_effect = [[], []]
-            self.mock_pscad.project.return_value = mock_project
-            ctx = MagicMock()
-            ctx.report_progress = AsyncMock()
-
-            with patch.dict(os.environ, {"POWERIO_MCP_ALLOWED_ROOTS": output_dir}):
-                with patch("pscad_mcp.tools.project_tools.asyncio.sleep", new_callable=AsyncMock):
-                    return await run_project_to_completion("test", ctx)
-
-    async def test_run_to_completion_tolerates_coarse_filesystem_mtime(self):
-        result = await self._run_short_run_with_output_mtime_offset(-1_000_000_000)
-        self.assertEqual(result["status"], "completed")
-        self.assertIn("output file was created or updated", result["message"])
-
-    async def test_run_to_completion_rejects_output_far_older_than_run(self):
-        result = await self._run_short_run_with_output_mtime_offset(-3600 * 1_000_000_000)
-        self.assertEqual(result["status"], "not_completed")
-
     async def test_run_to_completion_does_not_accept_empty_output_as_completion(self):
         with tempfile.TemporaryDirectory() as output_dir:
             mock_project = MagicMock()