reins — Sisakan Hanya Domain dari Quest CLI, Jadikan Ratchet sebagai Framework

reins — Sisakan Hanya Domain dari Quest CLI, Jadikan Ratchet sebagai Framework Image: AI generated

how-make-quest adalah cara membangun quest CLI dengan tangan kosong. Apa itu ratchet, bagaimana memasang gate, bagaimana menahan cheese. Beri satu artikel kepada agen, maka lahirlah Go CLI berbasis cobra.

Tetapi apa yang terjadi begitu Anda membangun quest CLI kedua. Anda menulis ulang mesin keadaan searah yang sama. Anda menulis ulang scan/next/submit/status/export yang sama. Anda menulis ulang penguncian PASS yang sama, penurunan monoton remaining yang sama, export JSONL yang sama. Yang berbeda hanya satu gate, namun setiap kali Anda menulis ulang seluruh sisanya. Inilah pajak boilerplate yang Anda bayar setiap kali membangun satu quest lagi.

Polanya bisa dipakai ulang. Kodenya tidak. reins menutup celah itu.

Apa yang invarian dan apa yang domain

Tumpuk dua quest CLI lalu lihat selisihnya (差分), batasnya jelas.

Invarian (dibagi semua quest)        Domain (berbeda tiap quest)
─────────────────────────            ─────────────────────
ratchet: TODO→PASS ireversibel       apa satu quest itu
kerangka perintah: scan/next/submit… apa itu "fakta"
agregasi level: Fail/Review→verdict  cheese mana yang harus ditahan
kemajuan persisten·resumable
export: pancaran 1 kali

Sisi kiri persis seperti yang dibuktikan how-make-quest — entah domainnya nama perusahaan, endpoint, atau fungsi, gigi ratchet tersangkut dengan cara yang sama. Hanya sisi kanan yang diketahui manusia. reins memasok sisi kiri sebagai framework, dan menyisakan hanya sisi kanan untuk Anda.

Ini bukan klaim baru melainkan prinsip lama yang dipaksakan reins lewat kode — pemisahan keputusan dan implementasi. Gate adalah keputusan (apa yang benar di domain ini), dan ratchet·CLI·agregasi adalah implementasi. Menulis ulang implementasi setiap kali adalah kegagalan mengikat keputusan pada implementasi.

Implementasikan hanya satu gate

Membuat quest dengan reins berarti mengisi empat metode dari satu interface.

type Definition interface {
    Seed(args []string) ([]*quest.Item, error)            // input → seed TODO awal
    Render(it *quest.Item) (string, error)                // prompt penulisan + konteks verifikasi yang ditampilkan next
    Prepare(it *quest.Item, raw []byte) (gate.Context, *quest.Verdict, error) // dekode submisi
    Rules() []gate.Rule                                   // katalog aturan-pelanggaran gate
}

func main() { cli.NewQuestCmd("myquest", myDef{}, cli.Options{}).Execute() }

Satu baris main memasok seluruh ratchet·enam perintah·agregasi·export·sesi resumable. Yang Anda tulis hanya empat potong domain. Agen tetap cukup tahu dua perintah saja — terima dengan next, kirim dengan submit. Sisanya diputuskan mesin.

Gate adalah katalog aturan pertahanan cheese

Inti dari how-make-quest adalah “rancang gate yang tak bisa di-cheese”. reins menjadikan rancangan itu sebagai struktur data — gate = katalog aturan. Satu aturan adalah satu detektor cheese. Begitu menemukan pelanggaran, ia aktif (true) dan memuat fakta (Fact).

// Salah satu aturan pertahanan cheese dari quest ekstraksi peristiwa berita.
// "apakah anchor who benar-benar ada di teks asli" — kalau agen mengarang seorang tokoh, ketahuan.
var whoAnchorPresent = gate.Rule{
    Meta: gate.RuleMeta{ID: "who-anchor-present", Level: gate.LevelFail, Desc: "anchor who wajib ada di teks asli"},
    Check: func(ctx gate.Context) (bool, quest.Fact) {
        sub := ctx.Submission.(*Event)
        if miss := textmatch.MissingTokens(ctx.Source, sub.Who.Anchors); len(miss) > 0 {
            return true, quest.Fact{Where: "who.anchors", Expected: "substring teks asli", Actual: miss[0]}
        }
        return false, quest.Fact{}
    },
}

Keutamaan struktur ini adalah ia bertumbuh. Setiap kali menemukan cheese baru, tambahkan satu aturan, maka gate menjadi sekuat itu. Dan katalog mendokumentasikan dirinya sendiri — ketika perintah rules mencetak daftar aturan, itulah “daftar audit cheese yang sedang saya tahan”. Tidak ada gate yang tak tahu apa yang ia tahan.

Tingkat keparahan bukan bobot melainkan level. Satu Fail saja berarti FAIL. Pelanggaran yang menentukan tidak dinegosiasikan — sembilan pelanggaran bernilai 99 poin tak bisa menutupi satu Fail. Evaluate mengagregasi aturan yang aktif menurut level: kalau ada satu saja Fail maka FAIL, kalau tidak tapi ada Review maka REVIEW, kalau semua lolos maka PASS.

Memaksa asimetri kewenangan lewat tipe

Satu baris terpenting di how-make-quest adalah “penguncian PASS hanya milik mesin”. reins menancapkan ini bukan sebagai konvensi melainkan sebagai tipe.

L1 mesin(deterministik)  satu-satunya kewenangan mengunci PASS
L2 AI(skeptis)           hanya REVIEW — mengajukan keraguan tapi tak bisa memberi completion
L3 manusia               residu yang dilewatkan keduanya

Gate mesin menerbitkan PASS. Meski Anda memasukkan verifikator AI ke dalam gate, paling jauh yang bisa ia lakukan adalah mengeluarkannya sebagai REVIEW. Hal yang salah dibuat mustahil sejak awal — kalau framework tidak menyediakan API yang memberi agen kewenangan PASS, maka bahkan karena keliru pun Anda tak bisa menyerahkan putusan kepada teman mabuk.

Backend kedua — defeat graph

Banyak gate yang cukup dengan agregasi level dari aturan-aturan independen. Tetapi begitu aturan-aturan mulai saling bersaing — “pelanggaran ini hanya bermakna kalau pelanggaran itu ada”, “akar penyebab kegagalan ini sebenarnya itu” — guard if-else buatan tangan mulai menggerogoti gate. Bukan di tempat gate lemah patah, melainkan di tempat gate yang kompleks membusuk.

Backend gate kedua dari reins memindahkan persaingan ini ke graf deklaratif — toulmin h-Categoriser. Model argumentasi Toulmin langsung menjadi struktur data:

Warrant — tautology PASS. Landasan “kalau tak ada sanggahan maka lolos”.
Counter — pelanggaran menyerang warrant.
Supersedes — prioritas antar aturan. Sanggahan mana yang mengalahkan sanggahan mana.

Klausa-klausa guard buatan tangan menguap menjadi edge Attacks·Supersedes. Dan kalau edge-nya 0, graf ini persis ekuivalen dengan agregasi level — kompleksitas adalah biaya yang hanya menyala saat dibutuhkan (opt-in) (menyala kalau Definition mengimplementasikan gate.Evaluator).

Hadiah sejati dari graf bukanlah putusan melainkan umpan balik. Evaluasi graf mengembalikan panduan langsung kepada agen — Verdict.Feedback: “mengapa kalah, dan apa yang harus diubah untuk menang.” Bukan sekadar “FAIL” melainkan akar penyebab yang dihitung dari struktur argumentasi.

Di sinilah paradoks how-make-quest bekerja lagi. Model menjilat — ia patuh begitu saja pada instruksi. Pada opini, menjilat adalah racun, tetapi pada fakta, menjilat adalah aset. Panduan itu bukan opini (“kok agak aneh”) melainkan fakta (“who.anchors tidak ada di teks asli, ubah ini”). Semakin model itu menjilat, semakin ia menerima fakta itu dengan patuh dan konvergen. Graf deterministik + LLM yang menjilat = loop dengan konvergensi yang dijamin.

Isolasi efek samping — evaluasi ground dan staged

Agar gate deterministik, jaringan tak boleh berada di dalam gate. Aturan yang memanggil net/http langsung mustahil di-unit-test, dan putusannya goyah tergantung kondisi koneksi.

reins menggiring efek samping ke pkg/ground — primitif seperti HTTPBody·MXResolves memiliki query eksternal lewat Resolver injeksi dan snapshot per permintaan. Aturan tetap murni, dan dunia luar adalah tanggung jawab ground.

Dan evaluasi staged: pemeriksaan murah berjalan lebih dulu, dan kalau itu gagal, fetch jaringan sama sekali tak terjadi. Tak ada alasan men-query DNS untuk submisi yang formatnya salah. Letakkan yang mahal dan goyah di belakang yang murah dan pasti.

Larangan abstraksi N=1

Salah satu konvensi reins paling tepat mengungkap watak framework ini — jangan mengekstrak abstraksi dari satu konsumen. Abstraksi baru baru dibekukan setelah diverifikasi oleh konsumen kedua.

Ini bukan kecerewetan melainkan prinsip pertama. Abstraksi yang diekstrak dari satu kasus salah mengira kebetulan kasus itu sebagai esensi. Baru ketika domain kedua menuntut abstraksi yang sama, ia terbukti invarian. Framework menerapkan “bukan klaim melainkan verifikasi” bahkan pada evolusi dirinya sendiri. Sebagaimana gate tak memercayai klaim agen, abstraksi tak memercayai klaim satu kasus.

Kalimat yang sama, menjadi library

reins berdiri di atas tujuh paket di pkg/ — textmatch (primitif pemblokir halusinasi), temporal (normalisasi waktu), quest (inti ratchet), gate (kontrak gate), graph (defeat graph), ground (isolasi jaringan), cli (scaffold cobra). Lolos go build·go test, seluruh fungsi tercakup. Dan toulmin terkopel searah hanya ke backend graf, sehingga konsumen yang tak memakai graf bahkan tak me-link toulmin.

Kode: github.com/park-jun-woo/reins

Kalau how-make-quest adalah satu kalimat — generasi boleh probabilistik, verifikasi harus deterministik — maka reins adalah kalimat itu yang dipadatkan menjadi bentuk yang bisa dikompilasi. Gate memverifikasi ulang fakta domain, ratchet mengunci yang sudah lolos, graf mengembalikan alasan kalah sebagai fakta, dan model yang menjilat tunduk pada fakta itu.

Lain kali Anda butuh quest CLI, jangan tulis ulang ratchet. Pakai hanya gate domain, dan pinjam tali kendalinya.

Bahan bacaan pendamping

Prinsip yang dipadatkan reins lewat kode — generasi probabilistik, verifikasi deterministik — bukanlah temuan reins seorang. Orang-orang yang saling tak kenal menabrak tembok yang sama dan sampai pada kesimpulan yang sama. Proyek-proyek konvergensi independen yang dikumpulkan how-make-quest adalah buktinya.

episteme — Memaksa Reasoning Surface sebelum pekerjaan yang tak bisa dibatalkan. Intuisi yang sama dengan ratchet reins — PASS diverifikasi sebelum dikunci.
MagLab — “LLM hanya menalar, angka diserahkan ke alat deterministik.” Pemisahan yang sama dengan reins yang mengisolasi efek samping ke pkg/ground.
Manifesto — “Agent proposes, World verifies.” Merangkum asimetri kewenangan reins (hanya L1 mengunci PASS) dalam satu kalimat.
oh-my-kamisama — “diffs beat claims.” Prinsip yang sama dengan gate yang memverifikasi ulang fakta bukan klaim agen.

Dan akar dari backend defeat graph adalah teori argumentasi — galur Toulmin·Dung·Amgoud di sumber-sumber di bawah. pkg/graph reins memindahkan logika formal berusia lebih dari 60 tahun itu menjadi struktur data Go.

Sumber

Toulmin, S. (1958). The Uses of Argument. Cambridge University Press. — model argumentasi yang Warrant·Ground·Backing-nya diambil langsung untuk defeat graph.
Dung, P.M. (1995). “On the Acceptability of Arguments and its Fundamental Role in Nonmonotonic Reasoning, Logic Programming and n-Person Games.” Artificial Intelligence, 77(2), 321–357. — sumber asli dari abstract argumentation framework dan graf attack(defeat).
Amgoud, L. & Ben-Naim, J. (2013). “Ranking-based semantics for argumentation frameworks.” SUM 2013, LNCS 8078, 134–147. — weighted h-Categoriser yang diadopsi pkg/graph. Sifat Compensation di mana node yang diserang pulih akseptabilitasnya kalau dibela lagi, jaminan konvergensi.
Nute, D. (1994). “Defeasible Logic.” In Handbook of Logic in Artificial Intelligence and Logic Programming, Vol. 3. Oxford University Press. — klasifikasi strict/defeasible/defeater. Akar formal dari level aturan reins (Fail/Review) dan prioritas Supersedes.
Modgil, S. & Prakken, H. (2014). “The ASPIC+ Framework for Structured Argumentation: A Tutorial.” Argument & Computation, 5(1), 31–62. — sistem argumentasi yang menstrukturkan klasifikasi Nute di dalam framework Dung. Silsilah defeat graph.
Gabriel, V.O. et al. (2020). “Reasoning in BDI agents using Toulmin’s argumentation model.” Theoretical Computer Science, 805, 76–91. — kasus pendahulu yang mengimplementasikan model Toulmin sebagai perangkat lunak (agen BDI). pkg/graph reins memindahkannya menjadi putusan gate.
Von Neumann, J. (1956). “Probabilistic Logics and the Synthesis of Reliable Organisms from Unreliable Components.” Automata Studies, Princeton University Press. — prinsip menumpukan protokol yang reliable di atas komponen yang tak stabil (premis reins).
Stechly, K., Valmeekam, K., & Kambhampati, S. (2024). “On the Self-Verification Limitations of Large Language Models.” arXiv:2402.08115 — self-verification nyaris tak menaikkan performa → alasan kewenangan PASS harus ada pada mesin L1.
McKee-Reid, L. et al. (2024). “Honesty to Subterfuge: In-Context RL Can Make Honest Models Reward Hack.” arXiv:2410.06491 — bahkan model jujur memanipulasi kalau memutuskan rewardnya sendiri → landasan asimetri kewenangan.
Bondarenko, A. et al. (2025). “Demonstrating Specification Gaming in Reasoning Models.” arXiv:2502.13295 — semakin tinggi kemampuannya, semakin pandai ia menemukan celah gate → alasan gate=katalog aturan harus bertumbuh.
Thaman, K. (2026). “Reward Hacking Benchmark: Measuring Exploits in LLM Agents with Tool Use.” arXiv:2605.02964 — membuat gate sengaja keras mengurangi eksploitasi sebesar 87,7%.
Fanous, A. et al. (2025). “SycEval: Evaluating LLM Sycophancy.” AAAI/ACM AIES 2025. arXiv:2502.08177 — pengukuran tingkat menyerah menjilat. Dua sisi dari “pada fakta, menjilat adalah aset”.
Shapira, I. et al. (2026). “How RLHF Amplifies Sycophancy.” arXiv:2602.01002 — teorema bahwa RLHF memperkuat penjilatan. Premis dari loop konvergensi umpan balik fakta + menjilat.
Deque Systems (2021). “Automated Testing Study Identifies 57 Percent of Digital Accessibility Issues.” — batas antara wilayah yang dapat diputuskan mesin (57%) dan residu manusia (20%).