@linklabjs/core 0.1.0

package/src/navigation/NavigationEngine.ts

@@ -0,0 +1,441 @@
+/**
+ * NavigationEngine - Moteur de navigation sémantique
+ *
+ * Trois modes orthogonaux :
+ *
+ *   PATHFIND  — Trouver les N meilleurs chemins entre deux nœuds
+ *   NAVIGATE  — Résoudre une stack de frames étape par étape
+ *   SCHEDULE  — Exécuter des actions par priorité sur un contexte
+ *
+ * Trois bus exposés sur chaque instance :
+ *
+ *   engine.hooks   — awaitable, enrichit ou annule le flux
+ *   engine.events  — fire-and-forget, observation pure
+ *   engine.errors  — synchrone, jamais silencieux
+ *
+ * Trail :
+ *   Le moteur accepte un Trail existant (Option B).
+ *   Si aucun Trail n'est fourni, il en crée un à partir de initialStack.
+ *   engine.trail est toujours accessible après création.
+ *
+ * ── Instrumentation @linklab/telemetry ──────────────────────────────────────
+ *   Chaque appel à run() produit un Span si @linklab/telemetry est installé.
+ *   Points mesurés :
+ *     - Step 'PathFinder'  : durée de findAllPaths() (mode PATHFIND)
+ *     - Step 'Resolver'    : durée de resolver.resolve() par frame (mode NAVIGATE)
+ *     - Step 'Scheduler'   : durée de scheduler.step() (mode SCHEDULE)
+ *   Le span est émis sur traceBus à la fin de run(), succès ou erreur.
+ */
+
+import type {
+  Graph,
+  GraphEdge,
+  Frame,
+  ScheduleAction,
+  EngineMode,
+  NavigationEngineConfig,
+  EngineStepResult,
+  PathQuery,
+  NavigationPath
+} from '../types/index.js'
+
+import { PathFinder } from '../core/PathFinder.js'
+import { Resolver }   from './Resolver.js'
+import { Scheduler }  from './Scheduler.js'
+import { Trail }      from './Trail.js'
+import { createGraphBuses, type GraphBuses } from '../core/GraphEvents.js'
+import { shim }       from '../instrumentation/TelemetryShim.js'
+
+export class NavigationEngine {
+  private mode:        EngineMode
+  private graph:       Graph
+  private pathFinder?: PathFinder
+  private resolver?:   Resolver
+  private scheduler?:  Scheduler
+  private config:      NavigationEngineConfig
+
+  // ── Trail — contexte de navigation vivant ────────────────────
+  public readonly trail: Trail
+
+  // ── Les trois bus ────────────────────────────────────────────
+  public readonly hooks:  GraphBuses['hooks']
+  public readonly events: GraphBuses['events']
+  public readonly errors: GraphBuses['errors']
+
+  constructor(config: NavigationEngineConfig) {
+    this.config = config
+    this.mode   = config.mode
+    this.graph  = config.graph
+
+    this.trail = config.trail ?? Trail.create({
+      frames: config.initialStack ?? []
+    })
+
+    if (!config.trail && config.initialStack) {
+      for (const frame of config.initialStack) {
+        if (!frame.state) {
+          frame.state = frame.id !== undefined ? 'RESOLVED' : 'UNRESOLVED'
+        }
+      }
+    }
+
+    const buses = createGraphBuses()
+    this.hooks  = buses.hooks
+    this.events = buses.events
+    this.errors = buses.errors
+
+    switch (this.mode) {
+      case 'PATHFIND':
+        this.pathFinder = new PathFinder(this.graph)
+        break
+      case 'NAVIGATE':
+        this.resolver = new Resolver(this.graph)
+        break
+      case 'SCHEDULE':
+        this.scheduler = new Scheduler(config.actions ?? [], this.graph)
+        break
+    }
+  }
+
+  // ==================== FACTORY METHODS ====================
+
+  static forPathfinding(graph: Graph, query: PathQuery): NavigationEngine {
+    return new NavigationEngine({ mode: 'PATHFIND', graph, pathQuery: query })
+  }
+
+  static forNavigation(
+    graph: Graph,
+    options: { trail: Trail } | { stack: Frame[] }
+  ): NavigationEngine {
+    if ('trail' in options) {
+      return new NavigationEngine({ mode: 'NAVIGATE', graph, trail: options.trail })
+    }
+    return new NavigationEngine({ mode: 'NAVIGATE', graph, initialStack: options.stack })
+  }
+
+  static forScheduling(
+    graph: Graph,
+    options: { trail?: Trail; stack?: Frame[]; actions: ScheduleAction[] }
+  ): NavigationEngine {
+    const trail = options.trail ?? Trail.create({ frames: options.stack ?? [] })
+    return new NavigationEngine({ mode: 'SCHEDULE', graph, trail, actions: options.actions })
+  }
+
+  // ==================== RUN ====================
+
+  async run(maxSteps: number = 1): Promise<EngineStepResult[]> {
+    // ── Span : contexte commun aux trois modes ───────────────
+    const trailStr = this._buildTrailString()
+    const spanBuilder = shim.startSpan({
+      trail:   trailStr,
+      from:    this._resolvedFrom(),
+      to:      this._targetTo(),
+      filters: this._currentFilters(),
+      path:    [],   // mis à jour après résolution
+    })
+
+    try {
+      let results: EngineStepResult[]
+
+      switch (this.mode) {
+        case 'PATHFIND':
+          results = await this.runPathfind(spanBuilder)
+          break
+        case 'NAVIGATE':
+          results = await this.runNavigate(maxSteps, spanBuilder)
+          break
+        case 'SCHEDULE':
+          results = await this.runSchedule(maxSteps, spanBuilder)
+          break
+        default:
+          throw new Error(`Mode inconnu : ${this.mode}`)
+      }
+
+      // Émettre le span de succès
+      if (spanBuilder) {
+        const rowCount = this._countRows(results)
+        const span = spanBuilder.end({ rowCount })
+        shim.emitEnd(span)
+      }
+
+      return results
+
+    } catch (err) {
+      // Émettre le span d'erreur
+      if (spanBuilder) {
+        const span = spanBuilder.endWithError(err as Error, {
+          compiledGraphHash: 'unknown',
+          weights:           {},
+          cacheState:        { l1HitRate: 0, l2HitRate: 0, globalHitRate: 0, yoyoEvents: 0 },
+        })
+        shim.emitError(span)
+      }
+      throw err
+    }
+  }
+
+  // ==================== PRIVATE (inchangé sauf signature + step timings) ====================
+
+  private async runPathfind(
+    spanBuilder: ReturnType<typeof shim.startSpan>
+  ): Promise<EngineStepResult[]> {
+    if (!this.pathFinder || !this.config.pathQuery) {
+      throw new Error('PATHFIND requiert pathQuery')
+    }
+
+    const { from, to, maxPaths = 5, transferPenalty = 0, via, minHops = 0 } = this.config.pathQuery
+    const startTime = Date.now()
+
+    const hookResult = await this.hooks.call('traversal.before', {
+      from, to,
+      stack: [...this.trail.frames],
+      graph: this.graph,
+    })
+
+    if (hookResult.cancelled) {
+      this.errors.emit('traversal.failed', {
+        from, to,
+        reason: hookResult.reason ?? 'Annulé par hook traversal.before',
+      })
+      return [{ time: 0, mode: 'PATHFIND', result: { type: 'FAIL', reason: hookResult.reason } }]
+    }
+
+    // ── Step : PathFinder ────────────────────────────────────
+    spanBuilder?.stepStart('PathFinder')
+    const allPaths = this.pathFinder.findAllPaths(from, to, maxPaths, 50, transferPenalty, via, minHops)
+    spanBuilder?.stepEnd('PathFinder')
+
+    if (allPaths.length === 0) {
+      this.errors.emit('route.notfound', {
+        from, to,
+        stack: [...this.trail.frames],
+      })
+      return [{ time: 0, mode: 'PATHFIND', result: { type: 'FAIL', reason: 'Aucun chemin trouvé' } }]
+    }
+
+    const pathsWithDetails = allPaths
+      .map(nodes => {
+        const edges: GraphEdge[] = []
+        let totalWeight = 0
+        for (let i = 0; i < nodes.length - 1; i++) {
+          const edge = this.graph.edges.find(e => e.from === nodes[i] && e.to === nodes[i + 1])
+          if (edge) { edges.push(edge); totalWeight += edge.weight }
+        }
+        return { nodes, edges, totalWeight } as NavigationPath
+      })
+      .sort((a, b) => a.totalWeight - b.totalWeight)
+      .slice(0, maxPaths)
+
+    const best = pathsWithDetails[0]
+
+    // Mettre à jour le path dans le span
+    if (spanBuilder) {
+      ;(spanBuilder as any).withPath?.(best.nodes)
+    }
+
+    this.events.emit('traversal.complete', {
+      from, to,
+      path:        best,
+      durationMs:  Date.now() - startTime,
+      stackDepth:  this.trail.depth,
+      routeUsed:   best.nodes.join('→'),
+      routeWeight: best.totalWeight,
+    })
+
+    return pathsWithDetails.map((path, index) => ({
+      time:   index,
+      mode:   'PATHFIND' as const,
+      path,
+      result: { type: 'SUCCESS' as const, data: { rank: index + 1, allPaths: pathsWithDetails } }
+    }))
+  }
+
+  private async runNavigate(
+    maxSteps: number,
+    spanBuilder: ReturnType<typeof shim.startSpan>
+  ): Promise<EngineStepResult[]> {
+    if (!this.resolver) throw new Error('NAVIGATE requiert Resolver')
+
+    const results: EngineStepResult[] = []
+
+    for (let t = 0; t < maxSteps; t++) {
+      const resolved   = this.trail.frames.filter(f => f.state === 'RESOLVED').length
+      const unresolved = this.trail.unresolved
+
+      if (unresolved.length === 0) {
+        results.push({
+          time: t, mode: 'NAVIGATE', phase: 'COMPLETE',
+          resolvedCount: resolved, unresolvedCount: 0,
+          result: { type: 'SUCCESS' }
+        })
+        break
+      }
+
+      const nextUnresolved = unresolved[0]
+
+      const hookResult = await this.hooks.call('traversal.before', {
+        from:  [...this.trail.frames].reverse().find(f => f.state === 'RESOLVED')?.entity ?? '',
+        to:    nextUnresolved.entity,
+        stack: [...this.trail.frames],
+        graph: this.graph,
+      })
+
+      if (hookResult.cancelled) {
+        this.errors.emit('traversal.failed', {
+          from:   '',
+          to:     nextUnresolved.entity,
+          reason: hookResult.reason ?? 'Annulé par hook traversal.before',
+        })
+        results.push({
+          time: t, mode: 'NAVIGATE', phase: 'COMPLETE',
+          result: { type: 'FAIL', reason: hookResult.reason }
+        })
+        break
+      }
+
+      const accessResult = await this.hooks.call('access.check', {
+        node:    nextUnresolved.entity,
+        stack:   [...this.trail.frames],
+        context: this.trail.user,
+      })
+
+      if (accessResult.cancelled) {
+        this.errors.emit('access.denied', {
+          node:   nextUnresolved.entity,
+          reason: accessResult.reason ?? 'Accès refusé',
+          stack:  [...this.trail.frames],
+        })
+        results.push({
+          time: t, mode: 'NAVIGATE', phase: 'COMPLETE',
+          result: { type: 'FAIL', reason: accessResult.reason }
+        })
+        break
+      }
+
+      const startTime    = Date.now()
+      const currentStack = [...this.trail.frames] as Frame[]
+
+      // ── Step : Resolver ──────────────────────────────────
+      spanBuilder?.stepStart('Resolver')
+      const newStack = await this.resolver.resolve(currentStack)
+      spanBuilder?.stepEnd('Resolver')
+
+      for (const newFrame of newStack) {
+        if (newFrame.state === 'RESOLVED' || newFrame.state === 'DEFERRED') {
+          this.trail.updateFrame(newFrame.entity, newFrame)
+        }
+      }
+
+      const justResolved = newStack.find(
+        f => f.entity === nextUnresolved.entity && f.state === 'RESOLVED'
+      )
+      if (justResolved?.resolvedBy) {
+        this.events.emit('traversal.complete', {
+          from:        justResolved.resolvedBy.via,
+          to:          justResolved.entity,
+          path:        { nodes: [justResolved.resolvedBy.via, justResolved.entity], edges: [], totalWeight: 0 },
+          durationMs:  Date.now() - startTime,
+          stackDepth:  this.trail.depth,
+          routeUsed:   justResolved.resolvedBy.relation,
+          routeWeight: 0,
+        })
+      }
+
+      results.push({
+        time: t, mode: 'NAVIGATE', phase: 'RESOLVE',
+        resolvedCount: resolved, unresolvedCount: unresolved.length
+      })
+    }
+
+    return results
+  }
+
+  private async runSchedule(
+    maxSteps: number,
+    spanBuilder: ReturnType<typeof shim.startSpan>
+  ): Promise<EngineStepResult[]> {
+    if (!this.scheduler) throw new Error('SCHEDULE requiert Scheduler')
+
+    const results: EngineStepResult[] = []
+    let currentStack: Frame[] = [...this.trail.frames]
+
+    for (let t = 0; t < maxSteps; t++) {
+      // ── Step : Scheduler ─────────────────────────────────
+      spanBuilder?.stepStart('Scheduler')
+      const stepResult = await this.scheduler.step(t, currentStack)
+      spanBuilder?.stepEnd('Scheduler')
+
+      if (!stepResult) {
+        results.push({
+          time: t, mode: 'SCHEDULE', phase: 'COMPLETE',
+          result: { type: 'SUCCESS', reason: 'Plus aucune action disponible' }
+        })
+        break
+      }
+
+      currentStack = stepResult.updatedStack
+
+      this.events.emit('traversal.complete', {
+        from:        stepResult.selectedAction,
+        to:          currentStack[currentStack.length - 1]?.entity ?? '',
+        path:        { nodes: [], edges: [], totalWeight: 0 },
+        durationMs:  0,
+        stackDepth:  this.trail.depth,
+        routeUsed:   stepResult.selectedAction,
+        routeWeight: 0,
+      })
+
+      results.push({
+        time: t, mode: 'SCHEDULE', phase: 'EXECUTE',
+        selectedAction: stepResult.selectedAction,
+        result:         stepResult.result
+      })
+    }
+
+    return results
+  }
+
+  // ==================== HELPERS INSTRUMENTATION ====================
+
+  private _buildTrailString(): string {
+    return this.trail.frames
+      .map(f => f.id !== undefined ? `${f.entity}(${f.id})` : f.entity)
+      .join('.')
+  }
+
+  private _resolvedFrom(): string {
+    const resolved = [...this.trail.frames].reverse().find(f => f.state === 'RESOLVED')
+    if (resolved) return resolved.entity
+    if (this.config.pathQuery) return this.config.pathQuery.from
+    return this.trail.frames[0]?.entity ?? ''
+  }
+
+  private _targetTo(): string {
+    const unresolved = this.trail.unresolved[0]
+    if (unresolved) return unresolved.entity
+    if (this.config.pathQuery) return this.config.pathQuery.to
+    return this.trail.frames[this.trail.frames.length - 1]?.entity ?? ''
+  }
+
+  private _currentFilters(): Record<string, any> {
+    const resolved = this.trail.frames.find(f => f.state === 'RESOLVED' && f.id !== undefined)
+    return resolved?.id !== undefined ? { id: resolved.id } : {}
+  }
+
+  private _countRows(results: EngineStepResult[]): number {
+    // PATHFIND : nombre de chemins trouvés
+    if (this.mode === 'PATHFIND') {
+      return results.filter(r => r.result?.type === 'SUCCESS').length
+    }
+    // NAVIGATE/SCHEDULE : nombre de steps résolus
+    return results.filter(r => r.phase === 'RESOLVE' || r.phase === 'EXECUTE').length
+  }
+
+  // ==================== GETTERS ====================
+
+  getMode():  EngineMode { return this.mode }
+  getGraph(): Graph      { return this.graph }
+
+  /** @deprecated Utiliser engine.trail directement */
+  getCurrentStack(): Frame[] { return [...this.trail.frames] }
+}

package/src/navigation/Resolver.ts

@@ -0,0 +1,134 @@
+/**
+ * Resolver - Résolution sémantique de frames (mode NAVIGATE)
+ *
+ * Parcourt la stack, trouve la première frame UNRESOLVED,
+ * identifie la meilleure arête dans le graphe V3 (nodes/edges)
+ * et résout la frame avec les filtres appropriés.
+ */
+
+import type { Frame, Graph, GraphEdge, FrameFilter } from '../types/index.js'
+
+export class Resolver {
+  constructor(private graph: Graph) {}
+
+  /**
+   * Résout la prochaine frame UNRESOLVED dans la stack.
+   * Retourne une nouvelle stack avec la frame résolue (ou DEFERRED si impossible).
+   */
+  async resolve(stack: Frame[]): Promise<Frame[]> {
+    const unresolved = stack.filter(f => f.state === 'UNRESOLVED')
+
+    if (unresolved.length === 0) return stack
+
+    const frame = unresolved[0]
+
+    // Frame racine (en position 0, aucune frame résolue avant elle) :
+    // c'est une collection ou un point d'entrée — pas besoin d'arête entrante.
+    const frameIndex = stack.indexOf(frame)
+    const hasPriorResolved = stack
+      .slice(0, frameIndex)
+      .some(f => f.state === 'RESOLVED' && f.id !== undefined && f.id !== null)
+
+    if (!hasPriorResolved) {
+      return stack.map(f => (f === frame ? { ...f, state: 'RESOLVED' as const } : f))
+    }
+
+    const candidate = this.selectBestEdge(frame, stack)
+
+    if (!candidate) {
+      console.warn(`[Resolver] Aucune arête trouvée pour "${frame.entity}"`)
+      return stack.map(f => (f === frame ? { ...f, state: 'DEFERRED' as const } : f))
+    }
+
+    const { edge, sourceFrame } = candidate
+
+    const resolved: Frame = {
+      ...frame,
+      state: 'RESOLVED',
+      resolvedBy: {
+        relation: edge.name ?? `${edge.from}→${edge.to}`,
+        via: edge.via ?? edge.from,
+        filters: [
+          {
+            field: `${sourceFrame.entity.toLowerCase()}Id`,
+            operator: 'equals',
+            value: sourceFrame.id!
+          },
+          // Filtres portés par l'arête elle-même (ex: condition sémantique)
+          ...this.extractEdgeFilters(edge)
+        ]
+      }
+    }
+
+    return stack.map(f => (f === frame ? resolved : f))
+  }
+
+  /**
+   * Trouve l'arête la plus pertinente pour résoudre une frame.
+   *
+   * Logique : on cherche parmi les frames RESOLVED (en remontant la stack),
+   * une arête qui va de cette entité source vers l'entité cible.
+   */
+  private selectBestEdge(
+    frame: Frame,
+    stack: Frame[]
+  ): { edge: GraphEdge; sourceFrame: Frame } | null {
+    // Frames résolues, les plus récentes en premier (dernier contexte connu)
+    const resolvedFrames = [...stack]
+      .reverse()
+      .filter(f => f.state === 'RESOLVED' && f.id !== undefined && f.id !== null)
+
+    for (const source of resolvedFrames) {
+      const candidates = this.graph.edges.filter(edge => {
+        // L'arête doit partir de l'entité source et arriver à l'entité cible
+        const matchesDirection = edge.from === source.entity && edge.to === frame.entity
+
+        // Si la frame a une intention, on vérifie la compatibilité sémantique
+        if (matchesDirection && frame.intent && edge.metadata?.condition) {
+          return this.intentMatchesCondition(frame.intent, edge.metadata.condition)
+        }
+
+        return matchesDirection
+      })
+
+      // On prend la candidate avec le poids le plus faible (chemin le plus direct)
+      if (candidates.length > 0) {
+        const best = candidates.sort((a, b) => a.weight - b.weight)[0]
+        return { edge: best, sourceFrame: source }
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Vérifie si l'intention de la frame est compatible avec
+   * les conditions sémantiques portées par l'arête.
+   */
+  private intentMatchesCondition(
+    intent: Record<string, any>,
+    condition: string | Record<string, any>
+  ): boolean {
+    if (typeof condition === 'string') return true // Pas de condition structurée
+
+    return Object.entries(condition).every(([key, value]) => {
+      if (intent[key] === undefined) return true // On ne filtre pas ce qu'on ne connaît pas
+      return intent[key] === value
+    })
+  }
+
+  /**
+   * Extrait les filtres implicites portés par les métadonnées d'une arête.
+   * Ex: une arête sémantique { condition: { jobId: 2 } } devient un filtre.
+   */
+  private extractEdgeFilters(edge: GraphEdge): FrameFilter[] {
+    const condition = edge.metadata?.condition
+    if (!condition || typeof condition === 'string') return []
+
+    return Object.entries(condition).map(([field, value]) => ({
+      field,
+      operator: 'equals' as const,
+      value
+    }))
+  }
+}

package/src/navigation/Scheduler.ts

@@ -0,0 +1,136 @@
+/**
+ * Scheduler - Exécution d'actions par priorité (mode SCHEDULE)
+ *
+ * À chaque step :
+ *   1. Filtre les actions disponibles (condition when + cooldown + terminal)
+ *   2. Sélectionne la plus prioritaire (weight le plus élevé)
+ *   3. L'exécute et met à jour l'état interne
+ *
+ * C'est le cœur du moteur d'agent : une boucle de décision
+ * déterministe basée sur les poids et l'état de la stack.
+ */
+
+import type {
+  ScheduleAction,
+  ActionState,
+  Frame,
+  Graph,
+  NavigationResult
+} from '../types/index.js'
+
+export interface SchedulerStepResult {
+  selectedAction: string
+  result: NavigationResult
+  updatedStack: Frame[]
+}
+
+export class Scheduler {
+  private actionStates: Map<string, ActionState>
+
+  constructor(
+    private actions: ScheduleAction[],
+    private graph: Graph
+  ) {
+    // Initialise l'état de chaque action
+    this.actionStates = new Map(
+      actions.map(a => [
+        a.name,
+        { cooldownUntil: 0, executionCount: 0, executed: false }
+      ])
+    )
+  }
+
+  /**
+   * Exécute un step du scheduler.
+   * Retourne null si aucune action n'est disponible (terminaison naturelle).
+   */
+  async step(time: number, stack: Frame[]): Promise<SchedulerStepResult | null> {
+    const available = this.getAvailableActions(time, stack)
+
+    if (available.length === 0) return null
+
+    // Sélection déterministe : weight le plus élevé
+    const selected = available.reduce((best, action) =>
+      action.weight > best.weight ? action : best
+    )
+
+    console.log(`  ⚙️  [Scheduler t=${time}] → ${selected.name} (weight: ${selected.weight})`)
+
+    let result: NavigationResult
+    let updatedStack: Frame[] = stack
+
+    try {
+      updatedStack = await selected.execute(stack, this.graph)
+      result = { type: 'SUCCESS', data: updatedStack }
+    } catch (err) {
+      result = {
+        type: 'FAIL',
+        reason: err instanceof Error ? err.message : String(err)
+      }
+      console.error(`  ❌ [Scheduler] Action échouée: ${selected.name}`, err)
+    }
+
+    // Callback optionnel (analytics, logging externe...)
+    if (selected.onUse) {
+      try {
+        selected.onUse(stack, result)
+      } catch {
+        // Silencieux — le callback ne doit pas planter le scheduler
+      }
+    }
+
+    // Mise à jour de l'état de l'action
+    this.updateState(selected, result, time)
+
+    return {
+      selectedAction: selected.name,
+      result,
+      updatedStack: result.type === 'SUCCESS' ? updatedStack : stack
+    }
+  }
+
+  /**
+   * Retourne les actions disponibles à un instant t pour une stack donnée.
+   * Filtre : terminal déjà exécuté, cooldown, maxExecutions, condition when().
+   */
+  getAvailableActions(time: number, stack: Frame[]): ScheduleAction[] {
+    return this.actions.filter(action => {
+      const state = this.actionStates.get(action.name)!
+
+      // Action terminale déjà exécutée
+      if (action.terminal && state.executed) return false
+
+      // En cooldown
+      if (state.cooldownUntil > time) return false
+
+      // Limite d'exécutions atteinte
+      if (action.maxExecutions !== undefined && state.executionCount >= action.maxExecutions) {
+        return false
+      }
+
+      // Condition métier
+      if (!action.when) return true
+
+      try {
+        return action.when(stack)
+      } catch {
+        return false
+      }
+    })
+  }
+
+  private updateState(action: ScheduleAction, result: NavigationResult, time: number): void {
+    const current = this.actionStates.get(action.name)!
+
+    this.actionStates.set(action.name, {
+      cooldownUntil: result.type === 'DEFER' ? time + (action.cooldown ?? 0) : 0,
+      executionCount: current.executionCount + 1,
+      executed: action.terminal ? true : current.executed,
+      lastResult: result
+    })
+  }
+
+  getActionState(name: string): ActionState | undefined {
+    return this.actionStates.get(name)
+  }
+}