vibes-plug 1.0.0 → 2.11.0

package/skills/local-slm-edge-ai-expert/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: local-slm-edge-ai-expert
+description: "Expert guide for Local Small Language Models (SLMs) and Edge AI execution — WebLLM, Transformers.js v3, ONNX Runtime Web, WebGPU, and zero-latency local embeddings / Panduan ahli SLM lokal dan AI edge di browser."
+author: "Roedy Rustam"
+---
+
+# Local SLM & Edge AI Expert (WebGPU & In-Browser Intelligence)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Purpose & Overview
+Production-grade architectural guide for running **Small Language Models (SLMs)** and embedding models directly inside client browsers and edge runtimes. Eliminates cloud API costs, guarantees 100% data privacy (zero cloud data leakage), and enables instant, offline-capable AI features using **WebGPU**, **Transformers.js v3**, **WebLLM**, and **ONNX Runtime Web**.
+
+### Key Capabilities
+1. **Client-Side Model Execution**: Running quantized 1B–4B SLMs (Llama 3.2 1B/3B, Gemma 2 2B, Phi-3.5 Mini, Qwen 2.5 1.5B/3B) entirely inside the user's browser via WebGPU.
+2. **In-Browser Embeddings**: Fast client-side vector embeddings with models like `all-MiniLM-L6-v2` or `bge-small-en-v1.5` using Transformers.js v3.
+3. **Hybrid Edge-Cloud Fallback**: Gracefully falling back to server-side LLMs when client hardware lacks WebGPU or sufficient VRAM.
+4. **Zero-Latency PII Masking**: Anonymizing sensitive user data locally on the client before sending queries to external LLMs.
+
+---
+
+### Production Implementation Recipes
+
+#### Recipe 1: In-Browser Semantic Embedding Generation with Transformers.js v3
+```typescript
+import { pipeline, env } from '@huggingface/transformers';
+
+// Configure cache and worker settings
+env.allowLocalModels = false;
+env.useBrowserCache = true;
+
+let embedder: any = null;
+
+export async function getLocalEmbedding(text: string): Promise<number[]> {
+  if (!embedder) {
+    embedder = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2', {
+      dtype: 'fp32',
+      device: 'webgpu', // Accelerate via WebGPU if supported
+    });
+  }
+
+  const output = await embedder(text, { pooling: 'mean', normalize: true });
+  return Array.from(output.data);
+}
+```
+
+#### Recipe 2: WebLLM In-Browser Chat Assistant with WebGPU
+```typescript
+import * as webllm from '@mlc-ai/web-llm';
+
+export async function createLocalChatEngine(onProgress?: (report: webllm.InitProgressReport) => void) {
+  // Check WebGPU compatibility
+  if (!('gpu' in navigator)) {
+    throw new Error('WebGPU is not supported in this browser. Fallback to cloud API.');
+  }
+
+  const selectedModel = 'Llama-3.2-1B-Instruct-q4f32_1-MLC';
+
+  const engine = await webllm.CreateMLCEngine(selectedModel, {
+    initProgressCallback: onProgress,
+  });
+
+  return {
+    generateResponse: async (prompt: string): Promise<string> => {
+      const reply = await engine.chat.completions.create({
+        messages: [{ role: 'user', content: prompt }],
+        temperature: 0.2,
+      });
+      return reply.choices[0]?.message.content || '';
+    },
+  };
+}
+```
+
+---
+
+### Implementation Checklist
+- [ ] Implement browser feature detection (`'gpu' in navigator`) before initiating WebGPU model loads.
+- [ ] Provide a transparent download progress bar when fetching model weights on initial visit.
+- [ ] Cache model shards in IndexedDB or Cache API to ensure instant subsequent launches.
+- [ ] Provide automatic fallback to lightweight serverless APIs when client device VRAM is constrained.
+
+## Orchestration & Integration
+- Integrates with: `ai-cost-token-optimizer`, `senior-frontend`, `vector-db-rag-expert`, `compliance-gdpr-privacy-expert`.
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Tujuan & Gambaran Umum
+Panduan arsitektur tingkat produksi untuk menjalankan **Small Language Models (SLM)** dan model *embedding* langsung di dalam browser pengguna dan runtime edge. Menghilangkan biaya API cloud, menjamin privasi data 100% (tidak ada data yang keluar ke server pihak ketiga), dan mengaktifkan fitur AI instan yang dapat bekerja secara *offline* menggunakan **WebGPU**, **Transformers.js v3**, **WebLLM**, dan **ONNX Runtime Web**.
+
+### Kemampuan Utama
+1. **Eksekusi Model di Sisi Klien**: Menjalankan SLM terkuantisasi 1B–4B (Llama 3.2 1B/3B, Gemma 2 2B, Phi-3.5 Mini, Qwen 2.5) sepenuhnya di dalam browser pengguna dengan akselerasi WebGPU.
+2. **Embedding Vektor di Browser**: Pembuatan vektor semantik secepat kilat menggunakan Transformers.js v3 (`all-MiniLM-L6-v2` atau `bge-small`).
+3. **Fallback Hibrida Klien-Cloud**: Mengalihkan tugas ke server secara otomatis jika perangkat klien tidak mendukung WebGPU atau memiliki VRAM terbatas.
+4. **Penyensoran PII Tanpa Latensi**: Mengaburkan data pribadi sensitif secara lokal di perangkat klien sebelum diteruskan ke cloud.
+
+---
+
+### Resep Implementasi Produksi
+
+#### Resep 1: Pembuatan Embedding Vektor di Browser dengan Transformers.js v3
+```typescript
+import { pipeline, env } from '@huggingface/transformers';
+
+env.allowLocalModels = false;
+env.useBrowserCache = true;
+
+let modelEmbedding: any = null;
+
+export async function buatEmbeddingLokal(teks: string): Promise<number[]> {
+  if (!modelEmbedding) {
+    modelEmbedding = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2', {
+      dtype: 'fp32',
+      device: 'webgpu',
+    });
+  }
+
+  const hasil = await modelEmbedding(teks, { pooling: 'mean', normalize: true });
+  return Array.from(hasil.data);
+}
+```
+
+#### Resep 2: Asisten AI di Browser dengan WebLLM & WebGPU
+```typescript
+import * as webllm from '@mlc-ai/web-llm';
+
+export async function inisialisasiMesinLokal(laporanProgres?: (laporan: webllm.InitProgressReport) => void) {
+  if (!('gpu' in navigator)) {
+    throw new Error('WebGPU tidak didukung pada browser ini. Alihkan ke API cloud.');
+  }
+
+  const modelTerpilih = 'Llama-3.2-1B-Instruct-q4f32_1-MLC';
+
+  const mesin = await webllm.CreateMLCEngine(modelTerpilih, {
+    initProgressCallback: laporanProgres,
+  });
+
+  return {
+    kirimPesan: async (pertanyaan: string): Promise<string> => {
+      const balasan = await mesin.chat.completions.create({
+        messages: [{ role: 'user', content: pertanyaan }],
+        temperature: 0.2,
+      });
+      return balasan.choices[0]?.message.content || '';
+    },
+  };
+}
+```
+
+---
+
+### Checklist Implementasi
+- [ ] Deteksi ketersediaan WebGPU (`'gpu' in navigator`) sebelum memuat model.
+- [ ] Tampilkan indikator progres unduhan bobot model saat pertama kali diakses.
+- [ ] Simpan bobot model di Cache API atau IndexedDB agar kunjungan berikutnya instan tanpa unduh ulang.
+- [ ] Siapkan jalur fallback ke API cloud jika memori klien tidak mencukupi.
+
+## Integrasi Orkestrasi
+- Terintegrasi dengan: `ai-cost-token-optimizer`, `senior-frontend`, `vector-db-rag-expert`, `compliance-gdpr-privacy-expert`.

package/skills/logging-error-tracking-expert/SKILL.md

@@ -0,0 +1,344 @@
+---
+name: logging-error-tracking-expert
+description: "Expert guide for structured logging (Pino, Winston), error tracking (Sentry), log aggregation (Axiom, Datadog), request correlation, and GDPR-compliant log management / Panduan ahli untuk logging terstruktur (Pino, Winston), pelacakan error (Sentry), agregasi log, korelasi request, dan manajemen log sesuai GDPR."
+author: "Roedy Rustam"
+---
+
+# Logging & Error Tracking Expert (2026 Edition)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+Connects and orchestrates with relevant domain skills like `brainstorming`, `zero-to-prod-orchestrator`, and `project-context-mapper` to ensure cohesive execution.
+
+### Description
+Production-grade guide for implementing structured logging, error tracking, and application monitoring. Covers **Pino** (high-performance JSON logging), **Sentry** SDK integration (React, Node.js, Next.js), **source map upload** for production errors, **request ID correlation** across microservices, **log aggregation** (Axiom, Datadog, Logflare), **alert rules**, **GDPR-compliant log redaction** (PII masking), and **OpenTelemetry integration**.
+
+### Trigger Conditions
+Activate this skill when:
+- Setting up structured logging for Node.js/Bun backend services.
+- Integrating Sentry for error tracking in React/Next.js apps.
+- Implementing request ID correlation across microservices.
+- Setting up log aggregation and search (Axiom, Datadog, Grafana Loki).
+- Configuring alerting rules for production errors.
+- Implementing GDPR-compliant log management (PII redaction).
+- Setting up source map uploads for production debugging.
+
+---
+
+### Logging Library Selection Guide
+
+| Library | Best For | Performance | Output Format |
+|---|---|---|---|
+| **Pino** | High-throughput Node.js services | ⭐⭐⭐⭐⭐ (fastest) | JSON (structured) |
+| **Winston** | Enterprise, multiple transports | ⭐⭐⭐ | Configurable |
+| **Bunyan** | Legacy projects | ⭐⭐⭐⭐ | JSON |
+| **console.log** | Never in production | ❌ | Unstructured |
+
+**Recommendation**: Use **Pino** for all production services (10x faster than Winston, native JSON).
+
+---
+
+### 1. Structured Logging with Pino
+
+```typescript
+// lib/logger.ts
+import pino from 'pino';
+
+export const logger = pino({
+  level: process.env.LOG_LEVEL ?? 'info',
+  // Redact sensitive fields (GDPR/PII)
+  redact: {
+    paths: ['req.headers.authorization', 'req.headers.cookie', '*.password', '*.token', '*.ssn', '*.creditCard'],
+    censor: '[REDACTED]',
+  },
+  // Standardized format
+  formatters: {
+    level: (label) => ({ level: label }),
+    bindings: (bindings) => ({
+      service: process.env.SERVICE_NAME ?? 'app',
+      environment: process.env.NODE_ENV,
+      version: process.env.APP_VERSION,
+      pid: bindings.pid,
+      hostname: bindings.hostname,
+    }),
+  },
+  timestamp: pino.stdTimeFunctions.isoTime,
+});
+
+// Child logger for specific domain
+export const dbLogger = logger.child({ module: 'database' });
+export const authLogger = logger.child({ module: 'auth' });
+export const paymentLogger = logger.child({ module: 'payment' });
+```
+
+#### Log Level Strategy
+```typescript
+// When to use each level:
+logger.fatal('Application cannot start — exiting');       // Process crash
+logger.error({ err }, 'Payment processing failed');        // Failed operations (needs attention)
+logger.warn('Rate limit threshold at 80%');                // Degraded state, approaching limits
+logger.info({ userId, action: 'login' }, 'User logged in'); // Business events, audit trail
+logger.debug({ query, params }, 'Database query executed'); // Development troubleshooting
+logger.trace({ request }, 'Incoming request');              // Extreme detail (rarely enabled)
+```
+
+---
+
+### 2. Request ID Correlation
+
+```typescript
+// middleware/request-id.ts
+import { randomUUID } from 'crypto';
+import { AsyncLocalStorage } from 'async_hooks';
+
+// Async context for request correlation
+export const requestContext = new AsyncLocalStorage<{ requestId: string }>();
+
+export function requestIdMiddleware(req: Request): string {
+  // Use incoming header or generate new ID
+  const requestId = req.headers.get('x-request-id') ?? randomUUID();
+
+  // Propagate to downstream services
+  return requestId;
+}
+
+// Usage with Pino child logger
+export function getRequestLogger() {
+  const ctx = requestContext.getStore();
+  return ctx ? logger.child({ requestId: ctx.requestId }) : logger;
+}
+
+// In API route
+export async function GET(request: Request) {
+  const requestId = requestIdMiddleware(request);
+
+  return requestContext.run({ requestId }, async () => {
+    const log = getRequestLogger();
+    log.info('Processing request');
+
+    // All downstream log calls include requestId automatically
+    const result = await fetchData(log);
+    return Response.json(result);
+  });
+}
+```
+
+---
+
+### 3. Sentry Integration (Next.js)
+
+```typescript
+// sentry.client.config.ts
+import * as Sentry from '@sentry/nextjs';
+
+Sentry.init({
+  dsn: process.env.NEXT_PUBLIC_SENTRY_DSN,
+  environment: process.env.NODE_ENV,
+  release: process.env.SENTRY_RELEASE,
+
+  // Performance monitoring
+  tracesSampleRate: process.env.NODE_ENV === 'production' ? 0.1 : 1.0,
+
+  // Session replay for debugging
+  replaysSessionSampleRate: 0.01, // 1% of sessions
+  replaysOnErrorSampleRate: 1.0,   // 100% of error sessions
+
+  integrations: [
+    Sentry.replayIntegration({ maskAllText: false, blockAllMedia: false }),
+  ],
+
+  // Filter noise
+  ignoreErrors: [
+    'ResizeObserver loop',
+    'Non-Error promise rejection',
+    /Loading chunk \d+ failed/,
+  ],
+
+  // Scrub PII before sending
+  beforeSend(event) {
+    if (event.user) {
+      delete event.user.ip_address;
+      delete event.user.email; // Or hash it
+    }
+    return event;
+  },
+});
+```
+
+```typescript
+// sentry.server.config.ts
+import * as Sentry from '@sentry/nextjs';
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  tracesSampleRate: 0.1,
+
+  // Capture unhandled promise rejections
+  integrations: [
+    Sentry.prismaIntegration(), // Auto-track Prisma queries
+  ],
+});
+```
+
+#### Source Map Upload (CI/CD)
+```yaml
+# .github/workflows/deploy.yml
+- name: Upload Source Maps to Sentry
+  env:
+    SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
+    SENTRY_ORG: your-org
+    SENTRY_PROJECT: your-project
+  run: |
+    npx @sentry/cli sourcemaps upload \
+      --release=${{ github.sha }} \
+      .next/static
+```
+
+---
+
+### 4. Log Aggregation Setup (Axiom)
+
+```typescript
+// lib/axiom-transport.ts
+import { pino } from 'pino';
+
+// Pino transport for Axiom (or any HTTP log service)
+const transport = pino.transport({
+  targets: [
+    // Console output (development)
+    { target: 'pino-pretty', level: 'debug' },
+    // Axiom (production)
+    {
+      target: '@axiomhq/pino',
+      level: 'info',
+      options: {
+        dataset: process.env.AXIOM_DATASET,
+        token: process.env.AXIOM_TOKEN,
+      },
+    },
+  ],
+});
+
+export const logger = pino(transport);
+```
+
+---
+
+### 5. Alert Rules Configuration
+
+```typescript
+// Example alert conditions to configure in your monitoring tool
+const ALERT_RULES = {
+  criticalErrors: {
+    condition: 'error count > 50 in 5 minutes',
+    severity: 'critical',
+    notification: ['pagerduty', 'slack'],
+  },
+  highErrorRate: {
+    condition: 'error rate > 5% of total requests',
+    severity: 'high',
+    notification: ['slack'],
+  },
+  slowResponses: {
+    condition: 'p99 response time > 3000ms for 10 minutes',
+    severity: 'medium',
+    notification: ['slack'],
+  },
+  diskSpace: {
+    condition: 'disk usage > 85%',
+    severity: 'warning',
+    notification: ['email'],
+  },
+};
+```
+
+---
+
+### 6. GDPR-Compliant Log Management
+
+```typescript
+// lib/pii-redactor.ts
+
+/** Fields that must be redacted in logs */
+const PII_PATTERNS = [
+  /\b\d{3}-\d{2}-\d{4}\b/g,           // SSN
+  /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g, // Credit card
+  /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g, // Email
+];
+
+export function redactPII(text: string): string {
+  let result = text;
+  for (const pattern of PII_PATTERNS) {
+    result = result.replace(pattern, '[REDACTED]');
+  }
+  return result;
+}
+
+// Log retention policy
+const LOG_RETENTION = {
+  debug: '7 days',
+  info: '30 days',
+  warn: '90 days',
+  error: '365 days',
+  audit: '7 years', // Compliance requirement
+};
+```
+
+---
+
+### Common Pitfalls to Avoid
+
+| Anti-Pattern | Problem | Correct Approach |
+|---|---|---|
+| `console.log` in production | Unstructured, no levels, no rotation | Use Pino with JSON output |
+| Logging PII (emails, passwords) | GDPR violation, security risk | Use Pino `redact` option |
+| No request correlation ID | Can't trace requests across services | Propagate `x-request-id` header |
+| Logging everything at `info` level | Log noise, storage waste | Use appropriate levels (debug/info/warn/error) |
+| No source maps in production errors | "Minified React error #xxx" | Upload source maps to Sentry |
+| No log rotation/retention policy | Disk fills up, storage costs grow | Set TTL per level, archive old logs |
+| Alerting on every error | Alert fatigue | Set meaningful thresholds and severity levels |
+
+---
+
+### Integration with Other Skills
+
+- `data-telemetry-expert` — OpenTelemetry spans + log correlation
+- `error-resilience-expert` — Error tracking and monitoring setup
+- `js-backend-expert` — Server-side logging middleware (Fastify/Hono/Express)
+- `ci-cd-devops-architect` — Source map upload in CI/CD pipeline
+- `production-ready-hardener` — Pre-launch logging and monitoring audit
+- `zero-trust-secret-vault` — Secure logging of secret access patterns
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi skill domain yang relevan seperti `brainstorming`, `zero-to-prod-orchestrator`, dan `project-context-mapper` untuk memastikan eksekusi yang kohesif.
+
+### Deskripsi
+Panduan tingkat produksi untuk mengimplementasikan logging terstruktur, pelacakan error, dan pemantauan aplikasi. Mencakup **Pino** (logging JSON berkinerja tinggi), integrasi SDK **Sentry** (React, Node.js, Next.js), **upload source map** untuk error produksi, **korelasi request ID** lintas microservice, **agregasi log** (Axiom, Datadog, Logflare), **aturan alerting**, **redaksi log sesuai GDPR** (masking PII), dan integrasi **OpenTelemetry**.
+
+### Kondisi Pemicu
+Aktifkan skill ini ketika:
+- Menyiapkan logging terstruktur untuk layanan backend Node.js/Bun.
+- Mengintegrasikan Sentry untuk pelacakan error di aplikasi React/Next.js.
+- Mengimplementasikan korelasi request ID lintas microservice.
+- Menyiapkan agregasi dan pencarian log (Axiom, Datadog, Grafana Loki).
+- Mengonfigurasi aturan alerting untuk error produksi.
+- Mengimplementasikan manajemen log sesuai GDPR (redaksi PII).
+
+### Integrasi dengan Skill Lain
+
+- `data-telemetry-expert` — Span OpenTelemetry + korelasi log
+- `error-resilience-expert` — Setup pelacakan error dan monitoring
+- `js-backend-expert` — Middleware logging sisi server (Fastify/Hono/Express)
+- `ci-cd-devops-architect` — Upload source map dalam pipeline CI/CD
+- `production-ready-hardener` — Audit logging dan monitoring pra-peluncuran

package/skills/mcp-client-orchestrator/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: mcp-client-orchestrator
+description: "Expert guide for the AI Agent to dynamically orchestrate and consume external MCP (Model Context Protocol) servers, giving it real-time superpowers over databases, GitHub, Slack, and local files."
+author: "Roedy Rustam"
+---
+
+# MCP Client Orchestrator
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+Connects and orchestrates with relevant domain skills like `brainstorming`, `zero-to-prod-orchestrator`, and `project-context-mapper` to ensure cohesive execution.
+
+### Description
+While `mcp-server-architect` teaches the agent how to *build* servers, this skill teaches the agent how to **consume** them as an MCP Client. This grants the agent "superpowers" by securely interacting with local PostgreSQL databases, GitHub repos, Figma APIs, and Slack channels in real-time, autonomously, using available MCP tool sets.
+
+### Trigger Conditions
+Activate this skill when:
+- The user asks the agent to query the database, but the agent doesn't have a direct SQL tool.
+- The user needs real-time context from an external system (e.g., "Read the latest Slack messages about this bug").
+- The user wants the agent to orchestrate multiple tools across different domains simultaneously.
+
+### Core Concepts
+
+#### 1. MCP Resource & Tool Discovery
+Before assuming a capability doesn't exist, the agent should dynamically inspect available tools.
+- Use `list_resources` or check `mcp_config.json` to see what servers are running.
+- Understand that MCP tools proxy capabilities securely. If there's a `postgres_mcp`, the agent can execute `execute_sql` through it.
+
+#### 2. Workflow Orchestration
+Example: "Find the bug reported on GitHub and fix it."
+1. Use the GitHub MCP to `search_issues`.
+2. Extract the stack trace from the issue comment.
+3. Use `grep_search` to find the failing code.
+4. Use `autonomous-tdd-debugger` to fix and test it.
+5. Use the GitHub MCP to `create_pull_request`.
+
+### Best Practices
+- **Never guess schema:** Always use MCP tools like `list_tables` or `get_schema` before writing a query.
+- **Respect Rate Limits:** If calling external APIs via MCP, avoid looping rapidly without timeouts.
+
+---
+
+### Integration with Other Skills (MANDATORY)
+- `doku-mcp-server` — An example of a specific MCP server the agent can orchestrate.
+- `ai-llm-integration-expert` — Provides context on how MCP fits into the broader LangGraph/AI landscape.
+- `multi-agent-orchestration` — Used when delegating different MCP tool calls to specialized subagents.
+
+### Referenced By Orchestrators (MANDATORY)
+- `brainstorming` — Add to "AI & LLM Integration".
+- `zero-to-prod-orchestrator` — Phase 4 (AI Agents).
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi skill domain yang relevan seperti `brainstorming`, `zero-to-prod-orchestrator`, dan `project-context-mapper` untuk memastikan eksekusi yang kohesif.
+
+### Deskripsi
+Skill yang memandu Agen AI tentang cara menggunakan (consume) server Model Context Protocol (MCP) eksternal, memberikan kekuatan *real-time* untuk berinteraksi dengan Database, GitHub, Slack, dan sistem lainnya secara otonom.
+
+### Kondisi Pemicu
+- Saat Anda (sebagai agen) perlu mengeksekusi SQL ke database lokal/remote namun tidak memiliki akses terminal langsung.
+- Saat Anda perlu membaca data *live* dari platform eksternal (Figma, GitHub, dll).
+
+### Panduan Singkat
+- **Eksplorasi Tool:** Selalu periksa tool MCP yang tersedia di sistem (misal `list_tables` atau `read_issue`). Jangan berasumsi Anda buta terhadap dunia luar jika server MCP-nya aktif.
+- **Orkestrasi Lintas Platform:** Anda dapat membaca pesan error di Slack via MCP, mencari kode yang relevan di *file system*, memperbaikinya, dan membuat Pull Request di GitHub via MCP secara otomatis. Ini adalah definisi sebenarnya dari Agen Otonom.
+- **Validasi Skema:** Jangan pernah menebak nama tabel. Selalu gunakan tool MCP untuk mengambil skema database terlebih dahulu sebelum menjalankan kueri `execute_sql`.