fix(s090): type the UUID columns the schemaless ledger reads, for Postgres

The pull request failed the postgres leg while the gate passed, twelve times with
one shape: Postgrex expected a binary of 16 bytes, got a UUID string.

A schemaless query has no schema to tell the adapter that session_id is a UUID.
SQLite stores one as text and accepts the string; Postgres wants sixteen bytes
and refuses it. The queries now annotate the type, which is correct on both. The
test seeded rows the same way and with the same result, so it seeds through the
schema instead, which dumps the UUID and the JSON correctly wherever it runs and
surfaced a third thing the schemaless path had hidden: utc_datetime_usec refuses
a second-truncated timestamp.

This is the second cost of the schemaless choice, and the choice is still right.
The first was losing the compiler's check on column names, answered with a test
that reads the table's columns; this is the second. Both are the price of a
boundary rule that is correct, and neither is an argument against it.

Verified locally rather than by pushing again: a pgvector pg17 container on 5433,
MIX_BUILD_PATH=_build_pg, and the leg's own command, mix test --exclude sqlite,
giving 656 passed and 38 excluded. Re-running CI to find out would have been
slower and told me less.

NOTES also records a mistake that cannot be undone. slice/090 was tagged and
pushed before the merge it named was confirmed, and the merge had not happened
because this very check was red, so the tag points at slice 080's merge commit.
The ruleset forbids deleting or moving a tag, which is the correct rule working
as intended, so the error is permanent and public. It is recorded beside the
truth rather than worked around: the real commit is named in PROOF and in
coverage.tsv. The rule that prevents a repeat is to tag after a merge is
confirmed, never after one is requested.

Signed-off-by: Ayla Croft <aylacroft@proton.me>

Author: HackTuah

lib/trinity/telemetry/costs.ex

@@ -59,7 +59,10 @@ defmodule Trinity.Telemetry.Costs do
   @spec for_session(String.t()) :: float()
   def for_session(session_id) do
     @table
-    |> where([u], u.session_id == ^session_id)
+    # `type/2` is not decoration here. A schemaless query has no schema to tell the adapter this
+    # column is a UUID: SQLite stores one as text and accepts the string, Postgres wants sixteen
+    # bytes and refuses it. The postgres leg caught that and the SQLite one never could.
+    |> where([u], u.session_id == type(^session_id, Trinity.UUID))
     |> select([u], sum(u.cost_usd))
     |> Repo.one()
     |> zero_if_nil()
@@ -77,7 +80,7 @@ defmodule Trinity.Telemetry.Costs do
     from(u in @table,
       join: s in "sessions",
       on: s.id == u.session_id,
-      where: s.persona_id == ^persona_id,
+      where: s.persona_id == type(^persona_id, Trinity.UUID),
       select: sum(u.cost_usd)
     )
     |> Repo.one()

scripts/dev_activity.sh

@@ -42,15 +42,14 @@ alias Trinity.LLM.Providers.Fake
 {:ok, session} = Sessions.create_session(%{persona_id: Sessions.default_persona().id, title: "Auditing the receipt chain"})
 IO.puts("SESSION=#{session.id}")
 
-now = DateTime.utc_now() |> DateTime.truncate(:second)
-rows =
-  for {model, cost, n} <- [{"anthropic:claude", 0.0121, 4}, {"openai:gpt", 0.0043, 6}, {"local:qwen", 0.0002, 11}],
-      _ <- 1..n do
-    %{id: Trinity.UUID.generate(), model_id: model, provider: "fake", kind: "stream",
-      input_tokens: 900, output_tokens: 420, cached_tokens: 0, reasoning_tokens: 0,
-      cost_usd: cost, session_id: session.id, provider_meta: JSON.encode!(%{}), inserted_at: now}
-  end
-Repo.insert_all("usage_events", rows)
+# Seeded through the schema, so the UUID and JSON columns are dumped correctly whichever adapter
+# is underneath. A schemaless insert works on SQLite and is refused by Postgres.
+for {model, cost, n} <- [{"anthropic:claude", 0.0121, 4}, {"openai:gpt", 0.0043, 6}, {"local:qwen", 0.0002, 11}],
+    _ <- 1..n do
+  Repo.insert!(%Trinity.LLM.Usage{model_id: model, provider: "fake", kind: "stream",
+    input_tokens: 900, output_tokens: 420, cached_tokens: 0, reasoning_tokens: 0,
+    cost_usd: cost, session_id: session.id, provider_meta: %{}, inserted_at: DateTime.utc_now()})
+end
 
 Trinity.Telemetry.approval_requested("write_note", :write, session.id)
 Trinity.Telemetry.approval_decided("write_note", :write, session.id, decision: :once, basis: :user, waited_ms: 3400)

test/trinity/telemetry/costs_test.exs

@@ -16,25 +16,26 @@ defmodule Trinity.Telemetry.CostsTest do
   alias Trinity.Sessions
   alias Trinity.Telemetry.Costs
 
+  # Inserted through the schema rather than schemalessly. A schemaless insert has no schema to tell
+  # the adapter which columns are UUIDs or JSON, so it passes a string and a map straight through:
+  # SQLite accepts both, Postgres refuses both. Seeding through the schema keeps this test honest
+  # on the adapter the postgres leg runs, which is where the first version of it failed.
   defp seed!(session_id, cost, opts \\ []) do
-    Repo.insert_all("usage_events", [
-      %{
-        id: Trinity.UUID.generate(),
-        model_id: Keyword.get(opts, :model, "fake:chat"),
-        provider: "fake",
-        kind: "stream",
-        input_tokens: 10,
-        output_tokens: 20,
-        cached_tokens: 0,
-        reasoning_tokens: 0,
-        cost_usd: cost,
-        session_id: session_id,
-        # Encoded here rather than passed as a map: a schemaless insert has no schema to tell the
-        # adapter this column is JSON, and SQLite refuses a bare map.
-        provider_meta: JSON.encode!(%{}),
-        inserted_at: Keyword.get(opts, :at, DateTime.utc_now() |> DateTime.truncate(:second))
-      }
-    ])
+    Repo.insert!(%Trinity.LLM.Usage{
+      model_id: Keyword.get(opts, :model, "fake:chat"),
+      provider: "fake",
+      kind: "stream",
+      input_tokens: 10,
+      output_tokens: 20,
+      cached_tokens: 0,
+      reasoning_tokens: 0,
+      cost_usd: cost,
+      session_id: session_id,
+      provider_meta: %{},
+      # Microsecond precision, because the schema declares :utc_datetime_usec and truncating to the
+      # second is a value it refuses. The schemaless version accepted it and wrote it anyway.
+      inserted_at: Keyword.get(opts, :at, DateTime.utc_now())
+    })
   end
 
   defp session!(opts \\ []) do