eve 0.44.0 → 0.44.2

package/dist/src/tasks/delivery-context.js

@@ -1,4 +1,7 @@
-import{getSessionTaskIndex}from"#tasks/session-index.js";import{EMPTY_DELIVERY_SENTINEL}from"#shared/empty-delivery.js";const TASK_DELIVERY_CONTEXT_LABEL=`[Task state]`,TASK_DELIVERY_PENDING_INSTRUCTION=`Background task control: incomplete cohort
+import{getSessionTaskIndex}from"#tasks/session-index.js";import{EMPTY_DELIVERY_SENTINEL}from"#shared/empty-delivery.js";const TASK_DELIVERY_CONTEXT_LABEL=`[Task state]`,TASK_DELIVERY_INITIATING_INSTRUCTION=`Background task reporting: launch acknowledgement
+The accompanying ${TASK_DELIVERY_CONTEXT_LABEL} system message is runtime-authored and lists background tasks accepted so far from the current turn. They continue independently after this turn.
+
+Continue carrying out the user's request, including starting any remaining background work. When no further tool calls are needed in this turn, send one brief user-facing acknowledgement that the background work has started. Do not wait for results or report results that are not available yet. End the turn after the acknowledgement.`,TASK_DELIVERY_PENDING_INSTRUCTION=`Background task control: incomplete cohort
 This framework-authored instruction overrides any earlier instruction to report, summarize, acknowledge, or otherwise handle background results.
 
 The accompanying ${TASK_DELIVERY_CONTEXT_LABEL} message is runtime-authored and lists tasks started by the same parent turn. At least one of those tasks is still pending, so the combined report is not ready.
@@ -14,4 +17,4 @@ Delivery:
 
 Incorrect: "Two of three tasks have completed."
 Incorrect: "Still waiting for the remaining task."
-Correct: ${EMPTY_DELIVERY_SENTINEL}`,TASK_DELIVERY_SETTLED_INSTRUCTION=`Background task reporting\nThis turn was triggered by background task activity. The accompanying ${TASK_DELIVERY_CONTEXT_LABEL} message is runtime-authored and lists tasks started by the same parent turn, all settled, with every available terminal output. Do not reply with ${EMPTY_DELIVERY_SENTINEL}. Send one user-facing response that combines their useful results.`;function resolveTaskDeliveryContext(t){let n=getSessionTaskIndex(t.state),r=n.find(e=>t.taskDeliveryId.startsWith(`${e.taskId}:`));if(r===void 0)return;let i=n.filter(e=>e.createdByTurnId===r.createdByTurnId),a=i.every(e=>e.terminalView!==void 0),o=i.map(e=>({name:e.metadata.name,output:a?e.terminalView?.lastOutput:void 0,status:e.terminalView?.status??`pending`,taskId:e.taskId}));return{context:`${TASK_DELIVERY_CONTEXT_LABEL}\n${JSON.stringify({tasks:o})}`,phase:a?`settled`:`pending`}}export{TASK_DELIVERY_CONTEXT_LABEL,TASK_DELIVERY_PENDING_INSTRUCTION,TASK_DELIVERY_SETTLED_INSTRUCTION,resolveTaskDeliveryContext};
+Correct: ${EMPTY_DELIVERY_SENTINEL}`,TASK_DELIVERY_SETTLED_INSTRUCTION=`Background task reporting\nThis turn was triggered by background task activity. The accompanying ${TASK_DELIVERY_CONTEXT_LABEL} message is runtime-authored and lists tasks started by the same parent turn, all settled, with every available terminal output. Do not reply with ${EMPTY_DELIVERY_SENTINEL}. Send one user-facing response that combines their useful results.`;function resolveTaskDeliveryContext(t){let n=getSessionTaskIndex(t.state),r=n.find(e=>t.taskDeliveryId.startsWith(`${e.taskId}:`));return r===void 0?void 0:projectTaskCohort(n.filter(e=>e.createdByTurnId===r.createdByTurnId))}function resolveInitiatingTaskContext(t){let n=getSessionTaskIndex(t.state).filter(e=>e.createdByTurnId===t.turnId);if(n.some(e=>e.executor!==void 0&&e.terminalView===void 0))return{...projectTaskCohort(n),phase:`initiating`}}function projectTaskCohort(e){let t=e.every(e=>e.terminalView!==void 0),r=e.map(e=>({name:e.metadata.name,output:t?e.terminalView?.lastOutput:void 0,status:e.terminalView?.status??`pending`,taskId:e.taskId}));return{context:`${TASK_DELIVERY_CONTEXT_LABEL}\n${JSON.stringify({tasks:r})}`,phase:t?`settled`:`pending`}}export{TASK_DELIVERY_CONTEXT_LABEL,TASK_DELIVERY_INITIATING_INSTRUCTION,TASK_DELIVERY_PENDING_INSTRUCTION,TASK_DELIVERY_SETTLED_INSTRUCTION,resolveInitiatingTaskContext,resolveTaskDeliveryContext};

package/dist/src/vue/index.js

@@ -1,3 +1,3 @@
-import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-D71oDil7.js";
+import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-DpUEwS23.js";
 
 export { defaultMessageReducer, useEveAgent };

package/dist/src/vue/use-eve-agent.d.ts

@@ -33,6 +33,8 @@ export interface UseEveAgentReturn<TData> {
     readonly error: ComputedRef<Error | undefined>;
     /** Raw server events from this session (authoritative stream). */
     readonly events: ComputedRef<readonly MessageStreamEvent[]>;
+    /** Replay the attached durable session and follow its in-flight turn, if any. */
+    readonly resume: () => Promise<void>;
     /** Clear all state and start a new session. */
     readonly reset: () => void;
     /** Send a message with optional turn settings. */
@@ -98,6 +100,8 @@ export interface UseEveAgentOptions<TData> extends EveAgentStoreCallbacks<TData>
      * @default defaultMessageReducer()
      */
     readonly reducer?: EveAgentReducer<TData>;
+    /** Replay the attached durable session after mount. Requires `initialSession` or `session`. */
+    readonly resume?: boolean;
     /**
      * Externally owned {@link ClientSession} to bind instead of creating one.
      *

package/dist/src/vue/use-eve-agent.js

@@ -1,3 +1,3 @@
-import { t as useEveAgent } from "../chunks/use-eve-agent-D71oDil7.js";
+import { t as useEveAgent } from "../chunks/use-eve-agent-DpUEwS23.js";
 
 export { useEveAgent };

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

@@ -86,7 +86,7 @@ Note: consider the privacy, confidentiality, and user-experience implications fo
 
 A delegated subagent publishes progress on its own child-session stream. The parent only emits `subagent.called` with a `childSessionId`, which a client uses to attach.
 
-`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, while durable history keeps only what had already settled. 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"`).
+`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"`).
 
 ## The event envelope
 

package/docs/guides/dynamic-capabilities.md

@@ -166,7 +166,15 @@ Write callback properties as inline function expressions, arrows, method shortha
 
 Closure values must be JSON-serializable. Plain objects, arrays, strings, finite numbers, booleans, and `null` are supported; `undefined` object properties are omitted. Functions, class instances, `Date`, `Map`, symbols, non-finite numbers, and cyclic values fail resolution with the tool name and callback phase instead of being serialized lossily.
 
-Call expressions such as `execute: makeExecutor()` are not transformed. Put the callback body directly in `defineTool()` inside an authored module; eve-provided factories may also supply pre-registered callbacks. eve rejects a dynamic tool if any present callback lacks durable metadata, and replay never reruns the current resolver to recover one.
+Call expressions such as `execute: makeExecutor()` are not transformed. Put the callback body directly in `defineTool()` inside an authored module; eve-provided factories may also supply pre-registered callbacks. eve rejects a dynamic tool if any present callback lacks durable metadata.
+
+### Identity and redeploys
+
+A parked call binds to its callback by **tool name and phase** — the same identity a static tool uses — never by source position. This gives dynamic tools static-tool semantics across deploys:
+
+- Editing a callback body (or anything else that does not change tool names) is safe: replaying a parked call runs the latest deployed code with the closure values snapshotted when the call was made.
+- If a persisted callback has no registered implementation (fresh process after a crash, or after a redeploy), eve re-runs `session.started` resolvers once to rebind it, then replays.
+- If the tool no longer exists under that name, replay fails closed with an explicit error instead of invoking something else. Turn-scoped and step-scoped tools are not rebound; a parked call to a missing one errors.
 
 ### Naming
 
@@ -189,7 +197,7 @@ A dynamic tool or skill whose name matches an **authored** one **overrides** it
 | `turn.started`    | Once per turn                                         | Every model call in the turn    |
 | `step.started`    | Before each model call                                | That model call                 |
 
-¹ Workflow recovery can redeliver a resolver event, so keep resolvers idempotent. Replaying a parked callback does not depend on running the resolver again.
+¹ Workflow recovery can redeliver a resolver event, so keep resolvers idempotent. Replaying a parked callback does not depend on running the resolver again — except for the one-shot rebind described under [Identity and redeploys](#identity-and-redeploys).
 
 ### Execution order
 

package/docs/guides/frontend/nextjs.mdx

@@ -90,6 +90,29 @@ const agent = useEveAgent({
 
 The browser still needs a production authentication policy. See [Authenticate browser requests](./overview#authenticate-browser-requests) for the default fail-closed behavior and channel configuration.
 
+## Use the generated Web Chat routes
+
+`eve init --channel-web-nextjs` and `eve add channel/web` generate a chat UI with URL-addressed durable sessions:
+
+- `/` is the initial landing page.
+- `/s` opens the conversation layout without creating an eve session. The first message creates the session.
+- `/s/[sessionId]` attaches to that durable session, replays its transcript, and follows an in-flight turn.
+
+After the first message is accepted, Web Chat replaces the browser URL with `/s/{sessionId}` without remounting the active stream. Reloading that URL passes the session to `useEveAgent` with `resume: true`, so completed history is replayed and an unfinished response continues streaming. **New chat** navigates to the sessionless `/s` route; it does not reset or delete the prior session, which remains available at its URL.
+
+The generated UI keeps transcript scroll position in browser `sessionStorage`. This is presentation state only and is not written to the eve session.
+
+For a custom Next.js chat route, pass the route session ID explicitly:
+
+```tsx
+const agent = useEveAgent({
+  initialSession: { sessionId, streamIndex: 0 },
+  resume: true,
+});
+```
+
+See [Resumable sessions](./overview#resumable-sessions) for persistence and replay semantics.
+
 ## Dev vs deploy topology
 
 - **Local dev.** `npm run dev` boots the eve dev server next to `next dev` and rewrites the eve routes over to it. The browser only ever talks to the Next.js origin.

package/docs/guides/frontend/overview.mdx

@@ -26,7 +26,7 @@ For a public demo, use `none()` from `eve/channels/auth` to admit anonymous requ
 
 ## Basic chat (React)
 
-The hook lives in `eve/react`. Render `data.messages`, gate the composer on `status`, and send text with `send`:
+The hook lives in `eve/react`. Render `data.messages`, use `status` to steer follow-ups during an active turn, and send text with `send`:
 
 ```tsx
 "use client";
@@ -44,7 +44,7 @@ export function Chat() {
         const form = new FormData(event.currentTarget);
         const message = String(form.get("message") ?? "").trim();
         if (message.length > 0) {
-          void agent.send(message);
+          void agent.send(message, isBusy ? { turnPolicy: "steer" } : undefined);
         }
       }}
     >
@@ -56,10 +56,8 @@ export function Chat() {
           )}
         </article>
       ))}
-      <input name="message" disabled={isBusy} />
-      <button disabled={isBusy} type="submit">
-        Send
-      </button>
+      <input name="message" />
+      <button type="submit">Send</button>
     </form>
   );
 }
@@ -78,6 +76,7 @@ export function Chat() {
 | `session` | Serializable fixed session cursor (`sessionId`, `streamIndex`).             |
 | `send`    | Send text or a multi-part message, with per-turn options.                   |
 | `respond` | Answer pending HITL input requests, with per-turn options.                  |
+| `resume`  | Replay an attached session and follow its in-flight turn.                   |
 | `cancel`  | Request durable cancellation of the active turn.                            |
 | `reset`   | Clear local events, data, errors, and the local session cursor.             |
 
@@ -105,7 +104,13 @@ await agent.send([
 ]);
 ```
 
-Assistant text, reasoning, tool calls, and tool results stream into `data` as they arrive, and `status` moves from `ready` to `submitted` to `streaming` and back. Call `cancel()` to stop the durable server-side turn, and `reset()` to clear local state so the next send starts a fresh durable session.
+Assistant text, reasoning, tool calls, and tool results stream into `data` as they arrive, and `status` moves from `ready` to `submitted` to `streaming` and back. To replace an active turn with a follow-up, send the message with `turnPolicy: "steer"`. eve accepts the message through the durable session, cancels the active turn, and keeps the hook attached through the replacement turn:
+
+```tsx
+await agent.send(message, { turnPolicy: "steer" });
+```
+
+Other message sends and HITL responses reject while the hook is processing a turn. Call `cancel()` to stop the durable server-side turn without replacing it, and `reset()` to clear local state so the next send starts a fresh durable session.
 
 `cancel()` can be called as soon as `status` is `"submitted"`; the hook waits for the active response to identify its turn when necessary, sends one guarded cancellation request, and keeps the event stream attached. The promise resolves when eve accepts the request or reports that no turn is active, and rejects if the cancellation request fails. The turn then settles on the same stream as `turn.cancelled` followed by `session.waiting`, so the session is safe to continue.
 
@@ -275,6 +280,7 @@ const [saved] = useState<SavedEveChat>(() => {
 const agent = useEveAgent({
   initialEvents: saved.events ?? [],
   initialSession: saved.session,
+  resume: saved.session !== undefined,
   onFinish(snapshot) {
     localStorage.setItem(
       "eve-chat",
@@ -295,9 +301,18 @@ then save a final snapshot in `onFinish`.
 
 `initialEvents` must be an ordered prefix of the same session's stream, but its endpoint does not have to line up exactly with where the stream resumes. Every event carries a stable [`meta.id`](/docs/concepts/sessions-runs-and-streaming#the-event-envelope), and the store drops any event whose id it has already applied — so a saved log that overlaps the replayed prefix renders once, and `onEvent` only fires for events your UI has not seen.
 
-For multiple chat threads, keep one saved event log and session cursor per thread. `agent`, `host`, `reducer`, `session`, `initialEvents`, `initialSession`, `auth`, `headers`, and `optimistic` are read when the hook creates its store, so remount the chat component when switching threads, for example with `key={chat.id}`.
+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. If the stream ends at an in-flight turn, the binding stays attached until that turn reaches its boundary. If the stream already ends at a settled session boundary, replay stops at the history tail.
+
+```tsx
+const agent = useEveAgent({
+  initialSession: { sessionId, streamIndex: 0 },
+  resume: true,
+});
+```
 
-If the user can refresh or navigate immediately after pressing send, create your app-level chat row and store the pending user message before calling `send()`. After the request starts, persist the session state as soon as it contains a `sessionId`, then reconnect an interrupted in-flight turn with `session.stream({ startIndex: savedEvents.length })` from the lower-level client.
+If the user can refresh or navigate immediately after pressing send, create your app-level chat row before calling `send()`, then persist the session ID from `onSessionChange`. This lets the reloaded UI mount with that ID and pass `resume: true` while the durable turn is still running.
 
 ## Custom hosts and headers
 

package/docs/guides/frontend/use-eve-agent-svelte.mdx

@@ -44,14 +44,14 @@ Call the binding once for a conversation and read its reactive getters directly.
 
 The state fields are reactive getters; the commands are ordinary methods:
 
-| Property                             | Svelte shape                      |
-| ------------------------------------ | --------------------------------- |
-| `data`                               | `TData`                           |
-| `status`                             | `UseEveAgentStatus`               |
-| `error`                              | `Error \| undefined`              |
-| `events`                             | `readonly MessageStreamEvent[]`   |
-| `session`                            | `ClientSessionState \| undefined` |
-| `send`, `respond`, `cancel`, `reset` | Methods                           |
+| Property                                       | Svelte shape                      |
+| ---------------------------------------------- | --------------------------------- |
+| `data`                                         | `TData`                           |
+| `status`                                       | `UseEveAgentStatus`               |
+| `error`                                        | `Error \| undefined`              |
+| `events`                                       | `readonly MessageStreamEvent[]`   |
+| `session`                                      | `ClientSessionState \| undefined` |
+| `send`, `respond`, `resume`, `cancel`, `reset` | Methods                           |
 
 Read the getters directly in templates, `$derived`, or `$effect`. The [shared returned-state reference](./overview#returned-state) describes what each value and command does.
 
@@ -106,7 +106,7 @@ See [Human-in-the-loop prompts](./overview#human-in-the-loop-prompts) for reques
 
 ## Cancel, reset, and resume
 
-Call `agent.cancel()` to stop the durable server-side turn while the binding remains attached through settlement. Destroying the component only disconnects its local stream; it does not cancel server execution. Call `agent.reset()` to clear local state and start a new session. Pass `initialSession` and `initialEvents` to restore a saved conversation. See [Resumable sessions](./overview#resumable-sessions) for the persistence contract and [Sending and streaming](./overview#sending-and-streaming) for cancellation behavior.
+Call `agent.cancel()` to stop the durable server-side turn while the binding remains attached through settlement. Destroying the component only disconnects its local stream; it does not cancel server execution. Call `agent.reset()` to clear local state and start a new session. Pass `initialSession`, `initialEvents`, and `resume: true` to restore a saved conversation and follow an in-flight turn. Use `agent.resume()` directly when restoration is controlled imperatively. See [Resumable sessions](./overview#resumable-sessions) for the persistence contract and [Sending and streaming](./overview#sending-and-streaming) for cancellation behavior.
 
 ## Custom host and credentials
 

package/docs/guides/frontend/use-eve-agent-vue.mdx

@@ -43,14 +43,14 @@ async function handleSubmit() {
 
 The state fields are computed refs; the commands are ordinary methods:
 
-| Property                             | Vue shape                                      |
-| ------------------------------------ | ---------------------------------------------- |
-| `data`                               | `ComputedRef<TData>`                           |
-| `status`                             | `ComputedRef<UseEveAgentStatus>`               |
-| `error`                              | `ComputedRef<Error \| undefined>`              |
-| `events`                             | `ComputedRef<readonly MessageStreamEvent[]>`   |
-| `session`                            | `ComputedRef<ClientSessionState \| undefined>` |
-| `send`, `respond`, `cancel`, `reset` | Methods                                        |
+| Property                                       | Vue shape                                      |
+| ---------------------------------------------- | ---------------------------------------------- |
+| `data`                                         | `ComputedRef<TData>`                           |
+| `status`                                       | `ComputedRef<UseEveAgentStatus>`               |
+| `error`                                        | `ComputedRef<Error \| undefined>`              |
+| `events`                                       | `ComputedRef<readonly MessageStreamEvent[]>`   |
+| `session`                                      | `ComputedRef<ClientSessionState \| undefined>` |
+| `send`, `respond`, `resume`, `cancel`, `reset` | Methods                                        |
 
 Destructuring preserves reactivity because each state value remains a ref. Read refs with `.value` in `<script>` and without `.value` in a template. The [shared returned-state reference](./overview#returned-state) describes what each value and command does.
 
@@ -108,7 +108,7 @@ See [Human-in-the-loop prompts](./overview#human-in-the-loop-prompts) for reques
 
 ## Cancel, reset, and resume
 
-Call `cancel()` to stop the durable server-side turn while the composable remains attached through settlement. Disposing the component only disconnects its local stream; it does not cancel server execution. Call `reset()` to clear local state and start a new session. Pass `initialSession` and `initialEvents` to restore a saved conversation. See [Resumable sessions](./overview#resumable-sessions) for the persistence contract and [Sending and streaming](./overview#sending-and-streaming) for cancellation behavior.
+Call `cancel()` to stop the durable server-side turn while the composable remains attached through settlement. Disposing the component only disconnects its local stream; it does not cancel server execution. Call `reset()` to clear local state and start a new session. Pass `initialSession`, `initialEvents`, and `resume: true` to restore a saved conversation and follow an in-flight turn. Use `resume()` directly when restoration is controlled imperatively. See [Resumable sessions](./overview#resumable-sessions) for the persistence contract and [Sending and streaming](./overview#sending-and-streaming) for cancellation behavior.
 
 ## Custom host and credentials
 

package/docs/tools/overview.mdx

@@ -70,10 +70,11 @@ progress with `task.send({ kind: "update", message })` and the terminal result w
 in-memory callback dies with the process — so the cross-process executor wire remains
 framework-owned and is not yet a stable authored-tool API.
 
-Each task-triggered parent turn includes runtime-authored state for tasks started by the same
-parent turn. The model is instructed to keep related intermediate results silent while that state
-contains pending tasks. Once every related task is terminal, the state includes their outputs so
-the model can combine the useful results.
+After the initiating turn accepts background tasks, eve supplies runtime-authored state for that
+cohort and instructs the model to acknowledge that the work started without waiting for results.
+Later task-triggered parent turns receive fresh state for the same cohort. The model is instructed
+to keep related intermediate results silent while any task remains pending. Once every related
+task is terminal, the state includes their outputs so the model can combine the useful results.
 
 ### The `ctx` parameter
 

package/package.json

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