specsmith 0.10.0.dev238__tar.gz → 0.10.0.dev239__tar.gz

{specsmith-0.10.0.dev238/src/specsmith.egg-info → specsmith-0.10.0.dev239}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.10.0.dev238
+Version: 0.10.0.dev239
 Summary: Applied Epistemic Engineering toolkit — AEE agent sessions, execution profiles, FPGA/HDL governance, tool installer, 50+ CLI commands.
 Author: BitConcepts
 License-Expression: MIT
@@ -88,6 +88,25 @@ specsmith treats belief systems like code: codable, testable, and deployable. It
 epistemically-governed projects, stress-tests requirements as BeliefArtifacts, runs
 cryptographically-sealed trace vaults, and orchestrates AI agents under formal AEE governance.
 
+**0.10.0 — Multi-Agent + BYOE.** A `/plan` goes to the architect, `/fix`
+goes to the coder, `/review` goes to a reviewer that runs on a different
+model family. Each *profile* is a `(provider, model, endpoint?, fallback_chain)`
+bundle stored in `~/.specsmith/agents.json`; an *activity routing table*
+maps slash commands and AEE phases to profiles; **BYOE endpoints**
+(`~/.specsmith/endpoints.json`) let you point a profile at any
+OpenAI-v1-compatible backend you self-host (vLLM, llama.cpp `server`,
+LM Studio, TGI, ...). Cross-family **diversity guard**, capability
+filtering, transient-failure fallback chains, and TraceVault decision
+seals on every `/agent` pin are wired in by default. See
+[`docs/site/agents.md`](docs/site/agents.md) for the five-minute walkthrough.
+
+```bash
+specsmith agents preset apply default       # frontier coder + cross-family reviewer
+specsmith endpoints add --id home-vllm \
+  --base-url http://10.0.0.4:8000/v1 --auth bearer-keyring
+specsmith run --agent opus-reviewer         # one-shot per-session pin
+```
+
 It also co-installs the standalone `epistemic` Python library for direct use in any project:
 
 ```python

{specsmith-0.10.0.dev238 → specsmith-0.10.0.dev239}/README.md

@@ -16,6 +16,25 @@ specsmith treats belief systems like code: codable, testable, and deployable. It
 epistemically-governed projects, stress-tests requirements as BeliefArtifacts, runs
 cryptographically-sealed trace vaults, and orchestrates AI agents under formal AEE governance.
 
+**0.10.0 — Multi-Agent + BYOE.** A `/plan` goes to the architect, `/fix`
+goes to the coder, `/review` goes to a reviewer that runs on a different
+model family. Each *profile* is a `(provider, model, endpoint?, fallback_chain)`
+bundle stored in `~/.specsmith/agents.json`; an *activity routing table*
+maps slash commands and AEE phases to profiles; **BYOE endpoints**
+(`~/.specsmith/endpoints.json`) let you point a profile at any
+OpenAI-v1-compatible backend you self-host (vLLM, llama.cpp `server`,
+LM Studio, TGI, ...). Cross-family **diversity guard**, capability
+filtering, transient-failure fallback chains, and TraceVault decision
+seals on every `/agent` pin are wired in by default. See
+[`docs/site/agents.md`](docs/site/agents.md) for the five-minute walkthrough.
+
+```bash
+specsmith agents preset apply default       # frontier coder + cross-family reviewer
+specsmith endpoints add --id home-vllm \
+  --base-url http://10.0.0.4:8000/v1 --auth bearer-keyring
+specsmith run --agent opus-reviewer         # one-shot per-session pin
+```
+
 It also co-installs the standalone `epistemic` Python library for direct use in any project:
 
 ```python

{specsmith-0.10.0.dev238 → specsmith-0.10.0.dev239}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specsmith"
-version = "0.10.0.dev238"
+version = "0.10.0.dev239"
 description = "Applied Epistemic Engineering toolkit — AEE agent sessions, execution profiles, FPGA/HDL governance, tool installer, 50+ CLI commands."
 readme = "README.md"
 license = "MIT"

{specsmith-0.10.0.dev238 → specsmith-0.10.0.dev239}/src/specsmith/agent/chat_runner.py

@@ -53,6 +53,14 @@ class ChatRunResult:
     files_changed: list[str] = field(default_factory=list)
     verdict: VerifierVerdict | None = None
     raw_text: str = ""
+    # C1: per-turn token + cost accounting. Populated by the provider
+    # driver when it can read counters from the response (Ollama and
+    # Anthropic both expose them). Falls back to a deterministic char-
+    # based heuristic so the TokenMeter chip is never zero on Ollama or
+    # OpenAI-compat endpoints that don't surface usage in streaming mode.
+    tokens_in: int = 0
+    tokens_out: int = 0
+    cost_usd: float = 0.0
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -61,6 +69,9 @@ class ChatRunResult:
             "files_changed": list(self.files_changed),
             "confidence": self.verdict.confidence if self.verdict else 0.0,
             "equilibrium": self.verdict.equilibrium if self.verdict else False,
+            "tokens_in": int(self.tokens_in),
+            "tokens_out": int(self.tokens_out),
+            "cost_usd": float(self.cost_usd),
         }
 
 
@@ -103,44 +114,99 @@ def run_chat(
             endpoint = None
         if endpoint is not None:
             try:
-                full_text = _run_openai_compat(messages, emitter, msg_block, endpoint=endpoint)
+                full_text, usage = _run_openai_compat(
+                    messages, emitter, msg_block, endpoint=endpoint
+                )
             except Exception:  # noqa: BLE001 - degrade to auto-detect
-                full_text = None
+                full_text, usage = None, _UsageDelta()
             if full_text is not None:
-                return _finalize(full_text, "openai_compat", project_dir, confidence_target)
+                return _finalize(
+                    full_text,
+                    "openai_compat",
+                    project_dir,
+                    confidence_target,
+                    messages=messages,
+                    usage=usage,
+                )
 
     # Order matters: Ollama first because it's local-first and free.
     for provider in (_run_ollama, _run_anthropic, _run_openai, _run_gemini):
         try:
-            full_text = provider(messages, emitter, msg_block)
+            full_text, usage = provider(messages, emitter, msg_block)
         except Exception:  # noqa: BLE001 - any failure → next provider
             continue
         if full_text is None:
             continue
-        return _finalize(full_text, provider.__name__, project_dir, confidence_target)
+        return _finalize(
+            full_text,
+            provider.__name__,
+            project_dir,
+            confidence_target,
+            messages=messages,
+            usage=usage,
+        )
     return None
 
 
+@dataclass
+class _UsageDelta:
+    """Per-turn token + cost counters reported by a provider driver.
+
+    All fields default to ``0`` so callers can construct a zero-value
+    instance without caring whether the provider supports usage tracking.
+    """
+
+    tokens_in: int = 0
+    tokens_out: int = 0
+    cost_usd: float = 0.0
+
+
 def _finalize(
     full_text: str,
     provider_fn_name: str,
     project_dir: Path,
     confidence_target: float,
+    *,
+    messages: list[dict[str, str]] | None = None,
+    usage: _UsageDelta | None = None,
 ) -> ChatRunResult:
     sections = _parse_output_contract(full_text)
     files_changed = _split_files_list(sections.get("files_changed", ""))
     report = report_from_chat_sections(sections, files_changed=files_changed)
     verdict = score(report, confidence_target=confidence_target)
     summary = (sections.get("plan") or full_text.strip()[:200]).strip() or verdict.summary
+
+    # C1: when the provider didn't report exact counts, estimate from text.
+    # The four-chars-per-token rule of thumb is OpenAI's published guidance
+    # and matches Ollama / Anthropic / Gemini within ~10% across the model
+    # families we ship today — close enough for the TokenMeter chip and
+    # the ``credits record`` ledger event.
+    if usage is None:
+        usage = _UsageDelta()
+    if usage.tokens_in == 0 and messages is not None:
+        usage.tokens_in = _estimate_tokens("\n".join(m.get("content", "") for m in messages))
+    if usage.tokens_out == 0:
+        usage.tokens_out = _estimate_tokens(full_text)
+
     return ChatRunResult(
         provider=provider_fn_name.removeprefix("_run_"),
         summary=summary,
         files_changed=files_changed,
         verdict=verdict,
         raw_text=full_text,
+        tokens_in=int(usage.tokens_in),
+        tokens_out=int(usage.tokens_out),
+        cost_usd=float(usage.cost_usd),
     )
 
 
+def _estimate_tokens(text: str) -> int:
+    """Rough char→token heuristic (4 chars/token, floor at 1 if non-empty)."""
+    if not text:
+        return 0
+    return max(1, len(text) // 4)
+
+
 # ---------------------------------------------------------------------------
 # Provider drivers — each returns the full assembled text or None
 # ---------------------------------------------------------------------------
@@ -150,13 +216,14 @@ def _run_ollama(
     messages: list[dict[str, str]],
     emitter: EventEmitter,
     block_id: str,
-) -> str | None:
+) -> tuple[str | None, _UsageDelta]:
     """Stream from a local Ollama daemon using only stdlib."""
     host = os.environ.get("OLLAMA_HOST", DEFAULT_OLLAMA_HOST).rstrip("/")
     model = os.environ.get("SPECSMITH_OLLAMA_MODEL", DEFAULT_OLLAMA_MODEL)
+    usage = _UsageDelta()
 
     if not _ollama_alive(host):
-        return None
+        return None, usage
 
     payload = json.dumps({"model": model, "messages": messages, "stream": True}).encode("utf-8")
     req = Request(  # noqa: S310 - URL is a hardcoded localhost default
@@ -181,8 +248,13 @@ def _run_ollama(
                 emitter.token(block_id, chunk)
                 pieces.append(chunk)
             if obj.get("done"):
+                # C1: Ollama exposes prompt_eval_count + eval_count on the
+                # final ``done`` message. Cost is zero for local models.
+                usage.tokens_in = int(obj.get("prompt_eval_count") or 0)
+                usage.tokens_out = int(obj.get("eval_count") or 0)
+                usage.cost_usd = 0.0
                 break
-    return "".join(pieces) if pieces else None
+    return ("".join(pieces) if pieces else None), usage
 
 
 def _ollama_alive(host: str) -> bool:
@@ -197,14 +269,15 @@ def _run_anthropic(
     messages: list[dict[str, str]],
     emitter: EventEmitter,
     block_id: str,
-) -> str | None:
+) -> tuple[str | None, _UsageDelta]:
     """Use the anthropic SDK if installed and a key is configured."""
+    usage = _UsageDelta()
     if not os.environ.get("ANTHROPIC_API_KEY"):
-        return None
+        return None, usage
     try:
         import anthropic
     except ImportError:
-        return None
+        return None, usage
 
     system = "\n".join(m["content"] for m in messages if m["role"] == "system")
     user_msgs = [m for m in messages if m["role"] != "system"]
@@ -221,35 +294,54 @@ def _run_anthropic(
             if text:
                 emitter.token(block_id, text)
                 pieces.append(text)
-    return "".join(pieces) if pieces else None
+        # C1: pull final usage off the SDK's `final_message`. Cost is the
+        # caller's problem (rate-limit module knows the model price); we
+        # report tokens here and let the credits ledger compute USD.
+        try:
+            final = stream.get_final_message()
+            usage.tokens_in = int(getattr(final.usage, "input_tokens", 0) or 0)
+            usage.tokens_out = int(getattr(final.usage, "output_tokens", 0) or 0)
+        except Exception:  # noqa: BLE001 - usage is best-effort
+            pass
+    return ("".join(pieces) if pieces else None), usage
 
 
 def _run_openai(
     messages: list[dict[str, str]],
     emitter: EventEmitter,
     block_id: str,
-) -> str | None:
+) -> tuple[str | None, _UsageDelta]:
     """Use the openai SDK if installed and a key is configured."""
+    usage = _UsageDelta()
     if not os.environ.get("OPENAI_API_KEY"):
-        return None
+        return None, usage
     try:
         from openai import OpenAI
     except ImportError:
-        return None
+        return None, usage
 
     client = OpenAI()
+    # ``stream_options.include_usage`` makes the final SSE chunk carry a
+    # populated ``usage`` block (otherwise streaming responses emit it as
+    # ``None``). Older SDK versions silently ignore unknown kwargs.
     stream = client.chat.completions.create(
         model=os.environ.get("OPENAI_MODEL", "gpt-4o-mini"),
         messages=messages,
         stream=True,
+        stream_options={"include_usage": True},
     )
     pieces: list[str] = []
     for chunk in stream:
-        text = (chunk.choices[0].delta.content or "") if chunk.choices else ""
-        if text:
-            emitter.token(block_id, text)
-            pieces.append(text)
-    return "".join(pieces) if pieces else None
+        if chunk.choices:
+            text = chunk.choices[0].delta.content or ""
+            if text:
+                emitter.token(block_id, text)
+                pieces.append(text)
+        usage_obj = getattr(chunk, "usage", None)
+        if usage_obj is not None:
+            usage.tokens_in = int(getattr(usage_obj, "prompt_tokens", 0) or 0)
+            usage.tokens_out = int(getattr(usage_obj, "completion_tokens", 0) or 0)
+    return ("".join(pieces) if pieces else None), usage
 
 
 def _run_openai_compat(
@@ -258,7 +350,7 @@ def _run_openai_compat(
     block_id: str,
     *,
     endpoint: Any,
-) -> str | None:
+) -> tuple[str | None, _UsageDelta]:
     """Stream from a user-registered OpenAI-v1-compatible endpoint (REQ-142).
 
     Uses raw stdlib HTTP so the openai SDK is not a hard dependency for
@@ -266,13 +358,14 @@ def _run_openai_compat(
     Server-Sent-Events ``data:`` lines, and forwards each ``content``
     delta as a ``token`` event on ``block_id``.
     """
+    usage = _UsageDelta()
     base_url = endpoint.base_url.rstrip("/")
     url = f"{base_url}/chat/completions"
     model = endpoint.default_model or os.environ.get("SPECSMITH_OPENAI_COMPAT_MODEL", "")
     if not model:
         # The endpoint did not pin a default model and the env override is
         # absent. We cannot fabricate one; fall back to the auto-detect chain.
-        return None
+        return None, usage
 
     headers: dict[str, str] = {
         "Content-Type": "application/json",
@@ -281,11 +374,20 @@ def _run_openai_compat(
     try:
         token = endpoint.resolve_token()
     except Exception:  # noqa: BLE001 - fall back to auto-detect chain
-        return None
+        return None, usage
     if token:
         headers["Authorization"] = f"Bearer {token}"
 
-    body = json.dumps({"model": model, "messages": messages, "stream": True}).encode("utf-8")
+    body = json.dumps(
+        {
+            "model": model,
+            "messages": messages,
+            "stream": True,
+            # Many vLLM/llama.cpp builds honour OpenAI's stream_options;
+            # the request is harmless if they don't.
+            "stream_options": {"include_usage": True},
+        }
+    ).encode("utf-8")
     req = Request(url, data=body, headers=headers, method="POST")  # noqa: S310 - user-supplied
 
     ctx = None
@@ -313,6 +415,10 @@ def _run_openai_compat(
                 except ValueError:
                     continue
                 choices = obj.get("choices") or []
+                usage_obj = obj.get("usage")
+                if usage_obj:
+                    usage.tokens_in = int(usage_obj.get("prompt_tokens") or 0)
+                    usage.tokens_out = int(usage_obj.get("completion_tokens") or 0)
                 if not choices:
                     continue
                 delta = (choices[0] or {}).get("delta") or {}
@@ -321,35 +427,50 @@ def _run_openai_compat(
                     emitter.token(block_id, chunk)
                     pieces.append(chunk)
     except (URLError, TimeoutError, OSError):
-        return None
-    return "".join(pieces) if pieces else None
+        return None, usage
+    return ("".join(pieces) if pieces else None), usage
 
 
 def _run_gemini(
     messages: list[dict[str, str]],
     emitter: EventEmitter,
     block_id: str,
-) -> str | None:
+) -> tuple[str | None, _UsageDelta]:
     """Use google-genai SDK if installed and a key is configured."""
+    usage = _UsageDelta()
     if not os.environ.get("GOOGLE_API_KEY"):
-        return None
+        return None, usage
     try:
         from google import genai
     except ImportError:
-        return None
+        return None, usage
 
     client = genai.Client()
     prompt = "\n".join(f"{m['role']}: {m['content']}" for m in messages)
     pieces: list[str] = []
+    last_chunk: Any = None
     for chunk in client.models.generate_content_stream(
         model=os.environ.get("GEMINI_MODEL", "gemini-2.5-flash"),
         contents=prompt,
     ):
+        last_chunk = chunk
         text = getattr(chunk, "text", "") or ""
         if text:
             emitter.token(block_id, text)
             pieces.append(text)
-    return "".join(pieces) if pieces else None
+    # Gemini exposes ``usage_metadata`` on the final chunk. Field names
+    # vary across SDK versions; we accept the union.
+    meta = getattr(last_chunk, "usage_metadata", None) if last_chunk else None
+    if meta is not None:
+        usage.tokens_in = int(
+            getattr(meta, "prompt_token_count", 0) or getattr(meta, "input_token_count", 0) or 0
+        )
+        usage.tokens_out = int(
+            getattr(meta, "candidates_token_count", 0)
+            or getattr(meta, "output_token_count", 0)
+            or 0
+        )
+    return ("".join(pieces) if pieces else None), usage
 
 
 # ---------------------------------------------------------------------------

{specsmith-0.10.0.dev238 → specsmith-0.10.0.dev239}/src/specsmith/agent/profiles.py

@@ -56,6 +56,33 @@ VALID_ROLES = (
     "generalist",
 )
 
+# Provider “family” groupings used by the diversity guard (G1). Profiles in
+# the same family are likely to share training data, system prompt biases,
+# and hallucination patterns — so pairing the coder with a reviewer in the
+# same family defeats the cross-check the reviewer is meant to provide.
+#
+# Anything not listed here is treated as its own family.
+PROVIDER_FAMILIES: dict[str, str] = {
+    "anthropic": "anthropic",
+    "openai": "openai",
+    "openai-compat": "openai",
+    "azure-openai": "openai",
+    "gemini": "google",
+    "google": "google",
+    "google-genai": "google",
+    "mistral": "mistral",
+    "ollama": "ollama",
+    "llamacpp": "ollama",
+    "vllm": "ollama",
+    "lmstudio": "ollama",
+}
+
+
+def provider_family(provider: str) -> str:
+    """Return the family name for ``provider`` (or the provider verbatim)."""
+    key = (provider or "").strip().lower()
+    return PROVIDER_FAMILIES.get(key, key or "unknown")
+
 
 # Default presets shipped with the CLI so a fresh install Just Works.
 # The exact model strings can be customised per-deployment via
@@ -493,7 +520,64 @@ class ProfileStore:
     def list_all(self) -> list[Profile]:
         return list(self.profiles)
 
-    # ── Routing ───────────────────────────────────────────────────────
+    def filter_by_capability(self, capability: str) -> list[Profile]:
+        """Return profiles whose ``capabilities`` list contains ``capability``.
+
+        Matching is case-insensitive and trims whitespace. An empty
+        ``capability`` argument returns ``[]`` rather than “everything” so
+        callers can distinguish “no filter” (don’t call this method) from
+        “filter for an empty value” (which is never meaningful).
+        """
+        needle = (capability or "").strip().lower()
+        if not needle:
+            return []
+        return [
+            p
+            for p in self.profiles
+            if any(needle == str(c).strip().lower() for c in p.capabilities)
+        ]
+
+    def diversity_warnings(self, *, candidate: Profile | None = None) -> list[str]:
+        """Return a list of plain-English diversity warnings for the store.
+
+        The reviewer profile exists to cross-check the coder; if both call
+        the same provider family the cross-check is degenerate. Same logic
+        applies to architect vs. reviewer (both should be skeptical of the
+        coder). When ``candidate`` is supplied the candidate is added to
+        the population *and* takes precedence over any same-id profile
+        already in the store, so a `specsmith agents add` invocation can
+        preview the warnings *before* writing the store.
+        """
+        population: dict[str, Profile] = {p.id: p for p in self.profiles}
+        if candidate is not None:
+            population[candidate.id] = candidate
+        by_role: dict[str, list[Profile]] = {}
+        for p in population.values():
+            by_role.setdefault(p.role, []).append(p)
+
+        warnings: list[str] = []
+        for left_role, right_role in (
+            ("coder", "reviewer"),
+            ("architect", "reviewer"),
+        ):
+            left = by_role.get(left_role) or []
+            right = by_role.get(right_role) or []
+            if not left or not right:
+                continue
+            for lp in left:
+                lf = provider_family(lp.provider)
+                for rp in right:
+                    if provider_family(rp.provider) == lf:
+                        warnings.append(
+                            f"{rp.id} ({rp.role}, {rp.provider}/{rp.model}) "
+                            f"shares the {lf!r} family with "
+                            f"{lp.id} ({lp.role}, {lp.provider}/{lp.model}); "
+                            "diversity is recommended so the reviewer can catch "
+                            "the coder's blind spots."
+                        )
+        return warnings
+
+    # ── Routing ─────────────────────────────────────────────────
 
     def set_route(self, activity: str, profile_id: str) -> None:
         activity = activity.strip()
@@ -558,6 +642,7 @@ def apply_preset(name: str, *, path: Path | None = None) -> ProfileStore:
 
 __all__ = [
     "DEFAULT_PRESETS",
+    "PROVIDER_FAMILIES",
     "Profile",
     "ProfileError",
     "ProfileStore",
@@ -566,4 +651,5 @@ __all__ = [
     "apply_preset",
     "default_store_path",
     "project_store_path",
+    "provider_family",
 ]

{specsmith-0.10.0.dev238 → specsmith-0.10.0.dev239}/src/specsmith/agent/runner.py

@@ -277,6 +277,13 @@ class AgentRunner:
             self.profile_id = new_profile or None
             self._state.profile_id = new_profile
             self._emit_event(type="system", message=f"profile = {new_profile or '(default)'}")
+            # G4: pin the profile choice into the project trace vault so the
+            # decision “I explicitly asked for profile X here” is
+            # cryptographically chained into the audit trail. Best-effort:
+            # missing TraceVault dependency / read-only filesystem must not
+            # break the chat loop.
+            if new_profile:
+                self._seal_profile_pin(new_profile)
             return None
         if text.startswith("/endpoint "):
             new_endpoint = text.split(maxsplit=1)[1].strip()
@@ -321,14 +328,21 @@ class AgentRunner:
             )
             return None
 
-        # Aggregate metrics into the session state. ``run_chat`` does not
-        # currently surface token counts, so we credit zero — the field is
-        # still updated so the TokenMeter chip shows turn counts.
+        # Aggregate metrics into the session state (C1).
+        # ``run_chat`` now reports tokens_in / tokens_out / cost_usd off the
+        # provider response (Ollama prompt_eval_count + eval_count, OpenAI
+        # streaming usage, Anthropic final_message.usage, Gemini
+        # usage_metadata) with a 4-chars-per-token fallback when the SDK
+        # omits them. The TokenMeter chip therefore shows real numbers
+        # instead of staying pinned at zero.
+        tokens_in = int(getattr(result, "tokens_in", 0) or 0) if result is not None else 0
+        tokens_out = int(getattr(result, "tokens_out", 0) or 0) if result is not None else 0
+        cost_usd = float(getattr(result, "cost_usd", 0.0) or 0.0) if result is not None else 0.0
         self._state.credit(
             profile_id=(profile.id if profile is not None else self.profile_id or ""),
-            tokens_in=0,
-            tokens_out=0,
-            cost_usd=0.0,
+            tokens_in=tokens_in,
+            tokens_out=tokens_out,
+            cost_usd=cost_usd,
             tool_calls=0,
         )
         self._state.elapsed_minutes = round((time.time() - self._started_at) / 60.0, 2)
@@ -397,3 +411,24 @@ class AgentRunner:
             return _v("specsmith")
         except Exception:  # noqa: BLE001
             return "0.0.0"
+
+    def _seal_profile_pin(self, profile_id: str) -> None:
+        """Append a TraceVault decision seal recording the ``/agent`` pin (G4).
+
+        Wrapped in best-effort try/except so an unwriteable
+        ``.specsmith/trace.jsonl`` (read-only fs, missing project root, etc.)
+        never breaks the chat loop. The seal type is ``decision`` because
+        a profile pin is an explicit governance choice the user made.
+        """
+        try:
+            from specsmith.trace import SealType, TraceVault
+
+            vault = TraceVault(Path(self.project_dir))
+            vault.seal(
+                seal_type=SealType.DECISION,
+                description=f"agent profile pinned via /agent: {profile_id}",
+                author="runner",
+                artifact_ids=[f"profile:{profile_id}"],
+            )
+        except Exception:  # noqa: BLE001 — trace sealing is best-effort
+            return