Initial commit: legawa multi-agent system for Indonesian legislators

Four agents (Analis RUU, Peneliti, Penyusun Naskah, Surat Konstituen)
running on two local llama.cpp endpoints (Qwen3 35B + 27B), with
pasal.id REST integration and a SQLite cache layer.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

.env.example

@@ -0,0 +1,18 @@
+# pasal.id API (https://pasal.id/api)
+PASAL_API_TOKEN=your-bearer-token-here
+PASAL_BASE_URL=https://pasal.id/api/v1
+
+# llama.cpp endpoints (OpenAI-compatible)
+# BIG: localhost, Qwen3 ~35B — synthesis, drafting, deep analysis
+LLM_BIG_URL=http://localhost:8080/v1
+LLM_BIG_MODEL=qwen3
+LLM_BIG_API_KEY=sk-no-key-required
+
+# SMALL: mi25 over LAN, Qwen3 ~27B — classification, extraction, query expansion
+LLM_SMALL_URL=http://mi25:8080/v1
+LLM_SMALL_MODEL=qwen3
+LLM_SMALL_API_KEY=sk-no-key-required
+
+# Generation defaults
+LLM_TEMPERATURE=0.3
+LLM_MAX_TOKENS=4096

.gitignore

@@ -0,0 +1,20 @@
+.env
+.venv/
+venv/
+__pycache__/
+*.pyc
+*.pyo
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+dist/
+build/
+*.egg-info/
+.idea/
+.vscode/
+output/
+*.pdf
+!docs/*.pdf
+
+# Claude Code per-user settings (project-level settings.json is fine to commit)
+.claude/settings.local.json

README.md

@@ -0,0 +1,78 @@
+# legawa
+
+Asisten multi-agen untuk anggota legislatif Indonesia (DPR/DPRD). Berjalan di atas dua instance llama.cpp lokal (Qwen3) dan menggunakan API publik [pasal.id](https://pasal.id) sebagai sumber peraturan perundang-undangan.
+
+## Arsitektur
+
+```
+                        ┌──────────────────────┐
+   pengguna (CLI) ─────▶│   Typer orchestrator │
+                        └──────────┬───────────┘
+                                   │
+              ┌────────────────────┼─────────────────────┐
+              ▼                    ▼                     ▼
+     ┌────────────────┐  ┌──────────────────┐  ┌────────────────────┐
+     │  Analis RUU    │  │  Peneliti Hukum  │  │  Penyusun Naskah   │
+     │  (BIG, tools)  │  │  (SMALL→BIG)     │  │  (BIG, opt. riset) │
+     └────────┬───────┘  └─────────┬────────┘  └─────────┬──────────┘
+              │                    │                     │
+              └──────────┬─────────┴─────────────────────┘
+                         ▼
+              ┌────────────────────┐
+              │   pasal.id REST    │  search · list · get_law
+              └────────────────────┘
+```
+
+Routing model:
+- **BIG** (`localhost:8080`, Qwen3 ~35B) — sintesis, drafting, analisis pasal-per-pasal.
+- **SMALL** (`mi25:8080`, Qwen3 ~27B) — klasifikasi, ekstraksi, ekspansi query.
+
+## Setup
+
+```bash
+cp .env.example .env
+# isi PASAL_API_TOKEN dan sesuaikan URL llama.cpp jika perlu
+
+pip install -e .
+legawa health
+```
+
+## Pemakaian
+
+```bash
+# Analisis RUU dari PDF
+legawa analyze ./ruu-cipta-kerja.pdf --out output/analisis.md
+
+# Riset hukum bertema
+legawa research "perlindungan data pribadi sektor kesehatan" -o output/riset.md
+
+# Susun pidato/memo/naskah akademik
+legawa draft pidato "urgensi RUU Masyarakat Adat" -o output/pidato.md
+legawa draft memo_kebijakan "subsidi BBM 2026" --no-research
+legawa draft naskah_akademik "perubahan UU Pemilu" -i "fokus pada presidential threshold"
+
+# Triase + balasan surat konstituen
+legawa surat ./inbox/aspirasi-001.txt -o output/balasan.md
+legawa surat ./inbox/aspirasi-001.txt --triase-only
+
+# Kelola cache pasal.id
+legawa cache stats
+legawa cache purge   # hapus entri expired
+```
+
+## Cache pasal.id
+
+Semua panggilan REST pasal.id dilewatkan melalui SQLite cache:
+
+| endpoint  | TTL       |
+|-----------|-----------|
+| `search`  | 1 jam     |
+| `laws`    | 1 jam     |
+| `laws/{}` | 24 jam    |
+
+Lokasi default: `~/.legawa/cache.db`. Override dengan `LEGAWA_CACHE_PATH=/custom/path.db`.
+
+## Catatan
+
+- Setiap klaim agen tentang peraturan existing dilengkapi `frbr_uri` pasal.id agar dapat diverifikasi.
+- Output tidak menggantikan tinjauan hukum profesional. Selalu review oleh staf ahli sebelum publikasi.

pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "legawa"
+version = "0.1.0"
+description = "Multi-agent assistant for Indonesian legislators (DPR/DPRD)"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "openai>=1.50.0",
+    "httpx>=0.27.0",
+    "typer>=0.12.0",
+    "rich>=13.7.0",
+    "python-dotenv>=1.0.0",
+    "pypdf>=4.3.0",
+    "pydantic>=2.7.0",
+]
+
+[project.scripts]
+legawa = "legawa.cli:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/legawa"]

src/legawa/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

src/legawa/__main__.py

@@ -0,0 +1,4 @@
+from .cli import app
+
+if __name__ == "__main__":
+    app()

src/legawa/agents/analis_ruu.py

@@ -0,0 +1,88 @@
+"""Analis RUU — agent yang menganalisis Rancangan Undang-Undang.
+
+Input: teks atau path PDF RUU.
+Output:
+  1. Ringkasan eksekutif
+  2. Analisis pasal-per-pasal
+  3. Daftar UU/peraturan yang dirujuk + status keberlakuan
+  4. Potensi konflik atau tumpang tindih dengan peraturan existing
+  5. Catatan untuk legislator (poin pertimbangan politik/hukum)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.console import Console
+
+from ..llm import LLMPool
+from ..tools.pasal import PasalClient, TOOL_SCHEMAS, build_dispatcher
+from .base import AgentResult, ToolAgent
+
+
+SYSTEM_PROMPT = """\
+Anda adalah Analis RUU senior yang membantu anggota legislatif Indonesia (DPR/DPRD)
+mengevaluasi rancangan peraturan perundang-undangan.
+
+Tugas Anda untuk setiap RUU yang diberikan:
+1. **Ringkasan Eksekutif** — 3–5 kalimat tentang tujuan, ruang lingkup, dan dampak utama RUU.
+2. **Analisis Pasal-per-Pasal** — untuk pasal-pasal kunci, jelaskan maksud, implikasi praktis,
+   dan ambiguitas yang berpotensi menimbulkan masalah implementasi.
+3. **Peraturan yang Dirujuk** — identifikasi UU/PP/Perpres yang disebut atau secara substantif
+   relevan. Gunakan tool `pasal_search` untuk memverifikasi keberadaan dan status keberlakuannya
+   (berlaku/dicabut/diubah). Tampilkan frbr_uri sebagai sitasi.
+4. **Potensi Konflik / Tumpang Tindih** — gunakan `pasal_search` dan `pasal_get_law` untuk
+   memeriksa peraturan terkait. Soroti pasal yang berpotensi bertentangan atau duplikatif,
+   sertakan kutipan pasal pembanding.
+5. **Catatan untuk Legislator** — poin pertimbangan: dampak fiskal, dampak konstituen,
+   isu HAM, kewenangan kelembagaan, kelayakan implementasi.
+
+Aturan:
+- WAJIB sitasi: setiap klaim tentang peraturan existing harus disertai frbr_uri dan kutipan
+  pasal yang relevan dari hasil tool. Jangan mengarang nomor UU.
+- Tulis seluruh analisis dalam Bahasa Indonesia formal, gaya legal-tehnis.
+- Gunakan tool secara agresif. Cari dahulu, sintesis kemudian. Lakukan setidaknya 3 pencarian
+  untuk RUU bertema substansial.
+- Output akhir dalam format Markdown dengan heading yang jelas.
+"""
+
+
+def load_ruu_text(source: str) -> str:
+    """Load RUU content from a file path (txt/md/pdf) or treat as raw text."""
+    path = Path(source)
+    if not path.exists() or not path.is_file():
+        return source
+
+    if path.suffix.lower() == ".pdf":
+        from pypdf import PdfReader
+
+        reader = PdfReader(str(path))
+        return "\n\n".join(page.extract_text() or "" for page in reader.pages)
+    return path.read_text(encoding="utf-8")
+
+
+def build_agent(pool: LLMPool, pasal: PasalClient, console: Console | None = None) -> ToolAgent:
+    return ToolAgent(
+        name="analis-ruu",
+        llm=pool.big,
+        system_prompt=SYSTEM_PROMPT,
+        tools=TOOL_SCHEMAS,
+        dispatcher=build_dispatcher(pasal),
+        max_iters=12,
+        console=console,
+    )
+
+
+def analyze(
+    pool: LLMPool,
+    pasal: PasalClient,
+    source: str,
+    *,
+    console: Console | None = None,
+) -> AgentResult:
+    text = load_ruu_text(source)
+    if len(text) > 60000:
+        text = text[:60000] + "\n\n[... teks dipotong karena panjang ...]"
+    agent = build_agent(pool, pasal, console=console)
+    user_input = f"Analisis RUU berikut:\n\n---\n{text}\n---"
+    return agent.run(user_input)

src/legawa/agents/base.py

@@ -0,0 +1,123 @@
+"""Generic tool-calling agent loop.
+
+Drives an OpenAI-compatible chat model (llama.cpp + Qwen3) through repeated
+tool calls until the model returns a final assistant message with no tool calls.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from rich.console import Console
+
+from ..llm import LLM
+
+
+ToolDispatcher = Callable[[str, dict[str, Any]], Any]
+
+
+@dataclass
+class AgentResult:
+    output: str
+    messages: list[dict[str, Any]]
+    tool_calls: list[dict[str, Any]] = field(default_factory=list)
+
+
+class ToolAgent:
+    def __init__(
+        self,
+        name: str,
+        llm: LLM,
+        system_prompt: str,
+        tools: list[dict[str, Any]],
+        dispatcher: ToolDispatcher,
+        *,
+        max_iters: int = 8,
+        console: Console | None = None,
+    ):
+        self.name = name
+        self.llm = llm
+        self.system_prompt = system_prompt
+        self.tools = tools
+        self.dispatcher = dispatcher
+        self.max_iters = max_iters
+        self.console = console or Console()
+
+    def run(self, user_input: str) -> AgentResult:
+        messages: list[dict[str, Any]] = [
+            {"role": "system", "content": self.system_prompt},
+            {"role": "user", "content": user_input},
+        ]
+        all_calls: list[dict[str, Any]] = []
+
+        for _ in range(self.max_iters):
+            msg = self.llm.chat_with_tools(messages, self.tools)
+            tool_calls = getattr(msg, "tool_calls", None) or []
+
+            assistant_entry: dict[str, Any] = {
+                "role": "assistant",
+                "content": msg.content or "",
+            }
+            if tool_calls:
+                assistant_entry["tool_calls"] = [
+                    {
+                        "id": tc.id,
+                        "type": "function",
+                        "function": {
+                            "name": tc.function.name,
+                            "arguments": tc.function.arguments,
+                        },
+                    }
+                    for tc in tool_calls
+                ]
+            messages.append(assistant_entry)
+
+            if not tool_calls:
+                return AgentResult(output=msg.content or "", messages=messages, tool_calls=all_calls)
+
+            for tc in tool_calls:
+                fn_name = tc.function.name
+                try:
+                    fn_args = json.loads(tc.function.arguments or "{}")
+                except json.JSONDecodeError as e:
+                    fn_args = {}
+                    err = f"invalid JSON in tool args: {e}"
+                    self.console.print(f"[red]{self.name}: {err}[/red]")
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tc.id,
+                        "content": json.dumps({"error": err}),
+                    })
+                    continue
+
+                self.console.print(
+                    f"[dim]{self.name} → {fn_name}({json.dumps(fn_args, ensure_ascii=False)[:160]})[/dim]"
+                )
+                try:
+                    result = self.dispatcher(fn_name, fn_args)
+                except Exception as e:  # noqa: BLE001
+                    result = {"error": str(e)}
+                    self.console.print(f"[red]{self.name} tool error: {e}[/red]")
+
+                all_calls.append({"name": fn_name, "args": fn_args, "result": result})
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": tc.id,
+                    "content": json.dumps(_truncate(result), ensure_ascii=False),
+                })
+
+        return AgentResult(
+            output="(agent reached max iterations without final answer)",
+            messages=messages,
+            tool_calls=all_calls,
+        )
+
+
+def _truncate(obj: Any, max_len: int = 24000) -> Any:
+    """Cap tool-result payload size to avoid blowing the context window."""
+    s = json.dumps(obj, ensure_ascii=False)
+    if len(s) <= max_len:
+        return obj
+    return {"_truncated": True, "preview": s[:max_len]}

src/legawa/agents/peneliti.py

@@ -0,0 +1,136 @@
+"""Peneliti Hukum — riset hukum bertema.
+
+Pipeline:
+  1. SMALL model: ekspansi topik → 4–6 query pencarian (Bahasa Indonesia, beragam sudut).
+  2. PasalClient: jalankan semua query, kumpulkan hits unik.
+  3. BIG model: sintesis temuan dengan sitasi frbr_uri + kutipan pasal.
+"""
+
+from __future__ import annotations
+
+import json
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any
+
+from rich.console import Console
+
+from ..llm import LLMPool
+from ..tools.pasal import PasalClient
+
+
+QUERY_EXPANSION_PROMPT = """\
+Anda membantu riset hukum Indonesia. Diberikan satu topik, hasilkan 4–6 query pencarian
+berbeda untuk database peraturan (pasal.id). Variasikan sudut pandang: subjek hukum,
+istilah teknis, sinonim, dan konteks kelembagaan.
+
+Output WAJIB berupa JSON array of strings, tanpa teks lain. Contoh:
+["query 1", "query 2", "query 3"]
+"""
+
+SYNTHESIS_PROMPT = """\
+Anda adalah peneliti hukum senior yang membantu legislator Indonesia.
+Diberikan topik riset dan kumpulan hasil pencarian peraturan dari pasal.id, susun memo riset
+dalam Bahasa Indonesia formal dengan struktur:
+
+# Memo Riset Hukum: <topik>
+
+## 1. Ringkasan Temuan
+3–5 kalimat yang menjawab inti topik.
+
+## 2. Peraturan Utama
+Untuk setiap peraturan kunci: judul, jenis, nomor/tahun, status, frbr_uri, dan ringkasan
+kontribusinya terhadap topik. Sertakan kutipan pasal pendek bila tersedia.
+
+## 3. Hubungan Antar Peraturan
+Identifikasi hierarki, perubahan, pencabutan, atau saling-rujuk antar peraturan.
+
+## 4. Celah / Pertanyaan Terbuka
+Aspek yang belum tercover oleh peraturan existing atau memerlukan riset lanjutan.
+
+## 5. Rekomendasi Tindak Lanjut untuk Legislator
+2–4 poin praktis (mis. usulan revisi, pertanyaan untuk RDP, dapil-impact).
+
+Aturan:
+- Setiap klaim tentang isi peraturan harus berasal dari hasil pencarian; cantumkan frbr_uri.
+- Jangan mengarang nomor UU atau pasal yang tidak ada di hasil.
+- Bila hasil tidak cukup, katakan secara eksplisit di bagian "Celah".
+"""
+
+
+def _expand_queries(pool: LLMPool, topic: str, console: Console) -> list[str]:
+    raw = pool.small.chat(
+        [
+            {"role": "system", "content": QUERY_EXPANSION_PROMPT},
+            {"role": "user", "content": f"Topik: {topic}"},
+        ],
+        temperature=0.4,
+        max_tokens=512,
+    )
+    # Be tolerant of model wrapping JSON in code fences.
+    cleaned = raw.strip()
+    if cleaned.startswith("```"):
+        cleaned = cleaned.strip("`")
+        if cleaned.lower().startswith("json"):
+            cleaned = cleaned[4:].strip()
+    try:
+        queries = json.loads(cleaned)
+        if isinstance(queries, list) and all(isinstance(q, str) for q in queries):
+            return queries[:6]
+    except json.JSONDecodeError:
+        pass
+    console.print(f"[yellow]peneliti: gagal parse query expansion, fallback ke topik mentah[/yellow]")
+    return [topic]
+
+
+def _dedupe_hits(results: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    seen: set[str] = set()
+    unique: list[dict[str, Any]] = []
+    for batch in results:
+        for hit in batch.get("results", []) or batch.get("hits", []) or []:
+            key = (
+                hit.get("frbr_uri")
+                or hit.get("work", {}).get("frbr_uri")
+                or json.dumps(hit, sort_keys=True)[:120]
+            )
+            if key in seen:
+                continue
+            seen.add(key)
+            unique.append(hit)
+    return unique
+
+
+def research(
+    pool: LLMPool,
+    pasal: PasalClient,
+    topic: str,
+    *,
+    console: Console | None = None,
+) -> str:
+    console = console or Console()
+    console.print(f"[cyan]peneliti: ekspansi query untuk topik '{topic}'[/cyan]")
+    queries = _expand_queries(pool, topic, console)
+    console.print(f"[dim]queries: {queries}[/dim]")
+
+    console.print(f"[cyan]peneliti: menjalankan {len(queries)} pencarian paralel[/cyan]")
+    with ThreadPoolExecutor(max_workers=min(6, len(queries))) as ex:
+        batches = list(ex.map(lambda q: pasal.search(q, limit=10), queries))
+
+    hits = _dedupe_hits(batches)
+    console.print(f"[cyan]peneliti: {len(hits)} hit unik, sintesis dengan model besar[/cyan]")
+
+    payload = {"topic": topic, "queries": queries, "hits": hits[:40]}
+    output = pool.big.chat(
+        [
+            {"role": "system", "content": SYNTHESIS_PROMPT},
+            {
+                "role": "user",
+                "content": (
+                    f"Topik: {topic}\n\n"
+                    f"Hasil pencarian (JSON):\n{json.dumps(payload, ensure_ascii=False)[:50000]}"
+                ),
+            },
+        ],
+        temperature=0.3,
+        max_tokens=4096,
+    )
+    return output

src/legawa/agents/penyusun.py

@@ -0,0 +1,99 @@
+"""Penyusun Naskah — drafter pidato, naskah akademik, dan memo kebijakan.
+
+Alur:
+  1. Jika user butuh dukungan riset, panggil Peneliti dulu untuk ringkasan basis hukum.
+  2. BIG model menyusun naskah final dengan gaya yang sesuai jenis dokumen.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from rich.console import Console
+
+from ..llm import LLMPool
+from ..tools.pasal import PasalClient
+from . import peneliti
+
+
+NaskahKind = Literal["pidato", "naskah_akademik", "memo_kebijakan", "siaran_pers"]
+
+
+STYLE_GUIDES: dict[str, str] = {
+    "pidato": (
+        "Pidato legislatif untuk dibacakan di hadapan rapat paripurna atau publik. "
+        "Gunakan retorika yang jelas, kalimat ritmis, sapaan formal ('Yang terhormat...'), "
+        "dan tutup dengan ajakan/komitmen. Panjang 600–900 kata."
+    ),
+    "naskah_akademik": (
+        "Naskah Akademik untuk RUU sesuai UU 12/2011 jo. UU 13/2022. Struktur: "
+        "Bab I Pendahuluan (latar belakang, identifikasi masalah, tujuan, metode); "
+        "Bab II Kajian Teoritis & Praktik Empiris; Bab III Evaluasi Peraturan Terkait; "
+        "Bab IV Landasan Filosofis/Sosiologis/Yuridis; Bab V Jangkauan, Arah Pengaturan, "
+        "Materi Muatan; Bab VI Penutup. Bahasa formal akademis."
+    ),
+    "memo_kebijakan": (
+        "Memo kebijakan internal 1–2 halaman: TL;DR (3 kalimat), Latar Belakang, "
+        "Pilihan Kebijakan dengan trade-off, Rekomendasi, Risiko & Mitigasi. Padat, action-oriented."
+    ),
+    "siaran_pers": (
+        "Siaran pers 250–400 kata dengan headline kuat, lead paragraf yang menjawab 5W1H, "
+        "kutipan dari anggota legislatif (placeholder [NAMA ANGGOTA]), dan boilerplate penutup."
+    ),
+}
+
+
+SYSTEM_TEMPLATE = """\
+Anda adalah Penyusun Naskah profesional yang membantu anggota legislatif Indonesia.
+
+Jenis dokumen: {kind}
+Pedoman gaya: {style}
+
+Aturan umum:
+- Bahasa Indonesia formal, presisi, dan menghormati kaidah hukum.
+- Bila diberikan basis riset (bagian "BASIS RISET"), pakai sebagai sumber fakta. Sertakan
+  sitasi peraturan dengan format: "UU No. X Tahun YYYY tentang ..." dan, bila tersedia,
+  frbr_uri dalam tanda kurung.
+- Jangan mengarang fakta hukum atau angka statistik. Jika tidak yakin, gunakan placeholder
+  bersudut kurung siku (mis. [DATA BPS DAPIL]).
+- Output dalam Markdown.
+"""
+
+
+def draft(
+    pool: LLMPool,
+    pasal: PasalClient,
+    kind: NaskahKind,
+    topic: str,
+    *,
+    with_research: bool = True,
+    extra_instructions: str | None = None,
+    console: Console | None = None,
+) -> str:
+    console = console or Console()
+    style = STYLE_GUIDES.get(kind)
+    if not style:
+        raise ValueError(f"jenis naskah tidak dikenal: {kind}. Pilihan: {list(STYLE_GUIDES)}")
+
+    research_block = ""
+    if with_research:
+        console.print(f"[cyan]penyusun: meminta peneliti merangkum basis hukum '{topic}'[/cyan]")
+        memo = peneliti.research(pool, pasal, topic, console=console)
+        research_block = f"\n\nBASIS RISET:\n{memo}\n"
+
+    user_msg = (
+        f"Topik: {topic}\n"
+        f"Jenis: {kind}\n"
+        + (f"Instruksi tambahan: {extra_instructions}\n" if extra_instructions else "")
+        + research_block
+        + "\nSusun naskah lengkap sesuai pedoman gaya."
+    )
+
+    return pool.big.chat(
+        [
+            {"role": "system", "content": SYSTEM_TEMPLATE.format(kind=kind, style=style)},
+            {"role": "user", "content": user_msg},
+        ],
+        temperature=0.5,
+        max_tokens=4096,
+    )

src/legawa/agents/surat.py

@@ -0,0 +1,228 @@
+"""Surat Konstituen — triase dan drafting balasan untuk surat/email konstituen.
+
+Pipeline:
+  1. SMALL model: klasifikasi terstruktur (kategori, urgensi, dapil-relevance, sentimen) +
+     ekstraksi entitas (nama, lokasi, isu utama, permintaan konkret).
+  2. BIG model: jika user minta draft, susun balasan formal Bahasa Indonesia dengan
+     gaya pelayanan publik yang empatik namun realistis tentang kewenangan legislator.
+  3. Jika klasifikasi menyebut peraturan/UU spesifik, panggil pasal.id untuk verifikasi
+     sebelum drafting (opsional, dikontrol flag).
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+from pydantic import BaseModel, Field, ValidationError
+from rich.console import Console
+
+from ..llm import LLMPool
+from ..tools.pasal import PasalClient
+
+
+KATEGORI = [
+    "aspirasi_kebijakan",       # usulan revisi UU/peraturan
+    "pengaduan_layanan_publik", # listrik, kesehatan, pendidikan, dll
+    "permohonan_bantuan",       # bantuan sosial, individu
+    "undangan_acara",
+    "ucapan",                   # selamat, dukacita, dll
+    "lain_lain",
+]
+
+URGENSI = ["rendah", "sedang", "tinggi", "kritis"]
+SENTIMEN = ["positif", "netral", "negatif", "marah"]
+
+
+class TriaseHasil(BaseModel):
+    kategori: str = Field(..., description=f"Salah satu dari: {KATEGORI}")
+    urgensi: str = Field(..., description=f"Salah satu dari: {URGENSI}")
+    sentimen: str = Field(..., description=f"Salah satu dari: {SENTIMEN}")
+    dapil_relevance: bool = Field(..., description="Apakah isu kemungkinan berasal dari/relevan dengan dapil legislator.")
+    nama_pengirim: str | None = None
+    lokasi: str | None = None
+    isu_utama: str = Field(..., description="1 kalimat ringkas inti permasalahan.")
+    permintaan_konkret: list[str] = Field(default_factory=list, description="Daftar permintaan eksplisit dari pengirim.")
+    peraturan_disebut: list[str] = Field(default_factory=list, description="UU/PP/Perpres yang disebut surat, mis. 'UU 13/2003'.")
+    perlu_tindak_lanjut_staf: bool = Field(..., description="Butuh action item untuk staf (cek lapangan, koordinasi dinas, dll).")
+    rangkuman: str = Field(..., description="2–3 kalimat rangkuman netral untuk staf.")
+
+
+@dataclass
+class SuratResult:
+    triase: TriaseHasil
+    raw_classification: str
+    balasan: str | None = None
+
+
+TRIASE_PROMPT = f"""\
+Anda adalah staf ahli yang melakukan triase surat/email konstituen untuk anggota legislatif Indonesia.
+
+Klasifikasikan surat berikut dan ekstrak informasi terstruktur. Output WAJIB berupa JSON valid
+yang sesuai schema berikut (tanpa teks tambahan, tanpa code fence):
+
+{{
+  "kategori": "<salah satu: {', '.join(KATEGORI)}>",
+  "urgensi": "<salah satu: {', '.join(URGENSI)}>",
+  "sentimen": "<salah satu: {', '.join(SENTIMEN)}>",
+  "dapil_relevance": <true|false>,
+  "nama_pengirim": "<string atau null>",
+  "lokasi": "<string atau null>",
+  "isu_utama": "<1 kalimat>",
+  "permintaan_konkret": ["<string>", ...],
+  "peraturan_disebut": ["<string>", ...],
+  "perlu_tindak_lanjut_staf": <true|false>,
+  "rangkuman": "<2-3 kalimat>"
+}}
+
+Aturan urgensi:
+- kritis: mengancam jiwa/keselamatan, bencana, kekerasan.
+- tinggi: kerugian materiil signifikan, hak dasar terlanggar, urgensi waktu < 1 minggu.
+- sedang: pengaduan layanan publik standar, aspirasi kebijakan dengan dampak konstituen.
+- rendah: ucapan, undangan rutin, pertanyaan informatif.
+"""
+
+
+REPLY_PROMPT = """\
+Anda adalah staf komunikasi legislator Indonesia. Susun balasan formal Bahasa Indonesia
+untuk surat konstituen berikut.
+
+Pedoman:
+- Sapaan formal sesuai jenis pengirim ("Yth. Bapak/Ibu [Nama]" atau "Yth. Saudara/i").
+- Akui penerimaan surat dan empati pada isu yang diangkat (1 paragraf).
+- Jelaskan secara realistis kewenangan legislator: legislator MEMBUAT undang-undang dan
+  mengawasi pemerintah, BUKAN eksekusi langsung. Untuk pengaduan layanan publik, arahkan
+  ke instansi/lembaga yang berwenang, namun tegaskan akan dilakukan pengawasan/koordinasi.
+- Jika ada peraturan yang relevan dan terverifikasi (lihat bagian "BASIS HUKUM"), sitasi.
+- Tutup dengan komitmen tindak lanjut konkret (mis. teruskan ke komisi terkait, agendakan
+  rapat dengar pendapat, dll) — jangan janji yang tidak bisa ditepati.
+- Tanda tangan: "Hormat kami,\\n[NAMA ANGGOTA LEGISLATIF]\\n[FRAKSI/DAERAH PEMILIHAN]"
+- Panjang 250–450 kata. Output Markdown.
+"""
+
+
+def _parse_triase(raw: str) -> TriaseHasil:
+    cleaned = raw.strip()
+    if cleaned.startswith("```"):
+        cleaned = cleaned.strip("`")
+        if cleaned.lower().startswith("json"):
+            cleaned = cleaned[4:].strip()
+    # Some models prepend explanations; try to isolate the JSON object.
+    if not cleaned.startswith("{"):
+        start = cleaned.find("{")
+        end = cleaned.rfind("}")
+        if start != -1 and end != -1 and end > start:
+            cleaned = cleaned[start : end + 1]
+    data = json.loads(cleaned)
+    return TriaseHasil.model_validate(data)
+
+
+def _verify_peraturan(pasal: PasalClient, refs: list[str], console: Console) -> str:
+    if not refs:
+        return ""
+    notes: list[str] = []
+    for ref in refs[:5]:
+        try:
+            r = pasal.search(ref, limit=3)
+            hits = r.get("results") or r.get("hits") or []
+            if hits:
+                top = hits[0]
+                title = top.get("title") or top.get("work", {}).get("title") or ref
+                frbr = top.get("frbr_uri") or top.get("work", {}).get("frbr_uri") or "-"
+                status = top.get("status") or top.get("work", {}).get("status") or "?"
+                notes.append(f"- {ref}: {title} (status: {status}, frbr_uri: {frbr})")
+            else:
+                notes.append(f"- {ref}: TIDAK DITEMUKAN di pasal.id — jangan sitasi.")
+        except Exception as e:  # noqa: BLE001
+            console.print(f"[yellow]surat: gagal verifikasi {ref}: {e}[/yellow]")
+            notes.append(f"- {ref}: verifikasi gagal, jangan sitasi.")
+    return "BASIS HUKUM:\n" + "\n".join(notes)
+
+
+def triage(
+    pool: LLMPool,
+    text: str,
+    *,
+    console: Console | None = None,
+) -> SuratResult:
+    console = console or Console()
+    raw = pool.small.chat(
+        [
+            {"role": "system", "content": TRIASE_PROMPT},
+            {"role": "user", "content": text},
+        ],
+        temperature=0.1,
+        max_tokens=1024,
+    )
+    try:
+        triase = _parse_triase(raw)
+    except (json.JSONDecodeError, ValidationError) as e:
+        console.print(f"[red]surat: gagal parse hasil triase: {e}[/red]")
+        console.print(f"[dim]raw: {raw[:500]}[/dim]")
+        raise
+
+    return SuratResult(triase=triase, raw_classification=raw)
+
+
+def reply(
+    pool: LLMPool,
+    pasal: PasalClient,
+    text: str,
+    *,
+    verify_law: bool = True,
+    console: Console | None = None,
+) -> SuratResult:
+    console = console or Console()
+    result = triage(pool, text, console=console)
+    t = result.triase
+    console.print(
+        f"[cyan]surat: kategori={t.kategori} urgensi={t.urgensi} sentimen={t.sentimen} "
+        f"dapil={t.dapil_relevance} tindak_lanjut={t.perlu_tindak_lanjut_staf}[/cyan]"
+    )
+
+    basis = _verify_peraturan(pasal, t.peraturan_disebut, console) if verify_law else ""
+
+    user_msg = (
+        f"SURAT KONSTITUEN:\n---\n{text}\n---\n\n"
+        f"HASIL TRIASE (JSON):\n{result.raw_classification}\n"
+        + (f"\n{basis}\n" if basis else "")
+        + "\nSusun balasan sesuai pedoman."
+    )
+    result.balasan = pool.big.chat(
+        [
+            {"role": "system", "content": REPLY_PROMPT},
+            {"role": "user", "content": user_msg},
+        ],
+        temperature=0.4,
+        max_tokens=2048,
+    )
+    return result
+
+
+def format_report(result: SuratResult) -> str:
+    """Render triase + balasan sebagai satu dokumen Markdown."""
+    t = result.triase
+    parts = [
+        "# Triase Surat Konstituen",
+        "",
+        f"- **Kategori**: {t.kategori}",
+        f"- **Urgensi**: {t.urgensi}",
+        f"- **Sentimen**: {t.sentimen}",
+        f"- **Relevansi dapil**: {'ya' if t.dapil_relevance else 'tidak'}",
+        f"- **Tindak lanjut staf**: {'ya' if t.perlu_tindak_lanjut_staf else 'tidak'}",
+        f"- **Pengirim**: {t.nama_pengirim or '-'}",
+        f"- **Lokasi**: {t.lokasi or '-'}",
+        "",
+        f"**Isu utama**: {t.isu_utama}",
+        "",
+        "**Permintaan konkret**:",
+    ]
+    parts.extend(f"- {p}" for p in (t.permintaan_konkret or ["(tidak ada)"]))
+    if t.peraturan_disebut:
+        parts += ["", "**Peraturan disebut**:"]
+        parts.extend(f"- {p}" for p in t.peraturan_disebut)
+    parts += ["", "**Rangkuman untuk staf**:", t.rangkuman]
+    if result.balasan:
+        parts += ["", "---", "", "# Draf Balasan", "", result.balasan]
+    return "\n".join(parts)

src/legawa/cli.py

@@ -0,0 +1,175 @@
+"""legawa CLI."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.markdown import Markdown
+
+from .agents import analis_ruu, peneliti, penyusun, surat
+from .config import load_settings
+from .llm import LLMPool
+from .tools.cache import CachingPasalClient
+from .tools.pasal import PasalClient
+
+
+app = typer.Typer(
+    name="legawa",
+    help="Asisten multi-agen untuk legislator Indonesia (DPR/DPRD).",
+    no_args_is_help=True,
+    add_completion=False,
+)
+console = Console()
+
+
+def _bootstrap(use_cache: bool = True) -> tuple[LLMPool, PasalClient | CachingPasalClient]:
+    settings = load_settings()
+    pool = LLMPool(settings)
+    raw = PasalClient(settings)
+    pasal = CachingPasalClient(raw) if use_cache else raw
+    return pool, pasal
+
+
+def _emit(text: str, out: Optional[Path]) -> None:
+    if out:
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(text, encoding="utf-8")
+        console.print(f"[green]→ ditulis ke {out}[/green]")
+    console.print(Markdown(text))
+
+
+@app.command()
+def analyze(
+    source: str = typer.Argument(..., help="Path ke RUU (PDF/TXT) atau teks RUU langsung."),
+    out: Optional[Path] = typer.Option(None, "--out", "-o", help="Tulis hasil ke file Markdown."),
+) -> None:
+    """Analisis RUU: ringkasan, pasal-per-pasal, konflik dengan UU existing."""
+    pool, pasal = _bootstrap()
+    try:
+        result = analis_ruu.analyze(pool, pasal, source, console=console)
+    finally:
+        pasal.close()
+    _emit(result.output, out)
+
+
+@app.command()
+def research(
+    topic: str = typer.Argument(..., help="Topik riset hukum (Bahasa Indonesia)."),
+    out: Optional[Path] = typer.Option(None, "--out", "-o"),
+) -> None:
+    """Peneliti hukum: ekspansi query, pencarian paralel pasal.id, sintesis memo."""
+    pool, pasal = _bootstrap()
+    try:
+        memo = peneliti.research(pool, pasal, topic, console=console)
+    finally:
+        pasal.close()
+    _emit(memo, out)
+
+
+@app.command()
+def draft(
+    kind: str = typer.Argument(..., help="Jenis: pidato | naskah_akademik | memo_kebijakan | siaran_pers"),
+    topic: str = typer.Argument(..., help="Topik / pokok bahasan."),
+    no_research: bool = typer.Option(False, "--no-research", help="Lewati basis riset."),
+    instruksi: Optional[str] = typer.Option(None, "--instruksi", "-i", help="Instruksi tambahan."),
+    out: Optional[Path] = typer.Option(None, "--out", "-o"),
+) -> None:
+    """Penyusun Naskah: pidato, naskah akademik, memo, siaran pers."""
+    pool, pasal = _bootstrap()
+    try:
+        text = penyusun.draft(
+            pool,
+            pasal,
+            kind=kind,  # type: ignore[arg-type]
+            topic=topic,
+            with_research=not no_research,
+            extra_instructions=instruksi,
+            console=console,
+        )
+    finally:
+        pasal.close()
+    _emit(text, out)
+
+
+@app.command(name="surat")
+def surat_cmd(
+    source: str = typer.Argument(..., help="Path ke file surat (txt/md) atau teks surat langsung."),
+    triase_only: bool = typer.Option(False, "--triase-only", help="Hanya triase, tanpa draft balasan."),
+    no_verify: bool = typer.Option(False, "--no-verify", help="Lewati verifikasi peraturan ke pasal.id."),
+    out: Optional[Path] = typer.Option(None, "--out", "-o"),
+) -> None:
+    """Triase surat konstituen + draft balasan formal."""
+    p = Path(source)
+    text = p.read_text(encoding="utf-8") if p.exists() and p.is_file() else source
+
+    pool, pasal = _bootstrap()
+    try:
+        if triase_only:
+            result = surat.triage(pool, text, console=console)
+        else:
+            result = surat.reply(pool, pasal, text, verify_law=not no_verify, console=console)
+    finally:
+        pasal.close()
+    _emit(surat.format_report(result), out)
+
+
+cache_app = typer.Typer(help="Kelola cache pasal.id (SQLite).", no_args_is_help=True)
+app.add_typer(cache_app, name="cache")
+
+
+@cache_app.command("stats")
+def cache_stats() -> None:
+    """Tampilkan jumlah entri & ukuran cache."""
+    _, pasal = _bootstrap(use_cache=True)
+    try:
+        s = pasal.stats()  # type: ignore[union-attr]
+    finally:
+        pasal.close()
+    console.print(s)
+
+
+@cache_app.command("purge")
+def cache_purge() -> None:
+    """Hapus entri cache yang sudah expired."""
+    _, pasal = _bootstrap(use_cache=True)
+    try:
+        n = pasal.purge_expired()  # type: ignore[union-attr]
+    finally:
+        pasal.close()
+    console.print(f"[green]purged {n} expired entries[/green]")
+
+
+@app.command()
+def health() -> None:
+    """Cek koneksi ke pasal.id dan kedua endpoint llama.cpp."""
+    settings = load_settings()
+    console.print(f"[dim]pasal.id  : {settings.pasal_base_url}[/dim]")
+    console.print(f"[dim]LLM big   : {settings.big.base_url}  ({settings.big.model})[/dim]")
+    console.print(f"[dim]LLM small : {settings.small.base_url}  ({settings.small.model})[/dim]")
+
+    pool = LLMPool(settings)
+    for label, llm in [("big", pool.big), ("small", pool.small)]:
+        try:
+            reply = llm.chat(
+                [{"role": "user", "content": "Jawab dengan satu kata: OK"}],
+                max_tokens=8,
+                temperature=0.0,
+            )
+            console.print(f"[green]✓ {label}: {reply.strip()[:40]}[/green]")
+        except Exception as e:  # noqa: BLE001
+            console.print(f"[red]✗ {label}: {e}[/red]")
+
+    try:
+        with PasalClient(settings) as pasal:
+            r = pasal.search("ketenagakerjaan", limit=1)
+        total = r.get("total") or len(r.get("results", []) or [])
+        console.print(f"[green]✓ pasal.id: query 'ketenagakerjaan' → {total} hit[/green]")
+    except Exception as e:  # noqa: BLE001
+        console.print(f"[red]✗ pasal.id: {e}[/red]")
+
+
+if __name__ == "__main__":
+    app()

src/legawa/config.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+@dataclass(frozen=True)
+class LLMConfig:
+    base_url: str
+    api_key: str
+    model: str
+    temperature: float
+    max_tokens: int
+
+
+@dataclass(frozen=True)
+class Settings:
+    pasal_token: str
+    pasal_base_url: str
+    big: LLMConfig
+    small: LLMConfig
+
+
+def _required(key: str) -> str:
+    val = os.environ.get(key)
+    if not val:
+        raise RuntimeError(f"missing env var: {key}")
+    return val
+
+
+def load_settings() -> Settings:
+    temp = float(os.environ.get("LLM_TEMPERATURE", "0.3"))
+    max_tokens = int(os.environ.get("LLM_MAX_TOKENS", "4096"))
+    return Settings(
+        pasal_token=_required("PASAL_API_TOKEN"),
+        pasal_base_url=os.environ.get("PASAL_BASE_URL", "https://pasal.id/api/v1"),
+        big=LLMConfig(
+            base_url=_required("LLM_BIG_URL"),
+            api_key=os.environ.get("LLM_BIG_API_KEY", "sk-no-key-required"),
+            model=os.environ.get("LLM_BIG_MODEL", "qwen3"),
+            temperature=temp,
+            max_tokens=max_tokens,
+        ),
+        small=LLMConfig(
+            base_url=_required("LLM_SMALL_URL"),
+            api_key=os.environ.get("LLM_SMALL_API_KEY", "sk-no-key-required"),
+            model=os.environ.get("LLM_SMALL_MODEL", "qwen3"),
+            temperature=temp,
+            max_tokens=max_tokens,
+        ),
+    )

src/legawa/llm.py

@@ -0,0 +1,61 @@
+"""LLM client wrappers for the two llama.cpp endpoints.
+
+- BIG  (localhost:8080, Qwen3 ~35B): synthesis, drafting, deep analysis.
+- SMALL (mi25:8080, Qwen3 ~27B):     classification, extraction, query expansion.
+
+Both expose an OpenAI-compatible chat/completions API, so we use the openai SDK.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Iterable
+
+from openai import OpenAI
+
+from .config import LLMConfig, Settings
+
+
+class LLM:
+    def __init__(self, cfg: LLMConfig):
+        self.cfg = cfg
+        self.client = OpenAI(base_url=cfg.base_url, api_key=cfg.api_key)
+
+    def chat(
+        self,
+        messages: list[dict[str, Any]],
+        *,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+    ) -> str:
+        resp = self.client.chat.completions.create(
+            model=self.cfg.model,
+            messages=messages,
+            temperature=self.cfg.temperature if temperature is None else temperature,
+            max_tokens=self.cfg.max_tokens if max_tokens is None else max_tokens,
+        )
+        return resp.choices[0].message.content or ""
+
+    def chat_with_tools(
+        self,
+        messages: list[dict[str, Any]],
+        tools: Iterable[dict[str, Any]],
+        *,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+    ) -> Any:
+        """Single tool-calling round-trip; returns the raw choice.message object."""
+        resp = self.client.chat.completions.create(
+            model=self.cfg.model,
+            messages=messages,
+            tools=list(tools),
+            tool_choice="auto",
+            temperature=self.cfg.temperature if temperature is None else temperature,
+            max_tokens=self.cfg.max_tokens if max_tokens is None else max_tokens,
+        )
+        return resp.choices[0].message
+
+
+class LLMPool:
+    def __init__(self, settings: Settings):
+        self.big = LLM(settings.big)
+        self.small = LLM(settings.small)

src/legawa/tools/cache.py

@@ -0,0 +1,158 @@
+"""SQLite cache layer for the pasal.id REST client.
+
+Transparent wrapper over PasalClient. Same method names, same return shapes.
+Agents and the CLI swap PasalClient → CachingPasalClient with no other changes.
+
+TTL defaults:
+  search    : 3600   (1 hour)  — search results shift as the corpus grows
+  list_laws : 3600   (1 hour)
+  get_law   : 86400  (24 hours) — full document content is stable
+
+Cache file:
+  $LEGAWA_CACHE_PATH if set, else $HOME/.legawa/cache.db
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import time
+from pathlib import Path
+from typing import Any, Callable
+
+from .pasal import PasalClient
+
+
+DEFAULT_TTL_SEARCH = 3600
+DEFAULT_TTL_LIST = 3600
+DEFAULT_TTL_GET = 86400
+
+
+def _default_cache_path() -> Path:
+    override = os.environ.get("LEGAWA_CACHE_PATH")
+    if override:
+        return Path(override)
+    return Path.home() / ".legawa" / "cache.db"
+
+
+class _SqliteCache:
+    def __init__(self, path: Path):
+        path.parent.mkdir(parents=True, exist_ok=True)
+        self.conn = sqlite3.connect(str(path), isolation_level=None, check_same_thread=False)
+        self.conn.execute("PRAGMA journal_mode=WAL")
+        self.conn.execute(
+            "CREATE TABLE IF NOT EXISTS cache ("
+            "  key TEXT PRIMARY KEY,"
+            "  value TEXT NOT NULL,"
+            "  expires_at INTEGER NOT NULL"
+            ")"
+        )
+
+    def get(self, key: str) -> Any | None:
+        now = int(time.time())
+        row = self.conn.execute(
+            "SELECT value, expires_at FROM cache WHERE key = ?", (key,)
+        ).fetchone()
+        if row is None:
+            return None
+        value, expires_at = row
+        if expires_at < now:
+            self.conn.execute("DELETE FROM cache WHERE key = ?", (key,))
+            return None
+        return json.loads(value)
+
+    def set(self, key: str, value: Any, ttl: int) -> None:
+        expires_at = int(time.time()) + ttl
+        self.conn.execute(
+            "INSERT OR REPLACE INTO cache(key, value, expires_at) VALUES (?, ?, ?)",
+            (key, json.dumps(value, ensure_ascii=False), expires_at),
+        )
+
+    def purge_expired(self) -> int:
+        cur = self.conn.execute("DELETE FROM cache WHERE expires_at < ?", (int(time.time()),))
+        return cur.rowcount or 0
+
+    def stats(self) -> dict[str, int]:
+        rows = self.conn.execute(
+            "SELECT COUNT(*), COALESCE(SUM(LENGTH(value)), 0) FROM cache"
+        ).fetchone()
+        return {"entries": rows[0], "bytes": rows[1]}
+
+    def close(self) -> None:
+        self.conn.close()
+
+
+def _key(prefix: str, args: dict[str, Any]) -> str:
+    # Drop None values so equivalent calls collapse to the same key.
+    cleaned = {k: v for k, v in args.items() if v is not None}
+    return f"{prefix}::{json.dumps(cleaned, sort_keys=True, ensure_ascii=False)}"
+
+
+class CachingPasalClient:
+    """Drop-in replacement for PasalClient with on-disk caching."""
+
+    def __init__(
+        self,
+        inner: PasalClient,
+        cache_path: Path | None = None,
+        *,
+        ttl_search: int = DEFAULT_TTL_SEARCH,
+        ttl_list: int = DEFAULT_TTL_LIST,
+        ttl_get: int = DEFAULT_TTL_GET,
+    ):
+        self._inner = inner
+        self._cache = _SqliteCache(cache_path or _default_cache_path())
+        self._ttl_search = ttl_search
+        self._ttl_list = ttl_list
+        self._ttl_get = ttl_get
+        self.hits = 0
+        self.misses = 0
+
+    def _cached(self, prefix: str, args: dict[str, Any], ttl: int, fetch: Callable[[], Any]) -> Any:
+        key = _key(prefix, args)
+        hit = self._cache.get(key)
+        if hit is not None:
+            self.hits += 1
+            return hit
+        self.misses += 1
+        value = fetch()
+        self._cache.set(key, value, ttl)
+        return value
+
+    def search(self, q: str, type: str | None = None, limit: int = 10) -> dict[str, Any]:
+        args = {"q": q, "type": type, "limit": limit}
+        return self._cached("search", args, self._ttl_search, lambda: self._inner.search(**args))
+
+    def list_laws(
+        self,
+        type: str | None = None,
+        year: int | None = None,
+        status: str | None = None,
+        limit: int = 20,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        args = {"type": type, "year": year, "status": status, "limit": limit, "offset": offset}
+        return self._cached("list", args, self._ttl_list, lambda: self._inner.list_laws(**args))
+
+    def get_law(self, frbr_uri: str) -> dict[str, Any]:
+        args = {"frbr_uri": frbr_uri}
+        return self._cached("get", args, self._ttl_get, lambda: self._inner.get_law(**args))
+
+    def stats(self) -> dict[str, Any]:
+        return {**self._cache.stats(), "session_hits": self.hits, "session_misses": self.misses}
+
+    def purge_expired(self) -> int:
+        return self._cache.purge_expired()
+
+    def close(self) -> None:
+        try:
+            self._inner.close()
+        finally:
+            self._cache.close()
+
+    def __enter__(self) -> "CachingPasalClient":
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.close()

src/legawa/tools/pasal.py

@@ -0,0 +1,175 @@
+"""Client for the pasal.id REST API.
+
+Endpoints (https://pasal.id/api/v1):
+  GET /search?q=...&type=...&limit=...      — keyword search
+  GET /laws?type=...&year=...&status=...    — list with filters
+  GET /laws/{frbr_uri}                      — full document + articles
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from ..config import Settings
+
+
+REGULATION_TYPES = [
+    "UU", "PERPPU", "PP", "PERPRES", "PERMEN",
+    "PERDA", "PERDA_PROV", "PERDA_KAB",
+]
+
+STATUS_VALUES = ["berlaku", "dicabut", "diubah"]
+
+
+class PasalClient:
+    def __init__(self, settings: Settings, timeout: float = 30.0):
+        self._client = httpx.Client(
+            base_url=settings.pasal_base_url,
+            headers={
+                "Authorization": f"Bearer {settings.pasal_token}",
+                "Accept": "application/json",
+                "User-Agent": "legawa/0.1",
+            },
+            timeout=timeout,
+        )
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> "PasalClient":
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.close()
+
+    def search(
+        self,
+        q: str,
+        type: str | None = None,
+        limit: int = 10,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"q": q, "limit": max(1, min(20, limit))}
+        if type:
+            params["type"] = type
+        r = self._client.get("/search", params=params)
+        r.raise_for_status()
+        return r.json()
+
+    def list_laws(
+        self,
+        type: str | None = None,
+        year: int | None = None,
+        status: str | None = None,
+        limit: int = 20,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {
+            "limit": max(1, min(50, limit)),
+            "offset": max(0, offset),
+        }
+        if type:
+            params["type"] = type
+        if year:
+            params["year"] = year
+        if status:
+            params["status"] = status
+        r = self._client.get("/laws", params=params)
+        r.raise_for_status()
+        return r.json()
+
+    def get_law(self, frbr_uri: str) -> dict[str, Any]:
+        # frbr_uri example: akn/id/act/uu/2003/13
+        r = self._client.get(f"/laws/{frbr_uri.lstrip('/')}")
+        r.raise_for_status()
+        return r.json()
+
+
+# OpenAI-compatible tool schemas exposed to agents.
+TOOL_SCHEMAS: list[dict[str, Any]] = [
+    {
+        "type": "function",
+        "function": {
+            "name": "pasal_search",
+            "description": (
+                "Cari peraturan perundang-undangan Indonesia di pasal.id berdasarkan kata kunci. "
+                "Mengembalikan daftar peraturan beserta cuplikan pasal yang relevan dan frbr_uri "
+                "yang bisa dipakai untuk mengambil dokumen lengkap."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "q": {"type": "string", "description": "Kata kunci pencarian (Bahasa Indonesia)."},
+                    "type": {
+                        "type": "string",
+                        "enum": REGULATION_TYPES,
+                        "description": "Filter jenis peraturan (opsional).",
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "minimum": 1,
+                        "maximum": 20,
+                        "default": 10,
+                    },
+                },
+                "required": ["q"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "pasal_list_laws",
+            "description": (
+                "Daftar peraturan dengan filter jenis, tahun, dan status. Berguna untuk eksplorasi "
+                "tanpa kata kunci spesifik."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "type": {"type": "string", "enum": REGULATION_TYPES},
+                    "year": {"type": "integer", "minimum": 1945, "maximum": 2100},
+                    "status": {"type": "string", "enum": STATUS_VALUES},
+                    "limit": {"type": "integer", "minimum": 1, "maximum": 50, "default": 20},
+                    "offset": {"type": "integer", "minimum": 0, "default": 0},
+                },
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "pasal_get_law",
+            "description": (
+                "Ambil dokumen peraturan lengkap beserta seluruh pasal dan relasi antar peraturan, "
+                "berdasarkan frbr_uri (mis. 'akn/id/act/uu/2003/13')."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "frbr_uri": {
+                        "type": "string",
+                        "description": "FRBR URI dari hasil search atau list_laws.",
+                    },
+                },
+                "required": ["frbr_uri"],
+            },
+        },
+    },
+]
+
+
+def build_dispatcher(client: PasalClient):
+    """Return a callable mapping tool_name -> args -> result dict."""
+
+    def dispatch(name: str, args: dict[str, Any]) -> Any:
+        if name == "pasal_search":
+            return client.search(**args)
+        if name == "pasal_list_laws":
+            return client.list_laws(**args)
+        if name == "pasal_get_law":
+            return client.get_law(**args)
+        raise ValueError(f"unknown tool: {name}")
+
+    return dispatch