@ekairos/events 1.22.34-beta.development.0 → 1.22.35

package/dist/context.engine.js

@@ -1,16 +1,21 @@
-import { registerContextEnv } from "./env.js";
+import { getContextRuntimeServices } from "./context.runtime.js";
 import { OUTPUT_ITEM_TYPE, WEB_CHANNEL } from "./context.events.js";
-import { applyToolExecutionResultToParts } from "./context.toolcalls.js";
+import { applyActionExecutionResultToParts } from "./context.action-calls.js";
 import { isContextPartEnvelope, normalizePartsForPersistence, } from "./context.parts.js";
-import { toolsToModelTools } from "./tools-to-model-tools.js";
 import { createAiSdkReactor, } from "./context.reactor.js";
-import { abortPersistedContextStepStream, closePersistedContextStepStream, createPersistedContextStepStream, closeContextStream, } from "./steps/stream.steps.js";
-import { completeExecution, createContextStep, initializeContext, saveTriggerAndCreateExecution, saveContextPartsStep, updateContextContent, updateContextStatus, updateItem, updateContextStep, } from "./steps/store.steps.js";
+import { abortPersistedContextStepStream, closeContextStream, createPersistedContextStepStreamForRuntime, finalizePersistedContextStepStreamForRuntime, writeActionResultPartChunksToSession, } from "./steps/stream.steps.js";
+import { completeExecution, completeExecutionStep, createContextStep, getContextItems, initializeContext, openExecutionStep, openExecution, saveExecutionStepOutput, updateContextContent, updateContextDefinition, updateContextReactor, updateContextStatus, updateItem, updateContextStep, updateExecutionWorkflowRun, upsertContextResources, } from "./steps/store.steps.js";
+import { readContextDurableWorkflowReturnValue, readContextDurableWorkflowStatus, resumeContextReturnValueHook, startContextDurableWorkflow, } from "./steps/durable.steps.js";
 import { getClientResumeHookUrl, toolApprovalHookToken, toolApprovalWebhookToken, } from "./context.hooks.js";
 import { getContextDurableWorkflow } from "./context.durable.js";
 export async function runContextReactionDirect(context, triggerEvent, params) {
     return await ContextEngine.runDirect(context, triggerEvent, params);
 }
+async function resolveReactRuntime(params) {
+    if (params.runtime)
+        return params.runtime;
+    throw new Error("ContextEngine.react requires runtime.");
+}
 export { toolApprovalHookToken, toolApprovalWebhookToken, getClientResumeHookUrl };
 function nowIso() {
     return new Date().toISOString();
@@ -24,13 +29,21 @@ function summarizePartPreview(part) {
     if (!part || typeof part !== "object")
         return {};
     if (isContextPartEnvelope(part)) {
-        const preview = part.content[0]?.type === "text"
-            ? part.content[0].text
-            : JSON.stringify(part.content[0] ?? part);
-        const state = "state" in part && typeof part.state === "string" ? part.state : undefined;
-        const toolCallId = "toolCallId" in part && typeof part.toolCallId === "string"
-            ? part.toolCallId
-            : undefined;
+        const preview = part.type === "message"
+            ? part.content.text ?? JSON.stringify(part.content.blocks?.[0] ?? part)
+            : part.type === "reasoning"
+                ? part.content.text
+                : part.type === "source"
+                    ? JSON.stringify(part.content.sources[0] ?? part)
+                    : part.content.status === "failed"
+                        ? part.content.error.message
+                        : JSON.stringify(part.content);
+        const state = part.type === "reasoning"
+            ? part.content.state
+            : part.type === "action"
+                ? part.content.status
+                : undefined;
+        const toolCallId = part.type === "action" ? part.content.actionCallId : undefined;
         return {
             partPreview: preview ? clipPreview(preview) : undefined,
             partState: state,
@@ -89,9 +102,39 @@ async function readActiveWorkflowRunId() {
         return null;
     }
 }
-async function createRuntimeOps(env, benchmark) {
-    const { getContextRuntime } = await import("./runtime.js");
-    const runtime = await getContextRuntime(env);
+function serializeContextReturnValueError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+        };
+    }
+    return {
+        message: String(error),
+    };
+}
+function unwrapContextReturnValueHookPayload(payload) {
+    if (payload.ok)
+        return payload.result;
+    const error = new Error(payload.error.message);
+    if (payload.error.name) {
+        error.name = payload.error.name;
+    }
+    if (payload.error.stack) {
+        error.stack = payload.error.stack;
+    }
+    throw error;
+}
+function isEmptyContextContent(content) {
+    if (content == null)
+        return true;
+    if (typeof content !== "object")
+        return false;
+    return Object.keys(content).length === 0;
+}
+async function createRuntimeOps(runtimeHandle, benchmark) {
+    const runtime = await getContextRuntimeServices(runtimeHandle);
     const { db } = runtime;
     const { InstantStore } = await import("./stores/instant.store.js");
     const requireContextId = (contextIdentifier) => {
@@ -145,13 +188,16 @@ async function createRuntimeOps(env, benchmark) {
             return { context, isNew: true };
         },
         updateContextContent: async (contextIdentifier, content) => await store.updateContextContent(contextIdentifier, content),
+        updateContextDefinition: async (contextIdentifier, definition) => await store.updateContextDefinition(contextIdentifier, definition),
+        upsertContextResources: async (contextIdentifier, resources) => await store.upsertContextResources(contextIdentifier, resources),
+        updateContextReactor: async (contextIdentifier, reactor) => await store.updateContextReactor(contextIdentifier, reactor),
         updateContextStatus: async (contextIdentifier, status) => await instrumentedDb.transact([
             instrumentedDb.tx.event_contexts[requireContextId(contextIdentifier)].update({
                 status,
                 updatedAt: new Date(),
             }),
         ]),
-        saveTriggerAndCreateExecution: async ({ contextIdentifier, triggerEvent }) => {
+        openExecution: async ({ contextIdentifier, triggerEvent }) => {
             const contextId = requireContextId(contextIdentifier);
             const triggerId = String(triggerEvent.id);
             const reactionId = makeRuntimeId();
@@ -209,6 +255,31 @@ async function createRuntimeOps(env, benchmark) {
                 },
             };
         },
+        openExecutionStep: async ({ contextIdentifier, content, executionId, iteration }) => {
+            const stepId = makeRuntimeId();
+            const now = new Date();
+            await instrumentedDb.transact([
+                instrumentedDb.tx.event_steps[stepId].create({
+                    createdAt: now,
+                    updatedAt: now,
+                    status: "running",
+                    iteration,
+                }),
+                instrumentedDb.tx.event_steps[stepId].link({ execution: executionId }),
+            ]);
+            const stream = await createPersistedContextStepStreamForRuntime({ db: instrumentedDb }, {
+                executionId,
+                stepId,
+            });
+            const context = await store.updateContextContent(contextIdentifier, content);
+            const events = await store.getItems(contextIdentifier);
+            return {
+                stepId,
+                stream,
+                context,
+                events,
+            };
+        },
         createContextStep: async ({ executionId, iteration }) => {
             const stepId = makeRuntimeId();
             await instrumentedDb.transact([
@@ -223,16 +294,67 @@ async function createRuntimeOps(env, benchmark) {
             return { stepId };
         },
         updateContextStep: async (params) => {
+            const update = { updatedAt: new Date() };
+            if (params.patch.status !== undefined)
+                update.status = params.patch.status;
+            if (params.patch.errorText !== undefined)
+                update.errorText = params.patch.errorText;
             await instrumentedDb.transact([
-                instrumentedDb.tx.event_steps[params.stepId].update({
-                    ...params.patch,
-                    updatedAt: new Date(),
-                }),
+                instrumentedDb.tx.event_steps[params.stepId].update(update),
             ]);
         },
-        saveContextPartsStep: async (params) => {
+        completeExecutionStep: async (params) => {
+            const actionResultChunkEvents = await writeActionResultPartChunksToSession({
+                session: params.session,
+                contextId: String(params.contextId ?? ""),
+                executionId: String(params.executionId ?? ""),
+                itemId: String(params.reactionEventId ?? ""),
+                actionResults: params.actionResults ?? [],
+            });
+            if (params.parts) {
+                await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
+            }
+            if (params.session) {
+                await finalizePersistedContextStepStreamForRuntime({
+                    runtime: { db: instrumentedDb },
+                    session: params.session,
+                    mode: "close",
+                });
+            }
+            const update = { updatedAt: new Date() };
+            update.status = params.stepStatus ?? "completed";
+            if (params.errorText !== undefined)
+                update.errorText = params.errorText;
+            await instrumentedDb.transact([
+                instrumentedDb.tx.event_steps[params.stepId].update(update),
+            ]);
+            if (!params.reactionEventId || !params.reactionEvent) {
+                return { actionResultChunkEvents };
+            }
+            await instrumentedDb.transact([
+                instrumentedDb.tx.event_items[params.reactionEventId].update(params.reactionEvent),
+            ]);
+            return {
+                reactionEvent: {
+                    ...params.reactionEvent,
+                    id: params.reactionEventId,
+                },
+                actionResultChunkEvents,
+            };
+        },
+        saveExecutionStepOutput: async (params) => {
             await store.saveStepParts({ stepId: params.stepId, parts: params.parts });
+            await instrumentedDb.transact([
+                instrumentedDb.tx.event_items[params.reactionEventId].update(params.reactionEvent),
+            ]);
+            return {
+                reactionEvent: {
+                    ...params.reactionEvent,
+                    id: params.reactionEventId,
+                },
+            };
         },
+        getItems: async (contextIdentifier) => await store.getItems(contextIdentifier),
         updateItem: async (itemId, item) => {
             await instrumentedDb.transact([instrumentedDb.tx.event_items[itemId].update(item)]);
             return {
@@ -240,9 +362,9 @@ async function createRuntimeOps(env, benchmark) {
                 id: itemId,
             };
         },
-        completeExecution: async (contextIdentifier, executionId, status) => {
+        completeExecution: async (contextIdentifier, executionId, status, opts) => {
             const contextId = requireContextId(contextIdentifier);
-            await instrumentedDb.transact([
+            const txs = [
                 instrumentedDb.tx.event_executions[executionId].update({
                     status,
                     updatedAt: new Date(),
@@ -251,38 +373,67 @@ async function createRuntimeOps(env, benchmark) {
                     status: "closed",
                     updatedAt: new Date(),
                 }),
-            ]);
+            ];
+            if (opts?.reactionEventId && opts.reactionEvent) {
+                txs.push(instrumentedDb.tx.event_items[opts.reactionEventId].update(opts.reactionEvent));
+            }
+            await instrumentedDb.transact(txs);
+            return opts?.reactionEventId && opts.reactionEvent
+                ? {
+                    reactionEvent: {
+                        ...opts.reactionEvent,
+                        id: opts.reactionEventId,
+                    },
+                }
+                : {};
         },
     };
 }
-async function createWorkflowOps(env) {
+async function createWorkflowOps(runtime) {
+    const env = runtime.env;
     return {
-        initializeContext: async (contextIdentifier, opts) => await initializeContext(env, contextIdentifier, opts),
-        updateContextContent: async (contextIdentifier, content) => await updateContextContent(env, contextIdentifier, content),
-        updateContextStatus: async (contextIdentifier, status) => await updateContextStatus(env, contextIdentifier, status),
-        saveTriggerAndCreateExecution: async ({ contextIdentifier, triggerEvent }) => await saveTriggerAndCreateExecution({ env, contextIdentifier, triggerEvent }),
-        createContextStep: async ({ executionId, iteration }) => await createContextStep({ env, executionId, iteration }),
-        updateContextStep: async (params) => await updateContextStep({ env, ...params }),
-        saveContextPartsStep: async (params) => await saveContextPartsStep({ env, ...params }),
-        updateItem: async (itemId, item, opts) => await updateItem(env, itemId, item, opts),
-        completeExecution: async (contextIdentifier, executionId, status) => await completeExecution(env, contextIdentifier, executionId, status),
+        initializeContext: async (contextIdentifier) => await initializeContext({ runtime, contextIdentifier }),
+        updateContextContent: async (contextIdentifier, content) => await updateContextContent({ runtime, contextIdentifier, content }),
+        updateContextDefinition: async (contextIdentifier, definition) => await updateContextDefinition({ runtime, contextIdentifier, definition }),
+        upsertContextResources: async (contextIdentifier, resources) => await upsertContextResources({ runtime, contextIdentifier, resources }),
+        updateContextReactor: async (contextIdentifier, reactor) => await updateContextReactor({ runtime, contextIdentifier, reactor }),
+        updateContextStatus: async (contextIdentifier, status) => await updateContextStatus({ runtime, contextIdentifier, status }),
+        openExecution: async ({ contextIdentifier, triggerEvent }) => await openExecution({ runtime, contextIdentifier, triggerEvent }),
+        openExecutionStep: async (params) => await openExecutionStep({ runtime, ...params }),
+        createContextStep: async ({ executionId, iteration }) => await createContextStep({ runtime, executionId, iteration }),
+        updateContextStep: async (params) => await updateContextStep({ runtime, ...params }),
+        completeExecutionStep: async (params) => await completeExecutionStep({ runtime, ...params }),
+        saveExecutionStepOutput: async (params) => await saveExecutionStepOutput({ runtime, ...params }),
+        getItems: async (contextIdentifier) => await getContextItems({ runtime, contextIdentifier }),
+        updateItem: async (itemId, item, opts) => await updateItem({ runtime, eventId: itemId, event: item, opts }),
+        completeExecution: async (contextIdentifier, executionId, status, opts) => await completeExecution({ runtime, contextIdentifier, executionId, status, ...opts }),
     };
 }
-async function getContextEngineOps(env, benchmark) {
+async function getContextEngineOps(runtime, benchmark) {
+    const env = runtime.env;
     const workflowRunId = await readActiveWorkflowRunId();
     if (workflowRunId) {
-        registerContextEnv(env, workflowRunId);
-        return await createWorkflowOps(env);
+        return await createWorkflowOps(runtime);
     }
-    registerContextEnv(env);
-    return await createRuntimeOps(env, benchmark);
+    return await createRuntimeOps(runtime, benchmark);
 }
 export class ContextEngine {
     constructor(opts = {}, reactor) {
         this.opts = opts;
-        this.reactor = reactor ?? createAiSdkReactor();
+        this.reactor =
+            reactor ??
+                createAiSdkReactor();
     }
-    async buildSkills(_context, _env) {
+    async describeContext(_content, _context, _env, _runtime) {
+        return null;
+    }
+    async defineGoal(_content, _context, _env, _runtime) {
+        return null;
+    }
+    async defineResources(_content, _context, _env, _runtime) {
+        return [];
+    }
+    async buildSkills(_context, _env, _runtime) {
         return [];
     }
     /**
@@ -302,13 +453,13 @@ export class ContextEngine {
      *   the builder) so results are durable and replay-safe.
      * - If it’s pure/deterministic, it can run in workflow context.
      */
-    async expandEvents(events, _context, _env) {
+    async expandEvents(events, _context, _env, _runtime) {
         return events;
     }
-    getModel(_context, _env) {
+    getModel(_context, _env, _runtime) {
         return "openai/gpt-5";
     }
-    getReactor(_context, _env) {
+    getReactor(_context, _env, _runtime) {
         return this.reactor;
     }
     /**
@@ -323,30 +474,36 @@ export class ContextEngine {
         return true;
     }
     async react(triggerEvent, params) {
-        if (params.durable) {
-            return await ContextEngine.startDurable(this, triggerEvent, params);
+        if (params.durable === false) {
+            return await ContextEngine.runDirect(this, triggerEvent, params);
         }
-        return await ContextEngine.runDirect(this, triggerEvent, params);
+        return await ContextEngine.startDurable(this, triggerEvent, params);
     }
     static async prepareExecutionShell(story, triggerEvent, params) {
-        const ops = await measureBenchmark(params.__benchmark, "react.resolveOpsMs", async () => await getContextEngineOps(params.env, params.__benchmark));
-        const silent = params.options?.silent ?? false;
-        const ctxResult = await measureBenchmark(params.__benchmark, "react.initializeContextMs", async () => await ops.initializeContext(params.context ?? null, { silent }));
+        const runtimeHandle = await resolveReactRuntime(params);
+        const env = runtimeHandle.env;
+        const ops = await measureBenchmark(params.__benchmark, "react.resolveOpsMs", async () => await getContextEngineOps(runtimeHandle, params.__benchmark));
+        const ctxResult = await measureBenchmark(params.__benchmark, "react.initializeContextMs", async () => await ops.initializeContext(params.context ?? null));
         let currentContext = ctxResult.context;
         const contextSelector = { id: String(currentContext.id) };
         if (ctxResult.isNew) {
-            await story.opts.onContextCreated?.({ env: params.env, context: currentContext });
+            await story.opts.onContextCreated?.({
+                env,
+                runtime: runtimeHandle,
+                context: currentContext,
+            });
         }
         if (currentContext.status === "closed") {
             await measureBenchmark(params.__benchmark, "react.reopenClosedContextMs", async () => await ops.updateContextStatus(contextSelector, "open_idle"));
             currentContext = { ...currentContext, status: "open_idle" };
         }
-        const shell = await measureBenchmark(params.__benchmark, "react.bootstrapShellMs", async () => await ops.saveTriggerAndCreateExecution({
+        const shell = await measureBenchmark(params.__benchmark, "react.openExecutionMs", async () => await ops.openExecution({
             contextIdentifier: contextSelector,
             triggerEvent,
         }));
         currentContext = { ...currentContext, status: "open_streaming" };
         return {
+            runtimeHandle,
             contextSelector,
             currentContext,
             trigger: shell.triggerEvent,
@@ -355,6 +512,8 @@ export class ContextEngine {
         };
     }
     static async startDurable(story, triggerEvent, params) {
+        const runtimeHandle = await resolveReactRuntime(params);
+        const env = runtimeHandle.env;
         if (params.options?.writable) {
             throw new Error("ContextEngine.react: durable runs manage their own workflow stream");
         }
@@ -364,44 +523,89 @@ export class ContextEngine {
         }
         const workflow = getContextDurableWorkflow();
         if (typeof workflow !== "function") {
-            throw new Error("ContextEngine.react: durable workflow is not configured. Call configureContextDurableWorkflow(...) in runtime bootstrap.");
+            const contextKeyLabel = contextKey || "(missing)";
+            throw new Error([
+                "ContextEngine.react(..., { durable: true }) needs a registered durable context workflow.",
+                "Call configureContextDurableWorkflow(contextDurableWorkflow) during server/workflow bootstrap.",
+                "If you want inline execution inside the current workflow step, pass durable: false.",
+                `Context key: ${contextKeyLabel}.`,
+            ].join(" "));
         }
         const shell = await ContextEngine.prepareExecutionShell(story, triggerEvent, params);
+        if (params.__initialContent !== undefined &&
+            isEmptyContextContent(shell.currentContext.content)) {
+            const ops = await getContextEngineOps(runtimeHandle, params.__benchmark);
+            const initialContent = params.__initialContent;
+            shell.currentContext = await ops.updateContextContent(shell.contextSelector, initialContent);
+        }
+        let run;
         try {
-            const [{ start }] = await Promise.all([
-                import("workflow/api"),
-            ]);
-            const run = await start(workflow, [
-                {
-                    contextKey,
-                    env: params.env,
-                    context: params.context ?? null,
-                    triggerEvent,
-                    options: {
-                        maxIterations: params.options?.maxIterations,
-                        maxModelSteps: params.options?.maxModelSteps,
-                        preventClose: params.options?.preventClose,
-                        sendFinish: params.options?.sendFinish,
-                        silent: params.options?.silent,
-                    },
-                    bootstrap: {
-                        contextId: shell.currentContext.id,
-                        trigger: shell.trigger,
-                        reaction: shell.reaction,
-                        execution: shell.execution,
-                    },
+            const parentWorkflowRunId = await readActiveWorkflowRunId();
+            let returnValueHook = null;
+            let returnValueHookPromise = null;
+            if (parentWorkflowRunId) {
+                try {
+                    const { createHook } = await import("workflow");
+                    const hook = createHook({
+                        token: `context:return:${shell.execution.id}`,
+                        metadata: {
+                            kind: "context.returnValue",
+                            contextId: shell.currentContext.id,
+                            executionId: shell.execution.id,
+                            parentWorkflowRunId,
+                        },
+                    });
+                    returnValueHook = {
+                        token: hook.token,
+                        parentWorkflowRunId,
+                    };
+                    returnValueHookPromise = Promise.resolve(hook);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (!message.includes("can only be called inside a workflow function")) {
+                        throw error;
+                    }
+                }
+            }
+            const payload = {
+                contextKey,
+                runtime: runtimeHandle,
+                context: params.context ?? null,
+                triggerEvent,
+                options: {
+                    maxIterations: params.options?.maxIterations,
+                    maxModelSteps: params.options?.maxModelSteps,
+                    preventClose: params.options?.preventClose,
+                    sendFinish: params.options?.sendFinish,
                 },
-            ]);
-            const runtime = await createRuntimeOps(params.env);
-            await runtime.db.transact([
-                runtime.db.tx.event_executions[shell.execution.id].update({
-                    workflowRunId: run.runId,
-                    updatedAt: new Date(),
-                }),
-            ]);
+                bootstrap: {
+                    contextId: shell.currentContext.id,
+                    trigger: shell.trigger,
+                    reaction: shell.reaction,
+                    execution: shell.execution,
+                    returnValueHookToken: returnValueHook?.token ?? null,
+                },
+            };
+            const startedRun = await measureBenchmark(params.__benchmark, "react.durable.startWorkflowMs", async () => await startContextDurableWorkflow({ payload }));
+            run = {
+                runId: String(startedRun.runId),
+                status: readContextDurableWorkflowStatus({ runId: String(startedRun.runId) }),
+                returnValue: returnValueHookPromise
+                    ? returnValueHookPromise.then(unwrapContextReturnValueHookPayload)
+                    : readContextDurableWorkflowReturnValue({
+                        runId: String(startedRun.runId),
+                    }),
+                returnValueHook,
+            };
+            await measureBenchmark(params.__benchmark, "react.durable.persistWorkflowRunIdMs", async () => await updateExecutionWorkflowRun({
+                runtime: runtimeHandle,
+                executionId: shell.execution.id,
+                workflowRunId: String(startedRun.runId),
+            }));
         }
         catch (error) {
-            const ops = await getContextEngineOps(params.env, params.__benchmark);
+            const ops = await getContextEngineOps(runtimeHandle, params.__benchmark);
             await ops.completeExecution(shell.contextSelector, shell.execution.id, "failed").catch(() => null);
             throw error;
         }
@@ -410,21 +614,52 @@ export class ContextEngine {
             trigger: shell.trigger,
             reaction: shell.reaction,
             execution: shell.execution,
+            run,
         };
     }
     static async runDirect(story, triggerEvent, params) {
-        const ops = await measureBenchmark(params.__benchmark, "react.resolveOpsMs", async () => await getContextEngineOps(params.env, params.__benchmark));
+        if (!params.__bootstrap) {
+            const shell = await ContextEngine.prepareExecutionShell(story, triggerEvent, params);
+            const run = ContextEngine.runDirect(story, triggerEvent, {
+                ...params,
+                runtime: shell.runtimeHandle,
+                __bootstrap: {
+                    contextId: shell.currentContext.id,
+                    trigger: shell.trigger,
+                    reaction: shell.reaction,
+                    execution: shell.execution,
+                },
+            });
+            return {
+                context: shell.currentContext,
+                trigger: shell.trigger,
+                reaction: shell.reaction,
+                execution: shell.execution,
+                run,
+            };
+        }
+        const runtimeHandle = await resolveReactRuntime(params);
+        const env = runtimeHandle.env;
+        const ops = await measureBenchmark(params.__benchmark, "react.resolveOpsMs", async () => await getContextEngineOps(runtimeHandle, params.__benchmark));
         const maxIterations = params.options?.maxIterations ?? 20;
         const maxModelSteps = params.options?.maxModelSteps ?? 1;
         const preventClose = params.options?.preventClose ?? false;
         const sendFinish = params.options?.sendFinish ?? true;
-        const silent = params.options?.silent ?? false;
         const writable = params.options?.writable;
         const bootstrapped = params.__bootstrap;
+        const returnValueHookToken = bootstrapped?.returnValueHookToken ?? null;
+        const resumeReturnValueHook = async (payload) => {
+            if (!returnValueHookToken)
+                return;
+            await resumeContextReturnValueHook({
+                token: returnValueHookToken,
+                payload,
+            });
+        };
         const shell = bootstrapped
             ? {
                 contextSelector: { id: String(bootstrapped.contextId) },
-                currentContext: (await measureBenchmark(params.__benchmark, "react.bootstrapContextLookupMs", async () => await ops.initializeContext({ id: String(bootstrapped.contextId) }, { silent }))).context,
+                currentContext: (await measureBenchmark(params.__benchmark, "react.bootstrapContextLookupMs", async () => await ops.initializeContext({ id: String(bootstrapped.contextId) }))).context,
                 trigger: bootstrapped.trigger,
                 reaction: bootstrapped.reaction,
                 execution: bootstrapped.execution,
@@ -447,7 +682,6 @@ export class ContextEngine {
                 execution = { ...execution, status: "failed" };
                 updatedContext = { ...updatedContext, status: "closed" };
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: [
                         {
@@ -470,9 +704,7 @@ export class ContextEngine {
                 // noop
             }
             try {
-                if (!silent) {
-                    await closeContextStream({ preventClose, sendFinish, writable });
-                }
+                await closeContextStream({ preventClose, sendFinish, writable });
             }
             catch {
                 // noop
@@ -480,55 +712,102 @@ export class ContextEngine {
         };
         try {
             for (let iter = 0; iter < maxIterations; iter++) {
-                // Create a persisted step per iteration (IDs generated in step runtime for replay safety)
                 const stagePrefix = `react.iteration.${iter}`;
-                const stepCreate = await measureBenchmark(params.__benchmark, `${stagePrefix}.createStepMs`, async () => await ops.createContextStep({
+                runtimeHandle.__ekairosContextRun = {
+                    contextId: currentContext.id,
                     executionId,
+                    triggerEventId,
+                    reactionEventId,
                     iteration: iter,
-                }));
-                currentStepId = stepCreate.stepId;
-                currentStepStream = await createPersistedContextStepStream({
-                    env: params.env,
+                };
+                // Hook: Context DSL `context()` (implemented by subclasses via `initialize()`)
+                const nextContent = await measureBenchmark(params.__benchmark, `${stagePrefix}.contextMs`, async () => await story.initialize(updatedContext, env, runtimeHandle));
+                const openedStep = await measureBenchmark(params.__benchmark, `${stagePrefix}.openExecutionStepMs`, async () => await ops.openExecutionStep({
+                    contextIdentifier: activeContextSelector,
+                    content: nextContent,
                     executionId,
-                    stepId: stepCreate.stepId,
-                });
+                    iteration: iter,
+                }));
+                currentStepId = openedStep.stepId;
+                currentStepStream = openedStep.stream;
+                updatedContext = openedStep.context;
+                const rawEvents = openedStep.events;
+                const previousResources = updatedContext.resources ?? [];
+                const resources = await measureBenchmark(params.__benchmark, `${stagePrefix}.resourcesMs`, async () => await story.defineResources(nextContent, updatedContext, env, runtimeHandle));
+                const shouldPersistResources = resources.length > 0 || previousResources.length > 0;
+                let contextResources = previousResources;
+                if (shouldPersistResources) {
+                    contextResources = await measureBenchmark(params.__benchmark, `${stagePrefix}.contextResourcesMs`, async () => await ops.upsertContextResources(activeContextSelector, resources));
+                    updatedContext = {
+                        ...updatedContext,
+                        resources: contextResources,
+                    };
+                }
+                else {
+                    updatedContext = {
+                        ...updatedContext,
+                        resources: [],
+                    };
+                }
+                const description = await measureBenchmark(params.__benchmark, `${stagePrefix}.descriptionMs`, async () => await story.describeContext(nextContent, updatedContext, env, runtimeHandle));
+                const goal = await measureBenchmark(params.__benchmark, `${stagePrefix}.goalMs`, async () => await story.defineGoal(nextContent, updatedContext, env, runtimeHandle));
+                if (description !== null || goal !== null) {
+                    updatedContext = await measureBenchmark(params.__benchmark, `${stagePrefix}.contextDefinitionMs`, async () => await ops.updateContextDefinition(activeContextSelector, {
+                        ...(description !== null ? { description } : {}),
+                        ...(goal !== null ? { goal } : {}),
+                    }));
+                    updatedContext = {
+                        ...updatedContext,
+                        resources: contextResources,
+                    };
+                }
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: [
                         {
                             type: "step.created",
                             at: nowIso(),
-                            stepId: String(stepCreate.stepId),
+                            stepId: String(openedStep.stepId),
                             executionId,
                             iteration: iter,
                             status: "running",
                         },
-                    ],
-                });
-                // Hook: Context DSL `context()` (implemented by subclasses via `initialize()`)
-                const nextContent = await measureBenchmark(params.__benchmark, `${stagePrefix}.contextMs`, async () => await story.initialize(updatedContext, params.env));
-                updatedContext = await measureBenchmark(params.__benchmark, `${stagePrefix}.persistContextMs`, async () => await ops.updateContextContent(activeContextSelector, nextContent));
-                await emitContextEvents({
-                    silent,
-                    writable,
-                    events: [
                         {
                             type: "context.content_updated",
                             at: nowIso(),
                             contextId: String(updatedContext.id),
                         },
+                        ...(description !== null || goal !== null
+                            ? [
+                                {
+                                    type: "context.definition_updated",
+                                    at: nowIso(),
+                                    contextId: String(updatedContext.id),
+                                },
+                            ]
+                            : []),
+                        ...(shouldPersistResources
+                            ? [
+                                {
+                                    type: "context.resources_updated",
+                                    at: nowIso(),
+                                    contextId: String(updatedContext.id),
+                                },
+                            ]
+                            : []),
                     ],
                 });
-                await story.opts.onContextUpdated?.({ env: params.env, context: updatedContext });
+                await story.opts.onContextUpdated?.({
+                    env,
+                    runtime: runtimeHandle,
+                    context: updatedContext,
+                });
                 // Hook: Context DSL `narrative()` (implemented by subclasses via `buildSystemPrompt()`)
-                const systemPrompt = await measureBenchmark(params.__benchmark, `${stagePrefix}.narrativeMs`, async () => await story.buildSystemPrompt(updatedContext, params.env));
+                const systemPrompt = await measureBenchmark(params.__benchmark, `${stagePrefix}.narrativeMs`, async () => await story.buildSystemPrompt(updatedContext, env, runtimeHandle));
                 // Hook: Context DSL `actions()` (implemented by subclasses via `buildTools()`)
-                const toolsAll = await measureBenchmark(params.__benchmark, `${stagePrefix}.actionsMs`, async () => await story.buildTools(updatedContext, params.env));
-                const skillsAll = await measureBenchmark(params.__benchmark, `${stagePrefix}.skillsMs`, async () => await story.buildSkills(updatedContext, params.env));
-                // IMPORTANT: step args must be serializable.
-                // Match DurableAgent behavior: convert tool input schemas to plain JSON Schema in workflow context.
-                const toolsForModel = toolsToModelTools(toolsAll);
+                const toolsAll = await measureBenchmark(params.__benchmark, `${stagePrefix}.actionsMs`, async () => await story.buildTools(updatedContext, env, runtimeHandle));
+                const skillsAll = await measureBenchmark(params.__benchmark, `${stagePrefix}.skillsMs`, async () => await story.buildSkills(updatedContext, env, runtimeHandle));
+                const expandedEvents = await measureBenchmark(params.__benchmark, `${stagePrefix}.expandEventsMs`, async () => await story.expandEvents(rawEvents, updatedContext, env, runtimeHandle));
                 // Execute model reaction for this iteration using the stable reaction event id.
                 //
                 // IMPORTANT:
@@ -536,7 +815,7 @@ export class ContextEngine {
                 // If we stream with a per-step id, the UI will render an optimistic assistant message
                 // (step id) and then a second persisted assistant message (reaction id) with the same
                 // content once InstantDB updates.
-                const reactor = story.getReactor(updatedContext, params.env);
+                const reactor = story.getReactor(updatedContext, env, runtimeHandle);
                 const reactionPartsBeforeStep = Array.isArray(reactionEvent.content?.parts)
                     ? [...reactionEvent.content.parts]
                     : [];
@@ -547,45 +826,48 @@ export class ContextEngine {
                     if (nextSignature === persistedReactionPartsSignature)
                         return;
                     persistedReactionPartsSignature = nextSignature;
-                    await ops.saveContextPartsStep({
-                        stepId: stepCreate.stepId,
+                    const saved = await ops.saveExecutionStepOutput({
+                        stepId: openedStep.stepId,
                         parts: normalizedParts,
+                        reactionEventId: reactionEvent.id,
+                        reactionEvent: {
+                            ...reactionEvent,
+                            content: {
+                                ...reactionEvent.content,
+                                parts: [...reactionPartsBeforeStep, ...normalizedParts],
+                            },
+                            status: "pending",
+                        },
                         executionId,
                         contextId: String(currentContext.id),
                         iteration: iter,
                     });
-                    reactionEvent = await ops.updateItem(reactionEvent.id, {
-                        ...reactionEvent,
-                        content: {
-                            ...reactionEvent.content,
-                            parts: [...reactionPartsBeforeStep, ...normalizedParts],
-                        },
-                        status: "pending",
-                    }, { executionId, contextId: String(currentContext.id) });
+                    reactionEvent = saved.reactionEvent;
                 };
-                const { assistantEvent, actionRequests, messagesForModel } = await measureBenchmark(params.__benchmark, `${stagePrefix}.reactorMs`, async () => await reactor({
-                    env: params.env,
+                const reactionResult = await measureBenchmark(params.__benchmark, `${stagePrefix}.reactorMs`, async () => await reactor({
+                    runtime: runtimeHandle,
                     context: updatedContext,
                     contextIdentifier: activeContextSelector,
+                    resources: contextResources,
+                    events: expandedEvents,
                     triggerEvent,
-                    model: story.getModel(updatedContext, params.env),
+                    model: story.getModel(updatedContext, env, runtimeHandle),
                     systemPrompt,
                     actions: toolsAll,
-                    toolsForModel,
                     skills: skillsAll,
                     eventId: reactionEventId,
                     executionId,
                     contextId: String(currentContext.id),
-                    stepId: String(stepCreate.stepId),
+                    stepId: String(openedStep.stepId),
                     iteration: iter,
                     maxModelSteps,
                     // Only emit a `start` chunk once per story turn.
-                    sendStart: !silent && iter === 0,
-                    silent,
+                    sendStart: iter === 0,
                     contextStepStream: currentStepStream?.stream,
                     writable,
                     persistReactionParts,
                 }));
+                const { assistantEvent, actionRequests, messagesForModel } = reactionResult;
                 const reviewRequests = actionRequests.length > 0
                     ? actionRequests.flatMap((actionRequest) => {
                         const toolDef = toolsAll[actionRequest.actionName];
@@ -614,21 +896,34 @@ export class ContextEngine {
                         parts: stepParts,
                     },
                 };
-                await measureBenchmark(params.__benchmark, `${stagePrefix}.saveStepPartsMs`, async () => await ops.saveContextPartsStep({
-                    stepId: stepCreate.stepId,
+                const nextAssistantParts = Array.isArray(assistantEventEffective.content?.parts)
+                    ? assistantEventEffective.content.parts
+                    : [];
+                const nextReactionEvent = {
+                    ...reactionEvent,
+                    content: {
+                        ...reactionEvent.content,
+                        parts: [...reactionPartsBeforeStep, ...nextAssistantParts],
+                    },
+                    status: "pending",
+                };
+                const appendedReactorOutput = await measureBenchmark(params.__benchmark, `${stagePrefix}.saveExecutionStepOutputMs`, async () => await ops.saveExecutionStepOutput({
+                    stepId: openedStep.stepId,
                     parts: stepParts,
+                    reactionEventId: reactionEvent.id,
+                    reactionEvent: nextReactionEvent,
                     executionId,
                     contextId: String(currentContext.id),
                     iteration: iter,
                 }));
+                reactionEvent = appendedReactorOutput.reactionEvent;
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: stepParts.map((part, idx) => ({
                         type: "part.created",
                         at: nowIso(),
-                        partKey: `${String(stepCreate.stepId)}:${idx}`,
-                        stepId: String(stepCreate.stepId),
+                        partKey: `${String(openedStep.stepId)}:${idx}`,
+                        stepId: String(openedStep.stepId),
                         idx,
                         partType: part && typeof part.type === "string"
                             ? String(part.type)
@@ -636,60 +931,26 @@ export class ContextEngine {
                         ...summarizePartPreview(part),
                     })),
                 });
-                // Persist/append the aggregated reaction event (stable `reactionEventId` for the execution).
-                const nextAssistantParts = Array.isArray(assistantEventEffective.content?.parts)
-                    ? assistantEventEffective.content.parts
-                    : [];
-                const nextReactionEvent = {
-                    ...reactionEvent,
-                    content: {
-                        ...reactionEvent.content,
-                        parts: [...reactionPartsBeforeStep, ...nextAssistantParts],
-                    },
-                    status: "pending",
-                };
-                reactionEvent = await measureBenchmark(params.__benchmark, `${stagePrefix}.persistAssistantReactionMs`, async () => await ops.updateItem(reactionEvent.id, nextReactionEvent, { executionId, contextId: String(currentContext.id) }));
-                if (currentStepStream) {
-                    await closePersistedContextStepStream({
-                        env: params.env,
-                        session: currentStepStream,
-                    });
-                    currentStepStream = null;
+                if (reactionResult.reactor?.kind) {
+                    updatedContext = await measureBenchmark(params.__benchmark, `${stagePrefix}.persistReactorStateMs`, async () => await ops.updateContextReactor(activeContextSelector, {
+                        kind: reactionResult.reactor.kind,
+                        state: {
+                            ...(reactionResult.reactor.state ?? {}),
+                            updatedAt: nowIso(),
+                        },
+                    }));
                 }
                 story.opts.onEventCreated?.(assistantEventEffective);
-                const firstActionRequest = actionRequests?.[0];
-                await measureBenchmark(params.__benchmark, `${stagePrefix}.markStepRunningMs`, async () => await ops.updateContextStep({
-                    stepId: stepCreate.stepId,
-                    patch: firstActionRequest
-                        ? {
-                            kind: "action_execute",
-                            actionName: typeof firstActionRequest.actionName === "string"
-                                ? firstActionRequest.actionName
-                                : undefined,
-                            actionInput: firstActionRequest.input,
-                        }
-                        : {
-                            kind: "message",
-                        },
-                    executionId,
-                    contextId: String(currentContext.id),
-                    iteration: iter,
-                }));
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: [
                         {
                             type: "step.updated",
                             at: nowIso(),
-                            stepId: String(stepCreate.stepId),
+                            stepId: String(openedStep.stepId),
                             executionId,
                             iteration: iter,
                             status: "running",
-                            kind: firstActionRequest ? "action_execute" : "message",
-                            actionName: firstActionRequest && typeof firstActionRequest.actionName === "string"
-                                ? firstActionRequest.actionName
-                                : undefined,
                         },
                     ],
                 });
@@ -697,50 +958,45 @@ export class ContextEngine {
                 if (!actionRequests.length) {
                     const endResult = await story.callOnEnd(assistantEventEffective);
                     if (endResult) {
-                        // Mark iteration step completed (no tools)
-                        await measureBenchmark(params.__benchmark, `${stagePrefix}.finalizeMessageStepMs`, async () => await ops.updateContextStep({
-                            stepId: stepCreate.stepId,
-                            patch: {
-                                status: "completed",
-                                kind: "message",
-                                actionRequests: [],
-                                actionResults: [],
-                                continueLoop: false,
-                            },
+                        const completedReactionEvent = {
+                            ...reactionEvent,
+                            status: "completed",
+                        };
+                        const finalized = await measureBenchmark(params.__benchmark, `${stagePrefix}.completeExecutionStepMs`, async () => await ops.completeExecutionStep({
+                            session: currentStepStream,
+                            stepId: openedStep.stepId,
+                            stepStatus: "completed",
+                            reactionEventId,
+                            reactionEvent: completedReactionEvent,
                             executionId,
                             contextId: String(currentContext.id),
                             iteration: iter,
                         }));
+                        currentStepStream = null;
+                        currentStepId = null;
+                        reactionEvent = finalized.reactionEvent ?? completedReactionEvent;
                         await emitContextEvents({
-                            silent,
                             writable,
                             events: [
                                 {
                                     type: "step.updated",
                                     at: nowIso(),
-                                    stepId: String(stepCreate.stepId),
+                                    stepId: String(openedStep.stepId),
                                     executionId,
                                     iteration: iter,
                                     status: "completed",
-                                    kind: "message",
                                 },
                                 {
                                     type: "step.completed",
                                     at: nowIso(),
-                                    stepId: String(stepCreate.stepId),
+                                    stepId: String(openedStep.stepId),
                                     executionId,
                                     iteration: iter,
                                     status: "completed",
                                 },
                             ],
                         });
-                        // Mark reaction event completed
-                        await measureBenchmark(params.__benchmark, `${stagePrefix}.completeReactionMs`, async () => await ops.updateItem(reactionEventId, {
-                            ...reactionEvent,
-                            status: "completed",
-                        }, { executionId, contextId: String(currentContext.id) }));
                         await emitContextEvents({
-                            silent,
                             writable,
                             events: [
                                 {
@@ -757,7 +1013,6 @@ export class ContextEngine {
                         execution = { ...execution, status: "completed" };
                         updatedContext = { ...updatedContext, status: "closed" };
                         await emitContextEvents({
-                            silent,
                             writable,
                             events: [
                                 {
@@ -775,19 +1030,15 @@ export class ContextEngine {
                                 },
                             ],
                         });
-                        if (!silent) {
-                            await closeContextStream({ preventClose, sendFinish, writable });
-                        }
-                        reactionEvent = {
-                            ...reactionEvent,
-                            status: "completed",
-                        };
-                        return {
+                        await closeContextStream({ preventClose, sendFinish, writable });
+                        const result = {
                             context: updatedContext,
                             trigger,
                             reaction: reactionEvent,
                             execution,
                         };
+                        await resumeReturnValueHook({ ok: true, result });
+                        return result;
                     }
                 }
                 // Execute actions (workflow context; action implementations decide step vs workflow)
@@ -807,9 +1058,8 @@ export class ContextEngine {
                             const { createHook, createWebhook } = await import("workflow");
                             const toolCallId = String(actionRequest.actionRef);
                             const hookToken = toolApprovalHookToken({ executionId, toolCallId });
-                            const webhookToken = toolApprovalWebhookToken({ executionId, toolCallId });
                             const hook = createHook({ token: hookToken });
-                            const webhook = createWebhook({ token: webhookToken });
+                            const webhook = createWebhook();
                             const approvalOrRequest = await Promise.race([
                                 hook.then((approval) => ({ source: "hook", approval })),
                                 webhook.then((request) => ({ source: "webhook", request })),
@@ -831,14 +1081,21 @@ export class ContextEngine {
                                 actionInput = approval.args;
                             }
                         }
-                        const output = await toolDef.execute(actionInput, {
-                            toolCallId: actionRequest.actionRef,
-                            messages: messagesForModel,
-                            eventId: reactionEventId,
-                            executionId,
-                            triggerEventId,
-                            contextId: currentContext.id,
-                        });
+                        const executeAction = toolDef.execute;
+                        const output = await Reflect.apply(executeAction, undefined, [actionInput, {
+                                runtime: runtimeHandle,
+                                context: updatedContext,
+                                contextIdentifier: activeContextSelector,
+                                toolCallId: actionRequest.actionRef,
+                                messages: messagesForModel,
+                                eventId: reactionEventId,
+                                executionId,
+                                triggerEventId,
+                                contextId: currentContext.id,
+                                stepId: String(openedStep.stepId),
+                                iteration: iter,
+                                contextStepStream: currentStepStream?.stream,
+                            }]);
                         return { actionRequest, success: true, output };
                     }
                     catch (e) {
@@ -850,26 +1107,19 @@ export class ContextEngine {
                         };
                     }
                 })));
-                // Merge action results into persisted parts (so next LLM call can see them)
+                // Merge action results into step parts so the next reaction can see them.
                 let finalizedStepParts = Array.isArray(stepParts) ? [...stepParts] : [];
                 for (const r of actionResults) {
-                    finalizedStepParts = applyToolExecutionResultToParts(finalizedStepParts, {
-                        toolCallId: r.actionRequest.actionRef,
-                        toolName: r.actionRequest.actionName,
+                    finalizedStepParts = applyActionExecutionResultToParts(finalizedStepParts, {
+                        actionCallId: r.actionRequest.actionRef,
+                        actionName: r.actionRequest.actionName,
                     }, {
                         success: Boolean(r.success),
                         result: r.output,
                         message: r.errorText,
                     });
                 }
-                await measureBenchmark(params.__benchmark, `${stagePrefix}.saveFinalStepPartsMs`, async () => await ops.saveContextPartsStep({
-                    stepId: stepCreate.stepId,
-                    parts: finalizedStepParts,
-                    executionId,
-                    contextId: String(currentContext.id),
-                    iteration: iter,
-                }));
-                reactionEvent = {
+                const pendingReactionEvent = {
                     ...reactionEvent,
                     content: {
                         ...reactionEvent.content,
@@ -879,85 +1129,70 @@ export class ContextEngine {
                     },
                     status: "pending",
                 };
-                // Callback for observability/integration
-                for (const r of actionResults) {
-                    await story.opts.onActionExecuted?.({
-                        actionRequest: r.actionRequest,
-                        success: r.success,
-                        output: r.output,
-                        errorText: r.errorText,
-                        eventId: reactionEventId,
-                        executionId,
-                    });
-                }
-                // Stop/continue boundary: allow the Context to decide if the loop should continue.
-                // IMPORTANT: we call this after tool results have been merged into the persisted `reactionEvent`,
-                // so stories can inspect `reactionEvent.content.parts` deterministically.
-                const continueLoop = await measureBenchmark(params.__benchmark, `${stagePrefix}.shouldContinueMs`, async () => await story.shouldContinue({
-                    env: params.env,
-                    context: updatedContext,
-                    reactionEvent,
-                    assistantEvent: assistantEventEffective,
-                    actionRequests,
+                const completedStep = await measureBenchmark(params.__benchmark, `${stagePrefix}.completeExecutionStepMs`, async () => await ops.completeExecutionStep({
+                    session: currentStepStream,
+                    stepId: openedStep.stepId,
+                    parts: finalizedStepParts,
                     actionResults: actionResults,
-                }));
-                // Persist per-iteration step outcome (tools + continue signal)
-                await measureBenchmark(params.__benchmark, `${stagePrefix}.completeStepMs`, async () => await ops.updateContextStep({
-                    stepId: stepCreate.stepId,
-                    patch: {
-                        status: "completed",
-                        kind: actionRequests?.length ? "action_result" : "message",
-                        actionName: typeof actionResults?.[0]?.actionRequest?.actionName === "string"
-                            ? actionResults[0].actionRequest.actionName
-                            : undefined,
-                        actionInput: actionResults?.[0]?.actionRequest?.input,
-                        actionOutput: actionResults?.[0]?.success === true
-                            ? actionResults[0]?.output
-                            : undefined,
-                        actionError: actionResults?.[0]?.success === false
-                            ? String(actionResults[0]?.errorText ?? "action_execution_failed")
-                            : undefined,
-                        actionRequests,
-                        actionResults,
-                        continueLoop: continueLoop !== false,
-                    },
+                    stepStatus: "completed",
+                    reactionEventId,
+                    reactionEvent: pendingReactionEvent,
                     executionId,
                     contextId: String(currentContext.id),
                     iteration: iter,
                 }));
+                currentStepStream = null;
+                currentStepId = null;
+                reactionEvent = completedStep.reactionEvent ?? pendingReactionEvent;
+                await emitContextEvents({
+                    writable,
+                    events: completedStep.actionResultChunkEvents,
+                });
                 await emitContextEvents({
-                    silent,
                     writable,
                     events: [
                         {
                             type: "step.updated",
                             at: nowIso(),
-                            stepId: String(stepCreate.stepId),
+                            stepId: String(openedStep.stepId),
                             executionId,
                             iteration: iter,
                             status: "completed",
-                            kind: actionRequests?.length ? "action_result" : "message",
-                            actionName: typeof actionResults?.[0]?.actionRequest?.actionName === "string"
-                                ? actionResults[0].actionRequest.actionName
-                                : undefined,
                         },
                         {
                             type: "step.completed",
                             at: nowIso(),
-                            stepId: String(stepCreate.stepId),
+                            stepId: String(openedStep.stepId),
                             executionId,
                             iteration: iter,
                             status: "completed",
                         },
                     ],
                 });
+                // Callback for observability/integration
+                for (const r of actionResults) {
+                    await story.opts.onActionExecuted?.({
+                        actionRequest: r.actionRequest,
+                        success: r.success,
+                        output: r.output,
+                        errorText: r.errorText,
+                        eventId: reactionEventId,
+                        executionId,
+                    });
+                }
+                // Stop/continue boundary: allow the Context to decide if the loop should continue.
+                // Tool results are already persisted in the completed reaction step here.
+                const continueLoop = await measureBenchmark(params.__benchmark, `${stagePrefix}.shouldContinueMs`, async () => await story.shouldContinue({
+                    env,
+                    runtime: runtimeHandle,
+                    context: updatedContext,
+                    reactionEvent,
+                    assistantEvent: assistantEventEffective,
+                    actionRequests,
+                    actionResults: actionResults,
+                }));
                 if (continueLoop !== false) {
-                    reactionEvent = await measureBenchmark(params.__benchmark, `${stagePrefix}.persistPendingReactionMs`, async () => await ops.updateItem(reactionEventId, {
-                        ...reactionEvent,
-                        status: "pending",
-                    }, { executionId, contextId: String(currentContext.id) }));
                     await emitContextEvents({
-                        silent,
                         writable,
                         events: [
                             {
@@ -972,12 +1207,11 @@ export class ContextEngine {
                     });
                 }
                 if (continueLoop === false) {
-                    await measureBenchmark(params.__benchmark, `${stagePrefix}.completeReactionMs`, async () => await ops.updateItem(reactionEventId, {
+                    reactionEvent = {
                         ...reactionEvent,
                         status: "completed",
-                    }, { executionId, contextId: String(currentContext.id) }));
+                    };
                     await emitContextEvents({
-                        silent,
                         writable,
                         events: [
                             {
@@ -990,11 +1224,14 @@ export class ContextEngine {
                             },
                         ],
                     });
-                    await measureBenchmark(params.__benchmark, `${stagePrefix}.completeExecutionMs`, async () => await ops.completeExecution(activeContextSelector, executionId, "completed"));
+                    await measureBenchmark(params.__benchmark, `${stagePrefix}.completeExecutionMs`, async () => await ops.completeExecution(activeContextSelector, executionId, "completed", {
+                        contextId: String(currentContext.id),
+                        reactionEventId,
+                        reactionEvent,
+                    }));
                     execution = { ...execution, status: "completed" };
                     updatedContext = { ...updatedContext, status: "closed" };
                     await emitContextEvents({
-                        silent,
                         writable,
                         events: [
                             {
@@ -1012,19 +1249,15 @@ export class ContextEngine {
                             },
                         ],
                     });
-                    if (!silent) {
-                        await closeContextStream({ preventClose, sendFinish, writable });
-                    }
-                    reactionEvent = {
-                        ...reactionEvent,
-                        status: "completed",
-                    };
-                    return {
+                    await closeContextStream({ preventClose, sendFinish, writable });
+                    const result = {
                         context: updatedContext,
                         trigger,
                         reaction: reactionEvent,
                         execution,
                     };
+                    await resumeReturnValueHook({ ok: true, result });
+                    return result;
                 }
             }
             throw new Error(`ContextEngine: maxIterations reached (${maxIterations}) without completion`);
@@ -1033,7 +1266,7 @@ export class ContextEngine {
             if (currentStepStream) {
                 try {
                     await abortPersistedContextStepStream({
-                        env: params.env,
+                        runtime: runtimeHandle,
                         session: currentStepStream,
                         reason: error instanceof Error ? error.message : String(error),
                     });
@@ -1059,7 +1292,6 @@ export class ContextEngine {
                         contextId: String(currentContext.id),
                     }));
                     await emitContextEvents({
-                        silent,
                         writable,
                         events: [
                             {
@@ -1078,6 +1310,10 @@ export class ContextEngine {
                 }
             }
             await failExecution();
+            await resumeReturnValueHook({
+                ok: false,
+                error: serializeContextReturnValueError(error),
+            }).catch(() => null);
             throw error;
         }
     }