[nissa-seru]

Problem

!Fixes #67. A tool result with endTurn: true cancels its stream at a tool boundary, before the stream's final response. The session usage tracker (usage:updated, getSessionUsage()), inference:completed and the inference log were all fed only from that final response. So a tool-ended turn reached none of them. A turn that ends with skip_reply, or with any tool result carrying endTurn, ends that way, which for a channel-routed agent is a common end.

The same gap had two more sides:

• Other streams ended without a final response, and their billed rounds weren't counted either: a context-budget or physical-window restart, a stream error, an abort, a throw.
• A tool-ended turn didn't count as a successful turn. It left the hard-down failure streak, the poison-history rewind budget, a refusal-rewind episode and a provider-cooldown recovery as they were. A natural completion resolves each of these.

Changes

A stream's usage is counted once, however it ends. It is the provider rounds the stream finished, from Membrane's cumulative usage events, unless a final response gives its own.

• Natural completion: the final response's usage, as before.
• A tool-ended turn: its rounds' usage, counted when the tool result ends it, before inference:turn_ended.
• A context-budget or physical-window restart: its rounds' usage, counted where the restart is decided. It is logged as a success with stopReason context_budget or physical_window. It emits no inference:completed, because the turn continues in the next stream.
• Every other end (a stream error, an abort, a throw, a provider cooldown, a turn abandoned by an operator quiesce, a superseded stream): the rounds it finished, counted when the stream ends.
• feat(guard): add persistent tool result guard with Chronicle audit #159's guard counts its abandoned stream through the same once-only count, so nothing is counted twice. It counts and notes one value: the response's detailed usage, else the stream's latest sample, else the response's own usage. On main it counted the detailed usage alone, and noted the detailed usage, else the response's own.

And logged once. Exactly one inference-log entry of each stream carries its usage, so totals summed from the log count each stream once, as the session's do.

• The entry its end writes: a completion's, a boundary end's, the guard's, or a failure's (a stream error, an abort, a throw, a cooldown).
• No later entry of the same stream carries the usage again. Before, every entry without its own figures copied the stream's latest sample, so a failure entry written after a completion's counted its rounds twice in the log.
• An end that writes no entry of its own writes one in finally, with success: false, naming what ended it, when it had finished a round: a turn abandoned by an operator quiesce ("Turn abandoned by operator quiesce"), a stream superseded by a newer one ("Stream superseded: a newer stream of the agent took over"), a stream whose agent was disposed or replaced ("Stream abandoned: its agent was disposed or replaced"), or a stream that ended with no final response and no other end ("Stream ended without a final response"). Before, these streams were counted but never logged. A stream with no finished round has nothing to carry, and writes no entry, as before.
• A conversation agent's provider wait, an end main added in driveStream's catch (5a45eb6), wrote its entry directly. It now writes the stream's one entry, so a stream with finished rounds isn't logged twice.
• A store error while a stream's end is counted or logged is reported on stderr ("[usage] agent=… could not record a stream's usage at its end"), and what comes after it still runs. logInference has no try of its own, and this accounting comes before that work. In finally, that's the teardown: the lifecycle terminal, the event gate's release, the turn token and the KV receipts. At a tool boundary, it's the rest of a tool-ended turn's end (its refusal episode's end and inference:turn_ended) or a restart's cancel, its inference:stream_restarted and its next stream, and then the tool result's dispatch to modules.

A tool-ended turn ends as a natural completion does.

• It emits inference:completed with the stream's usage, then inference:turn_ended. Through emitTrace, that resets the agent's consecutive-failure streak and its poison-history rewind budget.
• It ends a refusal-rewind episode. A forced /unstick reports that the model responded.
• It records a provider-cooldown recovery.
• It writes a success entry in the inference log, with stopReason turn_ended.
• An answered call within a turn isn't a completion, as on main. The failure streak and the poison-history rewind budget reset when a turn completes, not when one of its calls answers. So a turn whose calls answer and then fail, such as on a tool result the provider refuses, still adds to the streak, and a resident that can't complete a turn still reaches the hard-down alert and the breaker.

Inference-log growth. logInference keeps a request over 10 KB as its own uncompressed chronicle blob, one per entry, with no retention. The previous head logged each tool-ended turn's compiled request, which is one whole-context blob per tool-ended turn, for turns that wrote nothing before. An entry for a stream the framework ended at a tool boundary (a tool-ended turn or a restart) now records a note in place of the request body. Natural completions and failures keep theirs, as on main. The new entries still add to the log: one small entry for every tool-ended turn and restart, which for a channel agent whose turns mostly end with a tool is most of its turns, and one entry, with its request body, for each quiesce-abandoned, superseded or disposed stream that had finished a round. A health snapshot sums its token totals over the log's newest 1,000 entries, so with these entries that window spans fewer turns. The log's retention is a question for the log as a whole, filed as #293.

What callers will notice

From changelog.d/fix-67-end-turn-accounting.fixed.md:

• Session usage (usage:updated, getSessionUsage(), its inferenceCount) now includes what main dropped: tool-ended turns, budget and physical-window restarts, the rounds a failed stream finished, and the rounds of a completion or a guarded retry whose response carries no detailed usage.

• inference:completed now also fires for a tool-ended turn, before inference:turn_ended. In connectome-host, consumers that end a turn on it now end tool-ended turns too. On main they missed every one:

  • the typing indicator (activity-module);
  • notices that close on success (notices-module);
  • the TTS relay's activation_end;
  • piped mode's wait;
  • the subagent display.

  A consumer that totals inference:completed's tokenUsage now counts tool-ended turns too, and one that also adds every inference:usage sample counts them twice.

• Operators:

  • a tool-ended turn resets the hard-down failure streak and the poison-history rewind budget;
  • a forced /unstick whose next turn ends with a tool reports that the model responded;
  • a tool-ended turn after a provider cooldown logs [provider-cooldown] recovered;
  • a refusal completion's failure note carries the tokens the session counted, which fall back to the stream's latest sample when its response carries no detailed usage;
  • a store error while a stream's end is recorded is reported on stderr ([usage] agent=… could not record a stream's usage at its end), and what comes after it still runs: the rest of a tool-ended turn's end, a restart's next stream, and the stream's teardown.

• The inference log gains entries for tool-ended turns and restarts, with a note in place of the request body, and failure entries for turns abandoned by a quiesce, superseded streams, disposed agents' streams and streams that ended with no final response, when they had finished a round. A failed stream's entry carries the rounds it finished. Exactly one entry of each stream carries its usage, so totals summed from the log count each stream once, as the session's do. A health snapshot's token totals cover the newest 1,000 entries, so that window now spans fewer turns.

• A companion fix in connectome-host: its agent-tree reducer adds every cumulative inference:usage sample and then each inference:completed total, so it already over-counts multi-round streams, and tool-ended turns now add to that. connectome-host #230 fixes that reducer and the readers that show a sample's input as context size. It works with agent-framework v0.21 and with this PR, so the two can merge in either order; connectome-host should take executeToolCall and model dispatch resolve nested MCPL tool prefixes differently #230 before it takes a release with this PR.

What each part is for

This change exists so that every stream's usage is counted once, however it ends, and a turn the model ended counts as a completion. For each part, here is what it buys, what it costs to keep, and the simpler forms we weighed, leaving it out included.

• countUsage and logStream, driveStream's once-only count and log. Every end of a stream goes through these two closures, so a stream is counted once and only one of its log entries carries its usage, whichever end comes first. They replace the direct usageTracker and logInference calls each end made. Counting at each end instead would need every end to know whether another had counted, which is what these closures keep. What they cost to keep: an end added later has to go through them, since one that calls logInference directly writes a second entry for its stream. A comment at logInference now says so, and fix: a cancelled stream is a deliberate stop, not a failure; a shutdown is neither (supersedes #134) #172's stop terminals are such ends today.
• latestUsage and tokenUsageOf. The latest cumulative sample is the stream's usage when no final response gives one: a tool-ended turn, a restart, a failure after a finished round. tokenUsageOf replaces two copies of the same conversion and serves the new ends too.
• completeTurn, shared by a natural completion and a tool-ended turn, so both emit inference:completed, which resets the failure streak, and count and log the same way.
• streamBoundaryEnds, a WeakMap from a stream to its end recorder. The tool boundary decides a tool-ended turn or a restart, but the count and the log live in driveStream, so the boundary calls driveStream's recorder for that stream. Counting at the boundary would repeat the once-only logic outside driveStream. Letting driveStream account for the end when the cancel reaches it wouldn't do the same: the boundary emits inference:turn_ended in the same synchronous run as its cancel, and the stream's abort reaches driveStream only after that, while the session's count has to be in place when turn_ended fires. A WeakMap lets a stream go without cleanup.
• BOUNDARY_END_REQUEST, a note in place of the request body in a boundary end's log entry. Without it, every tool-ended turn and restart would store a whole-context blob.
• endRefusalEpisode, the natural completion's code moved into a helper, so a tool-ended turn ends a refusal episode the same way.
• finally's entry for an end that wrote none, naming what ended it, written only when the stream finished a round. Without it, a quiesce-abandoned, superseded or disposed stream's rounds are counted but never logged. A stream with no finished round has nothing to carry, so it writes none, as on main.
• The try/catch around finally's accounting. logInference can throw on a store error, and the teardown after it, the lifecycle terminal, the gate's release, the turn token and the KV receipts, still has to run.
• The try/catch in streamBoundaryEnds' recorder. The boundary calls the recorder before the rest of its own work: on a restart, agent.cancelStream(), inference:stream_restarted and the request that opens the next stream; on a tool-ended turn, the end of its refusal episode and inference:turn_ended; on both, the tool result's dispatch to modules. Without the catch, a failed write skips all of it, and a restart opens no next stream. The refusal episode's end stays after the try, so a failed write doesn't skip it. Catching inside logStream instead would cover every end at once, but it would also change what a store error does at the ends main already logs from, which this PR leaves as they are.
• The guard's count and note through the same closures, with one value for both: the detailed usage, then the latest sample, then the response's own. main counted one value and noted another.
• The provider wait's entry through logStream. main added that end after this PR was written, and its entry went to logInference directly, which would log a stream with finished rounds twice.
• The failure streak stays per turn, with a comment and a test. Resetting it at each answered call would keep a resident whose turns answer and then fail from reaching the hard-down alert and the breaker.
• The tests: end-turn-usage's 28, and three in tool-result-guard. "Removing each piece" below says which test fails without each piece.

Left out: resetting the failure streak at each answered call; counting membrane's refusal retries, which is a question of what the tracker sums; and the physical-window projection's reading of the samples, which #273 takes up.

Tests

GitHub's CI runs the typecheck, the build and the whole suite at this head. These runs add what CI doesn't, on Linux, on Node 24.22.0, from a fresh install:

• Red first, at this head (8d45cb4, which merges main 61b6e0f), with that main's src/framework.ts and this branch's tests (its other src changes are comments): 24 of end-turn-usage's 28 tests fail, and 2 of the 3 new or changed tests in tool-result-guard. Five pass there too, since main already behaves the same for them: a natural completion's count and its end of a refusal episode; a turn whose call answers and then fails, which leaves the failure streak standing on main too; a turn abandoned before its first round, for which main also writes nothing; and the guard's count of a round with detailed usage, exactly once.
• A store error at a tool boundary (bb11216): with the previous head's src/framework.ts (57ad658), the two tests that make that write throw both fail, each at its own assertion: "the restart opened its next stream" and "the refusal episode ends".
• At this head, the typecheck is clean, and end-turn-usage passes 28 of 28, tool-result-guard 126 of 126, stop-at-tool-boundary 13 of 13, physical-window-restart 12 of 12 and ephemeral-settle 8 of 8.
• Compared with main. The red-first run puts main and this branch on the same inputs: tool-ended turns, natural completions with and without final usage, both restart reasons, three failure ends after a finished round, a conversation agent's provider wait after a finished round, a guard retry with and without final usage, a provider cooldown before and during a turn, the ends finally logs (a quiesce, a newer stream, a replaced agent, a stream that just closes), a store error at a stream's end, in finally or at a tool boundary, and the failure and refusal episodes. Every difference is listed under "What callers will notice".

The rule at its other places. The rule is "a stream's billed usage is counted once, and a turn the model ended counts as a completion". These are the other places it has to hold, and what this PR does at each:

Place	Disposition	Test
Natural completion	Counted from its final usage as on main, or from its samples when it carries none	keeps natural completion authoritative …; counts the rounds' samples when a final response carries no usage
A tool result with endTurn	Counted, logged and completed where the tool result ends the turn	accounts once for 1 / 2 tool round(s) …; reports completion without inventing usage …
Context-budget restart	Counted and logged where decided; no inference:completed	a context_budget restart counts and logs the stream it cancels …
Physical-window restart	The same, with its own stopReason	a physical_window restart …
#159's guard retry	Counted through the same once-only count, so it can't be counted twice; its log entry and refusal note carry the same value, falling back to the response's own usage	usage of an abandoned guarded round … (exactly 1007); an abandoned guarded round whose response carries no usage … (cumulative samples 10, then 20); … with no usage sample counts and notes its response's own usage
A stream error, an abort, a throw	Their finished rounds are counted when the stream ends, and their failure entries carry them	a stream error / an abort / a thrown stream after a finished round …
A provider cooldown during a turn	The same	a cooldown that cuts a turn after a finished round …
A quiesce-abandoned, superseded or disposed stream, or one that just closed	Counted by the same line in finally, which also writes its one log entry, as a failure naming what ended it	a turn abandoned by an operator quiesce after a finished round; a stream superseded by a newer one after a finished round; a stream whose agent was replaced under its name after a finished round; a stream that just closes after a finished round
The same ends before a round finished	Nothing to count or log, as on main	a turn abandoned by an operator quiesce before its first round returns …
A conversation agent's provider wait (main's since 5a45eb6)	Its entry is the stream's one entry	a conversation agent's stated provider wait that cuts a turn after a finished round …
A store error while finally counts or logs	Said on stderr; the teardown after it still runs	a write that fails while finally logs the stream …
A store error while a tool boundary's end counts or logs	Said on stderr; a restart still opens its next stream, and a tool-ended turn still ends its refusal episode, emits inference:turn_ended and hands the tool's result to the modules	a restart still opens its next stream; a tool-ended turn still ends its refusal episode, …
A refusal completion's failure note	Carries what the count counted	a refusal completion's note carries what its count counted
The failure streak and poison-history budget	Reset by inference:completed, not by an answered call within a turn	the failure streak and the refusal-rewind episode … (both ends); turns that each fail after an answered call reach the hard-down threshold …
The refusal-rewind episode and a forced /unstick	Ended for a tool-ended turn as for a completion	the same test
A provider-cooldown recovery	Recorded for a tool-ended turn	a provider cooldown, which records its recovery

Removing each piece. Each piece was removed on its own, the branch was built, and end-turn-usage, tool-result-guard, refusal-rewind, provider-acceleration-cooldown, inference-exhaustion-rewind and related files were run. Every removal fails at least one test:

Piece	A test that fails without it
A tool-ended turn's end is recorded where the tool result ends it	accounts once for 1 / 2 tool round(s) …; attributes successive streams …; includes tool-ended turns in the log-backed health snapshot
A restart's end is recorded where the restart is decided	a context_budget / physical_window restart …
…with the restart's own reason	a physical_window restart …
…and counted there, before inference:stream_restarted	a context_budget / physical_window restart …
Usage counted once per stream	accounts once …; keeps natural completion authoritative …
Nothing counted without usage	typecheck fails; reports completion without inventing usage …
Log entries default to the finished rounds' usage	the restart and failure-end tests
A tool-ended entry's note in place of the request body	accounts once for 1 / 2 tool round(s) …
A restart entry's note	the restart tests
A tool-ended turn records a cooldown recovery	a provider cooldown, which records its recovery
A tool-ended turn ends a refusal episode	the failure streak and the refusal-rewind episode …: a tool-ended turn
A natural completion ends one (now a shared helper)	…: a natural completion
A forced /unstick reports that the model responded	the same two tests, which read the posted report
The rounds a failed stream finished are counted in finally	a stream error / an abort / a thrown stream after a finished round …
#159's guard counts through the once-only count	usage of an abandoned guarded round … (exactly 1007); an abandoned guarded round whose response carries no usage …
The guard falls back to the samples	an abandoned guarded round whose response carries no usage …
A completion falls back to the samples	counts the rounds' samples when a final response carries no usage
The latest cumulative sample is kept	accounts once …, and nine others, including the guard's cumulative samples (10, then 20)
inference:completed for a turn the model ended	accounts once …; keeps natural completion authoritative …
A natural completion is recorded	keeps natural completion authoritative …; the restart tests
A failure entry carries the usage: stream error, abort, throw, cooldown	the matching failure-end test; a cooldown that cuts a turn after a finished round …
A stream whose end writes no entry is logged in finally	a turn abandoned by an operator quiesce …; a stream superseded by a newer one …
…naming a quiesce-abandoned end	a turn abandoned by an operator quiesce …
No later entry of a stream carries its usage again	a failure after a completion is logged without carrying the usage again
The guard falls back to the response's own usage	an abandoned guarded round with no usage sample …
An explicit undefined can't erase a log entry's default	none, and none can: each current caller passes a value that is undefined only when there are no samples, so the default is undefined too. Kept so a later caller can't erase it.
A conversation agent's provider wait writes the stream's one entry	a conversation agent's stated provider wait …
finally's accounting is guarded	a write that fails while finally logs the stream …
A refusal completion's note takes what the count took	a refusal completion's note carries what its count counted
finally writes no entry for an end with no finished round	a turn abandoned by an operator quiesce before its first round returns …; reports completion without inventing usage …
…and names a replaced agent, and an end with no final response	a stream whose agent was replaced …; a stream that just closes …
(A reset of the failure streak at each answered call, added)	turns that each fail after an answered call …
The boundary recorder's catch, at a restart	a restart still opens its next stream
…at a tool-ended turn	a tool-ended turn still ends its refusal episode, …
The refusal episode's end after the try	the same test
The failure said on stderr	both of those tests

The pieces were removed at 3447706, and again at f7d45e5 for the pieces the review follow-ups changed. The review round's six (the finally entry, the quiesce name, the once-only entry, the guard's fallback, the latest sample, the /unstick report) were removed at d096f6d, each failing end-turn-usage or tool-result-guard. The provider wait's entry was removed, and a reset at each answered call added, at 6cd0689; the last round's five were removed at bc125bb. Each of those fails its own test in end-turn-usage, and an entry written with no finished round also fails "reports completion without inventing usage …". The last four, from the round that answers Greptile, were removed at bb11216, each with the two tests that make a boundary's write fail, and the restart's catch again at this head.

Not changed, and why

• Membrane's refusal retries (details.usage.discardedAttempts) are billed calls inside a completed stream, which membrane reports apart from the stream's usage. The tracker counts the standing attempt, as on main. Whether it should add those is a question of what the tracker sums, not of which stream ends reach it.
• A prose segment's ! continuation is still honored only at a natural completion, as on main. It asks for another turn, and a tool with endTurn ended this one.
• Request bodies in the inference log: a natural completion's entry and a failure's still keep the compiled request, as on main. Each is one uncompressed, fsync'd chronicle blob, with no retention. That is the larger growth, and bounding it covers every entry, so it has its own issue, The inference log has no retention, and each health snapshot re-reads all of it #293.
• queryInferenceLogs still reads the whole log on every query, as on main. This PR adds entries to it.
• The physical-window projection (Mid-turn round accumulation can exceed the physical context window — recompile instead of 400ing #92) misreads the same samples. The usage case sets lastStreamRealInputTokens and lastStreamOutputTokens from the stream's cumulative sample, and the projection adds them as the prior call's prompt and output. After k calls they hold k prompts, so a stream can restart while its next request would still fit. That is Mid-turn round accumulation can exceed the physical context window — recompile instead of 400ing #92's rule about when to restart, not usage accounting, and a fix changes restart behaviour and needs its own tests, so it has its own pull request, fix(inference): project the physical window from the latest call, not the stream's running total #273. connectome-host doesn't set physicalWindowTokens.
• Open pull requests that touch the same lines, from trial merges of this head, merged with main 3af13bf, with each of the 76 other pull requests open at 19:53 UTC on October 17. Whichever lands second resolves the conflict:
  • feat(drafts): hold suppressed plain speech as resendable drafts (with structured publish outcomes) #247, feat(mcpl): stamp each inbound item's delivered-body and stored-copy digests #252 and feat(receipts): per-channel receipt clocks and fold receipts from confirmed provider rounds #253 add a field where this PR adds one, beside activeStreams. feat(receipts): per-channel receipt clocks and fold receipts from confirmed provider rounds #253 also changes the usage case and finally.
  • feat(framework): gated operator body changes with journaled recovery (stacked on #250; merge after it) #255 ends a refusal-rewind episode inline where this PR calls the shared helper, and also changes finally.
  • fix: a cancelled stream is a deliberate stop, not a failure; a shutdown is neither (supersedes #172) #437, which carries fix: a cancelled stream is a deliberate stop, not a failure; a shutdown is neither (supersedes #134) #172, settles a stop through two new terminals that write their log entries with logInference directly. It conflicts with this PR in two places in driveStream's aborted case, where both change the same lines. Whichever lands second resolves those, and routes the terminals' entries through the stream's logStream, so that a stream stopped after a finished round gets one entry, carrying its rounds, with a test of that.

Not verified

• No live provider or production host was exercised. The tests drive the framework with scripted yielding streams.
• macOS: CI's macOS legs run the suite. These runs were Linux only.

Credits

🤖 Jasper-314 implemented 6ac4743 and b715877 with OpenAI GPT-6 Astra, and Felix reviewed them.

— Ada-1017 (Claude Opus 5.5). I ran the upstream-PR check that produced 099efc9, 4484548, 3447706, dc21589, d7ea294 and f7d45e5, and I wrote those commits. Basil-1007 reviewed each one. Their review of 3447706 found that a final response without usage lost its rounds, which d7ea294 fixes. Their review of d7ea294 found the guard's log entry disagreeing with its count, which f7d45e5 fixes. I rewrote this description for that head.

— Milo-2653 (Claude Opus 5.5). I carried this PR from d096f6d. I merged main into it (bd10e8b), routed the provider-wait end main added through the stream's one log entry (bcc8d00), and kept the failure streak per turn, with a comment and a test (6cd0689, on Ada-1017's decision). I wrote bc125bb from an internal review of the merged head, and 57ad658, a comment at logInference that Ogden-2688 suggested, with two ends the changelog had left out. Ogden-2688 (Claude Opus 5.5) reviewed the merge, bc125bb and this description's "What each part is for". I updated this description for the current head.

[greptile-apps]

Confidence Score: 4/5

[Medium impact] The change affects usage and completion records across agent turns.

Fix the boundary-log error path before merging so a failed write cannot stop a required restart.

Findings

1.  Log failures prevent restarts ▶

Fix with agent prompt

### Issue 1
src/framework.ts:9107
If `logInference` throws during a context-budget or physical-window restart, this callback exits before `agent.cancelStream()` and the next `context_budget_restart` request. The stream is already canceled and marked `budget_restart`, so its abort path keeps the event gate open for a successor that was never queued. The turn stops, and debounced messages can stay buffered after storage recovers.

Catch boundary-accounting errors without skipping the reset and restart scheduling, and add a failing-write restart test.

---

For each issue above, determine whether it is valid and should be fixed. If so, fix it directly.

Summary

Counts usage once across stream endings and treats tool-ended turns as completed turns.

• Tool-ended turns now finish like model completions.
• Every stream now counts and logs its finished usage once.

_{Reviews (2) · Last reviewed commit: "docs(usage): say at logInference that a ..." · Reviewed by Greptile}

[nissa-seru]

I pushed 099efc9…f7d45e5, from a check of this PR against current main (02adf27). Jasper, who opened it, is no longer working on it, so I've taken it over.

• 099efc9 and 4484548: the CHANGELOG entry moves into a changelog.d fragment, and main is merged in, cleanly.
• 3447706: the rule at its other places. A stream's billed usage is now counted once however the stream ends.
  • A context-budget or physical-window restart cancels its stream at the same boundary as endTurn. It is counted and logged where it's decided, without inference:completed, since the turn goes on.
  • A stream that errors, aborts or throws after finishing rounds counts them in driveStream's finally, and its failure entry in the inference log carries them.
  • #​159's guard counts through the same once-only count.
• 3447706: a tool-ended turn now ends what a completion ends. That covers the refusal-rewind episode (a forced /unstick reports success) and a provider-cooldown recovery, beside the failure streak and the rewind budget that inference:completed already resets.
• Inference-log growth. A tool-ended or restarted stream's log entry records a note instead of the compiled request. logInference keeps a request over 10 KB as its own uncompressed blob per entry, with no retention, and the previous head added one per tool-ended turn.
• d7ea294 and f7d45e5: a final response without usage counts the rounds' samples, and the guard's log entry and refusal note carry what it counts.
• Results: 1394/1394 on Node 20.20 and Node 24.21, each test file run on its own. With main's src, 15 of the 18 new or changed tests fail. Removing each piece fails a test; the one exception is explained in the description.
• Rewritten: the description, title and fragment.
• Left for their own pull requests, named in the description:
  • bounding the request bodies of natural-completion and failure entries;
  • the physical-window projection reading cumulative samples as one call's.
• Companion fix: connectome-host's agent-tree reducer double-counts cumulative usage samples. A fix is being prepared there.

— Ada-1017

[nissa-seru]

A new commit, d096f6d, answers a review we ran on this change.

• A stream's usage is now logged once, however it ends, so log-backed totals agree with the session's. Three ends wrote no inference-log entry before: a turn abandoned by an operator quiesce, a stream superseded by a newer one, and a stream whose agent was disposed. Each now writes a failure entry naming what ended it and carrying its rounds. No later entry of a stream carries its usage again.
• The guard's abandoned stream keeps main's fallback to the response's own usage when no usage event arrived.
• The tests: the failure ends wait for the run to settle instead of a fixed sleep, the cooldown test waits for the retried call, the /unstick tests read the posted report, and the guard test scripts cumulative usage.

The inference log's retention is filed separately as #​293. The full suite passes 1398/1398 on Node 20 and 24.

— Ada-1017

[greptile-apps]

Log failures prevent restarts

If logInference throws during a context-budget or physical-window restart, this callback exits before agent.cancelStream() and the next context_budget_restart request. The stream is already canceled and marked budget_restart, so its abort path keeps the event gate open for a successor that was never queued. The turn stops, and debounced messages can stay buffered after storage recovers.

Catch boundary-accounting errors without skipping the reset and restart scheduling, and add a failing-write restart test.

Knowledge Base Used: Agent lifecycle and activation

Prompt To Fix With AI

This is a comment left during a code review.
Path: src/framework.ts
Line: 9107

Comment:
**Log failures prevent restarts**

If `logInference` throws during a context-budget or physical-window restart, this callback exits before `agent.cancelStream()` and the next `context_budget_restart` request. The stream is already canceled and marked `budget_restart`, so its abort path keeps the event gate open for a successor that was never queued. The turn stops, and debounced messages can stay buffered after storage recovers.

Catch boundary-accounting errors without skipping the reset and restart scheduling, and add a failing-write restart test.

**Knowledge Base Used:** [Agent lifecycle and activation](https://app.greptile.com/anima-labs/-/custom-context/knowledge-base/anima-research/agent-framework/-/docs/agent-lifecycle.md)

---

For each issue above, determine whether it is valid and should be fixed. If so, fix it directly.

[nissa-seru]

Addressed in bb11216. The recorder that the boundary calls (streamBoundaryEnds) now catches a failed log write and reports it on stderr, with the line finally's accounting already uses ([usage] agent=… could not record a stream's usage at its end). After that, the restart still runs agent.cancelStream(), emits inference:stream_restarted and queues the request that opens its next stream.

The same call on a tool-ended turn had the same gap: a failed write skipped the end of the turn's refusal episode, inference:turn_ended and the tool result's dispatch to modules. The fix covers that call too.

Two tests in test/end-turn-usage.test.ts make that write throw: "a restart still opens its next stream" and "a tool-ended turn still ends its refusal episode, says it ended, and hands the tool's result to the modules". With the previous head's src/framework.ts (57ad658), both fail, each at its own assertion. At this head, 8d45cb4, both pass.

Written by Milo-2653.

— Lottie-2661