Merge remote-tracking branch 'origin/master' into worktree/pr628-merge-20260727

# Conflicts: # .agents/notes/implemented/architecture/2026-06-21-bounded-llm-request-recovery.i18n.yaml # .agents/notes/implemented/architecture/2026-06-21-bounded-llm-request-recovery.md # .agents/notes/implemented/architecture/2026-06-21-bounded-llm-request-recovery.zh.md # docs/architecture.i18n.yaml # docs/architecture.md # docs/architecture.zh.md # docs/cordis-catalog/events.md # docs/core-data-structures/llm-streaming.i18n.yaml # docs/core-data-structures/llm-streaming.md # docs/core-data-structures/llm-streaming.zh.md # docs/event-producer-consumer.md # examples/acp-agent/tests/snapshots/empty-response-retry/session.jsonl # packages/compact/compact-basic/src/index.ts # packages/compact/compact-basic/tests/compact-basic.spec.ts # packages/cordis/tool-cordis/src/api-catalog.ts # packages/core/agent-loop/README.i18n.yaml # packages/core/agent-loop/README.md # packages/core/agent-loop/README.zh.md # packages/core/agent-loop/src/loop.ts # packages/core/agent-loop/tests/request-recovery.spec.ts # packages/core/agent/src/types.ts # packages/core/scope/tests/invariant.spec.ts # packages/llm/llm-retry/README.i18n.yaml # packages/llm/llm-retry/README.md # packages/llm/llm-retry/README.zh.md # packages/llm/llm-retry/src/index.ts # packages/llm/llm-retry/src/invariant.ts # packages/llm/llm-retry/tests/invariant.spec.ts # packages/llm/llm-retry/tests/retry.spec.ts # packages/plan/plan-mode/src/index.ts # packages/plan/plan-mode/tests/integration.spec.ts # packages/plan/plan-mode/tests/plan-mode.spec.ts
2026-07-27 23:29:26 +08:00
parent 8a952ab433 5b5f089bd0
commit 29619eda77
461 changed files with 8294 additions and 10405 deletions
--- a/packages/llm/llm-retry/README.i18n.yaml
+++ b/packages/llm/llm-retry/README.i18n.yaml
@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/llm/llm-retry/README.md
-README.md: 0e43f25a5499ffa1a0716cedd0ecf9008c63396d
-README.zh.md: 8f8f51ae68c259cd3b9ae5d77c81af0339480e98
+README.md: 7a86652a794e70c4dfd00ab7427730387e3ec949
+README.zh.md: 6255cca8c3b669ddec401496acb1e79ad54a8b3e
--- a/packages/llm/llm-retry/README.md
+++ b/packages/llm/llm-retry/README.md
@@ -2,13 +2,13 @@

 English | [中文](README.zh.md)

-Function plugin that applies exact-provider retry policy on the agent loop's closed-step recovery seam. It does not wrap `ctx.llm.stream()`: every adapter call remains one provider attempt, and every retry opens a fresh numbered step.
+Function plugin that applies exact-provider retry policy through the agent loop's closed-step `agent/request-error` waterfall. It does not wrap `ctx.llm.stream()`: every adapter call remains one provider attempt, and every retry opens a fresh numbered turn.

 Each provider adapter owns an optional nested `retryPolicy`, captured when its route registers on `ctx.llm` and carried with each call that reaches that registration's final adapter boundary. An in-flight failure retains that serving policy if the route is later disposed or replaced; a failure before any final adapter is selected has no provider policy and delegates. Omission uses normal mode: two retries for `EMPTY_RESPONSE`, `RATE_LIMIT`, `SERVER`, `TIMEOUT`, and `TRANSPORT`, with bounded exponential backoff from 500 ms to 10 seconds and 10 percent jitter. `EMPTY_RESPONSE` is the adapters' classification of a degenerate provider completion that produced no durable content, so repeating it is safe. A normal policy can change its finite budget, eligible codes, and backoff. Always mode asks downstream recovery first, then retries every model-request failure without an attempt limit; success, cancellation, or plugin disposal stops it after active delegated recovery reaches quiescence.

 Both modes use bounded exponential backoff with symmetric jitter. A valid `providerRetryAfterMs` at or below `maxDelayMs` replaces local backoff without jitter. An over-cap provider delay makes normal mode delegate, while always mode uses its configured local backoff so it cannot terminate on that instruction.

-Before waiting, the plugin appends a non-surface `llm/retry` event with the provider, mode, canonical resolved-policy key, failure, and scheduled delay. The key includes every behavior-affecting field and sorts normal-mode codes because eligibility uses set membership. Retry numbers continue only across events with the same provider and complete policy key, so a route replacement with different limits, code membership, or backoff starts its own history. Normal events include the finite maximum; always events omit it, and UIs render `∞`. Cancellation and plugin disposal abort active backoff, drain active delegated recovery before applying the abort, and make a callback captured before disposal fail closed.
+Before waiting, the plugin appends a non-surface `llm/retry` event with the provider, mode, canonical resolved-policy key, failure, and scheduled delay. The key includes every behavior-affecting field and sorts normal-mode codes because eligibility uses set membership. Retry numbers continue only across events with the same provider and complete policy key, so a route replacement with different limits, code membership, or backoff starts its own history. Normal events include the finite maximum; always events omit it, and UIs render `∞`. After the wait, the listener returns `{ kind: 'retry' }`, and the loop closes the failed turn and opens a retry turn over the same durable history. Cancellation and plugin disposal abort active backoff, drain active delegated recovery before applying the abort, and make a callback captured before disposal fail closed.

 The separately published `./invariant` companion checks that every retry record names the current open turn and latest closed step, matches the failed request's durable provider, carries non-empty provider and policy identities, has mode-specific bounds, a unique step record, the correct provider-policy retry number, and a bounded timer delay. Full jitter may schedule zero milliseconds at its lower boundary.

@@ -34,7 +34,7 @@ The executor has no policy config. Multi-provider adapters such as `dsh-llm-pi-a

 #### What the model sees

-No retry event, delay, provider error, or failed partial output is model-visible. The next numbered step reconstructs the same explicit provider/model request from durable surface history unless a downstream recovery policy deliberately changes that surface.
+No retry event, delay, provider error, or failed partial output is model-visible. The retry turn reconstructs the same explicit provider/model request from durable surface history unless a downstream recovery policy deliberately changes that surface; failed chunks never enter derived messages.

 #### Token effect

@@ -46,7 +46,8 @@ The reconstructed request preserves the prior prefix and is eligible for provide

 ## Known Limitations and Deferred Work

- **Agent steps are the only retry boundary** — direct `ctx.llm.stream()` consumers remain single-attempt because a raw stream cannot separate already-emitted chunks durably.
+- **Agent turns are the only retry boundary** — direct `ctx.llm.stream()` consumers remain single-attempt because a raw stream cannot separate already-emitted chunks durably.
 - **Always mode retries permanent failures** — authentication, quota, invalid-request, protocol, and unrecoverable context errors continue until success, cancellation, or disposal; deployments own provider-specific cost and latency controls.
+- **Finite plugin budgets add** — normal mode counts only its configured codes and exact provider policy, while context-overflow compaction owns a separate budget. A future overlapping policy must document and test registration-order behavior.
 - **Recovery policies compose by waterfall order** — always mode accepts a downstream retry before applying its fallback. A later policy that ignores cancellation and never settles also prevents fallback, turn quiescence, and plugin disposal from completing.
 - **`llm/retry` records scheduling, not completion** — later step and turn events establish success, exhaustion, or cancellation.
--- a/packages/llm/llm-retry/README.zh.md
+++ b/packages/llm/llm-retry/README.zh.md
@@ -2,13 +2,13 @@

 [English](README.md) | 中文

-一个函数插件，在 agent loop 的已关闭步骤恢复 seam 上应用确切提供方的重试策略。它不包装 `ctx.llm.stream()`：每次适配器调用仍是一次提供方尝试，每次重试都会开启新的编号步骤。
+一个函数插件，通过 agent loop（智能体循环）在已关闭步骤上触发的 `agent/request-error` waterfall（瀑布式事件）应用确切提供方重试策略。它不包装 `ctx.llm.stream()`：每次适配器调用仍是一次提供方尝试，每次重试都会开启新的编号轮次。

-每个提供方适配器都拥有可选的嵌套 `retryPolicy`；路由在 `ctx.llm` 上注册时会捕获该策略，任何到达该注册最终适配器边界的调用都会携带它。如果之后释放或替换路由，进行中的失败仍会保留为其提供服务的策略；在选中任何最终适配器前发生的失败没有提供方策略，会继续委托。省略策略时使用 normal mode：为 `EMPTY_RESPONSE`、`RATE_LIMIT`、`SERVER`、`TIMEOUT` 和 `TRANSPORT` 重试两次，并采用从 500 ms 到 10 秒的有界指数退避与 10% jitter。`EMPTY_RESPONSE` 是适配器对未产生任何持久内容的退化提供方完成所作的分类，因此可安全重复。normal 策略可以更改其有限预算、合格 code 和退避配置。always mode 会先请求下游恢复，再无次数上限地重试每个模型请求失败；成功、取消或插件 dispose 会在活跃的委托恢复完全停稳后终止它。
+每个提供方适配器都拥有可选的嵌套 `retryPolicy`；路由在 `ctx.llm` 上注册时会捕获该策略，任何到达该注册最终适配器边界的调用都会携带它。如果之后释放或替换路由，进行中的失败仍会保留为其提供服务的策略；在选中任何最终适配器前发生的失败没有提供方策略，会继续委托。省略策略时使用 normal mode：为 `EMPTY_RESPONSE`、`RATE_LIMIT`、`SERVER`、`TIMEOUT` 和 `TRANSPORT` 重试两次，并采用从 500 ms 到 10 秒的有界指数退避与 10% jitter。`EMPTY_RESPONSE` 是适配器对未产生任何持久内容的退化提供方完成所作的分类，因此可安全重复。normal 策略可以更改其有限预算、合格 code 和退避配置。always mode 会先请求下游恢复，再无次数上限地重试每个模型请求失败；成功、取消或插件 dispose（资源释放）会在活跃的委托恢复完全停稳后终止它。

 两种 mode 都使用带对称 jitter 的有界指数退避。有效 `providerRetryAfterMs` 不超过 `maxDelayMs` 时会替换本地退避，并且不加 jitter。超出上限的提供方延迟会使 normal mode 继续委托；always mode 则改用已配置的本地退避，避免该指令终止重试。

-等待之前，插件会追加一个非表层 `llm/retry` 事件，携带提供方、mode、规范的解析策略 key、失败与计划延迟。该 key 包含每个会影响行为的字段，并会对 normal mode 的 code 排序，因为合格性采用集合成员关系判断。只有提供方与完整策略 key 相同的事件才会延续重试编号，因此，如果替换后的路由具有不同的限制、code 成员关系或退避配置，就会开启自己的历史。normal 事件包含有限上限；always 事件省略该上限，UI 会渲染 `∞`。取消与插件 dispose 会中止活跃退避，在应用中止前排空活跃的委托恢复，并使 dispose 前捕获的 callback 快速失败。
+等待前，插件会追加一条不进入表层的 `llm/retry` 事件，其中包含提供方、mode、规范的解析策略 key、失败和计划延迟。该 key 包含所有影响行为的字段，并对 normal mode 的 code 排序，因为合格性采用集合成员关系判断。只有提供方与完整策略 key 都相同的事件才会延续重试编号；因此，用限制、code 成员关系或退避不同的路由替换后，会开始自己的历史。normal 事件包含有限上限；always 事件省略该上限，UI 会渲染 `∞`。等待结束后，监听器返回 `{ kind: 'retry' }`，循环关闭失败轮次，并在同一持久历史上开启重试轮次。取消与插件 dispose 会中止活跃退避，在应用中止前排空活跃的委托恢复，并使 dispose 前捕获的 callback 只能以失败结束。

 单独发布的 `./invariant` 配套模块会检查每个重试记录是否指向当前开启轮次及其最新已关闭步骤，是否与失败请求的持久提供方匹配，是否携带非空的提供方与策略身份，是否满足 mode 特定边界，是否拥有唯一步骤记录和正确的提供方策略重试编号，以及是否携带有界定时器延迟。完整 jitter 可以在下界调度为零毫秒。

@@ -34,7 +34,7 @@

 #### 模型看到的内容

-模型不会看到重试事件、延迟、提供方错误或失败的部分输出。下一个编号步骤会从持久表层历史中重建相同的显式提供方／模型请求，除非下游恢复策略有意更改该表层。
+模型不会看到重试事件、延迟、提供方错误或失败的部分输出。重试轮次会从持久表层历史中重建相同的显式提供方／模型请求，除非下游恢复策略有意更改该表层；失败分片绝不会进入派生消息。

 #### Token 影响

@@ -46,7 +46,8 @@

 ## 已知限制与暂缓事项

- **Agent 步骤是唯一重试边界**：直接 `ctx.llm.stream()` 消费方仍只尝试一次，因为原始流无法将已发出 chunk 持久分隔为不同尝试。
+- **Agent 轮次是唯一重试边界**：直接 `ctx.llm.stream()` 消费方仍只尝试一次，因为原始流无法将已发出 chunk 持久分隔为不同尝试。
 - **always mode 会重试永久性失败**：身份验证、配额、无效请求、协议和无法恢复的上下文错误都会继续重试，直至成功、取消或 dispose；部署负责提供方特定的成本与延迟控制。
- **恢复策略按 waterfall 顺序组合**：always mode 会先接受下游的重试，再应用自己的回退。后续策略如果忽略取消且永不结算，也会阻止回退、轮次完全停稳和插件 dispose 完成。
+- **有限插件预算可叠加**：normal mode 只统计已配置 code 和确切提供方策略，上下文溢出压缩则拥有独立预算。未来如有重叠策略，必须记录并测试注册顺序行为。
+- **恢复策略按 waterfall 顺序组合**：always mode 会先接受下游重试，再应用自己的回退。后续策略如果忽略取消且永不结算，也会阻止回退、轮次完全停稳和插件 dispose 完成。
 - **`llm/retry` 记录调度，不是完成**：后续步骤与轮次事件用于确立成功、耗尽或取消。
--- a/packages/llm/llm-retry/src/history.ts
+++ b/packages/llm/llm-retry/src/history.ts
@@ -5,8 +5,7 @@ import type { SessionEvent } from '@deepseek-ai/dsh-session'
 /**
 * Find the provider in force when one step closed, excluding later recovery mutations.
 * Request headers remain effective across turn boundaries until a newer full
- * snapshot changes them. A preceding retry in the same turn is also a route
- * marker because every provider change requires a newer full snapshot.
+ * snapshot changes them; every provider change requires a newer full snapshot.
 * @param events - session events containing the closed step.
 * @param turn - turn that owns the failed step.
 * @param step - failed step whose provider is required.
@@ -28,11 +27,6 @@ export function providerForClosedStep(
    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
    const event = events[index]!
    if (event.type === 'request/header') return event.data.header.config.provider
-    if (event.type === 'llm/retry'
-      && event.data.turn === turn
-      && event.data.step < step) {
-      return event.data.provider
-    }
  }
  return undefined
 }
--- a/packages/llm/llm-retry/src/index.ts
+++ b/packages/llm/llm-retry/src/index.ts
@@ -7,7 +7,7 @@

 import type { Context } from 'cordis'
 import z from 'schemastery'
-import type { Agent, RequestError, RequestErrorDecision } from '@deepseek-ai/dsh-agent'
+import type { Agent, RequestError, RequestErrorAction } from '@deepseek-ai/dsh-agent'
 import type { LlmFailure, ResolvedRetryPolicy } from '@deepseek-ai/dsh-llm'
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
 import { providerForClosedStep } from './history.ts'
@@ -63,11 +63,11 @@ export interface RetryInternals {
 }

 type DownstreamOutcome =
-  | { readonly type: 'decision'; readonly decision: RequestErrorDecision }
+  | { readonly type: 'decision'; readonly decision: RequestErrorAction }
  | { readonly type: 'error'; readonly error: unknown }

 async function settleDownstream(
-  next: () => Promise<RequestErrorDecision>,
+  next: () => Promise<RequestErrorAction>,
 ): Promise<DownstreamOutcome> {
  try {
    return { type: 'decision', decision: await next() }
@@ -121,9 +121,9 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
  validateConfig(config)
  const random = internals.random ?? Math.random
  const lifetime = new AbortController()
-  const active = new Set<Promise<RequestErrorDecision>>()
+  const active = new Set<Promise<RequestErrorAction>>()

-  function track(operation: Promise<RequestErrorDecision>): Promise<RequestErrorDecision> {
+  function track(operation: Promise<RequestErrorAction>): Promise<RequestErrorAction> {
    const tracked = operation.finally(() => active.delete(tracked))
    active.add(tracked)
    return tracked
@@ -140,9 +140,9 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
    retry: number,
    delayMs: number,
    signal: AbortSignal,
-  ): Promise<RequestErrorDecision> {
+  ): Promise<RequestErrorAction> {
    const fusedSignal = AbortSignal.any([signal, lifetime.signal])
-    if (fusedSignal.aborted) return { action: 'fail' }
+    if (fusedSignal.aborted) return
    const eventData = policy.mode === 'normal'
      ? {
        turn,
@@ -166,8 +166,8 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
        failure,
      }
    agent.session.append('llm/retry', eventData)
-    if (!await cancellableDelay(delayMs, fusedSignal)) return { action: 'fail' }
-    return { action: 'retry' }
+    if (!await cancellableDelay(delayMs, fusedSignal)) return
+    return { kind: 'retry' }
  }

  async function recover(
@@ -179,8 +179,8 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
    priorFailures: readonly LlmFailure[],
    policy: ResolvedRetryPolicy | undefined,
    signal: AbortSignal,
-    next: () => Promise<RequestErrorDecision>,
-  ): Promise<RequestErrorDecision> {
+    next: () => Promise<RequestErrorAction>,
+  ): Promise<RequestErrorAction> {
    if (policy === undefined) return next()
    // The call-local policy belongs to the registration that served this
    // failure. Recover only the durable provider identity from the header;
@@ -191,19 +191,19 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
      throw new Error(`llm-retry: no request provider for closed turn ${turn}/step ${step}`)
    }
    if (policy.mode === 'always') {
-      if (signal.aborted || lifetime.signal.aborted) return { action: 'fail' }
+      if (signal.aborted || lifetime.signal.aborted) return
      const fusedSignal = AbortSignal.any([signal, lifetime.signal])
      // The loop and plugin lifetime stay open until delegated recovery settles.
      // An abort then wins before the decision or fallback can mutate later state.
      const downstream = await settleDownstream(next)
-      if (fusedSignal.aborted) return { action: 'fail' }
+      if (fusedSignal.aborted) return
      if (downstream.type === 'error') {
        ctx.logger.warn(
          `llm-retry: provider "${provider}" always policy ignored a downstream recovery failure: %o`,
          downstream.error,
        )
      }
-      if (downstream.type === 'decision' && downstream.decision.action === 'retry') {
+      if (downstream.type === 'decision' && downstream.decision?.kind === 'retry') {
        return downstream.decision
      }
    } else if (!policy.retryableCodes.includes(failure.code)) {
@@ -211,12 +211,11 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
    }

    const policyKey = retryPolicyKey(policy)
-    const firstPriorStep = step - priorFailures.length
+    const firstPriorTurn = turn - priorFailures.length
    const priorPolicyRetry = agent.session.events.findLast((event): event is SessionEvent<'llm/retry'> =>
      event.type === 'llm/retry'
-      && event.data.turn === turn
-      && event.data.step >= firstPriorStep
-      && event.data.step < step
+      && event.data.turn >= firstPriorTurn
+      && event.data.turn < turn
      && event.data.provider === provider
      && event.data.policyKey === policyKey,
    )
@@ -249,12 +248,12 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
    priorFailures: readonly LlmFailure[],
    policy: ResolvedRetryPolicy | undefined,
    signal: AbortSignal,
-    next: () => Promise<RequestErrorDecision>,
+    next: () => Promise<RequestErrorAction>,
  ) => {
    // A waterfall may have captured this callback before its registration was
    // removed. Lifetime cancellation must prevent that stale callback from
    // entering a downstream policy after disposal.
-    if (lifetime.signal.aborted) return Promise.resolve<RequestErrorDecision>({ action: 'fail' })
+    if (lifetime.signal.aborted) return Promise.resolve<RequestErrorAction>(undefined)
    return track(recover(agent, turn, step, error, failure, priorFailures, policy, signal, next))
  })

--- a/packages/llm/llm-retry/src/invariant.ts
+++ b/packages/llm/llm-retry/src/invariant.ts
@@ -41,6 +41,34 @@ function validateFailure(value: unknown, fail: InvariantFailure): asserts value
  }
 }

+/** Find the first turn in the structured-failure retry chain containing `turn`. */
+function retryChainStart(history: readonly SessionEvent[], turn: number): number {
+  let startIndex = history.findLastIndex(
+    event => event.type === 'turn/start' && event.data.turn === turn,
+  )
+  while (startIndex >= 0) {
+    const start = history[startIndex]
+    if (start?.type !== 'turn/start' || start.data.trigger.kind !== 'retry') break
+
+    let endIndex = startIndex - 1
+    while (endIndex >= 0 && history[endIndex]?.type !== 'turn/end') endIndex -= 1
+    const end = history[endIndex]
+    if (end?.type !== 'turn/end'
+      || end.data.reason.kind !== 'error'
+      || end.data.reason.failure === undefined) break
+
+    const previousStart = history.findLastIndex(
+      (event, index) =>
+        index < endIndex
+        && event.type === 'turn/start'
+        && event.data.turn === end.data.turn,
+    )
+    if (previousStart < 0) break
+    startIndex = previousStart
+  }
+  return startIndex
+}
+
 /** Validate one retry record against the open turn and most recently closed step. */
 function validateRetry(
  history: readonly SessionEvent[],
@@ -78,20 +106,23 @@ function validateRetry(
    fail(`llm/retry delayMs must be a finite number within 0..${MAX_TIMER_DELAY_MS}`)
  }

-  const turnStartIndex = history.findLastIndex(prior =>
-    prior.type === 'turn/start' || prior.type === 'turn/end')
-  const turnBoundary = history[turnStartIndex]
-  if (turnBoundary?.type !== 'turn/start') {
-    fail('llm/retry must be appended inside an open turn')
+  const currentTurnEvents: SessionEvent[] = []
+  let openTurn: number | undefined
+  for (const prior of history.slice().reverse()) {
+    if (prior.type === 'turn/end') fail('llm/retry must be appended inside an open turn')
+    if (prior.type === 'turn/start') {
+      openTurn = prior.data.turn
+      break
+    }
+    currentTurnEvents.push(prior)
  }
-  const openTurn = turnBoundary.data.turn
+  if (openTurn === undefined) fail('llm/retry must be appended inside an open turn')
  if (turn !== openTurn) {
    fail(`llm/retry names turn ${turn}, but the open turn is ${openTurn}`)
  }

-  const currentTurnEvents = history.slice(turnStartIndex + 1)
  let closedStep: number | undefined
-  for (const prior of currentTurnEvents.slice().reverse()) {
+  for (const prior of currentTurnEvents) {
    if (prior.type === 'step/start') {
      fail(`llm/retry must follow step/end, but step ${prior.data.step} is still open`)
    }
@@ -108,18 +139,16 @@ function validateRetry(
    fail(`llm/retry provider ${provider} does not match the failed request provider ${String(routedProvider)}`)
  }

-  const priorRetries = currentTurnEvents
+  const chainStart = retryChainStart(history, turn)
+  const chain = history.slice(Math.max(chainStart, 0))
+  const lastSuccess = chain.findLastIndex(prior => prior.type === 'assistant/message')
+  const chainRetries = chain.slice(lastSuccess + 1)
    .filter((prior): prior is SessionEvent<'llm/retry'> => prior.type === 'llm/retry')
-  if (priorRetries.some(prior => prior.data.step === step)) {
+  if (chainRetries.some(prior => prior.data.turn === turn && prior.data.step === step)) {
    fail(`llm/retry duplicates the retry record for turn ${turn}/step ${step}`)
  }
-  const lastSuccessIndex = currentTurnEvents.findLastIndex(prior => prior.type === 'assistant/message')
-  const priorPolicyRetry = currentTurnEvents.findLast((prior, index): prior is SessionEvent<'llm/retry'> => (
-    index > lastSuccessIndex
-    && prior.type === 'llm/retry'
-    && prior.data.provider === provider
-    && prior.data.policyKey === policyKey
-  ))
+  const priorPolicyRetry = chainRetries.findLast(prior =>
+    prior.data.provider === provider && prior.data.policyKey === policyKey)
  const expectedRetry = (priorPolicyRetry?.data.retry ?? 0) + 1
  if (retry !== expectedRetry) {
    fail(`llm/retry retry ${retry} must equal provider policy retry ${expectedRetry}`)
--- a/packages/llm/llm-retry/tests/invariant.spec.ts
+++ b/packages/llm/llm-retry/tests/invariant.spec.ts
@@ -61,10 +61,12 @@ describe('llm-retry invariants', () => {

    expect(() => {
      session.append('llm/retry', { turn: 1, step: 1, ...normal })
-      session.append('step/start', { turn: 1, step: 2 })
-      session.append('step/end', { turn: 1, step: 2 })
+      session.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, failure } })
+      session.append('turn/start', { turn: 2, trigger: { kind: 'retry' } })
+      session.append('step/start', { turn: 2, step: 1 })
+      session.append('step/end', { turn: 2, step: 1 })
      session.append('llm/retry', {
-        turn: 1, step: 2, ...normal, retry: 2, delayMs: 0,
+        turn: 2, step: 1, ...normal, retry: 2, delayMs: 0,
      })
      const unbounded = closeStep(ctx, 'retry-invariant-always')
      unbounded.append('llm/retry', { turn: 1, step: 1, ...always })
@@ -194,26 +196,32 @@ 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('step/start', { turn: 1, step: 2 })
-    mismatch.append('step/end', { turn: 1, step: 2 })
+    mismatch.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, failure } })
+    mismatch.append('turn/start', { turn: 2, trigger: { kind: 'retry' } })
+    mismatch.append('step/start', { turn: 2, step: 1 })
+    mismatch.append('step/end', { turn: 2, step: 1 })
    expect(() => {
-      mismatch.append('llm/retry', { turn: 1, step: 2, ...normal, retry: 1 })
+      mismatch.append('llm/retry', { turn: 2, step: 1, ...normal, retry: 1 })
    }).toThrow(/must equal provider policy retry 2/)

    const reset = closeStep(ctx, 'retry-invariant-reset')
    reset.append('llm/retry', { turn: 1, step: 1, ...normal })
-    reset.append('step/start', { turn: 1, step: 2 })
+    reset.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, failure } })
+    reset.append('turn/start', { turn: 2, trigger: { kind: 'retry' } })
+    reset.append('step/start', { turn: 2, step: 1 })
    reset.append('assistant/message', {
-      turn: 1,
-      step: 2,
+      turn: 2,
+      step: 1,
      content: [{ type: 'text', text: 'success' }],
      provenance: { provider: 'mock', model: 'mock' },
    }, { surfaceOp: 'append' })
-    reset.append('step/end', { turn: 1, step: 2 })
-    reset.append('step/start', { turn: 1, step: 3 })
-    reset.append('step/end', { turn: 1, step: 3 })
+    reset.append('step/end', { turn: 2, step: 1 })
+    reset.append('turn/end', { turn: 2, reason: { kind: 'completed' } })
+    reset.append('turn/start', { turn: 3, trigger: { kind: 'message', source: { kind: 'user' } } })
+    reset.append('step/start', { turn: 3, step: 1 })
+    reset.append('step/end', { turn: 3, step: 1 })
    expect(() => {
-      reset.append('llm/retry', { turn: 1, step: 3, ...normal })
+      reset.append('llm/retry', { turn: 3, step: 1, ...normal })
    }).not.toThrow()
  })

--- a/packages/llm/llm-retry/tests/loader-composition.spec.ts
+++ b/packages/llm/llm-retry/tests/loader-composition.spec.ts
@@ -7,7 +7,6 @@ import { Context } from 'cordis'
 import Loader from '@cordisjs/plugin-loader'
 import Include from '@cordisjs/plugin-include'
 import AgentRegistry from '@deepseek-ai/dsh-agent'
-import type { Agent } from '@deepseek-ai/dsh-agent'
 import AgentLoop from '@deepseek-ai/dsh-agent-loop'
 import LlmService, { LlmAdapter, LlmError, resolveRetryPolicy } from '@deepseek-ai/dsh-llm'
 import type { GenerateOptions, ResolvedRetryPolicy, StreamChunk } from '@deepseek-ai/dsh-llm'
@@ -42,17 +41,6 @@ class TransientOnceAdapter extends LlmAdapter {
  }
 }

-function waitForIdle(ctx: Context, agent: Agent): Promise<void> {
-  return new Promise((resolve) => {
-    const dispose = ctx.on('agent/status', (subject, status) => {
-      if (subject === agent && status === 'idle') {
-        dispose()
-        resolve()
-      }
-    })
-  })
-}
-
 afterEach(async () => {
  await context?.fiber.dispose()
  context = undefined
@@ -117,9 +105,8 @@ describe('real Loader composition', () => {
    const adapter = new TransientOnceAdapter()
    loaded.llm.registerAdapter(['mock'], adapter)
    const agent = loaded.agentLoop.create(SessionId('loader-retry'), { provider: 'mock', model: 'mock' })
-    const idle = waitForIdle(loaded, agent)
-    agent.followup([{ type: 'text', text: 'recover' }])
-    await idle
+    agent.followup({ content: [{ type: 'text', text: 'recover' }], source: { kind: 'user' } })
+    await agent.whenIdle()

    expect(adapter.requests).toBe(2)
    expect(agent.session.events.filter(event => event.type === 'llm/retry')).toHaveLength(1)
--- a/packages/llm/llm-retry/tests/persistence.spec.ts
+++ b/packages/llm/llm-retry/tests/persistence.spec.ts
@@ -49,7 +49,14 @@ describe.each(['jsonl', 'sqlite'] as const)('%s retry-event persistence', (kind)
        delayMs: 750,
        failure: { message: 'provider busy', code: 'RATE_LIMIT', status: 429 },
      })
-      session.append('turn/end', { turn: 1, reason: { kind: 'aborted' } })
+      session.append('turn/end', {
+        turn: 1,
+        reason: {
+          kind: 'error',
+          step: 1,
+          failure: { message: 'provider busy', code: 'RATE_LIMIT', status: 429 },
+        },
+      })

      expect(session.deriveMessages()).toEqual([])
      await ctx.sessions.flush(session)
--- a/packages/llm/llm-retry/tests/retry.spec.ts
+++ b/packages/llm/llm-retry/tests/retry.spec.ts
@@ -16,7 +16,7 @@ import type { SessionEvent } from '@deepseek-ai/dsh-session'
 import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
 import ToolRegistry, { defineContentToolFixture } from '@deepseek-ai/dsh-tools'
 import AgentRegistry from '@deepseek-ai/dsh-agent'
-import type { Agent, RequestErrorDecision } from '@deepseek-ai/dsh-agent'
+import type { Agent, RequestErrorAction } from '@deepseek-ai/dsh-agent'
 import AgentLoop from '@deepseek-ai/dsh-agent-loop'
 import * as retry from '../src/index.ts'

@@ -190,7 +190,7 @@ describe('provider-routed retry policy', () => {
    })
    const scheduled = waitForRetry(context, agent, 1)

-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    const event = await scheduled

    expect(event.data).toEqual({
@@ -213,8 +213,8 @@ describe('provider-routed retry policy', () => {
    await idle

    expect(adapter.requests).toHaveLength(2)
-    expect(agent.session.events.filter(item => item.type === 'step/start').map(item => item.data.step))
-      .toEqual([1, 2])
+    expect(agent.session.events.filter(item => item.type === 'step/start').map(item => item.data))
+      .toEqual([{ turn: 1, step: 1 }, { turn: 2, step: 1 }])
    expect(agent.session.deriveMessages().at(-1)).toEqual({
      role: 'assistant',
      content: [{ type: 'text', text: 'done' }],
@@ -235,7 +235,7 @@ describe('provider-routed retry policy', () => {
    const agent = context.agentLoop.create(SessionId('retry-empty-response'), { provider: 'mock', model: 'mock' })
    const scheduled = waitForRetry(context, agent, 1)

-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    const event = await scheduled
    expect(event.data.failure).toEqual({
      message: 'model returned a completed response with no content',
@@ -247,8 +247,10 @@ describe('provider-routed retry policy', () => {
    await idle

    expect(adapter.requests).toHaveLength(2)
-    expect(agent.session.events.filter(event => event.type === 'assistant/message').map(event => event.data.step))
-      .toEqual([2])
+    expect(agent.session.events.filter(event => event.type === 'assistant/message').map(event => ({
+      turn: event.data.turn,
+      step: event.data.step,
+    }))).toEqual([{ turn: 2, step: 1 }])
    expect(agent.session.deriveMessages().at(-1)).toMatchObject({
      role: 'assistant',
      content: [{ type: 'text', text: 'recovered' }],
@@ -275,18 +277,20 @@ describe('provider-routed retry policy', () => {
    const agent = context.agentLoop.create(SessionId('retry-partial'), { provider: 'mock', model: 'mock' })
    const scheduled = waitForRetry(context, agent, 1)

-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    await scheduled
    const idle = waitForIdle(context, agent)
    await vi.advanceTimersByTimeAsync(500)
    await idle

    const failedChunks = agent.session.events.filter(event =>
-      event.type === 'assistant/chunk' && event.data.step === 1,
+      event.type === 'assistant/chunk' && event.data.turn === 1 && event.data.step === 1,
    )
    expect(failedChunks).toHaveLength(6)
-    expect(agent.session.events.filter(event => event.type === 'assistant/message').map(event => event.data.step))
-      .toEqual([2])
+    expect(agent.session.events.filter(event => event.type === 'assistant/message').map(event => ({
+      turn: event.data.turn,
+      step: event.data.step,
+    }))).toEqual([{ turn: 2, step: 1 }])
    expect(agent.session.events.some(event => event.type === 'tool/call')).toBe(false)
    expect(toolExecutions).toBe(0)
    expect(agent.session.deriveMessages().at(-1)).toMatchObject({
@@ -312,7 +316,7 @@ describe('provider-routed retry policy', () => {
    const agent = context.agentLoop.create(SessionId('retry-exhausted'), { provider: 'mock', model: 'mock' })
    const first = waitForRetry(context, agent, 1)

-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    expect((await first).data.delayMs).toBe(450)

    const second = waitForRetry(context, agent, 2)
@@ -343,7 +347,7 @@ describe('provider-routed retry policy', () => {
    const agent = context.agentLoop.create(SessionId('retry-zero-delay'), { provider: 'mock', model: 'mock' })
    const scheduled = waitForRetry(context, agent, 1)

-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    expect((await scheduled).data.delayMs).toBe(0)

    const idle = waitForIdle(context, agent)
@@ -363,7 +367,7 @@ describe('provider-routed retry policy', () => {
    }) }))
    const acceptedAgent = context.agentLoop.create(SessionId('retry-after-accepted'), { provider: 'mock', model: 'mock' })
    const scheduled = waitForRetry(context, acceptedAgent, 1)
-    acceptedAgent.followup([{ type: 'text', text: 'go' }])
+    acceptedAgent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    expect((await scheduled).data.delayMs).toBe(2_000)
    const acceptedIdle = waitForIdle(context, acceptedAgent)
    await vi.advanceTimersByTimeAsync(2_000)
@@ -377,7 +381,7 @@ describe('provider-routed retry policy', () => {
    ;({ ctx: context } = await harness(rejected))
    const rejectedAgent = context.agentLoop.create(SessionId('retry-after-rejected'), { provider: 'mock', model: 'mock' })
    const rejectedIdle = waitForIdle(context, rejectedAgent)
-    rejectedAgent.followup([{ type: 'text', text: 'go' }])
+    rejectedAgent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    await rejectedIdle
    expect(rejected.requests).toHaveLength(1)
    expect(rejectedAgent.session.events.some(event => event.type === 'llm/retry')).toBe(false)
@@ -400,7 +404,7 @@ describe('provider-routed retry policy', () => {
    })
    const scheduled = waitForRetry(context, agent, 1)

-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    expect((await scheduled).data.delayMs).toBe(3)
    const idle = waitForIdle(context, agent)
    await vi.advanceTimersByTimeAsync(3)
@@ -415,7 +419,7 @@ describe('provider-routed retry policy', () => {
    ;({ ctx: context } = await harness(adapter))
    const agent = context.agentLoop.create(SessionId('retry-auth'), { provider: 'mock', model: 'mock' })
    const idle = waitForIdle(context, agent)
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    await idle
    expect(adapter.requests).toHaveLength(1)
    expect(agent.session.events.some(event => event.type === 'llm/retry')).toBe(false)
@@ -433,7 +437,7 @@ describe('provider-routed retry policy', () => {
    })
    const idle = waitForIdle(context, agent)

-    agent.followup([{ type: 'text', text: 'missing route' }])
+    agent.followup({ content: [{ type: 'text', text: 'missing route' }], source: { kind: 'user' } })
    await idle

    expect(adapter.requests).toHaveLength(0)
@@ -460,7 +464,7 @@ describe('provider-routed retry policy', () => {
      model: 'mock',
    })
    const normalIdle = waitForIdle(context, normalAgent)
-    normalAgent.followup([{ type: 'text', text: 'normal' }])
+    normalAgent.followup({ content: [{ type: 'text', text: 'normal' }], source: { kind: 'user' } })
    await normalIdle
    expect(normalAgent.session.events.some(event => event.type === 'llm/retry')).toBe(false)

@@ -469,7 +473,7 @@ describe('provider-routed retry policy', () => {
      model: 'mock',
    })
    const scheduled = waitForRetry(context, alwaysAgent, 1)
-    alwaysAgent.followup([{ type: 'text', text: 'always' }])
+    alwaysAgent.followup({ content: [{ type: 'text', text: 'always' }], source: { kind: 'user' } })
    expect((await scheduled).data).toMatchObject({
      provider: 'other',
      mode: 'always',
@@ -492,8 +496,8 @@ describe('provider-routed retry policy', () => {
    ;({ ctx: context } = await harness(adapter, {
      other: alwaysConfig({ initialDelayMs: 1, maxDelayMs: 1, jitterRatio: 0 }),
    }, (ctx) => {
-      ctx.on('agent/request', async (_agent, _turn, _step, config) => ({
-        ...config,
+      ctx.on('agent/request', async (_agent, _turn, _step, _signal, next) => ({
+        ...await next(),
        provider: 'other',
      }))
    }))
@@ -503,7 +507,7 @@ describe('provider-routed retry policy', () => {
    })
    const scheduled = waitForRetry(context, agent, 1)

-    agent.followup([{ type: 'text', text: 'reroute' }])
+    agent.followup({ content: [{ type: 'text', text: 'reroute' }], source: { kind: 'user' } })
    expect((await scheduled).data).toMatchObject({ provider: 'other', mode: 'always' })
    const idle = waitForIdle(context, agent)
    await vi.advanceTimersByTimeAsync(1)
@@ -529,9 +533,9 @@ describe('provider-routed retry policy', () => {
        backoff: { initialDelayMs: 1, maxDelayMs: 1 },
      }),
    }, (ctx) => {
-      ctx.on('agent/request', async (_agent, _turn, step, config) => ({
-        ...config,
-        provider: step === 1 ? 'mock' : 'other',
+      ctx.on('agent/request', async (_agent, turn, _step, _signal, next) => ({
+        ...await next(),
+        provider: turn === 1 ? 'mock' : 'other',
      }))
    }))
    const agent = context.agentLoop.create(SessionId('retry-provider-budgets'), {
@@ -540,7 +544,10 @@ describe('provider-routed retry policy', () => {
    })
    const idle = waitForIdle(context, agent)

-    agent.followup([{ type: 'text', text: 'switch provider after failure' }])
+    agent.followup({
+      content: [{ type: 'text', text: 'switch provider after failure' }],
+      source: { kind: 'user' },
+    })
    await vi.runAllTimersAsync()
    await idle

@@ -584,7 +591,10 @@ describe('provider-routed retry policy', () => {
        model: 'mock',
      })
      const scheduled = waitForRetry(context, agent, 1)
-      agent.followup([{ type: 'text', text: 'replace while in flight' }])
+      agent.followup({
+        content: [{ type: 'text', text: 'replace while in flight' }],
+        source: { kind: 'user' },
+      })
      await entered.promise

      mounted.disposeAdapter()
@@ -649,7 +659,7 @@ describe('provider-routed retry policy', () => {
    })
    const idle = waitForIdle(context, agent)

-    agent.followup([{ type: 'text', text: 'keep trying' }])
+    agent.followup({ content: [{ type: 'text', text: 'keep trying' }], source: { kind: 'user' } })
    await vi.runAllTimersAsync()
    await idle

@@ -686,7 +696,7 @@ describe('provider-routed retry policy', () => {
    })
    const scheduled = waitForRetry(context, agent, 1)

-    agent.followup([{ type: 'text', text: 'safe input' }])
+    agent.followup({ content: [{ type: 'text', text: 'safe input' }], source: { kind: 'user' } })
    await scheduled
    const idle = waitForIdle(context, agent)
    await vi.advanceTimersByTimeAsync(1)
@@ -708,14 +718,14 @@ describe('provider-routed retry policy', () => {
      textResponse('specialized recovery won'),
    ])
    ;({ ctx: context } = await harness(adapter, { mock: alwaysConfig() }))
-    context.on('agent/request-error', async () => ({ action: 'retry' }))
+    context.on('agent/request-error', async () => ({ kind: 'retry' }))
    const agent = context.agentLoop.create(SessionId('retry-always-composition'), {
      provider: 'mock',
      model: 'mock',
    })
    const idle = waitForIdle(context, agent)

-    agent.followup([{ type: 'text', text: 'recover' }])
+    agent.followup({ content: [{ type: 'text', text: 'recover' }], source: { kind: 'user' } })
    await idle

    expect(adapter.requests).toHaveLength(2)
@@ -742,7 +752,7 @@ describe('provider-routed retry policy', () => {
    })
    const scheduled = waitForRetry(context, agent, 1)

-    agent.followup([{ type: 'text', text: 'recover' }])
+    agent.followup({ content: [{ type: 'text', text: 'recover' }], source: { kind: 'user' } })
    await scheduled
    const idle = waitForIdle(context, agent)
    await vi.advanceTimersByTimeAsync(1)
@@ -761,7 +771,7 @@ describe('provider-routed retry policy', () => {
    context = mounted.ctx
    const agent = context.agentLoop.create(SessionId('retry-hmr'), { provider: 'mock', model: 'mock' })
    const scheduled = waitForRetry(context, agent, 1)
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    await scheduled
    const idle = waitForIdle(context, agent)

@@ -785,14 +795,14 @@ describe('provider-routed retry policy', () => {
      entered.resolve(undefined)
      await release.promise
      order.push('downstream')
-      return { action: 'retry' }
+      return { kind: 'retry' }
    })
    const agent = context.agentLoop.create(SessionId('retry-delegated-disposal'), {
      provider: 'mock',
      model: 'mock',
    })
    const idle = waitForIdle(context, agent).then(() => { order.push('idle') })
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    await entered.promise

    const disposing = mounted.retryFiber.dispose().then(() => { order.push('disposed') })
@@ -818,7 +828,7 @@ describe('provider-routed retry policy', () => {
    const adapter = new ScriptedAdapter([new LlmError('bad key', 'AUTH')])
    const mounted = await harness(adapter, { mock: alwaysConfig() })
    context = mounted.ctx
-    const downstream = Promise.withResolvers<RequestErrorDecision>()
+    const downstream = Promise.withResolvers<RequestErrorAction>()
    const entered = Promise.withResolvers<undefined>()
    const order: string[] = []
    context.on('agent/request-error', async () => {
@@ -832,7 +842,7 @@ describe('provider-routed retry policy', () => {
      model: 'mock',
    })
    const idle = waitForIdle(context, agent).then(() => { order.push('idle') })
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    await entered.promise

    agent.cancel({ kind: 'user' })
@@ -844,7 +854,7 @@ describe('provider-routed retry policy', () => {
    if (timer !== undefined) clearTimeout(timer)
    expect(outcome).toBe('blocked')

-    downstream.resolve({ action: 'retry' })
+    downstream.resolve({ kind: 'retry' })
    await idle

    expect(order).toEqual(['downstream', 'idle'])
@@ -859,7 +869,7 @@ describe('provider-routed retry policy', () => {
    const adapter = new ScriptedAdapter([new LlmError('bad key', 'AUTH')])
    const mounted = await harness(adapter, { mock: alwaysConfig() })
    context = mounted.ctx
-    const downstream = Promise.withResolvers<RequestErrorDecision>()
+    const downstream = Promise.withResolvers<RequestErrorAction>()
    const entered = Promise.withResolvers<undefined>()
    context.on('agent/request-error', (agent) => {
      agent.cancel({ kind: 'user' })
@@ -872,7 +882,7 @@ describe('provider-routed retry policy', () => {
    })
    const idle = waitForIdle(context, agent)

-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    await entered.promise
    let timer: ReturnType<typeof setTimeout> | undefined
    const outcome = await Promise.race([
@@ -882,7 +892,7 @@ describe('provider-routed retry policy', () => {
    if (timer !== undefined) clearTimeout(timer)
    expect(outcome).toBe('blocked')

-    downstream.resolve({ action: 'retry' })
+    downstream.resolve({ kind: 'retry' })
    await idle

    expect(adapter.requests).toHaveLength(1)
@@ -900,7 +910,7 @@ describe('provider-routed retry policy', () => {
      ctx.on('agent/request-error', (
        _agent, _turn, _step, _error, _failure, _history, _retryPolicy, _signal, next,
      ) => {
-        return new Promise<RequestErrorDecision>((resolve) => {
+        return new Promise<RequestErrorAction>((resolve) => {
          invokeCaptured = async () => { resolve(await next()) }
          captured.resolve(undefined)
        })
@@ -919,7 +929,7 @@ describe('provider-routed retry policy', () => {
      model: 'mock',
    })
    const idle = waitForIdle(context, agent)
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    await captured.promise

    await mounted.retryFiber.dispose()
@@ -940,7 +950,7 @@ describe('provider-routed retry policy', () => {
    ;({ ctx: context } = await harness(adapter, { mock: alwaysConfig() }))
    const agent = context.agentLoop.create(SessionId('retry-cancel'), { provider: 'mock', model: 'mock' })
    const scheduled = waitForRetry(context, agent, 1)
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    await scheduled
    const idle = waitForIdle(context, agent)
    agent.cancel({ kind: 'user' })
@@ -974,7 +984,7 @@ describe('provider-routed retry policy', () => {
    const agent = context.agentLoop.create(SessionId('retry-pre-cancel'), { provider: 'mock', model: 'mock' })
    const idle = waitForIdle(context, agent)

-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    await idle

    expect(adapter.requests).toHaveLength(1)
@@ -998,7 +1008,7 @@ describe('provider-routed retry policy', () => {
    })
    const idle = waitForIdle(context, agent)

-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
    await idle

    expect(adapter.requests).toHaveLength(1)
--- a/packages/llm/llm-retry/tests/transport-recovery.spec.ts
+++ b/packages/llm/llm-retry/tests/transport-recovery.spec.ts
@@ -66,7 +66,7 @@ function waitForIdle(ctx: Context, agent: Agent): Promise<void> {

 function sendAndWait(ctx: Context, agent: Agent): Promise<void> {
  const idle = waitForIdle(ctx, agent)
-  agent.followup([{ type: 'text', text: 'recover through the provider boundary' }])
+  agent.followup({ content: [{ type: 'text', text: 'recover through the provider boundary' }], source: { kind: 'user' } })
  return idle
 }

@@ -106,8 +106,9 @@ describe('bounded retry through the real DeepSeek HTTP/SSE adapter', () => {

    expect(server).toBeDefined()
    expect(server?.requests).toHaveLength(1)
-    expect(agent.session.events.filter(event => event.type === 'step/start').map(event => event.data.step))
-      .toEqual([1, 2])
+    expect(agent.session.events.filter(event => event.type === 'step/start')
+      .map(event => [event.data.turn, event.data.step]))
+      .toEqual([[1, 1], [2, 1]])
    expect(agent.session.events.filter(event => event.type === 'llm/retry').map(event => event.data.failure.code))
      .toEqual(['TRANSPORT'])
    expect(finalAssistantText(agent)).toBe('connected after retry')
@@ -135,10 +136,11 @@ describe('bounded retry through the real DeepSeek HTTP/SSE adapter', () => {
    expect(server.requests).toHaveLength(2)
    expect(server.requests[0]?.body).toEqual(server.requests[1]?.body)
    expect(agent.session.events.filter(event =>
-      event.type === 'assistant/chunk' && event.data.step === 1,
+      event.type === 'assistant/chunk' && event.data.turn === 1,
    )).toHaveLength(failedChunkCount)
-    expect(agent.session.events.filter(event => event.type === 'assistant/message').map(event => event.data.step))
-      .toEqual([2])
+    expect(agent.session.events.filter(event => event.type === 'assistant/message')
+      .map(event => [event.data.turn, event.data.step]))
+      .toEqual([[2, 1]])
    expect(agent.session.events.filter(event => event.type === 'llm/retry').map(event => event.data.failure.code))
      .toEqual(['TRANSPORT'])
    expect(finalAssistantText(agent)).toBe('recovered response')
@@ -161,8 +163,9 @@ describe('bounded retry through the real DeepSeek HTTP/SSE adapter', () => {
    expect(server.requests[0]?.body).toEqual(server.requests[1]?.body)
    expect(agent.session.events.filter(event => event.type === 'llm/retry').map(event => event.data.failure.code))
      .toEqual(['EMPTY_RESPONSE'])
-    expect(agent.session.events.filter(event => event.type === 'assistant/message').map(event => event.data.step))
-      .toEqual([2])
+    expect(agent.session.events.filter(event => event.type === 'assistant/message')
+      .map(event => [event.data.turn, event.data.step]))
+      .toEqual([[2, 1]])
    expect(agent.session.events.at(-1)).toMatchObject({
      type: 'turn/end',
      data: { reason: { kind: 'completed' } },
@@ -186,7 +189,7 @@ describe('bounded retry through the real DeepSeek HTTP/SSE adapter', () => {

    expect(server.requests).toHaveLength(1)
    expect(agent.session.events.filter(event =>
-      event.type === 'assistant/chunk' && event.data.step === 1,
+      event.type === 'assistant/chunk' && event.data.turn === 1,
    )).toHaveLength(2)
    expect(agent.session.events.some(event => event.type === 'assistant/message')).toBe(false)
    expect(agent.session.events.some(event => event.type === 'llm/retry')).toBe(false)
--- a/packages/llm/llm/src/types.ts
+++ b/packages/llm/llm/src/types.ts
@@ -235,8 +235,7 @@ export interface GenerateOptions {
  /**
   * Ordered conversation messages, exactly as the provider sees them (after
   * the `system` slot). A loop-built request assembles them as
-   * `EpochHeader.messagePrefix` + the derived history (dsh-agent-loop); a
-   * hand-built one-shot passes any list.
+   * the derived history (dsh-agent-loop); a hand-built one-shot passes any list.
   */
  messages: Message[]
  /** System prompt text (adapters map to the provider's system slot). */
--- a/packages/llm/token-meter/src/index.ts
+++ b/packages/llm/token-meter/src/index.ts
@@ -378,7 +378,6 @@ export class TokenMeterService extends Service {
  private _estimateHeader(header: EpochHeader | undefined): number {
    if (header === undefined) return 0
    let tokens = 0
-    for (const message of header.messagePrefix ?? []) tokens += this.estimateMessage(message)
    if (header.system !== undefined) {
      tokens += Math.ceil(header.system.length / CHARS_PER_TOKEN) + ROLE_OVERHEAD
    }
--- a/packages/llm/token-meter/tests/token-meter.spec.ts
+++ b/packages/llm/token-meter/tests/token-meter.spec.ts
@@ -183,7 +183,7 @@ describe('TokenMeterService pricing', () => {
    expect(snapshot.nodes).toHaveLength(1)
  })

-  it('prices header, prefix, tools, and surface when no reusable usage exists', () => {
+  it('prices header, tools, and surface when no reusable usage exists', () => {
    const service = meter()
    const session = new Session(SessionId('heuristic'))
    session.append('user/message', {
@@ -192,7 +192,6 @@ describe('TokenMeterService pricing', () => {
    }, { surfaceOp: 'append' })
    appendHeader(session, header('deepseek-v4-flash', {
      system: 'system',
-      messagePrefix: [textMessage('prefix')],
      tools: [{ name: 'read', description: 'read', parameters: { type: 'object' } }],
    }))
    const result = service.measure(session)
@@ -354,10 +353,6 @@ describe('replay anchors and surface folds', () => {
      ...anchoredHeader,
      config: { ...anchoredHeader.config, temperature: 0.2 },
    }).baseline.kind).toBe('estimated')
-    expect(service.measure(session, {
-      ...anchoredHeader,
-      messagePrefix: [textMessage('prefix')],
-    }).baseline.kind).toBe('estimated')
    expect(service.measure(session, {
      ...anchoredHeader,
      tools: [{ name: 'read', description: 'read', parameters: { type: 'object' } }],