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. 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:

• 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.

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).

Agent Telemetry Systems covers token spend, model routing and cost, and that is a different question from this one. 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.

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.

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.

The snapshot above stands as written, for 0.87.1. Six days later Earendil shipped Pi 1.0 (announced 2026-10-01). This box was updated from 0.87.1 to 1.0.0 with pi update --self on 2026-10-02.

What the announcement lists as added:

• Codemode: native support for MCP, and for non-LLM models (it names Jev and image models)
• Extension support for virtual models
• Deferred tool loading
• Cache warming for Anthropic models
• Mid-conversation system messages
• A new TUI theme, and full-screen mode by default

Alongside it, an experimental package, Pi Durable, described as "a new substrate for building long-running agentic applications". Both are MIT licensed; code is at earendil-works/pi.

What can be confirmed from the 1.0.0 binary's own help on this machine:

• A new pi mcp subcommand: add, remove, list, login, logout. It reads ~/.pi/agent/mcp.json and, in trusted projects, .pi/mcp.json.
• --tui-mode, with fullscreen as the stated default.
• The built-in tool list is unchanged: the same eight names as in the snapshot (read, bash, powershell, edit, write, grep, find, ls). What 1.0 adds arrives through MCP and extensions, not as new built-ins.

"pi wraps providers" now undersells it: with MCP in the agent, pi wraps tool servers as well. The closing question, whether anything in this layer has started persisting the program rather than the conversation about it, now has a named candidate in Pi Durable. That is the announcement's claim; it has not been tried here.

Not checked: codemode in use, deferred tool loading, cache warming, virtual models, and anything about Pi Durable. The comparison rows for Herdr and iTerm2 above were not re-read.

• 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.