@positronic/core 0.0.56 → 0.0.57

package/dist/src/dsl/brain-state-machine.js

@@ -64,33 +64,6 @@ function _object_spread_props(target, source) {
     }
     return target;
 }
-function _object_without_properties(source, excluded) {
-    if (source == null) return {};
-    var target = _object_without_properties_loose(source, excluded);
-    var key, i;
-    if (Object.getOwnPropertySymbols) {
-        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-        for(i = 0; i < sourceSymbolKeys.length; i++){
-            key = sourceSymbolKeys[i];
-            if (excluded.indexOf(key) >= 0) continue;
-            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-            target[key] = source[key];
-        }
-    }
-    return target;
-}
-function _object_without_properties_loose(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
-    for(i = 0; i < sourceKeys.length; i++){
-        key = sourceKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        target[key] = source[key];
-    }
-    return target;
-}
 function _to_consumable_array(arr) {
     return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
 }
@@ -110,104 +83,39 @@ var createMachine = robot3.createMachine, state = robot3.state, transition = rob
 import { BRAIN_EVENTS, STATUS } from './constants.js';
 import { applyPatches } from './json-patch.js';
 // ============================================================================
-// Tree Helper Functions
+// Tree Reconstruction Helper (for consumers who need tree representation)
 // ============================================================================
 /**
- * Get the deepest (currently executing) brain in the tree.
- */ function getDeepestBrain(root) {
-    if (!root) return null;
-    var current = root;
-    while(current.innerBrain){
-        current = current.innerBrain;
-    }
-    return current;
-}
-/**
- * Clone tree with a new innerBrain attached to the deepest node.
- */ function cloneTreeWithNewInner(root, newInner) {
-    if (!root.innerBrain) {
-        return _object_spread_props(_object_spread({}, root), {
-            innerBrain: newInner
-        });
-    }
-    return _object_spread_props(_object_spread({}, root), {
-        innerBrain: cloneTreeWithNewInner(root.innerBrain, newInner)
-    });
-}
-/**
- * Clone tree replacing the deepest brain.
- */ function cloneTreeReplacingDeepest(root, replacement) {
-    if (!root.innerBrain) {
-        return replacement;
-    }
-    return _object_spread_props(_object_spread({}, root), {
-        innerBrain: cloneTreeReplacingDeepest(root.innerBrain, replacement)
-    });
-}
-/**
- * Clone tree updating steps on the deepest brain.
- */ function cloneTreeUpdatingDeepestSteps(root, newSteps) {
-    if (!root.innerBrain) {
-        return _object_spread_props(_object_spread({}, root), {
-            steps: newSteps
-        });
-    }
-    return _object_spread_props(_object_spread({}, root), {
-        innerBrain: cloneTreeUpdatingDeepestSteps(root.innerBrain, newSteps)
-    });
-}
-/**
- * Clone tree removing the deepest brain and attaching its steps to parent step.
- * Returns null if root is the deepest (no parent).
- */ function cloneTreeRemovingDeepest(root) {
-    if (!root.innerBrain) {
-        // Root is the deepest - can't remove, return null
-        return null;
-    }
-    if (!root.innerBrain.innerBrain) {
-        // root.innerBrain is the deepest - remove it and attach steps to parent step
-        var completedBrain = root.innerBrain;
-        var updatedSteps = root.steps.map(function(step) {
-            if (step.id === completedBrain.parentStepId) {
-                return _object_spread_props(_object_spread({}, step), {
-                    innerSteps: completedBrain.steps,
-                    status: STATUS.COMPLETE
-                });
-            }
-            return step;
-        });
-        return _object_spread_props(_object_spread({}, root), {
-            steps: updatedSteps,
-            innerBrain: null
-        });
-    }
-    // Recurse down
-    return _object_spread_props(_object_spread({}, root), {
-        innerBrain: cloneTreeRemovingDeepest(root.innerBrain)
-    });
-}
-/**
- * Convert tree to flat array (for backwards compatibility).
- */ function treeToStack(root) {
-    var stack = [];
-    var current = root;
-    while(current){
-        stack.push({
-            brainRunId: current.brainRunId,
-            brainTitle: current.brainTitle,
-            brainDescription: current.brainDescription,
-            parentStepId: current.parentStepId,
-            steps: current.steps
-        });
-        current = current.innerBrain;
+ * Reconstruct the RunningBrain tree from flat brains map and stack.
+ * Use this when you need a tree representation for UI rendering or debugging.
+ * The flat structures (brains, brainIdStack) are the source of truth.
+ */ export function reconstructBrainTree(brains, brainIdStack) {
+    if (brainIdStack.length === 0) return null;
+    var innerBrain = null;
+    // Build from deepest to root (reverse iteration)
+    for(var i = brainIdStack.length - 1; i >= 0; i--){
+        var brainId = brainIdStack[i];
+        var entry = brains[brainId];
+        if (!entry) continue;
+        innerBrain = {
+            brainRunId: entry.brainRunId,
+            brainTitle: entry.brainTitle,
+            brainDescription: entry.brainDescription,
+            parentStepId: entry.parentStepId,
+            steps: entry.steps,
+            innerBrain: innerBrain,
+            depth: entry.depth
+        };
     }
-    return stack;
+    return innerBrain;
 }
 var createInitialContext = function(opts) {
     var _opts_initialState, _opts_options;
     return {
-        rootBrain: null,
-        brainStack: [],
+        // Flat storage (source of truth)
+        brains: {},
+        brainIdStack: [],
+        executionStack: [],
         depth: 0,
         brainRunId: null,
         currentStepId: null,
@@ -215,16 +123,19 @@ var createInitialContext = function(opts) {
         error: null,
         pendingWebhooks: null,
         currentState: (_opts_initialState = opts === null || opts === void 0 ? void 0 : opts.initialState) !== null && _opts_initialState !== void 0 ? _opts_initialState : {},
-        currentEvent: null,
         options: (_opts_options = opts === null || opts === void 0 ? void 0 : opts.options) !== null && _opts_options !== void 0 ? _opts_options : {},
+        agentContext: null,
         status: STATUS.PENDING,
         isTopLevel: false,
         isRunning: false,
         isComplete: false,
         isPaused: false,
+        isWaiting: false,
         isError: false,
         isCancelled: false,
-        topLevelStepCount: 0
+        isInAgentLoop: false,
+        topLevelStepCount: 0,
+        totalTokens: 0
     };
 };
 // ============================================================================
@@ -232,6 +143,7 @@ var createInitialContext = function(opts) {
 // ============================================================================
 var updateDerivedState = function(ctx, executionState) {
     // Map ExecutionState to STATUS - this gives consumers the authoritative status
+    // Note: agentLoop maps to RUNNING publicly (consumers don't need to know the difference)
     var status;
     switch(executionState){
         case 'idle':
@@ -240,9 +152,14 @@ var updateDerivedState = function(ctx, executionState) {
         case 'running':
             status = STATUS.RUNNING;
             break;
+        case 'agentLoop':
+            status = STATUS.RUNNING; // Publicly still "running"
+            break;
         case 'paused':
-            // Paused brains are still considered "running" in terms of database status
-            status = STATUS.RUNNING;
+            status = STATUS.PAUSED;
+            break;
+        case 'waiting':
+            status = STATUS.WAITING;
             break;
         case 'complete':
             status = STATUS.COMPLETE;
@@ -259,11 +176,13 @@ var updateDerivedState = function(ctx, executionState) {
     return _object_spread_props(_object_spread({}, ctx), {
         status: status,
         isTopLevel: ctx.depth === 1,
-        isRunning: executionState === 'running',
+        isRunning: executionState === 'running' || executionState === 'agentLoop',
         isComplete: executionState === 'complete',
         isPaused: executionState === 'paused',
+        isWaiting: executionState === 'waiting',
         isError: executionState === 'error',
-        isCancelled: executionState === 'cancelled'
+        isCancelled: executionState === 'cancelled',
+        isInAgentLoop: executionState === 'agentLoop'
     });
 };
 // ============================================================================
@@ -271,311 +190,211 @@ var updateDerivedState = function(ctx, executionState) {
 // ============================================================================
 var startBrain = reduce(function(ctx, param) {
     var brainRunId = param.brainRunId, brainTitle = param.brainTitle, brainDescription = param.brainDescription, initialState = param.initialState;
-    var currentStepId = ctx.currentStepId, rootBrain = ctx.rootBrain, depth = ctx.depth, existingBrainRunId = ctx.brainRunId, currentState = ctx.currentState, options = ctx.options;
+    var currentStepId = ctx.currentStepId, depth = ctx.depth, existingBrainRunId = ctx.brainRunId, currentState = ctx.currentState, brains = ctx.brains, brainIdStack = ctx.brainIdStack, executionStack = ctx.executionStack;
     var newDepth = depth + 1;
-    var newBrain = {
+    var brainInitialState = initialState !== null && initialState !== void 0 ? initialState : currentState;
+    // === NEW: Update flat structures ===
+    var parentBrainId = brainIdStack.length > 0 ? brainIdStack[brainIdStack.length - 1] : null;
+    var newBrainEntry = {
         brainRunId: brainRunId,
         brainTitle: brainTitle,
         brainDescription: brainDescription,
         parentStepId: currentStepId,
+        parentBrainId: parentBrainId,
         steps: [],
-        innerBrain: null,
         depth: newDepth
     };
-    // Build tree: if no root, this is root; else attach to deepest
-    var newRootBrain = rootBrain ? cloneTreeWithNewInner(rootBrain, newBrain) : newBrain;
+    var newBrains = _object_spread_props(_object_spread({}, brains), _define_property({}, brainTitle, newBrainEntry));
+    var newBrainIdStack = _to_consumable_array(brainIdStack).concat([
+        brainTitle
+    ]);
+    var newExecutionStack = _to_consumable_array(executionStack).concat([
+        {
+            state: brainInitialState,
+            stepIndex: 0
+        }
+    ]);
     var newCtx = _object_spread_props(_object_spread({}, ctx), {
-        rootBrain: newRootBrain,
-        brainStack: treeToStack(newRootBrain),
+        brains: newBrains,
+        brainIdStack: newBrainIdStack,
+        executionStack: newExecutionStack,
         depth: newDepth,
         brainRunId: existingBrainRunId !== null && existingBrainRunId !== void 0 ? existingBrainRunId : brainRunId,
-        currentState: newDepth === 1 ? initialState !== null && initialState !== void 0 ? initialState : currentState : currentState,
-        currentEvent: {
-            type: BRAIN_EVENTS.START,
-            brainTitle: brainTitle,
-            brainDescription: brainDescription,
-            brainRunId: brainRunId,
-            initialState: initialState !== null && initialState !== void 0 ? initialState : {},
-            status: STATUS.RUNNING,
-            options: options
-        }
+        currentState: newDepth === 1 ? brainInitialState : currentState
     });
     return updateDerivedState(newCtx, 'running');
 });
-var restartBrain = reduce(function(ctx, param) {
-    var brainRunId = param.brainRunId, brainTitle = param.brainTitle, brainDescription = param.brainDescription, initialState = param.initialState;
-    var currentStepId = ctx.currentStepId, rootBrain = ctx.rootBrain, depth = ctx.depth, existingBrainRunId = ctx.brainRunId, options = ctx.options;
-    // brain:restart can be either:
-    // 1. A resume of an existing brain on the stack (same brainTitle) - should REPLACE
-    // 2. A nested inner brain restarting (different brainTitle) - should ADD
-    if (rootBrain) {
-        var deepestBrain = getDeepestBrain(rootBrain);
-        // If the deepest brain has the same title, this is a resume - replace it
-        if (deepestBrain && deepestBrain.brainTitle === brainTitle) {
-            var replacementBrain = {
-                brainRunId: brainRunId,
-                brainTitle: brainTitle,
-                brainDescription: brainDescription,
-                parentStepId: deepestBrain.parentStepId,
-                steps: [],
-                innerBrain: null,
-                depth: deepestBrain.depth
-            };
-            var newRootBrain = cloneTreeReplacingDeepest(rootBrain, replacementBrain);
-            var newCtx = _object_spread_props(_object_spread({}, ctx), {
-                rootBrain: newRootBrain,
-                brainStack: treeToStack(newRootBrain),
-                // depth stays the same - we're replacing, not nesting
-                brainRunId: existingBrainRunId !== null && existingBrainRunId !== void 0 ? existingBrainRunId : brainRunId,
-                currentEvent: {
-                    type: BRAIN_EVENTS.RESTART,
-                    brainTitle: brainTitle,
-                    brainDescription: brainDescription,
-                    brainRunId: brainRunId,
-                    initialState: initialState !== null && initialState !== void 0 ? initialState : {},
-                    status: STATUS.RUNNING,
-                    options: options
-                }
-            });
-            return updateDerivedState(newCtx, 'running');
-        }
-        // Different title - this is a nested inner brain restarting, ADD to tree
-        var newDepth = depth + 1;
-        var newBrain = {
-            brainRunId: brainRunId,
-            brainTitle: brainTitle,
-            brainDescription: brainDescription,
-            parentStepId: currentStepId,
-            steps: [],
-            innerBrain: null,
-            depth: newDepth
-        };
-        var newRootBrain1 = cloneTreeWithNewInner(rootBrain, newBrain);
-        var newCtx1 = _object_spread_props(_object_spread({}, ctx), {
-            rootBrain: newRootBrain1,
-            brainStack: treeToStack(newRootBrain1),
-            depth: newDepth,
-            brainRunId: existingBrainRunId !== null && existingBrainRunId !== void 0 ? existingBrainRunId : brainRunId,
-            currentEvent: {
-                type: BRAIN_EVENTS.RESTART,
-                brainTitle: brainTitle,
-                brainDescription: brainDescription,
-                brainRunId: brainRunId,
-                initialState: initialState !== null && initialState !== void 0 ? initialState : {},
-                status: STATUS.RUNNING,
-                options: options
-            }
-        });
-        return updateDerivedState(newCtx1, 'running');
-    }
-    // No brain on stack - this is a fresh restart from idle state
-    var newBrain1 = {
-        brainRunId: brainRunId,
-        brainTitle: brainTitle,
-        brainDescription: brainDescription,
-        parentStepId: null,
-        steps: [],
-        innerBrain: null,
-        depth: 1
-    };
-    var newCtx2 = _object_spread_props(_object_spread({}, ctx), {
-        rootBrain: newBrain1,
-        brainStack: treeToStack(newBrain1),
-        depth: 1,
-        brainRunId: existingBrainRunId !== null && existingBrainRunId !== void 0 ? existingBrainRunId : brainRunId,
-        currentEvent: {
-            type: BRAIN_EVENTS.RESTART,
-            brainTitle: brainTitle,
-            brainDescription: brainDescription,
-            brainRunId: brainRunId,
-            initialState: initialState !== null && initialState !== void 0 ? initialState : {},
-            status: STATUS.RUNNING,
-            options: options
-        }
-    });
-    return updateDerivedState(newCtx2, 'running');
-});
 var completeBrain = reduce(function(ctx) {
-    var rootBrain = ctx.rootBrain, depth = ctx.depth, brainRunId = ctx.brainRunId, options = ctx.options;
-    if (!rootBrain) return ctx;
-    var completedBrain = getDeepestBrain(rootBrain);
-    if (!completedBrain) return ctx;
+    var depth = ctx.depth, brains = ctx.brains, brainIdStack = ctx.brainIdStack, executionStack = ctx.executionStack;
+    if (brainIdStack.length === 0) return ctx;
     var newDepth = depth - 1;
     var isOuterBrainComplete = newDepth === 0;
-    // When the outer brain completes, keep rootBrain so we can still display
-    // the final state. Only remove inner brains (attaching their steps to parent).
-    var newRootBrain = isOuterBrainComplete ? rootBrain : cloneTreeRemovingDeepest(rootBrain);
-    var newCtx = _object_spread_props(_object_spread({}, ctx), {
-        rootBrain: newRootBrain,
-        brainStack: treeToStack(newRootBrain),
-        depth: newDepth,
-        currentEvent: {
-            type: BRAIN_EVENTS.COMPLETE,
-            brainTitle: completedBrain.brainTitle,
-            brainDescription: completedBrain.brainDescription,
-            brainRunId: brainRunId,
-            status: STATUS.COMPLETE,
-            options: options
+    // === NEW: Update flat structures ===
+    var newBrains = brains;
+    var newBrainIdStack = brainIdStack;
+    var newExecutionStack = executionStack;
+    if (!isOuterBrainComplete) {
+        // Pop the completed brain from stack
+        var completedBrainId = brainIdStack[brainIdStack.length - 1];
+        var completedBrain = brains[completedBrainId];
+        newBrainIdStack = brainIdStack.slice(0, -1);
+        newExecutionStack = executionStack.slice(0, -1);
+        // Attach completed brain's steps to parent step
+        if (completedBrain && newBrainIdStack.length > 0) {
+            var parentBrainId = newBrainIdStack[newBrainIdStack.length - 1];
+            var parentBrain = brains[parentBrainId];
+            if (parentBrain && completedBrain.parentStepId) {
+                var updatedSteps = parentBrain.steps.map(function(step) {
+                    if (step.id === completedBrain.parentStepId) {
+                        return _object_spread_props(_object_spread({}, step), {
+                            innerSteps: completedBrain.steps,
+                            status: STATUS.COMPLETE
+                        });
+                    }
+                    return step;
+                });
+                newBrains = _object_spread_props(_object_spread({}, brains), _define_property({}, parentBrainId, _object_spread_props(_object_spread({}, parentBrain), {
+                    steps: updatedSteps
+                })));
+            }
         }
+    }
+    // If outer brain complete, keep everything as-is for final state display
+    var newCtx = _object_spread_props(_object_spread({}, ctx), {
+        brains: newBrains,
+        brainIdStack: newBrainIdStack,
+        executionStack: newExecutionStack,
+        depth: newDepth
     });
     return updateDerivedState(newCtx, isOuterBrainComplete ? 'complete' : 'running');
 });
 var errorBrain = reduce(function(ctx, param) {
     var error = param.error;
-    var rootBrain = ctx.rootBrain, brainRunId = ctx.brainRunId, options = ctx.options;
-    var currentBrain = getDeepestBrain(rootBrain);
     var newCtx = _object_spread_props(_object_spread({}, ctx), {
-        error: error,
-        currentEvent: {
-            type: BRAIN_EVENTS.ERROR,
-            brainTitle: currentBrain === null || currentBrain === void 0 ? void 0 : currentBrain.brainTitle,
-            brainDescription: currentBrain === null || currentBrain === void 0 ? void 0 : currentBrain.brainDescription,
-            brainRunId: brainRunId,
-            error: error,
-            status: STATUS.ERROR,
-            options: options
-        }
+        error: error
     });
     return updateDerivedState(newCtx, 'error');
 });
 var cancelBrain = reduce(function(ctx) {
-    var rootBrain = ctx.rootBrain, brainRunId = ctx.brainRunId, options = ctx.options;
-    var currentBrain = getDeepestBrain(rootBrain);
-    var newCtx = _object_spread_props(_object_spread({}, ctx), {
-        currentEvent: {
-            type: BRAIN_EVENTS.CANCELLED,
-            brainTitle: currentBrain === null || currentBrain === void 0 ? void 0 : currentBrain.brainTitle,
-            brainDescription: currentBrain === null || currentBrain === void 0 ? void 0 : currentBrain.brainDescription,
-            brainRunId: brainRunId,
-            status: STATUS.CANCELLED,
-            options: options
-        }
-    });
-    return updateDerivedState(newCtx, 'cancelled');
+    return updateDerivedState(ctx, 'cancelled');
 });
 var startStep = reduce(function(ctx, param) {
-    var stepId = param.stepId, stepTitle = param.stepTitle;
-    var rootBrain = ctx.rootBrain, brainRunId = ctx.brainRunId, options = ctx.options;
-    // Add step to current brain's steps if not already there
-    var newRootBrain = rootBrain;
-    if (rootBrain) {
-        var currentBrain = getDeepestBrain(rootBrain);
-        if (currentBrain) {
-            var existingStep = currentBrain.steps.find(function(s) {
-                return s.id === stepId;
-            });
-            var newSteps;
-            if (!existingStep) {
-                newSteps = _to_consumable_array(currentBrain.steps).concat([
-                    {
-                        id: stepId,
-                        title: stepTitle,
-                        status: STATUS.RUNNING
-                    }
-                ]);
-            } else {
-                newSteps = currentBrain.steps.map(function(s) {
-                    return s.id === stepId ? _object_spread_props(_object_spread({}, s), {
-                        status: STATUS.RUNNING
-                    }) : s;
-                });
-            }
-            newRootBrain = cloneTreeUpdatingDeepestSteps(rootBrain, newSteps);
+    var stepId = param.stepId, stepTitle = param.stepTitle, stepIndex = param.stepIndex;
+    var brains = ctx.brains, brainIdStack = ctx.brainIdStack, executionStack = ctx.executionStack;
+    if (brainIdStack.length === 0) return ctx;
+    // === NEW: Update flat structures ===
+    var currentBrainId = brainIdStack[brainIdStack.length - 1];
+    var currentBrain = brains[currentBrainId];
+    if (!currentBrain) return ctx;
+    // Update current brain's steps
+    var existingStep = currentBrain.steps.find(function(s) {
+        return s.id === stepId;
+    });
+    var newSteps = existingStep ? currentBrain.steps.map(function(s) {
+        return s.id === stepId ? _object_spread_props(_object_spread({}, s), {
+            status: STATUS.RUNNING
+        }) : s;
+    }) : _to_consumable_array(currentBrain.steps).concat([
+        {
+            id: stepId,
+            title: stepTitle,
+            status: STATUS.RUNNING
         }
-    }
+    ]);
+    var newBrains = _object_spread_props(_object_spread({}, brains), _define_property({}, currentBrainId, _object_spread_props(_object_spread({}, currentBrain), {
+        steps: newSteps
+    })));
+    // Update stepIndex in execution stack if provided
+    var newExecutionStack = stepIndex !== undefined && executionStack.length > 0 ? _to_consumable_array(executionStack.slice(0, -1)).concat([
+        _object_spread_props(_object_spread({}, executionStack[executionStack.length - 1]), {
+            stepIndex: stepIndex
+        })
+    ]) : executionStack;
     return _object_spread_props(_object_spread({}, ctx), {
-        rootBrain: newRootBrain,
-        brainStack: treeToStack(newRootBrain),
+        brains: newBrains,
+        executionStack: newExecutionStack,
         currentStepId: stepId,
-        currentStepTitle: stepTitle,
-        currentEvent: {
-            type: BRAIN_EVENTS.STEP_START,
-            brainRunId: brainRunId,
-            stepId: stepId,
-            stepTitle: stepTitle,
-            status: STATUS.RUNNING,
-            options: options
-        }
+        currentStepTitle: stepTitle
     });
 });
 var completeStep = reduce(function(ctx, param) {
-    var stepId = param.stepId, stepTitle = param.stepTitle, patch = param.patch;
-    var rootBrain = ctx.rootBrain, depth = ctx.depth, currentState = ctx.currentState, topLevelStepCount = ctx.topLevelStepCount, brainRunId = ctx.brainRunId, options = ctx.options;
-    var newRootBrain = rootBrain;
-    if (rootBrain) {
-        var currentBrain = getDeepestBrain(rootBrain);
-        if (currentBrain) {
-            var newSteps = currentBrain.steps.map(function(s) {
-                return s.id === stepId ? _object_spread_props(_object_spread({}, s), {
-                    status: STATUS.COMPLETE,
-                    patch: patch
-                }) : s;
-            });
-            newRootBrain = cloneTreeUpdatingDeepestSteps(rootBrain, newSteps);
-        }
+    var stepId = param.stepId, patch = param.patch;
+    var brains = ctx.brains, brainIdStack = ctx.brainIdStack, executionStack = ctx.executionStack, depth = ctx.depth, currentState = ctx.currentState, topLevelStepCount = ctx.topLevelStepCount;
+    if (brainIdStack.length === 0) return ctx;
+    // === NEW: Update flat structures ===
+    var currentBrainId = brainIdStack[brainIdStack.length - 1];
+    var currentBrain = brains[currentBrainId];
+    if (!currentBrain) return ctx;
+    // Update step status
+    var newSteps = currentBrain.steps.map(function(s) {
+        return s.id === stepId ? _object_spread_props(_object_spread({}, s), {
+            status: STATUS.COMPLETE,
+            patch: patch
+        }) : s;
+    });
+    var newBrains = _object_spread_props(_object_spread({}, brains), _define_property({}, currentBrainId, _object_spread_props(_object_spread({}, currentBrain), {
+        steps: newSteps
+    })));
+    // Apply patch to execution stack and increment stepIndex
+    var newExecutionStack = executionStack;
+    if (executionStack.length > 0) {
+        var topEntry = executionStack[executionStack.length - 1];
+        var newState = patch ? applyPatches(topEntry.state, [
+            patch
+        ]) : topEntry.state;
+        // Increment stepIndex so resume knows to start from the NEXT step
+        newExecutionStack = _to_consumable_array(executionStack.slice(0, -1)).concat([
+            _object_spread_props(_object_spread({}, topEntry), {
+                state: newState,
+                stepIndex: topEntry.stepIndex + 1
+            })
+        ]);
     }
-    // Apply patch to currentState only for top-level brain
-    var newState = currentState;
+    // Apply patch to currentState only for top-level brain (for backwards compat)
+    var newState1 = currentState;
     var newStepCount = topLevelStepCount;
     if (depth === 1 && patch) {
-        newState = applyPatches(currentState, [
+        newState1 = applyPatches(currentState, [
             patch
         ]);
         newStepCount = topLevelStepCount + 1;
     }
     return _object_spread_props(_object_spread({}, ctx), {
-        rootBrain: newRootBrain,
-        brainStack: treeToStack(newRootBrain),
-        currentState: newState,
-        topLevelStepCount: newStepCount,
-        currentEvent: {
-            type: BRAIN_EVENTS.STEP_COMPLETE,
-            brainRunId: brainRunId,
-            stepId: stepId,
-            stepTitle: stepTitle,
-            patch: patch,
-            status: STATUS.RUNNING,
-            options: options
-        }
+        brains: newBrains,
+        executionStack: newExecutionStack,
+        currentState: newState1,
+        topLevelStepCount: newStepCount
     });
 });
 var webhookPause = reduce(function(ctx, param) {
     var waitFor = param.waitFor;
-    var brainRunId = ctx.brainRunId, options = ctx.options;
     var newCtx = _object_spread_props(_object_spread({}, ctx), {
-        pendingWebhooks: waitFor,
-        currentEvent: {
-            type: BRAIN_EVENTS.WEBHOOK,
-            brainRunId: brainRunId,
-            waitFor: waitFor,
-            options: options
-        }
+        pendingWebhooks: waitFor
     });
-    return updateDerivedState(newCtx, 'paused');
+    return updateDerivedState(newCtx, 'waiting');
 });
-var webhookResponse = reduce(function(ctx, param) {
-    var response = param.response;
-    var brainRunId = ctx.brainRunId, options = ctx.options;
+var pauseBrain = reduce(function(ctx) {
+    return updateDerivedState(ctx, 'paused');
+});
+var resumeBrain = reduce(function(ctx) {
+    return updateDerivedState(ctx, 'running');
+});
+var resumeToAgentLoop = reduce(function(ctx) {
+    return updateDerivedState(ctx, 'agentLoop');
+});
+var webhookResponse = reduce(function(ctx) {
     var newCtx = _object_spread_props(_object_spread({}, ctx), {
-        pendingWebhooks: null,
-        currentEvent: {
-            type: BRAIN_EVENTS.WEBHOOK_RESPONSE,
-            brainRunId: brainRunId,
-            response: response,
-            options: options
-        }
+        pendingWebhooks: null
     });
     return updateDerivedState(newCtx, 'running');
 });
 var stepStatus = reduce(function(ctx, param) {
-    var eventBrainRunId = param.brainRunId, steps = param.steps;
-    var brainRunId = ctx.brainRunId, rootBrain = ctx.rootBrain, options = ctx.options;
-    if (!rootBrain) return ctx;
-    // Only update the current (deepest) brain in the tree.
-    // STEP_STATUS is emitted by the currently executing brain, which is always
-    // the deepest one. We can't match by brainRunId because nested brains share
-    // the same brainRunId, which would incorrectly update all nested brains.
-    var currentBrain = getDeepestBrain(rootBrain);
+    var steps = param.steps;
+    var brains = ctx.brains, brainIdStack = ctx.brainIdStack;
+    if (brainIdStack.length === 0) return ctx;
+    // === NEW: Update flat structures ===
+    var currentBrainId = brainIdStack[brainIdStack.length - 1];
+    var currentBrain = brains[currentBrainId];
     if (!currentBrain) return ctx;
     // Create a map of existing steps to preserve their patches
     var existingStepsById = new Map(currentBrain.steps.map(function(s) {
@@ -594,49 +413,87 @@ var stepStatus = reduce(function(ctx, param) {
             patch: existing.patch
         } : {});
     });
-    var newRootBrain = cloneTreeUpdatingDeepestSteps(rootBrain, newSteps);
+    var newBrains = _object_spread_props(_object_spread({}, brains), _define_property({}, currentBrainId, _object_spread_props(_object_spread({}, currentBrain), {
+        steps: newSteps
+    })));
     return _object_spread_props(_object_spread({}, ctx), {
-        rootBrain: newRootBrain,
-        brainStack: treeToStack(newRootBrain),
-        currentEvent: {
-            type: BRAIN_EVENTS.STEP_STATUS,
-            brainRunId: brainRunId,
-            steps: steps,
-            options: options
-        }
+        brains: newBrains
     });
 });
-var stepRetry = reduce(function(ctx, param) {
-    var stepId = param.stepId, stepTitle = param.stepTitle, error = param.error, attempt = param.attempt;
-    var brainRunId = ctx.brainRunId, options = ctx.options;
+// stepRetry is a no-op - we just let the event pass through
+var stepRetry = reduce(function(ctx) {
+    return ctx;
+});
+// passthrough is now a no-op - we just let the event pass through
+var passthrough = function() {
+    return reduce(function(ctx) {
+        return ctx;
+    });
+};
+// Reducer for agent iteration events that tracks tokens per-iteration
+// This ensures tokens are counted even if the agent doesn't complete (e.g., webhook interruption)
+var agentIteration = reduce(function(ctx, ev) {
+    var totalTokens = ctx.totalTokens;
+    var _ev_tokensThisIteration;
     return _object_spread_props(_object_spread({}, ctx), {
-        currentEvent: {
-            type: BRAIN_EVENTS.STEP_RETRY,
-            brainRunId: brainRunId,
-            stepId: stepId,
-            stepTitle: stepTitle,
-            error: error,
-            attempt: attempt,
-            options: options
-        }
+        totalTokens: totalTokens + ((_ev_tokensThisIteration = ev.tokensThisIteration) !== null && _ev_tokensThisIteration !== void 0 ? _ev_tokensThisIteration : 0)
     });
 });
-var passthrough = function(eventType) {
-    return reduce(function(ctx, ev) {
-        var brainRunId = ctx.brainRunId, options = ctx.options;
-        // Destructure to exclude 'type' (the action name) from being spread into currentEvent
-        var _actionType = ev.type, eventData = _object_without_properties(ev, [
-            "type"
-        ]);
+// Reducer for agent terminal events - clears agentContext since the agent has completed
+var agentTerminal = function() {
+    return reduce(function(ctx) {
         return _object_spread_props(_object_spread({}, ctx), {
-            currentEvent: _object_spread({
-                type: eventType,
-                brainRunId: brainRunId,
-                options: options
-            }, eventData)
+            agentContext: null
         });
     });
 };
+// Reducer for AGENT_START - initializes agentContext
+var agentStart = reduce(function(ctx, param) {
+    var stepId = param.stepId, stepTitle = param.stepTitle, prompt = param.prompt, system = param.system;
+    var newCtx = _object_spread_props(_object_spread({}, ctx), {
+        agentContext: {
+            stepId: stepId,
+            stepTitle: stepTitle,
+            prompt: prompt,
+            system: system,
+            responseMessages: [],
+            pendingToolCallId: null,
+            pendingToolName: null
+        }
+    });
+    return updateDerivedState(newCtx, 'agentLoop');
+});
+// Reducer for AGENT_RAW_RESPONSE_MESSAGE - accumulates messages in agentContext
+var agentRawResponseMessage = reduce(function(ctx, param) {
+    var message = param.message;
+    var agentContext = ctx.agentContext;
+    // Accumulate the message in agentContext
+    var updatedAgentContext = agentContext ? _object_spread_props(_object_spread({}, agentContext), {
+        responseMessages: _to_consumable_array(agentContext.responseMessages).concat([
+            message
+        ])
+    }) : null;
+    return _object_spread_props(_object_spread({}, ctx), {
+        agentContext: updatedAgentContext
+    });
+});
+// Reducer for AGENT_WEBHOOK - records pending tool call in agentContext
+var agentWebhook = reduce(function(ctx, param) {
+    var toolCallId = param.toolCallId, toolName = param.toolName;
+    var agentContext = ctx.agentContext;
+    // Update agentContext with pending tool info
+    var updatedAgentContext = agentContext ? _object_spread_props(_object_spread({}, agentContext), {
+        pendingToolCallId: toolCallId,
+        pendingToolName: toolName
+    }) : null;
+    return _object_spread_props(_object_spread({}, ctx), {
+        agentContext: updatedAgentContext
+    });
+});
+// Reducer for AGENT_USER_MESSAGE - no-op, just stays in agentLoop
+var agentUserMessage = reduce(function(ctx) {
+    return ctx;
+});
 // ============================================================================
 // Guards - Conditional transitions
 // ============================================================================
@@ -646,25 +503,67 @@ var isOuterBrain = guard(function(ctx) {
 var isInnerBrain = guard(function(ctx) {
     return ctx.depth > 1;
 });
+// Guard to check if we have agentContext (for resuming to agentLoop)
+var hasAgentContext = guard(function(ctx) {
+    return ctx.agentContext !== null;
+});
 // ============================================================================
 // State Machine Definition
 // ============================================================================
+// Define agent loop transitions as a reusable array for cleaner code
+var agentLoopTransitions = [
+    // Agent micro-events that stay in agentLoop
+    transition(BRAIN_EVENTS.AGENT_ITERATION, 'agentLoop', agentIteration),
+    transition(BRAIN_EVENTS.AGENT_RAW_RESPONSE_MESSAGE, 'agentLoop', agentRawResponseMessage),
+    transition(BRAIN_EVENTS.AGENT_TOOL_CALL, 'agentLoop', passthrough()),
+    transition(BRAIN_EVENTS.AGENT_TOOL_RESULT, 'agentLoop', passthrough()),
+    transition(BRAIN_EVENTS.AGENT_ASSISTANT_MESSAGE, 'agentLoop', passthrough()),
+    transition(BRAIN_EVENTS.AGENT_USER_MESSAGE, 'agentLoop', agentUserMessage),
+    // AGENT_WEBHOOK records pending tool call but stays in agentLoop
+    transition(BRAIN_EVENTS.AGENT_WEBHOOK, 'agentLoop', agentWebhook)
+];
 // Internal machine factory - called with pre-built context
 var makeBrainMachine = function(initialContext) {
     return createMachine('idle', {
-        idle: state(transition(BRAIN_EVENTS.START, 'running', startBrain), transition(BRAIN_EVENTS.RESTART, 'running', restartBrain)),
-        running: state(// Nested brain lifecycle
-        transition(BRAIN_EVENTS.START, 'running', startBrain), transition(BRAIN_EVENTS.RESTART, 'running', restartBrain), // Outer brain complete -> terminal
+        idle: state(transition(BRAIN_EVENTS.START, 'running', startBrain)),
+        // Standard step execution state
+        running: state(// Nested brain lifecycle - always uses START
+        transition(BRAIN_EVENTS.START, 'running', startBrain), // Outer brain complete -> terminal
         transition(BRAIN_EVENTS.COMPLETE, 'complete', isOuterBrain, completeBrain), // Inner brain complete -> stay running
         transition(BRAIN_EVENTS.COMPLETE, 'running', isInnerBrain, completeBrain), // Error (only outer brain errors are terminal)
         transition(BRAIN_EVENTS.ERROR, 'error', isOuterBrain, errorBrain), // Cancelled
-        transition(BRAIN_EVENTS.CANCELLED, 'cancelled', cancelBrain), // Webhook -> paused
-        transition(BRAIN_EVENTS.WEBHOOK, 'paused', webhookPause), // Webhook response (for resume from webhook - machine is already running)
+        transition(BRAIN_EVENTS.CANCELLED, 'cancelled', cancelBrain), // Paused (by signal)
+        transition(BRAIN_EVENTS.PAUSED, 'paused', pauseBrain), // Webhook -> waiting (for non-agent webhooks)
+        transition(BRAIN_EVENTS.WEBHOOK, 'waiting', webhookPause), // Webhook response (for resume from non-agent webhook)
         transition(BRAIN_EVENTS.WEBHOOK_RESPONSE, 'running', webhookResponse), // Step events
-        transition(BRAIN_EVENTS.STEP_START, 'running', startStep), transition(BRAIN_EVENTS.STEP_COMPLETE, 'running', completeStep), transition(BRAIN_EVENTS.STEP_STATUS, 'running', stepStatus), transition(BRAIN_EVENTS.STEP_RETRY, 'running', stepRetry), // Agent events (pass-through with event data)
-        transition(BRAIN_EVENTS.AGENT_START, 'running', passthrough(BRAIN_EVENTS.AGENT_START)), transition(BRAIN_EVENTS.AGENT_ITERATION, 'running', passthrough(BRAIN_EVENTS.AGENT_ITERATION)), transition(BRAIN_EVENTS.AGENT_TOOL_CALL, 'running', passthrough(BRAIN_EVENTS.AGENT_TOOL_CALL)), transition(BRAIN_EVENTS.AGENT_TOOL_RESULT, 'running', passthrough(BRAIN_EVENTS.AGENT_TOOL_RESULT)), transition(BRAIN_EVENTS.AGENT_ASSISTANT_MESSAGE, 'running', passthrough(BRAIN_EVENTS.AGENT_ASSISTANT_MESSAGE)), transition(BRAIN_EVENTS.AGENT_COMPLETE, 'running', passthrough(BRAIN_EVENTS.AGENT_COMPLETE)), transition(BRAIN_EVENTS.AGENT_TOKEN_LIMIT, 'running', passthrough(BRAIN_EVENTS.AGENT_TOKEN_LIMIT)), transition(BRAIN_EVENTS.AGENT_WEBHOOK, 'running', passthrough(BRAIN_EVENTS.AGENT_WEBHOOK))),
-        paused: state(transition(BRAIN_EVENTS.WEBHOOK_RESPONSE, 'running', webhookResponse), transition(BRAIN_EVENTS.CANCELLED, 'cancelled', cancelBrain), // RESTART happens when resuming from webhook
-        transition(BRAIN_EVENTS.RESTART, 'running', restartBrain)),
+        transition(BRAIN_EVENTS.STEP_START, 'running', startStep), transition(BRAIN_EVENTS.STEP_COMPLETE, 'running', completeStep), transition(BRAIN_EVENTS.STEP_STATUS, 'running', stepStatus), transition(BRAIN_EVENTS.STEP_RETRY, 'running', stepRetry), // AGENT_START transitions to the agentLoop state
+        transition(BRAIN_EVENTS.AGENT_START, 'agentLoop', agentStart)),
+        // Explicit agent loop state - isolates agent execution logic
+        agentLoop: state.apply(void 0, // Spread agent micro-transitions
+        _to_consumable_array(agentLoopTransitions).concat([
+            // Exit strategies - agent terminal events return to running
+            transition(BRAIN_EVENTS.AGENT_COMPLETE, 'running', agentTerminal()),
+            transition(BRAIN_EVENTS.AGENT_TOKEN_LIMIT, 'running', agentTerminal()),
+            transition(BRAIN_EVENTS.AGENT_ITERATION_LIMIT, 'running', agentTerminal()),
+            // Interruption handling - can pause or wait from agentLoop
+            transition(BRAIN_EVENTS.PAUSED, 'paused', pauseBrain),
+            transition(BRAIN_EVENTS.WEBHOOK, 'waiting', webhookPause),
+            // Error handling
+            transition(BRAIN_EVENTS.ERROR, 'error', isOuterBrain, errorBrain),
+            transition(BRAIN_EVENTS.CANCELLED, 'cancelled', cancelBrain)
+        ])),
+        paused: state(transition(BRAIN_EVENTS.CANCELLED, 'cancelled', cancelBrain), // RESUMED transitions out of paused state without creating a new brain
+        // If we have agentContext, resume to agentLoop; otherwise to running
+        transition(BRAIN_EVENTS.RESUMED, 'agentLoop', hasAgentContext, resumeToAgentLoop), transition(BRAIN_EVENTS.RESUMED, 'running', resumeBrain), // START is kept for backwards compatibility but RESUMED is preferred
+        transition(BRAIN_EVENTS.START, 'agentLoop', hasAgentContext, startBrain), transition(BRAIN_EVENTS.START, 'running', startBrain)),
+        waiting: state(// TODO: Could add PAUSED transition here to allow pausing a waiting brain.
+        // This would require queueing webhook responses (similar to USER_MESSAGE signals)
+        // so they can be processed when the brain is resumed.
+        // Webhook response - if we have agentContext, go back to agentLoop
+        transition(BRAIN_EVENTS.WEBHOOK_RESPONSE, 'agentLoop', hasAgentContext, webhookResponse), // Otherwise go to running
+        transition(BRAIN_EVENTS.WEBHOOK_RESPONSE, 'running', webhookResponse), transition(BRAIN_EVENTS.CANCELLED, 'cancelled', cancelBrain), // START can resume from waiting (after webhook response is processed)
+        // If we have agentContext, resume to agentLoop; otherwise to running
+        transition(BRAIN_EVENTS.START, 'agentLoop', hasAgentContext, startBrain), transition(BRAIN_EVENTS.START, 'running', startBrain)),
         // Terminal states - limited outgoing transitions
         complete: state(),
         error: state(// Allow STEP_STATUS after error so we can emit the final step statuses
@@ -719,71 +618,8 @@ var makeBrainMachine = function(initialContext) {
  */ export function sendEvent(machine, event) {
     machine.send(event);
 }
-// ============================================================================
-// Query Helpers (kept for backwards compatibility, but context is now preferred)
-// ============================================================================
-export function getDepth(machine) {
-    return machine.context.depth;
-}
-export function isTopLevel(machine) {
-    return machine.context.isTopLevel;
-}
-export function getCurrentStep(machine) {
-    var _machine_context = machine.context, rootBrain = _machine_context.rootBrain, currentStepId = _machine_context.currentStepId;
-    if (!rootBrain || !currentStepId) return null;
-    var currentBrain = getDeepestBrain(rootBrain);
-    var _currentBrain_steps_find;
-    return (_currentBrain_steps_find = currentBrain === null || currentBrain === void 0 ? void 0 : currentBrain.steps.find(function(s) {
-        return s.id === currentStepId;
-    })) !== null && _currentBrain_steps_find !== void 0 ? _currentBrain_steps_find : null;
-}
-export function getBrainStack(machine) {
-    return machine.context.brainStack;
-}
-export function getBrainRunId(machine) {
-    return machine.context.brainRunId;
-}
-export function getExecutionState(machine) {
-    return machine.machine.current;
-}
-export function getPendingWebhooks(machine) {
-    return machine.context.pendingWebhooks;
-}
-export function getError(machine) {
-    return machine.context.error;
-}
 /**
- * Get the completed steps from the state machine in the format needed for resume.
- * This reconstructs the nested step hierarchy from the brain tree.
- * Returns a deep copy to avoid mutating the state machine's context.
- */ export function getCompletedSteps(machine) {
-    var rootBrain = machine.context.rootBrain;
-    if (!rootBrain) {
-        return [];
-    }
-    // Deep copy the steps, including any innerBrain's steps attached to parent step
-    var copyStep = function(step) {
-        var _step_innerSteps;
-        return _object_spread_props(_object_spread({}, step), {
-            innerSteps: (_step_innerSteps = step.innerSteps) === null || _step_innerSteps === void 0 ? void 0 : _step_innerSteps.map(copyStep)
-        });
-    };
-    // Recursively build steps from the brain tree
-    var copyBrainSteps = function(brain) {
-        var steps = brain.steps.map(copyStep);
-        // If there's a running inner brain, attach its steps to the parent step
-        if (brain.innerBrain) {
-            var parentStepId = brain.innerBrain.parentStepId;
-            if (parentStepId) {
-                var parentStep = steps.find(function(s) {
-                    return s.id === parentStepId;
-                });
-                if (parentStep) {
-                    parentStep.innerSteps = copyBrainSteps(brain.innerBrain);
-                }
-            }
-        }
-        return steps;
-    };
-    return copyBrainSteps(rootBrain);
-}
+ * Export a machine instance for signal validation.
+ * This is created once and used to query valid transitions.
+ * The machine is created with default initial context - only the state definitions matter for validation.
+ */ export var brainMachineDefinition = makeBrainMachine(createInitialContext());