execweave 0.8.32__tar.gz → 0.8.33__tar.gz

{execweave-0.8.32 → execweave-0.8.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execweave
-Version: 0.8.32
+Version: 0.8.33
 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

{execweave-0.8.32 → execweave-0.8.33}/pyproject.toml

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

{execweave-0.8.32 → execweave-0.8.33}/src/execweave/__init__.py

@@ -1,3 +1,3 @@
 """ExecWeave runtime graph package."""
 
-__version__ = "0.8.32"
+__version__ = "0.8.33"

{execweave-0.8.32 → execweave-0.8.33}/src/execweave/_dashboard_shell_base.py

@@ -118,6 +118,7 @@ def render_static_dashboard_html(
     static_start = (
         "applyTheme(initialTheme());applyTransform();"
         "setSnapshot(window.__execweaveStaticGraph||{});"
+        "updateEvidence(window.__execweaveStaticGraph||{});"
         "setStatus('FINISHED','finished');"
         "window.__execweaveDashboard?.onFinished?.();"
     )

execweave-0.8.33/src/execweave/acceptance_output.py

@@ -0,0 +1,19 @@
+"""Safe output placement for workloads launched inside an active recording."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def prepare_acceptance_output(path: str | Path) -> Path:
+    output = Path(path).expanduser().resolve()
+    sidecar = os.environ.get("EXECWEAVE_SEMANTIC_SIDECAR")
+    shared = bool(sidecar and Path(sidecar).expanduser().resolve().parent == output
+                  and os.environ.get("EXECWEAVE_SESSION_ID"))
+    if output.exists():
+        if not output.is_dir():
+            raise FileExistsError(f"Acceptance output is not a directory: {output}")
+        if (output / "summary.json").exists() or (any(output.iterdir()) and not shared):
+            raise FileExistsError(f"Acceptance output contains a previous run: {output}")
+    output.mkdir(parents=True, exist_ok=True)
+    return output

{execweave-0.8.32 → execweave-0.8.33}/src/execweave/codex_adapter.py

@@ -9,6 +9,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 from .agent_topology import EVIDENCE_SUBAGENT_LIFECYCLE_HOOK, subagent_topology
+from .hook_input import read_hook_text
 
 _MAX_COMMAND_CHARS = 4096
 _MAX_LABEL_CHARS = 160
@@ -443,7 +444,7 @@ def append_semantic_records(path: str | Path, records: list[dict[str, Any]]) ->
 
 def read_hook_payload(stream: Any = None) -> dict[str, Any]:
     source = stream if stream is not None else sys.stdin
-    raw = source.read()
+    raw = read_hook_text(source)
     if not isinstance(raw, str) or not raw.strip():
         raise ValueError("Codex hook stdin is empty")
     try:

{execweave-0.8.32 → execweave-0.8.33}/src/execweave/codex_hook_cli.py

@@ -246,23 +246,32 @@ def main(argv: list[str] | None = None) -> int:
             failures=failures,
         )
 
-    try:
-        content_records = codex_hook_to_content_events(
-            payload,
-            store=content_store,
-            timestamp=observed_at,
-            include_metadata=False,
-        )
-    except _CAPTURE_ERRORS as exc:
-        failures.append("content_capture")
-        _capture_warning("content_capture", exc)
-    else:
-        _append_stage(
-            sidecar,
-            content_records,
-            stage="content_append",
-            failures=failures,
-        )
+    # Content fields are independent evidence. A malformed input string must not
+    # prevent a valid tool result (or transcript archive) from being stored.
+    content_fields = {"prompt", "tool_input", "tool_response", "last_assistant_message"}
+    for field in sorted(content_fields & payload.keys()):
+        isolated = {key: value for key, value in payload.items()
+                    if key not in content_fields or key == field}
+        try:
+            content_records = codex_hook_to_content_events(
+                isolated, store=content_store, timestamp=observed_at, include_metadata=False,
+            )
+        except _CAPTURE_ERRORS as exc:
+            failures.append("content_capture")
+            _capture_warning("content_capture:" + field, exc)
+            diagnostic = {
+                "timestamp": observed_at, "event_type": "semantic.codex.content.capture_failed",
+                "relation": "CONTENT_CAPTURE_FAILED",
+                "source": {"id": "agent:OpenAI Codex", "type": "agent", "name": "OpenAI Codex"},
+                "target": None,
+                "attributes": {"provider": "codex", "observed_field": field,
+                               "error_type": type(exc).__name__, "tool_use_id": payload.get("tool_use_id"),
+                               "codex_hook_event_name": payload.get("hook_event_name"),
+                               "causal": False, "inferred": False},
+            }
+            _append_stage(sidecar, [diagnostic], stage="content_diagnostic_append", failures=failures)
+        else:
+            _append_stage(sidecar, content_records, stage="content_append", failures=failures)
 
     try:
         archive_records = codex_conversation_archive_events(

{execweave-0.8.32 → execweave-0.8.33}/src/execweave/codex_hook_entry.py

@@ -142,7 +142,9 @@ def _append_interrupt_fast(sidecar: Path, payload: dict[str, Any]) -> None:
 
 def _active_auto_payload() -> tuple[str, dict[str, Any] | None]:
     try:
-        raw = sys.stdin.read()
+        from .hook_input import read_hook_text
+
+        raw = read_hook_text(sys.stdin)
     except (OSError, ValueError):
         # The passive entry boundary must remain fail-open even when stdin itself is
         # unavailable. The normal capture path will receive an empty stream and its

{execweave-0.8.32 → execweave-0.8.33}/src/execweave/collector.py

@@ -210,6 +210,9 @@ class RuntimeCollector:
                     "collector_pid": os.getpid(),
                     "backend": self.backend_name,
                     "execweave_version": __version__,
+                    "python_executable": sys.executable,
+                    "python_version": sys.version.split()[0],
+                    "package_path": str(Path(__file__).resolve().parent),
                 },
             )
         )

{execweave-0.8.32 → execweave-0.8.33}/src/execweave/conversation_records.py

@@ -230,7 +230,7 @@ def _merge_conversation_previews(entries: list[dict[str, Any]]) -> None:
             continue
         for message in preview.get("messages") or []:
             if isinstance(message, dict):
-                message["content_role"] = role
+                message.setdefault("content_role", role)
 
     snapshots: list[tuple[dict[str, Any], dict[str, Any]]] = []
     for entry in entries:
@@ -326,6 +326,9 @@ def conversation_record_entries(
         preview["provider_native_id"] = root_id
         original_source_id = entry.get("source_id")
         if isinstance(original_source_id, str) and original_source_id != root_id:
+            for message in preview.get("messages") or []:
+                if isinstance(message, dict):
+                    message["occurrence_id"] = original_source_id
             entry["evidence_source_id"] = original_source_id
             entry["evidence_source_type"] = entry.get("source_type")
         entry["source_id"] = root_id

{execweave-0.8.32 → execweave-0.8.33}/src/execweave/conversation_records_common.py

@@ -5,6 +5,7 @@ from typing import Any
 
 def history_message_key(message: dict[str, Any]) -> tuple[object, ...]:
     return (
+        message.get("occurrence_id"),
         message.get("ordinal"),
         message.get("kind"),
         message.get("sender"),

{execweave-0.8.32 → execweave-0.8.33}/src/execweave/dashboard_shell.py

@@ -117,13 +117,10 @@ def _defer_camera_takeover_until_node_drag(html: str) -> str:
 
 
 def _preserve_readable_initial_camera(html: str) -> str:
-    """Keep first paint readable without changing the explicit whole-graph Fit action.
+    """Use the same whole-graph Fit semantics for initial and explicit fitting.
 
-    The initial snapshot historically called the same whole-graph ``fit`` routine as
-    the user-facing Fit button. Dense graphs can therefore arrive below readable
-    screen-space size even though the camera is otherwise in manual mode. Give only
-    the automatic first fit a 0.5 scale floor; an explicit Fit still defaults to the
-    established 0.07 floor so the full graph remains available as an overview.
+    Readability is addressed by evidence-preserving display clusters, not by
+    silently clipping nodes while the toolbar claims the entire graph fits.
     """
     signature = "function fit(animate=true){"
     if html.count(signature) != 1:
@@ -148,7 +145,7 @@ def _preserve_readable_initial_camera(html: str) -> str:
         raise RuntimeError("initial camera fit seams changed")
     return html.replace(
         initial_fit,
-        "if(!hasFitted&&positions.size){fit(false,.5);hasFitted=true}",
+        "if(!hasFitted&&positions.size){fit(false,.48);hasFitted=true}",
     )
 
 
@@ -199,7 +196,8 @@ function execweaveFileClusterHistory(a){
     add('Model',node?.name);
     add('Provider',a.provider||a.provider_name);
     add('Inference calls',a.viewer_inference_count);
-    add('Inference history',execweaveInferenceHistory(a));
+    if(a.model_resource_id)add('Shared model resource',a.model_resource_id);
+    // Chronology is rendered below as persistent per-invocation accordions.
   }else if(kind==='tool_call'){"""
     if html.count(branch_seam) != 1:
         raise RuntimeError("agent panel file/model branch seam changed")
@@ -224,7 +222,7 @@ def _stop_conversation_polling_after_finish(html: str) -> str:
         ),
         (
             "async function refresh(){if(window.__execweaveStaticMode||refreshing)return;refreshing=true;try{const headers={};if(window.__execweaveToken)headers['X-ExecWeave-Token']=window.__execweaveToken;const response=await fetch('/conversations.json',{cache:'no-store',headers});if(response.ok){const payload=await response.json();setEntries(payload?.entries)}}catch(_){}finally{refreshing=false}}",
-            "async function refresh({allowDuringFinish=false}={}){if(window.__execweaveStaticMode||conversationPollingFinished||(conversationFinishing&&!allowDuringFinish))return false;if(refreshing)return conversationRefreshPromise;refreshing=true;const controller=new AbortController();conversationRefreshController=controller;const task=(async()=>{try{const headers={};if(window.__execweaveToken)headers['X-ExecWeave-Token']=window.__execweaveToken;const response=await fetch('/conversations.json',{cache:'no-store',headers,signal:controller.signal});if(!response.ok)return false;const payload=await response.json();setEntries(payload?.entries);return true}catch(_){return false}finally{if(conversationRefreshController===controller)conversationRefreshController=null;refreshing=false}})();conversationRefreshPromise=task;return await task}",
+            "async function refresh({allowDuringFinish=false}={}){if(window.__execweaveStaticMode||(conversationPollingFinished&&!allowDuringFinish)||(conversationFinishing&&!allowDuringFinish))return false;if(refreshing)return conversationRefreshPromise;refreshing=true;const controller=new AbortController();conversationRefreshController=controller;const timeout=setTimeout(()=>controller.abort(),5000);const task=(async()=>{try{const headers={};if(window.__execweaveToken)headers['X-ExecWeave-Token']=window.__execweaveToken;const response=await fetch('/conversations.json',{cache:'no-store',headers,signal:controller.signal});if(!response.ok)return false;const payload=await response.json();if(!Array.isArray(payload?.entries))return false;setEntries(payload.entries);return true}catch(_){return false}finally{clearTimeout(timeout);if(conversationRefreshController===controller)conversationRefreshController=null;refreshing=false}})();conversationRefreshPromise=task;return await task}",
             "agent conversation refresh seam changed",
         ),
         (
@@ -234,7 +232,7 @@ def _stop_conversation_polling_after_finish(html: str) -> str:
         ),
         (
             "const previous=window.__execweaveDashboard||{};window.__execweaveDashboard={...previous,onPayload(data){previous.onPayload?.(data);if(selectedNode)refresh()},onFinished(){previous.onFinished?.();if(selectedNode)refresh()}};",
-            "async function finishConversationPolling(){if(conversationPollingFinished)return conversationFinishSynchronized;if(conversationFinishing)return conversationFinishPromise;conversationFinishing=true;if(conversationRefreshTimer!==null){clearInterval(conversationRefreshTimer);conversationRefreshTimer=null}conversationFinishPromise=(async()=>{await conversationRefreshPromise;if(!selectedNode||window.__execweaveStaticMode)return true;return await refresh({allowDuringFinish:true})})().then(synchronized=>{conversationFinishSynchronized=Boolean(synchronized);return conversationFinishSynchronized}).finally(()=>{conversationPollingFinished=true;conversationFinishing=false;if(conversationRefreshController!==null){conversationRefreshController.abort();conversationRefreshController=null}});return await conversationFinishPromise}\nconst stopConversationPolling=finishConversationPolling;\nconst previous=window.__execweaveDashboard||{};window.__execweaveDashboard={...previous,onPayload(data){previous.onPayload?.(data);if(selectedNode&&!data?.live_finished&&!conversationFinishing&&!conversationPollingFinished)refresh()},onFinished(){previous.onFinished?.();void finishConversationPolling()}};",
+            "function reportFinalConversationSync(ok){let notice=document.getElementById('conversation-sync-status');if(ok){notice?.remove();return}if(notice)return;notice=document.createElement('div');notice.id='conversation-sync-status';notice.setAttribute('role','status');notice.style.cssText='position:fixed;right:18px;bottom:18px;z-index:100;max-width:360px;padding:12px;background:#2b2118;color:#fff;border:1px solid #e5ad63;border-radius:8px';notice.append(document.createTextNode('Conversation history may be incomplete. Final synchronization failed. '));const retry=document.createElement('button');retry.type='button';retry.textContent='Retry sync';retry.onclick=async()=>{retry.disabled=true;try{await finishConversationPolling()}finally{retry.disabled=false}};notice.append(retry);document.body.append(notice)}\nasync function finishConversationPolling(){if(conversationPollingFinished&&conversationFinishSynchronized)return true;if(conversationFinishing)return conversationFinishPromise;conversationFinishing=true;if(conversationRefreshTimer!==null){clearInterval(conversationRefreshTimer);conversationRefreshTimer=null}conversationFinishPromise=(async()=>{await conversationRefreshPromise;if(window.__execweaveStaticMode)return true;return await refresh({allowDuringFinish:true})})().then(synchronized=>{conversationFinishSynchronized=Boolean(synchronized);reportFinalConversationSync(conversationFinishSynchronized);return conversationFinishSynchronized}).finally(()=>{conversationPollingFinished=true;conversationFinishing=false;if(conversationRefreshController!==null){conversationRefreshController.abort();conversationRefreshController=null}});return await conversationFinishPromise}\nconst stopConversationPolling=finishConversationPolling;\nconst previous=window.__execweaveDashboard||{};window.__execweaveDashboard={...previous,onPayload(data){previous.onPayload?.(data);if(selectedNode&&!data?.live_finished&&!conversationFinishing&&!conversationPollingFinished)refresh()},onFinished(){previous.onFinished?.();void finishConversationPolling()}};",
             "agent conversation lifecycle seam changed",
         ),
         (

execweave-0.8.33/src/execweave/finalization.py

@@ -0,0 +1,44 @@
+"""Durable export status: session.finished is not proof that files were exported."""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import tempfile
+from pathlib import Path
+from typing import Any
+
+
+REQUIRED_EXPORTS = ("graph.json", "viewer.html", "conversations.json")
+
+
+def record_finalization(
+    run_dir: Path, *, state: str, error: BaseException | None = None,
+) -> dict[str, Any]:
+    files: dict[str, Any] = {}
+    for name in REQUIRED_EXPORTS:
+        path = run_dir / name
+        if path.is_file():
+            digest = hashlib.sha256()
+            with path.open("rb") as handle:
+                for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+                    digest.update(chunk)
+            files[name] = {"size_bytes": path.stat().st_size, "sha256": digest.hexdigest()}
+    missing = [name for name in REQUIRED_EXPORTS if not files.get(name, {}).get("size_bytes")]
+    payload = {"schema_version": "0.1", "state": state, "artifacts": files,
+               "missing": missing, "error_type": type(error).__name__ if error else None}
+    if state == "complete" and missing:
+        payload["state"] = "incomplete"
+    fd, temporary = tempfile.mkstemp(prefix=".finalization-", dir=run_dir)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as handle:
+            json.dump(payload, handle, indent=2, sort_keys=True)
+            handle.write("\n")
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary, run_dir / "finalization.json")
+    finally:
+        Path(temporary).unlink(missing_ok=True)
+    if state == "complete" and missing and error is None:
+        raise RuntimeError("Final export is incomplete: " + ", ".join(missing))
+    return payload

{execweave-0.8.32 → execweave-0.8.33}/src/execweave/graph.py

@@ -7,6 +7,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
+from .session_summary import SessionSummary
 from .fidelity import FidelityAccumulator
 from .provider_lifecycle import ProviderLifecycleAnnotation, provider_lifecycle_annotation
 from .validate import validate_event_stream
@@ -346,6 +347,10 @@ class ExecutionGraph:
         default_factory=lambda: datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
     )
 
+    evidence_counts: dict[str, int] = field(default_factory=dict)
+    session_outcome: dict[str, Any] = field(default_factory=dict)
+    runtime_environment: dict[str, Any] = field(default_factory=dict)
+
     def to_dict(self) -> dict[str, Any]:
         return {
             "graph_schema_version": GRAPH_SCHEMA_VERSION,
@@ -357,6 +362,9 @@ class ExecutionGraph:
             "edge_count": len(self.edges),
             "built_at": self.built_at,
             "fidelity": self.fidelity,
+            "evidence_counts": dict(self.evidence_counts),
+            "session_outcome": dict(self.session_outcome),
+            "runtime_environment": dict(self.runtime_environment),
             "nodes": [node.to_dict() for node in self.nodes],
             "edges": [edge.to_dict() for edge in self.edges],
         }
@@ -391,6 +399,7 @@ class GraphAccumulator:
         self.nodes: dict[str, GraphNode] = {}
         self.edges: dict[tuple[str, str, str], GraphEdge] = {}
         self._fidelity = FidelityAccumulator()
+        self._session_summary = SessionSummary()
         self._seen_logical_events: set[str] = set()
 
     @property
@@ -415,6 +424,7 @@ class GraphAccumulator:
             self.source_schema_versions.add(schema_version)
         self.event_count += 1
         self._fidelity.observe(event)
+        self._session_summary.observe(event)
         logical_key = logical_event_key(event)
         logical = logical_key not in self._seen_logical_events
         if logical_key is not None:
@@ -473,6 +483,9 @@ class GraphAccumulator:
                 self.edges.values(), key=lambda edge: (edge.source, edge.relation, edge.target)
             ),
             fidelity=self._fidelity.to_dict(),
+            evidence_counts=dict(self._session_summary.counts),
+            session_outcome=dict(self._session_summary.outcome),
+            runtime_environment=dict(self._session_summary.environment),
         )
 
     def to_dict(self) -> dict[str, Any]:

execweave-0.8.33/src/execweave/hook_input.py

@@ -0,0 +1,16 @@
+"""Read JSON hook transport as UTF-8, independently of the terminal code page."""
+from __future__ import annotations
+
+from typing import Any
+
+
+def read_hook_text(source: Any) -> str:
+    binary = getattr(source, "buffer", None)
+    raw = binary.read() if binary is not None else source.read()
+    if isinstance(raw, bytes):
+        # Strict decoding avoids silently replacing evidence. Invalid input is
+        # reported by the existing fail-open hook boundary, not mis-recorded.
+        return raw.decode("utf-8-sig")
+    if not isinstance(raw, str):
+        raise ValueError("hook stdin must supply UTF-8 bytes or text")
+    return raw.lstrip("\ufeff")

{execweave-0.8.32 → execweave-0.8.33}/src/execweave/live_core.py

@@ -19,6 +19,8 @@ from urllib.parse import parse_qs, urlencode, urlsplit
 from uuid import uuid4
 
 from .backends import create_collector
+from .conversation_records import write_conversation_records
+from .finalization import record_finalization
 from .graph import GRAPH_SCHEMA_VERSION, GraphAccumulator, build_execution_graph, write_execution_graph
 from .live_view import LIVE_HTML as _LIVE_HTML
 from .semantic import LiveSemanticNormalizer, merge_semantic_sidecar
@@ -152,6 +154,9 @@ def _compact_live_graph(graph: dict[str, object]) -> dict[str, object]:
         "nodes": [],
         "edges": [],
         "live_payload_compact": True,
+        "evidence_counts": graph.get("evidence_counts"),
+        "session_outcome": graph.get("session_outcome"),
+        "runtime_environment": graph.get("runtime_environment"),
     }
 
 
@@ -710,6 +715,7 @@ def run_live(
         if artifact.exists() and artifact.stat().st_size > 0:
             raise FileExistsError(f"ExecWeave live artifact already exists: {artifact}")
 
+    record_finalization(run_dir, state="recording")
     sink = JsonlSink(event_path)
     collector = create_collector(
         backend="portable",
@@ -748,9 +754,15 @@ def run_live(
         key: os.environ.get(key) for key in environment_updates
     }
     os.environ.update(environment_updates)
+    collection_error: Exception | None = None
+    export_complete = False
     try:
         try:
             return_code = collector.run(command)
+        except Exception as exc:
+            # The collector can have written a valid terminal stream before
+            # raising. Export it rather than leaving only raw evidence behind.
+            collection_error = exc
         finally:
             for key, value in previous_environment.items():
                 if value is None:
@@ -758,6 +770,7 @@ def run_live(
                 else:
                     os.environ[key] = value
 
+        record_finalization(run_dir, state="exporting", error=collection_error)
         validation = validate_event_stream(event_path)
         if not validation.valid:
             details = "; ".join(validation.errors)
@@ -771,11 +784,20 @@ def run_live(
         execution_graph = build_execution_graph(materialized_event_path)
         graph_payload = execution_graph.to_dict()
         write_execution_graph(execution_graph, graph_path)
+        # The extracted core must materialize the conversation index itself. The
+        # projected live wrapper also writes it, but direct live_core callers (and
+        # failure-path export) must not depend on that presentation monkeypatch.
+        write_conversation_records(graph_payload, run_dir)
         write_graph_html(graph_payload, viewer_path, open_browser=False)
+        record_finalization(run_dir, state="complete", error=collection_error)
+        export_complete = True
         state.finish(graph_payload, final_html=viewer_path.read_text(encoding="utf-8"))
         if linger_seconds:
             time.sleep(linger_seconds)
 
+        if collection_error is not None:
+            raise collection_error
+
         return LiveResult(
             session_id=session_id,
             return_code=return_code,
@@ -787,6 +809,35 @@ def run_live(
             graph=graph_path,
             viewer=viewer_path,
         )
+    except Exception as exc:
+        # Export/finalization diagnostics are secondary to an already observed
+        # collector failure. Preserve the primary exception and attach later
+        # failures as notes rather than replacing the root cause.
+        primary_error = collection_error if collection_error is not None else exc
+        if collection_error is not None and exc is not collection_error:
+            try:
+                collection_error.add_note(
+                    f"secondary export failure: {type(exc).__name__}: {exc}"
+                )
+            except AttributeError:  # pragma: no cover - Python < 3.11 compatibility
+                pass
+        try:
+            record_finalization(
+                run_dir,
+                state="complete" if export_complete else "failed",
+                error=primary_error,
+            )
+        except Exception as finalization_error:
+            try:
+                primary_error.add_note(
+                    "secondary finalization diagnostic failure: "
+                    f"{type(finalization_error).__name__}: {finalization_error}"
+                )
+            except AttributeError:  # pragma: no cover - Python < 3.11 compatibility
+                pass
+        if primary_error is not exc:
+            raise primary_error from exc
+        raise
     finally:
         server.shutdown()
         server.server_close()

{execweave-0.8.32 → execweave-0.8.33}/src/execweave/live_view_script_a.py

@@ -15,7 +15,19 @@ function nodeCategory(node){const value=String(node?.type||'').toLowerCase();if(
 function graphCounts(data){const nodes=Number(data.node_count)||((data.nodes||[]).length),edges=Number(data.edge_count)||((data.edges||[]).length);return{nodes,edges,estimated:nodes*4+edges*3}}
 function withinRenderBudget(data){const counts=graphCounts(data);return counts.nodes<=ACTIVE_MAX_NODES&&counts.edges<=ACTIVE_MAX_EDGES&&counts.estimated<=ACTIVE_MAX_DOM_ELEMENTS}
 function updateStats(data){stats.innerHTML=`<strong>${Number(data.node_count)||0}</strong> nodes · <strong>${Number(data.edge_count)||0}</strong> edges · <strong>${Number(data.event_count)||0}</strong> events`}
-function updateEvidence(data){const counts=data.live_evidence_counts||{},runtime=Number(counts.os_runtime)||0,specialized=Number(counts.specialized)||0,provisional=!!data.live_specialized_provisional;evidence.innerHTML=`OS <strong>${runtime}</strong> · specialized <strong>${specialized}</strong>${provisional?' · provisional':''}`;evidence.classList.toggle('provisional',provisional);evidence.title=provisional?'Specialized evidence is provisional until the canonical final merge.':'Observed evidence counts for this live session.'}
+function updateEvidence(data){
+  const raw=window.__execweaveCore?.getGraph?.()||window.__execweaveStaticGraph||{},counts=data.live_evidence_counts||data.evidence_counts||raw.evidence_counts||{};
+  const count=value=>typeof value==='number'&&Number.isInteger(value)&&value>=0?String(value):'—';
+  const provisional=!!data.live_specialized_provisional,specialized=count(counts.specialized);
+  const specializedMarkup=`specialized ${specialized}`.replace(specialized,`<strong>${specialized}</strong>`);
+  evidence.innerHTML=`OS <strong>${count(counts.os_runtime)}</strong> · ${specializedMarkup}${provisional?' · provisional':''}`;
+  evidence.classList.toggle('provisional',provisional);evidence.title='Observed event counts. — means unavailable, not zero.';
+  const outcome=data.session_outcome||raw.session_outcome||{},labels={succeeded:'SUCCEEDED',failed:'FAILED',interrupted:'INTERRUPTED',collector_failed:'COLLECTOR FAILED',unknown:'UNKNOWN'};
+  let badge=document.getElementById('workload-outcome');if(!badge){badge=document.createElement('span');badge.id='workload-outcome';evidence.after(badge)}
+  const finished=outcome.recorder_finished||data.live_finished||window.__execweaveStaticMode;
+  badge.textContent=finished?` · Workload: ${labels[outcome.state]||'UNKNOWN'}${Number.isInteger(outcome.return_code)?' · exit '+outcome.return_code:''}`:'';
+  badge.dataset.state=outcome.state||'unknown';badge.title='Workload result is separate from recorder FINISHED status.';
+}
 function setStatus(label,kind=''){statusLabel.textContent=label;status.className=kind}
 function enterProtectiveMode(data){const counts=graphCounts(data);edgeLayer.replaceChildren();labelLayer.replaceChildren();nodeLayer.replaceChildren();positions=new Map();nodeElements=new Map();edgeElements=new Map();svg.style.display='none';protective.hidden=false;protectiveSummary.textContent=`${counts.nodes} nodes · ${counts.edges} edges · about ${counts.estimated} SVG elements exceeds the live safety budget.`;setStatus('PROTECTED','reconnecting');protectedMode=true}
 function leaveProtectiveMode(){protective.hidden=true;svg.style.display='block';protectedMode=false}

execweave-0.8.33/src/execweave/session_summary.py

@@ -0,0 +1,48 @@
+"""Portable evidence counts and workload outcome derived from observed events.
+
+Recorder completion is deliberately separate from workload success. Missing
+terminal evidence is unknown, never a synthesized successful exit.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+
+class SessionSummary:
+    def __init__(self) -> None:
+        self.counts = {"os_runtime": 0, "specialized": 0}
+        self.outcome: dict[str, Any] = {"state": "unknown", "return_code": None}
+        self.environment: dict[str, Any] = {}
+
+    def observe(self, event: dict[str, Any]) -> None:
+        attributes = event.get("attributes")
+        attributes = attributes if isinstance(attributes, dict) else {}
+        kind = str(event.get("event_type") or "")
+        backend = attributes.get("backend")
+        semantic = (kind.startswith("semantic.")
+                    or (isinstance(backend, str) and backend in {"semantic", "model_runtime"})
+                    or attributes.get("attribution") == "semantic_sidecar")
+        self.counts["specialized" if semantic else "os_runtime"] += 1
+        if kind == "session.started":
+            for key in ("execweave_version", "python_executable", "python_version", "package_path", "backend"):
+                value = attributes.get(key)
+                if isinstance(value, str):
+                    self.environment[key] = value
+        if kind != "session.finished":
+            return
+        code = attributes.get("return_code")
+        if not isinstance(code, int) or isinstance(code, bool):
+            code = None
+        interrupted = attributes.get("interrupted") is True
+        collector_failed = attributes.get("collector_failed") is True
+        state = (
+            "collector_failed" if collector_failed else
+            "interrupted" if interrupted else
+            "succeeded" if code == 0 else
+            "failed" if code is not None else "unknown"
+        )
+        self.outcome = {
+            "state": state, "return_code": code, "interrupted": interrupted,
+            "collector_failed": collector_failed, "event_id": event.get("event_id"),
+            "timestamp": event.get("timestamp"), "recorder_finished": True,
+        }