execweave 0.8.33__tar.gz → 0.8.34__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execweave
-Version: 0.8.33
+Version: 0.8.34
 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
@@ -42,6 +42,7 @@ Requires-Python: >=3.10
 Requires-Dist: psutil>=5.9
 Requires-Dist: watchdog>=4.0
 Provides-Extra: dev
+Requires-Dist: cryptography>=44; extra == 'dev'
 Requires-Dist: pillow>=10.0; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'
 Requires-Dist: pywinpty<4,>=3.0.5; (platform_system == 'Windows') and extra == 'dev'
@@ -56,6 +57,8 @@ Provides-Extra: release
 Requires-Dist: build>=1.2; extra == 'release'
 Requires-Dist: tomli>=2.0; (python_version < '3.11') and extra == 'release'
 Requires-Dist: twine>=6.0; extra == 'release'
+Provides-Extra: validation
+Requires-Dist: cryptography>=44; extra == 'validation'
 Description-Content-Type: text/markdown
 
 # ExecWeave

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

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execweave"
-# ExecWeave v0.8.33 release metadata
-version = "0.8.33"
+# ExecWeave v0.8.34 release metadata
+version = "0.8.34"
 description = "Turn AI-agent runtime behavior into a local interactive execution graph."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -42,7 +42,9 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+validation = ["cryptography>=44"]
 dev = [
+  "cryptography>=44",
   "pytest>=8.0",
   "PyYAML>=6.0",
   "pillow>=10.0",

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

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

{execweave-0.8.33 → execweave-0.8.34}/src/execweave/_conversation_records_core.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import json
 import re
+from collections import Counter
 from pathlib import Path
 from typing import Any
 from .content_store import _filesystem_path
@@ -491,6 +492,7 @@ def conversation_record_entries(
         for node in nodes
         if isinstance(node.get("id"), str) and node.get("id")
     }
+    source_counts = Counter(node.get("id") for node in nodes if isinstance(node.get("id"), str))
     entries: list[dict[str, Any]] = []
     for edge in edges:
         target_id = edge.get("target")
@@ -542,6 +544,36 @@ def conversation_record_entries(
         derived = preview.pop("derived_agent_previews", None) if isinstance(preview, dict) else None
         if preview is not None:
             entry["conversation_preview"] = preview
+        # Keep each framework model response attached to its own content reference.
+        # Conversation merging publishes only one aggregate preview and can otherwise
+        # leave the actual model bodies behind a later control/status message.
+        source_attrs = source.get("attributes") if isinstance(source, dict) else None
+        if (
+            isinstance(source_attrs, dict)
+            and source.get("type") == "agent"
+            and source_counts[source_id] == 1
+            and source_attrs.get("conversation_scope") == "framework_agent"
+            and reference["content_kind"] in {
+                "metagpt.model_response", "autogen.model_response", "camel.model_response"
+            }
+            and edge.get("relation") == "HAS_MODEL_CONTENT"
+            and all(
+                record.get(flag) is None or record.get(flag) is False
+                for record in (edge, edge.get("attributes") if isinstance(edge.get("attributes"), dict) else {})
+                for flag in ("inferred", "viewer_only")
+            )
+            and isinstance(preview, dict)
+        ):
+            agent_path = preview.get("agent_path")
+            entry["model_response_preview"] = {
+                "schema_version": "1",
+                "source_id": source_id,
+                "agent_path": agent_path,
+                "messages": [dict(message) for message in preview.get("messages", [])
+                             if isinstance(message, dict) and agent_path
+                             and message.get("sender") == agent_path],
+                "messages_truncated": bool(preview.get("messages_truncated")),
+            }
         entries.append(entry)
         if isinstance(derived, list):
             entries.extend(_derived_agent_entries(entry, derived))
@@ -810,14 +842,19 @@ def _mark_shared_evidence(entries: list[dict[str, Any]]) -> None:
 def conversation_index_payload(
     graph: dict[str, Any],
     run_root: str | Path,
+    *,
+    investigation_cache=None,
+    include_investigation: bool = False,
 ) -> dict[str, Any]:
-    """Build the conversation index exactly as ``conversations.json`` carries it.
+    """Build the shared conversation projection, with opt-in investigation.
 
-    The live dashboard and the finalized viewer both read this. Keeping one
-    builder is the point: a live run that computed its own projection would be
-    free to disagree with the file written at finalization, and the disagreement
-    would show up as an agent seeing conversations that are not its own.
+    The default is the historical, lightweight conversation contract used by
+    ordinary Live polling. Event-stream inspection is requested explicitly by
+    the investigation reader and offline exporters. Both modes publish exactly
+    the same conversation entries; the extended mode only adds an index.
     """
+    from .investigation_index import build_investigation_index
+
     root = Path(run_root).expanduser().resolve()
     entries = conversation_record_entries(graph, root)
     _mark_shared_injected_context(entries)
@@ -830,6 +867,10 @@ def conversation_index_payload(
     return {
         "schema_version": "0.3",
         "scope": "run_local_provider_neutral_conversation_projection",
+        "session_id": graph.get("session_id") if isinstance(graph.get("session_id"), str) else None,
+        "source_path": graph.get("source_path") if isinstance(graph.get("source_path"), str) else None,
+        **({"investigation": build_investigation_index(graph, root, cache=investigation_cache)}
+           if include_investigation else {}),
         "entry_count": len(entries),
         "visible_message_count": visible_message_count,
         "external_provider_folder_lookup_required": False,
@@ -852,7 +893,7 @@ def write_conversation_records(
     root = Path(run_root).expanduser().resolve()
     root.mkdir(parents=True, exist_ok=True)
     if payload is None:
-        payload = conversation_index_payload(graph, root)
+        payload = conversation_index_payload(graph, root, include_investigation=True)
     entries = payload["entries"]
     json_path = root / "conversations.json"
     markdown_path = root / "conversations.md"

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

@@ -4,7 +4,13 @@ import json
 from typing import Any
 
 from .live_view import LIVE_HTML as _BASE_LIVE_HTML
+from .run_assessment import build_run_assessment
+from .viewer_run_assessment import inject_run_assessment
+from .viewer_investigation import inject_investigation
+from .viewer_runtime_evidence import inject_runtime_evidence
 from .viewer_agent_panel import inject_agent_panel
+from .viewer_framework_model_output import inject_framework_model_output
+from .viewer_content_browser import inject_content_browser
 from .viewer_dashboard_clean import fold_budget_bootstrap, inject_live_dashboard_clean
 from .viewer_dashboard_focus import inject_live_dashboard_focus
 from .viewer_dashboard_pr70 import inject_pr70_dashboard_repairs
@@ -84,7 +90,9 @@ def _build_dashboard_html() -> str:
     html = normalize_provider_execution_flow(
         harden_execution_flow_projection(inject_execution_flow(html))
     )
-    return _align_agent_panel_topology(inject_agent_panel(_guard_compact_live_snapshot(html)))
+    html = _align_agent_panel_topology(inject_agent_panel(_guard_compact_live_snapshot(html)))
+    html = inject_framework_model_output(html)
+    return inject_runtime_evidence(inject_investigation(inject_run_assessment(inject_content_browser(html))))
 
 
 DASHBOARD_HTML = _build_dashboard_html()
@@ -103,14 +111,21 @@ def render_static_dashboard_html(
     graph: dict[str, Any],
     *,
     conversation_entries: list[dict[str, Any]] | None = None,
+    investigation_index: dict[str, Any] | None = None,
 ) -> str:
     """Render the exact dashboard shell used by live, backed by embedded snapshots."""
+    # Derived presentation metadata belongs beside the raw graph, not in it.
+    assessment = graph.get("run_assessment")
+    if not isinstance(assessment, dict):
+        assessment = build_run_assessment(graph)
     bootstrap = (
         "<script>window.__execweaveStaticMode=true;"
         f"{fold_budget_bootstrap()}"
         f"{viewer_limits_bootstrap(resolve_viewer_limits())}"
+        f"window.__execweaveStaticRunAssessment={_safe_json(assessment)};"
         f"window.__execweaveStaticGraph={_safe_json(graph)};"
         f"window.__execweaveStaticConversations={_safe_json(conversation_entries or [])};"
+        f"window.__execweaveStaticInvestigation={_safe_json(investigation_index)};"
         "</script>\n"
     )
     html = DASHBOARD_HTML.replace("<script>", bootstrap + "<script>", 1)

{execweave-0.8.33 → execweave-0.8.34}/src/execweave/codex_conversation.py

@@ -354,7 +354,7 @@ class _DerivedThreads:
             return
         self._messages.setdefault(str(agent_path), []).append(message)
 
-    def previews(self) -> list[dict[str, Any]]:
+    def previews(self, *, preserve_history: bool = False) -> list[dict[str, Any]]:
         results: list[dict[str, Any]] = []
         for agent_path in sorted(self._messages):
             messages = sorted(
@@ -364,7 +364,7 @@ class _DerivedThreads:
                     str(message.get("timestamp") or ""),
                 ),
             )
-            truncated = len(messages) > _MAX_PREVIEW_MESSAGES
+            truncated = not preserve_history and len(messages) > _MAX_PREVIEW_MESSAGES
             if truncated:
                 messages = messages[:10] + messages[-(_MAX_PREVIEW_MESSAGES - 10) :]
             thread_id = self._thread_ids.get(agent_path)
@@ -393,9 +393,15 @@ def codex_rollout_preview(path: str | Path) -> dict[str, Any] | None:
     return previews[0] if previews else None
 
 
-def codex_rollout_previews(path: str | Path) -> list[dict[str, Any]]:
+def codex_rollout_previews(
+    path: str | Path, *, preserve_history: bool = False,
+) -> list[dict[str, Any]]:
     """Extract agent-local conversations a single Codex rollout provides evidence for.
 
+    ``preserve_history`` retains all normalized message records for the Dashboard;
+    the default remains the bounded preview used by existing callers. This does
+    not change per-message text limits or the provider visibility boundary.
+
     The first result is the rollout's own thread. Codex subagent rollouts can
     physically contain inherited parent history: newer paginated rollouts persist
     ordinals on each line, while older compatible rollouts derive them from physical
@@ -597,7 +603,7 @@ def codex_rollout_previews(path: str | Path) -> list[dict[str, Any]]:
                         )
     except (OSError, RuntimeError, UnicodeError):
         return []
-    truncated = len(messages) > _MAX_PREVIEW_MESSAGES
+    truncated = not preserve_history and len(messages) > _MAX_PREVIEW_MESSAGES
     if truncated:
         messages = messages[:10] + messages[-(_MAX_PREVIEW_MESSAGES - 10) :]
     owner = {
@@ -612,4 +618,4 @@ def codex_rollout_previews(path: str | Path) -> list[dict[str, Any]]:
         "messages_truncated": truncated,
         "messages": messages,
     }
-    return [owner, *derived.previews()]
+    return [owner, *derived.previews(preserve_history=preserve_history)]

execweave-0.8.34/src/execweave/content_integrity.py

@@ -0,0 +1,289 @@
+"""Verify declared archive references without inspecting provider payload bodies.
+
+The scope is the exported graph's observed_content nodes and conversation-index
+entries, not provider recall or an adversary-resistant log. Payload JSON is a leaf:
+strings/dictionaries supplied by agents never become additional filesystem paths.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import stat
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Iterator
+
+CONTENT_PATH = re.compile(r"content/sha256/([0-9a-f]{64})\.(?:json|txt|bin)")
+INDEXES = {"graph.json": "nodes", "conversations.json": "entries"}
+EXPORTS = (*INDEXES, "viewer.html")
+CHUNK = 1024 * 1024
+
+
+class ArchiveReadError(Exception):
+    """A bounded, content-free archive diagnostic."""
+
+
+def _signature(value: os.stat_result) -> tuple[int, ...]:
+    return (value.st_dev, value.st_ino, value.st_size, value.st_mtime_ns, value.st_ctime_ns)
+
+
+def _reject_link(path: Path) -> None:
+    info = path.lstat()
+    if stat.S_ISLNK(info.st_mode) or getattr(info, "st_file_attributes", 0) & 0x400:
+        raise ArchiveReadError("unsafe_path")  # Includes Windows reparse points.
+
+
+def _path_descriptor_stat(path: Path) -> os.stat_result:
+    """Compare two open-file snapshots, not Windows stat/fstat timestamps.
+
+    Path-based stat and descriptor-based fstat need not expose the same ctime
+    semantics on supported Windows/Python versions. Reopening the recorded path
+    preserves the identity/size/time comparison without rounding timestamps or
+    ignoring changes. This handle is metadata-only and never reads payload bytes.
+    """
+    _reject_link(path)
+    flags = os.O_RDONLY | getattr(os, "O_BINARY", 0)
+    flags |= getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_NONBLOCK", 0)
+    descriptor = os.open(path, flags)
+    try:
+        value = os.fstat(descriptor)
+        if not stat.S_ISREG(value.st_mode):
+            raise ArchiveReadError("not_regular_file")
+        return value
+    finally:
+        os.close(descriptor)
+
+
+@contextmanager
+def _open_regular(root: Path, relative: str) -> Iterator[Any]:
+    if relative not in EXPORTS and CONTENT_PATH.fullmatch(relative) is None:
+        raise ArchiveReadError("invalid_reference")
+    opened: list[int] = []
+    try:
+        parts = relative.split("/")
+        # Pin every directory on POSIX. O_NOFOLLOW prevents symlink traversal even
+        # when a directory entry is replaced between validation and opening.
+        if os.open in os.supports_dir_fd and hasattr(os, "O_NOFOLLOW"):
+            flags = os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW
+            parent = os.open(root, flags)
+            opened.append(parent)
+            for part in parts[:-1]:
+                parent = os.open(part, flags, dir_fd=parent)
+                opened.append(parent)
+            fd = os.open(parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK, dir_fd=parent)
+        else:
+            path = root
+            _reject_link(path)
+            for part in parts:
+                path = path / part
+                _reject_link(path)
+            # Windows has no Python dir_fd/O_NOFOLLOW equivalent. Reject reparse
+            # points before and after reading; do not claim tamper-proof storage.
+            fd = os.open(path, os.O_RDONLY | getattr(os, "O_BINARY", 0))
+        with os.fdopen(fd, "rb") as handle:
+            before = os.fstat(handle.fileno())
+            if not stat.S_ISREG(before.st_mode):
+                raise ArchiveReadError("not_regular_file")
+            yield handle
+            after = os.fstat(handle.fileno())
+            path = root
+            _reject_link(path)
+            for part in parts:
+                path = path / part
+                _reject_link(path)
+            if _signature(before) != _signature(after) or _signature(after) != _signature(_path_descriptor_stat(path)):
+                raise ArchiveReadError("changed_during_read")
+    except FileNotFoundError as exc:
+        raise ArchiveReadError("missing_file") from exc
+    except OSError as exc:
+        # Do not write raw exception messages: paths may contain private data.
+        raise ArchiveReadError("unreadable_or_unsafe_path") from exc
+    finally:
+        for fd in reversed(opened):
+            os.close(fd)
+
+
+def _read(root: Path, relative: str, limit: int, *, collect: bool = False) -> tuple[dict[str, Any], bytes]:
+    chunks: list[bytes] = []
+    digest = hashlib.sha256()
+    size = 0
+    with _open_regular(root, relative) as handle:
+        if os.fstat(handle.fileno()).st_size > limit:
+            raise ArchiveReadError("verification_limit")
+        while True:
+            chunk = handle.read(min(CHUNK, max(1, limit - size + 1)))
+            if not chunk:
+                break
+            size += len(chunk)
+            if size > limit:
+                raise ArchiveReadError("verification_limit")
+            digest.update(chunk)
+            if collect:
+                chunks.append(chunk)
+    return {"sha256": digest.hexdigest(), "size_bytes": size}, b"".join(chunks)
+
+
+def hash_export(root: Path, name: str) -> dict[str, Any]:
+    """Hash only a named, regular primary export, with bounded reads."""
+    if name not in EXPORTS:
+        raise ArchiveReadError("invalid_export")
+    return _read(root, name, 1024 * 1024 * 1024)[0]
+
+
+def _unique_keys(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError("duplicate JSON key")
+        result[key] = value
+    return result
+
+
+def _constant(value: str) -> None:
+    raise ValueError("non-finite JSON value")
+
+
+def audit_content_references(
+    run_root: str | Path,
+    *,
+    max_index_bytes: int = 64 * 1024 * 1024,
+    max_content_bytes: int = 1024 * 1024 * 1024,
+    max_references: int = 100_000,
+) -> dict[str, Any]:
+    """Verify registered references; limits and unknown sources never pass silently.
+
+    Missing size metadata on legacy references is accepted but not invented. Source
+    completeness is orthogonal: an intact blob of partial provider content can pass
+    byte-integrity verification without implying complete provider observation.
+    """
+    for limit in (max_index_bytes, max_content_bytes, max_references):
+        if type(limit) is not int or limit < 0:
+            raise ValueError("limits must be nonnegative integers")
+    root = Path(run_root).expanduser().absolute()
+    report: dict[str, Any] = {
+        "schema_version": "0.1",
+        "scope": "declared_graph_and_conversation_content",
+        "state": "incomplete",
+        "reference_count": 0,
+        "reference_count_truncated": False,
+        "unique_file_count": 0,
+        "verified_file_count": 0,
+        "error_count": 0,
+        "errors": [],
+        "errors_truncated": False,
+        "index_files": {},
+        "verified_files": {},
+        "limits": {"index_bytes": max_index_bytes, "content_bytes": max_content_bytes,
+                   "references": max_references},
+    }
+
+    def fail(code: str, location: str) -> None:
+        report["error_count"] += 1
+        if len(report["errors"]) < 100:
+            report["errors"].append({"code": code, "location": location})
+        else:
+            report["errors_truncated"] = True
+
+    # None is an unknown legacy size, not zero. A duplicate declaration must agree
+    # with every known size; a later valid reference cannot erase a conflict.
+    references: dict[str, tuple[str, int | None, str]] = {}
+    conflicted: set[str] = set()
+    limit_hit = False
+
+    def register(value: Any, location: str) -> None:
+        nonlocal limit_hit
+        if limit_hit:
+            return
+        report["reference_count"] += 1
+        if report["reference_count"] > max_references:
+            limit_hit = True
+            report["reference_count_truncated"] = True
+            fail("reference_limit", location)
+            return
+        if not isinstance(value, dict):
+            fail("invalid_reference", location)
+            return
+        path, digest, size = value.get("path"), value.get("sha256"), value.get("size_bytes")
+        match = CONTENT_PATH.fullmatch(path) if isinstance(path, str) else None
+        if (match is None or match[1] != digest or
+                ("size_bytes" in value and (type(size) is not int or size < 0))):
+            fail("invalid_reference", location)
+            return
+        previous = references.get(path)
+        if previous and previous[1] is not None and size is not None and previous[1] != size:
+            conflicted.add(path)
+            fail("conflicting_reference", location)
+            return
+        if previous is None or previous[1] is None:
+            references[path] = (digest, size, location)
+
+    sessions: set[str] = set()
+    for name, key in INDEXES.items():
+        try:
+            fingerprint, raw = _read(root, name, max_index_bytes, collect=True)
+            report["index_files"][name] = fingerprint
+            data = json.loads(raw.decode("utf-8"), object_pairs_hook=_unique_keys, parse_constant=_constant)
+            if not isinstance(data, dict) or not isinstance(data.get(key), list):
+                raise ValueError("invalid index shape")
+        except ArchiveReadError as exc:
+            fail(str(exc), name)
+            continue
+        except (ValueError, RecursionError):
+            fail("invalid_index", name)
+            continue
+        session = data.get("session_id")
+        if isinstance(session, str) and session:
+            sessions.add(session)
+        for index, item in enumerate(data[key]):
+            location = f"{name}/{key}/{index}"
+            if not isinstance(item, dict):
+                fail("invalid_index_entry", location)
+                continue
+            if key == "nodes":
+                if item.get("type") == "observed_content":
+                    register(item.get("attributes"), location)
+            else:
+                # Conversation entries are reference records. Do not walk preview
+                # messages, request objects, or arbitrary nested provider JSON.
+                if "path" in item or "sha256" in item:
+                    register(item, location)
+                else:
+                    fail("invalid_reference", location)
+        # A projected graph may retain hidden raw nodes under expansion.clusters.
+        if key == "nodes" and isinstance(data.get("expansion"), dict):
+            clusters = data["expansion"].get("clusters", {})
+            if not isinstance(clusters, dict):
+                fail("invalid_expansion", f"{name}/expansion/clusters")
+                continue
+            for cluster_index, cluster in enumerate(clusters.values()):
+                location = f"{name}/expansion/clusters/{cluster_index}"
+                if not isinstance(cluster, dict) or not isinstance(cluster.get("nodes"), list):
+                    fail("invalid_expansion", location)
+                    continue
+                for index, item in enumerate(cluster["nodes"]):
+                    if isinstance(item, dict) and item.get("type") == "observed_content":
+                        register(item.get("attributes"), f"{location}/nodes/{index}")
+    if len(sessions) > 1:
+        fail("index_session_mismatch", "graph.json/conversations.json")
+    report["unique_file_count"] = len(references)
+    budget = max_content_bytes
+    for path, (digest, size, location) in references.items():
+        if path in conflicted:
+            continue
+        try:
+            fingerprint, _ = _read(root, path, budget)
+            budget -= fingerprint["size_bytes"]
+            if fingerprint["sha256"] != digest:
+                raise ArchiveReadError("hash_mismatch")
+            if size is not None and fingerprint["size_bytes"] != size:
+                raise ArchiveReadError("size_mismatch")
+            report["verified_files"][path] = fingerprint
+        except ArchiveReadError as exc:
+            fail(str(exc), location)
+    report["verified_file_count"] = len(report["verified_files"])
+    report["completed_read_bytes"] = max_content_bytes - budget
+    if report["error_count"] == 0:
+        report["state"] = "complete"
+    return report