eve 0.83.3 → 0.84.1

package/dist/src/harness/session-machine/current.d.ts

@@ -1,9 +1,15 @@
 import type { ContextReader } from "#context/key.js";
-import { type TokenUsageDelta } from "#harness/turn-tag-state.js";
-import type { HarnessSessionBase, SessionStateMap } from "#harness/types.js";
+import type { HarnessSessionBase, SessionPublication, SessionStateMap } from "#harness/types.js";
 import { type SessionProjection } from "#protocol/session-projection.js";
-import type { MessageStreamEvent, UnstampedMessageStreamEvent } from "#protocol/message.js";
+import type { SessionEvent } from "#protocol/session-event.js";
+import type { StoredLine } from "#protocol/session-events/envelope.js";
+import type { SessionView as PublicSessionView } from "#protocol/session-projection/tables.js";
 export declare function enterSessionProjection(ctx: ContextReader, state: SessionStateMap | undefined): void;
+/**
+ * Enters a checkpointed projection directly, for a step that publishes without the session's
+ * state, as the session's end does.
+ */
+export declare function enterSessionProjectionAt(ctx: ContextReader, projection: SessionProjection | undefined): void;
 /** Enters the stored projection unless this step already did. */
 export declare function ensureSessionProjection(ctx: ContextReader, state: SessionStateMap | undefined): void;
 /**
@@ -15,29 +21,31 @@ export declare function liveProjection(ctx?: ContextReader | undefined): Session
 export declare function currentProjection(ctx?: ContextReader | undefined): SessionProjection;
 /** The step's live projection, or the session's stored one when no step entered it. */
 export declare function projectionFor(ctx: ContextReader, state: SessionStateMap | undefined): SessionProjection;
-export declare function recordPublishedEvent(ctx: ContextReader, event: MessageStreamEvent | UnstampedMessageStreamEvent): void;
+/** The position of the next line the step writes. */
+export declare function nextLinePosition(ctx: ContextReader): number;
+/**
+ * Records that the step wrote one line at `position`: its commit folds into the public view, and
+ * its events into what the view can't hold.
+ */
+export declare function recordPublishedLine(ctx: ContextReader, line: StoredLine, position: number, events: readonly SessionEvent[]): void;
+/** The public view as of the last line the step wrote, if a step entered its projection. */
+export declare function enteredView(ctx: ContextReader): PublicSessionView | undefined;
+/** The projection after one line: its view, then what the view can't hold. */
+export declare function advance(projection: SessionProjection, line: StoredLine, position: number, events: readonly SessionEvent[]): SessionProjection;
+/** The public view as of the last line the step wrote. */
+export declare function currentView(ctx?: ContextReader | undefined): PublicSessionView;
 /** Records the session a transition the step published produced. */
 export declare function recordAppliedSession(ctx: ContextReader, session: HarnessSessionBase): void;
 /** The session the step's last applied transition produced, if it applied any. */
 export declare function appliedSession<T extends HarnessSessionBase>(ctx: ContextReader): T | undefined;
-/**
- * Counts a model call's usage on `session` and on the session the step last applied. The provider
- * already served the call, so a hook that cancels the turn before the step applies again keeps it.
- */
-export declare function addStepUsage<T extends {
-    readonly state?: SessionStateMap;
-}>(session: T, turnId: string, usage: TokenUsageDelta | undefined): T;
 export declare function saveSessionProjection<T extends HarnessSessionBase>(session: T, ctx: ContextReader): T;
-/**
- * The session saves the lifecycle its steps read. Calls and tasks are for the stream's readers,
- * which fold them from the events, and their outputs can be large, so the checkpoint omits them.
- */
+/** The session saves the coordinates and public view its steps read. */
 export declare function saveProjection<T extends HarnessSessionBase>(session: T, projection: SessionProjection): T;
 /** The projection one step reads and folds what it publishes into. */
 export interface StepProjection {
     read(): SessionProjection;
-    /** Folds an event no publish sink folded: the step runs without one. */
-    record(event: UnstampedMessageStreamEvent): void;
+    /** Folds a publication no sink folded, preserving its commit boundaries. */
+    record(publication: SessionPublication): void;
 }
 /**
  * A step's projection: the context's live one, which the publish sink folds, or, for a step

package/dist/src/harness/session-machine/current.js

@@ -1 +1 @@
-import{SESSION_PROJECTION_STATE_KEY,storedProjection}from"./view.js";import{foldSession,pruneSessionProjection}from"#protocol/session-projection.js";import{contextStorage}from"#context/container.js";import{addTurnUsage}from"#harness/turn-tag-state.js";const LIVE_PROJECTIONS_GLOBAL_KEY=Symbol.for(`eve.live-session-projections`),liveProjections=globalThis[LIVE_PROJECTIONS_GLOBAL_KEY]??=new WeakMap;function enterSessionProjection(e,t){liveProjections.set(e,{projection:storedProjection(t)})}function ensureSessionProjection(e,t){liveProjections.has(e)||enterSessionProjection(e,t)}function liveProjection(e=contextStorage.getStore()){return e===void 0?void 0:liveProjections.get(e)?.projection}function currentProjection(e=contextStorage.getStore()){let t=e===void 0?void 0:liveProjections.get(e);if(t===void 0)throw Error(`Session lifecycle requires an initialized projection.`);return t.projection}function projectionFor(e,t){return liveProjections.get(e)?.projection??storedProjection(t)}function recordPublishedEvent(e,t){let n=liveProjections.get(e);if(n===void 0)throw Error(`Session publication requires an initialized projection.`);let r=foldSession(n.projection,t);n.projection=t.type===`session.waiting`?pruneSessionProjection(r):r}const appliedSessions=new WeakMap;function recordAppliedSession(e,t){appliedSessions.set(e,t)}function appliedSession(e){return appliedSessions.get(e)}function addStepUsage(e,t,n){let r=contextStorage.getStore(),i=r===void 0?void 0:appliedSessions.get(r);return r!==void 0&&i!==void 0&&appliedSessions.set(r,addTurnUsage(i,t,n)),addTurnUsage(e,t,n)}function saveSessionProjection(e,t){return saveProjection(e,currentProjection(t))}function saveProjection(e,t){let n={...t,calls:{},tasks:{}};return{...e,state:{...e.state,[SESSION_PROJECTION_STATE_KEY]:n}}}function stepProjection(e,t){if(e!==void 0)return ensureSessionProjection(e,t),{read:()=>currentProjection(e),record:t=>recordPublishedEvent(e,t)};let n=storedProjection(t);return{read:()=>n,record(e){let t=foldSession(n,e);n=e.type===`session.waiting`?pruneSessionProjection(t):t}}}export{addStepUsage,appliedSession,currentProjection,ensureSessionProjection,enterSessionProjection,liveProjection,projectionFor,recordAppliedSession,recordPublishedEvent,saveProjection,saveSessionProjection,stepProjection};
+import{SESSION_PROJECTION_STATE_KEY,storedProjection}from"./view.js";import{copyView,foldLine}from"#protocol/session-projection/fold.js";import{contextStorage}from"#context/container.js";import{linesOf}from"#protocol/session-lines.js";import{foldSession}from"#protocol/session-projection.js";import{cascade}from"#harness/session-machine/cascade.js";import{eventsOf}from"#harness/publication.js";const LIVE_PROJECTIONS_GLOBAL_KEY=Symbol.for(`eve.live-session-projections`),liveProjections=globalThis[LIVE_PROJECTIONS_GLOBAL_KEY]??=new WeakMap;function enterSessionProjection(e,t){liveProjections.set(e,{projection:storedProjection(t)})}function enterSessionProjectionAt(e,t){liveProjections.set(e,{projection:t??storedProjection(void 0)})}function ensureSessionProjection(e,t){liveProjections.has(e)||enterSessionProjection(e,t)}function liveProjection(e=contextStorage.getStore()){return e===void 0?void 0:liveProjections.get(e)?.projection}function currentProjection(e=contextStorage.getStore()){let t=e===void 0?void 0:liveProjections.get(e);if(t===void 0)throw Error(`Session lifecycle requires an initialized projection.`);return t.projection}function projectionFor(e,t){return liveProjections.get(e)?.projection??storedProjection(t)}function nextLinePosition(e){return currentProjection(e).view.position}function recordPublishedLine(e,t,n,r){let i=liveProjections.get(e);if(i===void 0)throw Error(`Session publication requires an initialized projection.`);i.projection=advance(i.projection,t,n,r)}function advanceView(e,t,n){if(!(`facts`in t))return{...e,position:Math.max(e.position,n+1)};let r=copyView(e);return foldLine(r,t,n,{retention:`operational`}),r}function enteredView(e){return liveProjections.get(e)?.projection.view}function advance(e,t,n,r){return n<e.view.position?e:foldSession({...e,view:advanceView(e.view,t,n)},r)}function currentView(e=contextStorage.getStore()){return currentProjection(e).view}const appliedSessions=new WeakMap;function recordAppliedSession(e,t){appliedSessions.set(e,t)}function appliedSession(e){return appliedSessions.get(e)}function saveSessionProjection(e,t){return saveProjection(e,currentProjection(t))}function saveProjection(e,t){return{...e,state:{...e.state,[SESSION_PROJECTION_STATE_KEY]:t}}}function stepProjection(e,t){if(e!==void 0)return ensureSessionProjection(e,t),{read:()=>currentProjection(e),record:t=>{let n=cascade(currentProjection(e).view,eventsOf(t));for(let t of linesOf(n,new Date().toISOString())){let n=`facts`in t?t.facts:[t.progress];recordPublishedLine(e,t,nextLinePosition(e),n)}}};let n=storedProjection(t);return{read:()=>n,record(e){let t=cascade(n.view,eventsOf(e));for(let e of linesOf(t,new Date().toISOString())){let t=`facts`in e?e.facts:[e.progress];n=advance(n,e,n.view.position,t)}}}}export{advance,appliedSession,currentProjection,currentView,ensureSessionProjection,enterSessionProjection,enterSessionProjectionAt,enteredView,liveProjection,nextLinePosition,projectionFor,recordAppliedSession,recordPublishedLine,saveProjection,saveSessionProjection,stepProjection};

package/dist/src/harness/session-machine/state.d.ts

@@ -1,23 +1,46 @@
 import type { ModelMessage } from "ai";
+import type { RememberedApproval, RememberRequest } from "#approval/evaluation.js";
 import type { AuthorizationChallenge } from "#harness/authorization.js";
 import type { SessionAuthContext } from "#channel/types.js";
-import type { SessionStateMap, StepInput } from "#harness/types.js";
+import type { SessionStateMap, HarnessStepInput } from "#harness/types.js";
 import type { RuntimeWorkflowTaskRequest } from "#shared/action-types.js";
-import type { InputRequest } from "#shared/input.js";
+import type { InteractionRequest } from "#protocol/session-events/families/interaction.js";
+import type { JsonObject } from "#shared/json.js";
 /** The coordinates of the model step a suspended step parked from. */
 export interface StepCoordinates {
     readonly sequence: number;
     readonly stepIndex: number;
     readonly turnId: string;
 }
+/** A call that needs a person's approval, and what they're asked. */
+export interface ApprovalAsk {
+    readonly remember?: RememberRequest;
+    readonly interactionId: string;
+    readonly call: {
+        readonly callId: string;
+        readonly toolName: string;
+        readonly input: JsonObject;
+        /** The dynamic entry's version the call was made from. */
+        readonly version?: string;
+    };
+    readonly request: InteractionRequest;
+}
 /**
- * A call that runs on the turn's next model call, whatever asked for it: a person approved it, or
- * the sign-ins it waited on called back.
+ * A call cleared to run: a person approved it, or nothing asked them to. One a sign-in stopped
+ * waits in its step until the sign-ins it lists call back, then runs as the call that asked.
  */
-export type ApprovedCall = Pick<InputRequest, "action" | "requestId"> & {
+export interface ApprovedCall {
+    readonly call: ApprovalAsk["call"];
+    /** The approval that cleared the call; absent for a call only sign-ins stopped. */
+    readonly interactionId?: string;
     /** The sign-ins the call stopped on: its outcome settles them. */
     readonly signIns?: readonly AuthorizationChallenge[];
-};
+    /**
+     * Who approved it, when a response policy allowed their answer. The call reads it when it
+     * runs, after the answer, and the responder's record with it, has settled.
+     */
+    readonly responder?: SessionAuthContext;
+}
 /**
  * A model step whose calls can't all settle yet: some await an approval or a sign-in, others the
  * runtime.
@@ -28,13 +51,14 @@ export interface SuspendedStep {
     readonly event: StepCoordinates;
     /** The withheld response. Results join it as they arrive. */
     readonly messages: readonly ModelMessage[];
-    /** Approvals the step still waits on. */
-    readonly requests: readonly InputRequest[];
     /**
-     * Calls a person approved that haven't run. They run when the turn next calls the model, after
-     * its step starts and its budget allows it, as calls the model makes do. A call a sign-in
-     * stopped is one of them, once the sign-ins it lists have called back, so the call that asked
-     * runs, rather than the model deciding again.
+     * The approvals the response's calls asked for. How each was answered is the session's
+     * interaction and response tables'; this only remembers what was asked.
+     */
+    readonly requests: readonly ApprovalAsk[];
+    /**
+     * Calls a sign-in stopped. Each stays open, without a result, until the sign-ins it lists have
+     * called back, then runs as the call that asked, rather than the model deciding again.
      */
     readonly approved?: readonly ApprovedCall[];
     /** Workflow and agent calls the runtime runs for the step. */
@@ -44,11 +68,14 @@ export interface SuspendedStep {
     readonly requester?: SessionAuthContext | null;
 }
 export interface TurnState {
-    /** Input that arrived before it could run: a partial answer, or input behind a policy pass. */
-    readonly queued?: StepInput;
+    /**
+     * Turn input that arrived before the turn could take it: behind a question a message can't
+     * steer past, such as the budget prompt, or behind approved calls the model reads first.
+     */
+    readonly queued?: HarnessStepInput;
     readonly suspended: readonly SuspendedStep[];
-    /** Approval keys a `once()` approval granted for the rest of the session. */
-    readonly grants: readonly string[];
+    /** People's approval decisions, under the keys their requests named, for the session. */
+    readonly remembered: Readonly<Record<string, RememberedApproval>>;
 }
 export declare const EMPTY_TURN_STATE: TurnState;
 export declare function readTurnState(state: SessionStateMap | undefined): TurnState;

package/dist/src/harness/session-machine/state.js

@@ -1 +1 @@
-const TURN_STATE_KEY=`eve.harness.turnState`,EMPTY_TURN_STATE={grants:[],suspended:[]};function readTurnState(e){return e?.[TURN_STATE_KEY]??EMPTY_TURN_STATE}function writeTurnState(e,t){let n={...e.state};return t.suspended.length===0&&t.queued===void 0&&t.grants.length===0?delete n[TURN_STATE_KEY]:n[TURN_STATE_KEY]=t,{...e,state:Object.keys(n).length===0?void 0:n}}export{EMPTY_TURN_STATE,readTurnState,writeTurnState};
+const TURN_STATE_KEY=`eve.harness.turnState`,EMPTY_TURN_STATE={remembered:{},suspended:[]};function readTurnState(e){return e?.[TURN_STATE_KEY]??EMPTY_TURN_STATE}function writeTurnState(e,t){let n={...e.state};return t.suspended.length===0&&t.queued===void 0&&Object.keys(t.remembered).length===0?delete n[TURN_STATE_KEY]:n[TURN_STATE_KEY]=t,{...e,state:Object.keys(n).length===0?void 0:n}}export{EMPTY_TURN_STATE,readTurnState,writeTurnState};

package/dist/src/harness/session-machine/suspended-steps.d.ts

@@ -0,0 +1,22 @@
+import type { ModelMessage } from "ai";
+import type { SuspendedStep, TurnState } from "./state.js";
+type ToolResponsePart = Extract<ModelMessage, {
+    role: "tool";
+}>["content"][number];
+export type ToolResultPart = Extract<ToolResponsePart, {
+    type: "tool-result";
+}>;
+/** The turn with `step` suspended after the steps it already holds. */
+export declare function suspend(turn: TurnState, step: SuspendedStep): TurnState;
+/** The ids of the calls a step's response made, except provider-executed ones. */
+export declare function stepCallIds(step: Pick<SuspendedStep, "messages">): ReadonlySet<string>;
+/** Every call the step made has a result: a pending approval's call has none yet. */
+export declare function isComplete(step: SuspendedStep): boolean;
+/**
+ * Places a result right after the message that made its call, under the call's name: a call
+ * made through `eve__tool` or `eve__skill` keeps that name in history, whatever entry it ran.
+ */
+export declare function withResult(messages: readonly ModelMessage[], result: ToolResultPart): ModelMessage[];
+/** The messages without the results of the calls in `callIds`, which stay as unanswered calls. */
+export declare function withoutResults(messages: readonly ModelMessage[], callIds: ReadonlySet<string>): ModelMessage[];
+export {};

package/dist/src/harness/session-machine/suspended-steps.js

@@ -0,0 +1 @@
+import{answeredCallIds}from"./view.js";function suspend(e,t){return{...e,suspended:[...e.suspended,t]}}function stepCallIds(e){let t=new Set;for(let n of e.messages)if(n.role===`assistant`&&typeof n.content!=`string`)for(let e of n.content)e.type===`tool-call`&&e.providerExecuted!==!0&&t.add(e.toolCallId);return t}function isComplete(e){let t=answeredCallIds(e.messages);return[...stepCallIds(e)].every(e=>t.has(e))}function withResult(e,t){let n=[...e],r=findCall(n,t.toolCallId);if(r===void 0)return n.push({content:[t],role:`tool`}),n;let i={...t,toolName:r.call.toolName},a=n[r.index+1];return a?.role===`tool`?n[r.index+1]={...a,content:[...a.content,i]}:n.splice(r.index+1,0,{content:[i],role:`tool`}),n}function withoutResults(e,t){return e.flatMap(e=>{if(e.role!==`tool`)return[e];let n=e.content.filter(e=>e.type!==`tool-result`||!t.has(e.toolCallId));return n.length===0?[]:[{...e,content:n}]})}function findCall(e,t){for(let[n,r]of e.entries()){if(r.role!==`assistant`||typeof r.content==`string`)continue;let e=r.content.find(e=>e.type===`tool-call`&&e.toolCallId===t);if(e!==void 0)return{call:e,index:n}}}export{isComplete,stepCallIds,suspend,withResult,withoutResults};

package/dist/src/harness/session-machine/transitions.d.ts

@@ -1,75 +1,74 @@
-import type { ModelMessage, UserContent } from "ai";
-import type { SubagentAuthorizationEventHookPayload, SubagentInputRequestHookPayload } from "#channel/types.js";
+import type { ModelMessage } from "ai";
+import type { SubagentInteractionHookPayload } from "#channel/types.js";
 import type { AuthorizationChallenge } from "#harness/authorization.js";
-import { type TurnWaitingOn, createSessionCompletedEvent, createSessionFailedEvent, type InputResolution, type RuntimeIdentity, type RuntimeTraceContext, type SessionPredecessor, type TaskCancelReason, type TaskStartedStreamEvent, type UnstampedMessageStreamEvent } from "#protocol/message.js";
+import { type InterruptedCall } from "#harness/interrupted-attempt.js";
+import type { RuntimeIdentity, TraceContext, SessionPredecessor } from "#protocol/session-events/families/session.js";
+import type { TaskCancelReason } from "#execution/tasks/table.js";
+import type { DeliverySource, ImportedMessage } from "#protocol/session-events/families/delivery.js";
+import type { ControlDelivery } from "#harness/types.js";
+import type { ResponseSubmittedData } from "#protocol/session-events/families/response.js";
+import type { SessionEvent } from "#protocol/session-event.js";
+import type { Cause, Principal, UserPart } from "#protocol/session-events/envelope.js";
+import type { TokenUsage } from "#shared/token-usage.js";
+import type { FactOf } from "#protocol/session-events/facts.js";
 import type { RuntimeActionResult } from "#shared/action-types.js";
+import type { Answer } from "#shared/input.js";
 import type { JsonObject, JsonValue } from "#shared/json.js";
-import type { SessionHistoryMessage } from "#shared/session-history.js";
-import type { TokenUsage } from "#shared/token-usage.js";
 import type { Transition } from "./commit.js";
-import { type WorkflowAskRoute } from "#harness/hitl/relays.js";
-import type { ApprovedCall, StepCoordinates, SuspendedStep, TurnState } from "./state.js";
+import type { WorkflowAskRoute } from "#harness/hitl/relays.js";
+import type { StoppedCall } from "#harness/inline-tool-authorization.js";
+import type { ApprovedCall, SuspendedStep, TurnState } from "./state.js";
 import { type SessionView } from "./view.js";
-type ToolResponsePart = Extract<ModelMessage, {
-    role: "tool";
-}>["content"][number];
-export type ToolResultPart = Extract<ToolResponsePart, {
-    type: "tool-result";
-}>;
+import { type ToolResultPart } from "./suspended-steps.js";
+/** A delivery a turn consumes, with what the person sent: nothing for an answer or context. */
+export interface ConsumedDelivery {
+    readonly deliveryId: string;
+    readonly parts: readonly UserPart[];
+    /** Earlier conversation the delivery brought, which its consumption records. */
+    readonly history?: readonly ImportedMessage[];
+}
 /**
- * Input arrives: the session starts once, a turn opens unless one is open (steering joins it),
- * any history the delivery added is published, and a message is received.
+ * Deliveries arrive for a turn: the session starts once, a turn opens unless one is open, and
+ * each delivery is consumed into it.
  */
 export declare function receive(view: SessionView, input: {
-    readonly imported?: readonly SessionHistoryMessage[];
-    readonly message?: string | UserContent;
+    readonly deliveries?: readonly ConsumedDelivery[];
+    /** What starts the turn when no delivery does. */
+    readonly cause?: Cause;
+    readonly parent?: {
+        readonly sessionId: string;
+        readonly callId: string;
+    };
     /** The session this one replaced, when eve started it in place of a stranded one. */
     readonly predecessor?: SessionPredecessor;
     readonly runtime?: RuntimeIdentity;
-    readonly trace?: RuntimeTraceContext;
-}): Transition;
-/** The open turn calls the model. */
-export declare function startStep(view: SessionView, input: {
-    readonly modelId: string;
+    readonly trace?: TraceContext;
 }): Transition;
 /**
- * The open turn parks: on `"tasks"` while work it started runs, on `"input"` while a person must
- * act on a sign-in, approval, or question. It resumes in the same turn.
+ * Deliveries join the open turn without opening one, as answers do.
+ * Between turns an answer has nothing to join: it took effect, and settles `applied`. A delivery
+ * already settled, such as one refused, joins nothing.
  */
-export declare function hold(view: SessionView, input: {
-    readonly on: TurnWaitingOn;
-}): Transition;
-/** Nothing is left to run: the turn completes, with its structured result when it has one. */
-export declare function finishTurn(view: SessionView, input?: {
-    readonly result?: JsonValue;
+export declare function join(view: SessionView, input: {
+    readonly deliveries: readonly ConsumedDelivery[];
 }): Transition;
 /**
- * The step failed. A recoverable failure parks the session for the user to retry; a terminal
+ * The step failed. A recoverable failure leaves the session for the user to retry; a terminal
  * one ends it.
  */
 export declare function fail(view: SessionView, failure: {
     readonly code: string;
     readonly details?: JsonObject;
     readonly message: string;
-    readonly terminal?: {
-        readonly sessionId: string;
-    };
+    readonly terminal?: true;
 }): Transition;
-/** The session waits for its next delivery. */
-export declare function idle(view: SessionView): Transition;
-export declare function sessionCompleted(usage: TokenUsage | undefined): ReturnType<typeof createSessionCompletedEvent>;
-export declare function sessionFailed(input: {
-    readonly code: string;
-    readonly details?: JsonObject;
-    readonly message: string;
-    readonly sessionId: string;
-    readonly usage: TokenUsage | undefined;
-}): ReturnType<typeof createSessionFailedEvent>;
 /** One call's result, ready for its step's transcript. */
 export interface SettledCall {
     readonly part: ToolResultPart;
     /** A runtime result, reported at the coordinates of the step that made the call. */
     readonly result?: RuntimeActionResult;
+    /** What the agent behind the call spent, which its settlement records. */
+    readonly usage?: TokenUsage;
 }
 /**
  * Results reach the steps that made their calls. A step whose every call now has a result
@@ -78,26 +77,20 @@ export interface SettledCall {
 export declare function settle(view: SessionView, input: {
     readonly results: readonly SettledCall[];
 }): {
-    commit: ModelMessage[];
-    events: UnstampedMessageStreamEvent[];
-    turn: {
-        queued?: import("../types.ts").StepInput;
-        grants: readonly string[];
-        suspended: SuspendedStep[];
-    };
+    events: SessionEvent[];
+    commit: readonly ModelMessage[];
+    turn: TurnState;
 };
-/** A call a discarded model-call attempt announced without a result. */
-export interface DiscardedCall {
-    readonly callId: string;
-    readonly toolName: string;
-}
 /**
- * A model-call attempt failed and the step retries it. The calls the attempt announced never
- * ran, so each settles as failed before the replacement attempt streams. Nothing reaches
- * history: the discarded response was never committed.
+ * A model-call attempt ends without its response reaching history, in one commit with the calls
+ * it announced. A retry replaces it: eve can't tell whether those calls ran, so they and the run
+ * settle `abandoned`. Steering cut it off: the calls are interrupted, and the run completed what
+ * it streamed, with what it spent.
  */
 export declare function discardAttempt(view: SessionView, input: {
-    readonly calls: readonly DiscardedCall[];
+    readonly runId: string;
+    readonly ending: "retried" | "steered";
+    readonly usage?: FactOf<"usage.recorded">["data"]["usage"];
 }): Transition;
 /**
  * A model response made calls the runtime runs. The response waits in a suspended step until
@@ -107,22 +100,21 @@ export declare function suspendStep(view: SessionView, step: Pick<SuspendedStep,
 /** The step without the approved calls in `callIds`, which have run or joined the runtime. */
 export declare function withoutApproved(step: SuspendedStep, callIds: ReadonlySet<string>): SuspendedStep;
 /**
- * The approved calls of `step` that can run. A call a sign-in stopped is approved too, but waits
- * until every sign-in it stopped on has called back.
+ * The calls of `step` a sign-in stopped that can run: every sign-in each stopped on has called
+ * back.
  */
 export declare function runnableCalls(view: SessionView, step: SuspendedStep): readonly ApprovedCall[];
-/** Approved calls of suspended steps that can run and haven't. */
-export declare function approvedCalls(view: SessionView): readonly ApprovedCall[];
-export declare function suspend(turn: TurnState, step: SuspendedStep): TurnState;
-/** The ids of the calls a step's response made, except provider-executed ones. */
-export declare function stepCallIds(step: Pick<SuspendedStep, "messages">): ReadonlySet<string>;
-/**
- * Places a result right after the message that made its call, under the call's name: a call
- * made through `eve__tool` or `eve__skill` keeps that name in history, whatever entry it ran.
- */
-export declare function withResult(messages: readonly ModelMessage[], result: ToolResultPart): ModelMessage[];
-/** A call started or reached a task. */
-export declare function startTask(view: SessionView, task: TaskStartedStreamEvent["data"]): Transition;
+/** Private dispatch metadata for a call that starts or reaches a task. */
+export interface TaskCallStart {
+    readonly clearedBy?: import("#protocol/session-events/families/call.js").ClearedBy;
+    readonly callId: string;
+    readonly taskId: string;
+    readonly turnId: string;
+    readonly kind: "agent" | "tool";
+    readonly name: string;
+}
+/** A task starts once; every call it serves starts against that task. */
+export declare function startTask(view: SessionView, task: TaskCallStart, introducedTasks?: Set<string>): Transition;
 export type TaskCallOutcome = {
     readonly status: "completed";
     readonly output?: JsonValue;
@@ -135,17 +127,16 @@ export type TaskCallOutcome = {
 };
 /** A task's run settled calls: each reports its outcome, naming the task as it started. */
 export declare function settleTask(view: SessionView, input: {
-    readonly task: {
-        readonly id: string;
-        readonly kind?: TaskStartedStreamEvent["data"]["kind"];
-        readonly name?: string;
-    };
     readonly calls: readonly {
         readonly callId: string;
-        readonly turnId: string;
     }[];
     readonly outcome: TaskCallOutcome;
 }): Transition;
+/** A task's body ended. Replying only settles calls; it never ends a resumable task. */
+export declare function endTask(view: SessionView, input: {
+    readonly taskId: string;
+    readonly outcome: TaskCallOutcome;
+}): Transition;
 /**
  * A task or workflow run ended, on its own or cancelled: nobody can answer what it relayed, so
  * each request still open is withdrawn.
@@ -155,46 +146,50 @@ export declare function finishRun(view: SessionView, run: {
     readonly requestIds?: Iterable<string>;
 }): Transition;
 /**
- * A child session or workflow run asks a question or for a sign-in. The session passes it up
- * with its original coordinates, and the open turn waits on the call it serves.
- * A child's fresh batch replaces its earlier one, whose open requests are withdrawn.
+ * A child session or workflow run relays one of its interaction facts. The session mirrors each
+ * as its own interaction, about the call it serves, with the asker as its origin: a request
+ * opens, and records where its answers go; the asker's settlement closes it; and the asker's
+ * admission or refusal of an answer this session forwarded applies to the forwarded copy. The
+ * open turn waits on a request about one of its calls; a task's request waits on the task.
  */
 export declare function relay(view: SessionView, input: {
-    readonly payload: SubagentInputRequestHookPayload | SubagentAuthorizationEventHookPayload;
-    readonly replacedRequestIds?: Iterable<string>;
+    readonly payload: SubagentInteractionHookPayload;
     /** The workflow tool run that relays the request, and the hook its `ctx.ask()` answers reach. */
     readonly runId?: string;
     readonly workflowAsk?: WorkflowAskRoute;
 }): Transition;
 /**
- * Answers to relayed requests are on their way to the asker: each request resolves here.
+ * Answers to requests this session relays went on to their askers. Each delivery that carried
+ * such answers is admitted here, with the answers it forwarded. An answer joins the open turn
+ * that asked; a delivery that also carries input for this session goes on to its turn. Between
+ * turns, forwarding alone applies the delivery. A question this session decides settles now; an
+ * approval stays open until its asker settles it.
  */
-export declare function receiveRelayedAnswer(input: {
-    readonly message: string | UserContent;
-    readonly sequence: number;
-    readonly turnId: string;
-}): import("#protocol/message.js").MessageReceivedStreamEvent;
 export declare function routeAnswer(view: SessionView, input: {
-    readonly children: readonly {
-        readonly event: StepCoordinates;
-        readonly resolutions: readonly InputResolution[];
+    readonly deliveries: readonly {
+        readonly deliveryId: string;
+        readonly principal?: Principal;
+        readonly source?: DeliverySource;
+        /** The open asking turn consumes the answer, with any message parts it carried. */
+        readonly consumed?: {
+            readonly turnId: string;
+            readonly parts: readonly UserPart[];
+        };
+        /** The delivery also carries input for this session, whose turn consumes and settles it. */
+        readonly continues?: true;
     }[];
+    /** Every answer forwarded, as admitted. */
+    readonly forwarded: readonly ResponseSubmittedData[];
     /**
-     * Answers left other relayed requests pending, and nothing for the turn itself: the open
-     * turn stays held, as after a partial approval answer.
+     * Relayed requests this session settles as it forwards their answer, because nobody else
+     * will before it acts: a workflow run's `ctx.ask()` question, since a run publishes nothing of
+     * its own, and a child's budget prompt this session stops on, since Stop ends its own turn.
      */
-    readonly holds?: boolean;
+    readonly decided: readonly {
+        readonly answer: Answer;
+        readonly outcome: "accepted" | "declined";
+    }[];
 }): Transition;
-/**
- * A workflow run's sign-in, reported to the session that owns the run, which relays it. Built
- * where the run asks, at the coordinates of the call it serves.
- */
-export declare function runSignIn(from: {
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly taskId?: string;
-    readonly turnId: string;
-}, challenge: AuthorizationChallenge, outcome?: "authorized" | "failed"): import("#protocol/message.js").AuthorizationCompletedStreamEvent | import("#protocol/message.js").AuthorizationRequiredStreamEvent;
 /**
  * Sign-in callbacks matched the attempts `attemptIds` name: the session stops waiting on them.
  * A call they stopped runs once every sign-in it waits on has called back (`runnableCalls`); any
@@ -206,22 +201,40 @@ export declare function matchSignIns(view: SessionView, input: {
 /** The sign-ins calls stopped on, which the calls report when they settle. */
 export declare function callSignIns(turn: TurnState): readonly AuthorizationChallenge[];
 /**
- * The `stopped` calls wait for a sign-in: their results leave the step, and they stay approved,
- * to run once the sign-ins call back, rather than the model asking for them again.
+ * The `stopped` calls wait for a sign-in: their results leave the step, and they stay approved and
+ * open, to run once the sign-ins call back, rather than the model asking for them again.
  */
 export declare function awaitSignIns(step: SuspendedStep, input: {
-    readonly stopped: readonly {
-        readonly action: ApprovedCall["action"];
-        readonly connections: readonly string[];
-    }[];
+    readonly stopped: readonly StoppedCall[];
     readonly challenges: readonly AuthorizationChallenge[];
 }): SuspendedStep;
-/** Sign-in callbacks arrived: each completion is reported at the coordinates of the turn that asked. */
+/**
+ * A call a sign-in stopped settled: the sign-ins it waited on end with it, accepted if it returned
+ * and failed with the reason it didn't. A failure with `retryable: false` is terminal, recorded as
+ * the settlement's `response.retryable`. Published before the call's own settlement.
+ */
+export declare function callSignInsSettled(view: Pick<SessionView, "projection">, call: ApprovedCall, failure?: {
+    readonly reason?: string;
+    readonly retryable?: boolean;
+}): SessionEvent[];
+/**
+ * Sign-in callbacks arrived: each attempt the session still waits on is accepted. A sign-in a
+ * call stopped on settles with the call instead (`callSignInsSettled`).
+ */
 export declare function completeSignIn(view: SessionView, input: {
     readonly completions: readonly AuthorizationChallenge[];
 }): Transition;
-/** Requests this session asked itself and still awaits; relayed requests answer elsewhere. */
-export declare function ownOpenRequestIds(view: Omit<SessionView, "turn">): ReadonlySet<string>;
+/**
+ * The delivery a clear or compact arrived as. One that names none, from a caller that predates
+ * control ids, is named by the position it applies at.
+ */
+export declare function controlDeliveryFor(view: SessionView, given?: ControlDelivery): ControlDelivery;
+/**
+ * A control's transition as a delivery: admitted before what it changes and applied after, in
+ * the same commit, with what it changes naming it as the cause. A control that names no
+ * delivery changes the session on its own.
+ */
+export declare function controlled(delivery: ControlDelivery | undefined, control: string, build: (cause: Cause | undefined) => Transition): Transition;
 /** What the model reads for a call its turn's cancellation stopped before the call settled. */
 export declare const CANCELLED_CALL_RESULT = "The turn was cancelled before this call finished.";
 /**
@@ -230,13 +243,24 @@ export declare const CANCELLED_CALL_RESULT = "The turn was cancelled before this
  * calls are stopped. The steps it ran commit to history, each unfinished call answered as
  * cancelled, so the model sees that the work started and stopped.
  */
-export declare function cancel(view: SessionView): Transition;
+export declare function cancel(view: SessionView, input?: {
+    readonly cause?: Cause;
+}): Transition;
+/**
+ * A step was interrupted after it published, and its retry runs from the checkpoint before it.
+ * Each step waiting on what the interrupted attempt did, an answer it applied or a call it
+ * started, can't resume from it again: the step stops, each call it made answered with what the
+ * stream says of it, so none runs again. The events the attempt wrote already say what changed.
+ */
+export declare function stopInterruptedSteps(view: SessionView, input: {
+    readonly calls: ReadonlyMap<string, InterruptedCall>;
+    readonly settledInteractions: ReadonlySet<string>;
+}): Transition;
 /**
  * `session.clear()`: everything the cleared history asked for is withdrawn, its approvals and
  * the session-limit prompt and every sign-in, and the calls awaiting them stop. Requests relayed
  * from live tasks stay: clearing doesn't stop the work that asked them.
  */
-export declare function clear(view: SessionView, input: {
-    readonly sessionId: string;
+export declare function clear(view: SessionView, input?: {
+    readonly cause?: Cause;
 }): Transition;
-export {};