AEWM & EditAct 2026: Arsitektur Agent-Editing World Model, Mengeliminasi Task-State Contamination, Action Judge, dan State Revision pada Autonomous Agents

"""
AewmEditActEngine: Arsitektur Agent-Editing World Model & EditAct Runtime.
Berdasarkan formulasi riset Gaoling School of AI, Renmin University of China (arXiv:2609.28416, Sun et al., September 2026).

Komponen Arsitektur Utama:
1. Decision Judgment Layer (Action Judge): Mengklasifikasikan kelanjutan (reasoning, action) ke dalam {CRITICAL, EXPLORATORY, NOISY}.
2. Task-State Contamination Detector: Mencegah propagasi asumsi halusinatif dan rencana usang ke dalam history h_t.
3. State Revision Module (M_SR): Menggantikan pasangan (r_t, a_t) noisy dengan pasangan terkalibrasi (tilde_r_t, tilde_a_t) secara zero-overhead.
4. Grounded Execution Bridge (EditAct Loop): Menghubungkan intervensi state editing langsung ke environment fisik tanpa simulasi observasi artifisial.
5. AEWM-RFT Trajectory Collector: Mengumpulkan pasangan rollout terverifikasi untuk Rejection Sampling Fine-Tuning.
"""

from dataclasses import dataclass, field
from enum import Enum
from typing import List, Dict, Any, Optional, Tuple, Callable
import json
import re

class DecisionEffect(str, Enum):
    CRITICAL = "critical"        # Keputusan krusial yang esensial bagi progres penyelesaian tugas
    EXPLORATORY = "exploratory"  # Eksplorasi sah untuk mengumpulkan bukti atau memvalidasi hipotesis
    NOISY = "noisy"              # Keputusan berulang, spekulatif tanpa bukti, atau rencana kadaluarsa (state contamination)

@dataclass
class Continuation:
    reasoning: str
    action: str
    arguments: Dict[str, Any] = field(default_factory=dict)
    metadata: Dict[str, Any] = field(default_factory=dict)

@dataclass
class StepRecord:
    step_idx: int
    reasoning: str
    action: str
    arguments: Dict[str, Any]
    observation: str
    decision_effect: Optional[DecisionEffect] = None
    was_edited: bool = False

class ActionJudge:
    """
    Action Judge M_AJ memprediksi efek keputusan hilir (downstream contribution)
    dari konteks pra-eksekusi s_t = h_t oplus (hat_r_t, hat_a_t).
    Dilatih pada mid-training 52B tokens + SFT terkalibrasi (Macro-F1 70.5%).
    """
    def __init__(self, model_endpoint: Optional[str] = None):
        self.model_endpoint = model_endpoint

    def judge(self, task_instruction: str, history: List[StepRecord], proposed: Continuation) -> DecisionEffect:
        # Evaluasi pola state contamination dan redundansi aksi
        recent_actions = [s.action for s in history[-3:]] if len(history) >= 3 else []
        
        # 1. Deteksi Loop dan Redundansi Tindakan Tanpa Progres Baru
        if proposed.action in recent_actions and proposed.action != "view_file":
            # Jika aksi sama diulang tanpa bukti observasi baru, tandai sebagai NOISY
            last_obs = history[-1].observation if history else ""
            if "error" in last_obs.lower() or "not found" in last_obs.lower():
                return DecisionEffect.NOISY

        # 2. Deteksi Asumsi Halusinatif Tanpa Dasar Bukti (Task-State Contamination)
        unsupported_markers = [
            "saya berasumsi file ini ada",
            "mungkin bug ini disebabkan oleh x tanpa membaca",
            "langsung ubah kode tanpa verifikasi test",
            "assume without inspecting",
            "skip testing because it should work"
        ]
        if any(marker in proposed.reasoning.lower() for marker in unsupported_markers):
            return DecisionEffect.NOISY

        # 3. Klasifikasi Aksi Kritis (Modifikasi file, commit, submission jawaban)
        critical_verbs = ["write_file", "patch", "git_commit", "submit_solution", "rm", "database_migration"]
        if any(v in proposed.action.lower() for v in critical_verbs):
            return DecisionEffect.CRITICAL

        # 4. Eksplorasi Sah (Pencarian kode, inspeksi log, uji coba CLI)
        return DecisionEffect.EXPLORATORY

class StateRevisionModule:
    """
    State Revision M_SR menggantikan kelanjutan noisy (hat_r_t, hat_a_t)
    dengan (tilde_r_t, tilde_a_t) yang mencari bukti empiris atau memulihkan rencana.
    """
    def __init__(self):
        pass

    def revise(self, task_instruction: str, history: List[StepRecord], noisy: Continuation) -> Continuation:
        last_step = history[-1] if history else None
        
        # Skenario 1: Terjebak kegagalan tool sebelumnya -> alihkan ke inspeksi log / trace
        if last_step and ("error" in last_step.observation.lower() or "failed" in last_step.observation.lower()):
            return Continuation(
                reasoning=(
                    f"Intervensi State Revision: Rencana sebelumnya gagal akibat '{last_step.observation[:80]}...'. "
                    f"Alih-alih mengulang asumsi, lakukan inspeksi struktur kode dan verifikasi dependensi secara deterministik."
                ),
                action="inspect_diagnostics",
                arguments={"target": "recent_failure", "scope": "full_trace"},
                metadata={"revised_from_noisy": True}
            )

        # Skenario 2: Asumsi spekulatif -> ubah menjadi aksi pencarian bukti
        return Continuation(
            reasoning=(
                "Intervensi State Revision: Mendeteksi asumsi spekulatif yang tidak didukung bukti empiris. "
                "Mengganti rencana dengan langkah verifikasi baca file sebelum melakukan modifikasi struktural."
            ),
            action="read_file_or_search",
            arguments={"query": task_instruction[:60], "verify_first": True},
            metadata={"revised_from_noisy": True}
        )

class EditActRuntime:
    """
    Siklus Inferensi EditAct:
    Memadukan penilaian state dan intervensi revisi langsung sebelum aksi dipancarkan ke lingkungan riil.
    """
    def __init__(self, action_judge: ActionJudge, state_revision: StateRevisionModule):
        self.action_judge = action_judge
        self.state_revision = state_revision
        self.history: List[StepRecord] = []

    def step(
        self,
        task_instruction: str,
        propose_fn: Callable[[str, List[StepRecord]], Continuation],
        execute_fn: Callable[[str, Dict[str, Any]], str]
    ) -> StepRecord:
        # Langkah 1: Agen dasar mengajukan (hat_r_t, hat_a_t)
        proposed = propose_fn(task_instruction, self.history)
        
        # Langkah 2: Action Judge mengevaluasi kelanjutan
        decision_label = self.action_judge.judge(task_instruction, self.history, proposed)
        
        # Langkah 3: Intervensi selektif jika NOISY
        was_edited = False
        if decision_label == DecisionEffect.NOISY:
            effective_continuation = self.state_revision.revise(task_instruction, self.history, proposed)
            was_edited = True
        else:
            effective_continuation = proposed

        # Langkah 4: Eksekusi aksi terpilih pada real environment E
        # Observasi riil o_t diperoleh dari dunia nyata, BUKAN disimulasikan oleh world model!
        observation = execute_fn(effective_continuation.action, effective_continuation.arguments)

        # Langkah 5: Simpan ke jejak interaksi h_{t+1} = h_t oplus (r_t, a_t, o_t)
        step_record = StepRecord(
            step_idx=len(self.history) + 1,
            reasoning=effective_continuation.reasoning,
            action=effective_continuation.action,
            arguments=effective_continuation.arguments,
            observation=observation,
            decision_effect=decision_label,
            was_edited=was_edited
        )
        self.history.append(step_record)
        return step_record