feat: implement per-event model attribution for enhanced event tracking

docs/adr/0028-session-stamped-events-and-scoped-recall.md

@@ -1,4 +1,4 @@
-# ADR-0028: Session-Stamped Events and Run-Scoped Memory Recall
+# ADR-0028: Session-Stamped, Model-Attributed Events and Run-Scoped Recall
 
 ## Status
 
@@ -24,6 +24,12 @@ and scoped the **UI** to one run. Three gaps remained on the data/context side:
 Additionally, the session id originates in `localStorage` — untrusted client input —
 and reached the ledger unvalidated.
 
+4. **No per-event model attribution.** `run.started.cast` recorded the *intended*
+   binding per agent, but no event recorded the model that *actually* produced it —
+   so "which model said this line" (and "which model won") was an inference from the
+   cast map, not a fact, and env overrides / endpoint fallbacks were invisible after
+   the fact.
+
 ## Decision
 
 - **`Event.session_id: str | None` on the envelope.** Stamped by the Conductor at
@@ -46,12 +52,32 @@ and reached the ledger unvalidated.
   search, free for callers). `session_id` rides in index metadata for forensics.
 - **RunIndex prefers the envelope.** `RunSummary.session_id` folds from
   `event.session_id` first, payload copy second.
+- **Per-event model attribution.** `Event.model_profile` (the route key the agent
+  asked for — tier or endpoint key) and `Event.model_id` (the concrete model that
+  ran). The agent captures both when it resolves its provider
+  (`ModelProvider.model_id` unifies the live gateway's `model` and the stub's
+  `variant`) and stamps them on the event it emits; handler subclasses inherit it
+  via `super().act()`. Scenario/genesis/lifecycle events stay `None`. mem0 metadata
+  carries them; the Show's cast card prefers the *actual* model once a line is
+  spoken (`short_model_name`), falling back to the intended binding.
+- **DB structure: columns + indexes, no new tables.** The queryable envelope facts
+  (`session_id`, `model_profile`, `model_id`) are typed columns, not buried JSON —
+  the right denormalization for an *immutable* log. We add a composite
+  `(run_id, offset)` index (the hottest read — `events_for_run` ordered by offset)
+  plus single indexes on `session_id` and `model_id`. We deliberately **do not**
+  add normalized/lookup tables or foreign keys: an append-only log never mutates,
+  so FKs buy no integrity and only cost joins. A materialized `runs` read-model
+  remains a deferred option (rebuildable cache) for *when* folding events is
+  measurably slow or real accounts arrive — not now.
 
 ## Consequences
 
-- Every action is directly filterable by session in SQL (`WHERE session_id = ?`,
-  indexed), in mem0 metadata, and in exported traces (the JSONL dump inherits the
-  envelope field for free).
+- Every action is directly filterable by session **and by model** in SQL
+  (`WHERE session_id = ?`, `WHERE model_id = ?`, both indexed), in mem0 metadata,
+  and in exported traces (the JSONL dump inherits the envelope fields for free).
+- "Which model won / spoke this line" is now a recorded fact, not an inference —
+  useful for sponsor-track receipts (which model played which part) and the demo's
+  per-card model badge.
 - Prompts are hermetic per run: neither the episodic window, nor salience ranking,
   nor semantic recall can surface another run's text. Verified by probe-agent and
   scoped-search tests.

src/agents/base.py

@@ -115,6 +115,11 @@ class ManifestAgent(Agent):
         self.memory_index = memory_index
         self._reflection_tracker: ReflectionTracker | None = None
         self.last_usage: dict[str, int] = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
+        # The model behind the most recent generation, captured when the provider is
+        # resolved and stamped onto the event in act()/reflection — so each line in the
+        # ledger records the model that actually produced it, not just the intended one.
+        self.last_model_profile: str | None = None
+        self.last_model_id: str | None = None
 
     @property
     def name(self) -> str:  # type: ignore[override]
@@ -175,6 +180,8 @@ class ManifestAgent(Agent):
             kind=parsed["kind"],
             actor=self.manifest.name,
             payload={k: v for k, v in parsed.items() if k != "kind"},
+            model_profile=self.last_model_profile,
+            model_id=self.last_model_id,
         )
 
     @staticmethod
@@ -237,6 +244,7 @@ class ManifestAgent(Agent):
         """
         wants_thought = bool(extra_fields and "thought" in extra_fields)
         provider = self.router.for_profile(self._route_key)
+        self._record_model(provider)
         with obs.span("agent.resolve", **{"mal.agent": role, "mal.profile": self._route_key}):
             if hasattr(provider, "complete_structured"):
                 model = build_output_model(allowed, extra_fields)
@@ -308,11 +316,18 @@ class ManifestAgent(Agent):
     def _complete(self, role: str, prompt: str) -> str:
         """Route to the provider for this agent's profile and record token usage."""
         provider = self.router.for_profile(self._route_key)
+        self._record_model(provider)
         raw = provider.complete(role, prompt)
         self.last_usage = dict(provider.last_usage)
         self._guard_model_error(role, raw)
         return raw
 
+    def _record_model(self, provider) -> None:
+        """Remember the model behind the current generation so the emitted event can
+        record it (the route key asked for + the concrete model that actually ran)."""
+        self.last_model_profile = self._route_key
+        self.last_model_id = getattr(provider, "model_id", "") or None
+
     # ── memory ──────────────────────────────────────────────────────────────
 
     def _recall(self, turn: int, projection: StageProjection, recent_events: tuple[Event, ...]) -> str:
@@ -349,6 +364,8 @@ class ManifestAgent(Agent):
             kind=_REFLECTION_KIND,
             actor=self.manifest.name,
             payload={k: v for k, v in parsed.items() if k != "kind"},
+            model_profile=self.last_model_profile,
+            model_id=self.last_model_id,
         )
 
     # ── output authority ──────────────────────────────────────────────────────

src/core/events.py

@@ -104,6 +104,15 @@ class Event(BaseModel):
     # headless/legacy events.  An OPTIONAL envelope field — additive, so
     # schema_version stays 1 and old rows load with session_id=None.
     session_id: str | None = None
+    # Which model produced this event, set by the agent at generation time:
+    #   model_profile — the route key the agent asked for (tiny/fast/balanced/
+    #                    strong, or an explicit catalogue endpoint key, ADR-0022)
+    #   model_id       — the concrete model that actually ran (e.g.
+    #                    "openai/openbmb/MiniCPM4.1-8B", or "stub:fast" offline)
+    # Both None for events with no model behind them (genesis, user.injected,
+    # run.started/finished).  Additive envelope fields — schema_version stays 1.
+    model_profile: str | None = None
+    model_id: str | None = None
 
     @field_validator("kind")
     @classmethod

src/core/memory_index.py

@@ -351,6 +351,8 @@ def _event_metadata(event: Event) -> dict:
         "created_at": event.created_at.isoformat(),
         "schema_version": event.schema_version,
         "session_id": event.session_id,
+        "model_profile": event.model_profile,
+        "model_id": event.model_id,
     }
 
 
@@ -368,6 +370,8 @@ def _event_from_metadata(metadata: dict | None) -> Event | None:
             payload=dict(metadata.get("payload") or {}),
             schema_version=int(metadata.get("schema_version", 1)),
             session_id=metadata.get("session_id") or None,
+            model_profile=metadata.get("model_profile") or None,
+            model_id=metadata.get("model_id") or None,
         )
     except (KeyError, ValueError, TypeError):  # pragma: no cover - defensive
         return None

src/core/sqlalchemy_ledger.py

@@ -70,6 +70,7 @@ class SqlAlchemyLedger(Ledger):
         from sqlalchemy import (
             Column,
             DateTime,
+            Index,
             Integer,
             MetaData,
             String,
@@ -97,6 +98,11 @@ class SqlAlchemyLedger(Ledger):
             Column("created_at", DateTime(timezone=True), nullable=False),
             Column("schema_version", Integer, nullable=False, server_default="1"),
             Column("session_id", String, nullable=True, index=True),
+            # Which model produced the event (set by the agent; ADR-0028).
+            Column("model_profile", String, nullable=True),
+            Column("model_id", String, nullable=True, index=True),
+            # Composite index for the hottest read: events of one run, by offset.
+            Index("ix_events_run_offset", "run_id", "offset"),
         )
         self._metadata.create_all(self._engine)
 
@@ -124,6 +130,8 @@ class SqlAlchemyLedger(Ledger):
                         created_at=_aware(event.created_at),
                         schema_version=event.schema_version,
                         session_id=event.session_id,
+                        model_profile=event.model_profile,
+                        model_id=event.model_id,
                     )
                 )
             self._cache.append(event)
@@ -243,6 +251,8 @@ class SqlAlchemyLedger(Ledger):
             created_at=created_at,
             schema_version=row["schema_version"],
             session_id=row.get("session_id"),
+            model_profile=row.get("model_profile"),
+            model_id=row.get("model_id"),
         )
 
 

src/core/sqlite_ledger.py

@@ -57,12 +57,17 @@ class SQLiteLedger(Ledger):
                 payload         TEXT    NOT NULL,
                 created_at      TEXT    NOT NULL,
                 schema_version  INTEGER NOT NULL DEFAULT 1,
-                session_id      TEXT
+                session_id      TEXT,
+                model_profile   TEXT,
+                model_id        TEXT
             );
-            CREATE INDEX IF NOT EXISTS idx_run_id ON events(run_id);
-            CREATE INDEX IF NOT EXISTS idx_kind   ON events(kind);
-            CREATE INDEX IF NOT EXISTS idx_actor  ON events(actor);
+            -- Composite (run_id, offset) serves the hottest read — events_for_run
+            -- ordered by offset — from one index, instead of a run_id seek + sort.
+            CREATE INDEX IF NOT EXISTS idx_run_offset ON events(run_id, offset);
+            CREATE INDEX IF NOT EXISTS idx_kind       ON events(kind);
+            CREATE INDEX IF NOT EXISTS idx_actor      ON events(actor);
             CREATE INDEX IF NOT EXISTS idx_session_id ON events(session_id);
+            CREATE INDEX IF NOT EXISTS idx_model_id   ON events(model_id);
         """)
         self._conn.commit()
 
@@ -74,8 +79,9 @@ class SQLiteLedger(Ledger):
         try:
             self._conn.execute(
                 "INSERT INTO events "
-                "(id, run_id, turn, kind, actor, payload, created_at, schema_version, session_id) "
-                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                "(id, run_id, turn, kind, actor, payload, created_at, schema_version, "
+                "session_id, model_profile, model_id) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
                 (
                     event.id,
                     event.run_id,
@@ -86,6 +92,8 @@ class SQLiteLedger(Ledger):
                     event.created_at.isoformat(),
                     event.schema_version,
                     event.session_id,
+                    event.model_profile,
+                    event.model_id,
                 ),
             )
             self._conn.commit()
@@ -122,7 +130,9 @@ class SQLiteLedger(Ledger):
         ledger = cls(path)
         return ledger
 
-    _SELECT_COLS = "id, run_id, turn, kind, actor, payload, created_at, schema_version, session_id"
+    _SELECT_COLS = (
+        "id, run_id, turn, kind, actor, payload, created_at, schema_version, session_id, model_profile, model_id"
+    )
 
     @staticmethod
     def _row_to_event(row: tuple) -> Event:
@@ -142,6 +152,8 @@ class SQLiteLedger(Ledger):
             created_at=created_at,
             schema_version=row[7],
             session_id=row[8],
+            model_profile=row[9],
+            model_id=row[10],
         )
 
     def _load_cache(self) -> None:

src/models/provider.py

@@ -41,6 +41,16 @@ class ModelProvider:
     def complete(self, role: str, prompt: str) -> str:
         raise NotImplementedError
 
+    @property
+    def model_id(self) -> str:
+        """The concrete model this provider runs — for per-event attribution.
+
+        Uniform across backends: the live gateway sets ``self.model`` (e.g.
+        ``openai/openbmb/MiniCPM4.1-8B``); the offline stub sets ``self.variant``
+        (e.g. ``stub:fast``).  Empty string when neither is set.
+        """
+        return str(getattr(self, "model", None) or getattr(self, "variant", None) or "")
+
     @property
     def last_usage(self) -> dict[str, int]:
         """Token usage of the most recent complete() call.

src/ui/fishbowl/adapter.py

@@ -98,6 +98,20 @@ def model_label(endpoint: str) -> str:
     return short or endpoint
 
 
+def short_model_name(model_id: str) -> str:
+    """Prettify a *concrete* resolved model string for the card's model badge.
+
+    Unlike :func:`model_label` (which resolves a catalogue *key*), this takes the
+    model that actually ran, recorded on the event envelope (ADR-0028): a served id
+    like ``openai/openbmb/MiniCPM4.1-8B`` → ``MiniCPM4.1-8B``, or the offline
+    ``stub:fast`` left as-is.  Empty input degrades to ``""`` so callers fall back.
+    """
+    text = (model_id or "").strip()
+    if not text or text.startswith("stub:"):
+        return text
+    return text.rsplit("/", 1)[-1] or text
+
+
 def agent_model(manifest) -> str:
     """The model an agent is actually running, for the Show's model badge.
 

src/ui/fishbowl/assets/styles.css

@@ -677,14 +677,29 @@ footer { display: none !important; }
 .fishbowl .mind.rattled .mind-front { border-color: var(--coral); animation: cardShake 0.4s ease-in-out infinite; }
 @keyframes cardShake { 0%,100% { transform: translateX(0); } 25% { transform: translateX(-2px); } 75% { transform: translateX(2px); } }
 
-.fishbowl .mind-head { display: grid; grid-template-columns: auto 1fr auto; gap: 10px; align-items: center; padding-bottom: 11px; border-bottom: 1px solid var(--line-soft); }
+/* head: avatar · identity · the live mood pill (the one datum that changes turn to turn) */
+.fishbowl .mind-head { display: grid; grid-template-columns: auto 1fr auto; gap: 11px; align-items: center; padding-bottom: 10px; border-bottom: 1px solid var(--line-soft); }
 .fishbowl .mind-id { min-width: 0; }
-.fishbowl .mind-name { font-size: 14px; font-weight: 700; letter-spacing: 0.06em; color: var(--ink); display: flex; align-items: center; gap: 7px; }
+.fishbowl .mind-name { font-size: 14.5px; font-weight: 700; letter-spacing: 0.04em; color: var(--ink); line-height: 1.15; display: flex; align-items: center; gap: 7px; }
 .fishbowl .mic { color: var(--coral); font-size: 9px; animation: livePulse 0.9s ease-in-out infinite; }
-.fishbowl .mind-arch { font-size: 10.5px; color: var(--ink-dim); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
-.fishbowl .mind-meta { display: flex; flex-direction: column; align-items: flex-end; gap: 4px; }
-.fishbowl .mind-model { display: flex; align-items: center; gap: 5px; font-size: 9.5px; letter-spacing: 0.04em; color: var(--ink-mid); }
-.fishbowl .mind-mood { font-family: var(--font-display); font-size: 8.5px; letter-spacing: 0.12em; text-transform: uppercase; }
+.fishbowl .mind-arch { margin-top: 3px; font-size: 10.5px; color: var(--ink-dim); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+
+/* mood pill — colour-coded by mood, with a glowing status dot; reads at a glance */
+.fishbowl .mind-mood-pill { display: inline-flex; align-items: center; gap: 6px; padding: 3px 9px 3px 8px; border-radius: 999px; border: 1px solid color-mix(in oklab, var(--mc) 50%, transparent); background: color-mix(in oklab, var(--mc) 13%, transparent); white-space: nowrap; align-self: start; }
+.fishbowl .mmp-dot { width: 6px; height: 6px; border-radius: 50%; background: var(--mc); box-shadow: 0 0 7px var(--mc); flex: none; }
+.fishbowl .mmp-label { font-family: var(--font-display); font-size: 8px; font-weight: 600; letter-spacing: 0.12em; text-transform: uppercase; color: var(--mc); }
+/* a panicking mind throbs its pill so the leak is impossible to miss */
+@media (prefers-reduced-motion: no-preference) {
+  .fishbowl .mind.rattled .mmp-dot { animation: livePulse 0.7s ease-in-out infinite; }
+}
+
+/* model meta-strip — provenance gets its own labelled row, so a long served id stays legible */
+.fishbowl .mind-meta-strip { display: flex; align-items: center; justify-content: space-between; gap: 8px; margin-top: 10px; padding: 6px 10px; border: 1px solid var(--line-soft); border-radius: var(--r); background: rgba(3,12,18,0.55); }
+.fishbowl .mms-model { display: flex; align-items: center; gap: 7px; min-width: 0; }
+.fishbowl .mms-model .tier-dot { width: 7px; height: 7px; }
+.fishbowl .mms-name { font-family: var(--font-display); font-size: 10px; letter-spacing: 0.01em; color: var(--ink-mid); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.fishbowl .mms-tier { font-family: var(--font-display); font-size: 8px; letter-spacing: 0.16em; text-transform: uppercase; color: var(--ink-faint); flex: none; }
+.fishbowl .mms-tier:empty { display: none; }
 
 .fishbowl .bubbles { display: flex; flex-direction: column; gap: 8px; padding-top: 11px; }
 .fishbowl .bubble { border-radius: var(--r); padding: 9px 11px 10px; position: relative; }
@@ -914,9 +929,6 @@ footer { display: none !important; }
   0%, 100% { box-shadow: 0 0 18px color-mix(in oklab, var(--ac) 32%, transparent); }
   50% { box-shadow: 0 0 30px color-mix(in oklab, var(--ac) 55%, transparent); }
 }
-/* tighten the head so name + model never feel cramped at card width */
-.fishbowl .mind-name { line-height: 1.2; }
-.fishbowl .mind-arch { margin-top: 2px; }
 .fishbowl .bubble.said { box-shadow: inset 0 0 0 1px var(--line-soft); }
 
 /* ---- SPLIT (Lab Readout): let the omniscient table flow full-width ---- */

src/ui/fishbowl/render/mindcard.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 
 import html
 
-from src.ui.fishbowl.adapter import TIER_COLOR
+from src.ui.fishbowl.adapter import TIER_COLOR, mood_color
 from src.ui.fishbowl.render.avatar import agent_color, agent_color_dim, render_avatar
 
 __all__ = ["render_mindcard"]
@@ -74,8 +74,13 @@ def render_mindcard(
     # to the profile tier name when it routes purely by profile.
     model = html.escape(str(card.get("model") or card.get("model_profile", "")))
     mood_label = html.escape(str(card.get("mood_label", "")))
+    mood_col = mood_color(mood)
     tier = card.get("tier", "mid")
     tier_color = TIER_COLOR.get(tier, "var(--cyan)")
+    # The profile label (tiny/fast/balanced/strong) sits beside the model name as the
+    # human-chosen tier; the concrete served id rides the tooltip so a long name stays short.
+    profile = html.escape(str(card.get("model_profile", "")))
+    model_title = html.escape(str(card.get("model_id") or card.get("model") or profile))
 
     mic = '<span class="mic">●</span>' if speaking else ""
 
@@ -104,11 +109,18 @@ def render_mindcard(
         f'<div class="mind-name disp">{name}{mic}</div>'
         f'<div class="mind-arch">{archetype}</div>'
         "</div>"
-        '<div class="mind-meta">'
-        f'<span class="mind-model" title="model"><span class="tier-dot" style="background:{tier_color}"></span>{model}</span>'
-        f'<span class="mind-mood">{mood_label}</span>'
+        f'<div class="mind-mood-pill" style="--mc:{mood_col}">'
+        '<span class="mmp-dot"></span>'
+        f'<span class="mmp-label">{mood_label}</span>'
         "</div>"
         "</div>"
+        f'<div class="mind-meta-strip" title="{model_title}">'
+        '<span class="mms-model">'
+        f'<span class="tier-dot" style="background:{tier_color}"></span>'
+        f'<span class="mms-name">{model}</span>'
+        "</span>"
+        f'<span class="mms-tier">{profile}</span>'
+        "</div>"
         '<div class="bubbles">'
         '<div class="bubble said">'
         '<span class="bub-tag">said aloud</span>'

src/ui/fishbowl/view_model.py

@@ -27,6 +27,7 @@ from src.ui.fishbowl.adapter import (
     mood_label,
     normalize_mood,
     scenario_voice,
+    short_model_name,
 )
 from src.ui.fishbowl.cast_state import derive_cast_state
 
@@ -65,6 +66,13 @@ def view_model_at(
     names = [m.name for m in cast]
     states = derive_cast_state(prefix, names)
 
+    # The model that *actually* produced each actor's most recent line (envelope,
+    # ADR-0028) — overrides the card's intended binding once a line has been spoken.
+    actual_model: dict[str, str] = {}
+    for e in prefix:
+        if e.model_id and e.actor in names:
+            actual_model[e.actor] = e.model_id
+
     speaking_id: str | None = None
     if k > 0:
         head = events[k - 1]
@@ -82,7 +90,9 @@ def view_model_at(
                 "hue": agent_hue(m),
                 "role": m.role,
                 "model_profile": m.model_profile,
-                "model": agent_model(m),
+                # Prefer the model that actually ran; fall back to the intended binding.
+                "model": short_model_name(actual_model[m.name]) if m.name in actual_model else agent_model(m),
+                "model_id": actual_model.get(m.name),
                 "model_endpoint": getattr(m, "model_endpoint", None),
                 "tier": agent_tier(m),
                 "said": st.said,

tests/test_model_attribution.py

@@ -0,0 +1,90 @@
+"""Per-event model attribution (ADR-0028): each agent line records the model that
+actually produced it — the route key it asked for (``model_profile``) and the
+concrete model that ran (``model_id``) — and that survives the SQL round-trip and
+surfaces on the Show's cast cards.
+
+No mocks: the deterministic stub drives the cast, so ``model_id`` reads ``stub:<tier>``
+offline — the same envelope a live Modal/HF run fills with the served model id.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from src.core.ledger_factory import make_ledger
+from src.core.registry import default_registry
+from src.ui.fishbowl.adapter import short_model_name
+from src.ui.fishbowl.session import FishbowlSession
+
+
+@pytest.fixture
+def shared_db(monkeypatch, tmp_path):
+    monkeypatch.setenv("DATABASE_URL", f"sqlite:///{tmp_path / 'events.db'}")
+
+
+def _first_scenario() -> str:
+    return next(iter(default_registry().scenarios))
+
+
+def _run_with_lines(session_id: str = "u1") -> FishbowlSession:
+    session = FishbowlSession(_first_scenario())
+    session.reset("seed", session_id=session_id)
+    for _ in range(session.autoplay_tick_cap):
+        events = session.events
+        if sum(1 for e in events if e.model_id) >= 2:
+            break
+        try:
+            if not session.step_one():
+                break
+        except Exception:
+            break
+    return session
+
+
+class TestShortModelName:
+    def test_strips_org_prefix(self):
+        assert short_model_name("openai/openbmb/MiniCPM4.1-8B") == "MiniCPM4.1-8B"
+        assert short_model_name("google/gemma-4-12B") == "gemma-4-12B"
+
+    def test_leaves_stub_and_empty_alone(self):
+        assert short_model_name("stub:fast") == "stub:fast"
+        assert short_model_name("") == ""
+        assert short_model_name(None) == ""  # type: ignore[arg-type]
+
+
+class TestEventModelAttribution:
+    def test_agent_events_record_profile_and_model(self, shared_db):
+        session = _run_with_lines()
+        produced = [e for e in session.events if e.model_id]
+        assert produced, "stub cast should have produced at least one model-backed line"
+        for e in produced:
+            # Offline, the route key is a tier and the model is its stub.
+            assert e.model_profile  # the route key the agent asked for
+            assert e.model_id == f"stub:{e.model_profile}" or e.model_id.startswith("stub:")
+
+    def test_scenario_and_genesis_events_have_no_model(self, shared_db):
+        session = _run_with_lines()
+        for e in session.events:
+            if e.kind in ("run.started", "run.finished") or e.actor == "conductor":
+                assert e.model_id is None and e.model_profile is None
+
+    def test_model_attribution_survives_sql_round_trip(self, shared_db):
+        session = _run_with_lines()
+        run_id = session.conductor.run_id
+        # A fresh ledger connection re-reads rows from disk — envelope must persist.
+        reread = make_ledger().events_for_run(run_id)
+        produced = [e for e in reread if e.model_id]
+        assert produced
+        assert all(e.model_profile for e in produced)
+
+
+class TestCardSurfacesActualModel:
+    def test_card_model_reflects_the_model_that_ran(self, shared_db):
+        session = _run_with_lines()
+        vm = session.snapshot()
+        spoken_actors = {e.actor for e in session.events if e.model_id}
+        cards = {c["id"]: c for c in vm["cast"]}
+        # Every actor that produced a line shows its actual (stub) model on the card.
+        for actor in spoken_actors & cards.keys():
+            assert cards[actor]["model_id"] is not None
+            assert cards[actor]["model"] == short_model_name(cards[actor]["model_id"])