Add session timeline logging and admin sessions view

app/pages/pm.vue

@@ -9,26 +9,19 @@
           <p class="mt-1 text-sm text-white/70">Alpha Build • Decision Tree • VATSIM</p>
         </div>
         <div class="flex flex-col items-stretch gap-2 sm:items-end">
-          <div class="text-right">
-            <v-chip size="small" :color="currentState?.phase === 'Interrupt' ? 'red' : 'cyan'" variant="flat" class="mb-1">
+          <div class="text-right space-y-1">
+            <v-chip size="small" :color="currentState?.phase === 'Interrupt' ? 'red' : 'cyan'" variant="flat">
               {{ currentState?.id || 'INIT' }}
             </v-chip>
             <div class="text-xs text-white/50">{{ currentState?.phase || 'Setup' }}</div>
+            <div class="flex items-center justify-end gap-2 text-[11px] text-white/60">
+              <v-chip size="x-small" color="cyan" variant="outlined">{{ activeFlowInfo.name }}</v-chip>
+              <v-chip size="x-small" color="purple" variant="text">{{ activeFlowInfo.modeLabel }}</v-chip>
+            </div>
+            <p v-if="activeFlowInfo.description" class="text-[10px] text-white/40">
+              {{ activeFlowInfo.description }}
+            </p>
           </div>
-          <v-select
-            v-model="selectedFlowSlug"
-            :items="flowOptions"
-            item-title="title"
-            item-value="value"
-            label="Flow"
-            variant="outlined"
-            density="compact"
-            hide-details
-            color="cyan"
-            class="min-w-[200px]"
-            :disabled="flowOptions.length <= 1"
-            prepend-inner-icon="mdi-sitemap"
-          />
         </div>
       </header>
 
@@ -617,6 +610,21 @@
               <v-chip size="small" color="grey" variant="outlined">LLM</v-chip>
             </div>
 
+            <div class="flex items-center justify-between text-[11px] text-white/50">
+              <span>Session: {{ sessionLabel }}</span>
+              <div class="flex flex-wrap gap-2" v-if="traceAutoSelection || (traceFallback?.used) || timelineUsedFallback">
+                <v-chip v-if="traceAutoSelection" size="x-small" color="cyan" variant="outlined">
+                  Auto: {{ traceAutoSelection.id }}
+                </v-chip>
+                <v-chip v-if="timelineUsedFallback" size="x-small" color="orange" variant="tonal">
+                  Fallback candidates
+                </v-chip>
+                <v-chip v-if="traceFallback?.used" size="x-small" color="red" variant="tonal">
+                  Fallback: {{ traceFallback.reason || 'triggered' }}
+                </v-chip>
+              </div>
+            </div>
+
             <div class="space-y-2 rounded-2xl border border-white/10 bg-black/30 p-3">
               <p class="text-xs uppercase tracking-[0.3em] text-white/40">Current node</p>
               <p class="font-mono text-sm text-white">{{ debugState?.id || '—' }}</p>
@@ -668,6 +676,57 @@
               </div>
               <p v-else class="text-xs text-white/50">No further decisions available.</p>
             </div>
+
+            <div class="space-y-2 rounded-2xl border border-white/10 bg-black/30 p-3">
+              <p class="text-xs uppercase tracking-[0.3em] text-white/40">Decision timeline</p>
+              <div v-if="timelineSteps.length" class="space-y-3">
+                <div
+                  v-for="(step, index) in timelineSteps"
+                  :key="`${step.stage}-${index}`"
+                  class="space-y-2 rounded-xl border border-white/10 bg-black/40 p-3"
+                >
+                  <div class="flex items-start justify-between gap-3">
+                    <div>
+                      <p class="font-semibold text-sm text-white">{{ step.label }}</p>
+                      <p class="text-[11px] text-white/50 uppercase tracking-[0.2em]">{{ step.stage }}</p>
+                    </div>
+                    <v-chip size="x-small" color="cyan" variant="outlined">
+                      {{ step.candidates.length }} candidates
+                    </v-chip>
+                  </div>
+                  <p v-if="step.note" class="text-[11px] text-white/50">{{ step.note }}</p>
+                  <div v-if="step.candidates.length" class="space-y-2">
+                    <div
+                      v-for="candidate in step.candidates"
+                      :key="candidate.id"
+                      class="rounded-lg border border-white/10 bg-black/30 p-2"
+                    >
+                      <div class="flex items-center justify-between gap-2">
+                        <span class="font-mono text-sm text-white">{{ candidate.id }}</span>
+                        <span class="text-[11px] text-white/50">{{ candidate.flow || 'current' }}</span>
+                      </div>
+                      <p v-if="candidate.summary" class="text-[11px] text-white/60 mt-1">{{ candidate.summary }}</p>
+                    </div>
+                  </div>
+                  <div v-if="step.eliminated?.length" class="space-y-2">
+                    <p class="text-[11px] text-red-200/80 uppercase tracking-[0.25em]">Eliminated</p>
+                    <div
+                      v-for="elim in step.eliminated"
+                      :key="`${step.stage}-${elim.candidate.id}`"
+                      class="space-y-1 rounded-lg border border-red-400/30 bg-red-500/10 p-2 text-xs text-red-100"
+                    >
+                      <div class="flex items-center justify-between gap-2">
+                        <span class="font-mono text-sm">{{ elim.candidate.id }}</span>
+                        <span class="text-[11px] text-red-200/80">{{ elim.kind }}</span>
+                      </div>
+                      <p class="text-[11px] text-red-100/80">{{ elim.reason }}</p>
+                      <p v-if="describeElimination(elim)" class="text-[10px] text-red-100/70">{{ describeElimination(elim) }}</p>
+                    </div>
+                  </div>
+                </div>
+              </div>
+              <p v-else class="text-[11px] text-white/50">No decision timeline available yet.</p>
+            </div>
           </v-card-text>
         </v-card>
 
@@ -979,10 +1038,11 @@ const {
   currentStep,
   availableFlows,
   activeFlow,
+  sessionId: engineSessionId,
+  lastDecisionTrace,
   initializeFlight,
   updateFrequencyVariables,
   fetchRuntimeTree,
-  setActiveFlow,
   isReady: engineReady,
   processPilotTransmission,
   buildLLMContext,
@@ -1050,39 +1110,49 @@ const clearLog = () => {
   clearLastTransmission()
 }
 
-const selectedFlowSlug = ref('')
-const flowOptions = computed(() =>
-  availableFlows.value.map((flow) => ({
-    title: flow.name,
-    value: flow.slug,
-    subtitle: flow.description,
-  }))
-)
-
-watch(
-  activeFlow,
-  (slug) => {
-    selectedFlowSlug.value = slug || ''
-  },
-  { immediate: true }
-)
-
-watch(selectedFlowSlug, (slug, previous) => {
-  if (!slug || slug === activeFlow.value || slug === previous) {
-    return
-  }
-  handleFlowChange(slug)
+const activeFlowInfo = computed(() => {
+  const slug = activeFlow.value
+  const flows = availableFlows.value
+  const entry = (slug ? flows.find((flow) => flow.slug === slug) : undefined) || flows.find((flow) => flow.mode === 'main') || flows[0]
+  const resolvedSlug = entry?.slug || slug || ''
+  const name = entry?.name || resolvedSlug || 'Main Flow'
+  const description = entry?.description || ''
+  const mode = entry?.mode || (resolvedSlug && resolvedSlug === slug ? 'parallel' : 'parallel')
+  const modeLabel = mode === 'main' ? 'Main' : mode === 'linear' ? 'Linear' : 'Parallel'
+  return { slug: resolvedSlug, name, description, mode, modeLabel }
 })
 
-function handleFlowChange(slug: string) {
-  if (!slug || slug === activeFlow.value) {
-    return
+const decisionTrace = computed(() => lastDecisionTrace.value)
+const timelineSteps = computed(() => decisionTrace.value?.candidateTimeline?.steps ?? [])
+const timelineUsedFallback = computed(() => Boolean(decisionTrace.value?.candidateTimeline?.fallbackUsed))
+const traceAutoSelection = computed(() => decisionTrace.value?.autoSelection ?? null)
+const traceFallback = computed(() => decisionTrace.value?.fallback ?? null)
+const sessionLabel = computed(() => engineSessionId.value || flags.session_id || '-')
+
+function describeElimination(entry: any): string {
+  if (!entry || typeof entry !== 'object') {
+    return ''
   }
-  try {
-    setActiveFlow(slug)
-  } catch (error) {
-    console.error('Failed to activate flow', error)
+  if (entry.kind === 'regex' && entry.context?.patterns?.length) {
+    const patterns = entry.context.patterns
+      .map((pattern: any) => pattern?.pattern)
+      .filter((value: string | undefined) => Boolean(value))
+      .join(', ')
+    return patterns ? `Patterns: ${patterns}` : entry.reason
   }
+  if (entry.kind === 'condition' && entry.context?.condition) {
+    const condition = entry.context.condition
+    if (condition.type === 'regex' || condition.type === 'regex_not') {
+      const flag = condition.pattern ? `/${condition.pattern}/${condition.patternFlags || 'i'}` : ''
+      return flag ? `Condition: ${condition.type} ${flag}` : entry.reason
+    }
+    const variable = condition.variable || 'value'
+    const operator = condition.operator || '=='
+    const expected = entry.context?.expectedValue ?? condition.value ?? '—'
+    const actual = entry.context?.actualValue ?? '—'
+    return `${variable} ${operator} ${expected} (actual: ${actual})`
+  }
+  return entry.reason
 }
 
 // UI State
@@ -1538,7 +1608,8 @@ const speakPrepared = async (prepared: PreparedSpeech, options: SpeechOptions =
       speed,
       moduleId: 'pilot-monitoring',
       lessonId: currentState.value?.id || 'general',
-      tag: options.tag || 'controller-reply'
+      tag: options.tag || 'controller-reply',
+      sessionId: engineSessionId.value || flags.session_id || undefined,
     })
 
     if (response.success && response.audio) {
@@ -1581,7 +1652,8 @@ const speakPlainText = (text: string, options: SpeechOptions = {}) => {
         speed,
         moduleId: 'pilot-monitoring',
         lessonId,
-        tag: options.tag || 'announcement'
+        tag: options.tag || 'announcement',
+        sessionId: engineSessionId.value || flags.session_id || undefined,
       })
 
       if (response.success && response.audio) {
@@ -1624,23 +1696,18 @@ const handlePilotTransmission = async (message: string, source: 'text' | 'ptt' =
   const prefix = source === 'ptt' ? 'Pilot (PTT)' : 'Pilot'
   setLastTransmission(`${prefix}: ${transcript}`)
 
-  const quickResponse = processPilotTransmission(transcript)
+  processPilotTransmission(transcript)
 
   if (readbackEnabled.value) {
     speakPilotReadback(transcript)
   }
 
-  if (quickResponse) {
-    scheduleControllerSpeech(quickResponse)
-    return
-  }
-
   const ctx = buildLLMContext(transcript)
 
   try {
-    const decision = await api.post('/api/llm/decide', ctx)
+    const { decision, trace } = await api.post('/api/llm/decide', ctx)
 
-    applyLLMDecision(decision)
+    applyLLMDecision(decision, trace)
 
     if (decision.controller_say_tpl && !decision.radio_check) {
       scheduleControllerSpeech(decision.controller_say_tpl)

server/api/atc/ptt.post.ts

@@ -31,14 +31,8 @@ interface PTTRequest {
 interface PTTResponse {
     success: boolean;
     transcription: string;
-    decision?: {
-        next_state: string;
-        controller_say_tpl?: string;
-        off_schema?: boolean;
-        radio_check?: boolean;
-        activate_flow?: string;
-        resume_previous?: boolean;
-    };
+    decision?: LLMDecisionResult['decision'];
+    trace?: LLMDecisionResult['trace'];
 }
 
 async function sh(cmd: string, args: string[]) {
@@ -228,6 +222,7 @@ export default defineEventHandler(async (event) => {
 
                       return {
                           id: candidate.id,
+                          flow: candidate.flow || undefined,
                           state: candidateState
                       };
                   })
@@ -235,12 +230,17 @@ export default defineEventHandler(async (event) => {
 
             const selectedCandidate = contextCandidates?.find(c => c.id === decision?.next_state);
 
+            const sessionId = typeof body.context?.flags?.session_id === 'string'
+                ? body.context.flags.session_id
+                : undefined;
+
             await TransmissionLog.create({
                 user: user?._id,
                 role: "pilot",
                 channel: "ptt",
                 direction: "incoming",
                 text: transcribedText,
+                sessionId,
                 metadata: {
                     moduleId: body.moduleId,
                     lessonId: body.lessonId,
@@ -270,6 +270,9 @@ export default defineEventHandler(async (event) => {
         if (decision) {
             result.decision = decision;
         }
+        if (decisionResult?.trace) {
+            result.trace = decisionResult.trace;
+        }
 
         return result;
 

server/api/atc/say.post.ts

@@ -123,10 +123,16 @@ export default defineEventHandler(async (event) => {
         lessonId?: string;
         tag?: string;
         format?: AudioFmt | "smallest";
+        sessionId?: string;
     }>(event);
 
     const user = await requireUserSession(event);
 
+    const rawSessionId = typeof body?.sessionId === "string"
+        ? body.sessionId.trim()
+        : "";
+    const sessionId = rawSessionId.length ? rawSessionId : undefined;
+
     const raw = (body?.text || "").trim();
     if (!raw) throw createError({ statusCode: 400, statusMessage: "text required" });
 
@@ -226,6 +232,7 @@ export default defineEventHandler(async (event) => {
                 direction: "outgoing",
                 text: raw,
                 normalized,
+                sessionId,
                 metadata: {
                     level,
                     voice,

server/models/TransmissionLog.ts

@@ -10,6 +10,7 @@ export interface TransmissionLogDocument extends mongoose.Document {
   text: string
   normalized?: string
   metadata?: Record<string, any>
+  sessionId?: string
   createdAt: Date
 }
 
@@ -21,6 +22,7 @@ const transmissionSchema = new mongoose.Schema<TransmissionLogDocument>({
   text: { type: String, required: true },
   normalized: { type: String },
   metadata: { type: Schema.Types.Mixed },
+  sessionId: { type: String, index: true },
   createdAt: { type: Date, default: () => new Date() },
 })
 

server/utils/openai.ts

@@ -1,7 +1,17 @@
 // server/utils/openai.ts
 import OpenAI from 'openai'
 import {spellIcaoDigits, toIcaoPhonetic} from '../../shared/utils/radioSpeech'
-import type {LLMDecision, LLMDecisionInput} from '../../shared/types/llm'
+import type {
+    CandidateTraceEntry,
+    CandidateTraceStep,
+    DecisionCandidateTimeline,
+    FlowActivationInstruction,
+    FlowActivationMode,
+    LLMDecision,
+    LLMDecisionInput,
+    LLMDecisionTrace,
+    LLMDecisionTraceCall,
+} from '../../shared/types/llm'
 import type { DecisionNodeCondition, DecisionNodeTrigger, RuntimeDecisionState, RuntimeDecisionSystem } from '../../shared/types/decision'
 import { buildRuntimeDecisionSystem } from '../services/decisionFlowService'
 import {getServerRuntimeConfig} from './runtimeConfig'
@@ -64,23 +74,6 @@ export async function decide(system: string, user: string): Promise<string> {
     return r.choices?.[0]?.message?.content?.trim() || ''
 }
 
-export interface LLMDecisionTraceCall {
-    stage: 'readback-check' | 'decision'
-    request: Record<string, any>
-    response?: any
-    rawResponseText?: string
-    error?: string
-}
-
-export interface LLMDecisionTrace {
-    calls: LLMDecisionTraceCall[]
-    fallback?: {
-        used: boolean
-        reason?: string
-        selected?: string
-    }
-}
-
 export interface LLMDecisionResult {
     decision: LLMDecision
     trace?: LLMDecisionTrace
@@ -211,12 +204,18 @@ interface DecisionCandidate {
     id: string
     flow: string
     state: RuntimeDecisionState
+    triggers: DecisionNodeTrigger[]
+    regexTriggers: DecisionNodeTrigger[]
+    noneTriggers: DecisionNodeTrigger[]
 }
 
 interface PreparedCandidateResult {
-    filteredCandidates: DecisionCandidate[]
+    finalCandidates: DecisionCandidate[]
     candidateFlowMap: Map<string, string>
     activeFlowSlug: string
+    flowEntryModes: Map<string, FlowActivationMode>
+    timeline: DecisionCandidateTimeline
+    autoSelected?: DecisionCandidate | null
 }
 
 const RUNTIME_CACHE_TTL_MS = 5_000
@@ -322,34 +321,48 @@ function parseComparable(raw: any): any {
     return raw
 }
 
-function compareValuesSafe(left: any, operator: string | undefined, right: any): boolean {
+function compareValuesSafe(left: any, operator: string | undefined, right: any): {
+    result: boolean
+    left: any
+    right: any
+    operator: string
+} {
     const normalizedLeft = normalizeComparable(left)
     const normalizedRight = normalizeComparable(parseComparable(right))
-    switch (operator) {
+    const op = operator || '=='
+    let result = false
+    switch (op) {
         case '>':
-            return typeof normalizedLeft === 'number' && typeof normalizedRight === 'number'
+            result = typeof normalizedLeft === 'number' && typeof normalizedRight === 'number'
                 ? normalizedLeft > normalizedRight
                 : false
+            break
         case '>=':
-            return typeof normalizedLeft === 'number' && typeof normalizedRight === 'number'
+            result = typeof normalizedLeft === 'number' && typeof normalizedRight === 'number'
                 ? normalizedLeft >= normalizedRight
                 : false
+            break
         case '<':
-            return typeof normalizedLeft === 'number' && typeof normalizedRight === 'number'
+            result = typeof normalizedLeft === 'number' && typeof normalizedRight === 'number'
                 ? normalizedLeft < normalizedRight
                 : false
+            break
         case '<=':
-            return typeof normalizedLeft === 'number' && typeof normalizedRight === 'number'
+            result = typeof normalizedLeft === 'number' && typeof normalizedRight === 'number'
                 ? normalizedLeft <= normalizedRight
                 : false
+            break
         case '!==':
         case '!=':
-            return normalizedLeft !== normalizedRight
+            result = normalizedLeft !== normalizedRight
+            break
         case '===':
         case '==':
         default:
-            return normalizedLeft === normalizedRight
+            result = normalizedLeft === normalizedRight
+            break
     }
+    return { result, left: normalizedLeft, right: normalizedRight, operator: op }
 }
 
 function resolveContextPath(
@@ -380,18 +393,39 @@ function evaluateConditionEntry(
     condition: DecisionNodeCondition | undefined,
     context: { variables: Record<string, any>; flags: Record<string, any> },
     utterance: string
-): boolean {
-    if (!condition) return true
+): { passed: boolean; detail?: { condition: DecisionNodeCondition; actualValue?: any; expectedValue?: any; operator?: string } } {
+    if (!condition) return { passed: true }
     switch (condition.type) {
-        case 'regex':
-            return evaluateRegexPattern(condition.pattern, condition.patternFlags, utterance)
-        case 'regex_not':
-            return !evaluateRegexPattern(condition.pattern, condition.patternFlags, utterance)
+        case 'regex': {
+            const passed = evaluateRegexPattern(condition.pattern, condition.patternFlags, utterance)
+            return {
+                passed,
+                detail: passed ? undefined : { condition },
+            }
+        }
+        case 'regex_not': {
+            const matched = evaluateRegexPattern(condition.pattern, condition.patternFlags, utterance)
+            const passed = !matched
+            return {
+                passed,
+                detail: passed ? undefined : { condition },
+            }
+        }
         case 'variable_value':
         default: {
             const left = resolveContextPath(condition.variable, context)
-            const operator = condition.operator || '=='
-            return compareValuesSafe(left, operator, condition.value)
+            const comparison = compareValuesSafe(left, condition.operator, condition.value)
+            return {
+                passed: comparison.result,
+                detail: comparison.result
+                    ? undefined
+                    : {
+                          condition,
+                          actualValue: comparison.left,
+                          expectedValue: comparison.right,
+                          operator: comparison.operator,
+                      },
+            }
         }
     }
 }
@@ -400,48 +434,26 @@ function evaluateConditionList(
     conditions: DecisionNodeCondition[] | undefined,
     context: { variables: Record<string, any>; flags: Record<string, any> },
     utterance: string
-): boolean {
+): { passed: boolean; failure?: { condition: DecisionNodeCondition; actualValue?: any; expectedValue?: any; operator?: string } } {
     if (!Array.isArray(conditions) || conditions.length === 0) {
-        return true
+        return { passed: true }
     }
     const ordered = [...conditions].sort((a, b) => (a?.order ?? 0) - (b?.order ?? 0))
     for (const condition of ordered) {
-        if (!evaluateConditionEntry(condition, context, utterance)) {
-            return false
+        const result = evaluateConditionEntry(condition, context, utterance)
+        if (!result.passed) {
+            return {
+                passed: false,
+                failure: {
+                    condition,
+                    actualValue: result.detail?.actualValue,
+                    expectedValue: result.detail?.expectedValue,
+                    operator: result.detail?.operator,
+                },
+            }
         }
     }
-    return true
-}
-
-function filterDecisionCandidates(
-    candidates: DecisionCandidate[],
-    utterance: string,
-    context: { variables: Record<string, any>; flags: Record<string, any> }
-): DecisionCandidate[] {
-    if (!candidates.length) {
-        return []
-    }
-
-    const regexMatches: DecisionCandidate[] = []
-    const noneMatches: DecisionCandidate[] = []
-
-    for (const candidate of candidates) {
-        const { matchesRegex, matchesNone } = analyzeTriggers(candidate.state?.triggers, utterance)
-        if (matchesRegex) {
-            regexMatches.push(candidate)
-        } else if (matchesNone) {
-            noneMatches.push(candidate)
-        }
-    }
-
-    const pool = regexMatches.length > 0 ? regexMatches : noneMatches
-    if (!pool.length) {
-        return []
-    }
-
-    return pool.filter(candidate =>
-        evaluateConditionList(candidate.state?.conditions, context, utterance)
-    )
+    return { passed: true }
 }
 
 async function prepareDecisionCandidates(
@@ -465,12 +477,42 @@ async function prepareDecisionCandidates(
         activeFlowSlug = system.main || Object.keys(system.flows)[0] || ''
     }
 
-    const uniqueCandidates = new Map<string, DecisionCandidate>()
+    const flowEntryModes = new Map<string, FlowActivationMode>()
+    for (const [slug, tree] of Object.entries(system.flows || {})) {
+        const mode = tree.entry_mode === 'main'
+            ? 'main'
+            : tree.entry_mode === 'linear'
+                ? 'linear'
+                : slug === system.main
+                    ? 'main'
+                    : 'parallel'
+        flowEntryModes.set(slug, mode)
+    }
 
-    const addCandidate = (candidate: DecisionCandidate | null | undefined) => {
-        if (!candidate || !candidate.id || !candidate.state) return
-        if (uniqueCandidates.has(candidate.id)) return
-        uniqueCandidates.set(candidate.id, candidate)
+    const candidateMap = new Map<string, DecisionCandidate>()
+
+    const createCandidate = (id: string, flow: string | undefined, state: RuntimeDecisionState | undefined): DecisionCandidate | null => {
+        if (!id || !state) return null
+        const triggers = Array.isArray(state.triggers) ? state.triggers.filter(Boolean) : []
+        const regexTriggers = triggers.filter(trigger => trigger?.type === 'regex')
+        const noneTriggers = triggers.filter(trigger => trigger?.type === 'none')
+        return {
+            id,
+            flow: flow || activeFlowSlug,
+            state,
+            triggers,
+            regexTriggers,
+            noneTriggers,
+        }
+    }
+
+    const addCandidate = (id: string | undefined, flow: string | undefined, state: RuntimeDecisionState | undefined) => {
+        if (!id) return
+        if (candidateMap.has(id)) return
+        const candidate = createCandidate(id, flow, state)
+        if (candidate) {
+            candidateMap.set(id, candidate)
+        }
     }
 
     for (const raw of input.candidates || []) {
@@ -478,14 +520,13 @@ async function prepareDecisionCandidates(
         const indexed = index.get(raw.id)
         const flow = raw.flow || indexed?.flow || activeFlowSlug
         const state = indexed?.state ? { ...indexed.state } : raw.state
-        if (!state) continue
-        addCandidate({ id: raw.id, flow: flow || activeFlowSlug, state })
+        addCandidate(raw.id, flow, state)
     }
 
     for (const raw of input.candidates || []) {
         if (!raw?.id || !raw.state) continue
-        if (!uniqueCandidates.has(raw.id)) {
-            addCandidate({ id: raw.id, flow: raw.flow || activeFlowSlug, state: raw.state })
+        if (!candidateMap.has(raw.id)) {
+            addCandidate(raw.id, raw.flow || activeFlowSlug, raw.state)
         }
     }
 
@@ -493,25 +534,211 @@ async function prepareDecisionCandidates(
         const startStateId = tree.start_state
         if (!startStateId) continue
         const indexed = index.get(startStateId)
-        if (!indexed) continue
-        addCandidate({ id: startStateId, flow: flowSlug, state: { ...indexed.state } })
+        const state = indexed?.state ? { ...indexed.state } : tree.states?.[startStateId]
+        addCandidate(startStateId, flowSlug, state)
     }
 
-    const candidates = Array.from(uniqueCandidates.values())
+    const candidates = Array.from(candidateMap.values())
     const context = { variables: input.variables || {}, flags: input.flags || {} }
-    const filteredCandidates = filterDecisionCandidates(candidates, utterance, context)
+    const timelineSteps: CandidateTraceStep[] = []
+    let fallbackUsed = false
+
+    const toTraceEntry = (candidate: DecisionCandidate): CandidateTraceEntry => ({
+        id: candidate.id,
+        flow: candidate.flow,
+        name: candidate.state?.name,
+        summary: candidate.state?.summary,
+        role: candidate.state?.role,
+        triggers: candidate.triggers,
+        conditions: candidate.state?.conditions || [],
+    })
+
+    const recordStep = (
+        stage: CandidateTraceStage,
+        label: string,
+        stepCandidates: DecisionCandidate[],
+        eliminated: CandidateTraceElimination[] = [],
+        note?: string
+    ) => {
+        timelineSteps.push({
+            stage,
+            label,
+            candidates: stepCandidates.map(toTraceEntry),
+            eliminated: eliminated.length ? eliminated : undefined,
+            note,
+        })
+    }
+
+    const regexCandidates = candidates.filter(candidate => candidate.regexTriggers.length > 0)
+    let workingSet: DecisionCandidate[] = []
+
+    if (regexCandidates.length > 0) {
+        recordStep('regex_candidates', 'Regex candidates', regexCandidates)
+
+        const survivors: DecisionCandidate[] = []
+        const eliminated: CandidateTraceElimination[] = []
+
+        for (const candidate of regexCandidates) {
+            const matched = candidate.regexTriggers.some(trigger =>
+                evaluateRegexPattern(trigger.pattern, trigger.patternFlags, utterance)
+            )
+            if (matched) {
+                survivors.push(candidate)
+            } else {
+                eliminated.push({
+                    candidate: toTraceEntry(candidate),
+                    kind: 'regex',
+                    reason: 'No regex trigger matched the pilot utterance.',
+                    context: {
+                        patterns: candidate.regexTriggers.map(trigger => ({
+                            id: trigger.id,
+                            pattern: trigger.pattern,
+                            flags: trigger.patternFlags,
+                        })),
+                        transcript: utterance,
+                    },
+                })
+            }
+        }
+
+        recordStep(
+            'regex_filtered',
+            'Regex evaluation',
+            survivors,
+            eliminated,
+            survivors.length ? undefined : 'No regex triggers matched the pilot transmission.'
+        )
+
+        workingSet = survivors
+    } else {
+        recordStep('regex_candidates', 'Regex candidates', [], [], 'No regex-triggered transitions available.')
+        workingSet = []
+    }
+
+    let finalCandidates: DecisionCandidate[] = []
+
+    if (workingSet.length > 0) {
+        const survivors: DecisionCandidate[] = []
+        const eliminated: CandidateTraceElimination[] = []
+
+        for (const candidate of workingSet) {
+            const evaluation = evaluateConditionList(candidate.state?.conditions, context, utterance)
+            if (evaluation.passed) {
+                survivors.push(candidate)
+            } else if (evaluation.failure) {
+                eliminated.push({
+                    candidate: toTraceEntry(candidate),
+                    kind: 'condition',
+                    reason: 'Node conditions were not satisfied.',
+                    context: {
+                        condition: evaluation.failure.condition,
+                        actualValue: evaluation.failure.actualValue,
+                        expectedValue: evaluation.failure.expectedValue,
+                        operator: evaluation.failure.operator,
+                    },
+                })
+            } else {
+                eliminated.push({
+                    candidate: toTraceEntry(candidate),
+                    kind: 'condition',
+                    reason: 'Node conditions were not satisfied.',
+                })
+            }
+        }
+
+        recordStep(
+            'condition_filtered',
+            'Condition evaluation',
+            survivors,
+            eliminated,
+            survivors.length ? undefined : 'All regex candidates failed their conditions.'
+        )
+
+        finalCandidates = survivors
+    }
+
+    if (finalCandidates.length === 0) {
+        fallbackUsed = true
+        const fallbackCandidates = candidates.filter(candidate =>
+            candidate.noneTriggers.length > 0 || (candidate.triggers.length === 0 && candidate.regexTriggers.length === 0)
+        )
+
+        if (fallbackCandidates.length > 0) {
+            recordStep('fallback_candidates', 'Fallback candidates', fallbackCandidates)
+
+            const survivors: DecisionCandidate[] = []
+            const eliminated: CandidateTraceElimination[] = []
+
+            for (const candidate of fallbackCandidates) {
+                const evaluation = evaluateConditionList(candidate.state?.conditions, context, utterance)
+                if (evaluation.passed) {
+                    survivors.push(candidate)
+                } else if (evaluation.failure) {
+                    eliminated.push({
+                        candidate: toTraceEntry(candidate),
+                        kind: 'condition',
+                        reason: 'Node conditions were not satisfied.',
+                        context: {
+                            condition: evaluation.failure.condition,
+                            actualValue: evaluation.failure.actualValue,
+                            expectedValue: evaluation.failure.expectedValue,
+                            operator: evaluation.failure.operator,
+                        },
+                    })
+                } else {
+                    eliminated.push({
+                        candidate: toTraceEntry(candidate),
+                        kind: 'condition',
+                        reason: 'Node conditions were not satisfied.',
+                    })
+                }
+            }
+
+            recordStep(
+                'fallback_filtered',
+                'Fallback evaluation',
+                survivors,
+                eliminated,
+                survivors.length ? undefined : 'No fallback candidates satisfied their conditions.'
+            )
+
+            finalCandidates = survivors
+        } else {
+            recordStep('fallback_candidates', 'Fallback candidates', [], [], 'No fallback triggers defined.')
+            recordStep('fallback_filtered', 'Fallback evaluation', [], [], 'No fallback candidates available.')
+        }
+    }
+
+    recordStep(
+        'final',
+        'Final candidates',
+        finalCandidates,
+        [],
+        finalCandidates.length ? undefined : 'No transitions remain after evaluation.'
+    )
+
+    const autoSelected = finalCandidates.length === 1 ? finalCandidates[0] : null
 
     const candidateFlowMap = new Map<string, string>()
-    for (const candidate of filteredCandidates) {
+    for (const candidate of finalCandidates) {
         if (candidate.flow) {
             candidateFlowMap.set(candidate.id, candidate.flow)
         }
     }
 
+    const timeline: DecisionCandidateTimeline = {
+        steps: timelineSteps,
+        fallbackUsed,
+        autoSelected: autoSelected ? toTraceEntry(autoSelected) : null,
+    }
+
     return {
-        filteredCandidates,
+        finalCandidates,
         candidateFlowMap,
         activeFlowSlug,
+        flowEntryModes,
+        timeline,
+        autoSelected,
     }
 }
 
@@ -649,28 +876,74 @@ export async function routeDecision(input: LLMDecisionInput): Promise<LLMDecisio
 
     const prepared = await prepareDecisionCandidates(input, pilotUtterance)
     candidateFlowMap = prepared.candidateFlowMap
+    const flowEntryModes = prepared.flowEntryModes
     if (prepared.activeFlowSlug) {
         activeFlowSlug = prepared.activeFlowSlug
         input.flow_slug = prepared.activeFlowSlug
     }
-    input.candidates = prepared.filteredCandidates.map(candidate => ({
+    trace.candidateTimeline = prepared.timeline
+    if (prepared.autoSelected) {
+        trace.autoSelection = {
+            id: prepared.autoSelected.id,
+            flow: prepared.autoSelected.flow,
+            reason: 'Single candidate remained after trigger and condition evaluation.',
+        }
+    }
+    input.candidates = prepared.finalCandidates.map(candidate => ({
         id: candidate.id,
         state: candidate.state,
         flow: candidate.flow,
     }))
 
-    const finalize = (decision: LLMDecision): LLMDecisionResult => {
-        const targetState = decision.next_state
-        if (targetState) {
-            const targetFlow = candidateFlowMap.get(targetState)
-            if (targetFlow && targetFlow !== activeFlowSlug) {
-                decision.activate_flow = targetFlow
+    const resolveActivationInstruction = (
+        value?: string | FlowActivationInstruction | null
+    ): FlowActivationInstruction | undefined => {
+        if (!value) return undefined
+        if (typeof value === 'string') {
+            const normalizedMode = flowEntryModes.get(value)
+                || (value === prepared.activeFlowSlug ? 'main' : undefined)
+            return {
+                slug: value,
+                mode: normalizedMode || 'parallel',
             }
         }
-        if (!trace.calls.length && !trace.fallback) {
-            return {decision}
+        if (!value.slug) return undefined
+        const normalizedMode = value.mode
+            || flowEntryModes.get(value.slug)
+            || (value.slug === prepared.activeFlowSlug ? 'main' : undefined)
+        return {
+            slug: value.slug,
+            mode: normalizedMode || 'parallel',
         }
-        return {decision, trace}
+    }
+
+    const finalize = (decision: LLMDecision): LLMDecisionResult => {
+        const targetState = decision.next_state
+        let activation = resolveActivationInstruction(decision.activate_flow as any)
+        if (!activation && targetState) {
+            const targetFlow = candidateFlowMap.get(targetState)
+            if (targetFlow && targetFlow !== activeFlowSlug) {
+                activation = resolveActivationInstruction(targetFlow)
+            }
+        }
+
+        if (activation) {
+            decision.activate_flow = activation
+        } else if (decision.activate_flow) {
+            delete (decision as any).activate_flow
+        }
+
+        const shouldAttachTrace = Boolean(
+            trace.calls.length
+            || trace.fallback
+            || (trace.candidateTimeline && trace.candidateTimeline.steps.length)
+            || trace.autoSelection
+        )
+
+        if (!shouldAttachTrace) {
+            return { decision }
+        }
+        return { decision, trace }
     }
 
     async function handleReadbackCheck(): Promise<LLMDecisionResult> {
@@ -799,24 +1072,6 @@ export async function routeDecision(input: LLMDecisionInput): Promise<LLMDecisio
         }
     }
 
-    // Instant detection without the LLM for common cases
-    if (pilotText.includes('radio check') || pilotText.includes('signal test') ||
-        (pilotText.includes('read') && (pilotText.includes('check') || pilotText.includes('you')))) {
-        return finalize({
-            next_state: input.state_id,
-            radio_check: true,
-            controller_say_tpl: `${input.variables.callsign}, read you five by five.`
-        })
-    }
-
-    // Emergency ohne LLM
-    if (pilotText.startsWith('mayday') && input.flags.in_air) {
-        return finalize({next_state: 'INT_MAYDAY'})
-    }
-    if (pilotText.startsWith('pan pan') && input.flags.in_air) {
-        return finalize({next_state: 'INT_PANPAN'})
-    }
-
     const optimizedInput = optimizeInputForLLM(input)
 
     // Check whether the next states require ATC responses

shared/types/decision.ts

@@ -126,6 +126,8 @@ export interface DecisionNodeMetadata {
   complexity?: 'low' | 'medium' | 'high'
 }
 
+export type DecisionFlowEntryMode = 'parallel' | 'linear'
+
 export interface DecisionNodeModel {
   stateId: string
   title?: string
@@ -197,6 +199,8 @@ export interface DecisionFlowModel {
   createdAt: string
   updatedAt: string
   nodeCount?: number
+  entryMode?: DecisionFlowEntryMode
+  isMain?: boolean
 }
 
 export interface RuntimeDecisionAutoTransition {
@@ -213,6 +217,8 @@ export interface RuntimeDecisionAutoTransition {
 export interface RuntimeDecisionState {
   role: DecisionNodeRole
   phase: string
+  name?: string
+  summary?: string
   say_tpl?: string
   utterance_tpl?: string
   else_say_tpl?: string
@@ -248,6 +254,7 @@ export interface RuntimeDecisionTree {
   roles: DecisionNodeRole[]
   phases: string[]
   states: Record<string, RuntimeDecisionState>
+  entry_mode?: 'main' | DecisionFlowEntryMode
 }
 
 export interface RuntimeDecisionSystem {
@@ -265,4 +272,6 @@ export interface DecisionFlowSummary {
   nodeCount: number
   updatedAt: string
   createdAt: string
+  entryMode?: DecisionFlowEntryMode
+  isMain?: boolean
 }

shared/types/llm.ts

@@ -1,3 +1,5 @@
+import type { DecisionNodeCondition, DecisionNodeTrigger } from './decision'
+
 export interface LLMDecisionInput {
     state_id: string
     state: any
@@ -8,6 +10,68 @@ export interface LLMDecisionInput {
     flow_slug?: string
 }
 
+export type FlowActivationMode = 'main' | 'parallel' | 'linear'
+
+export interface FlowActivationInstruction {
+    slug: string
+    mode?: FlowActivationMode
+}
+
+export interface CandidateTraceEntry {
+    id: string
+    flow: string
+    name?: string
+    summary?: string
+    role?: string
+    triggers?: DecisionNodeTrigger[]
+    conditions?: DecisionNodeCondition[]
+}
+
+export type CandidateTraceStage =
+    | 'regex_candidates'
+    | 'regex_filtered'
+    | 'condition_filtered'
+    | 'fallback_candidates'
+    | 'fallback_filtered'
+    | 'final'
+
+export interface CandidateTraceEliminationContext {
+    patterns?: Array<{ id?: string; pattern?: string; flags?: string }>
+    transcript?: string
+    condition?: {
+        id?: string
+        type: DecisionNodeCondition['type']
+        variable?: string
+        operator?: string
+        value?: number | string | boolean
+        pattern?: string
+        patternFlags?: string
+    }
+    actualValue?: any
+    expectedValue?: any
+}
+
+export interface CandidateTraceElimination {
+    candidate: CandidateTraceEntry
+    kind: 'regex' | 'condition'
+    reason: string
+    context?: CandidateTraceEliminationContext
+}
+
+export interface CandidateTraceStep {
+    stage: CandidateTraceStage
+    label: string
+    candidates: CandidateTraceEntry[]
+    eliminated?: CandidateTraceElimination[]
+    note?: string
+}
+
+export interface DecisionCandidateTimeline {
+    steps: CandidateTraceStep[]
+    fallbackUsed?: boolean
+    autoSelected?: CandidateTraceEntry | null
+}
+
 export interface LLMDecision {
     next_state: string
     updates?: Record<string, any>
@@ -15,6 +79,31 @@ export interface LLMDecision {
     controller_say_tpl?: string
     off_schema?: boolean
     radio_check?: boolean
-    activate_flow?: string
+    activate_flow?: string | FlowActivationInstruction
     resume_previous?: boolean
 }
+
+export interface LLMDecisionTraceCall {
+    stage: 'readback-check' | 'decision'
+    request: Record<string, any>
+    response?: any
+    rawResponseText?: string
+    error?: string
+}
+
+export interface LLMDecisionTraceFallback {
+    used: boolean
+    reason?: string
+    selected?: string
+}
+
+export interface LLMDecisionTrace {
+    calls: LLMDecisionTraceCall[]
+    fallback?: LLMDecisionTraceFallback
+    candidateTimeline?: DecisionCandidateTimeline
+    autoSelection?: {
+        id: string
+        flow: string
+        reason?: string
+    }
+}

shared/utils/communicationsEngine.ts

@@ -7,6 +7,7 @@ import type {
     RuntimeDecisionAutoTransition,
     DecisionNodeAutoTrigger,
 } from '../types/decision'
+import type { FlowActivationInstruction, FlowActivationMode, LLMDecisionTrace } from '../types/llm'
 import { normalizeRadioPhrase } from './radioSpeech'
 
 // --- DecisionTree runtime types ---
@@ -20,6 +21,7 @@ interface EngineFlags {
     stack: string[]
     off_schema_count: number
     radio_checks_done: number
+    session_id: string
     [key: string]: any
 }
 
@@ -120,6 +122,10 @@ type TelemetryState = {
     [key: string]: number
 }
 
+function createSessionId(): string {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`
+}
+
 export function normalizeATCText(text: string, context: Record<string, any>): string {
     const rendered = renderTpl(text, context)
     return normalizeRadioPhrase(rendered)
@@ -165,9 +171,12 @@ export default function useCommunicationsEngine() {
     const runtimeSystem = ref<RuntimeDecisionSystem | null>(null)
     const flowOrder = ref<string[]>([])
     const activeFlowSlug = ref<string>('')
+    const sessionId = ref<string>('')
+    const flowStack = ref<string[]>([])
 
     const tree = ref<RuntimeDecisionTree | null>(null)
     const ready = ref(false)
+    const lastDecisionTrace = ref<LLMDecisionTrace | null>(null)
 
     const flowSnapshots = reactive<Record<string, FlowSnapshot>>({})
 
@@ -227,7 +236,18 @@ export default function useCommunicationsEngine() {
         }
     }
 
+    function ensureSessionValue(raw?: string): string {
+        if (raw && typeof raw === 'string' && raw.trim().length) {
+            sessionId.value = raw.trim()
+        } else if (!sessionId.value) {
+            sessionId.value = createSessionId()
+        }
+        return sessionId.value
+    }
+
     function assignActiveFlags(next: EngineFlags) {
+        const normalizedSession = ensureSessionValue(next?.session_id)
+        next.session_id = normalizedSession
         flags.value = next
         if (activeFlowSlug.value && flowSnapshots[activeFlowSlug.value]) {
             flowSnapshots[activeFlowSlug.value].flags = next
@@ -275,11 +295,15 @@ export default function useCommunicationsEngine() {
             stack,
             off_schema_count: Number((baseFlags as any).off_schema_count) || 0,
             radio_checks_done: Number((baseFlags as any).radio_checks_done) || 0,
+            session_id: '',
             ...(baseFlags as EngineFlags),
         }
         if (!Array.isArray(flags.stack)) {
             flags.stack = []
         }
+        if (typeof flags.session_id !== 'string') {
+            flags.session_id = ''
+        }
 
         const telemetry: TelemetryState = {
             altitude_ft: Number((baseFlags as any).altitude_ft) || 0,
@@ -341,6 +365,49 @@ export default function useCommunicationsEngine() {
         setActiveStateId(snapshot.currentStateId)
         ready.value = snapshot.ready
     }
+
+    function resolveFlowMode(slug: string | undefined): FlowActivationMode {
+        if (!slug) return 'parallel'
+        const system = runtimeSystem.value
+        if (!system) return 'parallel'
+        if (slug === system.main) return 'main'
+        const treeData = system.flows[slug]
+        if (!treeData) return 'parallel'
+        if (treeData.entry_mode === 'main') return 'main'
+        if (treeData.entry_mode === 'linear') return 'linear'
+        return 'parallel'
+    }
+
+    function normalizeFlowInstruction(target: string | FlowActivationInstruction | null | undefined): FlowActivationInstruction | null {
+        if (!target) return null
+        if (typeof target === 'string') {
+            return { slug: target, mode: resolveFlowMode(target) }
+        }
+        if (!target.slug) return null
+        return { slug: target.slug, mode: target.mode ?? resolveFlowMode(target.slug) }
+    }
+
+    function setActiveFlow(target: string | FlowActivationInstruction, options: { skipStack?: boolean } = {}) {
+        const instruction = normalizeFlowInstruction(target)
+        if (!instruction) {
+            throw new Error(`Flow snapshot not loaded: ${typeof target === 'string' ? target : target?.slug}`)
+        }
+        const slug = instruction.slug
+        if (!slug || !flowSnapshots[slug]) {
+            throw new Error(`Flow snapshot not loaded: ${slug}`)
+        }
+        const previous = activeFlowSlug.value
+        const shouldPush = !options.skipStack
+            && instruction.mode === 'linear'
+            && previous
+            && previous !== slug
+        if (shouldPush) {
+            flowStack.value.push(previous)
+        }
+        activateFlow(slug)
+        ready.value = true
+        queueMicrotask(() => evaluateAutoTransitions())
+    }
     const nextCandidates = computed<string[]>(() => {
         const s = currentState.value
         if (!s) return []
@@ -416,6 +483,15 @@ export default function useCommunicationsEngine() {
             flowSnapshots[slug] = createSnapshotFromTree(treeData)
         }
 
+        flowStack.value = []
+        sessionId.value = createSessionId()
+        for (const slug of order) {
+            const snapshot = flowSnapshots[slug]
+            if (snapshot) {
+                snapshot.flags.session_id = sessionId.value
+            }
+        }
+
         const preferred = options.activeSlug && system.flows[options.activeSlug]
             ? options.activeSlug
             : system.main && system.flows[system.main]
@@ -440,6 +516,7 @@ export default function useCommunicationsEngine() {
                 stack: [],
                 off_schema_count: 0,
                 radio_checks_done: 0,
+                session_id: ensureSessionValue(),
             })
             assignActiveTelemetry({
                 altitude_ft: 0,
@@ -466,6 +543,8 @@ export default function useCommunicationsEngine() {
 
     const activeFlow = computed(() => activeFlowSlug.value)
 
+    const mainFlowSlug = computed(() => runtimeSystem.value?.main || '')
+
     const availableFlows = computed(() => {
         if (!runtimeSystem.value) return [] as Array<{ slug: string; name: string; description?: string; start: string }>
         return flowOrder.value
@@ -477,19 +556,11 @@ export default function useCommunicationsEngine() {
                     name: treeData.name || slug,
                     description: treeData.description,
                     start: treeData.start_state,
+                    mode: treeData.entry_mode || (slug === runtimeSystem.value!.main ? 'main' : 'parallel'),
                 }
             })
     })
 
-    function setActiveFlow(slug: string) {
-        if (!slug || !flowSnapshots[slug]) {
-            throw new Error(`Flow snapshot not loaded: ${slug}`)
-        }
-        activateFlow(slug)
-        ready.value = true
-        queueMicrotask(() => evaluateAutoTransitions())
-    }
-
     async function fetchRuntimeTree(slug = 'icao_atc_decision_tree') {
         ready.value = false
         const fetcher: any = (globalThis as any).$fetch
@@ -689,7 +760,8 @@ export default function useCommunicationsEngine() {
             current_unit: 'DEL',
             stack: [],
             off_schema_count: 0,
-            radio_checks_done: 0
+            radio_checks_done: 0,
+            session_id: ensureSessionValue(flags.value.session_id)
         }
         assignActiveFlags(nextFlags)
 
@@ -738,11 +810,14 @@ export default function useCommunicationsEngine() {
         }
     }
 
-    function applyLLMDecision(decision: any) {
+    function applyLLMDecision(decision: any, trace?: LLMDecisionTrace | null) {
         if (!decision || typeof decision !== 'object') {
+            lastDecisionTrace.value = null
             return
         }
 
+        lastDecisionTrace.value = trace ?? null
+
         if (decision.updates && typeof decision.updates === 'object') {
             Object.assign(variables.value, decision.updates)
         }
@@ -759,11 +834,14 @@ export default function useCommunicationsEngine() {
             flags.value.stack = decision.stack.slice()
         }
 
-        if (decision.activate_flow && decision.activate_flow !== activeFlowSlug.value) {
-            try {
-                setActiveFlow(decision.activate_flow)
-            } catch (err) {
-                console.warn('[Engine] Failed to activate flow from decision', err)
+        if (decision.activate_flow) {
+            const activation = normalizeFlowInstruction(decision.activate_flow as any)
+            if (activation && (activation.slug !== activeFlowSlug.value || activation.mode === 'main')) {
+                try {
+                    setActiveFlow(activation)
+                } catch (err) {
+                    console.warn('[Engine] Failed to activate flow from decision', err)
+                }
             }
         }
 
@@ -792,7 +870,10 @@ export default function useCommunicationsEngine() {
                 : null
 
         if (resumeFlow) {
-            resumePriorFlow()
+            const resumed = resumeLinearFlow()
+            if (!resumed) {
+                resumeStackedState()
+            }
         } else if (!decision.radio_check && nextState) {
             moveTo(nextState)
         }
@@ -806,31 +887,8 @@ export default function useCommunicationsEngine() {
         if (!ready.value) {
             return null
         }
-        // Log pilot input
         speak('pilot', transcript, currentStateId.value)
-
-        // Radio check detection (fallback if the LLM misses it)
-        const t = transcript.toLowerCase()
-        if (t.includes('radio check') || (t.includes('read') && t.includes('check'))) {
-            const callsign = variables.value.callsign || ''
-            const response = `${callsign}, read you five by five.`
-            flags.value.radio_checks_done++
-
-            setTimeout(() => {
-                speak('atc', response, currentStateId.value, { radioCheck: true })
-            }, 500)
-
-            return response
-        }
-
-        // Emergency Interrupts
-        if (flags.value.in_air && /^(mayday|pan\s*pan)/.test(t)) {
-            const intId = t.startsWith('mayday') ? 'INT_MAYDAY' : 'INT_PANPAN'
-            moveTo(intId)
-            return null
-        }
-
-        return null // Let the LLM decide
+        return null
     }
 
     function processUserTransmission(transcript: string): string | null {
@@ -986,11 +1044,31 @@ export default function useCommunicationsEngine() {
         }
     }
 
-    function resumePriorFlow() {
+    function resumeStackedState() {
         const prev = flags.value.stack.pop()
         if (prev) moveTo(prev)
     }
 
+    function resumeLinearFlow(): boolean {
+        const previousFlow = flowStack.value.pop()
+        if (previousFlow) {
+            try {
+                setActiveFlow({ slug: previousFlow, mode: resolveFlowMode(previousFlow) }, { skipStack: true })
+                return true
+            } catch (err) {
+                console.warn('[Engine] Failed to resume linear flow', err)
+            }
+        } else if (mainFlowSlug.value && activeFlowSlug.value !== mainFlowSlug.value) {
+            try {
+                setActiveFlow({ slug: mainFlowSlug.value, mode: 'main' }, { skipStack: true })
+                return true
+            } catch (err) {
+                console.warn('[Engine] Failed to restore main flow', err)
+            }
+        }
+        return false
+    }
+
     function speak(speaker: Role, tpl: string, stateId: string, options: { radioCheck?: boolean, offSchema?: boolean } = {}) {
         const msg = renderTpl(tpl, exposeCtx())
         const entry: EngineLog = {
@@ -1096,6 +1174,8 @@ export default function useCommunicationsEngine() {
         clearCommunicationLog: () => { assignCommunicationLog([]) },
         activeFlow,
         availableFlows,
+        sessionId: readonly(sessionId),
+        lastDecisionTrace: readonly(lastDecisionTrace),
 
         // pm_alt.vue integration
         flightContext: readonly(flightContext),
@@ -1118,7 +1198,6 @@ export default function useCommunicationsEngine() {
 
         // Flow Control
         moveTo,
-        resumePriorFlow,
 
         // Utilities
         normalizeATCText,