clio-kit 2.10.0__tar.gz → 2.10.2__tar.gz

{clio_kit-2.10.0 → clio_kit-2.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clio-kit
-Version: 2.10.0
+Version: 2.10.2
 Summary: CLIO Kit - MCP Servers, Clients, and Tools for AI Agents
 Project-URL: Homepage, https://github.com/iowarp/clio-kit
 Project-URL: Repository, https://github.com/iowarp/clio-kit
@@ -276,7 +276,7 @@ distinct `not_installed` semantic, while real Spack failures remain errors.
 | **`geo`** | 2.2.3 | Geospatial | Render GeoJSON vector layers with basemaps | `clio-kit mcp-server geo` |
 | **`geojson`** | 2.2.3 | Geospatial | Inspect, validate, and summarize GeoJSON | `clio-kit mcp-server geojson` |
 | **`hdf5`** | 2.2.3 | Data I/O | HPC-optimized scientific data with 27 tools, AI insights, caching, streaming | `clio-kit mcp-server hdf5` |
-| **`jarvis`** | 3.6.2 | Workflow | Durable pipeline, bounded package discovery, progress, artifact, and service-runtime management | `clio-kit mcp-server jarvis` |
+| **`jarvis`** | 3.7.1 | Workflow | Durable pipeline, bounded package discovery, progress, artifact, and service-runtime management | `clio-kit mcp-server jarvis` |
 | **`lmod`** | 2.2.3 | Environment | Environment module management | `clio-kit mcp-server lmod` |
 | **`ndp`** | 2.2.3 | Data Protocol | Search and discover datasets across CKAN instances | `clio-kit mcp-server ndp` |
 | **`node-hardware`** | 2.2.3 | System | System hardware information | `clio-kit mcp-server node-hardware` |

{clio_kit-2.10.0 → clio_kit-2.10.2}/README.md

@@ -250,7 +250,7 @@ distinct `not_installed` semantic, while real Spack failures remain errors.
 | **`geo`** | 2.2.3 | Geospatial | Render GeoJSON vector layers with basemaps | `clio-kit mcp-server geo` |
 | **`geojson`** | 2.2.3 | Geospatial | Inspect, validate, and summarize GeoJSON | `clio-kit mcp-server geojson` |
 | **`hdf5`** | 2.2.3 | Data I/O | HPC-optimized scientific data with 27 tools, AI insights, caching, streaming | `clio-kit mcp-server hdf5` |
-| **`jarvis`** | 3.6.2 | Workflow | Durable pipeline, bounded package discovery, progress, artifact, and service-runtime management | `clio-kit mcp-server jarvis` |
+| **`jarvis`** | 3.7.1 | Workflow | Durable pipeline, bounded package discovery, progress, artifact, and service-runtime management | `clio-kit mcp-server jarvis` |
 | **`lmod`** | 2.2.3 | Environment | Environment module management | `clio-kit mcp-server lmod` |
 | **`ndp`** | 2.2.3 | Data Protocol | Search and discover datasets across CKAN instances | `clio-kit mcp-server ndp` |
 | **`node-hardware`** | 2.2.3 | System | System hardware information | `clio-kit mcp-server node-hardware` |

{clio_kit-2.10.0 → clio_kit-2.10.2}/clio-kit-mcp-servers/adios/server.json

@@ -12,7 +12,7 @@
     {
       "registryType": "pypi",
       "identifier": "clio-kit",
-      "version": "2.10.0",
+      "version": "2.10.2",
       "transport": {
         "type": "stdio"
       },

{clio_kit-2.10.0 → clio_kit-2.10.2}/clio-kit-mcp-servers/arxiv/server.json

@@ -12,7 +12,7 @@
     {
       "registryType": "pypi",
       "identifier": "clio-kit",
-      "version": "2.10.0",
+      "version": "2.10.2",
       "transport": {
         "type": "stdio"
       },

{clio_kit-2.10.0 → clio_kit-2.10.2}/clio-kit-mcp-servers/chronolog/server.json

@@ -12,7 +12,7 @@
     {
       "registryType": "pypi",
       "identifier": "clio-kit",
-      "version": "2.10.0",
+      "version": "2.10.2",
       "transport": {
         "type": "stdio"
       },

{clio_kit-2.10.0 → clio_kit-2.10.2}/clio-kit-mcp-servers/compression/server.json

@@ -12,7 +12,7 @@
     {
       "registryType": "pypi",
       "identifier": "clio-kit",
-      "version": "2.10.0",
+      "version": "2.10.2",
       "transport": {
         "type": "stdio"
       },

{clio_kit-2.10.0 → clio_kit-2.10.2}/clio-kit-mcp-servers/darshan/server.json

@@ -12,7 +12,7 @@
     {
       "registryType": "pypi",
       "identifier": "clio-kit",
-      "version": "2.10.0",
+      "version": "2.10.2",
       "transport": {
         "type": "stdio"
       },

{clio_kit-2.10.0 → clio_kit-2.10.2}/clio-kit-mcp-servers/geo/server.json

@@ -12,7 +12,7 @@
     {
       "registryType": "pypi",
       "identifier": "clio-kit",
-      "version": "2.10.0",
+      "version": "2.10.2",
       "transport": {
         "type": "stdio"
       },

{clio_kit-2.10.0 → clio_kit-2.10.2}/clio-kit-mcp-servers/geojson/server.json

@@ -12,7 +12,7 @@
     {
       "registryType": "pypi",
       "identifier": "clio-kit",
-      "version": "2.10.0",
+      "version": "2.10.2",
       "transport": {
         "type": "stdio"
       },

{clio_kit-2.10.0 → clio_kit-2.10.2}/clio-kit-mcp-servers/hdf5/server.json

@@ -12,7 +12,7 @@
     {
       "registryType": "pypi",
       "identifier": "clio-kit",
-      "version": "2.10.0",
+      "version": "2.10.2",
       "transport": {
         "type": "stdio"
       },

{clio_kit-2.10.0 → clio_kit-2.10.2}/clio-kit-mcp-servers/jarvis/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "clio-jarvis",
   "description": "JARVIS-CD MCP with a compact user pipeline contract and explicit admin compatibility profiles",
-  "version": "3.6.2"
+  "version": "3.7.1"
 }

{clio_kit-2.10.0 → clio_kit-2.10.2}/clio-kit-mcp-servers/jarvis/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jarvis-mcp"
-version = "3.6.2"
+version = "3.7.1"
 description = "JARVIS-CD MCP with a compact user pipeline contract and explicit admin compatibility profiles"
 readme = "README.md"
 requires-python = ">=3.11"

{clio_kit-2.10.0 → clio_kit-2.10.2}/clio-kit-mcp-servers/jarvis/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.iowarp/jarvis-mcp",
   "title": "CLIO Jarvis",
   "description": "JARVIS-CD MCP with a compact user pipeline contract and explicit admin compatibility profiles",
-  "version": "3.6.2",
+  "version": "3.7.1",
   "repository": {
     "url": "https://github.com/iowarp/clio-kit",
     "source": "github"
@@ -12,7 +12,7 @@
     {
       "registryType": "pypi",
       "identifier": "clio-kit",
-      "version": "2.10.0",
+      "version": "2.10.2",
       "transport": {
         "type": "stdio"
       },

clio_kit-2.10.2/clio-kit-mcp-servers/jarvis/src/jarvis_mcp/artifact_content.py

@@ -0,0 +1,184 @@
+"""Bounded inline content reads for JARVIS-owned ``role="log"`` artifacts.
+
+Companion to :mod:`jarvis_mcp.artifacts`, which owns artifact snapshot
+validation and paging: that module's artifact page is a content-free
+manifest by design (identity, role, state, location only). This module adds
+one narrow, additive capability on top of it -- reading a bounded tail of a
+log artifact's own file -- kept in its own module rather than appended to
+either ``artifacts.py`` or the already-oversized ``jarvis_handler.py`` (see
+``scripts/check_file_size.py``'s per-file ratchet).
+
+A failed execution's own generated logs are the single most useful thing an
+agent can read after a terminal failure. Only ``role="log"`` artifacts are
+eligible: this is a deliberate, narrow scope, not a general remote-file-read
+primitive.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any, cast
+
+ARTIFACT_MAX_CONTENT_BYTES = 64 * 1024
+
+
+class ArtifactContentError(RuntimeError):
+    """One artifact's bounded inline content could not be resolved or read.
+
+    Always caught per-artifact by :func:`artifact_with_content` -- a single
+    unreadable log must never fail the whole bounded page.
+    """
+
+    def __init__(self, code: str, message: str) -> None:
+        """Create a stable per-artifact content error."""
+        super().__init__(message)
+        self.code = code
+        self.message = message
+
+
+def artifact_with_content(
+    item: dict[str, Any],
+    *,
+    execution_root: Path | None,
+    max_bytes: int,
+) -> dict[str, Any]:
+    """Return one page item enriched with a bounded inline content read.
+
+    Scoped to ``role="log"`` artifacts only -- this is a narrow, bounded log
+    reader, not a general remote-file-read primitive. Every other artifact,
+    and every log artifact whose content genuinely could not be resolved,
+    gets a typed ``content_error`` -- the caller always sees why, never a
+    silent gap where content might have been.
+    """
+    enriched = dict(item)
+    role = item.get("role")
+    if role != "log":
+        enriched.update(
+            content=None,
+            content_truncated=False,
+            content_bytes_read=0,
+            content_error=(
+                f"artifact role {role!r} is not eligible for inline content "
+                '(role must be "log")'
+            ),
+        )
+        return enriched
+    location = item.get("location")
+    if not isinstance(location, dict):
+        enriched.update(
+            content=None,
+            content_truncated=False,
+            content_bytes_read=0,
+            content_error="log artifact has no location to read content from",
+        )
+        return enriched
+    try:
+        path = resolve_artifact_path(location, execution_root=execution_root)
+        text, truncated, bytes_read = read_artifact_tail(path, max_bytes=max_bytes)
+    except ArtifactContentError as exc:
+        enriched.update(
+            content=None,
+            content_truncated=False,
+            content_bytes_read=0,
+            content_error=exc.message,
+        )
+        return enriched
+    enriched.update(
+        content=text,
+        content_truncated=truncated,
+        content_bytes_read=bytes_read,
+        content_error=None,
+    )
+    return enriched
+
+
+def execution_root_from_record(record_document: Mapping[str, Any]) -> Path | None:
+    """Resolve one execution's own root directory from its durable metadata.
+
+    Grounded, not guessed: ``pipeline_snapshot_path`` is written by JARVIS-CD
+    itself as ``execution_root / "runtime"`` for every execution (see
+    ``jarvis_cd.core.pipeline.Pipeline._launch``, which also places
+    ``stdout.log``/``stderr.log`` directly under that same ``execution_root``
+    -- this is the one durable field already present on every record that
+    names it, so no path is invented here. Falls back to ``script_path``
+    (present instead of ``pipeline_snapshot_path`` for scheduler-submitted
+    executions -- see the terminal execution-output declaration path) when
+    the primary field is absent or malformed. Returns ``None`` (never a
+    guess) when neither field resolves; callers must treat that as
+    "execution-scoped content is not resolvable for this record", not retry
+    with a fabricated path.
+    """
+    metadata = record_document.get("metadata")
+    if not isinstance(metadata, Mapping):
+        return None
+    for key in ("pipeline_snapshot_path", "script_path"):
+        raw_path = metadata.get(key)
+        if not isinstance(raw_path, str) or not raw_path.strip():
+            continue
+        candidate = Path(raw_path)
+        if candidate.name:
+            return candidate.parent
+    return None
+
+
+def resolve_artifact_path(
+    location: Mapping[str, Any],
+    *,
+    execution_root: Path | None,
+) -> Path:
+    """Resolve one already-validated artifact location to a real filesystem path.
+
+    ``execution_path`` locations were validated on the way in
+    (``artifacts.py::_validate_execution_path``) to contain no
+    ``..``/absolute component, so joining them onto ``execution_root`` can
+    never escape it. ``cluster_path`` locations are already validated
+    absolute paths on this same host -- ``jarvis_mcp`` runs co-located with
+    the execution it is reporting on, so this is a local read, never a
+    second network hop.
+    """
+    kind = location["kind"]
+    value = cast(str, location["value"])
+    if kind == "cluster_path":
+        return Path(value)
+    if kind == "execution_path":
+        if execution_root is None:
+            raise ArtifactContentError(
+                "jarvis_artifact_execution_root_unavailable",
+                "this execution's own root directory could not be resolved, "
+                "so its relative log path cannot be read",
+            )
+        return execution_root / value
+    raise ArtifactContentError(
+        "jarvis_artifact_content_unsupported_location",
+        f"artifact location kind {kind!r} does not support inline content",
+    )
+
+
+def read_artifact_tail(path: Path, *, max_bytes: int) -> tuple[str, bool, int]:
+    """Read up to ``max_bytes`` from the END of one file (tail semantics).
+
+    A log's most recent lines -- the ones nearest a crash -- are read, not
+    its head. Decoded permissively (``errors="replace"``): a partially
+    written multi-byte sequence at the tail boundary must not turn a
+    genuinely useful read into a hard failure.
+    """
+    try:
+        size = path.stat().st_size
+    except OSError as exc:
+        raise ArtifactContentError(
+            "jarvis_artifact_content_unreadable",
+            f"artifact file could not be read: {exc}",
+        ) from exc
+    truncated = size > max_bytes
+    offset = max(0, size - max_bytes)
+    try:
+        with path.open("rb") as handle:
+            handle.seek(offset)
+            raw = handle.read(max_bytes)
+    except OSError as exc:
+        raise ArtifactContentError(
+            "jarvis_artifact_content_unreadable",
+            f"artifact file could not be read: {exc}",
+        ) from exc
+    return raw.decode("utf-8", errors="replace"), truncated, len(raw)

{clio_kit-2.10.0 → clio_kit-2.10.2}/clio-kit-mcp-servers/jarvis/src/jarvis_mcp/artifacts.py

@@ -13,11 +13,21 @@ import hashlib
 import json
 import math
 import re
+import stat
+import time
 from collections.abc import Mapping
-from pathlib import PurePosixPath
+from pathlib import Path, PurePosixPath
 from typing import Any, cast
 from urllib.parse import urlsplit
 
+# Content-reading (``ArtifactContentError``/``artifact_with_content``) lives
+# in ``artifact_content.py``, not here: this module owns snapshot VALIDATION
+# and paging; that one owns the bounded, ``role="log"``-only file read
+# layered on top of a page's results.
+from jarvis_mcp.artifact_content import (
+    ARTIFACT_MAX_CONTENT_BYTES,
+    artifact_with_content,
+)
 
 ARTIFACT_SNAPSHOT_SCHEMA = "jarvis.execution.artifacts.v1"
 ARTIFACT_EVENT_SCHEMA = "jarvis.artifact.v1"
@@ -55,6 +65,7 @@ _ARTIFACT_ROLES = {
     "intermediate",
     "output",
     "log",
+    "frame",
     "checkpoint",
     "provenance",
     "validation",
@@ -87,6 +98,28 @@ _OPTIONAL_EVENT_FIELDS = {
     "checksum",
     "message",
 }
+MAX_EXECUTION_OUTPUT_FILES = 64
+_EXECUTION_OUTPUT_TRUNCATION_SCHEMA = "jarvis.execution-output-truncation.v1"
+_EXECUTION_OUTPUT_CONTROL_FILES = frozenset({"submit.slurm"})
+_EXECUTION_OUTPUT_ROLE_BY_SUFFIX = {
+    ".err": "log",
+    ".log": "log",
+    ".out": "log",
+    ".bp": "frame",
+    ".dcd": "frame",
+    ".dump": "frame",
+    ".h5": "frame",
+    ".hdf5": "frame",
+    ".lammpstrj": "frame",
+    ".nc": "frame",
+    ".npy": "frame",
+    ".npz": "frame",
+    ".pdb": "frame",
+    ".vti": "frame",
+    ".vtk": "frame",
+    ".vtu": "frame",
+    ".xyz": "frame",
+}
 
 
 class ArtifactSnapshotError(RuntimeError):
@@ -110,6 +143,119 @@ class ArtifactQueryError(RuntimeError):
         self.retryable = retryable
 
 
+def execution_output_artifact_events(
+    execution_root: Path,
+    *,
+    execution_id: str,
+    observed_at_epoch: float | None = None,
+) -> tuple[list[dict[str, Any]], dict[str, object] | None]:
+    """Declare bounded regular files directly under one terminal execution root.
+
+    Discovery is deliberately shallow: the execution root is listed once and
+    nested directories are never traversed. File contents are hashed for
+    identity, but never embedded in the returned manifest.
+    """
+    if not execution_root.is_dir():
+        return [], None
+    observed = time.time() if observed_at_epoch is None else observed_at_epoch
+    candidates: list[Path] = []
+    for path in sorted(execution_root.iterdir(), key=lambda item: item.name):
+        try:
+            path_stat = path.lstat()
+        except OSError:
+            continue
+        if (
+            path.name.startswith(".")
+            or path.name in _EXECUTION_OUTPUT_CONTROL_FILES
+            or stat.S_ISLNK(path_stat.st_mode)
+            or not stat.S_ISREG(path_stat.st_mode)
+        ):
+            continue
+        candidates.append(path)
+
+    events: list[dict[str, Any]] = []
+    for sequence, path in enumerate(candidates[:MAX_EXECUTION_OUTPUT_FILES], start=1):
+        digest, size = _hash_regular_file(path)
+        relative_path = path.relative_to(execution_root).as_posix()
+        role = _EXECUTION_OUTPUT_ROLE_BY_SUFFIX.get(path.suffix.lower(), "output")
+        artifact_id = (
+            "art_"
+            + hashlib.sha256(f"{execution_id}:{relative_path}".encode()).hexdigest()
+        )
+        events.append(
+            {
+                "schema_version": ARTIFACT_EVENT_SCHEMA,
+                "package_name": "jarvis.execution",
+                "package_id": "jarvis.execution",
+                "execution_id": execution_id,
+                "artifact_id": artifact_id,
+                "logical_name": relative_path,
+                "kind": "execution-file",
+                "role": role,
+                "structure": "file",
+                "ownership": "execution",
+                "state": "finalized",
+                "location": {"kind": "execution_path", "value": relative_path},
+                "size_bytes": size,
+                "checksum": f"sha256:{digest}",
+                "revision": 1,
+                "sequence": sequence,
+                "observed_at_epoch": observed,
+                "metadata": {"discovery": "execution-root-direct-file"},
+            }
+        )
+
+    truncation = None
+    if len(candidates) > MAX_EXECUTION_OUTPUT_FILES:
+        truncation = {
+            "schema_version": _EXECUTION_OUTPUT_TRUNCATION_SCHEMA,
+            "limit": MAX_EXECUTION_OUTPUT_FILES,
+            "observed_count": len(candidates),
+            "omitted_count": len(candidates) - MAX_EXECUTION_OUTPUT_FILES,
+        }
+        events.append(
+            {
+                "schema_version": ARTIFACT_EVENT_SCHEMA,
+                "package_name": "jarvis.execution",
+                "package_id": "jarvis.execution",
+                "execution_id": execution_id,
+                "artifact_id": "art_"
+                + hashlib.sha256(
+                    f"{execution_id}:execution-output-truncation".encode()
+                ).hexdigest(),
+                "logical_name": "__execution-output-truncation__",
+                "kind": "execution-output-truncation",
+                "role": "validation",
+                "structure": "file",
+                "ownership": "execution",
+                "state": "failed",
+                "revision": 1,
+                "sequence": len(events) + 1,
+                "observed_at_epoch": observed,
+                "message": "execution output file declaration cap exceeded",
+                "metadata": truncation,
+            }
+        )
+    return events, truncation
+
+
+def _hash_regular_file(path: Path) -> tuple[str, int]:
+    """Hash one stable regular file without retaining its content."""
+    digest = hashlib.sha256()
+    size = 0
+    with path.open("rb") as stream:
+        before = path.stat()
+        while chunk := stream.read(1024 * 1024):
+            digest.update(chunk)
+            size += len(chunk)
+        after = path.stat()
+    if not stat.S_ISREG(before.st_mode) or not stat.S_ISREG(after.st_mode):
+        raise RuntimeError("execution output changed from a regular file")
+    if before.st_size != size or after.st_size != size:
+        raise RuntimeError("execution output changed while hashing")
+    return digest.hexdigest(), size
+
+
 def artifact_snapshot_document(
     snapshot: object,
     *,
@@ -194,12 +340,24 @@ def artifact_query_page(
     artifact_id: str | None = None,
     page_size: int = ARTIFACT_DEFAULT_PAGE_SIZE,
     cursor: str | None = None,
+    content_max_bytes: int | None = None,
+    execution_root: Path | None = None,
 ) -> dict[str, Any]:
     """Filter and page one previously validated native artifact snapshot.
 
     Cursors bind the exact filters and a digest of the filtered producer
     snapshot. A changed artifact, execution state, or terminal flag makes an
     existing cursor stale instead of silently shifting an offset-based page.
+
+    ``content_max_bytes`` is a response-enrichment knob, not a filter: it is
+    deliberately excluded from the cursor's filter digest so a cursor minted
+    without it stays valid on a follow-up call that requests it (or vice
+    versa). When set, every ``role="log"`` artifact in the returned page gets
+    a bounded tail read of its own file (``content``/``content_truncated``/
+    ``content_bytes_read``); every other artifact, and every log artifact
+    whose content could not be resolved, gets a typed ``content_error``
+    instead -- never a silent omission, never a page-wide failure for one
+    unreadable file.
     """
     _validate_query_filters(
         package_id=package_id,
@@ -207,6 +365,7 @@ def artifact_query_page(
         state=state,
         artifact_id=artifact_id,
         page_size=page_size,
+        content_max_bytes=content_max_bytes,
     )
     filters = {
         "package_id": package_id,
@@ -309,6 +468,13 @@ def artifact_query_page(
             filter_digest=filter_digest,
             snapshot_digest=snapshot_digest,
         )
+    if content_max_bytes is not None:
+        page = [
+            artifact_with_content(
+                item, execution_root=execution_root, max_bytes=content_max_bytes
+            )
+            for item in page
+        ]
     return {
         "producer_schema_version": snapshot["schema_version"],
         "pipeline_id": snapshot["pipeline_id"],
@@ -329,7 +495,18 @@ def _validate_query_filters(
     state: str | None,
     artifact_id: str | None,
     page_size: int,
+    content_max_bytes: int | None = None,
 ) -> None:
+    if content_max_bytes is not None and (
+        isinstance(content_max_bytes, bool)
+        or not isinstance(content_max_bytes, int)
+        or not 1 <= content_max_bytes <= ARTIFACT_MAX_CONTENT_BYTES
+    ):
+        raise ArtifactQueryError(
+            "jarvis_artifact_content_max_bytes_invalid",
+            f"JARVIS artifact content_max_bytes must be between 1 and "
+            f"{ARTIFACT_MAX_CONTENT_BYTES}",
+        )
     if package_id is not None:
         try:
             _validate_text(package_id, field="package_id filter", maximum=256)

{clio_kit-2.10.0 → clio_kit-2.10.2}/clio-kit-mcp-servers/jarvis/src/jarvis_mcp/capabilities/__init__.py

@@ -3,12 +3,12 @@ Jarvis MCP Server
 
 Jarvis-CD MCP - Pipeline Management for High-Performance Computing with comprehensive workflow operations
 
-Version: 3.6.2
+Version: 3.7.1
 Author: IoWarp Team - Gnosis Research Center
 License: BSD-3-Clause
 """
 
-__version__ = "3.6.2"
+__version__ = "3.7.1"
 __author__ = "IoWarp Team - Gnosis Research Center"
 __email__ = "grc@illinoistech.edu"
 __license__ = "BSD-3-Clause"

{clio_kit-2.10.0 → clio_kit-2.10.2}/clio-kit-mcp-servers/jarvis/src/jarvis_mcp/capabilities/jarvis_handler.py

@@ -25,11 +25,13 @@ from uuid import uuid4
 from fastapi import HTTPException
 from fastmcp.exceptions import ToolError
 
+from jarvis_mcp.artifact_content import execution_root_from_record
 from jarvis_mcp.artifacts import (
     ArtifactQueryError,
     ArtifactSnapshotError,
     artifact_query_page,
     artifact_snapshot_document,
+    execution_output_artifact_events,
 )
 from jarvis_mcp.progress import (
     NativeProgressExecution,
@@ -37,7 +39,6 @@ from jarvis_mcp.progress import (
     progress_snapshot_document,
 )
 
-
 RUNTIME_METADATA_SCHEMA = "jarvis.runtime.v1"
 RUNTIME_ERROR_SCHEMA = "jarvis.error.v1"
 RUN_RESULT_SCHEMA = "clio-kit.jarvis-run.v1"
@@ -891,6 +892,25 @@ async def get_execution(
                     expected_execution_id=validated_execution,
                     expected_pipeline_id=validated_pipeline,
                 )
+                if artifact_snapshot is not None and record_document["terminal"]:
+                    execution_root = execution_root_from_record(record_document)
+                    if execution_root is not None:
+                        discovered, _truncation = execution_output_artifact_events(
+                            execution_root,
+                            execution_id=validated_execution,
+                        )
+                        if discovered:
+                            artifact_snapshot = artifact_snapshot_document(
+                                {
+                                    **artifact_snapshot,
+                                    "artifacts": [
+                                        *artifact_snapshot["artifacts"],
+                                        *discovered,
+                                    ],
+                                },
+                                expected_execution_id=validated_execution,
+                                expected_pipeline_id=validated_pipeline,
+                            )
                 handle_document = _execution_handle_document(
                     getattr(record, "handle", None),
                     expected_execution_id=validated_execution,
@@ -923,6 +943,7 @@ async def get_execution(
             if artifacts is not None:
                 if artifact_snapshot is None:
                     raise RuntimeError("JARVIS artifact query omitted its snapshot")
+                content_max_bytes = artifacts.get("content_max_bytes")
                 artifact_page = artifact_query_page(
                     artifact_snapshot,
                     package_id=artifacts.get("package_id"),
@@ -931,6 +952,12 @@ async def get_execution(
                     artifact_id=artifacts.get("artifact_id"),
                     page_size=artifacts.get("page_size", 50),
                     cursor=artifacts.get("cursor"),
+                    content_max_bytes=content_max_bytes,
+                    execution_root=(
+                        execution_root_from_record(record_document)
+                        if content_max_bytes is not None
+                        else None
+                    ),
                 )
             query_submit, query_wait = _execution_query_flags(record_document)
             runtime_metadata = _runtime_metadata_from_documents(