[FEATURE]: A2A tasks run on the runtime #783

Summary

AuraAgentExecutor runs the agent inside the execution stream, keeps its own cancel map (TaskCancelState and its guard), passes its own token to RunOptions::cancelled_by, and folds StreamItems into task status by hand. BusBridgedExecutor then republishes every execution event over the session-store bus with its own sequence numbers so another instance can relay a subscribe. That is a second registry and a second journal, both A2A-private, and the task's state is a fold over stream items rather than a reading of the run — which is how #737 happens: a cancel racing the fold records Canceled over a task the fold already completed.

Move the executor onto the runtime. A task starts a run; task status is a projection of the run's lifecycle; subscribe is a subscription; and the run's status, not a fold, decides whether a cancel still applies.

Goals

• An A2A task starts a run ([FEATURE]: A runtime that owns sessions and their runs #780) with the context id as its session. The task itself claims the session for the execution's life ([FEATURE]: Observers declare whether they collect, claim, or attend #781) — the epic's "bounded backend task" — so the run lives as long as the task does, whatever its clients do. That is today's behavior, not a change: a2a-server spawns drive_execution on a task of its own and hands each client a broadcast subscription, so an execution already outlives a client that disconnects. Subscribers, including the one that sent message/stream, collect.
• The execution stream is a projection of the run's subscription. If [FEATURE]: A2A Producer and Command interface from Agent Events #577 has landed, the projection is its producer.
• tasks/{id}:subscribe attaches to the session as a collecting observer from the run's Started ([FEATURE]: A session's event journal and late attach #779), so a subscriber arriving mid-task sees the task from the start without the bus.
• Cancel goes through the runtime by run id. A run that has already ended reports its terminal status and the cancel is a no-op, which closes [BUG]: A2A cancel can record Canceled over a task that already finished #737 by construction. TaskCancelState and its guard go.
• bus_bridge stays, fed from the runtime's subscription instead of the executor's stream, and keeps its contract from Cross-instance cancel leaves the executing instance's subscribers without a terminal frame #475. Generalizing it from A2A tasks to every run is [FEATURE]: Endpoints to list, inspect, attach to, and control sessions and runs #785's cross-instance goal.
• Wire parity unchanged, demonstrably: the A2A integration suites pass untouched.
• The command direction — a message arriving for a running task, a cancel — is what [FEATURE]: A2A Producer and Command interface from Agent Events #577 shapes into an interface. This issue only moves what exists.

Data structures

Proposed. The projection is a function over the subscription; the ids it needs are the task's.

pub struct A2aTaskIds { pub task_id: String, pub context_id: String }

/// Projects one run event onto the A2A execution stream. `None` for events A2A
/// has no frame for.
pub fn project_a2a(event: &SessionEvent, ids: &A2aTaskIds) -> Option<StreamResponse>;   // None for another run's events

// Lifecycle(Started)                       -> StatusUpdate { state: Working }
// Agent(TextDelta | Completed)             -> ArtifactUpdate (one part per chunk, as today)
// Agent(ApprovalPending) | Lifecycle(Parked) -> StatusUpdate { state: InputRequired }  (the #209 wiring)
// Lifecycle(Finished)                      -> StatusUpdate { state: Completed, final: true }
// Lifecycle(Cancelled)                     -> StatusUpdate { state: Canceled,  final: true }
// Lifecycle(Failed)                        -> StatusUpdate { state: Failed,    final: true }
// Lifecycle(ObserverAttached | ...)        -> None

Additional Context

Task-store writes stay where they are. The store is the durable record of a task; the runtime is the live record of a run; the executor keeps them in step, as it does today. The task record gains the run's RunId and SessionId (in its metadata, as the upstream Task type allows), so an instance serving tasks/{id}:subscribe for a task it did not start can find the session and the cursor without a fold over the execution stream.

A worker's tool calls within an orchestrated run are attributed to the run, not the worker, until #732 gives MCP a stream identity. The projection carries whatever AgentContext the event has; it does not repair it.

a2a-server's own ActiveExecution — a broadcast per task that its request handler subscribes clients to, with a "subscription fell behind active execution" error on lag — is upstream and stays. The executor's stream feeds it; the runtime's journal is what feeds the executor. The UnboundedSender<StreamResponse> the executor writes into is the one channel end this seam keeps, because the upstream executor interface is a stream; it is one hop at the seam, not a reach into the run. Because the task holds the claim for its whole life, ClaimsExhausted never fires for an A2A run before it is terminal, which is why #784 has no a2a liveness entry.

Searched Issues

• No similar issues found

Code of Conduct

• I agree to follow this project's Code of Conduct