GEPA-Curator (arXiv:2610.37651): Mengeliminasi Halusinasi Refleksi pada Self-Improving AI Agents via Adaptive Task Curation, Contrastive Prior Success, dan Meta-Harness Optimization

// Production Implementation: GEPA-Curator Outer-Loop Harness
// Mengeliminasi "Reflection Hallucination" pada Recursive Self-Improvement (RSI) Agents
// Berdasarkan Prinsip Rekayasa arXiv:2610.37651 (UC Berkeley, Furiosa AI, KAIST)

export interface AgentStepTrace {
  step: number;
  action: string;
  observation: string;
  toolCallId?: string;
  status: 'success' | 'client_error' | 'env_failure' | 'timeout';
}

export interface TaskTrajectory {
  taskId: string;
  epoch: number;
  promptVersion: string;
  steps: AgentStepTrace[];
  isSuccess: boolean;
  score: number;
  failureCategory?: 'prompt_defect' | 'harness_bug' | 'env_outage' | 'noisy_judge';
  rawFeedback?: string;
  timestamp: number;
}

export interface TaskCurationMeta {
  taskId: string;
  totalRollouts: number;
  consecutiveSuccesses: number;
  consecutiveFailures: number;
  hasPersistentEnvFault: boolean;
  judgeInconsistencyRatio: number;
  lastCuratorStatus: 'RUN' | 'SKIP_STABLE' | 'SKIP_ENV_FAULT' | 'SKIP_NOISY_EVAL';
}

export interface ContrastiveReflectionPair {
  taskId: string;
  failedTrajectory: TaskTrajectory;
  anchorSuccessfulTrajectory?: TaskTrajectory;
  curatorDiagnosticNotes: string;
}

export class GEPACuratorEngine {
  private readonly historyStore = new Map();
  private readonly metadataStore = new Map();

  constructor(
    private readonly config: {
      stableSuccessThreshold: number;      // e.g. 3 consecutive passes
      persistentEnvFaultThreshold: number; // e.g. 3 consecutive identical harness/env errors
      inconsistentJudgeThreshold: number;  // e.g. > 0.4 score variance on identical actions
      minExplorationRounds: number;        // e.g. 2 minimum tries before eligible to skip
    } = {
      stableSuccessThreshold: 3,
      persistentEnvFaultThreshold: 3,
      inconsistentJudgeThreshold: 0.35,
      minExplorationRounds: 2,
    }
  ) {}

  /**
   * Menganalisis riwayat task untuk menentukan apakah task memberikan sinyal gradien bersih
   * atau harus di-skip sementara untuk mencegah pencemaran prompt.
   */
  public evaluateTaskEligibility(taskId: string): { action: 'RUN' | 'SKIP'; reason: string } {
    const history = this.historyStore.get(taskId) || [];
    
    // Prioritas 1: Selalu eksplorasi task baru yang belum memiliki riwayat cukup
    if (history.length < this.config.minExplorationRounds) {
      return { action: 'RUN', reason: 'INSUFFICIENT_HISTORY_EXPLORATION_REQUIRED' };
    }

    const meta = this.getOrInitMeta(taskId);

    // Kriteria 1: Stable Success (Task sudah mantap terselesaikan, tidak memberi gradien baru)
    if (meta.consecutiveSuccesses >= this.config.stableSuccessThreshold) {
      meta.lastCuratorStatus = 'SKIP_STABLE';
      return { 
        action: 'SKIP', 
        reason: `STABLE_SUCCESS: Lolos ${meta.consecutiveSuccesses}x beruntun. Jangan overfit prompt.` 
      };
    }

    // Kriteria 2: Persistent Harness/Environment Failure (Tombol web rusak, API timeout)
    if (meta.hasPersistentEnvFault && meta.consecutiveFailures >= this.config.persistentEnvFaultThreshold) {
      meta.lastCuratorStatus = 'SKIP_ENV_FAULT';
      return { 
        action: 'SKIP', 
        reason: 'ENV_FAILURE_ISOLATED: Kerusakan infrastruktur/web button, bukan cacat prompt.' 
      };
    }

    // Kriteria 3: Evaluasi Tidak Konsisten (Noisy LLM-as-a-judge)
    if (meta.judgeInconsistencyRatio > this.config.inconsistentJudgeThreshold) {
      meta.lastCuratorStatus = 'SKIP_NOISY_EVAL';
      return { 
        action: 'SKIP', 
        reason: 'NOISY_EVAL_DISCARDED: Skor LLM judge bertentangan pada trajektori serupa.' 
      };
    }

    meta.lastCuratorStatus = 'RUN';
    return { action: 'RUN', reason: 'CLEAN_OPTIMIZATION_SIGNAL' };
  }

  /**
   * Mengambil trajektori sukses masa lalu yang paling valid sebagai jangkar (anchor)
   * untuk refleksi kontrastif bagi Reflector.
   */
  public retrievePriorSuccess(taskId: string): TaskTrajectory | undefined {
    const history = this.historyStore.get(taskId) || [];
    const successes = history.filter(t => t.isSuccess && t.score >= 1.0);
    
    if (successes.length === 0) return undefined;

    // Utamakan trajektori sukses dengan langkah terpendek dan verifikasi terbersih
    return successes.sort((a, b) => a.steps.length - b.steps.length)[0];
  }

  /**
   * Menyusun curated minibatch untuk dikirimkan ke Prompt Reflector
   */
  public buildCuratedBatch(candidateTaskIds: string[]): {
    curatedTaskIds: string[];
    skippedTaskIds: { id: string; reason: string }[];
  } {
    const curated: string[] = [];
    const skipped: { id: string; reason: string }[] = [];

    for (const taskId of candidateTaskIds) {
      const decision = this.evaluateTaskEligibility(taskId);
      if (decision.action === 'RUN') {
        curated.push(taskId);
      } else {
        skipped.push({ id: taskId, reason: decision.reason });
      }
    }

    return { curatedTaskIds: curated, skippedTaskIds: skipped };
  }

  /**
   * Menghasilkan konteks refleksi kontrastif terpadu untuk LLM Reflector
   */
  public assembleContrastiveContext(
    failedRun: TaskTrajectory
  ): ContrastiveReflectionPair {
    const priorSuccess = this.retrievePriorSuccess(failedRun.taskId);
    
    let diagnostic = '';
    if (priorSuccess) {
      diagnostic = `ANALYTIC CONTRAST AVAILABLE: Task ${failedRun.taskId} pernah berhasil diselesaikan pada epoch ${priorSuccess.epoch} dalam ${priorSuccess.steps.length} langkah. Bandingkan titik divergensi aksi pada step kegagalan saat ini.`;
    } else {
      diagnostic = `NO_PRIOR_SUCCESS_ANCHOR: Belum ada referensi sukses terverifikasi. Refleksi berbasis analisa heuristik murni.`;
    }

    return {
      taskId: failedRun.taskId,
      failedTrajectory: failedRun,
      anchorSuccessfulTrajectory: priorSuccess,
      curatorDiagnosticNotes: diagnostic,
    };
  }

  /**
   * Mencatat hasil eksekusi baru dan memperbarui profil statistik task
   */
  public recordExecution(trajectory: TaskTrajectory): void {
    const list = this.historyStore.get(trajectory.taskId) || [];
    list.push(trajectory);
    this.historyStore.set(trajectory.taskId, list);

    const meta = this.getOrInitMeta(trajectory.taskId);
    meta.totalRollouts += 1;

    if (trajectory.isSuccess) {
      meta.consecutiveSuccesses += 1;
      meta.consecutiveFailures = 0;
      meta.hasPersistentEnvFault = false;
    } else {
      meta.consecutiveFailures += 1;
      meta.consecutiveSuccesses = 0;
      if (trajectory.failureCategory === 'env_outage' || trajectory.failureCategory === 'harness_bug') {
        meta.hasPersistentEnvFault = true;
      }
    }
  }

  private getOrInitMeta(taskId: string): TaskCurationMeta {
    if (!this.metadataStore.has(taskId)) {
      this.metadataStore.set(taskId, {
        taskId,
        totalRollouts: 0,
        consecutiveSuccesses: 0,
        consecutiveFailures: 0,
        hasPersistentEnvFault: false,
        judgeInconsistencyRatio: 0,
        lastCuratorStatus: 'RUN',
      });
    }
    return this.metadataStore.get(taskId)!;
  }
}