feat: add syntax checker and improve multilingual prompt analysis

- add Indonesian word-order syntax checker with optional IndoBERT scoring
- integrate syntax findings into pipeline status, analysis, hot reload, and sub-server startup
- add syntax issue highlighting and explanation in the web UI
- improve English/Indonesian handling across PII, filler, NER, profanity, responsible, and word quality detectors
- tune lexicons to reduce false positives for Indonesian terms

.gitignore

@@ -2,6 +2,7 @@
 GEMINI.md
 AGENT.md
 CLAUDE.md
+.claude
 
 # Python
 __pycache__/

resources/lexicons/profanity/whitelist.txt

@@ -3,7 +3,6 @@ kampung
 buaya
 berak
 benar
-bugil
 bisu
 buta
 alay

resources/lexicons/word_quality/slang_id.tsv

@@ -700,7 +700,6 @@ btul	betul
 btulan	betulan
 buanget	banget
 buanyaaak	banyak
-buat	untuk
 buatin	membuat
 bujngn	bujangan
 bujukk	bujuk
@@ -2208,7 +2207,6 @@ ladenin	meladeni
 laen	lain
 laenny	lainnya
 lafazd	lafaz
-lagi	sedang
 lagihh	lagi
 lagii	lagi
 lagiii	lagi

src/core/pipeline_server.py

@@ -7,14 +7,17 @@
 Pipeline Server — Orchestrator semua detektor NLP.
 Port default: 8000
 
-Menggabungkan tujuh detektor dalam satu endpoint untuk frontend index.html:
-    1. PII Detector         — data pribadi (NIK, email, telepon, dll.)
+Menggabungkan delapan detektor dalam satu endpoint untuk frontend index.html:
+    1. PII Detector         — data pribadi (NIK, email, telepon, SSN, dll.)
     2. Word Quality         — kata slang, alay, dan typo
     3. Responsible Checker  — prompt injection, kecurangan akademik, konten berbahaya
     4. NER                  — entitas bernama (orang, lokasi, organisasi, dll.)
     5. Profanity Checker    — kata kasar dan tidak pantas
     6. Filler Checker       — frasa basa-basi yang membuang token
     7. Special Char Detector — karakter invisible dan tidak efektif (zero-width, full-width, dll.)
+    8. Syntax Checker       — urutan kata janggal Bahasa Indonesia (perplexity IndoBERT)
+
+PII, Filler, dan NER mendukung Bahasa Indonesia maupun Inggris (routing per bahasa).
 
 Endpoint HTTP:
     GET  /api/status   — status tiap detektor (siap / tidak siap)
@@ -30,6 +33,7 @@ Sub-server (dijalankan otomatis sebagai proses latar belakang):
     port 8005 — Profanity server     (web/profanity-test.html)
     port 8006 — Filler server        (web/filler-test.html)
     port 8007 — Special Char server  (web/special-char-test.html)
+    port 8008 — Syntax server        (deteksi urutan kata)
 
 Cara menjalankan:
     python src/core/pipeline_server.py
@@ -107,6 +111,10 @@ _FIELDS: list[dict] = [
      "color": "#7c2d12",  "surface": "#fff7ed"},
 ]
 
+# Field yang diperiksa Syntax Checker (kalimat naratif utuh). Field lain seperti
+# tone/outputFormat/example sengaja boleh berupa frasa pendek, jadi dilewati.
+_SYNTAX_FIELDS: frozenset[str] = frozenset({"task", "context", "references"})
+
 
 # ── State Global Detektor ──────────────────────────────────────────────────────
 #
@@ -120,11 +128,13 @@ _ner         = None   # IndonesianNER
 _prof        = None   # ProfanityChecker
 _filler      = None   # FillerChecker
 _special_char = None  # SpecialCharDetector
+_syntax      = None   # SyntaxChecker
 
 # Flag startup (disimpan agar reload menggunakan flag yang sama)
-_no_resp_ml = False
-_no_ner     = False
-_no_ner_ml  = False
+_no_resp_ml  = False
+_no_ner      = False
+_no_ner_ml   = False
+_no_syntax_ml = False
 _detectors_loaded = threading.Event()
 
 
@@ -150,6 +160,7 @@ class DetectorWatcher:
         ("profanity/profanity_checker.py",         "_reload_prof"),
         ("filler/filler_checker.py",               "_reload_filler"),
         ("special_char/special_char_detector.py",  "_reload_special_char"),
+        ("syntax/syntax_checker.py",               "_reload_syntax"),
         ("thesaurus/thesaurus_id.py",              "_reload_thesaurus"),
     ]
 
@@ -245,6 +256,14 @@ class DetectorWatcher:
         importlib.reload(m)
         _special_char = m.SpecialCharDetector()
 
+    def _reload_syntax(self) -> None:
+        global _syntax
+        import syntax.syntax_checker as m
+        importlib.reload(m)
+        checker = m.SyntaxChecker(use_ml=not _no_syntax_ml)
+        checker.load()
+        _syntax = checker
+
     def _reload_thesaurus(self) -> None:
         # Reset singleton di word_quality_detector agar terbaca ulang saat request berikutnya
         try:
@@ -343,7 +362,7 @@ def _resp_issue(finding, field: dict, text: str) -> dict:
         "issue_type":  finding.code,
         "css_class":   css,
         "severity":    finding.severity,
-        "word":        finding.evidence[:60] + ("..." if len(finding.evidence) > 60 else ""),
+        "word":        finding.evidence,
         "start":       start,
         "end":         end,
         "label":       finding.code.replace("_", " "),
@@ -444,6 +463,27 @@ def _special_char_issue(finding, field: dict) -> dict:
     }
 
 
+def _syntax_issue(finding, field: dict) -> dict:
+    """Konversi SyntaxFinding → dict issue standar."""
+    return {
+        "source":      "syntax",
+        "field_id":    field["id"],
+        "field_label": field["label"],
+        "issue_type":  "UNUSUAL_WORD_ORDER",
+        "css_class":   "syntax",
+        "severity":    "LOW",
+        "word":        finding.sentence,
+        "start":       finding.start,
+        "end":         finding.end,
+        "label":       "Urutan Kata",
+        "suggestion":  None,
+        "reason":      finding.reason,
+        "action":      "select",
+        "replacement": None,
+        "confidence":  finding.confidence,
+    }
+
+
 def _ner_issue(entity, field: dict) -> dict:
     """Konversi NEREntity → dict issue standar."""
     return {
@@ -553,6 +593,15 @@ def _analyze_field(f: dict, text: str) -> list[dict]:
         except Exception as e:
             logger.warning("Special Char error [%s]: %s", f["id"], e)
 
+    # Syntax checker hanya untuk field naratif (kalimat utuh). Field seperti
+    # tone/outputFormat/example sengaja bisa berupa frasa, jadi dilewati.
+    if _syntax and f["id"] in _SYNTAX_FIELDS:
+        try:
+            for finding in _syntax.check(text, language=language):
+                issues.append(_syntax_issue(finding, f))
+        except Exception as e:
+            logger.warning("Syntax error [%s]: %s", f["id"], e)
+
     return issues
 
 
@@ -641,6 +690,7 @@ def _evaluate(fields: dict[str, str]) -> dict:
             "profanity":    _prof         is not None,
             "filler":       _filler       is not None,
             "special_char": _special_char is not None,
+            "syntax":       _syntax       is not None,
         },
     }
 
@@ -744,6 +794,7 @@ class Handler(BaseHTTPRequestHandler):
                     "profanity":     _prof         is not None,
                     "filler":        _filler       is not None,
                     "special_char":  _special_char is not None,
+                    "syntax":        _syntax       is not None,
                 },
             })
         elif self.path.startswith("/api/"):
@@ -782,7 +833,8 @@ class Handler(BaseHTTPRequestHandler):
 
 # ── Entry Point ────────────────────────────────────────────────────────────────
 
-def _start_subservers(host: str, no_resp_ml: bool = False, no_ner: bool = False, no_ner_ml: bool = False) -> None:
+def _start_subservers(host: str, no_resp_ml: bool = False, no_ner: bool = False,
+                      no_ner_ml: bool = False, no_syntax_ml: bool = False) -> None:
     """
     Jalankan semua server test individual sebagai proses latar belakang.
 
@@ -794,10 +846,11 @@ def _start_subservers(host: str, no_resp_ml: bool = False, no_ner: bool = False,
       error diabaikan dengan pesan peringatan.
 
     Args:
-        host:        Host yang digunakan (sama dengan pipeline server).
-        no_resp_ml:  Teruskan flag --no-resp-ml ke responsible_server.
-        no_ner:      Jangan jalankan sub-server NER.
-        no_ner_ml:   Jangan jalankan sub-server NER karena server ini selalu memuat model ML.
+        host:         Host yang digunakan (sama dengan pipeline server).
+        no_resp_ml:   Teruskan flag --no-resp-ml ke responsible_server.
+        no_ner:       Jangan jalankan sub-server NER.
+        no_ner_ml:    Jangan jalankan sub-server NER karena server ini selalu memuat model ML.
+        no_syntax_ml: Jangan jalankan sub-server Syntax karena server ini selalu memuat model ML.
     """
     global _sub_processes
 
@@ -815,6 +868,11 @@ def _start_subservers(host: str, no_resp_ml: bool = False, no_ner: bool = False,
     else:
         logger.info("Sub-server NER dilewati (mode cepat / NER ML nonaktif).")
 
+    if not no_syntax_ml:
+        configs.append(("syntax/syntax_server.py", 8008, "Syntax", []))
+    else:
+        logger.info("Sub-server Syntax dilewati (mode cepat / Syntax ML nonaktif).")
+
     logger.info("─" * 56)
     logger.info("Memulai sub-server halaman test…")
 
@@ -854,7 +912,8 @@ def main() -> None:
         6. Filler Checker      (ringan, berbasis regex)
         7. Special Char Detector (ringan, berbasis karakter)
     """
-    global _pii, _wq, _resp, _ner, _prof, _filler, _special_char, _no_resp_ml, _no_ner, _no_ner_ml
+    global _pii, _wq, _resp, _ner, _prof, _filler, _special_char
+    global _no_resp_ml, _no_ner, _no_ner_ml, _no_syntax_ml
 
     # Railway (dan platform cloud lain) mengeset $PORT secara otomatis.
     # Fallback ke 8000 untuk development lokal.
@@ -873,18 +932,22 @@ def main() -> None:
     parser.add_argument("--no-ner-ml", action="store_true",
                         help="NER hanya rule-based (regex + nama), tanpa model transformer (~600 MB). "
                              "Lebih cepat; masih mendeteksi lembaga, tanggal, nama orang, dll.")
+    parser.add_argument("--no-syntax-ml", action="store_true",
+                        help="Nonaktifkan Syntax Checker (deteksi urutan kata, model IndoBERT ~420 MB).")
     parser.add_argument("--fast", action="store_true",
-                        help="Mode cepat: setara --no-resp-ml --no-ner-ml. Semua detektor aktif, tanpa model berat.")
+                        help="Mode cepat: setara --no-resp-ml --no-ner-ml --no-syntax-ml. "
+                             "Semua detektor ringan aktif, tanpa model berat.")
     args = parser.parse_args()
-    _no_resp_ml = args.no_resp_ml or args.fast
-    _no_ner     = args.no_ner
-    _no_ner_ml  = args.no_ner_ml or args.fast
+    _no_resp_ml   = args.no_resp_ml or args.fast
+    _no_ner       = args.no_ner
+    _no_ner_ml    = args.no_ner_ml or args.fast
+    _no_syntax_ml = args.no_syntax_ml or args.fast
 
     # ── Load semua detektor di background thread ──────────────────────────────
     # Server langsung mulai listen agar healthcheck Railway tidak timeout.
     # /api/status mengembalikan ready:false selama loading, ready:true setelah selesai.
     def _load_detectors():
-        global _pii, _wq, _resp, _ner, _prof, _filler, _special_char
+        global _pii, _wq, _resp, _ner, _prof, _filler, _special_char, _syntax
 
         # 1. PII Detector
         logger.info("Memuat PII Detector...")
@@ -952,11 +1015,27 @@ def main() -> None:
         _special_char = SpecialCharDetector()
         logger.info("Special Char Detector siap.")
 
-        # 8. Hot-reload watcher
+        # 8. Syntax Checker (deteksi urutan kata, model IndoBERT ~420 MB)
+        if _no_syntax_ml:
+            logger.info("Syntax Checker dinonaktifkan (--no-syntax-ml / --fast).")
+            _syntax = None
+        else:
+            logger.info("Memuat Syntax Checker (model IndoBERT, proses ini mungkin memerlukan waktu)...")
+            try:
+                from syntax.syntax_checker import SyntaxChecker
+                _syntax = SyntaxChecker(use_ml=True)
+                _syntax.load()
+                logger.info("Syntax Checker siap (ML aktif: %s).", _syntax.ml_active)
+            except Exception as e:
+                logger.error("Syntax Checker gagal dimuat: %s — lanjut tanpa deteksi urutan kata.", e)
+                _syntax = None
+
+        # 9. Hot-reload watcher
         DetectorWatcher(_SRC_DIR).start()
 
-        # 9. Sub-server halaman test
-        _start_subservers(args.host, no_resp_ml=_no_resp_ml, no_ner=_no_ner, no_ner_ml=_no_ner_ml)
+        # 10. Sub-server halaman test
+        _start_subservers(args.host, no_resp_ml=_no_resp_ml, no_ner=_no_ner,
+                          no_ner_ml=_no_ner_ml, no_syntax_ml=_no_syntax_ml)
 
         logger.info("Semua detektor siap. Pipeline aktif penuh.")
         _detectors_loaded.set()

src/filler/filler_checker.py

@@ -26,6 +26,7 @@ from __future__ import annotations
 
 import logging
 import re
+import threading
 from dataclasses import dataclass
 
 logger = logging.getLogger(__name__)
@@ -59,11 +60,26 @@ class FillerFinding:
 
 _F = re.IGNORECASE | re.UNICODE
 
-_PATTERNS: list[tuple[re.Pattern[str], str, str, float]] = []
+# Tuple: (pola, kategori, reason_id, confidence, reason_en)
+_PATTERNS: list[tuple[re.Pattern[str], str, str, float, str]] = []
 
 
-def _add(pattern: str, category: str, reason: str, conf: float = 0.88) -> None:
-    _PATTERNS.append((re.compile(pattern, _F), category, reason, conf))
+def _add(
+    pattern:   str,
+    category:  str,
+    reason:    str,
+    conf:      float = 0.88,
+    reason_en: str = "",
+) -> None:
+    """
+    Daftarkan satu pola filler.
+
+    Args:
+        reason:    Penjelasan Bahasa Indonesia (dipakai untuk teks id/mixed/unknown).
+        reason_en: Penjelasan Bahasa Inggris (dipakai saat language == "en").
+                   Jika kosong, fallback ke `reason`.
+    """
+    _PATTERNS.append((re.compile(pattern, _F), category, reason, conf, reason_en or reason))
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -78,6 +94,8 @@ _add(
     "Sapaan langsung ke nama AI tidak diperlukan — AI memahami konteks tanpa "
     "disapa. Menghapus frasa ini menghemat token dan membuat prompt lebih ringkas.",
     0.95,
+    reason_en="Greeting the AI by name is unnecessary — it understands context "
+    "without being addressed. Removing this phrase saves tokens and keeps the prompt concise.",
 )
 
 _add(
@@ -86,6 +104,7 @@ _add(
     "GREETING_AI",
     "Sapaan formal ke AI tidak diperlukan. Langsung tuliskan permintaan Anda.",
     0.90,
+    reason_en="A formal salutation to the AI is unnecessary. State your request directly.",
 )
 
 _add(
@@ -94,6 +113,7 @@ _add(
     "GREETING_AI",
     "Kata sapaan ini tidak diperlukan. Langsung tuliskan permintaan Anda.",
     0.87,
+    reason_en="This greeting is unnecessary. State your request directly.",
 )
 
 # AI baru: Grok, Perplexity, DeepSeek, Qwen, Falcon, Phi, dll.
@@ -105,6 +125,7 @@ _add(
     "GREETING_AI",
     "Sapaan langsung ke nama AI tidak diperlukan — langsung tuliskan permintaan Anda.",
     0.93,
+    reason_en="Greeting the AI by name is unnecessary — state your request directly.",
 )
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -118,6 +139,8 @@ _add(
     "Sapaan ini berdiri sendiri tanpa permintaan atau konteks apapun. "
     "AI tidak memerlukan sapaan — langsung tuliskan pertanyaan atau instruksi Anda.",
     0.93,
+    reason_en="This greeting stands alone without any request or context. The AI "
+    "does not need a greeting — write your question or instruction directly.",
 )
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -136,6 +159,8 @@ _add(
     "Ucapan terima kasih tidak menambah informasi ke prompt. "
     "AI tidak memiliki perasaan yang perlu dijaga — cukup tuliskan permintaan secara langsung.",
     0.90,
+    reason_en="Thanking the AI adds no information to the prompt. The AI has no "
+    "feelings to spare — simply state your request directly.",
 )
 
 # Terima kasih di tengah prompt (sebelum/sesudah koma)
@@ -159,6 +184,8 @@ _add(
     "Permintaan maaf tidak perlu dalam prompt. AI tidak terganggu oleh pertanyaan "
     "— justru itulah fungsinya. Langsung tuliskan permintaan Anda.",
     0.91,
+    reason_en="An apology is unnecessary in a prompt. The AI is not bothered by "
+    "questions — that is exactly its purpose. State your request directly.",
 )
 
 _add(
@@ -173,6 +200,17 @@ _add(
     "APOLOGY",
     "Permintaan maaf tidak diperlukan dalam prompt AI. Langsung tuliskan permintaan Anda.",
     0.90,
+    reason_en="An apology is unnecessary in an AI prompt. State your request directly.",
+)
+
+# "I'm sorry / I apologize" — pembuka maaf Bahasa Inggris
+_add(
+    r"\bi\s+(?:'m\s+|am\s+)?(?:sorry|apolog(?:ize|ise))\s+"
+    r'(?:for|to|about|if|that)\b',
+    "APOLOGY",
+    "Permintaan maaf tidak diperlukan dalam prompt AI. Langsung tuliskan permintaan Anda.",
+    0.85,
+    reason_en="An apology is unnecessary in an AI prompt. State your request directly.",
 )
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -238,6 +276,7 @@ _add(
     "EMPTY_OPENER",
     "Pembuka permintaan bantuan ini tidak menambah konteks. Langsung tuliskan tugas yang ingin dikerjakan.",
     0.86,
+    reason_en="This help-request opener adds no context. State the task you want done directly.",
 )
 
 _add(
@@ -245,6 +284,52 @@ _add(
     "EMPTY_OPENER",
     "Frasa ini terlalu umum. Jelaskan tugas atau konteksnya secara langsung.",
     0.84,
+    reason_en="This phrase is too general. Describe the task or context directly.",
+)
+
+# "I was wondering if/whether ..." sebagai pembuka basa-basi
+_add(
+    r"\bi\s+was\s+wondering\s+(?:if|whether)\b",
+    "EMPTY_OPENER",
+    "Pembuka ini dapat dipersingkat. Langsung tuliskan pertanyaan atau permintaan Anda.",
+    0.83,
+    reason_en="This opener can be trimmed. State your question or request directly.",
+)
+
+# "Would it be possible (for you) to ..."
+_add(
+    r"\bwould\s+it\s+be\s+possible\s+(?:for\s+(?:you|me)\s+)?to\b",
+    "EMPTY_OPENER",
+    "Frasa pembuka ini membuang token. Langsung tuliskan apa yang Anda inginkan.",
+    0.82,
+    reason_en="This opener wastes tokens. State directly what you want.",
+)
+
+# "I'd like to ask (you) ..."
+_add(
+    r"\bi(?:'d|\s+would)\s+like\s+to\s+ask\s+(?:you\s+)?\b",
+    "EMPTY_OPENER",
+    "Deklarasi 'ingin bertanya' tidak diperlukan. Langsung ajukan pertanyaannya.",
+    0.83,
+    reason_en="Declaring that you'd like to ask is unnecessary. Just ask the question.",
+)
+
+# "I'd appreciate it if you could/would ..."
+_add(
+    r"\bi(?:'d|\s+would)\s+appreciate\s+it\s+if\s+you\s+(?:could|would)\b",
+    "EMPTY_OPENER",
+    "Frasa kesopanan ini membuang token. Langsung tuliskan permintaan Anda.",
+    0.82,
+    reason_en="This politeness phrase wastes tokens. State your request directly.",
+)
+
+# "If you could (please) ..." sebagai pembuka
+_add(
+    r"(?:^|(?<=[.!?\n]))\s*if\s+you\s+(?:could|would|can)\s+(?:please\s+)?",
+    "EMPTY_OPENER",
+    "Pembuka kondisional ini tidak diperlukan. Langsung tuliskan instruksi Anda.",
+    0.80,
+    reason_en="This conditional opener is unnecessary. State your instruction directly.",
 )
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -292,6 +377,39 @@ _add(
     "EMOTIONAL_FILLER",
     "Frasa harapan ini tidak menambah informasi. Langsung tuliskan instruksi atau pertanyaan Anda.",
     0.84,
+    reason_en="This expression of hope adds no information. State your instruction or question directly.",
+)
+
+# "You're such a great/amazing AI" — sanjungan Bahasa Inggris
+_add(
+    r"\byou(?:'re|\s+are)\s+(?:such\s+)?(?:a\s+|an\s+)?"
+    r"(?:great|amazing|wonderful|fantastic|brilliant|incredible|awesome|smart|intelligent|the\s+best)\s+"
+    r"(?:AI|assistant|model|chatbot|bot)\b",
+    "EMOTIONAL_FILLER",
+    "Sanjungan ke AI tidak mempengaruhi kualitas jawaban. "
+    "Gunakan ruang prompt untuk informasi yang benar-benar relevan.",
+    0.85,
+    reason_en="Flattering the AI does not affect answer quality. Use the prompt space "
+    "for information that actually matters.",
+)
+
+# "I'm sure/confident you can help/do this" — pernyataan kepercayaan Bahasa Inggris
+_add(
+    r"\bi(?:'m|\s+am)\s+(?:sure|confident|certain)\s+(?:that\s+)?you\s+can\s+"
+    r"(?:help|do\s+this|handle\s+this|figure\s+this\s+out)\b",
+    "EMOTIONAL_FILLER",
+    "Frasa kepercayaan ini tidak menambah informasi ke prompt. Langsung tuliskan permintaan Anda.",
+    0.84,
+    reason_en="This statement of confidence adds no information to the prompt. State your request directly.",
+)
+
+# "I know you can do this/help" — penyemangat Bahasa Inggris
+_add(
+    r"\bi\s+know\s+you\s+can\s+(?:do\s+this|help|figure\s+this\s+out|handle\s+(?:this|it))\b",
+    "EMOTIONAL_FILLER",
+    "Frasa penyemangat ini tidak menambah informasi. Langsung tuliskan permintaan Anda.",
+    0.83,
+    reason_en="This encouragement adds no information. State your request directly.",
 )
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -341,6 +459,27 @@ _add(
     "Referensi 'ini/itu' tidak jelas tanpa konteks yang disebutkan sebelumnya. "
     "Tuliskan secara eksplisit apa topik yang dimaksud.",
     0.80,
+    reason_en="The reference 'this/that' is unclear without prior context. "
+    "State explicitly what topic you mean.",
+)
+
+# "you know", "i mean", "like that", "kind of", "sort of" — pengisi vague Bahasa Inggris
+_add(
+    r'\b(?:you\s+know|i\s+mean|like\s+(?:this|that)|kind\s+of|sort\s+of|'
+    r'that\s+(?:sort|kind|type)\s+of\s+thing)\b',
+    "VAGUE_REFERENCE",
+    "Frasa pengisi ini tidak jelas bagi AI. Jelaskan secara eksplisit apa yang dimaksud.",
+    0.80,
+    reason_en="This filler phrase is unclear to the AI. State explicitly what you mean.",
+)
+
+# "and stuff", "and things", "and so on", "etc." di akhir kalimat — penutup vague
+_add(
+    r'\b(?:and\s+(?:stuff|things|whatnot|so\s+on|so\s+forth)|et\s+cetera|etc\.?)\s*[,!.]?\s*$',
+    "VAGUE_REFERENCE",
+    "Penutup terbuka ini membuat permintaan tidak jelas. Sebutkan secara lengkap apa yang Anda maksud.",
+    0.80,
+    reason_en="This open-ended ending makes the request vague. Spell out fully what you mean.",
 )
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -447,6 +586,7 @@ _add(
     "UNNECESSARY_PREAMBLE",
     "Preamble ini tidak diperlukan. Langsung tuliskan pertanyaan Anda.",
     0.86,
+    reason_en="This preamble is unnecessary. Just write your question directly.",
 )
 
 _add(
@@ -454,6 +594,7 @@ _add(
     "UNNECESSARY_PREAMBLE",
     "Deklarasi bahwa pertanyaan singkat tidak menambah informasi. Langsung ajukan pertanyaannya.",
     0.84,
+    reason_en="Announcing that the question is short adds no information. Just ask it.",
 )
 
 _add(
@@ -461,6 +602,36 @@ _add(
     "UNNECESSARY_PREAMBLE",
     "Frasa pembuka ini dapat dipersingkat. Langsung tuliskan pertanyaan atau instruksi Anda.",
     0.83,
+    reason_en="This opener can be trimmed. Write your question or instruction directly.",
+)
+
+# "Allow me to ask / let me ask" — preamble formal Bahasa Inggris
+_add(
+    r'\b(?:allow|let)\s+me\s+(?:to\s+)?(?:ask|explain|clarify|say)\b',
+    "UNNECESSARY_PREAMBLE",
+    "Frasa formal ini tidak diperlukan. Langsung tuliskan pertanyaan atau instruksi Anda.",
+    0.83,
+    reason_en="This formal phrase is unnecessary. Write your question or instruction directly.",
+)
+
+# "I have a question/query/inquiry" — deklarasi punya pertanyaan
+_add(
+    r'\bi\s+have\s+(?:a|one|just\s+a)\s+'
+    r'(?:quick\s+|small\s+|simple\s+|brief\s+)?(?:question|query|inquiry)\b',
+    "UNNECESSARY_PREAMBLE",
+    "Deklarasi 'saya punya pertanyaan' tidak diperlukan. Langsung ajukan pertanyaannya.",
+    0.84,
+    reason_en="Declaring 'I have a question' is unnecessary. Just ask it.",
+)
+
+# "What I'd like to know/ask/understand is ..." — preamble panjang
+_add(
+    r"\b(?:the\s+question|what)\s+i(?:'d|\s+would)?\s+(?:like\s+to|want\s+to)\s+"
+    r"(?:know|ask|understand)\s+is\b",
+    "UNNECESSARY_PREAMBLE",
+    "Frasa preamble ini membuang token. Langsung tuliskan apa yang ingin Anda ketahui.",
+    0.84,
+    reason_en="This preamble wastes tokens. State directly what you want to know.",
 )
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -476,6 +647,8 @@ _add(
     "Bunyi ragu 'hmm' tidak menambah informasi. Hilangkan dan langsung tuliskan "
     "permintaan Anda.",
     0.92,
+    reason_en="The hesitation sound 'hmm' adds no information. Remove it and state "
+    "your request directly.",
 )
 
 _add(
@@ -483,6 +656,18 @@ _add(
     "HESITATION",
     "Bunyi ragu ini tidak diperlukan dalam prompt. Langsung tuliskan instruksi Anda.",
     0.90,
+    reason_en="This hesitation sound is unnecessary in a prompt. State your instruction directly.",
+)
+
+# "Well, so / Okay, so / So basically" — transisi percakapan Bahasa Inggris
+_add(
+    r'(?:^|(?<=[.!?\n]))\s*(?:well|okay|ok|so)\s*,?\s+(?:so|basically|anyway|um|uh)\b',
+    "HESITATION",
+    "Transisi percakapan ini tidak diperlukan dalam prompt tertulis. "
+    "Langsung tuliskan instruksi atau pertanyaan Anda.",
+    0.82,
+    reason_en="This conversational transition is unnecessary in a written prompt. "
+    "State your instruction or question directly.",
 )
 
 _add(
@@ -532,12 +717,33 @@ _ML_LABEL_TO_CAT: dict[str, str | None] = {
     "instruksi yang spesifik dan bermakna":                 None,  # safe
 }
 
+# Label Bahasa Inggris untuk teks Inggris (mDeBERTa bersifat multilingual).
+_ML_LABELS_EN = [
+    "an unnecessary greeting or filler phrase",          # → GREETING_AI / GREETING_ONLY
+    "a vague or overly general request for help",        # → EMPTY_OPENER
+    "an ambiguous demonstrative reference",              # → VAGUE_REFERENCE
+    "a specific and meaningful instruction",            # → safe (tidak dilaporkan)
+]
+
+_ML_LABEL_TO_CAT_EN: dict[str, str | None] = {
+    "an unnecessary greeting or filler phrase":   "GREETING_AI",
+    "a vague or overly general request for help": "EMPTY_OPENER",
+    "an ambiguous demonstrative reference":       "VAGUE_REFERENCE",
+    "a specific and meaningful instruction":      None,  # safe
+}
+
 _ML_REASON: dict[str, str] = {
     "GREETING_AI":     "Sapaan atau basa-basi terdeteksi. AI tidak memerlukan pembuka semacam ini — langsung tuliskan permintaan Anda.",
     "EMPTY_OPENER":    "Permintaan bantuan terlalu umum. Jelaskan secara spesifik apa yang ingin dibantu.",
     "VAGUE_REFERENCE": "Teks mengandung referensi yang ambigu. Jelaskan secara eksplisit apa yang dimaksud.",
 }
 
+_ML_REASON_EN: dict[str, str] = {
+    "GREETING_AI":     "A greeting or filler phrase was detected. The AI does not need such an opener — state your request directly.",
+    "EMPTY_OPENER":    "This help request is too general. Describe specifically what you need help with.",
+    "VAGUE_REFERENCE": "The text contains an ambiguous reference. State explicitly what you mean.",
+}
+
 
 # ═══════════════════════════════════════════════════════════════════════════════
 # Kelas Utama
@@ -569,6 +775,9 @@ class FillerChecker:
         """
         self._use_ml   = use_ml and _TRANSFORMERS_OK
         self._ml_pipe  = None
+        # Lock inferensi ML. Saat meminjam pipeline ResponsibleChecker, lock-nya
+        # ikut dipinjam agar inferensi pada model yang sama tetap terserialisasi.
+        self._ml_lock  = threading.Lock()
         self._loaded   = False
 
     def load(self) -> bool:
@@ -588,12 +797,15 @@ class FillerChecker:
         if not self._use_ml:
             return True
 
-        # Coba pinjam pipeline dari ResponsibleChecker (zero memory overhead)
+        # Coba pinjam pipeline dari ResponsibleChecker (zero memory overhead).
+        # Pinjam pula lock-nya: karena model torch sama, inferensi harus dilindungi
+        # lock yang sama agar tidak ada dua thread mengaksesnya bersamaan.
         try:
             from responsible.responsible_checker import get_checker as _get_resp
             resp = _get_resp(load=False)
             if resp.ml_active:
-                self._ml_pipe = resp._ml_pipe  # noqa: SLF001
+                self._ml_pipe = resp.ml_pipe
+                self._ml_lock = resp.ml_lock
                 logger.info("Filler ML Layer 2: meminjam pipeline ResponsibleChecker.")
                 return True
         except Exception:
@@ -638,9 +850,10 @@ class FillerChecker:
 
         findings:   list[FillerFinding]  = []
         seen_spans: set[tuple[int, int]] = set()
+        use_en = language == "en"
 
         # ── Layer 1: Regex ────────────────────────────────────────────────────
-        for pattern, category, reason, conf in _PATTERNS:
+        for pattern, category, reason_id, conf, reason_en in _PATTERNS:
             for m in pattern.finditer(text):
                 start, end = m.start(), m.end()
 
@@ -654,22 +867,28 @@ class FillerChecker:
 
                 seen_spans.add((start, end))
                 findings.append(FillerFinding(
-                    word=word[:60] + ("…" if len(word) > 60 else ""),
+                    word=word,
                     start=start,
                     end=end,
                     category=category,
-                    reason=reason,
+                    reason=reason_en if use_en else reason_id,
                     confidence=conf,
                 ))
 
-        # ── Layer 2: ML zero-shot (hanya jika Layer 1 kosong) ────────────────
-        if self._ml_pipe and not findings:
-            ml_result = self._check_ml(text)
-            findings.extend(ml_result)
+        # ── Layer 2: ML zero-shot — DINONAKTIFKAN ────────────────────────────
+        # Kategori "filler/vague" terlalu kabur secara semantik untuk zero-shot
+        # NLI: instruksi yang jelas dan konkret pun sering salah diklasifikasikan
+        # sebagai VAGUE_REFERENCE dengan skor tinggi (mis. "jelaskan perbedaan
+        # list dan tuple di python" → 0.95), tanpa ambang aman yang memisahkannya
+        # dari filler asli. Karena false positive lebih merugikan daripada
+        # melewatkan filler halus, Layer 2 dimatikan. Layer 1 (regex) yang presisi
+        # tetap menangani pola filler yang terdefinisi jelas.
+        # Metode _check_ml dipertahankan (dormant) agar mudah dihidupkan kembali
+        # bila tersedia model/label yang lebih sesuai.
 
         return sorted(findings, key=lambda f: f.start)
 
-    def _check_ml(self, text: str) -> list[FillerFinding]:
+    def _check_ml(self, text: str, language: str = "id") -> list[FillerFinding]:
         """
         Jalankan zero-shot classification pada teks penuh.
 
@@ -677,41 +896,52 @@ class FillerChecker:
         bahasa campuran, atau ekspresi tidak lazim.
         Hanya dipanggil ketika Layer 1 tidak menemukan apapun.
         """
+        use_en   = language == "en"
+        labels   = _ML_LABELS_EN if use_en else _ML_LABELS
+        label_to = _ML_LABEL_TO_CAT_EN if use_en else _ML_LABEL_TO_CAT
+        reasons  = _ML_REASON_EN if use_en else _ML_REASON
+        template = "This text contains {}." if use_en else "Teks ini mengandung {}."
+
         try:
-            result = self._ml_pipe(
-                text,
-                candidate_labels=_ML_LABELS,
-                hypothesis_template="Teks ini mengandung {}.",
-                multi_label=True,
-            )
+            # multi_label=False → label saling berkompetisi (softmax). Label "safe"
+            # (instruksi spesifik) ikut bersaing, sehingga instruksi konkret tidak
+            # salah ditandai sebagai filler. Lock menyerialkan akses model torch.
+            with self._ml_lock:
+                result = self._ml_pipe(
+                    text,
+                    candidate_labels=labels,
+                    hypothesis_template=template,
+                    multi_label=False,
+                )
         except Exception as exc:
             logger.debug("Filler ML gagal: %s", exc)
             return []
 
-        ml_findings: list[FillerFinding] = []
-        for label, score in zip(result["labels"], result["scores"]):
-            if score < _ML_THRESHOLD:
-                continue
-            cat = _ML_LABEL_TO_CAT.get(label)
-            if cat is None:
-                continue  # label "safe", tidak perlu dilaporkan
-
-            reason = _ML_REASON.get(cat, "Frasa ini perlu ditinjau kembali.")
-            reason += f" (terdeteksi oleh model ML, skor {score:.0%})"
-
-            # Laporkan sebagai temuan pada keseluruhan teks (start=0, end=len)
-            word = text[:60] + ("…" if len(text) > 60 else "")
-            ml_findings.append(FillerFinding(
-                word=word,
-                start=0,
-                end=len(text),
-                category=cat,
-                reason=reason,
-                confidence=round(score, 3),
-            ))
-            break  # satu temuan ML per teks sudah cukup
-
-        return ml_findings
+        # Hanya pertimbangkan label pemenang (skor tertinggi).
+        top_label = result["labels"][0]
+        top_score = result["scores"][0]
+        cat = label_to.get(top_label)
+        if cat is None or top_score < _ML_THRESHOLD:
+            # Pemenang adalah "instruksi spesifik" (aman) atau keyakinan terlalu
+            # rendah → tidak ada temuan.
+            return []
+
+        if use_en:
+            reason = reasons.get(cat, "This phrase should be reconsidered.")
+            reason += f" (detected by ML model, score {top_score:.0%})"
+        else:
+            reason = reasons.get(cat, "Frasa ini perlu ditinjau kembali.")
+            reason += f" (terdeteksi oleh model ML, skor {top_score:.0%})"
+
+        # Laporkan sebagai temuan pada keseluruhan teks (start=0, end=len).
+        return [FillerFinding(
+            word=text,
+            start=0,
+            end=len(text),
+            category=cat,
+            reason=reason,
+            confidence=round(top_score, 3),
+        )]
 
     @property
     def pattern_count(self) -> int:

src/ner/ner_model.py

@@ -209,19 +209,22 @@ _PLACES_GLOBAL_PATTERN = regex_alternation(_PLACES_GLOBAL) or (
 
 # ── Rule-Based Booster ─────────────────────────────────────────────────────────
 #
-# Regex untuk mendeteksi entitas khas Indonesia yang sering terlewat model ML.
-# Format setiap rule: (pola, label_internal, skor_tetap)
+# Regex untuk mendeteksi entitas yang sering terlewat model ML.
+# Format setiap rule: (pola, label_internal, skor_tetap, bahasa)
+#   bahasa: "id"  → hanya untuk teks Indonesia (id/mixed/unknown)
+#           "en"  → hanya untuk teks Inggris (en/mixed/unknown)
+#           "any" → universal/global, selalu aktif di semua bahasa
 # Diurutkan dari paling spesifik ke umum; hanya ditambahkan jika tidak tumpang-
 # tindih dengan hasil ML.
 
-_RULES: list[tuple[re.Pattern[str], str, float]] = [
+_RULES: list[tuple[re.Pattern[str], str, float, str]] = [
 
-    # English/global company suffixes
+    # English/global company suffixes (Inc., LLC, GmbH, S.A. — universal)
     (re.compile(
         r'\b(?:[A-Z][A-Za-z0-9&.,\'-]+(?:\s+[A-Z][A-Za-z0-9&.,\'-]+){0,5})\s+'
         rf'(?:{_ORG_SUFFIX_PATTERN})\b',
         re.UNICODE,
-    ), "ORGANISASI", 0.90),
+    ), "ORGANISASI", 0.90, "any"),
 
     # English institutions and government bodies
     (re.compile(
@@ -229,12 +232,12 @@ _RULES: list[tuple[re.Pattern[str], str, float]] = [
         r'(?:Department|Ministry|Office|Agency|Commission|Bureau)\s+of)\s+'
         r'[A-Z][A-Za-z&.,\'\s-]{2,60}',
         re.UNICODE,
-    ), "ORGANISASI", 0.89),
+    ), "ORGANISASI", 0.89, "any"),
 
-    # Well-known English acronyms
+    # Well-known English/global acronyms (UN, WHO, NASA, dll.)
     (re.compile(
         rf'\b(?:{_ORG_ACRONYM_PATTERN})\b',
-    ), "ORGANISASI", 0.94),
+    ), "ORGANISASI", 0.94, "any"),
 
     # Badan usaha Indonesia (PT, CV, UD, Firma, Koperasi, dll.)
     # Setiap kata dalam nama perusahaan harus diawali huruf kapital agar tidak
@@ -243,14 +246,14 @@ _RULES: list[tuple[re.Pattern[str], str, float]] = [
         r'\b(?:PT\.?\s+|CV\.?\s+|UD\.?\s+|Firma\s+|Koperasi\s+|Perum\s+|Persero\s+)'
         r'(?:[A-Z][A-Za-z0-9&.,\'-]*(?:\s+[A-Z][A-Za-z0-9&.,\'-]*){0,7})',
         re.UNICODE,
-    ), "ORGANISASI", 0.92),
+    ), "ORGANISASI", 0.92, "id"),
 
     # Perusahaan terbuka (Tbk/Persero/Perum sebagai suffix)
     (re.compile(
         r'\b(?:[A-Z][A-Za-z0-9&.,\'-]*(?:\s+[A-Z][A-Za-z0-9&.,\'-]*){0,7})'
         r'\s+(?:Tbk\.?|Persero|Perum)\b',
         re.UNICODE,
-    ), "ORGANISASI", 0.88),
+    ), "ORGANISASI", 0.88, "id"),
 
     # Lembaga pemerintah Indonesia
     (re.compile(
@@ -258,41 +261,41 @@ _RULES: list[tuple[re.Pattern[str], str, float]] = [
         r'Badan|Lembaga|Komisi|Direktorat\s+Jenderal?|Ditjen|Bappenas)\s+'
         r'(?:[A-Z][A-Za-z\s]{2,50})',
         re.UNICODE,
-    ), "ORGANISASI", 0.90),
+    ), "ORGANISASI", 0.90, "id"),
 
     # Akronim lembaga negara RI yang dikenal luas
     (re.compile(
         r'\b(?:KPK|OJK|BI|BPK|BPS|BPOM|BNPB|BPJS|KPU|Bawaslu|MK|MA|'
         r'DPR|DPD|MPR|Polri|TNI|Kejagung|BNN|PPATK|KemenPU|BRIN)\b',
-    ), "ORGANISASI", 0.95),
+    ), "ORGANISASI", 0.95, "id"),
 
     # Institusi pendidikan
     (re.compile(
         r'\b(?:Universitas|Institut|Politeknik|Sekolah\s+Tinggi|'
         r'STMIK|STIE|STIKES|STKIP|Akademi)\s+(?:[A-Z][A-Za-z\s]{2,50})',
         re.UNICODE,
-    ), "ORGANISASI", 0.90),
+    ), "ORGANISASI", 0.90, "id"),
 
     # Nama partai politik Indonesia
     (re.compile(
         r'\b(?:Partai\s+(?:Golkar|Gerindra|PDI-?P|Demokrat|PKS|PKB|PPP|Nasdem|Hanura|'
         r'Berkarya|PKPI|Garuda)|PDIP|Golkar|Gerindra)\b',
         re.IGNORECASE,
-    ), "ORGANISASI", 0.92),
+    ), "ORGANISASI", 0.92, "id"),
 
     # Satuan wilayah administratif
     (re.compile(
         r'\b(?:Provinsi|Kabupaten|Kecamatan|Kelurahan|Desa)\s+'
         r'(?:[A-Z][A-Za-z\s]{2,40})',
         re.UNICODE,
-    ), "LOKASI", 0.88),
+    ), "LOKASI", 0.88, "id"),
 
     # Kota besar Indonesia (dengan prefiks "Kota")
     (re.compile(
         r'\bKota\s+(?:Jakarta|Surabaya|Bandung|Medan|Semarang|Makassar|Palembang|'
         r'Tangerang|Depok|Bekasi|Bogor|Malang|Yogyakarta|Denpasar|Balikpapan)\b',
         re.IGNORECASE,
-    ), "LOKASI", 0.95),
+    ), "LOKASI", 0.95, "id"),
 
     # Undang-undang dan peraturan resmi Indonesia
     (re.compile(
@@ -301,13 +304,13 @@ _RULES: list[tuple[re.Pattern[str], str, float]] = [
         r'Keputusan\s+Presiden|Keppres|Perda)\s+'
         r'(?:No\.?\s*\d+\s*(?:/\s*\d{4})?|Nomor\s+\d+)',
         re.IGNORECASE,
-    ), "PERATURAN", 0.93),
+    ), "PERATURAN", 0.93, "id"),
 
     # Mata uang dan nilai moneter Indonesia
     (re.compile(
         r'\bRp\.?\s*[\d.,]+(?:\s*(?:ribu|juta|miliar|triliun))?\b',
         re.IGNORECASE,
-    ), "UANG", 0.95),
+    ), "UANG", 0.95, "id"),
 
     # Tanggal format formal Indonesia: "15 Maret 2020"
     (re.compile(
@@ -316,37 +319,38 @@ _RULES: list[tuple[re.Pattern[str], str, float]] = [
         r'September|Oktober|November|Desember)\s+'
         r'\d{4}\b',
         re.IGNORECASE,
-    ), "TANGGAL", 0.97),
+    ), "TANGGAL", 0.97, "id"),
 
-    # English date formats: "March 15, 2024"
+    # English date formats: "March 15, 2024" — format global, selalu aktif
     (re.compile(
         r'\b(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|'
         r'Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|'
         r'Nov(?:ember)?|Dec(?:ember)?)\s+\d{1,2},?\s+\d{4}\b',
         re.IGNORECASE,
-    ), "TANGGAL", 0.96),
+    ), "TANGGAL", 0.96, "any"),
 
     # English/global money values
     (re.compile(
         r'\b(?:USD|US\$|\$|EUR|€|GBP|£)\s*[\d,]+(?:\.\d{2})?'
         r'(?:\s*(?:thousand|million|billion|trillion))?\b',
         re.IGNORECASE,
-    ), "UANG", 0.94),
+    ), "UANG", 0.94, "any"),
 
     # Major English place names often used in examples
     (re.compile(
         rf'\b(?:{_PLACES_GLOBAL_PATTERN})\b',
         re.IGNORECASE,
-    ), "LOKASI", 0.90),
+    ), "LOKASI", 0.90, "any"),
 
-    # Gelar + nama orang: "Prof. Budi Raharjo", "Ibu Sari"
+    # Gelar + nama orang: "Prof. Budi Raharjo", "Ibu Sari", "Mr. John Smith"
     # Negative lookahead mencegah false positive pada idiom: "Ibu Kota", "Ibu Pertiwi", "Bapak Bangsa"
+    # Bilingual (gelar Indonesia + Inggris) → "any".
     (re.compile(
         r'\b(?:Bapak|Ibu|Pak|Bu|Dr\.?|Prof\.?|Professor|Mr\.?|Mrs\.?|Ms\.?|Miss|Ir\.?|Drs\.?|Hj\.?|H\.?)\s+'
         r'(?!(?:Kota|Pertiwi|Bangsa|Pembangunan|Rumah|Susuan|Angkat|Tiri)\b)'
         r'(?:[A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,4})',
         re.UNICODE,
-    ), "ORANG", 0.85),
+    ), "ORANG", 0.85, "any"),
 ]
 
 
@@ -443,9 +447,9 @@ class IndonesianNER:
         if not text:
             return []
 
-        ml_entities   = self._predict_ml(text)    if self._pipeline  else []
-        rule_entities = self._predict_rules(text) if self._use_rules else []
-        name_entities = self._predict_names(text) if self._use_rules else []
+        ml_entities   = self._predict_ml(text)              if self._pipeline  else []
+        rule_entities = self._predict_rules(text, language) if self._use_rules else []
+        name_entities = self._predict_names(text)           if self._use_rules else []
 
         combined = _merge_entities(ml_entities, rule_entities + name_entities)
         filtered = [e for e in combined if _is_plausible_entity(e.word)]
@@ -584,10 +588,18 @@ class IndonesianNER:
 
         return entities
 
-    def _predict_rules(self, text: str) -> list[NEREntity]:
-        """Jalankan semua pola regex dan kembalikan entitas yang cocok."""
+    def _predict_rules(self, text: str, language: str = "id") -> list[NEREntity]:
+        """
+        Jalankan pola regex yang sesuai bahasa dan kembalikan entitas yang cocok.
+
+        Rule khusus Indonesia (PT, Kementerian, Rupiah, dll.) dilewati pada teks
+        Inggris; rule universal/global (suffix perusahaan, tanggal, tempat dunia)
+        selalu aktif.
+        """
         entities: list[NEREntity] = []
-        for pattern, label, score in _RULES:
+        for pattern, label, score, lang in _RULES:
+            if lang != "any" and language not in (lang, "mixed", "unknown"):
+                continue   # rule tidak berlaku untuk bahasa ini
             for m in pattern.finditer(text):
                 word = m.group().strip()
                 if len(word) < 2:

src/pii/pii_detector.py

@@ -4,10 +4,16 @@
 # AUTHOR: Ariel Jonathan
 # ============================================================
 """
-PII (Personally Identifiable Information) Detector Bahasa Indonesia.
+PII (Personally Identifiable Information) Detector — Indonesia & Inggris.
 
-Mendeteksi 17 tipe data pribadi dalam teks bebas menggunakan pola regex
-dengan validasi struktural untuk mengurangi false positive:
+Mendeteksi data pribadi dalam teks bebas menggunakan pola regex dengan validasi
+struktural untuk mengurangi false positive. Recognizer dirutekan berdasarkan
+bahasa: identifier khusus Indonesia (NIK, NPWP, SIM, plat nomor, dll.) dilewati
+pada teks Inggris, sedangkan identifier Inggris/global (SSN AS, UK NIN, paspor
+generik) dilewati pada teks Indonesia. Identifier universal (email, IP, kartu
+kredit, rekening, tanggal lahir) selalu aktif.
+
+Tipe data Indonesia:
 
     NIK              Nomor Induk Kependudukan (16 digit)
                      → validasi: kode provinsi (38) + encoding tanggal lahir + gender
@@ -27,9 +33,17 @@ dengan validasi struktural untuk mengurangi false positive:
     KARTU_KREDIT     Kartu kredit/debit (Luhn + pola BIN Visa/MC/Amex/JCB)
     IP_V4            Alamat IPv4 dengan validasi rentang oktet 0–255
     IP_V6            Alamat IPv6 (format penuh & terkompresi)
-    TANGGAL_LAHIR    Tanggal lahir dalam berbagai format Indonesia
+    TANGGAL_LAHIR    Tanggal lahir dalam berbagai format Indonesia/Inggris
     ALAMAT           Pola alamat Indonesia (Jl., Jalan, Gg., Dusun, dsb.)
 
+Tipe data Inggris/global (aktif pada teks Inggris):
+
+    SSN_US                  US Social Security Number (dengan kata kunci "SSN")
+    NIN_UK                  UK National Insurance Number (mis. "AB 12 34 56 C")
+    PASPOR                  Paspor generik (dengan kata kunci "passport")
+    TELEPON_INTERNASIONAL   Nomor telepon internasional (dengan kata kunci)
+    ALAMAT                  Pola alamat Inggris ("123 Main Street", dengan kata kunci)
+
 Referensi format:
     NIK   → Permendagri No. 72/2012 tentang Penomoran NIK
     NPWP  → PMK No. 112/PMK.03/2022 tentang format NPWP 16 digit
@@ -214,6 +228,32 @@ def _validate_plate(text: str) -> bool:
     return m.group(1) in _PLATE_CODES
 
 
+def _validate_email(text: str) -> bool:
+    """
+    Validasi struktur dasar alamat email.
+
+    Regex pola email cukup permisif (mengizinkan titik berurutan & titik di tepi),
+    sehingga validator ini menolak bentuk tidak valid yang lolos pola:
+        user..name@contoh.com   (titik ganda di local part)
+        user.@contoh.com        (titik di akhir local part)
+        user@contoh..com        (titik ganda di domain)
+        user@.contoh.com        (titik di awal domain)
+    """
+    text = text.strip()
+    if text.count("@") != 1:
+        return False
+    local, _, domain = text.partition("@")
+    if not local or not domain:
+        return False
+    if local.startswith(".") or local.endswith(".") or ".." in local:
+        return False
+    if domain.startswith((".", "-")) or domain.endswith((".", "-")) or ".." in domain:
+        return False
+    if "." not in domain:
+        return False
+    return True
+
+
 def _strip_digits(text: str) -> str:
     """Hapus semua karakter non-digit dari teks (untuk input ke validator numerik)."""
     return re.sub(r"\D", "", text)
@@ -224,6 +264,14 @@ def _strip_digits(text: str) -> str:
 # Setiap recognizer menggabungkan: pola regex + validator struktural + skor dasar.
 # Diurutkan dari paling spesifik ke paling umum untuk mencegah false positive.
 
+# Set bahasa default: recognizer berlaku untuk semua bahasa kecuali ditandai lain.
+_ALL_LANGS: frozenset[str] = frozenset({"id", "en", "mixed", "unknown"})
+# Bahasa Indonesia (termasuk teks campuran & tak dikenal — anggap mungkin Indonesia).
+_ID_LANGS:  frozenset[str] = frozenset({"id", "mixed", "unknown"})
+# Bahasa Inggris (termasuk teks campuran).
+_EN_LANGS:  frozenset[str] = frozenset({"en", "mixed"})
+
+
 @dataclass
 class _Recognizer:
     """Definisi satu tipe PII: pola regex + validator opsional."""
@@ -233,17 +281,22 @@ class _Recognizer:
     confidence: float                            # kepercayaan dasar (sebelum validator)
     validator:  Callable[[str], bool | tuple] | None = None
     raw_input:  bool = False                     # True → kirim teks asli ke validator
+    # Bahasa tempat recognizer ini aktif. Default: semua bahasa (identifier universal).
+    languages:  frozenset[str] = field(default_factory=lambda: _ALL_LANGS)
 
 
 _RECOGNIZERS: list[_Recognizer] = [
 
-    # Email
+    # Email — pola permisif diperketat oleh _validate_email (tolak titik ganda/di tepi).
+    # Base 0.82 + bonus validator 0.15 → 0.97 untuk email yang valid.
     _Recognizer(
         label="EMAIL",
         pattern=re.compile(
             r'\b[A-Za-z0-9._%+\-]{1,64}@[A-Za-z0-9.\-]{1,255}\.[A-Za-z]{2,10}\b',
         ),
-        confidence=0.97,
+        confidence=0.82,
+        validator=_validate_email,
+        raw_input=True,
     ),
 
     # IPv6 (harus sebelum IPv4 agar tidak tersaingi pola yang lebih pendek)
@@ -293,6 +346,19 @@ _RECOGNIZERS: list[_Recognizer] = [
             r'(\d{3}[\s\-]?\d{2}[\s\-]?\d{4})'
         ),
         confidence=0.91,
+        languages=_EN_LANGS,
+    ),
+
+    # UK National Insurance Number (NIN): "AB 12 34 56 C", hanya dengan konteks.
+    _Recognizer(
+        label="NIN_UK",
+        pattern=re.compile(
+            r'(?i)(?:NIN[O]?|NI\s+(?:number|no\.?)|'
+            r'National\s+Insurance(?:\s+(?:number|no\.?))?)\s*:?#?\s*'
+            r'([A-CEGHJ-PR-TW-Z]{2}\s?\d{2}\s?\d{2}\s?\d{2}\s?[A-D])'
+        ),
+        confidence=0.88,
+        languages=_EN_LANGS,
     ),
 
     # Nomor telepon internasional, hanya jika ada keyword agar tidak menangkap angka acak.
@@ -303,6 +369,7 @@ _RECOGNIZERS: list[_Recognizer] = [
             r'(\+?[1-9]\d{0,2}[\s\-.(]*\d{2,4}[\s\-.)]*\d{3,4}[\s\-]*\d{3,5})'
         ),
         confidence=0.84,
+        languages=_EN_LANGS,
     ),
 
     # Paspor global/generic, hanya jika ada konteks passport.
@@ -313,6 +380,7 @@ _RECOGNIZERS: list[_Recognizer] = [
             r'([A-Z0-9]{6,12})'
         ),
         confidence=0.84,
+        languages=_EN_LANGS,
     ),
 
     # NPWP format lama: XX.XXX.XXX.X-XXX.XXX
@@ -322,6 +390,7 @@ _RECOGNIZERS: list[_Recognizer] = [
         confidence=0.90,
         validator=lambda t: _validate_npwp_lama(_strip_digits(t)),
         raw_input=True,
+        languages=_ID_LANGS,
     ),
 
     # NIK / NPWP baru (16 digit tanpa pemisah)
@@ -332,6 +401,7 @@ _RECOGNIZERS: list[_Recognizer] = [
         confidence=0.75,
         validator=lambda t: _validate_nik(t)[0],
         raw_input=False,
+        languages=_ID_LANGS,
     ),
 
     # BPJS Kesehatan (13 digit, dengan konteks kata kunci)
@@ -343,6 +413,7 @@ _RECOGNIZERS: list[_Recognizer] = [
             r'|\b(\d{13})\b(?=\s*(?:BPJS|bpjs))',
         ),
         confidence=0.85,
+        languages=_ID_LANGS,
     ),
 
     # BPJS Ketenagakerjaan (11 digit, dengan konteks kata kunci)
@@ -354,6 +425,7 @@ _RECOGNIZERS: list[_Recognizer] = [
             r'(\d{11})'
         ),
         confidence=0.88,
+        languages=_ID_LANGS,
     ),
 
     # SIM (12 digit, dengan konteks kata kunci)
@@ -363,6 +435,7 @@ _RECOGNIZERS: list[_Recognizer] = [
             r'(?i)(?:SIM\s+(?:No\.?\s*)?|No\.?\s*SIM\s*:?\s*)(\d{12})'
         ),
         confidence=0.87,
+        languages=_ID_LANGS,
     ),
 
     # Paspor Indonesia (1 huruf kapital + 7 digit)
@@ -373,6 +446,7 @@ _RECOGNIZERS: list[_Recognizer] = [
             r'\b([A-Z]\d{7})\b'
         ),
         confidence=0.82,
+        languages=_ID_LANGS,
     ),
 
     # Plat nomor TNKB (mis. "B 1234 ABC")
@@ -382,6 +456,7 @@ _RECOGNIZERS: list[_Recognizer] = [
         confidence=0.75,
         validator=lambda t: _validate_plate(t),
         raw_input=True,
+        languages=_ID_LANGS,
     ),
 
     # Nomor HP Indonesia
@@ -396,6 +471,7 @@ _RECOGNIZERS: list[_Recognizer] = [
         confidence=0.80,
         validator=lambda t: _validate_mobile(_strip_digits(t)),
         raw_input=True,
+        languages=_ID_LANGS,
     ),
 
     # Telepon tetap / fixed-line
@@ -408,6 +484,7 @@ _RECOGNIZERS: list[_Recognizer] = [
             r'(?!\d)'
         ),
         confidence=0.78,
+        languages=_ID_LANGS,
     ),
 
     # Nomor rekening bank (dengan konteks kata kunci)
@@ -461,6 +538,7 @@ _RECOGNIZERS: list[_Recognizer] = [
             r')',
         ),
         confidence=0.72,
+        languages=_ID_LANGS,
     ),
 
     # Alamat fisik Inggris/global sederhana.
@@ -473,6 +551,7 @@ _RECOGNIZERS: list[_Recognizer] = [
             r'Lane|Ln\.?|Drive|Dr\.?|Court|Ct\.?|Way|Place|Pl\.?))'
         ),
         confidence=0.78,
+        languages=_EN_LANGS,
     ),
 ]
 
@@ -508,6 +587,12 @@ class PIIDetector:
         """
         Scan teks dan kembalikan semua PII yang terdeteksi.
 
+        Args:
+            text:     Teks yang akan diperiksa.
+            language: "id", "en", "mixed", atau "unknown". Menentukan recognizer
+                      mana yang dijalankan — identifier khusus Indonesia (NIK, NPWP,
+                      SIM, dll.) dilewati pada teks Inggris, dan sebaliknya.
+
         Returns:
             Daftar PIIEntity diurutkan berdasarkan posisi (start ascending).
             Entitas yang tumpang-tindih diselesaikan: kepercayaan lebih tinggi menang.
@@ -518,6 +603,8 @@ class PIIDetector:
         raw: list[PIIEntity] = []
 
         for rec in _RECOGNIZERS:
+            if language not in rec.languages:
+                continue   # recognizer tidak berlaku untuk bahasa ini
             for m in rec.pattern.finditer(text):
 
                 # Ambil nilai dari capturing group(1) jika ada

src/profanity/profanity_checker.py

@@ -110,7 +110,7 @@ _BUILTIN_MEDIUM: set[str] = {
 # Kata umum Indonesia yang TIDAK boleh ditandai meski mungkin ada di lexicon
 # (daftar ini dibuat dari false positive yang terdeteksi saat pengujian)
 _WHITELIST_FALLBACK: frozenset[str] = frozenset({
-    "tolong", "kampung", "buaya", "berak", "bugil",
+    "tolong", "kampung", "buaya", "berak",
     "bisu",   "buta",    "alay",  "ampas", "celeng",
     # False positive dari lexicon eksternal — kata umum Bahasa Indonesia
     "jangan", "tepat",   "tidak", "kurang", "rusak",
@@ -219,25 +219,43 @@ def _is_known_common_word(word: str, language: str = "id") -> bool:
     return any(word_frequency(word, lang) >= _WORDFREQ_MIN for lang in langs)
 
 
-def _build_skeleton_index(words: set[str]) -> dict[str, str]:
+def _build_skeleton_index(words: set[str]) -> dict[str, list[str]]:
     """
-    Buat index skeleton konsonan → kata profanity untuk deteksi bentuk singkatan.
+    Buat index skeleton konsonan → daftar kata profanity untuk deteksi singkatan.
 
     Hanya kata dengan ≥ 4 huruf yang diindeks (mengurangi false positive pada
     singkatan umum non-profanity yang kebetulan memiliki skeleton sama).
 
+    Beberapa kata berbeda bisa berbagi skeleton yang sama (mis. "bangsat" dan
+    "bangset" → "bngst"). Karena itu nilainya berupa LIST, bukan satu kata —
+    mencegah entri saling menimpa yang dapat menyebabkan false negative.
+
     Returns:
-        dict {skeleton: kata_asli}
+        dict {skeleton: [kata_asli, ...]}
     """
-    idx: dict[str, str] = {}
+    idx: dict[str, list[str]] = {}
     for w in words:
         if len(w) >= 4:
             skel = _consonant_skeleton(w)
             if skel and len(skel) >= 3:
-                idx[skel] = w
+                idx.setdefault(skel, []).append(w)
     return idx
 
 
+def _match_skeleton(candidates: list[str] | None, norm_len: int) -> str | None:
+    """
+    Pilih kata profanity yang cocok untuk sebuah skeleton.
+
+    Mengembalikan kata terpanjang yang memenuhi syarat panjang (bentuk yang
+    dicek tidak lebih panjang dari kata asli di lexicon — menghindari false
+    positive pada kata panjang), atau None jika tidak ada yang memenuhi.
+    """
+    if not candidates:
+        return None
+    best = max(candidates, key=len)
+    return best if norm_len <= len(best) else None
+
+
 # ── Kelas Utama ────────────────────────────────────────────────────────────────
 
 class ProfanityChecker:
@@ -256,10 +274,10 @@ class ProfanityChecker:
     """
 
     def __init__(self) -> None:
-        self._high:        set[str]       = set()
-        self._medium:      set[str]       = set()
-        self._skel_high:   dict[str, str] = {}   # skeleton → kata HIGH
-        self._skel_medium: dict[str, str] = {}   # skeleton → kata MEDIUM
+        self._high:        set[str]             = set()
+        self._medium:      set[str]             = set()
+        self._skel_high:   dict[str, list[str]] = {}   # skeleton → daftar kata HIGH
+        self._skel_medium: dict[str, list[str]] = {}   # skeleton → daftar kata MEDIUM
         self._loaded = False
 
     # ── Public API ──
@@ -337,33 +355,32 @@ class ProfanityChecker:
                     continue
                 skel = _consonant_skeleton(norm)
                 if skel and len(skel) >= 3:
-                    if skel in self._skel_high and len(norm) <= len(self._skel_high[skel]):
+                    hi = _match_skeleton(self._skel_high.get(skel), len(norm))
+                    if hi is not None:
                         severity   = "HIGH"
-                        matched_as = self._skel_high[skel]
-                    elif skel in self._skel_medium and len(norm) <= len(self._skel_medium[skel]):
-                        severity   = "MEDIUM"
-                        matched_as = self._skel_medium[skel]
+                        matched_as = hi
+                    else:
+                        me = _match_skeleton(self._skel_medium.get(skel), len(norm))
+                        if me is not None:
+                            severity   = "MEDIUM"
+                            matched_as = me
 
             # Tahap 3: koreksi ejaan via SymSpell → cek apakah hasil koreksi adalah profanity.
             # Menangkap typo-profanity seperti "ptolol" → "tolol", "tollol" → "tolol".
             # Hanya dijalankan jika Tahap 1 & 2 tidak menemukan hasil.
+            # Memakai API publik WordQualityDetector.correct_spelling (tanpa akses field privat).
             if severity is None:
                 try:
                     from word_quality.word_quality_detector import get_detector
-                    from symspellpy import Verbosity as _V
                     wq = get_detector(load=False)
-                    if wq.is_loaded and wq._sym_spell is not None:  # noqa: SLF001
-                        norm2 = _normalize(raw)
-                        suggs = wq._sym_spell.lookup(  # noqa: SLF001
-                            norm2, _V.CLOSEST, max_edit_distance=2
-                        )
-                        if suggs:
-                            corrected = suggs[0].term
-                            if corrected != norm2:
-                                if corrected in self._high:
-                                    severity = "HIGH";   matched_as = corrected
-                                elif corrected in self._medium:
-                                    severity = "MEDIUM"; matched_as = corrected
+                    if wq.is_loaded:
+                        norm2     = _normalize(raw)
+                        corrected = wq.correct_spelling(norm2, language=language)
+                        if corrected:
+                            if corrected in self._high:
+                                severity = "HIGH";   matched_as = corrected
+                            elif corrected in self._medium:
+                                severity = "MEDIUM"; matched_as = corrected
                 except Exception:
                     pass  # SymSpell tidak tersedia atau gagal → lewati tahap ini
 

src/responsible/responsible_checker.py

@@ -41,6 +41,7 @@ from __future__ import annotations
 
 import logging
 import re
+import threading
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Literal
@@ -301,8 +302,8 @@ def _normalize_slang(text: str) -> str:
         det = get_detector(load=False)
         if not det.is_loaded or det.slang_dict_size == 0:
             return text
-        words = text.split()
-        return " ".join(det._slang_dict.get(w.lower(), w) for w in words)  # noqa: SLF001
+        # Pakai API publik (tanpa akses field privat _slang_dict)
+        return det.normalize_slang(text)
     except Exception:
         return text
 
@@ -340,6 +341,9 @@ class ResponsibleChecker:
         self._ml_model        = ml_model
         self._normalize_slang = normalize_slang
         self._ml_pipe         = None
+        # Model torch tidak thread-safe; lock ini menyerialkan inferensi saat
+        # banyak field dievaluasi paralel (ThreadPoolExecutor di pipeline).
+        self._ml_lock         = threading.Lock()
         self._loaded          = False
 
     # ── Public API ──
@@ -475,6 +479,16 @@ class ResponsibleChecker:
         """True jika model ML berhasil dimuat dan Layer 2 aktif."""
         return self._ml_pipe is not None
 
+    @property
+    def ml_pipe(self):
+        """Pipeline zero-shot (agar FillerChecker bisa meminjam tanpa akses privat)."""
+        return self._ml_pipe
+
+    @property
+    def ml_lock(self) -> threading.Lock:
+        """Lock inferensi ML — dibagikan ke peminjam pipeline agar serialisasi konsisten."""
+        return self._ml_lock
+
     # ── Internal ──
 
     def _check_ml(
@@ -482,12 +496,13 @@ class ResponsibleChecker:
     ) -> list[ResponsibleFinding]:
         """Jalankan zero-shot classification dan kembalikan temuan baru."""
         try:
-            result = self._ml_pipe(
-                text,
-                candidate_labels=_ML_LABELS,
-                hypothesis_template="Teks ini mengandung {}.",
-                multi_label=False,
-            )
+            with self._ml_lock:
+                result = self._ml_pipe(
+                    text,
+                    candidate_labels=_ML_LABELS,
+                    hypothesis_template="Teks ini mengandung {}.",
+                    multi_label=False,
+                )
         except Exception as exc:
             logger.warning("Zero-shot ML gagal: %s", exc)
             return []

src/syntax/syntax_checker.py

@@ -0,0 +1,425 @@
+# ============================================================
+# FILE  : syntax_checker.py
+# FUNGSI: Detektor urutan kata janggal Bahasa Indonesia
+# AUTHOR: Ariel Jonathan
+# ============================================================
+"""
+Syntax Checker — Detektor urutan kata tidak wajar dalam Bahasa Indonesia.
+
+Mendeteksi kalimat yang susunan katanya janggal sehingga sulit dipahami AI:
+
+    "makan suka aku"            → seharusnya "aku suka makan"
+    "laporan saya buat sudah"   → seharusnya "saya sudah buat laporan"
+
+Pendekatan: Pseudo-Log-Likelihood (PLL) + perbandingan permutasi, via IndoBERT.
+
+    Bahasa Indonesia bersifat fleksibel — urutan non-S-V-O sering tetap sah
+    (kalimat pasif "di-", topik-prominan, penekanan). Oleh karena itu deteksi
+    tidak memakai aturan tata bahasa kaku, melainkan mengukur seberapa "wajar"
+    sebuah kalimat secara statistik menurut model bahasa.
+
+    Untuk tiap kalimat dihitung rata-rata log-probabilitas per token (Salazar
+    et al. 2020, "Masked Language Model Scoring"): tiap token di-mask bergantian,
+    lalu model memprediksi token aslinya.
+
+    Skor PLL absolut bergantung pada panjang & kosakata kalimat, sehingga ambang
+    tetap rawan false positive. Solusinya: kalimat dibandingkan dengan beberapa
+    PERMUTASI ACAK kata-katanya sendiri. Kalimat gramatikal jauh mengungguli
+    acakannya (hampir tidak ada acakan yang lebih baik); kalimat janggal tidak.
+    Jika mayoritas permutasi acak justru lebih wajar daripada urutan aslinya,
+    kalimat ditandai UNUSUAL_WORD_ORDER. Metode ini self-normalizing — bebas dari
+    bias panjang/kosakata karena membandingkan kalimat dengan kata-katanya sendiri.
+
+Karena ambiguitas tata bahasa Indonesia cukup tinggi, temuan bersifat SARAN
+(severity rendah), bukan kesalahan pasti.
+
+Model: indolem/indobert-base-uncased (~420 MB, masked language model)
+
+Referensi:
+    Salazar et al. (2020). Masked Language Model Scoring. ACL 2020.
+    Koto et al. (2020). IndoLEM and IndoBERT. COLING 2020.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import logging
+import random
+import re
+import threading
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+
+# ── Dependensi Opsional ────────────────────────────────────────────────────────
+#
+# Cek ketersediaan transformers + torch TANPA mengimpornya (find_spec ~0 ms).
+# Impor sebenarnya (~4 dtk) ditunda ke load() — hanya saat ML benar-benar dipakai.
+
+_TRANSFORMERS_OK = (
+    importlib.util.find_spec("transformers") is not None
+    and importlib.util.find_spec("torch") is not None
+)
+if not _TRANSFORMERS_OK:
+    logger.info("transformers/torch tidak terinstal — Syntax Checker dinonaktifkan. "
+                "Jalankan: pip install transformers torch")
+
+
+# ── Konstanta & Konfigurasi ────────────────────────────────────────────────────
+
+_MODEL_ID = "indolem/indobert-base-uncased"
+
+# Panjang kalimat (dalam kata) yang diperiksa. Terlalu pendek → tidak cukup
+# konteks; terlalu panjang → mahal & ruang permutasi terlalu besar.
+_MIN_WORDS = 4
+_MAX_WORDS = 18
+
+# Token wordpiece maksimum per kalimat (batas keamanan komputasi)
+_MAX_TOKENS = 48
+
+# Jumlah kalimat maksimum yang diperiksa per pemanggilan (batas latency)
+_MAX_SENTENCES = 6
+
+# Jumlah permutasi acak per kalimat untuk pembanding self-normalizing.
+_SHUFFLE_COUNT = 6
+
+# Ambang rasio: tandai jika fraksi permutasi acak yang LEBIH WAJAR dari urutan
+# asli mencapai nilai ini. 0.66 = mayoritas (≥2/3) acakan mengalahkan urutan asli
+# → indikasi kuat urutan kata bermasalah. Makin tinggi → makin konservatif.
+_RATIO_THRESHOLD = 0.66
+
+# Seed tetap agar hasil deterministik antar-pemanggilan.
+_RNG_SEED = 1234
+
+
+# ── Tipe Data ──────────────────────────────────────────────────────────────────
+
+@dataclass(frozen=True)
+class SyntaxFinding:
+    """Satu kalimat dengan urutan kata yang terindikasi janggal."""
+
+    sentence:   str    # kalimat yang ditandai (dipotong jika > 80 karakter di pipeline)
+    start:      int    # offset karakter awal dalam teks asli
+    end:        int    # offset karakter akhir (eksklusif)
+    score:      float  # rata-rata log-probabilitas per token (makin rendah makin janggal)
+    reason:     str    # penjelasan untuk pengguna
+    confidence: float  # skor kepercayaan 0.0–1.0
+
+
+# ── Tokenisasi Kalimat ──────────────────────────────────────────────────────────
+
+# Pisah teks menjadi kalimat berdasarkan tanda akhir (. ! ?) atau baris baru,
+# sambil mempertahankan offset karakter di teks asli.
+_SENTENCE_SPLIT = re.compile(r'[^.!?\n]+(?:[.!?]+|\n|$)')
+
+
+def _split_sentences(text: str) -> list[tuple[str, int, int]]:
+    """
+    Pecah teks menjadi (kalimat, start, end) dengan offset di teks asli.
+
+    Hanya kalimat dengan jumlah kata dalam rentang [_MIN_WORDS, _MAX_WORDS]
+    yang dikembalikan.
+    """
+    results: list[tuple[str, int, int]] = []
+    for m in _SENTENCE_SPLIT.finditer(text):
+        raw = m.group()
+        stripped = raw.strip()
+        if not stripped:
+            continue
+        word_count = len(stripped.split())
+        if word_count < _MIN_WORDS or word_count > _MAX_WORDS:
+            continue
+        # Sesuaikan offset agar menunjuk teks tanpa spasi pinggir
+        lead = len(raw) - len(raw.lstrip())
+        start = m.start() + lead
+        end = start + len(stripped)
+        results.append((stripped, start, end))
+    return results
+
+
+def _make_shuffles(words: list[str], count: int, rng: random.Random) -> list[list[str]]:
+    """
+    Hasilkan hingga `count` permutasi acak unik dari `words`, semuanya berbeda
+    dari urutan asli. Mengembalikan list kosong jika kata terlalu sedikit.
+    """
+    if len(words) < 3:
+        return []
+    original = tuple(words)
+    seen: set[tuple[str, ...]] = {original}
+    shuffles: list[list[str]] = []
+    # Batasi percobaan agar tidak loop selamanya pada kalimat dengan kata berulang.
+    for _ in range(count * 6):
+        if len(shuffles) >= count:
+            break
+        candidate = words[:]
+        rng.shuffle(candidate)
+        key = tuple(candidate)
+        if key in seen:
+            continue
+        seen.add(key)
+        shuffles.append(candidate)
+    return shuffles
+
+
+# ── Kelas Utama ────────────────────────────────────────────────────────────────
+
+class SyntaxChecker:
+    """
+    Detektor urutan kata janggal Bahasa Indonesia berbasis perplexity IndoBERT.
+
+    Contoh penggunaan::
+
+        chk = SyntaxChecker()
+        chk.load()
+        for f in chk.check("makan suka aku nasi goreng"):
+            print(f.sentence, f.score, f.confidence)
+    """
+
+    def __init__(self, use_ml: bool = True, model_id: str = _MODEL_ID) -> None:
+        """
+        Args:
+            use_ml:   Aktifkan deteksi (butuh transformers + torch). Jika False
+                      atau dependensi tidak ada, check() selalu mengembalikan [].
+            model_id: ID model HuggingFace masked-LM untuk skoring.
+        """
+        self._use_ml    = use_ml and _TRANSFORMERS_OK
+        self._model_id  = model_id
+        self._tokenizer = None
+        self._model     = None
+        self._torch     = None
+        # Model torch tidak thread-safe; lock menyerialkan inferensi saat beberapa
+        # field (task/context/references) dievaluasi paralel di pipeline.
+        self._ml_lock   = threading.Lock()
+        self._loaded    = False
+
+    # ── Public API ──
+
+    def load(self) -> bool:
+        """
+        Muat tokenizer + model masked-LM.
+
+        Returns:
+            True jika model berhasil dimuat (deteksi aktif), False jika tidak.
+        """
+        if self._loaded:
+            return self._model is not None
+
+        self._loaded = True
+        if not self._use_ml:
+            return False
+
+        try:
+            import torch
+            from transformers import AutoModelForMaskedLM, AutoTokenizer
+
+            logger.info("Memuat model Syntax Checker '%s'...", self._model_id)
+            self._torch     = torch
+            self._tokenizer = AutoTokenizer.from_pretrained(self._model_id)
+            self._model     = AutoModelForMaskedLM.from_pretrained(self._model_id)
+            self._model.eval()
+            logger.info("Syntax Checker siap (model IndoBERT aktif).")
+            return True
+        except Exception as exc:
+            logger.warning("Gagal memuat Syntax Checker: %s — deteksi dinonaktifkan.", exc)
+            self._model = None
+            return False
+
+    def check(self, text: str, language: str = "id") -> list[SyntaxFinding]:
+        """
+        Periksa teks dan kembalikan kalimat dengan urutan kata janggal.
+
+        Args:
+            text:     Teks yang akan diperiksa.
+            language: Hanya teks Indonesia ("id"/"mixed"/"unknown") yang diperiksa.
+                      Teks Inggris ("en") dilewati — model dilatih untuk Indonesia.
+
+        Returns:
+            Daftar SyntaxFinding diurutkan berdasarkan posisi (start ascending).
+        """
+        if not text or not text.strip():
+            return []
+        if language == "en":
+            return []
+        if not self._loaded:
+            self.load()
+        if self._model is None:
+            return []
+
+        sentences = _split_sentences(text)[:_MAX_SENTENCES]
+        if not sentences:
+            return []
+
+        rng = random.Random(_RNG_SEED)
+        findings: list[SyntaxFinding] = []
+
+        for sentence, start, end in sentences:
+            words = sentence.split()
+            if len(words) < _MIN_WORDS:
+                continue
+
+            # Bangun permutasi acak yang berbeda dari urutan asli.
+            shuffles = _make_shuffles(words, _SHUFFLE_COUNT, rng)
+            if not shuffles:
+                continue
+
+            # Skor urutan asli + semua permutasi dalam satu forward pass.
+            variants = [sentence] + [" ".join(p) for p in shuffles]
+            scores   = self._pll_many(variants)
+            orig_score = scores[0]
+            shuffle_scores = [s for s in scores[1:] if s is not None]
+            if orig_score is None or not shuffle_scores:
+                continue
+
+            # Fraksi permutasi acak yang lebih wajar daripada urutan asli.
+            better = sum(1 for s in shuffle_scores if s > orig_score)
+            ratio  = better / len(shuffle_scores)
+            if ratio < _RATIO_THRESHOLD:
+                continue
+
+            # Kepercayaan proporsional terhadap rasio (0.66→~0.55, 1.0→~0.85).
+            confidence = max(0.50, min(0.85, 0.30 + ratio * 0.55))
+            findings.append(SyntaxFinding(
+                sentence=sentence,
+                start=start,
+                end=end,
+                score=round(orig_score, 3),
+                reason="Susunan kata kalimat ini terasa tidak wajar dan mungkin sulit "
+                       "dipahami AI. Periksa kembali urutan kata — pastikan mengikuti "
+                       "pola yang lazim (mis. subjek–predikat–objek).",
+                confidence=round(confidence, 3),
+            ))
+
+        return findings
+
+    # ── Properties ──
+
+    @property
+    def is_loaded(self) -> bool:
+        """True jika checker sudah mencoba memuat model."""
+        return self._loaded
+
+    @property
+    def ml_active(self) -> bool:
+        """True jika model berhasil dimuat dan deteksi aktif."""
+        return self._model is not None
+
+    # ── Internal ──
+
+    def _pll_many(self, variants: list[str]) -> list[float | None]:
+        """
+        Hitung rata-rata pseudo-log-likelihood per token untuk beberapa kalimat
+        sekaligus dalam SATU forward pass.
+
+        Untuk setiap varian, tiap token (kecuali token spesial) di-mask bergantian;
+        model memprediksi token aslinya. Semua baris ter-mask dari semua varian
+        digabung ke satu batch agar efisien, lalu hasilnya dipisah kembali.
+
+        Returns:
+            Daftar skor rata-rata log-prob (sejajar dengan `variants`); elemen
+            None untuk varian yang terlalu pendek / tak punya token termaskable.
+        """
+        torch = self._torch
+        tok   = self._tokenizer
+        model = self._model
+
+        mask_id = tok.mask_token_id
+        pad_id  = tok.pad_token_id if tok.pad_token_id is not None else 0
+        if mask_id is None:
+            return [None] * len(variants)
+
+        special_ids = set(tok.all_special_ids)
+
+        # Kumpulkan semua baris ter-mask dari semua varian.
+        # Tiap entri: (variant_idx, masked_ids, true_token_id, pos)
+        masked_rows: list[tuple[int, list[int], int, int]] = []
+        for vi, text in enumerate(variants):
+            ids = tok(text, truncation=True, max_length=_MAX_TOKENS)["input_ids"]
+            positions = [i for i, t in enumerate(ids) if t not in special_ids]
+            for pos in positions:
+                masked = list(ids)
+                true_tok = masked[pos]
+                masked[pos] = mask_id
+                masked_rows.append((vi, masked, true_tok, pos))
+
+        if not masked_rows:
+            return [None] * len(variants)
+
+        max_len = max(len(m[1]) for m in masked_rows)
+        n_rows  = len(masked_rows)
+
+        input_ids = torch.full((n_rows, max_len), pad_id, dtype=torch.long)
+        attn      = torch.zeros((n_rows, max_len), dtype=torch.long)
+        for r, (_vi, masked, _tok, _pos) in enumerate(masked_rows):
+            L = len(masked)
+            input_ids[r, :L] = torch.tensor(masked, dtype=torch.long)
+            attn[r, :L] = 1
+
+        with self._ml_lock, torch.no_grad():
+            logits = model(input_ids=input_ids, attention_mask=attn).logits
+
+        sums:   list[float] = [0.0] * len(variants)
+        counts: list[int]   = [0] * len(variants)
+        for r, (vi, _masked, true_tok, pos) in enumerate(masked_rows):
+            log_probs = torch.log_softmax(logits[r, pos], dim=-1)
+            sums[vi]   += log_probs[true_tok].item()
+            counts[vi] += 1
+
+        return [
+            (sums[i] / counts[i]) if counts[i] else None
+            for i in range(len(variants))
+        ]
+
+
+# ── Singleton ──────────────────────────────────────────────────────────────────
+
+_default_checker: SyntaxChecker | None = None
+
+
+def get_checker(use_ml: bool = True, load: bool = True) -> SyntaxChecker:
+    """
+    Kembalikan instance SyntaxChecker singleton (lazy-initialized).
+
+    Args:
+        use_ml: Aktifkan deteksi berbasis ML.
+        load:   Jika True, panggil load() otomatis sebelum dikembalikan.
+    """
+    global _default_checker
+    if _default_checker is None:
+        _default_checker = SyntaxChecker(use_ml=use_ml)
+    if load and not _default_checker.is_loaded:
+        _default_checker.load()
+    return _default_checker
+
+
+# ── Demo CLI ───────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    import sys
+
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s  %(message)s")
+
+    SAMPLES = [
+        "Aku suka makan nasi goreng.",            # normal
+        "Makan suka aku nasi goreng.",            # janggal
+        "Saya sudah menyelesaikan laporan ini.",  # normal
+        "Laporan ini saya sudah selesaikan.",     # agak janggal
+        "Tolong buatkan ringkasan artikel ini.",  # normal
+        "Ringkasan ini artikel buatkan tolong.",  # janggal
+    ]
+
+    texts = sys.argv[1:] or SAMPLES
+    chk   = SyntaxChecker()
+
+    if not chk.load():
+        print("[WARN] Model tidak tersedia — deteksi nonaktif.")
+        sys.exit(0)
+
+    print(f"Permutasi/kalimat: {_SHUFFLE_COUNT} | ambang rasio: {_RATIO_THRESHOLD:.0%}\n{'-' * 60}")
+    for text in texts:
+        findings = chk.check(text)
+        print(f"\n> {text}")
+        if not findings:
+            print("  (urutan kata wajar)")
+        for f in findings:
+            print(f"  [JANGGAL] skor={f.score:.2f} conf={f.confidence:.0%}  {f.sentence!r}")

src/syntax/syntax_server.py

@@ -0,0 +1,142 @@
+# ============================================================
+# FILE  : syntax_server.py
+# FUNGSI: Server HTTP standalone untuk Syntax Checker (port 8008)
+# AUTHOR: Ariel Jonathan
+# ============================================================
+"""
+Server HTTP untuk Syntax Checker — http://127.0.0.1:8008
+
+Endpoint:
+    GET  /api/status  — health-check
+    POST /api/syntax  — {"text": "...", "language": "id"}
+                        → {"findings": [...], "finding_count": int}
+
+Jalankan:
+    python -m src.syntax.syntax_server
+    python src/syntax/syntax_server.py --no-ml   # nonaktifkan model (deteksi mati)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import sys
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from syntax.syntax_checker import SyntaxChecker
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s  %(levelname)-7s  %(message)s",
+    datefmt="%H:%M:%S",
+)
+logger = logging.getLogger(__name__)
+
+_checker: SyntaxChecker | None = None
+_use_ml = True
+
+
+def _get() -> SyntaxChecker:
+    global _checker
+    if _checker is None:
+        _checker = SyntaxChecker(use_ml=_use_ml)
+        _checker.load()
+    return _checker
+
+
+class Handler(BaseHTTPRequestHandler):
+
+    def _cors(self):
+        self.send_header("Access-Control-Allow-Origin",  "*")
+        self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type")
+
+    def do_OPTIONS(self):
+        self.send_response(204); self._cors(); self.end_headers()
+
+    def _json(self, status: int, body: object):
+        payload = json.dumps(body, ensure_ascii=False).encode()
+        try:
+            self.send_response(status)
+            self.send_header("Content-Type",   "application/json; charset=utf-8")
+            self.send_header("Content-Length", str(len(payload)))
+            self._cors()
+            self.end_headers()
+            self.wfile.write(payload)
+        except (ConnectionAbortedError, BrokenPipeError, ConnectionResetError):
+            pass
+
+    def _body(self) -> dict | None:
+        n = int(self.headers.get("Content-Length", 0))
+        if not n:
+            return {}
+        try:
+            return json.loads(self.rfile.read(n))
+        except (json.JSONDecodeError, ValueError):
+            return None
+
+    def log_message(self, fmt, *args):
+        logger.info("%-6s %s", args[0] if args else "", args[1] if len(args) > 1 else "")
+
+    def do_GET(self):
+        if self.path == "/api/status":
+            chk = _get()
+            self._json(200, {
+                "ready":     True,
+                "ml_active": chk.ml_active,
+            })
+        else:
+            self._json(404, {"error": "Not found"})
+
+    def do_POST(self):
+        if self.path != "/api/syntax":
+            self._json(404, {"error": "Not found"}); return
+
+        body = self._body()
+        if body is None:
+            self._json(400, {"error": "JSON tidak valid."}); return
+
+        text = str(body.get("text", "")).strip()
+        if not text:
+            self._json(400, {"error": "Field 'text' kosong."}); return
+
+        language = str(body.get("language", "id"))
+        findings = _get().check(text, language=language)
+        self._json(200, {
+            "text":          text,
+            "finding_count": len(findings),
+            "findings": [
+                {
+                    "sentence":   f.sentence,
+                    "start":      f.start,
+                    "end":        f.end,
+                    "score":      f.score,
+                    "reason":     f.reason,
+                    "confidence": f.confidence,
+                }
+                for f in findings
+            ],
+        })
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=8008)
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--no-ml", action="store_true",
+                        help="Nonaktifkan model (deteksi mati, server tetap jalan).")
+    args = parser.parse_args()
+
+    _use_ml = not args.no_ml
+    logger.info("Memuat Syntax Checker (ML: %s)...", "aktif" if _use_ml else "nonaktif")
+    chk = _get()
+    logger.info("Syntax Checker siap (ML aktif: %s).", chk.ml_active)
+    server = HTTPServer((args.host, args.port), Handler)
+    logger.info("Syntax server berjalan di http://%s:%d", args.host, args.port)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        server.server_close()

src/word_quality/word_quality_detector.py

@@ -143,7 +143,9 @@ _BUILTIN_SLANG: dict[str, str] = {
     # Kata kerja & partikel umum
     "udah": "sudah", "udh": "sudah", "sdh": "sudah",
     "blm": "belum", "blom": "belum",
-    "lagi": "sedang", "lg": "sedang",
+    # "lagi" sengaja TIDAK dipetakan: ambigu (sedang vs. kembali/tambah).
+    # Hanya singkatan tak ambigu "lg" yang dipetakan.
+    "lg": "sedang",
     "kalo": "kalau", "klo": "kalau", "klu": "kalau",
     "sampe": "sampai", "ampe": "sampai",
     "gimana": "bagaimana", "gmn": "bagaimana",
@@ -184,7 +186,7 @@ _BUILTIN_SLANG: dict[str, str] = {
     "mau":   "mau",     # valid
     "dong":  "dong",    # valid
     "eh":    "eh",      # ekspresi, valid
-    "buat":  "untuk",   # kontekstual, tapi sering salah → diarahkan ke "untuk"
+    # "buat" sengaja TIDAK dipetakan: ambigu (untuk vs. membuat) — sering salah koreksi.
 }
 
 # Hapus entri yang tidak punya padanan formal (None) dan self-mapping
@@ -293,11 +295,26 @@ _NOISY_CASING = re.compile(r'\b[a-zA-Z]{3,}\b')
 
 
 def _is_noisy_casing(word: str) -> bool:
-    """Kembalikan True jika kata memiliki casing campur yang tidak wajar."""
+    """Kembalikan True jika kata memiliki casing campur yang tidak wajar (ALAY).
+
+    Perbedaan ALAY vs CamelCase/akronim teknis:
+    - ALAY:      bergantian acak — setidaknya 2 transisi huruf-kecil → huruf-besar
+                 Contoh: hArUs (2 transisi), sUnGgUh (3), sEkArAnG (4)
+    - CamelCase: paling banyak 1 transisi kecil→besar (1 kata baru internal)
+                 Contoh: JavaScript (1 transisi: a→S), WiFi (1: i→F), iPhone (1: i→P)
+    """
     if word == word.lower() or word == word.upper() or word == word.title():
         return False
-    # Ada huruf besar di tengah kata (setelah posisi 0) DAN ada huruf kecil
-    return any(c.isupper() for c in word[1:]) and any(c.islower() for c in word)
+    # Kumpulkan hanya huruf (abaikan angka & simbol)
+    letters = [c for c in word if c.isalpha()]
+    if len(letters) < 2:
+        return False
+    # Hitung transisi huruf-kecil → huruf-besar di posisi 1 ke atas
+    transitions = sum(
+        1 for i in range(1, len(letters))
+        if letters[i].isupper() and letters[i - 1].islower()
+    )
+    return transitions >= 2
 
 
 # ── Loader Data ────────────────────────────────────────────────────────────────
@@ -604,15 +621,65 @@ class WordQualityDetector:
         """True jika SymSpell berhasil dimuat (deteksi typo aktif)."""
         return self._sym_spell is not None or self._sym_spell_en is not None
 
+    # ── API Publik untuk Modul Lain ──
+    #
+    # Disediakan agar detektor lain (mis. ProfanityChecker, ResponsibleChecker)
+    # dapat memanfaatkan kamus slang & SymSpell TANPA mengakses field privat.
+
+    def correct_spelling(
+        self, word: str, max_edit_distance: int = _MAX_EDIT_DIST, language: str = "id"
+    ) -> str | None:
+        """
+        Kembalikan koreksi ejaan terbaik untuk `word` via SymSpell.
+
+        Args:
+            word:              Kata (idealnya sudah lowercase/ternormalisasi).
+            max_edit_distance: Jarak edit maksimum kandidat koreksi.
+            language:          "en" memakai kamus Inggris, selain itu Indonesia.
+
+        Returns:
+            Kata hasil koreksi, atau None jika SymSpell tidak tersedia, tidak ada
+            saran, atau kata sudah benar.
+        """
+        sym = self._sym_spell_en if language == "en" else self._sym_spell
+        if sym is None or not _SYMSPELL_OK:
+            return None
+        try:
+            suggestions = sym.lookup(
+                word, Verbosity.CLOSEST,
+                max_edit_distance=max_edit_distance,
+                include_unknown=False,
+            )
+        except Exception:
+            return None
+        if not suggestions:
+            return None
+        best = suggestions[0].term
+        return best if best != word else None
+
+    def normalize_slang(self, text: str) -> str:
+        """
+        Ganti tiap kata slang dalam `text` dengan padanan bakunya.
+
+        Berguna untuk pengecekan internal modul lain (mis. normalisasi sebelum
+        regex). Token yang tidak ada di kamus dibiarkan apa adanya.
+        """
+        if not self._slang_dict:
+            return text
+        return " ".join(self._slang_dict.get(w.lower(), w) for w in text.split())
+
     # ── Sub-Detektor Internal ──
 
     def _check_slang(self, word: str, start: int, end: int, language: str = "id") -> WordIssue | None:
         """
         Cek apakah kata ada di kamus slang dan memiliki padanan baku.
 
-        Urutan pencarian:
-          1. Kamus-alay (kamus utama, ~2400+ entri)
-          2. Tesaurus Bahasa Indonesia (fallback jika tidak ada di kamus)
+        Hanya kata yang TERDAFTAR EKSPLISIT di kamus slang/alay yang ditandai.
+        Fallback ke tesaurus sengaja TIDAK dipakai di sini: tesaurus akan
+        mengembalikan sinonim untuk kata baku apa pun (mis. "menyatakan" →
+        "mengungkapkan"), sehingga memicu false positive pada kata yang sudah
+        benar. Tesaurus tetap dipakai sebagai fallback koreksi typo di
+        _check_typo, di mana kata memang sudah dipastikan tidak dikenal.
         """
         if not self._use_slang:
             return None
@@ -644,21 +711,6 @@ class WordQualityDetector:
                 reason=f"Kata informal; padanan baku: \"{formal}\".",
             )
 
-        # Fallback: cari di tesaurus hanya untuk token Bahasa Indonesia.
-        if language == "en" or _language_for_token(key, language) == "en":
-            return None
-        thes_synonyms = _get_thesaurus().lookup(key, n=1)
-        if thes_synonyms:
-            suggestion = thes_synonyms[0]
-            if suggestion.lower() != key:
-                return WordIssue(
-                    word=word, start=start, end=end,
-                    issue_type="SLANG",
-                    suggestion=suggestion,
-                    confidence=0.75,
-                    reason=f"Kata informal/tidak baku; sinonim formal: \"{suggestion}\".",
-                )
-
         return None
 
     def _check_alay(self, word: str, start: int, end: int, language: str = "id") -> WordIssue | None:
@@ -668,8 +720,10 @@ class WordQualityDetector:
         w = word.lower()
 
         # Pola 1: singkatan numerik reduplikasi — "kata2" → "kata-kata"
+        # Hanya berlaku untuk Bahasa Indonesia (dan mixed/unknown); Inggris tidak mengenal
+        # pola reduplikasi dengan angka sehingga "type2", "level2", dst. tidak perlu di-flag.
         m = _NUMERIC_REDUPLICATION.fullmatch(w)
-        if m:
+        if m and language != "en":
             base       = m.group(1)
             suggestion = f"{base}-{base}"
             return WordIssue(
@@ -698,20 +752,42 @@ class WordQualityDetector:
         # Pola 3: substitusi angka-huruf (l33tspeak) — "k4mu" → "kamu"
         # Hanya untuk kata pendek (≤ 15 karakter) agar token acak panjang tidak lolos
         # sebelum sampai ke _check_typo.
-        if re.search(r'[0-9]', w) and re.search(r'[a-zA-Z]', w) and len(w) <= 15:
+        #
+        # Pengecekan kewajaran hasil de-leet bersifat LINTAS-BAHASA: bila hasilnya
+        # kata nyata di bahasa mana pun (Indonesia ATAU Inggris), token itu hampir
+        # pasti leetspeak yang disengaja. Sebelumnya kewajaran hanya dicek pada
+        # bahasa field; akibatnya leetspeak Indonesia (mis. "m3l4kuk4n") lolos saat
+        # field terdeteksi berbahasa Inggris.
+        #
+        # Guard false-positive: kata teknis sering berakhir dengan angka (MP3, IPv4,
+        # level5, Win32, SHA256). Kata leetspeak sejati hampir selalu berakhir huruf
+        # karena kata dasar yang mendasarinya berakhir huruf. Oleh karena itu:
+        #   • minimal 4 karakter (filter "3D", "C4", "MP3", dll. ≤ 3 karakter)
+        #   • karakter terakhir bukan digit (filter "level5", "IPv4", "type2", dll.)
+        if (4 <= len(w) <= 15
+                and not w[-1].isdigit()
+                and re.search(r'[0-9]', w)
+                and re.search(r'[a-zA-Z]', w)):
             candidate = w.translate(_NUM_TO_LETTER)
-            lang = _language_for_token(candidate, language)
-            if _WORDFREQ_OK and word_frequency(candidate, lang) > _WORDFREQ_MIN:
-                return WordIssue(
-                    word=word, start=start, end=end,
-                    issue_type="ALAY",
-                    suggestion=candidate,
-                    confidence=0.85,
-                    reason=f"Substitusi angka-huruf (l33tspeak); kemungkinan maksud: \"{candidate}\".",
+            if candidate != w and _WORDFREQ_OK:
+                best_freq = max(
+                    word_frequency(candidate, "id"),
+                    word_frequency(candidate, "en"),
                 )
+                if best_freq > _WORDFREQ_MIN:
+                    return WordIssue(
+                        word=word, start=start, end=end,
+                        issue_type="ALAY",
+                        suggestion=candidate,
+                        confidence=0.85,
+                        reason=f"Substitusi angka-huruf (l33tspeak); kemungkinan maksud: \"{candidate}\".",
+                    )
 
         # Pola 4: noisy casing campur — "hArUs" → "harus"
-        if _is_noisy_casing(word):
+        # Guard: kata yang mengandung digit sering berupa akronim teknis (IPv4, GPT4,
+        # Win32) yang punya huruf besar di prefix (IP, GP, W) → bukan ALAY.
+        # Kata alay dengan digit (mis. "m3l4kuk4n") sudah tertangkap lebih awal di Pola 3.
+        if _is_noisy_casing(word) and not any(c.isdigit() for c in word):
             suggestion = word.lower()
             return WordIssue(
                 word=word, start=start, end=end,

web/index.html

@@ -177,6 +177,10 @@
       background: #c7dcff;
     }
 
+    .syntax {
+      background: #e0e7ff;
+    }
+
     .quality {
       background: #ffd6a5;
     }
@@ -673,73 +677,79 @@
       <!-- ─────────────────────────────────────────
            Panel Kiri — Form Input
       ───────────────────────────────────────── -->
-      <section class="min-h-0 overflow-y-auto [scrollbar-gutter:stable] p-5
+      <section class="min-h-0 flex flex-col
                       bg-white border border-line rounded-lg box-border">
 
-        <label class="block mt-0 mb-[6px] text-sm font-bold" for="task">Task</label>
-        <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
-                 font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
-                 focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
-                 mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="task" rows="1"
-          placeholder="Apa yang ingin Anda minta kepada AI? Tuliskan permintaan secara spesifik."></textarea>
-
-        <label class="block mt-4 mb-[6px] text-sm font-bold" for="context">Context</label>
-        <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
-                 font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
-                 focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
-                 mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="context" rows="1"
-          placeholder="Latar belakang situasi yang perlu diketahui AI, misalnya: tujuan, kondisi, atau batasan yang relevan."></textarea>
-
-        <label class="block mt-4 mb-[6px] text-sm font-bold" for="references">References</label>
-        <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
-                 font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
-                 focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
-                 mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="references" rows="1"
-          placeholder="Sumber, dokumen, atau data yang menjadi acuan jawaban AI."></textarea>
-
-        <label class="block mt-4 mb-[6px] text-sm font-bold" for="role">Role</label>
-        <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
-                 font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
-                 focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
-                 mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="role" rows="1"
-          placeholder="Peran atau keahlian yang diinginkan dari AI. Contoh: Analis Data, Penulis Konten, Konsultan Hukum."></textarea>
-
-        <label class="block mt-4 mb-[6px] text-sm font-bold" for="audience">Audience</label>
-        <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
-                 font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
-                 focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
-                 mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="audience" rows="1"
-          placeholder="Siapa target pembaca jawaban ini? Contoh: mahasiswa S1, tim pemasaran, pelanggan baru."></textarea>
-
-        <label class="block mt-4 mb-[6px] text-sm font-bold" for="tone">Tone</label>
-        <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
-                 font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
-                 focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
-                 mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="tone" rows="1"
-          placeholder="Contoh: formal dan profesional, santai tapi sopan, ringkas dan to-the-point."></textarea>
-
-        <label class="block mt-4 mb-[6px] text-sm font-bold" for="constraints">Constraints</label>
-        <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
-                 font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
-                 focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
-                 mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="constraints" rows="1"
-          placeholder="Hal yang tidak boleh dilakukan AI. Contoh: jangan gunakan jargon teknis, maksimal 200 kata."></textarea>
-
-        <label class="block mt-4 mb-[6px] text-sm font-bold" for="outputFormat">Output Format</label>
-        <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
-                 font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
-                 focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
-                 mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="outputFormat" rows="1"
-          placeholder="Contoh: daftar poin, tabel perbandingan, paragraf naratif, format JSON."></textarea>
-
-        <label class="block mt-4 mb-[6px] text-sm font-bold" for="example">Example</label>
-        <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
-                 font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
-                 focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
-                 mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="example" rows="1"
-          placeholder="Tunjukkan contoh output yang Anda harapkan agar AI dapat mengikuti formatnya."></textarea>
-
-        <div class="flex justify-end gap-2 mt-4 pt-3 border-t border-line">
+        <!-- Area scroll form — tombol tidak ikut scroll -->
+        <div class="flex-1 min-h-0 overflow-y-auto [scrollbar-gutter:stable] px-4 py-3">
+
+          <label class="block mt-0 mb-[6px] text-sm font-bold" for="task">Task</label>
+          <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
+                   font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
+                   focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
+                   mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="task" rows="1"
+            placeholder="Apa yang ingin Anda minta kepada AI? Tuliskan permintaan secara spesifik."></textarea>
+
+          <label class="block mt-4 mb-[6px] text-sm font-bold" for="context">Context</label>
+          <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
+                   font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
+                   focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
+                   mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="context" rows="1"
+            placeholder="Latar belakang situasi yang perlu diketahui AI, misalnya: tujuan, kondisi, atau batasan yang relevan."></textarea>
+
+          <label class="block mt-4 mb-[6px] text-sm font-bold" for="references">References</label>
+          <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
+                   font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
+                   focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
+                   mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="references" rows="1"
+            placeholder="Sumber, dokumen, atau data yang menjadi acuan jawaban AI."></textarea>
+
+          <label class="block mt-4 mb-[6px] text-sm font-bold" for="role">Role</label>
+          <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
+                   font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
+                   focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
+                   mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="role" rows="1"
+            placeholder="Peran atau keahlian yang diinginkan dari AI. Contoh: Analis Data, Penulis Konten, Konsultan Hukum."></textarea>
+
+          <label class="block mt-4 mb-[6px] text-sm font-bold" for="audience">Audience</label>
+          <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
+                   font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
+                   focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
+                   mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="audience" rows="1"
+            placeholder="Siapa target pembaca jawaban ini? Contoh: mahasiswa S1, tim pemasaran, pelanggan baru."></textarea>
+
+          <label class="block mt-4 mb-[6px] text-sm font-bold" for="tone">Tone</label>
+          <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
+                   font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
+                   focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
+                   mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="tone" rows="1"
+            placeholder="Contoh: formal dan profesional, santai tapi sopan, ringkas dan to-the-point."></textarea>
+
+          <label class="block mt-4 mb-[6px] text-sm font-bold" for="constraints">Constraints</label>
+          <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
+                   font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
+                   focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
+                   mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="constraints" rows="1"
+            placeholder="Hal yang tidak boleh dilakukan AI. Contoh: jangan gunakan istilah teknis, maksimal 200 kata."></textarea>
+
+          <label class="block mt-4 mb-[6px] text-sm font-bold" for="outputFormat">Output Format</label>
+          <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
+                   font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
+                   focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
+                   mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="outputFormat" rows="1"
+            placeholder="Contoh: daftar poin, tabel perbandingan, paragraf naratif, format JSON."></textarea>
+
+          <label class="block mt-4 mb-[6px] text-sm font-bold" for="example">Example</label>
+          <textarea class="w-full max-w-full box-border px-[10px] py-[10px] border border-input rounded-[6px]
+                   font-[inherit] text-base min-h-[42px] overflow-hidden resize-none leading-[1.45]
+                   focus:outline-none focus:border-teal focus:ring-[3px] focus:ring-teal/[.14]
+                   mobile:min-h-[78px] mobile:px-[14px] mobile:py-[12px]" id="example" rows="1"
+            placeholder="Tunjukkan contoh output yang Anda harapkan agar AI dapat mengikuti formatnya."></textarea>
+
+        </div><!-- /scroll area -->
+
+        <!-- Tombol aksi — selalu terlihat di bawah panel -->
+        <div class="flex-none flex justify-end gap-2 px-5 py-3 border-t border-line bg-white rounded-b-lg">
           <button id="evaluateBtn" class="px-4 py-[9px] text-sm font-bold text-white bg-teal border border-teal
                    rounded-[6px] cursor-pointer hover:bg-teal-dark transition-colors duration-150
                    disabled:opacity-40 disabled:cursor-not-allowed disabled:hover:bg-teal" type="button"
@@ -850,6 +860,7 @@
       { key: "slang", label: "Kata Tidak Baku" },
       { key: "weak", label: "Penulisan Slang" },
       { key: "typo", label: "Kemungkinan Salah Ketik" },
+      { key: "syntax", label: "Urutan Kata" },
       { key: "quality", label: "Topik Sensitif" },
       { key: "filler", label: "Frasa Tidak Efektif" },
       { key: "special_char", label: "Karakter Khusus" },
@@ -866,6 +877,7 @@
       ner: "#bfe8c8",
       slang: "#d7c7ff",
       typo: "#c7dcff",
+      syntax: "#e0e7ff",
       quality: "#ffd6a5",
       responsible: "#f9c5d5",
       profanity: "#fecaca",
@@ -882,6 +894,7 @@
       slang: "Kata ini adalah kata gaul atau singkatan informal. AI mungkin salah memahami maksud Anda, sehingga jawabannya kurang tepat. Menggunakan kata yang lebih baku membuat permintaan Anda lebih mudah dimengerti.",
       weak: "Penulisan seperti ini (huruf berulang, angka menggantikan huruf, atau singkatan tidak lazim) bisa membuat AI salah membaca kata. Gunakan ejaan normal agar hasilnya lebih akurat.",
       typo: "Sepertinya ada kesalahan ketik di sini. Memperbaikinya membantu AI memahami maksud Anda dengan benar.",
+      syntax: "Susunan kata pada kalimat ini terasa kurang lazim sehingga maksudnya bisa ambigu bagi AI. Coba periksa kembali urutan katanya — umumnya mengikuti pola subjek–predikat–objek (misalnya 'saya membuat laporan', bukan 'laporan membuat saya'). Ini hanya saran; jika kalimat memang sudah sesuai maksud Anda, abaikan saja.",
       quality: "Pertanyaan ini menyentuh topik yang sensitif dan bisa menghasilkan jawaban yang tidak berimbang atau bias. Coba ubah ke sudut pandang yang lebih netral, misalnya meminta perbandingan objektif, bukan penilaian mana yang 'terbaik'.",
       missing: "Kolom ini belum diisi. Semakin lengkap informasi yang Anda berikan, semakin tepat dan berguna jawaban yang dihasilkan AI.",
       filler: "Frasa ini tidak menambah informasi dan hanya membuang token. AI tidak memerlukan sapaan, ucapan terima kasih, permintaan maaf, atau basa-basi. Langsung tuliskan permintaan secara spesifik. Referensi samar seperti 'gini nih' atau 'kayak gitu' juga perlu diganti dengan penjelasan eksplisit, karena AI tidak dapat menebak apa yang Anda bayangkan. Prompt yang lebih ringkas dan konkret menghasilkan jawaban yang lebih tepat sasaran.",