diff --git a/docs/config-catalog.md b/docs/config-catalog.md
index 4c68290ec3..c11bf455a8 100644
--- a/docs/config-catalog.md
+++ b/docs/config-catalog.md
@@ -27,7 +27,7 @@ export interface AcpConfig {
 
 Depends on: `Stream` (`@agentclientprotocol/sdk`)
 
-Source: [`packages/acp/acp/src/index.ts:57`](../packages/acp/acp/src/index.ts)
+Source: [`packages/acp/acp/src/index.ts:56`](../packages/acp/acp/src/index.ts)
 
 ## `@deepseek-ai/dsh-acp-demo`
 
@@ -749,7 +749,7 @@ Requires: `agents`
 export type Config = Readonly<Record<string, never>>
 ```
 
-Source: [`packages/llm/llm-retry/src/index.ts:45`](../packages/llm/llm-retry/src/index.ts)
+Source: [`packages/llm/llm-retry/src/index.ts:44`](../packages/llm/llm-retry/src/index.ts)
 
 ## `@deepseek-ai/dsh-lsp-local`
 
diff --git a/docs/cordis-catalog/events.md b/docs/cordis-catalog/events.md
index dafa342d5a..0c012e58da 100644
--- a/docs/cordis-catalog/events.md
+++ b/docs/cordis-catalog/events.md
@@ -13,27 +13,6 @@ Dispatch modes: **emit** (fire-and-forget), **waterfall** (each listener gets `n
 
 ## `agent/*`
 
-### `agent/cancel-requested` — emit
-
-Effective broad cancellation was requested, before queued/outbox work is cleared or the active turn is aborted. This observe-only notification cannot veto cancellation; listener failures are contained.
-
-```ts cordis-catalog
-/**
- * Effective broad cancellation was requested, before queued/outbox work
- * is cleared or the active turn is aborted. This observe-only notification
- * cannot veto cancellation; listener failures are contained.
- * @param agent - the agent whose current work is being cancelled.
- * @param cause - the explicit typed cancellation cause.
- * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.
- * @mode emit
- */
-'agent/cancel-requested'(this: Scoped<Agent>, agent: Agent, cause: AgentCancelCause): void
-```
-
-Types: [Agent](../core-data-structures/core.md) · [AgentCancelCause](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md)
-
-Source: [`packages/core/agent/src/types.ts:319`](../../packages/core/agent/src/types.ts)
-
 ### `agent/created` — emit
 
 A fully configured agent and live session were published. Setup is composition-only; `agent/session-start` is the first startup-driving seam. Synchronous listener failure vetoes publication, while returned-promise rejection is reported. Detach requested during dispatch waits until every creation listener has observed the stable entry.
@@ -54,7 +33,7 @@ A fully configured agent and live session were published. Setup is composition-o
 
 Types: [Agent](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md)
 
-Source: [`packages/core/agent/src/types.ts:250`](../../packages/core/agent/src/types.ts)
+Source: [`packages/core/agent/src/types.ts:151`](../../packages/core/agent/src/types.ts)
 
 ### `agent/disposed` — emit
 
@@ -74,7 +53,7 @@ An agent left the registry; AgentLoop emits this after driver quiescence and sco
 
 Types: [Agent](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md)
 
-Source: [`packages/core/agent/src/types.ts:259`](../../packages/core/agent/src/types.ts)
+Source: [`packages/core/agent/src/types.ts:160`](../../packages/core/agent/src/types.ts)
 
 ### `agent/error` — emit
 
@@ -96,115 +75,30 @@ A step or turn errored. The machine reports a failure here (plus the logger) eve
 
 Types: [Agent](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md)
 
-Source: [`packages/core/agent/src/types.ts:433`](../../packages/core/agent/src/types.ts)
-
-### `agent/inbox/dequeue` — emit
-
-The driver claimed one item out of the inbox: a queued item at a turn boundary, or steering drained between steps. Fires after the item leaves its FIFO and before it becomes a durable message.
-
-```ts cordis-catalog
-/**
- * The driver claimed one item out of the inbox: a queued item at a turn
- * boundary, or steering drained between steps. Fires after the item leaves
- * its FIFO and before it becomes a durable message.
- * @param agent - the agent whose inbox item was claimed.
- * @param item - the exact claimed occurrence.
- * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.
- * @mode emit
- */
-'agent/inbox/dequeue'(this: Scoped<Agent>, agent: Agent, item: InboxItem): void
-```
-
-Types: [Agent](../core-data-structures/core.md) · [InboxItem](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md)
-
-Source: [`packages/core/agent/src/types.ts:297`](../../packages/core/agent/src/types.ts)
-
-### `agent/inbox/discard` — emit
-
-Pending inbox items were dropped without delivering them, so every enqueue occurrence receives exactly one terminal `agent/inbox/dequeue` OR `agent/inbox/discard`. `cancel()` without `keepInbox`, including disposal, emits this after `agent/cancel-requested` when applicable and before aborting the active work. Fires once per drop with every dropped item.
-
-```ts cordis-catalog
-/**
- * Pending inbox items were dropped without delivering them, so every
- * enqueue occurrence receives exactly one terminal `agent/inbox/dequeue` OR
- * `agent/inbox/discard`. `cancel()` without `keepInbox`, including disposal,
- * emits this after `agent/cancel-requested` when applicable and before
- * aborting the active work. Fires once per drop with every dropped item.
- * @param agent - the agent whose inbox items were dropped.
- * @param items - the discarded occurrences in FIFO order (queued then steering); never empty.
- * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.
- * @mode emit
- */
-'agent/inbox/discard'(this: Scoped<Agent>, agent: Agent, items: InboxItem[]): void
-```
-
-Types: [Agent](../core-data-structures/core.md) · [InboxItem](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md)
-
-Source: [`packages/core/agent/src/types.ts:309`](../../packages/core/agent/src/types.ts)
-
-### `agent/inbox/enqueue` — emit
-
-An item entered the queued or steering inbox. `placement` is the acceptance-time routing result; listeners must not reconstruct it from later agent or session state.
-
-```ts cordis-catalog
-/**
- * An item entered the queued or steering inbox. `placement` is the
- * acceptance-time routing result; listeners must not reconstruct it from
- * later agent or session state.
- * @param agent - the owning agent.
- * @param item - accepted occurrence, message, and resolved placement.
- * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.
- * @mode emit
- */
-'agent/inbox/enqueue'(this: Scoped<Agent>, agent: Agent, item: InboxItem): void
-```
-
-Types: [Agent](../core-data-structures/core.md) · [InboxItem](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md)
-
-Source: [`packages/core/agent/src/types.ts:278`](../../packages/core/agent/src/types.ts)
-
-### `agent/inbox/update` — emit
-
-A still-pending queued item changed content. The item id, placement, and position remain stable while the event carries the replacement message.
-
-```ts cordis-catalog
-/**
- * A still-pending queued item changed content. The item id, placement, and
- * position remain stable while the event carries the replacement message.
- * @param agent - the owning agent.
- * @param item - the complete post-update occurrence.
- * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.
- * @mode emit
- */
-'agent/inbox/update'(this: Scoped<Agent>, agent: Agent, item: InboxItem): void
-```
-
-Types: [Agent](../core-data-structures/core.md) · [InboxItem](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md)
-
-Source: [`packages/core/agent/src/types.ts:287`](../../packages/core/agent/src/types.ts)
+Source: [`packages/core/agent/src/types.ts:261`](../../packages/core/agent/src/types.ts)
 
 ### `agent/prompt-submit` — waterfall
 
-Allow, rewrite, or block one claimed prompt before it becomes a user message or opens a turn. Call `next()` for the unchanged default. The signal controls only this admission attempt; listeners may cooperate with it but must not retain it for a later attempt or turn.
+Allow, rewrite, or block one claimed inbox batch before it becomes model-visible or opens a turn. Call `next()` for the unchanged default. The signal controls only this admission attempt; listeners may cooperate with it but must not retain it for a later attempt or turn.
 
 ```ts cordis-catalog
 /**
- * Allow, rewrite, or block one claimed prompt before it becomes a user
- * message or opens a turn. Call `next()` for the unchanged default. The
+ * Allow, rewrite, or block one claimed inbox batch before it becomes
+ * model-visible or opens a turn. Call `next()` for the unchanged default. The
  * signal controls only this admission attempt; listeners may cooperate with
  * it but must not retain it for a later attempt or turn.
- * @param agent - the agent whose turn claimed the message.
- * @param message - the frozen claimed message, including identity and source.
+ * @param agent - the agent whose driver claimed the batch.
+ * @param messages - the claimed messages.
  * @param signal - the current turn's explicit abort signal.
  * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.
  * @mode waterfall
  */
-'agent/prompt-submit'(this: Scoped<Agent>, agent: Agent, message: UserMessage, signal: AbortSignal, next: () => Promise<PromptDecision>): Promise<PromptDecision>
+'agent/prompt-submit'(this: Scoped<Agent>, agent: Agent, messages: UserMessage[], signal: AbortSignal, next: () => Promise<PromptDecision>): Promise<PromptDecision>
 ```
 
 Types: [Agent](../core-data-structures/core.md) · [PromptDecision](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md) · [UserMessage](../core-data-structures/session.md)
 
-Source: [`packages/core/agent/src/types.ts:346`](../../packages/core/agent/src/types.ts)
+Source: [`packages/core/agent/src/types.ts:196`](../../packages/core/agent/src/types.ts)
 
 ### `agent/request` — waterfall
 
@@ -228,37 +122,30 @@ Replace the frozen call configuration. `await next()` yields the config the mach
 
 Types: [Agent](../core-data-structures/core.md) · [LlmCallConfig](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md)
 
-Source: [`packages/core/agent/src/types.ts:372`](../../packages/core/agent/src/types.ts)
+Source: [`packages/core/agent/src/types.ts:222`](../../packages/core/agent/src/types.ts)
 
 ### `agent/request-error` — waterfall
 
-Handle a model-request failure after its failed step has closed but before the failed turn closes. A listener returns `{ kind: 'retry' }` without calling `next()` when it owns the error, or calls `next()` to delegate. The default `undefined` leaves the failure terminal.
+Handle one failed model-request attempt before the loop retries or closes its step. A listener returns `{ kind: 'retry' }` without calling `next()` when it owns recovery, or calls `next()` to delegate. The default `undefined` leaves the failure terminal.
 
 ```ts cordis-catalog
 /**
- * Handle a model-request failure after its failed step has closed but
- * before the failed turn closes. A listener returns `{ kind: 'retry' }`
- * without calling `next()` when it owns the error, or calls `next()` to
- * delegate. The default `undefined` leaves the failure terminal.
+ * Handle one failed model-request attempt before the loop retries or closes
+ * its step. A listener returns `{ kind: 'retry' }` without calling `next()`
+ * when it owns recovery, or calls `next()` to delegate. The default
+ * `undefined` leaves the failure terminal.
  * @param agent - the agent whose request failed.
- * @param turn - the open turn number.
- * @param step - the failed step number.
- * @param error - the original model-request failure.
- * @param failure - serializable facts normalized at the final adapter boundary.
- * @param priorFailures - immutable failures that already authorized another
- * retry turn in this consecutive sequence.
- * @param retryPolicy - immutable policy of the adapter registration that served
- * the failed request, or `undefined` if no final adapter served it.
+ * @param context - request coordinates, provider, normalized failure, and serving policy.
  * @param signal - the turn abort signal.
  * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.
  * @mode waterfall
  */
-'agent/request-error'(this: Scoped<Agent>, agent: Agent, turn: number, step: number, error: RequestError, failure: LlmFailure, priorFailures: readonly LlmFailure[], retryPolicy: ResolvedRetryPolicy | undefined, signal: AbortSignal, next: () => Promise<RequestErrorAction>): Promise<RequestErrorAction>
+'agent/request-error'(this: Scoped<Agent>, agent: Agent, context: RequestFailureContext, signal: AbortSignal, next: () => Promise<RequestErrorAction>): Promise<RequestErrorAction>
 ```
 
-Types: [Agent](../core-data-structures/core.md) · [LlmFailure](../core-data-structures/llm-streaming.md) · [RequestError](../core-data-structures/core.md) · [RequestErrorAction](../core-data-structures/core.md) · [ResolvedRetryPolicy](../core-data-structures/llm-streaming.md) · [Scoped](../core-data-structures/scope.md)
+Types: [Agent](../core-data-structures/core.md) · [RequestErrorAction](../core-data-structures/core.md) · [RequestFailureContext](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md)
 
-Source: [`packages/core/agent/src/types.ts:391`](../../packages/core/agent/src/types.ts)
+Source: [`packages/core/agent/src/types.ts:234`](../../packages/core/agent/src/types.ts)
 
 ### `agent/session-start` — emit
 
@@ -280,41 +167,17 @@ The session lifecycle began, once before the first turn. Use `agent.inject()` to
 
 Types: [Agent](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md) · [SessionStartSource](../core-data-structures/core.md)
 
-Source: [`packages/core/agent/src/types.ts:332`](../../packages/core/agent/src/types.ts)
-
-### `agent/settled` — emit
-
-One drain chain reached its terminal turn: that turn's `turn/end` is already committed. Automatically recovered failed turns do not emit this notification, and neither does a run that aborts or fails before its `turn/start` commits — there is no durable turn to settle against. `reason` says why; model-request recovery is exhausted when an error reaches it.
-
-```ts cordis-catalog
-/**
- * One drain chain reached its terminal turn: that turn's `turn/end` is
- * already committed. Automatically recovered failed turns do not emit this
- * notification, and neither does a run that aborts or fails before its
- * `turn/start` commits — there is no durable turn to settle against.
- * `reason` says why; model-request recovery is exhausted when an error
- * reaches it.
- * @param agent - the agent whose turn closed.
- * @param turn - the terminal turn number.
- * @param reason - why the terminal turn ended, with live error facts when it failed.
- * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.
- * @mode emit
- */
-'agent/settled'(this: Scoped<Agent>, agent: Agent, turn: number, reason: SettleReason): void
-```
-
-Types: [Agent](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md) · [SettleReason](../core-data-structures/core.md)
-
-Source: [`packages/core/agent/src/types.ts:420`](../../packages/core/agent/src/types.ts)
+Source: [`packages/core/agent/src/types.ts:182`](../../packages/core/agent/src/types.ts)
 
 ### `agent/status` — emit
 
-Agent status changed (`idle` ⇄ `running`). `send()` does not enter `running` synchronously; drive lifecycle from this event.
+Agent status changed (`idle` ⇄ `running`). A waking delivery enters `running` synchronously after reserving cancellation; `idle` means no driver remains scheduled or active.
 
 ```ts cordis-catalog
 /**
- * Agent status changed (`idle` ⇄ `running`). `send()` does not enter
- * `running` synchronously; drive lifecycle from this event.
+ * Agent status changed (`idle` ⇄ `running`). A waking delivery enters
+ * `running` synchronously after reserving cancellation; `idle` means no
+ * driver remains scheduled or active.
  * @param agent - the agent whose status flipped.
  * @param status - the status just entered (the transition's destination).
  * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.
@@ -325,7 +188,7 @@ Agent status changed (`idle` ⇄ `running`). `send()` does not enter `running` s
 
 Types: [Agent](../core-data-structures/core.md) · [AgentStatus](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md)
 
-Source: [`packages/core/agent/src/types.ts:268`](../../packages/core/agent/src/types.ts)
+Source: [`packages/core/agent/src/types.ts:170`](../../packages/core/agent/src/types.ts)
 
 ### `agent/step` — serial
 
@@ -349,7 +212,7 @@ Awaited serial checkpoint before EVERY request of a turn is built (the first as
 
 Types: [Agent](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md)
 
-Source: [`packages/core/agent/src/types.ts:359`](../../packages/core/agent/src/types.ts)
+Source: [`packages/core/agent/src/types.ts:209`](../../packages/core/agent/src/types.ts)
 
 ### `agent/turn-stopping` — serial
 
@@ -375,7 +238,7 @@ The turn is about to close: the model owes no response (no live tool calls, no f
 
 Types: [Agent](../core-data-structures/core.md) · [Scoped](../core-data-structures/scope.md)
 
-Source: [`packages/core/agent/src/types.ts:406`](../../packages/core/agent/src/types.ts)
+Source: [`packages/core/agent/src/types.ts:249`](../../packages/core/agent/src/types.ts)
 
 ## `agent-loop/*`
 
@@ -567,7 +430,7 @@ Waterfall around every streaming model call (retry, replay, routing). Bound to t
 
 Types: [GenerateOptions](../core-data-structures/core.md) · [LlmService](../core-data-structures/llm-streaming.md) · [StreamChunk](../core-data-structures/llm-streaming.md)
 
-Source: [`packages/llm/llm/src/index.ts:58`](../../packages/llm/llm/src/index.ts)
+Source: [`packages/llm/llm/src/index.ts:56`](../../packages/llm/llm/src/index.ts)
 
 ## `session/*`
 
@@ -592,7 +455,7 @@ Creation announcement during session publication. A synchronous throw vetoes and
 
 Types: [Scoped](../core-data-structures/scope.md) · [Session](../core-data-structures/session.md)
 
-Source: [`packages/core/session/src/index.ts:71`](../../packages/core/session/src/index.ts)
+Source: [`packages/core/session/src/index.ts:50`](../../packages/core/session/src/index.ts)
 
 ### `session/disposed` — emit
 
@@ -613,7 +476,7 @@ Emitted once when an announced session leaves the store, including publication r
 
 Types: [Scoped](../core-data-structures/scope.md) · [Session](../core-data-structures/session.md)
 
-Source: [`packages/core/session/src/index.ts:81`](../../packages/core/session/src/index.ts)
+Source: [`packages/core/session/src/index.ts:60`](../../packages/core/session/src/index.ts)
 
 ### `session/event` — emit
 
@@ -636,7 +499,7 @@ Post-commit, fire-and-forget append feed. The listener snapshot resolves before
 
 Types: [Scoped](../core-data-structures/scope.md) · [Session](../core-data-structures/session.md) · [SessionEvent](../core-data-structures/core.md)
 
-Source: [`packages/core/session/src/index.ts:93`](../../packages/core/session/src/index.ts)
+Source: [`packages/core/session/src/index.ts:72`](../../packages/core/session/src/index.ts)
 
 ### `session/flush` — parallel
 
@@ -657,7 +520,7 @@ Awaited parallel durability checkpoint: every listener runs and the caller await
 
 Types: [Scoped](../core-data-structures/scope.md) · [Session](../core-data-structures/session.md)
 
-Source: [`packages/core/session/src/index.ts:103`](../../packages/core/session/src/index.ts)
+Source: [`packages/core/session/src/index.ts:82`](../../packages/core/session/src/index.ts)
 
 ## `skills/*`
 
diff --git a/docs/cordis-catalog/services.md b/docs/cordis-catalog/services.md
index cda9061a63..26990aa0fc 100644
--- a/docs/cordis-catalog/services.md
+++ b/docs/cordis-catalog/services.md
@@ -1588,7 +1588,7 @@ fork(source: SessionForkSource, boundary?: number, childSessionId?: SessionId):
 
 Types: [CreateSessionOptions](../core-data-structures/persistence.md) · [Session](../core-data-structures/session.md) · [SessionId](../core-data-structures/core.md)
 
-Source: [`packages/core/session/src/index.ts:695`](../../packages/core/session/src/index.ts)
+Source: [`packages/core/session/src/index.ts:674`](../../packages/core/session/src/index.ts)
 
 ## `ctx.sessionTitle` — `SessionTitleService`
 
diff --git a/docs/core-data-structures/llm-streaming.md b/docs/core-data-structures/llm-streaming.md
index 6811611768..7fa02b6e3b 100644
--- a/docs/core-data-structures/llm-streaming.md
+++ b/docs/core-data-structures/llm-streaming.md
@@ -15,8 +15,9 @@ A streaming response interleaves several typed blocks (text, reasoning, multiple
  * Raw streaming protocol emitted by adapters.
  * Block indexes correlate interleaved deltas, and `block-end` carries the
  * assembled block. Adapters emit usage before the terminal finish and nothing
- * afterward; tool arguments remain raw JSON strings. Failures either throw or
- * end with `error`/`aborted`, and consumers must handle both paths.
+ * afterward; tool arguments remain raw JSON strings. An adapter implementation
+ * may throw, but `LlmService.stream()` normalizes that failure to a terminal
+ * `error` or `aborted` finish before exposing it to consumers.
  */
 type StreamChunk =
   | { type: 'block-start'; index: number; blockType: ContentBlockType }
@@ -141,7 +142,8 @@ declare class BlockAssembler {
   push(chunk: StreamChunk): void;
   /**
    * Assemble all blocks seen so far, in stream order.
-   * @returns one block per seen index; an open block assembles from its
+   * @returns one block per seen index, except that max-token truncation drops
+   *   tool calls that cannot be executed safely; an open block assembles from
    *   accumulated deltas (an unknown block type never closed by `block-end` throws).
    */
   blocks(): ContentBlock[];
@@ -169,6 +171,8 @@ declare class BlockAssembler {
 interface PreparedLlmCall {
   /** Detached, deep-frozen config with any adapter-owned default materialized. */
   readonly config: LlmCallConfig
+  /** Immutable retry policy captured with the adapter registration. */
+  readonly retryPolicy: ResolvedRetryPolicy
   /**
    * Dispatch this call once through the registration captured during
    * preparation. The request's call-config fields must match {@link config};
diff --git a/docs/core-data-structures/llm-streaming.zh.md b/docs/core-data-structures/llm-streaming.zh.md
index 35374af6a2..c25d140895 100644
--- a/docs/core-data-structures/llm-streaming.zh.md
+++ b/docs/core-data-structures/llm-streaming.zh.md
@@ -15,8 +15,9 @@
  * Raw streaming protocol emitted by adapters.
  * Block indexes correlate interleaved deltas, and `block-end` carries the
  * assembled block. Adapters emit usage before the terminal finish and nothing
- * afterward; tool arguments remain raw JSON strings. Failures either throw or
- * end with `error`/`aborted`, and consumers must handle both paths.
+ * afterward; tool arguments remain raw JSON strings. An adapter implementation
+ * may throw, but `LlmService.stream()` normalizes that failure to a terminal
+ * `error` or `aborted` finish before exposing it to consumers.
  */
 type StreamChunk =
   | { type: 'block-start'; index: number; blockType: ContentBlockType }
@@ -141,7 +142,8 @@ declare class BlockAssembler {
   push(chunk: StreamChunk): void;
   /**
    * Assemble all blocks seen so far, in stream order.
-   * @returns one block per seen index; an open block assembles from its
+   * @returns one block per seen index, except that max-token truncation drops
+   *   tool calls that cannot be executed safely; an open block assembles from
    *   accumulated deltas (an unknown block type never closed by `block-end` throws).
    */
   blocks(): ContentBlock[];
@@ -169,6 +171,8 @@ declare class BlockAssembler {
 interface PreparedLlmCall {
   /** Detached, deep-frozen config with any adapter-owned default materialized. */
   readonly config: LlmCallConfig
+  /** Immutable retry policy captured with the adapter registration. */
+  readonly retryPolicy: ResolvedRetryPolicy
   /**
    * Dispatch this call once through the registration captured during
    * preparation. The request's call-config fields must match {@link config};
diff --git a/docs/event-producer-consumer.md b/docs/event-producer-consumer.md
index 596f8f99f5..39f074a01c 100644
--- a/docs/event-producer-consumer.md
+++ b/docs/event-producer-consumer.md
@@ -8,22 +8,16 @@ This matrix shows which packages dispatch each harness-owned event and which pac
 | Event | Mode | Declared in | Dispatchers | Listeners |
 | --- | --- | --- | --- | --- |
 | `agent-loop/config-start-failed` | `emit` | [`packages/core/agent-loop/src/index.ts:148`](../packages/core/agent-loop/src/index.ts) | [`agent-loop`](../packages/core/agent-loop) (`events.dispatch`) | [`tui`](../packages/ui/tui) |
-| `agent/cancel-requested` | `emit` | [`packages/core/agent/src/types.ts:319`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emitAgentEvent`) | [`goal-session`](../packages/goal/goal-session) |
-| `agent/created` | `emit` | [`packages/core/agent/src/types.ts:250`](../packages/core/agent/src/types.ts) | [`agent`](../packages/core/agent) (`events.dispatch`) | [`goal-session`](../packages/goal/goal-session), [`tui`](../packages/ui/tui) |
-| `agent/disposed` | `emit` | [`packages/core/agent/src/types.ts:259`](../packages/core/agent/src/types.ts) | [`agent`](../packages/core/agent) (`events.dispatch`) | [`agent-loop`](../packages/core/agent-loop), [`goal-session`](../packages/goal/goal-session), [`tui`](../packages/ui/tui) |
-| `agent/error` | `emit` | [`packages/core/agent/src/types.ts:433`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emitAgentEvent`) | `apiproxy`, [`goal-session`](../packages/goal/goal-session), [`session-telemetry`](../packages/telemetry/session-telemetry), [`tui`](../packages/ui/tui) |
-| `agent/inbox/dequeue` | `emit` | [`packages/core/agent/src/types.ts:297`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emitAgentEvent`) | [`agent`](../packages/core/agent), `apiproxy`, [`tui`](../packages/ui/tui) |
-| `agent/inbox/discard` | `emit` | [`packages/core/agent/src/types.ts:309`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emitAgentEvent`) | [`agent`](../packages/core/agent), `apiproxy`, [`tui`](../packages/ui/tui) |
-| `agent/inbox/enqueue` | `emit` | [`packages/core/agent/src/types.ts:278`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emitAgentEvent`) | [`agent`](../packages/core/agent), `apiproxy`, [`goal-session`](../packages/goal/goal-session) |
-| `agent/inbox/update` | `emit` | [`packages/core/agent/src/types.ts:287`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emitAgentEvent`) | `apiproxy` |
-| `agent/prompt-submit` | `waterfall` | [`packages/core/agent/src/types.ts:346`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`waterfall`) | [`goal-session`](../packages/goal/goal-session), [`hooks-claude`](../packages/hooks/hooks-claude), [`hooks-codex`](../packages/hooks/hooks-codex), [`repeat-tool-guard`](../packages/guard/repeat-tool-guard), [`tui`](../packages/ui/tui) |
-| `agent/request` | `waterfall` | [`packages/core/agent/src/types.ts:372`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`waterfall`) | [`agent`](../packages/core/agent) |
-| `agent/request-error` | `waterfall` | [`packages/core/agent/src/types.ts:391`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`waterfall`) | [`compact-basic`](../packages/compact/compact-basic), [`llm-retry`](../packages/llm/llm-retry) |
-| `agent/session-start` | `emit` | [`packages/core/agent/src/types.ts:332`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emitAgentEvent`) | [`goal`](../packages/goal/goal), [`goal-session`](../packages/goal/goal-session), [`hooks-claude`](../packages/hooks/hooks-claude), [`hooks-codex`](../packages/hooks/hooks-codex), [`workspace-context`](../packages/context/workspace-context) |
-| `agent/settled` | `emit` | [`packages/core/agent/src/types.ts:420`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emitAgentEvent`) | [`compact-basic`](../packages/compact/compact-basic) |
-| `agent/status` | `emit` | [`packages/core/agent/src/types.ts:268`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emitAgentEvent`) | [`agent`](../packages/core/agent), `apiproxy`, [`goal-session`](../packages/goal/goal-session), [`tui`](../packages/ui/tui) |
-| `agent/step` | `serial` | [`packages/core/agent/src/types.ts:359`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`serial`) | [`compact-basic`](../packages/compact/compact-basic), [`plan-mode`](../packages/plan/plan-mode), [`session-checkpoint-policy`](../packages/session-persistence/session-checkpoint-policy), [`time-context`](../packages/context/time-context), [`tmux-context`](../packages/context/tmux-context), [`tool-skill`](../packages/skill/tool-skill), [`user-approval`](../packages/ui/user-approval), [`workspace-context`](../packages/context/workspace-context) |
-| `agent/turn-stopping` | `serial` | [`packages/core/agent/src/types.ts:406`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`serial`) | [`hooks-claude`](../packages/hooks/hooks-claude), [`hooks-codex`](../packages/hooks/hooks-codex) |
+| `agent/created` | `emit` | [`packages/core/agent/src/types.ts:151`](../packages/core/agent/src/types.ts) | [`agent`](../packages/core/agent) (`events.dispatch`) | [`goal-session`](../packages/goal/goal-session), [`tui`](../packages/ui/tui) |
+| `agent/disposed` | `emit` | [`packages/core/agent/src/types.ts:160`](../packages/core/agent/src/types.ts) | [`agent`](../packages/core/agent) (`events.dispatch`) | [`agent-loop`](../packages/core/agent-loop), [`goal-session`](../packages/goal/goal-session), [`tui`](../packages/ui/tui) |
+| `agent/error` | `emit` | [`packages/core/agent/src/types.ts:261`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emitAgentEvent`) | `apiproxy`, [`goal-session`](../packages/goal/goal-session), [`session-telemetry`](../packages/telemetry/session-telemetry), [`tui`](../packages/ui/tui) |
+| `agent/prompt-submit` | `waterfall` | [`packages/core/agent/src/types.ts:196`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`waterfall`) | [`goal-session`](../packages/goal/goal-session), [`hooks-claude`](../packages/hooks/hooks-claude), [`hooks-codex`](../packages/hooks/hooks-codex), [`repeat-tool-guard`](../packages/guard/repeat-tool-guard), [`tui`](../packages/ui/tui) |
+| `agent/request` | `waterfall` | [`packages/core/agent/src/types.ts:222`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`waterfall`) | [`agent`](../packages/core/agent) |
+| `agent/request-error` | `waterfall` | [`packages/core/agent/src/types.ts:234`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`waterfall`) | [`compact-basic`](../packages/compact/compact-basic), [`llm-retry`](../packages/llm/llm-retry) |
+| `agent/session-start` | `emit` | [`packages/core/agent/src/types.ts:182`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emitAgentEvent`) | [`goal`](../packages/goal/goal), [`goal-session`](../packages/goal/goal-session), [`hooks-claude`](../packages/hooks/hooks-claude), [`hooks-codex`](../packages/hooks/hooks-codex), [`workspace-context`](../packages/context/workspace-context) |
+| `agent/status` | `emit` | [`packages/core/agent/src/types.ts:170`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emitAgentEvent`) | [`agent`](../packages/core/agent), `apiproxy`, [`compact-basic`](../packages/compact/compact-basic), [`goal-session`](../packages/goal/goal-session), [`jsonrpc`](../packages/ui/jsonrpc), [`tui`](../packages/ui/tui) |
+| `agent/step` | `serial` | [`packages/core/agent/src/types.ts:209`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`serial`) | [`compact-basic`](../packages/compact/compact-basic), [`plan-mode`](../packages/plan/plan-mode), [`session-checkpoint-policy`](../packages/session-persistence/session-checkpoint-policy), [`time-context`](../packages/context/time-context), [`tmux-context`](../packages/context/tmux-context), [`tool-skill`](../packages/skill/tool-skill), [`user-approval`](../packages/ui/user-approval), [`workspace-context`](../packages/context/workspace-context) |
+| `agent/turn-stopping` | `serial` | [`packages/core/agent/src/types.ts:249`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`serial`) | [`hooks-claude`](../packages/hooks/hooks-claude), [`hooks-codex`](../packages/hooks/hooks-codex) |
 | `approval/request` | `waterfall` | [`packages/ui/user-approval/src/index.ts:30`](../packages/ui/user-approval/src/index.ts) | [`user-approval`](../packages/ui/user-approval) (`waterfall`) | [`acp`](../packages/acp/acp), `apiproxy` |
 | `commands/change` | `emit` | [`packages/ui/commands/src/index.ts:154`](../packages/ui/commands/src/index.ts) | [`commands`](../packages/ui/commands) (`events.dispatch`) | `apiproxy`, [`tui`](../packages/ui/tui) |
 | `domain/changed` | `emit` | [`packages/storage/storage-domain/src/events.ts:46`](../packages/storage/storage-domain/src/events.ts) | [`storage-domain`](../packages/storage/storage-domain) (`emit`) | `apiproxy`, [`storage-domain`](../packages/storage/storage-domain), [`workspace`](../packages/workspace/workspace) |
@@ -31,11 +25,11 @@ This matrix shows which packages dispatch each harness-owned event and which pac
 | `fs/observed` | `emit` | [`packages/fs/fs/src/index.ts:71`](../packages/fs/fs/src/index.ts) | [`tool-fs`](../packages/fs/tool-fs) (`emit`), [`tool-str-replace-editor`](../packages/fs/tool-str-replace-editor) (`emit`) | [`fs-policy`](../packages/fs/fs-policy), [`skill-local`](../packages/skill/skill-local) |
 | `fs/write-intent` | `waterfall` | [`packages/fs/fs/src/index.ts:54`](../packages/fs/fs/src/index.ts) | [`tool-fs`](../packages/fs/tool-fs) (`waterfall`), [`tool-str-replace-editor`](../packages/fs/tool-str-replace-editor) (`waterfall`) | [`fs-policy`](../packages/fs/fs-policy) |
 | `goal/changed` | `emit` | [`packages/goal/goal/src/domain.ts:135`](../packages/goal/goal/src/domain.ts) | [`goal`](../packages/goal/goal) (`emit`) | [`goal-session`](../packages/goal/goal-session) |
-| `llm/stream` | `waterfall` | [`packages/llm/llm/src/index.ts:58`](../packages/llm/llm/src/index.ts) | [`llm`](../packages/llm/llm) (`waterfall`) | [`agent-loop`](../packages/core/agent-loop), [`llm`](../packages/llm/llm), [`llm-replay`](../packages/support/llm-replay), [`session-checkpoint-policy`](../packages/session-persistence/session-checkpoint-policy), [`session-title`](../packages/session-title/session-title) |
-| `session/created` | `emit` | [`packages/core/session/src/index.ts:71`](../packages/core/session/src/index.ts) | [`session`](../packages/core/session) (`events.dispatch`) | `apiproxy`, [`compact`](../packages/compact/compact), [`goal`](../packages/goal/goal), [`hook-protocol`](../packages/hooks/hook-protocol), [`jsonrpc`](../packages/ui/jsonrpc), [`llm-retry`](../packages/llm/llm-retry), [`plan-mode`](../packages/plan/plan-mode), [`session`](../packages/core/session), [`session-persistence`](../packages/session-persistence/session-persistence), [`session-telemetry`](../packages/telemetry/session-telemetry), [`tools`](../packages/core/tools), [`user-approval`](../packages/ui/user-approval) |
-| `session/disposed` | `emit` | [`packages/core/session/src/index.ts:81`](../packages/core/session/src/index.ts) | [`session`](../packages/core/session) (`events.dispatch`) | [`agent-loop`](../packages/core/agent-loop), `apiproxy`, [`session-persistence`](../packages/session-persistence/session-persistence), [`session-projection-cache`](../packages/session-projection/session-projection-cache), [`session-telemetry`](../packages/telemetry/session-telemetry), [`session-title`](../packages/session-title/session-title) |
-| `session/event` | `emit` | [`packages/core/session/src/index.ts:93`](../packages/core/session/src/index.ts) | [`session`](../packages/core/session) (`events.dispatch`) | [`acp`](../packages/acp/acp), `apiproxy`, [`cli-demo`](../packages/examples/cli-demo), [`compact`](../packages/compact/compact), [`compact-basic`](../packages/compact/compact-basic), [`goal`](../packages/goal/goal), [`goal-session`](../packages/goal/goal-session), [`hook-protocol`](../packages/hooks/hook-protocol), [`jsonrpc`](../packages/ui/jsonrpc), [`session`](../packages/core/session), [`session-persistence`](../packages/session-persistence/session-persistence), [`session-projection`](../packages/session-projection/session-projection), [`session-projection-cache`](../packages/session-projection/session-projection-cache), [`session-telemetry`](../packages/telemetry/session-telemetry), [`session-title`](../packages/session-title/session-title), [`token-meter`](../packages/llm/token-meter), [`tools`](../packages/core/tools), [`tui`](../packages/ui/tui), [`user-approval`](../packages/ui/user-approval), [`workspace-context`](../packages/context/workspace-context) |
-| `session/flush` | `parallel` | [`packages/core/session/src/index.ts:103`](../packages/core/session/src/index.ts) | [`session`](../packages/core/session) (`events.dispatch`) | [`session-persistence`](../packages/session-persistence/session-persistence), [`session-telemetry`](../packages/telemetry/session-telemetry) |
+| `llm/stream` | `waterfall` | [`packages/llm/llm/src/index.ts:56`](../packages/llm/llm/src/index.ts) | [`llm`](../packages/llm/llm) (`waterfall`) | [`agent-loop`](../packages/core/agent-loop), [`llm`](../packages/llm/llm), [`llm-replay`](../packages/support/llm-replay), [`session-checkpoint-policy`](../packages/session-persistence/session-checkpoint-policy), [`session-title`](../packages/session-title/session-title) |
+| `session/created` | `emit` | [`packages/core/session/src/index.ts:50`](../packages/core/session/src/index.ts) | [`session`](../packages/core/session) (`events.dispatch`) | `apiproxy`, [`compact`](../packages/compact/compact), [`goal`](../packages/goal/goal), [`hook-protocol`](../packages/hooks/hook-protocol), [`jsonrpc`](../packages/ui/jsonrpc), [`llm-retry`](../packages/llm/llm-retry), [`plan-mode`](../packages/plan/plan-mode), [`session`](../packages/core/session), [`session-persistence`](../packages/session-persistence/session-persistence), [`session-telemetry`](../packages/telemetry/session-telemetry), [`tools`](../packages/core/tools), [`user-approval`](../packages/ui/user-approval) |
+| `session/disposed` | `emit` | [`packages/core/session/src/index.ts:60`](../packages/core/session/src/index.ts) | [`session`](../packages/core/session) (`events.dispatch`) | [`agent-loop`](../packages/core/agent-loop), `apiproxy`, [`session-persistence`](../packages/session-persistence/session-persistence), [`session-projection-cache`](../packages/session-projection/session-projection-cache), [`session-telemetry`](../packages/telemetry/session-telemetry), [`session-title`](../packages/session-title/session-title) |
+| `session/event` | `emit` | [`packages/core/session/src/index.ts:72`](../packages/core/session/src/index.ts) | [`session`](../packages/core/session) (`events.dispatch`) | [`acp`](../packages/acp/acp), `apiproxy`, [`cli-demo`](../packages/examples/cli-demo), [`compact`](../packages/compact/compact), [`compact-basic`](../packages/compact/compact-basic), [`goal`](../packages/goal/goal), [`goal-session`](../packages/goal/goal-session), [`hook-protocol`](../packages/hooks/hook-protocol), [`jsonrpc`](../packages/ui/jsonrpc), [`session`](../packages/core/session), [`session-persistence`](../packages/session-persistence/session-persistence), [`session-projection`](../packages/session-projection/session-projection), [`session-projection-cache`](../packages/session-projection/session-projection-cache), [`session-telemetry`](../packages/telemetry/session-telemetry), [`session-title`](../packages/session-title/session-title), [`token-meter`](../packages/llm/token-meter), [`tools`](../packages/core/tools), [`tui`](../packages/ui/tui), [`user-approval`](../packages/ui/user-approval), [`workspace-context`](../packages/context/workspace-context) |
+| `session/flush` | `parallel` | [`packages/core/session/src/index.ts:82`](../packages/core/session/src/index.ts) | [`session`](../packages/core/session) (`events.dispatch`) | [`session-persistence`](../packages/session-persistence/session-persistence), [`session-telemetry`](../packages/telemetry/session-telemetry) |
 | `skills/change` | `emit` | [`packages/skill/skill/src/index.ts:188`](../packages/skill/skill/src/index.ts) | [`skill`](../packages/skill/skill) (`events.dispatch`) | [`tui`](../packages/ui/tui) |
 | `subagent/end` | `emit` | [`packages/subagent/subagent/src/index.ts:140`](../packages/subagent/subagent/src/index.ts) | [`subagent`](../packages/subagent/subagent) (`events.dispatch`) | [`hooks-claude`](../packages/hooks/hooks-claude), [`jsonrpc`](../packages/ui/jsonrpc), [`subagent`](../packages/subagent/subagent) |
 | `subagent/provider-added` | `emit` | [`packages/subagent/subagent/src/index.ts:114`](../packages/subagent/subagent/src/index.ts) | [`subagent`](../packages/subagent/subagent) (`emit`) | [`subagent`](../packages/subagent/subagent), [`tool-subagent`](../packages/subagent/tool-subagent) |
diff --git a/examples/jsonrpc-agent/tests/sdk.snapshot.ts b/examples/jsonrpc-agent/tests/sdk.snapshot.ts
index 11c7615c48..57a99a00ef 100644
--- a/examples/jsonrpc-agent/tests/sdk.snapshot.ts
+++ b/examples/jsonrpc-agent/tests/sdk.snapshot.ts
@@ -2,7 +2,7 @@
  * Keyless snapshot coverage for the TypeScript SDK path: each scenario spawns
  * the REAL `dsh-jsonrpc-agent` runtime (per `DSH_EXAMPLE_MODE`) through the
  * REAL `@deepseek-ai/dsh-sdk-client`, drives one turn over stdio JSON-RPC,
- * and pins three surfaces — the SDK `TurnResult`, the complete notification
+ * and pins three surfaces — the SDK `RunResult`, the complete notification
  * stream, and the persisted session logs. Replay serves recorded model
  * responses via `llm-replay` (`cordis.snapshot.yml`); `DSH_SNAPSHOT=record`
  * re-records against the live API; `DSH_SNAPSHOT=refresh` replays committed
@@ -25,7 +25,7 @@ import {
   type NormalizeContext,
 } from '@deepseek-ai/dsh-acp-snapshot'
 import { resolveExampleLaunch } from '@deepseek-ai/dsh-loader-smoke'
-import { DeepSeekHarness, type HarnessNotification, type TurnResult } from '@deepseek-ai/dsh-sdk-client'
+import { DeepSeekHarness, type HarnessNotification, type RunResult } from '@deepseek-ai/dsh-sdk-client'
 
 const testsDir = dirOf(import.meta.url)
 const snapshotsDir = join(testsDir, 'snapshots')
@@ -187,18 +187,17 @@ function normalizeNotifications(notifications: readonly HarnessNotification[], c
   return normalizeStdout(`${records.map(record => JSON.stringify(record)).join('\n')}\n`, ctx)
 }
 
-/** Normalize the turn-result projection (status, reason kind, final text). */
-function normalizeResult(result: TurnResult, ctx: NormalizeContext): string {
+/** Normalize the owned-run projection. */
+function normalizeResult(result: RunResult, ctx: NormalizeContext): string {
   return normalizeStdout(`${JSON.stringify({
-    status: result.status,
-    reason: result.reason,
+    sessionId: result.sessionId,
     finalResponse: result.finalResponse,
   })}\n`, ctx)
 }
 
 /** One SDK turn against a fresh runtime subprocess in an isolated cwd. */
 async function runScenario(scenario: SdkScenario): Promise<{
-  result: TurnResult
+  result: RunResult
   notifications: HarnessNotification[]
   logs: PersistedLog[]
   observedFiles: Record<string, string | MissingFile>
@@ -351,8 +350,10 @@ describe('TypeScript SDK snapshots over the jsonrpc runtime', () => {
       expect(normalizedResult).toBe(await readFile(resultExpectedPath, 'utf8'))
 
       // Wire-shape invariants that must hold in every mode.
-      expect(result.status).toBe('ok')
-      expect(notifications.at(-1)?.method).toBe('session.finished')
+      expect(notifications.at(-1)).toMatchObject({
+        method: 'session.status',
+        params: { status: 'idle' },
+      })
       expect(observedFiles).toEqual(scenario.expectedFiles ?? {})
       if (scenario.expectedTools !== undefined) {
         const parent = ordered[0]
diff --git a/packages/acp/acp/tests/codec.spec.ts b/packages/acp/acp/tests/codec.spec.ts
index 0136ae7a94..ebee8a03c4 100644
--- a/packages/acp/acp/tests/codec.spec.ts
+++ b/packages/acp/acp/tests/codec.spec.ts
@@ -1,23 +1,7 @@
 import { describe, expect, it } from 'vitest'
-import type { TurnEndReason } from '@deepseek-ai/dsh-session'
-import { acpPromptToText, promptHasUnsupportedContent, turnEndToStopReason } from '../src/codec.ts'
+import { acpPromptToText, promptHasUnsupportedContent } from '../src/codec.ts'
 
 describe('ACP automation codec', () => {
-  it('maps every known turn outcome to a legal stop reason', () => {
-    const cases: [TurnEndReason, string][] = [
-      [{ kind: 'completed' }, 'end_turn'],
-      [{ kind: 'max-tokens' }, 'max_tokens'],
-      [{ kind: 'aborted', reason: { kind: 'user' } }, 'cancelled'],
-      [{ kind: 'interrupted' }, 'cancelled'],
-      [{ kind: 'error', error: new Error('boom') }, 'end_turn'],
-    ]
-    for (const [reason, expected] of cases) expect(turnEndToStopReason(reason)).toBe(expected)
-  })
-
-  it('uses a legal fallback for merge-extensible future outcomes', () => {
-    expect(turnEndToStopReason({ kind: 'future' } as unknown as TurnEndReason)).toBe('end_turn')
-  })
-
   it('flattens baseline blocks and rejects everything richer', () => {
     expect(acpPromptToText([{ type: 'text', text: 'a' }, { type: 'text', text: 'b' }])).toBe('ab')
     expect(acpPromptToText([
diff --git a/packages/client/runtime/src/client/sessions/request-inspection.ts b/packages/client/runtime/src/client/sessions/request-inspection.ts
index e15ad55c8b..bba937f4db 100644
--- a/packages/client/runtime/src/client/sessions/request-inspection.ts
+++ b/packages/client/runtime/src/client/sessions/request-inspection.ts
@@ -326,15 +326,6 @@ function deriveRequests(events: readonly SessionEvent[]): readonly RequestView[]
       })
       continue
     }
-    if (sourceEvent.type === 'turn/end' && sourceEvent.data.reason.kind === 'error') {
-      const reason = sourceEvent.data.reason
-      update(ordinaryByStep.get(requestKey(sourceEvent.data.turn, reason.step)), {
-        status: 'error',
-        error: 'failure' in reason ? reason.failure.message : reason.message,
-      })
-      continue
-    }
-
     const type = sourceEvent.type as string
     if (type === 'compact/start') {
       const event = sourceEvent as unknown as CompactionStartEvent
diff --git a/packages/client/runtime/src/client/sessions/session.ts b/packages/client/runtime/src/client/sessions/session.ts
index 6850e3e4c9..a686477d23 100644
--- a/packages/client/runtime/src/client/sessions/session.ts
+++ b/packages/client/runtime/src/client/sessions/session.ts
@@ -4,7 +4,7 @@ import type { Context } from 'cordis'
 import type { ContentBlock } from '@deepseek-ai/dsh-llm/types'
 import type { SessionEvent } from '@deepseek-ai/dsh-session/types'
 import type {
-  HistoryEntry, IApiClient, InboxItemId, MuxFrame, QueueAction, RpcError,
+  HistoryEntry, IApiClient, MessageId, MuxFrame, QueueAction, RpcError,
   RpcId, RpcResult, SessionId, ToolEventView,
 } from '@deepseek-ai/dsh-client-connection/client'
 // Value import from the inline-safe wire layer (not the connection plugin):
@@ -232,7 +232,7 @@ export class Session implements SessionFace {
   }
 
   /** Apply one operation to a still-pending queue occurrence. */
-  async updateQueue(itemId: InboxItemId, action: QueueAction): Promise<RpcResult<{ accepted: true }>> {
+  async updateQueue(itemId: MessageId, action: QueueAction): Promise<RpcResult<{ accepted: true }>> {
     try {
       return (await this.api.sessions.updateQueue({ sessionId: this.sessionId, itemId, action })).result
     } catch (error) {
@@ -405,8 +405,8 @@ export class Session implements SessionFace {
       case 'session/queue': {
         this.queued = frame.items.map(item => ({
           id: item.id,
-          preview: queuePreviewOf(item.message.content),
-          text: queueTextOf(item.message.content),
+          preview: queuePreviewOf(item.content),
+          text: queueTextOf(item.content),
         }))
         this.queueRev++
         this.notifier.markDirty()
diff --git a/packages/client/runtime/tests/queue-store.spec.ts b/packages/client/runtime/tests/queue-store.spec.ts
index ce684694f5..ef440cb293 100644
--- a/packages/client/runtime/tests/queue-store.spec.ts
+++ b/packages/client/runtime/tests/queue-store.spec.ts
@@ -108,7 +108,7 @@ describe('queue operation transport', () => {
     session.handleMuxEnvelope(rid('env-op'), queueFrame([{ id: 'q-op', body: 'pending' }]))
     const before = session.getSnapshot().queue
 
-    await expect(session.updateQueue(iid('q-op'), { kind: 'edit', content: text('next') }))
+    await expect(session.updateQueue(mid('q-op'), { kind: 'edit', content: text('next') }))
       .resolves.toEqual({ ok: true, value: { accepted: true } })
     expect(api.callsOf('session.updateQueue')).toEqual([{
       sessionId: SID,
diff --git a/packages/compact/compact-basic/tests/compact-basic.spec.ts b/packages/compact/compact-basic/tests/compact-basic.spec.ts
index 586934e42c..00f63ffa56 100644
--- a/packages/compact/compact-basic/tests/compact-basic.spec.ts
+++ b/packages/compact/compact-basic/tests/compact-basic.spec.ts
@@ -1383,7 +1383,10 @@ describe('automatic listener and loader composition', () => {
     const failure: LlmFailure = { message: error.message, code: error.code ?? 'UNKNOWN' }
     const turn = owner.session.events.findLast(event => event.type === 'turn/start')?.data.turn ?? 1
     return agentEvents(ctx, owner).waterfall(
-      'agent/request-error', turn, 1, error, failure, [], undefined, signal, next,
+      'agent/request-error',
+      { turn, step: 1, provider: 'test', failure, retryPolicy: undefined },
+      signal,
+      next,
     ).then(action => action?.kind === 'retry')
   }
 
diff --git a/packages/context/time-context/tests/time-context.spec.ts b/packages/context/time-context/tests/time-context.spec.ts
index 377e11abd7..884c9430ad 100644
--- a/packages/context/time-context/tests/time-context.spec.ts
+++ b/packages/context/time-context/tests/time-context.spec.ts
@@ -4,7 +4,7 @@ import Loader from '@cordisjs/plugin-loader'
 import { createUserMessage, CallId, LlmAdapter } from '@deepseek-ai/dsh-llm'
 import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm'
 import { Session, SessionId, type SessionEvent } from '@deepseek-ai/dsh-session'
-import AgentRegistry, { agentEvents, type Agent } from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { agentEvents, Inbox, type Agent } from '@deepseek-ai/dsh-agent'
 import { defineContentToolFixture } from '@deepseek-ai/dsh-tools'
 import AgentLoop from '@deepseek-ai/dsh-agent-loop'
 import { mountAgentLoopTestDependencies } from '@deepseek-ai/dsh-agent-loop-testkit'
@@ -40,6 +40,7 @@ function sessionAgent(session: Session, id = 'agent'): Agent {
     id: SessionId(id),
     options: {},
     session,
+    inbox: new Inbox(session),
     status: 'running',
     ctx: new Context(),
     followup: () => {},
diff --git a/packages/context/tmux-context/tests/tmux-context.spec.ts b/packages/context/tmux-context/tests/tmux-context.spec.ts
index a3a78c0153..4262383b7f 100644
--- a/packages/context/tmux-context/tests/tmux-context.spec.ts
+++ b/packages/context/tmux-context/tests/tmux-context.spec.ts
@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { Context } from 'cordis'
 import { Session, SessionId } from '@deepseek-ai/dsh-session'
-import AgentRegistry, { agentEvents, type Agent } from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { agentEvents, Inbox, type Agent } from '@deepseek-ai/dsh-agent'
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
 import { BashExecutor } from '@deepseek-ai/dsh-bash'
 import type { BashExecRequest, BashExecSpec, BashProcess, BashRunResult } from '@deepseek-ai/dsh-bash'
@@ -96,6 +96,7 @@ function sessionAgent(session: Session, id = 'agent'): Agent {
     id: SessionId(id),
     options: {},
     session,
+    inbox: new Inbox(session),
     status: 'running',
     ctx: new Context(),
     followup: () => {},
@@ -109,7 +110,7 @@ function sessionAgent(session: Session, id = 'agent'): Agent {
 }
 
 function openMessageTurn(session: Session, turn: number): void {
-  session.append('turn/start', { turn, trigger: { kind: 'message', source: { kind: 'user' } } })
+  session.append('turn/start', { turn })
   session.append('user/message', createUserMessage({
     content: [{ type: 'text', text: `turn ${turn}` }],
     source: { kind: 'user' },
diff --git a/packages/context/workspace-context/tests/workspace-context.spec.ts b/packages/context/workspace-context/tests/workspace-context.spec.ts
index cb4ca3533f..e23ea3205c 100644
--- a/packages/context/workspace-context/tests/workspace-context.spec.ts
+++ b/packages/context/workspace-context/tests/workspace-context.spec.ts
@@ -7,7 +7,7 @@ import Loader from '@cordisjs/plugin-loader'
 import * as workspaceContext from '@deepseek-ai/dsh-workspace-context'
 import LlmService, { createUserMessage, CallId, type Message, type StreamChunk } from '@deepseek-ai/dsh-llm'
 import SessionStore, { Session, SessionId, SESSION_FORMAT_VERSION, type SessionEvent, type UserMessage } from '@deepseek-ai/dsh-session'
-import AgentRegistry, { agentEvents, type Agent } from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { agentEvents, Inbox, type Agent } from '@deepseek-ai/dsh-agent'
 import AgentLoop from '@deepseek-ai/dsh-agent-loop'
 import { FileSystem, FsTargetKey, FsVersion } from '@deepseek-ai/dsh-fs'
 import type {
@@ -176,6 +176,7 @@ function stubAgent(cwd?: string, seed: SessionEvent[] = []): Agent {
     id: SessionId('a1'),
     options: {},
     session,
+    inbox: new Inbox(session),
     status: 'idle',
     followup: () => {},
     steer: () => {},
diff --git a/packages/cordis/tool-cordis/src/api-catalog.ts b/packages/cordis/tool-cordis/src/api-catalog.ts
index 60f7d330d8..7dc1aebf33 100644
--- a/packages/cordis/tool-cordis/src/api-catalog.ts
+++ b/packages/cordis/tool-cordis/src/api-catalog.ts
@@ -412,7 +412,7 @@ export const SERVICE_API: readonly ServiceApiEntry[] = [
       },
       {
         signature: 'stream(options: GenerateOptions): AsyncIterable<StreamChunk>',
-        jsDoc: '/**\n * Stream one model call as raw chunks (token-level deltas). Throws\n * `LlmError` with code `NO_ADAPTER` if no adapter is registered for\n * `options.provider`. Replay state is retained only when the same adapter\n * instance owns its historical provider and the target provider. Final\n * adapter selection remains fixed through asynchronous exact-model resolution\n * and dispatch. Selection, dispatch, and iteration failures retain their\n * original Error identity and are tagged in a call-local scope for narrow\n * agent-loop request recovery; middleware and nested-call failures remain\n * untagged for the outer call.\n * @param options - the full request; `options.provider` selects the adapter.\n * @returns the chunk stream, possibly wrapped by `llm/stream` listeners.\n */',
+        jsDoc: '/**\n * Stream one model call as raw chunks (token-level deltas). Replay state is\n * retained only when the same adapter instance owns its historical provider\n * and the target provider. Final adapter selection remains fixed through\n * asynchronous exact-model resolution and dispatch. Adapter selection,\n * dispatch, and iteration failures become terminal `error` or `aborted`\n * finish chunks; middleware, nested-call, cleanup, and consumer failures\n * remain thrown.\n * @param options - the full request; `options.provider` selects the adapter.\n * @returns the chunk stream, possibly wrapped by `llm/stream` listeners.\n */',
       },
     ],
   },
@@ -1119,13 +1119,6 @@ export const EVENT_API: readonly EventApiEntry[] = [
     jsDoc: '/**\n * A declarative agent entry failed before it could publish a live agent.\n * Consumers that buffer work for the configured identity use this\n * transient signal to reject that work instead of waiting forever. Normal\n * factory teardown suppresses failures from the cancelled startup attempt.\n * @param sessionId - exact shared agent/session identity that failed startup.\n * @param error - persistence, setup, or publication failure.\n * @mode emit\n */',
     summary: 'A declarative agent entry failed before it could publish a live agent.',
   },
-  {
-    name: 'agent/cancel-requested',
-    mode: 'emit',
-    signature: '\'agent/cancel-requested\'(this: Scoped<Agent>, agent: Agent, cause: AgentCancelCause): void',
-    jsDoc: '/**\n * Effective broad cancellation was requested, before queued/outbox work\n * is cleared or the active turn is aborted. This observe-only notification\n * cannot veto cancellation; listener failures are contained.\n * @param agent - the agent whose current work is being cancelled.\n * @param cause - the explicit typed cancellation cause.\n * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.\n * @mode emit\n */',
-    summary: 'Effective broad cancellation was requested, before queued/outbox work is cleared or the active turn is aborted.',
-  },
   {
     name: 'agent/created',
     mode: 'emit',
@@ -1147,40 +1140,12 @@ export const EVENT_API: readonly EventApiEntry[] = [
     jsDoc: '/**\n * A step or turn errored. The machine reports a failure here (plus the\n * logger) even when the error has no in-turn position for a durable record.\n * @param agent - the agent whose turn errored.\n * @param turn - the turn in which the failure surfaced.\n * @param step - the step at which the failure surfaced.\n * @param error - the failure, verbatim.\n * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.\n * @mode emit\n */',
     summary: 'A step or turn errored.',
   },
-  {
-    name: 'agent/inbox/dequeue',
-    mode: 'emit',
-    signature: '\'agent/inbox/dequeue\'(this: Scoped<Agent>, agent: Agent, item: InboxItem): void',
-    jsDoc: '/**\n * The driver claimed one item out of the inbox: a queued item at a turn\n * boundary, or steering drained between steps. Fires after the item leaves\n * its FIFO and before it becomes a durable message.\n * @param agent - the agent whose inbox item was claimed.\n * @param item - the exact claimed occurrence.\n * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.\n * @mode emit\n */',
-    summary: 'The driver claimed one item out of the inbox: a queued item at a turn boundary, or steering drained between steps.',
-  },
-  {
-    name: 'agent/inbox/discard',
-    mode: 'emit',
-    signature: '\'agent/inbox/discard\'(this: Scoped<Agent>, agent: Agent, items: InboxItem[]): void',
-    jsDoc: '/**\n * Pending inbox items were dropped without delivering them, so every\n * enqueue occurrence receives exactly one terminal `agent/inbox/dequeue` OR\n * `agent/inbox/discard`. `cancel()` without `keepInbox`, including disposal,\n * emits this after `agent/cancel-requested` when applicable and before\n * aborting the active work. Fires once per drop with every dropped item.\n * @param agent - the agent whose inbox items were dropped.\n * @param items - the discarded occurrences in FIFO order (queued then steering); never empty.\n * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.\n * @mode emit\n */',
-    summary: 'Pending inbox items were dropped without delivering them, so every enqueue occurrence receives exactly one terminal `agent/inbox/dequeue` OR `agent/inbox/discard`.',
-  },
-  {
-    name: 'agent/inbox/enqueue',
-    mode: 'emit',
-    signature: '\'agent/inbox/enqueue\'(this: Scoped<Agent>, agent: Agent, item: InboxItem): void',
-    jsDoc: '/**\n * An item entered the queued or steering inbox. `placement` is the\n * acceptance-time routing result; listeners must not reconstruct it from\n * later agent or session state.\n * @param agent - the owning agent.\n * @param item - accepted occurrence, message, and resolved placement.\n * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.\n * @mode emit\n */',
-    summary: 'An item entered the queued or steering inbox.',
-  },
-  {
-    name: 'agent/inbox/update',
-    mode: 'emit',
-    signature: '\'agent/inbox/update\'(this: Scoped<Agent>, agent: Agent, item: InboxItem): void',
-    jsDoc: '/**\n * A still-pending queued item changed content. The item id, placement, and\n * position remain stable while the event carries the replacement message.\n * @param agent - the owning agent.\n * @param item - the complete post-update occurrence.\n * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.\n * @mode emit\n */',
-    summary: 'A still-pending queued item changed content.',
-  },
   {
     name: 'agent/prompt-submit',
     mode: 'waterfall',
-    signature: '\'agent/prompt-submit\'(this: Scoped<Agent>, agent: Agent, message: UserMessage, signal: AbortSignal, next: () => Promise<PromptDecision>): Promise<PromptDecision>',
-    jsDoc: '/**\n * Allow, rewrite, or block one claimed prompt before it becomes a user\n * message or opens a turn. Call `next()` for the unchanged default. The\n * signal controls only this admission attempt; listeners may cooperate with\n * it but must not retain it for a later attempt or turn.\n * @param agent - the agent whose turn claimed the message.\n * @param message - the frozen claimed message, including identity and source.\n * @param signal - the current turn\'s explicit abort signal.\n * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.\n * @mode waterfall\n */',
-    summary: 'Allow, rewrite, or block one claimed prompt before it becomes a user message or opens a turn.',
+    signature: '\'agent/prompt-submit\'(this: Scoped<Agent>, agent: Agent, messages: UserMessage[], signal: AbortSignal, next: () => Promise<PromptDecision>): Promise<PromptDecision>',
+    jsDoc: '/**\n * Allow, rewrite, or block one claimed inbox batch before it becomes\n * model-visible or opens a turn. Call `next()` for the unchanged default. The\n * signal controls only this admission attempt; listeners may cooperate with\n * it but must not retain it for a later attempt or turn.\n * @param agent - the agent whose driver claimed the batch.\n * @param messages - the claimed messages.\n * @param signal - the current turn\'s explicit abort signal.\n * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.\n * @mode waterfall\n */',
+    summary: 'Allow, rewrite, or block one claimed inbox batch before it becomes model-visible or opens a turn.',
   },
   {
     name: 'agent/request',
@@ -1192,9 +1157,9 @@ export const EVENT_API: readonly EventApiEntry[] = [
   {
     name: 'agent/request-error',
     mode: 'waterfall',
-    signature: '\'agent/request-error\'(this: Scoped<Agent>, agent: Agent, turn: number, step: number, error: RequestError, failure: LlmFailure, priorFailures: readonly LlmFailure[], retryPolicy: ResolvedRetryPolicy | undefined, signal: AbortSignal, next: () => Promise<RequestErrorAction>): Promise<RequestErrorAction>',
-    jsDoc: '/**\n * Handle a model-request failure after its failed step has closed but\n * before the failed turn closes. A listener returns `{ kind: \'retry\' }`\n * without calling `next()` when it owns the error, or calls `next()` to\n * delegate. The default `undefined` leaves the failure terminal.\n * @param agent - the agent whose request failed.\n * @param turn - the open turn number.\n * @param step - the failed step number.\n * @param error - the original model-request failure.\n * @param failure - serializable facts normalized at the final adapter boundary.\n * @param priorFailures - immutable failures that already authorized another\n * retry turn in this consecutive sequence.\n * @param retryPolicy - immutable policy of the adapter registration that served\n * the failed request, or `undefined` if no final adapter served it.\n * @param signal - the turn abort signal.\n * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.\n * @mode waterfall\n */',
-    summary: 'Handle a model-request failure after its failed step has closed but before the failed turn closes.',
+    signature: '\'agent/request-error\'(this: Scoped<Agent>, agent: Agent, context: RequestFailureContext, signal: AbortSignal, next: () => Promise<RequestErrorAction>): Promise<RequestErrorAction>',
+    jsDoc: '/**\n * Handle one failed model-request attempt before the loop retries or closes\n * its step. A listener returns `{ kind: \'retry\' }` without calling `next()`\n * when it owns recovery, or calls `next()` to delegate. The default\n * `undefined` leaves the failure terminal.\n * @param agent - the agent whose request failed.\n * @param context - request coordinates, provider, normalized failure, and serving policy.\n * @param signal - the turn abort signal.\n * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.\n * @mode waterfall\n */',
+    summary: 'Handle one failed model-request attempt before the loop retries or closes its step.',
   },
   {
     name: 'agent/session-start',
@@ -1203,18 +1168,11 @@ export const EVENT_API: readonly EventApiEntry[] = [
     jsDoc: '/**\n * The session lifecycle began, once before the first turn. Use\n * `agent.inject()` to seed model-facing context. This is a notification, not\n * a veto; disposal requested by a lifecycle owner is rechecked before the\n * driver starts.\n * @param agent - the agent whose session lifecycle began.\n * @param source - why the session started (fresh startup, resume, …).\n * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.\n * @mode emit\n */',
     summary: 'The session lifecycle began, once before the first turn.',
   },
-  {
-    name: 'agent/settled',
-    mode: 'emit',
-    signature: '\'agent/settled\'(this: Scoped<Agent>, agent: Agent, turn: number, reason: SettleReason): void',
-    jsDoc: '/**\n * One drain chain reached its terminal turn: that turn\'s `turn/end` is\n * already committed. Automatically recovered failed turns do not emit this\n * notification, and neither does a run that aborts or fails before its\n * `turn/start` commits — there is no durable turn to settle against.\n * `reason` says why; model-request recovery is exhausted when an error\n * reaches it.\n * @param agent - the agent whose turn closed.\n * @param turn - the terminal turn number.\n * @param reason - why the terminal turn ended, with live error facts when it failed.\n * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.\n * @mode emit\n */',
-    summary: 'One drain chain reached its terminal turn: that turn\'s `turn/end` is already committed.',
-  },
   {
     name: 'agent/status',
     mode: 'emit',
     signature: '\'agent/status\'(this: Scoped<Agent>, agent: Agent, status: AgentStatus): void',
-    jsDoc: '/**\n * Agent status changed (`idle` ⇄ `running`). `send()` does not enter\n * `running` synchronously; drive lifecycle from this event.\n * @param agent - the agent whose status flipped.\n * @param status - the status just entered (the transition\'s destination).\n * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.\n * @mode emit\n */',
+    jsDoc: '/**\n * Agent status changed (`idle` ⇄ `running`). A waking delivery enters\n * `running` synchronously after reserving cancellation; `idle` means no\n * driver remains scheduled or active.\n * @param agent - the agent whose status flipped.\n * @param status - the status just entered (the transition\'s destination).\n * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.\n * @mode emit\n */',
     summary: 'Agent status changed (`idle` ⇄ `running`).',
   },
   {
@@ -1461,11 +1419,11 @@ export const EVENT_API: readonly EventApiEntry[] = [
 export const TYPE_API: readonly TypeApiEntry[] = [
   {
     name: 'Agent',
-    declaration: 'export interface Agent {\n    readonly id: SessionId;\n    readonly options: AgentOptions;\n    readonly session: Session;\n    readonly status: AgentStatus;\n    readonly acceptsNextStep: boolean;\n    readonly ctx: Context;\n    send(message: UserMessage, options: SendOptions): void;\n    updateInbox(id: InboxItemId, action: InboxAction): InboxActionResult;\n    cancel(cause: AgentCancelCause, options?: CancelOptions): void;\n    whenIdle(): Promise<void>;\n    followup(message: UserMessage): void;\n    steer(message: UserMessage): void;\n    inject(message: UserMessage): void;\n}',
+    declaration: 'export interface Agent {\n    readonly id: SessionId;\n    readonly options: AgentOptions;\n    readonly session: Session;\n    readonly inbox: Inbox;\n    readonly status: AgentStatus;\n    readonly ctx: Context;\n    cancel(cause: AgentCancelCause, options?: CancelOptions): void;\n    whenIdle(): Promise<void>;\n    followup(message: UserMessage): void;\n    steer(message: UserMessage): void;\n    inject(message: UserMessage): void;\n}',
   },
   {
     name: 'AgentCancelCause',
-    declaration: 'export type AgentCancelCause = {\n    readonly kind: \'user\';\n} | {\n    readonly kind: \'parent\';\n};',
+    declaration: 'export type AgentCancelCause = {\n    readonly kind: \'user\';\n} | {\n    readonly kind: \'parent\';\n} | {\n    readonly kind: \'hook\';\n    readonly reason: string;\n} | {\n    readonly kind: \'disposed\';\n};',
   },
   {
     name: 'AgentFactory',
@@ -1581,7 +1539,7 @@ export const TYPE_API: readonly TypeApiEntry[] = [
   },
   {
     name: 'CancelOptions',
-    declaration: 'export interface CancelOptions {\n    keepInbox?: boolean;\n}',
+    declaration: 'export interface CancelOptions {\n    keepInbox?: boolean | undefined;\n}',
   },
   {
     name: 'CodeBindingErrorClass',
@@ -1856,16 +1814,12 @@ export const TYPE_API: readonly TypeApiEntry[] = [
     declaration: 'export interface GoalView extends GoalSnapshot {\n    readonly roundsStarted: number;\n    readonly createdAt: number;\n    readonly updatedAt: number;\n    readonly activation: GoalActivation;\n}',
   },
   {
-    name: 'InboxAction',
-    declaration: 'export type InboxAction = {\n    readonly kind: \'edit\';\n    readonly content: ContentBlock[];\n} | {\n    readonly kind: \'remove\';\n};',
+    name: 'Inbox',
+    declaration: 'export class Inbox {\n    constructor(private readonly session: Session);\n    get nextTurn(): readonly UserMessage[];\n    get nextStep(): readonly UserMessage[];\n    get hasPending(): boolean;\n    splice(target: InboxTarget, start: number, deleteCount: number, inserted: UserMessage[], outcome?: \'admitted\' | \'canceled\'): UserMessage[];\n}',
   },
   {
-    name: 'InboxActionResult',
-    declaration: 'export type InboxActionResult = \'applied\' | \'not-found\';',
-  },
-  {
-    name: 'InboxItemId',
-    declaration: 'export type InboxItemId = Branded<\'InboxItemId\'>;',
+    name: 'InboxTarget',
+    declaration: 'export type InboxTarget = \'next-turn\' | \'next-step\';',
   },
   {
     name: 'InvariantFailure',
@@ -1969,7 +1923,7 @@ export const TYPE_API: readonly TypeApiEntry[] = [
   },
   {
     name: 'PreparedLlmCall',
-    declaration: 'export interface PreparedLlmCall {\n    readonly config: LlmCallConfig;\n    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;\n}',
+    declaration: 'export interface PreparedLlmCall {\n    readonly config: LlmCallConfig;\n    readonly retryPolicy: ResolvedRetryPolicy;\n    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;\n}',
   },
   {
     name: 'PreparedReferencedMessage',
@@ -2155,14 +2109,6 @@ export const TYPE_API: readonly TypeApiEntry[] = [
     name: 'ScopeKey',
     declaration: 'export type ScopeKey = object;',
   },
-  {
-    name: 'SendOptions',
-    declaration: 'export interface SendOptions {\n    target: SendTarget;\n    wakeup: boolean;\n}',
-  },
-  {
-    name: 'SendTarget',
-    declaration: 'export type SendTarget = \'next-turn\' | \'next-step\';',
-  },
   {
     name: 'Session',
     declaration: 'export class Session {\n    get surface(): SessionSurface;\n    readonly header: SessionHeader;\n    get id(): SessionId;\n    readonly firstLiveSeq: number;\n    constructor(id: SessionId, seed?: readonly SessionEvent[], header?: SessionHeader);\n    get events(): readonly SessionEvent[];\n    get seq(): number;\n    append<T extends SessionEventType>(type: T, data: SessionEventMap[T], ...opts: T extends SurfaceEventType ? [\n        opts: SurfaceIntent\n    ] : [\n    ]): SessionEvent<T>;\n    requestHeader(): EpochHeader | undefined;\n    deriveMessages(): Message[];\n    deriveEventMessage(event: SessionEvent): Message | null;\n}',
@@ -2177,7 +2123,7 @@ export const TYPE_API: readonly TypeApiEntry[] = [
   },
   {
     name: 'SessionEventMap',
-    declaration: 'export interface SessionEventMap {\n    \'turn/start\': {\n        turn: number;\n        trigger: TurnTrigger;\n    };\n    \'turn/end\': {\n        turn: number;\n        reason: TurnEndReason;\n    };\n    \'step/start\': {\n        turn: number;\n        step: number;\n    };\n    \'step/end\': {\n        turn: number;\n        step: number;\n    };\n    \'user/message\': UserMessage;\n    \'assistant/chunk\': {\n        turn: number;\n        step: number;\n        chunk: StreamChunk;\n    };\n    \'assistant/message\': {\n        turn: number;\n        step: number;\n        message: AssistantMessage;\n        usage?: TokenUsage;\n    };\n    \'tool/call\': {\n        turn: number;\n        step: number;\n        callId: CallId;\n        name: string;\n        arguments: string;\n    };\n    \'tool/result\': {\n        turn: number;\n        step: number;\n        message: ToolResultMessage;\n        error?: {\n            name: string;\n            code: string;\n        };\n        meta?: JsonValue;\n    };\n    \'steering/message\': {\n        turn: number;\n        message: UserMessage;\n    };\n    \'todo/write\': {\n        todos: TodoItem[];\n    };\n    \'request/header\': {\n        header: EpochHeader;\n        reason: RequestHeaderReason;\n    };\n}',
+    declaration: 'export interface SessionEventMap {\n    \'turn/start\': {\n        turn: number;\n    };\n    \'turn/end\': {\n        turn: number;\n        reason: TurnEndReason;\n    };\n    \'step/start\': {\n        turn: number;\n        step: number;\n    };\n    \'step/end\': {\n        turn: number;\n        step: number;\n    };\n    \'user/message\': UserMessage;\n    \'assistant/chunk\': {\n        turn: number;\n        step: number;\n        chunk: StreamChunk;\n    };\n    \'assistant/message\': {\n        turn: number;\n        step: number;\n        message: AssistantMessage;\n        usage?: TokenUsage;\n    };\n    \'tool/call\': {\n        turn: number;\n        step: number;\n        callId: CallId;\n        name: string;\n        arguments: string;\n    };\n    \'tool/result\': {\n        turn: number;\n        step: number;\n        message: ToolResultMessage;\n        error?: {\n            name: string;\n            code: string;\n        };\n        meta?: JsonValue;\n    };\n    \'steering/message\': {\n        turn: number;\n        message: UserMessage;\n    };\n    \'todo/write\': {\n        todos: TodoItem[];\n    };\n    \'request/header\': {\n        header: EpochHeader;\n        reason: RequestHeaderReason;\n    };\n}',
   },
   {
     name: 'SessionEventMetadataFilter',
@@ -2713,15 +2659,7 @@ export const TYPE_API: readonly TypeApiEntry[] = [
   },
   {
     name: 'TurnEndReasonMap',
-    declaration: 'export interface TurnEndReasonMap {\n    completed: {\n        kind: \'completed\';\n    };\n    aborted: {\n        kind: \'aborted\';\n    };\n    error: {\n        kind: \'error\';\n        step: number;\n    } & ({\n        failure: LlmFailure;\n        message?: never;\n        code?: never;\n    } | {\n        message: string;\n        code?: string;\n        failure?: never;\n    });\n    disposed: {\n        kind: \'disposed\';\n    };\n    \'max-tokens\': {\n        kind: \'max-tokens\';\n    };\n    interrupted: {\n        kind: \'interrupted\';\n    };\n}',
-  },
-  {
-    name: 'TurnTrigger',
-    declaration: 'export type TurnTrigger = TurnTriggerMap[keyof TurnTriggerMap];',
-  },
-  {
-    name: 'TurnTriggerMap',
-    declaration: 'export interface TurnTriggerMap {\n    message: {\n        kind: \'message\';\n        source: MessageSource;\n    };\n    retry: {\n        kind: \'retry\';\n    };\n    injection: {\n        kind: \'injection\';\n        source: MessageSource;\n    };\n}',
+    declaration: 'export interface TurnEndReasonMap {\n    completed: {\n        kind: \'completed\';\n    };\n    aborted: {\n        kind: \'aborted\';\n        reason: AgentCancelCause;\n    };\n    error: {\n        kind: \'error\';\n        error: unknown;\n    };\n    \'max-tokens\': {\n        kind: \'max-tokens\';\n    };\n    interrupted: {\n        kind: \'interrupted\';\n    };\n}',
   },
   {
     name: 'TypertContribution',
diff --git a/packages/core/agent-loop/tests/cancel.spec.ts b/packages/core/agent-loop/tests/cancel.spec.ts
index 87796c97b6..e86d1f9636 100644
--- a/packages/core/agent-loop/tests/cancel.spec.ts
+++ b/packages/core/agent-loop/tests/cancel.spec.ts
@@ -235,7 +235,7 @@ describe('Agent.cancel()', () => {
     agent.cancel({ kind: 'user' })
     await waitForIdle(ctx, agent)
 
-    expect(reasons).toEqual([{ kind: 'aborted' }])
+    expect(reasons).toEqual([{ kind: 'aborted', reason: { kind: 'user' } }])
     expect(userTexts(agent)).toEqual(['go'])
     expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(1)
     expect(adapter.requests).toHaveLength(1)
@@ -272,7 +272,7 @@ describe('Agent.cancel()', () => {
     dispose()
 
     expect(executions).toBe(0)
-    expect(reasons).toEqual([{ kind: 'aborted' }])
+    expect(reasons).toEqual([{ kind: 'aborted', reason: { kind: 'user' } }])
     const call = agent.session.events.find(event => event.type === 'tool/call')
     const result = agent.session.events.find(event => event.type === 'tool/result')
     expect(call?.type === 'tool/call' ? call.data.callId : undefined).toBe('c1')
@@ -291,7 +291,7 @@ describe('Agent.cancel()', () => {
       .find(block => block.type === 'tool-result')
     expect(replayedResult).toMatchObject({ toolCallId: 'c1', isError: true })
     expect(reasons).toEqual([
-      { kind: 'aborted' },
+      { kind: 'aborted', reason: { kind: 'user' } },
       { kind: 'completed' },
     ])
   })
@@ -342,7 +342,7 @@ describe('Agent.cancel()', () => {
     // the caller's cause — the marker carries `cancel(cause)` through even
     // though no AbortController observed it in this window.
     expect(streamed).toBe(false)
-    expect(reasons).toEqual([{ kind: 'aborted' }])
+    expect(reasons).toEqual([{ kind: 'aborted', reason: { kind: 'user' } }])
   })
 
   it('cancel from a synchronous step/start session-event listener drops the step (post-step-start window)', async () => {
@@ -370,12 +370,12 @@ describe('Agent.cancel()', () => {
     // No step streamed, the turn ended with the coarse aborted outcome, and the
     // log is balanced (the open step was closed by the cancel branch).
     expect(streamed).toBe(false)
-    expect(reasons).toEqual([{ kind: 'aborted' }])
+    expect(reasons).toEqual([{ kind: 'aborted', reason: { kind: 'user' } }])
     const types = agent.session.events.map(e => e.type)
     expect(types.filter(t => t === 'step/start').length).toBe(types.filter(t => t === 'step/end').length)
   })
 
-  it('disposal from a synchronous step/start session-event listener closes the open step as disposed', async () => {
+  it('disposal from a synchronous step/start session-event listener stops before adapter dispatch', async () => {
     const adapter = new MockAdapter([textResponse('should not stream')])
     const ctx = new Context()
     await ctx.plugin(LlmService)
@@ -405,8 +405,7 @@ describe('Agent.cancel()', () => {
 
     expect(streamed).toBe(false)
     expect(adapter.requests).toHaveLength(0)
-    const turnEnd = agent.session.events.findLast(e => e.type === 'turn/end')
-    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'disposed' })
+    expect(agent.session.events.some(e => e.type === 'turn/end')).toBe(false)
     const types = agent.session.events.map(e => e.type)
     expect(types.filter(t => t === 'step/start').length).toBe(types.filter(t => t === 'step/end').length)
   })
@@ -437,7 +436,7 @@ describe('Agent.cancel()', () => {
     // Only ONE step ran (the second was cancelled in the stopping window),
     // and the shared turn signal classified the durable outcome as aborted.
     expect(steps).toBe(1)
-    expect(reasons).toEqual([{ kind: 'aborted' }])
+    expect(reasons).toEqual([{ kind: 'aborted', reason: { kind: 'user' } }])
   })
 
   it('cancel from a synchronous agent/status(running) listener drops the turn (window 2)', async () => {
@@ -569,10 +568,10 @@ describe('Agent.cancel()', () => {
     const reasons = agent.session.events
       .filter(event => event.type === 'turn/end')
       .map(event => event.type === 'turn/end' ? event.data.reason : undefined)
-    expect(reasons).toEqual([{ kind: 'aborted' }, { kind: 'completed' }])
+    expect(reasons).toEqual([{ kind: 'aborted', reason: { kind: 'user' } }, { kind: 'completed' }])
   })
 
-  it('keeps the first typed cause for an active turn and detaches the runtime reason', async () => {
+  it('keeps the first typed cause for an active turn', async () => {
     const adapter = new MockAdapter(['hang'])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('typed-first-wins'), { provider: 'mock', model: 'mock' })
@@ -581,16 +580,17 @@ describe('Agent.cancel()', () => {
     send(agent, 'go')
     await expect.poll(() => adapter.requests.length).toBe(1)
     agent.cancel(supplied)
-    supplied.kind = 'user'
     agent.cancel({ kind: 'user' })
     await waitForIdle(ctx, agent)
 
     const runtimeReason: unknown = adapter.requests[0]?.signal?.reason
     expect(runtimeReason).toEqual({ kind: 'parent' })
-    expect(runtimeReason).not.toBe(supplied)
-    expect(Object.isFrozen(runtimeReason)).toBe(true)
+    expect(runtimeReason).toBe(supplied)
     const turnEnd = agent.session.events.findLast(event => event.type === 'turn/end')
-    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted' })
+    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({
+      kind: 'aborted',
+      reason: { kind: 'parent' },
+    })
   })
 
   it('preserves the first user cancellation when lifecycle teardown races it', async () => {
@@ -608,7 +608,7 @@ describe('Agent.cancel()', () => {
     await handle.dispose()
 
     const turnEnd = agent.session.events.findLast(event => event.type === 'turn/end')
-    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted' })
+    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted', reason: { kind: 'user' } })
   })
 
   it.each([
@@ -688,7 +688,7 @@ describe('Agent.cancel()', () => {
     if (stage === 'prompt-submit') {
       expect(turnEnd).toBeUndefined()
     } else {
-      expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted' })
+      expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted', reason: { kind: 'user' } })
     }
     await ctx.fiber.dispose()
   })
diff --git a/packages/core/agent-loop/tests/contract-regressions.spec.ts b/packages/core/agent-loop/tests/contract-regressions.spec.ts
index a87afb578b..70682656d7 100644
--- a/packages/core/agent-loop/tests/contract-regressions.spec.ts
+++ b/packages/core/agent-loop/tests/contract-regressions.spec.ts
@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
 import LlmService, { createUserMessage, freezeMessage, CallId, MessageSource, ProviderRequestId, StreamChunk  } from '@deepseek-ai/dsh-llm'
-import SessionStore, { Session, SessionEvent, SessionId, TurnEndReason } from '@deepseek-ai/dsh-session'
+import SessionStore, { Session, SessionEvent, SessionId, TurnEndReason, type UserMessage } from '@deepseek-ai/dsh-session'
 import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
 import ToolRegistry, { defineContentToolFixture, type PostToolDecision } from '@deepseek-ai/dsh-tools'
 import AgentRegistry, { type Agent } from '@deepseek-ai/dsh-agent'
@@ -268,7 +268,7 @@ describe('abort during tool execution ends the turn', () => {
         [{ type: 'text', text: 'accepted result context during disposal' }],
       ])
     expect(agent.session.events.find(event => event.type === 'turn/end')?.data.reason)
-      .toEqual({ kind: 'disposed' })
+      .toEqual({ kind: 'aborted', reason: { kind: 'disposed' } })
   })
 
   it('limits injection deferral to the current tool batch', async () => {
@@ -390,7 +390,6 @@ describe('steering from late extension points is never stranded', () => {
       if (event.type === 'turn/start') turns.push(event.data.turn)
       if (event.type === 'turn/end' && !steeredOnce) {
         steeredOnce = true
-        expect(agent.acceptsNextStep).toBe(false)
         agent.steer(createUserMessage({ content: [{ type: 'text', text: 'too late for this turn' }], source: { kind: 'user' } }))
       }
     })
@@ -461,7 +460,7 @@ describe('disposal leaves the two-state status contract balanced', () => {
     await driverDone(agent)
 
     expect(statuses).toEqual(['running', 'idle'])
-    expect(reasons).toEqual([{ kind: 'disposed' }])
+    expect(reasons).toEqual([{ kind: 'aborted', reason: { kind: 'disposed' } }])
     expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(1)
     const messages = agent.session.events
       .filter(event => event.type === 'user/message')
@@ -956,7 +955,7 @@ describe('turn and step boundary recovery', () => {
     const turnEnds = e.filter(x => x.type === 'turn/end').length
     expect(turnStarts).toBe(1)
     expect(turnEnds).toBe(1) // balanced — the turn was closed despite disposal
-    expect(reasons).toEqual([{ kind: 'disposed' }])
+    expect(reasons).toEqual([{ kind: 'aborted', reason: { kind: 'disposed' } }])
     // no error reason: disposal is not a failure.
     expect(e.some(x => x.type === 'turn/end' && x.data.reason.kind === 'error')).toBe(false)
   })
@@ -989,7 +988,7 @@ describe('turn and step boundary recovery', () => {
     // Balanced: one turn/start, one turn/end carrying disposed (NOT error).
     expect(e.filter(x => x.type === 'turn/start')).toHaveLength(1)
     const turnEnd = e.findLast(x => x.type === 'turn/end')
-    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'disposed' })
+    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted', reason: { kind: 'disposed' } })
     expect(e.some(x => x.type === 'turn/end' && x.data.reason.kind === 'error')).toBe(false)
     // No step opened (the throw was before step/start) and disposal is not a
     // failure, so no agent/error for the contained throw.
@@ -1225,7 +1224,7 @@ describe('disposal and cancellation during pre-step assembly', () => {
     expect(e.filter(x => x.type === 'turn/start')).toHaveLength(1)
     expect(e.filter(x => x.type === 'turn/end')).toHaveLength(1)
     const turnEnd = e.findLast(x => x.type === 'turn/end')
-    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'disposed' })
+    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted', reason: { kind: 'disposed' } })
     expect(e.some(x => x.type === 'step/start')).toBe(false)
     expect(e.some(x => x.type === 'assistant/chunk')).toBe(false)
   })
@@ -1272,12 +1271,12 @@ describe('disposal and cancellation during pre-step assembly', () => {
     expect(e.filter(x => x.type === 'turn/start')).toHaveLength(1)
     expect(e.filter(x => x.type === 'turn/end')).toHaveLength(1)
     const turnEnd = e.findLast(x => x.type === 'turn/end')
-    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted' })
+    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted', reason: { kind: 'user' } })
     expect(e.some(x => x.type === 'step/start')).toBe(false)
     expect(e.some(x => x.type === 'assistant/chunk')).toBe(false)
     expect(e.some(x => x.type === 'assistant/message')).toBe(false)
     expect(adapter.requests).toHaveLength(0)
-    expect(reasons).toEqual([{ kind: 'aborted' }])
+    expect(reasons).toEqual([{ kind: 'aborted', reason: { kind: 'user' } }])
   })
 
   it('disposal during agent/step listeners ends the turn disposed', { timeout: 15000 }, async () => {
@@ -1324,7 +1323,7 @@ describe('disposal and cancellation during pre-step assembly', () => {
     expect(e.filter(x => x.type === 'turn/end')).toHaveLength(1)
     const turnEnd = e.findLast(x => x.type === 'turn/end')
     // Disposal wins the post-listener check — reason is `disposed`.
-    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'disposed' })
+    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted', reason: { kind: 'disposed' } })
     expect(e.some(x => x.type === 'step/start')).toBe(false)
     expect(e.some(x => x.type === 'assistant/chunk')).toBe(false)
     // The durable turn/end record is the authoritative turn-boundary signal
@@ -1372,10 +1371,10 @@ describe('disposal and cancellation during pre-step assembly', () => {
     expect(e.filter(x => x.type === 'turn/start')).toHaveLength(1)
     expect(e.filter(x => x.type === 'turn/end')).toHaveLength(1)
     const turnEnd = e.findLast(x => x.type === 'turn/end')
-    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted' })
+    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted', reason: { kind: 'user' } })
     expect(e.some(x => x.type === 'step/start')).toBe(false)
     expect(e.some(x => x.type === 'assistant/chunk')).toBe(false)
-    expect(reasons).toEqual([{ kind: 'aborted' }])
+    expect(reasons).toEqual([{ kind: 'aborted', reason: { kind: 'user' } }])
   })
 
   it('disposal during assembly does not leak an LLM call or append assistant/chunk', { timeout: 15000 }, async () => {
diff --git a/packages/core/agent-loop/tests/coverage-edges.spec.ts b/packages/core/agent-loop/tests/coverage-edges.spec.ts
index 5a2ef01b7e..1ee67e70b8 100644
--- a/packages/core/agent-loop/tests/coverage-edges.spec.ts
+++ b/packages/core/agent-loop/tests/coverage-edges.spec.ts
@@ -165,8 +165,8 @@ describe('thrown-value propagation', () => {
     expect(errors[0]).toEqual({ code: 500 })
     const turnEnd = agent.session.events.find(e => e.type === 'turn/end')
     expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason.kind === 'error'
-      && ('failure' in turnEnd.data.reason ? turnEnd.data.reason.failure.code : turnEnd.data.reason.code))
-      .toBeUndefined()
+      ? turnEnd.data.reason.error
+      : undefined).toEqual({ code: 500 })
   })
 })
 
@@ -197,8 +197,7 @@ describe('coded error data emission', () => {
     const turnEnd = agent.session.events.find(e => e.type === 'turn/end')
     expect(turnEnd).toBeDefined()
     if (turnEnd?.type === 'turn/end' && turnEnd.data.reason.kind === 'error') {
-      expect('failure' in turnEnd.data.reason ? turnEnd.data.reason.failure.code : turnEnd.data.reason.code)
-        .toBe('RATE_LIMIT')
+      expect(turnEnd.data.reason.error).toMatchObject({ code: 'RATE_LIMIT' })
     }
   })
 })
@@ -221,7 +220,7 @@ describe('disposed vs aborted branching', () => {
     await driverDone(agent)
 
     // Disposal wins abort classification because the error path checks it first.
-    expect(reasons).toContainEqual({ kind: 'disposed' })
+    expect(reasons).toContainEqual({ kind: 'aborted', reason: { kind: 'disposed' } })
   })
 })
 
@@ -285,9 +284,7 @@ describe('request-error action edges', () => {
     ])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('retry-raced'), { provider: 'mock', model: 'mock' })
-    ctx.on('agent/request-error', async (
-      subject, _turn, _step, _error, _failure, _priorFailures, _retryPolicy, signal, next,
-    ) => {
+    ctx.on('agent/request-error', async (subject, _context, signal, next) => {
       await next()
       subject.cancel({ kind: 'user' })
       expect(signal.aborted).toBe(true)
@@ -480,7 +477,7 @@ describe('unrenderable failure settlement', () => {
     if (end?.type === 'turn/end' && end.data.reason.kind === 'error') {
       // The durable failure keeps the adapter facts' message, not the
       // unrenderable chain.
-      expect(end.data.reason.failure?.message).not.toBe('<unrenderable value>')
+      expect(errorChain(end.data.reason.error)).not.toBe('<unrenderable value>')
     }
   })
 })
@@ -493,10 +490,11 @@ describe('driver bookkeeping edges', () => {
       provider: 'mock',
       model: 'mock',
     })
-    ctx.on('agent/inbox/enqueue', (subject) => {
-      if (subject !== agent) return
-      subject.cancel({ kind: 'user' })
-      const mutable = subject as Agent & { done: Promise<void> }
+    ctx.on('session/event', (session, event) => {
+      if (session !== agent.session || event.type !== 'agent/inbox/spliced'
+        || event.data.target !== 'next-turn' || event.data.inserted.length === 0) return
+      agent.cancel({ kind: 'user' })
+      const mutable = agent as Agent & { done: Promise<void> }
       mutable.done = Promise.reject(new Error('replacement rejected'))
     })
 
diff --git a/packages/core/agent-loop/tests/interception.spec.ts b/packages/core/agent-loop/tests/interception.spec.ts
index faa23a2657..832181adb5 100644
--- a/packages/core/agent-loop/tests/interception.spec.ts
+++ b/packages/core/agent-loop/tests/interception.spec.ts
@@ -11,7 +11,6 @@ import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
 import ToolRegistry, { defineContentToolFixture, type PostToolDecision, type PreToolDecision } from '@deepseek-ai/dsh-tools'
 import AgentRegistry, {
   type Agent,
-  type InboxPlacement,
   type PromptDecision,
   type SessionStartSource,
 } from '@deepseek-ai/dsh-agent'
@@ -66,8 +65,8 @@ describe('agent/prompt-submit', () => {
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     const seen: string[] = []
-    ctx.on('agent/prompt-submit', async (_agent, message, _signal, next) => {
-      seen.push(message.content.map(b => (b.type === 'text' ? b.text : '')).join(''))
+    ctx.on('agent/prompt-submit', async (_agent, messages, _signal, next) => {
+      seen.push(messages[0]!.content.map(b => (b.type === 'text' ? b.text : '')).join(''))
       return next()
     })
 
@@ -86,9 +85,9 @@ describe('agent/prompt-submit', () => {
     const entered = Promise.withResolvers<undefined>()
     const decision = Promise.withResolvers<PromptDecision>()
     const observed: UserMessage[] = []
-    ctx.on('agent/inbox/enqueue', (subject, item) => {
-      if (subject !== agent) return
-      const message = item.message
+    ctx.on('agent/prompt-submit', async (subject, messages) => {
+      if (subject !== agent) return { kind: 'allow', messages }
+      const message = messages[0]!
       expect(Object.isFrozen(message)).toBe(true)
       expect(Object.isFrozen(message.content)).toBe(true)
       expect(Object.isFrozen(message.content[0])).toBe(true)
@@ -97,11 +96,7 @@ describe('agent/prompt-submit', () => {
         const block = message.content[0]
         if (block?.type === 'text') block.text = 'listener mutation'
       }).toThrow()
-    })
-    ctx.on('agent/inbox/enqueue', (subject, item) => {
-      if (subject === agent) observed.push(item.message)
-    })
-    ctx.on('agent/prompt-submit', async () => {
+      observed.push(message)
       entered.resolve(undefined)
       return decision.promise
     })
@@ -120,7 +115,7 @@ describe('agent/prompt-submit', () => {
     expect(() => {
       if (input.source.kind === 'plugin') input.source.plugin = 'caller mutation'
     }).toThrow(TypeError)
-    decision.resolve({ kind: 'allow' })
+    decision.resolve({ kind: 'allow', messages: [input] })
     await idle
 
     expect(observed).toHaveLength(1)
@@ -138,8 +133,11 @@ describe('agent/prompt-submit', () => {
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    ctx.on('agent/prompt-submit', async (): Promise<PromptDecision> =>
-      ({ kind: 'allow', content: [{ type: 'text', text: 'REWRITTEN' }] }))
+    ctx.on('agent/prompt-submit', async (_agent, messages): Promise<PromptDecision> =>
+      ({
+        kind: 'allow',
+        messages: [{ ...messages[0]!, content: [{ type: 'text', text: 'REWRITTEN' }] }],
+      }))
 
     send(agent, 'original')
     await waitForIdle(ctx, agent)
@@ -156,10 +154,10 @@ describe('agent/prompt-submit', () => {
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    ctx.on('agent/prompt-submit', async (): Promise<PromptDecision> =>
+    ctx.on('agent/prompt-submit', async (_agent, messages): Promise<PromptDecision> =>
       ({
         kind: 'allow',
-        additionalContexts: [createUserMessage({
+        messages: [...messages, createUserMessage({
           content: [{ type: 'text', text: '<system-reminder>extra ctx</system-reminder>' }],
           source: { kind: 'plugin', plugin: 'test' },
         })],
@@ -183,11 +181,13 @@ describe('agent/prompt-submit', () => {
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    ctx.on('agent/prompt-submit', async (): Promise<PromptDecision> =>
+    ctx.on('agent/prompt-submit', async (_agent, messages): Promise<PromptDecision> =>
       ({
         kind: 'allow',
-        content: [{ type: 'text', text: 'REWRITTEN prompt' }],
-        additionalContexts: [createUserMessage({
+        messages: [{
+          ...messages[0]!,
+          content: [{ type: 'text', text: 'REWRITTEN prompt' }],
+        }, createUserMessage({
           content: [{ type: 'text', text: 'injected ctx' }], source: { kind: 'plugin', plugin: 'test' },
         })],
       }))
@@ -236,20 +236,17 @@ describe('agent/prompt-submit', () => {
     const agent = ctx.agentLoop.create(SessionId('admission-outbox'), { provider: 'mock', model: 'mock' })
     const entered = Promise.withResolvers<undefined>()
     const decision = Promise.withResolvers<PromptDecision>()
-    const placements: InboxPlacement[] = []
-    ctx.on('agent/prompt-submit', async () => {
+    let claimed: UserMessage[] = []
+    ctx.on('agent/prompt-submit', async (_agent, messages) => {
+      claimed = messages
       entered.resolve(undefined)
       return decision.promise
     })
-    ctx.on('agent/inbox/enqueue', (subject, item) => {
-      if (subject === agent) placements.push(item.placement)
-    })
 
     const idle = waitForIdle(ctx, agent)
     send(agent, 'admitted prompt')
     await entered.promise
     expect(agent.status).toBe('running')
-    expect(agent.acceptsNextStep).toBe(true)
     expect(events(agent).some(event => event.type === 'turn/start')).toBe(false)
 
     agent.inject(createUserMessage({
@@ -258,11 +255,15 @@ describe('agent/prompt-submit', () => {
     }))
     agent.steer(createUserMessage({ content: [{ type: 'text', text: 'admission steering' }], source: { kind: 'user' } }))
     expect(events(agent).some(event => event.type === 'user/message')).toBe(false)
-    expect(placements).toEqual(['queued', 'steering'])
+    expect(agent.inbox.nextStep.map(message => message.content[0]))
+      .toEqual([
+        { type: 'text', text: 'attached context' },
+        { type: 'text', text: 'admission steering' },
+      ])
 
-    decision.resolve({ kind: 'allow' })
+    decision.resolve({ kind: 'allow', messages: claimed })
     await idle
-    expect(agent.acceptsNextStep).toBe(false)
+    expect(agent.inbox.hasPending).toBe(false)
 
     const staged = events(agent).filter(event =>
       event.type === 'turn/start' || event.type === 'user/message' || event.type === 'steering/message')
@@ -298,7 +299,6 @@ describe('agent/prompt-submit', () => {
     const blockedIdle = waitForIdle(ctx, agent)
     send(agent, 'blocked prompt')
     await entered.promise
-    expect(agent.acceptsNextStep).toBe(true)
     agent.inject(createUserMessage({
       content: [{ type: 'text', text: 'staged context' }],
       source: { kind: 'plugin', plugin: 'test' },
@@ -307,7 +307,7 @@ describe('agent/prompt-submit', () => {
     decision.resolve({ kind: 'block', reason: 'policy' })
     await blockedIdle
 
-    expect(agent.acceptsNextStep).toBe(false)
+    expect(agent.inbox.nextStep).toHaveLength(2)
     expect(events(agent)).toEqual([])
     expect(adapter.requests).toEqual([])
 
@@ -334,14 +334,16 @@ describe('agent/prompt-submit', () => {
       provider: 'mock',
       model: 'mock',
     })
-    ctx.on('agent/prompt-submit', async (_agent, message, _signal, next) => {
+    ctx.on('agent/prompt-submit', async (_agent, messages, _signal, next) => {
       const decision = await next()
-      return message.content.some(block => block.type === 'text' && block.text === 'blocked prompt')
+      return messages.some(message =>
+        message.content.some(block => block.type === 'text' && block.text === 'blocked prompt'))
         ? { kind: 'block', reason: 'policy' }
         : decision
     })
-    ctx.on('agent/prompt-submit', async (subject, message, _signal, next) => {
-      if (message.content.some(block => block.type === 'text' && block.text === 'blocked prompt')) {
+    ctx.on('agent/prompt-submit', async (subject, messages, _signal, next) => {
+      if (messages.some(message =>
+        message.content.some(block => block.type === 'text' && block.text === 'blocked prompt'))) {
         subject.inject(createUserMessage({
           content: [{ type: 'text', text: 'earlier state change' }],
           source: { kind: 'plugin', plugin: 'test' },
@@ -446,8 +448,9 @@ describe('agent/prompt-submit', () => {
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    ctx.on('agent/prompt-submit', async (_agent, message, _signal, next): Promise<PromptDecision> => {
-      const text = message.content.map(b => (b.type === 'text' ? b.text : '')).join('')
+    ctx.on('agent/prompt-submit', async (_agent, messages, _signal, next): Promise<PromptDecision> => {
+      const text = messages.flatMap(message => message.content)
+        .map(b => (b.type === 'text' ? b.text : '')).join('')
       return text === 'secret' ? { kind: 'block', reason: 'policy: no secrets' } : next()
     })
 
@@ -475,9 +478,9 @@ describe('agent/prompt-submit', () => {
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     let threw = false
-    ctx.on('agent/prompt-submit', async () => {
+    ctx.on('agent/prompt-submit', async (_agent, messages) => {
       if (!threw) { threw = true; throw new Error('prompt hook broke') }
-      return { kind: 'allow' as const }
+      return { kind: 'allow' as const, messages }
     })
     const errors: Error[] = []
     const reasons: TurnEndReason[] = []
@@ -680,8 +683,9 @@ describe('worked example: a native hook plugin is just a cordis plugin on the se
         agent.inject(createUserMessage({ content: [{ type: 'text', text: `policy active (started: ${source})` }], source: { kind: 'plugin', plugin: 'native-guard' } }))
       })
       // 2. PromptSubmit: block a forbidden prompt, annotate the rest.
-      ctx.on('agent/prompt-submit', async (_agent, message, _signal, next): Promise<PromptDecision> => {
-        const text = message.content.map(b => (b.type === 'text' ? b.text : '')).join('')
+      ctx.on('agent/prompt-submit', async (_agent, messages, _signal, next): Promise<PromptDecision> => {
+        const text = messages.flatMap(message => message.content)
+          .map(b => (b.type === 'text' ? b.text : '')).join('')
         if (text.includes('rm -rf')) return { kind: 'block', reason: 'destructive prompt blocked' }
         return next()
       })
diff --git a/packages/core/agent-loop/tests/loop.spec.ts b/packages/core/agent-loop/tests/loop.spec.ts
index bf71b5f591..7629c69276 100644
--- a/packages/core/agent-loop/tests/loop.spec.ts
+++ b/packages/core/agent-loop/tests/loop.spec.ts
@@ -94,11 +94,10 @@ describe('agent loop', () => {
     expect(order).toEqual(['turn/start', 'step/start', 'step/end', 'turn/end'])
 
     const types = agent.session.events.map(e => e.type)
-    // turn/start opens the turn, THEN the queued user message is recorded inside
-    // it (every event is turn-enclosed), then the assembled message (carrying the
-    // step's usage).
-    expect(types[0]).toBe('turn/start')
-    expect(types[1]).toBe('user/message')
+    // Durable inbox receipt and admission bracket the turn-owned transcript.
+    expect(types[0]).toBe('agent/inbox/spliced')
+    expect(types).toContain('turn/start')
+    expect(types).toContain('user/message')
     expect(types).toContain('assistant/message')
     const assistantMessage = agent.session.events.find(e => e.type === 'assistant/message')
     expect(assistantMessage?.type === 'assistant/message' && assistantMessage.data.usage).toEqual({ inputTokens: 10, outputTokens: 'hello there'.length })
@@ -201,9 +200,12 @@ describe('agent loop', () => {
     await waitForIdle(ctx, agent)
 
     expect(adapter.requests).toHaveLength(0) // the request was never sent
-    expect(errors.some(e => e.message.includes('no value for this assembly'))).toBe(true)
+    expect(errors).toEqual([])
     const turnEnd = agent.session.events.find(e => e.type === 'turn/end')
     expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason.kind).toBe('error')
+    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason.kind === 'error'
+      ? turnEnd.data.reason.error
+      : '').toContain('no value for this assembly')
 
     // The loop survived: a waterfall listener rescues {{cwd}} and the SAME
     // agent completes a real model turn.
@@ -307,9 +309,11 @@ describe('agent loop', () => {
     await waitForIdle(ctx, agent)
 
     const types = agent.session.events.map(e => e.type)
-    expect(types).toContain('steering/message')
-    // steering recorded before the second step's request derived its history
-    const steeringSeq = agent.session.events.find(e => e.type === 'steering/message')!.seq
+    const steering = agent.session.events.find(e =>
+      e.type === 'user/message' && JSON.stringify(e.data.content).includes('change of plans'))
+    expect(steering).toBeDefined()
+    // Steering is admitted before the second step's request derives history.
+    const steeringSeq = steering!.seq
     const secondStepStart = agent.session.events.filter(e => e.type === 'step/start')[1]
     expect(secondStepStart).toBeDefined()
     expect(steeringSeq).toBeLessThan(secondStepStart!.seq)
@@ -320,8 +324,8 @@ describe('agent loop', () => {
     expect(flat).toContain('change of plans')
   })
 
-  it('same-tick idle steering preserves one turn per send', async () => {
-    const adapter = new MockAdapter([textResponse('first'), textResponse('second')])
+  it('coalesces same-tick idle steering into one turn', async () => {
+    const adapter = new MockAdapter([textResponse('first')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
@@ -330,7 +334,7 @@ describe('agent loop', () => {
     agent.steer(createUserMessage({ content: [{ type: 'text', text: 'second idle steer' }], source: { kind: 'user' } }))
     await idle
 
-    expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(2)
+    expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(1)
     expect(agent.session.events
       .filter(event => event.type === 'user/message')
       .map(event => event.data.content)).toEqual([
@@ -338,13 +342,12 @@ describe('agent loop', () => {
       [{ type: 'text', text: 'second idle steer' }],
     ])
     expect(agent.session.events.filter(event => event.type === 'steering/message')).toEqual([])
-    expect(adapter.requests).toHaveLength(2)
+    expect(adapter.requests).toHaveLength(1)
     expect(JSON.stringify(adapter.requests[0]?.messages)).toContain('first idle steer')
-    expect(JSON.stringify(adapter.requests[0]?.messages)).not.toContain('second idle steer')
-    expect(JSON.stringify(adapter.requests[1]?.messages)).toContain('second idle steer')
+    expect(JSON.stringify(adapter.requests[0]?.messages)).toContain('second idle steer')
   })
 
-  it('keeps steering staged after a failed step until the next admitted turn', async () => {
+  it('contains a throwing step observer and carries steering into a replacement turn', async () => {
     const adapter = new MockAdapter([textResponse('recovered')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('failed-steering'), { provider: 'mock', model: 'mock' })
@@ -359,20 +362,13 @@ describe('agent loop', () => {
     send(agent, 'prompt')
     await waitForIdle(ctx, agent)
 
-    expect(adapter.requests).toHaveLength(0)
-    expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(1)
-    expect(agent.session.events.some(event => event.type === 'steering/message')).toBe(false)
-
-    send(agent, 'resume')
-    await waitForIdle(ctx, agent)
-
     expect(adapter.requests).toHaveLength(1)
     expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(2)
-    expect(agent.session.events.some(event => event.type === 'steering/message')).toBe(true)
+    expect(agent.session.events.some(event => event.type === 'steering/message')).toBe(false)
     expect(JSON.stringify(adapter.requests[0]?.messages)).toContain('pending steering')
   })
 
-  it('inject() while idle appends context without opening a turn', async () => {
+  it('inject() while idle durably stages context without opening a turn', async () => {
     const adapter = new MockAdapter([textResponse('ok')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
@@ -382,11 +378,14 @@ describe('agent loop', () => {
     expect(adapter.requests).toHaveLength(0)
     expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(0)
     expect(agent.session.events.at(-1)).toMatchObject({
-      type: 'user/message',
+      type: 'agent/inbox/spliced',
       data: {
-        role: 'user',
-        content: [{ type: 'text', text: 'file changed: a.ts' }],
-        source: { kind: 'plugin', plugin: 'watcher' },
+        target: 'next-step',
+        inserted: [{
+          role: 'user',
+          content: [{ type: 'text', text: 'file changed: a.ts' }],
+          source: { kind: 'plugin', plugin: 'watcher' },
+        }],
       },
     })
 
@@ -540,7 +539,7 @@ describe('agent loop', () => {
     expect(agent.session.events.some(e => e.type === 'tool/result')).toBe(true)
   })
 
-  it('a concluding tool result beats steering that arrived during the same step', async () => {
+  it('continues for steering that arrived during a concluding tool step', async () => {
     const adapter = new MockAdapter([
       toolCallResponse('c1', 'finalize', {}),
       textResponse('next turn reply'),
@@ -562,17 +561,10 @@ describe('agent loop', () => {
     send(agent, 'go')
     await waitForIdle(ctx, agent)
 
-    // The terminal result stands: no extra request reopens the concluded turn.
-    expect(adapter.requests).toHaveLength(1)
+    expect(adapter.requests).toHaveLength(2)
     const events = agent.session.events.map(event => event.type)
     expect(events.filter(type => type === 'turn/end')).toHaveLength(1)
-    // The steering is durable inside the concluded turn and feeds the NEXT
-    // turn's request instead of being dropped or re-queued.
-    expect(events).toContain('steering/message')
-
-    send(agent, 'follow up')
-    await waitForIdle(ctx, agent)
-    expect(adapter.requests).toHaveLength(2)
+    expect(JSON.stringify(adapter.requests[1]?.messages)).toContain('late steering')
     const texts = adapter.requests[1]!.messages
       .flatMap(message => message.content)
       .filter(block => block.type === 'text')
@@ -630,38 +622,21 @@ describe('agent loop', () => {
     expect(fires.every(({ signal }) => signal instanceof AbortSignal)).toBe(true)
   })
 
-  it('agent/step fires BEFORE the step it precedes opens (events land outside the step)', async () => {
-    // The append lands before step/start, yet derive happens afterwards and the
-    // same step's request must include it.
+  it('agent/step fires after its step boundary opens and before the request', async () => {
     const adapter = new MockAdapter([textResponse('ok')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    let injected = false
+    let boundaryOpen = false
     ctx.on('agent/step', (subject) => {
-      if (subject === agent && !injected) {
-        injected = true
-        subject.session.append('user/message', createUserMessage({
-          content: [{ type: 'text', text: 'INJECTED-IN-PRE-STEP' }],
-          source: { kind: 'plugin', plugin: 'test' },
-        }), { surfaceOp: 'append' })
-      }
+      if (subject === agent) boundaryOpen = subject.session.events.at(-1)?.type === 'step/start'
     })
 
     send(agent, 'go')
     await waitForIdle(ctx, agent)
 
-    // The adapter's request includes the node injected during pre-step (derive
-    // reflects it).
-    const text = JSON.stringify(adapter.requests[0]!.messages)
-    expect(text).toContain('INJECTED-IN-PRE-STEP')
-
-    // And the injected event sits BEFORE the first step/start in the log —
-    // the seam fired outside the step.
-    const events = agent.session.events
-    const injectedSeq = events.find(e => e.type === 'user/message' && e.data.source.kind === 'plugin')!.seq
-    const firstStepStartSeq = events.find(e => e.type === 'step/start')!.seq
-    expect(injectedSeq).toBeLessThan(firstStepStartSeq)
+    expect(boundaryOpen).toBe(true)
+    expect(adapter.requests).toHaveLength(1)
   })
 
   it('a throwing agent/step listener ends the turn (error), not the loop', async () => {
@@ -683,13 +658,11 @@ describe('agent loop', () => {
 
     send(agent, 'first')
     await waitForIdle(ctx, agent)
-    // The first turn failed at step 1 (no model call happened), surfaced via
-    // agent/error, with the durable failure on turn/end.reason.
-    expect(errors).toHaveLength(1)
-    expect(errors[0]!.message).toContain('boom in pre-step')
+    // The first turn failed at step 1 before a model call.
+    expect(errors).toEqual([])
     expect(adapter.requests.length).toBe(0)
     const firstTurnEnd = agent.session.events.find(e => e.type === 'turn/end')
-    expect(firstTurnEnd?.type === 'turn/end' && firstTurnEnd.data.reason).toMatchObject({ kind: 'error', step: 1 })
+    expect(firstTurnEnd?.type === 'turn/end' && firstTurnEnd.data.reason).toMatchObject({ kind: 'error' })
     // The step opened-and-closed count stays balanced even though it never ran.
     const types = agent.session.events.map(e => e.type)
     expect(types.filter(t => t === 'step/start').length).toBe(types.filter(t => t === 'step/end').length)
@@ -717,7 +690,7 @@ describe('agent loop', () => {
     agent.cancel({ kind: 'user' })
     await waitForIdle(ctx, agent)
 
-    expect(reasons).toEqual([{ kind: 'aborted' }])
+    expect(reasons).toEqual([{ kind: 'aborted', reason: { kind: 'user' } }])
   })
 
   it('surfaces max-tokens as the turn-end reason when the last step is cut off', async () => {
@@ -788,7 +761,7 @@ describe('agent loop', () => {
         source: { kind: 'plugin', plugin: 'max-tokens-test' },
       },
     ])
-    expect(reasons).toEqual([{ kind: 'max-tokens' }])
+    expect(reasons).toEqual([{ kind: 'completed' }])
   })
 
   it('a completed step after no max-tokens keeps the turn completed (max-tokens does not leak across turns)', async () => {
@@ -1005,14 +978,15 @@ describe('agent loop', () => {
     expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason.kind).toBe('completed')
   })
 
-  it('keeps a reentrant agent/inbox/enqueue send as the next independent turn', async () => {
-    const adapter = new MockAdapter([textResponse('first'), textResponse('second')])
+  it('contains a reentrant send attempted during durable inbox publication', async () => {
+    const adapter = new MockAdapter([textResponse('first')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     let nested = false
-    ctx.on('agent/inbox/enqueue', (subject) => {
-      if (subject !== agent || nested) return
+    ctx.on('session/event', (session, event) => {
+      if (session !== agent.session || event.type !== 'agent/inbox/spliced'
+        || event.data.inserted.length === 0 || nested) return
       nested = true
       send(agent, 'queued listener message')
     })
@@ -1025,11 +999,8 @@ describe('agent loop', () => {
     const messages = agent.session.events
       .filter(event => event.type === 'user/message')
       .map(event => event.data.content)
-    expect(turns).toHaveLength(2)
-    expect(messages).toEqual([
-      [{ type: 'text', text: 'outer message' }],
-      [{ type: 'text', text: 'queued listener message' }],
-    ])
+    expect(turns).toHaveLength(1)
+    expect(messages).toEqual([[{ type: 'text', text: 'outer message' }]])
   })
 
   it('preserves independent turn sources across an adjacent microtask send', async () => {
@@ -1068,7 +1039,7 @@ describe('agent loop', () => {
     ctx.on('session/event', (_s, event) => {
       if (event.type === 'assistant/chunk' && !queued) {
         queued = true
-        send(agent, 'second message')
+        queueMicrotask(() => { send(agent, 'second message') })
       }
     })
 
@@ -1110,7 +1081,7 @@ describe('agent loop', () => {
     ])
   })
 
-  it('errors from the model surface as agent/error and end the turn', async () => {
+  it('records normalized model errors on the turn boundary', async () => {
     const adapter = new MockAdapter([]) // script exhausted → throws
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
@@ -1125,13 +1096,12 @@ describe('agent loop', () => {
     send(agent, 'hi')
     await waitForIdle(ctx, agent)
 
-    expect(errors).toHaveLength(1)
-    expect(errors[0]!.message).toContain('script exhausted')
+    expect(errors).toEqual([])
     expect(reasons[0]).toMatchObject({ kind: 'error' })
     // The durable failure lives entirely on turn/end.reason (with the failing
     // step), not a standalone error event.
     const turnEnd = agent.session.events.find(e => e.type === 'turn/end')
-    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toMatchObject({ kind: 'error', step: 1 })
+    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toMatchObject({ kind: 'error' })
   })
 
   it('disposing the loop fiber mid-turn stops the loop (HMR safety)', async () => {
diff --git a/packages/core/agent-loop/tests/request-error.spec.ts b/packages/core/agent-loop/tests/request-error.spec.ts
index afd62f7d20..a7b35bfdbf 100644
--- a/packages/core/agent-loop/tests/request-error.spec.ts
+++ b/packages/core/agent-loop/tests/request-error.spec.ts
@@ -59,22 +59,19 @@ describe('agent/request-error', () => {
       turn: number
       step: number
       failure: LlmFailure
-      priorFailures: readonly LlmFailure[]
       retryPolicy: ResolvedRetryPolicy | undefined
     }[] = []
     const statuses: string[] = []
     ctx.on('agent/status', (subject, status) => {
       if (subject === agent) statuses.push(status)
     })
-    ctx.on('agent/request-error', async (
-      subject, turn, step, _error, failure, priorFailures, retryPolicy,
-    ) => {
+    ctx.on('agent/request-error', async (subject, context) => {
       expect(subject).toBe(agent)
       expect(agent.session.events.at(-1)).toMatchObject({
         type: 'step/end',
-        data: { turn, step },
+        data: { turn: context.turn, step: context.step },
       })
-      seen.push({ turn, step, failure, priorFailures, retryPolicy })
+      seen.push(context)
       return { kind: 'retry' }
     })
 
@@ -98,8 +95,6 @@ describe('agent/request-error', () => {
       },
     ])
     expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(1)
-    expect(seen.map(item => item.priorFailures.map(failure => failure.code)))
-      .toEqual([[], ['RATE_LIMIT']])
     expect(seen.map(item => item.retryPolicy)).toEqual([
       expect.objectContaining({ mode: 'normal' }),
       expect.objectContaining({ mode: 'normal' }),
@@ -123,7 +118,7 @@ describe('agent/request-error', () => {
     expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(1)
     expect(agent.session.events.find(event => event.type === 'turn/end')).toMatchObject({
       type: 'turn/end',
-      data: { reason: { kind: 'aborted' } },
+      data: { reason: { kind: 'aborted', reason: { kind: 'user' } } },
     })
   })
 
diff --git a/packages/core/agent/tests/agent.spec.ts b/packages/core/agent/tests/agent.spec.ts
index b2178aea7e..8ffc467e20 100644
--- a/packages/core/agent/tests/agent.spec.ts
+++ b/packages/core/agent/tests/agent.spec.ts
@@ -3,6 +3,7 @@ import { Context, Service, symbols } from 'cordis'
 import { Session, SessionId } from '@deepseek-ai/dsh-session'
 import AgentRegistry, {
   agentEvents,
+  Inbox,
 } from '@deepseek-ai/dsh-agent'
 
 import type {
@@ -15,16 +16,19 @@ import type {
 
 function stubAgent(rawId: string, overrides: Partial<Agent> = {}): Agent {
   const id = SessionId(rawId)
+  const session = new Session(id)
   const agent: Agent = {
     id,
     options: {},
-    session: new Session(id),
+    session,
+    inbox: new Inbox(session),
     status: 'idle',
     ctx: new Context(),
     followup: () => {},
     steer: () => {},
     inject: () => {},
     cancel() {},
+    whenIdle: () => Promise.resolve(),
   }
   return Object.assign(agent, overrides)
 }
diff --git a/packages/core/scope/src/scoped-events.generated.ts b/packages/core/scope/src/scoped-events.generated.ts
index e08fd2aabd..836294c93d 100644
--- a/packages/core/scope/src/scoped-events.generated.ts
+++ b/packages/core/scope/src/scoped-events.generated.ts
@@ -15,7 +15,6 @@ const scopedSubjectResolvers: Readonly<Record<string, ScopedSubjectResolver | nu
   'agent/request': args => args[0],
   'agent/request-error': args => args[0],
   'agent/session-start': args => args[0],
-  'agent/settled': args => args[0],
   'agent/status': args => args[0],
   'agent/step': args => args[0],
   'agent/turn-stopping': args => args[0],
diff --git a/packages/core/scope/tests/invariant.spec.ts b/packages/core/scope/tests/invariant.spec.ts
index ccc90e7843..35f3455a85 100644
--- a/packages/core/scope/tests/invariant.spec.ts
+++ b/packages/core/scope/tests/invariant.spec.ts
@@ -59,6 +59,7 @@ describe('scoped-dispatch invariants', () => {
           step: 1,
           provider: 'p',
           failure: { message: 'request', code: 'UNKNOWN' },
+          retryPolicy: undefined,
         },
         signal,
         () => Promise.resolve(undefined),
diff --git a/packages/core/session/src/index.ts b/packages/core/session/src/index.ts
index bf1601c43a..fba29e3585 100644
--- a/packages/core/session/src/index.ts
+++ b/packages/core/session/src/index.ts
@@ -169,7 +169,6 @@ function assertSessionEventEnvelope(value: Record<string, unknown>, index: numbe
     throw new Error(`seed event at index ${index} has an invalid event envelope`)
   }
   assertCurrentLlmShape(event, index)
-  assertCurrentTurnEndShape(event, index)
 }
 
 /** Reject obsolete request headers and malformed messages at the seed/load boundary. */
@@ -248,22 +247,6 @@ function assertMessageEventShape(event: Record<string, unknown>, subject: string
   }
 }
 
-/** Reject legacy aborted outcomes that persisted caller-owned reason detail. */
-function assertCurrentTurnEndShape(event: Record<string, unknown>, index: number): void {
-  if (event['type'] !== 'turn/end') return
-  const data = event['data']
-  /* v8 ignore next -- this migration recognizes only the legacy object shape; format-wide payload validation is separate. */
-  if (typeof data !== 'object' || data === null) return
-  const reason = (data as Record<string, unknown>)['reason']
-  /* v8 ignore next -- non-object reasons cannot carry the legacy aborted detail this migration removes. */
-  if (typeof reason !== 'object' || reason === null || Array.isArray(reason)) return
-  const record = reason as Record<string, unknown>
-  if (record['kind'] === 'aborted'
-    && (Object.keys(record).length !== 1 || !Object.hasOwn(record, 'kind'))) {
-    throw new Error(`seed turn/end at index ${index} uses unsupported reason-bearing aborted format`)
-  }
-}
-
 /** Whether an unknown value carries the current provider/model pair. */
 function hasProviderModel(value: unknown): boolean {
   if (typeof value !== 'object' || value === null) return false
diff --git a/packages/core/session/tests/fork.spec.ts b/packages/core/session/tests/fork.spec.ts
index dc22ec6512..3c79b05157 100644
--- a/packages/core/session/tests/fork.spec.ts
+++ b/packages/core/session/tests/fork.spec.ts
@@ -128,9 +128,9 @@ describe('SessionStore.fork', () => {
     const { ctx, sessions } = await setup()
     const reasons: TurnEndReason[] = [
       { kind: 'completed' },
-      { kind: 'aborted' },
-      { kind: 'error', step: 1, message: 'model failed', code: 'MODEL' },
-      { kind: 'disposed' },
+      { kind: 'aborted', reason: { kind: 'user' } },
+      { kind: 'error', error: new Error('model failed') },
+      { kind: 'aborted', reason: { kind: 'disposed' } },
       { kind: 'max-tokens' },
       { kind: 'interrupted' },
     ]
diff --git a/packages/core/session/tests/invariant.spec.ts b/packages/core/session/tests/invariant.spec.ts
index d4b71e0da2..0037646a12 100644
--- a/packages/core/session/tests/invariant.spec.ts
+++ b/packages/core/session/tests/invariant.spec.ts
@@ -326,7 +326,7 @@ describe('session-log invariants', () => {
       unresolved.append('step/start', { turn: 1, step: 1 })
       unresolved.append('tool/call', { turn: 1, step: 1, callId: CallId('c1'), name: 'echo', arguments: '{}' })
       unresolved.append('step/end', { turn: 1, step: 1 })
-      unresolved.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, message: 'boom' } })
+      unresolved.append('turn/end', { turn: 1, reason: { kind: 'error', error: new Error('boom') } })
     }).not.toThrow()
   })
 
diff --git a/packages/core/session/tests/session.spec.ts b/packages/core/session/tests/session.spec.ts
index ab4c84b1e7..c8c0ed3a59 100644
--- a/packages/core/session/tests/session.spec.ts
+++ b/packages/core/session/tests/session.spec.ts
@@ -70,30 +70,15 @@ describe('Session', () => {
     expect(structuredClone(turnEnd.data.reason)).toEqual({ kind: 'max-tokens' })
   })
 
-  it('round-trips the coarse aborted turn outcome', () => {
+  it('round-trips an aborted turn with its cancellation cause', () => {
     const session = new Session(SessionId('aborted'))
     session.append('turn/start', { turn: 1 })
-    session.append('turn/end', { turn: 1, reason: { kind: 'aborted' } })
+    session.append('turn/end', { turn: 1, reason: { kind: 'aborted', reason: { kind: 'user' } } })
     const replayed = new Session(SessionId('aborted-replay'), structuredClone(session.events))
     expect(replayed.events).toEqual(session.events)
     const turnEnd = replayed.events.findLast(event => event.type === 'turn/end')
-    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted' })
-  })
-
-  it('rejects legacy reason-bearing aborted outcomes at the seed/load boundary', () => {
-    const legacy = [
-      {
-        type: 'turn/start', seq: 0, time: 1,
-        data: { turn: 1 },
-      },
-      {
-        type: 'turn/end', seq: 1, time: 2,
-        data: { turn: 1, reason: { kind: 'aborted', reason: 'legacy cancellation detail' } },
-      },
-    ] as unknown as SessionEvent[]
-
-    expect(() => new Session(SessionId('legacy-aborted'), legacy))
-      .toThrow('seed turn/end at index 1 uses unsupported reason-bearing aborted format')
+    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason)
+      .toEqual({ kind: 'aborted', reason: { kind: 'user' } })
   })
 
   it('renders injected-context and steering messages as plain user content', () => {
diff --git a/packages/examples/cli-demo/tests/cli.spec.ts b/packages/examples/cli-demo/tests/cli.spec.ts
index 1414a0691a..3a7c29fadb 100644
--- a/packages/examples/cli-demo/tests/cli.spec.ts
+++ b/packages/examples/cli-demo/tests/cli.spec.ts
@@ -12,12 +12,11 @@ import { createUserMessage,
   type StreamChunk,
   type TokenUsage,
 } from '@deepseek-ai/dsh-llm'
-import { SessionId, type SessionEvent, type TurnEndReason } from '@deepseek-ai/dsh-session'
+import { SessionId, type SessionEvent } from '@deepseek-ai/dsh-session'
 import { afterEach, describe, expect, it } from 'vitest'
 import * as cliDemo from '../src/index.ts'
 import {
   executeCli,
-  formatTurnFailure,
   parseCliArgs,
   runOneShot,
   type CliResult,
@@ -345,7 +344,7 @@ describe('runOneShot and executeCli', () => {
     const output = await invoke(ctx, ['--output-format', 'json', 'task'])
     const result = JSON.parse(output.stdout) as CliResult
     expect(output.code).toBe(0)
-    expect(result).toMatchObject({ type: 'result', success: true, turn: 1, result: 'done', reason: { kind: 'completed' } })
+    expect(result).toMatchObject({ type: 'result', output: 'done' })
     expect(result.usage).toEqual({
       inputTokens: 17,
       outputTokens: 8,
@@ -376,7 +375,7 @@ describe('runOneShot and executeCli', () => {
       reasoningResponse('reasoning only'),
     ])
     const result = await runOneShot(ctx, { task: 'task' })
-    expect(result.result).toBe('working')
+    expect(result.output).toBe('working')
   })
 
   it('observes only the correlated main message turn', async () => {
@@ -421,8 +420,7 @@ describe('runOneShot and executeCli', () => {
     releaseStartup.resolve(undefined)
 
     const outcome = await result
-    expect(outcome.reason).toEqual({ kind: 'completed' })
-    expect(outcome).toMatchObject({ success: true, turn: 3, result: 'streamed' })
+    expect(outcome).toMatchObject({ type: 'result', output: 'streamed' })
     const events = streamed.map(item => item.event)
     expect(events[0]).toMatchObject({ type: 'turn/start', data: { turn: 3 } })
     expect(events.at(-1)).toMatchObject({ type: 'turn/end', data: { turn: 3 } })
@@ -443,15 +441,15 @@ describe('runOneShot and executeCli', () => {
     }))
 
     await expect(runOneShot(ctx, { task: 'original task' })).resolves.toMatchObject({
-      success: true,
-      result: 'rewritten answer',
+      type: 'result',
+      output: 'rewritten answer',
     })
   })
 
-  it('rejects tasks blocked before admission, including retained tasks', async () => {
+  it('settles blocked tasks at whole-agent idle without attributing a result', async () => {
     const blocked = await harness([])
     blocked.ctx.on('agent/prompt-submit', async () => ({ kind: 'block' as const, reason: 'denied' }))
-    await expect(runOneShot(blocked.ctx, { task: 'task' })).rejects.toThrow('canceled before admission')
+    await expect(runOneShot(blocked.ctx, { task: 'task' })).resolves.toMatchObject({ output: '' })
 
     const retained = await harness([])
     retained.ctx.on('agent/prompt-submit', async () => ({
@@ -459,7 +457,7 @@ describe('runOneShot and executeCli', () => {
       reason: 'deferred',
       keepInbox: true,
     }))
-    await expect(runOneShot(retained.ctx, { task: 'task' })).rejects.toThrow('not admitted')
+    await expect(runOneShot(retained.ctx, { task: 'task' })).resolves.toMatchObject({ output: '' })
     expect(retained.agent.status).toBe('idle')
 
     const failed = await harness([])
@@ -467,12 +465,12 @@ describe('runOneShot and executeCli', () => {
     await expect(runOneShot(failed.ctx, { task: 'task' })).rejects.toThrow('not admitted')
   })
 
-  it('emits partial data and a diagnostic for non-completed turns', async () => {
+  it('emits partial data without attributing a turn outcome', async () => {
     const { ctx } = await harness([textResponse('partial', { inputTokens: 2, outputTokens: 3 }, 'max-tokens')])
     const output = await invoke(ctx, ['--output-format', 'json', 'task'])
-    expect(JSON.parse(output.stdout)).toMatchObject({ success: false, result: 'partial', reason: { kind: 'max-tokens' } })
-    expect(output.code).toBe(1)
-    expect(output.stderr).toContain('output-token limit')
+    expect(JSON.parse(output.stdout)).toMatchObject({ type: 'result', output: 'partial' })
+    expect(output.code).toBe(0)
+    expect(output.stderr).toBe('')
   })
 
   it('cancels an active turn, emits its durable aborted result, and disposes', async () => {
@@ -487,9 +485,9 @@ describe('runOneShot and executeCli', () => {
     await running
     abort.abort('received SIGINT')
     const output = await outcome
-    expect(JSON.parse(output.stdout)).toMatchObject({ success: false, reason: { kind: 'aborted' } })
+    expect(output.stdout).toBe('')
     expect(output.code).toBe(1)
-    expect(output.stderr).toContain('turn 1 was aborted')
+    expect(output.stderr).toContain('received SIGINT')
     expect(agent.status).toBe('idle')
   })
 
@@ -572,18 +570,3 @@ describe('runOneShot and executeCli', () => {
     await queued.agent.whenIdle()
   })
 })
-
-describe('formatTurnFailure', () => {
-  it('diagnoses every durable reason and preserves merge-extensible unknowns', () => {
-    const cases: [TurnEndReason, string][] = [
-      [{ kind: 'completed' }, 'completed'],
-      [{ kind: 'aborted', reason: { kind: 'user' } }, 'was aborted'],
-      [{ kind: 'error', error: new Error('bad') }, 'failed: bad'],
-      [{ kind: 'error', error: { message: 'provider bad', code: 'SERVER' } }, 'provider bad'],
-      [{ kind: 'max-tokens' }, 'output-token limit'],
-      [{ kind: 'interrupted' }, 'persistence recovery'],
-    ]
-    for (const [reason, expected] of cases) expect(formatTurnFailure(reason)).toContain(expected)
-    expect(formatTurnFailure({ kind: 'extension' } as unknown as TurnEndReason)).toContain('extension')
-  })
-})
diff --git a/packages/fs/tool-str-replace-editor/tests/tools.spec.ts b/packages/fs/tool-str-replace-editor/tests/tools.spec.ts
index 0a3b65ba5e..268fa8fa28 100644
--- a/packages/fs/tool-str-replace-editor/tests/tools.spec.ts
+++ b/packages/fs/tool-str-replace-editor/tests/tools.spec.ts
@@ -6,7 +6,7 @@ import { Context } from 'cordis'
 import { FsVersion } from '@deepseek-ai/dsh-fs'
 import { CallId } from '@deepseek-ai/dsh-llm'
 import { Session, SessionId } from '@deepseek-ai/dsh-session'
-import AgentRegistry from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { Inbox } from '@deepseek-ai/dsh-agent'
 import type { Agent } from '@deepseek-ai/dsh-agent'
 import LocalFileSystem from '@deepseek-ai/dsh-fs-local'
 import * as FsPolicy from '@deepseek-ai/dsh-fs-policy'
@@ -28,18 +28,17 @@ afterEach(async () => {
 function agent(ctx: Context, cwd: string): Agent {
   const id = SessionId(`str-replace-editor-owner-${callNumber}`)
   const scope = ctx.plugin(() => {})
+  const session = new Session(id, [], { version: 0, id, createdAt: 0, cwd })
   const value: Agent = {
     id,
     options: {},
-    session: new Session(id, [], { version: 0, id, createdAt: 0, cwd }),
+    session,
+    inbox: new Inbox(session),
     status: 'idle',
-    acceptsNextStep: false,
     ctx: scope.ctx,
     followup: () => {},
     steer: () => {},
     inject: () => {},
-    send: () => {},
-    updateInbox: () => 'not-found',
     cancel() {},
     whenIdle: () => Promise.resolve(),
   }
diff --git a/packages/goal/command-goal/tests/command-goal.spec.ts b/packages/goal/command-goal/tests/command-goal.spec.ts
index ef7204e7c0..f7a1a5b304 100644
--- a/packages/goal/command-goal/tests/command-goal.spec.ts
+++ b/packages/goal/command-goal/tests/command-goal.spec.ts
@@ -1,7 +1,7 @@
 import { describe, expect, it, vi } from 'vitest'
 import { Context } from 'cordis'
 import Loader from '@cordisjs/plugin-loader'
-import AgentRegistry, {} from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { Inbox } from '@deepseek-ai/dsh-agent'
 import type { Agent, AgentStatus } from '@deepseek-ai/dsh-agent'
 import CommandService from '@deepseek-ai/dsh-commands'
 import GoalService from '@deepseek-ai/dsh-goal'
@@ -34,6 +34,7 @@ function stubAgent(ctx: Context, id: string): { agent: Agent; session: Session }
     id: session.id,
     options: {},
     session,
+    inbox: new Inbox(session),
     ctx: new Context(),
     get status() { return status },
     followup: () => {},
diff --git a/packages/goal/goal-session/tests/goal-session.spec.ts b/packages/goal/goal-session/tests/goal-session.spec.ts
index d1144bea1d..93d3ef926e 100644
--- a/packages/goal/goal-session/tests/goal-session.spec.ts
+++ b/packages/goal/goal-session/tests/goal-session.spec.ts
@@ -9,7 +9,7 @@ import type { GoalView } from '@deepseek-ai/dsh-goal'
 import { createUserMessage, LlmAdapter, LlmError  } from '@deepseek-ai/dsh-llm'
 import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm'
 import { SessionId } from '@deepseek-ai/dsh-session'
-import type { TurnEndReason, UserMessage } from '@deepseek-ai/dsh-session'
+import type { UserMessage } from '@deepseek-ai/dsh-session'
 import * as goalSession from '../src/index.ts'
 
 type ScriptEntry = StreamChunk[] | Error | 'hang' | ((options: GenerateOptions) => StreamChunk[])
@@ -133,28 +133,6 @@ async function waitForRequests(adapter: ScriptedAdapter, count: number): Promise
 }
 
 describe('goal-round outcome policy', () => {
-  it.each([
-    [{ kind: 'completed' }, true, { kind: 'continue' }],
-    [{ kind: 'aborted' }, true, { kind: 'pause', reason: 'cancelled' }],
-    [{ kind: 'error', step: 1, message: 'slow down', code: 'RATE_LIMIT' }, true,
-      { kind: 'blocked', code: 'usage-limited', message: 'slow down' }],
-    [{ kind: 'error', step: 1, failure: { message: 'credits exhausted', code: 'QUOTA' } }, true,
-      { kind: 'blocked', code: 'usage-limited', message: 'credits exhausted' }],
-    [{ kind: 'error', step: 1, failure: { message: 'provider failed', code: 'SERVER' } }, true,
-      { kind: 'blocked', code: 'turn-error', message: 'provider failed' }],
-    [{ kind: 'error', step: 1, message: 'broken' }, true,
-      { kind: 'blocked', code: 'turn-error', message: 'broken' }],
-    [{ kind: 'max-tokens' }, true,
-      { kind: 'blocked', code: 'max-tokens', message: 'model output reached max tokens' }],
-    [{ kind: 'disposed' }, true, { kind: 'disarm', reason: 'disposed' }],
-    [{ kind: 'interrupted' }, true, { kind: 'disarm', reason: 'interrupted' }],
-    [{ kind: 'completed' }, false, { kind: 'disarm', reason: 'durability-failed' }],
-    [{ kind: 'future-outcome' } as unknown as TurnEndReason, true,
-      { kind: 'blocked', code: 'unknown-turn-outcome', message: 'unknown turn outcome: future-outcome' }],
-  ] as const)('maps %j without abnormal automatic retry', (reason, durable, expected) => {
-    expect(goalSession.classifyGoalRound(reason, durable)).toEqual(expected)
-  })
-
   it('renders the objective, round budget, authority boundary, and completion protocol', () => {
     const goal: GoalView = {
       id: GoalId('goal-prompt'),
@@ -259,7 +237,7 @@ describe('same-session goal driving', () => {
 
   it('maps a downstream prompt veto to blocked without admitting the round', async () => {
     const test = await harness([])
-    test.ctx.on('agent/prompt-submit', (_agent, message, _signal, next) => message.source.kind === 'goal'
+    test.ctx.on('agent/prompt-submit', (_agent, messages, _signal, next) => messages[0]?.source.kind === 'goal'
       ? Promise.resolve({ kind: 'block', reason: 'deployment policy' })
       : next())
     test.ctx.goals.create(test.agent, { objective: 'respect policy' })
@@ -274,7 +252,7 @@ describe('same-session goal driving', () => {
 
   it('does not reserve again when a stopped-goal observer queues ordinary work', async () => {
     const test = await harness([textResponse('human follow-up')])
-    test.ctx.on('agent/prompt-submit', (_agent, message, _signal, next) => message.source.kind === 'goal'
+    test.ctx.on('agent/prompt-submit', (_agent, messages, _signal, next) => messages[0]?.source.kind === 'goal'
       ? Promise.resolve({ kind: 'block', reason: 'stop this round' })
       : next())
     test.ctx.on('goal/changed', (agent, change) => {
@@ -382,8 +360,8 @@ describe('same-session goal driving', () => {
   it('rechecks revision after downstream prompt hooks before admitting', async () => {
     const test = await harness([textResponse('new revision')])
     let edited = false
-    test.ctx.on('agent/prompt-submit', (agent, message, _signal, next) => {
-      if (message.source.kind === 'goal' && !edited) {
+    test.ctx.on('agent/prompt-submit', (agent, messages, _signal, next) => {
+      if (messages[0]?.source.kind === 'goal' && !edited) {
         edited = true
         const current = test.ctx.goals.get(agent)
         if (current === undefined) throw new Error('missing goal during prompt edit')
@@ -489,8 +467,8 @@ describe('same-session goal driving', () => {
     // attempt through cancel-requested) and THEN throws: the catch finds no
     // matching reservation and must not reschedule a paused goal.
     let fired = false
-    test.ctx.on('agent/prompt-submit', async (agent, message, _signal, next) => {
-      if (message.source.kind === 'goal' && !fired) {
+    test.ctx.on('agent/prompt-submit', async (agent, messages, _signal, next) => {
+      if (messages[0]?.source.kind === 'goal' && !fired) {
         fired = true
         agent.cancel({ kind: 'user' })
         throw new Error('hook cancelled then exploded')
@@ -513,8 +491,8 @@ describe('same-session goal driving', () => {
     // Registered after goal-session's own listener: the throw propagates back
     // through goal-session's next() await, dropping the whole admission.
     let threw = false
-    test.ctx.on('agent/prompt-submit', async (_agent, message, _signal, next) => {
-      if (message.source.kind === 'goal' && !threw) {
+    test.ctx.on('agent/prompt-submit', async (_agent, messages, _signal, next) => {
+      if (messages[0]?.source.kind === 'goal' && !threw) {
         threw = true
         throw new Error('downstream admission hook exploded')
       }
@@ -660,8 +638,8 @@ describe('same-session goal driving', () => {
   it('fails a post-hook read closed before the prompt can enter history', async () => {
     const test = await harness([])
     let armed = true
-    test.ctx.on('agent/prompt-submit', (_agent, message, _signal, next) => {
-      if (message.source.kind === 'goal' && armed) {
+    test.ctx.on('agent/prompt-submit', (_agent, messages, _signal, next) => {
+      if (messages[0]?.source.kind === 'goal' && armed) {
         armed = false
         vi.spyOn(test.ctx.goals, 'get').mockImplementationOnce(() => {
           throw new Error('post-hook projection failed')
@@ -735,8 +713,8 @@ describe('same-session goal driving', () => {
   it('blocks admission when downstream cancellation clears the reservation', async () => {
     const test = await harness([])
     let cancelled = false
-    test.ctx.on('agent/prompt-submit', (agent, message, _signal, next) => {
-      if (message.source.kind === 'goal' && !cancelled) {
+    test.ctx.on('agent/prompt-submit', (agent, messages, _signal, next) => {
+      if (messages[0]?.source.kind === 'goal' && !cancelled) {
         cancelled = true
         agent.cancel({ kind: 'user' })
       }
@@ -804,8 +782,8 @@ describe('same-session goal driving', () => {
   it('leaves a queued reservation pending when the driver runs before its turn settles', async () => {
     const test = await harness([textResponse('settled later')])
     let woken = false
-    test.ctx.on('agent/prompt-submit', async (_agent, message, _signal, next) => {
-      if (message.source.kind === 'goal' && !woken) {
+    test.ctx.on('agent/prompt-submit', async (_agent, messages, _signal, next) => {
+      if (messages[0]?.source.kind === 'goal' && !woken) {
         woken = true
         // A concurrent driver pass must observe the still-unsettled attempt
         // and yield rather than double-book or clear the reservation.
@@ -929,8 +907,8 @@ describe('same-session goal driving', () => {
   it('does not re-block a goal the downstream veto already saw cancelled', async () => {
     const test = await harness([])
     let vetoed = false
-    test.ctx.on('agent/prompt-submit', (agent, message, _signal, next) => {
-      if (message.source.kind === 'goal' && !vetoed) {
+    test.ctx.on('agent/prompt-submit', (agent, messages, _signal, next) => {
+      if (messages[0]?.source.kind === 'goal' && !vetoed) {
         vetoed = true
         agent.cancel({ kind: 'user' })
         return Promise.resolve<PromptDecision>({ kind: 'block', reason: 'cancelled by policy' })
@@ -952,8 +930,8 @@ describe('same-session goal driving', () => {
   it('awaits an unadmitted reservation stuck in admission during teardown without cancelling', async () => {
     const test = await harness([])
     let release: (() => void) | undefined
-    test.ctx.on('agent/prompt-submit', async (_agent, message, _signal, next) => {
-      if (message.source.kind === 'goal' && release === undefined) {
+    test.ctx.on('agent/prompt-submit', async (_agent, messages, _signal, next) => {
+      if (messages[0]?.source.kind === 'goal' && release === undefined) {
         await new Promise<void>((resolve) => { release = resolve })
       }
       return next()
diff --git a/packages/goal/goal/tests/goal.spec.ts b/packages/goal/goal/tests/goal.spec.ts
index f395996011..b4802204dc 100644
--- a/packages/goal/goal/tests/goal.spec.ts
+++ b/packages/goal/goal/tests/goal.spec.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from 'vitest'
 import { Context } from 'cordis'
-import AgentRegistry, { agentEvents } from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { agentEvents, Inbox } from '@deepseek-ai/dsh-agent'
 import type { Agent, AgentStatus } from '@deepseek-ai/dsh-agent'
 import { createUserMessage, HarnessError, type ContentBlock, type MessageSource } from '@deepseek-ai/dsh-llm'
 import SessionStore, { Session, SessionId, type UserMessage } from '@deepseek-ai/dsh-session'
@@ -44,6 +44,7 @@ function stubAgentForSession(session: Session): StubAgent {
     id,
     options: {},
     session,
+    inbox: new Inbox(session),
     ctx: new Context(),
     get status() { return status },
     followup: () => {},
diff --git a/packages/goal/goal/tests/invariant.spec.ts b/packages/goal/goal/tests/invariant.spec.ts
index 805c98fdcf..50fac9c5c6 100644
--- a/packages/goal/goal/tests/invariant.spec.ts
+++ b/packages/goal/goal/tests/invariant.spec.ts
@@ -52,13 +52,7 @@ describe('goal stream invariants', () => {
       source: changeSource,
     }), { surfaceOp: 'append' })
     session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
-    session.append('turn/start', {
-      turn: 2,
-      trigger: {
-        kind: 'message',
-        source: { kind: 'goal', goalId: change.goal.id, revision: 1, round: 1 },
-      },
-    })
+    session.append('turn/start', { turn: 2 })
     expect(() => {
       session.append('user/message', createUserMessage({
         content: [{ type: 'text', text: 'continue' }],
@@ -102,13 +96,7 @@ describe('goal stream invariants', () => {
 
     await ctx.plugin(InvariantService, { enabled: true })
     await ctx.plugin(GoalInvariantCompanion)
-    session.append('turn/start', {
-      turn: 2,
-      trigger: {
-        kind: 'message',
-        source: { kind: 'goal', goalId: change.goal.id, revision: 1, round: 1 },
-      },
-    })
+    session.append('turn/start', { turn: 2 })
     expect(() => {
       session.append('user/message', createUserMessage({
         content: [{ type: 'text', text: 'continue after load' }],
diff --git a/packages/goal/goal/tests/projection.spec.ts b/packages/goal/goal/tests/projection.spec.ts
index 70fcbc0d5a..23496935e6 100644
--- a/packages/goal/goal/tests/projection.spec.ts
+++ b/packages/goal/goal/tests/projection.spec.ts
@@ -10,7 +10,7 @@
 
 import { describe, expect, it, vi } from 'vitest'
 import { Context } from 'cordis'
-import AgentRegistry from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { Inbox } from '@deepseek-ai/dsh-agent'
 import type { Agent, AgentStatus } from '@deepseek-ai/dsh-agent'
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
 import type { UserMessage } from '@deepseek-ai/dsh-session'
@@ -35,6 +35,7 @@ function liveAgent(ctx: Context, session: Session): Agent {
     id: session.id,
     options: {},
     session,
+    inbox: new Inbox(session),
     ctx,
     get status() { return status },
     followup: () => {},
diff --git a/packages/goal/tool-goal/tests/tool-goal.spec.ts b/packages/goal/tool-goal/tests/tool-goal.spec.ts
index d411e0c9b2..89ff0206a6 100644
--- a/packages/goal/tool-goal/tests/tool-goal.spec.ts
+++ b/packages/goal/tool-goal/tests/tool-goal.spec.ts
@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
 import Loader from '@cordisjs/plugin-loader'
-import AgentRegistry, { agentEvents } from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { agentEvents, Inbox } from '@deepseek-ai/dsh-agent'
 import type { Agent, AgentStatus } from '@deepseek-ai/dsh-agent'
 import GoalService, { GoalId } from '@deepseek-ai/dsh-goal'
 import type { GoalRef } from '@deepseek-ai/dsh-goal'
@@ -29,6 +29,7 @@ function stubAgent(rawId: string, supplied?: Session): StubAgent {
     id: session.id,
     options: {},
     session,
+    inbox: new Inbox(session),
     get status() { return status },
     ctx: new Context(),
     followup: () => {},
diff --git a/packages/hooks/hooks-claude/tests/coverage-cases.ts b/packages/hooks/hooks-claude/tests/coverage-cases.ts
index f9f5d1b088..33e098b4da 100644
--- a/packages/hooks/hooks-claude/tests/coverage-cases.ts
+++ b/packages/hooks/hooks-claude/tests/coverage-cases.ts
@@ -514,10 +514,12 @@ export function defineCoverageCases(group: CoverageGroup): void {
       const path = hooks(d, { UserPromptSubmit: [{ hooks: [{ type: 'command', command: s }] }] })
       const adapter = new MockAdapter([textResponse('ok')])
       const ctx = await harness(path, adapter)
-      ctx.on('agent/prompt-submit', async () => ({
+      ctx.on('agent/prompt-submit', async (_agent, messages) => ({
         kind: 'allow' as const,
-        content: [{ type: 'text' as const, text: 'rewritten-prompt' }],
-        additionalContexts: [createUserMessage({
+        messages: [{
+          ...messages[0]!,
+          content: [{ type: 'text' as const, text: 'rewritten-prompt' }],
+        }, createUserMessage({
           content: [{ type: 'text' as const, text: 'from-downstream' }],
           source: { kind: 'plugin' as const, plugin: 'policy' },
         })],
diff --git a/packages/hooks/hooks-codex/tests/coverage-cases.ts b/packages/hooks/hooks-codex/tests/coverage-cases.ts
index fcded1394f..6cd2cd4617 100644
--- a/packages/hooks/hooks-codex/tests/coverage-cases.ts
+++ b/packages/hooks/hooks-codex/tests/coverage-cases.ts
@@ -122,10 +122,12 @@ export function defineCoverageCases(groups: CoverageGroup | readonly CoverageGro
       hooks(d, { UserPromptSubmit: [{ hooks: [{ type: 'command', command: sh(d, 'c.sh', '#!/usr/bin/env bash\necho \'{"hookSpecificOutput":{"hookEventName":"UserPromptSubmit","additionalContext":"from-bridge"}}\'\n') }] }] })
       const adapter = new MockAdapter([textResponse('ok')])
       const ctx = await harness(join(d, 'hooks.json'), adapter)
-      ctx.on('agent/prompt-submit', async () => ({
+      ctx.on('agent/prompt-submit', async (_agent, messages) => ({
         kind: 'allow' as const,
-        content: [{ type: 'text' as const, text: 'rewritten-prompt' }],
-        additionalContexts: [createUserMessage({
+        messages: [{
+          ...messages[0]!,
+          content: [{ type: 'text' as const, text: 'rewritten-prompt' }],
+        }, createUserMessage({
           content: [{ type: 'text' as const, text: 'from-downstream' }],
           source: { kind: 'plugin' as const, plugin: 'policy' },
         })],
diff --git a/packages/host/apiproxy/tests/api-proxy-approval.spec.ts b/packages/host/apiproxy/tests/api-proxy-approval.spec.ts
index f9a00cf9ef..4833667583 100644
--- a/packages/host/apiproxy/tests/api-proxy-approval.spec.ts
+++ b/packages/host/apiproxy/tests/api-proxy-approval.spec.ts
@@ -34,7 +34,7 @@ async function harness(): Promise<{ ctx: Context; api: ApiProxy }> {
 /** A minimal agent stand-in inside an open turn (the service only reaches `.session`). */
 function agentOf(ctx: Context): Agent {
   const session = ctx.sessions.create()
-  session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+  session.append('turn/start', { turn: 1 })
   return { session } as unknown as Agent
 }
 
@@ -185,7 +185,7 @@ describe('approval pending registry', () => {
     const abort = new AbortController()
     const mux = openMux(api, abort)
     const session = ctx.sessions.create()
-    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+    session.append('turn/start', { turn: 1 })
     session.append('approval/asked', { id: 'pre-aborted' as ApprovalRequestId, toolName: 'bash' })
     const agent = { session } as unknown as Agent
     const cancelled = new AbortController()
@@ -308,7 +308,7 @@ describe('approval pending registry', () => {
     // Bypass ApprovalService: a log whose sole asked event already has its
     // decided partner must not be re-claimed — the answerer delegates.
     const session = ctx.sessions.create()
-    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+    session.append('turn/start', { turn: 1 })
     session.append('approval/asked', { id: 'stale-ask' as ApprovalRequestId, toolName: 'bash' })
     session.append('approval/decided', { id: 'stale-ask' as ApprovalRequestId, outcome: 'rejected' })
     const agent = { session } as unknown as Agent
@@ -322,7 +322,7 @@ describe('approval pending registry', () => {
     // Bypass ApprovalService: dispatch the waterfall directly with a session
     // that has no approval/asked event — the proxy answerer must call next().
     const session = ctx.sessions.create()
-    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+    session.append('turn/start', { turn: 1 })
     const agent = { session } as unknown as Agent
     const outcome = await ctx.waterfall('approval/request', { agent, toolName: 'x' }, () => Promise.resolve('unavailable' as const))
     expect(outcome).toBe('unavailable')
diff --git a/packages/host/apiproxy/tests/api-proxy-rename.spec.ts b/packages/host/apiproxy/tests/api-proxy-rename.spec.ts
index 0e3f0ffe18..15c7361024 100644
--- a/packages/host/apiproxy/tests/api-proxy-rename.spec.ts
+++ b/packages/host/apiproxy/tests/api-proxy-rename.spec.ts
@@ -57,7 +57,7 @@ async function composed(withTitles = true): Promise<Context> {
 function liveAgent(ctx: Context, id: string, turns: number): Session {
   const session = ctx.sessions.create(sid(id), { meta: { cwd: '/proj' } })
   for (let turn = 1; turn <= turns; turn++) {
-    session.append('turn/start', { turn, trigger: { kind: 'message', source: { kind: 'user' } } })
+    session.append('turn/start', { turn })
     session.append('user/message', createUserMessage({
       content: [{ type: 'text', text: `prompt ${String(turn)}` }],
       source: { kind: 'user' },
diff --git a/packages/host/apiproxy/tests/api-proxy-workspace.spec.ts b/packages/host/apiproxy/tests/api-proxy-workspace.spec.ts
index 52e40decdc..c8f522f950 100644
--- a/packages/host/apiproxy/tests/api-proxy-workspace.spec.ts
+++ b/packages/host/apiproxy/tests/api-proxy-workspace.spec.ts
@@ -3,7 +3,7 @@ import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { describe, expect, it, vi } from 'vitest'
 import { Context } from 'cordis'
-import AgentRegistry from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { Inbox } from '@deepseek-ai/dsh-agent'
 import type { Agent, AgentFactory } from '@deepseek-ai/dsh-agent'
 import SessionStore, { SessionId } from '@deepseek-ai/dsh-session'
 import type { Session } from '@deepseek-ai/dsh-session'
@@ -44,6 +44,7 @@ function stubAgent(session: Session): Agent {
     id: session.id,
     options: {},
     session,
+    inbox: new Inbox(session),
     status: 'idle',
     ctx: new Context(),
     followup: () => {},
diff --git a/packages/llm/llm-retry/tests/invariant.spec.ts b/packages/llm/llm-retry/tests/invariant.spec.ts
index 5724b631f9..1e04d85b5e 100644
--- a/packages/llm/llm-retry/tests/invariant.spec.ts
+++ b/packages/llm/llm-retry/tests/invariant.spec.ts
@@ -72,7 +72,7 @@ describe('llm-retry invariants', () => {
 
     expect(() => {
       session.append('llm/retry', { turn: 1, step: 1, ...normal })
-      session.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, failure } })
+      session.append('turn/end', { turn: 1, reason: { kind: 'error', error: failure } })
       session.append('turn/start', { turn: 2 })
       session.append('step/start', { turn: 2, step: 1 })
       session.append('step/end', { turn: 2, step: 1 })
@@ -187,7 +187,10 @@ describe('llm-retry invariants', () => {
     }).toThrow(/latest closed step is 1/)
 
     const closedTurn = closeStep(ctx, 'retry-invariant-closed-turn')
-    closedTurn.append('turn/end', { turn: 1, reason: { kind: 'aborted' } })
+    closedTurn.append('turn/end', {
+      turn: 1,
+      reason: { kind: 'aborted', reason: { kind: 'user' } },
+    })
     expect(() => {
       closedTurn.append('llm/retry', { turn: 1, step: 1, ...normal })
     }).toThrow(/inside an open turn/)
@@ -207,7 +210,7 @@ describe('llm-retry invariants', () => {
     const ctx = await setup()
     const mismatch = closeStep(ctx, 'retry-invariant-numbering')
     mismatch.append('llm/retry', { turn: 1, step: 1, ...normal })
-    mismatch.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, failure } })
+    mismatch.append('turn/end', { turn: 1, reason: { kind: 'error', error: failure } })
     mismatch.append('turn/start', { turn: 2 })
     mismatch.append('step/start', { turn: 2, step: 1 })
     mismatch.append('step/end', { turn: 2, step: 1 })
@@ -217,7 +220,7 @@ describe('llm-retry invariants', () => {
 
     const reset = closeStep(ctx, 'retry-invariant-reset')
     reset.append('llm/retry', { turn: 1, step: 1, ...normal })
-    reset.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, failure } })
+    reset.append('turn/end', { turn: 1, reason: { kind: 'error', error: failure } })
     reset.append('turn/start', { turn: 2 })
     reset.append('step/start', { turn: 2, step: 1 })
     reset.append('assistant/message', {
@@ -264,7 +267,7 @@ describe('llm-retry invariants', () => {
     const missingStart = ctx.sessions.create(SessionId('retry-invariant-missing-start'))
     missingStart.append('turn/end', {
       turn: 1,
-      reason: { kind: 'error', step: 1, failure },
+      reason: { kind: 'error', error: failure },
     })
     appendRetryTurn(missingStart, 2)
 
diff --git a/packages/llm/llm-retry/tests/persistence.spec.ts b/packages/llm/llm-retry/tests/persistence.spec.ts
index 60fedbc70d..433f9d9bf5 100644
--- a/packages/llm/llm-retry/tests/persistence.spec.ts
+++ b/packages/llm/llm-retry/tests/persistence.spec.ts
@@ -53,8 +53,7 @@ describe.each(['jsonl', 'sqlite'] as const)('%s retry-event persistence', (kind)
         turn: 1,
         reason: {
           kind: 'error',
-          step: 1,
-          failure: { message: 'provider busy', code: 'RATE_LIMIT', status: 429 },
+          error: { message: 'provider busy', code: 'RATE_LIMIT', status: 429 },
         },
       })
 
diff --git a/packages/llm/llm-retry/tests/retry.spec.ts b/packages/llm/llm-retry/tests/retry.spec.ts
index 2a5d51116c..f011fb3e5d 100644
--- a/packages/llm/llm-retry/tests/retry.spec.ts
+++ b/packages/llm/llm-retry/tests/retry.spec.ts
@@ -908,9 +908,7 @@ describe('provider-routed retry policy', () => {
     const captured = Promise.withResolvers<undefined>()
     let invokeCaptured: (() => Promise<void>) | undefined
     const mounted = await harness(adapter, {}, (ctx) => {
-      ctx.on('agent/request-error', (
-        _agent, _turn, _step, _error, _failure, _history, _retryPolicy, _signal, next,
-      ) => {
+      ctx.on('agent/request-error', (_agent, _context, _signal, next) => {
         return new Promise<RequestErrorAction>((resolve) => {
           invokeCaptured = async () => { resolve(await next()) }
           captured.resolve(undefined)
@@ -919,9 +917,7 @@ describe('provider-routed retry policy', () => {
     })
     context = mounted.ctx
     let downstreamCalls = 0
-    context.on('agent/request-error', async (
-      _agent, _turn, _step, _error, _failure, _history, _retryPolicy, _signal, next,
-    ) => {
+    context.on('agent/request-error', async (_agent, _context, _signal, next) => {
       downstreamCalls += 1
       return next()
     })
@@ -975,9 +971,7 @@ describe('provider-routed retry policy', () => {
       textResponse('must not run'),
     ])
     ;({ ctx: context } = await harness(adapter, { mock: policy }, (ctx) => {
-      ctx.on('agent/request-error', async (
-        agent, _turn, _step, _error, _failure, _history, _retryPolicy, _signal, next,
-      ) => {
+      ctx.on('agent/request-error', async (agent, _context, _signal, next) => {
         agent.cancel({ kind: 'user' })
         return next()
       })
diff --git a/packages/llm/llm/README.zh.md b/packages/llm/llm/README.zh.md
index 4dc4a0ca06..28f281908c 100644
--- a/packages/llm/llm/README.zh.md
+++ b/packages/llm/llm/README.zh.md
@@ -16,10 +16,10 @@
 - `ctx.llm.listModels(provider: string): Promise<LlmModelInfo[]>` 发现某个已注册提供方当前公布的模型。
 - `ctx.llm.resolveModelInfo(provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>` 从拥有精确路由的适配器解析经校验的确切模型身份、可用上下文和推理（reasoning）元数据；异步适配器可选地支持取消。
 - `ctx.llm.resolveCallConfig(config: LlmCallConfig, signal?: AbortSignal): Promise<LlmCallConfig>` 校验显式推理强度，并填入适配器配置的默认值，但不自动调整。
-- `ctx.llm.prepareCall(config: LlmCallConfig, signal?: AbortSignal): Promise<PreparedLlmCall>` 解析配置并将其当前适配器注册捕获为一次可取消、一次性调用。
+- `ctx.llm.prepareCall(config: LlmCallConfig, signal?: AbortSignal): Promise<PreparedLlmCall>` 解析配置，并将当前适配器注册及不可变重试策略捕获为一次可取消、一次性调用。
 - `ctx.llm.stream(options: GenerateOptions): AsyncIterable<StreamChunk>` 将一次模型调用流式输出为原始分片（token 级增量）。消费方使用 `BlockAssembler` 将分片组装为块／消息。
 
-`LlmService` 保留来自最终适配器选择、同步 dispatch、iterator 构造与迭代的错误，并将其溯源绑定到该次模型调用返回的精确流句柄。`isLlmAdapterFailure(stream, value)` 只报告该调用最终适配器边界的错误；`llmFailureOf(stream, value)` 返回关联的不可变 `LlmFailure`；`llmRetryPolicyOf(stream)` 返回在该边界选中的确切注册所对应的不可变策略，即使之后释放或替换路由也不变。未到达最终适配器的调用没有服务策略。嵌套模型调用、`llm/stream` middleware 和下游消费方失败对外层调用仍未分类。分类绝不替换或更改适配器原有的带代码 `Error`。
+`LlmService` 将最终适配器选择、同步 dispatch、iterator 构造与迭代中的失败规范化为流协议唯一的终止形式：`finish { kind: 'error' | 'aborted', failure }`。部分增量输出后发生失败时，内容块可能仍未闭合；消费方会丢弃这些不完整输出。`llm/stream` middleware、嵌套调用、适配器清理和下游消费方的错误仍会抛出，因为它们属于插件或消费方失败，而非模型请求结果。已准备调用会暴露随其确切适配器注册一同捕获的不可变重试策略；完全由 middleware 处理的路由没有服务策略。
 
 提供方与模型元数据是发现接口，不是路由白名单。`registerAdapter()` 仍拥有提供方排他性，并为每条路由捕获适配器的重试策略；适配器则可以接受 `listModels()` 中不存在的模型 id，消费方禁止因模型未列出而拒绝请求。返回的 selector 元数据与输入脱离，无效或重复适配器配置项会以 `INVALID_ADAPTER` 或 `INVALID_CATALOG` 失败。
 
@@ -44,7 +44,7 @@
 
 消息内容是类型化内容块数组：`text`、`reasoning`、`tool-call`、`tool-result`。联合从可合并扩展的 `ContentBlockMap` 派生，因此插件可以通过 declaration merging 添加块类型。assistant 消息使用模型来源，其中携带提供方／模型溯源与可选适配器私有回放状态。dispatch 前，`LlmService` 只在历史提供方路由与目标提供方路由当前由完全相同的适配器实例拥有时才保留该状态；随后由适配器判定能否在模型／提供方间恢复或转换该状态。核心块集只包含每条已发布路径都支持的块。多模态内容（图像、音频等）没有核心块类型；需要它的功能会通过 map 添加，并一并添加相应的适配器／UI／压缩（compaction）支持。
 
-流式输出是原始分片协议（`block-start`、`text-delta`、`reasoning-delta`、`tool-call-delta`、`block-end`、`usage`、`finish`）。`BlockAssembler` 是将分片组装为块／消息的唯一共享实现。
+流式输出是原始分片协议（`block-start`、`text-delta`、`reasoning-delta`、`tool-call-delta`、`block-end`、`usage`、`finish`）。每个适配器结果都以一个终止 `finish` 到达消费方；运行故障使用其 `error` 或 `aborted` 原因，而不会跨流 API 抛出。`BlockAssembler` 是将分片组装为块／消息的唯一共享实现。
 
 ### 调用配置（`call-config.ts`）
 
@@ -67,7 +67,7 @@
 
 ### 真实适配器
 
-两个适配器使用不同内部机制实现 `LlmAdapter`：[`@deepseek-ai/dsh-llm-deepseek`](../llm-deepseek) 针对 `deepseek` 路由使用直接 fetch 加 `eventsource-parser` SSE（Server-Sent Events）分帧，[`@deepseek-ai/dsh-llm-pi-ai`](../llm-pi-ai) 则通过 `@earendil-works/pi-ai` 动态解析已配置提供方／模型对。两者都遵循 `StreamChunk` 约定，定义见 `types.ts`：usage 先于 finish，工具参数保持原始字符串，错误使用两种已批准路径之一。设计理由见 [双 LLM 适配器](../../../.agents/notes/implemented/architecture/2026-06-13-twin-llm-adapters.md)。
+两个适配器使用不同内部机制实现 `LlmAdapter`：[`@deepseek-ai/dsh-llm-deepseek`](../llm-deepseek) 针对 `deepseek` 路由使用直接 fetch 加 `eventsource-parser` SSE（Server-Sent Events）分帧，[`@deepseek-ai/dsh-llm-pi-ai`](../llm-pi-ai) 则通过 `@earendil-works/pi-ai` 动态解析已配置提供方／模型对。两者都遵循 `types.ts` 中的 `StreamChunk` 约定：usage 先于 finish，工具参数保持原始字符串。适配器实现在内部可以抛出异常或发出失败 finish；`LlmService` 会将两者都暴露为终止失败 finish。适配器理由见[双 LLM 适配器](../../../.agents/notes/implemented/architecture/2026-06-13-twin-llm-adapters.md)，服务边界见[终止失败决策](../../../.agents/notes/implemented/architecture/2026-07-29-terminal-llm-stream-failures.md)。
 
 ## 模型体验
 
diff --git a/packages/llm/llm/src/index.ts b/packages/llm/llm/src/index.ts
index a736d5042a..67b14d10fe 100644
--- a/packages/llm/llm/src/index.ts
+++ b/packages/llm/llm/src/index.ts
@@ -510,9 +510,12 @@ export class LlmService extends Service {
     let completed = false
     try {
       while (true) {
-        let item: IteratorResult<StreamChunk>
+        let item: { done: true } | { done: false; value: StreamChunk }
         try {
-          item = await iterator.next()
+          const next = await iterator.next()
+          item = next.done
+            ? { done: true }
+            : { done: false, value: next.value }
         } catch (error: unknown) {
           completed = true
           yield adapterFailureChunk(error, options.signal)
@@ -527,8 +530,7 @@ export class LlmService extends Service {
         yield item.value
       }
     } finally {
-      // oxlint-disable-next-line typescript/no-unnecessary-condition -- the iteration catch sets its latch before entering finally.
-      if (!completed && !iterationFailed) {
+      if (!completed) {
         const close = iterator.return?.bind(iterator)
         if (close) await close()
       }
diff --git a/packages/llm/llm/tests/service.spec.ts b/packages/llm/llm/tests/service.spec.ts
index 1afb3c4b6d..af87442744 100644
--- a/packages/llm/llm/tests/service.spec.ts
+++ b/packages/llm/llm/tests/service.spec.ts
@@ -6,11 +6,8 @@ import LlmService, {
   HarnessError,
   isContextWindowExceededError,
   isQuotaExceededError,
-  isLlmAdapterFailure,
   LlmAdapter,
   LlmError,
-  llmFailureOf,
-  llmRetryPolicyOf,
   ProviderRequestId,
   ReasoningEffortId,
   resolveRetryPolicy,
@@ -93,6 +90,12 @@ const SCRIPT: StreamChunk[] = [
   { type: 'finish', reason: { kind: 'stop' } },
 ]
 
+async function collect(stream: AsyncIterable<StreamChunk>): Promise<StreamChunk[]> {
+  const chunks: StreamChunk[] = []
+  for await (const chunk of stream) chunks.push(chunk)
+  return chunks
+}
+
 describe('LlmService', () => {
   it('recognizes structured and model-capacity context-window overflow details', () => {
     expect(isContextWindowExceededError('context_length_exceeded maximum context length')).toBe(true)
@@ -217,69 +220,58 @@ describe('LlmService', () => {
     )
   })
 
-  it('keeps the serving registration policy on an in-flight call after route replacement', async () => {
+  it('keeps a prepared registration and retry policy after route replacement', async () => {
     const oldPolicy = resolveRetryPolicy({ mode: 'always' }, 'old retryPolicy')
     const newPolicy = resolveRetryPolicy({ mode: 'normal', maxRetries: 0 }, 'new retryPolicy')
-    const entered = Promise.withResolvers<undefined>()
-    const release = Promise.withResolvers<undefined>()
-    const failure = new LlmError('old route failed', 'AUTH')
-    const oldAdapter = new class extends LlmAdapter {
+    const oldFailure = new LlmError('old route failed', 'AUTH')
+    const ctx = new Context()
+    await ctx.plugin(LlmService)
+    const disposeOld = ctx.llm.registerAdapter(['route'], new class extends ThrowingAdapter {
       override providerRetryPolicy(): typeof oldPolicy {
         return oldPolicy
       }
+    }(oldFailure))
+    const prepared = await ctx.llm.prepareCall({ provider: 'route', model: 'model' })
 
-      async * stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
-        entered.resolve(undefined)
-        await release.promise
-        throw failure
-      }
-    }()
-    const newAdapter = new class extends ScriptedAdapter {
+    disposeOld()
+    ctx.llm.registerAdapter(['route'], new class extends ScriptedAdapter {
       override providerRetryPolicy(): typeof newPolicy {
         return newPolicy
       }
-    }(SCRIPT)
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    const disposeOld = ctx.llm.registerAdapter(['route'], oldAdapter)
-    const stream = ctx.llm.stream({ provider: 'route', model: 'model', messages: [] })
-    const outcome = (async (): Promise<unknown> => {
-      try {
-        for await (const _chunk of stream) { /* drain */ }
-      } catch (error: unknown) {
-        return error
-      }
-      return undefined
-    })()
-    await entered.promise
+    }(SCRIPT))
 
-    disposeOld()
-    ctx.llm.registerAdapter(['route'], newAdapter)
-    release.resolve(undefined)
-
-    expect(await outcome).toBe(failure)
-    expect(llmRetryPolicyOf(stream)).toBe(oldPolicy)
+    const chunks = await collect(prepared.stream({ ...prepared.config, messages: [] }))
+    expect(chunks.at(-1)).toEqual({
+      type: 'finish',
+      reason: {
+        kind: 'error',
+        failure: { message: 'old route failed', code: 'AUTH' },
+      },
+    })
+    expect(prepared.retryPolicy).toBe(oldPolicy)
     expect(ctx.llm.providerRetryPolicy('route')).toBe(newPolicy)
   })
 
-  it('throws NO_ADAPTER for unregistered providers', async () => {
+  it('normalizes an unregistered provider to a terminal failure', async () => {
     const ctx = new Context()
     await ctx.plugin(LlmService)
-    const stream = ctx.llm.stream({ provider: 'nope', model: 'any-model', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _ of stream) { /* drain */ }
-    } catch (error: unknown) {
-      caught = error
-    }
-    expect(caught).toBeInstanceOf(LlmError)
-    expect((caught as LlmError).code).toBe('NO_ADAPTER')
-    expect((caught as LlmError).message).toContain('no adapter registered')
-    expect(isLlmAdapterFailure(stream, caught)).toBe(true)
-    expect(llmRetryPolicyOf(stream)).toBeUndefined()
+
+    const chunks = await collect(ctx.llm.stream({
+      provider: 'nope',
+      model: 'any-model',
+      messages: [],
+    }))
+
+    expect(chunks.at(-1)).toMatchObject({
+      type: 'finish',
+      reason: {
+        kind: 'error',
+        failure: { code: 'NO_ADAPTER', message: expect.stringContaining('no adapter registered') },
+      },
+    })
   })
 
-  it.each(['done', 'value'] as const)('tags a throwing IteratorResult.%s getter without replacing its Error', async (field) => {
+  it.each(['done', 'value'] as const)('normalizes a throwing IteratorResult.%s getter', async (field) => {
     const original = new LlmError(`${field} getter failed`, 'RESULT_GETTER_FAILED')
     const result = field === 'done' ? {} : { done: false }
     Object.defineProperty(result, field, { get: () => { throw original } })
@@ -295,31 +287,30 @@ describe('LlmService', () => {
     })
     const adapter = new class extends LlmAdapter {
       stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
-        return {
-          [Symbol.asyncIterator](): AsyncIterator<StreamChunk> {
-            return iterator
-          },
-        }
+        return { [Symbol.asyncIterator]: () => iterator }
       }
     }()
     const ctx = new Context()
     await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], adapter)
+    ctx.llm.registerAdapter(['test'], adapter)
 
-    const stream = ctx.llm.stream({ provider: 'test-model', model: 'test-model', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _chunk of stream) { /* drain */ }
-    } catch (error: unknown) {
-      caught = error
-    }
+    const chunks = await collect(ctx.llm.stream({
+      provider: 'test',
+      model: 'test',
+      messages: [],
+    }))
 
-    expect(caught).toBe(original)
-    expect(isLlmAdapterFailure(stream, caught)).toBe(true)
+    expect(chunks.at(-1)).toEqual({
+      type: 'finish',
+      reason: {
+        kind: 'error',
+        failure: { message: `${field} getter failed`, code: 'RESULT_GETTER_FAILED' },
+      },
+    })
     expect(cleanupLookups).toBe(0)
   })
 
-  it.each(['dispatch', 'iterator'] as const)('tags synchronous adapter %s failures without replacing their Error', async (boundary) => {
+  it.each(['dispatch', 'iterator'] as const)('normalizes synchronous adapter %s failures', async (boundary) => {
     const original = new LlmError(`${boundary} failed`, 'BOUNDARY_FAILED')
     const adapter = new class extends LlmAdapter {
       stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
@@ -329,339 +320,63 @@ describe('LlmService', () => {
     }()
     const ctx = new Context()
     await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], adapter)
+    ctx.llm.registerAdapter(['test'], adapter)
 
-    const stream = ctx.llm.stream({ provider: 'test-model', model: 'test-model', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _chunk of stream) { /* drain */ }
-    } catch (error: unknown) {
-      caught = error
-    }
+    const chunks = await collect(ctx.llm.stream({
+      provider: 'test',
+      model: 'test',
+      messages: [],
+    }))
 
-    expect(caught).toBe(original)
-    expect(isLlmAdapterFailure(stream, caught)).toBe(true)
-    expect(llmFailureOf(stream, caught)).toEqual({
-      message: `${boundary} failed`,
-      code: 'BOUNDARY_FAILED',
+    expect(chunks.at(-1)).toEqual({
+      type: 'finish',
+      reason: {
+        kind: 'error',
+        failure: { message: `${boundary} failed`, code: 'BOUNDARY_FAILED' },
+      },
     })
   })
 
-  it('keeps structured provider facts beside a frozen third-party Error', async () => {
-    const original = new LlmError('provider busy', 'RATE_LIMIT', {
+  it('preserves structured LlmError facts in the terminal failure', async () => {
+    const failure = new LlmError('provider busy', 'RATE_LIMIT', {
       status: 429,
       providerRetryAfterMs: 1_500,
       requestId: ProviderRequestId('req-7'),
     })
-    Object.freeze(original)
     const ctx = new Context()
     await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
+    ctx.llm.registerAdapter(['test'], new ThrowingAdapter(failure))
 
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _chunk of stream) { /* drain */ }
-    } catch (error: unknown) {
-      caught = error
-    }
+    const chunks = await collect(ctx.llm.stream({
+      provider: 'test',
+      model: 'test',
+      messages: [],
+    }))
 
-    expect(caught).toBe(original)
-    expect(llmFailureOf(stream, caught)).toEqual({
-      message: 'provider busy',
-      code: 'RATE_LIMIT',
-      status: 429,
-      providerRetryAfterMs: 1_500,
-      requestId: ProviderRequestId('req-7'),
-    })
-  })
-
-  it('does not trust retry facts carried by an unknown third-party Error', async () => {
-    const carried = { message: 'busy', code: 'SERVER', status: 503 }
-    const original = Object.assign(new Error('busy'), { failure: carried })
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-    const facts = llmFailureOf(stream, original)
-    carried.status = 500
-
-    expect(facts).toEqual({ message: 'busy', code: 'UNKNOWN' })
-    expect(Object.isFrozen(facts)).toBe(true)
-    expect(facts).not.toBe(carried)
-  })
-
-  it('keeps validated failure facts across package copies with matching own codes', async () => {
-    const original = Object.assign(new Error('provider busy'), {
-      code: 'RATE_LIMIT',
-      failure: {
-        message: 'provider busy',
-        code: 'RATE_LIMIT',
-        status: 429,
-        providerRetryAfterMs: 1_500,
-        requestId: 'req-cross-copy',
+    expect(chunks.at(-1)).toEqual({
+      type: 'finish',
+      reason: {
+        kind: 'error',
+        failure: {
+          message: 'provider busy',
+          code: 'RATE_LIMIT',
+          status: 429,
+          providerRetryAfterMs: 1_500,
+          requestId: ProviderRequestId('req-7'),
+        },
       },
     })
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-    expect(llmFailureOf(stream, original)).toEqual({
-      message: 'provider busy',
-      code: 'RATE_LIMIT',
-      status: 429,
-      providerRetryAfterMs: 1_500,
-      requestId: 'req-cross-copy',
-    })
   })
 
-  it('keeps an unknown SDK Error exact without trusting its private code or accessors', async () => {
-    const original = Object.assign(new Error('socket closed'), { code: 'ECONNRESET' })
-    Object.defineProperty(original, 'failure', {
-      get() { throw new Error('SDK failure accessor must not run') },
-    })
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-
-    expect(original.code).toBe('ECONNRESET')
-    expect(llmFailureOf(stream, original)).toEqual({ message: 'socket closed', code: 'UNKNOWN' })
-  })
-
-  it('keeps an SDK Error exact when its message accessor is hostile', async () => {
-    const original = Object.defineProperty(new Error(), 'message', {
-      get() { throw new Error('SDK message accessor trap') },
-    })
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-    expect(llmFailureOf(stream, original)).toEqual({ message: 'LLM adapter failed', code: 'UNKNOWN' })
-  })
-
-  it('keeps an SDK Error exact without trusting accessor-backed carried facts', async () => {
-    const original = Object.assign(new Error('busy'), {
-      failure: { message: 'busy', code: 'SERVER', status: 503 },
-    })
-    Object.defineProperty(original, 'code', {
-      get() { throw new Error('SDK code accessor must not escape') },
-    })
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-    expect(llmFailureOf(stream, original)).toEqual({ message: 'busy', code: 'UNKNOWN' })
-  })
-
-  it('does not trust carried facts matched only by an inherited code', async () => {
-    class InheritedCodeError extends Error {
-      get code(): string { return 'SERVER' }
-    }
-    const original = Object.assign(new InheritedCodeError('busy'), {
-      failure: { message: 'busy', code: 'SERVER', status: 503 },
-    })
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-    expect(llmFailureOf(stream, original)).toEqual({ message: 'busy', code: 'UNKNOWN' })
-  })
-
-  it('keeps an SDK Error exact when code descriptor inspection is trapped', async () => {
-    const target = Object.assign(new Error('busy'), {
-      code: 'SERVER',
-      failure: { message: 'busy', code: 'SERVER', status: 503 },
-    })
-    const original = new Proxy(target, {
-      getOwnPropertyDescriptor(value, property) {
-        if (property === 'code') throw new Error('SDK code descriptor trap')
-        return Reflect.getOwnPropertyDescriptor(value, property)
-      },
-    })
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-    expect(llmFailureOf(stream, original)).toEqual({ message: 'busy', code: 'UNKNOWN' })
-  })
-
-  it('falls back safely when SDK objects trap failure inspection or expose malformed facts', async () => {
-    const propertyTrap = new Proxy(new HarnessError('descriptor trapped', 'SERVER'), {
-      getOwnPropertyDescriptor(target, property) {
-        if (property === 'failure') throw new Error('SDK descriptor trap')
-        return Reflect.getOwnPropertyDescriptor(target, property)
-      },
-    })
-    const throwingFacts = Object.create(null) as Record<string, unknown>
-    Object.defineProperty(throwingFacts, 'message', {
-      get() { throw new Error('SDK fact getter trap') },
-    })
-    const carrying = (message: string, failure: unknown): HarnessError => Object.defineProperty(
-      new HarnessError(message, 'SERVER'),
-      'failure',
-      { value: failure },
-    )
-    const factGetter = carrying('fact getter failed', throwingFacts)
-    const malformed = carrying('malformed facts', { message: 'provider busy', code: 'SERVER', requestId: 1 })
-    const primitive = carrying('primitive facts', 1)
-    const nullFacts = carrying('null facts', null)
-    const mismatched = carrying('mismatched facts', { message: 'busy', code: 'RATE_LIMIT' })
-
-    for (const [original, expectedMessage] of [
-      [propertyTrap, 'descriptor trapped'],
-      [factGetter, 'fact getter failed'],
-      [malformed, 'malformed facts'],
-      [primitive, 'primitive facts'],
-      [nullFacts, 'null facts'],
-      [mismatched, 'mismatched facts'],
-    ] as const) {
-      const ctx = new Context()
-      await ctx.plugin(LlmService)
-      ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-      const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-
-      await expect((async () => {
-        for await (const _chunk of stream) { /* drain */ }
-      })()).rejects.toBe(original)
-      expect(llmFailureOf(stream, original)).toEqual({ message: expectedMessage, code: 'SERVER' })
-    }
-  })
-
-  it('retains a stable code from a HarnessError without requiring LlmError facts', async () => {
-    const original = new HarnessError('stable adapter failure', 'ADAPTER_STABLE')
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-provider'], new ThrowingAdapter(original))
-    const stream = ctx.llm.stream({ provider: 'test-provider', model: 'test-model', messages: [] })
-
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toBe(original)
-    expect(llmFailureOf(stream, original)).toEqual({
-      message: 'stable adapter failure',
-      code: 'ADAPTER_STABLE',
-    })
-    expect(llmFailureOf(stream, 'not an Error')).toBeUndefined()
-    expect(llmFailureOf({ [Symbol.asyncIterator]: () => stream[Symbol.asyncIterator]() }, original)).toBeUndefined()
-  })
-
-  it('keeps a nested adapter failure scoped to the nested model call', async () => {
-    const original = new LlmError('nested provider failed', 'NESTED_FAILED')
-    const outer = new RecordingAdapter(SCRIPT)
-    const nested = new ThrowingAdapter(original)
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['outer'], outer)
-    ctx.llm.registerAdapter(['nested'], nested)
-    let nestedStream: AsyncIterable<StreamChunk> | undefined
-    ctx.on('llm/stream', (options, next) => {
-      if (options.provider !== 'outer') return next()
-      return (async function* () {
-        nestedStream = ctx.llm.stream({ provider: 'nested', model: 'nested', messages: [] })
-        yield * nestedStream
-      })()
-    })
-
-    const outerStream = ctx.llm.stream({ provider: 'outer', model: 'outer', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _chunk of outerStream) { /* drain */ }
-    } catch (error: unknown) {
-      caught = error
-    }
-
-    expect(caught).toBe(original)
-    expect(nestedStream).toBeDefined()
-    expect(isLlmAdapterFailure(nestedStream!, caught)).toBe(true)
-    expect(isLlmAdapterFailure(outerStream, caught)).toBe(false)
-    expect(outer.lastOptions).toBeUndefined()
-  })
-
-  it('keeps call scopes distinct when middleware reuses an iterable', async () => {
-    const firstFailure = new LlmError('first provider failed', 'FIRST_FAILED')
-    const secondFailure = new LlmError('second provider failed', 'SECOND_FAILED')
-    const delegates: AsyncIterable<StreamChunk>[] = []
-    const shared: AsyncIterable<StreamChunk> = {
-      [Symbol.asyncIterator](): AsyncIterator<StreamChunk> {
-        const delegate = delegates.shift()
-        if (delegate === undefined) throw new Error('shared stream has no call delegate')
-        return delegate[Symbol.asyncIterator]()
-      },
-    }
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['first'], new ThrowingAdapter(firstFailure))
-    ctx.llm.registerAdapter(['second'], new ThrowingAdapter(secondFailure))
-    ctx.on('llm/stream', (_options, next) => {
-      delegates.push(next())
-      return shared
-    })
-
-    const firstStream = ctx.llm.stream({ provider: 'first', model: 'first', messages: [] })
-    const secondStream = ctx.llm.stream({ provider: 'second', model: 'second', messages: [] })
-    const catchFailure = async (stream: AsyncIterable<StreamChunk>): Promise<unknown> => {
-      try {
-        for await (const _chunk of stream) { /* drain */ }
-      } catch (error: unknown) {
-        return error
-      }
-      return new Error('expected adapter to fail')
-    }
-
-    expect(firstStream).not.toBe(secondStream)
-    const firstCaught = await catchFailure(firstStream)
-    expect(firstCaught).toBe(firstFailure)
-    expect(isLlmAdapterFailure(firstStream, firstCaught)).toBe(true)
-    expect(isLlmAdapterFailure(secondStream, firstCaught)).toBe(false)
-    const secondCaught = await catchFailure(secondStream)
-    expect(secondCaught).toBe(secondFailure)
-    expect(isLlmAdapterFailure(secondStream, secondCaught)).toBe(true)
-    expect(isLlmAdapterFailure(firstStream, secondCaught)).toBe(false)
-    expect(delegates).toHaveLength(0)
-  })
-
-  it('propagates a rejected next promptly without awaiting a non-settling return', async () => {
-    const original = new LlmError('provider failed', 'PROVIDER_FAILED')
-    let cleanupCalls = 0
+  it('normalizes arbitrary adapter rejections without throwing them downstream', async () => {
     const adapter = new class extends LlmAdapter {
       stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
         return {
           [Symbol.asyncIterator](): AsyncIterator<StreamChunk> {
             return {
-              next: () => Promise.reject(original),
-              return: () => {
-                cleanupCalls += 1
-                return new Promise<IteratorResult<StreamChunk>>(() => {})
-              },
+              // Third-party adapters can reject with arbitrary values.
+              // oxlint-disable-next-line typescript/prefer-promise-reject-errors
+              next: () => Promise.reject('plain provider failure'),
             }
           },
         }
@@ -669,30 +384,73 @@ describe('LlmService', () => {
     }()
     const ctx = new Context()
     await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], adapter)
+    ctx.llm.registerAdapter(['test'], adapter)
 
-    const stream = ctx.llm.stream({ provider: 'test-model', model: 'test-model', messages: [] })
-    const failure = (async (): Promise<unknown> => {
-      try {
-        for await (const _chunk of stream) { /* drain */ }
-      } catch (error: unknown) {
-        return error
-      }
-      return new Error('expected adapter iteration to fail')
-    })()
-    let timer: ReturnType<typeof setTimeout> | undefined
-    const timeout = new Promise<Error>((resolve) => {
-      timer = setTimeout(() => { resolve(new Error('adapter failure did not settle promptly')) }, 100)
+    const chunks = await collect(ctx.llm.stream({
+      provider: 'test',
+      model: 'test',
+      messages: [],
+    }))
+
+    expect(chunks.at(-1)).toEqual({
+      type: 'finish',
+      reason: {
+        kind: 'error',
+        failure: { message: 'plain provider failure', code: 'UNKNOWN' },
+      },
     })
-    const caught = await Promise.race([failure, timeout])
-    if (timer !== undefined) clearTimeout(timer)
-
-    expect(caught).toBe(original)
-    expect(isLlmAdapterFailure(stream, caught)).toBe(true)
-    expect(cleanupCalls).toBe(0)
   })
 
-  it('awaits one adapter return on downstream close and leaves its rejection unclassified', async () => {
+  it('maps adapter failure to aborted when the request signal is aborted', async () => {
+    const controller = new AbortController()
+    controller.abort('cancelled')
+    const ctx = new Context()
+    await ctx.plugin(LlmService)
+    ctx.llm.registerAdapter(['test'], new ThrowingAdapter(new Error('stopped')))
+
+    const chunks = await collect(ctx.llm.stream({
+      provider: 'test',
+      model: 'test',
+      messages: [],
+      signal: controller.signal,
+    }))
+
+    expect(chunks.at(-1)).toMatchObject({
+      type: 'finish',
+      reason: { kind: 'aborted', failure: { message: 'stopped' } },
+    })
+  })
+
+  it('leaves middleware and consumer failures thrown', async () => {
+    const middlewareFailure = new Error('middleware failed')
+    const middlewareCtx = new Context()
+    await middlewareCtx.plugin(LlmService)
+    middlewareCtx.llm.registerAdapter(['test'], new ScriptedAdapter(SCRIPT))
+    middlewareCtx.on('llm/stream', () => (async function* () {
+      throw middlewareFailure
+    })())
+    await expect(collect(middlewareCtx.llm.stream({
+      provider: 'test',
+      model: 'test',
+      messages: [],
+    }))).rejects.toBe(middlewareFailure)
+
+    const consumerFailure = new Error('consumer failed')
+    const consumerCtx = new Context()
+    await consumerCtx.plugin(LlmService)
+    consumerCtx.llm.registerAdapter(['test'], new ScriptedAdapter(SCRIPT))
+    await expect((async () => {
+      for await (const _chunk of consumerCtx.llm.stream({
+        provider: 'test',
+        model: 'test',
+        messages: [],
+      })) {
+        throw consumerFailure
+      }
+    })()).rejects.toBe(consumerFailure)
+  })
+
+  it('awaits adapter cleanup on downstream close and leaves cleanup failure thrown', async () => {
     const cleanup = new Error('cleanup failed')
     let cleanupCalls = 0
     const adapter = new class extends LlmAdapter {
@@ -712,95 +470,18 @@ describe('LlmService', () => {
     }()
     const ctx = new Context()
     await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], adapter)
+    ctx.llm.registerAdapter(['test'], adapter)
 
-    const stream = ctx.llm.stream({ provider: 'test-model', model: 'test-model', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _chunk of stream) break
-    } catch (error: unknown) {
-      caught = error
-    }
-
-    expect(caught).toBe(cleanup)
-    expect(isLlmAdapterFailure(stream, caught)).toBe(false)
+    await expect((async () => {
+      for await (const _chunk of ctx.llm.stream({
+        provider: 'test',
+        model: 'test',
+        messages: [],
+      })) break
+    })()).rejects.toBe(cleanup)
     expect(cleanupCalls).toBe(1)
   })
 
-  it('allows downstream close when the adapter iterator has no return method', async () => {
-    const adapter = new class extends LlmAdapter {
-      stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
-        return {
-          [Symbol.asyncIterator](): AsyncIterator<StreamChunk> {
-            return { next: () => Promise.resolve({ done: false, value: SCRIPT[0]! }) }
-          },
-        }
-      }
-    }()
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], adapter)
-
-    let chunks = 0
-    for await (const _chunk of ctx.llm.stream({ provider: 'test-model', model: 'test-model', messages: [] })) {
-      chunks += 1
-      break
-    }
-
-    expect(chunks).toBe(1)
-  })
-
-  it('normalizes and tags non-Error adapter failures once', async () => {
-    const adapter = new class extends LlmAdapter {
-      stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
-        return {
-          [Symbol.asyncIterator](): AsyncIterator<StreamChunk> {
-            // Third-party adapters can reject with arbitrary values.
-            // oxlint-disable-next-line typescript/prefer-promise-reject-errors
-            return { next: () => Promise.reject('plain provider failure') }
-          },
-        }
-      }
-    }()
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], adapter)
-
-    const stream = ctx.llm.stream({ provider: 'test-model', model: 'test-model', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _chunk of stream) { /* drain */ }
-    } catch (error: unknown) {
-      caught = error
-    }
-
-    expect(caught).toBeInstanceOf(HarnessError)
-    expect(caught).toMatchObject({ code: 'UNKNOWN', cause: 'plain provider failure' })
-    expect(isLlmAdapterFailure(stream, caught)).toBe(true)
-  })
-
-  it('does not tag a failure thrown downstream while consuming adapter output', async () => {
-    const downstream = new Error('consumer failed')
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    ctx.llm.registerAdapter(['test-model'], new ScriptedAdapter(SCRIPT))
-
-    const stream = ctx.llm.stream({ provider: 'test-model', model: 'test-model', messages: [] })
-    let caught: unknown
-    try {
-      for await (const _chunk of stream) throw downstream
-    } catch (error: unknown) {
-      caught = error
-    }
-
-    expect(caught).toBe(downstream)
-    expect(isLlmAdapterFailure(stream, caught)).toBe(false)
-    expect(isLlmAdapterFailure(new ScriptedAdapter(SCRIPT).stream({
-      provider: 'unbound', model: 'unbound', messages: [],
-    }), caught)).toBe(false)
-    expect(isLlmAdapterFailure(stream, 'consumer failed')).toBe(false)
-  })
-
   it('unregisters adapters when the owning fiber is disposed (HMR safety)', async () => {
     const ctx = new Context()
     await ctx.plugin(LlmService)
@@ -1064,15 +745,15 @@ describe('LlmService', () => {
     ctx.llm.registerAdapter(['route'], adapter)
     const prepared = await ctx.llm.prepareCall({ provider: 'route', model: 'model' })
     expect(Object.isFrozen(prepared.config)).toBe(true)
-    const stream = prepared.stream({
+    expect(() => prepared.stream({
       ...prepared.config,
       model: 'other',
       messages: [],
-    })
-
-    await expect((async () => {
-      for await (const _chunk of stream) { /* drain */ }
-    })()).rejects.toMatchObject({ code: 'INVALID_PREPARED_CALL' })
+    })).toThrow(expect.objectContaining({ code: 'INVALID_PREPARED_CALL' }))
+    await collect(prepared.stream({
+      ...prepared.config,
+      messages: [],
+    }))
     expect(() => prepared.stream({
       ...prepared.config,
       messages: [],
diff --git a/packages/plan/plan-mode/tests/integration.spec.ts b/packages/plan/plan-mode/tests/integration.spec.ts
index 0945a4c8c2..31f1ce66a0 100644
--- a/packages/plan/plan-mode/tests/integration.spec.ts
+++ b/packages/plan/plan-mode/tests/integration.spec.ts
@@ -136,9 +136,7 @@ describe('plan mode through the agent loop', () => {
     const adapter = new MockAdapter([failedRequest, textResponse('Recovered in plan mode.')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('it-plan-retry-flip'), { provider: 'mock', model: 'mock' })
-    ctx.on('agent/request-error', async (
-      subject, _turn, _step, _error, _failure, _priorFailures, _retryPolicy, _signal, next,
-    ) => {
+    ctx.on('agent/request-error', async (subject, _context, _signal, next) => {
       if (subject !== agent) return next()
       ctx.planMode.set(agent, true)
       return { kind: 'retry' }
diff --git a/packages/plan/plan-mode/tests/plan-mode.spec.ts b/packages/plan/plan-mode/tests/plan-mode.spec.ts
index d988fc3d1c..2708b00ecc 100644
--- a/packages/plan/plan-mode/tests/plan-mode.spec.ts
+++ b/packages/plan/plan-mode/tests/plan-mode.spec.ts
@@ -59,14 +59,15 @@ async function setup(config: PlanModeConfig = PLAN_CONFIG): Promise<Context> {
 async function boundary(ctx: Context, agent: Agent & { session: Session }, type: 'turn/start' | 'step/end'): Promise<void> {
   const events = agentEvents(ctx, agent)
   if (type === 'turn/start') {
+    const message = createUserMessage({
+      content: [{ type: 'text', text: 'boundary probe' }],
+      source: { kind: 'user' },
+    })
     await events.waterfall(
       'agent/prompt-submit',
-      createUserMessage({
-        content: [{ type: 'text', text: 'boundary probe' }],
-        source: { kind: 'user' },
-      }),
+      [message],
       new AbortController().signal,
-      () => Promise.resolve({ kind: 'allow' }),
+      () => Promise.resolve({ kind: 'allow', messages: [message] }),
     )
     return
   }
diff --git a/packages/pty/pty-local/tests/index.spec.ts b/packages/pty/pty-local/tests/index.spec.ts
index 3976e586cb..46cc691a38 100644
--- a/packages/pty/pty-local/tests/index.spec.ts
+++ b/packages/pty/pty-local/tests/index.spec.ts
@@ -3,7 +3,7 @@ import type { IPty, IPtyForkOptions } from 'node-pty'
 import { Context } from 'cordis'
 import Loader from '@cordisjs/plugin-loader'
 import SessionStore, { Session, SessionId } from '@deepseek-ai/dsh-session'
-import AgentRegistry, { type Agent } from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { Inbox, type Agent } from '@deepseek-ai/dsh-agent'
 import SandboxProvider from '@deepseek-ai/dsh-sandbox'
 import type { ConfinedArgv, SandboxPolicy } from '@deepseek-ai/dsh-sandbox'
 import SandboxPolicyService, { setSandboxMode } from '@deepseek-ai/dsh-sandbox-policy'
@@ -40,8 +40,9 @@ function config(): ResolvedConfig {
 
 function agent(ctx: Context): Agent {
   const id = SessionId('agent')
+  const session = new Session(id)
   return {
-    id, options: {}, session: new Session(id), status: 'idle', ctx,
+    id, options: {}, session, inbox: new Inbox(session), status: 'idle', ctx,
     followup: () => {}, steer: () => {}, inject: () => {}, cancel() {}, whenIdle: () => Promise.resolve(),
   }
 }
@@ -248,7 +249,7 @@ describe('pty-local plugin shape', () => {
     const session = ctx.sessions.create(SessionId('mode-owner'))
     const ownerFiber = await ctx.plugin(() => {})
     const owner: Agent = {
-      id: session.id, options: {}, session, status: 'idle', ctx: ownerFiber.ctx,
+      id: session.id, options: {}, session, inbox: new Inbox(session), status: 'idle', ctx: ownerFiber.ctx,
       followup: () => {}, steer: () => {}, inject: () => {}, cancel() {}, whenIdle: () => Promise.resolve(),
     }
     ctx.agents.register(owner)
@@ -291,7 +292,7 @@ describe('pty-local plugin shape', () => {
     const session = ctx.sessions.create(SessionId('pending-mode-owner'))
     const ownerFiber = await ctx.plugin(() => {})
     const owner: Agent = {
-      id: session.id, options: {}, session, status: 'idle', ctx: ownerFiber.ctx,
+      id: session.id, options: {}, session, inbox: new Inbox(session), status: 'idle', ctx: ownerFiber.ctx,
       followup: () => {}, steer: () => {}, inject: () => {}, cancel() {}, whenIdle: () => Promise.resolve(),
     }
     ctx.agents.register(owner)
diff --git a/packages/pty/pty-local/tests/local.spec.ts b/packages/pty/pty-local/tests/local.spec.ts
index c2cb23cb59..1a52bcc672 100644
--- a/packages/pty/pty-local/tests/local.spec.ts
+++ b/packages/pty/pty-local/tests/local.spec.ts
@@ -4,7 +4,7 @@ import { join } from 'node:path'
 import { afterEach, describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
 import { Session, SessionId } from '@deepseek-ai/dsh-session'
-import AgentRegistry, {} from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { Inbox } from '@deepseek-ai/dsh-agent'
 import type { Agent } from '@deepseek-ai/dsh-agent'
 import PtyService from '@deepseek-ai/dsh-pty'
 import type { PtySendOperation } from '@deepseek-ai/dsh-pty'
@@ -33,8 +33,9 @@ class PassthroughSandbox extends SandboxProvider {
 function stubAgent(ctx: Context, rawId: string): Agent {
   const id = SessionId(rawId)
   const scope = ctx.plugin(() => {})
+  const session = new Session(id)
   return {
-    id, options: {}, session: new Session(id), status: 'idle', ctx: scope.ctx,
+    id, options: {}, session, inbox: new Inbox(session), status: 'idle', ctx: scope.ctx,
     followup: () => {}, steer: () => {}, inject: () => {}, cancel() {}, whenIdle: () => Promise.resolve(),
   }
 }
diff --git a/packages/pty/pty/tests/service.spec.ts b/packages/pty/pty/tests/service.spec.ts
index cf5c4f0bab..5cb1dea2d0 100644
--- a/packages/pty/pty/tests/service.spec.ts
+++ b/packages/pty/pty/tests/service.spec.ts
@@ -1,7 +1,7 @@
 import { describe, expect, expectTypeOf, it } from 'vitest'
 import { Context } from 'cordis'
 import { Session, SessionId } from '@deepseek-ai/dsh-session'
-import AgentRegistry, {} from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { Inbox } from '@deepseek-ai/dsh-agent'
 import type { Agent } from '@deepseek-ai/dsh-agent'
 import PtyService, { PtyBackendCleanupError, PtyError, PtySessionId } from '@deepseek-ai/dsh-pty'
 import type {
@@ -21,10 +21,12 @@ const ptyServiceDisposers = new WeakMap<Context, () => Promise<void>>()
 function stubAgent(ctx: Context, rawId: string): Agent {
   const id = SessionId(rawId)
   const scopeFiber = ctx.plugin(() => {})
+  const session = new Session(id)
   const agent: Agent = {
     id,
     options: {},
-    session: new Session(id),
+    session,
+    inbox: new Inbox(session),
     status: 'idle',
     ctx: scopeFiber.ctx,
     followup: () => {},
diff --git a/packages/pty/tool-bash-persistent/tests/loader-composition.spec.ts b/packages/pty/tool-bash-persistent/tests/loader-composition.spec.ts
index 9e18402477..68f08223ff 100644
--- a/packages/pty/tool-bash-persistent/tests/loader-composition.spec.ts
+++ b/packages/pty/tool-bash-persistent/tests/loader-composition.spec.ts
@@ -8,7 +8,7 @@ import Loader from '@cordisjs/plugin-loader'
 import Include from '@cordisjs/plugin-include'
 import { CallId } from '@deepseek-ai/dsh-llm'
 import { Session, SessionId } from '@deepseek-ai/dsh-session'
-import AgentRegistry from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { Inbox } from '@deepseek-ai/dsh-agent'
 import type { Agent } from '@deepseek-ai/dsh-agent'
 import PtyService from '@deepseek-ai/dsh-pty'
 import * as PtyLocal from '@deepseek-ai/dsh-pty-local'
@@ -38,18 +38,17 @@ class PassthroughSandbox extends SandboxProvider {
 function agent(ctx: Context, cwd: string): Agent {
   const id = SessionId('persistent-bash-loader-agent')
   const scope = ctx.plugin(() => {})
+  const session = new Session(id, [], { version: 0, id, createdAt: 0, cwd })
   const value: Agent = {
     id,
     options: {},
-    session: new Session(id, [], { version: 0, id, createdAt: 0, cwd }),
+    session,
+    inbox: new Inbox(session),
     status: 'idle',
-    acceptsNextStep: false,
     ctx: scope.ctx,
     followup: () => {},
     steer: () => {},
     inject: () => {},
-    send: () => {},
-    updateInbox: () => 'not-found',
     cancel() {},
     whenIdle: () => Promise.resolve(),
   }
diff --git a/packages/pty/tool-bash-persistent/tests/tools.spec.ts b/packages/pty/tool-bash-persistent/tests/tools.spec.ts
index 9949879292..b0e64b770c 100644
--- a/packages/pty/tool-bash-persistent/tests/tools.spec.ts
+++ b/packages/pty/tool-bash-persistent/tests/tools.spec.ts
@@ -2,7 +2,7 @@ import { afterEach, describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
 import { CallId } from '@deepseek-ai/dsh-llm'
 import { Session, SessionId } from '@deepseek-ai/dsh-session'
-import AgentRegistry from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { Inbox } from '@deepseek-ai/dsh-agent'
 import type { Agent } from '@deepseek-ai/dsh-agent'
 import PtyService from '@deepseek-ai/dsh-pty'
 import type {
@@ -29,23 +29,22 @@ afterEach(async () => {
 function agent(ctx: Context, cwd: string | undefined): Agent {
   const id = SessionId(`persistent-bash-owner-${callNumber}`)
   const scope = ctx.plugin(() => {})
+  const session = new Session(id, [], {
+    version: 0,
+    id,
+    createdAt: 0,
+    ...cwd === undefined ? {} : { cwd },
+  })
   const value: Agent = {
     id,
     options: {},
-    session: new Session(id, [], {
-      version: 0,
-      id,
-      createdAt: 0,
-      ...cwd === undefined ? {} : { cwd },
-    }),
+    session,
+    inbox: new Inbox(session),
     status: 'idle',
-    acceptsNextStep: false,
     ctx: scope.ctx,
     followup: () => {},
     steer: () => {},
     inject: () => {},
-    send: () => {},
-    updateInbox: () => 'not-found',
     cancel() {},
     whenIdle: () => Promise.resolve(),
   }
diff --git a/packages/pty/tool-pty/tests/loader-composition.spec.ts b/packages/pty/tool-pty/tests/loader-composition.spec.ts
index da8555e4c8..29ad29e65d 100644
--- a/packages/pty/tool-pty/tests/loader-composition.spec.ts
+++ b/packages/pty/tool-pty/tests/loader-composition.spec.ts
@@ -8,7 +8,7 @@ import Loader from '@cordisjs/plugin-loader'
 import Include from '@cordisjs/plugin-include'
 import { CallId } from '@deepseek-ai/dsh-llm'
 import { Session, SessionId } from '@deepseek-ai/dsh-session'
-import AgentRegistry, {} from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { Inbox } from '@deepseek-ai/dsh-agent'
 import type { Agent } from '@deepseek-ai/dsh-agent'
 import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
 import ToolRegistry from '@deepseek-ai/dsh-tools'
@@ -38,8 +38,9 @@ class PassthroughSandbox extends SandboxProvider {
 function agent(ctx: Context): Agent {
   const scope = ctx.plugin(() => {})
   const id = SessionId('pty-loader-agent')
+  const session = new Session(id)
   const value: Agent = {
-    id, options: {}, session: new Session(id), status: 'idle', ctx: scope.ctx,
+    id, options: {}, session, inbox: new Inbox(session), status: 'idle', ctx: scope.ctx,
     followup: () => {}, steer: () => {}, inject: () => {}, cancel() {}, whenIdle: () => Promise.resolve(),
   }
   ctx.agents.register(value)
diff --git a/packages/pty/tool-pty/tests/tools.spec.ts b/packages/pty/tool-pty/tests/tools.spec.ts
index ed9a41d370..bc25489fcf 100644
--- a/packages/pty/tool-pty/tests/tools.spec.ts
+++ b/packages/pty/tool-pty/tests/tools.spec.ts
@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
 import { CallId } from '@deepseek-ai/dsh-llm'
 import { Session, SessionId } from '@deepseek-ai/dsh-session'
-import AgentRegistry, {} from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { Inbox } from '@deepseek-ai/dsh-agent'
 import type { Agent } from '@deepseek-ai/dsh-agent'
 import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
 import ToolRegistry, { renderToolsSdk } from '@deepseek-ai/dsh-tools'
@@ -16,8 +16,9 @@ import * as ToolPty from '@deepseek-ai/dsh-tool-pty'
 function fakeAgent(ctx: Context, rawId: string): Agent {
   const scope = ctx.plugin(() => {})
   const id = SessionId(rawId)
+  const session = new Session(id)
   const agent: Agent = {
-    id, options: {}, session: new Session(id), status: 'idle', ctx: scope.ctx,
+    id, options: {}, session, inbox: new Inbox(session), status: 'idle', ctx: scope.ctx,
     followup: () => {}, steer: () => {}, inject: () => {}, cancel() {}, whenIdle: () => Promise.resolve(),
   }
   ctx.agents.register(agent)
diff --git a/packages/sdk/sdk-client/tests/sdk-client.spec.ts b/packages/sdk/sdk-client/tests/sdk-client.spec.ts
index e31490a6cd..ca2d30b3cc 100644
--- a/packages/sdk/sdk-client/tests/sdk-client.spec.ts
+++ b/packages/sdk/sdk-client/tests/sdk-client.spec.ts
@@ -158,7 +158,6 @@ describe('DeepSeekHarness', () => {
     // Retry spawns a NEW subprocess through a fresh client (close is permanent).
     const result = await harness.run('again')
     expect(harness.client).not.toBe(firstClient)
-    expect(result.status).toBe('ok')
     expect(result.finalResponse).toBe('second boot answer')
     await harness.close()
     // close() is terminal: a handshake failure after it must not respawn.
@@ -176,7 +175,7 @@ describe('DeepSeekHarness', () => {
       await using harness = new DeepSeekHarness({ launch: fakeLaunch() })
       captured = harness
       const result = await harness.run('scoped')
-      expect(result.status).toBe('ok')
+      expect(result.finalResponse).toBe('scoped')
     }
     // After scope exit the runtime is closed: reuse fails loudly.
     await expect(captured.run('after')).rejects.toThrow(TransportClosedError)
diff --git a/packages/session-query/session-query-sqlite/tests/sqlite.spec.ts b/packages/session-query/session-query-sqlite/tests/sqlite.spec.ts
index 689bbad618..25cdb8fa6b 100644
--- a/packages/session-query/session-query-sqlite/tests/sqlite.spec.ts
+++ b/packages/session-query/session-query-sqlite/tests/sqlite.spec.ts
@@ -241,7 +241,7 @@ describe('SQLite session search', () => {
       { type: 'user/message', seq: 2, time: 12, data: createUserMessage({
         content: [{ type: 'text', text: 'needle summary' }], source: { kind: 'plugin', plugin: 'test' },
       }), surfaceOp: { op: 'replace', start: 0, end: 0 }, sourceEventSeqs: [0] },
-      { type: 'turn/end', seq: 3, time: 13, data: { turn: 1, reason: { kind: 'error', step: 1, message: 'needle failure' } } },
+      { type: 'turn/end', seq: 3, time: 13, data: { turn: 1, reason: { kind: 'error', error: 'needle failure' } } },
     ]
     ctx.sessions.create(SessionId('a'), { seed: events, meta: { cwd: '/a', parentSession: parent, createdAt: 20 } })
     ctx.sessions.create(SessionId('b'), { seed: messageEvents('needle peer', 12), meta: { createdAt: 20 } })
diff --git a/packages/session-query/session-query/tests/search-helpers.spec.ts b/packages/session-query/session-query/tests/search-helpers.spec.ts
index 891b95892c..c47f528809 100644
--- a/packages/session-query/session-query/tests/search-helpers.spec.ts
+++ b/packages/session-query/session-query/tests/search-helpers.spec.ts
@@ -111,11 +111,10 @@ describe('session-query semantic extraction', () => {
 
   it('extracts meaningful turn outcomes and skips structural or unknown events', () => {
     const reasons: Array<[SessionEvent<'turn/end'>['data']['reason'], string]> = [
-      [{ kind: 'error', step: 2, message: 'boom', code: 'E' }, 'error\nboom\nE'],
-      [{ kind: 'error', step: 2, message: 'boom' }, 'error\nboom'],
-      [{ kind: 'error', step: 2, failure: { message: 'provider boom', code: 'SERVER' } }, 'error\nprovider boom\nSERVER'],
-      [{ kind: 'aborted' }, 'aborted'],
-      [{ kind: 'disposed' }, 'disposed'],
+      [{ kind: 'error', error: new Error('boom') }, 'error\nboom'],
+      [{ kind: 'error', error: 'provider boom' }, 'error\nprovider boom'],
+      [{ kind: 'aborted', reason: { kind: 'user' } }, 'aborted'],
+      [{ kind: 'aborted', reason: { kind: 'disposed' } }, 'aborted'],
       [{ kind: 'max-tokens' }, 'max-tokens'],
       [{ kind: 'interrupted' }, 'interrupted'],
       [{ kind: 'completed' }, ''],
diff --git a/packages/session-title/session-title/tests/rename.spec.ts b/packages/session-title/session-title/tests/rename.spec.ts
index 01d613ee3e..c7069c5c2f 100644
--- a/packages/session-title/session-title/tests/rename.spec.ts
+++ b/packages/session-title/session-title/tests/rename.spec.ts
@@ -34,7 +34,7 @@ describe('SessionTitleService.rename', () => {
     await ctx.plugin(SessionStore)
     await ctx.plugin(SessionTitleService, CONFIG)
     const session = ctx.sessions.create(SessionId('rename-accept'))
-    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+    session.append('turn/start', { turn: 1 })
     appendHumanPrompt(session, 'Original prompt text')
     await settle()
 
@@ -79,7 +79,7 @@ describe('SessionTitleService.rename', () => {
       generate,
     })
     const session = ctx.sessions.create(SessionId('rename-pin'))
-    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+    session.append('turn/start', { turn: 1 })
     appendHumanPrompt(session, 'First prompt')
     await settle()
     ctx.sessionTitle.rename(session, 'Pinned by hand')
@@ -107,7 +107,7 @@ describe('SessionTitleService.rename', () => {
     await ctx.plugin(SessionStore)
     await ctx.plugin(SessionTitleService, CONFIG)
     const session = ctx.sessions.create(SessionId('rename-unpin-fallback'))
-    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+    session.append('turn/start', { turn: 1 })
     appendHumanPrompt(session, 'Derivable prompt words')
     await settle()
     ctx.sessionTitle.rename(session, 'Pinned without provider')
@@ -143,7 +143,7 @@ describe('SessionTitleService.rename', () => {
       generate,
     })
     const session = ctx.sessions.create(SessionId('rename-supersede'))
-    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+    session.append('turn/start', { turn: 1 })
     appendHumanPrompt(session, 'Prompt that triggers generation')
     session.append('request/header', {
       header: { config: { provider: 'main-route', model: 'chat-model' } },
@@ -169,7 +169,7 @@ describe('SessionTitleService.rename', () => {
     // re-derived fallback is empty, so the pinned title survives the refresh.
     await ctx.plugin(SessionTitleService, { ...CONFIG, fallbackMaxBytes: 3 })
     const session = ctx.sessions.create(SessionId('rename-unpin-empty'))
-    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+    session.append('turn/start', { turn: 1 })
     appendHumanPrompt(session, '😀😀')
     await settle()
     ctx.sessionTitle.rename(session, 'Sticky emoji pin')
diff --git a/packages/skill/tool-skill/tests/tool-skill.spec.ts b/packages/skill/tool-skill/tests/tool-skill.spec.ts
index 98ae51e38a..f49d05e55a 100644
--- a/packages/skill/tool-skill/tests/tool-skill.spec.ts
+++ b/packages/skill/tool-skill/tests/tool-skill.spec.ts
@@ -8,7 +8,7 @@ import { createScope, type Scope } from '@deepseek-ai/dsh-scope'
 import { Session, SessionId, type SessionEvent } from '@deepseek-ai/dsh-session'
 import SystemPrompt, { renderPrompt } from '@deepseek-ai/dsh-system-prompt'
 import ToolRegistry, { defineContentToolFixture } from '@deepseek-ai/dsh-tools'
-import AgentRegistry, { agentEvents, type Agent } from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { agentEvents, Inbox, type Agent } from '@deepseek-ai/dsh-agent'
 import SkillService from '@deepseek-ai/dsh-skill'
 import * as SkillLocal from '@deepseek-ai/dsh-skill-local'
 import * as toolSkill from '@deepseek-ai/dsh-tool-skill'
@@ -44,6 +44,7 @@ function agentForCwd(cwd: string): Agent {
     id,
     options: {},
     session,
+    inbox: new Inbox(session),
     status: 'idle',
     followup: () => {},
     steer: () => {},
@@ -60,6 +61,7 @@ function sessionAgent(session: Session, id = 'tool-skill-agent'): Agent {
     id: SessionId(id),
     options: {},
     session,
+    inbox: new Inbox(session),
     status: 'running',
     ctx: new Context(),
     followup: () => {},
diff --git a/packages/subagent/subagent-dsh-sdk/tests/subagent-dsh-sdk.spec.ts b/packages/subagent/subagent-dsh-sdk/tests/subagent-dsh-sdk.spec.ts
index 16a9c57899..2b22174eca 100644
--- a/packages/subagent/subagent-dsh-sdk/tests/subagent-dsh-sdk.spec.ts
+++ b/packages/subagent/subagent-dsh-sdk/tests/subagent-dsh-sdk.spec.ts
@@ -73,10 +73,10 @@ describe('sdkStopReason', () => {
   it('maps each child turn-end reason to the harness vocabulary', () => {
     expect(sdkStopReason({ kind: 'completed' })).toBe('completed')
     expect(sdkStopReason({ kind: 'max-tokens' })).toBe('max-tokens')
-    expect(sdkStopReason({ kind: 'aborted' })).toBe('aborted')
-    expect(sdkStopReason({ kind: 'error', step: 0, message: 'x' })).toBe('error')
+    expect(sdkStopReason({ kind: 'aborted', reason: { kind: 'user' } })).toBe('aborted')
+    expect(sdkStopReason({ kind: 'error', error: new Error('x') })).toBe('error')
     expect(sdkStopReason({ kind: 'interrupted' })).toBe('error')
-    expect(sdkStopReason({ kind: 'disposed' })).toBe('error')
+    expect(sdkStopReason({ kind: 'aborted', reason: { kind: 'disposed' } })).toBe('aborted')
   })
 
   it('treats an absent or unknown reason as an error', () => {
diff --git a/packages/support/llm-replay/tests/llm-replay.spec.ts b/packages/support/llm-replay/tests/llm-replay.spec.ts
index 467cc26a0b..86e45529a8 100644
--- a/packages/support/llm-replay/tests/llm-replay.spec.ts
+++ b/packages/support/llm-replay/tests/llm-replay.spec.ts
@@ -166,7 +166,7 @@ describe('deriveReplayScript', () => {
     const events: SessionEvent[] = [
       chunkEvent(1, 1, 1, { type: 'block-start', index: 0, blockType: 'text' }),
       chunkEvent(2, 1, 1, { type: 'text-delta', index: 0, text: 'par' }),
-      { type: 'turn/end', seq: 3, time: 0, data: { turn: 1, reason: { kind: 'error', step: 1, message: 'x' } } },
+      { type: 'turn/end', seq: 3, time: 0, data: { turn: 1, reason: { kind: 'error', error: 'x' } } },
     ]
     expect(() => deriveReplayScript(events)).toThrow(/without a finish chunk.*replay\.override\.json/s)
   })
diff --git a/packages/tasks/tasks-local/tests/tasks.spec.ts b/packages/tasks/tasks-local/tests/tasks.spec.ts
index 5cf11732cf..c3495a1cd2 100644
--- a/packages/tasks/tasks-local/tests/tasks.spec.ts
+++ b/packages/tasks/tasks-local/tests/tasks.spec.ts
@@ -1,7 +1,7 @@
 import { describe, expect, expectTypeOf, it, vi } from 'vitest'
 import { Context } from 'cordis'
 import { Session, SessionId } from '@deepseek-ai/dsh-session'
-import AgentRegistry, {} from '@deepseek-ai/dsh-agent'
+import AgentRegistry, { Inbox } from '@deepseek-ai/dsh-agent'
 import type { Agent } from '@deepseek-ai/dsh-agent'
 import { TaskId } from '@deepseek-ai/dsh-tasks'
 import type { TaskHooks, TaskKind, TaskOutcome, TaskSnapshot, TaskStart } from '@deepseek-ai/dsh-tasks'
@@ -18,10 +18,12 @@ const agentScopeDisposers = new WeakMap<Agent, () => Promise<void>>()
 function stubAgent(ctx: Context, rawId: string): Agent {
   const id = SessionId(rawId)
   const scopeFiber = ctx.plugin(() => {})
+  const session = new Session(id)
   const agent = {
     id,
     options: {},
-    session: new Session(id),
+    session,
+    inbox: new Inbox(session),
     status: 'idle' as const,
     ctx: scopeFiber.ctx,
     followup: () => {},
diff --git a/packages/telemetry/session-telemetry-otel/tests/otel.spec.ts b/packages/telemetry/session-telemetry-otel/tests/otel.spec.ts
index d6f8bf0664..fa2b67db2b 100644
--- a/packages/telemetry/session-telemetry-otel/tests/otel.spec.ts
+++ b/packages/telemetry/session-telemetry-otel/tests/otel.spec.ts
@@ -94,7 +94,7 @@ describe('TelemetryOtel wire', () => {
     const { ctx, fiber } = await boot(url)
     const session = ctx.sessions.create(SessionId('wire'), { meta: { cwd: '/tmp/w' } })
     session.append('turn/start', { turn: 1 })
-    session.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, message: 'boom' } })
+    session.append('turn/end', { turn: 1, reason: { kind: 'error', error: new Error('boom') } })
     await fiber.dispose()
 
     expect(captures.length).toBeGreaterThan(0)
diff --git a/packages/telemetry/session-telemetry/tests/telemetry.spec.ts b/packages/telemetry/session-telemetry/tests/telemetry.spec.ts
index c5d3fb650a..50c54f4148 100644
--- a/packages/telemetry/session-telemetry/tests/telemetry.spec.ts
+++ b/packages/telemetry/session-telemetry/tests/telemetry.spec.ts
@@ -126,7 +126,7 @@ describe('TelemetryCoordinator capture', () => {
       }),
     }, { surfaceOp: 'append' })
     session.append('telemetry-test/opaque', { payload: { nested: [] } })
-    session.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, message: 'boom' } })
+    session.append('turn/end', { turn: 1, reason: { kind: 'error', error: new Error('boom') } })
     const severities = backend.ledger().map(r => [r.attributes['event.type'], r.severity])
     expect(severities).toEqual([
       ['turn/start', 'info'],
diff --git a/packages/ui/permission/tests/projection.spec.ts b/packages/ui/permission/tests/projection.spec.ts
index 2046adb6a1..7f6ae10a30 100644
--- a/packages/ui/permission/tests/projection.spec.ts
+++ b/packages/ui/permission/tests/projection.spec.ts
@@ -62,7 +62,7 @@ describe('permissions projection unit', () => {
     expect(changes).toHaveLength(3)
     expect(changes.at(-1)).toMatchObject({ key: 'permissions', value: { currentValue: 'danger-full-access' } })
     // Unrelated event: same-reference apply, no notification.
-    session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
+    session.append('turn/start', { turn: 1 })
     expect(changes).toHaveLength(3)
   })
 
diff --git a/packages/ui/tui/src/index.ts b/packages/ui/tui/src/index.ts
index de8288d71d..ad1eb5fb12 100644
--- a/packages/ui/tui/src/index.ts
+++ b/packages/ui/tui/src/index.ts
@@ -1227,7 +1227,7 @@ export function createTuiChat(
       if (cleanedUp) return
       cleanedUp = true
       detachSubmit()
-      detachDiscard()
+      detachSplice()
     }
     // Prepended so this wrapper is outermost: it observes the exact accepted
     // message identity whether a downstream hook allows or blocks, then detaches.
@@ -1238,11 +1238,16 @@ export function createTuiChat(
       if (decision.kind !== 'allow') return decision
       return { ...decision, messages: [...decision.messages, attachedContext] }
     }, { prepend: true })
-    // Installed before followup(): an enqueue listener can synchronously
-    // cancel and discard before followup() returns its id.
-    const detachDiscard = ctx.on('agent/inbox/discard', (subject, items) => {
-      if (subject !== agent) return
-      for (const item of items) discarded.add(item.message.id)
+    // Installed before followup(): an inbox observer can synchronously cancel
+    // the inserted message before followup() returns.
+    const detachSplice = ctx.on('session/event', (session, event) => {
+      if (session !== agent.session || event.type !== 'agent/inbox/spliced'
+        || event.data.target !== 'next-turn' || event.data.outcome !== 'canceled') return
+      const removed = agent.inbox.nextTurn.slice(
+        event.data.start,
+        event.data.start + (event.data.removedCount ?? 0),
+      )
+      for (const item of removed) discarded.add(item.id)
       if (discarded.has(acceptedId)) cleanup()
     })
     // followup() accepts any typed input and contains listener failures;
@@ -1463,6 +1468,15 @@ export function createTuiChat(
 
   const disposeSessionEvents = ctx.on('session/event', (session, event) => {
     if (session !== agent.session) return
+    if (event.type === 'agent/inbox/spliced' && event.data.target === 'next-step') {
+      const removed = agent.inbox.nextStep.slice(
+        event.data.start,
+        event.data.start + (event.data.removedCount ?? 0),
+      )
+      let changed = false
+      for (const message of removed) changed = pendingSteering.delete(message.id) || changed
+      if (changed) refreshStatus()
+    }
     if (event.type === 'tool/result') fileSearch.invalidate()
     recordEventUsage(tokens, event)
     if (event.type === 'turn/start' && runningStatus !== undefined) runningStatus.turn = event.data.turn
@@ -1474,18 +1488,6 @@ export function createTuiChat(
     renderEvent(event, { addHistory: false, renderChunks: true })
     requestRender()
   })
-  const settlePendingSteering = (id: MessageId): void => {
-    if (pendingSteering.delete(id)) refreshStatus()
-  }
-  const disposeDequeued = ctx.on('agent/inbox/dequeue', (subject, item) => {
-    if (subject === agent) settlePendingSteering(item.message.id)
-  })
-  const disposeDiscarded = ctx.on('agent/inbox/discard', (subject, items) => {
-    if (subject !== agent) return
-    let changed = false
-    for (const item of items) changed = pendingSteering.delete(item.message.id) || changed
-    if (changed) refreshStatus()
-  })
   const disposeStatus = ctx.on('agent/status', (subject, status) => {
     if (subject !== agent) return
     // Leaving 'running' ends the turn's status line; clear any badge so the
@@ -1526,8 +1528,6 @@ export function createTuiChat(
     for (const value of promptValues) value.dispose()
     stopBannerReveal()
     disposeSessionEvents()
-    disposeDequeued()
-    disposeDiscarded()
     disposeStatus()
     disposeError()
     disposeAgent()
diff --git a/packages/ui/tui/tests/harness.ts b/packages/ui/tui/tests/harness.ts
index a6a22ec2d9..8e3ae3d634 100644
--- a/packages/ui/tui/tests/harness.ts
+++ b/packages/ui/tui/tests/harness.ts
@@ -2,6 +2,7 @@ import { createUserMessage, MessageId , createMessage } from '@deepseek-ai/dsh-l
 import { Context } from 'cordis'
 import type { Terminal } from '@earendil-works/pi-tui'
 import AgentRegistry, {
+  Inbox,
   type Agent,
   type AgentCancelCause,
   type AgentOptions,
@@ -190,6 +191,7 @@ export async function createTuiTestHarness<TerminalType extends Terminal, Exit e
     id: sessionId,
     options: options.agentOptions ?? { provider: 'deepseek', model: 'deepseek-v4-flash' },
     session,
+    inbox: new Inbox(session),
     status: options.status ?? 'idle',
     ctx,
     sent,
diff --git a/packages/ui/tui/tests/tui.snapshot.ts b/packages/ui/tui/tests/tui.snapshot.ts
index bc42fd57ed..2a6c83962d 100644
--- a/packages/ui/tui/tests/tui.snapshot.ts
+++ b/packages/ui/tui/tests/tui.snapshot.ts
@@ -387,7 +387,7 @@ describe('TUI terminal-state snapshots', () => {
       })
       harness.session.append('turn/end', {
         turn: 1,
-        reason: { kind: 'aborted' },
+        reason: { kind: 'aborted', reason: { kind: 'user' } },
       })
     })
     await checkpoint('retry-cancelled', harness.terminal, { includeScrollback: true })
@@ -407,8 +407,7 @@ describe('TUI terminal-state snapshots', () => {
         turn: 1,
         reason: {
           kind: 'error',
-          step: 3,
-          failure: { message: 'provider still unavailable', code: 'SERVER', status: 503 },
+          error: { message: 'provider still unavailable', code: 'SERVER', status: 503 },
         },
       })
     })
@@ -587,7 +586,7 @@ describe('TUI terminal-state snapshots', () => {
         session.append('step/end', { turn: 1, step: 1 })
         session.append('turn/end', {
           turn: 1,
-          reason: { kind: 'error', step: 1, message: `Unsafe turn error ${CONTROL_PROBE}` },
+          reason: { kind: 'error', error: `Unsafe turn error ${CONTROL_PROBE}` },
         })
       },
     }, { columns: 100, rows: 34 })
@@ -771,7 +770,7 @@ describe('TUI terminal-state snapshots', () => {
       harness.session.append('step/end', { turn: 1, step: 1 })
       harness.session.append('turn/end', {
         turn: 1,
-        reason: { kind: 'error', step: 1, message: 'provider stream failed after partial output' },
+        reason: { kind: 'error', error: 'provider stream failed after partial output' },
       })
       harness.session.append('turn/start', { turn: 2 })
       harness.session.append('turn/end', {
@@ -779,7 +778,10 @@ describe('TUI terminal-state snapshots', () => {
         reason: { kind: 'interrupted' },
       })
       harness.session.append('turn/start', { turn: 3 })
-      harness.session.append('turn/end', { turn: 3, reason: { kind: 'disposed' } })
+      harness.session.append('turn/end', {
+        turn: 3,
+        reason: { kind: 'aborted', reason: { kind: 'disposed' } },
+      })
       harness.session.append('turn/start', { turn: 4 })
       // A merge-extensible turn-end kind unknown to the TUI still surfaces its
       // name so the agent never stops without a visible reason.
diff --git a/packages/ui/tui/tests/tui.spec.ts b/packages/ui/tui/tests/tui.spec.ts
index 0979714468..458f3d57e7 100644
--- a/packages/ui/tui/tests/tui.spec.ts
+++ b/packages/ui/tui/tests/tui.spec.ts
@@ -5,17 +5,14 @@ import { describe, expect, it, vi } from 'vitest'
 import { Context } from 'cordis'
 import { CombinedAutocompleteProvider, visibleWidth, type Terminal } from '@earendil-works/pi-tui'
 import AgentRegistry, {
-  agentEvents, assembleContextFor, InboxItemId, type Agent, type InboxItem,
-  type InboxPlacement,
+  agentEvents, assembleContextFor, Inbox, type Agent,
 } from '@deepseek-ai/dsh-agent'
 import { createUserMessage,
   createToolResultMessage,
   ReasoningEffortId,
   type LlmCallConfig,
   type LlmModelReasoningInfo,
-  MessageId,
   createMessage,
-  freezeMessage,
 } from '@deepseek-ai/dsh-llm'
 import { GOAL_CHANGE_VERSION, GoalId, renderGoalChange, type GoalSnapshotChangeMeta } from '@deepseek-ai/dsh-goal'
 import CommandService, { type CommandInvocation } from '@deepseek-ai/dsh-commands'
@@ -54,13 +51,6 @@ const UNUSED_TOOL_OUTPUT: ToolDefinition['output'] = {
   render: () => [],
 }
 
-let nextInboxItem = 0
-
-/** Wrap one test message in the production inbox occurrence envelope. */
-function inboxItem(message: InboxItem['message'], placement: InboxPlacement): InboxItem {
-  return { id: InboxItemId(`tui-item-${nextInboxItem++}`), message, placement }
-}
-
 class FakeTerminal implements Terminal {
   columns = 88
   rows = 32
@@ -461,9 +451,9 @@ describe('goodbye message and /resume', () => {
   })
 
   it.each([
-    [{ kind: 'aborted' }, 'cancelled'],
-    [{ kind: 'error', step: 1, message: 'failed' }, 'error'],
-    [{ kind: 'disposed' }, 'disposed'],
+    [{ kind: 'aborted', reason: { kind: 'user' } }, 'cancelled'],
+    [{ kind: 'error', error: new Error('failed') }, 'error'],
+    [{ kind: 'aborted', reason: { kind: 'disposed' } }, 'cancelled'],
     [{ kind: 'max-tokens' }, 'max tokens'],
     [{ kind: 'interrupted' }, 'interrupted'],
     [{ kind: 'future-result' } as unknown as TurnEndReason, 'unknown result'],
@@ -1342,7 +1332,10 @@ describe('pi-tui chat lifecycle and transcript', () => {
     }), { surfaceOp: 'append' })
     appendAssistant(result.session, [])
     result.session.append('step/end', { turn: 1, step: 1 })
-    result.session.append('turn/end', { turn: 1, reason: { kind: 'aborted' } })
+    result.session.append('turn/end', {
+      turn: 1,
+      reason: { kind: 'aborted', reason: { kind: 'user' } },
+    })
     result.session.append('turn/start', { turn: 2 })
     result.session.append('turn/end', { turn: 2, reason: { kind: 'completed' } })
     result.session.append('turn/start', { turn: 3 })
@@ -1660,16 +1653,16 @@ describe('pi-tui chat lifecycle and transcript', () => {
     const submitSteering = (text: string): void => {
       result.terminal.send(text)
       result.terminal.send('\r')
+      const message = result.agent.steeredOptions.at(-1)
+      if (message !== undefined) {
+        result.agent.inbox.splice('next-step', result.agent.inbox.nextStep.length, 0, [message])
+      }
     }
     const drainSteering = (text: string): void => {
       const id = result.agent.steeredIds.shift()
       if (id !== undefined) {
-        result.ctx.emit('agent/inbox/dequeue', result.agent, inboxItem(freezeMessage({
-          id,
-          role: 'user',
-          content: [{ type: 'text', text }],
-          source: { kind: 'user' },
-        }), 'steering'))
+        const index = result.agent.inbox.nextStep.findIndex(message => message.id === id)
+        if (index >= 0) result.agent.inbox.splice('next-step', index, 1, [], 'admitted')
       }
       result.session.append('steering/message', {
         turn: 1,
@@ -1680,18 +1673,6 @@ describe('pi-tui chat lifecycle and transcript', () => {
       }, { surfaceOp: 'append' })
     }
 
-    // A steering queue for a different agent never touches this status line.
-    const other = { ...result.agent, id: SessionId('other') } as Agent
-    result.terminal.output = ''
-    result.ctx.emit('agent/inbox/enqueue', other, inboxItem(freezeMessage({
-      id: MessageId('stub'),
-      role: 'user',
-      content: [{ type: 'text', text: 'elsewhere' }],
-      source: { kind: 'user' },
-    }), 'queued'))
-    await tick()
-    expect(result.terminal.output).not.toContain('queued')
-
     // Two steering messages queue while the turn runs.
     submitSteering('first')
     result.terminal.output = ''
@@ -1753,34 +1734,15 @@ describe('pi-tui chat lifecycle and transcript', () => {
     submitSteering('fourth')
     await tick()
     expect(result.terminal.output).toContain('2 queued')
-    const discarded = result.agent.steeredIds.splice(0).map(id => freezeMessage({
-      id,
-      role: 'user' as const,
-      content: [{ type: 'text' as const, text: 'discarded' }],
-      source: { kind: 'user' as const },
-    }))
-    // Another agent's dequeue/discard, and ones naming no pending id, leave
-    // the badge alone.
-    result.ctx.emit('agent/inbox/dequeue', other, inboxItem(discarded[0]!, 'steering'))
-    result.ctx.emit('agent/inbox/dequeue', result.agent, inboxItem(freezeMessage({
-      id: MessageId('never-queued'),
-      role: 'user',
-      content: [{ type: 'text', text: 'x' }],
-      source: { kind: 'user' },
-    }), 'steering'))
-    result.ctx.emit('agent/inbox/discard', other, discarded.map(message => inboxItem(message, 'steering')))
-    result.ctx.emit('agent/inbox/discard', result.agent, [
-      inboxItem(freezeMessage({
-        id: MessageId('never-queued'),
-        role: 'user',
-        content: [{ type: 'text', text: 'x' }],
-        source: { kind: 'user' },
-      }), 'steering'),
-    ])
-    await tick()
-    expect(result.terminal.output).toContain('2 queued')
     result.terminal.output = ''
-    result.ctx.emit('agent/inbox/discard', result.agent, discarded.map(message => inboxItem(message, 'steering')))
+    result.agent.steeredIds.splice(0)
+    result.agent.inbox.splice(
+      'next-step',
+      0,
+      result.agent.inbox.nextStep.length,
+      [],
+      'canceled',
+    )
     await tick()
     expect(result.terminal.output).not.toContain('queued')
 
@@ -2096,12 +2058,6 @@ describe('pi-tui chat lifecycle and transcript', () => {
   it('tracks steering drains without a running status line', async () => {
     const result = await setup()
     const source = { kind: 'user' as const }
-    result.ctx.emit('agent/inbox/enqueue', result.agent, inboxItem(freezeMessage({
-      id: MessageId('stub'),
-      role: 'user',
-      content: [{ type: 'text', text: 'early' }],
-      source,
-    }), 'steering'))
     result.session.append('steering/message', {
       turn: 1,
       message: createUserMessage({
@@ -2609,21 +2565,25 @@ describe('pi-tui chat lifecycle and transcript', () => {
     // Idle: the snapshot rides the prompt's admission (additionalContexts on
     // the allow decision), not a separate pre-admission inject.
     expect(result.agent.injected).toHaveLength(0)
+    const submitted = result.agent.sentMessages[0]!
     const decision = await agentEvents(result.ctx, result.agent).waterfall(
-      'agent/prompt-submit', result.agent.sentMessages[0]!,
-      new AbortController().signal, () => Promise.resolve({ kind: 'allow' as const }),
+      'agent/prompt-submit', [submitted],
+      new AbortController().signal,
+      () => Promise.resolve({ kind: 'allow' as const, messages: [submitted] }),
     )
     expect(decision.kind).toBe('allow')
-    expect(decision.kind === 'allow' && decision.additionalContexts?.[0]?.source)
+    expect(decision.kind === 'allow'
+      && decision.messages.find(message => message.source.kind === 'session-reference')?.source)
       .toMatchObject({ kind: 'session-reference', references: [{ sessionId: 'source-session' }] })
 
     // The one-shot wrapper detached itself at admission: replaying the
     // waterfall attaches nothing a second time.
     const replay = await agentEvents(result.ctx, result.agent).waterfall(
-      'agent/prompt-submit', result.agent.sentMessages[0]!,
-      new AbortController().signal, () => Promise.resolve({ kind: 'allow' as const }),
+      'agent/prompt-submit', [submitted],
+      new AbortController().signal,
+      () => Promise.resolve({ kind: 'allow' as const, messages: [submitted] }),
     )
-    expect(replay.kind === 'allow' && replay.additionalContexts).toBeUndefined()
+    expect(replay.kind === 'allow' && replay.messages).toEqual([submitted])
 
     const mention = formatSessionReferenceMention({ sessionId: sourceId, label: 'Source chat' })
     result.agent.status = 'running'
@@ -2662,31 +2622,32 @@ describe('pi-tui chat lifecycle and transcript', () => {
     // Running each prompt's admission waterfall detaches its wrapper.
     for (const sent of result.agent.sentMessages) {
       await agentEvents(result.ctx, result.agent).waterfall(
-        'agent/prompt-submit', sent,
-        new AbortController().signal, () => Promise.resolve({ kind: 'allow' as const }),
+        'agent/prompt-submit', [sent],
+        new AbortController().signal, () => Promise.resolve({ kind: 'allow' as const, messages: [sent] }),
       )
     }
     // Both wrappers now gone: a discard naming either prompt's content finds
     // no armed listener, and an unrelated admission is untouched. The leak
     // regression: a listener installed after its cleanup already ran would
     // survive every future cleanup.
-    result.ctx.emit('agent/inbox/discard', result.agent, [inboxItem(result.agent.sentMessages[0]!, 'queued')])
+    const unrelatedMessage = createUserMessage({
+      content: [{ type: 'text', text: 'unrelated' }],
+      source: { kind: 'user' },
+    })
     const unrelated = await agentEvents(result.ctx, result.agent).waterfall(
-      'agent/prompt-submit', createUserMessage({
-        content: [{ type: 'text', text: 'unrelated' }],
-        source: { kind: 'user' },
-      }),
-      new AbortController().signal, () => Promise.resolve({ kind: 'allow' as const }),
+      'agent/prompt-submit', [unrelatedMessage],
+      new AbortController().signal,
+      () => Promise.resolve({ kind: 'allow' as const, messages: [unrelatedMessage] }),
     )
-    expect(unrelated.kind === 'allow' && unrelated.additionalContexts).toBeUndefined()
+    expect(unrelated.kind === 'allow' && unrelated.messages).toEqual([unrelatedMessage])
     // Replaying either sent prompt attaches nothing: the one-shot wrappers
     // are gone, not merely spent.
     for (const sent of result.agent.sentMessages) {
       const replay = await agentEvents(result.ctx, result.agent).waterfall(
-        'agent/prompt-submit', sent,
-        new AbortController().signal, () => Promise.resolve({ kind: 'allow' as const }),
+        'agent/prompt-submit', [sent],
+        new AbortController().signal, () => Promise.resolve({ kind: 'allow' as const, messages: [sent] }),
       )
-      expect(replay.kind === 'allow' && replay.additionalContexts).toBeUndefined()
+      expect(replay.kind === 'allow' && replay.messages).toEqual([sent])
     }
     await dispose(result)
   })
@@ -2704,20 +2665,11 @@ describe('pi-tui chat lifecycle and transcript', () => {
     // Real send() publishes its already identified snapshot, then an enqueue
     // listener may synchronously cancel and discard it before followup()
     // returns that id. This stub reproduces that ordering.
-    const foreign = { ...result.agent, id: SessionId('foreign') } as unknown as Agent
     result.agent.followup = (input) => {
       result.agent.sent.push(input.content)
       result.agent.sentMessages.push(input)
-      const message = freezeMessage({
-        id: input.id,
-        role: 'user' as const,
-        content: structuredClone(input.content),
-        source: structuredClone(input.source),
-      })
-      result.ctx.emit('agent/inbox/enqueue', foreign, inboxItem(message, 'queued'))
-      result.ctx.emit('agent/inbox/enqueue', result.agent, inboxItem(message, 'queued'))
-      result.ctx.emit('agent/inbox/discard', result.agent, [inboxItem(message, 'queued')])
-      return message.id
+      result.agent.inbox.splice('next-turn', 0, 0, [input])
+      result.agent.inbox.splice('next-turn', 0, 1, [], 'canceled')
     }
 
     result.terminal.send('@sync-source')
@@ -2731,10 +2683,11 @@ describe('pi-tui chat lifecycle and transcript', () => {
     // returned the existing id: replaying the prompt's admission attaches no
     // stranded snapshot, and nothing leaks for the TUI lifetime.
     const replay = await agentEvents(result.ctx, result.agent).waterfall(
-      'agent/prompt-submit', result.agent.sentMessages[0]!,
-      new AbortController().signal, () => Promise.resolve({ kind: 'allow' as const }),
+      'agent/prompt-submit', [result.agent.sentMessages[0]!],
+      new AbortController().signal,
+      () => Promise.resolve({ kind: 'allow' as const, messages: [result.agent.sentMessages[0]!] }),
     )
-    expect(replay.kind === 'allow' && replay.additionalContexts).toBeUndefined()
+    expect(replay.kind === 'allow' && replay.messages).toEqual([result.agent.sentMessages[0]!])
     await dispose(result)
   })
 
@@ -2762,22 +2715,25 @@ describe('pi-tui chat lifecycle and transcript', () => {
     await vi.waitFor(() => { expect(result.agent.sent).toHaveLength(1) })
 
     const blocked = await agentEvents(result.ctx, result.agent).waterfall(
-      'agent/prompt-submit', result.agent.sentMessages[0]!,
-      new AbortController().signal, () => Promise.resolve({ kind: 'allow' as const }),
+      'agent/prompt-submit', [result.agent.sentMessages[0]!],
+      new AbortController().signal,
+      () => Promise.resolve({ kind: 'allow' as const, messages: [result.agent.sentMessages[0]!] }),
     )
     expect(blocked.kind).toBe('block')
     // Nothing entered history and nothing waits for a later prompt: a fresh
     // unrelated admission sees no leftover contexts.
     expect(result.agent.injected).toHaveLength(0)
     blockPrompts = false
+    const unrelatedMessage = createUserMessage({
+      content: [{ type: 'text', text: 'unrelated' }],
+      source: { kind: 'user' },
+    })
     const unrelated = await agentEvents(result.ctx, result.agent).waterfall(
-      'agent/prompt-submit', createUserMessage({
-        content: [{ type: 'text', text: 'unrelated' }],
-        source: { kind: 'user' },
-      }),
-      new AbortController().signal, () => Promise.resolve({ kind: 'allow' as const }),
+      'agent/prompt-submit', [unrelatedMessage],
+      new AbortController().signal,
+      () => Promise.resolve({ kind: 'allow' as const, messages: [unrelatedMessage] }),
     )
-    expect(unrelated.kind === 'allow' && unrelated.additionalContexts).toBeUndefined()
+    expect(unrelated.kind === 'allow' && unrelated.messages).toEqual([unrelatedMessage])
 
     // Second referenced prompt, this time dropped by a broad cancel before
     // any admission runs: the discard listener releases the wrapper.
@@ -2788,31 +2744,33 @@ describe('pi-tui chat lifecycle and transcript', () => {
     result.terminal.send('\r')
     await vi.waitFor(() => { expect(result.agent.sent).toHaveLength(2) })
     // A different prompt passing the still-armed wrapper delegates untouched.
+    const differentMessage = createUserMessage({
+      content: [{ type: 'text', text: 'different prompt' }],
+      source: { kind: 'user' },
+    })
     const passthrough = await agentEvents(result.ctx, result.agent).waterfall(
-      'agent/prompt-submit', createUserMessage({
-        content: [{ type: 'text', text: 'different prompt' }],
-        source: { kind: 'user' },
-      }),
-      new AbortController().signal, () => Promise.resolve({ kind: 'allow' as const }),
+      'agent/prompt-submit', [differentMessage],
+      new AbortController().signal,
+      () => Promise.resolve({ kind: 'allow' as const, messages: [differentMessage] }),
     )
-    expect(passthrough.kind === 'allow' && passthrough.additionalContexts).toBeUndefined()
-    // A foreign agent's discard leaves the wrapper armed.
-    const foreign = { ...result.agent, id: SessionId('foreign') } as unknown as Agent
-    result.ctx.emit('agent/inbox/discard', foreign, [inboxItem(result.agent.sentMessages.at(-1)!, 'queued')])
-    // An unrelated discard for this agent also leaves the wrapper armed.
-    result.ctx.emit('agent/inbox/discard', result.agent, [inboxItem(createUserMessage({
+    expect(passthrough.kind === 'allow' && passthrough.messages).toEqual([differentMessage])
+    // Canceling the exact pending message releases its wrapper.
+    const canceled = result.agent.sentMessages.at(-1)!
+    result.agent.inbox.splice('next-turn', 0, 0, [canceled])
+    result.agent.inbox.splice('next-turn', 0, 1, [], 'canceled')
+    const unrelatedDiscard = createUserMessage({
       content: [{ type: 'text', text: 'unrelated discard' }],
       source: { kind: 'user' },
-    }), 'queued')])
-    result.ctx.emit('agent/inbox/discard', result.agent, [inboxItem(result.agent.sentMessages.at(-1)!, 'queued')])
+    })
+    result.agent.inbox.splice('next-turn', 0, 0, [unrelatedDiscard])
+    result.agent.inbox.splice('next-turn', 0, 1, [], 'canceled')
     await tick()
-    // Idempotent: a repeat discard after cleanup is a no-op.
-    result.ctx.emit('agent/inbox/discard', result.agent, [inboxItem(result.agent.sentMessages.at(-1)!, 'queued')])
     const afterDiscard = await agentEvents(result.ctx, result.agent).waterfall(
-      'agent/prompt-submit', result.agent.sentMessages.at(-1)!,
-      new AbortController().signal, () => Promise.resolve({ kind: 'allow' as const }),
+      'agent/prompt-submit', [canceled],
+      new AbortController().signal,
+      () => Promise.resolve({ kind: 'allow' as const, messages: [canceled] }),
     )
-    expect(afterDiscard.kind === 'allow' && afterDiscard.additionalContexts).toBeUndefined()
+    expect(afterDiscard.kind === 'allow' && afterDiscard.messages).toEqual([canceled])
     await dispose(result)
   })
 
@@ -2963,11 +2921,14 @@ describe('pi-tui chat lifecycle and transcript', () => {
     expect(result.agent.sent).toEqual([[
       { type: 'text', text: '@evil\\x1b\\x07\\x9b\\x0as' },
     ]])
+    const submitted = result.agent.sentMessages[0]!
     const decision = await agentEvents(result.ctx, result.agent).waterfall(
-      'agent/prompt-submit', result.agent.sentMessages[0]!,
-      new AbortController().signal, () => Promise.resolve({ kind: 'allow' as const }),
+      'agent/prompt-submit', [submitted],
+      new AbortController().signal,
+      () => Promise.resolve({ kind: 'allow' as const, messages: [submitted] }),
     )
-    expect(decision.kind === 'allow' && decision.additionalContexts?.[0]?.source)
+    expect(decision.kind === 'allow'
+      && decision.messages.find(message => message.source.kind === 'session-reference')?.source)
       .toMatchObject({ references: [{ sessionId: unsafeId }] })
     await dispose(result)
   })
@@ -3738,11 +3699,14 @@ describe('pi-tui chat lifecycle and transcript', () => {
     agentEvents(events.ctx, unrelatedAgent).emit('agent/disposed')
     agentEvents(events.ctx, events.agent).emit('agent/error', 1, 1, new Error('live failure'))
     events.session.append('step/end', { turn: 1, step: 1 })
-    events.session.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, message: 'live failure' } })
+    events.session.append('turn/end', { turn: 1, reason: { kind: 'error', error: 'live failure' } })
     events.session.append('turn/start', { turn: 2 })
-    events.session.append('turn/end', { turn: 2, reason: { kind: 'error', step: 1, message: 'durable failure' } })
+    events.session.append('turn/end', { turn: 2, reason: { kind: 'error', error: 'durable failure' } })
     events.session.append('turn/start', { turn: 3 })
-    events.session.append('turn/end', { turn: 3, reason: { kind: 'aborted' } })
+    events.session.append('turn/end', {
+      turn: 3,
+      reason: { kind: 'aborted', reason: { kind: 'user' } },
+    })
     events.session.append('turn/start', { turn: 4 })
     events.session.append('turn/end', { turn: 4, reason: { kind: 'max-tokens' } })
     events.session.append('turn/start', { turn: 5 })
@@ -3750,10 +3714,13 @@ describe('pi-tui chat lifecycle and transcript', () => {
     events.session.append('turn/start', { turn: 6 })
     events.session.append('turn/end', {
       turn: 6,
-      reason: { kind: 'error', step: 1, failure: { message: 'structured provider failure', code: 'SERVER' } },
+      reason: { kind: 'error', error: { message: 'structured provider failure', code: 'SERVER' } },
     })
     events.session.append('turn/start', { turn: 8 })
-    events.session.append('turn/end', { turn: 8, reason: { kind: 'disposed' } })
+    events.session.append('turn/end', {
+      turn: 8,
+      reason: { kind: 'aborted', reason: { kind: 'disposed' } },
+    })
     events.session.append('turn/start', { turn: 9 })
     // Merge-extensible reason kind unknown to the TUI still names the stop.
     events.session.append('turn/end', { turn: 9, reason: { kind: 'plugin-policy' } as never })
@@ -4935,7 +4902,7 @@ describe('terminal mounting', () => {
     ctx.provide('tools', { get: () => undefined } as never)
     const session = ctx.sessions.create(SessionId('main'))
     ctx.agents.register({
-      id: session.id, options: {}, session, status: 'idle', ctx,
+      id: session.id, options: {}, session, inbox: new Inbox(session), status: 'idle', ctx,
       followup: () => {}, steer: () => {}, inject: () => {}, cancel() {}, whenIdle: () => Promise.resolve(),
     })
     const terminal = new FakeTerminal()
@@ -4960,7 +4927,7 @@ describe('terminal mounting', () => {
     ctx.provide('tools', { get: () => undefined } as never)
     const session = ctx.sessions.create(SessionId('main'))
     ctx.agents.register({
-      id: session.id, options: {}, session, status: 'idle', ctx,
+      id: session.id, options: {}, session, inbox: new Inbox(session), status: 'idle', ctx,
       followup: () => {}, steer: () => {}, inject: () => {}, cancel() {}, whenIdle: () => Promise.resolve(),
     })
     const terminal = new FakeTerminal()
@@ -4995,14 +4962,14 @@ describe('terminal mounting', () => {
 
     const otherSession = ctx.sessions.create(SessionId('other-session'))
     ctx.agents.register({
-      id: otherSession.id, options: {}, session: otherSession, status: 'idle', ctx,
+      id: otherSession.id, options: {}, session: otherSession, inbox: new Inbox(otherSession), status: 'idle', ctx,
       followup: () => {}, steer: () => {}, inject: () => {}, cancel() {}, whenIdle: () => Promise.resolve(),
     })
     expect(terminal.started).toBe(0)
 
     const session = ctx.sessions.create(SessionId('late-session'))
     const agent = {
-      id: session.id, options: {}, session, status: 'idle', ctx,
+      id: session.id, options: {}, session, inbox: new Inbox(session), status: 'idle', ctx,
       followup: () => {}, steer: () => {}, inject: () => {}, cancel() {}, whenIdle: () => Promise.resolve(),
     } as Agent
     ctx.agents.register(agent)
@@ -5033,7 +5000,7 @@ describe('terminal mounting', () => {
 
     const session = ctx.sessions.create(SessionId('main-session'))
     ctx.agents.register({
-      id: session.id, options: {}, session, status: 'idle', ctx,
+      id: session.id, options: {}, session, inbox: new Inbox(session), status: 'idle', ctx,
       followup: () => {}, steer: () => {}, inject: () => {}, cancel() {}, whenIdle: () => Promise.resolve(),
     })
     await tick()
@@ -5077,7 +5044,7 @@ describe('terminal mounting', () => {
     session.append('turn/start', { turn: 1 })
     session.append('step/start', { turn: 1, step: 1 })
     ctx.agents.register({
-      id: session.id, options: {}, session, status: 'running', ctx,
+      id: session.id, options: {}, session, inbox: new Inbox(session), status: 'running', ctx,
       followup: () => {}, steer: () => {}, inject: () => {}, cancel() {}, whenIdle: () => Promise.resolve(),
     })
     const terminal = new FakeTerminal()