eve 0.43.0 → 0.44.1

package/dist/src/tracing/otel-declaration.d.ts

@@ -3,6 +3,10 @@ import { type InstrumentationProvider } from "#public/instrumentation/provider.j
 import type { InstrumentationRuntimeContextInput } from "#public/instrumentation/index.js";
 import type { JsonObject } from "#shared/json.js";
 import type { ResolvedContentOptions } from "#tracing/content-attributes.js";
+import type { ChannelAudience } from "#shared/channel-audience.js";
+import { type SpanExportPolicy } from "#tracing/span-export-policy.js";
+export type { SpanAttributeDecision, SpanExportAttributeValue, SpanExportContext, SpanExportPolicy, SpanExportPredicate, } from "#tracing/span-export-policy.js";
+export { composeSpanExportPolicies, redactSpanInputs, redactSpanOutputs, } from "#tracing/span-export-policy.js";
 /**
  * The process-wide OpenTelemetry settings, declared by `otel()`.
  *
@@ -28,6 +32,11 @@ export interface OtelOptions {
      * outgoing HTTP spans. Defaults to `false`.
      */
     readonly traceChannelRequests?: boolean;
+    /**
+     * Process-wide head gate for an agent session trace. Defaults to retaining
+     * only public conversations. A thrown error rejects the trace.
+     */
+    readonly tracePolicy?: TraceCapturePolicy;
     /**
      * Resource attributes merged into eve's own, which already carry the
      * service name.
@@ -52,22 +61,27 @@ export interface OtelOptions {
      */
     readonly instrumentations?: readonly unknown[];
 }
-/**
- * What one destination records of the conversation itself.
- *
- * Declining is per destination, not per process: content is written onto the
- * span if any destination wants it, and one that declined never exports it. So
- * an agent whose every destination declines still never materializes a prompt —
- * the union of nothing is nothing — but a local spool and a hosted backend no
- * longer have to agree.
- */
+export interface ManagedTraceOptions {
+    /** Destination policy applied before spans are exported. */
+    readonly exportPolicy?: SpanExportPolicy;
+    /** @deprecated Use `exportPolicy: redactSpanInputs()` instead. */
+    readonly recordInputs?: boolean;
+    /** @deprecated Use `exportPolicy: redactSpanOutputs()` instead. */
+    readonly recordOutputs?: boolean;
+}
+/** @deprecated Compose `redactSpanInputs()` and `redactSpanOutputs()` into an export policy. */
 export interface ContentOptions {
-    /** Record model prompts and tool call inputs. Defaults to `false`. */
     readonly recordInputs?: boolean;
-    /** Record model responses and tool call outputs. Defaults to `false`. */
     readonly recordOutputs?: boolean;
 }
-/** Where one `otelIntegration()` sends spans, and what it records. */
+export interface TraceCaptureContext {
+    readonly agentName?: string;
+    readonly audience: ChannelAudience;
+    readonly rootSessionId: string;
+    readonly sessionId: string;
+}
+export type TraceCapturePolicy = (trace: TraceCaptureContext) => boolean;
+/** Where one `otelIntegration()` sends spans. */
 export interface OtelIntegrationOptions extends ContentOptions {
     /** Merged into the pipeline in declaration order. */
     readonly spanProcessors?: readonly SpanProcessor[];
@@ -98,7 +112,7 @@ export interface OtelDeclaration extends InstrumentationProvider {
 /** One declared destination. A process may have as many as it has files. */
 export interface OtelIntegration extends InstrumentationProvider {
     readonly [OTEL_INTEGRATION]: true;
-    /** Resolved from `ContentOptions`, so the union does not re-apply defaults. */
+    /** @deprecated Content is captured upstream and redacted by destination policies. */
     readonly content: ResolvedContentOptions;
     readonly runtimeContext?: (input: InstrumentationRuntimeContextInput) => JsonObject | undefined;
     readonly spanProcessors: readonly SpanProcessorOrName[];
@@ -118,13 +132,14 @@ export declare function otel(options?: OtelOptions): OtelDeclaration;
  * the one-line form of a hosted backend enough. Pass `spanProcessors` instead
  * when the destination needs its own batching, sampling, or filtering.
  *
- * Declining content wraps every processor here, an author's included: they are
- * this destination, and the point of declining is that nothing under it sees
- * what was said.
+ * The export policy wraps every processor here, an author's included: they are
+ * this destination, and nothing beneath the policy sees what it removes.
  */
 export declare function otelIntegration(options?: OtelIntegrationOptions): OtelIntegration;
+/** @internal Local and Agent Runs destination declaration. */
+export declare function managedOtelIntegration(options?: OtelIntegrationOptions & ManagedTraceOptions): OtelIntegration;
 /** Vercel Agent Runs through the production request-context transport. @internal */
-export declare function agentRunsIntegration(options?: ContentOptions): OtelIntegration;
+export declare function agentRunsIntegration(options?: ManagedTraceOptions): OtelIntegration;
 export declare function resolveContentOptions(options: ContentOptions): ResolvedContentOptions;
 export declare function isOtelDeclaration(value: unknown): value is OtelDeclaration;
 export declare function isOtelIntegration(value: unknown): value is OtelIntegration;
@@ -140,11 +155,8 @@ export interface OtelPipeline {
 export interface OtelHarnessSettings {
     readonly functionId?: string;
     readonly traceChannelRequests: boolean;
-    /**
-     * What to write onto a span at all, as opposed to what any one destination
-     * exports. `agent/instrumentation.ts` sets this directly; a provider
-     * directory arrives at it as the union of its destinations.
-     */
+    readonly tracePolicy?: TraceCapturePolicy;
+    /** Legacy `defineInstrumentation()` capture settings. Provider destinations capture fully. */
     readonly recordInputs?: boolean;
     readonly recordOutputs?: boolean;
 }
@@ -169,11 +181,6 @@ export interface CollectedOtel {
  * happened to visit first. With one declaration per file that collision needs
  * two files both exporting `otel()`, which is the only way to reach it.
  *
- * Content capture is the union of what the destinations asked for, because it
- * governs what is written rather than what is exported. Each destination's own
- * processors already drop what it declined.
- *
  * @internal
  */
 export declare function collectOtelPipeline(values: readonly unknown[]): CollectedOtel;
-export {};

package/dist/src/tracing/otel-declaration.js

@@ -1 +1 @@
-import{PROVIDER}from"#public/instrumentation/provider.js";import{batchSpanProcessor}from"#tracing/batch-span-processor.js";import{contentFilteringProcessor}from"#tracing/content-span-processor.js";import{vercelRuntimeSpanProcessor}from"#tracing/vercel-runtime-span-exporter.js";const OTEL_DECLARATION=Symbol.for(`eve.instrumentation.otel`),OTEL_INTEGRATION=Symbol.for(`eve.instrumentation.otel-integration`);function otel(t={}){return{[OTEL_DECLARATION]:!0,[PROVIDER]:!0,options:t}}function otelIntegration(r={}){let i={recordInputs:r.recordInputs===!0,recordOutputs:r.recordOutputs===!0},o=r.spanProcessors??[],s=r.traceExporter===void 0?o:[...o,batchSpanProcessor(r.traceExporter)];return{[OTEL_INTEGRATION]:!0,[PROVIDER]:!0,content:i,runtimeContext:r.runtimeContext,spanProcessors:i.recordInputs&&i.recordOutputs?s:s.map(e=>contentFilteringProcessor(e,i))}}function agentRunsIntegration(t={}){let i=resolveContentOptions(t);return{[OTEL_INTEGRATION]:!0,[PROVIDER]:!0,content:i,spanProcessors:i.recordInputs&&i.recordOutputs?[`auto`]:[contentFilteringProcessor(vercelRuntimeSpanProcessor(),i)]}}function resolveContentOptions(e){return{recordInputs:e.recordInputs===!0,recordOutputs:e.recordOutputs===!0}}function isOtelDeclaration(e){return typeof e==`object`&&!!e&&e[OTEL_DECLARATION]===!0}function isOtelIntegration(e){return typeof e==`object`&&!!e&&e[OTEL_INTEGRATION]===!0}function collectOtelPipeline(e){let t=[],n=[],r,i=!1,a=!1,o=!1;for(let s of e){if(isOtelIntegration(s)){i=!0,a||=s.content.recordInputs,o||=s.content.recordOutputs,t.push(...s.spanProcessors),s.runtimeContext!==void 0&&n.push(s.runtimeContext);continue}if(isOtelDeclaration(s)){if(r!==void 0)throw Error("Instrumentation declares `otel()` more than once. One process has one OpenTelemetry tracer provider, so it has one resource, one sampler, and one propagator set — declare them in a single `otel()`.");i=!0,r=s}}let s=r?.options??{};return{declared:i,pipeline:{instrumentations:s.instrumentations,propagators:s.propagators,resource:s.resource,sampler:s.sampler,spanProcessors:t},runtimeContextResolvers:n,settings:{functionId:s.functionId,recordInputs:a,recordOutputs:o,traceChannelRequests:s.traceChannelRequests===!0}}}export{agentRunsIntegration,collectOtelPipeline,isOtelDeclaration,isOtelIntegration,otel,otelIntegration,resolveContentOptions};
+import{PROVIDER}from"#public/instrumentation/provider.js";import{composeSpanExportPolicies,composeSpanExportPolicies as composeSpanExportPolicies$1,redactSpanInputs,redactSpanInputs as redactSpanInputs$1,redactSpanOutputs,redactSpanOutputs as redactSpanOutputs$1}from"#tracing/span-export-policy.js";import{batchSpanProcessor}from"#tracing/batch-span-processor.js";import{contentFilteringProcessor}from"#tracing/content-span-processor.js";import{vercelRuntimeSpanProcessor}from"#tracing/vercel-runtime-span-exporter.js";const OTEL_DECLARATION=Symbol.for(`eve.instrumentation.otel`),OTEL_INTEGRATION=Symbol.for(`eve.instrumentation.otel-integration`);function otel(t={}){return{[OTEL_DECLARATION]:!0,[PROVIDER]:!0,options:t}}function otelIntegration(e={}){return createOtelIntegration(e)}function managedOtelIntegration(e={}){return createOtelIntegration(e,e.exportPolicy)}function createOtelIntegration(t,n){let r=t.spanProcessors??[],i=t.traceExporter===void 0?r:[...r,batchSpanProcessor(t.traceExporter)];return{[OTEL_INTEGRATION]:!0,[PROVIDER]:!0,content:resolveContentOptions(t),runtimeContext:t.runtimeContext,spanProcessors:i.map(e=>withExportPolicies(e,legacyContentRedactionPolicy(t),n))}}function agentRunsIntegration(t={}){return{[OTEL_INTEGRATION]:!0,[PROVIDER]:!0,content:resolveContentOptions(t),spanProcessors:[withExportPolicies(vercelRuntimeSpanProcessor(),legacyContentRedactionPolicy(t),t.exportPolicy)]}}function legacyContentRedactionPolicy(e){let t=[];return e.recordInputs===!1&&t.push(redactSpanInputs$1()),e.recordOutputs===!1&&t.push(redactSpanOutputs$1()),t.length===0?void 0:composeSpanExportPolicies$1(...t)}function resolveContentOptions(e){return{recordInputs:e.recordInputs!==!1,recordOutputs:e.recordOutputs!==!1}}function withExportPolicies(e,...t){let n=e;for(let e of t.toReversed())n=contentFilteringProcessor(n,e);return n}function isOtelDeclaration(e){return typeof e==`object`&&!!e&&e[OTEL_DECLARATION]===!0}function isOtelIntegration(e){return typeof e==`object`&&!!e&&e[OTEL_INTEGRATION]===!0}function collectOtelPipeline(e){let t=[],n=[],r,i=!1,a=!1;for(let o of e){if(isOtelIntegration(o)){i=!0,a=!0,t.push(...o.spanProcessors),o.runtimeContext!==void 0&&n.push(o.runtimeContext);continue}if(isOtelDeclaration(o)){if(r!==void 0)throw Error("Instrumentation declares `otel()` more than once. One process has one OpenTelemetry tracer provider, so it has one resource, one sampler, and one propagator set — declare them in a single `otel()`.");i=!0,r=o}}let o=r?.options??{},s={functionId:o.functionId,recordInputs:a,recordOutputs:a,traceChannelRequests:o.traceChannelRequests===!0};return o.tracePolicy!==void 0&&Object.assign(s,{tracePolicy:o.tracePolicy}),{declared:i,pipeline:{instrumentations:o.instrumentations,propagators:o.propagators,resource:o.resource,sampler:o.sampler,spanProcessors:t},runtimeContextResolvers:n,settings:s}}export{agentRunsIntegration,collectOtelPipeline,composeSpanExportPolicies,isOtelDeclaration,isOtelIntegration,managedOtelIntegration,otel,otelIntegration,redactSpanInputs,redactSpanOutputs,resolveContentOptions};

package/dist/src/tracing/sampled-trace.d.ts

@@ -0,0 +1,2 @@
+import { type SpanContext } from "#compiled/@opentelemetry/api/index.js";
+export declare function isSampledTrace(context: Pick<SpanContext, "traceFlags">): boolean;

package/dist/src/tracing/sampled-trace.js

@@ -0,0 +1 @@
+import{TraceFlags}from"#compiled/@opentelemetry/api/index.js";function isSampledTrace(e){return(e.traceFlags&TraceFlags.SAMPLED)===TraceFlags.SAMPLED}export{isSampledTrace};

package/dist/src/tracing/span-export-policy.d.ts

@@ -0,0 +1,41 @@
+import type { ChannelAudience } from "#shared/channel-audience.js";
+export interface SpanExportContext {
+    readonly attributes: Readonly<Record<string, unknown>>;
+    readonly audience: ChannelAudience;
+    readonly name: string;
+    readonly spanId: string;
+    readonly traceId: string;
+}
+export type SpanExportPredicate = (span: SpanExportContext) => boolean;
+export type SpanExportAttributeValue = string | number | boolean | readonly string[] | readonly number[] | readonly boolean[];
+export type SpanAttributeDecision = {
+    readonly action: "keep";
+} | {
+    readonly action: "drop";
+} | {
+    readonly action: "replace";
+    readonly value: SpanExportAttributeValue;
+};
+export interface SpanExportPolicy {
+    /** Return false to block one span without blocking its trace. */
+    readonly span?: SpanExportPredicate;
+    /** Drop or replace individual span attributes after content filtering. */
+    readonly attribute?: (input: {
+        readonly key: string;
+        readonly span: SpanExportContext;
+        readonly value: unknown;
+    }) => SpanAttributeDecision;
+}
+/** Redact input content from every matching span. */
+export declare function redactSpanInputs(when?: SpanExportPredicate): SpanExportPolicy;
+/** Redact output content, exception details, and status messages from every matching span. */
+export declare function redactSpanOutputs(when?: SpanExportPredicate): SpanExportPolicy;
+/** Compose policies in declaration order. A drop or redaction from any policy is final. */
+export declare function composeSpanExportPolicies(...policies: readonly SpanExportPolicy[]): SpanExportPolicy;
+/** @internal */
+export declare function spanExportPolicyStages(policy: SpanExportPolicy): readonly SpanExportPolicy[];
+/** @internal */
+export declare function contentRedactionForSpan(policy: SpanExportPolicy | undefined, span: SpanExportContext): {
+    readonly redactInputs: boolean;
+    readonly redactOutputs: boolean;
+};

package/dist/src/tracing/span-export-policy.js

@@ -0,0 +1 @@
+const contentRedactions=new WeakMap,composedPolicies=new WeakMap;function redactSpanInputs(t=()=>!0){let n={};return contentRedactions.set(n,{inputs:[t],outputs:[]}),n}function redactSpanOutputs(t=()=>!0){let n={};return contentRedactions.set(n,{inputs:[],outputs:[t]}),n}function composeSpanExportPolicies(...e){if(e.length===0)return{};if(e.length===1)return e[0];let n={};return composedPolicies.set(n,e.flatMap(spanExportPolicyStages)),n}function spanExportPolicyStages(e){return composedPolicies.get(e)??[e]}function contentRedactionForSpan(t,n){let r=t===void 0?void 0:contentRedactions.get(t);return{redactInputs:r?.inputs.some(e=>matches(e,n))??!1,redactOutputs:r?.outputs.some(e=>matches(e,n))??!1}}function matches(e,t){try{return e(t)}catch{return!0}}export{composeSpanExportPolicies,contentRedactionForSpan,redactSpanInputs,redactSpanOutputs,spanExportPolicyStages};

package/dist/src/tracing/suppress-tracing.d.ts

@@ -0,0 +1,2 @@
+import { type Context } from "#compiled/@opentelemetry/api/index.js";
+export declare function suppressTracing(context: Context): Context;

package/dist/src/tracing/suppress-tracing.js

@@ -0,0 +1 @@
+import{createContextKey}from"#compiled/@opentelemetry/api/index.js";const SUPPRESS_TRACING_KEY=createContextKey(`OpenTelemetry SDK Context Key SUPPRESS_TRACING`);function suppressTracing(e){return e.setValue(SUPPRESS_TRACING_KEY,!0)}export{suppressTracing};

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/channels/custom.mdx

@@ -306,6 +306,8 @@ export default defineChannel({
 
 The projection is re-evaluated whenever adapter state changes after channel event handlers run. Dynamic tool resolvers read it via `ctx.channel.metadata` and narrow it with `isChannel`. See [Dynamic capabilities](../guides/dynamic-capabilities) for the full consumption pattern.
 
+Metadata may include an `audience` classification: `public`, `private`, or `unknown`. Omit it when the channel cannot classify the conversation confidently; eve normalizes missing and invalid values to `unknown`. Consumers must treat `unknown` as non-public.
+
 When a parent agent dispatches a subagent, the framework forwards the parent's channel metadata projection to the child. The same `metadata(state)` projector also serves instrumentation metadata resolvers.
 
 ## Continuation tokens

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/guides/instrumentation.md

@@ -58,6 +58,8 @@ You are responsible for ensuring any observability or eval provider is approved
 
 The third configurable surface, [runtime context events](#runtime-context), attaches per-model-call values to these spans.
 
+Built-in messaging channels classify their instrumentation metadata with an `audience`: `public`, `private`, or `unknown`. Slack public channels and Chat SDK workspace-visible threads are public; direct and private conversations are private; platform surfaces without enough visibility evidence remain unknown.
+
 ## Channel delivery traces
 
 Instrumentation providers receive `channel.delivery.started` followed by

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/docs/tutorial/ship-it.mdx

@@ -73,7 +73,7 @@ export default function Page() {
 }
 ```
 
-`agent.data.messages` and `agent.status` cover most chat UIs. The hook also surfaces HITL prompts (the spend approval from [Step 8](./guard-the-spend)), so the dashboard can render approve/cancel controls. For the full API, see [Frontend](../guides/frontend/overview).
+`agent.data.messages` and `agent.status` cover most chat UIs. The generated Web Chat renders HITL prompts directly in the conversation: approvals get action controls, and `ask_question` gets a visible form with vertical choices, a text field, or both. The spend approval from [Step 8](./guard-the-spend) uses the same response path. For the full API, see [Frontend](../guides/frontend/overview).
 
 ## Replace `placeholderAuth`
 

package/package.json

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