eve 0.52.1 → 0.52.2

package/docs/concepts/built-in-tools.md

@@ -7,92 +7,183 @@ eve provides a default tool set for every agent and additional tools you can add
 
 ## Default tools
 
-Default tools require no imports. The exact set depends on the agent and session. `agent` is available only in the root session; `load_skill` and `connection_search` appear only when the agent declares the corresponding resources; `ask_question` requires a session that can request user input; and `web_search` requires a supported model provider. The harness advertises only the tools available to the current session.
+Default tools require no imports. The exact set depends on the agent and session, and the harness advertises only the tools available to the current session.
 
-The default shell and file tools (`bash`, `read_file`, and `write_file`) run in the app and proxy their work into the agent's [sandbox](../sandbox). The table shows where each tool's effect lands.
+### Disable optional default tools
 
-| Tool                | Does                                                                                                                                                                                                                | Where it runs |
-| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------- |
-| `bash`              | Run a shell command.                                                                                                                                                                                                | Sandbox       |
-| `read_file`         | Read a text file with line-numbered output (enables read-before-write).                                                                                                                                             | Sandbox FS    |
-| `write_file`        | Write a complete file; enforces read-before-write and stale-read detection.                                                                                                                                         | Sandbox FS    |
-| `web_fetch`         | Fetch a URL.                                                                                                                                                                                                        | App runtime   |
-| `web_search`        | Search the web (provider-managed; resolved from the model provider).                                                                                                                                                | Provider      |
-| `todo`              | Maintain a durable per-session todo list.                                                                                                                                                                           | App runtime   |
-| `ask_question`      | Ask the user a clarifying question or a choice mid-turn and park until they answer. No `execute`; the model calls it with `{ prompt, options?, allowFreeform? }`. See [Human-in-the-loop](/docs/human-in-the-loop). | App runtime   |
-| `agent`             | From the root session, delegate a subtask to a fresh copy of the root agent.                                                                                                                                        | App runtime   |
-| `load_skill`        | Pull an on-demand [skill](../skills)'s instructions into the current turn. Present only when the agent declares skills.                                                                                             | App runtime   |
-| `connection_search` | Discover tools across declared [connections](../connections); matched tools become directly callable. Present only when the agent declares connections.                                                             | App runtime   |
+Optional default tools are enabled unless you set `defaultTools: false` in `agent/agent.ts`:
 
-The model-facing file tools accept absolute paths and paths beginning with `$HOME/`. eve resolves `$HOME` against the sandbox before invoking non-shell file operations, so packaged skill references such as `$HOME/.agents/skills/<skill>/references/...` work consistently across `read_file`, `write_file`, and the opt-in `glob` and `grep` tools.
+```ts title="agent/agent.ts"
+import { defineAgent } from "eve";
 
-Notes:
+export default defineAgent({
+  defaultTools: false,
+  model: "openai/gpt-5.4",
+});
+```
 
-- **`agent`** is available only in the root session and always runs in the background. Its call returns a task receipt immediately, and task notifications deliver updates or the final result. The child uses the root's instructions, tools, connections, and sandbox, but starts with fresh conversation history and fresh [state](./state). The child receives neither `agent` nor `Workflow`; declared subagents do not receive the built-in `agent` either. See [Subagents](../subagents).
-- **`load_skill`** only pulls instructions into context. It adds no new execution surface, because behavior still comes from the tools the agent already has.
-- **`connection_search`** surfaces a connection's tools by their qualified name (e.g. `linear__list_issues`), which the model can then call directly. The model sees it only when the agent has connections.
-- **`web_search`** has no local executor; the provider runs it. AI Gateway models use Exa by default. To use Parallel instead, export `webSearch({ provider: "parallel" })` from `agent/tools/web_search.ts`. Direct provider models continue to use their native search implementation. To supply your own implementation, override it with `defineTool()`.
-- **`web_fetch`** follows up to ten redirects, rechecking every destination for SSRF safety. Non-success HTTP responses return a plain-text failure result with the response body when available instead of failing the tool call.
+This turns off the optional defaults described below. Add back only the tools the agent needs with the command in each tool's section. Existing files under `agent/tools/` remain available, including same-name replacements such as `agent/tools/bash.ts`.
 
-Review these default tools before production use. Disable, wrap, restrict, or require approval for any tool that can access the filesystem, network, shell, or sensitive data.
+`connection_search` stays available when the agent has connections because it provides access to their tools.
 
-## Add framework-provided tools
+### `bash`
 
-Some framework-provided tools stay out of the default set. Add the corresponding file when your agent needs one:
+`bash` runs shell commands in the agent's [sandbox](../sandbox).
 
-| Tool    | Definition to export             | Purpose                                    |
-| ------- | -------------------------------- | ------------------------------------------ |
-| `glob`  | `glob` from `eve/tools/glob`     | Find sandbox files by glob pattern.        |
-| `grep`  | `grep` from `eve/tools/grep`     | Search sandbox file contents by regex.     |
-| `sleep` | `sleep()` from `eve/tools/sleep` | Pause and durably resume the current turn. |
+```sh
+eve add tool/bash
+```
 
-For example, add file discovery and content search with two files:
+```ts title="agent/tools/bash.ts"
+export { default } from "eve/tools/bash";
+```
 
-```ts title="agent/tools/glob.ts"
-export { glob as default } from "eve/tools/glob";
+Override its description, approval policy, or executor by wrapping the exported definition:
+
+```ts title="agent/tools/bash.ts"
+import { defineTool } from "eve/tools";
+import { bash } from "eve/tools/bash";
+
+export default defineTool({
+  ...bash,
+  description: "Run approved project maintenance commands.",
+  async execute(input, ctx) {
+    console.info("Running sandbox command", input.command);
+    return bash.execute(input, ctx);
+  },
+});
 ```
 
-```ts title="agent/tools/grep.ts"
-export { grep as default } from "eve/tools/grep";
+Disable only `bash`:
+
+```ts title="agent/tools/bash.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
 ```
 
-The filename supplies the model-facing tool name. The tools run against the agent's sandbox and use the same schemas, results, and error behavior as eve's framework implementations. Wrap either definition with `defineTool({ ...glob, description: "..." })` or `defineTool({ ...grep, description: "..." })` when you need to change its description or approval policy.
+### `read_file`
+
+`read_file` reads text files from the sandbox with line-numbered output. It accepts absolute paths and paths beginning with `$HOME/`.
 
-The section below covers `sleep` in more detail.
+```sh
+eve add tool/read_file
+```
+
+```ts title="agent/tools/read_file.ts"
+export { default } from "eve/tools/read_file";
+```
 
-## Override a default
+Override it:
 
-Author a tool at the same slug and it takes over the built-in of that name. The file `agent/tools/write_file.ts` replaces the built-in `write_file` by existing:
+```ts title="agent/tools/read_file.ts"
+import { defineTool } from "eve/tools";
+import { readFile } from "eve/tools/read_file";
+
+export default defineTool({
+  ...readFile,
+  description: "Read project files from the sandbox.",
+});
+```
+
+Disable it:
+
+```ts title="agent/tools/read_file.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `write_file`
+
+`write_file` writes complete files in the sandbox. It enforces read-before-write and stale-read detection, and accepts absolute paths and paths beginning with `$HOME/`.
+
+```sh
+eve add tool/write_file
+```
+
+```ts title="agent/tools/write_file.ts"
+export { default } from "eve/tools/write_file";
+```
+
+Override it:
 
 ```ts title="agent/tools/write_file.ts"
 import { defineTool } from "eve/tools";
 import { writeFile } from "eve/tools/write_file";
 
 export default defineTool({
-  ...writeFile, // keep the default description, schema, and executor
+  ...writeFile,
+  description: "Write approved project files in the sandbox.",
   async execute(input, ctx) {
-    console.log("[write_file]", input.path);
+    if (!input.filePath.startsWith("/workspace/")) {
+      throw new Error("write_file is limited to /workspace");
+    }
     return writeFile.execute(input, ctx);
   },
 });
 ```
 
-Import each reusable definition from its own subpath:
+Disable it:
+
+```ts title="agent/tools/write_file.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `web_fetch`
+
+`web_fetch` fetches URLs from the app runtime. It follows up to ten redirects and checks every destination for SSRF safety. Non-success responses return plain text with the response body when available.
+
+```sh
+eve add tool/web_fetch
+```
+
+```ts title="agent/tools/web_fetch.ts"
+export { default } from "eve/tools/web_fetch";
+```
+
+Override it:
+
+```ts title="agent/tools/web_fetch.ts"
+import { defineTool } from "eve/tools";
+import { webFetch } from "eve/tools/web_fetch";
+
+export default defineTool({
+  ...webFetch,
+  description: "Fetch approved public documentation URLs.",
+  async execute(input, ctx) {
+    const hostname = new URL(input.url).hostname;
+    if (hostname !== "docs.example.com") {
+      throw new Error("web_fetch is limited to docs.example.com");
+    }
+    return webFetch.execute(input, ctx);
+  },
+});
+```
+
+Disable it:
+
+```ts title="agent/tools/web_fetch.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `web_search`
 
-| Definition  | Import                 | Registered by default |
-| ----------- | ---------------------- | --------------------- |
-| `bash`      | `eve/tools/bash`       | Yes                   |
-| `readFile`  | `eve/tools/read_file`  | Yes                   |
-| `writeFile` | `eve/tools/write_file` | Yes                   |
-| `todo`      | `eve/tools/todo`       | Yes                   |
-| `webFetch`  | `eve/tools/web_fetch`  | Yes                   |
-| `loadSkill` | `eve/tools/load_skill` | Yes                   |
-| `glob`      | `eve/tools/glob`       | No                    |
-| `grep`      | `eve/tools/grep`       | No                    |
+`web_search` uses provider-managed web search and appears only for supported model providers. AI Gateway models use Exa by default; direct provider models use their native search implementation.
 
-Importing a definition does not add it to an agent; export it from the corresponding `agent/tools/*.ts` file. Skip the spread and your replacement owns its own context. A fresh `defineTool` for `todo` does not inherit the default's durable state key.
+```sh
+eve add tool/web_search
+```
 
-Provider-managed web search has a dedicated configuration helper instead of an executable default:
+```ts title="agent/tools/web_search.ts"
+export { default } from "eve/tools/web_search";
+```
+
+Override the provider-managed configuration for AI Gateway:
 
 ```ts title="agent/tools/web_search.ts"
 import { webSearch } from "eve/tools/web_search";
@@ -100,41 +191,279 @@ import { webSearch } from "eve/tools/web_search";
 export default webSearch({ provider: "parallel" });
 ```
 
-Set `provider` to `"exa"` or `"parallel"`. Without this file, AI Gateway models use Exa.
+Replace provider-managed search with an authored implementation:
+
+```ts title="agent/tools/web_search.ts"
+import { defineTool } from "eve/tools";
 
-## Disable a default
+export default defineTool({
+  description: "Search the internal documentation index.",
+  inputSchema: { type: "object" },
+  async execute(input) {
+    return { results: [], query: input };
+  },
+});
+```
 
-Export a `disableTool()` sentinel from a file named after the tool's slug. The filename is what picks the default to remove:
+Disable it:
 
-```ts title="agent/tools/bash.ts"
+```ts title="agent/tools/web_search.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `todo`
+
+`todo` maintains a durable todo list for the session.
+
+```sh
+eve add tool/todo
+```
+
+```ts title="agent/tools/todo.ts"
+export { default } from "eve/tools/todo";
+```
+
+Override it. Spreading the definition preserves its durable state key:
+
+```ts title="agent/tools/todo.ts"
+import { defineTool } from "eve/tools";
+import { todo } from "eve/tools/todo";
+
+export default defineTool({
+  ...todo,
+  description: "Track the current implementation plan.",
+});
+```
+
+Disable it:
+
+```ts title="agent/tools/todo.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `ask_question`
+
+`ask_question` asks the user for clarification or a choice, then parks the turn until they answer. It appears only when the session can request user input. See [Human-in-the-loop](/docs/human-in-the-loop).
+
+```sh
+eve add tool/ask_question
+```
+
+```ts title="agent/tools/ask_question.ts"
+export { default } from "eve/tools/ask_question";
+```
+
+Replace its request-input behavior with an ordinary authored tool:
+
+```ts title="agent/tools/ask_question.ts"
+import { defineTool } from "eve/tools";
+
+export default defineTool({
+  description: "Record a clarification request.",
+  inputSchema: { type: "object" },
+  async execute(input) {
+    return { recorded: input };
+  },
+});
+```
+
+Disable it:
+
+```ts title="agent/tools/ask_question.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `agent`
+
+`agent` delegates a subtask to a fresh copy of the root agent. It is root-only, always runs in the background, and returns a task receipt immediately. The child receives the root's instructions, tools, connections, and sandbox, but starts with fresh conversation history and [state](./state). See [Subagents](../subagents).
+
+```sh
+eve add tool/agent
+```
+
+```ts title="agent/tools/agent.ts"
+export { default } from "eve/tools/agent";
+```
+
+The framework behavior cannot be overridden. Re-export the definition above to restore it, or disable it:
+
+```ts title="agent/tools/agent.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `task_cancel`
+
+`task_cancel` lets the root session cancel background tasks.
+
+```sh
+eve add tool/task_cancel
+```
+
+```ts title="agent/tools/task_cancel.ts"
+export { default } from "eve/tools/task_cancel";
+```
+
+The framework behavior cannot be overridden. Re-export the definition above to restore it, or disable it:
+
+```ts title="agent/tools/task_cancel.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `task_update`
+
+`task_update` lets a background task report progress to its parent. It appears only in delegated task sessions.
+
+```sh
+eve add tool/task_update
+```
+
+```ts title="agent/tools/task_update.ts"
+export { default } from "eve/tools/task_update";
+```
+
+The framework behavior cannot be overridden. Re-export the definition above to restore it, or disable it:
+
+```ts title="agent/tools/task_update.ts"
+import { disableTool } from "eve/tools";
+
+export default disableTool();
+```
+
+### `load_skill`
+
+`load_skill` pulls an on-demand [skill](../skills)'s instructions into the current turn. It appears only when the agent declares skills and adds no execution surface by itself.
+
+```sh
+eve add tool/load_skill
+```
+
+```ts title="agent/tools/load_skill.ts"
+export { default } from "eve/tools/load_skill";
+```
+
+Override it:
+
+```ts title="agent/tools/load_skill.ts"
+import { defineTool } from "eve/tools";
+import { loadSkill } from "eve/tools/load_skill";
+
+export default defineTool({
+  ...loadSkill,
+  description: "Load instructions for an available skill.",
+});
+```
+
+Disable it:
+
+```ts title="agent/tools/load_skill.ts"
 import { disableTool } from "eve/tools";
 
 export default disableTool();
 ```
 
-Use `agent/tools/agent.ts` to remove the root-only `agent` delegation tool. The root session then receives no tool for delegating to a fresh copy of itself, and the model never sees that tool.
+### `connection_search`
+
+`connection_search` discovers tools across declared [connections](../connections) and makes matches directly callable by qualified name, such as `linear__list_issues`. eve adds it automatically when connections exist, even when `defaultTools` is `false`, so there is no add command.
 
-If the filename matches no known framework tool, resolution fails instead of silently doing nothing, so a typo surfaces at build time rather than removing the wrong tool.
+An authored `agent/tools/connection_search.ts` replaces the framework behavior. Import the framework definition from `eve/tools/connection_search` when you need to reference it directly. Exporting `disableTool()` from this slot is an error because agents with connections require connection discovery.
 
-## When to override, disable, or author a new tool
+Review these tools before production use. Disable, wrap, restrict, or require approval for any tool that can access the filesystem, network, shell, or sensitive data.
 
-Three moves shape the harness. The right one depends on whether the model should keep the built-in capability.
+You can also add the opt-in framework tools described below.
 
-- **Override** when you want the same capability with different behavior. Import its definition from the matching `eve/tools/<name>` subpath and wrap it (logging, an extra guard, or a different backend), and the model still sees a tool by that name. Spreading keeps the default's description, schema, and any framework state, such as the `todo` tool's durable state key. Drop the spread and your replacement owns its own context, losing that wiring.
-- **Disable** when the model should not have the capability at all. A `disableTool()` sentinel removes the built-in, and the model never sees it. Reach for this to lock down `bash` or `web_fetch` in an agent that should not run shell commands or fetch arbitrary URLs.
-- **Author a new tool** when you want a capability the harness does not ship. Give it a fresh slug under `agent/tools/` and it joins the built-ins instead of replacing one. See [Tools](../tools) for the authoring model.
+## Opt-in framework tools
 
-## The opt-in `sleep` tool
+These framework-provided tools are not added by default. Add only the ones the agent needs.
 
-The framework also ships a durable `sleep` tool, but does not add it to agents by default. Enable it with `agent/tools/sleep.ts`:
+### `glob`
+
+`glob` finds sandbox files by glob pattern. Add it:
+
+```sh
+eve add tool/glob
+```
+
+```ts title="agent/tools/glob.ts"
+export { default } from "eve/tools/glob";
+```
+
+Customize it by wrapping the framework definition:
+
+```ts title="agent/tools/glob.ts"
+import { defineTool } from "eve/tools";
+import { glob } from "eve/tools/glob";
+
+export default defineTool({
+  ...glob,
+  description: "Find project files by glob pattern.",
+});
+```
 
-```ts
+Remove the file to remove the tool. `disableTool()` is unnecessary because `glob` is not added by default.
+
+### `grep`
+
+`grep` searches sandbox file contents with a regular expression. Add it:
+
+```sh
+eve add tool/grep
+```
+
+```ts title="agent/tools/grep.ts"
+export { default } from "eve/tools/grep";
+```
+
+Customize it by wrapping the framework definition:
+
+```ts title="agent/tools/grep.ts"
+import { defineTool } from "eve/tools";
+import { grep } from "eve/tools/grep";
+
+export default defineTool({
+  ...grep,
+  description: "Search project files with a regular expression.",
+});
+```
+
+Remove the file to remove the tool. `disableTool()` is unnecessary because `grep` is not added by default.
+
+### `sleep`
+
+`sleep` pauses and durably resumes the current turn. The model calls it with `{ seconds }`; the wait does not hold an application runtime open. Concurrent calls run in parallel, and the turn resumes after the longest wait. Add it:
+
+```sh
+eve add tool/sleep
+```
+
+```ts title="agent/tools/sleep.ts"
 import { sleep } from "eve/tools/sleep";
 
 export default sleep();
 ```
 
-The model calls it with `{ seconds }` when it is useful to wait before checking progress or status again. Each call runs as a durable tool workflow, so it does not hold an application runtime open, and the same turn continues automatically when the duration elapses. Concurrent `sleep` calls run in parallel, so the turn continues after the longest requested duration.
+Customize it by wrapping the framework definition:
+
+```ts title="agent/tools/sleep.ts"
+import { defineWorkflowTool } from "eve/tools";
+import { sleep } from "eve/tools/sleep";
+
+export default defineWorkflowTool({
+  ...sleep(),
+  description: "Pause before checking an external operation again.",
+});
+```
+
+Remove the file to remove the tool. `disableTool()` is unnecessary because `sleep` is not added by default.
 
 ## What to read next
 

package/docs/connections/openapi.mdx

@@ -150,6 +150,10 @@ export default defineOpenAPIConnection({
 
 The parameter `name` must exactly match the placeholder inside the path. If the spec omits an `in: "path"` parameter, the generated tool has no input for that segment and eve cannot fill it in from query parameters.
 
+## Schema annotations
+
+eve removes `default` and `example` annotations when their values conflict with the declared schema type. For example, a boolean property with `default: "false"` loses that annotation, while `default: false` is retained. This prevents invalid examples from guiding model input; eve does not coerce annotation values.
+
 ## Approval gates
 
 Generated operations can mutate state like authored tools. Use the shared connection `approval` option for human approval, and combine it with `operations.allow` for the smallest practical surface. See [Per-connection approval](../connections#per-connection-approval) for the helpers and [Human-in-the-loop](../human-in-the-loop#approvals) for policy behavior.

package/docs/evals/running.mdx

@@ -35,6 +35,8 @@ Tag filters compose: `--tag` keeps evals carrying at least one listed tag, then
 
 An eval that calls `t.skip(reason)` is reported as skipped, does not count as passed or failed, and never changes the exit code.
 
+`eve eval --json` flushes the complete report before exiting, including when stdout is piped to another process or redirected to a file.
+
 ## Artifacts
 
 Each run drops artifacts under `.eve/evals/<timestamp>/`: a run `summary.json`, a `results.jsonl` index, and per-eval assertion results, verdicts, captured event streams, and `t.log` lines under `evals/`. The console output stays tight on purpose; when an eval fails, the artifact has the full story.

package/docs/guides/client/streaming.mdx

@@ -24,7 +24,7 @@ The cancellation result is discriminated by `status`: only `accepted` includes
 
 Cancellation does not replace stream consumption. Continue reading the response to observe its terminal `turn.cancelled` and `session.waiting` boundary and to advance the client session cursor normally. Use `session.cancel({ turnId })` instead when you have only a fixed session handle and an observed turn ID.
 
-Between turns, `session.compact()` queues context compaction without sending model input. An accepted request reports the session id; consume the durable stream through the following `session.waiting` boundary before sending the next turn. `compaction.completed` confirms that summarization succeeded; without it, eve preserves the previous history. A never-started session returns `no_active_session` as a successful no-op.
+Between turns, `session.compact()` queues context compaction without sending model input. An accepted request reports the session id; consume the durable stream through the following `session.waiting` boundary before sending the next turn. `compaction.completed` confirms that summarization succeeded; without it, eve preserves the previous history, including when the model returns an empty summary. A never-started session returns `no_active_session` as a successful no-op.
 
 ```ts
 const compaction = await session.compact();
@@ -57,6 +57,10 @@ This consumes the stream until the current turn boundary:
 - `session.completed`
 - `session.failed`
 
+`result()` closes that HTTP stream, including when fetch instrumentation clones
+the response for tracing. The durable session remains available for follow-up
+turns after `session.waiting`.
+
 ## Stream events live
 
 Use `for await...of` when you want to render progress:
@@ -149,6 +153,8 @@ The stream can emit an interim `session.waiting` while the authorization callbac
 
 HTTP connections can end before a run does. The client reconnects from the number of events already consumed, so long turns continue without replaying events. By default, a turn response keeps reconnecting until it reaches a turn boundary or is aborted, including while the turn is paused for authorization. A manually opened `session.stream()` eventually stops after repeated empty streams when it can no longer make progress.
 
+Browser failures while reading a response body, including `TypeError: Load failed` and `TypeError: network error`, use the same reconnect policy. Invalid stream events still fail the read.
+
 If your consumer persists events, key on `event.meta.id`. It is stable across reconnects and rewinds, so an overlapping replay is safe to ingest twice. See [the event envelope](../../concepts/sessions-runs-and-streaming#the-event-envelope).
 
 Set `streamReconnectPolicy: { reconnect: false }` when a relay or proxy owns the cursor and reconnection policy. This makes a single stream GET attempt and returns when that connection ends; it does not stop the server-side turn:

package/docs/guides/dynamic-capabilities.md

@@ -219,7 +219,7 @@ the handler.
 
 ## Dynamic tools
 
-Pass `defineDynamic` an `events` object whose handlers return either a single `defineTool(...)`, a `Record<string, defineTool(...)>`, or `null` for no tools. Wrap every entry in `defineTool()`. eve records durable descriptors for `execute`, approval request and response policies, and `toModelOutput`, so a parked call can reconstruct the same callbacks in a fresh process.
+Pass `defineDynamic` an `events` object whose handlers return either a single `defineTool(...)`, a `Record<string, defineTool(...)>`, or `null` for no tools. Wrap every entry in `defineTool()`. eve records durable descriptors for `execute`, approval request and response policies, input-scoped `approvalKey` callbacks, and `toModelOutput`, so a parked call can reconstruct the same callbacks in a fresh process.
 
 Dynamic tool executors receive the same `ToolContext` as static authored tools, including inline provider auth through `ctx.getToken(provider)` and `ctx.requireAuth(provider)`.
 

package/docs/guides/frontend/overview.mdx

@@ -306,7 +306,7 @@ then save a final snapshot in `onFinish`.
 
 For multiple chat threads, keep one saved event log and session cursor per thread. `agent`, `host`, `reducer`, `session`, `initialEvents`, `initialSession`, `auth`, `headers`, `optimistic`, and `resume` are read when the hook creates its store, so remount the chat component when switching threads, for example with `key={chat.id}`.
 
-Pass `resume: true` with `initialSession` to rebuild the projection from the durable stream after mount. While `status` is `"resuming"`, render hydrated `data` but disable message and HITL submission; do not present cancellation or active-turn progress controls. If catch-up finds an in-flight turn, `status` changes to `"streaming"` before the binding follows it to a boundary. A settled tail changes directly to `"ready"`, and a terminal session failure changes to `"error"`.
+Pass `resume: true` with `initialSession` to rebuild the projection from the durable stream after mount. While `status` is `"resuming"`, render hydrated `data` but disable message and HITL submission; do not present cancellation or active-turn progress controls. If catch-up finds an in-flight turn, `status` changes to `"streaming"` before the binding follows it to a boundary. A settled tail changes directly to `"ready"` after a bounded catch-up check, without waiting for the live stream idle timeout. If that check finds a newly started turn or pending authorization, eve keeps following it. A terminal session failure changes to `"error"`.
 
 ```tsx
 const agent = useEveAgent({

package/docs/memory/custom-provider.md

@@ -173,7 +173,10 @@ turn recalls the same data again.
 ## Failure behavior
 
 - A throwing or invalid `recall["turn.started"]` fails the turn before the
-  model call. No slot's recall results are committed.
+  model call. No slot's recall results are committed. If the turn's
+  `abortSignal` is already aborted, eve treats the error as cancellation and
+  continues with any queued steering replacement. An `AbortError` with an active
+  signal still fails the turn.
 - A throwing `capture["compaction.requested"]` leaves history unchanged.
 - A throwing `recall["compaction.completed"]` fails an automatic turn. For
   standalone compaction, eve logs the error and returns the session to waiting,