@axlsdk/axl 0.19.1 → 0.20.0

package/dist/index.js

@@ -1,130 +1,9 @@
 import {
   __require
-} from "./chunk-JBLQKU6X.js";
+} from "./chunk-NVPA4RY6.js";
 
 // src/tool.ts
-var DEFAULT_MAX_STRING_LENGTH = 1e4;
-function validateStringLengths(value, maxLen, path = "") {
-  if (typeof value === "string") {
-    if (value.length > maxLen) {
-      throw new Error(
-        `String argument${path ? ` at "${path}"` : ""} exceeds maximum length (${value.length} > ${maxLen})`
-      );
-    }
-  } else if (Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      validateStringLengths(value[i], maxLen, path ? `${path}[${i}]` : `[${i}]`);
-    }
-  } else if (value !== null && typeof value === "object") {
-    for (const [key, val] of Object.entries(value)) {
-      validateStringLengths(val, maxLen, path ? `${path}.${key}` : key);
-    }
-  }
-}
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-function getBackoffMs(attempt, strategy) {
-  switch (strategy) {
-    case "none":
-      return 0;
-    case "linear":
-      return attempt * 1e3;
-    case "exponential":
-      return Math.pow(2, attempt - 1) * 1e3;
-  }
-}
-function tool(config) {
-  const retryPolicy = {
-    attempts: config.retry?.attempts ?? 1,
-    backoff: config.retry?.backoff ?? "exponential",
-    on: config.retry?.on
-  };
-  const maxStringLen = config.maxStringLength ?? DEFAULT_MAX_STRING_LENGTH;
-  const execute = async (input, ctx) => {
-    const parsed = config.input.parse(input);
-    if (maxStringLen > 0) {
-      validateStringLengths(parsed, maxStringLen);
-    }
-    const maxAttempts = retryPolicy.attempts ?? 1;
-    let lastError;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        return await config.handler(parsed, ctx);
-      } catch (err) {
-        lastError = err instanceof Error ? err : new Error(String(err));
-        if (attempt === maxAttempts) break;
-        if (retryPolicy.on && !retryPolicy.on(lastError)) {
-          break;
-        }
-        const backoffMs = getBackoffMs(attempt, retryPolicy.backoff ?? "exponential");
-        if (backoffMs > 0) {
-          await sleep(backoffMs);
-        }
-      }
-    }
-    throw lastError;
-  };
-  return {
-    name: config.name,
-    description: config.description,
-    inputSchema: config.input,
-    sensitive: config.sensitive ?? false,
-    retry: retryPolicy,
-    requireApproval: config.requireApproval ?? false,
-    hooks: config.hooks,
-    ...config.toModelOutput !== void 0 ? { toModelOutput: config.toModelOutput } : {},
-    async run(ctx, input) {
-      const startTime = Date.now();
-      try {
-        let processedInput = input;
-        if (config.hooks?.before) {
-          processedInput = await config.hooks.before(processedInput, ctx);
-        }
-        let result = await execute(processedInput, ctx);
-        if (config.hooks?.after) {
-          result = await config.hooks.after(result, ctx);
-        }
-        ctx.log("tool_call_complete", {
-          tool: config.name,
-          duration: Date.now() - startTime
-        });
-        return result;
-      } catch (err) {
-        ctx.log("tool_call_error", {
-          tool: config.name,
-          error: err instanceof Error ? err.message : String(err),
-          duration: Date.now() - startTime
-        });
-        throw err;
-      }
-    },
-    _execute: execute
-  };
-}
-
-// src/providers/types.ts
-function resolveThinkingOptions(options) {
-  if (options.thinkingBudget !== void 0 && options.thinkingBudget < 0) {
-    throw new Error(`thinkingBudget must be non-negative, got ${options.thinkingBudget}`);
-  }
-  const effort = options.effort;
-  const thinkingBudget = options.thinkingBudget;
-  const hasBudgetOverride = thinkingBudget !== void 0 && thinkingBudget > 0;
-  return {
-    effort,
-    thinkingBudget,
-    includeThoughts: options.includeThoughts ?? false,
-    // Budget override wins: effort: 'none' + thinkingBudget: 5000 → thinking enabled
-    thinkingDisabled: (effort === "none" || thinkingBudget === 0) && !hasBudgetOverride,
-    activeEffort: effort && effort !== "none" ? effort : void 0,
-    hasBudgetOverride
-  };
-}
-async function resolveApiKey(source) {
-  if (typeof source === "function") return await source() ?? "";
-  return source ?? "";
-}
+import { ZodError } from "zod";
 
 // src/errors.ts
 var AxlError = class extends Error {
@@ -135,6 +14,55 @@ var AxlError = class extends Error {
     this.code = code;
   }
 };
+var EventStreamOverflowError = class extends Error {
+  maxQueued;
+  eventType;
+  constructor(maxQueued, eventType, cause) {
+    super(
+      `AxlEventBus queue exceeded maxQueued=${maxQueued} (event type: ${eventType}). Consumer is too slow or the producer is unbounded. Configure \`maxQueued\`/\`onOverflow\` on the runtime, or set maxQueued: Infinity to disable.`
+    );
+    this.name = "EventStreamOverflowError";
+    this.maxQueued = maxQueued;
+    this.eventType = eventType;
+    if (cause !== void 0) {
+      Object.defineProperty(this, "cause", {
+        configurable: true,
+        enumerable: false,
+        value: cause
+      });
+    }
+  }
+};
+function isEventStreamOverflowError(error) {
+  return error instanceof EventStreamOverflowError;
+}
+function rethrowEventStreamOverflow(error) {
+  if (isEventStreamOverflowError(error)) throw error;
+}
+function preserveErrorCause(error, cause) {
+  if (cause === void 0 || cause === error || "cause" in error) return error;
+  Object.defineProperty(error, "cause", {
+    configurable: true,
+    enumerable: false,
+    value: cause
+  });
+  return error;
+}
+var ToolFailure = class extends AxlError {
+  modelMessage;
+  constructor(options) {
+    super(options.code ?? "TOOL_FAILURE", options.message);
+    this.name = "ToolFailure";
+    this.modelMessage = options.modelMessage;
+    if (options.cause !== void 0) {
+      Object.defineProperty(this, "cause", {
+        configurable: true,
+        enumerable: false,
+        value: options.cause
+      });
+    }
+  }
+};
 var ToolModelOutputError = class extends AxlError {
   toolName;
   cause;
@@ -240,19 +168,209 @@ var ValidationError = class extends AxlError {
     this.retries = retries;
   }
 };
-var ToolDenied = class extends AxlError {
-  toolName;
-  agentName;
-  constructor(toolName, agentName) {
+
+// src/tool.ts
+var DEFAULT_MAX_STRING_LENGTH = 1e4;
+var ToolStringLengthError = class extends Error {
+  constructor(path, actual, maximum) {
+    const renderedPath = path.reduce(
+      (current, part) => typeof part === "number" ? `${current}[${part}]` : current ? `${current}.${part}` : part,
+      ""
+    );
     super(
-      "TOOL_DENIED",
-      `Agent "${agentName}" attempted to call tool "${toolName}" which is not in its ACL`
+      `String argument${renderedPath ? ` at "${renderedPath}"` : ""} exceeds maximum length (${actual} > ${maximum})`
     );
-    this.name = "ToolDenied";
-    this.toolName = toolName;
-    this.agentName = agentName;
+    this.path = path;
+    this.actual = actual;
+    this.maximum = maximum;
+    this.name = "ToolStringLengthError";
   }
 };
+function validateStringLengths(value, maxLen, path = []) {
+  if (typeof value === "string") {
+    if (value.length > maxLen) {
+      throw new ToolStringLengthError(path, value.length, maxLen);
+    }
+  } else if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      validateStringLengths(value[i], maxLen, [...path, i]);
+    }
+  } else if (value !== null && typeof value === "object") {
+    for (const [key, val] of Object.entries(value)) {
+      validateStringLengths(val, maxLen, [...path, key]);
+    }
+  }
+}
+function sleep(ms, signal) {
+  if (!signal) return new Promise((resolve2) => setTimeout(resolve2, ms));
+  signal.throwIfAborted();
+  return new Promise((resolve2, reject) => {
+    const timeout = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timeout);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function isAbortError(error) {
+  try {
+    return error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+  } catch {
+    return false;
+  }
+}
+function toolArgumentIssues(error) {
+  if (error instanceof ZodError) {
+    return error.issues.map((issue) => ({
+      path: issue.path.map((part) => typeof part === "symbol" ? String(part) : part),
+      code: issue.code,
+      message: issue.message
+    }));
+  }
+  if (error instanceof ToolStringLengthError) {
+    return [
+      {
+        path: error.path,
+        code: "too_big",
+        message: error.message
+      }
+    ];
+  }
+  return [{ path: [], code: "invalid_arguments", message: "Tool arguments are invalid." }];
+}
+var TOOL_INTERNALS = /* @__PURE__ */ new WeakMap();
+function getToolInternals(tool2) {
+  const internals = TOOL_INTERNALS.get(tool2);
+  if (!internals) throw new Error(`Tool "${tool2.name}" was not created by tool()`);
+  return internals;
+}
+function prepareToolInput(tool2, input) {
+  return getToolInternals(tool2).prepareInput(input);
+}
+function executePreparedTool(tool2, input, ctx, options) {
+  return getToolInternals(tool2).executePrepared(input, ctx, options);
+}
+function getBackoffMs(attempt, strategy) {
+  switch (strategy) {
+    case "none":
+      return 0;
+    case "linear":
+      return attempt * 1e3;
+    case "exponential":
+      return Math.pow(2, attempt - 1) * 1e3;
+  }
+}
+function tool(config) {
+  const retryPolicy = {
+    attempts: config.retry?.attempts ?? 1,
+    backoff: config.retry?.backoff ?? "exponential",
+    on: config.retry?.on
+  };
+  const maxStringLen = config.maxStringLength ?? DEFAULT_MAX_STRING_LENGTH;
+  const prepareInput = (input) => {
+    const parsed = config.input.parse(input);
+    if (maxStringLen > 0) {
+      validateStringLengths(parsed, maxStringLen);
+    }
+    return parsed;
+  };
+  const executePrepared = async (parsed, ctx, options) => {
+    const maxAttempts = retryPolicy.attempts ?? 1;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      options?.signal?.throwIfAborted();
+      options?.onAttempt?.(attempt);
+      try {
+        const result = await config.handler(parsed, ctx);
+        if (options?.checkAfterHandlerAbort !== false) options?.signal?.throwIfAborted();
+        return result;
+      } catch (err) {
+        if (options?.signal?.aborted) options.signal.throwIfAborted();
+        if (isAbortError(err)) throw err;
+        rethrowEventStreamOverflow(err);
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt === maxAttempts) break;
+        if (retryPolicy.on && !retryPolicy.on(lastError)) {
+          break;
+        }
+        const backoffMs = getBackoffMs(attempt, retryPolicy.backoff ?? "exponential");
+        if (backoffMs > 0) {
+          await sleep(backoffMs, options?.signal);
+        }
+      }
+    }
+    throw lastError;
+  };
+  const execute = async (input, ctx) => executePrepared(prepareInput(input), ctx);
+  const instance = {
+    name: config.name,
+    description: config.description,
+    inputSchema: config.input,
+    sensitive: config.sensitive ?? false,
+    retry: retryPolicy,
+    requireApproval: config.requireApproval ?? false,
+    hooks: config.hooks,
+    ...config.toModelOutput !== void 0 ? { toModelOutput: config.toModelOutput } : {},
+    async run(ctx, input) {
+      const startTime = Date.now();
+      try {
+        let processedInput = input;
+        if (config.hooks?.before) {
+          processedInput = await config.hooks.before(processedInput, ctx);
+        }
+        let result = await execute(processedInput, ctx);
+        if (config.hooks?.after) {
+          result = await config.hooks.after(result, ctx);
+        }
+        ctx.log("tool_call_complete", {
+          tool: config.name,
+          duration: Date.now() - startTime
+        });
+        return result;
+      } catch (err) {
+        ctx.log("tool_call_error", {
+          tool: config.name,
+          error: err instanceof Error ? err.message : String(err),
+          duration: Date.now() - startTime
+        });
+        throw err;
+      }
+    },
+    _execute: execute
+  };
+  TOOL_INTERNALS.set(instance, {
+    prepareInput,
+    executePrepared
+  });
+  return instance;
+}
+
+// src/providers/types.ts
+function resolveThinkingOptions(options) {
+  if (options.thinkingBudget !== void 0 && options.thinkingBudget < 0) {
+    throw new Error(`thinkingBudget must be non-negative, got ${options.thinkingBudget}`);
+  }
+  const effort = options.effort;
+  const thinkingBudget = options.thinkingBudget;
+  const hasBudgetOverride = thinkingBudget !== void 0 && thinkingBudget > 0;
+  return {
+    effort,
+    thinkingBudget,
+    includeThoughts: options.includeThoughts ?? false,
+    // Budget override wins: effort: 'none' + thinkingBudget: 5000 → thinking enabled
+    thinkingDisabled: (effort === "none" || thinkingBudget === 0) && !hasBudgetOverride,
+    activeEffort: effort && effort !== "none" ? effort : void 0,
+    hasBudgetOverride
+  };
+}
+async function resolveApiKey(source) {
+  if (typeof source === "function") return await source() ?? "";
+  return source ?? "";
+}
 
 // src/providers/errors.ts
 var ProviderError = class extends AxlError {
@@ -361,7 +479,7 @@ function sleep2(ms, signal) {
     );
   });
 }
-function isAbortError(err, signal) {
+function isAbortError2(err, signal) {
   if (signal?.aborted) return true;
   return typeof err === "object" && err !== null && "name" in err && err.name === "AbortError";
 }
@@ -380,7 +498,7 @@ async function fetchWithRetry(input, init, opts) {
       try {
         res = await fetch(input, init);
       } catch (err) {
-        if (isAbortError(err, init?.signal ?? void 0)) throw err;
+        if (isAbortError2(err, init?.signal ?? void 0)) throw err;
         if (attempt >= maxRetries) {
           throw buildProviderError({
             provider,
@@ -3062,7 +3180,7 @@ var defaultRegistry = new ProviderRegistry();
 // src/context.ts
 import { AsyncLocalStorage } from "async_hooks";
 import { randomUUID } from "crypto";
-import { z, ZodError } from "zod";
+import { z, ZodError as ZodError2 } from "zod";
 
 // src/partial-json.ts
 var MAX_DEPTH = 256;
@@ -3681,9 +3799,9 @@ var AXL_EVENT_TYPES = [
   // Tool invocation lifecycle
   "tool_call_start",
   "tool_call_end",
+  "tool_call_rejected",
   // Single-point tool events
   "tool_approval",
-  "tool_denied",
   // Delegation
   "delegate",
   // Handoff (spans two asks; not AskScoped).
@@ -3714,7 +3832,7 @@ var AXL_EVENT_TYPES = [
   "memory_remember",
   "memory_recall",
   "memory_forget",
-  // Durable execution checkpoints (`ctx.checkpoint`)
+  // Scoped execution checkpoints (`ctx.checkpoint`)
   "checkpoint_save",
   "checkpoint_replay",
   // Human-in-the-loop (`ctx.awaitHuman`)
@@ -3729,6 +3847,12 @@ var AXL_EVENT_TYPES = [
   "done",
   "error"
 ];
+var AXL_EVENT_TYPES_V2 = AXL_EVENT_TYPES;
+var AXL_TOOL_LIFECYCLE_TYPES_V2 = [
+  "tool_call_start",
+  "tool_call_end",
+  "tool_call_rejected"
+];
 
 // src/event-stream.ts
 var STREAM_EVENTS = new Set(AXL_EVENT_TYPES);
@@ -3744,8 +3868,8 @@ var LIFECYCLE_TYPES = /* @__PURE__ */ new Set([
   "agent_call_end",
   "tool_call_start",
   "tool_call_end",
+  "tool_call_rejected",
   "tool_approval",
-  "tool_denied",
   "handoff_start",
   "handoff_return",
   "delegate",
@@ -3759,18 +3883,6 @@ var LIFECYCLE_TYPES = /* @__PURE__ */ new Set([
   "await_human",
   "await_human_resolved"
 ]);
-var EventStreamOverflowError = class extends Error {
-  maxQueued;
-  eventType;
-  constructor(maxQueued, eventType) {
-    super(
-      `AxlEventBus queue exceeded maxQueued=${maxQueued} (event type: ${eventType}). Consumer is too slow or the producer is unbounded. Configure \`maxQueued\`/\`onOverflow\` on the runtime, or set maxQueued: Infinity to disable.`
-    );
-    this.name = "EventStreamOverflowError";
-    this.maxQueued = maxQueued;
-    this.eventType = eventType;
-  }
-};
 var DEFAULT_MAX_QUEUED = 1e4;
 var DEFAULT_OVERFLOW = "drop-oldest-non-terminal";
 var AxlEventBus = class {
@@ -3781,6 +3893,7 @@ var AxlEventBus = class {
   maxQueued;
   onOverflow;
   overflowWarned = false;
+  droppedEvents = 0;
   /** Callbacks fired exactly once when `_finish()` is called. Used by
    *  curated views (e.g., `partialObjects`) that are listener-based and
    *  need a termination signal independent of any synthetic `done` event. */
@@ -3826,6 +3939,10 @@ var AxlEventBus = class {
    * can be 4 KB+ each, hence the more aggressive cleanup here).
    */
   stringStreamByAsk = /* @__PURE__ */ new Map();
+  /** Internal fan-out for `stringStream()` subscribers. Kept separate from
+   *  the public EventEmitter so strict curated-view overflow is a runtime
+   *  signal, not mistaken for (and swallowed as) a buggy user listener. */
+  stringStreamSubscribers = /* @__PURE__ */ new Set();
   /**
    * Hook fired when an iterator obtained from `[Symbol.asyncIterator]`
    * is `await using`-disposed. Set via the second constructor argument.
@@ -3859,6 +3976,12 @@ var AxlEventBus = class {
     this.bus.on("error", () => {
     });
   }
+  /** Machine-readable completeness across this bus's bounded iterable views.
+   *  EventEmitter listener delivery is independent and is not described by
+   *  this status. */
+  get observationStatus() {
+    return this.droppedEvents === 0 ? { complete: true } : { complete: false, reason: "queue_overflow", droppedEvents: this.droppedEvents };
+  }
   unknownEventWarned = false;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   on(event, handler) {
@@ -4171,7 +4294,7 @@ var AxlEventBus = class {
     }
     return {
       [Symbol.asyncIterator]() {
-        const pending = [];
+        const pending = /* @__PURE__ */ new Map();
         let resolveWaiter = null;
         let finished = self.finished;
         let unsubscribed = false;
@@ -4185,10 +4308,39 @@ var AxlEventBus = class {
           if (filterPath !== void 0 && path !== filterPath) return false;
           return true;
         };
+        const pendingKey = (askId, path) => JSON.stringify([askId, path]);
+        const enqueue = (event) => {
+          const key = pendingKey(event.askId, event.path);
+          const existing = pending.get(key);
+          if (existing) {
+            pending.set(key, {
+              ...event,
+              delta: existing.delta + event.delta
+            });
+            wakeWaiter();
+            return;
+          }
+          if (pending.size >= self.maxQueued) {
+            if (self.onOverflow === "throw") {
+              self.droppedEvents++;
+              throw new EventStreamOverflowError(self.maxQueued, "string_delta");
+            }
+            const oldest = pending.keys().next().value;
+            if (oldest !== void 0) {
+              pending.delete(oldest);
+              self.droppedEvents++;
+            }
+            self.warnOverflow(
+              "dropping oldest pending string field (stringStream subscriber is slower than producer)"
+            );
+          }
+          pending.set(key, event);
+          wakeWaiter();
+        };
         for (const [askId, paths] of self.stringStreamByAsk) {
           for (const [path, acc] of paths) {
             if (!matchesFilter(askId, path)) continue;
-            pending.push({
+            enqueue({
               askId,
               agent: acc.agent,
               path,
@@ -4198,51 +4350,37 @@ var AxlEventBus = class {
             });
           }
         }
-        const handler = (event) => {
-          if (event.type !== "string_delta") return;
-          const askId = event.askId ?? "";
-          if (!matchesFilter(askId, event.data.path)) return;
-          const paths = self.stringStreamByAsk.get(askId);
-          const acc = paths?.get(event.data.path);
-          const accumulated = acc?.text ?? event.data.delta;
-          pending.push({
-            askId,
-            agent: event.agent,
-            path: event.data.path,
-            delta: event.data.delta,
-            accumulated,
-            attempt: event.attempt
-          });
-          wakeWaiter();
-        };
-        self.bus.on("string_delta", handler);
-        const pipelineHandler = (event) => {
-          if (event.type !== "pipeline") return;
-          if (event.status !== "failed") return;
-          const askId = event.askId ?? "";
-          for (let i = pending.length - 1; i >= 0; i--) {
-            if (pending[i].askId === askId) pending.splice(i, 1);
+        const subscriber = {
+          push(event) {
+            if (matchesFilter(event.askId, event.path)) enqueue(event);
+          },
+          reset(askId) {
+            for (const [key, event] of pending) {
+              if (event.askId === askId) pending.delete(key);
+            }
           }
         };
-        self.bus.on("pipeline", pipelineHandler);
+        self.stringStreamSubscribers.add(subscriber);
         const unsubscribe = () => {
           if (unsubscribed) return;
           unsubscribed = true;
-          self.bus.off("string_delta", handler);
-          self.bus.off("pipeline", pipelineHandler);
+          self.stringStreamSubscribers.delete(subscriber);
           unsubscribeFinish();
         };
         const unsubscribeFinish = self._onFinish(() => {
           finished = true;
-          self.bus.off("string_delta", handler);
-          self.bus.off("pipeline", pipelineHandler);
+          self.stringStreamSubscribers.delete(subscriber);
           wakeWaiter();
         });
         return {
           async next() {
             while (true) {
-              if (pending.length > 0) {
-                return { value: pending.shift(), done: false };
+              if (pending.size > 0) {
+                const first = pending.entries().next().value;
+                if (first) {
+                  pending.delete(first[0]);
+                  return { value: first[1], done: false };
+                }
               }
               if (finished) {
                 unsubscribe();
@@ -4300,6 +4438,7 @@ var AxlEventBus = class {
    */
   _push(event) {
     if (this.finished) return;
+    let overflowError;
     if (event.type === "partial_object" && event.data?.object !== void 0) {
       const askId = event.askId ?? "";
       this.latestPartialByAsk.set(askId, {
@@ -4321,10 +4460,30 @@ var AxlEventBus = class {
         text: (existing?.text ?? "") + event.data.delta,
         attempt: event.attempt
       });
+      const accumulated = paths.get(event.data.path).text;
+      for (const subscriber of this.stringStreamSubscribers) {
+        try {
+          subscriber.push({
+            askId,
+            agent: event.agent,
+            path: event.data.path,
+            delta: event.data.delta,
+            accumulated,
+            attempt: event.attempt
+          });
+        } catch (error) {
+          if (isEventStreamOverflowError(error)) {
+            overflowError ??= error;
+          } else {
+            throw error;
+          }
+        }
+      }
     } else if (event.type === "pipeline" && event.status === "failed") {
       const askId = event.askId ?? "";
       this.latestPartialByAsk.delete(askId);
       this.stringStreamByAsk.delete(askId);
+      for (const subscriber of this.stringStreamSubscribers) subscriber.reset(askId);
     } else if (event.type === "ask_end") {
       this.stringStreamByAsk.delete(event.askId ?? "");
     }
@@ -4339,39 +4498,57 @@ var AxlEventBus = class {
     const waiter = this.waiters.shift();
     if (waiter) {
       waiter({ value: event, done: false });
+      if (overflowError) throw overflowError;
       return;
     }
     if (this.eventQueue.length >= this.maxQueued && !TERMINAL_TYPES.has(event.type)) {
-      this.handleOverflow(event);
+      try {
+        this.handleOverflow(event);
+      } catch (error) {
+        if (isEventStreamOverflowError(error)) {
+          overflowError ??= error;
+        } else {
+          throw error;
+        }
+      }
+      if (overflowError) throw overflowError;
       return;
     }
     this.eventQueue.push(event);
+    if (overflowError) throw overflowError;
   }
   /** Apply the overflow policy when the queue is at `maxQueued` and a
    *  non-terminal event arrives. Terminal events bypass this path entirely
    *  (checked by the caller). */
   handleOverflow(event) {
     if (this.onOverflow === "throw") {
+      this.droppedEvents++;
       throw new EventStreamOverflowError(this.maxQueued, event.type);
     }
     let droppedIdx = -1;
     for (let i = 0; i < this.eventQueue.length; i++) {
-      if (!TERMINAL_TYPES.has(this.eventQueue[i].type)) {
+      const candidate = this.eventQueue[i];
+      if (!TERMINAL_TYPES.has(candidate.type)) {
         droppedIdx = i;
         break;
       }
     }
-    if (!this.overflowWarned) {
-      this.overflowWarned = true;
-      console.warn(
-        `[axl] AxlEventBus queue exceeded maxQueued=${this.maxQueued}` + (droppedIdx >= 0 ? `; dropping oldest non-terminal events (consumer is slower than producer).` : `; queue is all terminals (preserved past cap so no terminal is lost).`) + ` This warning fires once per bus instance.`
-      );
-    }
+    this.warnOverflow(
+      droppedIdx >= 0 ? "dropping oldest non-terminal events (consumer is slower than producer)" : "queue contains only protected terminal events; preserving them past the cap"
+    );
     if (droppedIdx >= 0) {
       this.eventQueue.splice(droppedIdx, 1);
+      this.droppedEvents++;
     }
     this.eventQueue.push(event);
   }
+  warnOverflow(detail) {
+    if (this.overflowWarned) return;
+    this.overflowWarned = true;
+    console.warn(
+      `[axl] AxlEventBus queue exceeded maxQueued=${this.maxQueued}; ${detail}. This warning fires once per bus instance.`
+    );
+  }
   /**
    * Mark the bus as finished. Wakes any pending iterators with `done: true`
    * and drops further `_push` calls. Idempotent.
@@ -4438,6 +4615,43 @@ var AxlEventBus = class {
   }
 };
 
+// src/event-schema.ts
+var UnsupportedEventSchemaVersionError = class extends Error {
+  constructor(version) {
+    super(`Unsupported Axl event schema version: ${String(version)}`);
+    this.version = version;
+    this.name = "UnsupportedEventSchemaVersionError";
+  }
+};
+function getEventSchemaVersion(event) {
+  const version = event.schemaVersion === void 0 ? 1 : event.schemaVersion;
+  if (version !== 1 && version !== 2) throw new UnsupportedEventSchemaVersionError(version);
+  return version;
+}
+function getExecutionEventSchemaVersion(execution) {
+  const version = execution.eventSchemaVersion === void 0 ? 1 : execution.eventSchemaVersion;
+  if (version !== 1 && version !== 2) throw new UnsupportedEventSchemaVersionError(version);
+  return version;
+}
+function normalizeStoredExecution(execution) {
+  const version = getExecutionEventSchemaVersion(execution);
+  if (!Array.isArray(execution.events)) {
+    throw new TypeError(`Execution ${execution.executionId} has a non-array events field`);
+  }
+  for (const event of execution.events) {
+    const eventVersion = getEventSchemaVersion(event);
+    if (eventVersion !== version) {
+      throw new Error(
+        `Execution ${execution.executionId} declares event schema v${version} but contains a v${eventVersion} event`
+      );
+    }
+  }
+  if (version === 2) {
+    return { ...execution, eventSchemaVersion: 2 };
+  }
+  return { ...execution, eventSchemaVersion: 1 };
+}
+
 // src/redaction.ts
 var REDACTED = "[redacted]";
 function walkObjectOneLevel(obj, preserveKeys) {
@@ -4488,7 +4702,7 @@ function redactMemory(event) {
   };
 }
 var passthrough = (e) => e;
-var REDACTION_RULES = {
+var LEGACY_REDACTION_RULES = {
   workflow_start: (e) => e.data.input !== void 0 ? { ...e, data: { ...e.data, input: REDACTED } } : e,
   workflow_end: (e) => {
     const d = e.data;
@@ -4588,10 +4802,125 @@ var REDACTION_RULES = {
   done: (e) => ({ ...e, data: { result: REDACTED } }),
   error: (e) => ({ ...e, data: { ...e.data, message: REDACTED } })
 };
+function redactLegacyEvent(event) {
+  const rule = LEGACY_REDACTION_RULES[event.type];
+  return rule(event);
+}
+function redactV2Outcome(outcome) {
+  switch (outcome.status) {
+    case "succeeded":
+      return { ...outcome, result: REDACTED };
+    case "denied":
+      return outcome.reason === void 0 ? outcome : { ...outcome, reason: REDACTED };
+    case "cancelled":
+      return {
+        ...outcome,
+        cancellation: {
+          ...outcome.cancellation,
+          ..."result" in outcome.cancellation ? { result: REDACTED } : {},
+          ...outcome.cancellation.reason !== void 0 ? { reason: REDACTED } : {}
+        }
+      };
+    case "failed": {
+      const failure = outcome.failure;
+      return {
+        ...outcome,
+        failure: {
+          ...failure,
+          ..."result" in failure ? { result: REDACTED } : {},
+          error: {
+            ...failure.error,
+            message: REDACTED,
+            ...failure.error.cause !== void 0 ? { cause: REDACTED } : {}
+          }
+        }
+      };
+    }
+  }
+}
+function redactV2Rejection(data) {
+  switch (data.reason) {
+    case "unavailable":
+      return data;
+    case "invalid_json":
+      return { ...data, message: REDACTED };
+    case "invalid_arguments":
+      return {
+        ...data,
+        args: REDACTED,
+        issues: data.issues.map((issue) => ({
+          ...issue,
+          ...issue.message !== void 0 ? { message: REDACTED } : {}
+        }))
+      };
+  }
+}
+var V2_TOOL_REDACTION_RULES = {
+  tool_call_start: (event) => ({
+    ...event,
+    data: { ...event.data, args: REDACTED }
+  }),
+  tool_call_end: (event) => ({
+    ...event,
+    data: {
+      ...event.data,
+      args: REDACTED,
+      outcome: redactV2Outcome(event.data.outcome)
+    }
+  }),
+  tool_call_rejected: (event) => ({
+    ...event,
+    data: redactV2Rejection(event.data)
+  })
+};
+function reuseLegacyRule(type) {
+  return LEGACY_REDACTION_RULES[type];
+}
+var COMMON_V2_REDACTION_RULES = {
+  workflow_start: reuseLegacyRule("workflow_start"),
+  workflow_end: reuseLegacyRule("workflow_end"),
+  ask_start: reuseLegacyRule("ask_start"),
+  ask_end: reuseLegacyRule("ask_end"),
+  agent_call_start: reuseLegacyRule("agent_call_start"),
+  agent_call_end: reuseLegacyRule("agent_call_end"),
+  token: reuseLegacyRule("token"),
+  tool_approval: reuseLegacyRule("tool_approval"),
+  delegate: reuseLegacyRule("delegate"),
+  handoff_start: reuseLegacyRule("handoff_start"),
+  handoff_return: reuseLegacyRule("handoff_return"),
+  pipeline: reuseLegacyRule("pipeline"),
+  partial_object: reuseLegacyRule("partial_object"),
+  string_delta: reuseLegacyRule("string_delta"),
+  verify: reuseLegacyRule("verify"),
+  schema_diagnostic: reuseLegacyRule("schema_diagnostic"),
+  log: reuseLegacyRule("log"),
+  memory_remember: reuseLegacyRule("memory_remember"),
+  memory_recall: reuseLegacyRule("memory_recall"),
+  memory_forget: reuseLegacyRule("memory_forget"),
+  checkpoint_save: reuseLegacyRule("checkpoint_save"),
+  checkpoint_replay: reuseLegacyRule("checkpoint_replay"),
+  await_human: reuseLegacyRule("await_human"),
+  await_human_resolved: reuseLegacyRule("await_human_resolved"),
+  guardrail: reuseLegacyRule("guardrail"),
+  schema_check: reuseLegacyRule("schema_check"),
+  validate: reuseLegacyRule("validate"),
+  done: reuseLegacyRule("done"),
+  error: reuseLegacyRule("error")
+};
+var REDACTION_RULES = {
+  ...COMMON_V2_REDACTION_RULES,
+  ...V2_TOOL_REDACTION_RULES
+};
 function redactEvent(event) {
   const rule = REDACTION_RULES[event.type];
   return rule(event);
 }
+function redactHistoricalEvent(event) {
+  if (getEventSchemaVersion(event) === 1) {
+    return redactLegacyEvent(event);
+  }
+  return redactEvent(event);
+}
 
 // src/schema-diagnostics.ts
 var DEFAULT_SCHEMA_OVERSIZED_TOKENS = 4e3;
@@ -4791,8 +5120,8 @@ function normalize(value, path, stack) {
         "accessor properties are not supported"
       );
     }
-    if (typeof key === "symbol" && descriptor?.enumerable) {
-      throw invalid(`${path}[symbol]`, "enumerable symbol keys are not supported");
+    if (typeof key === "symbol") {
+      throw invalid(`${path}[symbol]`, "symbol keys are not supported");
     }
   }
   if (typeof descriptors.toJSON?.value === "function") {
@@ -4869,63 +5198,541 @@ function serializeToolModelOutput(toolName, output) {
   }
 }
 
-// src/context.ts
-var signalStorage = new AsyncLocalStorage();
-function isErrorShaped(value) {
-  return value !== null && typeof value === "object" && "error" in value;
+// src/tool-invocation.ts
+var INVALID_JSON_MODEL_MESSAGE = "Error: Invalid JSON in tool arguments. Please provide valid JSON.";
+var INVALID_ARGUMENTS_MODEL_MESSAGE = "Error: Tool arguments are invalid. Correct the arguments and try again.";
+var SENSITIVE_SUCCESS_MESSAGE = "[REDACTED - sensitive tool output]";
+var SENSITIVE_FAILURE_MESSAGE = "[REDACTED - sensitive tool failure]";
+var MAX_MCP_MODEL_ERROR_LENGTH = 2e3;
+function cloneToolArguments(value) {
+  try {
+    return structuredClone(value);
+  } catch {
+    throw new Error("Prepared tool arguments must be structured-cloneable");
+  }
+}
+function parseToolInvocation(options) {
+  const { toolCall, configuredTool, override, mcpCall, mcpTraceName, availableTools } = options;
+  const requestedTool = toolCall.function.name;
+  if (!override && !configuredTool && !mcpCall) {
+    return {
+      kind: "rejected",
+      requestedTool,
+      toolName: requestedTool,
+      callId: toolCall.id,
+      data: { reason: "unavailable", requestedTool, availableTools },
+      modelMessage: `Tool "${requestedTool}" is not available. Available tools: ${availableTools.length > 0 ? availableTools.join(", ") : "none"}`
+    };
+  }
+  let parsedArguments;
+  try {
+    parsedArguments = JSON.parse(toolCall.function.arguments);
+  } catch {
+    return {
+      kind: "rejected",
+      requestedTool,
+      toolName: mcpTraceName ?? requestedTool,
+      callId: toolCall.id,
+      data: {
+        reason: "invalid_json",
+        requestedTool,
+        message: "Tool arguments were not valid JSON."
+      },
+      modelMessage: INVALID_JSON_MODEL_MESSAGE
+    };
+  }
+  if (typeof parsedArguments !== "object" || parsedArguments === null || Array.isArray(parsedArguments)) {
+    return {
+      kind: "rejected",
+      requestedTool,
+      toolName: mcpTraceName ?? requestedTool,
+      callId: toolCall.id,
+      data: {
+        reason: "invalid_json",
+        requestedTool,
+        message: "Tool arguments must decode to a JSON object."
+      },
+      modelMessage: INVALID_JSON_MODEL_MESSAGE
+    };
+  }
+  const source = override ? { kind: "override", execute: override } : configuredTool ? { kind: "local", tool: configuredTool } : { kind: "mcp", call: mcpCall };
+  let preparedArguments = parsedArguments;
+  if (source.kind === "local") {
+    try {
+      preparedArguments = prepareToolInput(source.tool, parsedArguments);
+    } catch (error) {
+      return {
+        kind: "rejected",
+        requestedTool,
+        toolName: requestedTool,
+        callId: toolCall.id,
+        data: {
+          reason: "invalid_arguments",
+          requestedTool,
+          args: parsedArguments,
+          issues: toolArgumentIssues(error)
+        },
+        modelMessage: INVALID_ARGUMENTS_MODEL_MESSAGE
+      };
+    }
+  }
+  try {
+    preparedArguments = cloneToolArguments(preparedArguments);
+  } catch (error) {
+    return {
+      kind: "rejected",
+      requestedTool,
+      toolName: source.kind === "mcp" ? mcpTraceName ?? requestedTool : requestedTool,
+      callId: toolCall.id,
+      data: {
+        reason: "invalid_arguments",
+        requestedTool,
+        args: parsedArguments,
+        issues: toolArgumentIssues(error)
+      },
+      modelMessage: INVALID_ARGUMENTS_MODEL_MESSAGE
+    };
+  }
+  return {
+    requestedTool,
+    toolName: source.kind === "mcp" ? mcpTraceName ?? requestedTool : requestedTool,
+    callId: toolCall.id,
+    args: preparedArguments,
+    configuredTool,
+    source
+  };
 }
-function isErrorShapedSafely(value) {
+function isAbortError3(error) {
   try {
-    return isErrorShaped(value);
+    return error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
   } catch {
     return false;
   }
 }
-function recordToolSpanResult(span, value, suppressInspectionErrors) {
+function normalizeAbortError(reason) {
+  if (isAbortError3(reason)) return reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  if (reason !== void 0) {
+    Object.defineProperty(error, "cause", { value: reason, enumerable: false });
+  }
+  return error;
+}
+function cancellationError(signal, error) {
+  if (signal?.aborted) return normalizeAbortError(signal.reason);
+  return isAbortError3(error) ? normalizeAbortError(error) : void 0;
+}
+function eventError(error) {
   let isError = false;
-  let errorMessage;
-  const inspect = () => {
-    if (isErrorShaped(value)) {
-      isError = true;
-      errorMessage = value.error;
-    } else {
-      isError = false;
-    }
+  try {
+    isError = error instanceof Error;
+  } catch {
+  }
+  if (isError) {
+    const read = (key) => {
+      try {
+        return Reflect.get(error, key);
+      } catch {
+        return void 0;
+      }
+    };
+    const name = read("name");
+    const message = read("message");
+    const code = read("code");
+    const cause = read("cause");
+    return {
+      name: typeof name === "string" ? name : "Error",
+      message: typeof message === "string" ? message : "Unknown error",
+      ...typeof code === "string" ? { code } : {},
+      ...cause !== void 0 ? { cause } : {}
+    };
+  }
+  try {
+    return { name: "Error", message: String(error) };
+  } catch {
+    return { name: "Error", message: "Unknown thrown value" };
+  }
+}
+function isToolFailure(error) {
+  try {
+    return error instanceof ToolFailure;
+  } catch {
+    return false;
+  }
+}
+function cancellation(phase, error, result) {
+  let reason;
+  try {
+    reason = error instanceof Error && typeof error.message === "string" ? error.message : void 0;
+  } catch {
+  }
+  const cancellation2 = phase === "after_handler" || phase === "after_hook" || phase === "projection" || phase === "serialization" ? { phase, result, ...reason ? { reason } : {} } : { phase, ...reason ? { reason } : {} };
+  return {
+    kind: "cancelled",
+    cancellation: cancellation2,
+    error: normalizeAbortError(error)
   };
-  if (suppressInspectionErrors) {
+}
+function failed(phase, error, options = {}) {
+  let modelMessage;
+  if (isToolFailure(error)) {
     try {
-      inspect();
+      modelMessage = typeof error.modelMessage === "string" ? error.modelMessage : void 0;
     } catch {
-      isError = false;
-      errorMessage = void 0;
     }
-  } else {
-    inspect();
   }
-  span.setAttribute("axl.tool.success", !isError);
-  if (isError) span.setStatus("error", errorMessage);
+  const toolFailure = modelMessage !== void 0;
+  const common = {
+    phase,
+    kind: toolFailure ? "tool_failure" : "unexpected",
+    disposition: toolFailure ? "continue" : "abort",
+    error: eventError(error)
+  };
+  const failure = phase === "handler" ? { ...common, attempts: options.attempts ?? 1 } : phase === "after_hook" ? { ...common, result: options.result } : common;
+  return {
+    kind: "failed",
+    failure,
+    error,
+    ...modelMessage !== void 0 ? { modelMessage } : {}
+  };
+}
+function mcpContent(result) {
+  return result.content.map((content) => content.type === "text" ? content.text : `[${content.type}]`).join("\n");
+}
+function safeMcpModelError(content) {
+  let normalized = "";
+  for (const character of content) {
+    const code = character.charCodeAt(0);
+    normalized += code <= 31 && code !== 9 && code !== 10 && code !== 13 || code === 127 ? " " : character;
+  }
+  return `MCP tool error: ${normalized.slice(0, MAX_MCP_MODEL_ERROR_LENGTH)}`;
 }
-function prepareToolModelOutput(toolName, project) {
-  let output;
+async function executeAcceptedTool(options) {
+  const { invocation, context, signal, requestApproval, createChildContext } = options;
+  let effectiveArgs = cloneToolArguments(invocation.args);
+  if (invocation.source.kind === "local" && invocation.source.tool.requireApproval) {
+    try {
+      signal?.throwIfAborted();
+      const approval = await requestApproval();
+      signal?.throwIfAborted();
+      if (!approval.approved) return { kind: "denied", reason: approval.reason };
+    } catch (error) {
+      rethrowEventStreamOverflow(error);
+      const abort = cancellationError(signal, error);
+      if (abort !== void 0) return cancellation("approval", abort);
+      return {
+        kind: "failed",
+        failure: {
+          phase: "approval",
+          kind: "infrastructure",
+          disposition: "abort",
+          error: eventError(error)
+        },
+        error
+      };
+    }
+  }
+  if (invocation.source.kind === "local" && invocation.source.tool.hooks?.before) {
+    try {
+      signal?.throwIfAborted();
+      effectiveArgs = await invocation.source.tool.hooks.before(effectiveArgs, context);
+      signal?.throwIfAborted();
+    } catch (error) {
+      rethrowEventStreamOverflow(error);
+      const abort = cancellationError(signal, error);
+      if (abort !== void 0) return cancellation("before_hook", abort);
+      return failed("before_hook", error);
+    }
+  }
+  let result;
+  let attempts = 1;
   try {
-    output = project();
-  } catch (cause) {
-    throw new ToolModelOutputError(toolName, cause);
+    signal?.throwIfAborted();
+    switch (invocation.source.kind) {
+      case "override": {
+        const executeOverride = invocation.source.execute;
+        result = await executeOverride(effectiveArgs);
+        break;
+      }
+      case "local":
+        result = await executePreparedTool(
+          invocation.source.tool,
+          effectiveArgs,
+          createChildContext(),
+          {
+            signal,
+            onAttempt: (attempt) => attempts = attempt,
+            checkAfterHandlerAbort: false
+          }
+        );
+        break;
+      case "mcp": {
+        const mcpResult = await invocation.source.call(effectiveArgs);
+        if (signal?.aborted) return cancellation("after_handler", signal.reason, mcpResult);
+        if (mcpResult.isError) {
+          const content = mcpContent(mcpResult);
+          const error = new Error(content || "MCP tool returned an error");
+          return {
+            kind: "failed",
+            failure: {
+              phase: "handler",
+              kind: "mcp_error",
+              disposition: "continue",
+              error: { name: "McpToolError", message: error.message, code: "MCP_TOOL_ERROR" },
+              attempts: 1
+            },
+            error,
+            modelMessage: safeMcpModelError(content)
+          };
+        }
+        result = mcpResult;
+        break;
+      }
+    }
+  } catch (error) {
+    rethrowEventStreamOverflow(error);
+    const abort = cancellationError(signal, error);
+    if (abort !== void 0) return cancellation("handler", abort);
+    return failed("handler", error, { attempts });
+  }
+  if (signal?.aborted) return cancellation("after_handler", signal.reason, result);
+  if (invocation.source.kind === "local" && invocation.source.tool.hooks?.after) {
+    const rawResult = result;
+    try {
+      result = await invocation.source.tool.hooks.after(result, context);
+      signal?.throwIfAborted();
+    } catch (error) {
+      rethrowEventStreamOverflow(error);
+      const abort = cancellationError(signal, error);
+      if (abort !== void 0) return cancellation("after_hook", abort, rawResult);
+      return failed("after_hook", error, { result: rawResult });
+    }
+  }
+  return { kind: "succeeded", result };
+}
+function prepareToolMessage(invocation, outcome) {
+  const sensitive = invocation.configuredTool?.sensitive === true;
+  if (outcome.kind === "denied") {
+    return {
+      ok: true,
+      content: JSON.stringify({ error: "Tool request was denied by human approval." })
+    };
+  }
+  if (outcome.kind === "failed") {
+    if (outcome.failure.disposition !== "continue" || outcome.modelMessage === void 0) {
+      throw new Error("Aborting tool failures cannot produce provider messages");
+    }
+    return { ok: true, content: sensitive ? SENSITIVE_FAILURE_MESSAGE : outcome.modelMessage };
+  }
+  if (outcome.kind !== "succeeded") {
+    throw new Error("Cancelled tool calls cannot produce provider messages");
+  }
+  if (sensitive) return { ok: true, content: SENSITIVE_SUCCESS_MESSAGE };
+  if (invocation.source.kind === "mcp") {
+    try {
+      return { ok: true, content: mcpContent(outcome.result) };
+    } catch (error) {
+      rethrowEventStreamOverflow(error);
+      return { ok: false, phase: "serialization", error };
+    }
+  }
+  if (invocation.configuredTool?.toModelOutput) {
+    try {
+      const project = invocation.configuredTool.toModelOutput;
+      return {
+        ok: true,
+        content: serializeToolModelOutput(
+          invocation.requestedTool,
+          project(outcome.result)
+        )
+      };
+    } catch (error) {
+      rethrowEventStreamOverflow(error);
+      if (error instanceof ToolModelOutputError && isEventStreamOverflowError(error.cause)) {
+        throw error.cause;
+      }
+      return {
+        ok: false,
+        phase: "projection",
+        error: error instanceof ToolModelOutputError && error.toolName === invocation.requestedTool ? error : new ToolModelOutputError(invocation.requestedTool, error)
+      };
+    }
+  }
+  try {
+    const content = JSON.stringify(outcome.result);
+    if (content === void 0) throw new Error("Tool result is not JSON serializable");
+    return { ok: true, content };
+  } catch (error) {
+    rethrowEventStreamOverflow(error);
+    return { ok: false, phase: "serialization", error };
+  }
+}
+async function settleAcceptedTool(options) {
+  const internal = await executeAcceptedTool(options);
+  if (internal.kind === "cancelled") {
+    return {
+      outcome: { status: "cancelled", cancellation: internal.cancellation },
+      abortError: internal.error
+    };
+  }
+  if (internal.kind === "failed" && internal.failure.disposition === "abort") {
+    return {
+      outcome: { status: "failed", failure: internal.failure },
+      abortError: internal.error
+    };
+  }
+  const result = internal.kind === "succeeded" ? internal.result : void 0;
+  const outputPhase = internal.kind === "succeeded" && !options.invocation.configuredTool?.sensitive && options.invocation.source.kind !== "mcp" && options.invocation.configuredTool?.toModelOutput ? "projection" : "serialization";
+  if (internal.kind === "succeeded" && options.signal?.aborted) {
+    return {
+      outcome: {
+        status: "cancelled",
+        cancellation: { phase: outputPhase, result }
+      },
+      abortError: normalizeAbortError(options.signal.reason)
+    };
+  }
+  const prepared = prepareToolMessage(options.invocation, internal);
+  if (internal.kind === "succeeded" && options.signal?.aborted) {
+    return {
+      outcome: {
+        status: "cancelled",
+        cancellation: { phase: outputPhase, result }
+      },
+      abortError: normalizeAbortError(options.signal.reason)
+    };
+  }
+  if (!prepared.ok) {
+    const outputAbort = cancellationError(options.signal, prepared.error) ?? (prepared.error instanceof ToolModelOutputError ? cancellationError(options.signal, prepared.error.cause) : void 0);
+    if (outputAbort !== void 0) {
+      return {
+        outcome: {
+          status: "cancelled",
+          cancellation: { phase: prepared.phase, result }
+        },
+        abortError: outputAbort
+      };
+    }
+    const failure = {
+      phase: prepared.phase,
+      kind: "output",
+      disposition: "abort",
+      error: eventError(prepared.error),
+      result
+    };
+    return {
+      outcome: { status: "failed", failure },
+      abortError: prepared.error
+    };
+  }
+  if (internal.kind === "succeeded") {
+    return {
+      outcome: { status: "succeeded", result: internal.result },
+      providerContent: prepared.content
+    };
+  }
+  if (internal.kind === "denied") {
+    return {
+      outcome: { status: "denied", ...internal.reason ? { reason: internal.reason } : {} },
+      providerContent: prepared.content
+    };
+  }
+  return {
+    outcome: { status: "failed", failure: internal.failure },
+    providerContent: prepared.content
+  };
+}
+function recordToolSpanOutcome(span, outcome) {
+  span.setAttribute("axl.tool.outcome", outcome.status);
+  span.setAttribute("axl.tool.success", outcome.status === "succeeded");
+  switch (outcome.status) {
+    case "succeeded":
+      span.setStatus("ok");
+      return;
+    case "denied":
+      span.setStatus("unset");
+      return;
+    case "failed":
+      span.setAttribute("axl.tool.phase", outcome.failure.phase);
+      span.setStatus("error");
+      return;
+    case "cancelled":
+      span.setAttribute("axl.tool.phase", outcome.cancellation.phase);
+      span.setStatus("error");
+  }
+}
+
+// src/context.ts
+var signalStorage = new AsyncLocalStorage();
+var DEFAULT_BRANCH_DRAIN_TIMEOUT_MS = 5e3;
+function resolveBranchDrainTimeoutMs(value) {
+  const resolved = value === void 0 ? DEFAULT_BRANCH_DRAIN_TIMEOUT_MS : value;
+  if (typeof resolved !== "number" || Number.isNaN(resolved) || !Number.isFinite(resolved) || resolved < 0) {
+    throw new AxlError(
+      "INVALID_CONFIG",
+      `branchDrainTimeoutMs must be a non-negative finite number (got ${String(resolved)})`
+    );
   }
-  return serializeToolModelOutput(toolName, output);
+  return resolved;
 }
-function finalizeToolResult(options) {
-  const { toolName, configuredTool, outcome, legacyContent, emitEnd, beforeProjection } = options;
-  const projectionEligible = configuredTool !== void 0 && !configuredTool.sensitive && outcome.kind === "returned" && configuredTool.toModelOutput !== void 0;
-  if (projectionEligible) {
-    emitEnd();
-    beforeProjection();
-    const project = configuredTool.toModelOutput;
-    return prepareToolModelOutput(toolName, () => project(outcome.value));
+function parseHumanDecision(value) {
+  const invalid2 = () => {
+    throw new AxlError(
+      "INVALID_HUMAN_DECISION",
+      "Human decision must be a plain object with a boolean approved field and only branch-appropriate string data"
+    );
+  };
+  if (typeof value !== "object" || value === null || Array.isArray(value)) invalid2();
+  let prototype;
+  try {
+    prototype = Object.getPrototypeOf(value);
+  } catch {
+    return invalid2();
+  }
+  if (prototype !== Object.prototype && prototype !== null) invalid2();
+  let ownKeys;
+  try {
+    ownKeys = Reflect.ownKeys(value);
+  } catch {
+    return invalid2();
+  }
+  if (ownKeys.some(
+    (key) => typeof key !== "string" || key !== "approved" && key !== "data" && key !== "reason"
+  )) {
+    invalid2();
+  }
+  const readDataProperty = (key) => {
+    let descriptor;
+    try {
+      descriptor = Object.getOwnPropertyDescriptor(value, key);
+    } catch {
+      return invalid2();
+    }
+    if (!descriptor) {
+      if (ownKeys.includes(key)) invalid2();
+      return { present: false, value: void 0 };
+    }
+    if (!ownKeys.includes(key)) return invalid2();
+    if (!("value" in descriptor)) return invalid2();
+    return { present: true, value: descriptor.value };
+  };
+  const approved = readDataProperty("approved");
+  const data = readDataProperty("data");
+  const reason = readDataProperty("reason");
+  if (approved.present && approved.value === true && !reason.present) {
+    if (data.value === void 0 || typeof data.value === "string") {
+      return { approved: true, ...data.value === void 0 ? {} : { data: data.value } };
+    }
+  }
+  if (approved.present && approved.value === false && !data.present) {
+    if (reason.value === void 0 || typeof reason.value === "string") {
+      return {
+        approved: false,
+        ...reason.value === void 0 ? {} : { reason: reason.value }
+      };
+    }
   }
-  const content = legacyContent();
-  emitEnd();
-  return content;
+  return invalid2();
 }
 var askStorage = new AsyncLocalStorage();
 var inlineSchemaCache = /* @__PURE__ */ new WeakMap();
@@ -5060,9 +5867,8 @@ var WorkflowContext = class _WorkflowContext {
   providerRegistry;
   sessionHistory;
   onTrace;
-  onToken;
-  onToolCall;
   pendingDecisions;
+  awaitHumanClaims;
   budgetContext;
   stateStore;
   /** Root step counter for this execution. Inherited by every ctx.ask()
@@ -5083,27 +5889,27 @@ var WorkflowContext = class _WorkflowContext {
    * the caller-supplied key.
    */
   autoCheckpointCounters;
-  /** Idempotency guards for `workflow_start` / `workflow_end` emission.
+  branchDrainState;
+  /** Root-shared idempotency guards for workflow lifecycle emission.
    *  Both `runtime.execute()` and `runtime.stream()` have paths where a
    *  post-emit side-effect (checkpoint deletion, state-store persistence)
    *  can throw AFTER `_emitWorkflowEnd({status: 'completed'})` has already
    *  fired — the outer catch would then fire `_emitWorkflowEnd({status:
    *  'failed'})` for a second time. These flags make both emitters
    *  single-fire so consumers never see paired-then-conflicting terminal
-   *  events for one execution. */
-  _workflowStartEmitted = false;
-  _workflowEndEmitted = false;
+   *  events for one execution. Sharing the state with child contexts also
+   *  suppresses late branch events after bounded finalization. */
+  workflowLifecycleState;
   signal;
   summaryCache;
   workflowName;
   mcpManager;
   spanManager;
   memoryManager;
-  resumeMode;
   toolOverrides;
   awaitHumanHandler;
-  onAgentStart;
   onAgentCallComplete;
+  _onDecisionCleanupFailed;
   /** Shared mutable slot for the lazy `AxlEventBus`. The slot is shared
    *  by reference across parent/child contexts so a late allocation
    *  (consumer subscribes after a child context exists) is visible
@@ -5112,6 +5918,7 @@ var WorkflowContext = class _WorkflowContext {
    *  contexts that never observe). */
   _busRef;
   _eventStreamOptions;
+  _forceStreaming;
   /** Removes the constructor-registered `'abort'` listener from
    *  `this.signal` so a long-lived signal (e.g., a request-scoped or
    *  process-wide signal reused across many `runtime.createContext()` /
@@ -5131,8 +5938,7 @@ var WorkflowContext = class _WorkflowContext {
    *    *between* asks. `ctx.events.partialObjects` is the coalescing view
    *    designed for streaming-structured-output UIs.
    *  - **Ad-hoc contexts** from `runtime.createContext()`: the same
-   *    iterable replaces the legacy `onToken` / `onToolCall` /
-   *    `onAgentStart` callbacks.
+   *    iterable provides typed per-context observation.
    *  - **Cross-execution**: prefer `runtime.on('trace', …)` instead — that
    *    fans out across all executions, while `ctx.events` is per-context.
    *
@@ -5147,9 +5953,9 @@ var WorkflowContext = class _WorkflowContext {
    *
    * **Subscribe before the first `ctx.ask()`.** The streaming code
    * path inside `ctx.ask()` activates only when an observer is
-   * present at the time the ask starts (`_streamingEnabled` — either
-   * the legacy `onToken` callback is set or `ctx.events` has been
-   * allocated). If you allocate `ctx.events` AFTER a `ctx.ask()` has
+   * present at the time the ask starts (`_streamingEnabled` — an explicit
+   * runtime streaming mode or allocated `ctx.events`). If you allocate
+   * `ctx.events` AFTER a `ctx.ask()` has
    * begun, that in-flight ask will not stream `token` /
    * `partial_object` events at all (the agent loop went through
    * `provider.chat` instead of `provider.stream`). Subsequent asks
@@ -5188,18 +5994,16 @@ var WorkflowContext = class _WorkflowContext {
     this._busRef.current?._finish();
     this.abortListenerCleanup?.();
   }
-  /** True if any observer wants per-token streaming for asks started
-   *  from this context: either the legacy `onToken` callback is set
-   *  (e.g., `runtime.stream()` plumbs a sentinel) OR `ctx.events` has
-   *  been allocated (a workflow-handler consumer subscribed before
-   *  the ask). `ctx.ask` reads this to decide whether to enter the
+  /** True when asks should use provider streaming: `runtime.stream()` set an
+   *  explicit internal mode or `ctx.events` has been allocated. `ctx.ask`
+   *  reads this to decide whether to enter the
    *  streaming code path; the gate is re-checked per ask, so a
    *  consumer subscribing AFTER the first ask started still gets
    *  streaming on the next one. The check `_busRef.current !== undefined`
    *  is a one-way flag — `_finish` does not unset the reference, so
    *  once an observer was present, every subsequent ask streams. */
   get _streamingEnabled() {
-    return this.onToken !== void 0 || this._busRef.current !== void 0;
+    return this._forceStreaming || this._busRef.current !== void 0;
   }
   constructor(init) {
     this.input = init.input;
@@ -5209,9 +6013,8 @@ var WorkflowContext = class _WorkflowContext {
     this.providerRegistry = init.providerRegistry;
     this.sessionHistory = init.sessionHistory ?? [];
     this.onTrace = init.onTrace;
-    this.onToken = init.onToken;
-    this.onToolCall = init.onToolCall;
     this.pendingDecisions = init.pendingDecisions;
+    this.awaitHumanClaims = init.awaitHumanClaims ?? /* @__PURE__ */ new Map();
     this.budgetContext = init.budgetContext;
     this.stateStore = init.stateStore;
     this.signal = init.signal;
@@ -5219,13 +6022,13 @@ var WorkflowContext = class _WorkflowContext {
     this.mcpManager = init.mcpManager;
     this.spanManager = init.spanManager;
     this.memoryManager = init.memoryManager;
-    this.resumeMode = init.resumeMode ?? false;
     this.toolOverrides = init.toolOverrides;
     this.awaitHumanHandler = init.awaitHumanHandler;
-    this.onAgentStart = init.onAgentStart;
     this.onAgentCallComplete = init.onAgentCallComplete;
+    this._onDecisionCleanupFailed = init._onDecisionCleanupFailed;
     this._busRef = init._busRef ?? { current: void 0 };
     this._eventStreamOptions = init.eventStreamOptions;
+    this._forceStreaming = init._forceStreaming ?? false;
     if (init._busRef === void 0 && this.signal && !this.signal.aborted) {
       const signal = this.signal;
       const onAbort = () => {
@@ -5241,6 +6044,15 @@ var WorkflowContext = class _WorkflowContext {
       byAgent: /* @__PURE__ */ new Map(),
       root: 0
     };
+    const branchDrainTimeoutMs = resolveBranchDrainTimeoutMs(init.branchDrainTimeoutMs);
+    this.branchDrainState = init.branchDrainState ?? {
+      pending: /* @__PURE__ */ new Set(),
+      timeoutMs: branchDrainTimeoutMs
+    };
+    this.workflowLifecycleState = init.workflowLifecycleState ?? {
+      startEmitted: false,
+      endEmitted: false
+    };
     if (init.metadata?.summaryCache) {
       this.summaryCache = init.metadata.summaryCache;
     }
@@ -5249,16 +6061,9 @@ var WorkflowContext = class _WorkflowContext {
    * Create a child context for nested agent invocations (e.g., agent-as-tool).
    * Shares: budget tracking, abort signals, trace emission, provider registry,
    *         state store, span manager, memory manager, MCP manager, config,
-   *         awaitHuman handler, pending decisions, tool overrides, AND the
-   *         streaming callbacks (onToken / onAgentStart / onToolCall).
+   *         awaitHuman handler, pending decisions, tool overrides, and event bus.
    * Isolates: session history.
    *
-   * Streaming callbacks now propagate into nested asks because every callback
-   * invocation carries `meta.askId`/`meta.parentAskId`/`meta.depth` so
-   * consumers that want root-only behavior can filter on `meta.depth === 0`
-   * instead of relying on the runtime to drop nested events. This is the
-   * "nested ask visibility" fix from spec §3.2.
-   *
    * The shared step counter lives in `askStorage` (ALS), so there is no
    * per-context counter to pass through anymore. Nested events are
    * correlated to their parent via `parentAskId` (set on every nested ask
@@ -5279,12 +6084,11 @@ var WorkflowContext = class _WorkflowContext {
       spanManager: this.spanManager,
       memoryManager: this.memoryManager,
       onTrace: this.onTrace,
-      onToken: this.onToken,
-      onToolCall: this.onToolCall,
-      onAgentStart: this.onAgentStart,
       onAgentCallComplete: this.onAgentCallComplete,
+      _onDecisionCleanupFailed: this._onDecisionCleanupFailed,
       awaitHumanHandler: this.awaitHumanHandler,
       pendingDecisions: this.pendingDecisions,
+      awaitHumanClaims: this.awaitHumanClaims,
       toolOverrides: this.toolOverrides,
       signal: this.signal,
       workflowName: this.workflowName,
@@ -5292,12 +6096,15 @@ var WorkflowContext = class _WorkflowContext {
       // emitted from `ctx.ask` / spawn / race / parallel / map in this
       // child context don't collide with the parent's in the state store.
       autoCheckpointCounters: this.autoCheckpointCounters,
+      branchDrainState: this.branchDrainState,
+      workflowLifecycleState: this.workflowLifecycleState,
       // Share the parent's bus slot (mutable ref). Late allocation in
       // either parent or child propagates because both read the same
       // slot. Nested-ask events (agent-as-tool pattern) bubble up to
       // the parent's iterator with `parentAskId`/`depth` correlation
       // intact.
       _busRef: this._busRef,
+      _forceStreaming: this._forceStreaming,
       eventStreamOptions: this._eventStreamOptions
       // Isolated: sessionHistory (empty)
     });
@@ -5310,28 +6117,194 @@ var WorkflowContext = class _WorkflowContext {
   get currentSignal() {
     return signalStorage.getStore() ?? this.signal;
   }
-  /**
-   * Build a `CallbackMeta` for the current ask frame. Used at every
-   * `onToken`/`onToolCall`/`onAgentStart` call site so consumers can
-   * route or filter by ask correlation (`meta.depth === 0` for root
-   * chat UIs, etc.).
-   *
-   * If the call is somehow outside an ask frame (e.g., a programmatic
-   * `tool.run()` test harness), falls back to a synthetic meta keyed off
-   * `executionId` so the type contract holds — consumers see `depth: 0`
-   * and can ignore those events.
-   */
-  currentCallbackMeta(agentName) {
-    const frame = askStorage.getStore();
-    if (frame) {
-      return {
-        askId: frame.askId,
-        ...frame.parentAskId ? { parentAskId: frame.parentAskId } : {},
-        depth: frame.depth,
-        agent: agentName
+  _registerBranchDrain(promise) {
+    const state = this.branchDrainState;
+    state.pending.add(promise);
+    void promise.then(
+      () => state.pending.delete(promise),
+      (error) => {
+        state.pending.delete(promise);
+        if (!state.overflow && isEventStreamOverflowError(error)) {
+          state.overflow = error;
+        }
+      }
+    );
+  }
+  /** Wait for race/quorum losers (including nested branch work) to settle.
+   *  Primitive calls still resolve as soon as their winner/quorum is known;
+   *  this is only the runtime's terminal/persistence barrier. */
+  async _drainBranchWork() {
+    const state = this.branchDrainState;
+    state.deadline ??= Date.now() + state.timeoutMs;
+    while (state.pending.size > 0) {
+      const overflow2 = state.overflow;
+      state.overflow = void 0;
+      if (overflow2) throw overflow2;
+      const remaining = state.deadline - Date.now();
+      if (remaining <= 0) {
+        return {
+          complete: false,
+          reason: "branch_drain_timeout",
+          pendingContinuations: state.pending.size,
+          timeoutMs: state.timeoutMs
+        };
+      }
+      let timer;
+      const settled = await Promise.race([
+        Promise.allSettled([...state.pending]).then(() => true),
+        new Promise((resolve2) => {
+          timer = setTimeout(() => resolve2(false), remaining);
+        })
+      ]);
+      if (timer) clearTimeout(timer);
+      if (!settled) {
+        return {
+          complete: false,
+          reason: "branch_drain_timeout",
+          pendingContinuations: state.pending.size,
+          timeoutMs: state.timeoutMs
+        };
+      }
+    }
+    const overflow = state.overflow;
+    state.overflow = void 0;
+    if (overflow) throw overflow;
+    state.deadline = void 0;
+    return { complete: true };
+  }
+  /** Resolve, execute, and observe one non-handoff tool request. Rejections
+   * never start. Every accepted request emits one terminal event before a
+   * continuation message or abort escapes this coordinator. */
+  async observeToolInvocation(agent2, toolCall, currentMessages, availableTools) {
+    const signal = this.currentSignal;
+    signal?.throwIfAborted();
+    const requestedTool = toolCall.function.name;
+    const configuredTool = agent2._config.tools?.find(
+      (candidate) => candidate.name === requestedTool
+    );
+    const override = this.toolOverrides?.get(requestedTool);
+    const mcpManager = this.mcpManager;
+    const mcpMatch = !configuredTool ? mcpManager?.getToolsForAgent(agent2._config.mcp, agent2._config.mcpTools).find(({ tool: tool2 }) => tool2.name === requestedTool) : void 0;
+    const parsed = parseToolInvocation({
+      toolCall,
+      configuredTool,
+      override,
+      ...mcpMatch && mcpManager ? {
+        mcpCall: (args) => mcpManager.callTool(requestedTool, args, mcpMatch.server),
+        mcpTraceName: `${mcpMatch.server}:${requestedTool}`
+      } : {},
+      availableTools
+    });
+    signal?.throwIfAborted();
+    if ("kind" in parsed) {
+      this.emitEvent({
+        type: "tool_call_rejected",
+        agent: agent2._name,
+        tool: parsed.toolName,
+        callId: parsed.callId,
+        data: parsed.data
+      });
+      currentMessages.push({
+        role: "tool",
+        content: parsed.modelMessage,
+        tool_call_id: parsed.callId
+      });
+      return;
+    }
+    const startArgs = cloneToolArguments(parsed.args);
+    this.emitEvent({
+      type: "tool_call_start",
+      agent: agent2._name,
+      tool: parsed.toolName,
+      callId: parsed.callId,
+      data: {
+        args: startArgs,
+        ...parsed.requestedTool !== parsed.toolName ? { requestedTool: parsed.requestedTool } : {}
+      }
+    });
+    const startedAt = Date.now();
+    const requestApproval = async () => {
+      const approve = async () => {
+        const approvalArgs = cloneToolArguments(parsed.args);
+        const decision = await this.awaitHuman({
+          channel: "tool_approval",
+          prompt: `Tool "${parsed.toolName}" wants to execute with args: ${JSON.stringify(parsed.args)}`,
+          metadata: { toolName: parsed.toolName, args: approvalArgs, agent: agent2._name }
+        });
+        return decision.approved ? { approved: true } : { approved: false, reason: decision.reason ?? "Denied by human" };
       };
+      const approval = this.spanManager ? await this.spanManager.withSpanAsync(
+        "axl.tool.approval",
+        { "axl.tool.name": parsed.toolName, "axl.agent.name": agent2._name },
+        async (span) => {
+          const value = await approve();
+          span.setAttribute("axl.tool.approval.approved", value.approved);
+          return value;
+        }
+      ) : await approve();
+      this.emitEvent({
+        type: "tool_approval",
+        agent: agent2._name,
+        tool: parsed.toolName,
+        callId: parsed.callId,
+        data: {
+          approved: approval.approved,
+          args: cloneToolArguments(parsed.args),
+          ...approval.reason ? { reason: approval.reason } : {}
+        }
+      });
+      return approval;
+    };
+    let terminalEmitted = false;
+    const executeAndObserve = async (span) => {
+      const settlement2 = await settleAcceptedTool({
+        invocation: parsed,
+        context: this,
+        signal,
+        requestApproval,
+        createChildContext: () => this.createChildContext()
+      });
+      const duration = Date.now() - startedAt;
+      span?.setAttribute("axl.tool.duration", duration);
+      if (span) recordToolSpanOutcome(span, settlement2.outcome);
+      if (terminalEmitted) {
+        throw new Error(`Tool invocation ${parsed.callId} emitted more than one terminal event`);
+      }
+      terminalEmitted = true;
+      try {
+        this.emitEvent({
+          type: "tool_call_end",
+          agent: agent2._name,
+          tool: parsed.toolName,
+          callId: parsed.callId,
+          duration,
+          data: {
+            args: cloneToolArguments(parsed.args),
+            ...parsed.requestedTool !== parsed.toolName ? { requestedTool: parsed.requestedTool } : {},
+            outcome: settlement2.outcome
+          }
+        });
+      } catch (error) {
+        if (error instanceof Error && settlement2.abortError !== void 0) {
+          throw preserveErrorCause(error, settlement2.abortError);
+        }
+        throw error;
+      }
+      return settlement2;
+    };
+    const settlement = this.spanManager ? await this.spanManager.withSpanAsync(
+      "axl.tool.call",
+      { "axl.tool.name": parsed.toolName, "axl.agent.name": agent2._name },
+      executeAndObserve
+    ) : await executeAndObserve();
+    if (settlement.providerContent !== void 0) {
+      currentMessages.push({
+        role: "tool",
+        content: settlement.providerContent,
+        tool_call_id: parsed.callId
+      });
     }
-    return { askId: this.executionId, depth: 0, agent: agentName };
+    if (settlement.abortError !== void 0) throw settlement.abortError;
   }
   // ── ctx.ask() ─────────────────────────────────────────────────────────
   async ask(agent2, prompt, options) {
@@ -5360,18 +6333,21 @@ var WorkflowContext = class _WorkflowContext {
           const resolveCtx = options?.metadata ? { metadata: { ...this.metadata, ...options.metadata } } : { metadata: this.metadata };
           const usageCapture = {};
           const doCall = async () => {
-            const result = await this.executeAgentCall(
+            const result2 = await this.executeAgentCall(
               agent2,
               prompt,
               options,
               void 0,
               usageCapture
             );
-            return result;
+            return result2;
           };
           let outcome;
+          let askFailure;
+          let askFailed = false;
+          let result;
           try {
-            const result = this.spanManager ? await this.spanManager.withSpanAsync(
+            result = this.spanManager ? await this.spanManager.withSpanAsync(
               "axl.agent.ask",
               {
                 "axl.agent.name": agent2._name,
@@ -5430,36 +6406,34 @@ var WorkflowContext = class _WorkflowContext {
                 );
               }
             }
-            return result;
           } catch (err) {
+            askFailed = true;
+            askFailure = err;
             outcome = {
               ok: false,
               error: err instanceof Error ? err.message : String(err)
             };
-            throw err;
-          } finally {
-            try {
-              this.emitEvent({
-                type: "ask_end",
-                outcome: outcome ?? {
-                  ok: false,
-                  error: "ask_end emitted without outcome \u2014 internal bug"
-                },
-                cost: frame.askCost.value,
-                ...frame.askUnpriced ? { unpriced: true } : {},
-                duration: Date.now() - askStart
-              });
-            } catch (emitErr) {
-              if (emitErr instanceof EventStreamOverflowError && outcome && !outcome.ok) {
-                console.error(
-                  "[axl] ask_end emit overflowed during error path; preserving original error:",
-                  emitErr.message
-                );
-              } else {
-                throw emitErr;
-              }
-            }
           }
+          let terminalFailure;
+          let terminalFailed = false;
+          try {
+            this.emitEvent({
+              type: "ask_end",
+              outcome: outcome ?? {
+                ok: false,
+                error: "ask_end emitted without outcome \u2014 internal bug"
+              },
+              cost: frame.askCost.value,
+              ...frame.askUnpriced ? { unpriced: true } : {},
+              duration: Date.now() - askStart
+            });
+          } catch (error) {
+            terminalFailed = true;
+            terminalFailure = isEventStreamOverflowError(error) ? preserveErrorCause(error, askFailure) : error;
+          }
+          if (terminalFailed) throw terminalFailure;
+          if (askFailed) throw askFailure;
+          return result;
         });
       },
       { agent: agentName }
@@ -5681,7 +6655,6 @@ ${appendedSchemaText}`;
           }
         } : { type: "json_object" };
       }
-      const callbackMeta = this.currentCallbackMeta(agent2._name);
       const callParams = {
         ...chatOptions.temperature !== void 0 ? { temperature: chatOptions.temperature } : {},
         maxTokens: chatOptions.maxTokens,
@@ -5720,7 +6693,6 @@ ${appendedSchemaText}`;
           ...messagesSnapshot ? { messages: messagesSnapshot } : {}
         }
       });
-      this.onAgentStart?.({ agent: agent2._name, model: modelUri }, callbackMeta);
       let response;
       try {
         this.currentSignal?.throwIfAborted();
@@ -5746,7 +6718,6 @@ ${appendedSchemaText}`;
             if (chunk.type === "text_delta") {
               content2 += chunk.content;
               this.emitEvent({ type: "token", data: chunk.content });
-              this.onToken?.(chunk.content, callbackMeta);
               if (walker) {
                 walker.processChunk(chunk.content);
                 if (walker.consumeBoundary()) {
@@ -5856,6 +6827,7 @@ ${appendedSchemaText}`;
           ...retryReason ? { retryReason } : {}
         }
       });
+      this.currentSignal?.throwIfAborted();
       if (response.tool_calls && response.tool_calls.length > 0) {
         currentMessages.push({
           role: "assistant",
@@ -6025,263 +6997,12 @@ ${appendedSchemaText}`;
               return await handoffFn();
             }
           }
-          const tool2 = agent2._config.tools?.find((candidate) => candidate.name === toolName);
-          const isMcpTool = !tool2 && this.mcpManager?.isMcpTool(toolName);
-          const toolOverride = this.toolOverrides?.get(toolName);
-          if (toolOverride) {
-            let toolArgs2;
-            try {
-              toolArgs2 = JSON.parse(toolCall.function.arguments);
-            } catch {
-              currentMessages.push({
-                role: "tool",
-                content: `Error: Invalid JSON in tool arguments. Please provide valid JSON.`,
-                tool_call_id: toolCall.id
-              });
-              continue;
-            }
-            this.emitEvent({
-              type: "tool_call_start",
-              tool: toolName,
-              callId: toolCall.id,
-              data: { args: toolArgs2 }
-            });
-            this.onToolCall?.(
-              { name: toolName, args: toolArgs2, callId: toolCall.id },
-              callbackMeta
-            );
-            const toolStart2 = Date.now();
-            const suppressErrorShapeInspection2 = tool2?.sensitive === true || tool2?.toModelOutput !== void 0;
-            const executeOverride = async () => {
-              try {
-                return { kind: "returned", value: await toolOverride(toolArgs2) };
-              } catch (err) {
-                return {
-                  kind: "thrown",
-                  value: { error: err instanceof Error ? err.message : String(err) }
-                };
-              }
-            };
-            const outcome = this.spanManager ? await this.spanManager.withSpanAsync(
-              "axl.tool.call",
-              {
-                "axl.tool.name": toolName,
-                "axl.agent.name": agent2._name
-              },
-              async (span) => {
-                const result = await executeOverride();
-                span.setAttribute("axl.tool.duration", Date.now() - toolStart2);
-                recordToolSpanResult(span, result.value, suppressErrorShapeInspection2);
-                return result;
-              }
-            ) : await executeOverride();
-            const toolResult2 = outcome.value;
-            const resultContent2 = finalizeToolResult({
-              toolName,
-              configuredTool: tool2,
-              outcome,
-              legacyContent: () => tool2?.sensitive ? "[REDACTED - sensitive tool output]" : JSON.stringify(toolResult2),
-              emitEnd: () => {
-                const toolDuration2 = Date.now() - toolStart2;
-                this.emitEvent({
-                  type: "tool_call_end",
-                  agent: agent2._name,
-                  tool: toolName,
-                  duration: toolDuration2,
-                  data: { args: toolArgs2, result: toolResult2, callId: toolCall.id }
-                });
-              },
-              beforeProjection: () => this.currentSignal?.throwIfAborted()
-            });
-            currentMessages.push({
-              role: "tool",
-              content: resultContent2,
-              tool_call_id: toolCall.id
-            });
-            continue;
-          }
-          if (!tool2 && !isMcpTool) {
-            this.emitEvent({ type: "tool_denied", agent: agent2._name, tool: toolName });
-            currentMessages.push({
-              role: "tool",
-              content: `Tool "${toolName}" is not available. Available tools: ${agent2._config.tools?.map((t) => t.name).join(", ") ?? "none"}`,
-              tool_call_id: toolCall.id
-            });
-            continue;
-          }
-          let toolArgs;
-          try {
-            toolArgs = JSON.parse(toolCall.function.arguments);
-          } catch {
-            currentMessages.push({
-              role: "tool",
-              content: `Error: Invalid JSON in tool arguments. Please provide valid JSON.`,
-              tool_call_id: toolCall.id
-            });
-            continue;
-          }
-          this.emitEvent({
-            type: "tool_call_start",
-            tool: toolName,
-            callId: toolCall.id,
-            data: { args: toolArgs }
-          });
-          this.onToolCall?.({ name: toolName, args: toolArgs, callId: toolCall.id }, callbackMeta);
-          const toolStart = Date.now();
-          const suppressErrorShapeInspection = tool2?.sensitive === true || tool2?.toModelOutput !== void 0;
-          if (tool2 && tool2.requireApproval) {
-            const approvalFn = async () => {
-              const decision = await this.awaitHuman({
-                channel: "tool_approval",
-                prompt: `Tool "${toolName}" wants to execute with args: ${JSON.stringify(toolArgs)}`,
-                metadata: { toolName, args: toolArgs, agent: agent2._name }
-              });
-              if (!decision.approved) {
-                const reason = decision.reason ?? "Denied by human";
-                currentMessages.push({
-                  role: "tool",
-                  content: JSON.stringify({ error: `Tool denied by human: ${reason}` }),
-                  tool_call_id: toolCall.id
-                });
-                return { approved: false, reason };
-              }
-              return { approved: true };
-            };
-            let approvalOutcome;
-            if (this.spanManager) {
-              approvalOutcome = await this.spanManager.withSpanAsync(
-                "axl.tool.approval",
-                {
-                  "axl.tool.name": toolName,
-                  "axl.agent.name": agent2._name
-                },
-                async (span) => {
-                  const result = await approvalFn();
-                  span.setAttribute("axl.tool.approval.approved", result.approved);
-                  return result;
-                }
-              );
-            } else {
-              approvalOutcome = await approvalFn();
-            }
-            this.emitEvent({
-              type: "tool_approval",
-              agent: agent2._name,
-              tool: toolName,
-              data: {
-                approved: approvalOutcome.approved,
-                args: toolArgs,
-                ...approvalOutcome.reason ? { reason: approvalOutcome.reason } : {}
-              }
-            });
-            if (!approvalOutcome.approved) continue;
-          }
-          if (tool2 && tool2.hooks?.before) {
-            try {
-              toolArgs = await tool2.hooks.before(toolArgs, this);
-            } catch (err) {
-              const errorMsg = err instanceof Error ? err.message : String(err);
-              currentMessages.push({
-                role: "tool",
-                content: JSON.stringify({ error: `Before hook error: ${errorMsg}` }),
-                tool_call_id: toolCall.id
-              });
-              continue;
-            }
-          }
-          const executeTool = async () => {
-            let outcome;
-            let resultContent2;
-            if (isMcpTool && this.mcpManager) {
-              try {
-                const mcpResult = await this.mcpManager.callTool(toolName, toolArgs);
-                outcome = { kind: "returned", value: mcpResult };
-                resultContent2 = mcpResult.content.map(
-                  (c) => c.type === "text" ? c.text : `[${c.type}]`
-                ).join("\n");
-                if (mcpResult.isError) {
-                  resultContent2 = `Error: ${resultContent2}`;
-                }
-              } catch (err) {
-                outcome = {
-                  kind: "thrown",
-                  value: { error: err instanceof Error ? err.message : String(err) }
-                };
-                resultContent2 = JSON.stringify(outcome.value);
-              }
-            } else if (tool2) {
-              const childCtx = this.createChildContext();
-              try {
-                outcome = { kind: "returned", value: await tool2._execute(toolArgs, childCtx) };
-              } catch (err) {
-                outcome = {
-                  kind: "thrown",
-                  value: { error: err instanceof Error ? err.message : String(err) }
-                };
-              }
-              if (outcome.kind === "returned" && tool2.hooks?.after && !(suppressErrorShapeInspection ? isErrorShapedSafely(outcome.value) : isErrorShaped(outcome.value))) {
-                try {
-                  outcome = {
-                    kind: "returned",
-                    value: await tool2.hooks.after(outcome.value, this)
-                  };
-                } catch (err) {
-                  outcome = {
-                    kind: "thrown",
-                    value: {
-                      error: `After hook error: ${err instanceof Error ? err.message : String(err)}`
-                    }
-                  };
-                }
-              }
-              if (tool2.sensitive) {
-                resultContent2 = "[REDACTED - sensitive tool output]";
-              } else if (outcome.kind === "thrown" || tool2.toModelOutput === void 0) {
-                resultContent2 = JSON.stringify(outcome.value);
-              }
-            } else {
-              outcome = { kind: "returned", value: void 0 };
-              resultContent2 = "Tool execution error";
-            }
-            return { outcome, resultContent: resultContent2 };
-          };
-          const traceName = isMcpTool && this.mcpManager ? this.mcpManager.getQualifiedName(toolName) ?? toolName : toolName;
-          const execution = this.spanManager ? await this.spanManager.withSpanAsync(
-            "axl.tool.call",
-            {
-              "axl.tool.name": traceName,
-              "axl.agent.name": agent2._name
-            },
-            async (span) => {
-              const r = await executeTool();
-              span.setAttribute("axl.tool.duration", Date.now() - toolStart);
-              recordToolSpanResult(span, r.outcome.value, suppressErrorShapeInspection);
-              return r;
-            }
-          ) : await executeTool();
-          const toolResult = execution.outcome.value;
-          const toolDuration = Date.now() - toolStart;
-          const resultContent = finalizeToolResult({
-            toolName,
-            configuredTool: tool2,
-            outcome: execution.outcome,
-            legacyContent: () => execution.resultContent,
-            emitEnd: () => {
-              this.emitEvent({
-                type: "tool_call_end",
-                agent: agent2._name,
-                tool: traceName,
-                duration: toolDuration,
-                data: { args: toolArgs, result: toolResult, callId: toolCall.id }
-              });
-            },
-            beforeProjection: () => this.currentSignal?.throwIfAborted()
-          });
-          currentMessages.push({
-            role: "tool",
-            content: resultContent,
-            tool_call_id: toolCall.id
-          });
+          await this.observeToolInvocation(
+            agent2,
+            toolCall,
+            currentMessages,
+            toolDefs.map((tool2) => tool2.function.name)
+          );
         }
         continue;
       }
@@ -6401,7 +7122,7 @@ ${appendedSchemaText}`;
             pendingRetryReason = "schema";
             continue;
           }
-          const zodErr = schemaErr instanceof ZodError ? schemaErr : new ZodError([
+          const zodErr = schemaErr instanceof ZodError2 ? schemaErr : new ZodError2([
             {
               code: "custom",
               path: [],
@@ -6418,6 +7139,7 @@ ${appendedSchemaText}`;
             metadata: this.metadata
           });
         } catch (err) {
+          rethrowEventStreamOverflow(err);
           const reason = err instanceof Error ? err.message : String(err);
           validateResult = { valid: false, reason: `Validator error: ${reason}` };
         }
@@ -6754,12 +7476,12 @@ ${summaryResponse.content}`
    * Execute a function with checkpoint-replay semantics.
    *
    * On first execution, runs `fn()`, saves the result under `name`, and
-   * returns it. On replay (resume after restart), returns the saved result
-   * without re-executing. This prevents duplicate side effects (double API
-   * calls, double refunds, etc.).
+   * returns it. A later evaluation in the same explicit execution scope
+   * returns the saved result without re-executing. Axl does not restart or
+   * resume workflow continuations across processes.
    *
    * `name` must be a stable, caller-supplied identifier — the same call
-   * site MUST pass the same name across runs of the same execution for
+   * site MUST pass the same name across evaluations of the same execution for
    * replay to work. Names are scoped to a single execution and must be
    * unique within it; reusing a name (e.g. inside a loop) gives
    * last-write-wins behavior. For loops, compose names from the iterator:
@@ -6882,6 +7604,7 @@ ${summaryResponse.content}`
         for (let i = 0; i < n; i++) {
           const index = i;
           const p = signalStorage.run(composedSignal, () => fn(index));
+          this._registerBranchDrain(p);
           p.then((value) => {
             if (settled) return;
             results[index] = { ok: true, value };
@@ -6896,6 +7619,14 @@ ${summaryResponse.content}`
               reject(new QuorumNotMet(quorum, successCount, results));
             }
           }).catch((err) => {
+            if (isEventStreamOverflowError(err)) {
+              if (!settled) {
+                settled = true;
+                controller.abort();
+                reject(err);
+              }
+              return;
+            }
             if (settled) return;
             const isAbort = err instanceof DOMException && err.name === "AbortError";
             if (isAbort) {
@@ -6918,14 +7649,16 @@ ${summaryResponse.content}`
     }
     const parentSignal = this.currentSignal;
     const promises = Array.from({ length: n }, (_, i) => {
-      const run = () => fn(i).then((value) => ({ ok: true, value })).catch(
-        (err) => ({
+      const run = () => fn(i).then((value) => ({ ok: true, value })).catch((err) => {
+        rethrowEventStreamOverflow(err);
+        return {
           ok: false,
           error: err instanceof Error ? err.message : String(err)
-        })
-      );
+        };
+      });
       return parentSignal ? signalStorage.run(parentSignal, run) : run();
     });
+    for (const promise of promises) this._registerBranchDrain(promise);
     return Promise.all(promises);
   }
   // ── ctx.vote() ────────────────────────────────────────────────────────
@@ -7063,6 +7796,7 @@ ${summaryResponse.content}`
           try {
             validateResult = await options.validate(parsed, { metadata: this.metadata });
           } catch (err) {
+            rethrowEventStreamOverflow(err);
             const reason = err instanceof Error ? err.message : String(err);
             validateResult = { valid: false, reason: `Validator error: ${reason}` };
           }
@@ -7080,6 +7814,7 @@ ${summaryResponse.content}`
         emitVerifyOutcome(true, attempt + 1);
         return parsed;
       } catch (err) {
+        rethrowEventStreamOverflow(err);
         if (err instanceof ValidationError) {
           lastRetry = {
             error: err.reason,
@@ -7102,12 +7837,12 @@ ${summaryResponse.content}`
           }
           continue;
         }
-        const errorMsg = err instanceof ZodError ? err.message : err instanceof Error ? err.message : String(err);
+        const errorMsg = err instanceof ZodError2 ? err.message : err instanceof Error ? err.message : String(err);
         lastRetry = { error: errorMsg, output: rawOutput };
         if (attempt === maxRetries) {
           emitVerifyOutcome(false, attempt + 1, errorMsg);
           if (options?.fallback !== void 0) return options.fallback;
-          const zodErr = err instanceof ZodError ? err : new ZodError([{ code: "custom", path: [], message: errorMsg }]);
+          const zodErr = err instanceof ZodError2 ? err : new ZodError2([{ code: "custom", path: [], message: errorMsg }]);
           throw new VerifyError(rawOutput, zodErr, maxRetries);
         }
       }
@@ -7116,7 +7851,7 @@ ${summaryResponse.content}`
     if (options?.fallback !== void 0) return options.fallback;
     throw new VerifyError(
       lastRetry?.output,
-      new ZodError([{ code: "custom", path: [], message: "Verify failed" }]),
+      new ZodError2([{ code: "custom", path: [], message: "Verify failed" }]),
       maxRetries
     );
   }
@@ -7146,6 +7881,7 @@ ${summaryResponse.content}`
         const unpriced = this.budgetContext.unpriced;
         return { value, budgetExceeded: exceeded, totalCost, unpriced };
       } catch (err) {
+        rethrowEventStreamOverflow(err);
         if (this.budgetContext.exceeded) {
           return {
             value: null,
@@ -7246,7 +7982,8 @@ ${summaryResponse.content}`
       let remaining = fns.length;
       for (const fn of fns) {
         const p = signalStorage.run(composedSignal, fn);
-        p.then(async (value) => {
+        this._registerBranchDrain(p);
+        const continuation = p.then(async (value) => {
           if (settled) return;
           if (schema) {
             const parsed = schema.safeParse(value);
@@ -7276,6 +8013,7 @@ ${summaryResponse.content}`
                   return;
                 }
               } catch (err) {
+                rethrowEventStreamOverflow(err);
                 remaining--;
                 lastError = err instanceof Error ? err : new Error(`Validator error: ${String(err)}`);
                 if (remaining === 0 && !settled) {
@@ -7295,6 +8033,14 @@ ${summaryResponse.content}`
           controller.abort();
           resolve2(value);
         }).catch((err) => {
+          if (isEventStreamOverflowError(err)) {
+            if (!settled) {
+              settled = true;
+              controller.abort();
+              reject(err);
+            }
+            throw err;
+          }
           if (settled) return;
           if (err instanceof DOMException && err.name === "AbortError") {
             remaining--;
@@ -7311,6 +8057,7 @@ ${summaryResponse.content}`
             reject(lastError);
           }
         });
+        this._registerBranchDrain(continuation);
       }
     });
   }
@@ -7349,9 +8096,19 @@ ${summaryResponse.content}`
           const idx = nextIndex++;
           try {
             const value = mapSignal ? await signalStorage.run(mapSignal, () => fn(items[idx], idx)) : await fn(items[idx], idx);
+            if (settled) return;
             results[idx] = { ok: true, value };
             successCount++;
           } catch (err) {
+            if (isEventStreamOverflowError(err)) {
+              settled = true;
+              controller?.abort();
+              reject(err);
+              throw err;
+            }
+            if (settled) {
+              return;
+            }
             if (err instanceof DOMException && err.name === "AbortError" && controller?.signal.aborted) {
               completedCount++;
               return;
@@ -7377,7 +8134,9 @@ ${summaryResponse.content}`
       };
       const workers = Math.min(concurrency, items.length);
       for (let i = 0; i < workers; i++) {
-        runNext().catch((err) => {
+        const worker = runNext();
+        this._registerBranchDrain(worker);
+        worker.catch((err) => {
           if (!settled) reject(err);
         });
       }
@@ -7403,12 +8162,44 @@ ${summaryResponse.content}`
     return this._awaitHumanImpl(options);
   }
   async _awaitHumanImpl(options) {
+    const branchSignal = this.currentSignal;
+    const makeAbortError = (reason) => {
+      if (typeof DOMException !== "undefined") {
+        return new DOMException(
+          typeof reason === "string" ? reason : "awaitHuman aborted",
+          "AbortError"
+        );
+      }
+      const err = new Error(typeof reason === "string" ? reason : "awaitHuman aborted");
+      err.name = "AbortError";
+      return err;
+    };
+    const awaitWithAbort = async (promise, signal2 = branchSignal) => {
+      if (!signal2) return promise;
+      if (signal2.aborted) throw makeAbortError(signal2.reason);
+      let onAbort;
+      try {
+        return await Promise.race([
+          promise,
+          new Promise((_, reject) => {
+            onAbort = () => reject(makeAbortError(signal2.reason));
+            signal2.addEventListener("abort", onAbort, { once: true });
+          })
+        ]);
+      } finally {
+        if (onAbort) signal2.removeEventListener("abort", onAbort);
+      }
+    };
     if (this.awaitHumanHandler) {
+      if (branchSignal?.aborted) throw makeAbortError(branchSignal.reason);
       this.emitEvent({
         type: "await_human",
         data: { channel: options.channel, prompt: options.prompt }
       });
-      const decision2 = await this.awaitHumanHandler(options);
+      if (branchSignal?.aborted) throw makeAbortError(branchSignal.reason);
+      const decision2 = parseHumanDecision(
+        await awaitWithAbort(Promise.resolve(this.awaitHumanHandler(options)))
+      );
       this.emitEvent({
         type: "await_human_resolved",
         data: { channel: options.channel, decision: decision2 }
@@ -7420,68 +8211,126 @@ ${summaryResponse.content}`
         "Tool requires approval but no approval handler is configured. Provide awaitHumanHandler to createContext() or use runtime.execute() with workflow infrastructure."
       );
     }
-    if (this.stateStore) {
-      await this.stateStore.savePendingDecision(this.executionId, {
-        executionId: this.executionId,
-        channel: options.channel,
-        prompt: options.prompt,
-        metadata: options.metadata,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      await this.stateStore.saveExecutionState(this.executionId, {
-        workflow: this.workflowName ?? "unknown",
-        input: this.input,
-        step: this.stepRefRoot.value,
-        status: "waiting",
-        metadata: {
-          ...this.metadata,
-          awaitHumanChannel: options.channel,
-          awaitHumanPrompt: options.prompt
-        }
-      });
-    }
-    this.emitEvent({
-      type: "await_human",
-      data: { channel: options.channel, prompt: options.prompt }
+    const existingClaim = this.awaitHumanClaims.get(this.executionId);
+    if (existingClaim) {
+      const error = new AxlError(
+        "CONCURRENT_HUMAN_DECISION_UNSUPPORTED",
+        `Execution "${this.executionId}" already has an active human decision. Concurrent awaitHuman calls require request-scoped decision identifiers.`
+      );
+      existingClaim.abort(error);
+      throw error;
+    }
+    const claimController = new AbortController();
+    this.awaitHumanClaims.set(this.executionId, claimController);
+    const signal = branchSignal ? AbortSignal.any([branchSignal, claimController.signal]) : claimController.signal;
+    let saveAttempted = false;
+    let markReady;
+    const ready = new Promise((resolve2) => {
+      markReady = resolve2;
     });
-    const makeAbortError = (reason) => {
-      if (typeof DOMException !== "undefined") {
-        return new DOMException(
-          typeof reason === "string" ? reason : "awaitHuman aborted",
-          "AbortError"
-        );
-      }
-      const err = new Error(typeof reason === "string" ? reason : "awaitHuman aborted");
-      err.name = "AbortError";
-      return err;
+    let markCleanupFinished;
+    const cleanupFinished = new Promise((resolve2) => {
+      markCleanupFinished = resolve2;
+    });
+    let resolveDecision;
+    let rejectDecision;
+    const decisionPromise = new Promise((resolve2, reject) => {
+      resolveDecision = resolve2;
+      rejectDecision = reject;
+    });
+    void decisionPromise.catch(() => {
+    });
+    const registeredResolver = {
+      resolve: resolveDecision,
+      ready,
+      state: "preparing",
+      cancelled: false,
+      cleanupFinished
     };
-    const decision = await new Promise((resolve2, reject) => {
-      if (this.signal?.aborted) {
-        reject(makeAbortError(this.signal.reason));
-        return;
+    this.pendingDecisions.set(this.executionId, registeredResolver);
+    const abortListener = () => {
+      registeredResolver.cancelled = true;
+      markReady();
+      rejectDecision(makeAbortError(signal.reason));
+    };
+    signal.addEventListener("abort", abortListener, { once: true });
+    let decision;
+    try {
+      if (signal.aborted) throw makeAbortError(signal.reason);
+      if (this.stateStore) {
+        saveAttempted = true;
+        await this.stateStore.savePendingDecision(this.executionId, {
+          executionId: this.executionId,
+          channel: options.channel,
+          prompt: options.prompt,
+          metadata: options.metadata,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
       }
-      this.pendingDecisions.set(this.executionId, resolve2);
-      const onAbort = () => {
-        const current = this.pendingDecisions.get(this.executionId);
-        if (current === resolve2) {
-          this.pendingDecisions.delete(this.executionId);
+      if (signal.aborted) throw makeAbortError(signal.reason);
+      this.emitEvent({
+        type: "await_human",
+        data: { channel: options.channel, prompt: options.prompt }
+      });
+      registeredResolver.state = "pending";
+      markReady();
+      decision = await decisionPromise;
+    } catch (error) {
+      if (registeredResolver.state === "preparing") {
+        registeredResolver.state = "failed";
+        markReady();
+      }
+      let needsCompensation = saveAttempted;
+      const inFlightResolution = registeredResolver.resolution;
+      if (registeredResolver.state === "resolving" && inFlightResolution) {
+        needsCompensation = !await inFlightResolution;
+      } else if (registeredResolver.state === "resolved") {
+        needsCompensation = false;
+      }
+      if (this.stateStore && needsCompensation) {
+        try {
+          await this.stateStore.resolveDecision(this.executionId, {
+            approved: false,
+            reason: "Execution aborted while awaiting approval"
+          });
+        } catch (cleanupError) {
+          if (error instanceof Error && Object.isExtensible(error)) {
+            Object.defineProperty(error, "cleanupError", {
+              configurable: true,
+              enumerable: false,
+              value: cleanupError
+            });
+          }
+          try {
+            this._onDecisionCleanupFailed?.({
+              executionId: this.executionId,
+              ...this.workflowName ? { workflow: this.workflowName } : {},
+              operation: "resolveDecision_compensation",
+              error: cleanupError
+            });
+          } catch (observerError) {
+            console.error(
+              "[axl] decision_cleanup_failed listener threw; workflow outcome unchanged:",
+              observerError instanceof Error ? observerError.message : String(observerError)
+            );
+          }
         }
-        reject(makeAbortError(this.signal?.reason));
-      };
-      this.signal?.addEventListener("abort", onAbort, { once: true });
-    });
+      }
+      throw error;
+    } finally {
+      signal.removeEventListener("abort", abortListener);
+      if (this.pendingDecisions.get(this.executionId) === registeredResolver) {
+        this.pendingDecisions.delete(this.executionId);
+      }
+      if (this.awaitHumanClaims.get(this.executionId) === claimController) {
+        this.awaitHumanClaims.delete(this.executionId);
+      }
+      markCleanupFinished();
+    }
     this.emitEvent({
       type: "await_human_resolved",
       data: { channel: options.channel, decision }
     });
-    if (this.stateStore) {
-      await this.stateStore.saveExecutionState(this.executionId, {
-        workflow: this.workflowName ?? "unknown",
-        input: this.input,
-        step: this.stepRefRoot.value,
-        status: "running"
-      });
-    }
     return decision;
   }
   /**
@@ -7533,8 +8382,8 @@ ${summaryResponse.content}`
   // Internal: the runtime is the only caller, user workflows never call these.
   /** @internal — idempotent; no-ops on second+ call within one ctx. */
   _emitWorkflowStart(input) {
-    if (this._workflowStartEmitted) return;
-    this._workflowStartEmitted = true;
+    if (this.workflowLifecycleState.startEmitted) return;
+    this.workflowLifecycleState.startEmitted = true;
     this.emitEvent({
       type: "workflow_start",
       workflow: this.workflowName,
@@ -7550,8 +8399,8 @@ ${summaryResponse.content}`
    *  status. First-wins semantics: the completed event stands, the
    *  inner side-effect failure propagates as a normal thrown error. */
   _emitWorkflowEnd(info) {
-    if (this._workflowEndEmitted) return;
-    this._workflowEndEmitted = true;
+    if (this.workflowLifecycleState.endEmitted) return;
+    this.workflowLifecycleState.endEmitted = true;
     this.emitEvent({
       type: "workflow_end",
       workflow: this.workflowName,
@@ -7561,7 +8410,8 @@ ${summaryResponse.content}`
         duration: info.duration,
         ...info.result !== void 0 ? { result: info.result } : {},
         ...info.error !== void 0 ? { error: info.error } : {},
-        ...info.aborted ? { aborted: true } : {}
+        ...info.aborted ? { aborted: true } : {},
+        ...info.observation ? { observation: info.observation } : {}
       }
     });
   }
@@ -7850,6 +8700,7 @@ ${summaryResponse.content}`
    * consumer sites via the `type` discriminator.
    */
   emitEvent(partial) {
+    if (this.workflowLifecycleState.endEmitted && partial.type !== "workflow_end") return;
     const data = partial.data;
     const frame = askStorage.getStore();
     const step = (frame?.stepRef ?? this.stepRefRoot).value++;
@@ -7875,6 +8726,7 @@ ${summaryResponse.content}`
       }
     }
     const event = {
+      schemaVersion: 2,
       executionId: this.executionId,
       step,
       timestamp: Date.now(),
@@ -7895,13 +8747,13 @@ ${summaryResponse.content}`
       ...partial,
       data
     };
-    const finalEvent = this.config.trace?.redact ? redactEvent(event) : event;
+    const finalEvent = this.config.trace?.redact ? redactHistoricalEvent(event) : event;
     let overflowErr;
     if (this.onTrace) {
       try {
         this.onTrace(finalEvent);
       } catch (err) {
-        if (err instanceof EventStreamOverflowError) {
+        if (isEventStreamOverflowError(err)) {
           overflowErr = err;
         } else {
           console.error(
@@ -7916,7 +8768,7 @@ ${summaryResponse.content}`
       try {
         bus._push(finalEvent);
       } catch (err) {
-        if (err instanceof EventStreamOverflowError) {
+        if (isEventStreamOverflowError(err)) {
           if (!overflowErr) {
             overflowErr = err;
           } else {
@@ -8103,26 +8955,31 @@ var MemoryStore = class {
   }
   // ── Execution History ──────────────────────────────────────────────
   async saveExecution(execution) {
-    this.executionHistory.set(execution.executionId, structuredClone(execution));
+    const normalized = normalizeStoredExecution({
+      ...execution,
+      eventSchemaVersion: getExecutionEventSchemaVersion(execution)
+    });
+    this.executionHistory.set(execution.executionId, structuredClone(normalized));
   }
   async getExecution(executionId) {
     const exec = this.executionHistory.get(executionId);
-    return exec ? structuredClone(exec) : null;
+    return exec ? normalizeStoredExecution(structuredClone(exec)) : null;
   }
   async listExecutions(limit) {
     const sorted = [...this.executionHistory.values()].sort((a, b) => b.startedAt - a.startedAt);
     const result = limit ? sorted.slice(0, limit) : sorted;
-    return result.map((e) => structuredClone(e));
+    return result.map((e) => normalizeStoredExecution(structuredClone(e)));
   }
   async deleteExecution(executionId) {
-    const removed = this.executionHistory.delete(executionId);
-    this.checkpoints.delete(executionId);
-    this.executionStates.delete(executionId);
-    this.streamingEvents.delete(executionId);
-    if (this.decisions.delete(executionId)) {
+    const removedHistory = this.executionHistory.delete(executionId);
+    const removedCheckpoints = this.checkpoints.delete(executionId);
+    const removedState = this.executionStates.delete(executionId);
+    const removedStreaming = this.streamingEvents.delete(executionId);
+    const removedDecision = this.decisions.delete(executionId);
+    if (removedDecision) {
       this.persistAwaitHumanState();
     }
-    return removed;
+    return removedHistory || removedCheckpoints || removedState || removedStreaming || removedDecision;
   }
   // ── Eval History ──────────────────────────────────────────────────
   async saveEvalResult(entry) {
@@ -8228,16 +9085,23 @@ function rowToExecutionInfo(row) {
     startedAt: row.started_at,
     completedAt: row.completed_at ?? void 0,
     duration: row.duration,
-    error: row.error ?? void 0,
-    events: safeJsonParse(row.events) ?? []
+    events: safeJsonParse(row.events) ?? [],
+    ...row.event_schema_version != null ? { eventSchemaVersion: row.event_schema_version } : {}
   };
+  if (row.error != null) info.error = row.error;
   if (row.metadata != null) {
     const parsed = safeJsonParse(row.metadata);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       info.metadata = parsed;
     }
   }
-  return info;
+  if (row.observation != null) {
+    const parsed = safeJsonParse(row.observation);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      info.observation = parsed;
+    }
+  }
+  return normalizeStoredExecution(info);
 }
 var SQLiteStore = class {
   db;
@@ -8277,6 +9141,10 @@ var SQLiteStore = class {
    *   column (TEXT, nullable, JSON-serialized) so caller-supplied
    *   `ExecuteOptions.metadata` round-trips through history. Existing
    *   rows get `NULL`, deserialized as `metadata: undefined`.
+   * - v4 (event schema): add `execution_history.event_schema_version`.
+   *   Existing rows remain `NULL`, the documented v1 sentinel.
+   * - v5 (observation completeness): add `execution_history.observation`.
+   *   Existing rows remain `NULL`, meaning they predate the contract.
    *
    * Applied BEFORE `initTables()` so the subsequent `CREATE TABLE
    * IF NOT EXISTS` runs against the post-migration column name. Fresh
@@ -8294,7 +9162,7 @@ var SQLiteStore = class {
    * transactional re-read costs nothing.
    */
   migrate() {
-    const TARGET_VERSION = 3;
+    const TARGET_VERSION = 5;
     const current = this.db.pragma("user_version", { simple: true });
     if (current >= TARGET_VERSION) return;
     this.db.exec("BEGIN IMMEDIATE");
@@ -8322,6 +9190,18 @@ var SQLiteStore = class {
           this.db.exec("ALTER TABLE execution_history ADD COLUMN metadata TEXT");
         }
       }
+      if (committed < 4) {
+        const cols = this.db.pragma("table_info(execution_history)");
+        if (cols.length > 0 && !cols.some((c) => c.name === "event_schema_version")) {
+          this.db.exec("ALTER TABLE execution_history ADD COLUMN event_schema_version INTEGER");
+        }
+      }
+      if (committed < 5) {
+        const cols = this.db.pragma("table_info(execution_history)");
+        if (cols.length > 0 && !cols.some((c) => c.name === "observation")) {
+          this.db.exec("ALTER TABLE execution_history ADD COLUMN observation TEXT");
+        }
+      }
       this.db.pragma(`user_version = ${TARGET_VERSION}`);
       this.db.exec("COMMIT");
     } catch (err) {
@@ -8385,7 +9265,9 @@ var SQLiteStore = class {
         duration INTEGER NOT NULL DEFAULT 0,
         error TEXT,
         events TEXT NOT NULL,
-        metadata TEXT
+        metadata TEXT,
+        event_schema_version INTEGER,
+        observation TEXT
       );
 
       CREATE TABLE IF NOT EXISTS eval_history (
@@ -8470,7 +9352,7 @@ var SQLiteStore = class {
     const stmt = this.db.prepare("DELETE FROM decisions WHERE execution_id = ?");
     stmt.run(executionId);
   }
-  // ── Execution State (for awaitHuman suspend/resume) ────────────────────
+  // ── Legacy application-managed execution state ────────────────────────
   async saveExecutionState(executionId, state) {
     const stmt = this.db.prepare(
       "INSERT OR REPLACE INTO execution_state (execution_id, workflow, input, step, status, metadata) VALUES (?, ?, ?, ?, ?, ?)"
@@ -8505,19 +9387,25 @@ var SQLiteStore = class {
   }
   // ── Execution History ────────────────────────────────────────────────────
   async saveExecution(execution) {
+    const normalized = normalizeStoredExecution({
+      ...execution,
+      eventSchemaVersion: getExecutionEventSchemaVersion(execution)
+    });
     this.db.prepare(
-      "INSERT OR REPLACE INTO execution_history (execution_id, workflow, status, total_cost, started_at, completed_at, duration, error, events, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
+      "INSERT OR REPLACE INTO execution_history (execution_id, workflow, status, total_cost, started_at, completed_at, duration, error, events, metadata, event_schema_version, observation) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
     ).run(
-      execution.executionId,
-      execution.workflow,
-      execution.status,
-      execution.totalCost,
-      execution.startedAt,
-      execution.completedAt ?? null,
-      execution.duration,
-      execution.error ?? null,
-      JSON.stringify(execution.events),
-      execution.metadata !== void 0 ? JSON.stringify(execution.metadata) : null
+      normalized.executionId,
+      normalized.workflow,
+      normalized.status,
+      normalized.totalCost,
+      normalized.startedAt,
+      normalized.completedAt ?? null,
+      normalized.duration,
+      normalized.error ?? null,
+      JSON.stringify(normalized.events),
+      normalized.metadata !== void 0 ? JSON.stringify(normalized.metadata) : null,
+      normalized.eventSchemaVersion,
+      normalized.observation !== void 0 ? JSON.stringify(normalized.observation) : null
     );
   }
   async getExecution(executionId) {
@@ -8531,11 +9419,11 @@ var SQLiteStore = class {
   }
   async deleteExecution(executionId) {
     const tx = this.db.transaction(() => {
-      const result = this.db.prepare("DELETE FROM execution_history WHERE execution_id = ?").run(executionId);
-      this.db.prepare("DELETE FROM checkpoints WHERE execution_id = ?").run(executionId);
-      this.db.prepare("DELETE FROM execution_state WHERE execution_id = ?").run(executionId);
-      this.db.prepare("DELETE FROM decisions WHERE execution_id = ?").run(executionId);
-      return result.changes > 0;
+      const historyResult = this.db.prepare("DELETE FROM execution_history WHERE execution_id = ?").run(executionId);
+      const checkpointsResult = this.db.prepare("DELETE FROM checkpoints WHERE execution_id = ?").run(executionId);
+      const stateResult = this.db.prepare("DELETE FROM execution_state WHERE execution_id = ?").run(executionId);
+      const decisionsResult = this.db.prepare("DELETE FROM decisions WHERE execution_id = ?").run(executionId);
+      return historyResult.changes + checkpointsResult.changes + stateResult.changes + decisionsResult.changes > 0;
     });
     return tx();
   }
@@ -8861,6 +9749,11 @@ var AxlStream = class extends Readable {
   get lifecycle() {
     return this.events.lifecycle;
   }
+  /** Completeness of this stream's iterator queue. Check after consumption
+   *  before treating an unmatched lifecycle event as a producer defect. */
+  get observationStatus() {
+    return this.events.observationStatus;
+  }
   /** Coalescing iterator over `partial_object` events — yields the latest
    *  object payload per `askId`. Designed for streaming-structured-output
    *  UIs: when the producer outpaces the consumer, intermediate snapshots
@@ -8959,6 +9852,7 @@ var AxlStream = class extends Readable {
     if (this.events.isFinished) return;
     this.result = result;
     const doneEvent = {
+      schemaVersion: 2,
       type: "done",
       executionId,
       step: Number.MAX_SAFE_INTEGER,
@@ -8977,6 +9871,7 @@ var AxlStream = class extends Readable {
   _error(error, executionId) {
     if (this.events.isFinished) return;
     const errorEvent = {
+      schemaVersion: 2,
       type: "error",
       executionId,
       step: Number.MAX_SAFE_INTEGER,
@@ -9555,7 +10450,7 @@ async function createSpanManager(config) {
   if (!config?.enabled) {
     return new NoopSpanManager();
   }
-  const { OTelSpanManager } = await import("./span-manager-3IKXXUTZ.js");
+  const { OTelSpanManager } = await import("./span-manager-74ZCGELO.js");
   return OTelSpanManager.create(config);
 }
 
@@ -9577,11 +10472,7 @@ var STREAMING_EXCLUDED_TYPES = /* @__PURE__ */ new Set([
   "partial_object",
   "string_delta"
 ]);
-var INTERNAL_METADATA_KEYS = /* @__PURE__ */ new Set([
-  "sessionId",
-  "sessionHistory",
-  "resumeMode"
-]);
+var INTERNAL_METADATA_KEYS = /* @__PURE__ */ new Set(["sessionId", "sessionHistory"]);
 function liftPersistedMetadata(metadata) {
   if (!metadata) return void 0;
   const filtered = {};
@@ -9699,7 +10590,7 @@ var StreamingFlusher = class {
     await Promise.allSettled(pendings);
   }
 };
-function isAbortError2(err) {
+function isAbortError4(err) {
   return typeof err === "object" && err !== null && err.name === "AbortError";
 }
 function pushEventBounded(execInfo, event, cap) {
@@ -9711,7 +10602,18 @@ function pushEventBounded(execInfo, event, cap) {
   const last = execInfo.events[execInfo.events.length - 1];
   const alreadyTruncated = last?.type === "log" && typeof last.data === "object" && last.data !== null && last.data.event === "events_truncated";
   if (!alreadyTruncated) {
+    if (execInfo.observation?.complete !== false) {
+      execInfo.observation = {
+        complete: false,
+        reason: "persistence_truncated",
+        maxEvents: cap
+      };
+    }
+    if (event.type === "workflow_end") {
+      event.data.observation = execInfo.observation;
+    }
     execInfo.events[execInfo.events.length - 1] = {
+      schemaVersion: 2,
       type: "log",
       executionId: event.executionId,
       step: event.step,
@@ -9740,7 +10642,9 @@ function boundRecoveredEvents(events, cap) {
   const last = truncated[truncated.length - 1];
   const alreadyTruncated = last?.type === "log" && typeof last.data === "object" && last.data !== null && last.data.event === "events_truncated";
   if (!alreadyTruncated) {
+    const version = getEventSchemaVersion(events[0] ?? {});
     truncated[truncated.length - 1] = {
+      ...version === 2 ? { schemaVersion: 2 } : {},
       type: "log",
       executionId: events[0]?.executionId ?? "",
       step: last?.step ?? 0,
@@ -9754,6 +10658,16 @@ function boundRecoveredEvents(events, cap) {
   }
   return truncated;
 }
+var REMOVED_OBSERVATION_CALLBACKS = ["onToken", "onToolCall", "onAgentStart"];
+function assertNoRemovedObservationCallbacks(options) {
+  if (options === null || typeof options !== "object") return;
+  const removed = REMOVED_OBSERVATION_CALLBACKS.filter((key) => Object.hasOwn(options, key));
+  if (removed.length === 0) return;
+  throw new AxlError(
+    "INVALID_CONFIG",
+    `runtime.createContext() no longer accepts ${removed.join(", ")}. Observe ctx.events or use runtime.stream() instead. See docs/migration/stream-first-observation.md.`
+  );
+}
 var costScopeStorage = new AsyncLocalStorage2();
 function forwardAbortSignal(external, internal) {
   if (!external) return () => {
@@ -9915,9 +10829,7 @@ var AxlRuntime = class extends EventEmitter2 {
    * → parse output → emit `workflow_end` → delete checkpoints → persist.
    *
    * Shared between `execute()` and `stream()`. Centralizes the
-   * "start iff end" pairing invariant so a future emit path
-   * (e.g., `resumeExecution`) can inherit correct behavior by routing
-   * through this helper. Also factors out the AbortError detection.
+   * "start iff end" pairing invariant and AbortError detection.
    *
    * Side effects on `execInfo`: sets `status` / `completedAt` /
    * `duration` / `result` (or `error`) before emitting `workflow_end`.
@@ -9941,18 +10853,23 @@ var AxlRuntime = class extends EventEmitter2 {
    */
   async runWorkflowBody(args) {
     const { workflow: workflow2, ctx, execInfo, validated, span, cleanupAbortForwarder } = args;
+    let observation = execInfo.observation ?? { complete: true };
     try {
       ctx._emitWorkflowStart(validated);
       const raw = await workflow2.handler(ctx);
+      const drainedObservation = await ctx._drainBranchWork();
+      observation = drainedObservation.complete === false ? drainedObservation : execInfo.observation ?? drainedObservation;
       const result = workflow2.outputSchema ? workflow2.outputSchema.parse(raw) : raw;
       execInfo.status = "completed";
       execInfo.completedAt = Date.now();
       execInfo.duration = execInfo.completedAt - execInfo.startedAt;
       execInfo.result = result;
+      execInfo.observation = observation;
       ctx._emitWorkflowEnd({
         status: "completed",
         duration: execInfo.duration,
-        result
+        result,
+        observation
       });
       if (this.stateStore.deleteCheckpoints) {
         await this.stateStore.deleteCheckpoints(execInfo.executionId);
@@ -9962,19 +10879,28 @@ var AxlRuntime = class extends EventEmitter2 {
       this.persistExecution(execInfo);
       return result;
     } catch (err) {
-      const aborted = isAbortError2(err);
+      let terminalError = err;
+      try {
+        const drainedObservation = await ctx._drainBranchWork();
+        observation = drainedObservation.complete === false ? drainedObservation : execInfo.observation ?? drainedObservation;
+      } catch (drainErr) {
+        terminalError = drainErr instanceof Error ? preserveErrorCause(drainErr, terminalError) : drainErr;
+      }
+      const aborted = isAbortError4(terminalError);
       execInfo.status = "failed";
       execInfo.completedAt = Date.now();
       execInfo.duration = execInfo.completedAt - execInfo.startedAt;
-      execInfo.error = err instanceof Error ? err.message : String(err);
+      execInfo.error = terminalError instanceof Error ? terminalError.message : String(terminalError);
+      execInfo.observation = observation;
       ctx._emitWorkflowEnd({
         status: "failed",
         duration: execInfo.duration,
         error: execInfo.error,
-        ...aborted ? { aborted: true } : {}
+        ...aborted ? { aborted: true } : {},
+        observation
       });
       this.persistExecution(execInfo);
-      throw err;
+      throw terminalError;
     } finally {
       this.abortControllers.delete(execInfo.executionId);
       cleanupAbortForwarder?.();
@@ -10162,13 +11088,13 @@ var AxlRuntime = class extends EventEmitter2 {
     return result;
   }
   /** Get all execution info (running + completed + historical). */
-  /** Normalize an `ExecutionInfo` loaded from a `StateStore` so the
-   *  `events: AxlEvent[]` type contract holds for downstream consumers
+  /** Normalize an execution loaded from a `StateStore` so the
+   *  historical event union holds for downstream consumers
    *  (Studio aggregators, REST routes, redaction). Custom or legacy stores
    *  may persist rows without `events` (or with a non-array value) — without
    *  this guard, a single malformed row crashes every iterator over
-   *  `exec.events` and takes down dependent features. Mutates the row
-   *  in place; logs at most one warning per `executionId`. */
+   *  `exec.events` and takes down dependent features. Returns a normalized
+   *  copy; logs at most one warning per `executionId`. */
   normalizeStoredExecution(exec) {
     if (!Array.isArray(exec.events)) {
       if (!this.warnedMalformedExecutions.has(exec.executionId)) {
@@ -10177,9 +11103,9 @@ var AxlRuntime = class extends EventEmitter2 {
           `[axl] StateStore returned execution ${exec.executionId} with non-array events (got ${exec.events === null ? "null" : typeof exec.events}); coercing to []`
         );
       }
-      exec.events = [];
+      return normalizeStoredExecution({ ...exec, events: [] });
     }
-    return exec;
+    return normalizeStoredExecution(exec);
   }
   async getExecutions() {
     if (!this.historicalExecutionsLoadPromise && this.stateStore.listExecutions) {
@@ -10189,8 +11115,9 @@ var AxlRuntime = class extends EventEmitter2 {
             this.historicalExecutions.set(exec.executionId, this.normalizeStoredExecution(exec));
           }
         }
-      }).catch(() => {
+      }).catch((error) => {
         this.historicalExecutionsLoadPromise = null;
+        throw error;
       });
     }
     if (this.historicalExecutionsLoadPromise) {
@@ -10208,6 +11135,7 @@ var AxlRuntime = class extends EventEmitter2 {
    * and automatically emits trace events and tracks cost.
    */
   createContext(options) {
+    assertNoRemovedObservationCallbacks(options);
     const executionId = randomUUID3();
     const budgetLimit = options?.budget ? parseCost(options.budget) : Infinity;
     this.registerWithCostScope(executionId);
@@ -10223,10 +11151,8 @@ var AxlRuntime = class extends EventEmitter2 {
       memoryManager: this.memoryManager,
       sessionHistory: options?.sessionHistory,
       signal: options?.signal,
-      onToken: options?.onToken,
-      onToolCall: options?.onToolCall,
-      onAgentStart: options?.onAgentStart,
       awaitHumanHandler: options?.awaitHumanHandler,
+      _onDecisionCleanupFailed: (event) => this.emit("decision_cleanup_failed", event),
       eventStreamOptions: options?.events,
       onTrace: (event) => {
         this.emit("trace", event);
@@ -10260,6 +11186,7 @@ var AxlRuntime = class extends EventEmitter2 {
       );
     }
     const validated = workflow2.inputSchema.parse(input);
+    const branchDrainTimeoutMs = resolveBranchDrainTimeoutMs(options?.branchDrainTimeoutMs);
     const executionId = randomUUID3();
     const controller = new AbortController();
     this.abortControllers.set(executionId, controller);
@@ -10272,11 +11199,13 @@ var AxlRuntime = class extends EventEmitter2 {
       executionId,
       workflow: name,
       status: "running",
+      eventSchemaVersion: 2,
       events: [],
       totalCost: 0,
       unpriced: false,
       startedAt: Date.now(),
       duration: 0,
+      observation: { complete: true },
       metadata: liftPersistedMetadata(options?.metadata)
     };
     this.executions.set(executionId, execInfo);
@@ -10290,6 +11219,8 @@ var AxlRuntime = class extends EventEmitter2 {
       sessionHistory,
       signal: controller.signal,
       eventStreamOptions: options?.events,
+      branchDrainTimeoutMs,
+      _onDecisionCleanupFailed: (event) => this.emit("decision_cleanup_failed", event),
       onTrace: (event) => {
         pushEventBounded(execInfo, event, this.maxEventsPerExecution);
         execInfo.totalCost += eventCostContribution(event);
@@ -10334,7 +11265,6 @@ var AxlRuntime = class extends EventEmitter2 {
       workflowName: name,
       mcpManager: this.mcpManager,
       memoryManager: this.memoryManager,
-      resumeMode: !!options?.metadata?.resumeMode,
       spanManager: this.spanManager,
       budgetContext: {
         totalCost: 0,
@@ -10365,6 +11295,7 @@ var AxlRuntime = class extends EventEmitter2 {
   }
   /** Execute a workflow and return a stream. */
   stream(name, input, options) {
+    const branchDrainTimeoutMs = resolveBranchDrainTimeoutMs(options?.branchDrainTimeoutMs);
     const axlStream = new AxlStream(options?.events);
     const controller = new AbortController();
     axlStream.on("close", () => controller.abort());
@@ -10385,11 +11316,13 @@ var AxlRuntime = class extends EventEmitter2 {
         executionId,
         workflow: name,
         status: "running",
+        eventSchemaVersion: 2,
         events: [],
         totalCost: 0,
         unpriced: false,
         startedAt: Date.now(),
         duration: 0,
+        observation: { complete: true },
         metadata: liftPersistedMetadata(options?.metadata)
       };
       this.executions.set(executionId, execInfo);
@@ -10402,12 +11335,11 @@ var AxlRuntime = class extends EventEmitter2 {
         sessionHistory,
         signal: controller.signal,
         eventStreamOptions: options?.events,
-        // Sentinel `onToken` so the streaming code path in WorkflowContext
-        // is entered (it's gated on `this.onToken` being defined). The
-        // actual `token` AxlEvents are emitted via `emitEvent` and reach
-        // the wire through `onTrace` — this callback is just the gate.
-        onToken: () => {
-        },
+        branchDrainTimeoutMs,
+        _onDecisionCleanupFailed: (event) => this.emit("decision_cleanup_failed", event),
+        // Transport mode is explicit internal state. It is inherited by child
+        // contexts and does not allocate an unconsumed ctx.events queue.
+        _forceStreaming: true,
         onTrace: (event) => {
           pushEventBounded(execInfo, event, this.maxEventsPerExecution);
           execInfo.totalCost += eventCostContribution(event);
@@ -10453,7 +11385,6 @@ var AxlRuntime = class extends EventEmitter2 {
         workflowName: name,
         mcpManager: this.mcpManager,
         memoryManager: this.memoryManager,
-        resumeMode: !!options?.metadata?.resumeMode,
         spanManager: this.spanManager,
         budgetContext: {
           totalCost: 0,
@@ -10617,6 +11548,12 @@ var AxlRuntime = class extends EventEmitter2 {
         await this.stateStore.finalizeStreamingEvents?.(id);
         continue;
       }
+      const eventSchemaVersion = getEventSchemaVersion(events[0]);
+      for (const event of events) {
+        if (getEventSchemaVersion(event) !== eventSchemaVersion) {
+          throw new Error(`Streaming buffer ${id} contains mixed event schema versions`);
+        }
+      }
       const boundedEvents = boundRecoveredEvents(events, this.maxEventsPerExecution);
       const workflowStartEvent = boundedEvents.find((e) => e.type === "workflow_start");
       const lastEvent = boundedEvents[boundedEvents.length - 1];
@@ -10625,7 +11562,7 @@ var AxlRuntime = class extends EventEmitter2 {
       const workflowName = workflowStartEvent?.workflow ?? RECOVERED_UNKNOWN_WORKFLOW;
       const totalCost = boundedEvents.reduce((sum, e) => sum + eventCostContribution(e), 0);
       const unpriced = boundedEvents.some(isUnpricedLeaf);
-      const synthesized = {
+      const executionBase = {
         executionId: id,
         workflow: workflowName,
         status: "failed",
@@ -10637,6 +11574,16 @@ var AxlRuntime = class extends EventEmitter2 {
         duration: completedAt - startedAt,
         error: "process terminated (recovered from streaming buffer)"
       };
+      const synthesized = eventSchemaVersion === 2 ? {
+        ...executionBase,
+        eventSchemaVersion: 2,
+        events: boundedEvents,
+        observation: { complete: false, reason: "process_interrupted" }
+      } : {
+        ...executionBase,
+        eventSchemaVersion: 1,
+        events: boundedEvents
+      };
       if (this.stateStore.saveExecution) {
         try {
           await this.stateStore.saveExecution(synthesized);
@@ -10717,7 +11664,8 @@ var AxlRuntime = class extends EventEmitter2 {
    */
   async deleteExecution(id) {
     const wasActive = this.executions.has(id);
-    const hadPendingDecision = this.pendingDecisionResolvers.has(id);
+    const pendingDecisionResolver = this.pendingDecisionResolvers.get(id);
+    const hadPendingDecision = pendingDecisionResolver !== void 0;
     if (wasActive) {
       this.pendingDeletedExecutions.add(id);
       this.streamableExecutionIds.delete(id);
@@ -10726,8 +11674,12 @@ var AxlRuntime = class extends EventEmitter2 {
         controller.abort();
       }
     }
-    if (hadPendingDecision) {
-      this.pendingDecisionResolvers.delete(id);
+    if (pendingDecisionResolver) pendingDecisionResolver.cancelled = true;
+    if (pendingDecisionResolver) {
+      await pendingDecisionResolver.cleanupFinished;
+      if (this.pendingDecisionResolvers.get(id) === pendingDecisionResolver) {
+        this.pendingDecisionResolvers.delete(id);
+      }
     }
     const existing = await this.getExecution(id);
     const workflow2 = existing?.workflow;
@@ -10805,60 +11757,68 @@ var AxlRuntime = class extends EventEmitter2 {
   }
   /** Resolve a pending human decision. */
   async resolveDecision(executionId, decision) {
-    const resolver = this.pendingDecisionResolvers.get(executionId);
+    decision = parseHumanDecision(decision);
+    let resolver = this.pendingDecisionResolvers.get(executionId);
     if (resolver) {
-      resolver(decision);
-      this.pendingDecisionResolvers.delete(executionId);
+      if (resolver.cancelled) {
+        throw new AxlError(
+          "PENDING_DECISION_NOT_FOUND",
+          `The pending human decision for execution "${executionId}" is no longer active.`
+        );
+      }
+      await resolver.ready;
+      if (resolver.cancelled || resolver.state !== "pending" || this.pendingDecisionResolvers.get(executionId) !== resolver) {
+        throw new AxlError(
+          "PENDING_DECISION_NOT_FOUND",
+          `The pending human decision for execution "${executionId}" is no longer active.`
+        );
+      }
     }
-    await this.stateStore.resolveDecision(executionId, decision);
     if (!resolver) {
-      const state = await this.stateStore.getExecutionState(executionId);
-      if (state && state.status === "waiting") {
-        await this.resumeExecution(executionId);
+      const pending = await this.stateStore.getPendingDecisions();
+      resolver = this.pendingDecisionResolvers.get(executionId);
+      if (resolver) {
+        if (resolver.cancelled) {
+          throw new AxlError(
+            "PENDING_DECISION_NOT_FOUND",
+            `The pending human decision for execution "${executionId}" is no longer active.`
+          );
+        }
+        await resolver.ready;
+        if (resolver.cancelled || resolver.state !== "pending" || this.pendingDecisionResolvers.get(executionId) !== resolver) {
+          throw new AxlError(
+            "PENDING_DECISION_NOT_FOUND",
+            `The pending human decision for execution "${executionId}" is no longer active.`
+          );
+        }
+      } else if (!pending.some((request) => request.executionId === executionId)) {
+        throw new AxlError(
+          "PENDING_DECISION_NOT_FOUND",
+          `No pending human decision exists for execution "${executionId}".`
+        );
+      } else {
+        throw new AxlError(
+          "CROSS_PROCESS_RESUME_UNSUPPORTED",
+          `Execution "${executionId}" is not awaiting a decision in this runtime. Cross-process approval replay requires a durable decision/lease lineage and is not yet supported; any persisted pending request was preserved.`
+        );
       }
     }
-  }
-  /**
-   * Resume a specific execution that was waiting for a human decision.
-   * Re-runs the workflow from scratch; the workflow should use checkpoint-replay
-   * to skip already-completed steps and pick up from the awaitHuman point.
-   */
-  async resumeExecution(executionId) {
-    const state = await this.stateStore.getExecutionState(executionId);
-    if (!state) {
-      throw new Error(`No execution state found for "${executionId}"`);
-    }
-    const workflow2 = this.workflows.get(state.workflow);
-    if (!workflow2) {
-      throw new Error(
-        `Workflow "${state.workflow}" not registered. Cannot resume execution "${executionId}".`
-      );
-    }
-    return this.execute(state.workflow, state.input, {
-      metadata: { ...state.metadata, resumedFrom: executionId, resumeMode: true }
+    let finishResolution;
+    const resolutionFinished = new Promise((resolve2) => {
+      finishResolution = resolve2;
     });
-  }
-  /**
-   * Resume all pending executions that were waiting for human decisions.
-   * Call this on startup to resume workflows that were interrupted by a restart.
-   * Returns the execution IDs that were resumed.
-   */
-  async resumePending() {
-    const pendingIds = await this.stateStore.listPendingExecutions();
-    const resumed = [];
-    for (const executionId of pendingIds) {
-      try {
-        await this.resumeExecution(executionId);
-        resumed.push(executionId);
-      } catch (err) {
-        this.emit("error", {
-          type: "resume_failed",
-          executionId,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
+    resolver.state = "resolving";
+    resolver.resolution = resolutionFinished;
+    try {
+      await this.stateStore.resolveDecision(executionId, decision);
+      resolver.state = "resolved";
+      finishResolution(true);
+      resolver.resolve(decision);
+    } catch (error) {
+      resolver.state = "pending";
+      finishResolution(false);
+      throw error;
     }
-    return resumed;
   }
   /**
    * Summarize a list of chat messages into a concise summary string.
@@ -11760,28 +12720,32 @@ var RedisStore = class _RedisStore {
   async saveExecution(execution) {
     const ttl = this.ttlFor("executionHistory");
     const setOptions = ttl !== void 0 ? { EX: ttl } : void 0;
-    await this.client.multi().sAdd(this.execHistorySetKey(), execution.executionId).set(this.execHistoryKey(execution.executionId), JSON.stringify(execution), setOptions).zAdd(this.execHistoryZsetKey(), {
+    const storedExecution = normalizeStoredExecution({
+      ...execution,
+      eventSchemaVersion: getExecutionEventSchemaVersion(execution)
+    });
+    await this.client.multi().sAdd(this.execHistorySetKey(), execution.executionId).set(this.execHistoryKey(execution.executionId), JSON.stringify(storedExecution), setOptions).zAdd(this.execHistoryZsetKey(), {
       score: execution.startedAt,
       value: execution.executionId
     }).exec();
   }
   async getExecution(executionId) {
     const raw = await this.client.get(this.execHistoryKey(executionId));
-    return raw ? JSON.parse(raw) : null;
+    return raw ? normalizeStoredExecution(JSON.parse(raw)) : null;
   }
   async listExecutions(limit) {
-    return this.listHistoryByZset(
+    const executions = await this.listHistoryByZset(
       this.execHistorySetKey(),
       this.execHistoryZsetKey(),
       (id) => this.execHistoryKey(id),
       (a, b) => b.startedAt - a.startedAt,
       limit
     );
+    return executions.map(normalizeStoredExecution);
   }
   async deleteExecution(executionId) {
-    const [, deletedCount] = await this.client.multi().sRem(this.execHistorySetKey(), executionId).del(this.execHistoryKey(executionId)).zRem(this.execHistoryZsetKey(), executionId).del(this.checkpointKey(executionId)).del(this.executionStateKey(executionId)).sRem(this.pendingExecSetKey(), executionId).del(this.streamingEventsKey(executionId)).sRem(this.streamingIdsKey(), executionId).hDel(this.decisionsKey(), executionId).exec();
-    const deleted = typeof deletedCount === "number" ? deletedCount : 0;
-    return deleted > 0;
+    const results = await this.client.multi().sRem(this.execHistorySetKey(), executionId).del(this.execHistoryKey(executionId)).zRem(this.execHistoryZsetKey(), executionId).del(this.checkpointKey(executionId)).del(this.executionStateKey(executionId)).sRem(this.pendingExecSetKey(), executionId).del(this.streamingEventsKey(executionId)).sRem(this.streamingIdsKey(), executionId).hDel(this.decisionsKey(), executionId).exec();
+    return results.some((result) => typeof result === "number" && result > 0);
   }
   // ── Eval History ────────────────────────────────────────────────────
   async saveEvalResult(entry) {
@@ -11873,14 +12837,15 @@ var RedisStore = class _RedisStore {
   async getStreamingEvents(executionId) {
     const raws = await this.client.lRange(this.streamingEventsKey(executionId), 0, -1);
     if (raws.length === 0) return [];
-    const events = [];
-    for (const raw of raws) {
+    return raws.map((raw, index) => {
       try {
-        events.push(JSON.parse(raw));
-      } catch {
+        return JSON.parse(raw);
+      } catch (error) {
+        throw new Error(`Streaming buffer ${executionId} contains invalid JSON at index ${index}`, {
+          cause: error
+        });
       }
-    }
-    return events;
+    });
   }
   /** Close the Redis connection. */
   async close() {
@@ -12091,6 +13056,8 @@ function cosineSimilarity2(a, b) {
 }
 export {
   AXL_EVENT_TYPES,
+  AXL_EVENT_TYPES_V2,
+  AXL_TOOL_LIFECYCLE_TYPES_V2,
   AZURE_PROFILE,
   AnthropicProvider,
   AxlError,
@@ -12138,8 +13105,9 @@ export {
   SqliteVectorStore,
   ThinkTagScanner,
   TimeoutError,
-  ToolDenied,
+  ToolFailure,
   ToolModelOutputError,
+  UnsupportedEventSchemaVersionError,
   VLLM_PROFILE,
   ValidationError,
   VerifyError,
@@ -12154,6 +13122,8 @@ export {
   extractJson,
   extractThinkTags,
   findConfig,
+  getEventSchemaVersion,
+  getExecutionEventSchemaVersion,
   hasPositiveTokens,
   importModule,
   isCostBearingLeaf,
@@ -12162,6 +13132,7 @@ export {
   isUnpricedLeaf,
   isUsableCost,
   needsTsxLoader,
+  normalizeStoredExecution,
   openaiReasoningEmit,
   parsePartialJson,
   pickDefault,
@@ -12170,6 +13141,7 @@ export {
   reasoningEffortEmit,
   reasoningObjectEmit,
   redactEvent,
+  redactHistoricalEvent,
   registerConditions,
   resolveApiKey,
   resolvePerModel,