Calling these "wrappers" flattens the useful distinction. Each wraps a different layer, and only one of them wraps an agent.

Claude Code 2.1.283 exposes thirty hook events:

ConfigChange       CwdChanged         Elicitation        ElicitationResult
FileChanged        InstructionsLoaded MessageDisplay     Notification
PermissionDenied   PermissionRequest  PostCompact        PostToolBatch
PostToolUse        PostToolUseFailure PreCompact         PreToolUse
SessionEnd         SessionStart       Setup              Stop
StopFailure        SubagentStart      SubagentStop       TaskCompleted
TaskCreated        TeammateIdle       UserPromptExpansion UserPromptSubmit
WorktreeCreate     WorktreeRemove

On this machine three independent systems are subscribed to that surface, and they overlap:

Three consumers, one config file, no coordination between them. The vendor documentation acknowledges the consequence: iTerm2's installer "detects when Claude rewrites settings and breaks the hook, offering automatic reinstallation". That is a repair loop for a contended resource, shipped as a feature, which is the honest response to a config file with no ownership model. Nothing arbitrates between the three; they coexist because appending happens to work.

Shared REPL as Gossip Protocol covers the transport question. What is running here now is aq, an "ambient agent queue (gossip layer for multi-agent development)":

The design choice is in the last row and in the TTLs. Claims expire, checks are advisory, and validation never blocks. It is gossip, not locks — two agents editing the same file is a thing you find out about, not a thing you are prevented from doing. That is the right trade for a fleet where the cost of a false block exceeds the cost of a rare collision, and the wrong one where it does not. The TTL is the whole safety argument: a claim that outlives the work it describes is worse than no claim.

It hangs off PostToolUse with an Edit|Write matcher, which means the announcement is made after the edit lands. The protocol tells you a collision happened; it cannot tell you one is about to.

The three consumers read the same events for different purposes, and the difference is instructive.

• iTerm2 wants a state machine with three values — working, waiting, idle — rendered in a status bar. Latency is what it needs; history is irrelevant to it.
• aq wants the file path being touched and a claim string. It needs identity, not timing.
• crowsnest wants a trace.

The crowsnest hook is the one that extracts the most from the same payload. Its own comment records the method:

Models the hook control flow FROM THE PAYLOAD (not docs). Claude Code gives a real call graph: session_id ⊃ turn_id ⊃ tool_use_id (Pre/Post share it) + duration_ms (real tool time).

That is a span tree recovered from a hook stream — session contains turn contains tool call, with PreToolUse and PostToolUse sharing a tool_use_id so a call's start and end can be joined, and a real duration_ms rather than an inferred one. It maps onto a sighting with service as a per-session trace lane, run as the correlation group, and after as the causal link.

Two things about that are worth naming. The first is that the hook surface was evidently not designed as a tracing API, and turned out to be one — the tool_use_id shared across Pre and Post is what makes the join possible, and that is a correlation identifier whether or not it was meant as one. The second is the parenthetical: from the payload, not docs. The schema was derived by observing traffic rather than by reading a specification, which is the only method that survives a vendor changing the payload without changing the documentation.

The trace shape above is OTel-shaped without being OTel: spans, a parent relation, durations, a correlation group. Converting it is a mapping exercise, not a redesign, and the collector is already running — nexus exposes OTLP on 4317 (gRPC) and 4318 (HTTP).

This note deliberately stops there. Agent Telemetry Systems covers token spend, model routing and cost, and that is a different question from this one. The distinction worth keeping: this note is about plumbing — what emits, what subscribes, what correlates — and the telemetry note is about economics — what the traffic costs and how to route it more cheaply. They share a transport and almost nothing else. Folding them together would make both worse, because the plumbing question is answered by reading a payload and the economics question is answered by reading an invoice.

Set the three side by side and the gap is the same one in each.

pi is strikingly stateful about conversation: --continue, --resume, --session, --session-id, --fork, --session-dir, --export to HTML. So persistence did arrive. It arrived for what the agent said, for the terminal it said it in, and for the human's view of both — and not for the running system the agent is reasoning about. Three 2026 products, three different answers to "what should survive between turns", and not one of them keeps a debugger attached or a REPL warm.

That is the case for treating this as a snapshot rather than a conclusion. The integration layer is being built quickly and in the open; the question worth re-asking in a quarter is whether anything in it has started persisting the program rather than the conversation about it.

• CLI Coding Agents: 2026 Q2 Comparison — compares the agents themselves; this note covers the layer that grew around them two quarters later.
• Terminal AI Agents: The 2025 Landscape — the prior year's field.
• Shared REPL as Gossip Protocol — inter-agent transport, of which aq is one implementation.
• Agent Telemetry Systems — the cost side, deliberately separate.
• Claude Code Workshop (2026 Q2) — the hook surface as it stood earlier in the year.