feat: bill local tool execution time in chat agent runtime - #28211

Local tool batches now persist their billable wall-clock window to
chat_messages.runtime_ms, the source of truth for hb_agent_runtime_v1.
Each batch bills one window, from the batch start to the last billed
tool's completion, stored on that tool's message row. Tools in a batch
run in parallel, so the window equals the union of billed execution
intervals rather than a per-tool sum.

Sub-agent orchestration tools (spawn_agent, wait_agent, message_agent,
interrupt_agent, list_agents, list_subagent_models, and the deprecated
close_agent alias) never extend the window: every chat, including
children, bills its own runtime, so a parent's wait_agent would double
count. Client-executed dynamic tools, external agents, parked time,
and retry backoff remain unbilled.

Interrupted batches bill the partial window: the buffer episode stamps
the batch start, and the interrupt task places the window on the
window-defining synthesized cancellation row. Batches without a live
attempt (crash recovery, state promotion) bill nothing.

The usage query already sums runtime_ms role-agnostically, so no
schema, query, or cron changes are needed. Reported agent runtime
increases from deploy forward.

…on times

Address Codex review feedback:

- Record each local tool call's completion instant on the message part
  buffer as the tool finishes (chatloop OnToolComplete), because tool
  results are published only after the whole batch completes. The
  interrupt task now reads these live stamps instead of inferring
  completions from buffered results, which never exist while a sibling
  tool is still running, so an interrupted batch no longer bills a
  finished tool through to the interrupt instant.
- Assign the batch runtime to only the first tool row matching the
  window-defining tool call ID, so duplicate tool call IDs cannot
  multiply the billed sum.
- Replace the agent-authored ARCHITECTURE.md buffer API entries with a
  TODO item for the PR author, per the chatd documentation rule.

…tched call

Address Codex review feedback:

- Compute the batch's billable window from completion instants aligned
  with the tool calls by occurrence instead of the ID-keyed timestamp
  map. Duplicate tool call IDs, which reach execution when lifecycle
  hooks are disabled, previously overwrote each other there, letting a
  short duplicate shrink the window a longer one should have defined.
- Seed the buffer episode's tool batch with the dispatched call IDs so
  an interrupt can tell a call that was still running (seeded, no
  completion) from one rejected before execution (absent). Rejected
  calls previously looked like still-running work and billed the whole
  window up to the interrupt even when only unbilled tools actually
  ran.

…ccurrence

Address Codex review feedback:

- Store the tool batch's dispatched calls on the buffer episode as an
  occurrence list instead of an ID-keyed map, stamping completions onto
  the first still-running occurrence of the reported ID. Duplicate tool
  call IDs, which reach execution when lifecycle hooks are disabled,
  previously collapsed into one shared state, so one duplicate
  finishing made its still-running twin look finished and ended the
  interrupted batch's window early. The interrupt path now consumes
  per-ID occurrence queues in the same dispatch order the unresolved
  history rows walk.
- Close the buffer episode and snapshot its billing stamps in one
  critical section (CloseEpisodeForBilling) instead of reading
  ModelInvokedAt, ToolBatchStartedAt, and the completions before a
  separate CloseEpisode. Stamps recorded in those gaps went missing
  from the snapshot, billing a finished tool through to the interrupt
  or dropping a just-started batch's window entirely.

…he interrupt instant

Address Codex review feedback:

- Thread the call's occurrence index through OnToolComplete and
  RecordToolCompletion so a completion stamps its own occurrence
  instead of the first still-running occurrence sharing its tool call
  ID. Same-ID calls with different billing classifications, such as an
  unbilled wait_agent finishing before a billed execute, previously
  ended the billed occurrence's window early. The interrupt path also
  consumes an occurrence for every dispatched call, including unbilled
  ones, to keep same-ID queues aligned with the history walk.
- Pass the interrupt instant captured at episode close into the
  cancellation billing instead of taking a fresh clock reading inside
  machine.Update, so database contention or transaction retries no
  longer inflate a still-running call's billed window past the actual
  interrupt.

…osition

Address Codex review feedback:

- Seed each dispatched occurrence with its position in the step's
  unresolved tool-call order, the order interrupt reconstruction
  walks, and match occurrences to cancellation rows positionally
  instead of through per-ID queues. A call rejected before execution
  that shared an ID with a dispatched call previously consumed the
  dispatched occurrence and billed the whole window on a row that
  never ran. partitionAmbiguousToolCalls now reports each allowed
  call's input position so the seed does not re-derive it from IDs.
- Skip starting the billing batch for exclusive-policy violations.
  chatloop synthesizes error results for the whole batch without
  dispatching any tool, so seeding those calls let an interrupt
  racing the synthetic results bill never-run work from the batch
  stamp to the interrupt.

…er line

Address Codex review feedback: the docs prose style guide requires each
sentence on its own source line and the full text of a bullet item on a
single line, reformatting the entire paragraph when any line in it is
edited. The section kept fixed-column wrapping.

Address Codex review feedback:

- Return the episode's first-close instant in the billing snapshot and
  use it as the interrupt instant. Each retried interrupt attempt
  previously took a fresh clock reading, billing still-running tools
  (and the model window) through every retry of a transient database
  failure; every billing input now comes from the episode's stable
  first-close state, so retries recompute identical windows.
- Push the episode's eviction deadline out on every re-close, so a
  retry loop outlasting the buffer's retention window keeps its billing
  snapshot and buffered parts through a database outage instead of
  losing them to the cleanup loop; retry backoff (max 5s) stays well
  under the retention window (15s). The superseded heap item is
  skipped by the cleanup loop's existing identity check.

… retries

Address Codex review feedback: one interrupt attempt can outlive the
buffer's closed-episode retention (a machine.Update stalled on a
database outage runs up to the task timeout), and the eviction refresh
only happens when an attempt begins. A retry after such a stall found a
blank recreated episode and lost the interrupt instant, partial parts,
and tool completions, underbilling the interrupted work and dropping
the partial messages.

The runner now attaches a snapshot holder to the interrupt task's
input, which every retry attempt of the task instance shares. The
first attempt to read the episode stores the billing state and
buffered parts there, and later attempts reuse the carried snapshot
instead of re-reading the evictable buffer.

…e chat read

Address Codex review feedback: the interrupt task read the chat row
before snapshotting the buffer episode, so an initial read stalled past
the buffer's retention let the cleanup loop evict the episode first,
and the eventual snapshot found a blank recreated episode with no
billing stamps or partial parts.

StartInterrupt now captures the snapshot before its first database
read, keyed by the task input's attempt number. Generation attempts
only advance while the chat is running, so the pre-read key matches
the row while the chat stays interrupting; if the post-read attempt
number ever disagrees, the snapshot is retaken with the row's key. The
close-and-read sequence moved into a closeInterruptEpisode helper
shared by both paths.

# Conflicts:
#	coderd/x/chatd/chatloop/chatloop.go

Serial tool calls (SerialToolCalls) launch only after every concurrent
sibling settles, so measuring them from the shared batch start charged
the whole concurrent phase, including waits on unbilled sub-agent
orchestration tools, and an interrupt treated a dispatched serial call
that never launched as running since batch start.

The batch window is now the union of the billed calls' execution
intervals: chatloop stamps each call's start (concurrent calls at batch
start, serial calls at their launch) and reports it through the new
OnToolStart callback, the buffer records the marks per occurrence via
RecordToolStart, and both the committed path and the interrupt path
bill with the shared BilledIntervalsDuration union, so a span where
only unbilled tools were running never bills and a dispatched call
without a start mark bills nothing.

Restore docs/ai-coder/usage-data-reporting.md to its state on main,
removing this branch's edits to the agent runtime measurement section.