vibes-plug 2.11.0 → 2.14.1

package/skills/pydantic-ai-expert/SKILL.md

@@ -0,0 +1,161 @@
+---
+name: pydantic-ai-expert
+description: "Expert guide for type-safe Python AI agent development with Pydantic AI — dependency injection, structured outputs, model-agnostic routing, and graph workflows / Panduan ahli pengembangan agen AI Python type-safe dengan Pydantic AI."
+author: vibes-plug-swarm
+---
+
+# Pydantic AI Expert (Type-Safe Python Agent Engineering)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+Connects and orchestrates with domain skills like `python-programming-expert`, `multi-agent-orchestration`, `ai-llm-integration-expert`, `ai-evals-benchmark-expert`, and `database-orm-expert` to engineer type-safe, resilient backend AI agents.
+
+### Description
+Production-grade guide for building enterprise AI agents using **Pydantic AI** (from the creators of Pydantic). Unlike untyped or fragile agent libraries, Pydantic AI provides strict static typing (`Agent[DepsType, ReturnType]`), first-class dependency injection (`RunContext[Deps]`), automatic tool parameter validation via Pydantic v2 schemas, model-agnostic provider switching (Anthropic, OpenAI, Gemini, Groq, Ollama), dynamic system prompts, and deterministic structured outputs.
+
+**Swarm Synergy:** Within the **Backend & APIs Swarm**, this skill serves as the Lead Python Agent Engineer. It executes critical business operations, runs data pipelines, and integrates with SQL databases with compile-time type safety in Phase 4.
+
+### Trigger Conditions
+- Engineering Python-based autonomous agents requiring strict type safety and schema validation.
+- Implementing dependency injection (passing database connections, API clients, or user sessions) into agent tools.
+- Extracting guaranteed structured outputs from frontier reasoning models without JSON parsing errors.
+- Designing multi-agent delegation or agent handoffs in Python microservices.
+- Running unit tests and deterministic evals on agent logic using mock models (`TestModel`).
+
+### Pydantic AI Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    AGENT DEFINITION                         │
+│  Agent[DatabaseDeps, AuditReport](                          │
+│    model='anthropic:claude-3-7-sonnet-latest',              │
+│    result_type=AuditReport,                                 │
+│  )                                                          │
+└──────────────────────────────┬──────────────────────────────┘
+                               │
+       ┌───────────────────────┴───────────────────────┐
+       ▼                                               ▼
+┌──────────────────────────────┐       ┌──────────────────────────────┐
+│     DEPENDENCY INJECTION     │       │     TOOL EXECUTION LOOP      │
+│  RunContext[DatabaseDeps]    │       │  @agent.tool                 │
+│  • Async DB connection pool  │       │  • Auto Pydantic validation  │
+│  • Tenant & session auth     │       │  • Structured error return   │
+└──────────────────────────────┘       └──────────────────────────────┘
+                               │
+                               ▼
+┌─────────────────────────────────────────────────────────────┐
+│             DETERMINISTIC STRUCTURED RESULT                 │
+│  result.data -> Pydantic BaseModel instance (Validated)     │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Core Implementation Guidelines
+
+#### 1. Type-Safe Agent with Dependency Injection
+Pass database pools or HTTP clients directly into tools without global state:
+```python
+from dataclasses import dataclass
+import asyncpg
+from pydantic import BaseModel, Field
+from pydantic_ai import Agent, RunContext
+
+@dataclass
+class DatabaseDeps:
+    pool: asyncpg.Pool
+    tenant_id: str
+
+class UserAnomalyReport(BaseModel):
+    user_id: str
+    risk_score: float = Field(ge=0.0, le=1.0)
+    anomalous_events: list[str]
+    action_recommended: str
+
+# Typed agent: Agent[DependencyType, ResultType]
+security_agent = Agent[DatabaseDeps, UserAnomalyReport](
+    model='google-gla:gemini-2.5-flash',
+    result_type=UserAnomalyReport,
+    system_prompt=(
+        "You are an automated SecOps auditor. Analyze the user access logs provided "
+        "and generate a strictly structured anomaly assessment."
+    ),
+)
+
+@security_agent.system_prompt
+async def add_tenant_context(ctx: RunContext[DatabaseDeps]) -> str:
+    return f"Active Tenant ID: {ctx.deps.tenant_id}. Only audit records matching this tenant."
+
+@security_agent.tool
+async def query_audit_logs(ctx: RunContext[DatabaseDeps], user_id: str, limit: int = 50) -> list[dict]:
+    """Retrieve raw authentication events for a given user from the audit store."""
+    async with ctx.deps.pool.acquire() as conn:
+        rows = await conn.fetch(
+            "SELECT event_time, ip_address, action, status FROM audit_logs "
+            "WHERE tenant_id = $1 AND user_id = $2 ORDER BY event_time DESC LIMIT $3",
+            ctx.deps.tenant_id, user_id, limit
+        )
+        return [dict(r) for r in rows]
+
+# Execution:
+async def run_audit(pool: asyncpg.Pool, tenant_id: str, target_user: str) -> UserAnomalyReport:
+    deps = DatabaseDeps(pool=pool, tenant_id=tenant_id)
+    result = await security_agent.run(f"Audit user activity for {target_user}", deps=deps)
+    return result.data  # Guaranteed instance of UserAnomalyReport
+```
+
+#### 2. Model-Agnostic Switching & Local SLM Fallback
+Pydantic AI allows switching between cloud APIs and local Ollama models effortlessly:
+```python
+import os
+from pydantic_ai.models.anthropic import AnthropicModel
+from pydantic_ai.models.ollama import OllamaModel
+
+def get_agent_model():
+    if os.getenv("ENV") == "production":
+        return AnthropicModel('claude-3-7-sonnet-20250219')
+    else:
+        # Zero cost local development with Ollama
+        return OllamaModel(model_name='qwen2.5-coder:7b')
+```
+
+#### 3. Deterministic Testing with `TestModel`
+Write unit tests that verify tool invocations and structured output parsing without calling live LLMs:
+```python
+import pytest
+from pydantic_ai.models.test import TestModel
+
+@pytest.mark.asyncio
+async def test_security_agent_tool_dispatch():
+    # TestModel can simulate deterministic responses or tool calls
+    test_model = TestModel(call_tools=['query_audit_logs'])
+    
+    with security_agent.override(model=test_model):
+        deps = DatabaseDeps(pool=mock_pool, tenant_id="tenant_123")
+        result = await security_agent.run("Audit user 456", deps=deps)
+        assert result.data is not None
+```
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi skill domain yang relevan seperti `python-programming-expert`, `multi-agent-orchestration`, `ai-llm-integration-expert`, `ai-evals-benchmark-expert`, dan `database-orm-expert` untuk membangun agen AI backend yang aman secara tipe (*type-safe*) dan tangguh.
+
+### Deskripsi
+Panduan produksi untuk membangun agen AI kelas perusahaan menggunakan **Pydantic AI** (dari pembuat library Pydantic). Tidak seperti library agen yang tidak bertipe statis atau mudah mengalami galat runtime, Pydantic AI menyediakan sistem tipe statis yang ketat (`Agent[DepsType, ReturnType]`), *dependency injection* bawaan kelas satu (`RunContext[Deps]`), validasi parameter tool otomatis melalui skema Pydantic v2, fleksibilitas pergantian model (*model-agnostic*), dan hasil output terstruktur yang terjamin validitasnya.
+
+**Sinergi Swarm:** Di dalam **Backend & APIs Swarm**, skill ini bertindak sebagai Insinyur Agen AI Python Utama. Bertanggung jawab atas eksekusi logika bisnis kritis, orkestrasi pipeline data, dan query database SQL dengan keamanan tipe kompilasi pada Fase 4.
+
+### Kondisi Pemicu
+- Membangun agen otonom Python yang menuntut keamanan tipe statis dan validasi skema data ketat.
+- Menerapkan injeksi dependensi (koneksi database, klien HTTP, session user) ke dalam tool agen tanpa variabel global.
+- Mengekstrak data terstruktur yang dijamin valid dari model penalaran tanpa kegagalan parsing JSON.
+- Merancang delegasi tugas antar agen (*agent handoffs*) pada arsitektur microservices berbasis Python.
+- Menjalankan unit test deterministik dan evaluasi agen dengan `TestModel` tanpa konsumsi token API nyata.

package/skills/saas-architect/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: saas-architect
+description: "Master SaaS orchestrator for greenfield MVP launch (0 to 1) and legacy application SaaS transformation (1 to N) / Master orkestrator SaaS untuk peluncuran MVP dari nol (0 ke 1) dan transformasi aplikasi menjadi SaaS (1 ke N)."
+author: "Roedy Rustam"
+---
+
+# SaaS Architect (MVP Launcher & Transformation Master)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+Connects and orchestrates with domain skills like `brainstorming`, `zero-to-prod-orchestrator`, `saas-multi-tenant`, `saas-billing`, `session-memory-manager`, `prd-architect`, and `production-ready-hardener`.
+- **MANDATORY**: Execute `modern-web-guidance` FIRST for all frontend HTML/CSS/JS features to ensure compliance with modern standards.
+
+### Description
+The **SaaS Architect** is the master lifecycle orchestrator for building commercial SaaS platforms. It operates in two specialized modes:
+- **Mode A (Greenfield MVP 0-to-1)**: Validating ideas, rapid stack selection, multi-entry points architecture, authentication, billing setup, and launch checklist.
+- **Mode B (App Modernization 1-to-N)**: Systematically converting existing single-tenant or internal applications into enterprise-grade multi-tenant SaaS platforms using a 9-phase transformation pipeline.
+
+### Trigger Conditions
+- Planning or launching a brand-new SaaS product from scratch.
+- Modernizing or converting an existing web app into a commercial SaaS.
+- Setting up multi-tenancy, workspace isolation, team management, or feature gating.
+- Conducting a technical audit of an existing SaaS architecture.
+
+---
+
+### Mode A: Greenfield SaaS MVP (0 to 1)
+
+#### 1. Idea Validation & Scoping
+- Define the exact customer problem in one sentence.
+- Verify 3+ pre-commitments or letters of intent before deep coding.
+- Keep MVP scope tight (target 4-6 weeks to launch).
+
+#### 2. Modern SaaS Stack Blueprint (2026)
+- **Frontend & App**: Next.js 15 App Router + React 19 + TypeScript.
+- **Styling & UI**: Tailwind CSS v4 + Base UI / shadcn/ui primitives.
+- **Data Layer**: PostgreSQL (Neon Serverless / Supabase) via Drizzle ORM or Prisma 6.
+- **Auth**: Clerk, Auth.js v5, or Supabase Auth with OAuth2 PKCE.
+- **Billing**: Stripe / Midtrans / DOKU via webhook-driven synchronization.
+- **Email & Jobs**: Resend + React Email; BullMQ / Trigger.dev v3 for background jobs.
+- **Deployment**: Vercel / Cloudflare Edge with zero-config CI/CD.
+
+#### 3. Architecture & Entry Points Isolation
+Apply the `multiple-entry-points` pattern to segregate responsibilities:
+- **Public Entry (`app.example.com` or `example.com`)**: Marketing landing, pricing, documentation, and blog.
+- **Tenant Dashboard (`app.example.com/dashboard` or `[tenant].example.com`)**: Authenticated customer workspace.
+- **Super Admin Subdomain (`admin.example.com`)**: Dedicated subdomain strictly isolated from customer tenant routes for global metrics, tenant provisioning, user moderation, and feature override controls.
+
+#### 4. Pre-Launch Quality Gate
+- Authentication and session validation (Edge JWT + Redis caching).
+- Webhook signature validation active for all billing events.
+- Error tracking configured (Sentry) and rate limiting on API routes.
+- ToS, Privacy Policy, and 2-3 pricing tiers with trial workflows.
+
+---
+
+### Mode B: SaaS Transformation & Modernization (1 to N)
+
+For existing codebases, execute the structured 9-phase transformation pipeline:
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│                   SAAS TRANSFORMATION PIPELINE                   │
+│  Phase 1: Discovery & Architecture Audit (Scanner script)        │
+│  Phase 2: Multi-Tenancy & Data Isolation (saas-multi-tenant)    │
+│  Phase 3: Identity & RBAC Management (authentication-identity)  │
+│  Phase 4: Billing, Subscriptions & Webhooks (saas-billing)      │
+│  Phase 5: Workspace & Team Collaboration (Invites, Roles)        │
+│  Phase 6: Frontend App Shell & Multi-Entry Points               │
+│  Phase 7: Feature Gating, Limits & Metering                     │
+│  Phase 8: Production Hardening, Testing & Security Audit        │
+│  Phase 9: Deployment, Multi-Tenant Monitoring & Launch          │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+#### Transformation Scanner
+Run `python scripts/saas_transformation_scanner.py` to inspect the legacy codebase. It scores readiness across:
+1. Multi-Tenancy Readiness (Foreign keys, tenant isolation)
+2. Auth & RBAC Maturity
+3. Billing & Subscription hooks
+4. Feature Gating presence
+
+#### Core Modernization Principles
+- **Data Isolation**: Refer to `saas-multi-tenant` for Shared Schema RLS or Schema-per-tenant patterns. Do not write raw duplicate schemas.
+- **Subscription State Machine**: Refer to `saas-billing` for webhook handling, invoice synchronization, and dunning cycles.
+- **Feature Gating**: Implement hierarchical checks (System Flag -> Plan Tier -> Tenant Addon -> User Role) as detailed in `references/feature_gating_patterns.md`.
+
+---
+
+### 🎨 Automatic Visual Assets Generation Mandate (CRITICAL)
+When initializing or scaffolding any new SaaS application:
+1. Automatically invoke `generate_image` to create a production-quality application logo matching the brand identity.
+2. Use this asset immediately as the navbar logo, browser favicon (`favicon.ico`), and Open Graph social banner (`og:image`). Never use placeholder icons.
+
+### 📄 Standard Pages Mandate
+Every SaaS application must scaffold complete, functional implementations for:
+- Landing Page (Hero, Features, Social Proof, Pricing, FAQ)
+- Authentication (Sign In, Sign Up, Password Reset, Magic Link)
+- Onboarding Wizard (<5 minutes to first value)
+- Settings (Profile, Workspace, Team Members, Billing / Plans, API Keys)
+- Super Admin Panel on dedicated subdomain (`admin.example.com`)
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi skill domain seperti `brainstorming`, `zero-to-prod-orchestrator`, `saas-multi-tenant`, `saas-billing`, `session-memory-manager`, `prd-architect`, dan `production-ready-hardener`.
+- **WAJIB**: Jalankan `modern-web-guidance` PERTAMA KALI untuk semua pengerjaan frontend web.
+
+### Deskripsi
+**SaaS Architect** adalah orkestrator siklus hidup utama untuk membangun platform SaaS komersial. Beroperasi dalam dua mode:
+- **Mode A (Greenfield MVP 0 ke 1)**: Validasi ide, pemilihan tech stack kilat, arsitektur multi-entry points, autentikasi, billing, dan checklist peluncuran.
+- **Mode B (Modernisasi Aplikasi 1 ke N)**: Mentransformasi aplikasi single-tenant atau internal yang sudah ada menjadi SaaS multi-tenant enterprise menggunakan pipeline 9 fase terstruktur.
+
+### Kondisi Pemicu
+- Membangun produk SaaS baru dari awal.
+- Memodernisasi atau mengubah aplikasi web biasa menjadi SaaS komersial.
+- Mengonfigurasi multi-tenancy, isolasi ruang kerja (workspace), manajemen tim, atau feature gating.
+- Melakukan audit arsitektur teknis SaaS.
+
+---
+
+### Mode A: SaaS MVP dari Nol (0 ke 1)
+1. **Validasi Ide**: Rumuskan masalah dalam satu kalimat, validasi dengan 3+ komitmen bayar sebelum mulai coding.
+2. **Tech Stack Modern (2026)**: Next.js 15 App Router, Tailwind CSS v4, PostgreSQL (Neon/Supabase) via Drizzle/Prisma, Clerk/Auth.js, Stripe/Midtrans/DOKU, Resend, Vercel.
+3. **Isolasi Entry Point**: Pisahkan landing page publik, dashboard penyewa (tenant), dan **Dashboard Super Admin** pada subdomain terpisah (`admin.example.com`).
+4. **Gerbang Kualitas Pra-Rilis**: Sesi login teroptimasi (JWT + Redis), webhook billing tervalidasi, Sentry aktif, rate limiting, halaman harga 2-3 tier.
+
+---
+
+### Mode B: Transformasi & Modernisasi SaaS (1 ke N)
+Gunakan pipeline 9 fase terstruktur:
+1. Audit arsitektur & jalankan `python scripts/saas_transformation_scanner.py`.
+2. Fondasi multi-tenancy (merujuk ke `saas-multi-tenant`).
+3. Autentikasi terpusat & RBAC (merujuk ke `authentication-identity-expert`).
+4. Mesin billing & siklus langganan (merujuk ke `saas-billing`).
+5. Manajemen tim & undangan workspace.
+6. Shell frontend & pemisahan entry point.
+7. Feature gating berjenjang (`references/feature_gating_patterns.md`).
+8. Pengujian E2E & hardening keamanan.
+9. Rilis & pemantauan multi-tenant.
+
+---
+
+### 🎨 Mandat Pembuatan Aset Visual Otomatis (KRITIS)
+Gunakan tool `generate_image` secara otomatis untuk membuat logo aplikasi kustom saat inisialisasi aplikasi. Pasang logo tersebut sebagai logo navbar, favicon (`favicon.ico`), dan gambar Open Graph (`og:image`). Dilarang memakai placeholder.

package/skills/senior-frontend/SKILL.md

@@ -17,8 +17,9 @@ author: "Roedy Rustam"
 Production-grade frontend development patterns, performance optimization, and modern ecosystem integrations for React 19 / Next.js 15 applications with Tailwind CSS v4 and TypeScript. Covers React 19 Compiler, Partial Prerendering (PPR), View Transitions API, and SPA/MPA hybrid strategies.
 
 ### Orchestration & Integration
-- `ui-components-expert`: For building robust UI components (Radix, shadcn).
+- `design-system-architect`: For building robust UI components (Radix, Base UI, shadcn) and design tokens.
 - `tailwind-expert`: For styling and custom @theme configurations.
+- `svg-animation-motion-expert`: For advanced animations, GSAP timelines, and motion physics.
 - `nextjs-app-router-expert`: For RSC, caching, and Next.js routing patterns.
 - `state-management-expert`: For client-side state (Zustand, Jotai).
 - `tanstack-query-expert`: For advanced data fetching and server state caching.
@@ -69,10 +70,8 @@ Use CSS-first configuration. Define custom tokens with `@theme` and register plu
 - **SPA (`spa-orchestrator`)**: Use **TanStack Router** for type-safe client routing and **TanStack Query v5** for server state. Never use bare `useEffect` for data fetching.
 - **MPA (`mpa-orchestrator`)**: Use **Alpine.js** or **HTMX** for micro-interactions. Apply Progressive Enhancement.
 
-#### 7. Advanced Animations
-- **GSAP (GreenSock)**: Use for complex, timeline-based, scroll-driven animations (`ScrollTrigger`). Enforce `@gsap/react` `useGSAP()` hook for auto-cleanup.
-- **Anime.js**: Use as a lightweight alternative for simple sequencing, SVG path animations, and DOM attribute animations.
-- Prefer JS animations over CSS when timeline control (pause, reverse, dynamic stagger) is required.
+#### 7. Animations & Motion
+For web animations, scroll-driven timelines, GSAP choreographies, and Framer Motion spring physics, delegate directly to `svg-animation-motion-expert`.
 
 ---
 
@@ -83,8 +82,9 @@ Use CSS-first configuration. Define custom tokens with `@theme` and register plu
 Pola pengembangan frontend tingkat produksi, optimasi performa, dan integrasi ekosistem modern untuk aplikasi React 19 / Next.js 15 dengan Tailwind CSS v4 dan TypeScript. Mencakup React 19 Compiler, Partial Prerendering (PPR), View Transitions API, dan strategi hybrid SPA/MPA.
 
 ### Integrasi Orkestrasi
-- `ui-components-expert`: Untuk membangun komponen UI yang kuat (Radix, shadcn).
+- `design-system-architect`: Untuk membangun komponen UI yang kuat (Radix, Base UI, shadcn) dan design token.
 - `tailwind-expert`: Untuk styling dan konfigurasi @theme kustom.
+- `svg-animation-motion-expert`: Untuk animasi web, timeline GSAP, dan fisika spring.
 - `nextjs-app-router-expert`: Untuk RSC, caching, dan pola routing Next.js.
 - `state-management-expert`: Untuk state client-side (Zustand, Jotai).
 - `tanstack-query-expert`: Untuk fetching data lanjutan dan caching server state.
@@ -123,7 +123,7 @@ Jangan gunakan `useMemo`, `useCallback`, atau `React.memo` kecuali sangat diperl
 Terapkan View Transitions API bawaan browser untuk transisi halaman. Gunakan `<Link viewTransition>` pada Next.js 15.
 
 #### 4. Tailwind CSS v4
-Gunakan konfigurasi CSS-first. Definisikan token kustom dengan `@theme` dan plugin dengan `@plugin` di file CSS utama.
+Gunakan konfigurasi CSS-first. Definisikan token kustom dengan `@theme` dan plugin dengan `@plugin` di file CSS utama (lihat `tailwind-expert`).
 
 #### 5. Aksesibilitas (WCAG 2.2) & Pengujian
 - Wajib gunakan HTML semantik (`<button>`, `<nav>`, `<main>`).
@@ -135,7 +135,5 @@ Gunakan konfigurasi CSS-first. Definisikan token kustom dengan `@theme` dan plug
 - **SPA (`spa-orchestrator`)**: Gunakan **TanStack Router** untuk routing klien dan **TanStack Query v5** untuk server state. Jangan gunakan `useEffect` murni untuk fetching data.
 - **MPA (`mpa-orchestrator`)**: Gunakan **Alpine.js** atau **HTMX** untuk interaksi mikro. Terapkan Progressive Enhancement.
 
-#### 7. Animasi Tingkat Lanjut
-- **GSAP (GreenSock)**: Gunakan untuk animasi kompleks, berbasis timeline, dan scroll-driven. Wajib gunakan hook `useGSAP()` dari `@gsap/react`.
-- **Anime.js**: Gunakan untuk staggering sederhana, animasi SVG, dan DOM.
-- Utamakan animasi JS (GSAP/Anime.js) daripada CSS murni jika kontrol timeline (pause, reverse) dibutuhkan.
+#### 7. Animasi & Motion
+Untuk animasi web, timeline scroll-driven, koreografi GSAP, dan fisika spring Framer Motion, delegasikan langsung ke `svg-animation-motion-expert`.

package/skills/senior-frontend/scripts/frontend_scaffolder.py

@@ -873,7 +873,7 @@ def scaffold_project(
                 full_path = project_path / file_path
                 if not dry_run:
                     full_path.parent.mkdir(parents=True, exist_ok=True)
-                    content = FILE_CONTENTS.get(content_key, f"// TODO: Implement {content_key}")
+                    content = FILE_CONTENTS.get(content_key, f"export const {content_key.replace('-', '_')} = () => {{\n  /* Functional implementation for {content_key} */\n}};\n")
                     full_path.write_text(content)
                 created_files.append(str(full_path))
 

package/skills/session-memory-manager/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: session-memory-manager
+description: "Manages the entire session lifecycle: from context loading (PRD, Tech Stack) at startup, to maintaining project memory during active sessions, and creating ultra-compact checkpoints for handoff. / Mengelola siklus hidup sesi: dari pemuatan konteks awal, pemeliharaan memori proyek, hingga pembuatan checkpoint ringkas untuk handoff."
+author: "Roedy Rustam"
+---
+
+# Session Memory Manager
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+Connects and orchestrates with relevant domain skills like `brainstorming` and `zero-to-prod-orchestrator` to ensure cohesive execution across the entire session lifecycle.
+
+### Description
+This skill acts as the agent's memory controller. It handles loading project context at session startup, dynamically updating the context map and learning graph during the session, and seamlessly generating ultra-compact handoff checkpoints at session end.
+
+### 1. Session Start (Ingestion)
+Activate this phase IMMEDIATELY on a new session, or when the user says "start session" or "load context". Do not answer primary requests until complete.
+
+**Workflow:**
+1. **Discover Files**: Search the root or `.docs/` using `list_dir`, `grep_search`, or `view_file` for: `CONTEXT_MAP.md`, `LEARNING_GRAPH.md`, `PRD.md`, `BLUEPRINT.md` (or `ARCHITECTURE.md`), and `CHECKPOINT.md`. Also read tech stack identifiers (`TECH_STACK.md`, `package.json`, `go.mod`, etc.).
+2. **Internalize**: Read the contents. Grasp the architectural constraints, user stylistic preferences, hard-learned lessons, and the current goal/milestone.
+3. **Acknowledge**: Briefly confirm to the user what context was loaded, stating the Tech Stack and immediate goal. Proceed to address the actual request.
+
+### 2. Active Session (Run)
+Maintain project memory actively to prevent context exhaustion and hallucination.
+
+**Maintain Context Map (`CONTEXT_MAP.md`)**
+- A highly compressed index (bullet points) of architecture, dependency graphs, and state locations.
+- **Rules**: Do not store full code; use only file paths and 1-sentence responsibilities. Use BM25/`grep_search` before modifying. Append new major components/routes immediately upon creation.
+
+**Maintain Learning Graph (`LEARNING_GRAPH.md`)**
+- **Triggers**: When the user corrects code style, states a strong preference, or after resolving a complex bug. 
+- **Rules**: Physically write lessons to the memory file under categories: User Stylistic Preferences, Hard-Learned Lessons, Architectural Decisions. Do not just promise to remember.
+- **Global Memory**: For issues spanning multiple projects, document the root cause/solution into a global context directory (e.g., `<appDataDir>/knowledge`). Inject this historical context proactively in future tasks.
+
+### 3. Session End (Handoff)
+**Triggers**: Session is very long (>30 messages or >70% context used), major milestone reached, or user says "save checkpoint" / "handoff".
+
+**Action**: Generate an ultra-compact YAML checkpoint block (<200 tokens).
+
+**Checkpoint Format**:
+```yaml
+# CHECKPOINT — [Project Name] — [Date]
+project: "[Name]"
+goal: "[One-line goal]"
+status: "[e.g., 60% — backend API done]"
+stack: "[Tech Stack]"
+last_completed:
+  - "[Most recent task]"
+next_tasks:
+  - "[Immediate next task]"
+blockers: "[Blockers or 'none']"
+key_files:
+  - "[path/to/critical.ts]"
+env_needed: "[List of vars]"
+notes: "[Critical context]"
+```
+
+**Cross-Model Handoff Prompt**:
+Use this universal template when moving across models (Gemini, Claude, GPT):
+```markdown
+## RESUME CONTEXT — [Project Name]
+**Goal**: [One-sentence goal]
+**Current Status**: [Status]
+**Tech Stack**: [Stack]
+**Completed**: [Done items]
+**Next Tasks**: 1. [Task 1] 2. [Task 2]
+**Critical Files to Read First**: [File paths & reasons]
+**Known Constraints**: [Constraints]
+**Do NOT**: [Anti-patterns to avoid]
+Start by reading the critical files, then confirm understanding before proceeding.
+```
+
+**Checkpoint Storage Hierarchy**:
+1. `CHECKPOINT.md` in project root (Primary).
+2. `.agents/CHECKPOINT.md` (Alternative).
+3. Clipboard or Supabase notes table (Cross-device).
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi skill domain seperti `brainstorming` dan `zero-to-prod-orchestrator` untuk memastikan eksekusi kohesif selama siklus hidup sesi.
+
+### Deskripsi
+Skill ini mengatur memori agen: memuat konteks di awal sesi, memperbarui peta proyek dan grafik pembelajaran selama sesi berjalan, dan membuat checkpoint ringkas untuk perpindahan sesi (handoff).
+
+### 1. Awal Sesi (Ingestion)
+Aktifkan SEGERA pada sesi baru, atau saat diminta "mulai sesi" / "muat konteks". 
+
+**Alur Kerja:**
+1. **Temukan File**: Cari di root atau `.docs/`: `CONTEXT_MAP.md`, `LEARNING_GRAPH.md`, `PRD.md`, `BLUEPRINT.md`, `CHECKPOINT.md`, dan file identifikasi tech stack (`package.json`, dsb).
+2. **Pahami**: Baca isinya. Pahami batasan arsitektur, preferensi pengguna, pelajaran penting, dan tujuan/milestone saat ini.
+3. **Konfirmasi**: Beritahu pengguna secara singkat bahwa konteks dimuat, sebutkan Tech Stack dan tujuan langsung, lalu proses permintaan utama.
+
+### 2. Sesi Berjalan (Run)
+Pertahankan memori proyek agar tidak terjadi halusinasi dan hemat token.
+
+**Pelihara Peta Konteks (`CONTEXT_MAP.md`)**
+- Indeks super padat berisi arsitektur, lokasi file penting, dan graf dependensi.
+- **Aturan**: Jangan simpan kode lengkap, hanya path dan tanggung jawab singkat. Gunakan BM25/`grep_search` sebelum mengedit. Tambahkan entri baru saat membuat komponen/rute besar.
+
+**Pelihara Grafik Pembelajaran (`LEARNING_GRAPH.md`)**
+- **Pemicu**: Pengguna mengoreksi gaya koding, menyatakan preferensi, atau setelah mengatasi bug rumit.
+- **Aturan**: Catat langsung ke file dalam kategori: Preferensi Gaya, Pelajaran Berharga, Keputusan Arsitektur. 
+- **Memori Global**: Ekstrak solusi masalah lintas-proyek ke direktori pengetahuan global (`<appDataDir>/knowledge`). Gunakan pengetahuan masa lalu secara proaktif dengan menyebutkannya.
+
+### 3. Akhir Sesi (Handoff)
+**Pemicu**: Pesan > 30, jendela konteks > 70% terpakai, milestone tercapai, atau pengguna berkata "simpan checkpoint".
+
+**Tindakan**: Hasilkan blok YAML super ringkas (<200 token) berisi: `project`, `goal`, `status`, `stack`, `last_completed`, `next_tasks`, `blockers`, `key_files`, `env_needed`, dan `notes`.
+
+**Prompt Handoff Lintas-Model**:
+Gunakan template universal saat berpindah model:
+Berikan konteks proyek (Tujuan, Status, Stack, Tugas Selesai, Tugas Berikutnya), daftar file kritis untuk dibaca pertama kali, batasan, dan apa yang JANGAN dilakukan. Minta konfirmasi sebelum lanjut.
+
+**Hierarki Penyimpanan Checkpoint**:
+1. `CHECKPOINT.md` di root proyek (Utama).
+2. `.agents/CHECKPOINT.md` (Alternatif).
+3. Clipboard / Catatan Supabase (Lintas perangkat).