eve 0.62.0 → 0.63.0

package/docs/concepts/execution-model-and-durability.mdx

@@ -118,12 +118,11 @@ Some work has to wait, including a human approving a [tool](../tools) or an inte
 Background execution is a separate choice about result delivery. A background workflow tool
 returns a task receipt so the parent turn can continue; the tool's workflow may then run or
 suspend independently. A default workflow tool can suspend too, with its original tool call
-still pending. Ordinary background tools run their executor inside the initiating step and do
-not gain durable waits by setting `execution: "background"`.
+still pending. Declare background work with `defineWorkflowTool`; `defineTool` always executes
+inside its initiating step.
 
-A generator's `yield` reports progress; an awaited workflow operation provides the durable wait.
-For background tools, ordinary yields are stream-only, while `yield task.postMessage(...)`
-requests a parent-agent turn. See [background execution](../tools#background-execution) and
+An awaited workflow operation provides the durable wait. A generator's `yield` reports progress
+in default execution; background workflow tools consume yields without publishing progress. See [background execution](../tools#background-execution) and
 [workflow suspension](../tools/workflows#how-suspension-works) for the execution and result rules.
 
 ## Message delivery and steering

package/docs/concepts/sessions-runs-and-streaming.md

@@ -80,7 +80,7 @@ The stream is newline-delimited JSON (NDJSON), one event per line:
 | `input.requested`         | The run paused for human input ([HITL](/docs/human-in-the-loop) approval or `ask_question`); carries `requests`.                                   |
 | `input.resolved`          | The server accepted terminal human-input outcomes; carries `resolutions` with responses when provided.                                             |
 | `subagent.called`         | A subagent was delegated; carries `childSessionId` to attach to.                                                                                   |
-| `subagent.completed`      | A background subagent was admitted and returned its task receipt.                                                                                  |
+| `subagent.completed`      | The parent recorded a successful subagent invocation result; carries the actual output.                                                            |
 | `reasoning.appended`      | A reasoning text delta.                                                                                                                            |
 | `reasoning.completed`     | The finalized reasoning block.                                                                                                                     |
 | `message.appended`        | An assistant text delta.                                                                                                                           |
@@ -119,7 +119,7 @@ Note: consider the privacy, confidentiality, and user-experience implications fo
 
 When a task explicitly requires conditional delivery and there is nothing new to report, the agent can finish with exactly `<eve-empty-delivery/>`. eve emits `message.completed` with `message: null` for that intentional silence. The marker must be the entire response, apart from surrounding whitespace; the HTML-escaped form `&lt;eve-empty-delivery/&gt;` is also accepted. A response that quotes the marker in prose or code is delivered normally.
 
-A delegated subagent publishes progress on its own child-session stream. The parent emits `subagent.called` with a `childSessionId`, which a client uses to attach. `subagent.completed` carries a working task receipt after admission; terminal outcomes arrive as task-triggered `message.received` notifications with `data.kind: "execution.background_task"`. The default frontend reducer retains these events in `events` but does not project their runtime-authored text as participant messages.
+A delegated subagent publishes progress on its own child-session stream. The parent emits `subagent.called` with a `childSessionId`, which a client uses to attach. Both blocking and background calls emit `subagent.completed` with the actual output after the parent records a successful outcome. A background working receipt is an `action.result` tool output; it does not emit completion. Older streams can contain receipt-bearing completion events marked by `data.backgroundTask`; those are admission only. Completion does not mean that the reusable child session has ended. Background task terminal outcomes also arrive as task-triggered `message.received` notifications with `data.kind: "execution.background_task"`. The default frontend reducer retains these events in `events` but does not project their runtime-authored text as participant messages.
 
 `step.failed` and `turn.failed` carry `{ code, message, details? }` for the failed fragment or turn, and `session.failed` is the terminal session-level variant. `turn.cancelled` is not a failure: the cancelled turn ends without any failure event, `session.waiting` follows, and the session accepts the next message normally. Whatever the turn streamed before cancellation stays on the stream. Durable history keeps the accepted user input and previously settled work, but discards incomplete assistant output and unfinished tool state. When a turn requested an output schema, the finalized payload lands on `result.completed` as `data.result` before the turn boundary. `authorization.required` carries the sign-in challenge (`data.authorization` may include `url`, `userCode`, `expiresAt`, `instructions`), and `authorization.completed` carries `data.outcome` (`"authorized" | "declined" | "failed" | "timed-out"`).
 

package/docs/evals/assertions.mdx

@@ -83,7 +83,11 @@ Pick the cheapest builder that captures what "correct" means. When exact match i
 
 ## The matcher mini-language
 
-`t.calledTool` and `t.calledSubagent` take matcher objects. Tools accept `{ input, output, status, count }`; subagents accept `{ callId, childSessionId, remoteUrl, output, status, count }`. Calls match `status: "completed"` by default; use `"pending"`, `"failed"`, or `"rejected"` explicitly for lifecycle checks. A numeric `count` requires an exact number of calls matching every supplied constraint. Use a predicate for ranges or other custom count requirements; it receives the observed number of matching calls.
+`t.calledTool` and `t.calledSubagent` take matcher objects. Tools accept `{ input, output, status, count }`; subagents accept `{ callId, childSessionId, remoteUrl, output, status, count }`. Calls match `status: "completed"` by default. Tool lifecycle checks also accept `"pending"`, `"failed"`, and `"rejected"`. Subagent checks use the shared task status values: `"working"`, `"input_required"`, `"completed"`, `"failed"`, and `"cancelled"`. A numeric `count` requires an exact number of calls matching every supplied constraint. Use a predicate for ranges or other custom count requirements; it receives the observed number of matching calls.
+
+A background subagent that has only returned a working task receipt remains `working`; use `t.calledSubagent(name, { status: "working" })` to assert that delegation. Both blocking and background calls become `completed` when their actual successful result is observed through `subagent.completed`, even when the child session stays available for another call. A rejected dispatch is `failed`; an explicit cancelled child outcome is `cancelled`.
+
+The runner derives these values from captured events. It does not read stored task state, and the current stream does not expose every task transition. A proxied input request alone does not update the subagent call to `input_required`; assert that request with `requireInputRequest`. Check task notifications for background failure and cancellation when no child outcome event is present.
 
 Matcher values accept a literal (objects partial-deep-match), a RegExp, or a predicate function that returns a boolean:
 

package/docs/guides/dev-tui.md

@@ -17,19 +17,19 @@ The transcript remains in your terminal scrollback after you exit. Run `/help` i
 
 | Command     | Description                                                                                                                                                  |
 | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `/model`    | Choose the model, speed, and reasoning. Pass a model ID to set it directly: `/model provider/model-id`.                                                      |
+| `/reset`    | Start a fresh session.                                                                                                                                       |
+| `/clear`    | Clear the session's model-message history. `/new` is an alias.                                                                                               |
+| `/compact`  | Compact the current session's context.                                                                                                                       |
+| `/cancel`   | Cancel the current turn without discarding settled context.                                                                                                  |
 | `/login`    | Connect a ChatGPT subscription, Vercel account, or provider API key.                                                                                         |
-| `/model`    | Choose the model and its settings. Pass a model ID to set it directly: `/model provider/model-id`.                                                           |
 | `/add`      | Select and install channels, MCP connections, extensions, and observability integrations. Pass an item address to install it directly: `/add channel/slack`. |
 | `/deploy`   | Deploy the agent to Vercel production. Installs the Vercel CLI, signs in, and links the directory if needed.                                                 |
-| `/info`     | Show the resolved application, compiled artifacts, discovery diagnostics, and messaging routes.                                                              |
-| `/loglevel` | Choose which server and agent logs appear in the transcript.                                                                                                 |
 | `/traces`   | Open the local trace viewer. Pass a trace ID prefix to open a specific trace.                                                                                |
-| `/reset`    | Start a fresh session.                                                                                                                                       |
-| `/cancel`   | Cancel the current turn without discarding settled context.                                                                                                  |
-| `/clear`    | Clear the session's model-message history. `/new` is an alias.                                                                                               |
-| `/compact`  | Compact the current session's context.                                                                                                                       |
-| `/exit`     | Quit the UI.                                                                                                                                                 |
+| `/loglevel` | Choose which server and agent logs appear in the transcript.                                                                                                 |
+| `/info`     | Show the resolved application, compiled artifacts, discovery diagnostics, and messaging routes.                                                              |
 | `/help`     | List available commands.                                                                                                                                     |
+| `/exit`     | Quit the UI.                                                                                                                                                 |
 
 `/login`, `/model`, `/add`, `/deploy`, `/info`, and `/traces` are available when `eve dev` runs locally. They are unavailable when the UI connects to a server with `--url`.
 
@@ -59,7 +59,17 @@ Local discovery runs only in development. Deployments need explicitly provisione
 
 ### Models and settings
 
-`/model` opens the model picker and settings. Each completed selection applies immediately and returns to chat; there is no final Done step. A successful login or model change takes effect on the next prompt.
+`/model` walks through model, speed, and reasoning in order:
+
+1. Choose a model. Type to filter the list.
+2. Choose **Standard** or **Fast** speed, when supported.
+3. Choose a reasoning level, when the model supports reasoning settings. **Provider default** leaves the reasoning level to the provider.
+
+The picker highlights your current settings when they are compatible with the selected model and skips settings that cannot be changed. Use `↑` and `↓` to move, then `Enter` to advance or apply the final choice. `Esc` or `←` returns to the previous step; at the model list, either key cancels. `Ctrl+C` cancels from any step.
+
+Changes apply together after the final choice, then the picker returns to chat. Cancelling leaves your model and settings unchanged.
+
+A successful login or model change takes effect on the next prompt.
 
 OpenAI, ChatGPT, and Gateway connections default to `gpt-5.6-luna-fast`; Anthropic defaults to `claude-sonnet-5`. An explicitly authored compatible model stays selected. If a new default is unavailable, eve offers the connection's available models. Dynamic or custom model expressions must be edited in `agent.ts`.
 
@@ -82,6 +92,8 @@ Required authorization or deployment setup still runs for the selected item. Pre
 
 Type a message and press `Enter` to send it. When the agent asks a question or requests tool approval, respond in the prompt shown by the UI. Connection authorization can open a browser; keep local `eve dev` running until the browser returns to it.
 
+The activity line shows **Thinking** while the model reasons or waits to respond, **Generating** while it writes a response or tool input, and **Running** while tools execute. A blinking dot and elapsed time indicate progress, with token counts shown when available. The activity line disappears when the turn finishes or needs your input.
+
 While a turn is running, `Enter` sends your message immediately as steering. Before assistant output begins, the runtime interrupts pending model generation and continues the same turn with your correction. Executing tools finish safely. After output begins, steering applies at the next workflow boundary and preserves streamed text.
 
 Slash commands wait until the turn ends, except `/cancel`, which cancels directly. If the session does not support steering, messages queue for the next turn. Press `Esc` or `Ctrl+C` to cancel a turn with no queued messages. With queued messages, these keys select the oldest message for steering, or for the next turn if steering is unavailable. If a direct cancellation requested with `/cancel` or `Ctrl+C` does not settle, press `Ctrl+C` to stop waiting. The UI then returns to the prompt and asks you to press `Ctrl+C` again to exit. At an idle prompt, press `Ctrl+C` twice to exit.

package/docs/guides/frontend/overview.mdx

@@ -172,7 +172,7 @@ supplied `session` remains externally owned and is never replaced by prewarming
 
 `data.messages` are eve-owned `EveMessage[]`. Common text, reasoning, file, and dynamic-tool parts follow the [AI SDK `UIMessage`](https://ai-sdk.dev/docs/reference/ai-sdk-core/ui-message) rendering convention, but the types are not interchangeable. eve also exposes authorization and HITL metadata, and a file part's URL can be absent. Adapt those parts before passing messages to an API typed as `UIMessage[]`.
 
-When the root agent delegates, its stream emits `subagent.called` with the child's `childSessionId`, then `subagent.completed` after admission with a working task receipt. Later task notifications wake the parent with completion, failure, or cancellation. Detailed child progress lives on the child session's stream instead of being flattened into the root `data.messages`. Use the lower-level [TypeScript client](../client/overview#sessions) to attach to that ID when your UI needs live subagent activity. See [What the parent sees](../../subagents#what-the-parent-sees) for the complete contract.
+When the root agent delegates, its stream emits `subagent.called` with the child's `childSessionId`, then `subagent.completed` when the parent records a successful result, for both blocking and background invocations. A background working receipt appears in `action.result`, without a completion event. The child session can remain available for reuse. Task notifications wake the parent with completion, failure, or cancellation. Detailed child progress lives on the child session's stream instead of being flattened into the root `data.messages`. Use the lower-level [TypeScript client](../client/overview#sessions) to attach to that ID when your UI needs live subagent activity. See [What the parent sees](../../subagents#what-the-parent-sees) for the complete contract.
 
 ## Sending and streaming
 

package/docs/subagents/index.mdx

@@ -9,15 +9,16 @@ eve supports two ways to delegate work: the root-only built-in `agent` tool, whi
 
 Overlapping background work owned by a session forms a cohort. Tasks launched in
 later user turns join the open cohort while earlier work is still pending or its
-successful results await delivery. eve holds successful completion notifications
-until every task in that cohort has completed, failed, or been cancelled, then
-delivers the successful results together in one parent turn. Partial completions
-do not invoke the parent model. Work started after the cohort settles forms a new
-cohort. No configuration or debounce timer is required.
-
-User messages, input requests, authorization events, failures, and cancellation
-are handled without waiting for the cohort. Child lifecycle events are processed
-before completion delivery so usage accounting and handle cleanup stay ordered.
+terminal results await delivery. eve holds completion, failure, and cancellation
+notifications until every task in that cohort is terminal, then delivers all outcomes
+together in one parent turn. This includes cohorts where every task failed or was
+cancelled. Partial settlements do not invoke the parent model. Work started after the
+cohort settles forms a new cohort. No configuration or debounce timer is required.
+
+User messages, input requests, and authorization events are handled without waiting
+for the cohort. Failure and cancellation update task lifecycle state immediately;
+their automatic conversational report waits for the cohort. Child lifecycle events
+are processed before terminal delivery so usage accounting and handle cleanup stay ordered.
 To follow work in progress, subscribe to the child session streams.
 
 ## The built-in `agent` tool
@@ -234,6 +235,8 @@ Do not rely on subagent delegation by itself as an approval boundary. Put sensit
 
 Each delegated subagent spins up its own child session and stream. The parent stream carries the control-plane events `subagent.called` and `subagent.completed`, plus interactive `input.requested`, `authorization.required`, and `authorization.completed` events proxied from descendants so the root channel can prompt the user. To follow the child's other progress, read `subagent.called.data.childSessionId` and subscribe at `GET /eve/v1/session/:childSessionId/stream`.
 
+Both blocking and background invocations emit `subagent.called` after dispatch and `subagent.completed` after the parent records successful completion. Completion carries the actual output and identifies the same invocation by `callId`; the child session can remain available for reuse. A background working receipt is returned as an `action.result` tool output and does not emit completion. Background completion events do not wait for the cohort report. Failure and cancellation are not successful completion; task notifications retain those outcomes.
+
 Channels with activity reporting attribute the backing agent's tool activity to its background task. Local and remote subagents share the task's progress item rather than adding a separate agent item. Continuing or steering a child with `agentId` attaches its new activity to the new task; the previous task keeps its completed or cancelled status. This applies to the built-in `agent` and declared subagent tools, not to child invocations inside custom workflow tools. Activity reporting is best-effort and does not change task execution or result delivery.
 
 A background task that was already admitted survives cancellation of the turn that started it; background work that has not yet been admitted is rejected with the cancelled step. Use `task_cancel` to stop an admitted task. Cancellation delivers the task's final notification to an active parent even if the task must be stopped forcibly. Parent-session finalization cancels remaining live tasks.

package/docs/tools/overview.mdx

@@ -121,33 +121,25 @@ receive only the projected text.
 
 ### Background execution
 
-Background execution controls how a tool delivers its result to the parent agent. Durable
-suspension controls whether the executor can pause at a workflow wait and release compute.
-These are independent choices: `execution: "background"` selects the task lifecycle;
-`defineWorkflowTool` with a leading `"use workflow"` directive enables durable suspension.
-
-| Definition                                       | Durable waits inside `execute`                                  | Result delivered to the model                                          |
-| ------------------------------------------------ | --------------------------------------------------------------- | ---------------------------------------------------------------------- |
-| `defineTool`                                     | No; the executor runs inside the initiating step.               | Executor output after it finishes.                                     |
-| `defineTool` + `execution: "background"`         | No; the initiating step still waits for the executor to finish. | Task receipt, followed by task notifications.                          |
-| `defineWorkflowTool`                             | Yes; the tool call waits while the workflow can suspend.        | Workflow output after it finishes.                                     |
-| `defineWorkflowTool` + `execution: "background"` | Yes; the workflow body can outlive the initiating step.         | Task receipt before the body finishes, followed by task notifications. |
-
-A background tool receives a third `task` argument. Its tool result is the receipt
-`{ status: "working", taskId }`; its eventual output belongs to the task. Use a background
-workflow tool when the conversation should continue while the body waits for a person,
-webhook, or timer. Setting `execution: "background"` on an ordinary tool does not move its
-executor into a separate workflow or make an ordinary Promise a durable wait.
+Background execution controls how a workflow tool delivers its result to the parent agent.
+Set `execution: "background"` on `defineWorkflowTool`; ordinary `defineTool` calls always finish
+inside the initiating step.
+
+| Definition                                       | Durable waits inside `execute`                           | Result delivered to the model                                                                          |
+| ------------------------------------------------ | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `defineTool`                                     | No; the executor runs inside the initiating step.        | Executor output after it finishes.                                                                     |
+| `defineWorkflowTool`                             | Yes; the tool call waits while the workflow can suspend. | Workflow output after it finishes.                                                                     |
+| `defineWorkflowTool` + `execution: "background"` | Yes; the workflow body can outlive the initiating step.  | Task receipt before the body finishes; one combined report after all tasks in its cohort are terminal. |
+
+A background workflow tool's result is the receipt `{ status: "working", taskId }`; its eventual
+output belongs to the task. Use this mode when the conversation should continue while the body
+waits for a person, webhook, or timer.
 
 For background tools, `outputSchema` and `toModelOutput` describe the fixed receipt. The body's
 return value is available through the completed task's output.
 
-`task.delegated()` has been removed. Move external work into a `defineWorkflowTool` executor and
-return its result when it finishes. Rebuild extensions using the removed API after migrating.
-
-`yield task.postMessage(message)` is the only yield that requests a parent-agent turn. Calling
-`task.postMessage` only constructs the message descriptor; you must yield it to send it.
-In a workflow body, keep values needed after a wait in local variables; workflow replay
+The `TaskExec` argument and `task.postMessage` have been removed. Return the terminal result;
+background yields are consumed without publishing progress or retaining a task-progress stream. In a workflow body, keep values needed after a wait in local variables; workflow replay
 reconstructs them across durable waits.
 Use [`ctx.ask`](/docs/tools/workflows#ask-a-human-ctxask) when the body needs an answer from the human.
 Background tools are a normal execution mode and need no root-agent flag. Built-in, declared local,
@@ -158,10 +150,11 @@ cohort and instructs the model to acknowledge that the work started without wait
 [Schedule](/docs/schedules)-initiated turns are the exception: no user prompted them, so their
 launches keep conditional delivery and send no acknowledgement.
 Later task-triggered parent turns receive fresh state for the same cohort. Once every related
-task is terminal, the state includes their outputs so the model can combine the useful results.
+task is terminal, one automatic parent turn receives the cohort's completed, failed, and cancelled
+outcomes so the model can combine the useful results.
 eve does not instruct the model to stay silent while sibling tasks are pending; a new user
 question can receive an answer while background work continues. [Completion batching](/docs/subagents#completion-batching)
-combines successful results already queued for the parent.
+combines terminal results already queued for the parent.
 
 ### Yield and return
 
@@ -169,19 +162,18 @@ combines successful results already queued for the parent.
 It does not by itself create a durable wait for a person, timer, or external event. The value's
 meaning depends on the tool's execution mode:
 
-| Executor                                         | Ordinary `yield value`                                                                  | Final output                                                                                                      |
-| ------------------------------------------------ | --------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
-| `defineTool`, default execution                  | Earlier values are `action.partial` snapshots; the final yield becomes the tool result. | Last yielded value; a generator `return` value is ignored.                                                        |
-| `defineWorkflowTool`, default execution          | Every yield is an `action.partial` snapshot.                                            | Explicit return value; falls back to the last yield if the return is `null` or `undefined`, then to `null`.       |
-| Either definition with `execution: "background"` | Stream-only task progress; does not request a parent-agent turn.                        | Explicit return value becomes the task output; no return completes with `null`. The last yield is not a fallback. |
+| Executor                                            | Ordinary `yield value`                                                                  | Final output                                                                                                      |
+| --------------------------------------------------- | --------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
+| `defineTool`, default execution                     | Earlier values are `action.partial` snapshots; the final yield becomes the tool result. | Last yielded value; a generator `return` value is ignored.                                                        |
+| `defineWorkflowTool`, default execution             | Every yield is an `action.partial` snapshot.                                            | Explicit return value; falls back to the last yield if the return is `null` or `undefined`, then to `null`.       |
+| `defineWorkflowTool` with `execution: "background"` | Consumed without publishing progress or requesting a parent-agent turn.                 | Explicit return value becomes the task output; no return completes with `null`. The last yield is not a fallback. |
 
-For either kind of background tool, `yield task.postMessage(message)` sends a message to the
-parent agent while the task remains open. Return completes the task; throw fails it. These
-notifications are separate from the original tool call's receipt.
+For a background workflow tool, return completes the task and throw fails it. The automatic
+cohort report is separate from the original tool call's receipt.
 
 Progress snapshots do not enter model history as intermediate tool results. For a default
 executor, the final output selected by the rules above becomes the tool result. For a background
-executor, task messages and completion notifications provide input to later parent-agent turns.
+executor, the terminal cohort report provides input to a later parent-agent turn.
 
 ### Workflows as tools
 

package/docs/tools/workflows.mdx

@@ -178,8 +178,7 @@ agent should receive a tool result:
 
 Use default execution when the model needs the answer to continue. Use background execution when
 the conversation should continue while the task is pending. Background tools need no root-agent
-flag. Ordinary `defineTool` also accepts `execution: "background"`, but its executor still runs
-inside the initiating step and cannot suspend at workflow waits. See the
+flag. `defineTool` does not accept background execution. See the
 [tool execution comparison](/docs/tools#background-execution).
 
 ### How suspension works
@@ -429,23 +428,23 @@ This pattern controls specialist selection, not whether the parent model delegat
 
 ## Report progress: `yield`
 
-A workflow body may be an async generator. Ordinary yields report progress in both execution
-modes. After processing a yield, eve advances the generator; use an awaited workflow operation
+A workflow body may be an async generator. In default execution, yields report progress.
+Background execution consumes yielded values without publishing them or retaining a task-progress
+stream. After processing a yield, eve advances the generator; use an awaited workflow operation
 when the body needs to suspend.
 
-| Operation                         | Default execution                                                 | `execution: "background"`                                              |
-| --------------------------------- | ----------------------------------------------------------------- | ---------------------------------------------------------------------- |
-| `yield value`                     | Emits an `action.partial` snapshot for the pending tool call.     | Emits stream-only task progress; does not request a parent-agent turn. |
-| `yield task.postMessage(message)` | Unavailable; there is no `task` argument.                         | Sends a message requesting a parent-agent turn; the task stays open.   |
-| `return value`                    | Settles the tool call with its output.                            | Completes the task and delivers its output in a later notification.    |
-| No return value                   | Uses the last yield as output, or `null` if there were no yields. | Completes with `null`; yielded progress is not the task output.        |
+| Operation       | Default execution                                                 | `execution: "background"`                                                         |
+| --------------- | ----------------------------------------------------------------- | --------------------------------------------------------------------------------- |
+| `yield value`   | Emits an `action.partial` snapshot for the pending tool call.     | Consumes the value without publishing progress or requesting a parent-agent turn. |
+| `return value`  | Settles the tool call with its output.                            | Completes the task and contributes to its cohort's terminal report.               |
+| No return value | Uses the last yield as output, or `null` if there were no yields. | Completes with `null`; yielded progress is not the task output.                   |
 
 For default execution, an explicit `return null` also falls back to the last yield. Prefer an
 explicit object return when progress snapshots and the final result have different shapes.
 Progress snapshots are last-write-wins by tool call id and do not enter model history as
 intermediate tool results. A snapshot used as the final output does enter history as the tool result.
 
-This background workflow reports progress, sends the parent one message, and then suspends:
+This background workflow consumes an intermediate yield, then suspends until its timer expires:
 
 ```ts title="agent/tools/remind_with_progress.ts"
 import { defineWorkflowTool } from "eve/tools";
@@ -453,25 +452,22 @@ import { sleep } from "workflow";
 import { z } from "zod";
 
 export default defineWorkflowTool({
-  description: "Schedule a reminder and report progress before waiting.",
+  description: "Schedule a reminder.",
   inputSchema: z.object({ note: z.string(), delay: z.string() }),
   execution: "background",
-  async *execute({ note, delay }, ctx, task) {
+  async *execute({ note, delay }) {
     "use workflow";
-    yield { status: "preparing reminder" }; // Stream-only progress.
-    yield task.postMessage(`Reminder scheduled for ${delay}.`); // Parent-agent message.
+    yield { status: "preparing reminder" }; // Consumed without publishing progress in background mode.
     await sleep(delay); // Durable suspension while the timer is pending.
     return { reminder: note }; // Task completion notification.
   },
 });
 ```
 
-Calling `task.postMessage` constructs a descriptor; yielding it sends the message. It does not
-wait for a reply. Use [`ctx.ask`](#ask-a-human-ctxask) when the workflow needs a human answer.
-Removing `execution: "background"` requires removing the `task` argument and message yield; the
-ordinary progress yield and `await sleep(delay)` still work, but the model waits for the final
-reminder as the tool result. See [yield and return](/docs/tools#yield-and-return) for the different
-final-output rules of ordinary `defineTool` generators.
+Use [`ctx.ask`](#ask-a-human-ctxask) when the workflow needs a human answer. Removing
+`execution: "background"` makes the yield visible as progress and keeps the durable sleep; the model
+waits for the final reminder as the tool result. See [yield and return](/docs/tools#yield-and-return) for the
+final-output rules.
 
 ## Cancel and clean up: `ctx.abortSignal`
 
@@ -497,6 +493,11 @@ as cancelled whether or not it did. A body parked on a hook or a `sleep` does no
 it is abandoned when the grace period ends. Steps that received the signal are how you clean up
 first.
 
+The caller waits up to 35 seconds for a cooperatively cancelled run to settle before forcing it
+to stop. This includes time for the run to publish its outcome after body cleanup. A background
+task records its cancelled status before cleanup finishes, so that status alone does not mean
+its work has stopped.
+
 ## Workflow tool examples
 
 ### Approve with a deadline and an escalation
@@ -607,8 +608,10 @@ it.
 ## Semantics
 
 One call, one result. A waiting tool's call resolves once, with the return value, the error, or a
-cancellation. A background tool's call resolves once, with the receipt; everything after arrives as
-separate session input.
+cancellation. A background tool's call resolves once, with the receipt. Its terminal outcome arrives
+in one automatic report after every task in its cohort is terminal. A cohort includes overlapping
+background work in the same session, including tasks launched in later user turns while earlier
+work remains open.
 
 While a waiting tool runs, the turn is parked. A `queue` message waits for it. A `steer` message
 cancels the turn, which cancels the run, which withdraws its requests. Input responses never steer.
@@ -616,8 +619,12 @@ cancels the turn, which cancels the run, which withdraws its requests. Input res
 Background runs belong to the session. They survive turn completion and cancellation, appear in the
 session's task index, can be cancelled with `task_cancel`, and are cancelled when the session ends.
 
+The parent session records each background task's outcome when it processes the child's notification.
+The first terminal outcome it records is final: a late child result cannot replace a recorded
+cancellation. Task completion does not require the wrapper workflow to have exited.
+
 Errors follow the SDK. A thrown error in a step retries per the step's policy; `FatalError` does
-not. An error that escapes the body fails the run.
+not. An error that escapes the body fails the tool invocation.
 
 Starting a waiting workflow tool can also be retried. If dispatch is interrupted after starting a
 run, its retry starts another run, and both may execute. The parent tracks the run returned by the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.62.0",
+  "version": "0.63.0",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [

package/dist/src/cli/dev/tui/model-editor.d.ts

@@ -1,103 +0,0 @@
-import { type ReasoningLevel } from "#setup/boxes/model-capabilities.js";
-import type { GatewayModelCapabilities } from "#setup/boxes/model-capabilities.js";
-import { type SelectState } from "#setup/cli/select-state.js";
-import type { ModelSettingsRequest, ModelSettingsResult } from "#setup/flows/model.js";
-import type { SelectOption } from "#setup/prompter.js";
-/** The Change-model menu's rows, in visual order. */
-export type ModelEditorRowId = "model" | "reasoning" | "tier" | "done";
-/**
- * The screen stack, depth two: the value menu, or the model list it opens.
- * Reasoning and tier adjust inline on their menu rows — only the catalog pick
- * warrants its own screen. The list carries scratch select state seeded when
- * opened; Esc drops it, so "returns unchanged" is structural.
- */
-export type ModelEditorScreen = {
-    kind: "menu";
-    cursor: ModelEditorRowId;
-} | {
-    kind: "model";
-    select: SelectState;
-};
-/** The in-progress values; a completed selection is applied immediately. */
-export interface ModelEditorDraft {
-    modelId: string | null;
-    reasoning: "default" | ReasoningLevel;
-    tier: "standard" | "priority";
-}
-/** One Change-model interaction, advanced by {@link transitionModelEditor}. */
-export interface ModelEditorState {
-    screen: ModelEditorScreen;
-    draft: ModelEditorDraft;
-    /** Catalog capabilities for `draft.modelId`; recomputed on every pick. */
-    capabilities: GatewayModelCapabilities | undefined;
-}
-/** Semantic input after terminal-key decoding. */
-export type ModelEditorEvent = {
-    type: "move";
-    direction: "up" | "down";
-} | {
-    type: "adjust";
-    direction: "left" | "right";
-} | {
-    type: "char";
-    char: string;
-} | {
-    type: "backspace";
-} | {
-    type: "cancel";
-} | {
-    type: "submit";
-};
-export type ModelEditorTransition = {
-    kind: "ignore";
-    state: ModelEditorState;
-} | {
-    kind: "render";
-    state: ModelEditorState;
-} | {
-    kind: "cancel";
-} | {
-    kind: "settle";
-    result: ModelSettingsResult;
-};
-/**
- * How a value row presents: an adjustable control, a dim explanatory line the
- * cursor skips, or nothing at all — a control that cannot apply to the
- * drafted model (no priority tier) is noise, while an authored-but-unowned
- * state (custom tier, external provider) still explains itself.
- */
-export type ModelEditorSectionView = {
-    kind: "interactive";
-} | {
-    kind: "static";
-    text: string;
-} | {
-    kind: "hidden";
-};
-/**
- * The reasoning row stays interactive while a level is drafted even when the
- * catalog disowns reasoning, so the authored value at least stays visible.
- */
-export declare function reasoningSectionView(request: ModelSettingsRequest, draft: ModelEditorDraft, capabilities: GatewayModelCapabilities | undefined): ModelEditorSectionView;
-/** The tier row's presentation; static or hidden for every state it cannot own. */
-export declare function tierSectionView(request: ModelSettingsRequest, capabilities: GatewayModelCapabilities | undefined): ModelEditorSectionView;
-/**
- * The track's notch positions: the levels the catalog supports (every level
- * when capabilities are unknown). The provider default is not a notch — an
- * unset draft renders an empty track and the first right-adjust enters the
- * scale at the lowest level. A drafted level the catalog does not list is
- * inserted in canonical level order, so the track never hides the value it
- * is about to replace.
- */
-export declare function reasoningPositions(capabilities: GatewayModelCapabilities | undefined, drafted: "default" | ReasoningLevel): readonly ReasoningLevel[];
-/**
- * The value menu's rows, derived fresh from the draft on every transition and
- * paint: interactive sections are pickable rows, static sections are disabled
- * rows carrying their explanation, and a hidden tier is omitted entirely.
- * Value hints are the painter's job — it styles them with theme glyphs.
- */
-export declare function modelEditorMenuRows(request: ModelSettingsRequest, draft: ModelEditorDraft, capabilities: GatewayModelCapabilities | undefined): SelectOption<ModelEditorRowId>[];
-/** Creates the screen's state; the cursor opens on the first pickable row. */
-export declare function initialModelEditorState(request: ModelSettingsRequest): ModelEditorState;
-/** Applies one keypress worth of semantics; terminal resources stay in the renderer. */
-export declare function transitionModelEditor(state: ModelEditorState, event: ModelEditorEvent, request: ModelSettingsRequest): ModelEditorTransition;

package/dist/src/cli/dev/tui/model-editor.js

@@ -1 +0,0 @@
-import{ALL_REASONING_LEVELS}from"#setup/boxes/model-capabilities.js";import{filterOptions,initialSelectState,reduceSelect,selectValueAtCursor}from"#setup/cli/select-state.js";const NOT_EDITABLE_TEXT=`No editable agent.ts config object is available`;function reasoningSectionView(e,t,n){return e.settingsEditable?n?.reasoning===!1&&t.reasoning==="default"?{kind:`static`,text:`Not supported by the selected model`}:{kind:`interactive`}:{kind:`static`,text:NOT_EDITABLE_TEXT}}function tierSectionView(e,t){return e.settingsEditable?e.externalRouting?{kind:`static`,text:`Disabled for a direct external provider`}:e.serviceTier.kind===`custom`?{kind:`static`,text:`Custom (${e.serviceTier.value}) — authored in agent.ts`}:t!==void 0&&!t.fastMode?{kind:`hidden`}:{kind:`interactive`}:{kind:`static`,text:NOT_EDITABLE_TEXT}}function reasoningPositions(e,t){let n=[...e===void 0?ALL_REASONING_LEVELS:e.reasoningLevels];if(t!=="default"&&!n.includes(t)){let e=ALL_REASONING_LEVELS.indexOf(t),r=n.findIndex(t=>ALL_REASONING_LEVELS.indexOf(t)>e);r===-1?n.push(t):n.splice(r,0,t)}return n}function snapReasoningToCapabilities(e,t){if(e==="default"||t===void 0)return e;let n=t.reasoningLevels;if(!t.reasoning||n.length===0)return`default`;if(n.includes(e))return e;let r=ALL_REASONING_LEVELS.indexOf(e),i=n[0];for(let e of n)Math.abs(ALL_REASONING_LEVELS.indexOf(e)-r)<Math.abs(ALL_REASONING_LEVELS.indexOf(i)-r)&&(i=e);return i}function modelEditorMenuRows(e,t,n){let r=[];e.model.kind===`pick`?r.push({value:`model`,label:`Model`}):r.push({value:`model`,label:`Model`,disabled:!0,description:e.model.reason});let i=reasoningSectionView(e,t,n);i.kind===`static`?r.push({value:`reasoning`,label:`Reasoning effort`,disabled:!0,description:i.text}):r.push({value:`reasoning`,label:`Reasoning effort`});let a=tierSectionView(e,n);return a.kind===`interactive`?r.push({value:`tier`,label:`Service tier`}):a.kind===`static`&&r.push({value:`tier`,label:`Service tier`,disabled:!0,description:a.text}),r}function initialModelEditorState(e){let t={modelId:e.model.current,reasoning:e.reasoning??`default`,tier:e.serviceTier.kind===`priority`?`priority`:`standard`},n=e.capabilitiesFor(t.modelId);return{screen:{kind:`menu`,cursor:modelEditorMenuRows(e,t,n).find(e=>e.disabled!==!0)?.value??`done`},draft:t,capabilities:n}}function expandedModelSelect(e,t){let n={options:e.model.kind===`pick`?e.model.options:[]};return t!==null&&(n.defaultValue=t),initialSelectState(n)}function ignore(e){return{kind:`ignore`,state:e}}function toMenu(e,t){return{kind:`render`,state:{...e,screen:{kind:`menu`,cursor:t}}}}function settleResult(e,t){let n={};if(e.model.kind===`pick`&&t.modelId!==null&&t.modelId!==e.model.current&&(n.model=t.modelId),!e.settingsEditable)return n;t.reasoning!==(e.reasoning??`default`)&&(n.reasoning=t.reasoning);let r=!e.externalRouting&&e.serviceTier.kind!==`custom`,i=e.serviceTier.kind===`priority`?`priority`:`standard`;return r&&t.tier!==i&&(n.serviceTier=t.tier),n}function adjustMenuValue(e,t,n,r){let i=r===`left`?-1:1;if(n===`reasoning`){if(reasoningSectionView(t,e.draft,e.capabilities).kind!==`interactive`)return ignore(e);let n=reasoningPositions(e.capabilities,e.draft.reasoning);if(n.length===0)return ignore(e);let r=e.draft.reasoning==="default"?-1:n.indexOf(e.draft.reasoning),a=r===-1?n[i===1?0:n.length-1]:n[(r+i+n.length)%n.length];return a===e.draft.reasoning?ignore(e):{kind:`render`,state:{...e,draft:{...e.draft,reasoning:a}}}}if(n===`tier`){if(tierSectionView(t,e.capabilities).kind!==`interactive`)return ignore(e);let n=e.draft.tier===`priority`?`standard`:`priority`;return{kind:`render`,state:{...e,draft:{...e.draft,tier:n}}}}return ignore(e)}function transitionMenu(e,t,n,r){let i=modelEditorMenuRows(n,e.draft,e.capabilities);switch(t.type){case`cancel`:return{kind:`cancel`};case`move`:{let n=Math.max(0,i.findIndex(e=>e.value===r)),a=i[reduceSelect({filter:``,cursor:n,selected:new Set},{type:t.direction},{options:i}).cursor]?.value;return a===void 0||a===r?ignore(e):toMenu(e,a)}case`adjust`:return adjustMenuValue(e,n,r,t.direction);case`submit`:{let t=i.find(e=>e.value===r);return t===void 0||t.disabled===!0?ignore(e):r===`model`?{kind:`render`,state:{...e,screen:{kind:`model`,select:expandedModelSelect(n,e.draft.modelId)}}}:{kind:`settle`,result:settleResult(n,e.draft)}}case`char`:case`backspace`:return ignore(e)}}function transitionModelScreen(e,t,n,r){let i=n.model.kind===`pick`?n.model.options:[],renderSelect=t=>t===r?ignore(e):{kind:`render`,state:{...e,screen:{kind:`model`,select:t}}};switch(t.type){case`cancel`:return r.filter.length>0?renderSelect(reduceSelect(r,{type:`clear`},{options:i})):toMenu(e,`model`);case`move`:return renderSelect(reduceSelect(r,{type:t.direction},{options:i}));case`char`:return renderSelect(reduceSelect(r,{type:`char`,char:t.char},{options:i}));case`backspace`:return renderSelect(reduceSelect(r,{type:`backspace`},{options:i}));case`submit`:{let t=filterOptions(i,r.filter),a=selectValueAtCursor(t,r.cursor);if(a===void 0)return ignore(e);let o=n.capabilitiesFor(a);return{kind:`settle`,result:settleResult(n,{...e.draft,modelId:a,reasoning:snapReasoningToCapabilities(e.draft.reasoning,o),tier:o!==void 0&&!o.fastMode?`standard`:e.draft.tier})}}case`adjust`:return ignore(e)}}function transitionModelEditor(e,t,n){switch(e.screen.kind){case`menu`:return transitionMenu(e,t,n,e.screen.cursor);case`model`:return transitionModelScreen(e,t,n,e.screen.select)}}export{initialModelEditorState,modelEditorMenuRows,reasoningPositions,reasoningSectionView,tierSectionView,transitionModelEditor};

package/dist/src/execution/tasks/child/steps.d.ts

@@ -1,81 +0,0 @@
-import type { ActivityObserverConfig } from "#channel/types.js";
-import type { WorkflowToolAuthorizationRequest, WorkflowToolRunRequestMessage } from "#execution/tools/workflow/messages.js";
-import type { WorkflowToolRunTaskInputRequest } from "./workflow.js";
-import type { AnswerHookRoute } from "#harness/proxy-input-requests.js";
-import type { ActivityEventV1 } from "#protocol/activity.js";
-import { type TaskInboundAnswerInput, type TaskInboundMessage, type TaskInboundUpdate, type TaskProgress, type TaskView } from "#tasks/types.js";
-/**
- * Appends one full task view to the owning task run's `eve.task`
- * stream. Only the task run workflow calls this, which is what makes
- * the run the single writer readers can trust without re-validating.
- */
-export declare function appendTaskViewStep(input: {
-    readonly activityObserver?: ActivityObserverConfig;
-    readonly view: TaskView;
-}): Promise<void>;
-export declare function projectTaskActivity(input: {
-    readonly activityObserver: ActivityObserverConfig | undefined;
-    readonly settledAt: string;
-    readonly view: TaskView;
-}): readonly ActivityEventV1[];
-/** Appends task progress without starting a parent turn. */
-export declare function appendTaskProgressStep(input: {
-    readonly progress: TaskProgress;
-}): Promise<void>;
-/**
- * Wakes the parent session with a framework task notification.
- *
- * Rides the ordinary session delivery path: a parked parent starts a
- * turn carrying this message, while an active turn observes it at the
- * next safe boundary through the owner's normal delivery routing. A
- * parent whose session already ended is a tolerated no-op.
- */
-export declare function wakeTaskParentStep(input: {
-    readonly token: string;
-    readonly view: TaskView;
-}): Promise<void>;
-/** Forwards a running child's intermediate update to its parent session. */
-export declare function wakeTaskUpdateParentStep(input: {
-    readonly token: string;
-    readonly update: TaskInboundUpdate;
-    readonly view: TaskView;
-}): Promise<void>;
-/** Delivers one task-authored message to the parent as a new turn. */
-export declare function wakeTaskMessageParentStep(input: {
-    readonly message: TaskInboundMessage;
-    readonly taskId: string;
-    readonly token: string;
-}): Promise<void>;
-/** Forwards one agent spawn or settlement request to the parent session. */
-export declare function wakeTaskAgentRequestParentStep(input: {
-    readonly request: WorkflowToolRunRequestMessage;
-    readonly taskId: string;
-    readonly token: string;
-}): Promise<void>;
-/** Re-emits a task child's authorization event through the parent channel. */
-export declare function wakeTaskAuthorizationParentStep(input: {
-    readonly request: WorkflowToolAuthorizationRequest;
-    readonly taskId: string;
-    readonly token: string;
-}): Promise<void>;
-/** Sends a workflow-body question to the owning parent's pre-model router. */
-export declare function wakeWorkflowTaskInputRequestParentStep(input: {
-    readonly request: WorkflowToolRunTaskInputRequest;
-    readonly taskId: string;
-    readonly token: string;
-}): Promise<void>;
-/**
- * Forwards answered input to the blocked child.
- *
- * The task run performs this itself so the child unblocks and the
- * view leaves `input_required` under one durable decision. Returns
- * `unreachable` when the child hook is already gone, which leaves the
- * outstanding batch untouched rather than reporting a task as working
- * when nothing received the answer.
- */
-export declare function deliverTaskInputResponsesStep(input: {
-    readonly answer: TaskInboundAnswerInput;
-    readonly answerHook?: AnswerHookRoute;
-    readonly requestIds: readonly string[];
-}): Promise<"delivered" | "unreachable">;
-export declare function formatTaskNotification(view: TaskView): string;