vibes-plug 1.0.0 → 2.11.0

package/skills/js-backend-expert/SKILL.md

@@ -1,192 +1,219 @@
----
-name: js-backend-expert
-description: "Expert-level skill for Node.js 22+, Bun 1.2+, and Deno 2.x backend development. Covers Express 5, Fastify 5, Hono, NestJS, Prisma 6, Drizzle ORM, WebSockets, and microservices in English and Indonesian."
+---
+name: js-backend-expert
+description: "Expert-level skill for Node.js 24+ (LTS), Bun 1.2+, and Deno 2.x backend development. Covers Express 5, Fastify 5, Hono v4, NestJS, Prisma 6, Drizzle ORM, WebSockets, BullMQ, OpenTelemetry, and microservices in English and Indonesian."
 author: "Roedy Rustam"
----
-
-# JS Backend Expert (Node.js 24 / Bun 1.2 / Deno 2.x Edition)
-
-[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
-
----
-
-<a name="english"></a>
-## English
-
-### Description
-Production-grade guidance for building fast, scalable, and resilient JavaScript/TypeScript backend APIs, microservices, and serverless functions across **Node.js 24 (LTS)**, **Bun 1.2+**, and **Deno 2.x**. Covers high-throughput frameworks (Fastify 5, Hono, Express 5, NestJS), type-safe ORMs (Drizzle, Prisma 6), **Hono RPC** for type-safe full-stack communication, Edge Runtime patterns, WebSockets, BullMQ background jobs, and graceful shutdown handling.
-
-### Trigger Conditions
-- Bootstrapping or refactoring a Node.js, Bun, or Deno backend application or microservice.
-- Writing RESTful, GraphQL, WebSocket, or SSE (Server-Sent Events) API endpoints.
-- Developing web servers using **Fastify 5**, **Hono**, **Express 5**, or **NestJS**.
-- Building type-safe full-stack apps with **Hono RPC** or **tRPC**.
-- Deploying backend logic to Edge Runtimes (Cloudflare Workers, Vercel Edge).
-- Interacting with databases using **Drizzle ORM**, **Prisma 6**, or **Kysely**.
-- Setting up background job processing with **BullMQ** and **Redis**.
-- Implementing rate limiting, CORS, Content Security Policy (CSP), and JWT/Session authentication.
-- Writing backend tests using **Vitest**, **Supertest**, or Node's native `node:test` runner.
-
-### Runtime Matrix (Node.js 24 vs Bun 1.2 vs Deno 2.x)
-
-| Feature / Runtime | Node.js 24 (LTS) | Bun 1.2+ | Deno 2.x |
-|---|---|---|---|
-| Module Standard | Native ESM / CJS | Native ESM / CJS | Native ESM |
-| `.env` Loading | Native `--env-file` | Native | Native |
-| TypeScript Execution | Native `--experimental-strip-types` / `tsx` | Native (Zero-config) | Native (Zero-config) |
-| HTTP Server | `node:http` / `Fastify` | `Bun.serve()` / `Hono` | `Deno.serve()` / `Hono` |
-| Native WebSockets | Built-in (`WebSocket`) | Built-in (`Bun.serve`) | Built-in (`Deno.upgradeWebSocket`) |
-| Package Manager | npm / pnpm | bun (built-in) | npm / jsr |
-| Test Runner | `node:test` / Vitest | `bun test` | `deno test` |
-| Edge Deploy | Vercel Serverless | Railway / Fly.io | Deno Deploy |
-
-### Framework Guidance
-
-#### 1. Fastify 5 (High-Throughput & Schema Validation)
-Use Fastify for performance-critical REST APIs. Always validate input using **TypeBox** or **Zod**:
-```typescript
-import Fastify from 'fastify';
-import { z } from 'zod';
-
-const app = Fastify({ logger: true });
-
-app.post('/api/users', async (request, reply) => {
-  const bodySchema = z.object({
-    email: z.string().email(),
-    name: z.string().min(2),
-  });
-  const data = bodySchema.parse(request.body);
-  return reply.status(201).send({ status: 'created', user: data });
-});
-```
-
-#### 2. Hono (Multi-Runtime & Hono RPC)
-Use Hono for cross-runtime backends. The killer feature in 2026 is **Hono RPC** — end-to-end type-safe API calls without code generation:
-```typescript
-// server.ts
-import { Hono } from 'hono';
-import { zValidator } from '@hono/zod-validator';
-import { z } from 'zod';
-
-const app = new Hono()
-  .get('/health', (c) => c.json({ status: 'ok' }))
-  .post(
-    '/users',
-    zValidator('json', z.object({ name: z.string(), email: z.string().email() })),
-    async (c) => {
-      const body = c.req.valid('json');
-      const user = await db.user.create({ data: body });
-      return c.json(user, 201);
-    }
-  );
-
-export type AppType = typeof app;
-export default app;
-
-// client.ts — fully type-safe, no codegen needed
-import { hc } from 'hono/client';
-import type { AppType } from './server';
-
-const client = hc<AppType>('http://localhost:3000');
-const res = await client.users.$post({ json: { name: 'Alice', email: 'alice@example.com' } });
-const user = await res.json(); // Fully typed!
-```
-
-#### 3. Express 5
-Express 5 natively catches rejected promises in async route handlers — eliminating the need for `express-async-errors`. It's ideal for teams already familiar with Express.
-
-#### 4. Edge Runtime (Cloudflare Workers / Vercel Edge)
-For ultra-low latency at the edge, use **Hono** (runs natively on all edge platforms):
-```typescript
-// Cloudflare Worker
-export default {
-  async fetch(request: Request, env: Env): Promise<Response> {
-    return app.fetch(request, env);
-  }
-};
-```
-Edge Runtime restrictions: No Node.js built-ins (`fs`, `path`), limited memory, no long-running processes. Use `fetch`, Web Crypto API, and Cloudflare KV/D1/R2.
-
----
-
-### Type-Safe Data Layer (Drizzle ORM & Prisma 6)
-- **Drizzle ORM**: Prefer for zero-overhead, SQL-like TypeScript query building in serverless/edge applications.
-- **Prisma 6**: Prefer for complex relational schema modeling, auto-generated TypeScript client, and rich `prisma studio` tooling.
-- **Connection Pooling**: Always use connection poolers (PgBouncer, Supavisor, Neon Hyperdrive) when deploying serverless handlers.
-
-### Background Jobs (BullMQ + Redis)
-```typescript
-import { Queue, Worker } from 'bullmq';
-import { Redis } from 'ioredis';
-
-const connection = new Redis({ maxRetriesPerRequest: null });
-const emailQueue = new Queue('email', { connection });
-
-// Enqueue
-await emailQueue.add('welcome-email', { userId: '123' }, { delay: 1000 });
-
-// Worker
-const worker = new Worker('email', async (job) => {
-  await sendWelcomeEmail(job.data.userId);
-}, { connection, concurrency: 5 });
-```
-
-### Graceful Shutdown & Resilience
-Never terminate the process abruptly. Clean up database pools, HTTP listeners, and Redis queues:
-```typescript
-const shutdown = async (signal: string) => {
-  console.log(`Received ${signal}. Shutting down gracefully...`);
-  await server.close();
-  await dbPool.end();
-  await worker.close();
-  process.exit(0);
-};
-
-process.on('SIGTERM', () => shutdown('SIGTERM'));
-process.on('SIGINT', () => shutdown('SIGINT'));
-```
-
----
-
-<a name="bahasa-indonesia"></a>
-## Bahasa Indonesia
-
-### Deskripsi
-Panduan tingkat produksi untuk membangun API backend JavaScript/TypeScript yang cepat, skalabel, dan tangguh di lingkungan **Node.js 24 (LTS)**, **Bun 1.2+**, dan **Deno 2.x**. Mencakup framework berkinerja tinggi (Fastify 5, Hono, Express 5, NestJS), ORM type-safe (Drizzle, Prisma 6), **Hono RPC** untuk komunikasi full-stack type-safe, pola Edge Runtime, WebSocket, background jobs (BullMQ), dan penanganan *graceful shutdown*.
-
-### Kondisi Pemicu
-- Merancang atau merefaktor aplikasi backend Node.js, Bun, atau Deno.
-- Menulis endpoint RESTful, GraphQL, WebSocket, atau SSE.
-- Membangun web server dengan Fastify 5, Hono, Express 5, atau NestJS.
-- Membangun aplikasi full-stack type-safe dengan **Hono RPC** atau tRPC.
-- Men-deploy logika backend ke Edge Runtime (Cloudflare Workers, Vercel Edge).
-- Berinteraksi dengan database menggunakan Drizzle ORM, Prisma 6, atau Kysely.
-- Mengatur background job dengan BullMQ dan Redis.
-
-### Matriks Runtime
-Node.js 24 sebagai LTS terbaru, Bun 1.2+ untuk performa maksimal dan zero-config TypeScript, Deno 2.x untuk keamanan bawaan dan kompatibilitas npm.
-
-### Panduan Framework
-
-#### 1. Fastify 5 — Kinerja Tinggi & Validasi Skema
-Gunakan untuk REST API dengan throughput tinggi. Selalu validasi input menggunakan TypeBox atau Zod.
-
-#### 2. Hono & Hono RPC — Multi-Runtime & Type-Safe Full-Stack
-Hono berjalan di Node.js, Bun, Cloudflare Workers, dan Deno. **Hono RPC** adalah fitur unggulan 2026 — panggilan API end-to-end yang fully type-safe tanpa code generation. Klien mendapatkan tipe yang tepat dari definisi server secara otomatis.
-
-#### 3. Express 5
-Express 5 otomatis menangkap rejected promises di async route handler tanpa butuh library tambahan.
-
-#### 4. Edge Runtime (Cloudflare Workers / Vercel Edge)
-Gunakan Hono untuk latensi ultra-rendah di edge. Batasan edge: tanpa built-in Node.js (`fs`, `path`), memori terbatas, tanpa proses long-running. Gunakan `fetch`, Web Crypto API, dan Cloudflare KV/D1/R2.
-
-### Lapisan Data Type-Safe
-- **Drizzle ORM**: Ideal untuk serverless/edge dengan query bergaya SQL dan zero overhead.
-- **Prisma 6**: Ideal untuk pemodelan skema relasional kompleks dan tooling prisma studio yang kaya.
-- **Connection Pooling**: Wajib di lingkungan serverless — gunakan PgBouncer, Supavisor, atau Neon Hyperdrive.
-
-### Background Jobs (BullMQ + Redis)
-Gunakan BullMQ dengan Redis untuk pemrosesan tugas latar belakang yang andal dengan retry otomatis, delay, dan konkurensi yang dapat dikonfigurasi.
-
-### Graceful Shutdown
-Jangan hentikan proses secara mendadak. Bersihkan connection pool, HTTP server, dan worker queue sebelum keluar.
+---
+
+# JS Backend Expert (Node.js 24 LTS / Bun 1.2 / Deno 2.x Edition)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description
+Production-grade guidance for building fast, scalable, and resilient JavaScript/TypeScript backend APIs, microservices, and serverless functions across **Node.js 24 (LTS)**, **Bun 1.2+**, and **Deno 2.x**. Covers high-throughput frameworks (Fastify 5, Hono, Express 5, NestJS), type-safe ORMs (Drizzle, Prisma 6), **Hono RPC** for type-safe full-stack communication, Edge Runtime patterns, WebSockets, BullMQ background jobs, and graceful shutdown handling.
+
+### Trigger Conditions
+- Bootstrapping or refactoring a Node.js, Bun, or Deno backend application or microservice.
+- Writing RESTful, GraphQL, WebSocket, or SSE (Server-Sent Events) API endpoints.
+- Developing web servers using **Fastify 5**, **Hono**, **Express 5**, or **NestJS**.
+- Building type-safe full-stack apps with **Hono RPC** or **tRPC**.
+- Deploying backend logic to Edge Runtimes (Cloudflare Workers, Vercel Edge).
+- Interacting with databases using **Drizzle ORM**, **Prisma 6**, or **Kysely**.
+- Setting up background job processing with **BullMQ** and **Redis**.
+- Implementing rate limiting, CORS, Content Security Policy (CSP), and JWT/Session authentication.
+- Writing backend tests using **Vitest**, **Supertest**, or Node's native `node:test` runner.
+
+### Runtime Matrix (Node.js 24 vs Bun 1.2 vs Deno 2.x)
+
+| Feature / Runtime | Node.js 24 (LTS) | Bun 1.2+ | Deno 2.x |
+|---|---|---|---|
+| Module Standard | Native ESM / CJS | Native ESM / CJS | Native ESM |
+| `.env` Loading | Native `--env-file` | Native | Native |
+| TypeScript Execution | Native `--experimental-strip-types` / `tsx` | Native (Zero-config) | Native (Zero-config) |
+| HTTP Server | `node:http` / `Fastify` | `Bun.serve()` / `Hono` | `Deno.serve()` / `Hono` |
+| Native WebSockets | Built-in (`WebSocket`) | Built-in (`Bun.serve`) | Built-in (`Deno.upgradeWebSocket`) |
+| Package Manager | npm / pnpm | bun (built-in) | npm / jsr |
+| Test Runner | `node:test` / Vitest | `bun test` | `deno test` |
+| Edge Deploy | Vercel Serverless | Railway / Fly.io | Deno Deploy |
+
+### Framework Guidance
+
+#### 1. Fastify 5 (High-Throughput & Schema Validation)
+Use Fastify for performance-critical REST APIs. Always validate input using **TypeBox** or **Zod**:
+```typescript
+import Fastify from 'fastify';
+import { z } from 'zod';
+
+const app = Fastify({ logger: true });
+
+app.post('/api/users', async (request, reply) => {
+  const bodySchema = z.object({
+    email: z.string().email(),
+    name: z.string().min(2),
+  });
+  const data = bodySchema.parse(request.body);
+  return reply.status(201).send({ status: 'created', user: data });
+});
+```
+
+#### 2. Hono (Multi-Runtime & Hono RPC)
+Use Hono for cross-runtime backends. The killer feature in 2026 is **Hono RPC** — end-to-end type-safe API calls without code generation:
+```typescript
+// server.ts
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { z } from 'zod';
+
+const app = new Hono()
+  .get('/health', (c) => c.json({ status: 'ok' }))
+  .post(
+    '/users',
+    zValidator('json', z.object({ name: z.string(), email: z.string().email() })),
+    async (c) => {
+      const body = c.req.valid('json');
+      const user = await db.user.create({ data: body });
+      return c.json(user, 201);
+    }
+  );
+
+export type AppType = typeof app;
+export default app;
+
+// client.ts — fully type-safe, no codegen needed
+import { hc } from 'hono/client';
+import type { AppType } from './server';
+
+const client = hc<AppType>('http://localhost:3000');
+const res = await client.users.$post({ json: { name: 'Alice', email: 'alice@example.com' } });
+const user = await res.json(); // Fully typed!
+```
+
+#### 3. NestJS (Enterprise Architecture)
+Use NestJS for large-scale, enterprise-grade applications. It enforces a strict modular architecture (Controllers, Providers, Modules) inspired by Angular.
+- **Dependency Injection**: Leverage built-in DI for testable, loosely coupled services.
+- **TypeScript First**: Decorators (`@Controller()`, `@Get()`) provide clean, declarative routing.
+- **Under the Hood**: By default uses Express, but can be switched to Fastify for higher performance using `platform-fastify`.
+
+#### 4. Express 5
+Express 5 natively catches rejected promises in async route handlers — eliminating the need for `express-async-errors`. While less opinionated than NestJS and slower than Fastify, its ecosystem is unparalleled. Ideal for teams migrating legacy apps.
+
+#### 5. Edge Runtime (Cloudflare Workers / Vercel Edge)
+For ultra-low latency at the edge, use **Hono** (runs natively on all edge platforms):
+```typescript
+// Cloudflare Worker
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    return app.fetch(request, env);
+  }
+};
+```
+Edge Runtime restrictions: No Node.js built-ins (`fs`, `path`), limited memory, no long-running processes. Use `fetch`, Web Crypto API, and Cloudflare KV/D1/R2.
+
+---
+
+### Type-Safe Data Layer (Drizzle ORM & Prisma 6)
+- **Drizzle ORM**: Prefer for zero-overhead, SQL-like TypeScript query building in serverless/edge applications.
+- **Prisma 6**: Prefer for complex relational schema modeling, auto-generated TypeScript client, and rich `prisma studio` tooling.
+- **Connection Pooling**: Always use connection poolers (PgBouncer, Supavisor, Neon Hyperdrive) when deploying serverless handlers.
+
+### Background Jobs (BullMQ + Redis)
+```typescript
+import { Queue, Worker } from 'bullmq';
+import { Redis } from 'ioredis';
+
+const connection = new Redis({ maxRetriesPerRequest: null });
+const emailQueue = new Queue('email', { connection });
+
+// Enqueue
+await emailQueue.add('welcome-email', { userId: '123' }, { delay: 1000 });
+
+// Worker
+const worker = new Worker('email', async (job) => {
+  await sendWelcomeEmail(job.data.userId);
+}, { connection, concurrency: 5 });
+```
+
+### Graceful Shutdown & Resilience
+Never terminate the process abruptly. Clean up database pools, HTTP listeners, and Redis queues:
+```typescript
+const shutdown = async (signal: string) => {
+  console.log(`Received ${signal}. Shutting down gracefully...`);
+  await server.close();
+  await dbPool.end();
+  await worker.close();
+  process.exit(0);
+};
+
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+process.on('SIGINT', () => shutdown('SIGINT'));
+```
+
+## Orchestration & Integration
+- **Upstream Orchestrator**: Executes during **Phase 4** of `zero-to-prod-orchestrator` or after backend decision lock in `brainstorming`.
+- **API Contracts & Specs**: Delegate OpenAPI / GraphQL / gRPC design to `api-design-expert` and TypeScript type generation to `typescript-expert`.
+- **Database & ORM Layer**: Delegate schema design, migrations, and pooling to `database-orm-expert` and `supabase-migration`. Connect to `edge-serverless-db-expert` for serverless database architectures.
+- **Authentication & Security**: Delegate JWT/OAuth2 flows to `authentication-identity-expert` and environment secret security to `zero-trust-secret-vault`.
+- **Durable Async Jobs**: Delegate fault-tolerant long-running workflows to `async-queue-temporal-expert`.
+- **Error Resilience**: Implement error handling patterns and circuit breakers via `error-resilience-expert`.
+- **Automated Testing & Docs**: Delegate integration testing to `e2e-testing-expert` and update change logs via `auto-doc-updater`.
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Panduan tingkat produksi untuk membangun API backend JavaScript/TypeScript yang cepat, skalabel, dan tangguh di lingkungan **Node.js 24 LTS**, **Bun 1.2+**, dan **Deno 2.x**. Mencakup framework berkinerja tinggi (Fastify 5, Hono v4, Express 5, NestJS), ORM type-safe (Drizzle, Prisma 6), **Hono RPC** untuk komunikasi full-stack type-safe, pola Edge Runtime, WebSocket, background jobs (BullMQ), OpenTelemetry, dan penanganan *graceful shutdown*.
+
+### Kondisi Pemicu
+- Merancang atau merefaktor aplikasi backend Node.js, Bun, atau Deno.
+- Menulis endpoint RESTful, GraphQL, WebSocket, atau SSE.
+- Membangun web server dengan Fastify 5, Hono, Express 5, atau NestJS.
+- Membangun aplikasi full-stack type-safe dengan **Hono RPC** atau tRPC.
+- Men-deploy logika backend ke Edge Runtime (Cloudflare Workers, Vercel Edge).
+- Berinteraksi dengan database menggunakan Drizzle ORM, Prisma 6, atau Kysely.
+- Mengatur background job dengan BullMQ dan Redis.
+
+### Matriks Runtime
+Node.js 24 sebagai LTS terbaru, Bun 1.2+ untuk performa maksimal dan zero-config TypeScript, Deno 2.x untuk keamanan bawaan dan kompatibilitas npm.
+
+### Panduan Framework
+
+#### 1. Fastify 5 — Kinerja Tinggi & Validasi Skema
+Gunakan untuk REST API dengan throughput tinggi. Selalu validasi input menggunakan TypeBox atau Zod.
+
+#### 2. Hono & Hono RPC — Multi-Runtime & Type-Safe Full-Stack
+Hono berjalan di Node.js, Bun, Cloudflare Workers, dan Deno. **Hono RPC** adalah fitur unggulan 2026 — panggilan API end-to-end yang fully type-safe tanpa code generation. Klien mendapatkan tipe yang tepat dari definisi server secara otomatis.
+
+#### 3. NestJS — Arsitektur Enterprise
+Gunakan NestJS untuk aplikasi skala besar tingkat *enterprise*. NestJS memaksakan arsitektur modular yang ketat dengan Dependency Injection dan Decorators. NestJS menggunakan Express secara bawaan, namun dapat dialihkan ke Fastify untuk performa lebih tinggi.
+
+#### 4. Express 5
+Express 5 otomatis menangkap rejected promises di async route handler tanpa butuh library tambahan. Sangat cocok untuk tim yang sudah familiar dengan ekosistem Express.
+
+#### 5. Edge Runtime (Cloudflare Workers / Vercel Edge)
+Gunakan Hono untuk latensi ultra-rendah di edge. Batasan edge: tanpa built-in Node.js (`fs`, `path`), memori terbatas, tanpa proses long-running. Gunakan `fetch`, Web Crypto API, dan Cloudflare KV/D1/R2.
+
+### Lapisan Data Type-Safe
+- **Drizzle ORM**: Ideal untuk serverless/edge dengan query bergaya SQL dan zero overhead.
+- **Prisma 6**: Ideal untuk pemodelan skema relasional kompleks dan tooling prisma studio yang kaya.
+- **Connection Pooling**: Wajib di lingkungan serverless — gunakan PgBouncer, Supavisor, atau Neon Hyperdrive.
+
+### Background Jobs (BullMQ + Redis)
+Gunakan BullMQ dengan Redis untuk pemrosesan tugas latar belakang yang andal dengan retry otomatis, delay, dan konkurensi yang dapat dikonfigurasi.
+
+### Graceful Shutdown
+Jangan hentikan proses secara mendadak. Bersihkan connection pool, HTTP server, dan worker queue sebelum keluar.
+
+## Integrasi Orkestrasi
+- **Orkestrator Utama**: Dieksekusi pada **Fase 4** dari `zero-to-prod-orchestrator` atau setelah finalisasi backend di `brainstorming`.
+- **Kontrak & Spesifikasi API**: Delegasikan desain OpenAPI / GraphQL / gRPC ke `api-design-expert` dan tipe TypeScript ke `typescript-expert`.
+- **Database & ORM**: Delegasikan desain skema, migrasi, dan pooling ke `database-orm-expert` dan `supabase-migration`. Hubungkan dengan `edge-serverless-db-expert` untuk arsitektur database serverless.
+- **Autentikasi & Keamanan**: Delegasikan alur JWT/OAuth2 ke `authentication-identity-expert` dan keamanan kredensial ke `zero-trust-secret-vault`.
+- **Pekerjaan Asinkron Tahan Gagal**: Delegasikan workflow kompleks ke `async-queue-temporal-expert`.
+- **Ketahanan Error**: Terapkan pola penanganan error dan circuit breaker melalui `error-resilience-expert`.
+- **Pengujian & Dokumentasi**: Delegasikan pengujian integrasi ke `e2e-testing-expert` dan perbarui catatan perubahan via `auto-doc-updater`.

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

@@ -0,0 +1,71 @@
+---
+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
+
+### Orchestration & Integration
+Connects and orchestrates with relevant domain skills like `brainstorming`, `zero-to-prod-orchestrator`, and `project-context-mapper` to ensure cohesive execution.
+
+### 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
+
+### 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 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.