vibes-plug 2.11.0 → 3.9.0

package/skills/ai-safety-governance-expert/SKILL.md

@@ -0,0 +1,223 @@
+---
+name: ai-safety-governance-expert
+description: "Expert guide for AI Safety, Governance, and Responsible AI in production — Constitutional AI enforcement, runtime guardrails (NeMo Guardrails 2.0, Llama Guard 3), bias auditing, hallucination detection, EU AI Act compliance, model cards, and content provenance / Panduan ahli untuk Keamanan AI, Tata Kelola, dan AI Bertanggung Jawab di produksi."
+author: "vibes-plug-swarm"
+version: "3.0.0"
+---
+
+# AI Safety, Governance, and Responsible AI Expert
+
+## 1. Constitutional AI Enforcement / Penegakan AI Konstitusional
+
+Define constitutional rules as structured guardrails for all AI operations. Implement policies at multiple interception points: pre-generation, post-generation, and retrieval.
+
+### Principles & Configuration
+- Embed constitution directly into system prompts.
+- Implement explicit Colang 2.0 flows for conversational state management.
+- Abort sequences when user prompts violate strict constitutional principles.
+
+```yaml
+# NeMo Guardrails configuration example (config.yml)
+models:
+  - type: main
+    engine: openai
+    model: gpt-4o
+
+rails:
+  input:
+    flows:
+      - check_jailbreak
+      - check_topic_restriction
+  output:
+    flows:
+      - check_hallucination
+      - check_toxicity
+
+instructions:
+  - type: general
+    content: |
+      You are a helpful, respectful, and honest assistant.
+      Always prioritize safety, avoid giving harmful advice, and maintain neutrality.
+```
+
+## 2. Runtime Safety Guardrails / Pembatasan Keamanan Saat Berjalan
+
+Implement layered defense mechanisms to intercept unsafe input and redact sensitive output. Utilize state-of-the-art moderation models such as Llama Guard 3.
+
+### Layered Defense Architecture
+1. **System Prompt**: Set boundaries and behavior guidelines.
+2. **Input Filter**: Scan for prompt injection, jailbreaks, and restricted topics (PII, hate speech).
+3. **Model Generation**: Generate response using the core LLM.
+4. **Output Filter**: Redact PII, filter toxicity, and enforce factuality checking.
+5. **Delivery**: Send safe response to the user.
+
+```typescript
+// Multi-layer guardrail pipeline in TypeScript
+import { LlamaGuard } from '@safety/llama-guard';
+import { PIIRedactor } from '@safety/redactor';
+import { LLMService } from './llm';
+
+export async function generateSafeResponse(prompt: string): Promise<string> {
+  // Layer 2: Input Guardrail
+  const inputCheck = await LlamaGuard.checkPrompt(prompt);
+  if (!inputCheck.isSafe) {
+    throw new Error(`Unsafe prompt detected: ${inputCheck.violationCategory}`);
+  }
+
+  // Layer 3: Model Generation
+  const rawResponse = await LLMService.generate(prompt);
+
+  // Layer 4: Output Guardrails
+  const outputCheck = await LlamaGuard.checkResponse(prompt, rawResponse);
+  if (!outputCheck.isSafe) {
+    throw new Error('Unsafe response blocked by output guardrails.');
+  }
+
+  const redactedResponse = PIIRedactor.redact(rawResponse);
+  
+  // Layer 5: Delivery
+  return redactedResponse;
+}
+```
+
+## 3. Hallucination Detection & Grounding / Deteksi Halusinasi & Grounding
+
+Employ grounding techniques and retrieval-augmented verification to minimize hallucinations. Implement real-time factuality metrics on generated text.
+
+### Citation Verification Pipeline
+- **Claim Extraction**: Extract factual claims from the response.
+- **Source Matching**: Retrieve grounding documents for each claim.
+- **Confidence Scoring**: Calculate factuality using NLI (Natural Language Inference) models.
+
+```python
+# Hallucination detection with SelfCheckGPT principles
+from selfcheckgpt.modeling_selfcheck import SelfCheckNLI
+import spacy
+
+nlp = spacy.load("en_core_web_sm")
+selfcheck_nli = SelfCheckNLI(device="cpu") # use cuda if available
+
+def detect_hallucination(response_text, context_documents):
+    sentences = [sent.text for sent in nlp(response_text).sents]
+    
+    # Calculate NLI scores against provided context
+    nli_scores = selfcheck_nli.predict(
+        sentences=sentences,
+        sampled_passages=[context_documents] * len(sentences)
+    )
+    
+    threshold = 0.85
+    hallucinated_sentences = [
+        sentences[i] for i, score in enumerate(nli_scores) if score < threshold
+    ]
+    
+    return {
+        "is_grounded": len(hallucinated_sentences) == 0,
+        "hallucinations": hallucinated_sentences
+    }
+```
+
+## 4. Automated Bias Auditing / Audit Bias Otomatis
+
+Continuously monitor AI systems for demographic parity, equal opportunity, and equalized odds.
+
+### Audit Pipeline
+1. **Test Suite**: Run standardized prompts targeting various demographics.
+2. **Metric Collection**: Evaluate embeddings and outputs for representational and allocative harms.
+3. **Report**: Aggregate fairness metrics into actionable dashboards.
+4. **Remediation**: Apply fairness constraints during fine-tuning.
+
+```python
+# Bias audit script using fairlearn
+from fairlearn.metrics import demographic_parity_difference
+from sklearn.metrics import accuracy_score
+import pandas as pd
+
+def audit_model_fairness(predictions, true_labels, sensitive_features):
+    df = pd.DataFrame({
+        'y_true': true_labels,
+        'y_pred': predictions,
+        'sensitive_feature': sensitive_features
+    })
+    
+    dp_diff = demographic_parity_difference(
+        y_true=df['y_true'], 
+        y_pred=df['y_pred'], 
+        sensitive_features=df['sensitive_feature']
+    )
+    
+    overall_accuracy = accuracy_score(df['y_true'], df['y_pred'])
+    
+    print(f"Demographic Parity Difference: {dp_diff:.4f}")
+    print(f"Overall Accuracy: {overall_accuracy:.4f}")
+    
+    if dp_diff > 0.1:
+        print("WARNING: Significant demographic parity violation detected.")
+```
+
+## 5. AI Model Cards & Documentation / Kartu Model & Dokumentasi AI
+
+Maintain standardized Model Cards for transparency and accountability, automatically generated from evaluation results.
+
+### Required Model Card Sections
+- **Intended Use**: Primary use cases and out-of-scope applications.
+- **Limitations**: Known failure modes and biases.
+- **Training Data**: Overview of pre-training and fine-tuning datasets, including opt-out mechanisms.
+- **Performance Metrics**: Standardized benchmark scores (MMLU, HumanEval) and fairness metrics.
+- **Ethical Considerations**: Mitigation strategies for potential harms.
+
+## 6. AI Compliance Matrix / Matriks Kepatuhan AI
+
+Map AI deployments against global regulatory frameworks. Implement automated risk classification checks.
+
+### Frameworks & Controls
+- **EU AI Act**: Classify systems as Unacceptable (prohibited), High Risk (strict requirements), Limited (transparency required), or Minimal.
+- **NIST AI RMF**: Implement Govern, Map, Measure, and Manage functions.
+- **GDPR Article 22**: Ensure human-in-the-loop (HITL) for automated decision-making.
+- **SOC2**: Implement AI-specific data isolation and auditing controls.
+
+```python
+# Risk classification decision tree
+def classify_eu_ai_act_risk(system_purpose, employs_biometrics, affects_safety):
+    if system_purpose in ["social_scoring", "subliminal_manipulation"]:
+        return "UNACCEPTABLE_RISK"
+    
+    if employs_biometrics or affects_safety or system_purpose in ["employment", "education", "credit_scoring"]:
+        return "HIGH_RISK"
+        
+    if system_purpose in ["chatbot", "deepfake", "emotion_recognition"]:
+        return "LIMITED_RISK"
+        
+    return "MINIMAL_RISK"
+```
+
+## 7. Content Provenance & Watermarking / Asal Konten & Watermarking
+
+Ensure transparency in AI-generated outputs by embedding provenance data.
+
+### Implementation Strategies
+- **C2PA Credentials**: Attach cryptographic content credentials to AI-generated images and audio.
+- **Invisible Text Watermarking**: Alter token probabilities during generation (e.g., SynthID text) to embed a detectable signature.
+- **Clear Disclosures**: Always present visible labels indicating content is AI-generated, especially for synthetic media and bots.
+
+## 8. Orchestration & Integration / Orkestrasi & Integrasi
+
+This skill connects to the broader ecosystem to enforce safety across all capabilities.
+
+### Connected Skills
+- `ai-llm-integration-expert`
+- `ai-prompt-engineering-expert`
+- `autonomous-red-teamer`
+- `compliance-gdpr-privacy-expert`
+- `session-memory-manager`
+- `production-ready-hardener`
+- `brainstorming`
+- `zero-to-prod-orchestrator`
+
+## English
+## Bahasa Indonesia
+
+
+## Orchestration & Integration
+- Connects to `zero-to-prod-orchestrator`
+- Connects to `brainstorming`

package/skills/angular-expert/SKILL.md

@@ -1,148 +1,149 @@
----
-name: angular-expert
-description: "Expert guide for Angular 19+ enterprise applications — Signals, Standalone Components, NgRx SignalStore, SSR with Hydration, and Angular Material 3 / Panduan ahli aplikasi enterprise Angular 19+."
-author: "Roedy Rustam"
----
-
-# Angular Expert (2026 Edition)
-
-[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
-
----
-
-<a name="english"></a>
-## English
-
-### Orchestration & Integration
-- **`typescript-expert`**: Strict TypeScript typing and decorators in Angular 19+.
-- **`api-design-expert`**: REST and GraphQL client architecture with Angular `HttpClient`.
-- **`e2e-testing-expert`**: Playwright and Cypress end-to-end testing for Angular apps.
-- **`global-a11y-i18n-expert`**: Angular localized translations (`@angular/localize`) and accessibility compliance.
-- **`ci-cd-devops-architect`**: Dockerizing and deploying Angular SSR applications.
-
-### Description
-Production-ready guide for building scalable, enterprise-grade web applications using Angular 19+. Covers modern Standalone Components (NgModule-free), fine-grained Signals (`signal()`, `computed()`, `effect()`), Signal-based inputs/outputs, NgRx SignalStore, deferrable views (`@defer`), SSR with Event Replay hydration, and Angular Material 3.
-
-### Trigger Conditions
-- Building or refactoring enterprise-scale Angular applications.
-- Migrating legacy Angular (NgModules / RxJS heavy) to Angular 19+ Standalone Components & Signals.
-- Implementing state management with NgRx SignalStore.
-- Configuring Angular SSR with hydration and deferrable views (`@defer`).
-
----
-
-### Core Architecture & Modern Patterns
-
-#### 1. Standalone Component with Signals & Signal Inputs
-```typescript
-import { Component, signal, computed, input, output, ChangeDetectionStrategy } from '@angular/core';
-import { CommonModule } from '@angular/common';
-
-export interface UserItem {
-  id: string;
-  name: string;
-  role: 'admin' | 'member';
-}
-
-@Component({
-  selector: 'app-user-card',
-  standalone: true,
-  imports: [CommonModule],
-  template: `
-    <div class="user-card" [class.admin]="isAdmin()">
-      <h3>{{ user().name }}</h3>
-      <p>Role: {{ user().role }}</p>
-      <button (click)="onRoleChange()">Promote</button>
-    </div>
-  `,
-  changeDetection: ChangeDetectionStrategy.OnPush,
-})
-export class UserCardComponent {
-  // Signal inputs & outputs (Angular 19+)
-  user = input.required<UserItem>();
-  roleUpdated = output<string>();
-
-  isAdmin = computed(() => this.user().role === 'admin');
-
-  onRoleChange() {
-    this.roleUpdated.emit(this.user().id);
-  }
-}
-```
-
-#### 2. NgRx SignalStore
-```typescript
-import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
-import { computed, inject } from '@angular/core';
-import { HttpClient } from '@angular/common/http';
-import { rxMethod } from '@ngrx/signals/rxjs-interop';
-import { pipe, switchMap, tap } from 'rxjs';
-
-interface ProductsState {
-  products: Array<{ id: string; title: string; price: number }>;
-  isLoading: boolean;
-  filter: string;
-}
-
-const initialState: ProductsState = {
-  products: [],
-  isLoading: false,
-  filter: '',
-};
-
-export const ProductsStore = signalStore(
-  { providedIn: 'root' },
-  withState(initialState),
-  withComputed(({ products, filter }) => ({
-    filteredProducts: computed(() =>
-      products().filter((p) => p.title.toLowerCase().includes(filter().toLowerCase()))
-    ),
-    totalCount: computed(() => products().length),
-  })),
-  withMethods((store, http = inject(HttpClient)) => ({
-    updateFilter(filter: string) {
-      patchState(store, { filter });
-    },
-    loadProducts: rxMethod<void>(
-      pipe(
-        tap(() => patchState(store, { isLoading: true })),
-        switchMap(() =>
-          http.get<Array<{ id: string; title: string; price: number }>>('/api/products').pipe(
-            tap((products) => patchState(store, { products, isLoading: false }))
-          )
-        )
-      )
-    ),
-  }))
-);
-```
-
-#### 3. Deferrable Views (`@defer`)
-```html
-@defer (on viewport; prefetch on idle) {
-  <app-analytics-dashboard [data]="dashboardData()" />
-} @placeholder {
-  <div class="skeleton-loader">Loading analytics widget...</div>
-} @error {
-  <p>Failed to load analytics dashboard.</p>
-}
-```
-
----
-
-<a name="bahasa-indonesia"></a>
-## Bahasa Indonesia
-
-### Integrasi Orkestrasi
-- **`typescript-expert`**: Penggunaan TypeScript ketat dan dekorator pada Angular 19+.
-- **`api-design-expert`**: Arsitektur klien REST dan GraphQL dengan `HttpClient`.
-- **`e2e-testing-expert`**: Pengujian end-to-end menggunakan Playwright atau Cypress.
-
-### Deskripsi
-Panduan produksi untuk membangun aplikasi web skala enterprise menggunakan Angular 19+. Mencakup Standalone Components tanpa NgModule, reaktivitas modern berbasis Signals, NgRx SignalStore, deferrable views (`@defer`), SSR dengan hidrasi Event Replay, dan integrasi Angular Material 3.
-
-### Kondisi Pemicu
-- Membangun atau merestrukturisasi aplikasi enterprise Angular.
-- Migrasi Angular lama (berbasis NgModule/RxJS berat) ke Angular 19+ Standalone & Signals.
-- Mengelola state aplikasi menggunakan NgRx SignalStore.
-- Mengoptimalkan performa rendering dengan deferrable views dan SSR hydration.
+---
+name: angular-expert
+description: "Expert guide for Angular 19+ enterprise applications — Signals, Standalone Components, NgRx SignalStore, SSR with Hydration, and Angular Material 3 / Panduan ahli aplikasi enterprise Angular 19+."
+author: "Roedy Rustam"
+version: "3.0.0"
+---
+
+# Angular Expert (2026 Edition)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+- **`typescript-expert`**: Strict TypeScript typing and decorators in Angular 19+.
+- **`api-design-expert`**: REST and GraphQL client architecture with Angular `HttpClient`.
+- **`e2e-testing-expert`**: Playwright and Cypress end-to-end testing for Angular apps.
+- **`global-a11y-i18n-expert`**: Angular localized translations (`@angular/localize`) and accessibility compliance.
+- **`ci-cd-devops-architect`**: Dockerizing and deploying Angular SSR applications.
+
+### Description
+Production-ready guide for building scalable, enterprise-grade web applications using Angular 19+. Covers modern Standalone Components (NgModule-free), fine-grained Signals (`signal()`, `computed()`, `effect()`), Signal-based inputs/outputs, NgRx SignalStore, deferrable views (`@defer`), SSR with Event Replay hydration, and Angular Material 3.
+
+### Trigger Conditions
+- Building or refactoring enterprise-scale Angular applications.
+- Migrating legacy Angular (NgModules / RxJS heavy) to Angular 19+ Standalone Components & Signals.
+- Implementing state management with NgRx SignalStore.
+- Configuring Angular SSR with hydration and deferrable views (`@defer`).
+
+---
+
+### Core Architecture & Modern Patterns
+
+#### 1. Standalone Component with Signals & Signal Inputs
+```typescript
+import { Component, signal, computed, input, output, ChangeDetectionStrategy } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+export interface UserItem {
+  id: string;
+  name: string;
+  role: 'admin' | 'member';
+}
+
+@Component({
+  selector: 'app-user-card',
+  standalone: true,
+  imports: [CommonModule],
+  template: `
+    <div class="user-card" [class.admin]="isAdmin()">
+      <h3>{{ user().name }}</h3>
+      <p>Role: {{ user().role }}</p>
+      <button (click)="onRoleChange()">Promote</button>
+    </div>
+  `,
+  changeDetection: ChangeDetectionStrategy.OnPush,
+})
+export class UserCardComponent {
+  // Signal inputs & outputs (Angular 19+)
+  user = input.required<UserItem>();
+  roleUpdated = output<string>();
+
+  isAdmin = computed(() => this.user().role === 'admin');
+
+  onRoleChange() {
+    this.roleUpdated.emit(this.user().id);
+  }
+}
+```
+
+#### 2. NgRx SignalStore
+```typescript
+import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
+import { computed, inject } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { rxMethod } from '@ngrx/signals/rxjs-interop';
+import { pipe, switchMap, tap } from 'rxjs';
+
+interface ProductsState {
+  products: Array<{ id: string; title: string; price: number }>;
+  isLoading: boolean;
+  filter: string;
+}
+
+const initialState: ProductsState = {
+  products: [],
+  isLoading: false,
+  filter: '',
+};
+
+export const ProductsStore = signalStore(
+  { providedIn: 'root' },
+  withState(initialState),
+  withComputed(({ products, filter }) => ({
+    filteredProducts: computed(() =>
+      products().filter((p) => p.title.toLowerCase().includes(filter().toLowerCase()))
+    ),
+    totalCount: computed(() => products().length),
+  })),
+  withMethods((store, http = inject(HttpClient)) => ({
+    updateFilter(filter: string) {
+      patchState(store, { filter });
+    },
+    loadProducts: rxMethod<void>(
+      pipe(
+        tap(() => patchState(store, { isLoading: true })),
+        switchMap(() =>
+          http.get<Array<{ id: string; title: string; price: number }>>('/api/products').pipe(
+            tap((products) => patchState(store, { products, isLoading: false }))
+          )
+        )
+      )
+    ),
+  }))
+);
+```
+
+#### 3. Deferrable Views (`@defer`)
+```html
+@defer (on viewport; prefetch on idle) {
+  <app-analytics-dashboard [data]="dashboardData()" />
+} @placeholder {
+  <div class="skeleton-loader">Loading analytics widget...</div>
+} @error {
+  <p>Failed to load analytics dashboard.</p>
+}
+```
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Integrasi Orkestrasi
+- **`typescript-expert`**: Penggunaan TypeScript ketat dan dekorator pada Angular 19+.
+- **`api-design-expert`**: Arsitektur klien REST dan GraphQL dengan `HttpClient`.
+- **`e2e-testing-expert`**: Pengujian end-to-end menggunakan Playwright atau Cypress.
+
+### Deskripsi
+Panduan produksi untuk membangun aplikasi web skala enterprise menggunakan Angular 19+. Mencakup Standalone Components tanpa NgModule, reaktivitas modern berbasis Signals, NgRx SignalStore, deferrable views (`@defer`), SSR dengan hidrasi Event Replay, dan integrasi Angular Material 3.
+
+### Kondisi Pemicu
+- Membangun atau merestrukturisasi aplikasi enterprise Angular.
+- Migrasi Angular lama (berbasis NgModule/RxJS berat) ke Angular 19+ Standalone & Signals.
+- Mengelola state aplikasi menggunakan NgRx SignalStore.
+- Mengoptimalkan performa rendering dengan deferrable views dan SSR hydration.

package/skills/anti-slop/SKILL.md

@@ -0,0 +1,134 @@
+---
+name: anti-slop
+description: "Comprehensive Anti-AI Slop enforcement guide. Updated to include token efficiency and code gardening / Panduan penegakan anti-AI slop komprehensif. Diperbarui dengan efisiensi token dan perawatan kode."
+author: "Roedy Rustam"
+version: "3.0.0"
+---
+
+# Anti-Slop, Token Efficiency & Code Gardening Protocol (2026 Edition)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description & Trigger Conditions
+The absolute zero-tolerance standard against AI slop, bloated context, and architectural decay. AI slop manifests as conversational pleasantries, lazy placeholders, speculative over-engineering, decorative comments, and vague buzzwords. This skill enforces rigorous anti-slop rules, token-saving compression, and code gardening across the engineering lifecycle.
+Triggers: Any code generation/modification, automated reviews, long-running sessions, explicit "be concise/minimal" requests, or when a codebase exhibits "AI smell" (inconsistencies, duplication, dead code).
+
+---
+
+## The 5 Pillars of AI Slop Elimination
+
+### Pillar 1: Conversational & Sycophancy Slop
+- **🔴 Forbidden**: Preambles ("Certainly! I'd be happy to help"), prompt echoing, apology loops, trailing motivational fluff.
+- **✅ Standard**: Imperative, code-first communication. Zero filler. 
+
+### Pillar 2: Placeholder & Truncation Slop ("Lazy LLM")
+- **🔴 Forbidden**: `// TODO: implement`, `// ... rest of code`, or returning mock arrays when production features are requested.
+- **✅ Standard**: Output must be 100% complete, functional, and production-ready.
+
+### Pillar 3: Speculative & Decorative Over-Engineering Slop
+- **🔴 Forbidden**: Creating factory patterns (`IUserServiceFactoryProvider`) for single implementations, triple-validated defensive code when TypeScript/Zod guarantee type safety.
+- **✅ Standard**: YAGNI (You Aren't Gonna Need It). Write the simplest direct implementation. Trust the types.
+
+### Pillar 4: Obvious & Decorative Comment Slop
+- **🔴 Forbidden**: Narrating syntax line-by-line (e.g., `// Increment count by 1 \n setCount(count + 1);`).
+- **✅ Standard**: Comments explain WHY (architectural decisions, business constraints), never WHAT.
+
+### Pillar 5: Buzzword & Artifact Slop
+- **🔴 Forbidden**: Documents filled with generic marketing jargon ("seamless integration", "robust synergy") with zero technical density.
+- **✅ Standard**: High technical density with explicit schemas, route tables, column types, and verifiable NFR latency budgets.
+
+---
+
+## Token Efficiency & Compression Protocol
+
+### 1. Response Compression Rules
+- **No preamble/restatement/summaries**: Show code immediately, explain briefly after.
+- **Diff format**: For file edits, show only changed lines.
+- **Bullet > prose**: Use 1-sentence rationales over paragraphs.
+
+### 2. Context Window Budget Awareness (200K Context)
+```text
+System prompt + skills: ~15K | Conversation history: ~50K | File reads: ~100K | Response: ~35K
+```
+- Summarize large files mentally; `view_file` only specific sections. Create a checkpoint with `session-memory-manager` when near full.
+
+### 3. Tool Call Minimization & First Draft Quality
+- Read multiple files in parallel.
+- Use `grep_search` over full reads.
+- Generate correct, production-ready code with inline error handling on the first try. Avoid edit-retry cycles.
+
+---
+
+## Legacy Code Gardening Protocol
+
+### 1. Context Drift Analysis & Code Smells
+- **Inconsistent Styles**: Mixed `async/await` vs `.then()`, variable namings (`userId` vs `user_id`). Fix with Prettier/ESLint rules.
+- **Bloated Components**: 5+ states, 10+ props, 20+ imports. Apply Single Responsibility and split them.
+- **Dependency Creep**: Use `npx depcheck` for unused dependencies and `npx bundle-phobia-cli` for sizing.
+- **Graveyard of Dead Utilities**: Use semantic search/grep to find and remove 0-usage exported functions.
+
+### 2. 4-Phase Gardening Protocol
+1. **Discovery**: Map file tree, find bloated files, duplicated logic, unused exports, and style drift.
+2. **Triage**: Categorize into Critical (bugs/data loss), High (diverging duplicates), Medium (smells), Low (style).
+3. **Systematic Refactoring**: Start smallest first. Remove dead code, extract duplicates, simplify abstractions, standardize names, add tests.
+4. **Prevention**: Add strict ESLint rules, `depcheck` in CI, and architecture tests.
+
+---
+
+## Automated Anti-Slop Audit Script
+Run `scripts/check-anti-slop.js` in CI to detect placeholders (`// ...`), unfinished stubs (`TODO:`), mock data in prod, and syntax narration (`// increment`). Fail builds if AI slop is detected.
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi & Kondisi Pemicu
+Standar nol-toleransi terhadap AI slop, pemborosan token, dan pembusukan arsitektur. AI slop muncul sebagai basa-basi, placeholder, over-engineering spekulatif, dan komentar dekoratif. Skill ini menegakkan anti-slop, kompresi respons, dan perawatan kode (code gardening).
+Pemicu: Pembuatan/modifikasi kode, review otomatis, sesi panjang, permintaan respons ringkas, atau saat codebase menunjukkan "AI smell" (inkonsistensi, duplikasi, kode mati).
+
+---
+
+### 5 Pilar Utama Pembasmian AI Slop
+
+1. **Pilar 1: Eliminasi Basa-Basi Percakapan** - Dilarang menggunakan pengantar atau pengulangan instruksi. Harus *code-first* dan tanpa basa-basi.
+2. **Pilar 2: Larangan Placeholder & Truncation ("Lazy LLM")** - Dilarang keras menggunakan `// TODO` atau memotong kode. Wajib 100% lengkap dan siap produksi.
+3. **Pilar 3: Anti Over-Engineering Spekulatif** - Hindari *factory pattern* atau layer ekstra tanpa alasan. Jangan validasi ganda jika Zod/TypeScript sudah menanganinya. Terapkan YAGNI.
+4. **Pilar 4: Eliminasi Komentar Sintaksis** - Jangan menarasikan baris kode (mis. `// tambah satu`). Komentar hanya untuk menjelaskan MENGAPA (alasan bisnis/arsitektur).
+5. **Pilar 5: Eliminasi Slop Dokumen & Buzzword** - Hindari kata-kata marketing kosong. Gunakan densitas teknis tinggi dengan skema pasti dan metrik konkret.
+
+---
+
+### Protokol Efisiensi & Kompresi Token
+
+- **Kompresi Respons**: Gunakan format diff untuk kode. Penjelasan menggunakan poin 1-kalimat daripada paragraf. Tanpa basa-basi.
+- **Budget 200K Konteks**: Batasi baca file penuh; gunakan `grep_search`. Buat checkpoint dengan `session-memory-manager` jika token menipis.
+- **Efisiensi Tool**: Baca file paralel, temukan konten spesifik dengan grep. Hasilkan draf pertama yang siap produksi tanpa siklus edit berulang.
+
+---
+
+### Protokol Berkebun Kode Warisan (Code Gardening)
+
+1. **Analisis Context Drift**: Perbaiki inkonsistensi gaya (contoh: `async` vs `then`, `userId` vs `user_id`) dengan ESLint/Prettier.
+2. **Komponen Membengkak**: Pecah komponen yang memiliki >5 state, >10 prop, atau >20 impor berdasarkan Tanggung Jawab Tunggal.
+3. **Utilitas Mati & Dependensi**: Hapus fungsi tanpa penggunaan. Gunakan `npx depcheck` untuk package tidak terpakai dan `bundle-phobia-cli` untuk ukuran.
+4. **Protokol 4 Fase**:
+   - *Discovery*: Petakan duplikasi dan kode mati.
+   - *Triage*: Kategorikan Kritis hingga Rendah.
+   - *Refactoring*: Hapus kode mati, ekstrak duplikat, sederhanakan abstraksi, tambah test.
+   - *Prevention*: Tambahkan ESLint strict, depcheck CI, dan uji arsitektur.
+
+---
+
+## Orchestration & Integration
+- `zero-to-prod-orchestrator`: Anti-slop checks at architectural and deployment phases.
+- `session-memory-manager`: Context resets when token budgets approach limits.
+- `scalability-clean-code`: Enforces SOLID boundaries against speculative over-engineering.
+- `autonomous-tdd-debugger`: Validates execution completeness over mock/stub code.
+- `coderabbit` & `brainstorming`: Clean PR reviews and dense documentation.
+- `dependency-upgrade-migrator`: Integrates with dependency audits (`depcheck`).