vibes-plug 1.0.0 → 2.5.0

package/skills/legacy-code-translator/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: legacy-code-translator
+description: "Methodological guide for the AI Agent to safely and systematically translate, refactor, and modernize giant legacy codebases (PHP, Python 2, old React) into modern stacks."
+author: "Roedy Rustam"
+---
+
+# Legacy Code Translator (Refactoring Engine)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description
+A rigid methodology for the AI agent to reverse-engineer and translate legacy codebases into modern architectures without losing business logic. This gives the agent the "superpower" to handle massive enterprise migrations safely, avoiding the common hallucination trap of rewriting everything at once.
+
+### Trigger Conditions
+Activate this skill when the user says:
+- "Migrate this old PHP codebase to Next.js."
+- "Translate this Python script to Rust."
+- "Refactor this giant React class component into hooks."
+
+### Core Concepts
+
+#### 1. The 4-Step Migration Protocol
+The agent MUST follow this exact sequence:
+1. **Understand (AST Map):** Map out the legacy code's inputs, outputs, and side effects. Document this in an artifact (`migration_plan.md`).
+2. **Isolate Logic:** Separate the core business rules from the legacy framework bindings (e.g., separate the tax calculation logic from the WordPress hook).
+3. **Translate:** Write the modernized code in the new language/framework.
+4. **Verify (Shadow Testing):** Compare the output of the new code against the old code using identical inputs.
+
+#### 2. Agent Constraints
+- **NEVER overwrite the legacy file directly.** Always create the new file side-by-side (e.g., `User.legacy.php` and `user.service.ts`).
+- **NEVER attempt to translate a 2000-line file in one shot.** Break it down by functions or modules to prevent context window exhaustion and token truncation.
+- **Preserve quirks:** Sometimes legacy bugs are actually relied-upon business logic. Document suspicious logic before fixing it.
+
+---
+
+### Integration with Other Skills (MANDATORY)
+- `prd-architect` — To document the extracted business rules before writing modern code.
+- `project-context-mapper` — To understand how the legacy files intertwine before pulling them apart.
+- `autonomous-tdd-debugger` — To write tests against the old code, ensuring the new code passes the exact same tests.
+
+### Referenced By Orchestrators (MANDATORY)
+- `brainstorming` — Add to "Architecture & Scale".
+- `zero-to-prod-orchestrator` — Phase 2 (Foundation / Refactoring).
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Panduan metodologis ketat bagi Agen AI untuk membongkar, menerjemahkan, dan memodernisasi *codebase* warisan (legacy) berskala raksasa (seperti PHP 5 atau React lawas) ke arsitektur modern tanpa kehilangan atau merusak *business logic* yang ada.
+
+### Kondisi Pemicu
+- Saat diminta memigrasikan sistem lama ke framework baru.
+- Saat harus menerjemahkan kode antar bahasa pemrograman (misal: Python ke Rust, atau PHP ke Go).
+
+### Panduan Singkat
+- **Jangan Langsung Timpa:** Jangan pernah menulis ulang kode lama di file yang sama. Buat file baru bersisian (`old_logic.js` -> `new_logic.ts`), lalu perlahan pindahkan impornya.
+- **Pecah Skala Raksasa:** LLM akan berhalusinasi jika diminta menerjemahkan 2000 baris kode sekaligus. Pecah tugas tersebut menjadi level fungsi (function-by-function).
+- **Pemetaan Input/Output:** Sebelum menulis kode baru, agen wajib mendaftar semua *input* (argumen, variabel global, request DB) dan *output* (return, modifikasi state, update DB) dari fungsi lama ke dalam dokumen artefak.

package/skills/llm-cost-arbitrage-router/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: llm-cost-arbitrage-router
+description: "Dynamically routes LLM calls based on cost/latency and builds semantic caching layers to reduce token burn / Mengarahkan pemanggilan LLM secara dinamis berdasarkan biaya/latensi dan membangun lapisan semantic cache untuk menekan pengeluaran token."
+author: vibes-plug-swarm
+---
+
+# Predictive LLM Cost Arbitrage Router (FinOps AI Agent)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description
+An advanced FinOps architectural skill designed to prevent API cost overruns in AI applications. Instead of hardcoding a single model (e.g., GPT-4 or Claude 3.5 Sonnet) for every task, this agent builds an intelligent routing layer. It evaluates incoming prompts for complexity and dynamically routes simple queries to cheaper, faster models (e.g., Llama 3 8B, Gemini Flash) and complex reasoning tasks to frontier models. Additionally, it implements Semantic Caching (e.g., with Redis or Upstash) to serve identical or semantically similar queries without hitting the LLM provider, slashing token costs by up to 90%.
+
+### Trigger Conditions
+- When building AI-native applications, chatbots, or RAG systems.
+- During Phase 4 (Backend Architecture) when implementing external API layers.
+- When explicitly requested by the user to "optimize AI costs" or "reduce token usage."
+
+### Operating Protocol
+1. **Model Fallback & Routing**: Sets up an abstraction layer (like LiteLLM or Vercel AI SDK Core) to support multiple providers.
+2. **Complexity Scoring**: Implements heuristics (prompt length, required JSON schema, keyword analysis) to route to the cheapest capable model.
+3. **Semantic Caching Integration**: Implements a Vector DB or Redis caching layer. Before routing to an LLM, it embeddings the user prompt and checks if a semantically similar query was answered recently.
+4. **Token Budgeting**: Sets hard limits and alerts for daily API consumption per tenant/user.
+
+## Orchestration & Integration
+- Enhances `ai-llm-integration-expert` with enterprise-grade cost controls.
+- Connects to `edge-serverless-db-expert` (Upstash/Redis) for fast semantic caching.
+- Collaborates with `vector-db-rag-expert` for similarity scoring during cache retrieval.
+- Feeds billing metrics into `saas-billing` for usage-based AI pricing models.
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Keterampilan arsitektur *FinOps* canggih yang dirancang untuk mencegah pembengkakan biaya API pada aplikasi berbasis AI. Alih-alih menetapkan satu model secara kaku (misalnya GPT-4 atau Claude 3.5 Sonnet) untuk semua tugas, agen ini membangun lapisan *routing* yang cerdas. Agen akan mengevaluasi tingkat kerumitan setiap prompt yang masuk dan mengarahkan *query* sederhana ke model yang lebih murah dan cepat (mis. Llama 3 8B, Gemini Flash), sementara tugas penalaran kompleks diarahkan ke model raksasa (*frontier*). Selain itu, agen ini mengimplementasikan *Semantic Caching* (misal dengan Redis atau Upstash) untuk menyajikan jawaban pada *query* yang identik atau mirip secara semantik tanpa harus menghubungi penyedia LLM, memangkas biaya token hingga 90%.
+
+### Kondisi Pemicu
+- Saat membangun aplikasi AI-native, chatbot, atau sistem RAG.
+- Selama Fase 4 (Arsitektur Backend) saat mengimplementasikan lapisan API eksternal.
+- Ketika diminta secara eksplisit oleh pengguna untuk "mengoptimalkan biaya AI" atau "mengurangi penggunaan token".
+
+### Protokol Operasi
+1. **Routing & Fallback Model**: Menyiapkan lapisan abstraksi (seperti LiteLLM atau Vercel AI SDK Core) untuk mendukung berbagai penyedia model.
+2. **Penilaian Kompleksitas**: Mengimplementasikan heuristik (panjang prompt, kebutuhan skema JSON, analisis kata kunci) untuk mengarahkan prompt ke model termurah yang mampu menyelesaikannya.
+3. **Integrasi Semantic Caching**: Mengimplementasikan lapisan *cache* Vector DB atau Redis. Sebelum mengirim ke LLM, prompt pengguna diubah menjadi vektor (*embedding*) untuk mengecek apakah pertanyaan serupa pernah dijawab baru-baru ini.
+4. **Penganggaran Token**: Menetapkan batas maksimal dan notifikasi untuk konsumsi API harian per pengguna/tenant.
+
+## Integrasi Orkestrasi
+- Memperkuat `ai-llm-integration-expert` dengan kontrol biaya skala *enterprise*.
+- Terhubung dengan `edge-serverless-db-expert` (Upstash/Redis) untuk *semantic caching* secepat kilat.
+- Berkolaborasi dengan `vector-db-rag-expert` untuk perhitungan kemiripan saat pencarian *cache*.
+- Memasok metrik penagihan ke `saas-billing` untuk model bisnis AI berbasis penggunaan (*usage-based pricing*).

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

@@ -0,0 +1,338 @@
+---
+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
+
+### 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
+
+### 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,70 @@
+---
+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
+
+### 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
+
+### 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`.