reactifact 0.15.1__tar.gz → 0.15.3__tar.gz

{reactifact-0.15.1/reactifact.egg-info → reactifact-0.15.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactifact
-Version: 0.15.1
+Version: 0.15.3
 Summary: Reactive, artifact-driven agent runtime: agents transform versioned, typed, provenance-aware artifacts inside an evolving context
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/bzdvdn/reactifact
@@ -323,6 +323,23 @@ by hand. Run it yourself: `uv run python -m examples.ledger.main`.
 - **Viz & CLI** — Mermaid `blueprint`/`context_to_mermaid`/`trace_to_mermaid`;
   `reactifact` with `graph`/`context`/`trace`/`replay`/`branch`.
 
+## Agent Skills
+
+reactifact ships official **Agent Skills** — reusable instructions that teach a
+coding agent (Claude Code, Cursor, Codex, Copilot, …) how to build *with*
+reactifact. They're bundled with the package, so they always match your version:
+
+```bash
+python -m reactifact skills list                    # what is available
+python -m reactifact skills install                 # -> .agents/skills/
+python -m reactifact skills install --target both    # + .claude/skills/
+```
+
+Skills: `reactifact` (mental model), `reactifact-agents`, `reactifact-llm`,
+`reactifact-rag`, `reactifact-testing`, `reactifact-eval`,
+`reactifact-observability`, `reactifact-from-langchain` — see
+[Agent skills](docs/en/skills.md).
+
 ## Run a demo
 
 Offline-capable, no API keys required (deterministic fallbacks):
@@ -380,7 +397,7 @@ uv sync --extra dev --extra web
 
 ## Status & contributing
 
-Active, `0.14.x`, pre-1.0 — the API is stabilizing and `1.0` will freeze it
+Active, `0.15.x`, pre-1.0 — the API is stabilizing and `1.0` will freeze it
 (see the [roadmap](docs/roadmap.md)); releases follow
 [Keep a Changelog](CHANGELOG.md). Questions and design discussion live in
 [GitHub Discussions](https://github.com/bzdvdn/reactifact/discussions); a star,

{reactifact-0.15.1 → reactifact-0.15.3}/README.md

@@ -277,6 +277,23 @@ by hand. Run it yourself: `uv run python -m examples.ledger.main`.
 - **Viz & CLI** — Mermaid `blueprint`/`context_to_mermaid`/`trace_to_mermaid`;
   `reactifact` with `graph`/`context`/`trace`/`replay`/`branch`.
 
+## Agent Skills
+
+reactifact ships official **Agent Skills** — reusable instructions that teach a
+coding agent (Claude Code, Cursor, Codex, Copilot, …) how to build *with*
+reactifact. They're bundled with the package, so they always match your version:
+
+```bash
+python -m reactifact skills list                    # what is available
+python -m reactifact skills install                 # -> .agents/skills/
+python -m reactifact skills install --target both    # + .claude/skills/
+```
+
+Skills: `reactifact` (mental model), `reactifact-agents`, `reactifact-llm`,
+`reactifact-rag`, `reactifact-testing`, `reactifact-eval`,
+`reactifact-observability`, `reactifact-from-langchain` — see
+[Agent skills](docs/en/skills.md).
+
 ## Run a demo
 
 Offline-capable, no API keys required (deterministic fallbacks):
@@ -334,7 +351,7 @@ uv sync --extra dev --extra web
 
 ## Status & contributing
 
-Active, `0.14.x`, pre-1.0 — the API is stabilizing and `1.0` will freeze it
+Active, `0.15.x`, pre-1.0 — the API is stabilizing and `1.0` will freeze it
 (see the [roadmap](docs/roadmap.md)); releases follow
 [Keep a Changelog](CHANGELOG.md). Questions and design discussion live in
 [GitHub Discussions](https://github.com/bzdvdn/reactifact/discussions); a star,

{reactifact-0.15.1 → reactifact-0.15.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactifact"
-version = "0.15.1"
+version = "0.15.3"
 description = "Reactive, artifact-driven agent runtime: agents transform versioned, typed, provenance-aware artifacts inside an evolving context"
 readme = "README.md"
 requires-python = ">=3.11"

{reactifact-0.15.1 → reactifact-0.15.3}/reactifact/__init__.py

@@ -51,7 +51,7 @@ from .tools import FunctionTool, Tool, ToolOutput, tool
 from .triggers import Trigger
 from .types import register as register_type
 
-__version__ = "0.15.1"
+__version__ = "0.15.3"
 
 __all__ = [
     "Agent",

{reactifact-0.15.1 → reactifact-0.15.3}/reactifact/agents.py

@@ -1,17 +1,42 @@
 from __future__ import annotations
 
+import time
 from abc import ABC
 from collections.abc import Sequence
+from contextvars import ContextVar, Token
 from typing import Any
 
 from .artifacts import Artifact
 from .consume import Consume
 from .context import Context
+from .effects import current_effects
 from .events import Event, EventType
 from .patches import Patch
 from .produce import Produce, ProduceCall
 from .triggers import Trigger
 
+#: Per-task log of the produces that ran for the current agent execution:
+#: ``(produce_class_name, operations_authored, latency_ms)``. ``Runtime._execute``
+#: opens it (and later records the span), ``Agent.execute`` appends — a
+#: contextvar so concurrent executions sharing one ``Agent`` instance never race.
+_produce_runs: ContextVar[list[tuple[str, int, float]] | None] = ContextVar(
+    "reactifact_produce_runs", default=None
+)
+
+
+def begin_produce_runs() -> Token[Any]:
+    """Opens the per-task produce-run log (see ``_produce_runs``)."""
+    return _produce_runs.set([])
+
+
+def produce_runs() -> list[tuple[str, int, float]]:
+    """The produce runs recorded for the current task (empty if none)."""
+    return _produce_runs.get() or []
+
+
+def end_produce_runs(token: Token[Any]) -> None:
+    _produce_runs.reset(token)
+
 
 class Agent(ABC):  # noqa: B024 — interface without abstract methods, run() has a default
     """Base container: consumes some artifacts and produces others.
@@ -154,14 +179,30 @@ class Agent(ABC):  # noqa: B024 — interface without abstract methods, run() ha
         if not self.produces:
             return None
         inputs = self._collect_inputs(context)
+        slot = current_effects()
+        log = _produce_runs.get()
         for p in self.produces:
             runs, trigger = self._resolve_produce_call(p, event, context)
             if not runs:
                 continue
+            before = len(slot.operations) if slot is not None else 0
+            started = time.monotonic()
             call = ProduceCall(
                 context=context, inputs=inputs, event=event, trigger=trigger
             )
-            await p.produce(call)
+            try:
+                await p.produce(call)
+            finally:
+                # Record the produce even when it raises — a failing produce is
+                # exactly what a trace should show (the span is then the error
+                # span, with this produce's partial operations/latency).
+                if log is not None:
+                    operations = (
+                        len(slot.operations) if slot is not None else 0
+                    ) - before
+                    log.append(
+                        (p.name, operations, (time.monotonic() - started) * 1000)
+                    )
         return None
 
     @staticmethod

{reactifact-0.15.1 → reactifact-0.15.3}/reactifact/audit.py

@@ -47,10 +47,30 @@ DEFAULT_RELATIONS: tuple[str, ...] = (
 )
 
 
+def _transient_fields(model: type[BaseModel]) -> set[str]:
+    """Field names a model declares as transactional *envelope*, not state.
+
+    A model lists them as ``transient_fields: ClassVar[frozenset[str]]``
+    (e.g. `PendingAction.dispatched_at`, `PendingQuestion.resolved_at`).
+    Wall-clock transitions are excluded from the content hash so an otherwise
+    identical state doesn't hash differently run to run — the *fact* of the
+    transition stays hashed (`status`/`resolution`); only its timestamp drops.
+    """
+    names = getattr(model, "transient_fields", ())
+    return set(names) if names else set()
+
+
 def _canonical(value: Any) -> str:
-    """Canonical JSON for hashing (sorted keys; pydantic models dumped)."""
+    """Canonical JSON for hashing (sorted keys; pydantic models dumped).
+
+    A model's `transient_fields` are dropped before hashing — envelope, not
+    state. Everything else is serialized exactly as before, so a state with no
+    transient fields hashes the same as it always did.
+    """
     if isinstance(value, BaseModel):
-        payload: Any = value.model_dump(mode="json")
+        payload: Any = value.model_dump(
+            mode="json", exclude=_transient_fields(type(value)) or None
+        )
     else:
         payload = value
     return json.dumps(payload, sort_keys=True, ensure_ascii=False, default=str)

{reactifact-0.15.1 → reactifact-0.15.3}/reactifact/interrupt.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from datetime import datetime
-from typing import Any, Literal
+from typing import Any, ClassVar, Literal
 
 from pydantic import BaseModel, Field
 
@@ -21,6 +21,11 @@ class PendingQuestion(BaseModel):
     resolution: str | None = None
     resolved_at: datetime | None = None
 
+    #: Wall-clock fields excluded from `context_hash` (transactional envelope,
+    #: not state): a resolved question's *state* is `resolution`, the moment it
+    #: was resolved is not something two equivalent runs must agree on.
+    transient_fields: ClassVar[frozenset[str]] = frozenset({"resolved_at"})
+
 
 class PendingAction(BaseModel):
     """An outbound side effect awaiting dispatch (outbox, §42/§55/§59).
@@ -52,3 +57,9 @@ class PendingAction(BaseModel):
     attempts: int = 0
     dispatched_at: datetime | None = None
     error: str | None = None
+
+    #: Wall-clock field excluded from `context_hash` (transactional envelope,
+    #: not state): the *fact* that the action dispatched (`status`/`error`/
+    #: `attempts`) is hashed, the moment it happened is not — so an outbox run
+    #: stays run-to-run reproducible.
+    transient_fields: ClassVar[frozenset[str]] = frozenset({"dispatched_at"})

{reactifact-0.15.1 → reactifact-0.15.3}/reactifact/produce.py

@@ -266,6 +266,37 @@ class Produce(Generic[TOut]):
         """
         return None
 
+    #: Explicit display name (set by e.g. tool-use produces); when unset,
+    #: `name` derives a readable one from the class/function/artifact type.
+    _name: str | None = None
+
+    @property
+    def name(self) -> str:
+        """A human-readable name for traces/logs.
+
+        Subclass-style produces use their class name; an ``@produce``-decorated
+        function uses the wrapped function's name; a bare ``Produce(Model)``
+        (declared only to widen an agent's allowed ``Create`` types) falls back
+        to its output artifact type — otherwise every such no-op would show up
+        as a generic ``Produce``. An explicit ``name`` (e.g. a tool-use produce's)
+        always wins.
+        """
+        explicit = getattr(self, "_name", None)
+        if explicit:
+            return str(explicit)
+        cls = type(self).__name__
+        if cls not in ("Produce", "_FunctionProduce"):
+            return cls
+        func = getattr(self, "_func", None)
+        if func is not None:
+            return str(getattr(func, "__name__", cls))
+        artifact = getattr(self.artifact_type, "__name__", "")
+        return f"Produce[{artifact}]" if artifact else cls
+
+    @name.setter
+    def name(self, value: str) -> None:
+        self._name = value
+
     def _apply_result(self, result: Any) -> None:
         """Writes a `@produce`-decorated function's return-style result into
         the effect slot (§24).
@@ -319,6 +350,8 @@ def produce(
             )
 
         class _FunctionProduce(Produce[Any]):
+            _func: Callable[[ProduceCall], Any]
+
             async def produce(self, call: ProduceCall) -> None:
                 result = func(call)
                 if asyncio.iscoroutine(result):
@@ -329,6 +362,8 @@ def produce(
         instance = _FunctionProduce(
             artifact_type=artifact_type, also_creates=also_creates, reacts_to=reacts_to
         )
+        # Keep the function for `Produce.name` (a readable trace/log label).
+        instance._func = func
         return instance
 
     return decorator

{reactifact-0.15.1 → reactifact-0.15.3}/reactifact/runtime.py

@@ -7,7 +7,7 @@ from collections.abc import AsyncIterator, Awaitable, Callable, Mapping
 from dataclasses import dataclass
 from typing import Any, Literal, cast
 
-from .agents import Agent
+from .agents import Agent, begin_produce_runs, end_produce_runs, produce_runs
 from .artifacts import Artifact
 from .budget import Budget, BudgetLLM, BudgetTracker, RunOutcome, RunStats
 from .commit import Commit, Read, Write
@@ -31,9 +31,17 @@ logger = get_logger(__name__)
 #: A scheduled patch with its trigger reads and (optional) trace span.
 PatchWork = tuple[Patch, Agent, list[Read], AgentSpan | None]
 #: One agent execution result: patch (if any), the agent/event/reads that
-#: produced it, latency, and the exception if the produce raised and
-#: `isolate_errors` was set.
-AgentResult = tuple[Patch | None, Agent, Event, list[Read], float, BaseException | None]
+#: produced it, latency, the exception if the produce raised and
+#: `isolate_errors` was set, and the produces that ran (name/ops/latency).
+AgentResult = tuple[
+    Patch | None,
+    Agent,
+    Event,
+    list[Read],
+    float,
+    BaseException | None,
+    list[tuple[str, int, float]],
+]
 #: Performs one committed `PendingAction` (outbox). Called by the runtime after
 #: the intent is committed; the app performs the real I/O and returns (or
 #: raises). Must be idempotent on `idempotency_key` (§42).
@@ -650,18 +658,22 @@ class Runtime:
         """
         patches_to_apply: list[PatchWork] = []
         runs = 0
-        for patch, agent, event, reads, latency, error in results:
+        for patch, agent, event, reads, latency, error, produce_run_list in results:
             if self._budget_exhausted():
                 break
             runs += 1
             self._runs_used += 1
             if error is not None:
                 self._errors_used += 1
-                self._trace.record_span(agent, event, reads, latency, error=error)
+                self._trace.record_span(
+                    agent, event, reads, latency, error=error, produces=produce_run_list
+                )
                 continue
             if patch is None or patch.is_empty():
                 continue
-            span = self._trace.record_span(agent, event, reads, latency)
+            span = self._trace.record_span(
+                agent, event, reads, latency, produces=produce_run_list
+            )
             self._validate_patch_types(patch, agent)
             self._enforce_authorization(patch)
             patch = self._apply_guardrails(patch)
@@ -794,6 +806,7 @@ class Runtime:
         task = asyncio.current_task()
         self._trace.register_task(task, agent.name)
         effects_token = set_effects(Effects(self.context))
+        produce_runs_token = begin_produce_runs()
         slot: Effects | None = None
         patch: Patch | None = None
         error: BaseException | None = None
@@ -817,6 +830,8 @@ class Runtime:
                 if self.on_agent_error is not None:
                     self.on_agent_error(agent, event, exc)
         finally:
+            runs = produce_runs()
+            end_produce_runs(produce_runs_token)
             reset_effects(effects_token)
             self._trace.unregister_task(task)
         latency = (time.monotonic() - started) * 1000
@@ -829,7 +844,7 @@ class Runtime:
                     "error": repr(error),
                 },
             )
-            return None, agent, event, reads, latency, error
+            return None, agent, event, reads, latency, error, runs
         logger.debug(
             "agent finished",
             extra={"agent": agent.name, "latency_ms": round(latency, 2)},
@@ -843,7 +858,7 @@ class Runtime:
                 combined.merge(patch)
             combined.merge(slot.to_patch())
             patch = combined
-        return patch, agent, event, reads, latency, None
+        return patch, agent, event, reads, latency, None, runs
 
     async def arun(
         self,

{reactifact-0.15.1 → reactifact-0.15.3}/reactifact/tracing/__init__.py

@@ -11,6 +11,7 @@ from .models import (
     AgentSpan,
     ArtifactRef,
     LLMCall,
+    ProduceRun,
     RelationRef,
     RunTrace,
     Tag,
@@ -35,6 +36,7 @@ __all__ = [
     "LangfuseTracer",
     "OTLPTracer",
     "PostgresStore",
+    "ProduceRun",
     "RecordingLLM",
     "RelationRef",
     "RunTrace",

{reactifact-0.15.1 → reactifact-0.15.3}/reactifact/tracing/langfuse.py

@@ -96,6 +96,11 @@ class LangfuseTracer(Tracer):
             )
             span_start = span.started_at or run_start
             agent_span_id = _span_id(f"{trace_id}:span:{i}:{span.agent}")
+            spans.extend(
+                self._produce_spans(
+                    trace_id, agent_span_id, trace_attrs, run_start, i, span
+                )
+            )
             for j, call in enumerate(span.llm_calls):
                 spans.append(
                     self._llm_span(
@@ -145,8 +150,29 @@ class LangfuseTracer(Tracer):
                 _type_summary(span.writes),
             ),
         ]
+        if span.event_artifact_type:
+            attrs.append(
+                _attr(
+                    "langfuse.observation.metadata.event_artifact_type",
+                    span.event_artifact_type,
+                )
+            )
         if span.error:
             attrs.append(_attr("langfuse.observation.metadata.error", span.error))
+        if span.produces:
+            attrs.append(
+                _attr(
+                    "langfuse.observation.metadata.produces",
+                    [
+                        {
+                            "name": p.name,
+                            "operations": p.operations,
+                            "latency_ms": p.latency_ms,
+                        }
+                        for p in span.produces
+                    ],
+                )
+            )
         return {
             "traceId": trace_id,
             "spanId": _span_id(f"{trace_id}:span:{index}:{span.agent}"),
@@ -158,6 +184,53 @@ class LangfuseTracer(Tracer):
             "attributes": attrs,
         }
 
+    def _produce_spans(
+        self,
+        trace_id: str,
+        parent_span_id: str,
+        trace_attrs: list[dict[str, Any]],
+        run_start: datetime,
+        span_index: int,
+        span: AgentSpan,
+    ) -> list[dict[str, Any]]:
+        """One child observation per produce the agent ran, so Langfuse's
+        waterfall shows the ``Consume → Produce`` steps instead of a single
+        opaque agent span.
+
+        Produces run sequentially within an agent, so they are laid out
+        back-to-back from the span start by each one's measured latency.
+        """
+        if not span.produces:
+            return []
+        cursor = span.started_at or run_start
+        out: list[dict[str, Any]] = []
+        for k, produce in enumerate(span.produces):
+            end = cursor + timedelta(milliseconds=produce.latency_ms)
+            out.append(
+                {
+                    "traceId": trace_id,
+                    "spanId": _span_id(
+                        f"{trace_id}:produce:{span_index}:{k}:{produce.name}"
+                    ),
+                    "parentSpanId": parent_span_id,
+                    "name": produce.name,
+                    "kind": 1,
+                    "startTimeUnixNano": _unix_nanos(cursor),
+                    "endTimeUnixNano": _unix_nanos(end),
+                    "attributes": [
+                        *trace_attrs,
+                        _attr("langfuse.observation.type", "span"),
+                        _attr("langfuse.observation.metadata.agent", span.agent),
+                        _attr(
+                            "langfuse.observation.metadata.operations",
+                            produce.operations,
+                        ),
+                    ],
+                }
+            )
+            cursor = end
+        return out
+
     def _llm_span(
         self,
         trace_id: str,

{reactifact-0.15.1 → reactifact-0.15.3}/reactifact/tracing/models.py

@@ -88,11 +88,31 @@ class TagAssignment(BaseModel):
     updated_at: datetime | None = None
 
 
+class ProduceRun(BaseModel):
+    """One produce execution within an agent span (§54).
+
+    An agent runs one or more ``Produce``s per event; the span records which
+    ones actually ran and how much each contributed (``operations`` = authored
+    effect operations, so the produce that did the work is distinguishable from
+    one that merely matched the event).
+    """
+
+    name: str
+    operations: int = 0
+    latency_ms: float = 0.0
+
+
 class AgentSpan(BaseModel):
     """A single agent execution within a run (§54)."""
 
     agent: str
     event_type: str = ""
+    #: The artifact type whose change triggered this agent (its matched
+    #: ``Consume``) — e.g. ``DraftAnswer`` vs ``FinalResponse`` for an agent that
+    #: consumes both. ``event_type`` alone (created/updated) can't tell them apart.
+    event_artifact_type: str = ""
+    #: The produces that ran for this event, in execution order.
+    produces: list[ProduceRun] = Field(default_factory=list)
     reads: list[ArtifactRef] = Field(default_factory=list)
     writes: list[ArtifactRef] = Field(default_factory=list)
     relations: list[RelationRef] = Field(default_factory=list)

{reactifact-0.15.1 → reactifact-0.15.3}/reactifact/tracing/otlp.py

@@ -123,8 +123,19 @@ class OTLPTracer(Tracer):
             attr("reactifact.reads", type_summary(span.reads)),
             attr("reactifact.writes", type_summary(span.writes)),
         ]
+        if span.event_artifact_type:
+            attrs.append(
+                attr("reactifact.event_artifact_type", span.event_artifact_type)
+            )
         if span.error:
             attrs.append(attr("error.type", span.error))
+        if span.produces:
+            attrs.append(
+                attr(
+                    "reactifact.produces",
+                    ", ".join(f"{p.name}({p.operations})" for p in span.produces),
+                )
+            )
         return {
             "traceId": tid,
             "spanId": span_id(f"{tid}:span:{index}:{span.agent}"),

{reactifact-0.15.1 → reactifact-0.15.3}/reactifact/tracing/postgres.py

@@ -27,6 +27,7 @@ from .models import (
     AgentSpan,
     ArtifactRef,
     LLMCall,
+    ProduceRun,
     RelationRef,
     RunTrace,
     TagAssignment,
@@ -70,13 +71,15 @@ class PostgresStore:
                         run_id TEXT NOT NULL REFERENCES runs(id),
                         agent TEXT NOT NULL,
                         event_type TEXT NOT NULL DEFAULT '',
+                        event_artifact_type TEXT NOT NULL DEFAULT '',
                         latency_ms REAL NOT NULL DEFAULT 0,
                         error TEXT,
                         started_at TIMESTAMPTZ,
                         reads JSONB NOT NULL DEFAULT '[]',
                         writes JSONB NOT NULL DEFAULT '[]',
                         relations JSONB NOT NULL DEFAULT '[]',
-                        llm_calls JSONB NOT NULL DEFAULT '[]'
+                        llm_calls JSONB NOT NULL DEFAULT '[]',
+                        produces JSONB NOT NULL DEFAULT '[]'
                     )
                     """
                 )
@@ -122,6 +125,14 @@ class PostgresStore:
                 await cur.execute(
                     "ALTER TABLE spans ADD COLUMN IF NOT EXISTS started_at TIMESTAMPTZ"
                 )
+                await cur.execute(
+                    "ALTER TABLE spans ADD COLUMN IF NOT EXISTS "
+                    "produces JSONB NOT NULL DEFAULT '[]'"
+                )
+                await cur.execute(
+                    "ALTER TABLE spans ADD COLUMN IF NOT EXISTS "
+                    "event_artifact_type TEXT NOT NULL DEFAULT ''"
+                )
             await conn.commit()
         finally:
             await conn.close()
@@ -159,13 +170,15 @@ class PostgresStore:
                     if span_started is not None and span_started.tzinfo is None:
                         span_started = span_started.replace(tzinfo=UTC)
                     await cur.execute(
-                        "INSERT INTO spans (run_id, agent, event_type, latency_ms, error, "
-                        "started_at, reads, writes, relations, llm_calls) "
-                        "VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)",
+                        "INSERT INTO spans (run_id, agent, event_type, event_artifact_type, "
+                        "latency_ms, error, started_at, reads, writes, relations, llm_calls, "
+                        "produces) "
+                        "VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)",
                         (
                             trace.id,
                             span.agent,
                             span.event_type,
+                            span.event_artifact_type,
                             span.latency_ms,
                             span.error,
                             span_started,
@@ -181,6 +194,9 @@ class PostgresStore:
                             psycopg.types.json.Jsonb(
                                 [c.model_dump(mode="json") for c in span.llm_calls]
                             ),
+                            psycopg.types.json.Jsonb(
+                                [p.model_dump(mode="json") for p in span.produces]
+                            ),
                         ),
                     )
             await conn.commit()
@@ -387,8 +403,8 @@ class PostgresStore:
                 if row is None:
                     return None
                 await cur.execute(
-                    "SELECT agent, event_type, latency_ms, error, started_at, "
-                    "reads, writes, relations, llm_calls "
+                    "SELECT agent, event_type, event_artifact_type, latency_ms, error, "
+                    "started_at, reads, writes, relations, llm_calls, produces "
                     "FROM spans WHERE run_id = %s ORDER BY id",
                     (trace_id,),
                 )
@@ -408,13 +424,15 @@ class PostgresStore:
             AgentSpan(
                 agent=r[0],
                 event_type=r[1],
-                latency_ms=r[2],
-                error=r[3],
-                started_at=r[4],
-                reads=[ArtifactRef(**d) for d in r[5]],
-                writes=[ArtifactRef(**d) for d in r[6]],
-                relations=[RelationRef(**d) for d in r[7]],
-                llm_calls=[LLMCall(**d) for d in r[8]],
+                event_artifact_type=r[2],
+                latency_ms=r[3],
+                error=r[4],
+                started_at=r[5],
+                reads=[ArtifactRef(**d) for d in r[6]],
+                writes=[ArtifactRef(**d) for d in r[7]],
+                relations=[RelationRef(**d) for d in r[8]],
+                llm_calls=[LLMCall(**d) for d in r[9]],
+                produces=[ProduceRun(**d) for d in r[10]],
             )
             for r in span_rows
         ]