@falai/agent 2.6.1 → 3.0.0

package/dist/cjs/core/ResponsePipeline.js

@@ -5,13 +5,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponsePipeline = void 0;
 exports.hasDirectivePositionField = hasDirectivePositionField;
-const utils_1 = require("../utils");
-const session_1 = require("../utils/session");
-const template_1 = require("../utils/template");
-const Step_1 = require("../core/Step");
-const BranchEvaluator_1 = require("./BranchEvaluator");
-const DirectiveChainTracker_1 = require("./DirectiveChainTracker");
-const ResponseGenerationError_1 = require("./ResponseGenerationError");
+const index_js_1 = require("../utils/index.js");
+const session_js_1 = require("../utils/session.js");
+const template_js_1 = require("../utils/template.js");
+const Step_js_1 = require("../core/Step.js");
+const BranchEvaluator_js_1 = require("./BranchEvaluator.js");
+const DirectiveChainTracker_js_1 = require("./DirectiveChainTracker.js");
+const ResponseGenerationError_js_1 = require("./ResponseGenerationError.js");
 /**
  * Position fields on a Directive that represent a navigation decision.
  * When any of these is set, the directive "wins" the turn's position decision
@@ -29,6 +29,23 @@ function hasDirectivePositionField(directive) {
         return false;
     return DIRECTIVE_POSITION_FIELDS.some((field) => directive[field] !== undefined);
 }
+/**
+ * Compute the per-key data writes the signal phase applied to a session.
+ * The signal phase and routing start from the same input session, so any
+ * key whose value differs between the input and the signal output was
+ * written by the signal phase alone (handler `updateData` calls).
+ */
+function diffSignalDataWrites(before, after) {
+    const beforeData = (before ?? {});
+    const afterData = (after ?? {});
+    const writes = {};
+    for (const key of Object.keys(afterData)) {
+        if (afterData[key] !== beforeData[key]) {
+            writes[key] = afterData[key];
+        }
+    }
+    return writes;
+}
 /**
  * Shared response processing logic between respond() and respondStream() methods
  */
@@ -47,7 +64,7 @@ class ResponsePipeline {
      */
     createChainTracker() {
         const maxChain = this.options.maxDirectiveChain ?? 10;
-        this._chainTracker = new DirectiveChainTracker_1.DirectiveChainTracker(maxChain);
+        this._chainTracker = new DirectiveChainTracker_js_1.DirectiveChainTracker(maxChain);
         return this._chainTracker;
     }
     /**
@@ -78,7 +95,7 @@ class ResponsePipeline {
             ...contextOverride,
         };
         // Initialize or get session (use the live session if available)
-        const targetSession = session || params.currentSession || (0, utils_1.createSession)();
+        const targetSession = session || params.currentSession || (0, index_js_1.createSession)();
         return {
             effectiveContext,
             session: targetSession,
@@ -89,7 +106,7 @@ class ResponsePipeline {
      * Handle routing and step selection logic
      */
     async handleRoutingAndStepSelection(params) {
-        const { session, history, context, signal } = params;
+        const { session, history, context, signal, allowedFlows } = params;
         // PHASE 2: ROUTING + STEP SELECTION - Determine which flow and step to use (combined)
         let selectedFlow;
         let responseDirectives;
@@ -97,12 +114,23 @@ class ResponsePipeline {
         let isFlowComplete = false;
         let completedFlows = [];
         let targetSession = session;
+        // Flows exited this turn via pendingDirective redirect/reset
+        const endedFlows = [];
+        let exitPrevFlowId;
+        let exitPrevFlowTitle;
+        let exitReason;
         // Get flows early since we need them for pending directives
         const flows = this.getFlows();
+        // Routing candidates may be narrowed for this turn (entry pins); the
+        // pendingDirective applier below still resolves targets against the FULL
+        // registry so declared redirects always resolve.
+        const routingFlows = allowedFlows && allowedFlows.length > 0
+            ? flows.filter((f) => allowedFlows.includes(f.id) || allowedFlows.includes(f.title))
+            : flows;
         // Check for pending directive from previous flow completion or external dispatch
         if (targetSession.pendingDirective) {
             const directive = targetSession.pendingDirective;
-            utils_1.logger.debug(`[ResponsePipeline] Applying pending directive at start of turn`);
+            index_js_1.logger.debug(`[ResponsePipeline] Applying pending directive at start of turn`);
             // Track directive chain depth (Requirement 22.1)
             const tracker = this.chainTracker;
             tracker.record(directive, "pending");
@@ -118,23 +146,30 @@ class ResponsePipeline {
                 ...targetSession,
                 pendingDirective: nextDirective,
             };
+            // Capture the flow we're leaving so directive-driven exits surface on
+            // the response (endedFlows).
+            exitPrevFlowId = targetSession.currentFlow?.id;
+            exitPrevFlowTitle = exitPrevFlowId
+                ? flows.find((f) => f.id === exitPrevFlowId)?.title
+                : undefined;
             // Apply the directive: resolve position field to a flow/step
             if (directive.goTo) {
+                exitReason = 'goto';
                 const flowTarget = typeof directive.goTo === 'string'
                     ? directive.goTo
                     : directive.goTo.flow;
                 if (flowTarget) {
                     const targetFlow = flows.find((r) => r.id === flowTarget || r.title === flowTarget);
                     if (targetFlow) {
-                        utils_1.logger.debug(`[ResponsePipeline] Pending directive goTo → flow: ${targetFlow.title}`);
-                        targetSession = (0, session_1.enterFlow)(targetSession, targetFlow.id, targetFlow.title);
+                        index_js_1.logger.debug(`[ResponsePipeline] Pending directive goTo → flow: ${targetFlow.title}`);
+                        targetSession = (0, session_js_1.enterFlow)(targetSession, targetFlow.id, targetFlow.title);
                         // Merge initial data if available
                         if (targetFlow.initialData) {
-                            targetSession = (0, utils_1.mergeCollected)(targetSession, targetFlow.initialData);
+                            targetSession = (0, index_js_1.mergeCollected)(targetSession, targetFlow.initialData);
                         }
                         // Merge directive-carried data if present
                         if (typeof directive.goTo === 'object' && directive.goTo.data) {
-                            targetSession = (0, utils_1.mergeCollected)(targetSession, directive.goTo.data);
+                            targetSession = (0, index_js_1.mergeCollected)(targetSession, directive.goTo.data);
                         }
                         selectedFlow = targetFlow;
                         // If goTo specifies a step, enter it
@@ -142,13 +177,13 @@ class ResponsePipeline {
                             const stepTarget = directive.goTo.step;
                             const targetStep = targetFlow.getStep(stepTarget);
                             if (targetStep) {
-                                targetSession = (0, utils_1.enterStep)(targetSession, targetStep.id, targetStep.description);
+                                targetSession = (0, index_js_1.enterStep)(targetSession, targetStep.id, targetStep.description);
                                 selectedStep = targetStep;
                             }
                         }
                     }
                     else {
-                        utils_1.logger.warn(`[FlowConfigurationError] Pending directive goTo target not found: flow "${flowTarget}" does not exist. Falling back to normal routing. Fix the goTo reference or remove the pending directive.`);
+                        index_js_1.logger.warn(`[FlowConfigurationError] Pending directive goTo target not found: flow "${flowTarget}" does not exist. Falling back to normal routing. Fix the goTo reference or remove the pending directive.`);
                     }
                 }
             }
@@ -162,11 +197,11 @@ class ResponsePipeline {
                 if (flowTarget) {
                     const targetFlow = flows.find((r) => r.id === flowTarget || r.title === flowTarget);
                     if (targetFlow) {
-                        targetSession = (0, session_1.enterFlow)(targetSession, targetFlow.id, targetFlow.title);
+                        targetSession = (0, session_js_1.enterFlow)(targetSession, targetFlow.id, targetFlow.title);
                         selectedFlow = targetFlow;
                         const targetStep = targetFlow.getStep(stepTarget);
                         if (targetStep) {
-                            targetSession = (0, utils_1.enterStep)(targetSession, targetStep.id, targetStep.description);
+                            targetSession = (0, index_js_1.enterStep)(targetSession, targetStep.id, targetStep.description);
                             selectedStep = targetStep;
                         }
                     }
@@ -178,13 +213,14 @@ class ResponsePipeline {
                         selectedFlow = currentFlow;
                         const targetStep = currentFlow.getStep(stepTarget);
                         if (targetStep) {
-                            targetSession = (0, utils_1.enterStep)(targetSession, targetStep.id, targetStep.description);
+                            targetSession = (0, index_js_1.enterStep)(targetSession, targetStep.id, targetStep.description);
                             selectedStep = targetStep;
                         }
                     }
                 }
             }
             else if (directive.reset) {
+                exitReason = 'reset';
                 // Reset current flow
                 if (targetSession.currentFlow) {
                     const currentFlow = flows.find(r => r.id === targetSession.currentFlow?.id);
@@ -196,14 +232,14 @@ class ResponsePipeline {
                         if (resetStep) {
                             const targetStep = currentFlow.getStep(resetStep);
                             if (targetStep) {
-                                targetSession = (0, utils_1.enterStep)(targetSession, targetStep.id, targetStep.description);
+                                targetSession = (0, index_js_1.enterStep)(targetSession, targetStep.id, targetStep.description);
                                 selectedStep = targetStep;
                             }
                         }
                         else {
                             // Reset to initial step
                             const initialStep = currentFlow.initialStep;
-                            targetSession = (0, utils_1.enterStep)(targetSession, initialStep.id, initialStep.description);
+                            targetSession = (0, index_js_1.enterStep)(targetSession, initialStep.id, initialStep.description);
                             selectedStep = initialStep;
                         }
                     }
@@ -212,14 +248,20 @@ class ResponsePipeline {
             // For complete/abort, selectedFlow stays undefined → handled downstream
             // Apply state writes from the directive
             if (directive.dataUpdate) {
-                targetSession = (0, utils_1.mergeCollected)(targetSession, directive.dataUpdate);
+                targetSession = (0, index_js_1.mergeCollected)(targetSession, directive.dataUpdate);
             }
             // Skip FlowRouter.decideFlowAndStep — the directive resolved the position
         }
-        // If no pending transition or transition handled, do normal routing
-        if (flows.length > 0 && !selectedFlow) {
+        if (exitReason &&
+            exitPrevFlowId &&
+            (!selectedFlow || selectedFlow.id !== exitPrevFlowId)) {
+            endedFlows.push({ flowId: exitPrevFlowId, title: exitPrevFlowTitle, reason: exitReason });
+        }
+        // If no pending transition or transition handled, do normal routing.
+        // Candidates honor allowedFlows; completion scoring runs over the same set.
+        if (routingFlows.length > 0 && !selectedFlow) {
             const orchestration = await this.flowRouter.decideFlowAndStep({
-                flows: flows,
+                flows: routingFlows,
                 session: targetSession,
                 history,
                 agentOptions: this.options,
@@ -235,7 +277,7 @@ class ResponsePipeline {
             completedFlows = orchestration.completedFlows || [];
             // Log if flow is complete
             if (isFlowComplete) {
-                utils_1.logger.debug(`[ResponsePipeline] Flow complete: all required data collected or last step reached`);
+                index_js_1.logger.debug(`[ResponsePipeline] Flow complete: all required data collected or last step reached`);
             }
         }
         return {
@@ -245,15 +287,36 @@ class ResponsePipeline {
             session: targetSession,
             isFlowComplete,
             completedFlows,
+            ...(endedFlows.length > 0 ? { endedFlows } : {}),
         };
     }
+    /**
+     * Combine a routing-derived session with the signal phase's non-position
+     * mutations. The routing session is the base — it owns position state AND
+     * data merges such as flow initialData and directive-carried writes; the
+     * signal phase's mutations (trigger recording under `signals`, handler
+     * data writes) are re-applied on top. Both phases start from the same
+     * input session, so their mutations cannot silently collide.
+     */
+    combineRoutingAndSignalSessions(params) {
+        const { inputSession, signalSession, routingSession } = params;
+        let combined = routingSession;
+        if (signalSession.signals !== inputSession.signals) {
+            combined = { ...combined, signals: signalSession.signals };
+        }
+        const signalWrites = diffSignalDataWrites(inputSession.data, signalSession.data);
+        if (Object.keys(signalWrites).length > 0) {
+            combined = (0, index_js_1.mergeCollected)(combined, signalWrites);
+        }
+        return combined;
+    }
     /**
      * Determine next step and update session
      */
     async determineNextStep(params) {
         const { selectedFlow, selectedStep, session, isFlowComplete, context, busDirective } = params;
         if (!selectedFlow) {
-            return { nextStep: undefined, session };
+            return { nextStep: undefined, session, isFlowComplete };
         }
         // ─── GUARD: directive bus winner with a position field preempts branches ───
         // Resolution precedence (design.md): bus > branches > linear > AI.
@@ -261,8 +324,8 @@ class ResponsePipeline {
         // complete, abort, reset), that decision wins the turn. Do NOT evaluate
         // branches or linear/AI selection — the caller applies the bus directive.
         if (hasDirectivePositionField(busDirective)) {
-            utils_1.logger.debug(`[ResponsePipeline] Directive bus winner has position field — skipping branch evaluation and linear/AI selection`);
-            return { nextStep: undefined, session };
+            index_js_1.logger.debug(`[ResponsePipeline] Directive bus winner has position field — skipping branch evaluation and linear/AI selection`);
+            return { nextStep: undefined, session, isFlowComplete };
         }
         // STEP 1 (Algorithm 1): branches win over linear chain AND flow completion.
         // Evaluate branches before checking isFlowComplete — a branch can redirect
@@ -274,13 +337,20 @@ class ResponsePipeline {
             if (currentStep?.branches && currentStep.branches.length > 0) {
                 const branchResult = await this.evaluateStepBranches(currentStep, selectedFlow, session, context);
                 if (branchResult) {
-                    return branchResult;
+                    // A branch that resolved a position overrides the router's completion
+                    // proposal. Without this, a branch that parks on a step of its own
+                    // flow (`then: '<stepId>'`, `then: { reset: true }`) keeps
+                    // isFlowComplete=true, the caller drops the step it just resolved,
+                    // and the turn ends as a silent completion — no LLM call, empty
+                    // reply, flow marked completed for the rest of the session.
+                    const resolvedPosition = Boolean(branchResult.nextStep || branchResult.flowChanged);
+                    return { ...branchResult, isFlowComplete: resolvedPosition ? false : isFlowComplete };
                 }
                 // undefined → fall through to linear/AI selection or flow completion
             }
         }
         if (isFlowComplete) {
-            return { nextStep: undefined, session };
+            return { nextStep: undefined, session, isFlowComplete: true };
         }
         let nextStep;
         // If we have a selected step from the combined routing decision, use it
@@ -294,15 +364,15 @@ class ResponsePipeline {
                 : undefined;
             // Get candidate steps based on current position in the flow
             const candidates = await this.flowRouter.getCandidateStepsWithConditions(selectedFlow, currentStep, // Pass current step instead of undefined to maintain progression
-            (0, template_1.createTemplateContext)({ data: session.data, session, context }));
+            (0, template_js_1.createTemplateContext)({ data: session.data, session, context }));
             if (candidates.length > 0) {
                 nextStep = candidates[0].step;
-                utils_1.logger.debug(`[ResponsePipeline] Using first valid step: ${nextStep.id}${currentStep ? ' (progressing from ' + currentStep.id + ')' : ' for new flow'}`);
+                index_js_1.logger.debug(`[ResponsePipeline] Using first valid step: ${nextStep.id}${currentStep ? ' (progressing from ' + currentStep.id + ')' : ' for new flow'}`);
             }
             else {
                 // Fallback to initial step even if it should be skipped
                 nextStep = selectedFlow.initialStep;
-                utils_1.logger.warn(`[FlowConfigurationError] No valid steps found in flow "${selectedFlow.title}": all candidates were skipped. Falling back to initial step "${nextStep.id}". Review step skip conditions.`);
+                index_js_1.logger.warn(`[FlowConfigurationError] No valid steps found in flow "${selectedFlow.title}": all candidates were skipped. Falling back to initial step "${nextStep.id}". Review step skip conditions.`);
             }
         }
         // Before entering the step, check if requires fields are satisfied
@@ -310,7 +380,7 @@ class ResponsePipeline {
             const sessionData = session.data || {};
             const missingRequires = nextStep.requires.filter(field => sessionData[String(field)] === undefined);
             if (missingRequires.length > 0) {
-                utils_1.logger.debug(`[ResponsePipeline] Cannot enter step "${nextStep.id}": missing required fields [${missingRequires.join(', ')}]. Staying at current step.`);
+                index_js_1.logger.debug(`[ResponsePipeline] Cannot enter step "${nextStep.id}": missing required fields [${missingRequires.join(', ')}]. Staying at current step.`);
                 // Stay at current step - don't enter the next one
                 const currentStepId = session.currentStep?.id;
                 if (currentStepId && selectedFlow) {
@@ -319,13 +389,13 @@ class ResponsePipeline {
                         nextStep = currentStepInstance;
                     }
                 }
-                return { nextStep, session };
+                return { nextStep, session, isFlowComplete: false };
             }
         }
         // Update session with next step
-        const updatedSession = (0, utils_1.enterStep)(session, nextStep.id, nextStep.description);
-        utils_1.logger.debug(`[ResponsePipeline] Entered step: ${nextStep.id}`);
-        return { nextStep, session: updatedSession };
+        const updatedSession = (0, index_js_1.enterStep)(session, nextStep.id, nextStep.description);
+        index_js_1.logger.debug(`[ResponsePipeline] Entered step: ${nextStep.id}`);
+        return { nextStep, session: updatedSession, isFlowComplete: false };
     }
     /**
      * Evaluate branches on a step and resolve the `then` value.
@@ -339,7 +409,7 @@ class ResponsePipeline {
      * Returns the resolved { nextStep, session, flowChanged? } or undefined if no branch matched.
      */
     async evaluateStepBranches(currentStep, selectedFlow, session, context) {
-        const history = session.history ? (0, utils_1.historyToEvents)(session.history) : [];
+        const history = session.history ? (0, index_js_1.historyToEvents)(session.history) : [];
         // Build the BranchPredicateContext
         const branchCtx = {
             data: session.data,
@@ -348,8 +418,8 @@ class ResponsePipeline {
             history,
         };
         // Create the AI condition evaluator
-        const aiEvaluator = (0, BranchEvaluator_1.createAiConditionEvaluator)(this.options.provider, history, context);
-        const result = await (0, BranchEvaluator_1.evaluateBranches)(currentStep.branches, branchCtx, aiEvaluator);
+        const aiEvaluator = (0, BranchEvaluator_js_1.createAiConditionEvaluator)(this.options.provider, history, context);
+        const result = await (0, BranchEvaluator_js_1.evaluateBranches)(currentStep.branches, branchCtx, aiEvaluator);
         if (result === undefined) {
             return undefined; // No branch matched → fall through to linear/AI selection
         }
@@ -362,8 +432,8 @@ class ResponsePipeline {
         // 1. Look up in current flow's step registry first (local step wins)
         const localStep = selectedFlow.getStep(result);
         if (localStep) {
-            const updatedSession = (0, utils_1.enterStep)(session, localStep.id, localStep.description);
-            utils_1.logger.debug(`[ResponsePipeline] Branch resolved to local step: ${localStep.id}`);
+            const updatedSession = (0, index_js_1.enterStep)(session, localStep.id, localStep.description);
+            index_js_1.logger.debug(`[ResponsePipeline] Branch resolved to local step: ${localStep.id}`);
             return { nextStep: localStep, session: updatedSession };
         }
         // 2. Look up in agent's flow registry
@@ -371,12 +441,12 @@ class ResponsePipeline {
         const targetFlow = flows.find(f => f.id === result || f.title === result);
         if (targetFlow) {
             // Treat as applyDirective({ goTo: result }) — enter the target flow
-            utils_1.logger.debug(`[ResponsePipeline] Branch resolved to flow: ${targetFlow.title}`);
-            const updatedSession = (0, session_1.enterFlow)(session, targetFlow.id, targetFlow.title);
+            index_js_1.logger.debug(`[ResponsePipeline] Branch resolved to flow: ${targetFlow.title}`);
+            const updatedSession = (0, session_js_1.enterFlow)(session, targetFlow.id, targetFlow.title);
             return { nextStep: undefined, session: updatedSession, flowChanged: targetFlow };
         }
         // 3. Neither → throw FlowConfigurationError
-        throw new Step_1.FlowConfigurationError(`[FlowConfigurationError] Unresolved branch target: "${result}" does not match any step in flow "${selectedFlow.id}" or any flow in the agent. ` +
+        throw new Step_js_1.FlowConfigurationError(`[FlowConfigurationError] Unresolved branch target: "${result}" does not match any step in flow "${selectedFlow.id}" or any flow in the agent. ` +
             `Source: ${selectedFlow.id}.${currentStep.id}. Fix the branch "then" value to reference a valid step id or flow id/title.`);
     }
     /**
@@ -390,7 +460,7 @@ class ResponsePipeline {
         let updatedSession = session;
         // Apply state writes first
         if (directive.dataUpdate) {
-            updatedSession = (0, utils_1.mergeCollected)(updatedSession, directive.dataUpdate);
+            updatedSession = (0, index_js_1.mergeCollected)(updatedSession, directive.dataUpdate);
         }
         // Handle position fields
         if (directive.goToStep) {
@@ -405,24 +475,24 @@ class ResponsePipeline {
                 const flows = this.getFlows();
                 const targetFlow = flows.find(f => f.id === flowTarget || f.title === flowTarget);
                 if (targetFlow) {
-                    updatedSession = (0, session_1.enterFlow)(updatedSession, targetFlow.id, targetFlow.title);
-                    updatedSession = (0, utils_1.enterStep)(updatedSession, stepTarget);
+                    updatedSession = (0, session_js_1.enterFlow)(updatedSession, targetFlow.id, targetFlow.title);
+                    updatedSession = (0, index_js_1.enterStep)(updatedSession, stepTarget);
                     // Try to resolve the target step instance for the caller
                     const targetStepInstance = targetFlow.getStep(stepTarget);
-                    utils_1.logger.debug(`[ResponsePipeline] Branch directive goToStep → ${flowTarget}.${stepTarget}`);
+                    index_js_1.logger.debug(`[ResponsePipeline] Branch directive goToStep → ${flowTarget}.${stepTarget}`);
                     return { nextStep: targetStepInstance || undefined, session: updatedSession, flowChanged: targetFlow };
                 }
-                throw new Step_1.FlowConfigurationError(`[FlowConfigurationError] Branch directive goToStep targets unknown flow: "${flowTarget}" does not match any flow id or title. ` +
+                throw new Step_js_1.FlowConfigurationError(`[FlowConfigurationError] Branch directive goToStep targets unknown flow: "${flowTarget}" does not match any flow id or title. ` +
                     `Fix the goToStep.flow value or use goTo to target a known flow.`);
             }
             // Local step reference
             const targetStep = selectedFlow.getStep(stepTarget);
             if (targetStep) {
-                updatedSession = (0, utils_1.enterStep)(updatedSession, targetStep.id, targetStep.description);
-                utils_1.logger.debug(`[ResponsePipeline] Branch directive goToStep → ${targetStep.id}`);
+                updatedSession = (0, index_js_1.enterStep)(updatedSession, targetStep.id, targetStep.description);
+                index_js_1.logger.debug(`[ResponsePipeline] Branch directive goToStep → ${targetStep.id}`);
                 return { nextStep: targetStep, session: updatedSession };
             }
-            throw new Step_1.FlowConfigurationError(`[FlowConfigurationError] Branch directive goToStep targets unknown step: "${stepTarget}" does not exist in flow "${selectedFlow.id}". ` +
+            throw new Step_js_1.FlowConfigurationError(`[FlowConfigurationError] Branch directive goToStep targets unknown step: "${stepTarget}" does not exist in flow "${selectedFlow.id}". ` +
                 `Fix the goToStep value to reference a valid step id in the current flow.`);
         }
         if (directive.goTo) {
@@ -433,24 +503,24 @@ class ResponsePipeline {
                 const flows = this.getFlows();
                 const targetFlow = flows.find(f => f.id === flowTarget || f.title === flowTarget);
                 if (targetFlow) {
-                    updatedSession = (0, session_1.enterFlow)(updatedSession, targetFlow.id, targetFlow.title);
+                    updatedSession = (0, session_js_1.enterFlow)(updatedSession, targetFlow.id, targetFlow.title);
                     // If goTo is an object with a step field, enter that step too
                     if (typeof directive.goTo === 'object' && directive.goTo.step) {
-                        updatedSession = (0, utils_1.enterStep)(updatedSession, directive.goTo.step);
+                        updatedSession = (0, index_js_1.enterStep)(updatedSession, directive.goTo.step);
                     }
-                    utils_1.logger.debug(`[ResponsePipeline] Branch directive goTo → ${targetFlow.title}`);
+                    index_js_1.logger.debug(`[ResponsePipeline] Branch directive goTo → ${targetFlow.title}`);
                     return { nextStep: undefined, session: updatedSession, flowChanged: targetFlow };
                 }
-                throw new Step_1.FlowConfigurationError(`[FlowConfigurationError] Branch directive goTo targets unknown flow: "${flowTarget}" does not match any flow id or title. ` +
+                throw new Step_js_1.FlowConfigurationError(`[FlowConfigurationError] Branch directive goTo targets unknown flow: "${flowTarget}" does not match any flow id or title. ` +
                     `Fix the goTo value to reference a valid flow.`);
             }
         }
         if (directive.complete) {
-            utils_1.logger.debug(`[ResponsePipeline] Branch directive complete`);
+            index_js_1.logger.debug(`[ResponsePipeline] Branch directive complete`);
             return { nextStep: undefined, session: updatedSession };
         }
         if (directive.abort) {
-            utils_1.logger.debug(`[ResponsePipeline] Branch directive abort`);
+            index_js_1.logger.debug(`[ResponsePipeline] Branch directive abort`);
             return { nextStep: undefined, session: updatedSession };
         }
         if (directive.reset) {
@@ -460,14 +530,14 @@ class ResponsePipeline {
             if (resetStep) {
                 const targetStep = selectedFlow.getStep(resetStep);
                 if (targetStep) {
-                    updatedSession = (0, utils_1.enterStep)(updatedSession, targetStep.id, targetStep.description);
+                    updatedSession = (0, index_js_1.enterStep)(updatedSession, targetStep.id, targetStep.description);
                     return { nextStep: targetStep, session: updatedSession };
                 }
             }
             // Reset to initial step
             const initialStep = selectedFlow.initialStep;
-            updatedSession = (0, utils_1.enterStep)(updatedSession, initialStep.id, initialStep.description);
-            utils_1.logger.debug(`[ResponsePipeline] Branch directive reset → ${initialStep.id}`);
+            updatedSession = (0, index_js_1.enterStep)(updatedSession, initialStep.id, initialStep.description);
+            index_js_1.logger.debug(`[ResponsePipeline] Branch directive reset → ${initialStep.id}`);
             return { nextStep: initialStep, session: updatedSession };
         }
         // Directive with only non-position fields (e.g., just dataUpdate/contextUpdate/reply)
@@ -485,17 +555,20 @@ class ResponsePipeline {
             // Create a fresh chain tracker for this turn (Requirement 22.1)
             this.createChainTracker();
             // ROUTING SKIP OPTIMIZATION (Requirements 20.1, 20.2, 20.3):
-            // When the current step has collect fields AND pre-extraction populates at least
-            // one of those fields, skip FlowRouter.decideFlowAndStep for this turn.
-            const routingSkipResult = await this.attemptRoutingSkipForCollect(params);
-            if (routingSkipResult) {
+            // When the current step has collect fields AND step-scoped pre-extraction
+            // populates at least one of those fields, skip FlowRouter.decideFlowAndStep
+            // for this turn. The check's extraction result is reused by the fallthrough
+            // paths below so a turn costs at most ONE extraction LLM call.
+            const routingSkipCheck = await this.attemptRoutingSkipForCollect(params);
+            if (routingSkipCheck.skipResult) {
+                const skipResult = routingSkipCheck.skipResult;
                 // Even when routing is skipped, run pre-signal phase if processor is present
                 if (this.signalCoordinator.enabled) {
                     const signalResult = await this.signalCoordinator.runPrePhase(params.session, params.context, params.history);
                     // If signal halts, override the routing skip result
                     if (signalResult.mergedDirective?.halt) {
                         return {
-                            ...routingSkipResult,
+                            ...skipResult,
                             session: signalResult.updatedSession,
                             signalFirings: signalResult.firings,
                             signalHalted: true,
@@ -506,15 +579,20 @@ class ResponsePipeline {
                     if (hasDirectivePositionField(signalResult.mergedDirective)) {
                         return this.signalCoordinator.applyPositionDirective(signalResult);
                     }
-                    // Non-position directive: propagate for pre-LLM augmentation
+                    // Non-position directive: keep the skip result (extraction merges,
+                    // step entry) and re-apply the signal phase's non-position mutations
                     return {
-                        ...routingSkipResult,
-                        session: signalResult.updatedSession,
+                        ...skipResult,
+                        session: this.combineRoutingAndSignalSessions({
+                            inputSession: params.session,
+                            signalSession: signalResult.updatedSession,
+                            routingSession: skipResult.session,
+                        }),
                         signalFirings: signalResult.firings,
                         signalPreDirective: signalResult.mergedDirective || undefined,
                     };
                 }
-                return routingSkipResult;
+                return skipResult;
             }
             // ── PARALLEL PRE-SIGNAL PHASE + ROUTING (Algorithm 5) ────────────────
             // When signalProcessor is present, run pre-signals in parallel with routing.
@@ -528,6 +606,7 @@ class ResponsePipeline {
                         history: params.history,
                         context: params.context,
                         signal: params.signal,
+                        allowedFlows: params.allowedFlows,
                     }),
                 ]);
                 // ── Requirement 8.2: halt → discard routing, skip LLM ────────────
@@ -548,38 +627,41 @@ class ResponsePipeline {
                 }
                 // ── Requirement 8.4: non-position directive → use routing, propagate augmentation ──
                 // ── Requirement 8.5: no directive → use routing as-is ─────────────
-                let updatedSession = signalResult.updatedSession;
-                // Apply data/context updates from signal to the routed session
+                // Base = routed session (position state AND router data merges such as
+                // flow initialData survive); the signal phase's non-position mutations
+                // (trigger state, handler data writes) are re-applied on top.
+                let updatedSession = this.combineRoutingAndSignalSessions({
+                    inputSession: params.session,
+                    signalSession: signalResult.updatedSession,
+                    routingSession: routingResult.session,
+                });
+                // Explicit dataUpdate from the signal's merged directive lands last
                 if (signalResult.mergedDirective?.dataUpdate) {
-                    updatedSession = (0, utils_1.mergeCollected)(updatedSession, signalResult.mergedDirective.dataUpdate);
+                    updatedSession = (0, index_js_1.mergeCollected)(updatedSession, signalResult.mergedDirective.dataUpdate);
                 }
-                // Use routing result for flow/step, but carry signal session state
-                // Merge routing session changes on top of signal session
-                const routingSession = routingResult.session;
-                updatedSession = {
-                    ...updatedSession,
-                    currentFlow: routingSession.currentFlow,
-                    currentStep: routingSession.currentStep,
-                    flowHistory: routingSession.flowHistory,
-                    pendingDirective: routingSession.pendingDirective,
-                };
                 const isFlowComplete = routingResult.isFlowComplete;
-                // PRE-EXTRACTION: same logic as below — extract data from user message
+                // PRE-EXTRACTION: same logic as below — extract data from user message.
+                // Reuses the routing-skip check's step-scoped extraction when it already
+                // ran this turn (at most ONE extraction LLM call per turn).
                 if (routingResult.selectedFlow && !isFlowComplete) {
-                    if (this.shouldPreExtractData(routingResult.selectedFlow)) {
-                        utils_1.logger.debug(`[ResponsePipeline] Pre-extracting data for flow: ${routingResult.selectedFlow.title}`);
-                        const extractedData = await this.preExtractFlowData({
+                    let extractedData;
+                    if (routingSkipCheck.extractionRan) {
+                        extractedData = routingSkipCheck.extractedData;
+                    }
+                    else if (this.shouldPreExtractData(routingResult.selectedFlow)) {
+                        index_js_1.logger.debug(`[ResponsePipeline] Pre-extracting data for flow: ${routingResult.selectedFlow.title}`);
+                        extractedData = await this.preExtractFlowData({
                             route: routingResult.selectedFlow,
                             history: params.history,
                             context: params.context,
                             session: updatedSession,
                             signal: params.signal,
                         });
-                        if (extractedData && Object.keys(extractedData).length > 0) {
-                            utils_1.logger.debug(`[ResponsePipeline] Pre-extracted data:`, extractedData);
-                            updatedSession = (0, utils_1.mergeCollected)(updatedSession, extractedData);
-                            await this.updateCollectedData(extractedData);
-                        }
+                    }
+                    if (extractedData && Object.keys(extractedData).length > 0) {
+                        index_js_1.logger.debug(`[ResponsePipeline] Pre-extracted data:`, extractedData);
+                        updatedSession = (0, index_js_1.mergeCollected)(updatedSession, extractedData);
+                        await this.updateCollectedData(extractedData);
                     }
                 }
                 // Determine next step
@@ -595,9 +677,10 @@ class ResponsePipeline {
                     selectedStep: stepResult.nextStep,
                     responseDirectives: routingResult.responseDirectives,
                     session: stepResult.session,
-                    isFlowComplete: stepResult.flowChanged ? false : isFlowComplete,
+                    isFlowComplete: stepResult.isFlowComplete,
                     signalFirings: signalResult.firings,
                     signalPreDirective: signalResult.mergedDirective || undefined,
+                    endedFlows: routingResult.endedFlows,
                 };
             }
             // ── No signal processor: existing behavior (zero overhead) ────────────
@@ -606,30 +689,37 @@ class ResponsePipeline {
                 history: params.history,
                 context: params.context,
                 signal: params.signal,
+                allowedFlows: params.allowedFlows,
             });
             let updatedSession = routingResult.session;
             const isFlowComplete = routingResult.isFlowComplete;
             // PRE-EXTRACTION: If entering a flow that collects data, extract data from user message first
-            // This allows us to skip steps whose data is already provided
+            // This allows us to skip steps whose data is already provided.
+            // Reuses the routing-skip check's step-scoped extraction when it already
+            // ran this turn — at most ONE extraction LLM call per turn.
             if (routingResult.selectedFlow && !isFlowComplete) {
                 // Always pre-extract when flow collects data (not just on new flow entry)
                 // This ensures step selection has the most up-to-date data
-                if (this.shouldPreExtractData(routingResult.selectedFlow)) {
-                    utils_1.logger.debug(`[ResponsePipeline] Pre-extracting data for flow: ${routingResult.selectedFlow.title}`);
-                    const extractedData = await this.preExtractFlowData({
+                let extractedData;
+                if (routingSkipCheck.extractionRan) {
+                    extractedData = routingSkipCheck.extractedData;
+                }
+                else if (this.shouldPreExtractData(routingResult.selectedFlow)) {
+                    index_js_1.logger.debug(`[ResponsePipeline] Pre-extracting data for flow: ${routingResult.selectedFlow.title}`);
+                    extractedData = await this.preExtractFlowData({
                         route: routingResult.selectedFlow,
                         history: params.history,
                         context: params.context,
                         session: updatedSession,
                         signal: params.signal,
                     });
-                    if (extractedData && Object.keys(extractedData).length > 0) {
-                        utils_1.logger.debug(`[ResponsePipeline] Pre-extracted data:`, extractedData);
-                        // Merge pre-extracted data into session before step selection
-                        updatedSession = (0, utils_1.mergeCollected)(updatedSession, extractedData);
-                        // Also update agent's collected data
-                        await this.updateCollectedData(extractedData);
-                    }
+                }
+                if (extractedData && Object.keys(extractedData).length > 0) {
+                    index_js_1.logger.debug(`[ResponsePipeline] Pre-extracted data:`, extractedData);
+                    // Merge pre-extracted data into session before step selection
+                    updatedSession = (0, index_js_1.mergeCollected)(updatedSession, extractedData);
+                    // Also update agent's collected data
+                    await this.updateCollectedData(extractedData);
                 }
             }
             // Determine next step using pipeline method for consistency
@@ -645,12 +735,14 @@ class ResponsePipeline {
                 selectedStep: stepResult.nextStep, // Use the determined next step
                 responseDirectives: routingResult.responseDirectives,
                 session: stepResult.session,
-                // If a branch changed the flow, the original isFlowComplete no longer applies
-                isFlowComplete: stepResult.flowChanged ? false : isFlowComplete,
+                // determineNextStep owns the verdict: a branch that resolved a position
+                // (new flow, or a step of this one) overrides the router's proposal.
+                isFlowComplete: stepResult.isFlowComplete,
+                endedFlows: routingResult.endedFlows,
             };
         }
         catch (error) {
-            throw ResponseGenerationError_1.ResponseGenerationError.fromError(error, 'routing_optimization', params);
+            throw ResponseGenerationError_js_1.ResponseGenerationError.fromError(error, 'routing_optimization', params);
         }
     }
     /**
@@ -678,7 +770,7 @@ class ResponsePipeline {
             const currentStep = isInSameFlow && session.currentStep
                 ? selectedFlow.getStep(session.currentStep.id)
                 : undefined;
-            utils_1.logger.debug(`[ResponsePipeline] Step determination: flow match=${isInSameFlow}, currentFlow=${session.currentFlow?.id}, selectedFlow=${selectedFlow.id}, currentStep=${currentStep?.id || 'none'}`);
+            index_js_1.logger.debug(`[ResponsePipeline] Step determination: flow match=${isInSameFlow}, currentFlow=${session.currentFlow?.id}, selectedFlow=${selectedFlow.id}, currentStep=${currentStep?.id || 'none'}`);
             // STEP 1 (Algorithm 1): branches win over linear chain
             if (currentStep?.branches && currentStep.branches.length > 0) {
                 const branchResult = await this.evaluateStepBranches(currentStep, selectedFlow, session, context);
@@ -696,16 +788,16 @@ class ResponsePipeline {
             if (!nextStep) {
                 // Get candidate steps based on current position in the flow
                 const candidates = await this.flowRouter.getCandidateStepsWithConditions(selectedFlow, currentStep, // Pass current step instead of undefined to maintain progression
-                (0, template_1.createTemplateContext)({ data: session.data, session, context }));
-                utils_1.logger.debug(`[ResponsePipeline] Found ${candidates.length} candidate steps${currentStep ? ' from current step ' + currentStep.id : ' (new flow entry)'}`);
+                (0, template_js_1.createTemplateContext)({ data: session.data, session, context }));
+                index_js_1.logger.debug(`[ResponsePipeline] Found ${candidates.length} candidate steps${currentStep ? ' from current step ' + currentStep.id : ' (new flow entry)'}`);
                 if (candidates.length > 0) {
                     nextStep = candidates[0].step;
-                    utils_1.logger.debug(`[ResponsePipeline] Using first valid step: ${nextStep.id}${currentStep ? ' (progressing from ' + currentStep.id + ')' : ' for new flow'}`);
+                    index_js_1.logger.debug(`[ResponsePipeline] Using first valid step: ${nextStep.id}${currentStep ? ' (progressing from ' + currentStep.id + ')' : ' for new flow'}`);
                 }
                 else {
                     // Fallback to initial step even if it should be skipped
                     nextStep = selectedFlow.initialStep;
-                    utils_1.logger.warn(`[FlowConfigurationError] No valid steps found: all candidates were skipped in flow. Falling back to initial step "${nextStep.id}". Review step skip conditions.`);
+                    index_js_1.logger.warn(`[FlowConfigurationError] No valid steps found: all candidates were skipped in flow. Falling back to initial step "${nextStep.id}". Review step skip conditions.`);
                 }
             }
         }
@@ -717,7 +809,7 @@ class ResponsePipeline {
             if (missingRequires.length > 0) {
                 const warning = `[FlowConfigurationError] Cannot advance to step "${nextStep.description || nextStep.id}": ` +
                     `missing required fields [${missingRequires.join(', ')}]. Staying at current step. Ensure preceding steps collect these fields.`;
-                utils_1.logger.warn(warning);
+                index_js_1.logger.warn(warning);
                 console.warn(warning);
                 // Stay at the current step - don't enter the next one
                 const currentStepId = session.currentStep?.id;
@@ -725,82 +817,101 @@ class ResponsePipeline {
                     const currentStepInstance = selectedFlow.getStep(currentStepId);
                     if (currentStepInstance) {
                         nextStep = currentStepInstance;
-                        utils_1.logger.debug(`[ResponsePipeline] Staying at current step: ${nextStep.id} due to missing requires`);
+                        index_js_1.logger.debug(`[ResponsePipeline] Staying at current step: ${nextStep.id} due to missing requires`);
                     }
                 }
             }
             else {
-                session = (0, utils_1.enterStep)(session, nextStep.id, nextStep.description);
-                utils_1.logger.debug(`[ResponsePipeline] Entered step: ${nextStep.id}`);
+                session = (0, index_js_1.enterStep)(session, nextStep.id, nextStep.description);
+                index_js_1.logger.debug(`[ResponsePipeline] Entered step: ${nextStep.id}`);
             }
         }
         else {
-            session = (0, utils_1.enterStep)(session, nextStep.id, nextStep.description);
-            utils_1.logger.debug(`[ResponsePipeline] Entered step: ${nextStep.id}`);
+            session = (0, index_js_1.enterStep)(session, nextStep.id, nextStep.description);
+            index_js_1.logger.debug(`[ResponsePipeline] Entered step: ${nextStep.id}`);
         }
         return { nextStep, session, flowTransition: false };
     }
     /**
-     * Routing skip optimization (Requirements 20.1, 20.2, 20.3):
-     * When the current step declares `collect` fields AND pre-extraction populates
-     * at least one of those fields from the user's message, skip routing for this turn.
+     * Routing skip check (Requirements 20.1, 20.2, 20.3):
+     * When the current step declares `collect` fields AND step-scoped extraction
+     * populates at least one of those fields from the user's message, the caller
+     * skips routing for this turn (`skipResult`).
      *
-     * Returns the routing result if the skip applies, or undefined to fall through
-     * to normal routing.
+     * The extraction is scoped to EXACTLY this step's collect fields — incidental
+     * mentions of other (e.g. other-flow) fields cannot pin the routing decision.
+     * It is skipped entirely when every collect field is already populated.
+     *
+     * Always returns what the check did so the caller can reuse the single
+     * extraction result in its normal path instead of extracting twice:
+     * - `extractionRan` — whether an extraction LLM call was made this turn.
+     * - `extractedData` — that call's result (empty when nothing found / not run).
      */
     async attemptRoutingSkipForCollect(params) {
         const { session } = params;
+        const notApplicable = { extractionRan: false, extractedData: {} };
         // Only applies when we already have a current flow and step
         if (!session.currentFlow || !session.currentStep) {
-            return undefined;
+            return notApplicable;
         }
         // Also skip this optimization if there's a pending directive (it takes priority)
         if (session.pendingDirective) {
-            return undefined;
+            return notApplicable;
         }
         // Look up the actual Flow and Step objects to access `collect`
         const currentFlow = this.getFlows().find((f) => f.id === session.currentFlow?.id);
         if (!currentFlow) {
-            return undefined;
+            return notApplicable;
         }
         const currentStep = currentFlow.getStep(session.currentStep.id);
         if (!currentStep || !currentStep.collect || currentStep.collect.length === 0) {
-            return undefined;
+            return notApplicable;
         }
-        // We have a step with collect fields. Run pre-extraction to see if the
-        // user's message populates any of them.
         const collectFields = currentStep.collect;
+        // Every relevant field already set — the skip cannot fire; don't spend
+        // an extraction LLM call probing for it.
+        const sessionRecord = (session.data ?? {});
+        const allPopulated = collectFields.every((field) => {
+            const value = sessionRecord[String(field)];
+            return value !== undefined && value !== null;
+        });
+        if (allPopulated) {
+            return notApplicable;
+        }
         // Snapshot current data for comparison
-        const dataBefore = { ...session.data };
-        // Run pre-extraction against the current flow
+        const dataBefore = { ...sessionRecord };
+        // Step-scoped pre-extraction: see if the user's message populates any of
+        // THIS step's collect fields.
         const extractedData = await this.preExtractFlowData({
             route: currentFlow,
             history: params.history,
             context: params.context,
             session,
             signal: params.signal,
+            restrictToFields: collectFields.map(String),
         });
         if (!extractedData || Object.keys(extractedData).length === 0) {
-            return undefined;
+            return { extractionRan: true, extractedData: {} };
         }
         // Determine which collect fields were newly populated by pre-extraction
+        const extractedRecord = extractedData;
         const populatedCollectFields = [];
         for (const field of collectFields) {
-            const key = field;
-            const hadValue = dataBefore[field] !== undefined && dataBefore[field] !== null;
-            const hasNewValue = extractedData[field] !== undefined && extractedData[field] !== null;
+            const key = String(field);
+            const hadValue = dataBefore[key] !== undefined && dataBefore[key] !== null;
+            const hasNewValue = extractedRecord[key] !== undefined && extractedRecord[key] !== null;
             if (hasNewValue && !hadValue) {
                 populatedCollectFields.push(key);
             }
         }
         if (populatedCollectFields.length === 0) {
             // Pre-extraction didn't populate any declared collect field — no skip
-            return undefined;
+            return { extractionRan: true, extractedData };
         }
         // ROUTING SKIP: pre-extraction populated collect fields → retain current flow/step
-        utils_1.logger.debug(`[ResponsePipeline] Routing skip: pre-extraction populated collect fields [${populatedCollectFields.join(', ')}] for step "${currentStep.id}" — skipping FlowRouter`);
+        index_js_1.logger.debug(`[ResponsePipeline] Routing skip: pre-extraction populated collect fields [${populatedCollectFields.join(', ')}] for step "${currentStep.id}" — skipping FlowRouter`);
         // Merge extracted data into session
-        const updatedSession = (0, utils_1.mergeCollected)(session, extractedData);
+        const updatedSession = (0, index_js_1.mergeCollected)(session, extractedData);
         await this.updateCollectedData(extractedData);
         // Determine next step using pipeline method for consistency
         // Pass the current flow/step as the routing result (retained)
@@ -812,11 +923,15 @@ class ResponsePipeline {
             context: params.context,
         });
         return {
-            selectedFlow: stepResult.flowChanged || currentFlow,
-            selectedStep: stepResult.nextStep,
-            responseDirectives: undefined,
-            session: stepResult.session,
-            isFlowComplete: false,
+            extractionRan: true,
+            extractedData,
+            skipResult: {
+                selectedFlow: stepResult.flowChanged || currentFlow,
+                selectedStep: stepResult.nextStep,
+                responseDirectives: undefined,
+                session: stepResult.session,
+                isFlowComplete: stepResult.isFlowComplete,
+            },
         };
     }
     /**
@@ -835,20 +950,43 @@ class ResponsePipeline {
         const hasDataCollectionSteps = steps.some(step => step.collect && step.collect.length > 0);
         return hasDataCollectionSteps;
     }
+    /**
+     * Build an extraction schema limited to the given subset of agent schema
+     * fields. Used by the routing-skip probe so only the current step's collect
+     * fields are visible to the extractor.
+     */
+    buildFieldRestrictedSchema(agentSchema, fields) {
+        const properties = {};
+        for (const field of fields) {
+            const prop = agentSchema.properties?.[field];
+            if (prop) {
+                properties[field] = prop;
+            }
+        }
+        return {
+            type: "object",
+            description: `Extraction restricted to these fields: ${fields.join(', ')}`,
+            properties,
+            additionalProperties: false,
+        };
+    }
     /**
      * Pre-extract data from user message when entering a flow
      * This allows skipping steps whose data is already provided
      */
     async preExtractFlowData(params) {
-        const { route: flow, history, signal } = params;
+        const { route: flow, history, signal, restrictToFields } = params;
         // Build a schema for data extraction based on flow's fields
-        const extractionSchema = this.getSchema();
-        if (!extractionSchema) {
-            utils_1.logger.warn(`[ResponsePipeline] No schema available for pre-extraction`);
+        const agentSchema = this.getSchema();
+        if (!agentSchema) {
+            index_js_1.logger.warn(`[ResponsePipeline] No schema available for pre-extraction`);
             return {};
         }
+        const extractionSchema = restrictToFields
+            ? this.buildFieldRestrictedSchema(agentSchema, restrictToFields)
+            : agentSchema;
         // Get last user message
-        const lastMessage = (0, utils_1.getLastMessageFromHistory)(history);
+        const lastMessage = (0, index_js_1.getLastMessageFromHistory)(history);
         // Build extraction prompt
         const extractionPrompt = [
             `Extract any relevant information from the user's message that matches the following data fields.`,
@@ -859,15 +997,20 @@ class ResponsePipeline {
             `Extract data for these fields if present:`,
         ];
         // Add field descriptions
-        if (flow.requiredFields) {
-            extractionPrompt.push(`Required fields: ${flow.requiredFields.join(', ')}`);
+        if (restrictToFields) {
+            extractionPrompt.push(`Only these fields: ${restrictToFields.join(', ')}`);
         }
-        if (flow.optionalFields) {
-            extractionPrompt.push(`Optional fields: ${flow.optionalFields.join(', ')}`);
+        else {
+            if (flow.requiredFields) {
+                extractionPrompt.push(`Required fields: ${flow.requiredFields.join(', ')}`);
+            }
+            if (flow.optionalFields) {
+                extractionPrompt.push(`Optional fields: ${flow.optionalFields.join(', ')}`);
+            }
         }
         extractionPrompt.push(``, `Return ONLY the extracted data as JSON. If no data can be extracted, return an empty object {}.`);
         // Convert Event[] to HistoryItem[] for provider call
-        const historyItems = (0, utils_1.eventsToHistory)(history);
+        const historyItems = (0, index_js_1.eventsToHistory)(history);
         // Call AI to extract data
         try {
             const result = await this.options.provider.generateMessage({
@@ -886,7 +1029,7 @@ class ResponsePipeline {
             return result.structured || {};
         }
         catch (error) {
-            utils_1.logger.error(`[ResponsePipeline] Pre-extraction failed:`, error);
+            index_js_1.logger.error(`[ResponsePipeline] Pre-extraction failed:`, error);
             return {};
         }
     }