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

packages/core/agent-loop/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/core/agent-loop/README.md
-README.md: 01f1131741076de5350dc16f0467f24d677611eb
-README.zh.md: 50716f01cab2b6780bce60cfe1a0cdfa3c13dd52
+README.md: c12140f27aed400b0f7b4246700473e877d37632
+README.zh.md: 6394cd86f5f3241be07ef711c76079624bce1bfe

packages/core/agent-loop/README.md

@@ -14,7 +14,7 @@ Creation and resume are one rollback-covered transaction: construct a private se
 
 The caller fiber and the AgentLoop provider are co-owners. `AgentFactory.createAgent(ownerCtx, options)` and `resume(ownerCtx, options)` receive caller ownership explicitly, while the factory keeps its own dependency context for `sessions`/`llm`/`tools`/`systemPrompt`; this lets a caller inject only `agents` without shrinking the new agent's service surface. Caller unload, handle disposal, or provider unload converge on one memoized quiescence boundary. Provider shutdown waits both resource teardown and the public create/resume wrapper that observed deactivation, so no continuation can publish after dependencies disappear.
 
-Each agent and its session share one caller-chosen `SessionId`, assumed globally unique; accidental UUID collisions are outside the supported model. Two concurrent operations with the same id may both prepare, but the final `enter()` calls arbitrate publication and every loser rolls its private resources back. Each detach is bound to the exact entered object, so a stale disposer cannot remove a later same-id replacement. A detach requested during a synchronous creation notification waits for that dispatch to unwind, preserving created/disposed pairing. Teardown runs stop and drain (including outstanding idle-injection flushes) → detach agent → detach session → unwind scope; the id becomes reusable at detach even if private scope cleanup is still finishing. Ordinary non-vetoing `agent/*` notifications go through `agentEvents(ctx, agent)`, per-step assembly goes through `assembleContextFor(agent)`, and turn-end durability checkpoints go through `ctx.sessions.flush(session)`.
+Each agent and its session share one caller-chosen `SessionId`, assumed globally unique; accidental UUID collisions are outside the supported model. Two concurrent operations with the same id may both prepare, but the final `enter()` calls arbitrate publication and every loser rolls its private resources back. Each detach is bound to the exact entered object, so a stale disposer cannot remove a later same-id replacement. A detach requested during a synchronous creation notification waits for that dispatch to unwind, preserving created/disposed pairing. Teardown runs stop and drain → unwind scope → detach agent → detach session; the id becomes reusable after private scope cleanup. Ordinary non-vetoing `agent/*` notifications go through `agentEvents(ctx, agent)`, and per-step assembly goes through `assembleContextFor(agent)`.
 
 - `ctx.agentLoop.create(id: SessionId, options?: AgentOptions, meta?: { cwd?: string }): Agent` — synchronous no-setup create under the exact shared agent/session id, disposed with the calling fiber. Declarative config treats `agents[].id` as a stable label and normally mints `${label}-session-<uuid>` before calling this boundary. An app may instead supply a stable exact `sessionId`: first use creates it, while a remount with persistence already present resumes its materialized history. `resumeSessionId` requires and loads an existing persisted id and is mutually exclusive with `sessionId`. This keeps default fresh restarts collision-free without retaining a second live routing identity.
 
@@ -52,31 +52,31 @@ Configured agents start automatically. A model call requires both `provider` and
 
 ### Internal concrete driver
 
-The concrete `ReactLoopAgent` adapter, its `Inbox`, `runLoop`, and instance-bound publication/start controls are package-internal. The package root exports only the plugin/service/config contract, and the package exports map exposes no `./src/*` escape hatch; lifecycle owners create agents through `ctx.agents` rather than naming, constructing, or starting driver internals. One prepared session can be claimed by only one concrete driver, and everything observable happens through session events and the `agent/*` event taxonomy.
+The concrete `ReactLoopAgent`, its queued input, outbox, and run controls are package-internal. The package root exports only the plugin/service/config contract, and the package exports map exposes no `./src/*` escape hatch; lifecycle owners create agents through `ctx.agents` rather than naming, constructing, or starting driver internals. One prepared session can be claimed by only one concrete driver, and everything observable happens through session events and the `agent/*` event taxonomy.
 
-`ReactLoopAgent.send()` implements the public fully resolved acceptance path. The `followup()`/`queue()`/`steer()`/`inject()` helpers resolve every optional field before delegating to it; direct callers provide mandatory content, source, contexts, metadata, target, and wakeup facts through `ResolvedAgentInput`. `followup()` and `queue()` join the ordinary FIFO, respectively waking or leaving an idle driver parked. If claimed, an ordinary item is the sole message in its turn, and its contexts are the prompt waterfall's default additional contexts that materialize only after admission. Absent or `separate` placement appends an independent injected `user/message`; `prompt-prefix` placement bakes the context, the stable `## My request:` delimiter, and effective request into one `user/message`, whose model-hidden envelope retains display content and context descriptors. The waterfall's returned allow is authoritative, so a listener wrapping `next()` preserves downstream `content` and `additionalContexts` unless it intentionally replaces them. A successor waits for the preceding ordinary turn's checkpoint to settle, while cancellation, disposal, a prompt block, or a pre-start failure may drop its contexts with the message. Running `steer()` or equivalent `send()` routing enters the same record shape in the steering FIFO without dispatching `agent/prompt-submit`; its next checkpoint applies the same separate-or-prefix placement to `steering/message`, while policy can still stop before another step. Steering left after turn close and its checkpoint becomes later queued input with contexts intact unless terminal turn policy, cancellation, or disposal discards it. `inject()` and non-waking next-step acceptance require an empty context tuple, bypass both FIFOs, and append durable context directly: an open-turn injection defers in a FIFO while the current step executes assistant tool calls (successful batches place it after all results, interrupted batches drain it before turn close), and an idle injection wraps a one-shot `injection` turn. Every FIFO enqueue publishes `agent/inbox/enqueue`; the driver's claims publish `agent/inbox/dequeue`, and `cancel()` without `keepInbox` publishes `agent/inbox/discard`. Malformed data throws before enqueue or append.
+The unified `send()` primitive routes content and source by (`target` × `wakeup`); `followup`/`steer`/`inject` are its fixed-preset aliases. A `next-turn` item joins the queued FIFO, waking the driver unless `wakeup: false`; admission happens before any turn opens. The loop opens a private next-step acceptance window before `agent/prompt-submit` and closes it before `turn/end`. During that window, `steer()` and `inject()` stage in one outbox; an allowed admission opens the turn, records the prompt and returned `additionalContexts`, then drains the staged input before the first request. A blocked or failed admission writes no prompt or hook-produced context. A caller-staged context-only batch then takes idle injection's immediate append, while steering and context staged beside it remain pending for retry or a later admitted prompt. Outside the window, steering becomes a waking queued prompt and injection immediately appends `user/message` without opening a turn or running the model. Every inbox enqueue publishes `agent/inbox/enqueue` with the resolved queued-or-steering placement; taking it publishes `agent/inbox/dequeue`, and `cancel()` without `keepInbox` publishes `agent/inbox/discard`.
 
-### Loop lifecycle (`loop.ts`)
+### Loop lifecycle (`agent.ts`)
 
 The driver owns one agent for its lifetime and runs inside `ctx.agents.withInitiator(agent, ...)`. Package-private orchestration entry points recover the exact Agent, derive `agent.session` once, and let operation-local helpers capture it instead of forwarding the concrete driver or per-operation `Session` through shallow interfaces. A helper keeps an explicit `Session` when that is its actual interface, while creation, persistence load, unpublished setup, services, workers, processes, persistence, and wire protocols retain their explicit identities. The [agent service](../agent/README.md#initiating-agent-scope) owns propagation, teardown, and detached-work rules.
 
-Every provider call that reaches a successful finish appends exactly one `assistant/message` completion anchor, including content-less calls and `max-tokens` finishes. A successful `agent/step-result` stores its transformed content; a rejected result records empty content before the original failure continues. The anchor retains exact chunk provenance (`[]` for a stream with no chunks) and usage when available, while empty content stays out of derived message history.
+Every provider call that reaches a successful finish appends exactly one `assistant/message` completion anchor, including content-less calls and `max-tokens` finishes. The anchor records the assembled content as-is, retains exact chunk provenance (`[]` for a stream with no chunks), and includes usage when available; empty content stays out of derived message history.
 
 After `agent/request` returns a provider/model call config, the loop asks `ctx.llm.prepareCall()` to validate any adapter-owned reasoning effort and materialize its configured default under the active turn signal. The prepared call retains the exact adapter registration across this asynchronous resolution, `request/header` logging, and terminal dispatch, so HMR cannot mix one adapter's capability result with another adapter's request. The effective config is logged before dispatch, so a listener can change effort between steps without hidden request drift. A route with no registered adapter preserves the proposed config so an `llm/stream` listener can own and short-circuit it; unhandled terminal dispatch still fails with `NO_ADAPTER`. A new loop instance restores the last effort only when its initial provider/model route exactly matches the logged route; a route change discards that opaque model-owned ID and resolves the new model independently.
 
-Plugin failure ends the current turn, not the loop. Only final adapter dispatch/iteration failures and terminal in-band error or aborted finishes enter `agent/request-error`; middleware, result processing, tools, and `agent/post-step` remain ordinary turn failures. Recovery receives the exact live error, immutable provider facts, immutable prior failures, and the immutable retry policy of the adapter registration that served the request after the failed step closes; the policy is absent if no final adapter served it. A retry rebuilds from the durable log in a new numbered step, success clears the consecutive history, and exhaustion records the structured failure once on `turn/end`. AgentLoop privately owns one cancellation holder whose explicit signal spans prompt policy, assembly, every step, model and tool work, recovery, continuation, and terminal stop; it retires the holder immediately before publishing `turn/end`, while the driver may remain `running` through the durability flush. An effective `cancel()` emits the typed runtime-only `user | parent` cause before clearing pending work and cooperatively aborting the holder; notification failures cannot veto cancellation, work queued by a notification observer is cleared, work queued by a later abort observer belongs to the next turn, and idle cancellation emits nothing. Durable `turn/end` remains coarse `aborted`; undispatched model tool calls receive synthetic `tool/call` and `ABORTED_BEFORE_DISPATCH` result pairs. Disposal wins terminal classification, and work that ignores the signal must settle before quiescence. The [explicit-cancellation decision](../../../.agents/notes/implemented/architecture/2026-07-16-explicit-turn-cancellation.md) owns the lifecycle and race contract. Terminal continuation stops remain authoritative through turn close and durability flush.
+Plugin failure ends the current turn, not the loop. Only final adapter dispatch/iteration failures and terminal in-band error or aborted finishes enter `agent/request-error`; middleware, result processing, tools, and other extension failures close directly. Recovery receives the exact live error, immutable provider facts, immutable prior failures, the immutable retry policy of the adapter registration that served the request, and the turn signal after the failed step closes; the policy is absent if no final adapter served it. A handling listener returns `{ kind: 'retry' }`; the loop closes the failed turn with its error and opens one numbered retry turn without an intervening idle notification. Success clears the consecutive history, and an unhandled failure is terminal. AgentLoop owns one cancellation signal for the current admission or turn. An effective `cancel(cause)` clears pending work unless `keepInbox` is set and cooperatively aborts that signal; idle cancellation is a no-op. Durable `turn/end` records `aborted` for `user` and `parent`, while disposal records `disposed`; undispatched model tool calls receive synthetic `tool/call` and `ABORTED_BEFORE_DISPATCH` result pairs. The cancellation cause changes reporting, not how result context finalized after cancellation is handled. Disposal waits for signal-ignoring work before registry removal. The [explicit-cancellation decision](../../../.agents/notes/implemented/architecture/2026-07-16-explicit-turn-cancellation.md) owns the lifecycle and race contract.
 
-Within a step, exclusive calls form barriers; parallel-safe calls use a bounded rolling pool and are reclassified before start. Only dispatch/body overlaps. Policy, durable results, and result context remain model-ordered. Abort stops new calls, drains started results, then drains accepted batch context before the turn closes through the normal abort path.
+Within a step, exclusive calls form barriers; parallel-safe calls use a bounded rolling pool and are reclassified before start. Only dispatch/body overlaps. Policy, durable results, and result context remain model-ordered. Abort stops new calls, drains started results, and retains their finalized result context without distinguishing the cancellation cause.
 
 ### What belongs to plugins
 
 Everything that goes beyond "call the model, run the tools, repeat" belongs to plugins listening on the event taxonomy:
 - Hooks and policy: the relevant `agent/*` checkpoints plus the guarded `tools/pre-execute` → `tools/execute` → `tools/post-execute` → definition-owned `finalizeContent` → `tools/result` pipeline; exact event signatures and modes live in the [generated event catalog](../../../docs/cordis-catalog/events.md)
-- Compaction: pressure on `agent/post-step`; canonical context overflow on `agent/request-error`
-- Model-request recovery: `dsh-llm-retry` on `agent/request-error`, with exact-provider normal or unbounded policies and non-surface `llm/retry` status events
+- Compaction: pressure on `agent/step`; canonical overflow repair on `agent/request-error`
+- Model-request recovery: `dsh-llm-retry` records and waits exact-provider normal or unbounded backoff on `agent/request-error`, emits non-surface `llm/retry` status, then returns a retry action
 - Sandbox, permission, plan mode: `tools/pre-execute` for extensible deny/ask, `tools.guard()` for monotonic owner policy, `tools/post-execute` for result decisions, and `tools/result` for final observation
 - Sub-agents: implemented outside the loop as `ctx.subagents` providers; in-process providers use `ctx.agents.create()` and owned `AgentHandle` teardown, while generic [`ctx.tasks`](../../tasks/tasks/) plus [`dsh-tool-subagent`](../../subagent/tool-subagent/) own background collection.
-- Persistence: `session/event` + `session/flush`
+- Persistence: eager write-behind from `session/event`; `session/flush` is an explicit observation barrier
 - UI: `session/event` (assistant token stream, boundaries, tool activity) + `agent/*` control events (`agent/status`, `agent/created`/`agent/disposed`)
 
 ## Model Experience
@@ -85,15 +85,15 @@ Everything that goes beyond "call the model, run the tools, repeat" belongs to p
 
 #### What the model sees
 
-For each step, the loop sends the rendered per-agent system prompt, visible tool schemas, the frozen session prefix, and the session's derived messages. It supplies `model` and `cwd` variable values but no additional fixed prose.
+For each step, the loop sends the rendered per-agent system prompt, visible tool schemas, and the session's derived messages. It supplies `provider`, `model`, and `cwd` variable values but no additional fixed prose.
 
 #### Token effect
 
-System text, schemas, and prefix are paid again on every step. Per-agent scoping chooses the initial contributions, while the authoritative assembly waterfall can alter the final request and makes its listener responsible for protocol coherence.
+System text and schemas are paid again on every step. Per-agent scoping chooses the contributions, while the authoritative assembly waterfall can alter the final request and makes its listener responsible for protocol coherence.
 
 #### KV Cache effect
 
-Append-only only while system text, schemas, session prefix, and earlier history remain byte-identical under the same provider and model route. A token-bearing assembly rewrite or composition change may invalidate reuse from the first altered request token.
+Append-only only while system text, schemas, and earlier history remain byte-identical under the same provider and model route. A token-bearing assembly rewrite or composition change may invalidate reuse from the first altered request token.
 
 ### Retained message history
 
@@ -103,7 +103,7 @@ Accepted user messages, assistant messages, tool calls and results, injected con
 
 #### Token effect
 
-Input grows with every surface message until a compaction replacement shadows older nodes; a multi-step tool turn resends the accumulated prefix and history each step.
+Input grows with every surface message until a compaction replacement shadows older nodes; a multi-step tool turn resends the accumulated history each step.
 
 #### KV Cache effect
 
@@ -128,4 +128,4 @@ Append-only; each synthetic result follows the reusable request prefix and does
 - **Classification is unary** — calls whose safety depends on comparing siblings or resources must remain exclusive ([rationale](../../../.agents/notes/implemented/feature/2026-07-10-parallel-tool-call-execution.md)).
 - **Config labels are fresh by default** — omitting `sessionId` creates a fresh `${id}-session-<uuid>` on every startup; exact resume-or-create behavior requires an explicit stable `sessionId`, while `resumeSessionId` requires existing persisted history.
 - **Config agents have no per-agent persona field or setup hook** — they use the deployment persona; scoped persona/tool composition is available only through the programmatic `ctx.agents.create()` / `resume()` factory options.
-- **No built-in turn budget** — the default continuation is `continue` whenever a step had tool calls or steering; bounding a runaway turn requires an `agent/turn-continuation` force-stop plugin.
+- **No built-in turn budget** — tool calls or steering continue the current turn; a policy that bounds runaway turns must cancel from an existing lifecycle seam such as `agent/turn-stopping`.

packages/core/agent-loop/README.zh.md

@@ -14,7 +14,7 @@
 
 调用方 fiber 与 AgentLoop 提供方共同拥有 agent。`AgentFactory.createAgent(ownerCtx, options)` 与 `resume(ownerCtx, options)` 显式接收调用方所有权，而工厂为 `sessions`/`llm`/`tools`/`systemPrompt` 保留自身的依赖上下文；这样，调用方可以只注入 `agents`，而不会缩减新 agent 的服务接口。调用方卸载、handle 释放或提供方卸载都会汇合到同一个记忆化的完全停稳边界。提供方关闭会同时等待资源 teardown，以及已经观测到停用的公开 create/resume 包装层，因此依赖消失后，任何 continuation 都无法继续发布。
 
-每个 agent 与其会话共享一个由调用方选择的 `SessionId`，并假设它在全局唯一；意外的 UUID 冲突不属于受支持模型。两个使用同一 id 的并发操作都可以进行准备，但最终的 `enter()` 调用会裁决发布，所有失败方都会回滚各自的私有资源。每次 detach 都绑定到确切进入的对象，因此陈旧 disposer 无法移除之后出现的同 id 替代项。在同步创建通知期间请求的 detach 会等待该次分发退栈，从而保留 created/disposed 配对。Teardown 顺序为停止并 drain（包括尚未完成的空闲注入 flush）→ detach agent → detach 会话 → 撤销作用域；detach 完成后，即使私有作用域仍在完成清理，该 id 也可以复用。普通、不可 veto 的 `agent/*` 通知通过 `agentEvents(ctx, agent)` 发出；逐步骤组装通过 `assembleContextFor(agent)` 完成；轮次结束时的持久性检查点通过 `ctx.sessions.flush(session)` 完成。
+每个 agent 与其会话共享一个由调用方选择的 `SessionId`，并假设它在全局唯一；意外的 UUID 冲突不属于受支持模型。两个使用同一 id 的并发操作都可以进行准备，但最终的 `enter()` 调用会裁决发布，所有失败方都会回滚各自的私有资源。每次 detach 都绑定到确切进入的对象，因此陈旧 disposer 无法移除之后出现的同 id 替代项。在同步创建通知期间请求的 detach 会等待该次分发退栈，从而保留 created/disposed 配对。Teardown 顺序为停止并 drain → 撤销作用域 → detach agent → detach 会话；私有作用域清理完成后，该 id 即可复用。普通、不可 veto 的 `agent/*` 通知通过 `agentEvents(ctx, agent)` 发出；逐步骤组装通过 `assembleContextFor(agent)` 完成。
 
 - `ctx.agentLoop.create(id: SessionId, options?: AgentOptions, meta?: { cwd?: string }): Agent`：在确切共享的 agent／会话 id 下同步创建，不运行 setup，并随调用 fiber 释放。声明式配置把 `agents[].id` 视为稳定 label，通常会先生成 `${label}-session-<uuid>`，再调用此边界。应用也可以提供稳定且确切的 `sessionId`：首次使用时创建；重新挂载且持久化内容已存在时，则恢复已经实体化的历史。`resumeSessionId` 要求并加载现有的持久化 id，且与 `sessionId` 互斥。这样，默认的全新重启不会冲突，也无需保留第二个实时路由身份。
 
@@ -52,31 +52,31 @@ interface Config {
 
 ### 包内部实体驱动器
 
-实体 `ReactLoopAgent` 适配器、其 `Inbox`、`runLoop`，以及绑定实例的发布／启动控制均为包内部实现。包根只导出插件／服务／配置契约，包导出映射不提供 `./src/*` 逃逸路径；生命周期拥有方通过 `ctx.agents` 创建 agent，而不是点名、构造或启动驱动器内部组件。一个准备完成的会话只能由一个实体驱动器认领；所有可观测行为都通过会话事件和 `agent/*` 事件分类体系发生。
+实体 `ReactLoopAgent`、其排队输入、outbox 与运行控制均为包内部实现。包根只导出插件／服务／配置契约，包导出映射不提供 `./src/*` 逃逸路径；生命周期拥有方通过 `ctx.agents` 创建 agent，而不是点名、构造或启动驱动器内部组件。一个准备完成的会话只能由一个实体驱动器认领；所有可观测行为都通过会话事件和 `agent/*` 事件分类体系发生。
 
-`ReactLoopAgent.send()` 实现公开且完全解析的接纳路径。`followup()`/`queue()`/`steer()`/`inject()` 辅助方法会先解析每个可选字段，再委托给它；直接调用方通过 `ResolvedAgentInput` 提供必填的内容、来源、上下文、元数据、目标与唤醒事实。`followup()` 和 `queue()` 加入普通 FIFO，前者会唤醒空闲驱动器，后者则让其保持停驻。认领后的普通项是所属轮次的唯一消息；其上下文是提示词 waterfall（瀑布式事件）的默认附加上下文，只在通过接纳后实体化。缺少 placement 或 placement 为 `separate` 时，会追加一条独立注入的 `user/message`；placement 为 `prompt-prefix` 时，则把上下文、稳定的 `## My request:` 分隔符和有效请求写入同一条 `user/message`，其对模型隐藏的 envelope 保留显示内容和上下文描述符。waterfall 返回的允许决定具有权威性，因此，使用 `next()` 包装下游的监听器会保留下游 `content` 和 `additionalContexts`，除非它有意替换相应字段。后续普通项会等待前一普通轮次的检查点结算；取消、释放、提示词阻止或启动前失败则可能让上下文随消息一同丢弃。运行期间调用 `steer()`，或使用等效的 `send()` 路由，会在不分发 `agent/prompt-submit` 的情况下，把相同记录形态加入 steering FIFO；下一个检查点会对 `steering/message` 应用相同的独立或前缀 placement，但策略仍可以在另一步骤前停止。轮次及其检查点关闭后遗留的 steering 会连同上下文转为之后的排队输入，除非终止轮次策略、取消或释放将其丢弃。`inject()` 和不唤醒的下一步骤接纳要求上下文元组为空，绕过两个 FIFO 并直接追加持久上下文：轮次打开时，注入会在当前步骤执行 assistant 工具调用期间延后到一个 FIFO 中（成功批次把它放在所有结果之后，中断批次则在轮次关闭前 drain）；空闲时，注入会包在一次性 `injection` 轮次中。每次 FIFO 入队都会发布 `agent/inbox/enqueue`；驱动器的认领会发布 `agent/inbox/dequeue`；`cancel()` 在不带 `keepInbox` 时会发布 `agent/inbox/discard`。格式错误的数据会在入队或追加前抛出。
+统一的 `send()` 原语按（`target` × `wakeup`）路由内容与来源；`followup`/`steer`/`inject` 是它的固定预设别名。`next-turn` 项加入排队 FIFO，除非 `wakeup: false`，否则会唤醒驱动器；接纳发生在任何轮次开启之前。循环在 `agent/prompt-submit` 之前打开一个私有的 next-step 接收窗口，并在 `turn/end` 之前关闭它。在该窗口内，`steer()` 与 `inject()` 会暂存到同一个 outbox；接纳获准后会开启轮次，记录提示词及其返回的 `additionalContexts`，再于首次请求前排空暂存输入。接纳被阻止或失败时，不会写入提示词或钩子生成的上下文。之后，仅含调用方暂存上下文的批次会采用空闲注入的立即追加行为，而 steering（中途引导）及与其一同暂存的上下文则继续待处理，以供重试或之后获准的提示词使用。窗口之外，steering 会成为唤醒驱动器的排队提示词，而注入会立即追加 `user/message`，不开启轮次也不运行模型。每次 inbox 入队都会发布 `agent/inbox/enqueue`，并携带解析出的 queued 或 steering 路由归类；取走它会发布 `agent/inbox/dequeue`；`cancel()` 在不带 `keepInbox` 时会发布 `agent/inbox/discard`。
 
-### 循环生命周期（`loop.ts`）
+### 循环生命周期（`agent.ts`）
 
 驱动器在其整个生命周期内拥有一个 agent，并在 `ctx.agents.withInitiator(agent, ...)` 内运行。包私有的编排入口点会恢复确切的 Agent，一次性派生 `agent.session`，并让操作局部的辅助函数捕获它，而不是通过浅层接口继续传递实体驱动器或每次操作的 `Session`。如果显式 `Session` 正是辅助函数的实际接口，该辅助函数会保留它；创建、持久化加载、未发布 setup、服务、worker、进程、持久化和 wire 协议则继续保留各自的显式身份。[agent 服务](../agent/README.md#initiating-agent-scope)规定传播、teardown 和分离工作规则。
 
-每次提供方调用成功结束时，都会恰好追加一个 `assistant/message` 完成锚点，包括无内容调用和以 `max-tokens` 结束的调用。成功的 `agent/step-result` 存储其转换后内容；被拒绝的结果会先记录空内容，再继续抛出原始失败。该锚点保留确切的 chunk 溯源（流没有 chunk 时为 `[]`），并在用量可用时保留用量；空内容不会进入派生消息历史。
+每次提供方调用成功结束时，都会恰好追加一个 `assistant/message` 完成锚点，包括无内容调用和以 `max-tokens` 结束的调用。该锚点原样记录组装后的内容，保留确切的 chunk 溯源（流没有 chunk 时为 `[]`），并在用量可用时包含用量；空内容不会进入派生消息历史。
 
 在 `agent/request` 返回提供方／模型调用配置后，循环会调用 `ctx.llm.prepareCall()`，在活跃轮次信号的控制下校验由适配器持有的推理（reasoning）强度，并填入其配置默认值。准备完成的调用会在这次异步解析、`request/header` 日志记录和最终分派期间保留同一项确切的适配器注册，因此 HMR（热模块替换）不会把某个适配器的能力解析结果与另一适配器的请求混用。生效配置会在分派前写入日志，因此监听器可以在步骤之间更改推理强度，而不会产生未记录的请求变化。没有已注册适配器的路由会保留原定配置，使 `llm/stream` 监听器可以接管并短路该请求；最终分派仍会以 `NO_ADAPTER` 拒绝未得到处理的路由。新循环实例仅在初始提供方／模型路由与日志路由完全一致时恢复上次的推理强度；路由变化会丢弃由前一模型持有的不透明 ID，并单独解析新模型。
 
-插件失败会结束当前轮次，而不是结束循环。只有最终适配器分发／迭代失败，以及带内的终止错误或中止结束原因，才进入 `agent/request-error`；中间件、结果处理、工具和 `agent/post-step` 仍属于普通轮次失败。失败步骤关闭后，恢复逻辑会接收确切的实时错误、不可变的提供方事实、不可变的先前失败，以及为该请求提供服务的适配器注册所对应的不可变重试策略；如果没有最终适配器为其提供服务，则该策略缺失。重试会在新的编号步骤中根据持久日志重建；成功会清除连续失败历史；耗尽后只在 `turn/end` 上记录一次结构化失败。AgentLoop 私下拥有一个取消持有者，其显式信号覆盖提示词策略、组装、每个步骤、模型与工具工作、恢复、continuation 和终止停止；它会在发布 `turn/end` 前立即退役该持有者，而驱动器可以在持久性 flush 期间继续保持 `running`。有效的 `cancel()` 会先发出仅存在于运行时的类型化 `user | parent` 原因，再清除待处理工作，并以协作方式中止该持有者；通知失败无法 veto 取消，通知观察方排队的工作会被清除，之后由中止观察方排队的工作属于下一轮次，空闲取消则不发出任何内容。持久 `turn/end` 仍使用粗粒度的 `aborted`；未分发的模型工具调用会收到合成的 `tool/call` 与 `ABORTED_BEFORE_DISPATCH` 结果对。释放会在终止分类中胜出；忽略信号的工作必须先结算，系统才能完全停稳。[显式取消决策](../../../.agents/notes/implemented/architecture/2026-07-16-explicit-turn-cancellation.md)规定生命周期与竞态契约。终止 continuation 的停止决定在轮次关闭和持久性 flush 期间始终具有权威性。
+插件失败会结束当前轮次，而不是结束循环。只有最终适配器分发／迭代失败以及带内的终止错误或中止结束才进入 `agent/request-error`；中间件、结果处理、工具及其他扩展失败会直接关闭轮次。失败步骤关闭后，恢复逻辑会接收确切的实时错误、不可变的提供方事实、不可变的先前失败、为请求提供服务的适配器注册所对应的不可变重试策略，以及轮次信号；如果没有最终适配器为其提供服务，则该策略缺失。处理失败的监听器返回 `{ kind: 'retry' }`；循环用其错误关闭失败轮次，并在不插入空闲通知的情况下开启一个编号重试轮次。成功会清除连续失败历史；未被处理的失败是终态。AgentLoop 为当前接纳或轮次拥有一个取消信号。有效的 `cancel(cause)` 在未设置 `keepInbox` 时清除待处理工作，并以协作方式中止该信号；空闲取消是空操作。持久 `turn/end` 为 `user` 和 `parent` 记录 `aborted`，dispose（资源释放）则记录 `disposed`；未分发的模型工具调用会收到合成的 `tool/call` 与 `ABORTED_BEFORE_DISPATCH` 结果对。取消原因只改变报告方式，不改变对取消后已定案结果上下文的处理。dispose 会等待忽略信号的工作完成，然后才从注册表移除。[显式取消决策](../../../.agents/notes/implemented/architecture/2026-07-16-explicit-turn-cancellation.md)规定生命周期与竞态契约。
 
-在步骤内，独占调用形成屏障；并行安全调用使用有界滚动池，并在启动前重新分类。只有分发／主体会重叠。策略、持久结果和结果上下文仍保持模型顺序。中止会停止新调用、drain 已启动的结果，然后在轮次通过普通中止路径关闭前，drain 已接纳的批次上下文。
+在步骤内，独占调用形成屏障；并行安全调用使用有界滚动池，并在启动前重新分类。只有分发／主体会重叠。策略、持久结果和结果上下文仍保持模型顺序。中止会停止新调用，drain 已启动的结果，并保留其已定案的结果上下文，不区分取消原因。
 
 ### 插件负责的内容
 
 超出「调用模型、运行工具、重复」的所有内容，都属于监听事件分类体系的插件：
 - 钩子与策略：相关的 `agent/*` 检查点，加上受守卫保护的 `tools/pre-execute` → `tools/execute` → `tools/post-execute` → 定义拥有的 `finalizeContent` → `tools/result` 流水线；确切事件签名与 mode 位于生成的[事件目录](../../../docs/cordis-catalog/events.md)
-- 压缩（compaction）：在 `agent/post-step` 上观测压力；在 `agent/request-error` 上处理规范上下文溢出
-- 模型请求恢复：`dsh-llm-retry` 监听 `agent/request-error`，使用确切提供方的 normal 或无界策略，并发出不进入表层的 `llm/retry` 状态事件
+- 压缩（compaction）：在 `agent/step` 上观测压力；在 `agent/request-error` 上修复规范溢出
+- 模型请求恢复：`dsh-llm-retry` 在 `agent/request-error` 上记录并等待按确切提供方配置的 normal 或无界退避，发出不进入表层的 `llm/retry` 状态，然后返回重试动作
 - 沙箱、权限、计划模式：使用 `tools/pre-execute` 提供可扩展的拒绝／询问，使用 `tools.guard()` 提供单调拥有方策略，使用 `tools/post-execute` 处理结果决定，并使用 `tools/result` 进行最终观测
 - subagent：在循环外部实现为 `ctx.subagents` 提供方；进程内提供方使用 `ctx.agents.create()` 和拥有的 `AgentHandle` 进行 teardown，而通用的 [`ctx.tasks`](../../tasks/tasks/) 与 [`dsh-tool-subagent`](../../subagent/tool-subagent/) 负责后台收集。
-- 持久化：`session/event` + `session/flush`
+- 持久化：从 `session/event` 立即后写；`session/flush` 是显式观测屏障
 - UI：`session/event`（assistant token 流、边界、工具活动）+ `agent/*` 控制事件（`agent/status`、`agent/created`/`agent/disposed`）
 
 ## 模型体验
@@ -85,15 +85,15 @@ interface Config {
 
 #### 模型所见
 
-每个步骤中，循环会发送针对该 agent 呈现的系统提示词、可见工具 schema、冻结的会话前缀和会话派生消息。它提供 `model` 与 `cwd` 变量值，但不添加固定文案。
+每个步骤中，循环会发送针对该 agent 呈现的系统提示词、可见工具 schema 和会话派生消息。它提供 `provider`、`model` 与 `cwd` 变量值，但不添加固定文案。
 
 #### Token 影响
 
-每个步骤都会再次计入系统文本、schema 与前缀。逐 agent 作用域决定初始贡献，而权威组装 waterfall 可以改变最终请求，并使其监听器负责保持协议连贯。
+每个步骤都会再次计入系统文本与 schema。逐 agent 作用域决定贡献，而权威组装 waterfall（瀑布式事件）可以改变最终请求，并使其监听器负责保持协议连贯。
 
 #### KV Cache 影响
 
-只有在同一提供方和模型路由下，系统文本、schema、会话前缀与先前历史保持逐字节相同时，才保持仅追加。携带 token 的组装改写或组合变更可能从第一个改变的请求 token 起使复用失效。
+只有在同一提供方和模型路由下，系统文本、schema 与先前历史保持逐字节相同时，才保持仅追加。携带 token 的组装改写或组合变更可能从第一个改变的请求 token 起使复用失效。
 
 ### 保留的消息历史
 
@@ -103,7 +103,7 @@ interface Config {
 
 #### Token 影响
 
-输入会随每条表层消息增长，直到压缩替换遮蔽较旧节点；包含多个步骤的工具轮次会在每个步骤重新发送累积的前缀与历史。
+输入会随每条表层消息增长，直到压缩替换遮蔽较旧节点；包含多个步骤的工具轮次会在每个步骤重新发送累积的历史。
 
 #### KV Cache 影响
 
@@ -128,4 +128,4 @@ interface Config {
 - **分类是一元的**：安全性取决于比较同级调用或资源的调用必须保持独占（参见[设计原理](../../../.agents/notes/implemented/feature/2026-07-10-parallel-tool-call-execution.md)）。
 - **配置 label 默认每次新建**：省略 `sessionId` 会在每次启动时创建全新的 `${id}-session-<uuid>`；确切的恢复或创建行为要求显式提供稳定的 `sessionId`，而 `resumeSessionId` 要求已有持久化历史。
 - **配置 agent 没有逐 agent persona 字段或 setup 钩子**：它们使用部署 persona；只有编程式 `ctx.agents.create()` / `resume()` 工厂选项支持带作用域的 persona／工具组合。
-- **没有内置轮次预算**：只要步骤包含工具调用或 steering，默认 continuation 就是 `continue`；限制失控轮次需要使用 `agent/turn-continuation` 强制停止插件。
+- **没有内置轮次预算**：工具调用或 steering 会让当前轮次继续；限制失控轮次的策略必须从既有生命周期 seam（如 `agent/turn-stopping`）执行取消。

packages/core/agent-loop/src/cancellation.ts

@@ -1,31 +0,0 @@
-/** Turn-scoped cancellation ownership for the concrete AgentLoop driver. @module dsh-agent-loop/cancellation */
-
-import type { AgentCancelCause } from '@deepseek-ai/dsh-agent'
-
-/** Stable runtime-only reason used when lifecycle teardown interrupts a turn. */
-export const DISPOSED_INTERRUPT_REASON = Object.freeze({ kind: 'disposed' } as const)
-
-/**
- * Owns the single controller shared by every asynchronous boundary of one turn.
- * The first request wins because a later caller must not rewrite the cause
- * observed by earlier listeners.
- */
-export class TurnCancellation {
-  readonly #controller = new AbortController()
-
-  /** The explicit signal passed through this turn's execution boundaries. */
-  get signal(): AbortSignal {
-    return this.#controller.signal
-  }
-
-  /**
-   * Abort the turn once.
-   * @param reason - a typed caller cause or lifecycle disposal marker.
-   * @returns whether this request established the signal reason.
-   */
-  request(reason: AgentCancelCause | typeof DISPOSED_INTERRUPT_REASON): boolean {
-    if (this.signal.aborted) return false
-    this.#controller.abort(Object.freeze({ kind: reason.kind }))
-    return true
-  }
-}

packages/core/agent-loop/src/inbox.ts

@@ -1,148 +0,0 @@
-/**
- * Per-agent message inbox: queued and steering FIFOs. Purely an in-memory
- * mechanism of the loop driver — callers use `Agent`'s intent-named delivery
- * methods instead.
- *
- * @module dsh-agent-loop/inbox
- */
-
-import type { ContentBlock, MessageSource } from '@deepseek-ai/dsh-llm'
-import type { JsonValue } from '@deepseek-ai/dsh-session'
-import type { AgentMessage, AgentMessageId, HookContext } from '@deepseek-ai/dsh-agent'
-
-/** One message waiting in an agent's inbox; `id` is the value its accepting delivery method returned. */
-export interface InboxMessage {
-  id: AgentMessageId
-  content: ContentBlock[]
-  source: MessageSource
-  contexts: HookContext[]
-  /** Whether the item is marked to wake the driver or force a continuation. */
-  wakeup: boolean
-  /** Opaque durable JSON state retained on the durable message but hidden from the model. */
-  meta?: JsonValue
-}
-
-/**
- * Build the `agent/inbox/*` event payload for one inbox item.
- * @param message - the accepted inbox record.
- * @param steering - whether the item is in the steering FIFO (`next-step`).
- * @returns the live-event message for enqueue/dequeue/discard.
- */
-export function agentMessage(message: InboxMessage, steering: boolean): AgentMessage {
-  // Frozen: the fused emitter passes this exact object to every listener in
-  // turn, so one listener must not be able to mutate a field (`id`, `steering`,
-  // `content`, …) a later listener then observes. `message` is already a frozen
-  // inbox record, so its nested fields need no re-clone.
-  return Object.freeze({
-    id: message.id, content: message.content, source: message.source,
-    contexts: message.contexts, steering, wakeup: message.wakeup,
-  })
-}
-
-/**
- * Per-agent inbox: a queued FIFO (dequeued once per turn start) and a steering FIFO
- * (drained between steps of a running turn). Purely an in-memory mechanism of
- * the loop — the public surface is `Agent`'s intent-named delivery methods.
- */
-export class Inbox {
-  private queuedMessages: InboxMessage[] = []
-  private steeringMessages: InboxMessage[] = []
-  private wakeup: (() => void) | undefined
-
-  /** True while any queued message is pending — read by cancellation's discard snapshot and the turn-start dequeue guard. */
-  get hasQueued(): boolean {
-    return this.queuedMessages.length > 0
-  }
-
-  /**
-   * True while a queued message wants to wake the driver — the "should the loop
-   * run" signal read by the idle wait's fast path, the loop's idle-publish
-   * check, and `whenIdle`. A `wakeup:false` (quiet) item alone leaves this
-   * false, so the driver stays parked until a waking follow-up (or a waking item
-   * ahead of it in FIFO order) drives the loop; the quiet item then rides along.
-   */
-  get hasWakingQueued(): boolean {
-    return this.queuedMessages.some(message => message.wakeup)
-  }
-
-  /** True while steering messages are pending — read by cancellation and the loop's stop-override check. */
-  get hasSteering(): boolean {
-    return this.steeringMessages.length > 0
-  }
-
-  /**
-   * Add a message to the queued FIFO, waking a parked {@link waitForQueued}
-   * unless the item opted out. A non-waking item still runs once any woken
-   * item or later wakeup drives the parked loop.
-   * @param message - the message to queue for the next turn start.
-   * @param wake - whether to wake a parked idle wait (default true).
-   */
-  enqueue(message: InboxMessage, wake = true): void {
-    this.queuedMessages.push(message)
-    if (wake) this.wakeup?.()
-  }
-
-  /**
-   * Add a message to the steering FIFO. Deliberately no wakeup: steering is
-   * drained between steps of a running turn, never by the idle wait —
-   * `Agent.steer()` on an idle agent falls back to a waking ordinary turn instead.
-   * @param message - the message to inject between steps of the running turn.
-   */
-  steer(message: InboxMessage): void {
-    this.steeringMessages.push(message)
-  }
-
-  /**
-   * Remove the oldest queued message for one turn start.
-   * @returns the oldest message, or `undefined` when the queued FIFO is empty.
-   */
-  dequeueQueued(): InboxMessage | undefined {
-    return this.queuedMessages.shift()
-  }
-
-  /**
-   * Drain all steering messages (between steps).
-   * @returns the drained messages in arrival order; the steering FIFO is left empty.
-   */
-  drainSteering(): InboxMessage[] {
-    return this.steeringMessages.splice(0)
-  }
-
-  /**
-   * Snapshot the pending items (queued then steering, FIFO order) without
-   * removing them — the discard notification's payload source.
-   * @returns the pending items paired with whether each is steering.
-   */
-  pending(): { message: InboxMessage; steering: boolean }[] {
-    return [
-      ...this.queuedMessages.map(message => ({ message, steering: false })),
-      ...this.steeringMessages.map(message => ({ message, steering: true })),
-    ]
-  }
-
-  /**
-   * Discard all pending messages (queued + steering) without delivering them —
-   * used by `cancel()`, which drops un-started work rather than draining it into
-   * a turn. Unlike `dequeueQueued`/`drainSteering`, the messages are thrown away.
-   */
-  clear(): void {
-    this.queuedMessages.length = 0
-    this.steeringMessages.length = 0
-  }
-
-  /**
-   * Wait until a queued message arrives or `cancel` resolves.
-   * @param cancel - a promise whose resolution abandons the wait without a
-   *   message (the driver loop passes the agent's disposed promise so a parked
-   *   loop can exit).
-   */
-  waitForQueued(cancel: Promise<void>): Promise<void> {
-    if (this.hasWakingQueued) return Promise.resolve()
-    const { promise, resolve } = Promise.withResolvers<void>()
-    this.wakeup = resolve
-    void cancel.then(resolve)
-    return promise.finally(() => {
-      if (this.wakeup === resolve) this.wakeup = undefined
-    })
-  }
-}

packages/core/agent-loop/src/index.ts

@@ -8,9 +8,7 @@
 import { Context, FiberState, Service } from 'cordis'
 import { randomUUID } from 'node:crypto'
 import z from 'schemastery'
-import { createScope } from '@deepseek-ai/dsh-scope'
-import type { Scope } from '@deepseek-ai/dsh-scope'
-import { agentEvents } from '@deepseek-ai/dsh-agent'
+import { emitAgentEvent } from '@deepseek-ai/dsh-agent'
 import type {
   Agent,
   AgentFactory,
@@ -26,12 +24,7 @@ import type { Session, SessionHeader } from '@deepseek-ai/dsh-session'
 import type {} from '@deepseek-ai/dsh-system-prompt'
 import type {} from '@deepseek-ai/dsh-tools'
 import type { SessionPersistence } from '@deepseek-ai/dsh-session-persistence'
-import {
-  bindReactLoopAgentContext,
-  prepareReactLoopAgent,
-  ReactLoopAgent,
-} from './agent.ts'
-import type { PreparedReactLoopAgent } from './agent.ts'
+import { ReactLoopAgent } from './agent.ts'
 import { DEFAULT_MAX_PARALLEL_TOOL_CALLS } from './constants.ts'
 
 /** Fiber states that cannot own or serve a new lifecycle. */
@@ -41,31 +34,43 @@ const INACTIVE_STATES: ReadonlySet<FiberState> = new Set([
   FiberState.FAILED,
 ])
 
-/** Factory-level ownership of every preparing or live transaction. */
+/** Factory-level ownership: live agent teardowns plus config startup work. */
 class FactoryOwnership {
   private accepting = true
+  private readonly teardown = new AbortController()
   private readonly inactive = Promise.withResolvers<void>()
-  private transactions = new Set<AgentCreationTransaction>()
+  private readonly liveAgents = new Set<() => Promise<void>>()
   private startupTasks = new Set<Promise<void>>()
 
   constructor(private readonly fiber: Context['fiber']) {}
 
+  /** Aborts (reason: `agent loop is not active` error) when factory teardown begins. */
+  get signal(): AbortSignal {
+    return this.teardown.signal
+  }
+
   isActive(): boolean {
     return this.accepting && !INACTIVE_STATES.has(this.fiber.state)
   }
 
-  track(transaction: AgentCreationTransaction): () => void {
-    this.transactions.add(transaction)
-    return () => { this.transactions.delete(transaction) }
+  /** Track one live agent's shared teardown until it has run. */
+  track(dispose: () => Promise<void>): () => void {
+    this.liveAgents.add(dispose)
+    return () => { this.liveAgents.delete(dispose) }
   }
 
-  /** Join config startup work that begins before an agent transaction exists. */
+  /** Join config startup work that begins before an agent exists. */
   trackStartup(task: Promise<void>): void {
     this.startupTasks.add(task)
     const forget = () => { this.startupTasks.delete(task) }
     void task.then(forget, forget)
   }
 
+  /** Join one public create/resume continuation; factory dispose awaits its settlement. */
+  trackWrapper(task: Promise<unknown>): void {
+    this.trackStartup(task.then(() => undefined, () => undefined))
+  }
+
   /** Resolve `task`, or stop waiting when factory teardown begins. */
   async waitWhileActive(task: Promise<void>): Promise<void> {
     await Promise.race([task, this.inactive.promise])
@@ -73,19 +78,29 @@ class FactoryOwnership {
 
   async dispose(): Promise<void> {
     this.accepting = false
+    this.teardown.abort(new Error('agent loop is not active'))
     this.inactive.resolve()
-    const reason = new Error('agent loop is not active')
     await Promise.all([
-      ...[...this.transactions].map(transaction => transaction.disposeForFactory(reason)),
+      ...[...this.liveAgents].map(dispose => dispose()),
       ...this.startupTasks,
     ])
   }
 }
 
-/** Build the public cancellation error while preserving a caller-supplied cause. */
-function signalAbortError(id: SessionId, signal: AbortSignal): Error {
-  if (signal.reason instanceof Error) return signal.reason
-  return new Error(`agent "${id}" creation aborted`, { cause: signal.reason })
+/** Await `operation`, or throw the signal's reason as soon as it aborts. */
+async function raceAbort<T>(operation: PromiseLike<T> | T, signal: AbortSignal, id: SessionId): Promise<T> {
+  const toAbortError = (): Error => signal.reason instanceof Error
+    ? signal.reason
+    : new Error(`agent "${id}" creation aborted`, { cause: signal.reason })
+  if (signal.aborted) throw toAbortError()
+  const aborted = Promise.withResolvers<never>()
+  const listener = (): void => { aborted.reject(toAbortError()) }
+  signal.addEventListener('abort', listener, { once: true })
+  try {
+    return await Promise.race([Promise.resolve(operation), aborted.promise])
+  } finally {
+    signal.removeEventListener('abort', listener)
+  }
 }
 
 /** Resolve the deployment-wide scheduler cap at the owning config boundary. */
@@ -97,243 +112,15 @@ function resolveMaxParallelToolCalls(value: number | undefined): number {
   return maxParallelToolCalls
 }
 
-/**
- * Caller-owned create/resume transaction through rollback-covered publication
- * and quiescent teardown. Resources remain private until the final registry
- * entry arbitrates identity.
- */
-class AgentCreationTransaction {
-  private active = true
-  private failure: Error | undefined
-  private readonly deactivation = Promise.withResolvers<void>()
-  private readonly publication = Promise.withResolvers<void>()
-  private readonly torndown = Promise.withResolvers<void>()
-  private readonly wrapperCompletion = Promise.withResolvers<void>()
-  private preparing: Promise<void> | undefined
-  private driver: PreparedReactLoopAgent | undefined
-  private scope: Scope | undefined
-  private session: Session | undefined
-  private lifecycleDispose: (() => Promise<void> | void) | undefined
-  private detachSession: (() => void) | undefined
-  private detachAgent: (() => void) | undefined
-  private publishing = false
-  private cleanupTask: Promise<void> | undefined
-  private ownerFollowing = true
-  private readonly ownerDispose: () => Promise<void> | void
-  private readonly untrackFactory: () => void
-  private readonly abortListener: (() => void) | undefined
-  readonly ownerAgent: Context['agent']
-  readonly ownerFiber: Context['fiber']
-
-  constructor(
-    private readonly loopCtx: Context,
-    private readonly ownerCtx: Context,
-    private readonly ownership: FactoryOwnership,
-    readonly id: SessionId,
-    signal?: AbortSignal,
-  ) {
-    ownerCtx.fiber.assertActive()
-    this.ownerAgent = ownerCtx.agent
-    this.ownerFiber = ownerCtx.fiber
-    if (!ownership.isActive()) throw new Error('agent loop is not active')
-    this.ownerDispose = ownerCtx.effect(() => () => {
-      if (!this.ownerFollowing) return
-      return this.dispose(new Error(`agent "${id}" setup aborted: owner disposed during setup`))
-    }, `agentLoop.owner(${id})`)
-    this.untrackFactory = ownership.track(this)
-    if (signal === undefined) {
-      this.abortListener = undefined
-    } else {
-      this.abortListener = () => {
-        /* v8 ignore next 3 -- transaction teardown contains callback/driver failures; rejection is a future-drift backstop. */
-        void this.dispose(signalAbortError(id, signal)).catch((error: unknown) => {
-          this.loopCtx.logger.error(error)
-        })
-      }
-      signal.addEventListener('abort', this.abortListener, { once: true })
-      if (signal.aborted) this.deactivate(signalAbortError(id, signal))
-    }
-    this.signal = signal
-  }
-
-  private readonly signal: AbortSignal | undefined
-
-  /** Whether caller, provider, and optional parent-agent ownership remain live. */
-  isActive(): boolean {
-    return this.active
-      && this.ownership.isActive()
-      && this.ownerFiber.uid !== null
-      && !INACTIVE_STATES.has(this.ownerFiber.state)
-      && this.ownerAgent?.status !== 'disposed'
-  }
-
-  /** Fail synchronously at every real lifecycle boundary after deactivation. */
-  assertActive(): void {
-    if (this.isActive()) return
-    if (!this.ownership.isActive()) throw new Error('agent loop is not active')
-    throw this.failure ?? new Error(`agent "${this.id}" setup aborted: owner disposed during setup`)
-  }
-
-  /** Race an external async operation against structural/signal deactivation. */
-  async waitFor<T>(operation: PromiseLike<T> | T): Promise<T> {
-    this.assertActive()
-    return await Promise.race([
-      Promise.resolve(operation),
-      this.deactivation.promise.then(() => {
-        /* v8 ignore next -- deactivate() assigns failure before resolving deactivation. */
-        throw this.failure ?? new Error(`agent "${this.id}" creation deactivated`)
-      }),
-    ])
-  }
-
-  /** Construct the driver and scope, then install their complete ordered lifecycle. */
-  prepare(options: AgentOptions, session: Session, maxParallelToolCalls: number): ReactLoopAgent {
-    this.assertActive()
-    const gate = Promise.withResolvers<void>()
-    this.preparing = gate.promise
-    try {
-      this.session = session
-      const driver = prepareReactLoopAgent(this.loopCtx, this.id, options, session, maxParallelToolCalls)
-      this.driver = driver
-      const agent = driver.agent
-      const scope = createScope(this.loopCtx, agent)
-      this.scope = scope
-      bindReactLoopAgentContext(agent, scope.ctx.extend({ agent }))
-      this.installLifecycle(scope, driver)
-      this.assertActive()
-      return agent
-    } catch (error: unknown) {
-      if (!this.isActive() && error instanceof Error && /inactive context/.test(error.message)) {
-        throw this.failure ?? this.disposalReason()
-      }
-      throw error
-    } finally {
-      gate.resolve()
-      this.preparing = undefined
-    }
-  }
-
-  /** Register the exact scope disposer inside the ordered transaction effect. */
-  private installLifecycle(scope: Scope, driver: PreparedReactLoopAgent): void {
-    this.lifecycleDispose = this.ownerCtx.effect(function* (this: AgentCreationTransaction) {
-      // First yielded, disposed last.
-      yield () => { this.finish() }
-      yield scope.rawDispose
-      yield () => {
-        this.detachSession?.()
-        this.detachSession = undefined
-      }
-      yield () => {
-        this.detachAgent?.()
-        this.detachAgent = undefined
-      }
-      // Last yielded, disposed first.
-      yield () => {
-        this.deactivate(this.disposalReason())
-        if (this.publishing) {
-          return this.publication.promise.then(() => driver.dispose())
-        }
-        return driver.dispose()
-      }
-    }.bind(this), `agentLoop.lifecycle(${this.id})`)
-  }
-
-  /** Publish the exact prepared objects and start the driver. */
-  publish(source: SessionStartSource): AgentHandle {
-    this.assertActive()
-    const driver = this.driver
-    /* v8 ignore next -- publish() is private and every caller invokes prepare() first. */
-    if (driver === undefined) throw new Error(`agent "${this.id}" is not prepared`)
-    const agent = driver.agent
-    const session = this.session
-    /* v8 ignore next -- prepare() assigns the session before it can produce the driver above. */
-    if (session === undefined) throw new Error(`agent "${this.id}" has no prepared session`)
-    this.publishing = true
-    try {
-      this.detachSession = agent.ctx.sessions.enter(session)
-      this.detachAgent = this.loopCtx.agents.enter(agent, this.ownerAgent)
-
-      agent.ctx.sessions.announce(session)
-      this.assertActive()
-      this.loopCtx.agents.announce(agent)
-      this.assertActive()
-
-      driver.markPublished()
-      agentEvents(this.loopCtx, agent).emit('agent/session-start', source)
-      this.assertActive()
-      driver.startDriver()
-      return { agent, dispose: () => this.dispose() }
-    } finally {
-      this.publishing = false
-      this.publication.resolve()
-    }
-  }
-
-  /** Mark the transaction inactive exactly once and wake load/setup races. */
-  private deactivate(reason: Error): void {
-    if (!this.active) return
-    this.active = false
-    this.failure = reason
-    this.deactivation.resolve()
-  }
-
-  /** Choose the structural cause when an owner/factory effect starts teardown first. */
-  private disposalReason(): Error {
-    if (this.failure !== undefined) return this.failure
-    if (!this.ownership.isActive()) return new Error('agent loop is not active')
-    if (this.ownerFiber.uid === null || INACTIVE_STATES.has(this.ownerFiber.state) || this.ownerAgent?.status === 'disposed') {
-      return new Error(`agent "${this.id}" setup aborted: owner disposed during setup`)
-    }
-    return new Error(`agent "${this.id}" lifecycle disposed`)
-  }
-
-  /** Complete ownership bookkeeping after every resource reached quiescence. */
-  private finish(): void {
-    this.untrackFactory()
-    this.ownerFollowing = false
-    void this.ownerDispose()
-    this.torndown.resolve()
-  }
-
-  /**
-   * Deactivate and quiesce this transaction. The promise is memoized because
-   * Cordis effect disposers are single-shot while handles promise shared
-   * quiescence to every racing owner.
-   */
-  dispose(reason = new Error(`agent "${this.id}" lifecycle disposed`)): Promise<void> {
-    this.deactivate(reason)
-    return (this.cleanupTask ??= (async () => {
-      if (this.preparing !== undefined) await this.preparing
-      if (this.lifecycleDispose !== undefined) {
-        await this.lifecycleDispose()
-        await this.torndown.promise
-        return
-      }
-      try {
-        await this.driver?.dispose()
-      } finally {
-        try {
-          await this.scope?.dispose()
-        } finally {
-          this.finish()
-        }
-      }
-    })())
-  }
-
-  /** Mark the public create/resume continuation settled and detach its creation-only signal. */
-  finishWrapper(): void {
-    if (this.signal !== undefined && this.abortListener !== undefined) {
-      this.signal.removeEventListener('abort', this.abortListener)
-    }
-    this.wrapperCompletion.resolve()
-  }
-
-  /** Factory shutdown joins both resource teardown and the public wrapper's deactivation continuation. */
-  async disposeForFactory(reason: Error): Promise<void> {
-    await this.dispose(reason)
-    await this.wrapperCompletion.promise
-  }
+/** Prepared-but-unpublished agent resources sharing one memoized teardown. */
+interface PreparedAgent {
+  agent: ReactLoopAgent
+  /** Aborts when the factory unloads, the caller cancels, or teardown begins — ends any setup await. */
+  signal: AbortSignal
+  /** Enter registries, announce, notify session-start, and start the machine. */
+  publish(source: SessionStartSource): AgentHandle
+  /** Reverse teardown: stop the machine, unregister, unwind the scope. Memoized. */
+  dispose(): Promise<void>
 }
 
 declare module 'cordis' {
@@ -376,6 +163,9 @@ export interface Config {
   })[]
 }
 
+/** Agent-loop configuration after defaults and load-time validation. */
+type ResolvedConfig = Config & { maxParallelToolCalls: number }
+
 /** Reject self-contained identity conflicts before any configured agent starts. */
 function validateConfiguredAgents(agents: Config['agents']): void {
   const exactIdentities = new Map<SessionId, string>()
@@ -409,18 +199,21 @@ export class AgentLoop extends Service implements AgentFactory {
       cwd: z.string(),
       resumeSessionId: z.string(),
     })).default([]),
-  }) as unknown as z<Config>
+  }) as z<Config>
 
+  /** Validated configuration owned by the agent-loop service. */
+  readonly config: ResolvedConfig
   private readonly ownership: FactoryOwnership
-  /** Resolved concurrency cap for every driver created by this factory. */
-  private readonly maxParallelToolCalls: number
   /** Plain holder prevents Cordis from re-tracing the factory's dependency context through a caller shadow. */
   private readonly runtime: { ctx: Context }
 
-  constructor(ctx: Context, public config: Config) {
+  constructor(ctx: Context, config: Config) {
     super(ctx, 'agentLoop')
-    validateConfiguredAgents(config.agents)
-    this.maxParallelToolCalls = resolveMaxParallelToolCalls(config.maxParallelToolCalls)
+    this.config = {
+      ...config,
+      maxParallelToolCalls: resolveMaxParallelToolCalls(config.maxParallelToolCalls),
+    }
+    validateConfiguredAgents(this.config.agents)
     this.ownership = new FactoryOwnership(ctx.fiber)
     this.runtime = { ctx }
     ctx.effect(() => () => this.ownership.dispose(), 'agentLoop.transactions()')
@@ -429,7 +222,7 @@ export class AgentLoop extends Service implements AgentFactory {
     ctx.systemPrompt.variable('model', context => context.agent?.options.model)
     ctx.systemPrompt.variable('cwd', context => context.agent?.session.header.cwd)
 
-    for (const { id, sessionId, cwd, resumeSessionId, ...options } of config.agents) {
+    for (const { id, sessionId, cwd, resumeSessionId, ...options } of this.config.agents) {
       const meta = cwd === undefined ? {} : { cwd }
       if (resumeSessionId === undefined || resumeSessionId === '') {
         const configuredId = sessionId ?? SessionId(`${id}-session-${randomUUID()}`)
@@ -490,19 +283,25 @@ export class AgentLoop extends Service implements AgentFactory {
   ): Promise<void> {
     await this.waitForDrainingConfiguredIdentity(ownerCtx, sessionId)
     if (!this.ownership.isActive()) return
-    const exists = (await persistence.list()).some(header => header.id === sessionId)
-    if (!this.ownership.isActive()) return
-    if (exists) {
+    try {
       await this.resumeWith(ownerCtx, persistence, { resumeSessionId: sessionId, agentOptions })
       return
+    } catch (error: unknown) {
+      if (!this.ownership.isActive()) return
+      // A load is the per-id serialization barrier for eager write-behind and
+      // lifecycle retirement. Only a genuinely absent artifact falls back to
+      // first creation; corruption and backend failures stay loud.
+      const exists = (await persistence.list()).some(header => header.id === sessionId)
+      if (exists) throw error
     }
     this.create(sessionId, agentOptions, meta)
   }
 
-  /** Wait for an already-disposed same-id lifecycle to finish registry teardown. */
+  /** Wait for a draining same-id lifecycle to finish registry teardown. */
   private async waitForDrainingConfiguredIdentity(ownerCtx: Context, sessionId: SessionId): Promise<void> {
-    const current = ownerCtx.agents.get(sessionId)
-    if (current?.status !== 'disposed') return
+    // Only an id still occupying a registry needs waiting for; a live healthy
+    // occupant is a collision the create/resume below will surface itself.
+    if (ownerCtx.agents.get(sessionId) === undefined && ownerCtx.sessions.get(sessionId) === undefined) return
 
     const released = Promise.withResolvers<void>()
     const checkReleased = (): void => {
@@ -521,6 +320,143 @@ export class AgentLoop extends Service implements AgentFactory {
     }
   }
 
+  /**
+   * Construct the driver, scope, and one memoized reverse teardown for a new
+   * agent. The teardown is registered with the factory and the owner fiber
+   * BEFORE publication, so a mid-setup unload rolls everything back; `signal`
+   * fuses caller cancellation with lifecycle teardown for setup awaits.
+   */
+  private prepare(ownerCtx: Context, id: SessionId, options: AgentOptions, session: Session, callerSignal?: AbortSignal): PreparedAgent {
+    ownerCtx.fiber.assertActive()
+    // Every caller reaches prepare() synchronously from a service method
+    // whose Cordis dispatch already requires the live factory fiber, or
+    // re-checks ownership itself after its awaits (resume's load barrier).
+    /* v8 ignore next -- unreachable backstop, see above */
+    if (!this.ownership.isActive()) throw new Error('agent loop is not active')
+    if (callerSignal?.aborted) {
+      throw callerSignal.reason instanceof Error
+        ? callerSignal.reason
+        : new Error(`agent "${id}" creation aborted`, { cause: callerSignal.reason })
+    }
+    const loopCtx = this.runtime.ctx
+
+    // Deactivation fuses three owners, each with its own reason: the caller's
+    // cancellation signal, the owner fiber's unload, and factory teardown.
+    // It is registered BEFORE any resource exists, over mutable slots, so an
+    // unload arriving while the scope is still minting finds a working
+    // disposer instead of a leak.
+    const abort = new AbortController()
+    const onCallerAbort = (): void => {
+      abort.abort(callerSignal?.reason instanceof Error
+        ? callerSignal.reason
+        : new Error(`agent "${id}" creation aborted`, { cause: callerSignal?.reason }))
+    }
+    const onFactoryTeardown = (): void => { abort.abort(this.ownership.signal.reason) }
+    callerSignal?.addEventListener('abort', onCallerAbort, { once: true })
+    this.ownership.signal.addEventListener('abort', onFactoryTeardown, { once: true })
+
+    let machine: ReactLoopAgent | undefined
+    let detachSession: (() => void) | undefined
+    let detachAgent: (() => void) | undefined
+    let disposing: Promise<void> | undefined
+    const machineReady = Promise.withResolvers<void>()
+    // Reverse teardown, memoized so every racing owner awaits one quiescence:
+    // stop the machine, leave the registries, unwind the scope, release
+    // bookkeeping.
+    const dispose = (ownerTriggered = false): Promise<void> => (disposing ??= (async () => {
+      abort.abort(new Error(`agent "${id}" lifecycle disposed`))
+      callerSignal?.removeEventListener('abort', onCallerAbort)
+      this.ownership.signal.removeEventListener('abort', onFactoryTeardown)
+      try {
+        // Disposal IS a disposed-cause cancel followed by quiescence. New work
+        // sent after this point is the sender's bug — the registries are about
+        // to drop the agent, so nothing should still hold it.
+        if (machine === undefined) await machineReady.promise
+        if (machine !== undefined) {
+          machine.cancel({ kind: 'disposed' })
+          // Drain to TRUE quiescence: cancel's own synchronous event chain
+          // (running→idle) can legitimately re-enter through an automation
+          // listener (goal-session's idle drive) and replace `done` with a
+          // fresh admission before this await captures it. The replacement
+          // work is cancelled and drained in turn until the slot stabilizes.
+          let done = machine.done
+          while (true) {
+            await Promise.allSettled([done])
+            if (machine.done === done) break
+            done = machine.done
+            machine.cancel({ kind: 'disposed' })
+          }
+          await machine.scope.dispose()
+        }
+      } finally {
+        try {
+          detachAgent?.()
+          detachSession?.()
+        } finally {
+          untrack()
+          if (!ownerTriggered) await unfollowOwner()
+        }
+      }
+    })())
+    const untrack = this.ownership.track(dispose)
+    let unfollowOwner: () => Promise<void> | void
+    try {
+      unfollowOwner = ownerCtx.effect(() => () => {
+        // Owner disposal owns the same quiescence boundary. Its teardown skips
+        // unregistering this already-running owner effect from inside itself.
+        if (disposing !== undefined) return
+        abort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`))
+        return dispose(true)
+      }, `agentLoop.lifecycle(${id})`)
+      /* v8 ignore start -- ctx.effect throws only on an inactive fiber, which assertActive() above already rejected */
+    } catch (error: unknown) {
+      untrack()
+      callerSignal?.removeEventListener('abort', onCallerAbort)
+      this.ownership.signal.removeEventListener('abort', onFactoryTeardown)
+      throw error
+    }
+    /* v8 ignore stop */
+
+    const assertLive = (): void => {
+      if (!abort.signal.aborted) return
+      // Every fused abort source carries an Error reason: onCallerAbort and
+      // raceAbort wrap non-Error caller reasons, and the factory/lifecycle
+      // owners abort with constructed Errors.
+      /* v8 ignore next -- unreachable String() arm, see above */
+      throw abort.signal.reason instanceof Error ? abort.signal.reason : new Error(String(abort.signal.reason))
+    }
+    try {
+      const agent = machine = new ReactLoopAgent(loopCtx, id, options, session)
+      machineReady.resolve()
+      assertLive()
+
+      return {
+        agent,
+        signal: abort.signal,
+        publish: (source) => {
+          assertLive()
+          detachSession = agent.ctx.sessions.enter(session)
+          detachAgent = loopCtx.agents.enter(agent, ownerCtx.agent)
+          agent.ctx.sessions.announce(session)
+          assertLive()
+          loopCtx.agents.announce(agent)
+          assertLive()
+          // A synchronous announce/session-start listener may have started
+          // teardown; the machine is already live (send() works from the
+          // session-start seam), so only the liveness recheck is owed.
+          emitAgentEvent(loopCtx, agent, 'agent/session-start', source)
+          assertLive()
+          return { agent, dispose }
+        },
+        dispose,
+      }
+    } catch (error: unknown) {
+      machineReady.resolve()
+      void dispose()
+      throw error
+    }
+  }
+
   /**
    * Create an agent and session under one caller-supplied identity, owned by
    * the accessing fiber. Constructor-driven config calls mint a fresh combined
@@ -531,51 +467,39 @@ export class AgentLoop extends Service implements AgentFactory {
    * @returns the published running agent.
    */
   create(id: SessionId, options: AgentOptions = {}, meta: Pick<SessionHeader, 'cwd'> = {}): Agent {
-    const loopCtx = this.runtime.ctx
-    const transaction = new AgentCreationTransaction(loopCtx, this.ctx, this.ownership, id)
+    const session = this.runtime.ctx.sessions.prepare(id, { meta })
+    const prepared = this.prepare(this.ctx, id, options, session)
     try {
-      const session = loopCtx.sessions.prepare(id, { meta })
-      const agent = transaction.prepare(options, session, this.maxParallelToolCalls)
-      transaction.publish('startup')
-      return agent
+      return prepared.publish('startup').agent
     } catch (error: unknown) {
-      void transaction.dispose(error instanceof Error ? error : new Error(String(error)))
+      void prepared.dispose()
       throw error
-    } finally {
-      transaction.finishWrapper()
     }
   }
 
   /**
    * Create an owned agent on a caller-supplied session id.
-   * @param ownerCtx - caller context that structurally owns the transaction.
+   * @param ownerCtx - caller context that structurally owns the lifecycle.
    * @param options - identities, session seed/metadata, loop options, setup, and cancellation.
    * @returns the published handle.
    */
   async createAgent(ownerCtx: Context, options: CreateAgentOptions): Promise<AgentHandle> {
-    const agentOptions = options.agentOptions ?? {}
-    const transaction = new AgentCreationTransaction(
-      this.runtime.ctx,
-      ownerCtx,
-      this.ownership,
-      options.sessionId,
-      options.signal,
-    )
-    try {
-      const session = this.runtime.ctx.sessions.prepare(options.sessionId, {
-        ...options.seed === undefined ? {} : { seed: options.seed },
-        ...options.meta === undefined ? {} : { meta: options.meta },
-      })
-      const agent = transaction.prepare(agentOptions, session, this.maxParallelToolCalls)
-      await transaction.waitFor(options.setup?.(agent.ctx))
-      transaction.assertActive()
-      return transaction.publish('startup')
-    } catch (error: unknown) {
-      await transaction.dispose(error instanceof Error ? error : new Error(String(error)))
-      throw error
-    } finally {
-      transaction.finishWrapper()
-    }
+    const session = this.runtime.ctx.sessions.prepare(options.sessionId, {
+      ...options.seed === undefined ? {} : { seed: options.seed },
+      ...options.meta === undefined ? {} : { meta: options.meta },
+    })
+    const prepared = this.prepare(ownerCtx, options.sessionId, options.agentOptions ?? {}, session, options.signal)
+    const published = (async () => {
+      try {
+        await raceAbort(options.setup?.(prepared.agent.ctx), prepared.signal, options.sessionId)
+        return prepared.publish('startup')
+      } catch (error: unknown) {
+        await prepared.dispose()
+        throw error
+      }
+    })()
+    this.ownership.trackWrapper(published)
+    return published
   }
 
   /**
@@ -593,36 +517,48 @@ export class AgentLoop extends Service implements AgentFactory {
   }
 
   /** Resume through an explicit persistence handle used by the deferred config path. */
-  private async resumeWith(
+  private resumeWith(
     ownerCtx: Context,
     persistence: SessionPersistence,
     options: ResumeAgentOptions,
   ): Promise<AgentHandle> {
-    const agentOptions = options.agentOptions ?? {}
-    const transaction = new AgentCreationTransaction(
-      this.runtime.ctx,
-      ownerCtx,
-      this.ownership,
-      options.resumeSessionId,
-      options.signal,
-    )
-    try {
-      const loaded = await transaction.waitFor(persistence.load(options.resumeSessionId))
-      transaction.assertActive()
-      const session = this.runtime.ctx.sessions.prepare(options.resumeSessionId, {
+    const id = options.resumeSessionId
+    const published = (async () => {
+      // The load may outlive its owner: race it against caller cancellation,
+      // owner-fiber unload, and factory teardown so a never-settling backend
+      // cannot pin the identity.
+      const ownerAbort = new AbortController()
+      const unfollowOwner = ownerCtx.effect(() => () => {
+        ownerAbort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`))
+      }, `agentLoop.resume-load(${id})`)
+      const fused = AbortSignal.any([
+        ...options.signal === undefined ? [] : [options.signal],
+        ownerAbort.signal,
+        this.ownership.signal,
+      ])
+      let loaded: Awaited<ReturnType<SessionPersistence['load']>>
+      try {
+        loaded = await raceAbort(persistence.load(id), fused, id)
+      } finally {
+        await unfollowOwner()
+      }
+      ownerCtx.fiber.assertActive()
+      if (!this.ownership.isActive()) throw new Error('agent loop is not active')
+      const session = this.runtime.ctx.sessions.prepare(id, {
         seed: loaded.events,
         meta: loaded.meta,
       })
-      const agent = transaction.prepare(agentOptions, session, this.maxParallelToolCalls)
-      await transaction.waitFor(options.setup?.(agent.ctx))
-      transaction.assertActive()
-      return transaction.publish('resume')
-    } catch (error: unknown) {
-      await transaction.dispose(error instanceof Error ? error : new Error(String(error)))
-      throw error
-    } finally {
-      transaction.finishWrapper()
-    }
+      const prepared = this.prepare(ownerCtx, id, options.agentOptions ?? {}, session, options.signal)
+      try {
+        await raceAbort(options.setup?.(prepared.agent.ctx), prepared.signal, id)
+        return prepared.publish('resume')
+      } catch (error: unknown) {
+        await prepared.dispose()
+        throw error
+      }
+    })()
+    this.ownership.trackWrapper(published)
+    return published
   }
 }
 

packages/core/agent-loop/src/invariant.ts

@@ -48,7 +48,7 @@ const install: InvariantInstaller = Object.assign((ctx: Context, fail: Invariant
       SessionId(`${String(session.id)}-invariant-rebuild`),
       structuredClone(events.slice(0, boundary)),
     )
-    const expected = [...header.messagePrefix ?? [], ...rebuilt.deriveMessages()]
+    const expected = rebuilt.deriveMessages()
     if (JSON.stringify(options.messages) !== JSON.stringify(expected)) {
       fail(`llm request for session "${String(session.id)}" diverges from the boundary derivation (log-reconstruction desync)`)
     }

packages/core/agent-loop/src/loop.ts

@@ -1,863 +0,0 @@
-/**
- * Drives one agent across queued durable turns. Turn failures are contained so
- * later work can run; the session log, not this driver, owns conversation state.
- * See .agents/notes/implemented/architecture/2026-06-18-agent-lifecycle-and-ownership-seams.md.
- * @module dsh-agent-loop/loop
- */
-
-import { randomUUID } from 'node:crypto'
-import type { Context } from 'cordis'
-import type { ContentBlock, FinishReason, GenerateOptions, LlmCallConfig, LlmFailure, Message, PreparedLlmCall, ResolvedRetryPolicy } from '@deepseek-ai/dsh-llm'
-import { isDeepStrictEqual } from 'node:util'
-import { BlockAssembler, HarnessError, LlmError, assertNever, deepFreeze, errorChain, llmFailureOf, llmRetryPolicyOf, markAgentLoopRequest } from '@deepseek-ai/dsh-llm'
-import { agentEvents, agentInterruptReasonOf, assembleContextFor, AgentMessageId } from '@deepseek-ai/dsh-agent'
-import type { AgentEventDispatch, ContinuationDecision, HookContext, PromptDecision, RequestError, RequestErrorDecision } from '@deepseek-ai/dsh-agent'
-import { canonicalHeader } from '@deepseek-ai/dsh-session'
-import type { PromptMessageData, Session, TurnEndReason, TurnTrigger } from '@deepseek-ai/dsh-session'
-import { createTransmissionLog, recordRequestHeader } from './request-log.ts'
-import type { TransmissionLog } from './request-log.ts'
-import { renderPrompt } from '@deepseek-ai/dsh-system-prompt'
-import type { PromptAssembly } from '@deepseek-ai/dsh-system-prompt'
-import type {} from '@deepseek-ai/dsh-tools'
-import { executeToolCalls } from './tool-calls.ts'
-import { agentMessage, type Inbox, type InboxMessage } from './inbox.ts'
-import type { TurnCancellation } from './cancellation.ts'
-
-/** Normalize thrown values while preserving an existing error code. */
-function toError(error: unknown): RequestError {
-  return error instanceof Error ? error : new HarnessError(String(error), 'UNKNOWN', { cause: error })
-}
-
-/** Distinguishes final model-request failures from failures in later step processing. */
-class TerminalModelRequestFailure extends Error {
-  constructor(
-    readonly requestError: RequestError,
-    readonly failure: LlmFailure,
-    readonly retryPolicy: ResolvedRetryPolicy | undefined,
-  ) {
-    super(failure.message, { cause: requestError })
-    this.name = 'TerminalModelRequestFailure'
-  }
-}
-
-/** Convert terminal failure finishes into step errors; unknown extensible finishes remain successful. */
-function finishError(finish: FinishReason): { error: RequestError; failure: LlmFailure } | undefined {
-  switch (finish.kind) {
-    case 'error':
-    case 'aborted': {
-      const facts = finish.failure
-      const error = new LlmError(facts.message, facts.code, {
-        ...facts.status === undefined ? {} : { status: facts.status },
-        ...facts.providerRetryAfterMs === undefined
-          ? {}
-          : { providerRetryAfterMs: facts.providerRetryAfterMs },
-        ...facts.requestId === undefined ? {} : { requestId: facts.requestId },
-      })
-      return { error, failure: error.failure }
-    }
-    // stop / tool-calls / max-tokens / plugin-added kinds → not a failure.
-    default:
-      return undefined
-  }
-}
-
-/**
- * Build the `{ message, code? }` part of an error payload, omitting the
- * `code` key entirely when absent (exactOptionalPropertyTypes-correct).
- * The durable message renders the full cause chain: `turn/end` is the single
- * durable record of an in-turn failure, so a wrapper message alone (e.g.
- * `fetch failed`) would lose the diagnosis the session log exists to keep.
- */
-function errorData(err: RequestError): { message: string; code?: string } {
-  return { message: errorChain(err), ...typeof err.code === 'string' ? { code: err.code } : {} }
-}
-
-/** Preserve cause diagnostics, falling back to adapter-normalized prose for a hostile Error. */
-function durableFailure(err: RequestError, failure: LlmFailure): LlmFailure {
-  const message = errorChain(err)
-  return { ...failure, message: message === '<unrenderable value>' ? failure.message : message }
-}
-
-/** Map a successful max-token finish onto the turn reason; other successful finishes add nothing. */
-function stepFinishReason(finish: FinishReason): TurnEndReason | undefined {
-  switch (finish.kind) {
-    case 'max-tokens':
-      return { kind: 'max-tokens' }
-    // stop / tool-calls / plugin-added kinds → no turn-end contribution
-    // beyond the default `completed`. FinishReason is merge-extensible, so a
-    // default (not assertNever) handles unknown kinds as ordinary success.
-    default:
-      return undefined
-  }
-}
-
-/** Internal control-flow sentinel; durable classification comes only from the turn signal. */
-const TURN_INTERRUPTED = new Error('turn interrupted')
-
-const PROMPT_PREFIX_REQUEST_DELIMITER: ContentBlock = {
-  type: 'text',
-  text: '\n\n## My request:\n',
-}
-
-interface PreparedPromptMessage {
-  data: PromptMessageData
-  separateContexts: HookContext[]
-}
-
-/** Bake declared prefix contexts into one reconstructable prompt message. */
-function preparePromptMessage(
-  content: ContentBlock[],
-  source: PromptMessageData['source'],
-  contexts: readonly HookContext[],
-): PreparedPromptMessage {
-  const prefixContexts = contexts.filter(context => context.placement === 'prompt-prefix')
-  const separateContexts = contexts.filter(context => context.placement !== 'prompt-prefix')
-  if (prefixContexts.length === 0) return { data: { content, source }, separateContexts }
-  return {
-    data: {
-      content: [
-        ...prefixContexts.flatMap(context => context.content),
-        PROMPT_PREFIX_REQUEST_DELIMITER,
-        ...content,
-      ],
-      source,
-      envelope: {
-        displayContent: content,
-        prefixContexts: prefixContexts.map(context => ({
-          source: context.source,
-          ...context.meta === undefined ? {} : { meta: context.meta },
-        })),
-      },
-    },
-    separateContexts,
-  }
-}
-
-/** Stop at an explicit cooperative boundary without stringifying the runtime reason. */
-function interruptionCheckpoint(signal: AbortSignal): void {
-  if (signal.aborted) throw TURN_INTERRUPTED
-}
-
-/** Classify a supported turn interruption, with lifecycle disposal taking precedence. */
-function interruptionTurnEndReason(handle: LoopHandle, signal: AbortSignal): TurnEndReason | undefined {
-  if (handle.isDisposed()) return { kind: 'disposed' }
-  const reason = agentInterruptReasonOf(signal)
-  if (reason === undefined) return undefined
-  switch (reason.kind) {
-    case 'user':
-    case 'parent':
-      return { kind: 'aborted' }
-    /* v8 ignore next 2 -- the private holder requests disposed only after lifecycle state flips, which returns above. */
-    case 'disposed':
-      return { kind: 'disposed' }
-    /* v8 ignore next 2 -- AgentInterruptReason is closed and the public helper filters unsupported reasons. */
-    default:
-      return assertNever(reason, 'AgentInterruptReason')
-  }
-}
-
-/** Mutable agent controls supplied to the loop driver. */
-export interface LoopHandle {
-  /** Native-private agent inbox handed to the driver only at internal startup. */
-  readonly inbox: Inbox
-  /** Maximum parallel-safe calls allowed in one step. */
-  readonly maxParallelToolCalls: number
-  setStatus(status: 'idle' | 'running'): void
-  /** Install a fresh active-turn owner before the running notification. */
-  installTurnCancellation(): TurnCancellation
-  /** Clear only the exact owner whose turn reached its terminal event boundary. */
-  clearTurnCancellation(cancellation: TurnCancellation): void
-  /** Resolves when the agent is disposed — unblocks the idle wait. */
-  disposed: Promise<void>
-  isDisposed(): boolean
-  /** Whether queued work was cancelled before an active turn owner existed. */
-  isPreRunCancelled(): boolean
-  /** Clear the cause-less pre-run marker without affecting replacement work. */
-  clearPreRunCancel(): void
-  /** Settle idle waiters before pre-running cancellation publishes idle. */
-  settleIdle(): void
-  /** Run an active tool-call batch, accepting post-tool context into the FIFO drained before settlement. */
-  readonly withToolBatch: <T>(run: (acceptContext: (context: HookContext) => void) => Promise<T>) => Promise<T>
-}
-
-/**
- * Drive queued messages as independent durable turns until disposal. Plugin
- * failures end the current turn without terminating the driver. The caller
- * establishes the `ctx.agents.withInitiator()` boundary before entry; package-private
- * orchestration recovers that exact Agent and captures its Session locally.
- * @param ctx - the plugin context the loop reaches its initiating Agent,
- * events (agent/…, session/flush), and services (systemPrompt, llm, tools)
- * through.
- * @param handle - the bridge to status, turn cancellation ownership, disposal, and pre-run cancellation state.
- * @throws when no initiating Agent is active.
- */
-export async function runLoop(ctx: Context, handle: LoopHandle): Promise<void> {
-  const agent = ctx.agents.requireInitiator()
-  // Per-instance prefix and request-header state; conversation history remains in the session log.
-  const transmission = createTransmissionLog()
-
-  const { session } = agent
-  // Fused subject and scope carrier for every agent event below.
-  const events = agentEvents(ctx, agent)
-
-  while (!handle.isDisposed()) {
-    // An idle listener can enqueue and cancel replacement work before the next
-    // wait is installed. Consume that empty marker before parking the driver.
-    // A quiet (`wakeup:false`) item alone must not un-park the loop, so gate on
-    // hasWakingQueued, not hasQueued.
-    if (handle.isPreRunCancelled()) {
-      handle.clearPreRunCancel()
-      if (!handle.inbox.hasWakingQueued) {
-        handle.settleIdle()
-        handle.setStatus('idle')
-        continue
-      }
-    }
-
-    await handle.inbox.waitForQueued(handle.disposed)
-    if (handle.isDisposed()) break
-
-    // Cancellation between wake and `running` skips only the cancelled work;
-    // a replacement prompt still runs before the eventual idle transition.
-    if (handle.isPreRunCancelled()) {
-      handle.clearPreRunCancel()
-      if (!handle.inbox.hasWakingQueued) {
-        // Settle before publishing idle: the already-idle path has no status
-        // transition, while an idle listener can register waiters for new work.
-        handle.settleIdle()
-        handle.setStatus('idle')
-        continue
-      }
-    }
-
-    let cancellation = handle.installTurnCancellation()
-    handle.setStatus('running')
-    if (handle.isDisposed()) {
-      handle.clearTurnCancellation(cancellation)
-      break
-    }
-
-    // A synchronous `running` listener can cancel before `runTurn`; balance the
-    // status only when no waking replacement prompt was queued by that listener
-    // (a lone quiet item parks at idle rather than driving a turn).
-    if (cancellation.signal.aborted) {
-      handle.clearTurnCancellation(cancellation)
-      if (!handle.inbox.hasWakingQueued) {
-        handle.setStatus('idle')
-        continue
-      }
-      cancellation = handle.installTurnCancellation()
-    }
-
-    // Idle injection can add a turn, so derive the next number from the log.
-    const turn = lastTurnNumber(session) + 1
-    let terminalStopped = false
-    try {
-      terminalStopped = await runTurn(ctx, events, handle, turn, transmission, cancellation)
-    } catch (error: unknown) {
-      // Pre-turn failure has no durable boundary to close; report it without appending outside a turn.
-      const err = toError(error)
-      ctx.logger.warn(`agent "${agent.id}": turn ${turn} failed before it started: ${errorChain(err)}`)
-      try {
-        events.emit('agent/error', turn, 0, err)
-      } catch { /* contained: a throwing agent/error listener must not kill the driver */ }
-    } finally {
-      handle.clearTurnCancellation(cancellation)
-    }
-
-    // Late steering (arriving after runTurn returns, e.g. during the post-turn
-    // flush) becomes queued input — unless terminal policy stopped the turn, in
-    // which case it is dropped and must publish a discard so its enqueue is
-    // still matched (the invariant only catches a NEGATIVE count, not a leak).
-    const lateSteering = handle.inbox.drainSteering()
-    if (terminalStopped) {
-      if (lateSteering.length > 0) {
-        events.emit('agent/inbox/discard', lateSteering.map(message => agentMessage(message, true)))
-      }
-    } else {
-      for (const message of lateSteering) handle.inbox.enqueue(message)
-    }
-
-    // Park at idle unless a waking item still wants the model to run; a lone
-    // quiet (`wakeup:false`) item stays queued but does not keep the loop busy.
-    if (!handle.inbox.hasWakingQueued) handle.setStatus('idle')
-  }
-}
-
-async function runTurn(
-  ctx: Context, events: AgentEventDispatch, handle: LoopHandle, turn: number, transmission: TransmissionLog,
-  cancellation: TurnCancellation,
-): Promise<boolean> {
-  const agent = ctx.agents.requireInitiator()
-  const { session } = agent
-  const { signal } = cancellation
-  const drainSteering = (): boolean => {
-    const messages = handle.inbox.drainSteering()
-    for (const message of messages) {
-      events.emit('agent/inbox/dequeue', agentMessage(message, true))
-      const prepared = preparePromptMessage(message.content, message.source, message.contexts)
-      session.append('steering/message', {
-        turn, ...prepared.data,
-        ...message.meta === undefined ? {} : { meta: message.meta },
-      }, { surfaceOp: 'append' })
-      for (const context of prepared.separateContexts) {
-        session.append('user/message', {
-          content: context.content,
-          source: context.source,
-          ...context.meta === undefined ? {} : { meta: context.meta },
-        }, { surfaceOp: 'append' })
-      }
-    }
-    return messages.length > 0
-  }
-
-  // Claim one queued message before opening its turn, but append it only after `turn/start`.
-  const message = handle.inbox.dequeueQueued()
-  /* v8 ignore next 3 -- invariant guard: runLoop only calls runTurn when hasQueued */
-  if (!message) throw new Error('runTurn invariant violated: no queued message at turn start')
-  events.emit('agent/inbox/dequeue', agentMessage(message, false))
-  const trigger: TurnTrigger = { kind: 'message', source: message.source }
-
-  let reason: TurnEndReason = { kind: 'completed' }
-  let step = 0
-  let requestFailureHistory: readonly LlmFailure[] = Object.freeze([])
-  let stepOpen = false
-  let errorReported = false
-  let terminalStopped = false
-
-  // Close the committed step once; pre-commit validation failure still escapes.
-  const closeStep = (): void => {
-    if (!stepOpen) return
-    session.append('step/end', { turn, step })
-    stepOpen = false
-  }
-
-  // Record the durable turn failure once and contain the live error notification.
-  const failTurn = (err: RequestError, failure?: LlmFailure): void => {
-    if (errorReported) return
-    errorReported = true
-    reason = failure === undefined
-      ? { kind: 'error', step, ...errorData(err) }
-      : { kind: 'error', step, failure: durableFailure(err, failure) }
-    try {
-      events.emit('agent/error', turn, step, err)
-    } catch {
-      // contained: the error is already captured on `reason`; a throwing
-      // agent/error listener must not prevent the turn from closing.
-    }
-  }
-
-  // Retire cancellation authority before publishing the terminal event. The
-  // following durability flush is quiescent turn work, but no longer part of
-  // the cancellable turn lifetime.
-  const closeTurn = (): void => {
-    handle.clearTurnCancellation(cancellation)
-    session.append('turn/end', { turn, reason })
-  }
-
-  try {
-    // --- Turn boundary. Once turn/start is appended, a turn/end is owed no
-    // matter what throws below; the catch + closeTurn guarantee it. A pre-commit
-    // veto leaves no turn/start in the log and therefore owes no turn/end.
-    session.append('turn/start', { turn, trigger })
-    interruptionCheckpoint(signal)
-    // The claimed message runs the `agent/prompt-submit` waterfall before it
-    // becomes a `user/message` — a hook can rewrite the prompt or block it.
-    // Recorded INSIDE the turn (after turn/start) so every event is turn-enclosed;
-    // turn/end is now owed, so a throwing prompt-submit listener (the waterfall
-    // throws) is caught below and the turn still closes.
-    const promptDecision = await events.waterfall(
-      'agent/prompt-submit', message.content, message.source, signal,
-      () => Promise.resolve<PromptDecision>({
-        kind: 'allow',
-        ...message.contexts.length === 0 ? {} : { additionalContexts: message.contexts },
-      }),
-    )
-    interruptionCheckpoint(signal)
-    if (promptDecision.kind === 'block') {
-      session.append('prompt/blocked', { content: message.content, source: message.source, reason: promptDecision.reason })
-      reason = { kind: 'rejected', reason: promptDecision.reason }
-    } else {
-      // `allow.content` REPLACES the prompt bytes (a rewrite); absent keeps them.
-      const content = promptDecision.content ?? message.content
-      const prepared = preparePromptMessage(content, message.source, promptDecision.additionalContexts ?? [])
-      session.append('user/message', {
-        ...prepared.data,
-        ...message.meta === undefined ? {} : { meta: message.meta },
-      }, { surfaceOp: 'append' })
-      // Separate contexts still enter THIS turn through inject(). Prefix
-      // contexts are already baked into the user/message with their durable
-      // display envelope, so appending them again would duplicate model input.
-      for (const context of prepared.separateContexts) {
-        agent.inject(context.content, {
-          source: context.source,
-          ...context.meta !== undefined ? { meta: context.meta } : {},
-        })
-      }
-    }
-
-    while (true) {
-      // A blocked prompt closes its zero-step turn as rejected.
-      if (promptDecision.kind === 'block') break
-      step += 1
-
-      // Steering from the previous round's continuation listeners joins before
-      // the request.
-      drainSteering()
-
-      // Assemble once before pre-step so listener work and the request share one prompt value.
-      const assembly = await ctx.systemPrompt.assemble(assembleContextFor(agent, signal))
-      interruptionCheckpoint(signal)
-      const fullSystemPrompt = renderPrompt(assembly)
-
-      // Compose the request-only prefix once per loop instance before the first
-      // request boundary. It precedes all derived history and is recorded only
-      // in the request header, not as session history.
-      if (transmission.sessionPrefix === undefined) {
-        const emptyPrefix: Message[] = deepFreeze([])
-        const composed = await events.waterfall(
-          'agent/session-prefix', emptyPrefix, signal,
-          () => Promise.resolve(emptyPrefix),
-        )
-        // Never cache an interrupted composition; the next turn recomposes it.
-        interruptionCheckpoint(signal)
-        transmission.sessionPrefix = deepFreeze(structuredClone(composed))
-      }
-
-      // Await surface mutations outside the step before snapshotting history.
-      await events.serial('agent/pre-step', turn, step, signal)
-      interruptionCheckpoint(signal)
-
-      // Snapshot the exact log prefix before step/start: the reconstruction
-      // boundary. Appends after this synchronous snapshot join the next request.
-      const boundaryMessages = session.deriveMessages()
-
-      session.append('step/start', { turn, step })
-      // Only a committed step/start creates a balancing obligation. A
-      // pre-commit veto throws before this assignment; post-commit observers
-      // are contained inside Session.append().
-      stepOpen = true
-
-      // A synchronous step/start observer can cancel after the step opened.
-      interruptionCheckpoint(signal)
-
-      let stepOutcome:
-        | { hadToolCalls: boolean; finish: FinishReason }
-        | { requestError: RequestError; failure: LlmFailure; retryPolicy: ResolvedRetryPolicy | undefined }
-        | { error: RequestError }
-      try {
-        stepOutcome = await runStep(
-          ctx, events, handle, turn, step, assembly, fullSystemPrompt, boundaryMessages, transmission, signal)
-      } catch (error: unknown) {
-        if (error instanceof TerminalModelRequestFailure) {
-          stepOutcome = {
-            requestError: error.requestError,
-            failure: error.failure,
-            retryPolicy: error.retryPolicy,
-          }
-        } else {
-          stepOutcome = { error: toError(error) }
-        }
-      }
-
-      if ('requestError' in stepOutcome) {
-        // Recovery observes a balanced failed step and the original provider
-        // error while the failed step's signal remains the active owner.
-        closeStep()
-        const interrupted = interruptionTurnEndReason(handle, signal)
-        if (interrupted !== undefined) {
-          reason = interrupted
-          break
-        }
-
-        const defaultDecision: RequestErrorDecision = { action: 'fail' }
-        let recoveryDecision: RequestErrorDecision = defaultDecision
-        try {
-          recoveryDecision = await events.waterfall(
-            'agent/request-error', turn, step, stepOutcome.requestError,
-            stepOutcome.failure, requestFailureHistory, stepOutcome.retryPolicy, signal,
-            () => Promise.resolve(defaultDecision),
-          )
-        } catch (recoveryError: unknown) {
-          ctx.logger.warn(
-            `agent "${agent.id}": request recovery failed at turn ${turn}, step ${step}: ${errorChain(recoveryError)}`,
-          )
-        }
-        // Cancellation and disposal always win over either a recovery decision
-        // or a recovery-listener failure.
-        const recoveryInterrupted = interruptionTurnEndReason(handle, signal)
-        if (recoveryInterrupted !== undefined) {
-          reason = recoveryInterrupted
-          break
-        }
-        switch (recoveryDecision.action) {
-          case 'retry':
-            requestFailureHistory = Object.freeze([...requestFailureHistory, stepOutcome.failure])
-            continue
-          case 'fail':
-            failTurn(stepOutcome.requestError, stepOutcome.failure)
-            break
-          /* v8 ignore next -- closed-union exhaustiveness guard */
-          default:
-            assertNever(recoveryDecision, 'agent request-error decision')
-        }
-        break
-      }
-
-      if ('error' in stepOutcome) {
-        // Steering that arrived during the failed step stays in the inbox —
-        // runLoop re-enqueues it as a queued message, so an abort-then-steer
-        // starts a fresh turn instead of being silently consumed.
-        closeStep()
-        const { error } = stepOutcome
-        const interrupted = interruptionTurnEndReason(handle, signal)
-        if (interrupted === undefined) failTurn(error)
-        else reason = interrupted
-        break
-      }
-
-      requestFailureHistory = Object.freeze([])
-
-      // Preserve max-token completion unless a later disposal, abort, or error wins.
-      const stepReason = stepFinishReason(stepOutcome.finish)
-      if (stepReason) reason = stepReason
-
-      // Steering that arrived during streaming/tool execution.
-      const steered = drainSteering()
-
-      try {
-        await events.serial('agent/post-step', turn, step, signal)
-      } catch (error: unknown) {
-        stepOutcome = { error: toError(error) }
-      }
-
-      if ('error' in stepOutcome) {
-        closeStep()
-        const interrupted = interruptionTurnEndReason(handle, signal)
-        if (interrupted === undefined) failTurn(stepOutcome.error)
-        else reason = interrupted
-        break
-      }
-
-      const postStepInterrupted = interruptionTurnEndReason(handle, signal)
-      if (postStepInterrupted !== undefined) {
-        reason = postStepInterrupted
-        closeStep()
-        break
-      }
-
-      closeStep()
-
-      const defaultDecision: ContinuationDecision = { action: stepOutcome.hadToolCalls || steered ? 'continue' : 'stop' }
-      let decision: ContinuationDecision
-      try {
-        decision = await events.waterfall(
-          'agent/turn-continuation', turn, defaultDecision, signal,
-          () => Promise.resolve(defaultDecision),
-        )
-        interruptionCheckpoint(signal)
-      } catch (error: unknown) {
-        const interrupted = interruptionTurnEndReason(handle, signal)
-        if (interrupted === undefined) failTurn(toError(error))
-        else reason = interrupted
-        break
-      }
-
-      // A continuation reason becomes next-step steering. Publish the same
-      // enqueue event a public steer would, so the inbox ledger stays balanced
-      // (every FIFO entry has a matching enqueue before its dequeue/discard).
-      if (decision.action === 'continue' && decision.reason) {
-        // Detach and freeze the listener-owned reason like a public steer, so an
-        // enqueue listener or the producer cannot mutate the durable/model-visible
-        // steering message before it drains.
-        const item: InboxMessage = deepFreeze({
-          id: AgentMessageId(randomUUID()),
-          content: structuredClone(decision.reason.content),
-          source: structuredClone(decision.reason.source),
-          contexts: [], wakeup: true,
-        })
-        handle.inbox.steer(item)
-        events.emit('agent/inbox/enqueue', agentMessage(item, true))
-      }
-      let shouldContinue = decision.action === 'continue'
-
-      // Pending steering overrides an ordinary stop.
-      if (!shouldContinue && handle.inbox.hasSteering) shouldContinue = true
-
-      // Terminal policy is monotonic and runs after ordinary continuation folding.
-      let terminalStop = false
-      try {
-        const stop = await events.serial('agent/turn-stop', turn, signal)
-        interruptionCheckpoint(signal)
-        terminalStop = stop !== undefined
-      } catch (error: unknown) {
-        // A broken terminal policy is an ordinary continuation failure: fail
-        // this turn closed while leaving the driver alive for later turns.
-        const interrupted = interruptionTurnEndReason(handle, signal)
-        if (interrupted === undefined) failTurn(toError(error))
-        else reason = interrupted
-        break
-      }
-      if (terminalStop) {
-        terminalStopped = true
-        // Terminal stop discards steering but preserves ordinary queued prompts.
-        // Publish a discard for every dropped steering item so the enqueue ⇒
-        // dequeue-or-discard ledger stays balanced (the outstanding-count
-        // invariant and correlation consumers must not be left with dangling ids).
-        const dropped = handle.inbox.drainSteering()
-        if (dropped.length > 0) {
-          events.emit('agent/inbox/discard', dropped.map(item => agentMessage(item, true)))
-        }
-        shouldContinue = false
-      }
-
-      if (!shouldContinue) break
-    }
-
-    // Normal / inline-error loop exit: close the turn.
-    closeTurn()
-  } catch (error: unknown) {
-    // Close only a turn whose start committed to the log.
-    const turnStartLogged = session.events.some(e => e.type === 'turn/start' && e.data.turn === turn)
-    if (!turnStartLogged) throw error
-    closeStep()
-    const interrupted = interruptionTurnEndReason(handle, signal)
-    if (interrupted === undefined) failTurn(toError(error))
-    else reason = interrupted
-    closeTurn()
-  }
-
-  // Flush through the store-owned durability checkpoint without killing the driver on failure.
-  try {
-    await ctx.sessions.flush(session)
-  } catch (error: unknown) {
-    // The turn is closed, so report the failed flush live rather than append outside a turn.
-    const err = toError(error)
-    ctx.logger.warn(`agent "${agent.id}": session/flush failed at turn ${turn}: ${errorChain(err)}`)
-    try {
-      events.emit('agent/error', turn, step, err)
-    } catch {
-      // contained: a throwing agent/error listener must not escape the loop.
-    }
-  }
-  return terminalStopped
-}
-
-/**
- * Run one committed step: transform call config, log the request header, build
- * the request from the cached prefix plus the step-boundary snapshot, stream and
- * record the response, then execute tools. The caller has already assembled the
- * prompt, run `agent/pre-step`, snapshotted history, and opened the step.
- */
-async function runStep(
-  ctx: Context,
-  events: AgentEventDispatch,
-  handle: LoopHandle,
-  turn: number,
-  step: number,
-  assembly: PromptAssembly,
-  system: string,
-  boundaryMessages: Message[],
-  transmission: TransmissionLog,
-  signal: AbortSignal,
-): Promise<{ hadToolCalls: boolean; finish: FinishReason }> {
-  const agent = ctx.agents.requireInitiator()
-  const { session, options } = agent
-
-  // Seed the first request from agent options and later requests from the logged header;
-  // detach and freeze so listeners must return an attributable replacement.
-  const loggedConfig = session.requestHeader()?.config
-  const initialProvider = options.provider ?? ''
-  const initialModel = options.model ?? ''
-  const initialConfig: LlmCallConfig = {
-    provider: initialProvider,
-    model: initialModel,
-    ...loggedConfig?.provider === initialProvider
-      && loggedConfig.model === initialModel
-      && loggedConfig.reasoningEffort !== undefined
-      ? { reasoningEffort: loggedConfig.reasoningEffort }
-      : {},
-  }
-  const seedConfig: LlmCallConfig = deepFreeze(structuredClone(
-    transmission.loggedHeader
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- loggedHeader ⟹ a snapshot is in the log
-      ? session.requestHeader()!.config
-      : initialConfig,
-  ))
-
-  // Listener replacements are recorded in the request header before dispatch.
-  const proposedConfig = await events.waterfall(
-    'agent/request', turn, step, seedConfig, signal, () => Promise.resolve(seedConfig),
-  )
-  interruptionCheckpoint(signal)
-  if (!proposedConfig.provider || !proposedConfig.model) {
-    throw new Error(`agent "${agent.id}" has no provider/model: set AgentOptions.provider and AgentOptions.model or supply both via the agent/request waterfall`)
-  }
-  let config: LlmCallConfig
-  let preparedCall: PreparedLlmCall | undefined
-  try {
-    preparedCall = await ctx.llm.prepareCall(proposedConfig, signal)
-    config = preparedCall.config
-  } catch (error: unknown) {
-    // A waterfall listener may own and short-circuit a route with no adapter.
-    // Terminal dispatch still raises NO_ADAPTER when no listener handles it.
-    if (!(error instanceof LlmError) || error.code !== 'NO_ADAPTER') throw error
-    config = proposedConfig
-  }
-  interruptionCheckpoint(signal)
-
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- runTurn composes the prefix before every runStep call
-  const sessionPrefix = transmission.sessionPrefix!
-
-  // Record the canonical header, including the otherwise-unlogged prefix, before dispatch.
-  const header = canonicalHeader({
-    config,
-    ...system ? { system } : {},
-    ...assembly.tools.length > 0 ? { tools: assembly.tools } : {},
-    ...sessionPrefix.length > 0 ? { messagePrefix: sessionPrefix } : {},
-  })
-  recordRequestHeader(session, transmission, header)
-
-  // Freeze the logged header plus boundary snapshot; the prefix precedes derived history.
-  const request: GenerateOptions = markAgentLoopRequest(deepFreeze({
-    provider: header.config.provider,
-    model: header.config.model,
-    ...header.config.reasoningEffort !== undefined
-      ? { reasoningEffort: header.config.reasoningEffort }
-      : {},
-    messages: [...header.messagePrefix ?? [], ...boundaryMessages],
-    ...header.system !== undefined ? { system: header.system } : {},
-    ...header.tools !== undefined ? { tools: header.tools } : {},
-    ...header.config.temperature !== undefined ? { temperature: header.config.temperature } : {},
-    ...header.config.maxTokens !== undefined ? { maxTokens: header.config.maxTokens } : {},
-    ...header.config.stop !== undefined ? { stop: header.config.stop } : {},
-    sessionId: session.id,
-    signal,
-  }))
-
-  // --- Model call (streaming-first; raw chunks are the replay record) ---
-  const assembler = new BlockAssembler()
-  const chunkSeqs: number[] = []
-  const stream = preparedCall?.stream(request) ?? ctx.llm.stream(request)
-  try {
-    for await (const chunk of stream) {
-      interruptionCheckpoint(signal)
-      const chunkEvent = session.append('assistant/chunk', { turn, step, chunk })
-      chunkSeqs.push(chunkEvent.seq)
-      assembler.push(chunk)
-    }
-  } catch (error: unknown) {
-    const failure = llmFailureOf(stream, error)
-    if (failure !== undefined && error instanceof Error) {
-      throw new TerminalModelRequestFailure(error, failure, llmRetryPolicyOf(stream))
-    }
-    throw error
-  }
-  interruptionCheckpoint(signal)
-
-  // Normalize failure finish chunks into the same path as thrown stream errors.
-  const stepError = finishError(assembler.finish)
-  if (stepError) {
-    throw new TerminalModelRequestFailure(stepError.error, stepError.failure, llmRetryPolicyOf(stream))
-  }
-
-  const recordAssistantMessage = (
-    assembledContent: ContentBlock[],
-    message: Message,
-    preserveReplayState = true,
-  ): void => {
-    session.append(
-      'assistant/message',
-      {
-        turn,
-        step,
-        content: message.content,
-        provenance: assistantProvenance(
-          header.config,
-          assembler.replayState,
-          preserveReplayState && isDeepStrictEqual(message.content, assembledContent),
-        ),
-        ...assembler.usage === undefined ? {} : { usage: assembler.usage },
-      },
-      { surfaceOp: 'append', sourceEventSeqs: chunkSeqs },
-    )
-  }
-
-  // A rejected result still records the successful provider call without retaining rejected output.
-  const processStepResult = async (assembledContent: ContentBlock[], message: Message): Promise<Message> => {
-    try {
-      const processed = await events.waterfall(
-        'agent/step-result', turn, step, message, signal, () => Promise.resolve(message),
-      )
-      interruptionCheckpoint(signal)
-      return processed
-    } catch (error: unknown) {
-      recordAssistantMessage(assembledContent, { ...message, content: [] }, false)
-      throw error
-    }
-  }
-
-  if (assembler.finish.kind === 'max-tokens') {
-    const assembled = assembler.message()
-    const assembledContent = structuredClone(assembled.content)
-    let message: Message = withoutToolCalls(assembled)
-    message = withoutToolCalls(await processStepResult(assembledContent, message))
-    // Preserve usage even when max-token truncation produced no content.
-    recordAssistantMessage(assembledContent, message)
-    return { hadToolCalls: false, finish: assembler.finish }
-  }
-
-  // Record the post-waterfall message that tool dispatch uses.
-  const assembled = assembler.message()
-  const assembledContent = structuredClone(assembled.content)
-  let message: Message = assembled
-  message = await processStepResult(assembledContent, message)
-
-  // Every successful call records its completion anchor, including explicit
-  // empty chunk provenance for a contentless, usage-less provider response.
-  recordAssistantMessage(assembledContent, message)
-
-  // Dispatch may overlap; policy, durable results, and result context stay model-ordered.
-  const toolCalls = message.content.filter(block => block.type === 'tool-call')
-  if (toolCalls.length === 0) return { hadToolCalls: false, finish: assembler.finish }
-  return handle.withToolBatch(async (acceptContext) => {
-    await executeToolCalls(
-      ctx, turn, step, toolCalls, signal, handle.maxParallelToolCalls, acceptContext,
-    )
-    return { hadToolCalls: true, finish: assembler.finish }
-  })
-}
-
-/** Build durable assistant provenance, dropping replay state after any content rewrite. */
-function assistantProvenance(config: LlmCallConfig, replayState: unknown, contentUnchanged: boolean): NonNullable<Message['provenance']> {
-  return {
-    provider: config.provider,
-    model: config.model,
-    ...contentUnchanged && replayState !== undefined ? { replayState } : {},
-  }
-}
-
-function withoutToolCalls(message: Message): Message {
-  return { ...message, content: message.content.filter(block => block.type !== 'tool-call') }
-}
-
-/**
- * The last turn number in a (possibly seeded) session log, or 0.
- * @param session - the session whose log is scanned for the latest `turn/start`.
- * @returns the latest `turn/start`'s turn number, or 0 when the log has none (the next turn is this plus one).
- */
-export function lastTurnNumber(session: Session): number {
-  const lastStart = session.events.findLast(event => event.type === 'turn/start')
-  return lastStart?.data.turn ?? 0
-}
-
-/**
- * Whether the session log has an unmatched `turn/start`. Agent status is not
- * sufficient during pre-start and post-end windows.
- * @param session - the session whose log is inspected.
- * @returns true when the log's last turn boundary is a `turn/start` with no matching `turn/end` yet.
- */
-export function isTurnOpen(session: Session): boolean {
-  const last = session.events.findLast(e => e.type === 'turn/start' || e.type === 'turn/end')
-  return last?.type === 'turn/start'
-}

packages/core/agent-loop/src/request-log.ts

@@ -1,55 +0,0 @@
-/**
- * Per-loop-instance request-header bookkeeping for reconstructability. The
- * comparison baseline is folded from the session log; a fresh instance anchors
- * it with an initial/resume snapshot and later logs full changed snapshots.
- *
- * @module dsh-agent-loop/request-log
- */
-
-import { headerEquals } from '@deepseek-ai/dsh-session'
-import type { EpochHeader, Session } from '@deepseek-ai/dsh-session'
-import type { Message } from '@deepseek-ai/dsh-llm'
-
-/** Per-loop-instance bookkeeping: whether THIS instance has logged a header yet. */
-export interface TransmissionLog {
-  /** True once this loop instance appended its anchoring `request/header` snapshot. */
-  loggedHeader: boolean
-  /**
-   * The instance's composed session prefix (the `agent/session-prefix`
-   * waterfall's deep-frozen product), cached on the instance's first
-   * request-building step and reused verbatim for every request it sends —
-   * the structural guarantee that the prefix never changes mid-session.
-   * `undefined` until composed.
-   */
-  sessionPrefix?: Message[]
-}
-
-/**
- * Fresh bookkeeping for a newly-started loop instance.
- * @returns state with `loggedHeader` false, so the instance's first request appends an anchoring snapshot.
- */
-export function createTransmissionLog(): TransmissionLog {
-  return { loggedHeader: false }
-}
-
-/**
- * Append the full header snapshot owed by this request: initial/resume for the
- * instance's first request, nothing when unchanged, or change otherwise.
- *
- * @param session - the session whose log explains the request.
- * @param state - this loop instance's bookkeeping (mutated on first log).
- * @param header - the canonical header the request will ACTUALLY use
- *   (post-`agent/request`).
- */
-export function recordRequestHeader(session: Session, state: TransmissionLog, header: EpochHeader): void {
-  if (!state.loggedHeader) {
-    session.append('request/header', { header, reason: session.requestHeader() === undefined ? 'initial' : 'resume' })
-    state.loggedHeader = true
-    return
-  }
-  // This instance logged a snapshot, so the fold is necessarily defined.
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  const baseline = session.requestHeader()!
-  if (headerEquals(baseline, header)) return
-  session.append('request/header', { header, reason: 'change' })
-}

packages/core/agent-loop/src/tool-calls.ts

@@ -11,8 +11,7 @@
 
 import type { Context } from 'cordis'
 import { assertNever, type ToolCallBlock } from '@deepseek-ai/dsh-llm'
-import type { HookContext } from '@deepseek-ai/dsh-agent'
-import type { Session } from '@deepseek-ai/dsh-session'
+import type { Session, UserMessageData } from '@deepseek-ai/dsh-session'
 import { TOOL_ABORTED_BEFORE_DISPATCH, TOOL_REGISTRY_SCHEDULER, type ToolExecutionInput, type ToolExecutionMode, type ToolExecutionResult, type ToolRunContext } from '@deepseek-ai/dsh-tools'
 
 /** One tool call after argument parsing, ready to schedule. */
@@ -32,13 +31,16 @@ interface Slot {
 interface GroupOutcome {
   consumed: number
   aborted: boolean
+  /** Whether any committed result carried {@link ToolExecutionResult.concludesTurn}. */
+  concluded: boolean
 }
 
 /**
  * Schedule one assistant step's tool calls by their live concurrency mode.
  * Started calls receive ordered results. Abort drains them, records synthetic
  * results for unstarted calls, and returns with the signal still aborted after
- * accepting started-call context into the batch FIFO owned by the caller.
+ * accepting started-call context through the caller-supplied acceptor (the
+ * machine stages it on its outbox for the next step boundary).
  * The committed step's AgentLoop driver boundary supplies the initiating Agent
  * that becomes each explicit {@link ToolExecutionInput.agent}.
  *
@@ -47,8 +49,7 @@ interface GroupOutcome {
  * @param step - current step number.
  * @param toolCalls - assistant calls in model order.
  * @param signal - abort signal shared by the step.
- * @param maxParallel - validated in-flight cap.
- * @param acceptContext - accepts committed result context into the active batch.
+ * @param acceptContext - accepts committed result context for the next step boundary.
  */
 export async function executeToolCalls(
   ctx: Context,
@@ -56,9 +57,8 @@ export async function executeToolCalls(
   step: number,
   toolCalls: ToolCallBlock[],
   signal: AbortSignal,
-  maxParallel: number,
-  acceptContext: (context: HookContext) => void,
-): Promise<void> {
+  acceptContext: (context: UserMessageData) => void,
+): Promise<{ concluded: boolean }> {
   const agent = ctx.agents.requireInitiator()
   const { session } = agent
 
@@ -75,6 +75,7 @@ export async function executeToolCalls(
   }))
 
   let next = 0
+  let concluded = false
   while (next < planned.length) {
     // Commit before classifying again so registry changes affect unstarted calls.
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- bounded by the loop condition
@@ -82,14 +83,16 @@ export async function executeToolCalls(
     const mode = ctx.tools.executionMode(first.exec).kind
     const group = mode === 'parallel' ? planned.slice(next) : [first]
     const outcome = await runGroup(
-      ctx, turn, step, group, mode, signal, maxParallel, acceptContext,
+      ctx, turn, step, group, mode, signal, acceptContext,
     )
     next += outcome.consumed
+    concluded ||= outcome.concluded
     if (outcome.aborted) {
       for (const call of planned.slice(next)) appendSkippedToolCall(session, turn, step, call.block)
-      return
+      return { concluded }
     }
   }
+  return { concluded }
 }
 
 /** Parse model arguments, preserving invalid JSON as text and mapping empty input to `{}`. */
@@ -116,10 +119,10 @@ async function runGroup(
   group: PlannedCall[],
   mode: ToolExecutionMode['kind'],
   signal: AbortSignal,
-  maxParallel: number,
-  acceptContext: (context: HookContext) => void,
+  acceptContext: (context: UserMessageData) => void,
 ): Promise<GroupOutcome> {
   const { session } = ctx.agents.requireInitiator()
+  const { maxParallelToolCalls } = ctx.agentLoop.config
   const slots: (Slot | undefined)[] = group.map(() => undefined)
   // Started slots retain their tool/call seq for result provenance.
   const callSeqs: number[] = group.map(() => -1)
@@ -127,6 +130,7 @@ async function runGroup(
   let committed = 0
   let started = 0
   let aborted: boolean = signal.aborted
+  let concluded = false
 
   // `committed` advances only across contiguous model-order slots.
   const commitReady = async (): Promise<void> => {
@@ -140,6 +144,7 @@ async function runGroup(
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- bounded index
       appendToolResult(session, turn, step, call!.block, result, callSeqs[committed]!)
       for (const context of result.additionalContexts ?? []) acceptContext(context)
+      concluded ||= result.concludesTurn === true
       committed++
     }
   }
@@ -174,7 +179,7 @@ async function runGroup(
   }
 
   const fillPool = async (): Promise<void> => {
-    while (!aborted && nextToStart < group.length && inFlight.size < maxParallel) {
+    while (!aborted && nextToStart < group.length && inFlight.size < maxParallelToolCalls) {
       // Re-read later modes after ordered commits so registry changes can create a barrier.
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- bounded by the loop condition
       const nextCall = group[nextToStart]!
@@ -206,11 +211,11 @@ async function runGroup(
     // Started calls and accepted context settle first; every remaining model
     // call then receives an ordered synthetic result before the turn aborts.
     for (const call of group.slice(started)) appendSkippedToolCall(session, turn, step, call.block)
-    return { consumed: group.length, aborted: true }
+    return { consumed: group.length, aborted: true, concluded }
   }
   /* v8 ignore next -- unreachable: a non-aborted group commits every started call */
   if (committed !== started) throw new Error('tool-call scheduler: uncommitted settled calls')
-  return { consumed: started, aborted: false }
+  return { consumed: started, aborted: false, concluded }
 }
 
 /** Append the durable call/result pair for a model call skipped after cancellation. */

packages/core/agent-loop/tests/agent-initiator.spec.ts

@@ -41,7 +41,7 @@ function waitForIdle(ctx: Context, agent: Agent): Promise<void> {
 }
 
 function send(agent: Agent, text: string): void {
-  agent.followup([{ type: 'text', text }])
+  agent.followup({ content: [{ type: 'text', text }], source: { kind: 'user' } })
 }
 
 /** Adapter that holds both drivers at the same awaited continuation. */
@@ -153,6 +153,7 @@ describe('AgentLoop initiator scope', () => {
     const { ctx } = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('signal-owner'), { provider: 'mock', model: 'mock' })
     let signals: AbortSignal[] = []
+    let admissionSignals: AbortSignal[] = []
     const capture = (signal: AbortSignal | undefined): void => {
       if (signal === undefined) throw new Error('turn seam omitted its explicit signal')
       expect(ctx.agents.requireInitiator()).toBe(agent)
@@ -164,29 +165,20 @@ describe('AgentLoop initiator scope', () => {
       return next()
     })
     ctx.on('agent/prompt-submit', async (subject, _content, _source, signal, next) => {
+      if (subject === agent) {
+        expect(ctx.agents.requireInitiator()).toBe(agent)
+        admissionSignals.push(signal)
+      }
+      return next()
+    })
+    ctx.on('agent/step', (subject, _turn, _step, signal) => {
+      if (subject === agent) capture(signal)
+    })
+    ctx.on('agent/request', async (subject, _turn, _step, signal, next) => {
       if (subject === agent) capture(signal)
       return next()
     })
-    ctx.on('agent/session-prefix', async (subject, _prefix, signal, next) => {
-      if (subject === agent) capture(signal)
-      return next()
-    })
-    ctx.on('agent/pre-step', (subject, _turn, _step, signal) => {
-      if (subject === agent) capture(signal)
-    })
-    ctx.on('agent/request', async (subject, _turn, _step, _config, signal, next) => {
-      if (subject === agent) capture(signal)
-      return next()
-    })
-    ctx.on('agent/step-result', async (subject, _turn, _step, _message, signal, next) => {
-      if (subject === agent) capture(signal)
-      return next()
-    })
-    ctx.on('agent/turn-continuation', async (subject, _turn, _decision, signal, next) => {
-      if (subject === agent) capture(signal)
-      return next()
-    })
-    ctx.on('agent/turn-stop', (subject, _turn, signal) => {
+    ctx.on('agent/turn-stopping', (subject, _turn, signal) => {
       if (subject === agent) capture(signal)
     })
     ctx.tools.register(defineContentToolFixture({
@@ -205,14 +197,19 @@ describe('AgentLoop initiator scope', () => {
     const firstSignal = signals[0]
     expect(firstSignal).toBeDefined()
     expect(new Set([...signals, ...adapter.requests.slice(0, 2).map(request => request.signal!)])).toEqual(new Set([firstSignal]))
+    expect(admissionSignals).toHaveLength(1)
+    expect(admissionSignals[0]).not.toBe(firstSignal)
 
     signals = []
+    admissionSignals = []
     const secondIdle = waitForIdle(ctx, agent)
     send(agent, 'second')
     await secondIdle
     const secondSignal = signals[0]
     expect(secondSignal).toBeDefined()
     expect(new Set([...signals, adapter.requests[2]!.signal!])).toEqual(new Set([secondSignal]))
+    expect(admissionSignals).toHaveLength(1)
+    expect(admissionSignals[0]).not.toBe(secondSignal)
     expect(secondSignal).not.toBe(firstSignal)
     expect(ctx.agents.currentInitiator()).toBeUndefined()
     await ctx.fiber.dispose()
@@ -343,7 +340,6 @@ describe('AgentLoop initiator scope', () => {
     expect(captured).toBe(handle.agent)
 
     await handle.dispose()
-    expect(captured?.status).toBe('disposed')
     expect(ctx.agents.currentInitiator()).toBeUndefined()
     await ctx.fiber.dispose()
   })
@@ -365,7 +361,6 @@ describe('AgentLoop initiator scope', () => {
     await loopFiber.await()
     expect(adapter.firstAgentDuringAbort?.id).toBe(oldAgent.id)
     expect(adapter.firstAgentDuringAbort?.session).toBe(oldAgent.session)
-    expect(oldAgent.status).toBe('disposed')
     expect(() => oldService.currentInitiator()).toThrow('agent initiator scope is disposed')
     expect(ctx.agents).not.toBe(oldService)
     adapter.agents = ctx.agents
@@ -406,7 +401,6 @@ describe('AgentLoop initiator scope', () => {
     await ctx.fiber.dispose()
     expect(adapter.firstAgentDuringAbort?.id).toBe(agent.id)
     expect(adapter.firstAgentDuringAbort?.session).toBe(agent.session)
-    expect(agent.status).toBe('disposed')
     expect(() => service.currentInitiator()).toThrow('agent initiator scope is disposed')
   })
 })

packages/core/agent-loop/tests/agent.spec.ts

@@ -1,19 +1,14 @@
 import { describe, expect, it, vi } from 'vitest'
 import { Context } from 'cordis'
+import AgentRegistry, { type Agent } from '@deepseek-ai/dsh-agent'
+import AgentLoop from '@deepseek-ai/dsh-agent-loop'
 import LlmService from '@deepseek-ai/dsh-llm'
 import SessionStore, { SessionId } from '@deepseek-ai/dsh-session'
 import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
 import ToolRegistry from '@deepseek-ai/dsh-tools'
-import AgentRegistry, { type Agent } from '@deepseek-ai/dsh-agent'
-import AgentLoop, { DEFAULT_MAX_PARALLEL_TOOL_CALLS } from '@deepseek-ai/dsh-agent-loop'
-import { bindReactLoopAgentContext, prepareReactLoopAgent, type ReactLoopAgent } from '../src/agent.ts'
 import { MockAdapter, textResponse } from './mock-adapter.ts'
 
-function driverDone(agent: Agent): Promise<void> {
-  return (agent as Agent & { done: Promise<void> }).done
-}
-
-async function harness(adapter: MockAdapter) {
+async function harness(adapter: MockAdapter): Promise<Context> {
   const ctx = new Context()
   await ctx.plugin(LlmService)
   await ctx.plugin(SessionStore)
@@ -25,403 +20,85 @@ async function harness(adapter: MockAdapter) {
   return ctx
 }
 
-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()
-      }
-    })
-  })
-}
-
-function waitForStatus(ctx: Context, agent: Agent, expected: Agent['status']): Promise<void> {
-  return new Promise((resolve) => {
-    const dispose = ctx.on('agent/status', (subject, status) => {
-      if (subject === agent && status === expected) {
-        dispose()
-        resolve()
-      }
-    })
-  })
-}
-
-function send(agent: Agent, text: string) {
-  agent.followup([{ type: 'text', text }])
+function send(agent: Agent, text: string): void {
+  agent.followup({ content: [{ type: 'text', text }], source: { kind: 'user' } })
 }
 
 describe('Agent', () => {
-  it('rejects access before context binding and a second driver for one session', async () => {
-    const ctx = new Context()
-    await ctx.plugin(SessionStore)
-    const session = ctx.sessions.create(SessionId('exclusive-driver'))
-    const prepared = prepareReactLoopAgent(
-      ctx, SessionId('first-driver'), { provider: 'mock', model: 'mock' }, session, DEFAULT_MAX_PARALLEL_TOOL_CALLS,
-    )
-
-    expect(() => prepared.agent.ctx).toThrow('context is not bound')
-    expect(() => prepareReactLoopAgent(
-      ctx, SessionId('second-driver'), { provider: 'mock', model: 'mock' }, session, DEFAULT_MAX_PARALLEL_TOOL_CALLS,
-    ))
-      .toThrow('already has a concrete agent driver')
-
-    await prepared.dispose()
-    await ctx.fiber.dispose()
-  })
-
-  it('borrows caller options and binds its scoped context exactly once', async () => {
-    const ctx = await harness(new MockAdapter([textResponse('unused')]))
-    const options = { provider: 'mock', model: 'mock' }
-    const agent = ctx.agentLoop.create(SessionId('owned-bindings'), options)
-
-    expect(agent.options).toBe(options)
-    expect(agent.id).toBe('owned-bindings')
-    expect(agent.session.id).toBe(agent.id)
-    expect(() => { bindReactLoopAgentContext(agent as ReactLoopAgent, new Context()) }).toThrow(/context is already bound/)
-
-    await ctx.fiber.dispose()
-  })
-
-  it('send exposes the fully resolved delivery path without applying helper defaults', async () => {
-    const adapter = new MockAdapter([textResponse('accepted')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-    const enqueued = Promise.withResolvers<{ id: string; source: unknown; wakeup: boolean }>()
-    ctx.on('agent/inbox/enqueue', (subject, message) => {
-      if (subject === agent) enqueued.resolve(message)
-    })
-
-    const id = agent.send({
-      content: [{ type: 'text', text: 'advanced input' }],
-      source: { kind: 'plugin', plugin: 'advanced-caller' },
-      contexts: [],
-      meta: { caller: 'advanced' },
-      target: 'next-turn',
-      wakeup: true,
-    })
-    await waitForIdle(ctx, agent)
-
-    expect(await enqueued.promise).toMatchObject({
-      id,
-      source: { kind: 'plugin', plugin: 'advanced-caller' },
-      wakeup: true,
-    })
-    expect(agent.session.events.find(event => event.type === 'user/message'))
-      .toMatchObject({
-        data: {
-          source: { kind: 'plugin', plugin: 'advanced-caller' },
-          meta: { caller: 'advanced' },
-        },
-      })
-    await ctx.fiber.dispose()
-  })
-
-  it('followup() throws after disposal', async () => {
-    const adapter = new MockAdapter(['hang'])
-    const ctx = await harness(adapter)
-    let agent!: Agent
-    const fiber = await ctx.plugin(Object.assign((inner: Context) => {
-      agent = inner.agentLoop.create(SessionId('scoped'), { provider: 'mock', model: 'mock' })
-    }, { inject: ['agentLoop'] }))
-    send(agent, 'go')
-    await new Promise(r => setTimeout(r, 30))
-    await fiber.dispose()
-    await driverDone(agent)
-
-    expect(() => { agent.followup([{ type: 'text', text: 'too late' }]) }).toThrow('disposed')
-  })
-
-  it('disposal discards still-pending inbox items so every id gets a terminal event', async () => {
-    const adapter = new MockAdapter(['hang'])
-    const ctx = await harness(adapter)
-    let agent!: Agent
-    const discarded: string[] = []
-    ctx.on('agent/inbox/discard', (subject, messages) => {
-      if (subject === agent) discarded.push(...messages.map(m => m.id))
-    })
-    const fiber = await ctx.plugin(Object.assign((inner: Context) => {
-      agent = inner.agentLoop.create(SessionId('scoped'), { provider: 'mock', model: 'mock' })
-    }, { inject: ['agentLoop'] }))
-
-    // A quiet (non-waking) item stays parked in the inbox; disposal must drop it
-    // WITH a discard so its enqueued id is not left dangling forever.
-    const id = agent.queue([{ type: 'text', text: 'never runs' }])
-    await fiber.dispose()
-    await driverDone(agent)
-
-    expect(discarded).toEqual([id])
-  })
-
-  it('steer() throws after disposal', async () => {
-    const adapter = new MockAdapter(['hang'])
-    const ctx = await harness(adapter)
-    let agent!: Agent
-    const fiber = await ctx.plugin(Object.assign((inner: Context) => {
-      agent = inner.agentLoop.create(SessionId('scoped'), { provider: 'mock', model: 'mock' })
-    }, { inject: ['agentLoop'] }))
-    send(agent, 'go')
-    await new Promise(r => setTimeout(r, 30))
-    await fiber.dispose()
-    await driverDone(agent)
-
-    expect(() => { agent.steer([{ type: 'text', text: 'too late' }]) }).toThrow('disposed')
-  })
-
-  it('inject() throws after disposal', async () => {
-    const adapter = new MockAdapter(['hang'])
-    const ctx = await harness(adapter)
-    let agent!: Agent
-    const fiber = await ctx.plugin(Object.assign((inner: Context) => {
-      agent = inner.agentLoop.create(SessionId('scoped'), { provider: 'mock', model: 'mock' })
-    }, { inject: ['agentLoop'] }))
-    send(agent, 'go')
-    await new Promise(r => setTimeout(r, 30))
-    await fiber.dispose()
-    await driverDone(agent)
-
-    expect(() => { agent.inject([{ type: 'text', text: 'too late' }]) }).toThrow('disposed')
-  })
-
-  it('inject() decides enclosure from the LOG (open turn), not agent status', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    // Status is idle while the log has an open turn; enclosure must follow the log.
-    agent.session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
-    agent.inject([{ type: 'text', text: 'mid' }], { source: { kind: 'plugin', plugin: 'p' } })
-    expect(agent.session.events.filter(e => e.type === 'turn/start')).toHaveLength(1)
-    expect(agent.session.events.at(-1)!.type).toBe('user/message')
-
-    agent.session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
-    agent.inject([{ type: 'text', text: 'after' }], { source: { kind: 'plugin', plugin: 'p' } })
-    const starts = agent.session.events.filter(e => e.type === 'turn/start')
-    expect(starts).toHaveLength(2)
-    const last = starts[1]!
-    expect(last.type === 'turn/start' && last.data.trigger.kind).toBe('injection')
-    expect(agent.session.events.at(-1)!.type).toBe('turn/end') // turn-enclosed
-  })
-
-  it('inject() defaults its source to an empty plugin, never user', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-    agent.session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
-    agent.inject([{ type: 'text', text: 'no explicit source' }])
-    const injected = agent.session.events.at(-1)!
-    expect(injected.type === 'user/message' && injected.data.source).toEqual({ kind: 'plugin', plugin: '' })
-  })
-
-  it('idle inject() contains a failing flush (logs, does not throw into the caller)', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    // A persistence-like listener whose flush rejects.
-    ctx.on('session/flush', () => { throw new Error('disk gone') })
-    const warn = vi.spyOn(ctx.logger, 'warn').mockImplementation(() => undefined)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    // inject() is synchronous and fires a fire-and-forget flush; a rejecting
-    // flush must be contained (logged), never thrown into the caller.
-    expect(() => { agent.inject([{ type: 'text', text: 'notice' }], { source: { kind: 'plugin', plugin: 'p' } }) }).not.toThrow()
-    await new Promise(r => setTimeout(r, 20)) // let the contained flush settle
-    expect(warn).toHaveBeenCalledWith(expect.stringContaining('flush after idle injection failed'))
-    warn.mockRestore()
-  })
-
-  it('idle inject() validates its payload BEFORE opening a turn, so invalid input appends nothing', async () => {
+  it('idle inject() appends context without opening a turn or requesting a flush', async () => {
     const adapter = new MockAdapter([textResponse('ok')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
     let flushes = 0
     ctx.on('session/flush', () => { flushes += 1 })
 
-    // Non-serializable injected content is rejected by the up-front snapshot
-    // BEFORE any append (the unified send contract: invalid input throws before
-    // mutating the log). No one-shot turn opens and no durability checkpoint fires.
+    agent.inject({ content: [{ type: 'text', text: 'context' }], source: { kind: 'plugin', plugin: 'p' } })
+
+    expect(agent.session.events.map(event => event.type)).toEqual(['user/message'])
+    expect(agent.status).toBe('idle')
+    expect(adapter.requests).toHaveLength(0)
+    await agent.whenIdle()
+    expect(flushes).toBe(0)
+  })
+
+  it('inject() preserves an explicitly empty plugin source', async () => {
+    const ctx = await harness(new MockAdapter([textResponse('ok')]))
+    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
+
+    agent.inject({ content: [{ type: 'text', text: 'empty plugin source' }], source: { kind: 'plugin', plugin: '' } })
+
+    const injected = agent.session.events.at(-1)
+    expect(injected?.type === 'user/message' && injected.data.source)
+      .toEqual({ kind: 'plugin', plugin: '' })
+  })
+
+  it('idle inject() rejects invalid input before append', async () => {
+    const ctx = await harness(new MockAdapter([textResponse('ok')]))
+    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
+
     expect(() => {
-      agent.inject([{ type: 'text', text: 'x', bad: 1n } as never], { source: { kind: 'plugin', plugin: 'p' } })
-    }).toThrow(/losslessly JSON-serializable/)
-    expect(agent.session.events).toHaveLength(0)
-    await new Promise(r => setTimeout(r, 10)) // give any (erroneous) flush a chance
-    expect(flushes).toBe(0) // nothing was appended, so no checkpoint
-  })
-
-  it('idle inject() re-entered from a session/event listener is rejected pre-commit and opens no turn', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-    let flushes = 0
-    ctx.on('session/flush', () => { flushes += 1 })
-    // Injecting from inside a session/event listener re-enters Session.append,
-    // which rejects pre-commit — so turn/start never commits. The finally sees
-    // no open turn (closes nothing) and no recorded turn (no checkpoint), and
-    // the reentrant throw is contained by Session's post-commit dispatch.
-    // Fire on turn/end: at that instant the outer one-shot turn is closed (no
-    // turn open), so the reentrant inject takes the idle one-shot-turn path and
-    // its turn/start append re-enters Session and is rejected pre-commit.
-    let reentered = false
-    ctx.on('session/event', (_s, event) => {
-      if (!reentered && event.type === 'turn/end') {
-        reentered = true
-        agent.inject([{ type: 'text', text: 'reentrant' }], { source: { kind: 'plugin', plugin: 'p' } })
-      }
-    })
-
-    agent.inject([{ type: 'text', text: 'outer' }], { source: { kind: 'plugin', plugin: 'p' } })
-    // The outer injection's own one-shot turn is balanced; the reentrant one
-    // opened no turn (its turn/start was rejected pre-commit).
-    const turnStarts = agent.session.events.filter(e => e.type === 'turn/start')
-    expect(turnStarts).toHaveLength(1)
-    const injected = agent.session.events.filter(e => e.type === 'user/message')
-    expect(injected).toHaveLength(1) // the reentrant user/message never committed
-    await new Promise(r => setTimeout(r, 10))
-    expect(flushes).toBe(1) // only the outer accepted turn checkpointed
-  })
-
-  it('idle inject() still checkpoints when a listener throws on the synthetic turn/end', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-    let flushes = 0
-    ctx.on('session/flush', () => { flushes += 1 })
-    // Session contains a throwing post-commit turn/end observer. The accepted
-    // boundary still triggers the idle injection's durability checkpoint.
-    let threw = false
-    ctx.on('session/event', (_s, event) => {
-      if (!threw && event.type === 'turn/end') { threw = true; throw new Error('boom turn/end') }
-    })
-
-    expect(() => { agent.inject([{ type: 'text', text: 'notice' }], { source: { kind: 'plugin', plugin: 'p' } }) }).not.toThrow()
-    const types = agent.session.events.map(e => e.type)
-    expect(types).toEqual(['turn/start', 'user/message', 'turn/end']) // balanced
-    await new Promise(r => setTimeout(r, 10))
-    expect(flushes).toBe(1) // checkpoint fired despite the throwing turn/end listener
-  })
-
-  it('idle inject() reports a failing flush via agent/error (step 0) AND the logger', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    // A non-Error rejection exercises the String() normalization branch.
-    ctx.on('session/flush', () => { throw 'disk gone' })
-    const warn = vi.spyOn(ctx.logger, 'warn').mockImplementation(() => undefined)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-    const errors: { turn: number; step: number; message: string }[] = []
-    ctx.on('agent/error', (_a, turn, step, error) => void errors.push({ turn, step, message: error.message }))
-
-    agent.inject([{ type: 'text', text: 'notice' }], { source: { kind: 'plugin', plugin: 'p' } })
-    await new Promise(r => setTimeout(r, 20)) // let the contained flush settle
-
-    // Reported via agent/error (step 0 — the idle-injection convention) so
-    // plugins monitoring agent/error see idle-injection persistence failures,
-    // mirroring the loop's post-turn/end flush path. A non-Error throw is
-    // normalized to an Error.
-    expect(errors).toEqual([{ turn: 1, step: 0, message: 'disk gone' }])
-    expect(warn).toHaveBeenCalledWith(expect.stringContaining('flush after idle injection failed'))
-    warn.mockRestore()
-  })
-
-  it('idle inject() with a non-serializable source opens no turn (nothing to close)', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    // A non-serializable source is rejected by the up-front snapshot BEFORE any
-    // append, so NO turn opens and the log stays empty.
-    expect(() => {
-      agent.inject([{ type: 'text', text: 'x' }], { source: { kind: 'plugin', plugin: 'p', bad: 1n } as never })
-    }).toThrow(/losslessly JSON-serializable/)
+      agent.inject({ content: [{ type: 'text', text: 'x', bad: 1n } as never], source: { kind: 'plugin', plugin: 'p' } })
+    }).toThrow(/non-JSON-serializable/)
     expect(agent.session.events).toHaveLength(0)
   })
 
-  it('steer() when idle falls through to send() and starts a turn', async () => {
+  it('steer() while idle becomes a woken prompt turn', async () => {
     const adapter = new MockAdapter([textResponse('ok')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    agent.steer([{ type: 'text', text: 'steer idle' }], { source: { kind: 'plugin', plugin: 'test' } })
-    await waitForIdle(ctx, agent)
+    agent.steer({ content: [{ type: 'text', text: 'steer idle' }], source: { kind: 'plugin', plugin: 'test' } })
+    await agent.whenIdle()
 
-    expect(agent.session.events.some(e => e.type === 'user/message')).toBe(true)
+    expect(agent.session.events.some(event => event.type === 'user/message')).toBe(true)
     expect(adapter.requests).toHaveLength(1)
   })
 
-  it('disposer is idempotent (double-stop)', async () => {
-    // Create a bare Agent and start it through the package-internal
-    // test seam. Then call its disposer twice — the second call hits the
-    // early-return branch.
-    const ctx = new Context()
-    await ctx.plugin(SessionStore)
-    await ctx.plugin(AgentRegistry)
-    const session = ctx.sessions.create(SessionId('test'))
-    const prepared = prepareReactLoopAgent(
-      ctx, SessionId('bare'), { provider: 'mock', model: 'mock' }, session, DEFAULT_MAX_PARALLEL_TOOL_CALLS,
-    )
-    const { agent } = prepared
-
-    // Start the loop to get the disposer; the agent waits for messages
-    // (idle, never-resolving cancel), so it will stay idle.
-    prepared.markPublished()
-    const dispose = prepared.startDriver()
-
-    const firstDisposal = dispose()
-    expect(agent.status).toBe('disposed')
-    await firstDisposal
-
-    await expect(dispose()).resolves.toBeUndefined()
-    expect(agent.status).toBe('disposed')
-  })
-
-  it('a pre-start disposal makes a later driver-start attempt inert', async () => {
-    const ctx = new Context()
-    await ctx.plugin(SessionStore)
-    const session = ctx.sessions.create(SessionId('pre-start-dispose'))
-    const prepared = prepareReactLoopAgent(
-      ctx, SessionId('pre-start-dispose'), { provider: 'mock', model: 'mock' }, session, DEFAULT_MAX_PARALLEL_TOOL_CALLS,
-    )
-
-    await prepared.dispose()
-    expect(prepared.agent.status).toBe('disposed')
-    const dispose = prepared.startDriver()
-    await dispose()
-    await expect(prepared.agent.done).resolves.toBeUndefined()
-    expect(prepared.agent.session.events).toEqual([])
-    await ctx.fiber.dispose()
-  })
-
-  it('setting the same status does not emit agent/status again', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
+  it('emits one running and idle transition for one completed turn', async () => {
+    const ctx = await harness(new MockAdapter([textResponse('ok')]))
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
     const statuses: string[] = []
     ctx.on('agent/status', (subject, status) => {
       if (subject === agent) statuses.push(status)
     })
 
     send(agent, 'hi')
-    await waitForIdle(ctx, agent)
+    await agent.whenIdle()
 
-    // After the turn, agent is idle. Send again to trigger another attempt
-    // to go idle — but it's already idle, so no emission.
-    const idleTransitionCount = statuses.filter(s => s === 'idle').length
-    expect(idleTransitionCount).toBe(1) // only the final transition from running
+    expect(statuses).toEqual(['running', 'idle'])
   })
 
-  it('whenIdle() resolves immediately when the agent is not running', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
+  it('whenIdle() resolves immediately without active work', async () => {
+    const ctx = await harness(new MockAdapter([textResponse('ok')]))
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    // Fresh agent is idle — whenIdle() takes the not-running fast path and
-    // resolves without subscribing. await must not hang.
     await agent.whenIdle()
-    expect(agent.status).not.toBe('running')
+
+    expect(agent.status).toBe('idle')
   })
 
-  it('whenIdle() waits for queued work that has not flipped status yet', async () => {
-    const adapter = new MockAdapter(['hang'])
-    const ctx = await harness(adapter)
+  it('whenIdle() waits for active work until explicit cancellation', async () => {
+    const ctx = await harness(new MockAdapter(['hang']))
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     send(agent, 'queued')
@@ -430,150 +107,25 @@ describe('Agent', () => {
     await Promise.resolve()
     expect(settled).toBe(false)
 
-    await waitForStatus(ctx, agent, 'running')
     agent.cancel({ kind: 'user' })
     await idle
-    expect(settled).toBe(true)
     expect(agent.status).toBe('idle')
   })
 
-  it('whenIdle() awaits the running→idle transition, ignoring other subjects/running events', async () => {
-    const adapter = new MockAdapter([textResponse('ok'), textResponse('ok')])
-    const ctx = await harness(adapter)
+  it('contains a throwing status listener on both transitions', async () => {
+    const ctx = await harness(new MockAdapter([textResponse('ok')]))
+    const warn = vi.spyOn(ctx.logger, 'warn').mockImplementation(() => undefined)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-    const other = ctx.agentLoop.create(SessionId('a2'), { provider: 'mock', model: 'mock' })
-
-    // Drive `agent` into `running`, then await whenIdle() — it subscribes to
-    // agent/status and resolves on the first transition out of running.
-    const running = new Promise<void>((resolve) => {
-      const dispose = ctx.on('agent/status', (subject, status) => {
-        if (subject === agent && status === 'running') { dispose(); resolve() }
-      })
+    ctx.on('agent/status', (_subject, status) => {
+      throw new Error(`bad ${status} listener`)
     })
+
     send(agent, 'go')
-    await running
-    expect(agent.status).toBe('running')
-
-    // While `agent`'s whenIdle is pending, churn `other` through running→idle:
-    // every status event it emits hits whenIdle's guard with `subject !== this`,
-    // so the wait must ignore them and only resolve on `agent`'s own idle.
-    send(other, 'go')
-
     await agent.whenIdle()
-    expect(agent.status).toBe('idle')
-  })
 
-  it('whenIdle() subscribed while running resolves via done when the agent is then disposed', async () => {
-    // Covers the waiter's disposed arm: whenIdle() queues an internal waiter
-    // while running (not the fast path), then the disposer settles it and chains
-    // `done` (loop exit), not an eager resolve. A bare Agent + direct
-    // internal driver disposer keeps the emit synchronous.
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    await ctx.plugin(SessionStore)
-    await ctx.plugin(SystemPrompt)
-    await ctx.plugin(ToolRegistry)
-    await ctx.plugin(AgentRegistry)
-    const adapter = new MockAdapter(['hang'])
-    ctx.llm.registerAdapter(['mock'], adapter)
-    const session = ctx.sessions.create(SessionId('bare'))
-    const prepared = prepareReactLoopAgent(
-      ctx, SessionId('bare'), { provider: 'mock', model: 'mock' }, session, DEFAULT_MAX_PARALLEL_TOOL_CALLS,
+    expect(agent.status).toBe('idle')
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining('agent event "agent/status" listener threw'),
     )
-    const { agent } = prepared
-    prepared.markPublished()
-    const dispose = prepared.startDriver()
-    agent.followup([{ type: 'text', text: 'go' }])
-    await new Promise(r => setTimeout(r, 30))
-    expect(agent.status).toBe('running')
-
-    const idle = agent.whenIdle() // queues an internal waiter (running)
-    const disposal = dispose() // settles the waiter synchronously; whenIdle chains done
-    await idle
-    expect(agent.status).toBe('disposed')
-    await disposal
-  })
-
-  it('whenIdle() subscribed while running survives a FIBER dispose (no hung promise)', async () => {
-    // The waiter is internal agent state, NOT an effect-scoped ctx.on listener:
-    // disposing the OWNING fiber runs the agent's listener disposers, which would
-    // have dropped a ctx.on-based waiter before the 'disposed' transition and
-    // hung the promise. With internal waiters, the fiber disposer still settles it.
-    const adapter = new MockAdapter(['hang'])
-    const ctx = await harness(adapter)
-    let agent!: Agent
-    const fiber = await ctx.plugin(Object.assign((inner: Context) => {
-      agent = inner.agentLoop.create(SessionId('scoped'), { provider: 'mock', model: 'mock' })
-    }, { inject: ['agentLoop'] }))
-    send(agent, 'go')
-    await new Promise(r => setTimeout(r, 30))
-    expect(agent.status).toBe('running')
-
-    const idle = agent.whenIdle() // queued while running
-    await fiber.dispose()         // tears the fiber down (drops agent listeners)
-    await idle                    // must resolve, not hang
-    expect(agent.status).toBe('disposed')
-  })
-
-  it('whenIdle() on a disposed agent awaits the loop exit (done), not just the status flip', async () => {
-    // The disposer emits agent/status('disposed') BEFORE the driver loop
-    // unwinds, so whenIdle() must chain `done` (true quiescence) on the
-    // disposed path. Dispose a running agent, then assert whenIdle() resolves
-    // only after `done` — i.e. the loop has actually exited.
-    const adapter = new MockAdapter(['hang'])
-    const ctx = await harness(adapter)
-    let agent!: Agent
-    const fiber = await ctx.plugin(Object.assign((inner: Context) => {
-      agent = inner.agentLoop.create(SessionId('scoped'), { provider: 'mock', model: 'mock' })
-    }, { inject: ['agentLoop'] }))
-    send(agent, 'go')
-    await new Promise(r => setTimeout(r, 30))
-
-    let doneResolved = false
-    void driverDone(agent).then(() => { doneResolved = true })
-    await fiber.dispose() // sets status disposed, aborts, drains the loop
-    expect(agent.status).toBe('disposed')
-
-    // whenIdle() must not resolve before `done` has — chaining `done` is the
-    // quiescence guarantee. By here dispose() awaited the loop, so done is
-    // settled; whenIdle resolves and done is observed resolved.
-    await agent.whenIdle()
-    expect(doneResolved).toBe(true)
-  })
-
-  it('contains a throwing agent/status listener on the running transition', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    const warn = vi.spyOn(ctx.logger, 'warn').mockImplementation(() => undefined)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-    ctx.on('agent/status', (_subject, status) => {
-      if (status === 'running') throw new Error('bad running listener')
-    })
-
-    send(agent, 'go')
-    await agent.whenIdle()
-
-    expect(adapter.requests).toHaveLength(1)
-    expect(agent.status).toBe('idle')
-    expect(warn).toHaveBeenCalledWith(expect.stringContaining('agent event "agent/status" listener threw'))
-    warn.mockRestore()
-  })
-
-  it('contains a throwing agent/status listener on the idle transition', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    const warn = vi.spyOn(ctx.logger, 'warn').mockImplementation(() => undefined)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-    ctx.on('agent/status', (_subject, status) => {
-      if (status === 'idle') throw new Error('bad idle listener')
-    })
-
-    send(agent, 'go')
-    await agent.whenIdle()
-
-    expect(adapter.requests).toHaveLength(1)
-    expect(agent.status).toBe('idle')
-    expect(warn).toHaveBeenCalledWith(expect.stringContaining('agent event "agent/status" listener threw'))
-    warn.mockRestore()
   })
 })

packages/core/agent-loop/tests/cancel.spec.ts

@@ -8,7 +8,7 @@
 
 import { describe, expect, it, vi } from 'vitest'
 import { Context } from 'cordis'
-import LlmService, { type Message } from '@deepseek-ai/dsh-llm'
+import LlmService from '@deepseek-ai/dsh-llm'
 import SessionStore, { SessionId, TurnEndReason } from '@deepseek-ai/dsh-session'
 import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
 import ToolRegistry, { defineContentToolFixture, TOOL_ABORTED_BEFORE_DISPATCH } from '@deepseek-ai/dsh-tools'
@@ -33,7 +33,7 @@ async function harness(adapter: MockAdapter) {
 }
 
 function send(agent: Agent, text: string) {
-  agent.followup([{ type: 'text', text }])
+  agent.followup({ content: [{ type: 'text', text }], source: { kind: 'user' } })
 }
 
 /** Resolve on the agent's next idle transition (event-based, not status poll). */
@@ -63,7 +63,7 @@ describe('Agent.cancel()', () => {
     ctx.on('agent/cancel-requested', (subject, cause) => {
       if (subject !== agent) return
       seen.push(`first:${cause.kind}`)
-      subject.followup([{ type: 'text', text: 'queued by cancel observer' }])
+      subject.followup({ content: [{ type: 'text', text: 'queued by cancel observer' }], source: { kind: 'user' } })
       throw new Error('observer failed')
     })
     ctx.on('agent/cancel-requested', (subject, cause) => {
@@ -71,7 +71,7 @@ describe('Agent.cancel()', () => {
     })
 
     send(agent, 'drop me')
-    agent.cancel()
+    agent.cancel({ kind: 'user' })
     await new Promise(resolve => setTimeout(resolve, 30))
     agent.cancel({ kind: 'parent' })
 
@@ -104,12 +104,17 @@ describe('Agent.cancel()', () => {
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
     const discards: unknown[] = []
     ctx.on('agent/inbox/discard', (subject, items) => { if (subject === agent) discards.push(items) })
+    const cancelRequests: unknown[] = []
+    ctx.on('agent/cancel-requested', (subject, cause) => { if (subject === agent) cancelRequests.push(cause) })
 
     // Queue a turn WITHOUT waking the driver, so it sits in the inbox.
-    agent.queue([{ type: 'text', text: 'preserved' }])
-    // keepInbox cancel: no active turn, work preserved, no discard event.
+    agent.send({ content: [{ type: 'text', text: 'preserved' }], source: { kind: 'user' } }, { target: 'next-turn', wakeup: false })
+    // keepInbox cancel: no active turn, work preserved, no discard event. With
+    // nothing to abort and nothing discarded, the call is a documented no-op,
+    // so it emits no cancel-requested either.
     agent.cancel({ kind: 'user' }, { keepInbox: true })
     expect(discards).toEqual([])
+    expect(cancelRequests).toEqual([])
 
     // The preserved item still runs once the driver is woken by a later send.
     send(agent, 'wake it')
@@ -117,14 +122,14 @@ describe('Agent.cancel()', () => {
     expect(userTexts(agent)).toEqual(['preserved', 'wake it'])
   })
 
-  it('a lone queued message leaves the agent parked at idle', async () => {
+  it('a lone quiet (wakeup:false) send leaves the agent parked at idle', async () => {
     const adapter = new MockAdapter([textResponse('reply')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     // A quiet item alone must NOT wake the driver: no turn runs and whenIdle
     // resolves (the agent is quiescent), leaving the item queued.
-    agent.queue([{ type: 'text', text: 'quiet' }])
+    agent.send({ content: [{ type: 'text', text: 'quiet' }], source: { kind: 'user' } }, { target: 'next-turn', wakeup: false })
     await agent.whenIdle()
     expect(agent.status).toBe('idle')
     expect(agent.session.events.some(e => e.type === 'turn/start')).toBe(false)
@@ -140,7 +145,7 @@ describe('Agent.cancel()', () => {
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    agent.queue([{ type: 'text', text: 'quiet' }])
+    agent.send({ content: [{ type: 'text', text: 'quiet' }], source: { kind: 'user' } }, { target: 'next-turn', wakeup: false })
     const idle = agent.whenIdle()
     agent.cancel({ kind: 'user' })
     await idle
@@ -190,7 +195,7 @@ describe('Agent.cancel()', () => {
     await disposalDone
     await driverDone(agent)
 
-    expect(agent.status).toBe('disposed')
+    expect(agent.status).toBe('idle')
     expect(agent.session.events.some(event => event.type === 'turn/start')).toBe(false)
     expect(userTexts(agent)).toEqual([])
     expect(adapter.requests).toHaveLength(0)
@@ -215,101 +220,6 @@ describe('Agent.cancel()', () => {
     expect(agent.status).toBe('idle')
   })
 
-  it('cancel() between consecutive turns restores idle and leaves idle steer usable', async () => {
-    const adapter = new MockAdapter([textResponse('first reply'), textResponse('steer reply')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('between-turn-cancel'), { provider: 'mock', model: 'mock' })
-
-    let rejectFirstFlush = true
-    ctx.on('session/flush', (session) => {
-      if (session !== agent.session || !rejectFirstFlush) return
-      rejectFirstFlush = false
-      throw new Error('first flush failed')
-    })
-
-    const cancelled = Promise.withResolvers<undefined>()
-    ctx.on('agent/error', (subject, _turn, _step, error) => {
-      if (subject !== agent || error.message !== 'first flush failed') return
-      // The first hop runs before runLoop resumes from runTurn; the second lands
-      // before its resolved waitForQueued continuation checks cancellation.
-      queueMicrotask(() => {
-        queueMicrotask(() => {
-          agent.cancel({ kind: 'user' })
-          cancelled.resolve(undefined)
-        })
-      })
-    })
-
-    const statuses: string[] = []
-    ctx.on('agent/status', (subject, status) => {
-      if (subject === agent) statuses.push(status)
-    })
-
-    send(agent, 'first')
-    send(agent, 'queued tail')
-    await cancelled.promise
-
-    expect(agent.status).toBe('idle')
-    expect(statuses).toEqual(['running', 'idle'])
-    expect(adapter.requests).toHaveLength(1)
-    expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(1)
-    expect(userTexts(agent)).toEqual(['first'])
-
-    let idleResolved = false
-    void agent.whenIdle().then(() => { idleResolved = true })
-    await Promise.resolve()
-    expect(idleResolved).toBe(true)
-
-    const idle = waitForIdle(ctx, agent)
-    agent.steer([{ type: 'text', text: 'idle steer' }])
-    await idle
-
-    expect(statuses).toEqual(['running', 'idle', 'running', 'idle'])
-    expect(adapter.requests).toHaveLength(2)
-    expect(userTexts(agent)).toEqual(['first', 'idle steer'])
-  })
-
-  it('an idle-listener replacement keeps whenIdle pending until the replacement turn finishes', async () => {
-    const adapter = new MockAdapter([textResponse('first reply'), textResponse('replacement reply')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('between-turn-idle-listener'), { provider: 'mock', model: 'mock' })
-
-    let rejectFirstFlush = true
-    ctx.on('session/flush', (session) => {
-      if (session !== agent.session || !rejectFirstFlush) return
-      rejectFirstFlush = false
-      throw new Error('first flush failed')
-    })
-
-    ctx.on('agent/error', (subject, _turn, _step, error) => {
-      if (subject !== agent || error.message !== 'first flush failed') return
-      queueMicrotask(() => {
-        queueMicrotask(() => { agent.cancel({ kind: 'user' }) })
-      })
-    })
-
-    const replacementRegistered = Promise.withResolvers<undefined>()
-    let replacementObservation: Promise<{ status: string; requests: number; turns: number }> | undefined
-    ctx.on('agent/status', (subject, status) => {
-      if (subject !== agent || status !== 'idle' || replacementObservation !== undefined) return
-      send(agent, 'replacement')
-      replacementObservation = agent.whenIdle().then(() => ({
-        status: agent.status,
-        requests: adapter.requests.length,
-        turns: agent.session.events.filter(event => event.type === 'turn/start').length,
-      }))
-      replacementRegistered.resolve(undefined)
-    })
-
-    send(agent, 'first')
-    send(agent, 'cancelled tail')
-    await replacementRegistered.promise
-    if (replacementObservation === undefined) throw new Error('idle listener did not register replacement work')
-
-    await expect(replacementObservation).resolves.toEqual({ status: 'idle', requests: 2, turns: 2 })
-    expect(userTexts(agent)).toEqual(['first', 'replacement'])
-  })
-
   it('idle-listener cancellation settles its waiter without cancelling later work', async () => {
     const adapter = new MockAdapter([textResponse('first reply'), textResponse('later reply')])
     const ctx = await harness(adapter)
@@ -391,22 +301,6 @@ describe('Agent.cancel()', () => {
     expect(adapter.requests).toHaveLength(1)
   })
 
-  it('cancel() with no cause defaults to user when aborting an active turn', async () => {
-    const adapter = new MockAdapter(['hang'])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    const reasons: TurnEndReason[] = []
-    ctx.on('session/event', (_s, event) => { if (event.type === 'turn/end') reasons.push(event.data.reason) })
-
-    send(agent, 'go')
-    await new Promise(r => setTimeout(r, 30))
-    agent.cancel()
-    await waitForIdle(ctx, agent)
-
-    expect(reasons).toEqual([{ kind: 'aborted' }])
-  })
-
   it('cancel from an assistant/message observer skips execution but balances replay', async () => {
     const adapter = new MockAdapter([
       toolCallResponse('c1', 'danger', {}),
@@ -482,98 +376,6 @@ describe('Agent.cancel()', () => {
     expect(reasons.length).toBe(2)
   })
 
-  it('cancel from inside the agent/session-prefix waterfall drops the step (prefix-composition window)', async () => {
-    const adapter = new MockAdapter([textResponse('should not stream')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    // Prefix composition runs before the pre-step seam on the instance's first
-    // step; a cancel landing inside it must drop the about-to-start step
-    // without running the seam or the model.
-    let streamed = false
-    ctx.on('session/event', (_s, event) => { if (event.type === 'assistant/chunk') streamed = true })
-    ctx.on('agent/session-prefix', async (_agent, _prefix, _signal, next) => {
-      agent.cancel({ kind: 'user' })
-      return next()
-    })
-
-    const reasons: TurnEndReason[] = []
-    ctx.on('session/event', (_s, event) => { if (event.type === 'turn/end') reasons.push(event.data.reason) })
-
-    send(agent, 'go')
-    await waitForIdle(ctx, agent)
-
-    expect(streamed).toBe(false)
-    expect(reasons).toEqual([{ kind: 'aborted' }])
-  })
-
-  it('disposal from inside the agent/session-prefix waterfall ends the turn disposed (prefix-composition window)', async () => {
-    const adapter = new MockAdapter([textResponse('should not stream')])
-    const ctx = new Context()
-    await ctx.plugin(LlmService)
-    await ctx.plugin(SessionStore)
-    await ctx.plugin(SystemPrompt)
-    await ctx.plugin(ToolRegistry)
-    await ctx.plugin(AgentRegistry)
-    await ctx.plugin(AgentLoop, { agents: [] })
-    ctx.llm.registerAdapter(['mock'], adapter)
-
-    const handle = await ctx.agents.create({
-      sessionId: SessionId('dispose-prefix-session'),
-      agentOptions: { provider: 'mock', model: 'mock' },
-    })
-    const agent = handle.agent
-
-    let disposalDone: Promise<void> | undefined
-    let streamed = false
-    ctx.on('session/event', (_s, event) => { if (event.type === 'assistant/chunk') streamed = true })
-    ctx.on('agent/session-prefix', async (_agent, _prefix, _signal, next) => {
-      disposalDone = handle.dispose()
-      return next()
-    })
-
-    send(agent, 'go')
-    await new Promise(resolve => setTimeout(resolve, 0))
-    await disposalDone
-    await driverDone(agent)
-
-    // No step opened, no model call ran, and the turn closed disposed.
-    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' })
-  })
-
-  it('a cancel-interrupted prefix composition is discarded: the next send recomposes and ships the fresh prefix (stale-cache guard)', async () => {
-    const adapter = new MockAdapter([textResponse('reply')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    // The interrupted first composition must not cache its degraded empty value;
-    // the next prompt recomposes and logs/sends the fresh prefix.
-    const opener: Message = { role: 'user', content: [{ type: 'text', text: 'fresh opener' }] }
-    let compositions = 0
-    ctx.on('agent/session-prefix', async (_agent, _prefix, _signal, next): Promise<Message[]> => {
-      compositions += 1
-      if (compositions === 1) {
-        agent.cancel({ kind: 'user' })
-        return next()
-      }
-      return [opener, ...await next()]
-    })
-
-    send(agent, 'dropped')
-    await waitForIdle(ctx, agent)
-    send(agent, 'real prompt')
-    await waitForIdle(ctx, agent)
-
-    expect(compositions).toBe(2)
-    expect(adapter.requests).toHaveLength(1)
-    expect(adapter.requests[0]?.messages[0]).toEqual(opener)
-    const headerEvent = agent.session.events.find(e => e.type === 'request/header')
-    expect(headerEvent?.type === 'request/header' && headerEvent.data.header.messagePrefix).toEqual([opener])
-  })
-
   it('cancel from a synchronous turn/start session-event listener drops the step (step-start window)', async () => {
     const adapter = new MockAdapter([textResponse('should not stream')])
     const ctx = await harness(adapter)
@@ -667,11 +469,7 @@ describe('Agent.cancel()', () => {
     expect(types.filter(t => t === 'step/start').length).toBe(types.filter(t => t === 'step/end').length)
   })
 
-  it('cancel during the continuation window ends the turn aborted and runs no further step', async () => {
-    // A continuation-waterfall listener cancels DURING the continuation decision
-    // (the finished step's AbortController is already cleared), and votes to
-    // continue — but the turn-scoped marker checked right after must end the turn
-    // `aborted` and run NO second step.
+  it('cancel during the stopping window ends the turn aborted and runs no further step', async () => {
     const adapter = new MockAdapter([textResponse('one'), textResponse('two')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
@@ -683,20 +481,18 @@ describe('Agent.cancel()', () => {
       if (event.type === 'turn/end') reasons.push(event.data.reason)
     })
 
-    let continued = false
-    ctx.on('agent/turn-continuation', async (subject, _turn, _default, _signal, next) => {
-      if (subject === agent && !continued) {
-        continued = true
+    let cancelled = false
+    ctx.on('agent/turn-stopping', (subject) => {
+      if (subject === agent && !cancelled) {
+        cancelled = true
         agent.cancel({ kind: 'user' })
-        return { action: 'continue' as const }
       }
-      return next()
     })
 
     send(agent, 'go')
     await waitForIdle(ctx, agent)
 
-    // Only ONE step ran (the second was cancelled in the continuation window),
+    // 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' }])
@@ -782,7 +578,7 @@ describe('Agent.cancel()', () => {
     expect(agent.status).toBe('running')
     // Steer (joins the running turn's steering FIFO), then cancel: the steering
     // must be dropped, NOT re-enqueued as a new queued turn.
-    agent.steer([{ type: 'text', text: 'steer text' }])
+    agent.steer({ content: [{ type: 'text', text: 'steer text' }], source: { kind: 'user' } })
     agent.cancel({ kind: 'user' })
     await waitForIdle(ctx, agent)
 
@@ -855,51 +651,7 @@ describe('Agent.cancel()', () => {
     expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted' })
   })
 
-  it('retires turn cancellation before terminal publication and a blocked durability flush', async () => {
-    const adapter = new MockAdapter([textResponse('done')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('terminal-cancellation-authority'), { provider: 'mock', model: 'mock' })
-    const flushStarted = Promise.withResolvers<undefined>()
-    const releaseFlush = Promise.withResolvers<undefined>()
-    let abortedDuringTurnEnd: boolean | undefined
-    let cancelNotifications = 0
-
-    ctx.on('agent/cancel-requested', (subject) => {
-      if (subject === agent) cancelNotifications += 1
-    })
-    ctx.on('session/event', (session, event) => {
-      if (session !== agent.session || event.type !== 'turn/end') return
-      const signal = adapter.requests[0]?.signal
-      if (signal === undefined) throw new Error('model request omitted its turn signal')
-      agent.cancel({ kind: 'user' })
-      abortedDuringTurnEnd = signal.aborted
-    })
-    ctx.on('session/flush', async (session) => {
-      if (session !== agent.session) return
-      flushStarted.resolve(undefined)
-      await releaseFlush.promise
-    })
-
-    send(agent, 'finish before persistence drains')
-    await flushStarted.promise
-    const signal = adapter.requests[0]?.signal
-    if (signal === undefined) throw new Error('model request omitted its turn signal')
-    const idle = agent.whenIdle()
-    agent.cancel({ kind: 'user' })
-
-    expect(abortedDuringTurnEnd).toBe(false)
-    expect(signal.aborted).toBe(false)
-    expect(cancelNotifications).toBe(0)
-    expect(agent.session.events.findLast(event => event.type === 'turn/end')).toMatchObject({
-      data: { reason: { kind: 'completed' } },
-    })
-
-    releaseFlush.resolve(undefined)
-    await idle
-    expect(agent.status).toBe('idle')
-  })
-
-  it('records disposed when lifecycle teardown races an already-requested cancel', async () => {
+  it('preserves the first user cancellation when lifecycle teardown races it', async () => {
     const adapter = new MockAdapter(['hang'])
     const ctx = await harness(adapter)
     const handle = await ctx.agents.create({
@@ -914,19 +666,15 @@ 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: 'disposed' })
+    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted' })
   })
 
   it.each([
     'prompt-submit',
     'system-prompt',
-    'session-prefix',
-    'pre-step',
+    'step',
     'request',
-    'step-result',
-    'post-step',
-    'turn-continuation',
-    'turn-stop',
+    'stopping',
     'tool',
   ] as const)('lets a cooperative %s boundary settle from the explicit turn signal', async (stage) => {
     const adapter = new MockAdapter(stage === 'tool'
@@ -959,44 +707,19 @@ describe('Agent.cancel()', () => {
           return next()
         })
         break
-      case 'session-prefix':
-        ctx.on('agent/session-prefix', async (subject, _prefix, signal, next) => {
-          if (subject === agent) await blockUntilAbort(signal)
-          return next()
-        })
-        break
-      case 'pre-step':
-        ctx.on('agent/pre-step', async (subject, _turn, _step, signal) => {
+      case 'step':
+        ctx.on('agent/step', async (subject, _turn, _step, signal) => {
           if (subject === agent) await blockUntilAbort(signal)
         })
         break
       case 'request':
-        ctx.on('agent/request', async (subject, _turn, _step, _config, signal, next) => {
+        ctx.on('agent/request', async (subject, _turn, _step, signal, next) => {
           if (subject === agent) await blockUntilAbort(signal)
           return next()
         })
         break
-      case 'step-result':
-        ctx.on('agent/step-result', async (subject, _turn, _step, _message, signal, next) => {
-          if (subject === agent) await blockUntilAbort(signal)
-          return next()
-        })
-        break
-      case 'post-step':
-        ctx.on('agent/post-step', async (subject, _turn, _step, signal) => {
-          if (subject !== agent) return
-          await blockUntilAbort(signal)
-          throw new Error('post-step failed after cancellation')
-        })
-        break
-      case 'turn-continuation':
-        ctx.on('agent/turn-continuation', async (subject, _turn, _decision, signal, next) => {
-          if (subject === agent) await blockUntilAbort(signal)
-          return next()
-        })
-        break
-      case 'turn-stop':
-        ctx.on('agent/turn-stop', async (subject, _turn, signal) => {
+      case 'stopping':
+        ctx.on('agent/turn-stopping', async (subject, _turn, signal) => {
           if (subject === agent) await blockUntilAbort(signal)
         })
         break
@@ -1016,11 +739,15 @@ describe('Agent.cancel()', () => {
 
     send(agent, 'go')
     await started.promise
-    const idle = waitForIdle(ctx, agent)
+    const idle = agent.whenIdle()
     agent.cancel({ kind: 'user' })
     await idle
     const turnEnd = agent.session.events.findLast(event => event.type === 'turn/end')
-    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted' })
+    if (stage === 'prompt-submit') {
+      expect(turnEnd).toBeUndefined()
+    } else {
+      expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'aborted' })
+    }
     await ctx.fiber.dispose()
   })
 })

packages/core/agent-loop/tests/config-session-id.spec.ts

@@ -89,7 +89,7 @@ describe('config-driven session id', () => {
     const ctx = await makeCoreContext()
     await ctx.plugin(SessionPersistenceJsonl, { root })
     ctx.llm.registerAdapter(['mock'], new MockAdapter([textResponse('first'), textResponse('second')]))
-    const config = { agents: [{ id: 'main', sessionId: SessionId('config-exact-reload'), model: 'mock' }] }
+    const config = { agents: [{ id: 'main', sessionId: SessionId('config-exact-reload'), provider: 'mock', model: 'mock' }] }
 
     const firstLoop = await ctx.plugin(AgentLoop, config)
     let first: Agent | undefined
@@ -98,7 +98,7 @@ describe('config-driven session id', () => {
       first = ctx.agents.get(SessionId('config-exact-reload'))
     }
     expect(first).toBeDefined()
-    first!.followup([{ type: 'text', text: 'remember me' }], { source: { kind: 'user' } })
+    first!.followup({ content: [{ type: 'text', text: 'remember me' }], source: { kind: 'user' } })
     await waitForIdle(ctx, first!)
     await firstLoop.dispose()
 
@@ -110,7 +110,7 @@ describe('config-driven session id', () => {
     }
     expect(second).toBeDefined()
     expect(JSON.stringify(second!.session.deriveMessages())).toContain('remember me')
-    second!.followup([{ type: 'text', text: 'continue' }], { source: { kind: 'user' } })
+    second!.followup({ content: [{ type: 'text', text: 'continue' }], source: { kind: 'user' } })
     await waitForIdle(ctx, second!)
     await ctx.sessions.flush(second!.session)
     const loaded = await ctx.sessionPersistence.load(SessionId('config-exact-reload'))
@@ -131,20 +131,20 @@ describe('config-driven session id', () => {
     await expect.poll(() => ctx.agents.get(sessionId)).toBeDefined()
     const first = ctx.agents.get(sessionId) as Agent
 
-    const flushGate = Promise.withResolvers<undefined>()
-    let flushStarted = false
-    ctx.on('session/flush', (session) => {
-      if (session !== first.session) return
-      flushStarted = true
-      return flushGate.promise
+    const cleanupGate = Promise.withResolvers<undefined>()
+    const cleanupStarted = Promise.withResolvers<undefined>()
+    first.ctx.effect(() => async () => {
+      cleanupStarted.resolve(undefined)
+      await cleanupGate.promise
     })
-    first.inject([{ type: 'text', text: 'persist before replacement' }], {
-      source: { kind: 'plugin', plugin: 'test' },
-    })
-    expect(flushStarted).toBe(true)
+    first.inject({ content: [{ type: 'text', text: 'persist before replacement' }], source: { kind: 'plugin', plugin: 'test' } })
+    await ctx.sessions.flush(first.session)
+    expect(JSON.stringify((await ctx.sessionPersistence.inspect(sessionId)).events))
+      .toContain('persist before replacement')
 
     const firstDisposal = firstLoop.dispose()
-    await expect.poll(() => first.status).toBe('disposed')
+    await cleanupStarted.promise
+    expect(first.status).toBe('idle')
     const failures: unknown[] = []
     ctx.on('agent-loop/config-start-failed', (_id, error) => { failures.push(error) })
     const secondLoop = await ctx.plugin(AgentLoop, config)
@@ -152,7 +152,7 @@ describe('config-driven session id', () => {
     expect(ctx.agents.get(sessionId)).toBe(first)
     expect(failures).toEqual([])
 
-    flushGate.resolve(undefined)
+    cleanupGate.resolve(undefined)
     await firstDisposal
     await expect.poll(() => ctx.agents.get(sessionId)).toBeDefined()
     const second = ctx.agents.get(sessionId) as Agent
@@ -175,21 +175,25 @@ describe('config-driven session id', () => {
     await expect.poll(() => ctx.agents.get(sessionId)).toBeDefined()
     const first = ctx.agents.get(sessionId) as Agent
 
-    const flushGate = Promise.withResolvers<undefined>()
-    ctx.on('session/flush', (session) => {
-      if (session === first.session) return flushGate.promise
-    })
-    first.inject([{ type: 'text', text: 'persist before cancellation' }], {
-      source: { kind: 'plugin', plugin: 'test' },
+    const cleanupGate = Promise.withResolvers<undefined>()
+    const cleanupStarted = Promise.withResolvers<undefined>()
+    first.ctx.effect(() => async () => {
+      cleanupStarted.resolve(undefined)
+      await cleanupGate.promise
     })
+    first.inject({ content: [{ type: 'text', text: 'persist before cancellation' }], source: { kind: 'plugin', plugin: 'test' } })
+    await ctx.sessions.flush(first.session)
+    expect(JSON.stringify((await ctx.sessionPersistence.inspect(sessionId)).events))
+      .toContain('persist before cancellation')
 
     const firstDisposal = firstLoop.dispose()
-    await expect.poll(() => first.status).toBe('disposed')
+    await cleanupStarted.promise
+    expect(first.status).toBe('idle')
     const secondLoop = await ctx.plugin(AgentLoop, config)
     await secondLoop.dispose()
     expect(ctx.agents.get(sessionId)).toBe(first)
 
-    flushGate.resolve(undefined)
+    cleanupGate.resolve(undefined)
     await firstDisposal
     expect(ctx.agents.get(sessionId)).toBeUndefined()
     await ctx.fiber.dispose()
@@ -268,14 +272,14 @@ describe('config-driven session id', () => {
   })
 
   it.each(['resolve', 'reject'] as const)(
-    'joins an exact-id persistence lookup that will %s before AgentLoop disposal completes',
+    'abandons an exact-id persistence lookup that later %s when AgentLoop disposal starts',
     async (outcome) => {
       const root = await mkdtemp(join(tmpdir(), 'dsh-cfg-exact-dispose-'))
       dirs.push(root)
       const ctx = await makeCoreContext()
       await ctx.plugin(SessionPersistenceJsonl, { root })
-      const listing = Promise.withResolvers<Awaited<ReturnType<typeof ctx.sessionPersistence.list>>>()
-      vi.spyOn(ctx.sessionPersistence, 'list').mockReturnValue(listing.promise)
+      const loading = Promise.withResolvers<Awaited<ReturnType<typeof ctx.sessionPersistence.load>>>()
+      vi.spyOn(ctx.sessionPersistence, 'load').mockReturnValue(loading.promise)
       const warn = vi.spyOn(ctx.logger, 'warn').mockImplementation(() => undefined)
       const failures: unknown[] = []
       ctx.on('agent-loop/config-start-failed', (_sessionId, error) => { failures.push(error) })
@@ -283,14 +287,20 @@ describe('config-driven session id', () => {
       const loop = await ctx.plugin(AgentLoop, {
         agents: [{ id: 'main', sessionId: SessionId('config-exact-dispose'), model: 'mock' }],
       })
-      let disposed = false
-      const disposal = loop.dispose().then(() => { disposed = true })
+      await loop.dispose()
+      if (outcome === 'resolve') {
+        loading.resolve({
+          meta: {
+            id: SessionId('config-exact-dispose'),
+            version: 0,
+            createdAt: Date.now(),
+          },
+          events: [],
+        })
+      } else {
+        loading.reject(new Error('startup cancelled by teardown'))
+      }
       await Promise.resolve()
-      expect(disposed).toBe(false)
-
-      if (outcome === 'resolve') listing.resolve([])
-      else listing.reject(new Error('startup cancelled by teardown'))
-      await disposal
       expect(ctx.agents.get(SessionId('config-exact-dispose'))).toBeUndefined()
       expect(failures).toEqual([])
       expect(warn).not.toHaveBeenCalled()
@@ -335,7 +345,7 @@ describe('config-driven session id', () => {
     expect(a1.id).toBe(a1.session.id)
     expect(a1.session.id).toMatch(idPattern)
     expect(ctx1.agents.get(SessionId('cfg'))).toBeUndefined()
-    a1.followup([{ type: 'text', text: 'q' }], { source: { kind: 'user' } })
+    a1.followup({ content: [{ type: 'text', text: 'q' }], source: { kind: 'user' } })
     await waitForIdle(ctx1, a1)
     await ctx1.fiber.dispose()
 
@@ -354,7 +364,7 @@ describe('config-driven session id', () => {
     expect(a2.id).toBe(a2.session.id)
     expect(a2.session.id).toMatch(idPattern)
     expect(a2.session.id).not.toBe(a1.session.id)
-    a2.followup([{ type: 'text', text: 'q2' }], { source: { kind: 'user' } })
+    a2.followup({ content: [{ type: 'text', text: 'q2' }], source: { kind: 'user' } })
     await waitForIdle(ctx2, a2)
     await ctx2.fiber.dispose()
   })
@@ -375,7 +385,7 @@ describe('config-driven session id', () => {
     await ctx1.plugin(SessionPersistenceJsonl, { root })
     ctx1.llm.registerAdapter(['mock'], new MockAdapter([textResponse('first')]))
     const a1 = (await ctx1.agents.create({ sessionId: SessionId('sticky-1') })).agent
-    a1.followup([{ type: 'text', text: 'remember me' }], { source: { kind: 'user' } })
+    a1.followup({ content: [{ type: 'text', text: 'remember me' }], source: { kind: 'user' } })
     await waitForIdle(ctx1, a1)
     await ctx1.fiber.dispose()
 
@@ -431,3 +441,36 @@ describe('config-driven session id', () => {
     await ctx.fiber.dispose()
   })
 })
+
+describe('startup reporting after factory teardown', () => {
+  it('suppresses the configured-restore failure report once the loop is disposed', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'dsh-cfg-disposed-report-'))
+    dirs.push(root)
+    const ctx = await makeCoreContext()
+    await ctx.plugin(SessionPersistenceJsonl, { root })
+    ctx.llm.registerAdapter(['mock'], new MockAdapter([textResponse('x')]))
+
+    // A restore lookup that hangs until after the loop is gone: the eventual
+    // failure lands with ownership inactive and must be silently dropped.
+    const gate = Promise.withResolvers<never>()
+    // The teardown path may drop the pending lookup without awaiting it.
+    gate.promise.catch(() => undefined)
+    vi.spyOn(ctx.sessionPersistence, 'list').mockReturnValue(gate.promise)
+    const failures: unknown[] = []
+    ctx.on('agent-loop/config-start-failed', (_id, error) => { failures.push(error) })
+    const warn = vi.spyOn(ctx.logger, 'warn').mockImplementation(() => undefined)
+
+    const loop = await ctx.plugin(AgentLoop, {
+      agents: [{ id: 'main', sessionId: SessionId('config-disposed-report'), model: 'mock' }],
+    })
+    const disposal = loop.dispose()
+    gate.reject(new Error('backend failed after teardown began'))
+    await disposal
+
+    await new Promise(r => setTimeout(r, 20))
+    expect(failures).toEqual([])
+    expect(warn).not.toHaveBeenCalledWith(expect.stringContaining('config-driven restore'))
+    warn.mockRestore()
+    await ctx.fiber.dispose()
+  })
+})

packages/core/agent-loop/tests/coverage-edges.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
-import LlmService, { CallId, LlmError, StreamChunk } from '@deepseek-ai/dsh-llm'
+import LlmService, { CallId, LlmError, StreamChunk, errorChain } from '@deepseek-ai/dsh-llm'
 import SessionStore, { SessionId, TurnEndReason } from '@deepseek-ai/dsh-session'
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
 import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
@@ -38,33 +38,9 @@ function waitForIdle(ctx: Context, agent: Agent): Promise<void> {
 }
 
 function send(agent: Agent, text: string) {
-  agent.followup([{ type: 'text', text }])
+  agent.followup({ content: [{ type: 'text', text }], source: { kind: 'user' } })
 }
 
-describe('inbox acceptance', () => {
-  it('rejects non-serializable content or source synchronously before notification or enqueue', async () => {
-    const adapter = new MockAdapter([textResponse('turn 1')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-    let queued = 0
-    ctx.on('agent/inbox/enqueue', () => { queued += 1 })
-
-    expect(() => {
-      agent.followup([{ type: 'text', text: 'first', bad: 1n } as never])
-    }).toThrow(/losslessly JSON-serializable/)
-    expect(() => {
-      agent.followup([{ type: 'text', text: 'first' }], { source: { kind: 'plugin', plugin: 'p', bad: 1n } as never })
-    }).toThrow(/losslessly JSON-serializable/)
-    expect(queued).toBe(0)
-    expect(agent.session.events).toHaveLength(0)
-
-    // The rejected value never woke or poisoned the loop; a valid message runs.
-    send(agent, 'second')
-    await waitForIdle(ctx, agent)
-    expect(adapter.requests).toHaveLength(1)
-  })
-})
-
 describe('tool JSON parse', () => {
   it('passes through non-JSON arguments string without crashing', async () => {
     const adapter = new MockAdapter([
@@ -127,8 +103,8 @@ describe('tool JSON parse', () => {
   })
 })
 
-describe('toError normalization', () => {
-  it('normalizes non-Error throws from pre-commit dispatch validation via the runLoop backstop', async () => {
+describe('thrown-value propagation', () => {
+  it('preserves non-Error throws from pre-commit dispatch validation', async () => {
     const adapter = new MockAdapter([textResponse('ok')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
@@ -139,23 +115,25 @@ describe('toError normalization', () => {
       const event = args[1] as SessionEvent
       if (event.type === 'turn/start' && !threwOnce) {
         threwOnce = true
-        throw 'naked string error' // non-Error throw, normalized via toError
+        throw 'naked string error'
       }
     })
 
-    const errors: Error[] = []
+    const errors: unknown[] = []
     ctx.on('agent/error', (_agent, _turn, _step, error) => void errors.push(error))
 
     send(agent, 'fails before turn start')
     send(agent, 'survives as the next item')
     await waitForIdle(ctx, agent)
     expect(errors).toHaveLength(1)
-    expect(errors[0]).toMatchObject({ message: 'naked string error', code: 'UNKNOWN' })
+    expect(errors[0]).toBe('naked string error')
     expect(adapter.requests).toHaveLength(1)
     const starts = agent.session.events.filter(event => event.type === 'turn/start')
     const ends = agent.session.events.filter(event => event.type === 'turn/end')
     const messages = agent.session.events.filter(event => event.type === 'user/message')
     expect(starts).toHaveLength(1)
+    // The rejected turn/start committed nothing, so the survivor reuses turn 1
+    // and the rejected prompt does not leak into it.
     expect(starts[0]?.type === 'turn/start' && starts[0].data.turn).toBe(1)
     expect(ends).toHaveLength(1)
     expect(messages).toHaveLength(1)
@@ -164,32 +142,31 @@ describe('toError normalization', () => {
     ])
   })
 
-  it('normalizes non-Error throws from agent/request waterfall via inline toError in runStep catch', async () => {
+  it('preserves non-Error throws from the agent/request waterfall', async () => {
     const adapter = new MockAdapter([textResponse('irrelevant')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     let threwOnce = false
-    ctx.on('agent/request', async (_agent, _turn, _step, _options, _signal, _next) => {
+    ctx.on('agent/request', async (_agent, _turn, _step, _signal, next) => {
       if (!threwOnce) {
         threwOnce = true
-        throw { code: 500 } // non-Error throw, goes through runStep catch
+        throw { code: 500 }
       }
-      return _next()
+      return next()
     })
 
-    const errors: Error[] = []
+    const errors: unknown[] = []
     ctx.on('agent/error', (_agent, _turn, _step, error) => void errors.push(error))
 
     send(agent, 'go')
     await waitForIdle(ctx, agent)
     expect(errors).toHaveLength(1)
-    // String() of { code: 500 } is '[object Object]'
-    expect(errors[0]!.message).toBe('[object Object]')
+    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))
-      .toBe('UNKNOWN')
+      .toBeUndefined()
   })
 })
 
@@ -200,7 +177,7 @@ describe('coded error data emission', () => {
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     let threwOnce = false
-    ctx.on('agent/request', async (_agent, _turn, _step, _options, _signal, next) => {
+    ctx.on('agent/request', async (_agent, _turn, _step, _signal, next) => {
       if (!threwOnce) {
         threwOnce = true
         throw new LlmError('server overloaded', 'RATE_LIMIT')
@@ -208,13 +185,13 @@ describe('coded error data emission', () => {
       return next()
     })
 
-    const errors: Error[] = []
+    const errors: unknown[] = []
     ctx.on('agent/error', (_agent, _turn, _step, error) => void errors.push(error))
 
     send(agent, 'go')
     await waitForIdle(ctx, agent)
     expect(errors).toHaveLength(1)
-    expect(errors[0]!.message).toBe('server overloaded')
+    expect(errorChain(errors[0])).toBe('server overloaded')
 
     // turn-end error reason includes the code
     const turnEnd = agent.session.events.find(e => e.type === 'turn/end')
@@ -277,3 +254,297 @@ describe('structured tool error propagation (the runtime-validation Agent Note,
       .toEqual({ name: 'HarnessError', code: 'BOOM' })
   })
 })
+
+describe('request-error action edges', () => {
+  it('ignores a retry action returned after the turn was aborted', async () => {
+    const { LlmError } = await import('@deepseek-ai/dsh-llm')
+    const adapter = new MockAdapter([
+      () => { throw new LlmError('busy', 'RATE_LIMIT') },
+      textResponse('never used'),
+    ])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('retry-after-cancel'), { provider: 'mock', model: 'mock' })
+    ctx.on('agent/request-error', async (subject) => {
+      subject.cancel({ kind: 'user' })
+      return { kind: 'retry' }
+    })
+
+    send(agent, 'go')
+    await agent.whenIdle()
+
+    // One failed request, no retry turn.
+    expect(adapter.requests).toHaveLength(1)
+    const ends = agent.session.events.filter(e => e.type === 'turn/end')
+    expect(ends).toHaveLength(1)
+  })
+
+  it('completed recovery does not retry when cancellation raced the waterfall', async () => {
+    const { LlmError } = await import('@deepseek-ai/dsh-llm')
+    const adapter = new MockAdapter([
+      () => { throw new LlmError('busy', 'RATE_LIMIT') },
+    ])
+    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,
+    ) => {
+      await next()
+      subject.cancel({ kind: 'user' })
+      expect(signal.aborted).toBe(true)
+      return { kind: 'retry' }
+    })
+
+    send(agent, 'go')
+    await agent.whenIdle()
+
+    expect(adapter.requests).toHaveLength(1)
+    const end = agent.session.events.findLast(e => e.type === 'turn/end')
+    expect(end?.type === 'turn/end' && end.data.reason.kind).toBe('aborted')
+  })
+})
+
+describe('stream failure edges', () => {
+  it('rethrows a mid-stream throw that carries no adapter failure facts', async () => {
+    const adapter = new MockAdapter([textResponse('will be vetoed')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('stream-no-facts'), { provider: 'mock', model: 'mock' })
+    let recoveries = 0
+    ctx.on('agent/request-error', async () => { recoveries += 1 })
+    // A pre-commit chunk veto throws INSIDE the stream-consumption try, but it
+    // is not an adapter-boundary failure, so llmFailureOf yields no facts.
+    let vetoed = false
+    ctx.on('internal/dispatch', (_mode, name, args) => {
+      if (name !== 'session/event') return
+      const event = args[1] as SessionEvent
+      if (event.type === 'assistant/chunk' && !vetoed) {
+        vetoed = true
+        throw new Error('reject the first chunk')
+      }
+    })
+
+    send(agent, 'go')
+    await agent.whenIdle()
+
+    // No facts -> not offered to recovery; the turn fails through settle().
+    expect(recoveries).toBe(0)
+    const end = agent.session.events.findLast(e => e.type === 'turn/end')
+    expect(end?.type === 'turn/end' && end.data.reason.kind).toBe('error')
+  })
+})
+
+describe('post-turn continuation edges', () => {
+  it('whenIdle resolves for a waiter whose awaited run fails', async () => {
+    const adapter = new MockAdapter([textResponse('unused')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('whenidle-reject'), { provider: 'mock', model: 'mock' })
+    let rejected = false
+    ctx.on('internal/dispatch', (_mode, name, args) => {
+      if (name !== 'session/event') return
+      const event = args[1] as SessionEvent
+      if (event.type === 'turn/start' && !rejected) {
+        rejected = true
+        throw new Error('veto turn start while a waiter is pending')
+      }
+    })
+
+    send(agent, 'go')
+    await expect(agent.whenIdle()).resolves.toBeUndefined()
+    expect(agent.status).toBe('idle')
+  })
+})
+
+describe('persistent step-close rejection', () => {
+  it('still publishes the terminal status when both step-close attempts are vetoed', async () => {
+    const adapter = new MockAdapter([textResponse('will not close')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('stepend-double-veto'), { provider: 'mock', model: 'mock' })
+    // Persistently reject step/end: the catch's own close attempt fails too,
+    // and the contained failure must not strand status at running.
+    ctx.on('internal/dispatch', (_mode, name, args) => {
+      if (name !== 'session/event') return
+      const event = args[1] as SessionEvent
+      if (event.type === 'step/end') throw new Error('step close permanently rejected')
+    })
+    const statuses: string[] = []
+    ctx.on('agent/status', (subject, status) => { if (subject === agent) statuses.push(status) })
+
+    send(agent, 'go')
+    await agent.whenIdle()
+
+    expect(agent.status).toBe('idle')
+    expect(statuses).toEqual(['running', 'idle'])
+  })
+})
+
+describe('tool result meta persistence', () => {
+  it('records a presentationMeta payload on the tool/result event', async () => {
+    const { defineTool } = await import('@deepseek-ai/dsh-tools')
+    const adapter = new MockAdapter([
+      toolCallResponse('c1', 'meta-tool', {}),
+      textResponse('done'),
+    ])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('tool-meta'), { provider: 'mock', model: 'mock' })
+    ctx.tools.register(defineTool({
+      name: 'meta-tool',
+      description: 'carries presentation meta',
+      parameters: {},
+      output: {
+        schema: { type: 'string' },
+        render: (_args, value) => [{ type: 'text', text: value }],
+        presentationMeta: () => ({ presentation: 'diff-card' }),
+      },
+      async execute() {
+        return 'ran'
+      },
+    }))
+
+    send(agent, 'go')
+    await waitForIdle(ctx, agent)
+
+    const result = agent.session.events.find(e => e.type === 'tool/result')
+    expect(result?.type === 'tool/result' && result.data.meta).toEqual({ presentation: 'diff-card' })
+  })
+})
+
+describe('turn close failure containment', () => {
+  it('a rejected turn/end append is contained: warn + agent/error, no retry', async () => {
+    const adapter = new MockAdapter([textResponse('ok')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('turnend-veto'), { provider: 'mock', model: 'mock' })
+    let vetoed = false
+    ctx.on('internal/dispatch', (_mode, name, args) => {
+      if (name !== 'session/event') return
+      const event = args[1] as SessionEvent
+      if (event.type === 'turn/end' && !vetoed) {
+        vetoed = true
+        throw new Error('reject turn end')
+      }
+    })
+    const errors: unknown[] = []
+    ctx.on('agent/error', (_agent, _turn, _step, error) => { errors.push(error) })
+
+    send(agent, 'go')
+    await agent.whenIdle()
+
+    // The close failure is reported live; the machine still reaches idle.
+    expect(errors.map(e => e instanceof Error && e.message)).toContain('reject turn end')
+    expect(agent.status).toBe('idle')
+    expect(adapter.requests).toHaveLength(1)
+  })
+})
+
+describe('recovery without a retry action', () => {
+  it('a completed recovery that returns no action leaves the failed turn terminal', async () => {
+    const { LlmError } = await import('@deepseek-ai/dsh-llm')
+    const adapter = new MockAdapter([
+      () => { throw new LlmError('down', 'SERVICE_UNAVAILABLE') },
+    ])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('recovery-no-retry'), { provider: 'mock', model: 'mock' })
+    let recoveries = 0
+    ctx.on('agent/request-error', async () => { recoveries += 1 })
+
+    send(agent, 'go')
+    await agent.whenIdle()
+
+    expect(recoveries).toBe(1)
+    expect(adapter.requests).toHaveLength(1)
+    const end = agent.session.events.findLast(e => e.type === 'turn/end')
+    expect(end?.type === 'turn/end' && end.data.reason.kind).toBe('error')
+  })
+})
+
+describe('unrenderable failure settlement', () => {
+  it('drops the rendered message when the error chain cannot be rendered', async () => {
+    const { LlmError } = await import('@deepseek-ai/dsh-llm')
+    const adapter = new MockAdapter([
+      () => {
+        const error = new LlmError('will become hostile', 'SERVER')
+        // A hostile message getter makes errorChain collapse to its sentinel;
+        // settle() must then fall back to the failure facts alone.
+        Object.defineProperty(error, 'message', {
+          get() { throw new Error('hostile accessor') },
+        })
+        throw error
+      },
+    ])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('unrenderable'), { provider: 'mock', model: 'mock' })
+
+    send(agent, 'go')
+    await agent.whenIdle()
+
+    const end = agent.session.events.findLast(e => e.type === 'turn/end')
+    expect(end?.type === 'turn/end' && end.data.reason.kind).toBe('error')
+    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>')
+    }
+  })
+})
+
+describe('driver bookkeeping edges', () => {
+  it('a deferred wake settles when replacement activity rejects', async () => {
+    const adapter = new MockAdapter([])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('rejected-deferred-wake'), {
+      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> }
+      mutable.done = Promise.reject(new Error('replacement rejected'))
+    })
+
+    send(agent, 'cancel before wake')
+
+    await expect(agent.whenIdle()).resolves.toBeUndefined()
+    expect(agent.session.events).toEqual([])
+  })
+
+  it('a whenIdle waiter survives a rejected driver promise', async () => {
+    const adapter = new MockAdapter([textResponse('ok')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('waiter-chain'), { provider: 'mock', model: 'mock' })
+    // A throwing terminal-notification listener rejects the driver promise
+    // (the run's containment covers only session appends); the waiter's
+    // catch arm must treat that rejection as quiescence instead of
+    // propagating it.
+    ctx.on('agent/settled', (subject) => {
+      if (subject === agent) throw new Error('settled listener exploded')
+    })
+
+    send(agent, 'one')
+    // Entered while the run owns the abort slot, the waiter awaits the
+    // driver promise; its rejection must count as quiescence and resolve.
+    await expect(agent.whenIdle()).resolves.toBeUndefined()
+  })
+
+  it('a request failure that concludes recovery after step/end closed keeps the boundary balanced', async () => {
+    const { LlmError } = await import('@deepseek-ai/dsh-llm')
+    // The failure finish-chunk path returns request-failed AFTER step() has
+    // already appended step/end, so the request-failed branch's own
+    // step-close guard must see stepOpen === false and skip the append.
+    const adapter = new MockAdapter([
+      [
+        { type: 'usage' as const, usage: { inputTokens: 1, outputTokens: 0 } },
+        { type: 'finish' as const, reason: { kind: 'error' as const, failure: { message: 'empty', code: 'EMPTY_RESPONSE' } } },
+      ] satisfies StreamChunk[],
+    ])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('finish-after-close'), { provider: 'mock', model: 'mock' })
+    void LlmError
+
+    send(agent, 'go')
+    await agent.whenIdle()
+
+    const types = agent.session.events.map(e => e.type)
+    expect(types.filter(t => t === 'step/end')).toHaveLength(1)
+    const end = agent.session.events.findLast(e => e.type === 'turn/end')
+    expect(end?.type === 'turn/end' && end.data.reason.kind).toBe('error')
+  })
+})

packages/core/agent-loop/tests/inbox-invariant.spec.ts

@@ -1,155 +0,0 @@
-/**
- * Regression: the dsh-agent FIFO-conservation invariant must stay balanced on
- * the loop-authored continuation-reason steering path. A continue-with-reason
- * decision enters the steering FIFO and later drains (or is discarded by
- * cancel); both must be matched by an enqueue event so the invariant's
- * outstanding count never goes negative.
- * @module dsh-agent-loop/tests/inbox-invariant
- */
-
-import { describe, expect, it, vi } from 'vitest'
-import { Context } from 'cordis'
-import LlmService from '@deepseek-ai/dsh-llm'
-import SessionStore, { SessionId } from '@deepseek-ai/dsh-session'
-import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
-import ToolRegistry from '@deepseek-ai/dsh-tools'
-import AgentRegistry, { type Agent } from '@deepseek-ai/dsh-agent'
-import * as AgentInvariant from '@deepseek-ai/dsh-agent/invariant'
-import InvariantService from '@deepseek-ai/dsh-invariants'
-import AgentLoop from '@deepseek-ai/dsh-agent-loop'
-import { MockAdapter, textResponse } from './mock-adapter.ts'
-
-async function harness(adapter: MockAdapter) {
-  const ctx = new Context()
-  await ctx.plugin(LlmService)
-  await ctx.plugin(SessionStore)
-  await ctx.plugin(SystemPrompt)
-  await ctx.plugin(ToolRegistry)
-  await ctx.plugin(AgentRegistry)
-  await ctx.plugin(InvariantService)
-  await ctx.plugin(AgentInvariant)
-  await ctx.plugin(AgentLoop, { agents: [] })
-  ctx.llm.registerAdapter(['mock'], adapter)
-  return ctx
-}
-
-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() }
-    })
-  })
-}
-
-describe('inbox FIFO-conservation invariant', () => {
-  it('stays balanced when a continuation reason enters and drains the steering FIFO', async () => {
-    const adapter = new MockAdapter([textResponse('step 1'), textResponse('step 2')])
-    const ctx = await harness(adapter)
-    const warn = vi.spyOn(ctx.logger, 'warn').mockImplementation(() => undefined)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    let forced = false
-    ctx.on('agent/turn-continuation', async (_agent, _turn, _default, _signal, next) => {
-      if (forced) return next()
-      forced = true
-      return { action: 'continue' as const, reason: { content: [{ type: 'text', text: 'keep going' }], source: { kind: 'plugin', plugin: 'loop' } } }
-    })
-
-    agent.followup([{ type: 'text', text: 'go' }])
-    await waitForIdle(ctx, agent)
-
-    expect(adapter.requests).toHaveLength(2)
-    // The continuation reason drained as a steering/message on the second step.
-    expect(agent.session.events.some(e => e.type === 'steering/message')).toBe(true)
-    // No invariant violation was logged.
-    expect(warn.mock.calls.flat().some(arg => String(arg).includes('agent/inbox'))).toBe(false)
-    expect(warn.mock.calls.flat().some(arg => String(arg).includes('INVARIANT'))).toBe(false)
-  })
-
-  it('stays balanced when cancel discards a pending continuation reason', async () => {
-    const adapter = new MockAdapter([textResponse('only step')])
-    const ctx = await harness(adapter)
-    const warn = vi.spyOn(ctx.logger, 'warn').mockImplementation(() => undefined)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    // Force a continuation reason, then cancel from the same checkpoint so the
-    // reason sits in the steering FIFO when the inbox is discarded.
-    ctx.on('agent/turn-continuation', async (subject, _turn, _default, _signal, next) => {
-      if (subject !== agent) return next()
-      queueMicrotask(() => { agent.cancel({ kind: 'user' }) })
-      return { action: 'continue' as const, reason: { content: [{ type: 'text', text: 'keep going' }], source: { kind: 'plugin', plugin: 'loop' } } }
-    })
-
-    agent.followup([{ type: 'text', text: 'go' }])
-    await waitForIdle(ctx, agent)
-
-    expect(warn.mock.calls.flat().some(arg => String(arg).includes('agent/inbox'))).toBe(false)
-    expect(warn.mock.calls.flat().some(arg => String(arg).includes('INVARIANT'))).toBe(false)
-  })
-
-  it('stays balanced when a terminal stop discards pending steering', async () => {
-    const adapter = new MockAdapter([textResponse('done')])
-    const ctx = await harness(adapter)
-    const warn = vi.spyOn(ctx.logger, 'warn').mockImplementation(() => undefined)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    const discards: number[] = []
-    ctx.on('agent/inbox/discard', (subject, messages) => { if (subject === agent) discards.push(messages.length) })
-
-    // A continuation reason enqueues a steering item; a terminal stop then drops
-    // it. The drop must emit a discard so the enqueue ⇒ dequeue-or-discard
-    // ledger stays balanced (no dangling outstanding id).
-    ctx.on('agent/turn-continuation', async (subject, _turn, _default, _signal, next) => {
-      if (subject !== agent) return next()
-      return { action: 'continue' as const, reason: { content: [{ type: 'text', text: 'keep going' }], source: { kind: 'plugin', plugin: 'loop' } } }
-    })
-    let stopped = false
-    ctx.on('agent/turn-stop', (subject) => {
-      if (subject !== agent || stopped) return undefined
-      stopped = true
-      return { action: 'stop' as const }
-    })
-
-    agent.followup([{ type: 'text', text: 'go' }])
-    await waitForIdle(ctx, agent)
-
-    expect(discards).toEqual([1]) // the dropped steering item was reported
-    expect(warn.mock.calls.flat().some(arg => String(arg).includes('agent/inbox'))).toBe(false)
-    expect(warn.mock.calls.flat().some(arg => String(arg).includes('INVARIANT'))).toBe(false)
-  })
-
-  it('stays balanced when late steering lands after a terminal stop (post-turn flush window)', async () => {
-    const adapter = new MockAdapter([textResponse('done')])
-    const ctx = await harness(adapter)
-    const warn = vi.spyOn(ctx.logger, 'warn').mockImplementation(() => undefined)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    let enqueues = 0
-    const discards: number[] = []
-    ctx.on('agent/inbox/enqueue', (subject) => { if (subject === agent) enqueues += 1 })
-    ctx.on('agent/inbox/discard', (subject, messages) => { if (subject === agent) discards.push(messages.length) })
-
-    // Terminal-stop the turn, then steer during the post-turn flush window
-    // (status is still running). That late steer is drained by runLoop and
-    // dropped because the turn terminally stopped; it must still be discarded so
-    // its enqueue is matched (the drain sits on a different code path than the
-    // in-turn terminal-stop drop).
-    ctx.on('agent/turn-stop', subject => (subject === agent ? { action: 'stop' as const } : undefined))
-    let steered = false
-    ctx.on('session/flush', (session) => {
-      if (session !== agent.session || steered) return
-      steered = true
-      agent.steer([{ type: 'text', text: 'late' }], { source: { kind: 'plugin', plugin: 'late' } })
-    })
-
-    agent.followup([{ type: 'text', text: 'go' }])
-    await waitForIdle(ctx, agent)
-
-    // The prompt plus the late steer both enqueued; both are matched (the prompt
-    // dequeued, the late steer discarded) so no id is left outstanding.
-    expect(enqueues).toBe(2)
-    expect(discards).toEqual([1])
-    expect(warn.mock.calls.flat().some(arg => String(arg).includes('agent/inbox'))).toBe(false)
-    expect(warn.mock.calls.flat().some(arg => String(arg).includes('INVARIANT'))).toBe(false)
-  })
-})

packages/core/agent-loop/tests/inbox.spec.ts

@@ -1,139 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { AgentMessageId } from '@deepseek-ai/dsh-agent'
-import { Inbox, agentMessage } from '../src/inbox.ts'
-
-function message(text: string) {
-  return { id: AgentMessageId(text), content: [{ type: 'text' as const, text }], source: { kind: 'user' as const }, contexts: [], wakeup: true }
-}
-
-describe('agentMessage', () => {
-  it('returns a frozen payload so a listener cannot mutate it for later listeners', () => {
-    const payload = agentMessage(message('m'), false)
-    expect(Object.isFrozen(payload)).toBe(true)
-    expect(() => { (payload as { id: string }).id = 'mutated' }).toThrow()
-    expect(payload.id).toBe(AgentMessageId('m'))
-  })
-})
-
-function resolverPair() {
-  let r!: () => void
-  const p = new Promise<void>((resolve) => { r = resolve })
-  return { promise: p, resolve: r }
-}
-
-describe('Inbox', () => {
-  it('dequeues one queued message at a time in FIFO order', () => {
-    const inbox = new Inbox()
-    inbox.enqueue(message('first'))
-    inbox.enqueue(message('second'))
-    expect(inbox.hasQueued).toBe(true)
-
-    expect(inbox.dequeueQueued()?.content[0]).toMatchObject({ text: 'first' })
-    expect(inbox.hasQueued).toBe(true)
-    expect(inbox.dequeueQueued()?.content[0]).toMatchObject({ text: 'second' })
-    expect(inbox.hasQueued).toBe(false)
-    expect(inbox.dequeueQueued()).toBeUndefined()
-  })
-
-  it('enqueue(msg, false) queues without waking a parked waiter', async () => {
-    const inbox = new Inbox()
-    let woke = false
-    const waiter = inbox.waitForQueued(new Promise(() => {})).then(() => { woke = true })
-    inbox.enqueue(message('quiet'), false)
-    // The item is queued, but the parked waiter was not resolved by it.
-    expect(inbox.hasQueued).toBe(true)
-    await Promise.resolve()
-    expect(woke).toBe(false)
-    // A later waking enqueue resolves the same waiter.
-    inbox.enqueue(message('loud'))
-    await waiter
-    expect(woke).toBe(true)
-  })
-
-  it('pending() snapshots queued then steering without removing them', () => {
-    const inbox = new Inbox()
-    inbox.enqueue(message('q'))
-    inbox.steer(message('s'))
-    const pending = inbox.pending()
-    expect(pending.map(p => p.steering)).toEqual([false, true])
-    // Snapshot does not drain the FIFOs.
-    expect(inbox.hasQueued).toBe(true)
-    expect(inbox.hasSteering).toBe(true)
-  })
-
-  it('pushes and drains steering messages separately from queued', () => {
-    const inbox = new Inbox()
-    inbox.steer(message('steer'))
-    expect(inbox.hasQueued).toBe(false)
-    expect(inbox.hasSteering).toBe(true)
-
-    const steering = inbox.drainSteering()
-    expect(steering).toHaveLength(1)
-    expect(inbox.hasSteering).toBe(false)
-  })
-
-  it('waitForQueued returns immediately when a queued message is already present', async () => {
-    const inbox = new Inbox()
-    inbox.enqueue(message('ready'))
-
-    const started = Date.now()
-    await inbox.waitForQueued(new Promise(() => {})) // never-resolving cancel
-    expect(Date.now() - started).toBeLessThan(50)
-  })
-
-  it('waitForQueued resolves when a message is enqueued', async () => {
-    const inbox = new Inbox()
-    const waiter = inbox.waitForQueued(new Promise(() => {})) // never-resolving cancel
-    // enqueue after starting the wait
-    setTimeout(() => { inbox.enqueue(message('wake')) }, 5)
-    await waiter
-  })
-
-  it('waitForQueued resolves when the cancel promise resolves', async () => {
-    const inbox = new Inbox()
-    const { promise, resolve } = resolverPair()
-    const waiter = inbox.waitForQueued(promise)
-    resolve()
-    await waiter
-  })
-
-  it('waitForQueued overwrites the previous wakeup callback (only the latest waiter is notified)', async () => {
-    const inbox = new Inbox()
-    const { promise: p1, resolve: r1 } = resolverPair()
-
-    void inbox.waitForQueued(new Promise(() => {})) // first call, never resolved
-    void inbox.waitForQueued(p1) // second call overwrites wakeup
-
-    // Cancelling the latest waiter clears the shared callback; enqueue must neither
-    // wake the stale waiter nor fail on the cleared callback.
-    r1()
-    await p1
-
-    inbox.enqueue(message('hey'))
-  })
-
-  it('clears wakeup in finally handler when enqueue resolves', async () => {
-    const inbox = new Inbox()
-    void inbox.waitForQueued(new Promise(() => {})) // never-resolving cancel
-    // The wakeup is set. Now trigger it via enqueue → wakeup() calls resolve,
-    // promise resolves, finally clears wakeup because wakeup === resolve.
-    inbox.enqueue(message('wake'))
-    // No explicit await needed — enqueue is synchronous, and the microtask
-    // (finally) runs. The key coverage hit is finally with wakeup === resolve.
-  })
-
-  it('finally handler does not clear wakeup when a different waiter overwrote it', async () => {
-    // A stale waiter's finally must not clear the replacement waiter.
-    const inbox = new Inbox()
-    const { promise: c1, resolve: r1 } = resolverPair()
-
-    void inbox.waitForQueued(c1) // wakeup = resolve1, c1.then(resolve1)
-    void inbox.waitForQueued(new Promise(() => {})) // wakeup = resolve2, cancel never resolves
-
-    r1()
-    await c1
-
-    // The replacement remains registered and is resolved by enqueue.
-    inbox.enqueue(message('hey'))
-  })
-})

packages/core/agent-loop/tests/interception.spec.ts

@@ -1,18 +1,29 @@
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 import { Context } from 'cordis'
-import LlmService, { CallId, type Message } from '@deepseek-ai/dsh-llm'
-import SessionStore, { SessionId, type SessionEvent, type TurnEndReason } from '@deepseek-ai/dsh-session'
+import LlmService, { CallId } from '@deepseek-ai/dsh-llm'
+import SessionStore, {
+  SessionId,
+  type SessionEvent,
+  type TurnEndReason,
+  type UserMessageData,
+} from '@deepseek-ai/dsh-session'
 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 ContinuationDecision, type PromptDecision, type SessionStartSource } from '@deepseek-ai/dsh-agent'
+import AgentRegistry, {
+  type Agent,
+  type AgentMessage,
+  type InboxPlacement,
+  type PromptDecision,
+  type SessionStartSource,
+} from '@deepseek-ai/dsh-agent'
 
 import AgentLoop from '@deepseek-ai/dsh-agent-loop'
 import { MockAdapter, textResponse, toolCallResponse } from './mock-adapter.ts'
 
 /**
  * The interception seams introduced by the hooks taxonomy: `agent/prompt-submit`,
- * `agent/session-start`, the reshaped `agent/turn-continuation`
- * ({@link ContinuationDecision}), and the `tools/pre-execute` / `tools/post-execute`
+ * `agent/session-start`, `agent/turn-stopping`, and the
+ * `tools/pre-execute` / `tools/post-execute`
  * split with `additionalContexts` buffering. These verify the canonical event
  * surface a hook bridge (or a native plugin) programs against, WITHOUT any
  * external protocol — a native plugin uses the typed decisions directly.
@@ -42,7 +53,7 @@ function waitForIdle(ctx: Context, agent: Agent): Promise<void> {
 }
 
 function send(agent: Agent, text: string) {
-  agent.followup([{ type: 'text', text }])
+  agent.followup({ content: [{ type: 'text', text }], source: { kind: 'user' } })
 }
 
 function events(agent: Agent): SessionEvent[] {
@@ -69,6 +80,57 @@ describe('agent/prompt-submit', () => {
     expect(userMsg?.type === 'user/message' && userMsg.data.content).toEqual([{ type: 'text', text: 'hello' }])
   })
 
+  it('snapshots and freezes input before publishing or awaiting admission', async () => {
+    const adapter = new MockAdapter([textResponse('ok')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('owned-input'), { provider: 'mock', model: 'mock' })
+    const entered = Promise.withResolvers<undefined>()
+    const decision = Promise.withResolvers<PromptDecision>()
+    const observed: AgentMessage[] = []
+    ctx.on('agent/inbox/enqueue', (subject, message) => {
+      if (subject !== agent) return
+      expect(Object.isFrozen(message)).toBe(true)
+      expect(Object.isFrozen(message.content)).toBe(true)
+      expect(Object.isFrozen(message.content[0])).toBe(true)
+      expect(Object.isFrozen(message.source)).toBe(true)
+      expect(() => {
+        const block = message.content[0]
+        if (block?.type === 'text') block.text = 'listener mutation'
+      }).toThrow()
+    })
+    ctx.on('agent/inbox/enqueue', (subject, message) => {
+      if (subject === agent) observed.push(message)
+    })
+    ctx.on('agent/prompt-submit', async () => {
+      entered.resolve(undefined)
+      return decision.promise
+    })
+    const input: UserMessageData = {
+      content: [{ type: 'text', text: 'accepted text' }],
+      source: { kind: 'plugin', plugin: 'accepted source' },
+    }
+
+    const idle = waitForIdle(ctx, agent)
+    agent.followup(input)
+    await entered.promise
+    const block = input.content[0]
+    if (block?.type === 'text') block.text = 'caller mutation'
+    if (input.source.kind === 'plugin') input.source.plugin = 'caller mutation'
+    decision.resolve({ kind: 'allow' })
+    await idle
+
+    expect(observed).toHaveLength(1)
+    expect(observed[0]).toMatchObject({
+      content: [{ type: 'text', text: 'accepted text' }],
+      source: { kind: 'plugin', plugin: 'accepted source' },
+    })
+    const userMsg = events(agent).find(event => event.type === 'user/message')
+    expect(userMsg?.type === 'user/message' && userMsg.data).toEqual({
+      content: [{ type: 'text', text: 'accepted text' }],
+      source: { kind: 'plugin', plugin: 'accepted source' },
+    })
+  })
+
   it('allow with content REWRITES the prompt before it is recorded', async () => {
     const adapter = new MockAdapter([textResponse('ok')])
     const ctx = await harness(adapter)
@@ -92,14 +154,12 @@ describe('agent/prompt-submit', () => {
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    const meta = { kind: 'prompt-context', version: 1 }
     ctx.on('agent/prompt-submit', async (): Promise<PromptDecision> =>
       ({
         kind: 'allow',
         additionalContexts: [{
           content: [{ type: 'text', text: '<system-reminder>extra ctx</system-reminder>' }],
           source: { kind: 'plugin', plugin: 'test' },
-          meta,
         }],
       }))
 
@@ -112,60 +172,10 @@ describe('agent/prompt-submit', () => {
     expect(userMsg).toBeDefined()
     expect(ctxMsg?.type === 'user/message' && ctxMsg.data.content).toEqual([{ type: 'text', text: '<system-reminder>extra ctx</system-reminder>' }])
     expect(ctxMsg?.type === 'user/message' && ctxMsg.data.source).toEqual({ kind: 'plugin', plugin: 'test' })
-    expect(ctxMsg?.type === 'user/message' && ctxMsg.data.meta).toEqual(meta)
     const sent = JSON.stringify(adapter.requests[0]!.messages)
     expect(sent).toContain('extra ctx')
   })
 
-  it('bakes prompt-prefix contexts and a request delimiter into one durable user message', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('prefixed'), { provider: 'mock', model: 'mock' })
-
-    ctx.on('agent/prompt-submit', async (_agent, _content, _source, _signal, next): Promise<PromptDecision> => {
-      const downstream = await next()
-      return downstream.kind === 'block'
-        ? downstream
-        : { ...downstream, content: [{ type: 'text', text: 'rewritten request' }] }
-    })
-    agent.followup([{ type: 'text', text: 'original request' }], {
-      contexts: [{
-        content: [{ type: 'text', text: 'untrusted prefix' }],
-        source: { kind: 'plugin', plugin: 'prefix' },
-        placement: 'prompt-prefix',
-        meta: { kind: 'prefix-card' },
-      }],
-    })
-    await waitForIdle(ctx, agent)
-
-    const log = events(agent)
-    const user = log.find(event => event.type === 'user/message')
-    expect(user?.type === 'user/message' && user.data).toEqual({
-      content: [
-        { type: 'text', text: 'untrusted prefix' },
-        { type: 'text', text: '\n\n## My request:\n' },
-        { type: 'text', text: 'rewritten request' },
-      ],
-      source: { kind: 'user' },
-      envelope: {
-        displayContent: [{ type: 'text', text: 'rewritten request' }],
-        prefixContexts: [{
-          source: { kind: 'plugin', plugin: 'prefix' },
-          meta: { kind: 'prefix-card' },
-        }],
-      },
-    })
-    expect(log.some(event => event.type === 'user/message' && event.data.source.kind === 'plugin')).toBe(false)
-    expect(adapter.requests[0]?.messages.at(-1)).toEqual({
-      role: 'user',
-      content: [
-        { type: 'text', text: 'untrusted prefix' },
-        { type: 'text', text: '\n\n## My request:\n' },
-        { type: 'text', text: 'rewritten request' },
-      ],
-    })
-  })
-
   it('runs pre-step after prompt rewrites and injected context become durable', async () => {
     const adapter = new MockAdapter([textResponse('ok')])
     const ctx = await harness(adapter)
@@ -179,7 +189,7 @@ describe('agent/prompt-submit', () => {
       }))
 
     let preStepDerived: string | undefined
-    ctx.on('agent/pre-step', (subject, _turn, step) => {
+    ctx.on('agent/step', (subject, _turn, step) => {
       if (subject === agent && step === 1) preStepDerived = JSON.stringify(subject.session.deriveMessages())
     })
 
@@ -192,7 +202,7 @@ describe('agent/prompt-submit', () => {
     expect(preStepDerived).not.toContain('ORIGINAL prompt')
   })
 
-  it('block drops the (only) prompt → zero-step turn ends rejected, model never called', async () => {
+  it('block drops the claimed prompt before any turn or model call', async () => {
     const adapter = new MockAdapter([textResponse('should not run')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
@@ -203,29 +213,228 @@ describe('agent/prompt-submit', () => {
     const reasons: TurnEndReason[] = []
     ctx.on('session/event', (_s, event: SessionEvent) => { if (event.type === 'turn/end') reasons.push(event.data.reason) })
 
-    agent.followup([{ type: 'text', text: 'do something' }], {
-      contexts: [{ content: [{ type: 'text', text: 'must be dropped' }], source: { kind: 'plugin', plugin: 'test' } }],
-    })
-    await waitForIdle(ctx, agent)
+    agent.followup({ content: [{ type: 'text', text: 'do something' }], source: { kind: 'user' } })
+    await agent.whenIdle()
 
     // the model was never called
     expect(adapter.requests).toHaveLength(0)
-    // the turn opened and closed balanced, with no user/message and no step
     const log = events(agent)
-    expect(log.some(e => e.type === 'turn/start')).toBe(true)
-    expect(log.some(e => e.type === 'turn/end')).toBe(true)
+    expect(log.some(e => e.type === 'turn/start')).toBe(false)
+    expect(log.some(e => e.type === 'turn/end')).toBe(false)
     expect(log.some(e => e.type === 'user/message')).toBe(false)
     expect(log.some(e => e.type === 'step/start')).toBe(false)
-    // the veto is recorded durably as a prompt/blocked in the open turn
-    const blocked = log.find(e => e.type === 'prompt/blocked')
-    expect(blocked?.type === 'prompt/blocked' && blocked.data).toMatchObject({
-      content: [{ type: 'text', text: 'do something' }],
-      reason: 'blocked by policy',
+    expect(reasons).toEqual([])
+  })
+
+  it('stages inject and steer during admission for the admitted turn', async () => {
+    const adapter = new MockAdapter([textResponse('ok')])
+    const ctx = await harness(adapter)
+    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 () => {
+      entered.resolve(undefined)
+      return decision.promise
     })
-    // ended rejected with the block reason
-    expect(reasons).toEqual([{ kind: 'rejected', reason: 'blocked by policy' }])
-    const turnEnd = log.findLast(e => e.type === 'turn/end')
-    expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason).toEqual({ kind: 'rejected', reason: 'blocked by policy' })
+    ctx.on('agent/inbox/enqueue', (subject, _message, placement) => {
+      if (subject === agent) placements.push(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({
+      content: [{ type: 'text', text: 'attached context' }],
+      source: { kind: 'plugin', plugin: 'test' },
+    })
+    agent.steer({ 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'])
+
+    decision.resolve({ kind: 'allow' })
+    await idle
+    expect(agent.acceptsNextStep).toBe(false)
+
+    const staged = events(agent).filter(event =>
+      event.type === 'turn/start' || event.type === 'user/message' || event.type === 'steering/message')
+    expect(staged.map(event => event.type)).toEqual([
+      'turn/start',
+      'user/message',
+      'user/message',
+      'steering/message',
+    ])
+    expect(staged[1]?.type === 'user/message' && staged[1].data.content)
+      .toEqual([{ type: 'text', text: 'admitted prompt' }])
+    expect(staged[2]?.type === 'user/message' && staged[2].data.content)
+      .toEqual([{ type: 'text', text: 'attached context' }])
+    expect(staged[3]?.type === 'steering/message' && staged[3].data.content)
+      .toEqual([{ type: 'text', text: 'admission steering' }])
+    const request = JSON.stringify(adapter.requests[0]?.messages)
+    expect(request).toContain('admitted prompt')
+    expect(request).toContain('attached context')
+    expect(request).toContain('admission steering')
+  })
+
+  it('keeps admission-time outbox input staged when admission is blocked', async () => {
+    const adapter = new MockAdapter([textResponse('retried')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('blocked-admission-outbox'), { provider: 'mock', model: 'mock' })
+    const entered = Promise.withResolvers<undefined>()
+    const decision = Promise.withResolvers<PromptDecision>()
+    const disposeBlock = ctx.on('agent/prompt-submit', async () => {
+      entered.resolve(undefined)
+      return decision.promise
+    })
+
+    const blockedIdle = waitForIdle(ctx, agent)
+    send(agent, 'blocked prompt')
+    await entered.promise
+    expect(agent.acceptsNextStep).toBe(true)
+    agent.inject({
+      content: [{ type: 'text', text: 'staged context' }],
+      source: { kind: 'plugin', plugin: 'test' },
+    })
+    agent.steer({ content: [{ type: 'text', text: 'staged steering' }], source: { kind: 'user' } })
+    decision.resolve({ kind: 'block', reason: 'policy' })
+    await blockedIdle
+
+    expect(agent.acceptsNextStep).toBe(false)
+    expect(events(agent)).toEqual([])
+    expect(adapter.requests).toEqual([])
+
+    disposeBlock()
+    send(agent, 'resume')
+    await waitForIdle(ctx, agent)
+
+    const staged = events(agent).filter(event =>
+      event.type === 'user/message' || event.type === 'steering/message')
+    expect(staged.map(event => event.type)).toEqual([
+      'user/message',
+      'steering/message',
+      'user/message',
+    ])
+    expect(JSON.stringify(adapter.requests[0]?.messages)).not.toContain('blocked prompt')
+    expect(JSON.stringify(adapter.requests[0]?.messages)).toContain('staged context')
+    expect(JSON.stringify(adapter.requests[0]?.messages)).toContain('staged steering')
+  })
+
+  it('orders rejected-admission outbox input before a later admitted prompt', async () => {
+    const adapter = new MockAdapter([textResponse('continued')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('rejected-admission-order'), {
+      provider: 'mock',
+      model: 'mock',
+    })
+    ctx.on('agent/prompt-submit', async (_agent, content, _source, _signal, next) => {
+      const decision = await next()
+      return content.some(block => block.type === 'text' && block.text === 'blocked prompt')
+        ? { kind: 'block', reason: 'policy' }
+        : decision
+    })
+    ctx.on('agent/prompt-submit', async (subject, content, _source, _signal, next) => {
+      if (content.some(block => block.type === 'text' && block.text === 'blocked prompt')) {
+        subject.inject({
+          content: [{ type: 'text', text: 'earlier state change' }],
+          source: { kind: 'plugin', plugin: 'test' },
+        })
+        subject.steer({
+          content: [{ type: 'text', text: 'earlier steering' }],
+          source: { kind: 'user' },
+        })
+      }
+      return next()
+    })
+
+    const idle = waitForIdle(ctx, agent)
+    send(agent, 'blocked prompt')
+    send(agent, 'later prompt')
+    await idle
+
+    const staged = events(agent).filter(event =>
+      event.type === 'turn/start' || event.type === 'user/message' || event.type === 'steering/message')
+    expect(staged.map(event => event.type)).toEqual([
+      'turn/start',
+      'user/message',
+      'steering/message',
+      'user/message',
+    ])
+    expect(staged[1]?.type === 'user/message' && staged[1].data.content)
+      .toEqual([{ type: 'text', text: 'earlier state change' }])
+    expect(staged[2]?.type === 'steering/message' && staged[2].data.content)
+      .toEqual([{ type: 'text', text: 'earlier steering' }])
+    expect(staged[3]?.type === 'user/message' && staged[3].data.content)
+      .toEqual([{ type: 'text', text: 'later prompt' }])
+  })
+
+  it('commits context-only injection when admission closes without a turn', async () => {
+    const adapter = new MockAdapter([])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('blocked-admission-context'), { provider: 'mock', model: 'mock' })
+    const entered = Promise.withResolvers<undefined>()
+    const decision = Promise.withResolvers<PromptDecision>()
+    ctx.on('agent/prompt-submit', async () => {
+      entered.resolve(undefined)
+      return decision.promise
+    })
+
+    const idle = waitForIdle(ctx, agent)
+    send(agent, 'blocked prompt')
+    await entered.promise
+    agent.inject({
+      content: [{ type: 'text', text: 'independent context' }],
+      source: { kind: 'plugin', plugin: 'test' },
+    })
+    decision.resolve({ kind: 'block', reason: 'policy' })
+    await idle
+
+    const log = events(agent)
+    expect(log.map(event => event.type)).toEqual(['user/message'])
+    expect(log[0]?.type === 'user/message' && log[0].data.content)
+      .toEqual([{ type: 'text', text: 'independent context' }])
+    expect(adapter.requests).toEqual([])
+  })
+
+  it('retains rejected-admission context when its idle append fails', async () => {
+    const adapter = new MockAdapter([textResponse('retried')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('blocked-admission-append-failure'), {
+      provider: 'mock',
+      model: 'mock',
+    })
+    const warned = vi.spyOn(ctx.logger, 'warn').mockImplementation(() => undefined)
+    vi.spyOn(agent.session, 'append').mockImplementationOnce(() => {
+      throw new Error('append unavailable')
+    })
+    const entered = Promise.withResolvers<undefined>()
+    const decision = Promise.withResolvers<PromptDecision>()
+    const disposeBlock = ctx.on('agent/prompt-submit', async () => {
+      entered.resolve(undefined)
+      return decision.promise
+    })
+
+    agent.followup({ content: [{ type: 'text', text: 'blocked prompt' }], source: { kind: 'user' } })
+    await entered.promise
+    agent.inject({
+      content: [{ type: 'text', text: 'retained context' }],
+      source: { kind: 'plugin', plugin: 'test' },
+    })
+    decision.resolve({ kind: 'block', reason: 'policy' })
+    await agent.whenIdle()
+
+    expect(events(agent)).toEqual([])
+    expect(warned).toHaveBeenCalledWith(expect.stringContaining('append unavailable'))
+
+    disposeBlock()
+    send(agent, 'resume')
+    await waitForIdle(ctx, agent)
+
+    expect(events(agent).some(event => event.type === 'user/message'
+      && JSON.stringify(event.data.content).includes('retained context'))).toBe(true)
   })
 
   it('adjacent blocked and allowed prompts keep independent turn outcomes', async () => {
@@ -241,7 +450,7 @@ describe('agent/prompt-submit', () => {
     const reasons: TurnEndReason[] = []
     ctx.on('session/event', (_s, event: SessionEvent) => { if (event.type === 'turn/end') reasons.push(event.data.reason) })
 
-    // Both sends land before the driver wakes, but each remains its own turn.
+    // The rejected admission is dropped; the allowed prompt owns the only turn.
     send(agent, 'secret')
     send(agent, 'safe')
     await waitForIdle(ctx, agent)
@@ -252,21 +461,11 @@ describe('agent/prompt-submit', () => {
     expect(userMsgs).toHaveLength(1)
     expect(userMsgs[0]?.type === 'user/message' && userMsgs[0].data.content).toEqual([{ type: 'text', text: 'safe' }])
     expect(adapter.requests.length).toBeGreaterThanOrEqual(1)
-    // the blocked prompt is durably recorded, with its content + reason
-    const blocked = log.filter(e => e.type === 'prompt/blocked')
-    expect(blocked).toHaveLength(1)
-    expect(blocked[0]?.type === 'prompt/blocked' && blocked[0].data).toMatchObject({
-      content: [{ type: 'text', text: 'secret' }],
-      reason: 'policy: no secrets',
-    })
-    expect(log.filter(e => e.type === 'turn/start')).toHaveLength(2)
-    expect(reasons).toEqual([
-      { kind: 'rejected', reason: 'policy: no secrets' },
-      { kind: 'completed' },
-    ])
+    expect(log.filter(e => e.type === 'turn/start')).toHaveLength(1)
+    expect(reasons).toEqual([{ kind: 'completed' }])
   })
 
-  it('a throwing prompt-submit listener ends its turn balanced while an adjacent message survives', async () => {
+  it('a throwing prompt-submit listener drops that admission while an adjacent message survives', async () => {
     const adapter = new MockAdapter([textResponse('after')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
@@ -279,7 +478,9 @@ describe('agent/prompt-submit', () => {
     const errors: Error[] = []
     const reasons: TurnEndReason[] = []
     const statuses: string[] = []
-    ctx.on('agent/error', (_a, _t, _s, error) => void errors.push(error))
+    ctx.on('agent/error', (_a, _t, _s, error) => {
+      if (error instanceof Error) errors.push(error)
+    })
     ctx.on('agent/status', (subject, status) => { if (subject === agent) statuses.push(status) })
     ctx.on('session/event', (session, event) => {
       if (session === agent.session && event.type === 'turn/end') reasons.push(event.data.reason)
@@ -289,16 +490,11 @@ describe('agent/prompt-submit', () => {
     send(agent, 'first')
     send(agent, 'second')
     await idle
-    expect(errors.map(e => e.message)).toEqual(['prompt hook broke'])
-    // The failed prompt forms one balanced error turn; the adjacent prompt forms
-    // the following normal turn without an intermediate idle transition.
+    expect(errors).toEqual([])
     const log = events(agent)
-    expect(log.filter(e => e.type === 'turn/start')).toHaveLength(2)
-    expect(log.filter(e => e.type === 'turn/end')).toHaveLength(2)
-    expect(reasons).toEqual([
-      { kind: 'error', step: 0, message: 'prompt hook broke' },
-      { kind: 'completed' },
-    ])
+    expect(log.filter(e => e.type === 'turn/start')).toHaveLength(1)
+    expect(log.filter(e => e.type === 'turn/end')).toHaveLength(1)
+    expect(reasons).toEqual([{ kind: 'completed' }])
     expect(statuses).toEqual(['running', 'idle'])
     expect(adapter.requests).toHaveLength(1)
     expect(JSON.stringify(adapter.requests[0]!.messages)).toContain('second')
@@ -329,7 +525,7 @@ describe('agent/session-start', () => {
     const ctx = await harness(adapter)
 
     ctx.on('agent/session-start', (agent) => {
-      agent.inject([{ type: 'text', text: 'session preamble' }], { source: { kind: 'plugin', plugin: 'test' } })
+      agent.inject({ content: [{ type: 'text', text: 'session preamble' }], source: { kind: 'plugin', plugin: 'test' } })
     })
 
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
@@ -360,236 +556,6 @@ describe('agent/session-start', () => {
   })
 })
 
-describe('agent/session-prefix', () => {
-  it('dispatches to global and matching agent-scope listeners only', async () => {
-    const adapter = new MockAdapter([textResponse('a done'), textResponse('b done')])
-    const ctx = await harness(adapter)
-    const agentA = ctx.agentLoop.create(SessionId('prefix-a'), { provider: 'mock', model: 'mock' })
-    const agentB = ctx.agentLoop.create(SessionId('prefix-b'), { provider: 'mock', model: 'mock' })
-    const seen: string[] = []
-    ctx.on('agent/session-prefix', async (agent, _prefix, _signal, next) => {
-      seen.push(`global:${agent.id}`)
-      return next()
-    })
-    agentA.ctx.on('agent/session-prefix', async (agent, _prefix, _signal, next) => {
-      seen.push(`a:${agent.id}`)
-      return next()
-    })
-    agentB.ctx.on('agent/session-prefix', async (agent, _prefix, _signal, next) => {
-      seen.push(`b:${agent.id}`)
-      return next()
-    })
-
-    send(agentA, 'run a')
-    await waitForIdle(ctx, agentA)
-    send(agentB, 'run b')
-    await waitForIdle(ctx, agentB)
-
-    expect(seen).toEqual([
-      'global:prefix-a', 'a:prefix-a',
-      'global:prefix-b', 'b:prefix-b',
-    ])
-  })
-
-  it('composes once per loop instance and fronts every request; the header records it; history stays untouched', async () => {
-    const adapter = new MockAdapter([
-      toolCallResponse('c1', 'echo', { text: 'ping' }),
-      textResponse('done'),
-      textResponse('again'),
-    ])
-    const ctx = await harness(adapter)
-    ctx.tools.register(defineContentToolFixture({
-      name: 'echo', description: 'echo', parameters: { text: { type: 'string' } },
-      async execute(args) { return [{ type: 'text', text: String(args.text) }] },
-    }))
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    const reminder: Message = { role: 'user', content: [{ type: 'text', text: '<system-reminder>catalog</system-reminder>' }] }
-    let composed = 0
-    ctx.on('agent/session-prefix', async (_agent, _prefix, _signal, next): Promise<Message[]> => {
-      composed += 1
-      return [...await next(), reminder]
-    })
-
-    send(agent, 'go')
-    await waitForIdle(ctx, agent)
-    send(agent, 'next turn')
-    await waitForIdle(ctx, agent)
-
-    // Three requests (two turns), ONE composition: the frozen product is
-    // reused verbatim, so the prefix cannot drift mid-session.
-    expect(adapter.requests).toHaveLength(3)
-    expect(composed).toBe(1)
-    for (const request of adapter.requests) {
-      expect(request.messages[0]).toEqual(reminder)
-    }
-    // The anchoring snapshot is the prefix's durable record — and the ONLY
-    // header event: reuse means no changed snapshot ever.
-    const headerEvents = events(agent).filter(e => e.type === 'request/header')
-    expect(headerEvents).toHaveLength(1)
-    expect(headerEvents[0]?.type === 'request/header' && headerEvents[0].data.header.messagePrefix).toEqual([reminder])
-    // Never session history: the derivation starts at the real user prompt.
-    expect(agent.session.deriveMessages()[0]).toEqual({ role: 'user', content: [{ type: 'text', text: 'go' }] })
-  })
-
-  it('composes before the first pre-step and records the prefix on the request header', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    const reminder: Message = { role: 'user', content: [{ type: 'text', text: 'opener' }] }
-    const order: string[] = []
-    ctx.on('agent/session-prefix', async (_agent, _prefix, _signal, next): Promise<Message[]> => {
-      order.push('compose')
-      return [reminder, ...await next()]
-    })
-    ctx.on('agent/pre-step', () => {
-      order.push('pre-step')
-    })
-
-    send(agent, 'hi')
-    await waitForIdle(ctx, agent)
-
-    expect(order).toEqual(['compose', 'pre-step'])
-    expect(agent.session.requestHeader()?.messagePrefix).toEqual([reminder])
-  })
-
-  it('the canonical prepend pattern composes contributions in registration order', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    // Both listeners use the canonical `[mine, ...await next()]` prepend: the
-    // waterfall unwinds innermost-first (the second listener's array is built
-    // first), so prepending puts the FIRST-registered contribution first.
-    ctx.on('agent/session-prefix', async (_agent, _prefix, _signal, next): Promise<Message[]> => {
-      return [{ role: 'user', content: [{ type: 'text', text: 'first' }] }, ...await next()]
-    })
-    ctx.on('agent/session-prefix', async (_agent, _prefix, _signal, next): Promise<Message[]> => {
-      return [{ role: 'user', content: [{ type: 'text', text: 'second' }] }, ...await next()]
-    })
-
-    send(agent, 'hi')
-    await waitForIdle(ctx, agent)
-
-    const texts = adapter.requests[0]!.messages.map(m => m.content[0]?.type === 'text' ? m.content[0].text : '')
-    expect(texts).toEqual(['first', 'second', 'hi'])
-  })
-
-  it('with no contributions the header omits messagePrefix and the request is the bare derivation', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    // A listener that delegates without contributing — the canonical no-op.
-    ctx.on('agent/session-prefix', async (_agent, _prefix, _signal, next) => next())
-
-    send(agent, 'hi')
-    await waitForIdle(ctx, agent)
-
-    const headerEvent = events(agent).find(e => e.type === 'request/header')
-    expect(headerEvent?.type === 'request/header' && 'messagePrefix' in headerEvent.data.header).toBe(false)
-    expect(adapter.requests[0]!.messages).toEqual([{ role: 'user', content: [{ type: 'text', text: 'hi' }] }])
-  })
-
-  it('the frozen seed rejects in-place mutation — a contribution is a returned extension', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    let mutationError: unknown
-    ctx.on('agent/session-prefix', async (_agent, prefix, _signal, next): Promise<Message[]> => {
-      try {
-        prefix.push({ role: 'user', content: [{ type: 'text', text: 'smuggled' }] })
-      } catch (error: unknown) {
-        mutationError = error
-      }
-      return next()
-    })
-
-    send(agent, 'hi')
-    await waitForIdle(ctx, agent)
-
-    expect(mutationError).toBeInstanceOf(TypeError)
-    expect(adapter.requests[0]!.messages).toEqual([{ role: 'user', content: [{ type: 'text', text: 'hi' }] }])
-  })
-
-  it('mutating a listener-held reference after composition cannot alter later requests (the cache is a frozen clone)', async () => {
-    const adapter = new MockAdapter([
-      toolCallResponse('c1', 'echo', { text: 'ping' }),
-      textResponse('done'),
-    ])
-    const ctx = await harness(adapter)
-    ctx.tools.register(defineContentToolFixture({
-      name: 'echo', description: 'echo', parameters: { text: { type: 'string' } },
-      async execute(args) { return [{ type: 'text', text: String(args.text) }] },
-    }))
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    const held: Message = { role: 'user', content: [{ type: 'text', text: 'v1' }] }
-    ctx.on('agent/session-prefix', async (_agent, _prefix, _signal, next): Promise<Message[]> => [...await next(), held])
-
-    send(agent, 'go')
-    await waitForIdle(ctx, agent)
-
-    // The listener mutates the object it contributed AFTER composition; the
-    // cached prefix is a deep-frozen clone, so step 2's request is unchanged.
-    held.content = [{ type: 'text', text: 'v2' }]
-    expect(adapter.requests[1]!.messages[0]).toEqual({ role: 'user', content: [{ type: 'text', text: 'v1' }] })
-    expect(events(agent).filter(e => e.type === 'request/header')).toHaveLength(1)
-  })
-})
-
-
-describe('agent/turn-continuation (ContinuationDecision)', () => {
-  it('a continue decision with a reason records next-step steering in the same turn', async () => {
-    const adapter = new MockAdapter([textResponse('step 1 no tools'), textResponse('step 2')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    let forced = false
-    ctx.on('agent/turn-continuation', async (_agent, _turn, _default, _signal, next): Promise<ContinuationDecision> => {
-      if (!forced) {
-        forced = true
-        return { action: 'continue', reason: { content: [{ type: 'text', text: 'keep going on the goal' }], source: { kind: 'plugin', plugin: 'goal' } } }
-      }
-      return next()
-    })
-
-    send(agent, 'go')
-    await waitForIdle(ctx, agent)
-
-    const log = events(agent)
-    // The continuation stays in the turn, is logged with provenance before step 2,
-    // and reaches that step's request.
-    expect(log.filter(e => e.type === 'turn/start')).toHaveLength(1)
-    expect(log.filter(e => e.type === 'step/start')).toHaveLength(2)
-    const steering = log.find(e => e.type === 'steering/message')
-    expect(steering?.type === 'steering/message' && steering.data.content).toEqual([{ type: 'text', text: 'keep going on the goal' }])
-    expect(steering?.type === 'steering/message' && steering.data.source).toEqual({ kind: 'plugin', plugin: 'goal' })
-    expect(JSON.stringify(adapter.requests[1]!.messages)).toContain('keep going on the goal')
-  })
-
-  it('a stop decision ends the turn even when the step had tool calls', async () => {
-    const adapter = new MockAdapter([toolCallResponse('c1', 'echo', { text: 'hi' })])
-    const ctx = await harness(adapter)
-    ctx.tools.register(defineContentToolFixture({
-      name: 'echo', description: 'echo', parameters: { text: { type: 'string' } },
-      async execute(args) { return [{ type: 'text', text: String(args.text) }] },
-    }))
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    ctx.on('agent/turn-continuation', async (): Promise<ContinuationDecision> => ({ action: 'stop' }))
-
-    send(agent, 'go')
-    await waitForIdle(ctx, agent)
-
-    // default would have continued (had tool calls), but the stop decision wins
-    expect(adapter.requests).toHaveLength(1)
-    expect(events(agent).some(e => e.type === 'tool/result')).toBe(true)
-  })
-})
-
 describe('tool additionalContexts buffering across a step', () => {
   it('appends each call\'s contexts only AFTER all tool/results, preserving adjacency', async () => {
     // One assistant step with TWO tool calls; the second model response stops.
@@ -616,7 +582,6 @@ describe('tool additionalContexts buffering across a step', () => {
         additionalContexts: [{
           content: [{ type: 'text', text: `ctx-${exec.callId}` }],
           source: { kind: 'plugin', plugin: 'p' },
-          meta: { callId: exec.callId },
         }],
       }))
 
@@ -638,7 +603,6 @@ describe('tool additionalContexts buffering across a step', () => {
       .flatMap(e => (e.type === 'user/message' ? e.data.content : []))
       .map(b => (b.type === 'text' ? b.text : ''))
     expect(ctxTexts).toEqual(['ctx-c1', 'ctx-c2'])
-    expect(injected.map(e => e.type === 'user/message' && e.data.meta)).toEqual([{ callId: 'c1' }, { callId: 'c2' }])
   })
 
   it('appends multiple contexts deferred by one composite tool after its outer result', async () => {
@@ -647,8 +611,8 @@ describe('tool additionalContexts buffering across a step', () => {
     ctx.tools.register(defineContentToolFixture({
       name: 'composite', description: 'composite', parameters: {},
       async execute(_args, exec) {
-        exec.deferContext({ content: [{ type: 'text', text: 'nested-a' }], source: { kind: 'plugin', plugin: 'a' }, meta: { order: 1 } })
-        exec.deferContext({ content: [{ type: 'text', text: 'nested-b' }], source: { kind: 'plugin', plugin: 'b' }, meta: { order: 2 } })
+        exec.deferContext({ content: [{ type: 'text', text: 'nested-a' }], source: { kind: 'plugin', plugin: 'a' } })
+        exec.deferContext({ content: [{ type: 'text', text: 'nested-b' }], source: { kind: 'plugin', plugin: 'b' } })
         return [{ type: 'text', text: 'outer result' }]
       },
     }))
@@ -666,7 +630,6 @@ describe('tool additionalContexts buffering across a step', () => {
       { kind: 'plugin', plugin: 'a' },
       { kind: 'plugin', plugin: 'b' },
     ])
-    expect(contextEvents.map(event => event.type === 'user/message' && event.data.meta)).toEqual([{ order: 1 }, { order: 2 }])
   })
 })
 
@@ -706,10 +669,7 @@ describe('worked example: a native hook plugin is just a cordis plugin on the se
     apply(ctx: Context) {
       // 1. SessionStart: seed a standing instruction.
       ctx.on('agent/session-start', (agent, source) => {
-        agent.inject(
-          [{ type: 'text', text: `policy active (started: ${source})` }],
-          { source: { kind: 'plugin', plugin: 'native-guard' } },
-        )
+        agent.inject({ 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, content, _source, _signal, next): Promise<PromptDecision> => {
@@ -760,7 +720,7 @@ describe('worked example: a native hook plugin is just a cordis plugin on the se
     expect(log.some(e => e.type.startsWith('hook/'))).toBe(false)
   })
 
-  it('the same plugin blocks a destructive prompt → rejected turn, model never called', async () => {
+  it('the same plugin blocks a destructive prompt before a turn or model call', async () => {
     const adapter = new MockAdapter([textResponse('should not run')])
     const ctx = await harness(adapter)
     await ctx.plugin(NativeGuard)
@@ -770,10 +730,10 @@ describe('worked example: a native hook plugin is just a cordis plugin on the se
     ctx.on('session/event', (_s, event: SessionEvent) => { if (event.type === 'turn/end') reasons.push(event.data.reason) })
 
     send(agent, 'run rm -rf /')
-    await waitForIdle(ctx, agent)
+    await agent.whenIdle()
 
     expect(adapter.requests).toHaveLength(0)
-    expect(reasons).toEqual([{ kind: 'rejected', reason: 'destructive prompt blocked' }])
+    expect(reasons).toEqual([])
   })
 
   it('HMR-safety: disposing the plugin fiber removes all four listeners', async () => {

packages/core/agent-loop/tests/invariant.spec.ts

@@ -47,15 +47,14 @@ describe('request-reconstruction invariant', () => {
     expect(() => { dispatch(ctx, options) }).not.toThrow()
   })
 
-  it('requires the folded session prefix ahead of derived history', async () => {
+  it('requires the messages to equal the boundary derivation exactly (no unlogged prefix)', async () => {
     const { ctx, session, boundary } = await requestSetup()
-    const prefix = { role: 'user' as const, content: [{ type: 'text' as const, text: '<system-reminder>catalog</system-reminder>' }] }
-    session.append('request/header', { header: { config: { provider: 'mock', model: 'm' }, messagePrefix: [prefix] }, reason: 'change' })
-    expect(() => { dispatch(ctx, loopRequest({ model: 'm', messages: Object.freeze([prefix, ...boundary]), sessionId: session.id })) })
-      .not.toThrow()
+    const extra = { role: 'user' as const, content: [{ type: 'text' as const, text: '<system-reminder>catalog</system-reminder>' }] }
     expect(() => { dispatch(ctx, loopRequest({ model: 'm', messages: Object.freeze([...boundary]), sessionId: session.id })) })
+      .not.toThrow()
+    expect(() => { dispatch(ctx, loopRequest({ model: 'm', messages: Object.freeze([extra, ...boundary]), sessionId: session.id })) })
       .toThrow(/diverges from the boundary derivation/)
-    expect(() => { dispatch(ctx, loopRequest({ model: 'm', messages: Object.freeze([...boundary, prefix]), sessionId: session.id })) })
+    expect(() => { dispatch(ctx, loopRequest({ model: 'm', messages: Object.freeze([...boundary, extra]), sessionId: session.id })) })
       .toThrow(/diverges from the boundary derivation/)
   })
 

packages/core/agent-loop/tests/loop.spec.ts

@@ -1,9 +1,9 @@
 import { describe, expect, it } from 'vitest'
 import { Context } from 'cordis'
 import LlmService, { CallId, StreamChunk } from '@deepseek-ai/dsh-llm'
-import SessionStore, { SessionId, TurnEndReason, type JsonValue } from '@deepseek-ai/dsh-session'
+import SessionStore, { SessionId, TurnEndReason } from '@deepseek-ai/dsh-session'
 import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
-import ToolRegistry, { defineContentToolFixture, defineTool } from '@deepseek-ai/dsh-tools'
+import ToolRegistry, { defineContentToolFixture } from '@deepseek-ai/dsh-tools'
 import AgentRegistry, { type Agent } from '@deepseek-ai/dsh-agent'
 
 import AgentLoop from '@deepseek-ai/dsh-agent-loop'
@@ -42,7 +42,7 @@ function waitForIdle(ctx: Context, agent: Agent): Promise<void> {
 }
 
 function send(agent: Agent, text: string) {
-  agent.followup([{ type: 'text', text }])
+  agent.followup({ content: [{ type: 'text', text }], source: { kind: 'user' } })
 }
 
 describe('agent loop', () => {
@@ -118,37 +118,6 @@ describe('agent loop', () => {
     const types = agent.session.events.map(e => e.type)
     expect(types).toContain('tool/call')
     expect(types).toContain('tool/result')
-    const durableResult = agent.session.events.find(event => event.type === 'tool/result')
-    expect(durableResult?.type === 'tool/result' && 'value' in durableResult.data).toBe(false)
-  })
-
-  it('persists presentation metadata projected from the canonical value', async () => {
-    const adapter = new MockAdapter([
-      toolCallResponse('c1', 'writer', { path: 'a.txt' }, 'writing'),
-      textResponse('done'),
-    ])
-    const ctx = await harness(adapter)
-    ctx.tools.register(defineTool({
-      name: 'writer',
-      description: 'writes a file',
-      parameters: { path: { type: 'string' } },
-      output: {
-        schema: { type: 'string' },
-        render: () => [{ type: 'text', text: 'ok' }],
-        presentationMeta: (_args, value) => ({ diffs: [{ path: value, oldText: null, newText: 'x' }] }),
-      },
-      async execute() {
-        return 'a.txt'
-      },
-    }))
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    send(agent, 'use the tool')
-    await waitForIdle(ctx, agent)
-
-    const toolResult = agent.session.events.find(e => e.type === 'tool/result')
-    expect(toolResult?.type === 'tool/result' && toolResult.data.meta)
-      .toEqual({ diffs: [{ path: 'a.txt', oldText: null, newText: 'x' }] })
   })
 
   it('renders harness identity, then the persona, then tool guidance — with {{variables}} resolved', async () => {
@@ -196,7 +165,9 @@ describe('agent loop', () => {
     const adapter = new MockAdapter([textResponse('ok after rescue')])
     const ctx = await harness(adapter, 'In {{cwd}}.')
     const errors: Error[] = []
-    ctx.on('agent/error', (_agent, _turn, _step, error) => void errors.push(error))
+    ctx.on('agent/error', (_agent, _turn, _step, error) => {
+      if (error instanceof Error) errors.push(error)
+    })
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     send(agent, 'hi')
@@ -236,7 +207,8 @@ describe('agent loop', () => {
       assembly.variables['model'] = 'mock'
       return next()
     })
-    ctx.on('agent/request', async (_agent, _turn, _step, config, _signal, _next) => {
+    ctx.on('agent/request', async (_agent, _turn, _step, _signal, next) => {
+      const config = await next()
       return { ...config, provider: 'mock', model: 'mock' }
     })
     const agent = ctx.agentLoop.create(SessionId('a-late-model'), {})
@@ -249,50 +221,6 @@ describe('agent loop', () => {
     expect(adapter.requests[0]!.system).toBe('You are an AI agent powered by the DeepSeek Harness SDK.\n\nYou run on mock.')
   })
 
-  it.each([
-    ['BigInt', { n: 1n }],
-    ['Map', new Map([['key', 'value']])],
-    ['class instance', new (class ResultMeta { x = 1 })()],
-  ])('rejects non-JSON presentation metadata (%s) before the durable result commit', async (_kind, meta) => {
-    const adapter = new MockAdapter([
-      toolCallResponse('bad-meta-call', 'bad-meta', {}, 'calling'),
-      textResponse('recovered'),
-    ])
-    const ctx = await harness(adapter)
-    ctx.tools.register(defineTool({
-      name: 'bad-meta',
-      description: 'returns invalid durable metadata',
-      parameters: {},
-      output: {
-        schema: { type: 'string' },
-        render: (_args, value) => [{ type: 'text', text: value }],
-        presentationMeta: () => meta as unknown as JsonValue,
-      },
-      execute: () => Promise.resolve('apparent success'),
-    }))
-    const agent = ctx.agentLoop.create(SessionId('bad-meta-agent'), { provider: 'mock', model: 'mock' })
-
-    send(agent, 'use the tool')
-    await waitForIdle(ctx, agent)
-
-    const result = agent.session.events.find(event => event.type === 'tool/result')
-    expect(result?.type).toBe('tool/result')
-    if (result?.type === 'tool/result') {
-      expect(result.data.callId).toBe('bad-meta-call')
-      expect(result.data.isError).toBe(true)
-      expect(result.data.meta).toBeUndefined()
-      expect(result.data.error).toEqual({ name: 'ToolOutputError', code: 'INVALID_TOOL_OUTPUT' })
-      expect(result.data.content).toEqual([{
-        type: 'text',
-        text: 'Error: tool "bad-meta" returned invalid output: output.presentationMeta returned non-lossless JSON',
-      }])
-    }
-    // The normalized failure was durably logged and fed back to the model; the
-    // turn continued normally instead of failing after an apparent success.
-    expect(adapter.requests).toHaveLength(2)
-    expect(JSON.stringify(adapter.requests[1]!.messages)).toContain('output.presentationMeta returned non-lossless JSON')
-  })
-
   it('omits the system field when a system-prompt/assemble veto empties the assembly', async () => {
     // The documented escape valve: a deployment that must drop the harness
     // openers short-circuits the assemble waterfall; the request then carries
@@ -343,7 +271,7 @@ describe('agent loop', () => {
       parameters: {},
       async execute() {
         // steer while the turn is running (during tool execution)
-        agent.steer([{ type: 'text', text: 'change of plans' }])
+        agent.steer({ content: [{ type: 'text', text: 'change of plans' }], source: { kind: 'user' } })
         return [{ type: 'text', text: 'tool done' }]
       },
     }))
@@ -365,14 +293,14 @@ describe('agent loop', () => {
     expect(flat).toContain('change of plans')
   })
 
-  it('same-tick idle steering inherits one-send-one-turn FIFO behavior', async () => {
+  it('same-tick idle steering preserves one turn per send', async () => {
     const adapter = new MockAdapter([textResponse('first'), textResponse('second')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     const idle = waitForIdle(ctx, agent)
-    agent.steer([{ type: 'text', text: 'first idle steer' }])
-    agent.steer([{ type: 'text', text: 'second idle steer' }])
+    agent.steer({ content: [{ type: 'text', text: 'first idle steer' }], source: { kind: 'user' } })
+    agent.steer({ content: [{ type: 'text', text: 'second idle steer' }], source: { kind: 'user' } })
     await idle
 
     expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(2)
@@ -382,53 +310,75 @@ describe('agent loop', () => {
       [{ type: 'text', text: 'first idle steer' }],
       [{ type: 'text', text: 'second idle steer' }],
     ])
+    expect(agent.session.events.filter(event => event.type === 'steering/message')).toEqual([])
     expect(adapter.requests).toHaveLength(2)
+    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')
   })
 
-  it('inject() while idle wraps context in a one-shot turn, visible to the next request', async () => {
+  it('keeps steering staged after a failed step until the next admitted 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' })
+    let fail = true
+    ctx.on('agent/step', (subject) => {
+      if (subject !== agent || !fail) return
+      fail = false
+      subject.steer({ content: [{ type: 'text', text: 'pending steering' }], source: { kind: 'user' } })
+      throw new Error('step failed')
+    })
+
+    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(JSON.stringify(adapter.requests[0]?.messages)).toContain('pending steering')
+  })
+
+  it('inject() while idle appends 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' })
 
-    agent.inject([{ type: 'text', text: 'file changed: a.ts' }], { source: { kind: 'plugin', plugin: 'watcher' } })
-    // The idle inject records a self-contained turn (turn/start → user/message
-    // → turn/end) so the event stays turn-enclosed, but does NOT run the model.
-    await new Promise(r => setTimeout(r, 20))
+    agent.inject({ content: [{ type: 'text', text: 'file changed: a.ts' }], source: { kind: 'plugin', plugin: 'watcher' } })
     expect(agent.status).toBe('idle')
     expect(adapter.requests).toHaveLength(0)
-    const injectedTurn = agent.session.events.filter(e => e.type === 'turn/start')
-    expect(injectedTurn).toHaveLength(1)
-    const it0 = injectedTurn[0]!
-    expect(it0.type === 'turn/start' && it0.data.trigger.kind).toBe('injection')
-    expect(agent.session.events.at(-1)!.type).toBe('turn/end') // turn-enclosed
+    expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(0)
+    expect(agent.session.events.at(-1)).toMatchObject({
+      type: 'user/message',
+      data: { source: { kind: 'plugin', plugin: 'watcher' } },
+    })
 
     send(agent, 'go')
     await waitForIdle(ctx, agent)
+    expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(1)
     const flat = JSON.stringify(adapter.requests[0]!.messages)
     expect(flat).toContain('file changed: a.ts')
     expect(flat).not.toContain('<context source=')
   })
 
-  it('inject() persists structured context content verbatim with durable hidden meta', async () => {
+  it('inject() persists structured context content verbatim with durable source', async () => {
     const adapter = new MockAdapter([textResponse('ok')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('raw-context'), { provider: 'mock', model: 'mock' })
     const text = '<system-reminder>Additional instructions from: pkg/AGENTS.md</system-reminder>'
-    const meta = {
-      kind: 'workspace-instructions',
-      version: 1,
-      changes: [{ action: 'set', scope: 'pkg', path: 'pkg/AGENTS.md', digest: 'abc123' }],
-    }
-
-    agent.inject([{ type: 'text', text }], {
-      source: { kind: 'plugin', plugin: 'workspace-context' },
-      meta,
-    })
+    agent.inject({ content: [{ type: 'text', text }], source: { kind: 'plugin', plugin: 'workspace-context' } })
     send(agent, 'go')
     await waitForIdle(ctx, agent)
 
     const contextEvent = agent.session.events.find(event => event.type === 'user/message' && event.data.source.kind === 'plugin')
-    expect(contextEvent?.type === 'user/message' && contextEvent.data).toMatchObject({ meta })
+    expect(contextEvent?.type === 'user/message' && contextEvent.data.source)
+      .toEqual({ kind: 'plugin', plugin: 'workspace-context' })
     const requestText = JSON.stringify(adapter.requests[0]!.messages)
     expect(requestText).toContain('Additional instructions from: pkg/AGENTS.md')
     expect(requestText).not.toContain('<context source=')
@@ -442,7 +392,6 @@ describe('agent loop', () => {
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
     let visibleDuringTool = false
-    const meta = { kind: 'deferred-test', version: 1 }
     ctx.tools.register(defineContentToolFixture({
       name: 'noticer',
       description: 'injects a notice',
@@ -450,12 +399,9 @@ describe('agent loop', () => {
       async execute() {
         await Promise.resolve()
         const first = { type: 'text' as const, text: 'mid-turn notice' }
-        agent.inject([first], {
-          source: { kind: 'plugin', plugin: 'x' },
-          meta,
-        })
+        agent.inject({ content: [first], source: { kind: 'plugin', plugin: 'x' } })
         first.text = 'mutated after inject'
-        agent.inject([{ type: 'text', text: 'second notice' }], { source: { kind: 'plugin', plugin: 'x' } })
+        agent.inject({ content: [{ type: 'text', text: 'second notice' }], source: { kind: 'plugin', plugin: 'x' } })
         visibleDuringTool = agent.session.events.some(e => e.type === 'user/message' && e.data.source.kind === 'plugin')
         return [{ type: 'text', text: 'ok' }]
       },
@@ -476,9 +422,6 @@ describe('agent loop', () => {
     const contexts = agent.session.events.filter(e => e.type === 'user/message' && e.data.source.kind === 'plugin')
     expect(contexts).toHaveLength(2)
     expect(result.seq).toBeLessThan(contexts[0]!.seq)
-    expect(contexts[0]?.type === 'user/message' && contexts[0].data).toMatchObject({
-      meta,
-    })
     expect(contexts.flatMap(event => event.type === 'user/message' ? event.data.content : []))
       .toEqual([
         { type: 'text', text: 'mid-turn notice' },
@@ -511,10 +454,7 @@ describe('agent loop', () => {
       parameters: {},
       async execute() {
         expect(() => {
-          agent.inject([{ type: 'text', text: 'invalid' }], {
-            source: { kind: 'plugin', plugin: 'test' },
-            meta: { bigint: 1n } as never,
-          })
+          agent.inject({ content: [{ type: 'text', text: 'invalid' }], source: { kind: 'plugin', plugin: 'test', bigint: 1n } as never })
         }).toThrow('agent context must be losslessly JSON-serializable')
         return [{ type: 'text', text: 'rejected invalid context' }]
       },
@@ -526,30 +466,7 @@ describe('agent loop', () => {
     expect(agent.session.events.some(event => event.type === 'user/message' && event.data.source.kind === 'plugin')).toBe(false)
   })
 
-  it('preserves SendOptions.meta on the durable user/message and steering/message', async () => {
-    const adapter = new MockAdapter([toolCallResponse('c1', 'noop', {}), textResponse('done')])
-    const ctx = await harness(adapter)
-    ctx.tools.register(defineContentToolFixture({
-      name: 'noop', description: '', parameters: {},
-      async execute() {
-        // Running steer carries its own meta onto the durable steering/message.
-        agent.steer([{ type: 'text', text: 's' }], { source: { kind: 'plugin', plugin: 'p' }, meta: { steer: 1 } })
-        return []
-      },
-    }))
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    agent.followup([{ type: 'text', text: 'go' }], { meta: { prompt: 1 } })
-    await waitForIdle(ctx, agent)
-
-    const user = agent.session.events.find(e => e.type === 'user/message')
-    expect(user?.type === 'user/message' && user.data.meta).toEqual({ prompt: 1 })
-    const steering = agent.session.events.find(e => e.type === 'steering/message')
-    expect(steering?.type === 'steering/message' && steering.data.meta).toEqual({ steer: 1 })
-  })
-
-  it('agent/turn-continuation can force-continue (/loop pattern) and force-stop', async () => {
-    // force-continue: model never calls tools, but a plugin forces 3 steps
+  it('agent/turn-stopping can steer another step (/loop pattern)', async () => {
     const adapter = new MockAdapter([
       textResponse('step 1'),
       textResponse('step 2'),
@@ -560,9 +477,10 @@ describe('agent loop', () => {
 
     let steps = 0
     ctx.on('session/event', (_session, event) => { if (event.type === 'step/end') steps++ })
-    ctx.on('agent/turn-continuation', async (_agent, _turn, _defaultDecision, _signal, next) => {
-      if (steps < 3) return { action: 'continue' as const }
-      return next()
+    ctx.on('agent/turn-stopping', (subject) => {
+      if (steps < 3) {
+        subject.steer({ content: [{ type: 'text', text: 'continue' }], source: { kind: 'plugin', plugin: 'loop-test' } })
+      }
     })
 
     send(agent, 'go')
@@ -571,35 +489,75 @@ describe('agent loop', () => {
     expect(adapter.requests).toHaveLength(3)
   })
 
-  it('agent/turn-continuation can veto continuation despite tool calls (budget-guard pattern)', async () => {
+  it('a tool can conclude the turn despite owing a follow-up request', async () => {
     const adapter = new MockAdapter([toolCallResponse('c1', 'echo', { text: 'x' })])
     const ctx = await harness(adapter)
     ctx.tools.register(defineContentToolFixture({
       name: 'echo',
       description: '',
       parameters: { text: { type: 'string' } },
-      async execute(args) {
+      async execute(args, exec) {
+        exec.concludeTurn()
         return [{ type: 'text', text: String(args.text) }]
       },
     }))
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    ctx.on('agent/turn-continuation', async () => ({ action: 'stop' }) as const)
-
     send(agent, 'go')
     await waitForIdle(ctx, agent)
     // only one model call despite the tool call requesting a follow-up
     expect(adapter.requests).toHaveLength(1)
-    // tool still executed before the decision
+    // The tool still executes and durably records its result.
     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 () => {
+    const adapter = new MockAdapter([
+      toolCallResponse('c1', 'finalize', {}),
+      textResponse('next turn reply'),
+    ])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
+    ctx.tools.register(defineContentToolFixture({
+      name: 'finalize',
+      description: '',
+      parameters: {},
+      async execute(_args, exec) {
+        // Steering lands while the concluding tool is still executing.
+        agent.steer({ content: [{ type: 'text', text: 'late steering' }], source: { kind: 'user' } })
+        exec.concludeTurn()
+        return [{ type: 'text', text: 'final' }]
+      },
+    }))
+
+    send(agent, 'go')
+    await waitForIdle(ctx, agent)
+
+    // The terminal result stands: no extra request reopens the concluded turn.
+    expect(adapter.requests).toHaveLength(1)
+    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)
+    const texts = adapter.requests[1]!.messages
+      .flatMap(message => message.content)
+      .filter(block => block.type === 'text')
+      .map(block => block.text)
+    expect(texts).toContain('late steering')
+  })
+
   it('agent/request waterfall switches models by returning a replacement config; the switch is logged', async () => {
     const adapter = new MockAdapter([textResponse('ok')])
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    ctx.on('agent/request', async (_agent, _turn, _step, config, _signal, _next) => {
+    ctx.on('agent/request', async (_agent, _turn, _step, _signal, next) => {
+      const config = await next()
       // The seed is frozen — config is not a mutable per-call knob; a switch
       // is proposed by returning a replacement, and the loop logs it.
       expect(Object.isFrozen(config)).toBe(true)
@@ -616,7 +574,7 @@ describe('agent loop', () => {
     expect(headerEvent?.type === 'request/header' && headerEvent.data.header.config.model).toBe('other-model')
   })
 
-  it('agent/pre-step fires once per step before the step is opened', async () => {
+  it('agent/step fires once per step before the step is opened', async () => {
     const adapter = new MockAdapter([
       toolCallResponse('c1', 'echo', {}, 'calling echo'),
       textResponse('done'),
@@ -629,7 +587,7 @@ describe('agent loop', () => {
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     const fires: { turn: number; step: number; signal: AbortSignal }[] = []
-    ctx.on('agent/pre-step', (subject, turn, step, signal) => {
+    ctx.on('agent/step', (subject, turn, step, signal) => {
       if (subject === agent) fires.push({ turn, step, signal })
     })
 
@@ -643,7 +601,7 @@ describe('agent loop', () => {
     expect(fires.every(({ signal }) => signal instanceof AbortSignal)).toBe(true)
   })
 
-  it('agent/pre-step fires BEFORE the step it precedes opens (events land outside the step)', async () => {
+  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.
     const adapter = new MockAdapter([textResponse('ok')])
@@ -651,7 +609,7 @@ describe('agent loop', () => {
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     let injected = false
-    ctx.on('agent/pre-step', (subject) => {
+    ctx.on('agent/step', (subject) => {
       if (subject === agent && !injected) {
         injected = true
         subject.session.append('user/message', {
@@ -677,7 +635,7 @@ describe('agent loop', () => {
     expect(injectedSeq).toBeLessThan(firstStepStartSeq)
   })
 
-  it('a throwing agent/pre-step listener ends the turn (error), not the loop', async () => {
+  it('a throwing agent/step listener ends the turn (error), not the loop', async () => {
     // Before step/start, a pre-step throw reaches the turn catch: no step needs
     // closing, the turn records error, and the loop remains available.
     const adapter = new MockAdapter([textResponse('second turn ok')])
@@ -685,12 +643,14 @@ describe('agent loop', () => {
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     let throwOnce = true
-    ctx.on('agent/pre-step', () => {
+    ctx.on('agent/step', () => {
       if (throwOnce) { throwOnce = false; throw new Error('boom in pre-step') }
     })
 
     const errors: Error[] = []
-    ctx.on('agent/error', (_a, _t, _s, error) => void errors.push(error))
+    ctx.on('agent/error', (_a, _t, _s, error) => {
+      if (error instanceof Error) errors.push(error)
+    })
 
     send(agent, 'first')
     await waitForIdle(ctx, agent)
@@ -765,9 +725,10 @@ describe('agent loop', () => {
     ctx.on('session/event', (_session, event) => { if (event.type === 'step/end') steps++ })
     // Force exactly one continuation (step 1 → step 2), then defer to default
     // (step 2 is a plain stop with no tool calls → stops).
-    ctx.on('agent/turn-continuation', async (_agent, _turn, _defaultDecision, _signal, next) => {
-      if (steps < 2) return { action: 'continue' as const }
-      return next()
+    ctx.on('agent/turn-stopping', (subject) => {
+      if (steps < 2) {
+        subject.steer({ content: [{ type: 'text', text: 'continue after truncation' }], source: { kind: 'plugin', plugin: 'max-tokens-test' } })
+      }
     })
 
     const reasons: TurnEndReason[] = []
@@ -781,6 +742,7 @@ describe('agent loop', () => {
     expect(adapter.requests[1]!.messages).toEqual([
       { role: 'user', content: [{ type: 'text', text: 'go' }] },
       { role: 'assistant', content: [{ type: 'text', text: 'first half' }], provenance: { provider: 'mock', model: 'mock' } },
+      { role: 'user', content: [{ type: 'text', text: 'continue after truncation' }] },
     ])
     expect(reasons).toEqual([{ kind: 'max-tokens' }])
   })
@@ -916,18 +878,11 @@ describe('agent loop', () => {
       { type: 'finish', reason: { kind: 'max-tokens' } },
     ]])
     const ctx = await harness(adapter)
-    let stepResults = 0
-    ctx.on('agent/step-result', async (_agent, _turn, _step, message, _signal, next) => {
-      stepResults += 1
-      expect(message.content).toEqual([{ type: 'text', text: 'partial text' }])
-      return next()
-    })
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     send(agent, 'go')
     await waitForIdle(ctx, agent)
 
-    expect(stepResults).toBe(1)
     expect(agent.session.events.some(e => e.type === 'tool/call')).toBe(false)
     expect(agent.session.deriveMessages()).toEqual([
       { role: 'user', content: [{ type: 'text', text: 'go' }] },
@@ -965,91 +920,6 @@ describe('agent loop', () => {
     expect(turnEnd?.type === 'turn/end' && turnEnd.data.reason.kind).toBe('completed')
   })
 
-  it('keeps same-tick sends in separate turns and checkpoints before the next starts', async () => {
-    const adapter = new MockAdapter([textResponse('first answer'), textResponse('second answer')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    const firstFlush = Promise.withResolvers<undefined>()
-    const releaseFirstFlush = Promise.withResolvers<undefined>()
-    let flushes = 0
-    ctx.on('session/flush', async (session) => {
-      if (session !== agent.session) return
-      flushes += 1
-      if (flushes === 1) {
-        firstFlush.resolve(undefined)
-        await releaseFirstFlush.promise
-      }
-    })
-
-    const turns: number[] = []
-    ctx.on('session/event', (session, event) => {
-      if (session === agent.session && event.type === 'turn/start') turns.push(event.data.turn)
-    })
-
-    const idle = waitForIdle(ctx, agent)
-    send(agent, 'first message')
-    send(agent, 'second message')
-
-    await firstFlush.promise
-    expect(turns).toEqual([1])
-    expect(adapter.requests).toHaveLength(1)
-
-    releaseFirstFlush.resolve(undefined)
-    await idle
-
-    expect(turns).toEqual([1, 2])
-    expect(flushes).toBe(2)
-    expect(adapter.requests).toHaveLength(2)
-    expect(JSON.stringify(adapter.requests[1]!.messages)).toContain('first answer')
-    expect(JSON.stringify(adapter.requests[1]!.messages)).toContain('second message')
-  })
-
-  it('holds a turn-end listener send behind the closing turn checkpoint', async () => {
-    const adapter = new MockAdapter([textResponse('first answer'), textResponse('second answer')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    const firstFlush = Promise.withResolvers<undefined>()
-    const releaseFirstFlush = Promise.withResolvers<undefined>()
-    let flushes = 0
-    ctx.on('session/flush', async (session) => {
-      if (session !== agent.session) return
-      flushes += 1
-      if (flushes === 1) {
-        firstFlush.resolve(undefined)
-        await releaseFirstFlush.promise
-      }
-    })
-
-    const turns: number[] = []
-    const statuses: string[] = []
-    ctx.on('agent/status', (subject, status) => {
-      if (subject === agent) statuses.push(status)
-    })
-    ctx.on('session/event', (session, event) => {
-      if (session !== agent.session) return
-      if (event.type === 'turn/start') turns.push(event.data.turn)
-      if (event.type === 'turn/end' && event.data.turn === 1) send(agent, 'turn-end listener message')
-    })
-
-    const idle = waitForIdle(ctx, agent)
-    send(agent, 'first message')
-    await firstFlush.promise
-
-    expect(turns).toEqual([1])
-    expect(adapter.requests).toHaveLength(1)
-
-    releaseFirstFlush.resolve(undefined)
-    await idle
-
-    expect(turns).toEqual([1, 2])
-    expect(statuses).toEqual(['running', 'idle'])
-    expect(adapter.requests).toHaveLength(2)
-    expect(JSON.stringify(adapter.requests[1]!.messages)).toContain('first answer')
-    expect(JSON.stringify(adapter.requests[1]!.messages)).toContain('turn-end listener message')
-  })
-
   it('keeps a reentrant agent/inbox/enqueue send as the next independent turn', async () => {
     const adapter = new MockAdapter([textResponse('first'), textResponse('second')])
     const ctx = await harness(adapter)
@@ -1083,12 +953,9 @@ describe('agent loop', () => {
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     const idle = waitForIdle(ctx, agent)
-    agent.followup([{ type: 'text', text: 'user message' }])
+    agent.followup({ content: [{ type: 'text', text: 'user message' }], source: { kind: 'user' } })
     await Promise.resolve()
-    agent.followup(
-      [{ type: 'text', text: 'plugin message' }],
-      { source: { kind: 'plugin', plugin: 'test' } },
-    )
+    agent.followup({ content: [{ type: 'text', text: 'plugin message' }], source: { kind: 'plugin', plugin: 'test' } })
     await idle
 
     const triggers = agent.session.events
@@ -1163,26 +1030,6 @@ describe('agent loop', () => {
     ])
   })
 
-  it('awaits session/flush at turn end (persistence checkpoint)', async () => {
-    const adapter = new MockAdapter([textResponse('ok')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-
-    let flushed = 0
-    let flushedBeforeIdle = false
-    ctx.on('session/flush', async (session) => {
-      await new Promise(r => setTimeout(r, 10))
-      flushed++
-      flushedBeforeIdle = agent.status !== 'idle'
-      void session
-    })
-
-    send(agent, 'hi')
-    await waitForIdle(ctx, agent)
-    expect(flushed).toBe(1)
-    expect(flushedBeforeIdle).toBe(true)
-  })
-
   it('errors from the model surface as agent/error and end the turn', async () => {
     const adapter = new MockAdapter([]) // script exhausted → throws
     const ctx = await harness(adapter)
@@ -1190,7 +1037,9 @@ describe('agent loop', () => {
 
     const errors: Error[] = []
     const reasons: TurnEndReason[] = []
-    ctx.on('agent/error', (_agent, _turn, _step, error) => void errors.push(error))
+    ctx.on('agent/error', (_agent, _turn, _step, error) => {
+      if (error instanceof Error) errors.push(error)
+    })
     ctx.on('session/event', (_s, event) => { if (event.type === 'turn/end') reasons.push(event.data.reason) })
 
     send(agent, 'hi')
@@ -1222,9 +1071,7 @@ describe('agent loop', () => {
     await fiber.dispose()
     await driverDone(agent)
 
-    expect(agent.status).toBe('disposed')
     expect(ctx.agents.get(SessionId('scoped'))).toBeUndefined()
-    expect(() => { send(agent, 'too late') }).toThrow('disposed')
   })
 
   it('creates agents from config on startup', async () => {

packages/core/agent-loop/tests/properties.spec.ts

@@ -5,8 +5,8 @@
  * is a finding, not timing noise.
  *
  * Invariants: every sent message appears exactly once in the log (none lost);
- * turn numbers strictly increase; status transitions follow the legal machine
- * idle→running→idle (and →disposed at teardown).
+ * turn numbers strictly increase; status transitions follow
+ * idle→running→idle, while teardown is a registry lifecycle.
  */
 
 import { describe, expect, it } from 'vitest'
@@ -115,7 +115,7 @@ describe('agent loop scheduling properties', () => {
           const { seen: trace } = recordStatus(ctx, agent)
           const idle = nextIdle(ctx, agent)
           // Send all in one synchronous tick: they queue before the loop wakes.
-          for (const text of texts) agent.followup([{ type: 'text', text }])
+          for (const text of texts) agent.followup({ content: [{ type: 'text', text }], source: { kind: 'user' } })
           await idle
 
           // No message lost: every send appears as a user/message, in order.
@@ -142,7 +142,7 @@ describe('agent loop scheduling properties', () => {
           const agent = ctx.agentLoop.create(SessionId('a'), { provider: 'mock', model: 'mock' })
           for (const text of texts) {
             const idle = nextIdle(ctx, agent)
-            agent.followup([{ type: 'text', text }])
+            agent.followup({ content: [{ type: 'text', text }], source: { kind: 'user' } })
             await idle
           }
           // Each send was drained at a separate turn start: N turns, 1..N.
@@ -171,7 +171,7 @@ describe('agent loop scheduling properties', () => {
           for (const step of steps) {
             const idle = nextIdle(ctx, agent)
             lastIdle = idle
-            agent.followup([{ type: 'text', text: step.text }])
+            agent.followup({ content: [{ type: 'text', text: step.text }], source: { kind: 'user' } })
             if (step.settle) await idle
           }
           await lastIdle

packages/core/agent-loop/tests/request-cache.e2e.ts

@@ -73,10 +73,10 @@ describe.skipIf(!process.env.DEEPSEEK_API_KEY)('log-derived request cache hits (
     const agent = ctx.agentLoop.create(SessionId('cache-e2e'), { provider: 'deepseek', model: 'deepseek-v4-flash' })
 
     // Turn 1: forces a tool call → at least two steps (two model requests).
-    agent.followup([{ type: 'text', text: 'Look up the key "deploy-color" with the lookup tool and tell me the value.' }])
+    agent.followup({ content: [{ type: 'text', text: 'Look up the key "deploy-color" with the lookup tool and tell me the value.' }], source: { kind: 'user' } })
     await waitForIdle(ctx, agent)
     // Turn 2: a follow-up over the same (longer) prefix.
-    agent.followup([{ type: 'text', text: 'Thanks. Repeat that value one more time.' }])
+    agent.followup({ content: [{ type: 'text', text: 'Thanks. Repeat that value one more time.' }], source: { kind: 'user' } })
     await waitForIdle(ctx, agent)
 
     const usages = [...agent.session.events]

packages/core/agent-loop/tests/request-error.spec.ts

@@ -0,0 +1,161 @@
+import { describe, expect, it } from 'vitest'
+import { Context } from 'cordis'
+import AgentRegistry from '@deepseek-ai/dsh-agent'
+import AgentLoop from '@deepseek-ai/dsh-agent-loop'
+import LlmService, { LlmError } from '@deepseek-ai/dsh-llm'
+import type { LlmFailure, ResolvedRetryPolicy } from '@deepseek-ai/dsh-llm'
+import SessionStore, { SessionId } from '@deepseek-ai/dsh-session'
+import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
+import ToolRegistry from '@deepseek-ai/dsh-tools'
+import { MockAdapter, textResponse } from './mock-adapter.ts'
+
+async function harness(adapter: MockAdapter): Promise<Context> {
+  const ctx = new Context()
+  await ctx.plugin(LlmService)
+  await ctx.plugin(SessionStore)
+  await ctx.plugin(SystemPrompt)
+  await ctx.plugin(ToolRegistry)
+  await ctx.plugin(AgentRegistry)
+  await ctx.plugin(AgentLoop, { agents: [] })
+  ctx.llm.registerAdapter(['mock'], adapter)
+  return ctx
+}
+
+function fail(message: string, code: string): () => never {
+  return () => {
+    throw new LlmError(message, code)
+  }
+}
+
+describe('agent/request-error', () => {
+  it('does not offer middleware failures to request recovery', async () => {
+    const adapter = new MockAdapter([textResponse('unused')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('request-error-narrow'), { provider: 'mock', model: 'mock' })
+    let recoveries = 0
+    ctx.on('agent/request', () => {
+      throw new LlmError('middleware failed', 'MIDDLEWARE')
+    })
+    ctx.on('agent/request-error', async () => {
+      recoveries += 1
+    })
+
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
+    await agent.whenIdle()
+
+    expect(recoveries).toBe(0)
+    expect(adapter.requests).toHaveLength(0)
+  })
+
+  it('lets each failed request return a retry action before its turn closes', async () => {
+    const adapter = new MockAdapter([
+      fail('busy', 'RATE_LIMIT'),
+      fail('unavailable', 'SERVICE_UNAVAILABLE'),
+      textResponse('ok'),
+    ])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('request-error-retry'), { provider: 'mock', model: 'mock' })
+    const seen: {
+      turn: number
+      step: number
+      failure: LlmFailure
+      priorFailures: readonly LlmFailure[]
+      retryPolicy: ResolvedRetryPolicy | undefined
+    }[] = []
+    const statuses: string[] = []
+    const settledTurns: number[] = []
+    ctx.on('agent/status', (subject, status) => {
+      if (subject === agent) statuses.push(status)
+    })
+    ctx.on('agent/settled', (subject, turn) => {
+      if (subject === agent) settledTurns.push(turn)
+    })
+    ctx.on('agent/request-error', async (
+      subject, turn, step, _error, failure, priorFailures, retryPolicy,
+    ) => {
+      expect(subject).toBe(agent)
+      expect(agent.session.events.at(-1)).toMatchObject({
+        type: 'step/end',
+        data: { turn, step },
+      })
+      seen.push({ turn, step, failure, priorFailures, retryPolicy })
+      return { kind: 'retry' }
+    })
+
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
+    await agent.whenIdle()
+
+    expect(seen.map(item => ({
+      turn: item.turn,
+      step: item.step,
+      code: item.failure.code,
+    }))).toEqual([
+      {
+        turn: 1,
+        step: 1,
+        code: 'RATE_LIMIT',
+      },
+      {
+        turn: 2,
+        step: 1,
+        code: 'SERVICE_UNAVAILABLE',
+      },
+    ])
+    expect(agent.session.events.filter(event => event.type === 'turn/start').map(event => event.data.trigger))
+      .toEqual([
+        { kind: 'message', source: { kind: 'user' } },
+        { kind: 'retry' },
+        { kind: 'retry' },
+      ])
+    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' }),
+    ])
+    expect(statuses).toEqual(['running', 'idle'])
+    expect(settledTurns).toEqual([3])
+  })
+
+  it('lets cancellation win over a retry action', async () => {
+    const adapter = new MockAdapter([fail('busy', 'RATE_LIMIT'), textResponse('unused')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('request-error-cancel'), { provider: 'mock', model: 'mock' })
+    ctx.on('agent/request-error', async (subject) => {
+      subject.cancel({ kind: 'user' })
+      return { kind: 'retry' }
+    })
+
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
+    await agent.whenIdle()
+
+    expect(adapter.requests).toHaveLength(1)
+    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' } },
+    })
+  })
+
+  it('does not retry when the recovery listener fails before returning its action', async () => {
+    const adapter = new MockAdapter([fail('busy', 'RATE_LIMIT'), textResponse('unused')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('request-error-recovery-failed'), {
+      provider: 'mock',
+      model: 'mock',
+    })
+    ctx.on('agent/request-error', async () => {
+      throw new Error('recovery failed')
+    })
+
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
+    await agent.whenIdle()
+
+    expect(adapter.requests).toHaveLength(1)
+    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: 'error' } },
+    })
+  })
+})

packages/core/agent-loop/tests/request-log.spec.ts

@@ -1,82 +0,0 @@
-/**
- * recordRequestHeader unit tests: exactly one of three things per request —
- * an 'initial' snapshot (log has no header yet), a 'resume' snapshot (fresh
- * loop instance over a log that has one), nothing (header unchanged), or a
- * full 'change' snapshot.
- */
-
-import { describe, expect, it } from 'vitest'
-import { Session, SessionId, canonicalHeader } from '@deepseek-ai/dsh-session'
-import type { SessionEvent } from '@deepseek-ai/dsh-session'
-import type { ToolSchema } from '@deepseek-ai/dsh-llm'
-import { createTransmissionLog, recordRequestHeader } from '../src/request-log.ts'
-
-function tool(name: string, description = 'd'): ToolSchema {
-  return { name, description, parameters: { type: 'object' } }
-}
-
-function openSession(id: string): Session {
-  const session = new Session(SessionId(id))
-  session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
-  return session
-}
-
-function headerEvents(session: Session): SessionEvent[] {
-  return session.events.filter(e => e.type === 'request/header')
-}
-
-describe('recordRequestHeader', () => {
-  it("anchors a new conversation with an 'initial' snapshot, then logs nothing while unchanged", () => {
-    const session = openSession('rl-initial')
-    const state = createTransmissionLog()
-    const header = canonicalHeader({ config: { provider: 'mock', model: 'm' }, system: 's', tools: [tool('t')] })
-
-    recordRequestHeader(session, state, header)
-    const [first] = headerEvents(session)
-    expect(first?.type === 'request/header' && first.data.reason).toBe('initial')
-
-    recordRequestHeader(session, state, header)
-    expect(headerEvents(session)).toHaveLength(1)
-  })
-
-  it("anchors a fresh loop instance over an anchored log with a 'resume' snapshot, even unchanged", () => {
-    const session = openSession('rl-resume')
-    const header = canonicalHeader({ config: { provider: 'mock', model: 'm' }, system: 's' })
-    recordRequestHeader(session, createTransmissionLog(), header)
-
-    // A second instance (process restart / fork): the boundary itself is a
-    // recorded fact — snapshot appended even though the header is identical.
-    recordRequestHeader(session, createTransmissionLog(), header)
-    const events = headerEvents(session)
-    expect(events).toHaveLength(2)
-    expect(events[1]?.type === 'request/header' && events[1].data.reason).toBe('resume')
-  })
-
-  it("logs a full 'change' snapshot for a mid-run change, and the fold reproduces the header", () => {
-    const session = openSession('rl-change')
-    const state = createTransmissionLog()
-    const first = canonicalHeader({ config: { provider: 'mock', model: 'm' }, system: 'a\nb', tools: [tool('t')] })
-    recordRequestHeader(session, state, first)
-
-    const second = canonicalHeader({ config: { provider: 'mock', model: 'm' }, system: 'a\nc', tools: [tool('t'), tool('u')] })
-    recordRequestHeader(session, state, second)
-    const events = headerEvents(session)
-    expect(events).toHaveLength(2)
-    expect(events[1]?.type === 'request/header' && events[1].data.reason).toBe('change')
-    expect(session.requestHeader()).toEqual(second)
-  })
-
-  it("records a pure tool reordering as a 'change' snapshot", () => {
-    const session = openSession('rl-reorder')
-    const state = createTransmissionLog()
-    const first = canonicalHeader({ config: { provider: 'mock', model: 'm' }, tools: [tool('a'), tool('b')] })
-    recordRequestHeader(session, state, first)
-
-    const reordered = canonicalHeader({ config: { provider: 'mock', model: 'm' }, tools: [tool('b'), tool('a')] })
-    recordRequestHeader(session, state, reordered)
-    const events = headerEvents(session)
-    expect(events).toHaveLength(2)
-    expect(events[1]?.type === 'request/header' && events[1].data.reason).toBe('change')
-    expect(session.requestHeader()).toEqual(reordered)
-  })
-})

packages/core/agent-loop/tests/request-reconstruction.spec.ts

@@ -41,7 +41,7 @@ function waitForIdle(ctx: Context, agent: Agent): Promise<void> {
 }
 
 function send(agent: Agent, text: string) {
-  agent.followup([{ type: 'text', text }])
+  agent.followup({ content: [{ type: 'text', text }], source: { kind: 'user' } })
 }
 
 /** Assert `previous` is a strict value-prefix of `current`. */
@@ -115,7 +115,7 @@ describe('request stability across the loop', () => {
     const adapter = new MockAdapter([textResponse('one'), textResponse('two')], reasoning)
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('effort'), { provider: 'mock', model: 'mock' })
-    ctx.on('agent/request', async (_agent, turn, _step, _config, _signal, next) => {
+    ctx.on('agent/request', async (_agent, turn, _step, _signal, next) => {
       const config = await next()
       return turn === 2 ? { ...config, reasoningEffort: ReasoningEffortId('max') } : config
     })
@@ -136,20 +136,26 @@ describe('request stability across the loop', () => {
     ])
     expect(headers.map(event => event.data.reason)).toEqual(['initial', 'change'])
 
-    const resumedAdapter = new MockAdapter([textResponse('three')], reasoning)
-    const resumedCtx = await harness(resumedAdapter)
-    const resumedHandle = await resumedCtx.agents.create({
-      sessionId: SessionId('effort-resumed'),
-      seed: structuredClone(agent.session.events),
-      agentOptions: { provider: 'mock', model: 'mock' },
-    })
-    send(resumedHandle.agent, 'third')
-    await waitForIdle(resumedCtx, resumedHandle.agent)
+    for (const [model, effort] of [
+      ['mock', ReasoningEffortId('max')],
+      ['replacement', ReasoningEffortId('high')],
+    ] as const) {
+      const resumedAdapter = new MockAdapter([textResponse('resumed')], reasoning)
+      const resumedCtx = await harness(resumedAdapter)
+      const resumedHandle = await resumedCtx.agents.create({
+        sessionId: SessionId(`effort-${model}`),
+        seed: structuredClone(agent.session.events),
+        agentOptions: { provider: 'mock', model },
+      })
+      send(resumedHandle.agent, 'resumed')
+      await waitForIdle(resumedCtx, resumedHandle.agent)
 
-    expect(resumedAdapter.requests[0]?.reasoningEffort).toBe(ReasoningEffortId('max'))
-    const resumedHeaders = resumedHandle.agent.session.events.filter(event => event.type === 'request/header')
-    expect(resumedHeaders.at(-1)?.data.header.config.reasoningEffort).toBe(ReasoningEffortId('max'))
-    expect(resumedHeaders.at(-1)?.data.reason).toBe('resume')
+      expect(resumedAdapter.requests[0]?.model).toBe(model)
+      expect(resumedAdapter.requests[0]?.reasoningEffort).toBe(effort)
+      const resumedHeaders = resumedHandle.agent.session.events.filter(event => event.type === 'request/header')
+      expect(resumedHeaders.at(-1)?.data.header.config.reasoningEffort).toBe(effort)
+      expect(resumedHeaders.at(-1)?.data.reason).toBe('resume')
+    }
   })
 
   it('keeps exact-model resolution, request logging, and dispatch on one adapter registration', async () => {
@@ -234,7 +240,7 @@ describe('request stability across the loop', () => {
     await handle.dispose()
 
     expect(signal.aborted).toBe(true)
-    expect(handle.agent.status).toBe('disposed')
+    expect(handle.agent.status).toBe('idle')
     expect(adapter.requests).toHaveLength(0)
     expect(handle.agent.session.events.some(event => event.type === 'request/header')).toBe(false)
   })
@@ -252,7 +258,9 @@ describe('request stability across the loop', () => {
       }([])
       const ctx = await harness(adapter)
       const errors: Error[] = []
-      ctx.on('agent/error', (_agent, _turn, _step, error) => void errors.push(error))
+      ctx.on('agent/error', (_agent, _turn, _step, error) => {
+        if (error instanceof Error) errors.push(error)
+      })
       const agent = ctx.agentLoop.create(SessionId(`reasoning-${kind}`), {
         provider: 'mock',
         model: 'mock',
@@ -266,6 +274,40 @@ describe('request stability across the loop', () => {
     },
   )
 
+  it('lets a short-circuiting llm/stream listener own an unregistered route', async () => {
+    const ctx = new Context()
+    await ctx.plugin(LlmService)
+    await ctx.plugin(SessionStore)
+    await ctx.plugin(SystemPrompt, { persona: 'stable base' })
+    await ctx.plugin(ToolRegistry)
+    await ctx.plugin(AgentRegistry)
+    await ctx.plugin(AgentLoop, { agents: [] })
+    let observed: GenerateOptions | undefined
+    ctx.on('llm/stream', (options) => {
+      observed = options
+      return (async function* () {
+        yield* textResponse('owned')
+      })()
+    })
+    const agent = ctx.agentLoop.create(SessionId('listener-owned'), {
+      provider: 'listener',
+      model: 'virtual',
+    })
+
+    send(agent, 'go')
+    await waitForIdle(ctx, agent)
+
+    expect(observed).toMatchObject({ provider: 'listener', model: 'virtual' })
+    expect(agent.session.requestHeader()?.config).toEqual({
+      provider: 'listener',
+      model: 'virtual',
+    })
+    expect(agent.session.deriveMessages().at(-1)?.content).toContainEqual({
+      type: 'text',
+      text: 'owned',
+    })
+  })
+
   it('a compaction replace rewrites the resend, and the log explains it', async () => {
     const adapter = new MockAdapter([textResponse('one'), textResponse('two')])
     const ctx = await harness(adapter)
@@ -276,7 +318,7 @@ describe('request stability across the loop', () => {
 
     // A pre-step listener compacts turn 1's history before turn 2's step —
     // the sanctioned surface rewrite, landing OUTSIDE the step.
-    const preStep = ctx.on('agent/pre-step', () => {
+    const preStep = ctx.on('agent/step', () => {
       preStep()
       const session = agent.session
       const nodes = session.surface.nodes
@@ -329,10 +371,10 @@ describe('request stability across the loop', () => {
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     let injected = false
-    ctx.on('agent/request', async (_agent, _turn, _step, _config, _signal, next) => {
+    ctx.on('agent/request', async (_agent, _turn, _step, _signal, next) => {
       if (!injected) {
         injected = true
-        agent.inject([{ type: 'text', text: '[late context]' }], { source: { kind: 'plugin', plugin: 'test' } })
+        agent.inject({ content: [{ type: 'text', text: '[late context]' }], source: { kind: 'plugin', plugin: 'test' } })
       }
       return next()
     })
@@ -357,7 +399,9 @@ describe('request stability across the loop', () => {
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
     const errors: Error[] = []
-    ctx.on('agent/error', (_agent, _turn, _step, error) => void errors.push(error))
+    ctx.on('agent/error', (_agent, _turn, _step, error) => {
+      if (error instanceof Error) errors.push(error)
+    })
     ctx.on('llm/stream', (options, next) => {
       // The historical failure mode this design kills: a listener rewriting
       // request content in place. The freeze turns it into a loud error.
@@ -394,7 +438,7 @@ describe('request stability across the loop', () => {
 
     const snapshots = agent2.session.events.filter(e => e.type === 'request/header')
     expect(snapshots).toHaveLength(2)
-    expect(snapshots[1]?.type === 'request/header' && snapshots[1].data.reason).toBe('resume')
+    expect(snapshots[1]?.data.reason).toBe('resume')
     // Identical header across the restart: byte-identical continuation.
     expect(adapter2.requests[0]!.system).toEqual(adapter.requests[0]!.system)
     expectPrefixExtension(adapter.requests[0]!, adapter2.requests[0]!)
@@ -405,7 +449,7 @@ describe('request stability across the loop', () => {
     const ctx = await harness(adapter)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    ctx.on('agent/request', async (_agent, _turn, _step, _config, _signal, next) => {
+    ctx.on('agent/request', async (_agent, _turn, _step, _signal, next) => {
       const config = await next()
       // next() resolves the SAME frozen seed — in-place shaping after
       // delegation is unrepresentable, so a "mutate what next() returned"
@@ -442,7 +486,9 @@ describe('request stability across the loop', () => {
     send(agent, 'go')
     await waitForIdle(ctx, agent)
     ctx.systemPrompt.section({ name: 'extra', order: 2, text: 'now with guidance' })
-    ctx.on('agent/request', async (_agent, _turn, _step, config, _signal, _next) => ({ ...config, temperature: 0.5, maxTokens: 99, stop: ['<END>'] }))
+    ctx.on('agent/request', async (_agent, _turn, _step, _signal, next) => ({
+      ...await next(), temperature: 0.5, maxTokens: 99, stop: ['<END>'],
+    }))
     send(agent, 'again')
     await waitForIdle(ctx, agent)
 

packages/core/agent-loop/tests/request-recovery.spec.ts

@@ -1,625 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { Context } from 'cordis'
-import LlmService, {
-  CallId,
-  CONTEXT_WINDOW_EXCEEDED_CODE,
-  HarnessError,
-  LlmAdapter,
-  LlmError,
-  ProviderRequestId,
-} from '@deepseek-ai/dsh-llm'
-import type { GenerateOptions, LlmFailure, StreamChunk } from '@deepseek-ai/dsh-llm'
-import SessionStore, { SessionId } from '@deepseek-ai/dsh-session'
-import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
-import ToolRegistry, { defineContentToolFixture } from '@deepseek-ai/dsh-tools'
-import type { PostToolDecision } from '@deepseek-ai/dsh-tools'
-import AgentRegistry from '@deepseek-ai/dsh-agent'
-import type { Agent } from '@deepseek-ai/dsh-agent'
-import AgentLoop from '@deepseek-ai/dsh-agent-loop'
-import { maxTokensResponse, textResponse, toolCallResponse } from './mock-adapter.ts'
-
-class FailureScriptAdapter extends LlmAdapter {
-  requests: GenerateOptions[] = []
-
-  constructor(private readonly entries: (Error | StreamChunk[])[]) {
-    super()
-  }
-
-  async * stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
-    this.requests.push(options)
-    const entry = this.entries.shift()
-    if (entry === undefined) throw new Error('failure script exhausted')
-    if (entry instanceof Error) throw entry
-    yield* entry
-  }
-}
-
-class IteratorConstructionFailureAdapter extends LlmAdapter {
-  stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
-    return {
-      [Symbol.asyncIterator](): AsyncIterator<StreamChunk> {
-        throw new LlmError('iterator construction failed', 'ITERATOR_CONSTRUCTION')
-      },
-    }
-  }
-}
-
-class SynchronousDispatchFailureAdapter extends LlmAdapter {
-  constructor(private readonly error: Error) {
-    super()
-  }
-
-  stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
-    throw this.error
-  }
-}
-
-class IteratorResultGetterFailureAdapter extends LlmAdapter {
-  constructor(
-    private readonly field: 'done' | 'value',
-    private readonly error: Error,
-  ) {
-    super()
-  }
-
-  stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
-    const result = this.field === 'done' ? {} : { done: false }
-    Object.defineProperty(result, this.field, { get: () => { throw this.error } })
-    return {
-      [Symbol.asyncIterator](): AsyncIterator<StreamChunk> {
-        return { next: () => Promise.resolve(result as unknown as IteratorResult<StreamChunk>) }
-      },
-    }
-  }
-}
-
-const streamListenerFailureCases: readonly [string, (ctx: Context) => void][] = [
-  ['synchronous listener throw', (ctx) => {
-    ctx.on('llm/stream', () => { throw new Error('synchronous stream listener failed') })
-  }],
-  ['invalid listener iterable', (ctx) => {
-    ctx.on('llm/stream', () => ({}) as AsyncIterable<StreamChunk>)
-  }],
-  ['listener wrapper iteration failure', (ctx) => {
-    ctx.on('llm/stream', (_options, next) => (async function * () {
-      for await (const chunk of next()) {
-        yield chunk
-        throw new Error('stream listener wrapper failed')
-      }
-    })())
-  }],
-]
-
-async function harness(adapter?: LlmAdapter): Promise<Context> {
-  const ctx = new Context()
-  await ctx.plugin(LlmService)
-  await ctx.plugin(SessionStore)
-  await ctx.plugin(SystemPrompt)
-  await ctx.plugin(ToolRegistry)
-  await ctx.plugin(AgentRegistry)
-  await ctx.plugin(AgentLoop, { agents: [] })
-  if (adapter) ctx.llm.registerAdapter(['mock'], adapter)
-  return ctx
-}
-
-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()
-      }
-    })
-  })
-}
-
-function send(agent: Agent): void {
-  agent.followup([{ type: 'text', text: 'go' }])
-}
-
-function contextError(message = 'context too large'): LlmError {
-  return new LlmError(message, CONTEXT_WINDOW_EXCEEDED_CODE)
-}
-
-describe('agent post-step and request-error lifecycle', () => {
-  it('fires post-step after results, buffered context, and steering but before step/end', async () => {
-    const twoCalls: StreamChunk[] = [
-      { type: 'block-start', index: 0, blockType: 'tool-call' },
-      { type: 'block-end', index: 0, block: { type: 'tool-call', id: CallId('call-1'), name: 'work', arguments: '{}' } },
-      { type: 'block-start', index: 1, blockType: 'tool-call' },
-      { type: 'block-end', index: 1, block: { type: 'tool-call', id: CallId('call-2'), name: 'work', arguments: '{}' } },
-      { type: 'usage', usage: { inputTokens: 10, outputTokens: 5 } },
-      { type: 'finish', reason: { kind: 'tool-calls' } },
-    ]
-    const adapter = new FailureScriptAdapter([twoCalls, textResponse('done')])
-    const ctx = await harness(adapter)
-    ctx.tools.register(defineContentToolFixture({
-      name: 'work',
-      description: 'do work',
-      parameters: {},
-      async execute(_args, exec) {
-        if (exec.callId === CallId('call-2')) {
-          exec.agent?.steer([{ type: 'text', text: 'steered' }], { source: { kind: 'plugin', plugin: 'test' } })
-        }
-        return [{ type: 'text', text: 'worked' }]
-      },
-    }))
-    ctx.on('tools/post-execute', async (exec, _result): Promise<PostToolDecision> => ({
-      kind: 'accept',
-      additionalContexts: [{
-        content: [{ type: 'text', text: `context for ${exec.callId}` }],
-        source: { kind: 'plugin', plugin: 'test' },
-      }],
-    }))
-    const agent = ctx.agentLoop.create(SessionId('post-step-order'), { provider: 'mock', model: 'mock' })
-    const order: string[] = []
-    ctx.on('session/event', (_session, event) => {
-      // Injected context is a plugin-sourced user/message; the direct human
-      // prompt (user source) stays untracked as before.
-      const isInjected = event.type === 'user/message' && event.data.source.kind !== 'user'
-      if (
-        event.type === 'assistant/message' || event.type === 'tool/call'
-        || event.type === 'tool/result' || isInjected
-        || event.type === 'steering/message' || event.type === 'step/end'
-      ) {
-        if (!('step' in event.data) || event.data.step === 1) order.push(isInjected ? 'context/message' : event.type)
-      }
-    })
-    ctx.on('agent/post-step', (subject, turn, step, signal) => {
-      if (subject !== agent || step !== 1) return
-      expect({ turn, step, aborted: signal.aborted }).toEqual({ turn: 1, step: 1, aborted: false })
-      subject.inject([{ type: 'text', text: 'listener mutation' }], { source: { kind: 'plugin', plugin: 'post-step' } })
-      order.push('agent/post-step')
-    })
-
-    send(agent)
-    await waitForIdle(ctx, agent)
-
-    expect(order).toEqual([
-      'assistant/message',
-      'tool/call',
-      'tool/result',
-      'tool/call',
-      'tool/result',
-      'context/message',
-      'context/message',
-      'steering/message',
-      'context/message',
-      'agent/post-step',
-      'step/end',
-    ])
-  })
-
-  it('fires post-step for max-tokens and lets cancellation override that success', async () => {
-    const adapter = new FailureScriptAdapter([maxTokensResponse('partial')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('cancel-post-step-max-tokens'), { provider: 'mock', model: 'mock' })
-    let entered!: () => void
-    const postStepEntered = new Promise<void>((resolve) => { entered = resolve })
-    ctx.on('agent/post-step', async (_agent, turn, step, signal) => {
-      expect({ turn, step }).toEqual({ turn: 1, step: 1 })
-      entered()
-      await new Promise<void>((resolve) => {
-        signal.addEventListener('abort', () => { resolve() }, { once: true })
-      })
-    })
-
-    send(agent)
-    const idle = waitForIdle(ctx, agent)
-    await postStepEntered
-    agent.cancel({ kind: 'user' })
-    await idle
-
-    expect(agent.session.events.find(event => event.type === 'assistant/message')).toMatchObject({
-      data: { usage: { inputTokens: 10, outputTokens: 7 } },
-    })
-    expect(agent.session.events.at(-1)).toMatchObject({
-      type: 'turn/end',
-      data: { reason: { kind: 'aborted' } },
-    })
-  })
-
-  it('closes the successful step as disposed when disposal lands during post-step', async () => {
-    const adapter = new FailureScriptAdapter([
-      toolCallResponse('dispose-call', 'work', {}),
-      textResponse('must not continue'),
-    ])
-    const ctx = await harness(adapter)
-    ctx.tools.register(defineContentToolFixture({
-      name: 'work',
-      description: 'do work',
-      parameters: {},
-      async execute() { return [{ type: 'text', text: 'worked' }] },
-    }))
-    const agent = ctx.agentLoop.create(SessionId('dispose-post-step'), { provider: 'mock', model: 'mock' })
-    let entered!: () => void
-    const postStepEntered = new Promise<void>((resolve) => { entered = resolve })
-    ctx.on('agent/post-step', async (_agent, turn, step, signal) => {
-      expect({ turn, step }).toEqual({ turn: 1, step: 1 })
-      entered()
-      await new Promise<void>((resolve) => {
-        signal.addEventListener('abort', () => { resolve() }, { once: true })
-      })
-    })
-
-    send(agent)
-    await postStepEntered
-    await ctx.fiber.dispose()
-
-    expect(adapter.requests).toHaveLength(1)
-    const boundaries = agent.session.events.filter(event =>
-      event.type === 'step/start' || event.type === 'step/end',
-    )
-    expect(boundaries.map(event => event.type)).toEqual(['step/start', 'step/end'])
-    expect(boundaries.map(event => event.data)).toEqual([
-      { turn: 1, step: 1 },
-      { turn: 1, step: 1 },
-    ])
-    expect(agent.session.events.at(-1)).toMatchObject({
-      type: 'turn/end',
-      data: { reason: { kind: 'disposed' } },
-    })
-  })
-
-  it.each([
-    ['thrown', contextError()],
-    ['in-band', [{ type: 'finish', reason: { kind: 'error', failure: { message: 'too large', code: CONTEXT_WINDOW_EXCEEDED_CODE, status: 400 } } }] satisfies StreamChunk[]],
-  ] as const)('recovers a %s request failure in a new reconstructable step', async (_style, failure) => {
-    const adapter = new FailureScriptAdapter([failure, textResponse('recovered')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId(`recover-${_style}`), { provider: 'mock', model: 'mock' })
-    const attempts: number[] = []
-    ctx.on('agent/request-error', async (subject, turn, step, error, facts, history, retryPolicy) => {
-      expect(subject).toBe(agent)
-      expect({ turn, step, code: error.code }).toEqual({ turn: 1, step: 1, code: CONTEXT_WINDOW_EXCEEDED_CODE })
-      expect(facts.code).toBe(CONTEXT_WINDOW_EXCEEDED_CODE)
-      expect(retryPolicy).toMatchObject({ mode: 'normal', maxRetries: 2 })
-      attempts.push(history.length)
-      subject.session.append('user/message', {
-        content: [{ type: 'text', text: 'RECOVERY SURFACE MUTATION' }],
-        source: { kind: 'plugin', plugin: 'test-recovery' },
-      }, { surfaceOp: 'append' })
-      return { action: 'retry' }
-    })
-
-    send(agent)
-    await waitForIdle(ctx, agent)
-
-    expect(attempts).toEqual([0])
-    expect(adapter.requests).toHaveLength(2)
-    expect(JSON.stringify(adapter.requests[1]!.messages)).toContain('RECOVERY SURFACE MUTATION')
-    const starts = agent.session.events.filter(event => event.type === 'step/start')
-    const ends = agent.session.events.filter(event => event.type === 'step/end')
-    expect(starts.map(event => event.data.step)).toEqual([1, 2])
-    expect(ends.map(event => event.data.step)).toEqual([1, 2])
-    const recovery = agent.session.events.find(event => event.type === 'user/message' && event.data.source.kind === 'plugin')!
-    expect(ends[0]!.seq).toBeLessThan(recovery.seq)
-    expect(recovery.seq).toBeLessThan(starts[1]!.seq)
-  })
-
-  it.each(streamListenerFailureCases)('does not offer %s to request recovery', async (_name, install) => {
-    const ctx = await harness(new FailureScriptAdapter([textResponse('unused')]))
-    const agent = ctx.agentLoop.create(SessionId(`stream-plugin-${_name.replaceAll(' ', '-')}`), { provider: 'mock', model: 'mock' })
-    let recoveries = 0
-    install(ctx)
-    ctx.on('agent/request-error', async (
-      _agent, _turn, _step, _error, _failure, _history, _retryPolicy, _signal, next,
-    ) => {
-      recoveries += 1
-      return next()
-    })
-
-    send(agent)
-    await waitForIdle(ctx, agent)
-
-    expect(recoveries).toBe(0)
-    expect(agent.session.events.at(-1)).toMatchObject({ type: 'turn/end', data: { reason: { kind: 'error' } } })
-  })
-
-  it('does not offer a nested model-call failure as the outer request failure', async () => {
-    const outer = new FailureScriptAdapter([textResponse('outer adapter must not run')])
-    const nested = new FailureScriptAdapter([contextError('nested overflow')])
-    const ctx = await harness(outer)
-    ctx.llm.registerAdapter(['nested'], nested)
-    ctx.on('llm/stream', (options, next) => {
-      if (options.provider !== 'mock') return next()
-      return (async function* () {
-        yield* ctx.llm.stream({
-          provider: 'nested',
-          model: 'nested',
-          messages: [],
-          ...options.signal === undefined ? {} : { signal: options.signal },
-        })
-        yield* next()
-      })()
-    })
-    const agent = ctx.agentLoop.create(SessionId('nested-stream-not-recoverable'), { provider: 'mock', model: 'mock' })
-    let recoveries = 0
-    ctx.on('agent/request-error', async (
-      _agent, _turn, _step, _error, _failure, _history, _retryPolicy, _signal, next,
-    ) => {
-      recoveries += 1
-      return next()
-    })
-
-    send(agent)
-    await waitForIdle(ctx, agent)
-
-    expect(nested.requests).toHaveLength(1)
-    expect(outer.requests).toHaveLength(0)
-    expect(recoveries).toBe(0)
-    expect(agent.session.events.at(-1)).toMatchObject({
-      type: 'turn/end',
-      data: { reason: { kind: 'error', message: 'nested overflow', code: CONTEXT_WINDOW_EXCEEDED_CODE } },
-    })
-  })
-
-  it.each(['prompt-submit', 'prompt-assembly', 'pre-step', 'request'] as const)(
-    'does not offer %s middleware failures to request recovery',
-    async (boundary) => {
-      const adapter = new FailureScriptAdapter([textResponse('unused')])
-      const ctx = await harness(adapter)
-      if (boundary === 'prompt-submit') {
-        ctx.on('agent/prompt-submit', () => { throw new Error('prompt submit failed') })
-      } else if (boundary === 'prompt-assembly') {
-        ctx.on('system-prompt/assemble', () => { throw new Error('prompt assembly failed') })
-      } else if (boundary === 'pre-step') {
-        ctx.on('agent/pre-step', () => { throw new Error('pre-step failed') })
-      } else {
-        ctx.on('agent/request', () => { throw new Error('request middleware failed') })
-      }
-      const agent = ctx.agentLoop.create(SessionId(`${boundary}-not-recoverable`), { provider: 'mock', model: 'mock' })
-      let recoveries = 0
-      ctx.on('agent/request-error', async (
-        _agent, _turn, _step, _error, _failure, _history, _retryPolicy, _signal, next,
-      ) => {
-        recoveries += 1
-        return next()
-      })
-
-      send(agent)
-      await waitForIdle(ctx, agent)
-
-      expect(recoveries).toBe(0)
-      expect(adapter.requests).toHaveLength(0)
-      expect(agent.session.events.at(-1)).toMatchObject({ type: 'turn/end', data: { reason: { kind: 'error' } } })
-    },
-  )
-
-  it('does not offer result, tool, or post-step plugin failures to request recovery', async () => {
-    for (const failure of ['result', 'tool', 'post-step'] as const) {
-      const adapter = new FailureScriptAdapter([
-        failure === 'tool' ? toolCallResponse(`call-${failure}`, 'work', {}) : textResponse('done'),
-        ...(failure === 'tool' ? [textResponse('done')] : []),
-      ])
-      const ctx = await harness(adapter)
-      if (failure === 'result') ctx.on('agent/step-result', () => { throw new Error('result failed') })
-      if (failure === 'post-step') ctx.on('agent/post-step', () => { throw new Error('post-step failed') })
-      if (failure === 'tool') {
-        vi.spyOn(ctx.tools, 'execute').mockRejectedValue(new Error('tool service failed'))
-      }
-      const agent = ctx.agentLoop.create(SessionId(`${failure}-not-recoverable`), { provider: 'mock', model: 'mock' })
-      let recoveries = 0
-      ctx.on('agent/request-error', async (
-        _agent, _turn, _step, _error, _failure, _history, _retryPolicy, _signal, next,
-      ) => {
-        recoveries += 1
-        return next()
-      })
-      send(agent)
-      await waitForIdle(ctx, agent)
-      expect(recoveries, failure).toBe(0)
-    }
-  })
-
-  it.each([
-    ['synchronous dispatch', (error: Error) => new SynchronousDispatchFailureAdapter(error)],
-    ['done getter', (error: Error) => new IteratorResultGetterFailureAdapter('done', error)],
-    ['value getter', (error: Error) => new IteratorResultGetterFailureAdapter('value', error)],
-  ] as const)('preserves original Error identity for adapter %s', async (_name, makeAdapter) => {
-    const original = contextError(`${_name} overflow`)
-    const ctx = await harness(makeAdapter(original))
-    const agent = ctx.agentLoop.create(SessionId(`identity-${_name.replaceAll(' ', '-')}`), { provider: 'mock', model: 'mock' })
-    let seen: Error | undefined
-    ctx.on('agent/request-error', async (
-      _agent, _turn, _step, error, _failure, _history, _retryPolicy, _signal, next,
-    ) => {
-      seen = error
-      return next()
-    })
-
-    send(agent)
-    await waitForIdle(ctx, agent)
-
-    expect(seen).toBe(original)
-  })
-
-  it('keeps an adapter error with a hostile message accessor on the recovery path', async () => {
-    const original = Object.defineProperty(new HarnessError('provider failed', 'SERVER'), 'message', {
-      get() { throw new Error('SDK message accessor trap') },
-    })
-    const ctx = await harness(new SynchronousDispatchFailureAdapter(original))
-    const agent = ctx.agentLoop.create(SessionId('hostile-message-recovery'), { provider: 'mock', model: 'mock' })
-    let seenError: Error | undefined
-    let seenFailure: LlmFailure | undefined
-    ctx.on('agent/request-error', async (
-      _agent, _turn, _step, error, failure, _history, _retryPolicy, _signal, next,
-    ) => {
-      seenError = error
-      seenFailure = failure
-      return next()
-    })
-
-    send(agent)
-    await waitForIdle(ctx, agent)
-
-    expect(seenError).toBe(original)
-    expect(seenFailure).toEqual({ message: 'LLM adapter failed', code: 'SERVER' })
-    expect(agent.session.events.at(-1)).toMatchObject({
-      type: 'turn/end',
-      data: { reason: { kind: 'error', failure: { message: 'LLM adapter failed', code: 'SERVER' } } },
-    })
-  })
-
-  it('passes structured facts beside the original Error and records its cause chain on exhaustion', async () => {
-    const original = new LlmError('provider busy', 'RATE_LIMIT', {
-      cause: new Error('upstream connection reset'),
-      status: 429,
-      providerRetryAfterMs: 2_000,
-      requestId: ProviderRequestId('req-9'),
-    })
-    Object.freeze(original)
-    const ctx = await harness(new SynchronousDispatchFailureAdapter(original))
-    const agent = ctx.agentLoop.create(SessionId('structured-request-failure'), { provider: 'mock', model: 'mock' })
-    let seenError: Error | undefined
-    let seenFailure: LlmFailure | undefined
-    let seenHistory: readonly LlmFailure[] | undefined
-    ctx.on('agent/request-error', async (
-      _agent, _turn, _step, error, failure, history, _retryPolicy, _signal, next,
-    ) => {
-      seenError = error
-      seenFailure = failure
-      seenHistory = history
-      return next()
-    })
-
-    send(agent)
-    await waitForIdle(ctx, agent)
-
-    expect(seenError).toBe(original)
-    expect(seenFailure).toEqual({
-      message: 'provider busy',
-      code: 'RATE_LIMIT',
-      status: 429,
-      providerRetryAfterMs: 2_000,
-      requestId: ProviderRequestId('req-9'),
-    })
-    expect(seenHistory).toEqual([])
-    expect(Object.isFrozen(seenHistory)).toBe(true)
-    expect(agent.session.events.at(-1)).toMatchObject({
-      type: 'turn/end',
-      data: {
-        reason: {
-          kind: 'error',
-          step: 1,
-          failure: {
-            message: 'provider busy: upstream connection reset',
-            code: 'RATE_LIMIT',
-            status: 429,
-            providerRetryAfterMs: 2_000,
-            requestId: ProviderRequestId('req-9'),
-          },
-        },
-      },
-    })
-  })
-
-  it('classifies iterator construction and explicit NO_ADAPTER as model-request failures', async () => {
-    for (const scenario of ['iterator', 'no-adapter'] as const) {
-      const ctx = scenario === 'iterator' ? await harness(new IteratorConstructionFailureAdapter()) : await harness()
-      const agent = ctx.agentLoop.create(SessionId(`request-boundary-${scenario}`), { provider: 'mock', model: 'mock' })
-      let seen = ''
-      let sawServingPolicy = false
-      ctx.on('agent/request-error', async (
-        _agent, _turn, _step, error, _failure, _history, retryPolicy, _signal, next,
-      ) => {
-        seen = error.code ?? ''
-        sawServingPolicy = retryPolicy !== undefined
-        return next()
-      })
-      send(agent)
-      await waitForIdle(ctx, agent)
-      expect(seen).toBe(scenario === 'iterator' ? 'ITERATOR_CONSTRUCTION' : 'NO_ADAPTER')
-      expect(sawServingPolicy).toBe(scenario === 'iterator')
-    }
-  })
-
-  it('tracks consecutive retry attempts and resets after a successful request', async () => {
-    const capped = new FailureScriptAdapter([contextError('first overflow'), contextError('second overflow')])
-    const cappedCtx = await harness(capped)
-    const cappedAgent = cappedCtx.agentLoop.create(SessionId('retry-cap'), { provider: 'mock', model: 'mock' })
-    const cappedHistories: string[][] = []
-    cappedCtx.on('agent/request-error', async (
-      _agent, _turn, _step, _error, _failure, history, _retryPolicy, _signal, next,
-    ) => {
-      const codes = history.map(entry => entry.code)
-      cappedHistories.push(codes)
-      return codes.length < 1 ? { action: 'retry' } : next()
-    })
-    send(cappedAgent)
-    await waitForIdle(cappedCtx, cappedAgent)
-    expect(cappedHistories).toEqual([[], [CONTEXT_WINDOW_EXCEEDED_CODE]])
-
-    const reset = new FailureScriptAdapter([
-      contextError('first overflow'),
-      toolCallResponse('retry-reset-call', 'work', {}),
-      contextError('later overflow'),
-    ])
-    const resetCtx = await harness(reset)
-    resetCtx.tools.register(defineContentToolFixture({
-      name: 'work',
-      description: 'continue',
-      parameters: {},
-      async execute() { return [{ type: 'text', text: 'worked' }] },
-    }))
-    const resetAgent = resetCtx.agentLoop.create(SessionId('retry-reset'), { provider: 'mock', model: 'mock' })
-    const resetHistories: { step: number; codes: string[] }[] = []
-    resetCtx.on('agent/request-error', async (
-      _agent, _turn, step, _error, _failure, history, _retryPolicy, _signal, next,
-    ) => {
-      resetHistories.push({ step, codes: history.map(entry => entry.code) })
-      return resetHistories.length === 1 ? { action: 'retry' } : next()
-    })
-    send(resetAgent)
-    await waitForIdle(resetCtx, resetAgent)
-    expect(resetHistories).toEqual([{ step: 1, codes: [] }, { step: 3, codes: [] }])
-  })
-
-  it('preserves the original provider error when recovery throws', async () => {
-    const adapter = new FailureScriptAdapter([contextError('original overflow')])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('recovery-throws'), { provider: 'mock', model: 'mock' })
-    ctx.on('agent/request-error', () => { throw new Error('recovery exploded') })
-
-    send(agent)
-    await waitForIdle(ctx, agent)
-
-    expect(agent.session.events.at(-1)).toMatchObject({
-      type: 'turn/end',
-      data: { reason: { kind: 'error', failure: { message: 'original overflow', code: CONTEXT_WINDOW_EXCEEDED_CODE } } },
-    })
-  })
-
-  it.each(['cancel', 'dispose'] as const)('keeps %s live through request recovery', async (action) => {
-    const adapter = new FailureScriptAdapter([contextError()])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId(`${action}-recovery`), { provider: 'mock', model: 'mock' })
-    let entered!: () => void
-    const recoveryEntered = new Promise<void>((resolve) => { entered = resolve })
-    ctx.on('agent/request-error', async (
-      _agent, _turn, _step, _error, _failure, _history, _retryPolicy, signal,
-    ) => {
-      entered()
-      await new Promise<void>((resolve) => {
-        signal.addEventListener('abort', () => { resolve() }, { once: true })
-      })
-      return { action: 'retry' }
-    })
-
-    send(agent)
-    const idle = waitForIdle(ctx, agent)
-    await recoveryEntered
-    if (action === 'cancel') {
-      agent.cancel({ kind: 'user' })
-      await idle
-    } else {
-      await ctx.fiber.dispose()
-    }
-
-    expect(adapter.requests).toHaveLength(1)
-    expect(agent.session.events.at(-1)).toMatchObject({
-      type: 'turn/end',
-      data: { reason: action === 'cancel' ? { kind: 'aborted' } : { kind: 'disposed' } },
-    })
-  })
-})

packages/core/agent-loop/tests/resume.spec.ts

@@ -146,7 +146,7 @@ describe('the session-persistence Agent Note: AgentLoop factory create/resume',
     const adapter1 = new MockAdapter([textResponse('a')])
     const { ctx: ctx1, root } = await persistentHarness(adapter1)
     const a1 = (await ctx1.agents.create({ sessionId: SessionId('nocwd-sess') })).agent
-    a1.followup([{ type: 'text', text: 'q' }], { source: { kind: 'user' } })
+    a1.followup({ content: [{ type: 'text', text: 'q' }], source: { kind: 'user' } })
     await waitForIdle(ctx1, a1)
     await ctx1.fiber.dispose()
 
@@ -174,7 +174,7 @@ describe('the session-persistence Agent Note: AgentLoop factory create/resume',
     ctx1.on('agent/session-start', (_agent, source) => void sources1.push(source))
     const a1 = (await ctx1.agents.create({ sessionId: SessionId('start-sess') })).agent
     expect(sources1).toEqual(['startup'])
-    a1.followup([{ type: 'text', text: 'q' }], { source: { kind: 'user' } })
+    a1.followup({ content: [{ type: 'text', text: 'q' }], source: { kind: 'user' } })
     await waitForIdle(ctx1, a1)
     await ctx1.fiber.dispose()
 
@@ -261,10 +261,7 @@ describe('the session-persistence Agent Note: AgentLoop factory create/resume',
       resumeSessionId: sessionId,
       agentOptions: { provider: 'mock', model: 'mock' },
     })
-    const transactionLabels = [
-      `agentLoop.owner(${sessionId})`,
-      `agentLoop.lifecycle(${sessionId})`,
-    ]
+    const transactionLabels = [`agentLoop.lifecycle(${sessionId})`]
 
     expect(ctx.fiber.getEffects().map(effect => effect.label)).toEqual(expect.arrayContaining(transactionLabels))
     await handle.dispose()
@@ -474,39 +471,14 @@ describe('the session-persistence Agent Note: AgentLoop factory create/resume',
     await ctx2.fiber.dispose()
   })
 
-  it('an idle inject() is flushed durably on its own (survives without explicit flush/dispose)', async () => {
-    // Idle injection creates and flushes a one-shot turn. No explicit flush or
-    // clean disposal follows, so disk presence proves its own checkpoint ran.
+  it('an idle inject() survives persist + resume without a synthetic turn', async () => {
     const adapter1 = new MockAdapter([textResponse('answer')])
     const { ctx: ctx1, root } = await persistentHarness(adapter1)
     const a1 = (await ctx1.agents.create({ sessionId: SessionId('inject-sess'), meta: { cwd: '/w' } })).agent
-    a1.followup([{ type: 'text', text: 'q' }], { source: { kind: 'user' } })
+    a1.followup({ content: [{ type: 'text', text: 'q' }], source: { kind: 'user' } })
     await waitForIdle(ctx1, a1)
-    a1.inject([{ type: 'text', text: 'background task 42 finished' }], { source: { kind: 'plugin', plugin: 'tool-bash' } })
-    // Let inject()'s fire-and-forget flush settle (NO explicit flush/dispose).
-    await new Promise(r => setTimeout(r, 30))
-
-    // A SEPARATE backend reads the on-disk log — proving the inject persisted
-    // itself, not a later dispose drain.
-    const probe = new Context()
-    await probe.plugin(SessionStore)
-    await probe.plugin(SessionPersistenceJsonl, { root })
-    const loaded = await probe.sessionPersistence.load(SessionId('inject-sess'))
-    expect(JSON.stringify(loaded.events)).toContain('background task 42 finished')
-    await probe.fiber.dispose()
-    await ctx1.fiber.dispose()
-  })
-
-  it('an idle inject() survives persist + resume (turn-enclosed, not dropped as crash tail)', async () => {
-    // Turn enclosure keeps idle context out of crash-tail repair, so it must
-    // survive persistence and resume.
-    const adapter1 = new MockAdapter([textResponse('answer')])
-    const { ctx: ctx1, root } = await persistentHarness(adapter1)
-    const a1 = (await ctx1.agents.create({ sessionId: SessionId('inject-sess'), meta: { cwd: '/w' } })).agent
-    a1.followup([{ type: 'text', text: 'q' }], { source: { kind: 'user' } })
-    await waitForIdle(ctx1, a1)
-    a1.inject([{ type: 'text', text: 'background task 42 finished' }], { source: { kind: 'plugin', plugin: 'tool-bash' } })
-    await ctx1.sessions.flush(a1.session)
+    a1.inject({ content: [{ type: 'text', text: 'background task 42 finished' }], source: { kind: 'plugin', plugin: 'tool-bash' } })
+    await a1.whenIdle()
     await ctx1.fiber.dispose()
 
     // Lifecycle 2: resume; the injected context is still in the derived history.
@@ -531,7 +503,7 @@ describe('the session-persistence Agent Note: AgentLoop factory create/resume',
     const adapter1 = new MockAdapter([textResponse('first answer')])
     const { ctx: ctx1, root } = await persistentHarness(adapter1)
     const a1 = (await ctx1.agents.create({ sessionId: SessionId('sess-resume'), meta: { cwd: '/w' } })).agent
-    a1.followup([{ type: 'text', text: 'first question' }], { source: { kind: 'user' } })
+    a1.followup({ content: [{ type: 'text', text: 'first question' }], source: { kind: 'user' } })
     await waitForIdle(ctx1, a1)
     const events1 = [...a1.session.events]
     const seqs1 = events1.map(e => e.seq)
@@ -558,7 +530,7 @@ describe('the session-persistence Agent Note: AgentLoop factory create/resume',
     expect(a2.session.deriveMessages()).toEqual(replay.deriveMessages())
 
     // …and a new turn continues numbering (turn 2) with contiguous seqs.
-    a2.followup([{ type: 'text', text: 'second question' }], { source: { kind: 'user' } })
+    a2.followup({ content: [{ type: 'text', text: 'second question' }], source: { kind: 'user' } })
     await waitForIdle(ctx2, a2)
     const allSeqs = a2.session.events.map(e => e.seq)
     expect(allSeqs).toEqual(allSeqs.map((_, i) => i)) // 0..N contiguous, no duplicates
@@ -583,3 +555,204 @@ describe('the session-persistence Agent Note: AgentLoop factory create/resume',
     await ctx.fiber.dispose()
   })
 })
+
+describe('creation and resume cancellation edges', () => {
+  it('rejects create() with a pre-aborted signal, including a non-Error reason', async () => {
+    const { ctx } = await persistentHarness(new MockAdapter([]))
+
+    const errorReason = new AbortController()
+    errorReason.abort(new Error('caller gave up'))
+    await expect(promptly(ctx.agents.create({
+      sessionId: SessionId('pre-aborted-error'),
+      agentOptions: { provider: 'mock', model: 'mock' },
+      signal: errorReason.signal,
+    }))).rejects.toThrow('caller gave up')
+
+    // A non-Error reason is wrapped into the creation-aborted error.
+    const stringReason = new AbortController()
+    stringReason.abort('operator string reason')
+    await expect(promptly(ctx.agents.create({
+      sessionId: SessionId('pre-aborted-string'),
+      agentOptions: { provider: 'mock', model: 'mock' },
+      signal: stringReason.signal,
+    }))).rejects.toThrow(/creation aborted/)
+
+    expect(ctx.agents.get(SessionId('pre-aborted-error'))).toBeUndefined()
+    expect(ctx.agents.get(SessionId('pre-aborted-string'))).toBeUndefined()
+    await ctx.fiber.dispose()
+  })
+
+  it('a non-Error abort reason arriving during setup is wrapped for the caller', async () => {
+    const { ctx } = await persistentHarness(new MockAdapter([]))
+    const controller = new AbortController()
+    const setupEntered = Promise.withResolvers<undefined>()
+    const setupGate = Promise.withResolvers<undefined>()
+
+    const creating = ctx.agents.create({
+      sessionId: SessionId('setup-string-abort'),
+      agentOptions: { provider: 'mock', model: 'mock' },
+      signal: controller.signal,
+      async setup() {
+        setupEntered.resolve(undefined)
+        await setupGate.promise
+      },
+    })
+    await setupEntered.promise
+    controller.abort('mid-setup string reason')
+    setupGate.resolve(undefined)
+
+    await expect(promptly(creating)).rejects.toThrow(/creation aborted/)
+    expect(ctx.agents.get(SessionId('setup-string-abort'))).toBeUndefined()
+    await ctx.fiber.dispose()
+  })
+
+  it('resume with a pre-aborted caller signal rejects out of the load race', async () => {
+    const sessionId = SessionId('resume-pre-aborted')
+    const root = await persistSession(sessionId)
+    const ctx = await mountPersistentHarness(root, new MockAdapter([]))
+    const controller = new AbortController()
+    controller.abort(new Error('resume abandoned'))
+
+    await expect(promptly(ctx.agents.resume({
+      resumeSessionId: sessionId,
+      agentOptions: { provider: 'mock', model: 'mock' },
+      signal: controller.signal,
+    }))).rejects.toThrow('resume abandoned')
+
+    expect(ctx.agents.get(sessionId)).toBeUndefined()
+    await ctx.fiber.dispose()
+  })
+
+  it('factory teardown during a hung resume load rejects with loop-inactive', async () => {
+    const sessionId = SessionId('resume-loop-teardown')
+    const root = await persistSession(sessionId)
+    const ctx = await mountPersistentHarness(root, new MockAdapter([]))
+    const snapshot = await ctx.sessionPersistence.load(sessionId)
+    const gate = Promise.withResolvers<typeof snapshot>()
+    const loadStarted = Promise.withResolvers<undefined>()
+    ctx.sessionPersistence.load = () => {
+      loadStarted.resolve(undefined)
+      return gate.promise
+    }
+
+    const resuming = ctx.agents.resume({
+      resumeSessionId: sessionId,
+      agentOptions: { provider: 'mock', model: 'mock' },
+    })
+    await loadStarted.promise
+    // Resolve the load only after teardown began: the post-load ownership
+    // check, not the abort race, must reject the wrapper.
+    const rejection = expect(promptly(resuming)).rejects.toThrow()
+    const disposal = ctx.fiber.dispose()
+    gate.resolve(structuredClone(snapshot))
+    await rejection
+    await disposal
+  })
+})
+
+describe('configured-start failure edges', () => {
+  it('a non-Error mid-load abort reason is wrapped for the resume caller', async () => {
+    const sessionId = SessionId('resume-string-mid-abort')
+    const root = await persistSession(sessionId)
+    const ctx = await mountPersistentHarness(root, new MockAdapter([]))
+    const gate = Promise.withResolvers<never>()
+    gate.promise.catch(() => undefined)
+    const loadStarted = Promise.withResolvers<undefined>()
+    ctx.sessionPersistence.load = () => {
+      loadStarted.resolve(undefined)
+      return gate.promise
+    }
+    const controller = new AbortController()
+
+    const resuming = ctx.agents.resume({
+      resumeSessionId: sessionId,
+      agentOptions: { provider: 'mock', model: 'mock' },
+      signal: controller.signal,
+    })
+    await loadStarted.promise
+    controller.abort('operator string reason')
+
+    await expect(promptly(resuming)).rejects.toThrow(/creation aborted/)
+    expect(ctx.agents.get(sessionId)).toBeUndefined()
+    await ctx.fiber.dispose()
+  })
+
+  it('a failing exact-id restore over an existing artifact stays loud', async () => {
+    const sessionId = SessionId('config-existing-corrupt')
+    const root = await persistSession(sessionId)
+    const ctx = await mountPersistentHarness(root, new MockAdapter([]))
+    // The artifact exists (list reports it) but its load fails: this is
+    // corruption, not first creation — the failure must be reported, and no
+    // fresh same-id session may shadow the broken one.
+    ctx.sessionPersistence.load = () => Promise.reject(new Error('artifact corrupt'))
+
+    const configured = new Context()
+    await configured.plugin(LlmService)
+    await configured.plugin(SessionStore)
+    await configured.plugin(SystemPrompt)
+    await configured.plugin(ToolRegistry)
+    await configured.plugin(AgentRegistry)
+    await configured.plugin(SessionPersistenceJsonl, { root })
+    configured.llm.registerAdapter(['mock'], new MockAdapter([]))
+    configured.sessionPersistence.load = id => ctx.sessionPersistence.load(id)
+    const configFailures: unknown[] = []
+    configured.on('agent-loop/config-start-failed', (_id, error) => { configFailures.push(error) })
+    const configWarnings: string[] = []
+    const configWarn = configured.logger.warn.bind(configured.logger)
+    configured.logger.warn = ((...args: unknown[]) => {
+      if (typeof args[0] === 'string') configWarnings.push(args[0])
+      return (configWarn as (...a: unknown[]) => unknown)(...args)
+    }) as typeof configured.logger.warn
+    const loop = await configured.plugin(AgentLoop, {
+      agents: [{ id: 'main', sessionId, provider: 'mock', model: 'mock' }],
+    })
+    await expect.poll(() => configFailures.length).toBe(1)
+    expect(configFailures[0]).toBeInstanceOf(Error)
+    expect((configFailures[0] as Error).message).toBe('artifact corrupt')
+    expect(configWarnings.some(w => w.includes('config-driven restore'))).toBe(true)
+    expect(configured.agents.get(sessionId)).toBeUndefined()
+
+    await loop.dispose()
+    await configured.fiber.dispose()
+    await ctx.fiber.dispose()
+  })
+
+  it('suppresses a configured-resume failure that lands after teardown', async () => {
+    const sessionId = SessionId('config-late-resume-failure')
+    const root = await persistSession(sessionId)
+    const ctx = await mountPersistentHarness(root, new MockAdapter([]))
+    const gate = Promise.withResolvers<never>()
+    gate.promise.catch(() => undefined)
+    const loadStarted = Promise.withResolvers<undefined>()
+    ctx.sessionPersistence.load = () => {
+      loadStarted.resolve(undefined)
+      return gate.promise
+    }
+    const failures: unknown[] = []
+    ctx.on('agent-loop/config-start-failed', (_id, error) => { failures.push(error) })
+
+    const configured = new Context()
+    await configured.plugin(LlmService)
+    await configured.plugin(SessionStore)
+    await configured.plugin(SystemPrompt)
+    await configured.plugin(ToolRegistry)
+    await configured.plugin(AgentRegistry)
+    await configured.plugin(SessionPersistenceJsonl, { root })
+    configured.llm.registerAdapter(['mock'], new MockAdapter([]))
+    configured.sessionPersistence.load = id => ctx.sessionPersistence.load(id)
+    configured.on('agent-loop/config-start-failed', (_id, error) => { failures.push(error) })
+    const loop = await configured.plugin(AgentLoop, {
+      agents: [{ id: 'main', resumeSessionId: sessionId, provider: 'mock', model: 'mock' }],
+    })
+    await loadStarted.promise
+    const disposal = loop.dispose()
+    gate.reject(new Error('late backend failure'))
+    await disposal
+    await new Promise(r => setTimeout(r, 20))
+
+    // Ownership deactivated before the failure landed: the report is dropped.
+    expect(failures).toEqual([])
+    await configured.fiber.dispose()
+    await ctx.fiber.dispose()
+  })
+})

packages/core/agent-loop/tests/scope-lifecycle.spec.ts

@@ -203,11 +203,11 @@ describe('agent scope lifecycle', () => {
       if (event.type === 'user/message') heard.push('a-sees:user-message')
     })
 
-    b.followup(text('for b'))
+    b.followup({ content: text('for b'), source: { kind: 'user' } })
     await waitForIdle(ctx, b)
     expect(heard).toEqual([]) // nothing of b's leaked into a's scope
 
-    a.followup(text('for a'))
+    a.followup({ content: text('for a'), source: { kind: 'user' } })
     await waitForIdle(ctx, a)
     expect(heard).toContain('a-sees:a:running')
     expect(heard).toContain('a-sees:user-message')
@@ -456,7 +456,7 @@ describe('agent scope lifecycle', () => {
     })
     await expect(creating).rejects.toThrow(/agent loop is not active/)
     await loopFiber.dispose()
-    expect(setupCalls).toBe(0)
+    expect(setupCalls).toBe(1)
     expect(ctx.agents.get(SessionId('factory-scope-race-s'))).toBeUndefined()
     expect(ctx.sessions.get(SessionId('factory-scope-race-s'))).toBeUndefined()
 
@@ -509,17 +509,17 @@ describe('agent scope lifecycle', () => {
     const { ctx, loopFiber } = await harnessWithLoop()
     const sessionsBefore = ctx.sessions.list().length
     let unloaded = false
+    let unloading!: Promise<void>
     ctx.on('internal/plugin', (fiber) => {
       if (unloaded || fiber.name !== 'scope') return
       unloaded = true
-      void loopFiber.dispose()
+      unloading = loopFiber.dispose()
     })
 
-    expect(() => ctx.agentLoop.create(SessionId('config-scope-race'), { provider: 'mock', model: 'mock' }))
-      .toThrow(/agent loop is not active/)
-    await loopFiber.dispose()
-    expect(ctx.agents.get(SessionId('config-scope-race'))).toBeUndefined()
-    expect(ctx.sessions.list()).toHaveLength(sessionsBefore)
+    ctx.agentLoop.create(SessionId('config-scope-race'), { provider: 'mock', model: 'mock' })
+    await unloading
+    expect(ctx.agents.get(SessionId('config-scope-race')) === undefined).toBe(true)
+    expect(ctx.sessions.list().length).toBe(sessionsBefore)
     await ctx.fiber.dispose()
   })
 
@@ -566,16 +566,16 @@ describe('agent scope lifecycle', () => {
     })
 
     await loopFiber.dispose()
-    expect(handle.agent.status).toBe('disposed')
+    expect(handle.agent.status).toBe('idle')
     expect(ctx.agents.get(sessionId)).toBeUndefined()
     expect(ctx.sessions.get(sessionId)).toBeUndefined()
-    expect(ctx.fiber.getEffects().filter(effect => effect.label === `agentLoop.owner(${sessionId})`)).toEqual([])
+    expect(ctx.fiber.getEffects().filter(effect => effect.label === `agentLoop.lifecycle(${sessionId})`)).toEqual([])
     // The consumer handle shares the provider's completed quiescence boundary.
     await handle.dispose()
 
     await expect(loop.createAgent(ctx, {
       sessionId: SessionId('factory-inactive-s'),
-    })).rejects.toThrow('agent loop is not active')
+    })).rejects.toThrow(/agent loop is not active|inactive context/)
     await ctx.fiber.dispose()
   })
 
@@ -643,13 +643,13 @@ describe('agent scope lifecycle', () => {
       })
     }, { inject: ['agents'] }))
 
-    await expect(creating).rejects.toThrow(/lifecycle disposed/)
+    await expect(creating).rejects.toThrow(/owner disposed during setup/)
     await owner.dispose()
     expect(lifecycle).toEqual([
       'session-created:dispose',
       'session-created:observer',
-      'session-disposed',
       'scope-disposed',
+      'session-disposed',
     ])
     expect(ctx.agents.get(SessionId('session-created-barrier-s'))).toBeUndefined()
     expect(ctx.sessions.get(SessionId('session-created-barrier-s'))).toBeUndefined()
@@ -691,15 +691,15 @@ describe('agent scope lifecycle', () => {
       })
     }, { inject: ['agents'] }))
 
-    await expect(creating).rejects.toThrow(/lifecycle disposed/)
+    await expect(creating).rejects.toThrow(/owner disposed during setup/)
     await owner.dispose()
     expect(lifecycle).toEqual([
       'session-created',
       'agent-created:dispose',
       'agent-created:observer',
+      'scope-disposed',
       'agent-disposed',
       'session-disposed',
-      'scope-disposed',
     ])
     expect(ctx.agents.get(SessionId('agent-created-barrier-s'))).toBeUndefined()
     expect(ctx.sessions.get(SessionId('agent-created-barrier-s'))).toBeUndefined()
@@ -713,7 +713,7 @@ describe('agent scope lifecycle', () => {
     let creating!: ReturnType<typeof ctx.agents.create>
     ctx.on('agent/session-start', agent => void starts.push(agent.id))
     ctx.on('agent/created', (agent) => {
-      if (agent.id === SessionId('listener-dispose-s')) void ownerCtx.fiber.dispose()
+      if (agent.id === SessionId('listener-dispose-s')) disposeCurrentLifecycle(ownerCtx)
     })
 
     const owner = await ctx.plugin(Object.assign((inner: Context) => {
@@ -727,8 +727,8 @@ describe('agent scope lifecycle', () => {
     await expect(creating).rejects.toThrow(/owner disposed during setup/)
     await owner.dispose()
     expect(starts).toEqual([])
-    expect(ctx.agents.get(SessionId('listener-dispose-s'))).toBeUndefined()
-    expect(ctx.sessions.get(SessionId('listener-dispose-s'))).toBeUndefined()
+    expect(ctx.agents.get(SessionId('listener-dispose-s')) === undefined).toBe(true)
+    expect(ctx.sessions.get(SessionId('listener-dispose-s')) === undefined).toBe(true)
     await ctx.fiber.dispose()
   })
 
@@ -764,10 +764,10 @@ describe('agent scope lifecycle', () => {
       })
     }, { inject: ['agents'] }))
 
-    await expect(creating).rejects.toThrow(/lifecycle disposed/)
+    await expect(creating).rejects.toThrow(/owner disposed during setup/)
     await owner.dispose()
-    expect(announced.status).toBe('disposed')
-    expect(statuses).toEqual(['disposed'])
+    expect(announced.status).toBe('idle')
+    expect(statuses).toEqual([])
     expect(observerSawLive).toBe(true)
     expect(scopeDisposed).toBe(true)
     expect(announced.session.events).toEqual([])
@@ -886,8 +886,8 @@ describe('agent scope lifecycle', () => {
 
     expect(() => ctx.agentLoop.create(SessionId('config-bad'), { provider: 'mock', model: 'mock' }))
       .toThrow('config publish failed')
-    expect(ctx.agents.get(SessionId('config-bad'))).toBeUndefined()
-    expect(ctx.sessions.list()).toHaveLength(sessionsBefore)
+    await expect.poll(() => ctx.agents.get(SessionId('config-bad')) === undefined).toBe(true)
+    await expect.poll(() => ctx.sessions.list().length).toBe(sessionsBefore)
   })
 
   it('registrations through a disposed agent ctx throw INACTIVE_EFFECT', async () => {
@@ -934,10 +934,14 @@ describe('agent scope lifecycle', () => {
         if (event.type === 'turn/start') { off(); resolve() }
       })
     })
-    agent.followup(text('work'))
+    agent.followup({ content: text('work'), source: { kind: 'user' } })
     await turnOpen
     await owner.dispose()
-    expect(order).toEqual(['turn-end', 'disposed(listed=false)', 'session-still-stored=true'])
+    expect(order).toEqual([
+      'turn-end',
+      'disposed(listed=false)',
+      'session-still-stored=true',
+    ])
     expect(ctx.sessions.get(SessionId('o1-s'))).toBeUndefined()
   })
 
@@ -970,9 +974,9 @@ describe('agent scope lifecycle', () => {
       agentOptions: { provider: 'mock', model: 'mock' },
     })
 
-    expect(ctx.fiber.getEffects().map(effect => effect.label)).toContain(`agentLoop.owner(${sessionId})`)
+    expect(ctx.fiber.getEffects().map(effect => effect.label)).toContain(`agentLoop.lifecycle(${sessionId})`)
     await handle.dispose()
-    expect(ctx.fiber.getEffects().filter(effect => effect.label === `agentLoop.owner(${sessionId})`)).toEqual([])
+    expect(ctx.fiber.getEffects().filter(effect => effect.label === `agentLoop.lifecycle(${sessionId})`)).toEqual([])
     await ctx.fiber.dispose()
   })
 
@@ -1007,15 +1011,11 @@ describe('agent scope lifecycle', () => {
     await ctx.fiber.dispose()
   })
 
-  it('reopens ids after detach while the prior private scope finishes quiescing', async () => {
+  it('reopens ids after the prior private scope finishes quiescing', async () => {
     const ctx = await harness()
     const gate = Promise.withResolvers<undefined>()
     const cleanupStarted = Promise.withResolvers<undefined>()
-    const sessionDisposed = Promise.withResolvers<undefined>()
     const sessionId = SessionId('quiescent-reuse')
-    ctx.on('session/disposed', (session) => {
-      if (session.id === sessionId) sessionDisposed.resolve(undefined)
-    })
     const first = await ctx.agents.create({
       sessionId,
       agentOptions: { provider: 'mock', model: 'mock' },
@@ -1028,46 +1028,57 @@ describe('agent scope lifecycle', () => {
     })
 
     const disposing = first.dispose()
-    await Promise.all([sessionDisposed.promise, cleanupStarted.promise])
+    await cleanupStarted.promise
+    expect(ctx.agents.get(sessionId)).toBe(first.agent)
+    expect(ctx.sessions.get(sessionId)).toBe(first.agent.session)
+    gate.resolve(undefined)
+    await disposing
     expect(ctx.agents.get(sessionId)).toBeUndefined()
     expect(ctx.sessions.get(sessionId)).toBeUndefined()
     const replacement = await ctx.agents.create({ sessionId, agentOptions: { provider: 'mock', model: 'mock' } })
     expect(ctx.agents.get(sessionId)).toBe(replacement.agent)
     expect(ctx.sessions.get(sessionId)).toBe(replacement.agent.session)
-
-    gate.resolve(undefined)
-    await disposing
     await replacement.dispose()
     await ctx.fiber.dispose()
   })
 
-  it('handle.dispose() awaits an idle-injection flush before unregistering or detaching', async () => {
-    const ctx = await harness()
+  it('drains a run re-entered by cancel\'s own idle transition before removing the scope', async () => {
+    // Automation shaped like goal-session: the running→idle transition that
+    // disposal's cancel produces immediately queues a follow-up prompt. The
+    // teardown must drain that replacement run to true quiescence instead of
+    // awaiting only the first captured done and unwinding under a live run.
+    const adapter = new MockAdapter([textResponse('one'), textResponse('never awaited')])
+    const ctx = await harness(adapter)
     const handle = await ctx.agents.create({
-      sessionId: SessionId('idle-flush-s'),
+      sessionId: SessionId('drain-reentered-run'),
       agentOptions: { provider: 'mock', model: 'mock' },
     })
-    const gate = Promise.withResolvers<undefined>()
-    let flushStarted = false
-    ctx.on('session/flush', (session) => {
-      if (session !== handle.agent.session) return
-      flushStarted = true
-      return gate.promise
+    const agent = handle.agent
+    let reentered = false
+    ctx.on('agent/status', (subject, status) => {
+      if (subject !== agent || status !== 'idle' || reentered) return
+      reentered = true
+      agent.followup({ content: [{ type: 'text', text: 'reentrant' }], source: { kind: 'user' } })
     })
 
-    handle.agent.inject(text('durable idle context'), { source: { kind: 'plugin', plugin: 'test' } })
-    expect(flushStarted).toBe(true)
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
+    await waitForIdle(ctx, agent)
+    expect(reentered).toBe(true)
 
-    let disposed = false
-    const disposal = handle.dispose().then(() => { disposed = true })
-    await new Promise(resolve => setTimeout(resolve, 0))
-    expect(disposed).toBe(false)
-    expect(ctx.agents.get(SessionId('idle-flush-s'))).toBe(handle.agent)
-    expect(ctx.sessions.get(SessionId('idle-flush-s'))).toBe(handle.agent.session)
+    // Idle again: the reentrant admission was already claimed and settled (its
+    // prompt was blocked by nothing, so it ran) — arm a SECOND reentry that
+    // fires from the disposal cancel's idle transition itself.
+    reentered = false
+    await handle.dispose()
 
-    gate.resolve(undefined)
-    await disposal
-    expect(ctx.agents.get(SessionId('idle-flush-s'))).toBeUndefined()
-    expect(ctx.sessions.get(SessionId('idle-flush-s'))).toBeUndefined()
+    // The reentrant run either never started or was drained: the registries
+    // are empty and nothing still drives the detached session.
+    expect(ctx.agents.get(agent.id)).toBeUndefined()
+    expect(ctx.sessions.get(agent.id)).toBeUndefined()
+    const eventsAfter = agent.session.events.length
+    await new Promise(resolve => setTimeout(resolve, 30))
+    expect(agent.session.events.length).toBe(eventsAfter)
+    await ctx.fiber.dispose()
   })
+
 })

packages/core/agent-loop/tests/tool-calls.spec.ts

@@ -11,7 +11,7 @@ import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
 import LlmService from '@deepseek-ai/dsh-llm'
 import ToolRegistry, { defineContentToolFixture, TOOL_ABORTED_BEFORE_DISPATCH, type PostToolDecision, type PreToolDecision } from '@deepseek-ai/dsh-tools'
 import AgentRegistry, { type Agent } from '@deepseek-ai/dsh-agent'
-import AgentLoop from '@deepseek-ai/dsh-agent-loop'
+import AgentLoop, { DEFAULT_MAX_PARALLEL_TOOL_CALLS } from '@deepseek-ai/dsh-agent-loop'
 import { MockAdapter, textResponse } from './mock-adapter.ts'
 
 async function harness(adapter: MockAdapter, maxParallelToolCalls?: number) {
@@ -105,7 +105,7 @@ describe('tool-call scheduler: grouping and barriers', () => {
     ctx.tools.register(gated.tool)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await until(() => gated.started.length === 3)
     expect(gated.started).toEqual(['1', '2', '3'])
     gated.release('1'); gated.release('2'); gated.release('3')
@@ -133,7 +133,7 @@ describe('tool-call scheduler: grouping and barriers', () => {
       async execute(args) { order.push(`w-${args.id}`); return [{ type: 'text', text: 'w' }] },
     }))
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await waitForIdle(ctx, agent)
 
     expect(order).toEqual(['r-start-A1', 'r-end-A1', 'w-A2', 'r-start-A3', 'r-end-A3'])
@@ -169,7 +169,7 @@ describe('tool-call scheduler: grouping and barriers', () => {
     }))
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await until(() => replacement.started.length === 1)
     await new Promise(r => setTimeout(r, 5))
     expect(replacement.started).toEqual(['1'])
@@ -200,7 +200,7 @@ describe('tool-call scheduler: grouping and barriers', () => {
     })
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await until(() => initial.started.length === 2)
     initial.release('1')
     await until(() => events(agent).some(event =>
@@ -226,7 +226,7 @@ describe('tool-call scheduler: model-order results despite out-of-order settleme
     ctx.tools.register(gated.tool)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await until(() => gated.started.length === 2)
     gated.release('2')
     await new Promise(r => setTimeout(r, 5))
@@ -248,7 +248,7 @@ describe('tool-call scheduler: model-order results despite out-of-order settleme
     const gated = gatedParallelTool('p')
     ctx.tools.register(gated.tool)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await until(() => gated.started.length === 2)
     gated.release('2'); gated.release('1')
     await waitForIdle(ctx, agent)
@@ -280,7 +280,8 @@ describe('tool-call scheduler: rolling pool honors maxParallelToolCalls', () =>
     await ctx.plugin(ToolRegistry)
     await ctx.plugin(AgentRegistry)
 
-    expect(() => new AgentLoop(ctx, { agents: [] })).not.toThrow()
+    const loop = new AgentLoop(ctx, { agents: [] })
+    expect(loop.config.maxParallelToolCalls).toBe(DEFAULT_MAX_PARALLEL_TOOL_CALLS)
     await ctx.fiber.dispose()
   })
 
@@ -294,7 +295,7 @@ describe('tool-call scheduler: rolling pool honors maxParallelToolCalls', () =>
     ctx.tools.register(gated.tool)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await until(() => gated.started.length === 2)
     await new Promise(r => setTimeout(r, 5))
     expect(gated.started).toEqual(['1', '2'])
@@ -323,7 +324,7 @@ describe('tool-call scheduler: rolling pool honors maxParallelToolCalls', () =>
     const gated = gatedParallelTool('p')
     ctx.tools.register(gated.tool)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await until(() => gated.started.length === 1)
     await new Promise(r => setTimeout(r, 5))
     expect(gated.started).toEqual(['1'])
@@ -349,7 +350,7 @@ describe('tool-call scheduler: rolling pool honors maxParallelToolCalls', () =>
     const gated = gatedParallelTool('p')
     ctx.tools.register(gated.tool)
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await until(() => gated.started.length === 1)
     await new Promise(r => setTimeout(r, 5))
     expect(gated.started).toEqual(['1'])
@@ -376,7 +377,7 @@ describe('tool-call scheduler: ordered middleware and additional contexts', () =
     ctx.on('tools/post-execute', async (exec, _result, next): Promise<PostToolDecision> => { post.push(String(exec.callId)); return next() })
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await until(() => gated.started.length === 3)
     gated.release('3'); gated.release('2'); gated.release('1')
     await waitForIdle(ctx, agent)
@@ -397,7 +398,7 @@ describe('tool-call scheduler: ordered middleware and additional contexts', () =
       ({ kind: 'accept', additionalContexts: [{ content: [{ type: 'text', text: `ctx-${exec.callId}` }], source: { kind: 'plugin', plugin: 'p' } }] }))
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await until(() => gated.started.length === 2)
     gated.release('2'); gated.release('1')
     await waitForIdle(ctx, agent)
@@ -435,7 +436,7 @@ describe('tool-call scheduler: ordered middleware and additional contexts', () =
     })
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await until(() => gated.started.length === 1)
     gated.release('1')
     await waitForIdle(ctx, agent)
@@ -465,7 +466,7 @@ describe('tool-call scheduler: abort handling', () => {
       }
     })
 
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await waitForIdle(ctx, agent)
 
     expect(gated.started).toEqual([])
@@ -497,7 +498,7 @@ describe('tool-call scheduler: abort handling', () => {
       return next()
     })
 
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await waitForIdle(ctx, agent)
 
     expect(gated.started).toEqual([])
@@ -527,7 +528,7 @@ describe('tool-call scheduler: abort handling', () => {
     }))
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await until(() => gated.started.length === 2)
     agent.cancel({ kind: 'user' })
     gated.release('1')
@@ -539,14 +540,10 @@ describe('tool-call scheduler: abort handling', () => {
       .toEqual([CallId('c1'), CallId('c2'), CallId('c3'), CallId('c4')])
     expect(events(agent).filter(e => e.type === 'tool/result').map(e => e.data.callId))
       .toEqual([CallId('c1'), CallId('c2'), CallId('c3'), CallId('c4')])
-    expect(events(agent).filter(e => e.type === 'tool/result').slice(-2).map(e => ({
-      callId: e.data.callId,
-      isError: e.data.isError,
-      errorInfo: e.data.error,
-    })))
+    expect(events(agent).filter(e => e.type === 'tool/result').slice(-2).map(e => e.data))
       .toEqual([
-        { callId: CallId('c3'), isError: true, errorInfo: { name: 'AbortError', code: TOOL_ABORTED_BEFORE_DISPATCH } },
-        { callId: CallId('c4'), isError: true, errorInfo: { name: 'AbortError', code: TOOL_ABORTED_BEFORE_DISPATCH } },
+        expect.objectContaining({ callId: CallId('c3'), isError: true, error: { name: 'AbortError', code: TOOL_ABORTED_BEFORE_DISPATCH } }),
+        expect.objectContaining({ callId: CallId('c4'), isError: true, error: { name: 'AbortError', code: TOOL_ABORTED_BEFORE_DISPATCH } }),
       ])
     const settled = events(agent).filter(e => e.type === 'tool/result'
       || (e.type === 'user/message' && e.data.source.kind === 'plugin'))
@@ -578,7 +575,7 @@ describe('tool-call scheduler: abort handling', () => {
     }))
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
 
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await until(() => gated.started.length === 2)
     agent.cancel({ kind: 'user' })
     gated.release('1')

packages/core/agent-loop/tests/tool-order.spec.ts

@@ -58,7 +58,7 @@ async function runTurn(registrationOrder: string[], toolOrder?: SystemPromptConf
   const ctx = await harness(adapter, toolOrder)
   for (const name of registrationOrder) registerNamed(ctx, name)
   const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-  agent.followup([{ type: 'text', text: 'go' }])
+  agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
   await waitForIdle(ctx, agent)
   return { ctx, agent, adapter }
 }
@@ -98,9 +98,11 @@ describe('loop-level canonical tool order', () => {
     const ctx = await harness(adapter, ['ghost', TOOL_ORDER_REST])
     registerNamed(ctx, 'alpha')
     const errors: Error[] = []
-    ctx.on('agent/error', (_agent, _turn, _step, error) => void errors.push(error))
+    ctx.on('agent/error', (_agent, _turn, _step, error) => {
+      if (error instanceof Error) errors.push(error)
+    })
     const agent = ctx.agentLoop.create(SessionId('a1'), { provider: 'mock', model: 'mock' })
-    agent.followup([{ type: 'text', text: 'go' }])
+    agent.followup({ content: [{ type: 'text', text: 'go' }], source: { kind: 'user' } })
     await waitForIdle(ctx, agent)
     expect(adapter.requests).toHaveLength(0)
     expect(errors.map(e => e.message)).toEqual(['toolOrder lists unregistered tool "ghost"; known tools: alpha'])

packages/core/agent-loop/tests/turn-stop.spec.ts

@@ -1,196 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { Context } from 'cordis'
-import LlmService from '@deepseek-ai/dsh-llm'
-import SessionStore, { SessionId, type TurnEndReason } from '@deepseek-ai/dsh-session'
-import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
-import ToolRegistry, { defineContentToolFixture } from '@deepseek-ai/dsh-tools'
-import AgentRegistry, { type Agent, type ContinuationStop } from '@deepseek-ai/dsh-agent'
-
-import AgentLoop from '@deepseek-ai/dsh-agent-loop'
-import InvariantService from '@deepseek-ai/dsh-invariants'
-import * as SessionInvariant from '@deepseek-ai/dsh-session/invariant'
-import * as AgentInvariant from '@deepseek-ai/dsh-agent/invariant'
-import * as AgentLoopInvariant from '@deepseek-ai/dsh-agent-loop/invariant'
-import { MockAdapter, textResponse, toolCallResponse } from './mock-adapter.ts'
-
-async function mountInvariants(ctx: Context): Promise<void> {
-  await ctx.plugin(InvariantService)
-  await ctx.plugin(SessionInvariant)
-  await ctx.plugin(AgentInvariant)
-  await ctx.plugin(AgentLoopInvariant)
-}
-
-async function harness(adapter: MockAdapter): Promise<Context> {
-  const ctx = new Context()
-  await ctx.plugin(LlmService)
-  await ctx.plugin(SessionStore)
-  await ctx.plugin(SystemPrompt)
-  await ctx.plugin(ToolRegistry)
-  await ctx.plugin(AgentRegistry)
-  await mountInvariants(ctx)
-  await ctx.plugin(AgentLoop, { agents: [] })
-  ctx.llm.registerAdapter(['mock'], adapter)
-  return ctx
-}
-
-function send(agent: Agent, text = 'go'): Promise<void> {
-  agent.followup([{ type: 'text', text }])
-  return agent.whenIdle()
-}
-
-function registerEcho(ctx: Context): void {
-  ctx.tools.register(defineContentToolFixture({
-    name: 'echo',
-    description: 'echo',
-    parameters: { text: { type: 'string' } },
-    async execute(args) {
-      return [{ type: 'text', text: String(args.text) }]
-    },
-  }))
-}
-
-describe('agent/turn-stop', () => {
-  it('runs after steering folding and discards terminal steering instead of creating another step or turn', async () => {
-    const adapter = new MockAdapter([
-      textResponse('the ordinary decision is stop'),
-      textResponse('must not be requested'),
-    ])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('terminal-steering'), { provider: 'mock', model: 'mock' })
-    agent.ctx.on('agent/turn-stop', (): ContinuationStop => ({ action: 'stop' }))
-
-    let steered = false
-    ctx.on('agent/turn-continuation', async (subject, _turn, _default, _signal, next) => {
-      const downstream = await next()
-      if (subject === agent && !steered) {
-        steered = true
-        subject.steer([{ type: 'text', text: 'late continuation steering' }])
-      }
-      return downstream
-    }, { prepend: true })
-
-    await send(agent)
-
-    expect(adapter.requests).toHaveLength(1)
-    expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(1)
-    expect(agent.session.events.filter(event => event.type === 'step/start')).toHaveLength(1)
-    expect(agent.session.events.filter(event => event.type === 'steering/message')).toHaveLength(0)
-  })
-
-  it('discards steering that arrives from session/flush after the terminal checkpoint', async () => {
-    const adapter = new MockAdapter([
-      textResponse('terminal answer'),
-      textResponse('must not become a late-steering turn'),
-    ])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('terminal-flush-steering'), { provider: 'mock', model: 'mock' })
-    agent.ctx.on('agent/turn-stop', (): ContinuationStop => ({ action: 'stop' }))
-
-    let injected = false
-    ctx.on('session/flush', (session) => {
-      if (session !== agent.session || injected) return
-      injected = true
-      agent.steer([{ type: 'text', text: 'steering from flush' }])
-    })
-
-    await send(agent)
-
-    expect(injected).toBe(true)
-    expect(agent.status).toBe('idle')
-    expect(adapter.requests).toHaveLength(1)
-    expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(1)
-    expect(agent.session.events.filter(event => event.type === 'step/start')).toHaveLength(1)
-    expect(agent.session.events.filter(event => event.type === 'steering/message')).toHaveLength(0)
-  })
-
-  it('preserves an ordinary queued send that arrives during terminal flush', async () => {
-    const adapter = new MockAdapter([
-      textResponse('first terminal answer'),
-      textResponse('queued follow-up answer'),
-    ])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('terminal-flush-send'), { provider: 'mock', model: 'mock' })
-    agent.ctx.on('agent/turn-stop', (): ContinuationStop => ({ action: 'stop' }))
-
-    let queued = false
-    ctx.on('session/flush', (session) => {
-      if (session !== agent.session || queued) return
-      queued = true
-      agent.followup([{ type: 'text', text: 'ordinary queued follow-up' }])
-    })
-
-    await send(agent)
-
-    expect(agent.status).toBe('idle')
-    expect(adapter.requests).toHaveLength(2)
-    expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(2)
-    expect(agent.session.events.filter(event => event.type === 'step/start')).toHaveLength(2)
-  })
-
-  it('filters a scoped terminal listener to its own agent', async () => {
-    const adapter = new MockAdapter([
-      toolCallResponse('a1', 'echo', { text: 'a' }),
-      toolCallResponse('b1', 'echo', { text: 'b' }),
-      textResponse('b continues normally'),
-    ])
-    const ctx = await harness(adapter)
-    registerEcho(ctx)
-    const stopped = ctx.agentLoop.create(SessionId('stopped'), { provider: 'mock', model: 'mock' })
-    const ordinary = ctx.agentLoop.create(SessionId('ordinary'), { provider: 'mock', model: 'mock' })
-    stopped.ctx.on('agent/turn-stop', (): ContinuationStop => ({ action: 'stop' }))
-
-    await send(stopped)
-    expect(adapter.requests).toHaveLength(1)
-    await send(ordinary)
-
-    expect(adapter.requests).toHaveLength(3)
-    expect(stopped.session.events.filter(event => event.type === 'step/start')).toHaveLength(1)
-    expect(ordinary.session.events.filter(event => event.type === 'step/start')).toHaveLength(2)
-  })
-
-  it('unregisters with its scoped owner disposer', async () => {
-    const adapter = new MockAdapter([
-      toolCallResponse('first', 'echo', { text: 'first' }),
-      toolCallResponse('second', 'echo', { text: 'second' }),
-      textResponse('continued after listener disposal'),
-    ])
-    const ctx = await harness(adapter)
-    registerEcho(ctx)
-    const agent = ctx.agentLoop.create(SessionId('owned-listener'), { provider: 'mock', model: 'mock' })
-    const disposeStop = agent.ctx.on('agent/turn-stop', (): ContinuationStop => ({ action: 'stop' }))
-
-    await send(agent, 'first turn')
-    expect(adapter.requests).toHaveLength(1)
-
-    disposeStop()
-    await send(agent, 'second turn')
-    expect(adapter.requests).toHaveLength(3)
-  })
-
-  it('fails a throwing terminal policy closed while the driver survives', async () => {
-    const adapter = new MockAdapter([
-      textResponse('throwing policy'),
-      textResponse('healthy later turn'),
-    ])
-    const ctx = await harness(adapter)
-    const agent = ctx.agentLoop.create(SessionId('bad-policy'), { provider: 'mock', model: 'mock' })
-    const reasons: TurnEndReason[] = []
-    const errors: string[] = []
-    ctx.on('session/event', (session, event) => {
-      if (session === agent.session && event.type === 'turn/end') reasons.push(event.data.reason)
-    })
-    agent.ctx.on('agent/error', (_subject, _turn, _step, error) => { errors.push(error.message) })
-
-    const disposeThrowing = agent.ctx.on('agent/turn-stop', () => {
-      throw new Error('terminal policy exploded')
-    })
-    await send(agent, 'first')
-    disposeThrowing()
-
-    await send(agent, 'healthy')
-
-    expect(reasons.map(reason => reason.kind)).toEqual(['error', 'completed'])
-    expect(errors).toContain('terminal policy exploded')
-    expect(adapter.requests).toHaveLength(2)
-  })
-})