@nylorun/runtime 0.16.0-beta → 0.19.0-beta

package/dist/core/flow-host.js

@@ -14,6 +14,9 @@
  * - `deriveAgentEffectSessionId(workflowSessionId, path, request): string`
  * - `isWorkflowManifest(manifest): manifest is WorkflowManifest`
  * - `isFlowToolEffect(request): boolean`, `isFlowEffect(request): boolean`
+ * - `linkedMessageInput(body): JsonValue`
+ * - `settleAgentEffect({ t, effect, outcome }): Promise<void>`
+ * - `recordVerdict(t, request, value): Promise<void>`
  * - `pathDepth(path): number`
  * - `countActiveFlowWork(t, workflowSessionId, turnId): Promise<number>`
  * - `commandKey(sessionId, idempotencyKey): string`
@@ -25,8 +28,9 @@
  * - `reconcilePendingAgentEffect({ t, effectId, schedule }): Promise<boolean>`
  * - `planCancelCascade({ t, workflowSessionId, turnId }): Promise<CascadeCancelPlan>`
  * - `cancelSiblingWork({ t, workflowSessionId, turnId, siblingPaths?, cancelEffectIds? }): Promise<CancelSiblingResult>`
- * - `fenceWorkflowActions({ t, workflowSessionId, turnId }): Promise<{ cancelled; uncertain }>`
+ * - `cancelQueuedEffects({ t, workflowSessionId, turnId }): Promise<string[]>`
  * - `aggregateWaits({ t, workflowSessionId }): Promise<FlowWait[]>`
+ * - `flowInteractionOf(waits, workflowSessionId, interactionId): { id; kind } | undefined`
  * - `findInteractionOwner({ t, workflowSessionId, interactionId }): Promise<{ sessionId; path } | undefined>`
  * - `foreignInteractionConflict({ t, workflowSessionId, interactionId }): Promise<{ status: 409; message; ownerSessionId } | undefined>`
  * - `wakeForQueuedEffects({ t, workflowSessionId, turnId, limits, schedule }): Promise<boolean>`
@@ -40,10 +44,11 @@
  * commits. The effect is bound to its turn through the message's idempotency key
  * (`linkedMessageKey`): the `commands` document of that key names the turn it opened.
  *
- * The Tenant sweep (`tenant/sweep.ts`) calls the reconcile and re-offer functions, one
- * transaction per effect or Action.
+ * The Tenant sweep (`tenant/sweep.ts`) calls the reconcile functions, one transaction per
+ * effect.
  */
 import { createHash } from "node:crypto";
+import { isVerdict } from "@nylorun/core/define";
 import { mayDispatchMore } from "./limits.js";
 /** Deterministic agent session id: derive(workflowSessionId, path, …parts). */
 export function deriveSessionId(workflowSessionId, path, ...parts) {
@@ -84,23 +89,61 @@ export function isFlowToolEffect(request) {
         request.capabilityId === undefined);
 }
 export function isFlowEffect(request) {
-    return (request.kind === "agent" ||
-        request.kind === "fn" ||
-        request.kind === "verify" ||
-        isFlowToolEffect(request));
+    return request.kind === "agent" || isFlowToolEffect(request);
+}
+/** Pretty JSON for a message, or a string as it is. */
+function text(value) {
+    return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+}
+/**
+ * What a flow `agent` effect sends its linked session (D12): the stage's input, and, when the
+ * engine sent the flow's own input beside it, that input first as the original request. Pure,
+ * so a replayed effect sends the same message.
+ */
+export function linkedMessageInput(body) {
+    if (body.flowInput === undefined)
+        return body.input;
+    return `Original request:\n${text(body.flowInput)}\n\n${text(body.input)}`;
+}
+/**
+ * Settle a flow `agent` effect with its linked turn's outcome, in the caller's transaction,
+ * which holds the workflow session's lock. A verifier agent's verdict is recorded as
+ * `loop.verified`; an outcome that is not a verdict fails the Loop in the engine instead.
+ */
+export async function settleAgentEffect(input) {
+    const { t, effect, outcome } = input;
+    await t.put("effects", effect.request.effectId, { ...effect, status: "completed", outcome });
+    if (effect.request.context?.role === "verify-agent")
+        await recordVerdict(t, effect.request, outcome.value);
+}
+/**
+ * Record a Loop verifier's verdict as `loop.verified`: a verifier agent's output, or an HTTP
+ * verifier's answer (`role: "verify-http"`, a completed HTTP outcome). Anything that is not a
+ * verdict records nothing; the engine fails the Loop on it.
+ */
+export async function recordVerdict(t, request, value) {
+    const answer = value;
+    const verdict = request.context?.role !== "verify-http"
+        ? value
+        : answer?.kind === "completed"
+            ? answer.output
+            : undefined;
+    if (!isVerdict(verdict))
+        return;
+    await t.event(request.sessionId, request.turnId, "loop.verified", {
+        path: String(request.context.loopPath ?? request.path ?? ""),
+        n: Number(request.context.n ?? 1),
+        pass: verdict.pass,
+        ...(verdict.pass ? {} : { feedback: verdict.feedback }),
+        ...(verdict.data !== undefined ? { data: verdict.data } : {}),
+    });
 }
-/** Actions still to be settled: waiting to be delivered, or being delivered. */
-const OPEN_ACTION = ["pending", "delivering"];
 function scheduleAfterCommit(t, schedule, id, wake) {
     t.afterCommit(() => schedule(id, wake));
 }
-/** Active agent turns + pending/delivering actions for one workflow turn. */
+/** Active agent turns + tool nodes in flight for one workflow turn. */
 export async function countActiveFlowWork(t, workflowSessionId, turnId) {
     const effects = await t.effectsForTurn(workflowSessionId, turnId);
-    const openActions = new Set((await t.actionsForSession(workflowSessionId, {
-        turnId,
-        statuses: OPEN_ACTION,
-    })).map((action) => action.actionId));
     let n = 0;
     for (const effect of effects) {
         if (effect.status === "queued")
@@ -111,10 +154,7 @@ export async function countActiveFlowWork(t, workflowSessionId, turnId) {
             n += 1;
             continue;
         }
-        if ((effect.request?.kind === "fn" ||
-            effect.request?.kind === "verify" ||
-            isFlowToolEffect(effect.request)) &&
-            openActions.has(effect.request.effectId))
+        if (isFlowToolEffect(effect.request) && effect.status === "invoking")
             n += 1;
     }
     return n;
@@ -199,11 +239,7 @@ export async function wakeLinkedWorkflow(input) {
                 },
             }
             : { value: input.output ?? null };
-    await t.put("effects", link.effectId, {
-        ...effect,
-        status: "completed",
-        outcome,
-    });
+    await settleAgentEffect({ t, effect, outcome });
     workflow.status = "runnable";
     await t.put("sessions", workflow.id, workflow);
     scheduleAfterCommit(t, input.schedule, workflow.id, {
@@ -259,45 +295,22 @@ export function pathDepth(path) {
         return 0;
     return path.split("/").filter(Boolean).length;
 }
-/**
- * Plan a cancel cascade for a workflow session: linked agents deepest first,
- * then pending → cancelled and delivering → uncertain actions (SD-P11 / WF-R53).
- */
+/** Plan a cancel cascade for a workflow session: linked agents deepest first (SD-P11 / WF-R53). */
 export async function planCancelCascade(input) {
     const { t } = input;
     const agentEntries = (await t.linkedSessions(input.workflowSessionId)).map((linked) => ({ sessionId: linked.agentSessionId, path: linked.link.path }));
     agentEntries.sort((a, b) => pathDepth(b.path) - pathDepth(a.path));
-    const pendingActionIds = [];
-    const deliveringActionIds = [];
-    const actions = await t.actionsForSession(input.workflowSessionId, {
-        ...(input.turnId !== null ? { turnId: input.turnId } : {}),
-        statuses: OPEN_ACTION,
-    });
-    for (const action of actions) {
-        if (action.status === "pending")
-            pendingActionIds.push(action.actionId);
-        // Being delivered: the code may already be running.
-        else
-            deliveringActionIds.push(action.actionId);
-    }
-    return {
-        agentSessionIds: agentEntries.map((e) => e.sessionId),
-        pendingActionIds,
-        deliveringActionIds,
-    };
+    return { agentSessionIds: agentEntries.map((e) => e.sessionId) };
 }
 /**
  * Cancel sibling work under a Parallel/Map parent when one branch fails (PAR-R6).
- * Agent turns listed in `agentSessionIds` are returned for the caller to cancel;
- * pending actions → cancelled, delivering tool actions → uncertain.
+ * Agent turns listed in `agentSessionIds` are returned for the caller to cancel.
  * When `cancelEffectIds` is provided, those effects are marked cancelled and their
  * paths are included in the sibling path set.
  */
 export async function cancelSiblingWork(input) {
     const { t } = input;
     await t.lockSession(input.workflowSessionId);
-    const cancelledActions = [];
-    const uncertainActions = [];
     const agentSessionIds = [];
     const siblingPaths = new Set(input.siblingPaths ?? []);
     for (const effectId of input.cancelEffectIds ?? []) {
@@ -328,66 +341,21 @@ export async function cancelSiblingWork(input) {
             ["running", "runnable", "paused", "waiting"].includes(session.status))
             agentSessionIds.push(agentSessionId);
     }
-    const actions = await t.actionsForSession(input.workflowSessionId, {
-        turnId: input.turnId,
-        statuses: OPEN_ACTION,
-    });
-    for (const action of actions) {
-        if (!matchesSibling(action.path))
-            continue;
-        // Delivered work may already have had an external effect.
-        const next = action.status === "pending" ? "cancelled" : "uncertain";
-        action.status = next;
-        await t.put("actions", action.actionId, action);
-        const effect = await t.get("effects", action.actionId);
-        if (effect) {
-            effect.status = next;
-            await t.put("effects", action.actionId, effect);
-        }
-        if (next === "cancelled")
-            cancelledActions.push(action.actionId);
-        else
-            uncertainActions.push(action.actionId);
-    }
-    return { cancelledActions, uncertainActions, agentSessionIds };
+    return { agentSessionIds };
 }
-/**
- * Apply cancel fencing to workflow-session actions (pending→cancelled,
- * delivering→uncertain).
- */
-export async function fenceWorkflowActions(input) {
+/** Cancel a cancelled workflow turn's queued effects, which never started. */
+export async function cancelQueuedEffects(input) {
     const { t } = input;
     await t.lockSession(input.workflowSessionId);
     const turn = input.turnId !== null ? { turnId: input.turnId } : {};
     const cancelled = [];
-    const uncertain = [];
-    const actions = await t.actionsForSession(input.workflowSessionId, {
-        ...turn,
-        statuses: OPEN_ACTION,
-    });
-    for (const action of actions) {
-        // Delivered work may already have had an external effect.
-        const next = action.status === "pending" ? "cancelled" : "uncertain";
-        action.status = next;
-        await t.put("actions", action.actionId, action);
-        const effect = await t.get("effects", action.actionId);
-        if (effect) {
-            effect.status = next;
-            await t.put("effects", action.actionId, effect);
-        }
-        if (next === "cancelled")
-            cancelled.push(action.actionId);
-        else
-            uncertain.push(action.actionId);
-    }
-    // Drop queued effects that never started.
     const queued = await t.effectsForSession(input.workflowSessionId, { ...turn, statuses: ["queued"] });
     for (const effect of queued) {
         effect.status = "cancelled";
         await t.put("effects", effect.request.effectId, effect);
         cancelled.push(effect.request.effectId);
     }
-    return { cancelled, uncertain };
+    return cancelled;
 }
 function waitsFromSession(sessionId, path, raw) {
     if (!Array.isArray(raw))
@@ -400,9 +368,10 @@ function waitsFromSession(sessionId, path, raw) {
             continue;
         waits.push({
             sessionId,
-            path,
+            path: typeof call.path === "string" ? call.path : path,
             interactionId,
             kind: String(interaction?.kind ?? call.kind ?? "approval"),
+            ...(call.interaction !== undefined ? { interaction: call.interaction } : {}),
             ...(call.invocationId !== undefined
                 ? { invocationId: String(call.invocationId) }
                 : {}),
@@ -421,13 +390,9 @@ export async function aggregateWaits(input) {
     if (!workflow)
         return [];
     const waits = [];
-    // Workflow-owned interactions (tool-node / verify approvals) live on the workflow session.
-    if (Array.isArray(workflow.waits))
-        waits.push(...waitsFromSession(workflow.id, "", workflow.waits));
-    else if (workflow.waits &&
-        typeof workflow.waits === "object" &&
-        Array.isArray(workflow.waits.interactions))
-        waits.push(...waitsFromSession(workflow.id, "", workflow.waits.interactions));
+    // Workflow-owned interactions (tool-node approvals) live on the workflow session. Waits it
+    // copied from linked sessions are read from those sessions below, never from this copy.
+    waits.push(...waitsFromSession(workflow.id, "", ownWaits(workflow.waits, workflow.id)));
     for (const { agentSessionId, link, session } of await t.linkedSessions(input.workflowSessionId)) {
         if (session.status !== "paused")
             continue;
@@ -435,6 +400,23 @@ export async function aggregateWaits(input) {
     }
     return waits;
 }
+/** The entries of a workflow's `waits` that the workflow itself owns. */
+function ownWaits(raw, workflowSessionId) {
+    const list = Array.isArray(raw)
+        ? raw
+        : raw && typeof raw === "object" && Array.isArray(raw.interactions)
+            ? raw.interactions
+            : [];
+    return list.filter((call) => call?.sessionId === undefined || call.sessionId === workflowSessionId);
+}
+/**
+ * The workflow-owned interaction `interactionId` among a workflow's `waits` (a tool node that
+ * asked), or undefined.
+ */
+export function flowInteractionOf(raw, workflowSessionId, interactionId) {
+    const hit = waitsFromSession(workflowSessionId, "", ownWaits(raw, workflowSessionId)).find((wait) => wait.interactionId === interactionId);
+    return hit && { id: hit.interactionId, kind: hit.kind };
+}
 /**
  * Look up which session owns an interaction id. Used for 409 foreign approvals (WF-R52).
  */

package/dist/core/provider.d.ts

@@ -8,5 +8,8 @@ export declare function gatewayModel(options: {
     token: string;
     model: string;
 }): ModelProvider;
-/** Deterministic release fixture; still uses the real engine and remote customer tool. */
+/**
+ * Deterministic release fixture; still uses the real engine. With a `lookup_order` tool it looks
+ * up the demo order through it once; without one it answers in text.
+ */
 export declare function toolFixtureModel(): ModelProvider;

package/dist/core/provider.js

@@ -22,7 +22,10 @@ export function gatewayModel(options) {
         return response.json();
     };
 }
-/** Deterministic release fixture; still uses the real engine and remote customer tool. */
+/**
+ * Deterministic release fixture; still uses the real engine. With a `lookup_order` tool it looks
+ * up the demo order through it once; without one it answers in text.
+ */
 export function toolFixtureModel() {
     return async (effect) => {
         const call = effect.input;
@@ -46,6 +49,8 @@ export function toolFixtureModel() {
                     },
                 ],
             };
+        if (!call.tools.some((tool) => tool.name === "lookup_order"))
+            return { output: [{ type: "text", text: "Hello from the fixture model." }] };
         return {
             output: [
                 {

package/dist/core/sandbox-routes.d.ts

@@ -1,4 +1,3 @@
-import type { Action } from "@nylorun/core/contracts";
 import type { WorkspacePort } from "../harness-api/workspace.js";
 import type { SandboxToolOutcome } from "../sandbox/tools.js";
 import { type SessionSandboxRef } from "../sandbox/share.js";
@@ -19,20 +18,12 @@ export type SandboxRouteDeps = {
     readonly sandbox: Pick<WorkspacePort, "run">;
     /** The session (rejects when missing) and its owner chain, read in one transaction. */
     readonly session: (id: string) => Promise<SandboxRouteRead>;
-    readonly getAction: (id: string) => Promise<Action | undefined>;
 };
 /**
  * `POST /v1/sessions/:id/sandbox/:tool` — application principal.
  * Refused while the session has an active agent turn.
  */
 export declare function handleSessionSandboxTool(deps: SandboxRouteDeps, sessionId: string, toolName: string, body: unknown, signal: AbortSignal): Promise<SandboxToolOutcome>;
-/**
- * `POST /v1/actions/:id/sandbox/:tool` — the Action endpoint, authorized by the delivery token
- * of the Action's current delivery (`delivery.generation`). The body is the tool's input.
- */
-export declare function handleActionSandboxTool(deps: SandboxRouteDeps, actionId: string, toolName: string, body: unknown, signal: AbortSignal, delivery: {
-    generation: number;
-}): Promise<SandboxToolOutcome>;
 /**
  * Validate PutSession.sandbox attach: same owner, and a sandbox to share. A session whose
  * definition declares a sandbox must declare the owner's spec; one whose definition declares

package/dist/core/sandbox-routes.js

@@ -1,6 +1,6 @@
 /**
- * HTTP handlers for session-scoped and claim-scoped sandbox tool endpoints.
- * Wired from TenantRuntime; keeps route bodies out of the hot runtime file.
+ * HTTP handlers for the session-scoped sandbox tool route (`POST /v1/sessions/:id/sandbox/:tool`)
+ * and the sandbox attach check of `PUT /v1/sessions/:id`.
  */
 import { isSandboxToolName, } from "@nylorun/core/define";
 import { capabilityForSandbox, owningSandboxSessionId, sandboxSpecOf, sandboxWorkspaceOf, sandboxSpecsEqual, sessionSandboxSpec, } from "../sandbox/share.js";
@@ -56,25 +56,6 @@ export async function handleSessionSandboxTool(deps, sessionId, toolName, body,
     const tool = parseTool(toolName);
     return runTool(deps, read, tool, toolInput(body), signal);
 }
-/**
- * `POST /v1/actions/:id/sandbox/:tool` — the Action endpoint, authorized by the delivery token
- * of the Action's current delivery (`delivery.generation`). The body is the tool's input.
- */
-export async function handleActionSandboxTool(deps, actionId, toolName, body, signal, delivery) {
-    if (!body || typeof body !== "object" || Array.isArray(body))
-        throw new SandboxRouteError(400, "Sandbox tool body must be an object");
-    const action = await deps.getAction(actionId);
-    if (!action)
-        throw new SandboxRouteError(404, "Action not found");
-    if (action.status !== "delivering" ||
-        action.generation !== delivery.generation ||
-        Date.parse(action.deadlineAt ?? "") <= Date.now())
-        throw new SandboxRouteError(409, "The delivery was cancelled, lost or delivered again");
-    const read = await deps.session(action.sessionId);
-    if (read.session.activeTurnId !== action.turnId)
-        throw new SandboxRouteError(409, "Action unavailable");
-    return runTool(deps, read, parseTool(toolName), toolInput(body), signal);
-}
 /**
  * Validate PutSession.sandbox attach: same owner, and a sandbox to share. A session whose
  * definition declares a sandbox must declare the owner's spec; one whose definition declares

package/dist/execution/memory.d.ts

@@ -2,7 +2,7 @@ import { type DurableExecution, type SandboxSignal, type Wake, type WorkerHandle
 export interface MemoryExecutionOptions {
     /** Delay between sweep passes of one Tenant. Default 5000. */
     sweepIntervalMs?: number;
-    /** First retry delay after `advance` or `deliver` throws; doubles per attempt. Default 50. */
+    /** First retry delay after `advance` throws; doubles per attempt. Default 50. */
     retryDelayMs?: number;
     /** Attempts before giving up on a throwing handler and reporting it. Default 5. */
     maxAttempts?: number;
@@ -39,7 +39,6 @@ export declare class MemoryExecution implements DurableExecution {
     private readonly onError;
     constructor(options?: MemoryExecutionOptions);
     wake(tenantId: string, sessionId: string, wake: Wake): Promise<void>;
-    deliver(tenantId: string, actionId: string): Promise<void>;
     sandbox(tenantId: string, sandboxId: string, signal: SandboxSignal): Promise<void>;
     private armSandbox;
     private runSandbox;
@@ -49,8 +48,8 @@ export declare class MemoryExecution implements DurableExecution {
     start(handlers: WorkerHandlers): Promise<void>;
     stop(): Promise<void>;
     /**
-     * Resolves once no advance or delivery is running or queued and no busy or
-     * retry re-run is pending. Timers and sweeps are not waited for. Test helper.
+     * Resolves once no advance is running or queued and no busy or retry re-run is
+     * pending. Timers and sweeps are not waited for. Test helper.
      */
     idle(): Promise<void>;
     private enqueue;
@@ -58,7 +57,7 @@ export declare class MemoryExecution implements DurableExecution {
     /** Drops dedupe keys older than the retention window. */
     private forgetDedupeKeys;
     private runOnce;
-    /** Runs the key's handler; resolves to a delay when the key must run again. */
+    /** Runs the session's advance; resolves to a delay when it must run again. */
     private call;
     private armTimer;
     private scheduleSweep;

package/dist/execution/memory.js

@@ -44,10 +44,7 @@ export class MemoryExecution {
                 return;
             this.seen.set(dedupe, now);
         }
-        this.enqueue("advance", tenantId, sessionId);
-    }
-    async deliver(tenantId, actionId) {
-        this.enqueue("deliver", tenantId, actionId);
+        this.enqueue(tenantId, sessionId);
     }
     async sandbox(tenantId, sandboxId, signal) {
         const key = `${tenantId}\u0000${sandboxId}`;
@@ -173,8 +170,8 @@ export class MemoryExecution {
         await settleWithin(this.inflight, this.stopGraceMs);
     }
     /**
-     * Resolves once no advance or delivery is running or queued and no busy or
-     * retry re-run is pending. Timers and sweeps are not waited for. Test helper.
+     * Resolves once no advance is running or queued and no busy or retry re-run is
+     * pending. Timers and sweeps are not waited for. Test helper.
      */
     async idle() {
         while (this.delayed.size > 0 ||
@@ -182,14 +179,13 @@ export class MemoryExecution {
             [...this.keys.values()].some((s) => s.running || (s.queued && this.handlers)))
             await new Promise((resolve) => setTimeout(resolve, 1));
     }
-    enqueue(kind, tenantId, id) {
-        const key = stateKey(kind, tenantId, id);
+    enqueue(tenantId, sessionId) {
+        const key = sessionKey(tenantId, sessionId);
         let state = this.keys.get(key);
         if (!state)
             this.keys.set(key, (state = {
-                kind,
                 tenantId,
-                id,
+                sessionId,
                 running: false,
                 queued: false,
                 attempts: 0,
@@ -211,7 +207,7 @@ export class MemoryExecution {
                 state.running = false;
                 // Idle keys hold nothing (a retry keeps its attempt count); forget them so
                 // long-lived processes stay small.
-                const key = stateKey(state.kind, state.tenantId, state.id);
+                const key = sessionKey(state.tenantId, state.sessionId);
                 if (!state.queued && state.attempts === 0 && this.keys.get(key) === state)
                     this.keys.delete(key);
             }
@@ -228,7 +224,7 @@ export class MemoryExecution {
     async runOnce(state, handlers) {
         const controller = new AbortController();
         state.controller = controller;
-        const again = () => this.enqueue(state.kind, state.tenantId, state.id);
+        const again = () => this.enqueue(state.tenantId, state.sessionId);
         try {
             const retryAfterMs = await this.call(state, handlers, controller.signal);
             state.attempts = 0;
@@ -248,16 +244,10 @@ export class MemoryExecution {
             state.controller = undefined;
         }
     }
-    /** Runs the key's handler; resolves to a delay when the key must run again. */
+    /** Runs the session's advance; resolves to a delay when it must run again. */
     async call(state, handlers, signal) {
-        if (state.kind === "advance") {
-            const result = await handlers.advance(state.tenantId, state.id, signal);
-            return result.status === "busy" ? result.retryAfterMs : undefined;
-        }
-        if (!handlers.deliver)
-            throw new Error("WorkerHandlers.deliver is required for deliveries");
-        const result = await handlers.deliver(state.tenantId, state.id, signal);
-        return result.status === "retry" ? result.retryAfterMs : undefined;
+        const result = await handlers.advance(state.tenantId, state.sessionId, signal);
+        return result.status === "busy" ? result.retryAfterMs : undefined;
     }
     armTimer(id, timer) {
         timer.handle = setTimeout(() => {
@@ -305,7 +295,3 @@ export class MemoryExecution {
         void promise.finally(() => this.inflight.delete(promise));
     }
 }
-/** Advances and deliveries are queued apart: a session id and an Action id may be equal. */
-function stateKey(kind, tenantId, id) {
-    return `${kind}\u0000${sessionKey(tenantId, id)}`;
-}

package/dist/execution/types.d.ts

@@ -27,16 +27,7 @@
  *   becomes `uncertain` is settled in the Session Store and `advance` returns
  *   `done`.
  * - **Sweeps.** `armSweep` arms one self-re-arming sweep per Tenant; arming an
- *   armed Tenant is a no-op. The sweep settles lapsed deliveries and re-wakes
- *   orphaned `runnable` sessions.
- * - **One delivery per Action at a time.** `deliver` runs
- *   `WorkerHandlers.deliver` for the key `<tenantId>:<actionId>` at least once
- *   after it resolves. Two deliveries for one key never overlap; repeated
- *   `deliver` calls may each run it, so the handler reads the Action's state
- *   and does nothing when there is nothing to deliver.
- * - **Retry after `retry`.** A delivery that returns `retry` is run again for
- *   the same key after `retryAfterMs`. This is how an Action endpoint that is
- *   down or busy is retried; the handler throws only on infrastructure errors.
+ *   armed Tenant is a no-op. The sweep re-wakes orphaned `runnable` sessions.
  * - **One reconcile per sandbox at a time** (F7.2). `sandbox` runs
  *   `WorkerHandlers.sandbox` for the key `<tenantId>:<sandboxId>` at least once
  *   after a `reconcile` resolves, never overlapping another run for the key. A
@@ -49,8 +40,6 @@
 export type WakeReason = 
 /** Session commands. */
 "message" | "approve" | "respond"
-/** An Action's outcome was recorded (a delivery's answer or a background result). */
- | "action_result"
 /** A linked agent turn completed, failed or was cancelled. */
  | "linked"
 /** Queued flow effects, pending agent effects reconciled. */
@@ -98,14 +87,6 @@ export interface SandboxResult {
         at: number;
     }[];
 }
-export type DeliverResult = {
-    status: "done";
-}
-/** The Action is still to be delivered; run again for this key after `retryAfterMs`. */
- | {
-    status: "retry";
-    retryAfterMs: number;
-};
 /** What a Worker runs when Durable Session Execution calls it. */
 export interface WorkerHandlers {
     /**
@@ -118,11 +99,6 @@ export interface WorkerHandlers {
     sweep(tenantId: string): Promise<void>;
     /** A durable timer set with `timer` fired. Required when `timer` is used. */
     fire?(tenantId: string, key: string): Promise<void>;
-    /**
-     * Delivers one Action to its Action endpoint. `signal` aborts when the Worker
-     * stops. Throw only on infrastructure errors. Required when `deliver` is used.
-     */
-    deliver?(tenantId: string, actionId: string, signal: AbortSignal): Promise<DeliverResult>;
     /**
      * Reconciles one pod sandbox (F7.2), serialized per sandbox. Throw only on infrastructure
      * errors. Required when `sandbox` is used.
@@ -138,12 +114,6 @@ export interface DurableExecution {
      * implementation can; `fire` must be idempotent either way.
      */
     timer(tenantId: string, key: string, at: Date): Promise<void>;
-    /**
-     * At-least-once: `WorkerHandlers.deliver(tenantId, actionId)` runs after this
-     * resolves, never overlapping another delivery of the same Action. Send it
-     * after the transaction that made the Action pending commits.
-     */
-    deliver(tenantId: string, actionId: string): Promise<void>;
     /**
      * A pod sandbox's reconcile, or one of its timers (F7.2): see "One reconcile per sandbox
      * at a time". Absent where pods are not supported.
@@ -183,7 +153,7 @@ export interface StuckInvocation {
     handler: string;
     /**
      * Object key: `<tenantId>:<sessionId>`, `<tenantId>`, `<tenantId>:<timer key>` or
-     * `<tenantId>:<actionId>`.
+     * `<tenantId>:<sandboxId>`.
      */
     key: string;
     tenantId?: string;
@@ -191,7 +161,7 @@ export interface StuckInvocation {
     lastFailure?: string;
     modifiedAt?: string;
 }
-/** The key one advance (or one delivery, with an Action id) at a time is serialized on. */
+/** The key one advance (or one sandbox reconcile, with a sandbox id) at a time is serialized on. */
 export declare function sessionKey(tenantId: string, sessionId: string): string;
 /** Splits a key made by `sessionKey`. Tenant ids never contain `:`. */
 export declare function parseSessionKey(key: string): {

package/dist/execution/types.js

@@ -27,16 +27,7 @@
  *   becomes `uncertain` is settled in the Session Store and `advance` returns
  *   `done`.
  * - **Sweeps.** `armSweep` arms one self-re-arming sweep per Tenant; arming an
- *   armed Tenant is a no-op. The sweep settles lapsed deliveries and re-wakes
- *   orphaned `runnable` sessions.
- * - **One delivery per Action at a time.** `deliver` runs
- *   `WorkerHandlers.deliver` for the key `<tenantId>:<actionId>` at least once
- *   after it resolves. Two deliveries for one key never overlap; repeated
- *   `deliver` calls may each run it, so the handler reads the Action's state
- *   and does nothing when there is nothing to deliver.
- * - **Retry after `retry`.** A delivery that returns `retry` is run again for
- *   the same key after `retryAfterMs`. This is how an Action endpoint that is
- *   down or busy is retried; the handler throws only on infrastructure errors.
+ *   armed Tenant is a no-op. The sweep re-wakes orphaned `runnable` sessions.
  * - **One reconcile per sandbox at a time** (F7.2). `sandbox` runs
  *   `WorkerHandlers.sandbox` for the key `<tenantId>:<sandboxId>` at least once
  *   after a `reconcile` resolves, never overlapping another run for the key. A
@@ -49,13 +40,12 @@ export const WAKE_REASONS = [
     "message",
     "approve",
     "respond",
-    "action_result",
     "linked",
     "flow",
     "recover",
     "rollover",
 ];
-/** The key one advance (or one delivery, with an Action id) at a time is serialized on. */
+/** The key one advance (or one sandbox reconcile, with a sandbox id) at a time is serialized on. */
 export function sessionKey(tenantId, sessionId) {
     return `${tenantId}:${sessionId}`;
 }