thread's active grants inside the transaction that writes the terminal row,

  and `mint_grant/1` refuses a thread that is not open. Deleting a thread — or

  the account, under the DATA-004 cascade — deletes its grants with it.

- **A thread is bounded.** The objective is capped at 32 KB and the terminal

  report at 32 KB, both by check constraint; every transcript entry is pinned

  to `openagents.thread.event.v1` with a 16 KB payload ceiling and no

  `updated_at`; and a thread is open with no report or terminal with one,

  never both and never neither.

- **A thread is bounded where a bound means something.** The objective is

  capped at 32 KB and the terminal report at 32 KB, both by check constraint;

  every transcript entry is pinned to `openagents.thread.event.v1` with no

  `updated_at`; and a thread is open with no report or terminal with one, never

  both and never neither. A transcript entry carries no size ceiling, only the

  requirement that it says something (`thread_events_payload_present_check`).

  The 16 KB ceiling it used to carry was inherited from `scv_run_events`, whose

  payloads are a deliberately minimal projection of work stored elsewhere; this

  table is the work, and has to reproduce a session as a full ATIF trajectory. A

  single observed reasoning block is 38,791 characters, so the ceiling bought

  chunking and reassembly on every read rather than any real bound. What a

  client sends to a model is bounded by the client.

- **Authority is capped at admission.** `OpenAgents.Threads.open/3` refuses an

  account already holding `maximum_open_threads_per_account` open threads with

### The two limits

**A payload is 2 to 16,384 bytes**, enforced by

`thread_events_payload_bound_check` on `octet_length(payload::text)`.

**A payload had a 16,384 byte ceiling**, enforced by

`thread_events_payload_bound_check`. It was inherited from tables that carry no

content and has been removed; the section below says why.

**A listing returns at most 50 events**, `@maximum_listed` in

`OpenAgents.Threads`.

`OpenAgents.Threads`. This one is a pagination bound rather than a storage

bound, and the cursor added alongside it is the answer.

Measured against four real coder sessions from the same afternoon:

| `17-08-32` | 4 | 5 | 4 | 9 | 8,418 B |

| `17-24-37` | 6 | 0 | 6 | 6 | 0 B |

For tool results the payload cap is not the binding constraint: the largest

observed was 8.4 KB, and the transcript already bounds a result to 4,000

characters before it reaches a model, so the same bound applied to an event

keeps every one of them comfortably inside 16 KB. A 30 KB shell output would not

fit, which is why the bound is applied rather than assumed. Reasoning is the

exception, and it has its own section below.

The payload ceiling turned out to be inherited rather than reasoned, and is

gone; see below. What remains true of the measurements is that tool results are

small — the largest observed was 8.4 KB — and that reasoning is not: a single

block reached 38,791 characters, which is what exposed the ceiling as the wrong

rule for this table.

**The listing cap was the binding constraint.** Turn-level persistence fits

inside fifty with room to spare; tool-level passes it on an ordinary working

session, and recording reasoning in parts pushes it further still. So `list_events/2` now takes an `:after` cursor and the route publishes

session. So `list_events/2` now takes an `:after` cursor and the route publishes

each event's id, because a history that cannot be read back is not persistence.

That is the one server change this section required, and it is done.

  fact, and splitting them doubles the count against the cap for nothing.

- `turn.assistant` — the answer, with the turn's token usage and call count.

**Reasoning is recorded, and it is not optional.** An earlier draft of this

document left it out and called that a saving, on the grounds that it is not

**Reasoning is recorded whole, and it is not optional.** An earlier draft of

this document left it out and called that a saving, on the grounds that it is not

sent back to a model. That was wrong twice over. It is sent back now — a model

that cannot see how it reached its last answer reasons its way there again — and

it is the largest single part of what a session produces: 150,322 characters

stores the arrival cannot be read back as the thing. Notices never reached a

model. That is the whole of what is dropped.

### Reasoning does not fit in one event

The payload cap is 16,384 bytes and the largest single reasoning block measured

is **38,791 characters**. So reasoning is the one thing here that a single event

cannot hold, and the cap is not the wrong size — a bounded event is the point of

an append-only evidence table.

It is stored in ordered parts: `turn.reasoning` events carrying `part`, `of`,

and a slice bounded well inside the cap, reassembled in order on read. The

alternative is raising the constraint, which trades a bound that holds for every

event against one case, and the case is the one that will keep growing.

This also means the event count per turn is no longer fixed, which the cursor

already handles.

### The payload ceiling was inherited, and is gone

An earlier draft of this section proposed splitting reasoning across events,

because the largest single block measured is 38,791 characters against a 16,384

byte payload ceiling. That was fitting the wrong constraint, and the reasoning

given for it — that a bounded event is the point of an append-only evidence

table — does not survive reading where the bound came from.

The same `octet_length(payload::text) <= 16384` appears on `voice_events`,

`scv_run_events`, program receipts, and `ComputerActivity`. `thread_events`

copied it: the schema said so outright. Where that bound is actually justified,

it is justified by those tables carrying **no content** —

`2026-08-21-sarah-computers-and-scv-architecture-audit.md` records that an SCV

event payload is reduced to a fixed key allowlist and that "no file paths, tool

arguments, tool output, or report prose reach an event row", and that

`ComputerActivity` events are "a projection and never the authority".

`thread_events` is the authority, and the bar set above is a full ATIF

trajectory. A ceiling designed to keep content out of a projection is the wrong

rule for the table that holds the content. It is dropped

(`20260824184030_relax_thread_event_payload_ceiling`), the floor stays at "is a

JSON object", and `INVARIANTS.md` moves with it.

### Storing and sending are different questions

Removing the ceiling does not mean a client sends everything to a model on every

round. Those are separate decisions and the confusion between them is what

produced the chunking proposal:

- **The record holds what happened.** Every turn, all of the reasoning, every

  tool call with its whole result. Unbounded, because a truncated record cannot

  reproduce the session and a session that cannot be reproduced is not evidence

  of anything.

- **The wire is bounded by the client.** The model transcript already bounds a

  tool result to 4,000 characters, and that bound belongs there — it is a

  context-budget decision made against a model's window, not a property of what

  happened.

A client that needs to page a large payload over the wire can do that when it

needs to. It is a transport concern, and solving it in the store cost every

future reader a reassembly step for nothing.

### Resume

  One bounded, append-only entry in a thread's transcript

  (`openagents.thread.event.v1`).

  The shape follows `OpenAgents.SCV.ExecutionEvent`: the schema string is

  pinned by the database, the payload is capped at 16 KB, and there is no

  `updated_at`, so a recorded event is evidence rather than state.

  The schema string is pinned by the database and there is no `updated_at`, so a

  recorded event is evidence rather than state.

  Unlike `OpenAgents.SCV.ExecutionEvent`, whose payloads are a deliberately

  minimal projection of work that lives elsewhere, this table is the work: a

  thread's transcript has to reproduce the session as a full ATIF trajectory.

  So the payload carries what happened rather than a summary of it, and the only

  floor is that it is a JSON object — an event whose type is the whole of it

  satisfies that. What a client sends to a model is bounded by the client; what

  the record holds is what happened.

  """

  use Ecto.Schema

    |> validate_inclusion(:schema, [@schema_version])

    |> foreign_key_constraint(:thread_id)

    |> check_constraint(:schema, name: :thread_events_schema_check)

    |> check_constraint(:payload, name: :thread_events_payload_bound_check)

    |> check_constraint(:payload, name: :thread_events_payload_present_check)

  end

end

        "esbuild openagents --minify",

        "phx.digest"

      ],

      precommit: [

        "cmd sh ops/dev/install-push-guard.sh --ensure",

        "hex.audit",

        "deps.audit",

        "compile --warnings-as-errors",

        "deps.unlock --check-unused",

        "format",

        "cmd ops/ci/reference-check.sh",

        "cmd elixir ops/ci/docs-check.exs",

        "assets.test",

        "test --warnings-as-errors"

      ]

      # Scaled to what changed: a prose-only change runs the checks that read

      # prose, and everything else runs the whole gate. The rules live in the

      # script because an alias cannot branch. See `ops/dev/precommit.sh`.

      precommit: ["cmd sh ops/dev/precommit.sh"]

    ]

  end

end

#!/usr/bin/env bash

#

# The precommit gate, scaled to what changed.

#

# The full gate compiles, audits dependencies, builds assets, and runs the whole

# suite — some four thousand tests and several minutes. That is the right price

# for a change to the application and the wrong one for a change to a document,

# and paying it for prose is how a gate stops being run.

#

# So a change that touches only prose runs only the checks that read prose. The

# rule is deliberately narrow: every changed path must be Markdown, and no

# Markdown that any code or test names by path counts, because several documents

# in this repository are read by the suite and changing one of those is a change

# to the suite's input. Anything else, including anything unreadable or

# ambiguous, takes the full gate.

set -euo pipefail

root=$(git rev-parse --show-toplevel)

cd "$root"

full() {

  mix hex.audit

  mix deps.audit

  mix compile --warnings-as-errors

  mix deps.unlock --check-unused

  mix format

  mix cmd ops/ci/reference-check.sh

  mix cmd elixir ops/ci/docs-check.exs

  mix assets.test

  mix test --warnings-as-errors

}

prose() {

  mix format

  mix cmd ops/ci/reference-check.sh

  mix cmd elixir ops/ci/docs-check.exs

}

sh ops/dev/install-push-guard.sh --ensure

# Everything this change touches: the working tree against HEAD, plus anything

# already committed that main has not seen. A commit made before running this

# is still part of what is about to be pushed.

changed=$(

  {

    git diff --name-only HEAD 2>/dev/null || true

    git ls-files --others --exclude-standard 2>/dev/null || true

    if git rev-parse --verify --quiet openagents/main >/dev/null 2>&1; then

      git diff --name-only "$(git merge-base HEAD openagents/main)"...HEAD 2>/dev/null || true

    fi

  } | sort -u | sed '/^$/d'

)

# Nothing to classify is not a reason to skip: a gate that finds no evidence

# runs the whole thing.

if [ -z "$changed" ]; then

  full

  exit 0

fi

while IFS= read -r path; do

  case "$path" in

    *.md) ;;

    *)

      full

      exit 0

      ;;

  esac

  # A document the suite reads is the suite's input, whatever its extension.

  if grep -rqlF "$path" lib test ops --include="*.ex" --include="*.exs" --include="*.sh" \

    2>/dev/null; then

    full

    exit 0

  fi

done <<EOF_PATHS

$changed

EOF_PATHS

echo "precommit: prose only (${changed//$'\n'/, }) — running the checks that read prose."

prose

    20260824035934,

    20260824040140,

    20260824042729,

    20260824043735

    20260824043735,

    20260824184030

  ],

  "required_tables": [

    "users",

defmodule OpenAgents.Repo.Migrations.RelaxThreadEventPayloadCeiling do

  @moduledoc """

  A thread's transcript holds the work, so it cannot be capped like a projection.

  The 16 KB ceiling came from `scv_run_events`, whose payloads are deliberately

  minimal: that table reduces a payload to a fixed key allowlist and lets no

  file path, tool argument, tool output, or report prose reach a row, because

  the work itself lives elsewhere. `ComputerActivity` states the same premise

  outright — its events are a projection and never the authority.

  `thread_events` is the authority. It has to reproduce a session as a full

  ATIF trajectory, and a single reasoning block observed in a live session is

  38,791 characters. Under the inherited ceiling the only way to record that was

  to split it across events and reassemble it on read, which is a wire concern

  solved in the store, and a reader of the transcript paying for it forever.

  So the upper bound goes. The floor stays at "is a JSON object", which an event

  carrying nothing but its type satisfies, and the schema pin and the

  append-only shape are untouched.

  Boundedness moves to where it belongs — what a client sends to a model is

  bounded by the client, and what the record holds is what happened.

  """

  use Ecto.Migration

  def up do

    drop constraint(:thread_events, :thread_events_payload_bound_check)

    create constraint(:thread_events, :thread_events_payload_present_check,

             check: "octet_length(payload::text) >= 2"

           )

  end

  def down do

    drop constraint(:thread_events, :thread_events_payload_present_check)

    create constraint(:thread_events, :thread_events_payload_bound_check,

             check: "octet_length(payload::text) BETWEEN 2 AND 16384"

           )

  end

end

               thread |> Threads.list_events() |> Enum.map(& &1.event_type)

    end

    test "a payload past the ceiling is refused by the database" do

    test "a payload larger than a projection would allow is recorded whole" do

      user = owner("event-bound")

      {:ok, thread} = Threads.open(user, "Record something large")

      assert {:error, changeset} =

               Threads.record_event(thread, "thread.turn.started", %{

                 "blob" => String.duplicate("a", 16_400)

               })

      # Past the 16 KB ceiling this table inherited from `scv_run_events`, whose

      # payloads are a minimal projection of work stored elsewhere. This table

      # is the work: a single reasoning block observed in a live session is

      # 38,791 characters, and a transcript that cannot hold it cannot

      # reproduce the session.

      blob = String.duplicate("a", 40_000)

      assert {:ok, _updated} =

               Threads.record_event(thread, "thread.turn.started", %{"blob" => blob})

      stored =

        thread

        |> Threads.list_events()

        |> Enum.find(&(&1.payload["blob"] != nil))

      assert %{payload: _} = errors_on(changeset)

      assert stored.payload["blob"] == blob

    end

    test "a terminal thread accepts no further transcript" do

      assert Enum.map(rest["events"], & &1["payload"]["text"]) |> List.last() == "three"

    end

    test "records a payload far larger than the old ceiling", %{authenticated: conn, id: id} do

      # A single reasoning block observed in a live session is 38,791

      # characters. Under the inherited 16 KB ceiling the only way to record one

      # was to split it and reassemble it on every read.

      reasoning = String.duplicate("thinking about the problem. ", 2_000)

      assert byte_size(reasoning) > 16_384

      conn

      |> post(~p"/api/v3/threads/#{id}/events", %{

        "event_type" => "turn.reasoning",

        "payload" => %{"text" => reasoning}

      })

      |> json_response(201)

      body = conn |> get(~p"/api/v3/threads/#{id}/events") |> json_response(200)

      stored =

        body["events"]

        |> Enum.find(&(&1["event_type"] == "turn.reasoning"))

        |> get_in(["payload", "text"])

      # Stored whole, so the transcript reproduces the session rather than a

      # summary of it.

      assert stored == reasoning

    end

    test "accepts an event whose type is the whole of it", %{authenticated: conn, id: id} do

      # Some events carry nothing but their type, and the route defaults an

      # absent payload to an empty object. The remaining floor is that the

      # column holds valid JSON, not that the JSON is interesting.

      body =

        conn

        |> post(~p"/api/v3/threads/#{id}/events", %{"event_type" => "turn.started"})

        |> json_response(201)

      assert body["thread"]["event_count"] > 0

    end

    test "refuses an event with no type", %{authenticated: conn, id: id} do

      body =

        conn