SkillForge (arXiv:2610.09832 / NeurIPS 2026): Co-Evolving Skills & Agents via Dynamic Skill Lifecycles, Solusi Obsolete Memory & Peningkatan Akurasi RL Otonom

// Production Implementation: SkillForge Dynamic Lifecycle & Memory Pruning Engine
// Mengimplementasikan Fitness-Driven Lifecycle (Trial -> Active -> Stable -> Retired) sesuai arXiv:2610.09832

export type SkillState = 'TRIAL' | 'ACTIVE' | 'STABLE' | 'RETIRED';

export interface SkillDescriptor {
  id: string;
  name: string;
  taskCondition: string; // Predikat kondisi penerapan tugas (Applicability Condition)
  instructions: string;   // Prosedur langkah kerja / playbook aksi
  state: SkillState;
  createdAtIteration: number;
  lastUpdatedIteration: number;
  metrics: {
    invocations: number;
    successCount: number;
    failureCount: number;
    averageDeltaReward: number;
    costTokenAverage: number;
    fitnessScore: number;
  };
}

export interface RolloutFeedback {
  skillId: string;
  taskSuccess: boolean;
  rewardGain: number;
  tokenConsumption: number;
  errorTrace?: string;
}

export interface LifecycleThresholds {
  minTrialInvocations: number;
  activePromotionFitness: number;
  stablePromotionFitness: number;
  retirementFitnessFloor: number;
  maxConsecutiveFailures: number;
}

export class SkillForgeLifecycleEngine {
  private library: Map = new Map();
  private retirementArchive: Map = new Map();

  constructor(
    private thresholds: LifecycleThresholds = {
      minTrialInvocations: 5,
      activePromotionFitness: 0.65,
      stablePromotionFitness: 0.88,
      retirementFitnessFloor: 0.35,
      maxConsecutiveFailures: 3,
    }
  ) {}

  /**
   * 1. Ingest Skill Baru ke Status TRIAL
   */
  public registerDiscoveredSkill(
    name: string,
    taskCondition: string,
    instructions: string,
    currentIteration: number
  ): SkillDescriptor {
    const skill: SkillDescriptor = {
      id: `skill_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`,
      name,
      taskCondition,
      instructions,
      state: 'TRIAL',
      createdAtIteration: currentIteration,
      lastUpdatedIteration: currentIteration,
      metrics: {
        invocations: 0,
        successCount: 0,
        failureCount: 0,
        averageDeltaReward: 0,
        costTokenAverage: 0,
        fitnessScore: 0.5, // Netral prior
      },
    };

    this.library.set(skill.id, skill);
    return skill;
  }

  /**
   * 2. Hitung Composite Fitness Score (arXiv:2610.09832 Eq. 2)
   * Fitness = w_sr * SR + w_rew * DeltaReward - w_cost * NormCost - w_fail * FailurePenalty
   */
  public updateSkillRollout(feedback: RolloutFeedback, currentIteration: number): void {
    const skill = this.library.get(feedback.skillId);
    if (!skill || skill.state === 'RETIRED') return;

    const m = skill.metrics;
    m.invocations += 1;
    if (feedback.taskSuccess) {
      m.successCount += 1;
    } else {
      m.failureCount += 1;
    }

    // Exponential moving average untuk reward gain dan cost
    const alpha = 0.2;
    m.averageDeltaReward = (1 - alpha) * m.averageDeltaReward + alpha * feedback.rewardGain;
    m.costTokenAverage = (1 - alpha) * m.costTokenAverage + alpha * feedback.tokenConsumption;

    const successRate = m.successCount / m.invocations;
    const normalizedCost = Math.min(m.costTokenAverage / 2000, 1.0);

    // Formulasi Fitness: Sukses (45%) + Delta Reward (35%) - Token Overhead (10%) - Failure Penalty (10%)
    m.fitnessScore = Math.max(
      0,
      0.45 * successRate +
      0.35 * Math.tanh(m.averageDeltaReward) -
      0.10 * normalizedCost -
      0.10 * (m.failureCount / m.invocations)
    );

    skill.lastUpdatedIteration = currentIteration;

    // Evaluasi Transisi State Siklus Hidup
    this.evaluateLifecycleTransition(skill);
  }

  /**
   * 3. Evaluasi State Transition Machine (Trial -> Active -> Stable -> Retired)
   */
  private evaluateLifecycleTransition(skill: SkillDescriptor): void {
    const m = skill.metrics;

    // A. Transisi dari TRIAL
    if (skill.state === 'TRIAL') {
      if (m.invocations >= this.thresholds.minTrialInvocations) {
        if (m.fitnessScore >= this.thresholds.activePromotionFitness) {
          skill.state = 'ACTIVE';
          console.log(`[LIFECYCLE] Skill "${skill.name}" dipromosikan: TRIAL -> ACTIVE (Fitness: ${m.fitnessScore.toFixed(3)})`);
        } else if (m.fitnessScore < this.thresholds.retirementFitnessFloor) {
          this.retireSkill(skill, 'Gagal masa percobaan (Low Fitness Trial)');
        }
      }
      return;
    }

    // B. Transisi dari ACTIVE
    if (skill.state === 'ACTIVE') {
      if (m.fitnessScore >= this.thresholds.stablePromotionFitness && m.invocations >= 15) {
        skill.state = 'STABLE';
        console.log(`[LIFECYCLE] Skill "${skill.name}" dikristalisasi: ACTIVE -> STABLE (Fitness: ${m.fitnessScore.toFixed(3)})`);
      } else if (m.fitnessScore < this.thresholds.retirementFitnessFloor) {
        this.retireSkill(skill, 'Degradasi performa kebijakan (Obsolete Active Skill)');
      }
      return;
    }

    // C. Evaluasi STABLE (Bisa terkena regresi jika policy agen berevolusi melampaui skill tersebut)
    if (skill.state === 'STABLE') {
      if (m.fitnessScore < this.thresholds.activePromotionFitness) {
        skill.state = 'ACTIVE';
        console.log(`[LIFECYCLE] Skill "${skill.name}" diturunkan: STABLE -> ACTIVE (Fitness: ${m.fitnessScore.toFixed(3)})`);
      }
    }
  }

  /**
   * 4. Pensiunkan & Arsipkan Skill Kadaluarsa (Mencegah Pencemaran Context Memory)
   */
  private retireSkill(skill: SkillDescriptor, reason: string): void {
    skill.state = 'RETIRED';
    this.library.delete(skill.id);
    this.retirementArchive.set(skill.id, skill);
    console.log(`[LIFECYCLE] Skill "${skill.name}" DIPENSIUNKAN: ${reason} (Fitness: ${skill.metrics.fitnessScore.toFixed(3)})`);
  }

  /**
   * 5. LLM-Guided Mutation: Memperbaiki instruksi skill aktif yang mengalami bottleneck
   */
  public generateMutationCandidate(skillId: string, errorAnalysis: string): string {
    const skill = this.library.get(skillId);
    if (!skill) throw new Error('Skill tidak ditemukan');

    // Menghasilkan instruksi revisi yang mengoreksi pola kegagalan
    return `// Mutated instructions for ${skill.name}\n// Root Cause Solved: ${errorAnalysis}\n${skill.instructions}\n// [MUTATION GUARD]: Validasi prasyarat sebelum eksekusi aksi kritis.`;
  }

  public getActiveLibrary(): SkillDescriptor[] {
    return Array.from(this.library.values()).filter(s => s.state !== 'RETIRED');
  }

  public getCompactContextPrompt(): string {
    return this.getActiveLibrary()
      .map(s => `[${s.state}] ${s.name} (Fitness: ${s.metrics.fitnessScore.toFixed(2)}): ${s.taskCondition} -> ${s.instructions}`)
      .join('\n\n');
  }
}