@falai/agent 1.2.8 → 2.0.0

package/dist/core/{RoutingEngine.js → FlowRouter.js}

@@ -1,15 +1,14 @@
 import { MessageRole } from "../types";
-import { enterRoute, mergeCollected } from "../utils";
+import { enterFlow, mergeCollected, isFlowCompletedThisSession } from "../utils";
 import { PromptComposer } from "./PromptComposer";
-import { END_ROUTE_ID } from "../constants";
 import { createTemplateContext, getLastMessageFromHistory, logger, eventsToHistory } from "../utils";
-export class RoutingEngine {
+export class FlowRouter {
     constructor(options) {
         this.options = options;
     }
     /**
      * Check whether the history contains any user messages.
-     * Used to detect "session resume" scenarios where a route/step was
+     * Used to detect "session resume" scenarios where a flow/step was
      * pre-set programmatically and the conversation starts with only
      * system messages (or no messages at all).
      * @private
@@ -19,46 +18,46 @@ export class RoutingEngine {
     }
     /**
      * Handle the "session resume" fast-path: when a session already has a
-     * pre-set currentRoute (and optionally currentStep) and the conversation
+     * pre-set currentFlow (and optionally currentStep) and the conversation
      * history contains no user messages, honor the pre-set position instead
-     * of running AI route/step selection.
+     * of running AI flow/step selection.
      *
      * Returns `undefined` when the fast-path does not apply.
      * @private
      */
     async handleSessionResume(params) {
-        const { routes, session, history, context } = params;
+        const { flows, session, history, context } = params;
         // Fast-path only applies when:
-        // 1. Session already has a currentRoute set
+        // 1. Session already has a currentFlow set
         // 2. There are no user messages in the history (system-only or empty)
-        if (!session.currentRoute || this.hasUserMessages(history)) {
+        if (!session.currentFlow || this.hasUserMessages(history)) {
             return undefined;
         }
-        // Find the pre-set route among available routes
-        const presetRoute = routes.find((r) => r.id === session.currentRoute.id);
-        if (!presetRoute) {
-            logger.warn(`[RoutingEngine] Session resume: pre-set route '${session.currentRoute.id}' not found among available routes, falling back to normal routing`);
+        // Find the pre-set flow among available flows
+        const presetFlow = flows.find((r) => r.id === session.currentFlow.id);
+        if (!presetFlow) {
+            logger.warn(`[FlowConfigurationError] Pre-set flow not found: session references flow "${session.currentFlow.id}" which does not exist among available flows. Falling back to normal routing. Remove the stale session reference or register the missing flow.`);
             return undefined;
         }
-        logger.debug(`[RoutingEngine] Session resume: honoring pre-set route '${presetRoute.title}' (no user messages in history)`);
-        // Enter route if needed (merges initialData, no-op if already entered)
-        const updatedSession = this.enterRouteIfNeeded(session, presetRoute);
-        // Evaluate cross-route completions
-        const completedRoutes = this.evaluateRouteCompletions(routes, updatedSession.data || {});
+        logger.debug(`[FlowRouter] Session resume: honoring pre-set flow '${presetFlow.title}' (no user messages in history)`);
+        // Enter flow if needed (merges initialData, no-op if already entered)
+        const updatedSession = this.enterFlowIfNeeded(session, presetFlow);
+        // Evaluate cross-flow completions
+        const completedFlows = this.evaluateFlowCompletions(flows, updatedSession.data || {});
         // If a currentStep is also pre-set, honor it — stay on that step
         if (session.currentStep) {
-            const presetStep = presetRoute.getStep(session.currentStep.id);
+            const presetStep = presetFlow.getStep(session.currentStep.id);
             if (presetStep) {
-                logger.debug(`[RoutingEngine] Session resume: honoring pre-set step '${presetStep.id}'`);
+                logger.debug(`[FlowRouter] Session resume: honoring pre-set step '${presetStep.id}'`);
                 return {
-                    selectedRoute: presetRoute,
+                    selectedFlow: presetFlow,
                     selectedStep: presetStep,
                     session: updatedSession,
-                    isRouteComplete: false,
-                    completedRoutes,
+                    isFlowComplete: false,
+                    completedFlows,
                 };
             }
-            logger.warn(`[RoutingEngine] Session resume: pre-set step '${session.currentStep.id}' not found in route '${presetRoute.title}', resolving from initial step`);
+            logger.warn(`[FlowConfigurationError] Pre-set step not found: session references step "${session.currentStep.id}" which does not exist in flow "${presetFlow.title}". Resolving from initial step. Remove the stale step reference or register the missing step.`);
         }
         // No currentStep pre-set (or it wasn't found) — resolve from initialStep
         // using the standard candidate logic (handles skipIf, etc.)
@@ -68,67 +67,97 @@ export class RoutingEngine {
             history,
             data: updatedSession.data,
         });
-        const candidates = await this.getCandidateStepsWithConditions(presetRoute, undefined, // No current step — start from beginning
+        const candidates = await this.getCandidateStepsWithConditions(presetFlow, undefined, // No current step — start from beginning
         templateContext);
         if (candidates.length === 0) {
-            logger.warn(`[RoutingEngine] Session resume: no valid steps found for route '${presetRoute.title}'`);
+            logger.warn(`[FlowConfigurationError] No valid steps found: all steps in flow "${presetFlow.title}" are skipped by their conditions. Check skip/when conditions on the flow's steps.`);
             return {
-                selectedRoute: presetRoute,
+                selectedFlow: presetFlow,
                 selectedStep: undefined,
                 session: updatedSession,
-                isRouteComplete: false,
-                completedRoutes,
+                isFlowComplete: false,
+                completedFlows,
             };
         }
         const candidate = candidates[0];
-        if (candidate.isRouteComplete) {
-            logger.debug(`[RoutingEngine] Session resume: route '${presetRoute.title}' is already complete`);
+        if (candidate.isFlowComplete) {
+            logger.debug(`[FlowRouter] Session resume: flow '${presetFlow.title}' is already complete`);
             return {
-                selectedRoute: presetRoute,
+                selectedFlow: presetFlow,
                 selectedStep: undefined,
                 session: updatedSession,
-                isRouteComplete: true,
-                completedRoutes,
+                isFlowComplete: true,
+                completedFlows,
             };
         }
-        logger.debug(`[RoutingEngine] Session resume: resolved initial step '${candidate.step.id}'`);
+        logger.debug(`[FlowRouter] Session resume: resolved initial step '${candidate.step.id}'`);
         return {
-            selectedRoute: presetRoute,
+            selectedFlow: presetFlow,
             selectedStep: candidate.step,
             session: updatedSession,
-            isRouteComplete: false,
-            completedRoutes,
+            isFlowComplete: false,
+            completedFlows,
         };
     }
     /**
-     * Enter a route if not already in it, merging initial data
+     * Enter a flow if not already in it, merging initial data.
+     *
+     * When the flow is `reentrant` and was previously completed in this
+     * session, clears every field declared in the flow's `requiredFields`
+     * and `optionalFields` before entering — so the flow starts fresh from
+     * its initial step instead of being instantly marked complete by stale
+     * data. Fields not owned by this flow are preserved.
+     *
      * @private
      */
-    enterRouteIfNeeded(session, route) {
-        if (!session.currentRoute || session.currentRoute.id !== route.id) {
-            let updatedSession = enterRoute(session, route.id, route.title);
+    enterFlowIfNeeded(session, route) {
+        if (!session.currentFlow || session.currentFlow.id !== route.id) {
+            let workingSession = session;
+            // Re-entry into a `reentrant` flow that previously completed:
+            // clear owned fields so completion logic doesn't short-circuit on
+            // stale data from the prior run.
+            const previouslyCompleted = isFlowCompletedThisSession(session, route.id);
+            if (previouslyCompleted && route.reentrant) {
+                const ownedFields = [
+                    ...(route.requiredFields ?? []),
+                    ...(route.optionalFields ?? []),
+                ];
+                if (ownedFields.length > 0) {
+                    const owned = new Set(ownedFields);
+                    const filtered = {};
+                    for (const key of Object.keys(session.data ?? {})) {
+                        if (!owned.has(key)) {
+                            filtered[key] =
+                                session.data[key];
+                        }
+                    }
+                    workingSession = { ...session, data: filtered };
+                    logger.debug(`[FlowRouter] Re-entering reentrant flow ${route.title}: cleared ${ownedFields.length} owned field(s)`);
+                }
+            }
+            let updatedSession = enterFlow(workingSession, route.id, route.title);
             if (route.initialData) {
                 updatedSession = mergeCollected(updatedSession, route.initialData);
-                logger.debug(`[RoutingEngine] Merged initial data for route ${route.title}:`, route.initialData);
+                logger.debug(`[FlowRouter] Merged initial data for flow ${route.title}:`, route.initialData);
             }
-            logger.debug(`[RoutingEngine] Entered route: ${route.title}`);
-            this.options?.onRouteSwitch?.();
+            logger.debug(`[FlowRouter] Entered flow: ${route.title}`);
+            this.options?.onFlowSwitch?.();
             return updatedSession;
         }
         return session;
     }
     /**
-     * Optimized decision for single-route scenarios
-     * Skips route scoring and only does step selection
+     * Optimized decision for single-flow scenarios
+     * Skips flow scoring and only does step selection
      * @private
      */
-    async decideSingleRouteStep(params) {
+    async decideSingleFlowStep(params) {
         const { route, session, history, agentOptions, provider, context, signal } = params;
-        const selectedRoute = route;
-        // Enter route if not already in it (this may merge initial data)
-        const updatedSession = this.enterRouteIfNeeded(session, route);
-        // Check if this single route is complete (use updated session data)
-        const completedRoutes = route.isComplete(updatedSession.data || {}) ? [route] : [];
+        const selectedFlow = route;
+        // Enter flow if not already in it (this may merge initial data)
+        const updatedSession = this.enterFlowIfNeeded(session, route);
+        // Check if this single flow is complete (use updated session data)
+        const completedFlows = route.isComplete(updatedSession.data || {}) ? [route] : [];
         // Get candidate steps using new condition evaluation
         const templateContext = createTemplateContext({
             context,
@@ -141,44 +170,43 @@ export class RoutingEngine {
             : undefined;
         const candidates = await this.getCandidateStepsWithConditions(route, currentStep, templateContext);
         if (candidates.length === 0) {
-            logger.warn(`[RoutingEngine] Single-route: No valid steps found`);
-            return { selectedRoute, session: updatedSession };
+            logger.warn(`[FlowConfigurationError] No valid steps found: all candidates in the single-flow agent are skipped. Check step skip/when conditions.`);
+            return { selectedFlow, session: updatedSession };
         }
         // If only one candidate, check if it's a completion marker
         if (candidates.length === 1) {
             const candidate = candidates[0];
-            if (candidate.isRouteComplete) {
-                logger.debug(`[RoutingEngine] Single-route: Route complete - all required fields collected or END_ROUTE reached`);
-                // Don't return a selectedStep when route is complete - there's no step to enter
+            if (candidate.isFlowComplete) {
+                logger.debug(`[FlowRouter] Single-flow: Flow complete - all required fields collected or last step reached`);
+                // Don't return a selectedStep when flow is complete - there's no step to enter
                 return {
-                    selectedRoute,
+                    selectedFlow,
                     selectedStep: undefined,
                     session: updatedSession,
-                    isRouteComplete: true,
-                    completedRoutes,
+                    isFlowComplete: true,
+                    completedFlows,
                 };
             }
             else {
-                logger.debug(`[RoutingEngine] Single-route: Only one valid step: ${candidate.step.id}`);
+                logger.debug(`[FlowRouter] Single-flow: Only one valid step: ${candidate.step.id}`);
                 return {
-                    selectedRoute,
+                    selectedFlow,
                     selectedStep: candidate.step,
                     session: updatedSession,
-                    isRouteComplete: false,
-                    completedRoutes,
+                    isFlowComplete: false,
+                    completedFlows,
                 };
             }
         }
-        // No candidates means route has no valid next steps (edge case)
-        // Don't mark as complete based on data alone — only END_ROUTE completes a route
+        // No candidates means flow has no valid next steps (edge case)
         if (candidates.length === 0) {
-            logger.debug(`[RoutingEngine] Single-route: No valid candidate steps found`);
+            logger.debug(`[FlowRouter] Single-flow: No valid candidate steps found`);
             return {
-                selectedRoute,
+                selectedFlow,
                 selectedStep: undefined,
                 session: updatedSession,
-                isRouteComplete: false,
-                completedRoutes,
+                isFlowComplete: false,
+                completedFlows,
             };
         }
         // Multiple candidates - use AI to select best step
@@ -189,10 +217,10 @@ export class RoutingEngine {
             const whenResult = await candidate.step.evaluateWhen(templateContext);
             stepConditionContext.push(...whenResult.aiContextStrings);
         }
-        // Check if any candidate is a completion marker (isRouteComplete = true)
-        const hasCompletionOption = candidates.some(c => c.isRouteComplete);
+        // Check if any candidate is a completion marker (isFlowComplete = true)
+        const hasCompletionOption = candidates.some(c => c.isFlowComplete);
         const stepPrompt = await this.buildStepSelectionPrompt({
-            route,
+            flow: route,
             currentStep,
             candidates,
             data: updatedSession.data || {},
@@ -202,9 +230,9 @@ export class RoutingEngine {
             context,
             session: updatedSession,
             stepConditionContext,
-            includeEndRoute: hasCompletionOption,
+            includeCompletion: hasCompletionOption,
         });
-        const stepSchema = this.buildStepSelectionSchema(candidates.filter(c => !c.isRouteComplete).map((c) => c.step), hasCompletionOption);
+        const stepSchema = this.buildStepSelectionSchema(candidates.filter(c => !c.isFlowComplete).map((c) => c.step), hasCompletionOption);
         const stepResult = await provider.generateMessage({
             prompt: stepPrompt,
             history: eventsToHistory(history),
@@ -216,37 +244,37 @@ export class RoutingEngine {
             },
         });
         const selectedStepId = stepResult.structured?.selectedStepId;
-        // Check if AI selected END_ROUTE
-        if (selectedStepId === END_ROUTE_ID) {
-            logger.debug(`[RoutingEngine] Single-route: AI selected END_ROUTE - completing route`);
-            logger.debug(`[RoutingEngine] Single-route: Reasoning: ${stepResult.structured?.reasoning}`);
+        // Check if AI selected flow completion
+        if (selectedStepId === '__COMPLETE__') {
+            logger.debug(`[FlowRouter] Single-flow: AI selected flow completion`);
+            logger.debug(`[FlowRouter] Single-flow: Reasoning: ${stepResult.structured?.reasoning}`);
             return {
-                selectedRoute,
+                selectedFlow,
                 selectedStep: undefined,
                 responseDirectives: stepResult.structured?.responseDirectives,
                 session: updatedSession,
-                isRouteComplete: true,
-                completedRoutes,
+                isFlowComplete: true,
+                completedFlows,
             };
         }
         const selectedStep = candidates.find((c) => c.step.id === selectedStepId);
         if (selectedStep) {
-            logger.debug(`[RoutingEngine] Single-route: AI selected step: ${selectedStep.step.id}`);
-            logger.debug(`[RoutingEngine] Single-route: Reasoning: ${stepResult.structured?.reasoning}`);
+            logger.debug(`[FlowRouter] Single-flow: AI selected step: ${selectedStep.step.id}`);
+            logger.debug(`[FlowRouter] Single-flow: Reasoning: ${stepResult.structured?.reasoning}`);
         }
         else {
-            logger.warn(`[RoutingEngine] Single-route: Invalid step ID returned, using first candidate`);
+            logger.warn(`[FlowConfigurationError] Invalid step ID returned: AI router returned a step ID that does not match any candidate. Falling back to first candidate. Check flow step ids and router configuration.`);
         }
         return {
-            selectedRoute,
+            selectedFlow,
             selectedStep: selectedStep?.step || candidates[0].step,
             responseDirectives: stepResult.structured?.responseDirectives,
             session: updatedSession,
-            completedRoutes,
+            completedFlows,
         };
     }
     /**
-     * Recursively traverse step chain to find first non-skipped step or END_ROUTE using new condition evaluation
+     * Recursively traverse step chain to find first non-skipped step using new condition evaluation
      * @private
      */
     async findFirstValidStepRecursiveWithConditions(currentStep, templateContext, visited) {
@@ -257,76 +285,78 @@ export class RoutingEngine {
         visited.add(currentStep.id);
         const transitions = currentStep.getTransitions();
         const allAiContextStrings = [];
+        // No transitions means implicit terminus — flow is complete
+        if (transitions.length === 0) {
+            return {
+                isFlowComplete: true,
+                aiContextStrings: allAiContextStrings,
+            };
+        }
         for (const transition of transitions) {
             const target = transition;
-            // Check for END_ROUTE transition
-            if (target && target.id === END_ROUTE_ID) {
-                // Found END_ROUTE - route is complete
-                return {
-                    isRouteComplete: true,
-                    aiContextStrings: allAiContextStrings,
-                };
-            }
             if (!target)
                 continue;
-            // Evaluate skipIf condition using new system
-            const skipResult = await target.evaluateSkipIf(templateContext);
+            // Evaluate skip condition (code-only, if-shape)
+            const skipResult = await target.evaluateSkip(templateContext);
             allAiContextStrings.push(...skipResult.aiContextStrings);
             // If target should NOT be skipped, we found our step
             if (!skipResult.shouldSkip) {
-                logger.debug(`[RoutingEngine] Found valid step after skipping: ${target.id}`);
+                logger.debug(`[FlowRouter] Found valid step after skipping: ${target.id}`);
                 return {
                     step: target,
-                    isRouteComplete: false,
+                    isFlowComplete: false,
                     aiContextStrings: allAiContextStrings,
                 };
             }
             // Target should be skipped too - recurse deeper
-            logger.debug(`[RoutingEngine] Skipping step ${target.id} (skipIf condition met), continuing traversal...`);
+            logger.debug(`[FlowRouter] Skipping step ${target.id} (skipIf condition met), continuing traversal...`);
             const result = await this.findFirstValidStepRecursiveWithConditions(target, templateContext, visited);
             // Collect AI context from recursive call
             if (result.aiContextStrings) {
                 allAiContextStrings.push(...result.aiContextStrings);
             }
-            // If we found something (a valid step or END_ROUTE), return it
-            if (result.step || result.isRouteComplete) {
+            // If we found something (a valid step or flow complete), return it
+            if (result.step || result.isFlowComplete) {
                 return {
                     ...result,
                     aiContextStrings: allAiContextStrings,
                 };
             }
         }
-        // No valid steps or END_ROUTE found in this branch
-        return { aiContextStrings: allAiContextStrings };
+        // No valid steps found in this branch — all skipped with no further transitions
+        return {
+            isFlowComplete: true,
+            aiContextStrings: allAiContextStrings,
+        };
     }
     /**
      * Identify valid next candidate steps using new condition evaluation system
-     * Returns step with isRouteComplete flag if route is complete (all steps skipped + has END_ROUTE transition)
+     * Returns step with isFlowComplete flag if flow is complete (all steps skipped or no transitions remain)
      *
-     * NEW: Automatically completes route when all required fields are collected
+     * Flow completion is implicit: when the last step has no transitions, the flow is done.
      */
     async getCandidateStepsWithConditions(route, currentStep, templateContext) {
         const candidates = [];
         if (!currentStep) {
-            // Entering route for the first time — always start the step flow
+            // Entering flow for the first time — always start the step flow
             const initialStep = route.initialStep;
-            const skipResult = await initialStep.evaluateSkipIf(templateContext);
+            const skipResult = await initialStep.evaluateSkip(templateContext);
             if (skipResult.shouldSkip) {
-                // Initial step should be skipped - recursively traverse to find first non-skipped step or END_ROUTE
+                // Initial step should be skipped - recursively traverse to find first non-skipped step
                 const result = await this.findFirstValidStepRecursiveWithConditions(initialStep, templateContext, new Set());
-                if (result.isRouteComplete) {
-                    // All steps are skipped and we reached END_ROUTE
-                    logger.debug(`[RoutingEngine] Route complete on entry: all steps skipped, END_ROUTE reached`);
+                if (result.isFlowComplete) {
+                    // All steps are skipped and no transitions remain
+                    logger.debug(`[FlowRouter] Flow complete on entry: all steps skipped, no transitions remain`);
                     candidates.push({
                         step: initialStep,
-                        isRouteComplete: true,
+                        isFlowComplete: true,
                     });
                 }
                 else if (result.step) {
                     // Found a non-skipped step
                     candidates.push({
                         step: result.step,
-                        isRouteComplete: result.isRouteComplete || false,
+                        isFlowComplete: result.isFlowComplete || false,
                     });
                 }
                 // If no step found and not complete, fall through to return empty candidates
@@ -334,87 +364,84 @@ export class RoutingEngine {
             else {
                 candidates.push({
                     step: initialStep,
-                    isRouteComplete: false,
+                    isFlowComplete: false,
                 });
             }
             return candidates;
         }
-        // Continue normal step progression — routes complete via END_ROUTE, not via data collection
+        // Continue normal step progression — flows complete when last step has no transitions (implicit terminus)
         const transitions = currentStep.getTransitions();
-        let hasEndRoute = false;
+        // No transitions means this is the last step — flow is complete
+        if (transitions.length === 0) {
+            logger.debug(`[FlowRouter] Flow complete: current step has no transitions (implicit terminus)`);
+            return [
+                {
+                    step: currentStep,
+                    isFlowComplete: true,
+                },
+            ];
+        }
         for (const transition of transitions) {
             const target = transition;
-            // Check for END_ROUTE transition (no target step)
-            if (target && target.id === END_ROUTE_ID) {
-                hasEndRoute = true;
-                continue;
-            }
             if (!target)
                 continue;
-            const skipResult = await target.evaluateSkipIf(templateContext);
+            const skipResult = await target.evaluateSkip(templateContext);
             if (skipResult.shouldSkip) {
-                logger.debug(`[RoutingEngine] Skipping step ${target.id} (skipIf condition met)`);
-                // Recursively traverse to find next valid step or END_ROUTE
+                logger.debug(`[FlowRouter] Skipping step ${target.id} (skip condition met)`);
+                // Recursively traverse to find next valid step
                 const result = await this.findFirstValidStepRecursiveWithConditions(target, templateContext, new Set([currentStep.id]) // Already visited current step
                 );
-                if (result.isRouteComplete) {
-                    hasEndRoute = true;
+                if (result.isFlowComplete) {
+                    // All forward paths lead to terminus
+                    candidates.push({
+                        step: currentStep,
+                        isFlowComplete: true,
+                    });
                 }
                 else if (result.step) {
                     // Found a non-skipped step deeper in the chain
                     candidates.push({
                         step: result.step,
-                        isRouteComplete: result.isRouteComplete || false,
+                        isFlowComplete: false,
                     });
                 }
                 continue;
             }
             candidates.push({
                 step: target,
-                isRouteComplete: hasEndRoute || false,
+                isFlowComplete: false,
             });
         }
-        // If no valid candidates found
+        // If no valid candidates found after evaluating all transitions
         if (candidates.length === 0) {
-            // If current step has END_ROUTE transition, the route is complete
-            if (hasEndRoute) {
-                logger.debug(`[RoutingEngine] Route complete: all steps processed, END_ROUTE reached`);
-                // Return current step with completion flag
-                return [
-                    {
-                        step: currentStep,
-                        isRouteComplete: true,
-                    },
-                ];
-            }
-            // Otherwise, stay in current step if it's still valid
-            const currentSkipResult = await currentStep.evaluateSkipIf(templateContext);
-            if (!currentSkipResult.shouldSkip) {
-                candidates.push({
+            // All transitions were skipped — flow is complete
+            logger.debug(`[FlowRouter] Flow complete: all transitions skipped`);
+            return [
+                {
                     step: currentStep,
-                    isRouteComplete: hasEndRoute || false,
-                });
-            }
+                    isFlowComplete: true,
+                },
+            ];
         }
         return candidates;
     }
     /**
      * Full routing orchestration: builds prompt and schema, calls AI, selects route/step,
-     * and updates the session (including initialData merge when entering a new route).
+     * and updates the session (including initialData merge when entering a new flow).
      *
      * OPTIMIZATION: If there's only 1 route, skips route scoring and only does step selection.
-     * CROSS-ROUTE COMPLETION: Evaluates all routes for completion based on collected data.
+     * CROSS-FLOW COMPLETION: Evaluates all flows for completion based on collected data.
      */
-    async decideRouteAndStep(params) {
-        const { routes, session, history, agentOptions, provider, context, signal, } = params;
-        if (routes.length === 0) {
+    async decideFlowAndStep(params) {
+        const { flows, session, history, agentOptions, provider, context, signal, } = params;
+        if (flows.length === 0) {
             return { session };
         }
-        // SESSION RESUME: If the session has a pre-set route and there are no user
+        // SESSION RESUME: If the session has a pre-set flow and there are no user
         // messages in the history, honor the pre-set position without AI routing.
         // This supports programmatic session setup and persistence-based resume.
         const resumeResult = await this.handleSessionResume({
-            routes,
+            flows,
             session,
             history,
             context,
@@ -422,16 +449,24 @@ export class RoutingEngine {
         if (resumeResult) {
             return resumeResult;
         }
-        // CROSS-ROUTE COMPLETION EVALUATION: Check all routes for completion
-        const completedRoutes = this.evaluateRouteCompletions(routes, session.data || {});
-        // Log completed routes
-        if (completedRoutes.length > 0) {
-            logger.debug(`[RoutingEngine] Found ${completedRoutes.length} completed routes: ${completedRoutes.map(r => r.title).join(', ')}`);
-        }
-        // OPTIMIZATION: Single route - skip route scoring, only do step selection
-        if (routes.length === 1) {
-            const result = await this.decideSingleRouteStep({
-                route: routes[0],
+        // Exclude flows that completed earlier in this session unless explicitly
+        // re-entrant. A completed flow surrenders the conversation back to
+        // routing — it cannot be re-selected without `flow.reentrant: true`.
+        const reEntryFiltered = flows.filter((f) => !isFlowCompletedThisSession(session, f.id) || f.reentrant === true);
+        const excludedFlows = flows.length - reEntryFiltered.length;
+        if (excludedFlows > 0) {
+            logger.debug(`[FlowRouter] Excluded ${excludedFlows} completed (non-reentrant) flow(s) from routing candidates`);
+        }
+        // CROSS-FLOW COMPLETION EVALUATION: Check all eligible flows for completion
+        const completedFlows = this.evaluateFlowCompletions(reEntryFiltered, session.data || {});
+        // Log completed flows
+        if (completedFlows.length > 0) {
+            logger.debug(`[FlowRouter] Found ${completedFlows.length} completed routes: ${completedFlows.map(r => r.title).join(', ')}`);
+        }
+        // OPTIMIZATION: Single flow - skip flow scoring, only do step selection
+        if (reEntryFiltered.length === 1) {
+            const result = await this.decideSingleFlowStep({
+                route: reEntryFiltered[0],
                 session,
                 history,
                 agentOptions,
@@ -441,9 +476,15 @@ export class RoutingEngine {
             });
             return {
                 ...result,
-                completedRoutes,
+                completedFlows,
             };
         }
+        // No eligible flows after re-entry filtering — caller falls back to the
+        // generic non-flow response path.
+        if (reEntryFiltered.length === 0) {
+            logger.debug(`[FlowRouter] All flows completed and none are reentrant — releasing session to fallback`);
+            return { session, completedFlows };
+        }
         const lastUserMessage = getLastMessageFromHistory(history);
         const templateContext = createTemplateContext({
             context,
@@ -451,56 +492,55 @@ export class RoutingEngine {
             history,
             data: session.data
         });
-        // Apply route filtering with new condition evaluation system
-        const skipIfResult = await this.filterRoutesBySkipIf(routes, templateContext);
-        const whenResult = await this.filterRoutesByWhen(skipIfResult.eligibleRoutes, templateContext);
-        // Use filtered routes for further processing
+        // Apply flow filtering with new condition evaluation system
+        const whenResult = await this.filterFlowsByWhen(reEntryFiltered, templateContext);
+        // Use filtered flows for further processing
         const eligibleRoutes = whenResult.eligibleRoutes;
-        logger.debug(`[RoutingEngine] Route filtering: ${routes.length} total → ${skipIfResult.eligibleRoutes.length} after skipIf → ${eligibleRoutes.length} after when`);
-        let activeRouteSteps;
-        let activeRoute;
-        let isRouteComplete = false;
+        logger.debug(`[FlowRouter] Flow filtering: ${flows.length} total → ${reEntryFiltered.length} after re-entry filter → ${eligibleRoutes.length} after when`);
+        let activeFlowSteps;
+        let activeFlow;
+        let isFlowComplete = false;
         let updatedSession = session;
-        if (session.currentRoute) {
-            activeRoute = eligibleRoutes.find((r) => r.id === session.currentRoute?.id);
-            if (activeRoute) {
+        if (session.currentFlow) {
+            activeFlow = eligibleRoutes.find((r) => r.id === session.currentFlow?.id);
+            if (activeFlow) {
                 const currentStep = session.currentStep
-                    ? activeRoute.getStep(session.currentStep.id)
+                    ? activeFlow.getStep(session.currentStep.id)
                     : undefined;
                 const activeTemplateContext = createTemplateContext({
                     ...templateContext,
                     session: updatedSession,
                     data: updatedSession.data
                 });
-                const candidates = await this.getCandidateStepsWithConditions(activeRoute, currentStep, activeTemplateContext);
-                // Check if route is complete
+                const candidates = await this.getCandidateStepsWithConditions(activeFlow, currentStep, activeTemplateContext);
+                // Check if flow is complete
                 // getCandidateStepsWithConditions now automatically handles completion when required fields are collected
-                if (candidates.length === 1 && candidates[0].isRouteComplete) {
-                    isRouteComplete = true;
-                    logger.debug(`[RoutingEngine] Route ${activeRoute.title} is complete - all required fields collected or END_ROUTE reached`);
+                if (candidates.length === 1 && candidates[0].isFlowComplete) {
+                    isFlowComplete = true;
+                    logger.debug(`[FlowRouter] Flow ${activeFlow.title} is complete - all required fields collected or last step reached`);
                     // Don't include steps in routing if route is complete
-                    activeRouteSteps = undefined;
+                    activeFlowSteps = undefined;
                 }
                 else if (candidates.length === 0) {
-                    // No candidates available — don't end route based on data alone
-                    logger.debug(`[RoutingEngine] Route ${activeRoute.title} has no valid candidate steps`);
-                    activeRouteSteps = undefined;
+                    // No candidates available — don't end flow based on data alone
+                    logger.debug(`[FlowRouter] Flow ${activeFlow.title} has no valid candidate steps`);
+                    activeFlowSteps = undefined;
                 }
                 else {
                     // Multiple candidates or single non-complete candidate
-                    activeRouteSteps = candidates.map((c) => c.step);
-                    logger.debug(`[RoutingEngine] Found ${activeRouteSteps.length} candidate steps for active route`);
+                    activeFlowSteps = candidates.map((c) => c.step);
+                    logger.debug(`[FlowRouter] Found ${activeFlowSteps.length} candidate steps for active route`);
                 }
             }
         }
-        const routingSchema = this.buildDynamicRoutingSchema(eligibleRoutes, undefined, activeRouteSteps);
+        const routingSchema = this.buildDynamicFlowSchema(eligibleRoutes, undefined, activeFlowSteps);
         const routingPrompt = await this.buildRoutingPrompt({
             history,
-            routes: eligibleRoutes,
+            flows: eligibleRoutes,
             lastMessage: lastUserMessage,
             agentOptions,
             session,
-            activeRouteSteps,
+            activeFlowSteps,
             context,
         });
         const routingResult = await provider.generateMessage({
@@ -513,115 +553,92 @@ export class RoutingEngine {
                 schemaName: "routing_output",
             },
         });
-        let selectedRoute;
+        let selectedFlow;
         let selectedStep;
         let responseDirectives;
-        if (routingResult.structured?.routes) {
-            // Use cross-route completion evaluation to select optimal route
-            const optimalRoute = this.selectOptimalRoute(eligibleRoutes, updatedSession.data || {}, routingResult.structured.routes, updatedSession.currentRoute?.id);
-            // If no optimal route found, check why
+        if (routingResult.structured?.flows) {
+            // Use cross-flow completion evaluation to select optimal flow
+            const optimalRoute = this.selectOptimalFlow(eligibleRoutes, updatedSession.data || {}, routingResult.structured.flows, updatedSession.currentFlow?.id);
+            // If no optimal flow found, check why
             if (!optimalRoute) {
                 if (eligibleRoutes.length === 0) {
-                    // No routes passed filtering
-                    logger.debug(`[RoutingEngine] No eligible routes available - all routes filtered out`);
-                    selectedRoute = undefined;
+                    // No flows passed filtering
+                    logger.debug(`[FlowRouter] No eligible flows available - all flows filtered out`);
+                    selectedFlow = undefined;
                 }
                 else {
-                    // Routes exist but selectOptimalRoute returned undefined
-                    // This means all routes are 100% complete
-                    logger.debug(`[RoutingEngine] No optimal route found - all ${eligibleRoutes.length} eligible routes are complete`);
-                    selectedRoute = undefined;
+                    // Routes exist but selectOptimalFlow returned undefined
+                    // This means all flows are 100% complete
+                    logger.debug(`[FlowRouter] No optimal route found - all ${eligibleRoutes.length} eligible routes are complete`);
+                    selectedFlow = undefined;
                 }
             }
             else {
-                selectedRoute = optimalRoute;
+                selectedFlow = optimalRoute;
             }
             responseDirectives = routingResult.structured.responseDirectives;
-            if (selectedRoute === activeRoute &&
+            if (selectedFlow === activeFlow &&
                 routingResult.structured.selectedStepId &&
-                activeRoute) {
-                selectedStep = activeRoute.getStep(routingResult.structured.selectedStepId);
+                activeFlow) {
+                selectedStep = activeFlow.getStep(routingResult.structured.selectedStepId);
                 if (selectedStep) {
-                    logger.debug(`[RoutingEngine] AI selected step: ${selectedStep.id} in active route`);
-                    logger.debug(`[RoutingEngine] Step reasoning: ${routingResult.structured.stepReasoning}`);
+                    logger.debug(`[FlowRouter] AI selected step: ${selectedStep.id} in active route`);
+                    logger.debug(`[FlowRouter] Step reasoning: ${routingResult.structured.stepReasoning}`);
                 }
             }
-            if (selectedRoute) {
-                logger.debug(`[RoutingEngine] Selected route: ${selectedRoute.title}`);
-                updatedSession = this.enterRouteIfNeeded(updatedSession, selectedRoute);
+            if (selectedFlow) {
+                logger.debug(`[FlowRouter] Selected route: ${selectedFlow.title}`);
+                updatedSession = this.enterFlowIfNeeded(updatedSession, selectedFlow);
             }
         }
         return {
-            selectedRoute,
+            selectedFlow,
             selectedStep,
             responseDirectives,
             session: updatedSession,
-            isRouteComplete,
-            completedRoutes,
+            isFlowComplete,
+            completedFlows,
         };
     }
     /**
-     * Filter routes based on skipIf conditions
-     * @param routes - All available routes
-     * @param templateContext - Context for condition evaluation
-     * @returns Object with eligible routes and collected AI context strings
-     */
-    async filterRoutesBySkipIf(routes, templateContext) {
-        const eligibleRoutes = [];
-        const aiContextStrings = [];
-        for (const route of routes) {
-            const skipResult = await route.evaluateSkipIf(templateContext);
-            // Collect AI context strings from skipIf conditions
-            aiContextStrings.push(...skipResult.aiContextStrings);
-            // If route should not be skipped, it's eligible
-            if (!skipResult.programmaticResult) {
-                eligibleRoutes.push(route);
-            }
-            else {
-                logger.debug(`[RoutingEngine] Skipping route ${route.title} (skipIf condition met)`);
-            }
-        }
-        return { eligibleRoutes, aiContextStrings };
-    }
-    /**
-     * Filter routes based on when conditions
-     * @param routes - Routes that passed skipIf filtering
+     * Filter flows based on when conditions
+     * @param routes - Flows that passed skipIf filtering
      * @param templateContext - Context for condition evaluation
-     * @returns Object with eligible routes and collected AI context strings
+     * @returns Object with eligible flows and collected AI context strings
      */
-    async filterRoutesByWhen(routes, templateContext) {
+    async filterFlowsByWhen(routes, templateContext) {
         const eligibleRoutes = [];
         const aiContextStrings = [];
         for (const route of routes) {
             const whenResult = await route.evaluateWhen(templateContext);
             // Collect AI context strings from when conditions
             aiContextStrings.push(...whenResult.aiContextStrings);
-            // If route has no programmatic conditions or they evaluate to true, it's eligible
+            // If flow has no programmatic conditions or they evaluate to true, it's eligible
             if (!whenResult.hasProgrammaticConditions || whenResult.programmaticResult) {
                 eligibleRoutes.push(route);
             }
             else {
-                logger.debug(`[RoutingEngine] Route ${route.title} not eligible (when condition not met)`);
+                logger.debug(`[FlowRouter] Flow ${route.title} not eligible (when condition not met)`);
             }
         }
         return { eligibleRoutes, aiContextStrings };
     }
     /**
-     * Evaluate all routes for completion based on collected data
-     * @param routes - All available routes
+     * Evaluate all flows for completion based on collected data
+     * @param routes - All available flows
      * @param data - Currently collected agent-level data
-     * @returns Array of routes that are complete
+     * @returns Array of flows that are complete
      */
-    evaluateRouteCompletions(routes, data) {
+    evaluateFlowCompletions(routes, data) {
         return routes.filter(route => route.isComplete(data));
     }
     /**
-     * Get completion status for all routes
-     * @param routes - All available routes
+     * Get completion status for all flows
+     * @param routes - All available flows
      * @param data - Currently collected agent-level data
-     * @returns Map of route ID to completion progress (0-1)
+     * @returns Map of flow ID to completion progress (0-1)
      */
-    getRouteCompletionStatus(routes, data) {
+    getFlowCompletionStatus(routes, data) {
         const completionStatus = new Map();
         for (const route of routes) {
             const progress = route.getCompletionProgress(data);
@@ -630,28 +647,28 @@ export class RoutingEngine {
         return completionStatus;
     }
     /**
-     * Find the best route to continue based on completion status and user intent
-     * Prioritizes routes that are partially complete but not finished
-     * IMPORTANT: Completed routes are excluded to prevent re-entering finished tasks
-     * @param routes - All available routes
+     * Find the best flow to continue based on completion status and user intent
+     * Prioritizes flows that are partially complete but not finished
+     * IMPORTANT: Completed flows are excluded to prevent re-entering finished tasks
+     * @param routes - All available flows
      * @param data - Currently collected agent-level data
      * @param routeScores - AI-generated route scores from routing decision
-     * @returns Route that should be prioritized for continuation
+     * @returns Flow that should be prioritized for continuation
      */
-    selectOptimalRoute(routes, data, routeScores, currentRouteId) {
-        const completionStatus = this.getRouteCompletionStatus(routes, data);
-        const switchMargin = this.options?.routeSwitchMargin ?? 15;
+    selectOptimalFlow(routes, data, routeScores, currentRouteId) {
+        const completionStatus = this.getFlowCompletionStatus(routes, data);
+        const switchMargin = this.options?.flowSwitchMargin ?? 15;
         // Create weighted scores combining AI intent scores with completion progress
         const weightedScores = [];
         for (const route of routes) {
             const aiScore = routeScores[route.id] || 0;
             const completionProgress = completionStatus.get(route.id) || 0;
-            // ALWAYS skip fully completed routes to prevent re-entering finished tasks
+            // ALWAYS skip fully completed flows to prevent re-entering finished tasks
             if (completionProgress >= 1.0) {
-                logger.debug(`[RoutingEngine] Excluding completed route: ${route.title} (100% complete)`);
+                logger.debug(`[FlowRouter] Excluding completed flow: ${route.title} (100% complete)`);
                 continue;
             }
-            // Boost partially complete routes that match user intent
+            // Boost partially complete flows that match user intent
             let weightedScore = aiScore;
             if (completionProgress > 0 && completionProgress < 1.0) {
                 weightedScore += (completionProgress * 20); // Up to 20 point boost
@@ -664,48 +681,48 @@ export class RoutingEngine {
             return undefined;
         }
         // Apply sticky routing: if there's a current route, only switch if the
-        // best alternative exceeds the current route's score by the configured margin
+        // best alternative exceeds the current flow's score by the configured margin
         if (currentRouteId) {
             const currentEntry = weightedScores.find(e => e.route.id === currentRouteId);
             const bestEntry = weightedScores[0];
             if (currentEntry && bestEntry.route.id !== currentRouteId) {
                 if (bestEntry.score < currentEntry.score + switchMargin) {
-                    logger.debug(`[RoutingEngine] Staying on current route: ${currentEntry.route.title} ` +
+                    logger.debug(`[FlowRouter] Staying on current flow: ${currentEntry.route.title} ` +
                         `(current: ${currentEntry.score}, best alternative: ${bestEntry.score}, ` +
                         `margin required: ${switchMargin})`);
                     return currentEntry.route;
                 }
-                logger.debug(`[RoutingEngine] Switching route: ${currentEntry.route.title} → ${bestEntry.route.title} ` +
+                logger.debug(`[FlowRouter] Switching flow: ${currentEntry.route.title} → ${bestEntry.route.title} ` +
                     `(current: ${currentEntry.score}, alternative: ${bestEntry.score}, ` +
                     `margin: ${switchMargin})`);
             }
         }
-        logger.debug(`[RoutingEngine] Selected optimal route: ${weightedScores[0].route.title} ` +
+        logger.debug(`[FlowRouter] Selected optimal route: ${weightedScores[0].route.title} ` +
             `(AI: ${routeScores[weightedScores[0].route.id]}, ` +
             `Completion: ${(completionStatus.get(weightedScores[0].route.id) || 0) * 100}%, ` +
             `Weighted: ${weightedScores[0].score})`);
         return weightedScores[0].route;
     }
     /**
-     * Build prompt for step selection within a single route
+     * Build prompt for step selection within a single flow
      * @private
      */
     async buildStepSelectionPrompt(params) {
-        const { route, currentStep, candidates, data, history, lastMessage, agentOptions, context, session, stepConditionContext, includeEndRoute = false, } = params;
+        const { flow: route, currentStep, candidates, data, history, lastMessage, agentOptions, context, session, stepConditionContext, includeCompletion = false, } = params;
         const templateContext = createTemplateContext({ context, session, history });
         const pc = new PromptComposer(templateContext, this.options?.promptSectionCache);
         // Add agent metadata
         if (agentOptions) {
             await pc.addAgentMeta(agentOptions);
         }
-        // Add route context
-        await pc.addInstruction(`Active Route: ${route.title}\nDescription: ${route.description || "N/A"}`);
+        // Add flow context
+        await pc.addInstruction(`Active Flow: ${route.title}\nDescription: ${route.description || "N/A"}`);
         // Add current step context
         if (currentStep) {
             await pc.addInstruction(`Current Step: ${currentStep.id}\nDescription: ${currentStep.description || "N/A"}`);
         }
         else {
-            await pc.addInstruction("Current Step: None (entering route)");
+            await pc.addInstruction("Current Step: None (entering flow)");
         }
         // Add collected data context
         if (Object.keys(data).length > 0) {
@@ -769,8 +786,8 @@ export class RoutingEngine {
             "- Choose the step that makes the most sense for moving the conversation forward",
             "- Steps with skipIf conditions that are met have already been filtered out",
         ];
-        if (includeEndRoute) {
-            decisionRules.push("", `- You can select '${END_ROUTE_ID}' to complete this route if:`, "  * All required data has been collected", "  * The user's intent suggests they're done with this task", "  * No further steps are needed to fulfill the user's request");
+        if (includeCompletion) {
+            decisionRules.push("", `- You can select '__COMPLETE__' to complete this flow if:`, "  * All required data has been collected", "  * The user's intent suggests they're done with this task", "  * No further steps are needed to fulfill the user's request");
         }
         decisionRules.push("", "Return ONLY JSON matching the provided schema.");
         await pc.addInstruction(decisionRules.join("\n"));
@@ -780,11 +797,11 @@ export class RoutingEngine {
      * Build schema for step selection
      * @private
      */
-    buildStepSelectionSchema(validSteps, includeEndRoute = false) {
+    buildStepSelectionSchema(validSteps, includeCompletion = false) {
         const stepIds = validSteps.map((s) => s.id);
-        // Add END_ROUTE as an option if requested (when required fields are complete)
-        if (includeEndRoute) {
-            stepIds.push(END_ROUTE_ID);
+        // Add completion option if requested (when required fields are complete)
+        if (includeCompletion) {
+            stepIds.push('__COMPLETE__');
         }
         return {
             description: "Step transition decision based on conversation context and collected data",
@@ -798,8 +815,8 @@ export class RoutingEngine {
                 selectedStepId: {
                     type: "string",
                     nullable: false,
-                    description: includeEndRoute
-                        ? `The ID of the selected step to transition to, or '${END_ROUTE_ID}' to complete the route`
+                    description: includeCompletion
+                        ? "The ID of the selected step to transition to, or '__COMPLETE__' to complete the flow"
                         : "The ID of the selected step to transition to",
                     enum: stepIds,
                 },
@@ -813,20 +830,20 @@ export class RoutingEngine {
             additionalProperties: false,
         };
     }
-    buildDynamicRoutingSchema(routes, extrasSchema, activeRouteSteps) {
+    buildDynamicFlowSchema(routes, extrasSchema, activeFlowSteps) {
         const routeIds = routes.map((r) => r.id);
         const routeProperties = {};
         for (const id of routeIds) {
             routeProperties[id] = {
                 type: "number",
                 nullable: false,
-                description: `Score for route ${id} based on direct evidence, context and semantic fit (0-100)`,
+                description: `Score for flow ${id} based on direct evidence, context and semantic fit (0-100)`,
                 minimum: 0,
                 maximum: 100,
             };
         }
         const base = {
-            description: "Full intent analysis: score ALL available routes (0-100) using evidence and context",
+            description: "Full intent analysis: score ALL available flows (0-100) using evidence and context",
             type: "object",
             properties: {
                 context: {
@@ -834,12 +851,12 @@ export class RoutingEngine {
                     nullable: false,
                     description: "Brief summary of the user's intent/context",
                 },
-                routes: {
+                flows: {
                     type: "object",
                     properties: routeProperties,
                     required: routeIds,
                     nullable: false,
-                    description: "Mapping of routeId to score (0-100)",
+                    description: "Mapping of flowId to score (0-100)",
                 },
                 responseDirectives: {
                     type: "array",
@@ -847,17 +864,17 @@ export class RoutingEngine {
                     description: "Optional bullet points the response should address (concise)",
                 },
             },
-            required: ["context", "routes"],
+            required: ["context", "flows"],
             additionalProperties: false,
         };
-        // Add step selection fields if there's an active route with steps
-        if (activeRouteSteps && activeRouteSteps.length > 0) {
+        // Add step selection fields if there's an active flow with steps
+        if (activeFlowSteps && activeFlowSteps.length > 0) {
             base.properties = base.properties || {};
             base.properties.selectedStepId = {
                 type: "string",
                 nullable: false,
-                description: "The step ID to transition to within the active route (required if continuing in current route)",
-                enum: activeRouteSteps.map((s) => s.id),
+                description: "The step ID to transition to within the active flow (required if continuing in current flow)",
+                enum: activeFlowSteps.map((s) => s.id),
             };
             base.properties.stepReasoning = {
                 type: "string",
@@ -877,7 +894,7 @@ export class RoutingEngine {
         return base;
     }
     async buildRoutingPrompt(params) {
-        const { history, routes, lastMessage, agentOptions, session, activeRouteSteps, context, } = params;
+        const { history, flows: routes, lastMessage, agentOptions, session, activeFlowSteps, context, } = params;
         const templateContext = createTemplateContext({ context, session, history });
         const pc = new PromptComposer(templateContext, this.options?.promptSectionCache);
         if (agentOptions) {
@@ -885,10 +902,10 @@ export class RoutingEngine {
         }
         await pc.addInstruction("Task: Intent analysis and route scoring (0-100). Score ALL listed routes.");
         // Add session context if available
-        if (session?.currentRoute) {
+        if (session?.currentFlow) {
             const sessionInfo = [
                 "Current conversation context:",
-                `- Active route: ${session.currentRoute.title} (${session.currentRoute.id})`,
+                `- Active route: ${session.currentFlow.title} (${session.currentFlow.id})`,
             ];
             if (session.currentStep) {
                 sessionInfo.push(`- Current step: ${session.currentStep.id}`);
@@ -902,16 +919,16 @@ export class RoutingEngine {
             sessionInfo.push("Note: User is mid-conversation. They may want to continue current route or switch to a new one based on their intent.");
             await pc.addInstruction(sessionInfo.join("\n"));
             // Add cross-route completion status
-            const completionStatus = this.getRouteCompletionStatus(routes, session.data || {});
-            const completedRoutes = this.evaluateRouteCompletions(routes, session.data || {});
+            const completionStatus = this.getFlowCompletionStatus(routes, session.data || {});
+            const completedFlows = this.evaluateFlowCompletions(routes, session.data || {});
             if (completionStatus.size > 0) {
                 const statusInfo = [
                     "",
-                    "Route completion status based on collected data:",
+                    "Flow completion status based on collected data:",
                 ];
                 for (const route of routes) {
                     const progress = completionStatus.get(route.id) || 0;
-                    const isComplete = completedRoutes.includes(route);
+                    const isComplete = completedFlows.includes(route);
                     const progressPercent = Math.round(progress * 100);
                     statusInfo.push(`- ${route.title}: ${progressPercent}% complete${isComplete ? ' ✓ COMPLETE' : ''}`);
                     if (!isComplete && route.requiredFields) {
@@ -925,14 +942,14 @@ export class RoutingEngine {
                 await pc.addInstruction(statusInfo.join("\n"));
             }
             // Add available steps for the active route
-            if (activeRouteSteps && activeRouteSteps.length > 0) {
+            if (activeFlowSteps && activeFlowSteps.length > 0) {
                 const stepInfo = [
                     "",
                     "Available steps in active route (choose one to transition to):",
                 ];
                 const activeStepConditionContext = [];
-                for (const step of activeRouteSteps) {
-                    const idx = activeRouteSteps.indexOf(step);
+                for (const step of activeFlowSteps) {
+                    const idx = activeFlowSteps.indexOf(step);
                     stepInfo.push(`${idx + 1}. Step: ${step.id}`);
                     if (step.description) {
                         stepInfo.push(`   Description: ${step.description}`);
@@ -976,7 +993,7 @@ export class RoutingEngine {
         }
         await pc.addInteractionHistory(history);
         await pc.addLastMessage(lastMessage);
-        await pc.addRoutingOverview(routes);
+        await pc.addFlowOverview(routes);
         await pc.addInstruction([
             "Scoring rules:",
             "- 90-100: explicit keywords + clear intent",
@@ -989,4 +1006,4 @@ export class RoutingEngine {
         return pc.build();
     }
 }
-//# sourceMappingURL=RoutingEngine.js.map
+//# sourceMappingURL=FlowRouter.js.map