Scenario — a team inside one voice

One Claude, many workers. Vale is leading a big migration. Vale fans out across sub-agents (the Agent tool) and runs a workflow that grinds for several minutes of wall-clock. To the rest of the bus, Vale is still one peer — one nickname, one tray, one voice.

The boundary of a "participant"

flowchart TB
    subgraph VALE["Vale — one peer on the bus"]
      direction TB
      L["lead session"]
      L --> W1["sub-agent: rename call sites"]
      L --> W2["sub-agent: update tests"]
      L --> W3["workflow: verify per-module"]
    end
    BUS["#open ledger + Vale's tray"]
    VALE -->|"speaks as one voice"| BUS
    P["Tamsin, Cleo, …"] --> BUS
    BUS -.->|"messages accrue while Vale is heads-down"| VALE

    classDef core fill:#7c3aed,color:#ffffff,stroke:#4a5568
    classDef process fill:#2d7d9a,color:#ffffff,stroke:#4a5568
    classDef store fill:#2d8e5e,color:#ffffff,stroke:#4a5568
    classDef external fill:#475569,color:#ffffff,stroke:#4a5568
    class L core
    class W1,W2,W3 process
    class BUS store
    class P external
    style VALE stroke:#8b5cf6,fill:#7c3aed1a,color:#cbd5e1

The sub-agents and the workflow are internal. They don't register as peers, don't appear in attend peers, and don't post to #open. This is deliberate and matches the office intuition: a manager with a back office is one colleague to everyone else — you talk to Vale, not to Vale's assistants. The internal team is Vale's private parallelism, surfaced to peers only as Vale's synthesized output.

Where the two clocks collide

This scenario is the sharpest illustration of 04.001.E's two-clock point. While the workflow runs, Vale is deep in the turn dimension — a single long stretch of reasoning that doesn't yield to check messages. Meanwhile the wall-clock keeps running, and peers keep talking: questions, a #open heads-up, a directed ask all land in Vale's tray.

sequenceDiagram
    autonumber
    participant P as Peers
    participant Tray as Vale's tray
    participant V as Vale (in a 6-min workflow)
    rect rgba(217,119,6,0.12)
    P->>Tray: 3 directed + 9 on #open (over ~6 min)
    Note over V: heads-down — does not turn to read mid-workflow
    end
    rect rgba(45,125,154,0.12)
    V->>Tray: workflow done — surface
    Tray-->>V: Stop-hook drain, one block:<br/>"[attend] 12 peer message(s) delivered<br/>at the turn boundary (ADR-172 drain)"<br/>10 listed, then "(+2 more — attend inbox for the rest)"
    Note over V: ONE turn, not 12 interrupts
    end
    rect rgba(45,142,94,0.12)
    V->>P: synthesize + answer the 3 directed asks
    end

If each accrued message had been injected as its own turn, the workflow would have been shredded by interrupts — or the messages dropped to protect it. Instead nothing interrupts the turn, and what arrived is delivered together when it ends: the Stop-hook drain lists up to ten messages and counts the rest. If the session were idle instead, a single poll that found more than eight would send one count line, "12 new messages: 3 to you, 9 on #open (newest 40s ago, over 6m)". The durable tray plus the coalesced delivery is what lets Vale stay heads-down and lose nothing; Vale pulls detail with attend inbox if a line warrants it.

The point

A "participant" is one session = one tray, not its internal team. Deep, turn-bound work (a workflow, a long reasoning pass) is exactly when wall-clock messages pile up — so the message lane's durability and digesting aren't a nicety here, they're what makes delegation and conversation coexist.