The turn end
The trace carries what the assistant wrote before a search. The turn end carries what it concluded. It is off by default, and it reports only turns in which a search was served.
Turning it on
Add one line to the [miner] table of your config, ~/.jevlin/jevlin.toml:
[miner]
turn_end = true
With it on, when a turn ends, the agent's end-of-turn hook sends the router one record for that turn. Without that line, nothing is sent. export JEVLIN_TRACE=off turns it off too, with the trace.
Which agents
| agent | sends a turn end |
|---|---|
| Claude Code | Yes, on 2.1.196 or later. Earlier versions give the hook no prompt id, so they send no final answer; searches are unaffected. |
| Cursor | Yes. Its hooks carry no text written between tool calls, so the steps list the searches only. |
| opencode | Yes. When a turn that searched goes idle, the plugin pipes the turn to jevlin. |
| Codex | Yes, on macOS and Linux where its hooks are installed. The turn is read from Codex's own session file. |
| Pi, Hermes, any other agent | No. |
What travels
| field | carries |
|---|---|
session_id, turn_id | The same hashed ids the turn's searches carried, so the record joins them. |
harness | Which agent. |
status | completed, interrupted or failed. |
user_text | What you asked in that turn, scrubbed of secrets, first 32 KiB. Absent for a turn Claude Code started rather than you: a continuation, a background task's result, a compaction summary. |
final_text | The assistant's last message of the turn, scrubbed, last 32 KiB. Only on a completed turn. |
steps | The turn in order: what the assistant wrote, and for each tool it called the tool's name, duration and whether it succeeded. Never a tool's input or output. A search of ours is marked by its call id. |
model, usage | The model, and the turn's token counts. |
What you typed in a searched turn is sent. What your tools read and wrote never is: not a file's contents, not a command, not its output. The model's private reasoning and a subagent's own steps are not sent either. The turn end record has every field and every limit.
Only turns that searched
search marks the turn after the router answers, so a search you refused, or one that failed, does not count, and a turn with no served search sends nothing. The mark is an empty file under ~/.jevlin/sessions, one per searched turn.
Under Claude Code, a subagent searches under the turn that launched it, and one running in the background can do so after that turn has ended. That turn is then reported late, by the next turn end in the session, with what you asked, its steps and its last message as the transcript holds them. Only a subagent's search makes a turn late: a turn you interrupted after the agent itself searched sends nothing, but one in which a subagent searched is reported late, as completed. A turn is reported once. Under Codex and opencode a subagent runs a turn of its own, and its search is joined to no turn end.
How it is sent
The hook writes the record to an owner-only file in sessions/, and a detached jevlin turn-end sends it once to the router miner.router_url names, then deletes the file, sent or not. The hook itself never waits on the network, and a failure to send never affects the search or the agent.
Why turn it on
A search on its own says what was asked. The trace adds what the agent was thinking just before. The turn end closes the loop: whether the agent reached an answer, what it was, and which tools it took to get there. On the platform's Trajectories view that is the difference between a list of searches and a readable path. See Trajectory observability.