HEXIS 2026: Mengapa Frontier AI Agents Kerap Gagal Mematuhi Skills, Kompilasi Natural Language ke Extended Finite State Machines (EFSM), dan Pemisahan Knowledge vs Control Flow

/**
 * HEXIS: Extended Finite State Machine (EFSM) Compiler & Execution Engine
 * Berdasarkan formulasi matematis riset arXiv:2609.30123 (September 2026)
 *
 * Prinsip Inti:
 * 1. Decoupled Control & Knowledge: Model hanya melakukan reasoning lokal pada state saat ini (p_q).
 * 2. Guarded State Transitions: Runtime mengevaluasi kondisi transisi deterministik secara urut (g_j(v+)).
 * 3. Typed Variable Binding: Data operasional diisolasi pada register variabel v, bukan riwayat teks mentah.
 */

export type VariableValue = string | number | boolean | Record | any[];
export type VariableStore = Record;

export interface StateTransitionGuard {
  targetStateId: string;
  condition: (vars: VariableStore) => boolean;
  description: string;
}

export type StateOperationKind = 'MODEL_INFERENCE' | 'TOOL_INVOCATION' | 'TERMINAL';

export interface EFSMState {
  id: string;
  kind: StateOperationKind;
  description: string;
  localInstruction: string; // p_q: instruksi lokal yang diisolasi
  readVariables: string[];  // R_q: subset variabel yang dibaca
  writeVariables: string[]; // W_q: subset variabel yang ditulis
  toolTarget?: string;
  toolArgsTemplate?: Record;
  outgoingEdges: StateTransitionGuard[]; // E_q: transisi berurutan
  terminalOutcome?: 'SUCCESS' | 'FAILURE' | 'ABORTED';
}

export interface EFSMDefinition {
  name: string;
  version: string;
  initialStateId: string;
  variables: Record;
  states: Map;
  terminalStateIds: Set;
}

export interface ExecutionStepTrace {
  step: number;
  stateId: string;
  stateKind: StateOperationKind;
  inputs: Record;
  outputs: Record;
  selectedTransitionTarget: string | null;
  durationMs: number;
}

/**
 * Runtime Executor untuk Mesin EFSM Terkompilasi HEXIS
 */
export class HEXISEFSMRuntime {
  private definition: EFSMDefinition;
  private variables: VariableStore;
  private currentStateId: string;
  private stepCount: number = 0;
  private executionTrace: ExecutionStepTrace[] = [];

  constructor(definition: EFSMDefinition) {
    this.definition = definition;
    this.variables = {};
    for (const [key, meta] of Object.entries(definition.variables)) {
      this.variables[key] = meta.initialValue;
    }
    this.currentStateId = definition.initialStateId;
  }

  /**
   * Menjalankan siklus eksekusi state machine hingga mencapai terminal state atau batas iterasi
   */
  public async execute(
    modelInvoker: (prompt: string, context: Record) => Promise>,
    toolInvoker: (tool: string, args: Record) => Promise>,
    maxSteps: number = 50
  ): Promise<{
    outcome: 'SUCCESS' | 'FAILURE' | 'ABORTED' | 'STEP_LIMIT_EXCEEDED';
    variables: VariableStore;
    trace: ExecutionStepTrace[];
  }> {
    while (this.stepCount < maxSteps) {
      this.stepCount++;
      const state = this.definition.states.get(this.currentStateId);
      if (!state) {
        throw new Error(`Runtime Error: State "${this.currentStateId}" tidak terdaftar dalam EFSM.`);
      }

      const start = performance.now();

      // 1. Ekstraksi Restricted View Variables (v | R_q)
      const restrictedView: Record = {};
      for (const varName of state.readVariables) {
        restrictedView[varName] = this.variables[varName];
      }

      let writePayload: Record = {};

      // 2. Eksekusi Operasi Lokal State
      if (state.kind === 'MODEL_INFERENCE') {
        // Model hanya melihat instruksi lokal p_q dan variabel input yang dideklarasikan
        writePayload = await modelInvoker(state.localInstruction, restrictedView);
      } else if (state.kind === 'TOOL_INVOCATION') {
        const resolvedArgs: Record = {};
        for (const [argKey, template] of Object.entries(state.toolArgsTemplate || {})) {
          resolvedArgs[argKey] = this.resolveVariableTemplate(template, this.variables);
        }
        writePayload = await toolInvoker(state.toolTarget!, resolvedArgs);
      } else if (state.kind === 'TERMINAL') {
        return {
          outcome: state.terminalOutcome || 'SUCCESS',
          variables: this.variables,
          trace: this.executionTrace,
        };
      }

      // 3. Update Register Variabel: v+ = v[W_q <- y_q]
      for (const varName of state.writeVariables) {
        if (varName in writePayload) {
          this.variables[varName] = writePayload[varName];
        }
      }

      // 4. Evaluasi Guarded Transitions: j* = min { j : g_j(v+) == true }
      let nextStateId: string | null = null;
      for (const edge of state.outgoingEdges) {
        if (edge.condition(this.variables)) {
          nextStateId = edge.targetStateId;
          break;
        }
      }

      const elapsed = performance.now() - start;

      this.executionTrace.push({
        step: this.stepCount,
        stateId: state.id,
        stateKind: state.kind,
        inputs: restrictedView,
        outputs: writePayload,
        selectedTransitionTarget: nextStateId,
        durationMs: Number(elapsed.toFixed(2)),
      });

      if (!nextStateId) {
        // Fallback jika tidak ada edge yang terpenuhi
        return {
          outcome: 'ABORTED',
          variables: this.variables,
          trace: this.executionTrace,
        };
      }

      this.currentStateId = nextStateId;
      if (this.definition.terminalStateIds.has(this.currentStateId)) {
        const termState = this.definition.states.get(this.currentStateId);
        return {
          outcome: termState?.terminalOutcome || 'SUCCESS',
          variables: this.variables,
          trace: this.executionTrace,
        };
      }
    }

    return {
      outcome: 'STEP_LIMIT_EXCEEDED',
      variables: this.variables,
      trace: this.executionTrace,
    };
  }

  private resolveVariableTemplate(template: string, vars: VariableStore): any {
    if (template.startsWith('$') && template.slice(1) in vars) {
      return vars[template.slice(1)];
    }
    return template;
  }
}

/**
 * Static Safety & Verification Checker untuk Hasil Kompilasi EFSM
 */
export class HEXISStaticVerifier {
  public static verify(definition: EFSMDefinition): { valid: boolean; errors: string[] } {
    const errors: string[] = [];

    // Check initial state
    if (!definition.states.has(definition.initialStateId)) {
      errors.push(`Initial state "${definition.initialStateId}" tidak ditemukan.`);
    }

    // Check reachability and variable soundness
    for (const [id, state] of definition.states.entries()) {
      if (state.kind !== 'TERMINAL' && state.outgoingEdges.length === 0) {
        errors.push(`Non-terminal state "${id}" tidak memiliki outgoing edges.`);
      }
      for (const edge of state.outgoingEdges) {
        if (!definition.states.has(edge.targetStateId)) {
          errors.push(`Edge dari state "${id}" mengarah ke target yang tidak valid: "${edge.targetStateId}".`);
        }
      }
    }

    return {
      valid: errors.length === 0,
      errors,
    };
  }
}