execweave 0.8.10__tar.gz → 0.8.11__tar.gz

{execweave-0.8.10 → execweave-0.8.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execweave
-Version: 0.8.10
+Version: 0.8.11
 Summary: Turn AI-agent runtime behavior into a local interactive execution graph.
 Project-URL: Homepage, https://github.com/Irish-kw/ExecWeave
 Project-URL: Repository, https://github.com/Irish-kw/ExecWeave
@@ -85,7 +85,7 @@ ExecWeave is a source-available, local-first observability project that turns AI
   <img src="docs/assets/codex.gif" alt="ExecWeave animated live demo" width="100%">
 </p>
 
-This README documents **v0.8.10**. This release fixes Windows Cursor launch resolution for arbitrary install roots and lets an ExecWeave-managed local `ollama serve` capture later loopback inference clients into the same semantic stream and dashboard.
+This README documents **v0.8.11**. This release makes managed local `ollama serve` capture fail-safe for independent loopback clients, so a later `ollama run`, SDK, or `curl` request from another terminal is recorded in the same semantic stream instead of silently falling back without conversation evidence. It also finalizes merged events, `graph.json`, and `viewer.html` when a Live run is stopped with Ctrl+C.
 
 ## Why ExecWeave
 
@@ -130,7 +130,7 @@ Google Antigravity currently uses the `agy` CLI command; ExecWeave also accepts
 
 For Cursor on Windows, bare `cursor` follows the PATH entry the user actually has and, when it is the normal `.../resources/app/bin/cursor.cmd` shim, derives the matching `Cursor.exe` from that same installation root. This works for custom drives and arbitrary install directories; explicit launcher paths are left untouched. macOS/Windows standard desktop paths remain a fallback when the PATH shim cannot identify the desktop binary.
 
-For a managed local Ollama server, `execweave live --open -- ollama serve` owns the public loopback endpoint and relays the real server through an internal loopback port. A later `ollama run`, Ollama SDK request, OpenAI-compatible client, or `curl` started from another terminal can therefore appear in the same ExecWeave semantic stream even though that client is not a child of the `ollama serve` process. Relay mode is deliberately limited to local `localhost` / `127.0.0.1` binds; external, wildcard, and IPv6 exposure is not rewritten.
+For a managed local Ollama server, `execweave live --open -- ollama serve` owns the public loopback endpoint and relays the real server through an internal loopback port. A later `ollama run`, Ollama SDK request, OpenAI-compatible client, or `curl` started from another terminal can therefore appear in the same ExecWeave semantic stream even though that client is not a child of the `ollama serve` process. ExecWeave prints the active public-to-internal relay mapping; if the public loopback endpoint cannot be safely reserved, the managed run now fails explicitly rather than silently losing conversation capture. Relay mode is deliberately limited to local `localhost` / `127.0.0.1` binds; external, wildcard, and IPv6 exposure is not rewritten. Stopping Live with Ctrl+C still finalizes the run artifacts before returning.
 
 Build finalized run artifacts with:
 

{execweave-0.8.10 → execweave-0.8.11}/README.de.md

@@ -32,7 +32,7 @@ ExecWeave ist ein source-available, local-first Observability-Projekt, das Aktiv
   <img src="docs/assets/codex.gif" alt="ExecWeave animated live demo" width="100%">
 </p>
 
-Dieses README dokumentiert **v0.8.10**.
+Dieses README dokumentiert **v0.8.11**.
 
 ## Warum ExecWeave
 

{execweave-0.8.10 → execweave-0.8.11}/README.fr.md

@@ -32,7 +32,7 @@ ExecWeave est un projet d’observabilité source-available et local-first qui t
   <img src="docs/assets/codex.gif" alt="ExecWeave animated live demo" width="100%">
 </p>
 
-Ce README décrit **v0.8.10**.
+Ce README décrit **v0.8.11**.
 
 ## Pourquoi ExecWeave
 

{execweave-0.8.10 → execweave-0.8.11}/README.ja.md

@@ -32,7 +32,7 @@ ExecWeave は source-available / local-first の observability プロジェク
   <img src="docs/assets/codex.gif" alt="ExecWeave animated live demo" width="100%">
 </p>
 
-この README は **v0.8.10** を説明します。
+この README は **v0.8.11** を説明します。
 
 ## ExecWeave を使う理由
 

{execweave-0.8.10 → execweave-0.8.11}/README.ko.md

@@ -32,7 +32,7 @@ ExecWeave는 source-available, local-first observability 프로젝트입니다.
   <img src="docs/assets/codex.gif" alt="ExecWeave animated live demo" width="100%">
 </p>
 
-이 README는 **v0.8.10**을 설명합니다.
+이 README는 **v0.8.11**을 설명합니다.
 
 ## 왜 ExecWeave인가
 

{execweave-0.8.10 → execweave-0.8.11}/README.md

@@ -32,7 +32,7 @@ ExecWeave is a source-available, local-first observability project that turns AI
   <img src="docs/assets/codex.gif" alt="ExecWeave animated live demo" width="100%">
 </p>
 
-This README documents **v0.8.10**. This release fixes Windows Cursor launch resolution for arbitrary install roots and lets an ExecWeave-managed local `ollama serve` capture later loopback inference clients into the same semantic stream and dashboard.
+This README documents **v0.8.11**. This release makes managed local `ollama serve` capture fail-safe for independent loopback clients, so a later `ollama run`, SDK, or `curl` request from another terminal is recorded in the same semantic stream instead of silently falling back without conversation evidence. It also finalizes merged events, `graph.json`, and `viewer.html` when a Live run is stopped with Ctrl+C.
 
 ## Why ExecWeave
 
@@ -77,7 +77,7 @@ Google Antigravity currently uses the `agy` CLI command; ExecWeave also accepts
 
 For Cursor on Windows, bare `cursor` follows the PATH entry the user actually has and, when it is the normal `.../resources/app/bin/cursor.cmd` shim, derives the matching `Cursor.exe` from that same installation root. This works for custom drives and arbitrary install directories; explicit launcher paths are left untouched. macOS/Windows standard desktop paths remain a fallback when the PATH shim cannot identify the desktop binary.
 
-For a managed local Ollama server, `execweave live --open -- ollama serve` owns the public loopback endpoint and relays the real server through an internal loopback port. A later `ollama run`, Ollama SDK request, OpenAI-compatible client, or `curl` started from another terminal can therefore appear in the same ExecWeave semantic stream even though that client is not a child of the `ollama serve` process. Relay mode is deliberately limited to local `localhost` / `127.0.0.1` binds; external, wildcard, and IPv6 exposure is not rewritten.
+For a managed local Ollama server, `execweave live --open -- ollama serve` owns the public loopback endpoint and relays the real server through an internal loopback port. A later `ollama run`, Ollama SDK request, OpenAI-compatible client, or `curl` started from another terminal can therefore appear in the same ExecWeave semantic stream even though that client is not a child of the `ollama serve` process. ExecWeave prints the active public-to-internal relay mapping; if the public loopback endpoint cannot be safely reserved, the managed run now fails explicitly rather than silently losing conversation capture. Relay mode is deliberately limited to local `localhost` / `127.0.0.1` binds; external, wildcard, and IPv6 exposure is not rewritten. Stopping Live with Ctrl+C still finalizes the run artifacts before returning.
 
 Build finalized run artifacts with:
 

{execweave-0.8.10 → execweave-0.8.11}/README.ru.md

@@ -32,7 +32,7 @@ ExecWeave — source-available, local-first проект наблюдаемос
   <img src="docs/assets/codex.gif" alt="ExecWeave animated live demo" width="100%">
 </p>
 
-Этот README описывает **v0.8.10**.
+Этот README описывает **v0.8.11**.
 
 ## Почему ExecWeave
 

{execweave-0.8.10 → execweave-0.8.11}/README.zh-CN.md

@@ -32,7 +32,7 @@ ExecWeave 是一个 source-available、local-first 的可观测性项目，把 A
   <img src="docs/assets/codex.gif" alt="ExecWeave animated live demo" width="100%">
 </p>
 
-本 README 对应 **v0.8.10**。
+本 README 对应 **v0.8.11**。
 
 ## 为什么是 ExecWeave
 

{execweave-0.8.10 → execweave-0.8.11}/README.zh-TW.md

@@ -32,7 +32,7 @@ ExecWeave 是一個 source-available、local-first 的可觀測性專案，會
   <img src="docs/assets/codex.gif" alt="ExecWeave animated live demo" width="100%">
 </p>
 
-本 README 對應 **v0.8.10**。
+本 README 對應 **v0.8.11**。
 
 ## 為什麼是 ExecWeave
 

{execweave-0.8.10 → execweave-0.8.11}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execweave"
-# ExecWeave v0.8.10 release metadata
-version = "0.8.10"
+# ExecWeave v0.8.11 release metadata
+version = "0.8.11"
 description = "Turn AI-agent runtime behavior into a local interactive execution graph."
 readme = "README.md"
 requires-python = ">=3.10"

{execweave-0.8.10 → execweave-0.8.11}/src/execweave/__init__.py

@@ -1,3 +1,3 @@
 """ExecWeave runtime graph package."""
 
-__version__ = "0.8.10"
+__version__ = "0.8.11"

{execweave-0.8.10 → execweave-0.8.11}/src/execweave/auto_specialized.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 import os
 import socket
+import sys
 import threading
 import time
 from contextlib import contextmanager
@@ -398,18 +399,47 @@ def auto_specialized_launch(
         yield environment
         return
     listen_host, listen_port = listen_address
-    internal_port = _allocate_loopback_port()
-    upstream = f"http://127.0.0.1:{internal_port}"
+    public_endpoint = f"http://{listen_host}:{listen_port}"
     try:
-        server = ExecWeaveHTTPProxyServer(
-            (listen_host, listen_port),
-            ProxyConfig(upstream=upstream, sidecar=sidecar, mode="ollama"),
-            recorder=_record_ollama_inference_exchange,
+        existing = _get_json(
+            f"{public_endpoint}/api/ps",
+            timeout=_PROBE_TIMEOUT_SECONDS,
+        )
+    except _PROBE_ERRORS:
+        existing = None
+    if isinstance(existing, dict) and isinstance(existing.get("models"), list):
+        print(
+            "ExecWeave Ollama relay: existing Ollama server detected at "
+            f"{public_endpoint}; leaving that server unclaimed.",
+            file=sys.stderr,
         )
-    except OSError:
-        # Fail open: preserve the child command's normal bind/error behavior.
         yield environment
         return
+
+    internal_port = _allocate_loopback_port()
+    upstream = f"http://127.0.0.1:{internal_port}"
+    server: ExecWeaveHTTPProxyServer | None = None
+    last_bind_error: OSError | None = None
+    for attempt in range(5):
+        try:
+            server = ExecWeaveHTTPProxyServer(
+                (listen_host, listen_port),
+                ProxyConfig(upstream=upstream, sidecar=sidecar, mode="ollama"),
+                recorder=_record_ollama_inference_exchange,
+            )
+            break
+        except OSError as exc:
+            last_bind_error = exc
+            if attempt < 4:
+                time.sleep(0.05)
+    if server is None:
+        raise RuntimeError(
+            "ExecWeave could not reserve the Ollama endpoint "
+            f"{public_endpoint} for transparent conversation capture. "
+            "Stop any existing Ollama server using that endpoint or set "
+            "OLLAMA_HOST to a free loopback port before starting "
+            "`execweave live -- ollama serve`."
+        ) from last_bind_error
     thread = threading.Thread(
         target=server.serve_forever,
         kwargs={"poll_interval": 0.05},
@@ -418,6 +448,11 @@ def auto_specialized_launch(
     )
     thread.start()
     environment["OLLAMA_HOST"] = upstream
+    print(
+        "ExecWeave Ollama relay: "
+        f"http://{listen_host}:{listen_port} -> {upstream}",
+        file=sys.stderr,
+    )
     try:
         yield environment
     finally:

{execweave-0.8.10 → execweave-0.8.11}/src/execweave/collector.py

@@ -9,6 +9,7 @@ from typing import Iterable
 
 import psutil
 
+from . import __version__
 from .auto_specialized import (
     auto_specialized_launch,
     auto_specialized_probe,
@@ -139,6 +140,7 @@ class RuntimeCollector:
                 "command": command,
                 "cwd": str(self.watch_root),
                 "backend": self.backend_name,
+                "execweave_version": __version__,
             },
         )
         self.sink.emit(
@@ -148,7 +150,11 @@ class RuntimeCollector:
                 relation="STARTED_SESSION",
                 source=agent,
                 target=session,
-                attributes={"collector_pid": os.getpid(), "backend": self.backend_name},
+                attributes={
+                    "collector_pid": os.getpid(),
+                    "backend": self.backend_name,
+                    "execweave_version": __version__,
+                },
             )
         )
 
@@ -166,31 +172,42 @@ class RuntimeCollector:
 
         process: subprocess.Popen[bytes] | None = None
         return_code = 1
+        interrupted = False
         post_command_probe = prepare_post_command_specialized_probe(command)
         try:
-            with auto_specialized_launch(command, server_relay=True) as launch_environment:
-                process = subprocess.Popen(
-                    launch_command,
-                    cwd=str(self.watch_root),
-                    env=launch_environment,
-                )
-                root = psutil.Process(process.pid)
-                snapshot = _safe_process_snapshot(root)
-                if snapshot is not None:
-                    self._record_process_start(snapshot, parent=session, relation="LAUNCHED")
+            try:
+                with auto_specialized_launch(
+                    command,
+                    server_relay=True,
+                ) as launch_environment:
+                    process = subprocess.Popen(
+                        launch_command,
+                        cwd=str(self.watch_root),
+                        env=launch_environment,
+                    )
+                    root = psutil.Process(process.pid)
+                    snapshot = _safe_process_snapshot(root)
+                    if snapshot is not None:
+                        self._record_process_start(snapshot, parent=session, relation="LAUNCHED")
+
+                    with auto_specialized_probe(command):
+                        while process.poll() is None:
+                            self._sample_process_tree(root)
+                            time.sleep(self.poll_interval)
 
-                with auto_specialized_probe(command):
-                    while process.poll() is None:
                         self._sample_process_tree(root)
-                        time.sleep(self.poll_interval)
-
-                    self._sample_process_tree(root)
-                    self._mark_disappeared_processes(set())
-                return_code = int(process.returncode or 0)
-            run_post_command_specialized_probe(
-                post_command_probe,
-                return_code=return_code,
-            )
+                        self._mark_disappeared_processes(set())
+                    return_code = int(process.returncode or 0)
+            except KeyboardInterrupt:
+                interrupted = True
+                return_code = 130
+                if process is not None:
+                    self._terminate_process_tree(process)
+            if not interrupted:
+                run_post_command_specialized_probe(
+                    post_command_probe,
+                    return_code=return_code,
+                )
             return return_code
         finally:
             if watcher is not None:
@@ -205,10 +222,53 @@ class RuntimeCollector:
                         "return_code": return_code,
                         "root_pid": process.pid if process is not None else None,
                         "backend": self.backend_name,
+                        "interrupted": interrupted,
+                        "execweave_version": __version__,
                     },
                 )
             )
 
+    @staticmethod
+    def _terminate_process_tree(process: subprocess.Popen[bytes]) -> None:
+        descendants: list[psutil.Process] = []
+        try:
+            root = psutil.Process(process.pid)
+            descendants = root.children(recursive=True)
+        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+            pass
+
+        for child in reversed(descendants):
+            try:
+                child.terminate()
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                pass
+
+        if process.poll() is None:
+            try:
+                process.terminate()
+            except OSError:
+                pass
+
+        if descendants:
+            _, alive = psutil.wait_procs(descendants, timeout=2.0)
+            for child in alive:
+                try:
+                    child.kill()
+                except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                    pass
+
+        try:
+            process.wait(timeout=2.0)
+        except subprocess.TimeoutExpired:
+            try:
+                process.kill()
+            except OSError:
+                return
+            try:
+                process.wait(timeout=2.0)
+            except subprocess.TimeoutExpired:
+                pass
+
     def _sample_process_tree(self, root: psutil.Process) -> None:
         processes: list[psutil.Process] = []
         try:

{execweave-0.8.10 → execweave-0.8.11}/src/execweave/strace_backend.py

@@ -653,7 +653,10 @@ class StraceRuntimeCollector:
         ]
         return_code = 1
         try:
-            with auto_specialized_launch(command) as launch_environment:
+            with auto_specialized_launch(
+                command,
+                server_relay=True,
+            ) as launch_environment:
                 completed = subprocess.run(
                     strace_command,
                     cwd=str(self.watch_root),

execweave-0.8.11/tests/test_ollama_serve_runtime_integration.py

@@ -0,0 +1,293 @@
+from __future__ import annotations
+
+import json
+import socket
+import sys
+import threading
+import time
+from pathlib import Path
+from urllib.error import URLError
+from urllib.request import Request, urlopen
+
+import psutil
+import pytest
+
+import execweave
+import execweave.collector as collector_module
+from execweave.auto_specialized import auto_specialized_launch
+from execweave.collector import RuntimeCollector
+from execweave.live_core import run_live
+from execweave.sink import JsonlSink
+
+
+def _free_loopback_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(("127.0.0.1", 0))
+        return int(sock.getsockname()[1])
+
+
+def _wait_for_json(url: str, timeout: float = 8.0) -> dict[str, object]:
+    deadline = time.monotonic() + timeout
+    last_error: Exception | None = None
+    while time.monotonic() < deadline:
+        try:
+            with urlopen(url, timeout=0.5) as response:
+                value = json.loads(response.read().decode("utf-8"))
+            if isinstance(value, dict):
+                return value
+        except (URLError, OSError, TimeoutError, json.JSONDecodeError) as exc:
+            last_error = exc
+        time.sleep(0.05)
+    raise AssertionError(f"endpoint did not become ready: {url}: {last_error}")
+
+
+def _wait_for_child_ready(
+    ready_path: Path,
+    *,
+    started_path: Path,
+    thread: threading.Thread,
+    errors: list[BaseException],
+    result: dict[str, object],
+    event_path: Path,
+    timeout: float = 8.0,
+) -> None:
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if ready_path.exists():
+            return
+        if errors or not thread.is_alive():
+            events = event_path.read_text(encoding="utf-8") if event_path.exists() else ""
+            raise AssertionError(
+                "collector stopped before fake Ollama became ready: "
+                f"started={started_path.exists()} errors={errors!r} "
+                f"result={result!r} events={events}"
+            )
+        time.sleep(0.02)
+    events = event_path.read_text(encoding="utf-8") if event_path.exists() else ""
+    raise AssertionError(
+        "fake Ollama did not become ready: "
+        f"started={started_path.exists()} thread_alive={thread.is_alive()} "
+        f"errors={errors!r} result={result!r} events={events}"
+    )
+
+
+def _write_fake_ollama_server(path: Path) -> None:
+    path.write_text(
+        r'''from http.server import BaseHTTPRequestHandler, HTTPServer
+import json
+import os
+from pathlib import Path
+import socket
+from urllib.parse import urlsplit
+
+Path(os.environ["FAKE_OLLAMA_STARTED"]).write_text("started", encoding="utf-8")
+endpoint = urlsplit(os.environ["OLLAMA_HOST"])
+
+# HTTPServer.server_bind() calls socket.getfqdn(). On GitHub's macOS runner
+# that lookup can block for many seconds even for a loopback address, which
+# makes this local fixture race the test timeout. Avoid external hostname
+# resolution: this fixture only needs an HTTP listener on a known loopback IP.
+socket.getfqdn = lambda name="": name or "127.0.0.1"
+
+class Handler(BaseHTTPRequestHandler):
+    def log_message(self, format, *args):
+        return
+
+    def send_json(self, payload, status=200):
+        body = json.dumps(payload).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self):
+        if self.path == "/api/ps":
+            self.send_json({"models": []})
+            return
+        self.send_json({"error": "not found"}, 404)
+
+    def do_POST(self):
+        length = int(self.headers.get("Content-Length", "0"))
+        request = json.loads(self.rfile.read(length).decode("utf-8"))
+        if self.path != "/api/chat":
+            self.send_json({"error": "not found"}, 404)
+            return
+        self.send_json({
+            "model": request.get("model", "tiny"),
+            "message": {"role": "assistant", "content": "collector relay answer"},
+            "done": True,
+        })
+        self.server.done = True
+
+server = HTTPServer((endpoint.hostname, endpoint.port), Handler)
+server.timeout = 0.2
+server.done = False
+Path(os.environ["FAKE_OLLAMA_READY"]).write_text("ready", encoding="utf-8")
+while not server.done:
+    server.handle_request()
+server.server_close()
+''',
+        encoding="utf-8",
+    )
+
+
+def test_runtime_collector_ollama_serve_captures_independent_client(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    public_port = _free_loopback_port()
+    public_endpoint = f"http://127.0.0.1:{public_port}"
+    sidecar = tmp_path / "semantic.jsonl"
+    event_path = tmp_path / "events.jsonl"
+    started_path = tmp_path / "fake-ollama.started"
+    ready_path = tmp_path / "fake-ollama.ready"
+    fake_server = tmp_path / "fake_ollama_server.py"
+    _write_fake_ollama_server(fake_server)
+
+    monkeypatch.setenv("EXECWEAVE_SEMANTIC_SIDECAR", str(sidecar))
+    monkeypatch.setenv("OLLAMA_HOST", public_endpoint)
+    monkeypatch.setenv("FAKE_OLLAMA_STARTED", str(started_path))
+    monkeypatch.setenv("FAKE_OLLAMA_READY", str(ready_path))
+    monkeypatch.setattr(
+        collector_module,
+        "resolve_launch_command",
+        lambda command: [sys.executable, str(fake_server)],
+    )
+
+    collector = RuntimeCollector(
+        session_id="serve-integration",
+        sink=JsonlSink(event_path),
+        watch_root=tmp_path,
+        poll_interval=0.02,
+        collect_filesystem=False,
+        collect_network=False,
+    )
+    result: dict[str, object] = {}
+    errors: list[BaseException] = []
+
+    def run_collector() -> None:
+        try:
+            result["return_code"] = collector.run(["ollama", "serve"])
+        except BaseException as exc:
+            errors.append(exc)
+
+    thread = threading.Thread(target=run_collector, daemon=True)
+    thread.start()
+
+    _wait_for_child_ready(
+        ready_path,
+        started_path=started_path,
+        thread=thread,
+        errors=errors,
+        result=result,
+        event_path=event_path,
+    )
+    assert _wait_for_json(public_endpoint + "/api/ps") == {"models": []}
+
+    request = Request(
+        public_endpoint + "/api/chat",
+        data=json.dumps(
+            {
+                "model": "tiny",
+                "messages": [{"role": "user", "content": "outside process tree"}],
+            }
+        ).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    with urlopen(request, timeout=5) as response:
+        response_payload = json.loads(response.read().decode("utf-8"))
+    assert response_payload["message"]["content"] == "collector relay answer"
+
+    thread.join(timeout=10)
+    assert not thread.is_alive()
+    assert errors == []
+    assert result["return_code"] == 0
+
+    semantic_rows = [
+        json.loads(line)
+        for line in sidecar.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    ]
+    kinds = {
+        (row.get("target", {}).get("attributes") or {}).get("content_kind")
+        for row in semantic_rows
+        if isinstance(row, dict)
+    }
+    assert "model_runtime.ollama.request_messages" in kinds
+    assert "model_runtime.ollama.assistant_messages" in kinds
+    assert any(
+        row.get("attributes", {}).get("transport_relay_observed") is True
+        for row in semantic_rows
+        if isinstance(row, dict)
+    )
+
+    runtime_rows = [
+        json.loads(line)
+        for line in event_path.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    ]
+    started = next(row for row in runtime_rows if row["event_type"] == "session.started")
+    assert started["attributes"]["execweave_version"] == execweave.__version__
+
+
+def test_ollama_serve_relay_bind_failure_is_not_silent(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    # A raw TCP listener is intentionally not an Ollama server: the /api/ps
+    # preflight must not classify arbitrary port occupancy as a server to preserve.
+    holder = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    holder.bind(("127.0.0.1", 0))
+    holder.listen()
+    port = int(holder.getsockname()[1])
+    monkeypatch.setenv("EXECWEAVE_SEMANTIC_SIDECAR", str(tmp_path / "semantic.jsonl"))
+    monkeypatch.setenv("OLLAMA_HOST", f"http://127.0.0.1:{port}")
+    try:
+        with pytest.raises(RuntimeError, match="could not reserve the Ollama endpoint"):
+            with auto_specialized_launch(
+                ["ollama", "serve"],
+                server_relay=True,
+            ):
+                raise AssertionError("relay must not silently fall back")
+    finally:
+        holder.close()
+
+
+def test_ctrl_c_still_materializes_live_artifacts(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    def interrupt_poll(self: RuntimeCollector, root: psutil.Process) -> None:
+        raise KeyboardInterrupt
+
+    monkeypatch.setattr(RuntimeCollector, "_sample_process_tree", interrupt_poll)
+    result = run_live(
+        [sys.executable, "-c", "import time; time.sleep(30)"],
+        watch_root=tmp_path,
+        output_dir=tmp_path / "run",
+        collect_filesystem=False,
+        collect_network=False,
+        open_browser=False,
+        linger_seconds=0,
+    )
+
+    assert result.return_code == 130
+    assert result.graph.exists()
+    assert result.viewer.exists()
+    assert result.materialized_event_stream.exists()
+
+    rows = [
+        json.loads(line)
+        for line in result.event_stream.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    ]
+    finished = next(row for row in rows if row["event_type"] == "session.finished")
+    assert finished["attributes"]["return_code"] == 130
+    assert finished["attributes"]["interrupted"] is True
+    assert finished["attributes"]["execweave_version"] == execweave.__version__
+
+    launched = next(row for row in rows if row["event_type"] == "process.started")
+    pid = int(launched["target"]["attributes"]["pid"])
+    assert not psutil.pid_exists(pid)