thienbun-ai-dev-toolkit 1.0.0

package/README.md

@@ -0,0 +1,310 @@
+# AI Dev Toolkit
+
+Personal toolkit for AI-assisted development. Combines curated skills, workflows, and rules for **Antigravity**, **Cursor**, **Claude Code**, and **GitHub Copilot**.
+
+---
+
+## Table of Contents
+
+- [First-Time Setup](#first-time-setup)
+- [What's Automatic vs Manual](#whats-automatic-vs-manual)
+- [Repository Structure](#repository-structure)
+- [How the 3-Tier System Works](#how-the-3-tier-system-works)
+- [Skills Reference](#skills-reference)
+- [Workflows Reference](#workflows-reference)
+- [Cross-IDE Support](#cross-ide-support)
+- [Skill Discovery](#skill-discovery)
+- [Updating](#updating)
+- [Adding to a New Project](#adding-to-a-new-project)
+- [Team Onboarding](#team-onboarding)
+
+---
+
+## First-Time Setup
+
+### Prerequisites
+
+- macOS with Zsh
+- Antigravity IDE (primary)
+- Git installed
+
+### Step 1: Clone and make executable
+
+```bash
+cd ~/Documents
+git clone <your-repo-url> ai-dev-toolkit
+chmod +x ai-dev-toolkit/scripts/setup-antigravity.sh
+```
+
+### Step 2: Run setup from inside your project
+
+```bash
+cd ~/Documents/Zigvy/hr-forte/hr-leave-module
+~/Documents/ai-dev-toolkit/scripts/setup-antigravity.sh
+```
+
+This one command does:
+
+| Step | What happens                                                   | Auto?        |
+| ---- | -------------------------------------------------------------- | ------------ |
+| 1    | Backs up `~/.gemini/GEMINI.md` → `GEMINI.md.backup`            | ✅ Automatic |
+| 2    | Writes all 42 rules (Sections I–XI) to `~/.gemini/GEMINI.md`   | ✅ Automatic |
+| 3    | Copies skills to `~/.agents/skills/` + symlinks to Antigravity | ✅ Automatic |
+| 4    | Copies workflows to `<project>/.agent/workflows/`              | ✅ Automatic |
+| 5    | Checks for bloated skills (>50 files = warning)                | ✅ Automatic |
+| 6    | Creates `.cursor/skills/` and `.claude/skills/` symlinks       | ✅ Automatic |
+
+### Step 3: Verify in Antigravity
+
+1. Open Antigravity → **Customizations** → **Rules** tab
+   - You should see Sections I–XI (42 rules)
+2. Open Antigravity → **Customizations** → **Workflows** tab
+   - You should see: plan, review, debug, verify
+
+### Step 4: (Optional) Cross-IDE config
+
+If you also use Cursor, Claude Code, or Copilot:
+
+```bash
+# For Cursor — copy .cursorrules to project root
+cp ~/Documents/ai-dev-toolkit/cross-ide/.cursorrules ~/Documents/Zigvy/hr-forte/hr-leave-module/.cursorrules
+
+# For Claude Code — copy CLAUDE.md to project root
+cp ~/Documents/ai-dev-toolkit/cross-ide/CLAUDE.md ~/Documents/Zigvy/hr-forte/hr-leave-module/CLAUDE.md
+
+# For GitHub Copilot / Codex — copy AGENTS.md to project root
+cp ~/Documents/ai-dev-toolkit/cross-ide/AGENTS.md ~/Documents/Zigvy/hr-forte/hr-leave-module/AGENTS.md
+```
+
+> **Note**: Edit these files after copying to add project-specific context (architecture, DB, key patterns).
+
+---
+
+## What's Automatic vs Manual
+
+### ✅ Automatic (AI does this without prompting)
+
+| What                       | How it works                                            | Source file                                          |
+| -------------------------- | ------------------------------------------------------- | ---------------------------------------------------- |
+| **TypeScript rules**       | Always active — AI reads `GEMINI.md` every conversation | `user-rules/memory-rules.md` → `~/.gemini/GEMINI.md` |
+| **No `any`**, strict types | Part of Section III (TS Essentials) in rules            | Always active                                        |
+| **Proposal-only mode**     | AI proposes first, asks before editing                  | Section I in rules                                   |
+| **Verify before done**     | AI re-reads checklist, runs `tsc`, reports status       | Section X in rules                                   |
+| **English output**         | All code, comments, docs in English                     | Section XI in rules                                  |
+| **DDD skill**              | AI reads when task involves DDD patterns                | `skills/ddd-core-rules/SKILL.md`                     |
+| **TS patterns**            | AI reads when writing TypeScript                        | `skills/typescript-mastery/SKILL.md`                 |
+| **Review checklist**       | AI reads when reviewing code                            | `skills/code-review/SKILL.md`                        |
+| **Git conventions**        | AI reads when making commits                            | `skills/git-workflow/SKILL.md`                       |
+
+### 🔧 Manual (You trigger these)
+
+| What                  | How to trigger             | When to use                                       |
+| --------------------- | -------------------------- | ------------------------------------------------- |
+| **Plan workflow**     | Type `/plan` in chat       | Starting a new feature or complex task            |
+| **Review workflow**   | Type `/review` in chat     | Before creating a PR                              |
+| **Debug workflow**    | Type `/debug` in chat      | Stuck on a bug                                    |
+| **Verify workflow**   | Type `/verify` in chat     | Before declaring task complete                    |
+| **Setup script**      | Run `setup-antigravity.sh` | New machine, new project, or after toolkit update |
+| **Cross-IDE configs** | Copy files to project root | When using Cursor/Claude/Copilot                  |
+
+### 🧠 Semi-Automatic (AI decides)
+
+Skills are read **only when relevant**. The AI matches the `description` field in each `SKILL.md` against your current task:
+
+- Working on DDD module? → AI reads `ddd-core-rules`
+- Writing TypeScript? → AI reads `typescript-mastery`
+- Reviewing code? → AI reads `code-review`
+- Not related? → AI skips it (saves context)
+
+---
+
+## Repository Structure
+
+```
+ai-dev-toolkit/
+│
+├── README.md                          ← This file
+│
+├── skills/                            ← Global skills (copied to ~/.agents/skills/)
+│   ├── ddd-core-rules/SKILL.md        ← DDD best practices (Eric Evans, Fowler)
+│   ├── typescript-mastery/SKILL.md    ← TS patterns, type guards, generics
+│   ├── code-review/SKILL.md           ← 8-section review checklist
+│   └── git-workflow/SKILL.md          ← Conventional Commits, PR workflow
+│
+├── workflows/                         ← Workflows (copied to project .agent/workflows/)
+│   ├── plan.md                        ← /plan — structured planning
+│   ├── review.md                      ← /review — code review
+│   ├── debug.md                       ← /debug — systematic debugging
+│   └── verify.md                      ← /verify — verification before done
+│
+├── user-rules/
+│   └── memory-rules.md                ← All 42 rules (written to ~/.gemini/GEMINI.md)
+│
+├── cross-ide/                         ← Templates for other AI IDEs
+│   ├── CLAUDE.md                      ← Claude Code project config
+│   ├── AGENTS.md                      ← GitHub Copilot / Codex config
+│   └── .cursorrules                   ← Cursor IDE rules
+│
+├── references/
+│   └── skill-discovery.md             ← How to find and install new skills
+│
+├── plans/                             ← Implementation plans archive
+│   ├── plan-core.md
+│   ├── plan-hr-leave-module.md
+│   └── plan-hr-forte-mobile.md
+│
+└── scripts/
+    └── setup-antigravity.sh           ← One-command setup script
+```
+
+---
+
+## How the 3-Tier System Works
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Tier 1: RULES (Always Active)                          │
+│  ~/.gemini/GEMINI.md                                     │
+│  Applied to EVERY conversation, EVERY project           │
+│  42 rules: strict mode, TS, workflow, verify, English   │
+├─────────────────────────────────────────────────────────┤
+│  Tier 2: SKILLS (Semi-Auto)                             │
+│  ~/.agents/skills/*.SKILL.md                             │
+│  AI reads when description matches current task         │
+│  DDD rules, TS mastery, code review, git workflow       │
+├─────────────────────────────────────────────────────────┤
+│  Tier 3: WORKFLOWS (Manual)                             │
+│  <project>/.agent/workflows/*.md                         │
+│  Triggered by /command in chat                          │
+│  /plan, /review, /debug, /verify                        │
+└─────────────────────────────────────────────────────────┘
+```
+
+**Key insight**: Put rules you want **always enforced** in Tier 1. Put **detailed reference material** in Tier 2 (skills). Put **step-by-step processes** in Tier 3 (workflows).
+
+---
+
+## Skills Reference
+
+### ddd-core-rules
+
+- **When AI reads it**: Working on DDD-structured modules
+- **Content**: Aggregate rules, layer dependencies, tactical patterns, anti-patterns
+- **Sources**: Eric Evans, Martin Fowler, nestjslatam/ddd
+
+### typescript-mastery
+
+- **When AI reads it**: Writing or reviewing TypeScript code
+- **Content**: Type design, discriminated unions, branded types, type guards, generics, RO-RO, pitfalls
+- **Naming conventions table** included
+
+### code-review
+
+- **When AI reads it**: Reviewing code (own or others')
+- **Content**: 8-section checklist (type safety, architecture, performance, error handling, security, testing, docs)
+- **Severity levels**: 🔴 Critical, 🟡 Warning, 🟢 Suggestion
+
+### git-workflow
+
+- **When AI reads it**: Making commits, creating branches, preparing PRs
+- **Content**: Conventional Commits format, branch naming, PR template, release flow diagram
+
+---
+
+## Workflows Reference
+
+| Command   | Purpose                               | When to use                         |
+| --------- | ------------------------------------- | ----------------------------------- |
+| `/plan`   | Create structured plan with checklist | Starting new feature, 3+ step task  |
+| `/review` | Systematic code review                | Before PR, after implementation     |
+| `/debug`  | Step-by-step debugging                | Stuck on a bug, unexpected behavior |
+| `/verify` | Evidence-based completion check       | Before declaring task done          |
+
+---
+
+## Cross-IDE Support
+
+| IDE                | Config file                    | How AI reads it                      | Template location         |
+| ------------------ | ------------------------------ | ------------------------------------ | ------------------------- |
+| **Antigravity**    | `GEMINI.md` + `.agent/skills/` | Auto (rules always, skills by match) | Setup script handles this |
+| **Cursor**         | `.cursorrules` in project root | Auto reads on project open           | `cross-ide/.cursorrules`  |
+| **Claude Code**    | `CLAUDE.md` in project root    | Auto reads on project open           | `cross-ide/CLAUDE.md`     |
+| **GitHub Copilot** | `AGENTS.md` in project root    | Auto reads for agent mode            | `cross-ide/AGENTS.md`     |
+
+> **Important**: After copying cross-IDE templates, edit them to add project-specific details (architecture, database, key patterns). The templates contain generic TypeScript rules only.
+
+---
+
+## Skill Discovery
+
+### Find and install new skills
+
+```bash
+npx skills find <query>       # Search by keyword
+npx skills add <owner/repo>   # Install from GitHub
+```
+
+### Curated catalogs
+
+| Catalog              | URL                                                                        |
+| -------------------- | -------------------------------------------------------------------------- |
+| skills.sh            | [skills.sh](https://skills.sh)                                             |
+| Antigravity Awesome  | [GitHub](https://github.com/sickn33/antigravity-awesome-skills)            |
+| Awesome Agent Skills | [GitHub](https://github.com/VoltAgent/awesome-agent-skills)                |
+| Awesome Cursorrules  | [GitHub](https://github.com/PatrickJS/awesome-cursorrules/tree/main/rules) |
+
+See [references/skill-discovery.md](references/skill-discovery.md) for detailed guide with evaluation criteria.
+
+---
+
+## Updating
+
+When you update this toolkit repo:
+
+```bash
+# 1. Update the toolkit
+cd ~/Documents/ai-dev-toolkit
+git pull   # or edit files directly
+
+# 2. Re-run setup in each project
+cd ~/Documents/Zigvy/hr-forte/hr-leave-module
+~/Documents/ai-dev-toolkit/scripts/setup-antigravity.sh
+```
+
+The script is **idempotent** — safe to run multiple times. It will:
+
+- Overwrite rules with the latest version (old version backed up)
+- Overwrite skills (latest version)
+- Overwrite workflows (latest version)
+
+---
+
+## Adding to a New Project
+
+```bash
+cd ~/Documents/Zigvy/new-project
+~/Documents/ai-dev-toolkit/scripts/setup-antigravity.sh
+```
+
+That's it. The script creates `.agent/workflows/` in the project and installs global skills + rules.
+
+For cross-IDE support, also copy the config templates:
+
+```bash
+cp ~/Documents/ai-dev-toolkit/cross-ide/.cursorrules .
+cp ~/Documents/ai-dev-toolkit/cross-ide/CLAUDE.md .
+cp ~/Documents/ai-dev-toolkit/cross-ide/AGENTS.md .
+```
+
+---
+
+## Team Onboarding
+
+For a new team member:
+
+1. **Clone the project** → workflows in `.agent/workflows/` are included
+2. **Run setup script** → installs global rules + skills
+3. **Verify** → open Antigravity → Customizations → check Rules + Workflows tabs
+4. **Done** — AI now understands project context and follows all conventions
+
+> **Note**: User rules in `GEMINI.md` are personal (not committed to git). Each team member runs the setup script once on their machine.

package/cross-ide/.cursorrules

@@ -0,0 +1,30 @@
+You are a senior TypeScript programmer with experience in NestJS and React Native.
+Generate code, corrections, and refactorings that comply with these principles.
+
+## TypeScript Rules
+- Never use `any`. Use `unknown` + type guards if type is truly unknown.
+- Always declare return types for all functions and methods.
+- Prefer `interface` for object shapes, `type` for unions/intersections.
+- Use `readonly` for data that should not change after creation.
+- PascalCase for classes/interfaces/types, camelCase for variables/methods, kebab-case for files.
+- Functions: single purpose, <20 lines, verb-first naming.
+- Use RO-RO pattern (Receive Object, Return Object) for 3+ parameters.
+- DTOs: validate inputs with class-validator. Declare simple types for outputs.
+- Prefer composition over inheritance. Follow SOLID principles.
+- Use `as const` for literals, `readonly` arrays/tuples where applicable.
+
+## Code Quality
+- No empty catch blocks.
+- No TODO/FIXME without linked issue.
+- No magic numbers — use named constants.
+- No dead code or unused imports.
+
+## Architecture
+- Adapt to existing module patterns (DDD or Legacy).
+- Controllers: thin — routing + validation + DTO mapping only.
+- Services: contain business logic.
+- Domain layer must not import from framework or ORM.
+
+## Output
+- All code, comments, documentation must be in English.
+- Commit messages follow Conventional Commits format.

package/cross-ide/AGENTS.md

@@ -0,0 +1,33 @@
+# AGENTS.md Template
+
+# Copy this to your project root for GitHub Copilot / Codex support.
+
+# These tools read AGENTS.md for project-specific instructions.
+
+## Project Context
+
+<!-- Replace with your project description -->
+
+This is a TypeScript project. Follow these rules strictly.
+
+## Coding Standards
+
+- Never use `any` type. Use `unknown` + type guards.
+- Always declare return types for functions.
+- Interface for object shapes, type for unions/intersections.
+- Functions: single purpose, <20 lines.
+- Use `readonly` for immutable data.
+- PascalCase for classes, camelCase for variables, kebab-case for files.
+
+## Architecture Rules
+
+<!-- Add your architecture-specific rules -->
+
+- Follow existing module patterns
+- Keep controllers thin — routing + validation only
+- Business logic in services/use-cases
+
+## Output Language
+
+- All code, comments, variable names, documentation: English only
+- Never write non-English text in code files

package/cross-ide/CLAUDE.md

@@ -0,0 +1,41 @@
+# CLAUDE.md Template
+
+# Copy this to your project root for Claude Code support.
+
+# Claude Code reads this file automatically when opening a project.
+
+## Project Overview
+
+<!-- Replace with your project description -->
+
+This is a TypeScript project using [NestJS/React Native/etc].
+
+## Architecture
+
+<!-- Describe your architecture (DDD, MVC, etc) -->
+
+## Coding Standards
+
+- TypeScript strict mode. No `any`.
+- Prefer `interface` for object shapes, `type` for unions.
+- Functions: single purpose, <20 lines, verb-first naming.
+- Use `readonly` for immutable data.
+- DTOs: validate with class-validator.
+
+## Conventions
+
+- File naming: kebab-case (e.g., `user-profile.service.ts`)
+- Commit messages: Conventional Commits (`feat:`, `fix:`, `refactor:`)
+- Branch naming: `feature/TICKET-description`, `fix/TICKET-description`
+
+## Testing
+
+- Unit tests: Arrange-Act-Assert pattern
+- Run: `npm test`
+- Type check: `npx tsc --noEmit`
+
+## Important Rules
+
+- PROPOSAL ONLY: Propose changes first, don't edit without confirmation.
+- All output in English (code, comments, docs, commits).
+- Verify before done: re-read checklist, run type check, confirm each item.

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "thienbun-ai-dev-toolkit",
+  "version": "1.0.0",
+  "description": "Personal AI dev toolkit — curated skills, workflows, and rules for Antigravity, Cursor, Claude Code",
+  "bin": {
+    "thienbun-ai-dev-toolkit": "./scripts/setup-antigravity.sh"
+  },
+  "files": [
+    "skills/",
+    "workflows/",
+    "user-rules/",
+    "cross-ide/",
+    "references/",
+    "scripts/"
+  ],
+  "keywords": [
+    "antigravity",
+    "ai-coding",
+    "skills",
+    "workflows",
+    "typescript",
+    "ddd"
+  ],
+  "license": "MIT"
+}

package/references/skill-discovery.md

@@ -0,0 +1,78 @@
+# Skill Discovery Guide
+
+## Finding Skills
+
+```bash
+# Search for skills by keyword
+npx skills find <query>
+
+# Examples
+npx skills find "react native"
+npx skills find "nestjs"
+npx skills find "typescript"
+npx skills find "ddd"
+```
+
+## Installing Skills
+
+```bash
+# Install from GitHub repo (all skills in that repo)
+npx skills add <owner/repo>
+
+# Install specific skill from a repo
+npx skills add <owner/repo> --skill <skill-name>
+
+# Example
+npx skills add vercel/next.js --skill next-performance
+```
+
+## Curated Catalogs
+
+### Primary Resources
+
+| Catalog                  | URL                                                                                                     | Description                                                |
+| ------------------------ | ------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------- |
+| **skills.sh**            | [skills.sh](https://skills.sh)                                                                          | Central registry. Browse by category, filter by popularity |
+| **Antigravity Awesome**  | [GitHub](https://github.com/sickn33/antigravity-awesome-skills)                                         | Curated for Antigravity specifically                       |
+| **Awesome Agent Skills** | [GitHub](https://github.com/VoltAgent/awesome-agent-skills)                                             | Cross-platform catalog (works with any AI IDE)             |
+| **Awesome Cursorrules**  | [GitHub](https://github.com/PatrickJS/awesome-cursorrules/tree/main/rules)                              | 100+ stack-specific rules for Cursor                       |
+| **Antigravity Prompts**  | [GitHub](https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools/tree/main/Google/Antigravity) | Reference system prompts                                   |
+
+### Relevant Stack Rules (from awesome-cursorrules)
+
+| Stack                    | Rule Set                                             |
+| ------------------------ | ---------------------------------------------------- |
+| **NestJS + TypeScript**  | `typescript-nestjs-best-practices-cursorrules-promp` |
+| **React Native + Expo**  | `react-native-expo-cursorrules-prompt-file`          |
+| **React + TypeScript**   | `typescript-react-cursorrules-prompt-file`           |
+| **Next.js + TypeScript** | `nextjs-typescript-cursorrules-prompt-file`          |
+| **Code Quality**         | `javascript-typescript-code-quality-cursorrules-pro` |
+| **Jest Testing**         | `jest-unit-testing-cursorrules-prompt-file`          |
+| **Git Commits**          | `git-conventional-commit-messages`                   |
+
+> **Note**: `.cursorrules` format ≠ `SKILL.md` format. To convert:
+>
+> 1. Create folder: `your-skill-name/SKILL.md`
+> 2. Add YAML frontmatter: `name` + `description`
+> 3. Paste cursorrules content as markdown body
+
+## Evaluating Skills
+
+Before installing a skill, check:
+
+- ⭐ Stars/popularity — community validation
+- 📝 Content quality — specific rules vs generic advice
+- 🔧 Stack match — does it match your actual tech stack?
+- 📏 Size — avoid bloated skills (>50 files = likely too much context)
+
+### Strategy: Keep Few, Keep Curated
+
+> Installing 100+ generic skills dilutes AI attention. Better: 5–10 curated skills with project-specific context.
+
+| Category                        | Recommendation                                      |
+| ------------------------------- | --------------------------------------------------- |
+| Super-Coder (SOLID, Clean Code) | Keep 1-2 curated. AI already knows these basics.    |
+| Tech-Stack (NestJS, React, RN)  | ✅ High value if matched to your stack              |
+| QA & Debugging                  | `verification-before-completion` + custom is enough |
+| Documentation                   | `documentation-templates` + Knowledge Router        |
+| UI/UX Design                    | ✅ Useful for FE/mobile/personal projects           |

package/scripts/setup-antigravity.sh

@@ -0,0 +1,130 @@
+#!/bin/bash
+# setup-antigravity.sh — One command to set up everything
+#
+# Usage:
+#   cd <your-project>
+#   ~/Documents/ai-dev-toolkit/scripts/setup-antigravity.sh
+#
+# What it does:
+#   1. Updates global rules → ~/.gemini/GEMINI.md
+#   2. Installs global skills → ~/.agents/skills/ (+ symlink)
+#   3. Installs workflows → <project>/.agent/workflows/
+#   4. Cleans bloated skills + creates cross-IDE symlinks
+
+set -e
+
+TOOLKIT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+AGENTS_SKILLS_DIR="$HOME/.agents/skills"
+ANTIGRAVITY_SKILLS_DIR="$HOME/.gemini/antigravity/skills"
+GEMINI_RULES="$HOME/.gemini/GEMINI.md"
+PROJECT_AGENT_DIR=".agent"
+
+echo "🚀 AI Dev Toolkit — One Command Setup"
+echo "   Toolkit: $TOOLKIT_DIR"
+echo "   Project: $(pwd)"
+echo ""
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# Step 1: Update global rules (GEMINI.md)
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+echo "📝 Step 1: Updating global rules → $GEMINI_RULES"
+
+if [ -f "$TOOLKIT_DIR/user-rules/memory-rules.md" ]; then
+  # Extract the content between ``` blocks
+  RULES_CONTENT=$(sed -n '/^```$/,/^```$/p' "$TOOLKIT_DIR/user-rules/memory-rules.md" | sed '1d;$d')
+
+  if [ -n "$RULES_CONTENT" ]; then
+    # Backup existing rules
+    if [ -f "$GEMINI_RULES" ]; then
+      cp "$GEMINI_RULES" "$GEMINI_RULES.backup"
+      echo "   📋 Backed up existing rules → GEMINI.md.backup"
+    fi
+    # Write new rules
+    echo "$RULES_CONTENT" > "$GEMINI_RULES"
+    echo "   ✅ Global rules updated (Sections I–XI)"
+  else
+    echo "   ⚠️  Could not parse rules from memory-rules.md"
+  fi
+else
+  echo "   ⚠️  user-rules/memory-rules.md not found"
+fi
+
+echo ""
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# Step 2: Install global skills
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+echo "📦 Step 2: Installing global skills"
+mkdir -p "$AGENTS_SKILLS_DIR"
+mkdir -p "$ANTIGRAVITY_SKILLS_DIR"
+
+if [ -d "$TOOLKIT_DIR/skills" ]; then
+  for skill_dir in "$TOOLKIT_DIR/skills"/*/; do
+    skill_name=$(basename "$skill_dir")
+    if [ -f "$skill_dir/SKILL.md" ]; then
+      # Copy to ~/.agents/skills/ (actual location)
+      cp -r "$skill_dir" "$AGENTS_SKILLS_DIR/"
+      # Create symlink in ~/.gemini/antigravity/skills/ (Antigravity reads here)
+      ln -sf "$AGENTS_SKILLS_DIR/$skill_name" "$ANTIGRAVITY_SKILLS_DIR/$skill_name" 2>/dev/null || true
+      echo "   ✅ $skill_name"
+    fi
+  done
+else
+  echo "   ⚠️  No skills/ directory found"
+fi
+
+echo ""
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# Step 3: Install workflows into project
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+echo "📋 Step 3: Installing workflows → $PROJECT_AGENT_DIR/workflows/"
+
+if [ -d ".git" ] || [ -d "$PROJECT_AGENT_DIR" ]; then
+  mkdir -p "$PROJECT_AGENT_DIR/workflows"
+  if [ -d "$TOOLKIT_DIR/workflows" ]; then
+    for wf in "$TOOLKIT_DIR/workflows"/*.md; do
+      wf_name=$(basename "$wf")
+      cp "$wf" "$PROJECT_AGENT_DIR/workflows/"
+      echo "   ✅ $wf_name"
+    done
+  fi
+else
+  echo "   ⚠️  Not in a project directory (no .git or .agent found)"
+  echo "   Run this script from inside your project folder"
+fi
+
+echo ""
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# Step 4: Health check
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+echo "🔍 Step 4: Health check"
+
+# Check bloated skills
+if [ -d "$PROJECT_AGENT_DIR/skills" ]; then
+  SKILL_COUNT=$(find "$PROJECT_AGENT_DIR/skills" -type f | wc -l | tr -d ' ')
+  if [ "$SKILL_COUNT" -gt 50 ]; then
+    echo "   ⚠️  Project has $SKILL_COUNT skill files (too many, AI gets diluted)"
+  else
+    echo "   ✅ Project skills: $SKILL_COUNT files"
+  fi
+fi
+
+# Cross-IDE symlinks
+if [ -d "$PROJECT_AGENT_DIR/skills" ]; then
+  mkdir -p .cursor .claude 2>/dev/null || true
+  ln -sf "../$PROJECT_AGENT_DIR/skills" .cursor/skills 2>/dev/null \
+    && echo "   ✅ .cursor/skills → .agent/skills" || true
+  ln -sf "../$PROJECT_AGENT_DIR/skills" .claude/skills 2>/dev/null \
+    && echo "   ✅ .claude/skills → .agent/skills" || true
+fi
+
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "✅ All done! Summary:"
+echo "   📝 Rules   → ~/.gemini/GEMINI.md (backed up old version)"
+echo "   📦 Skills  → ~/.agents/skills/ (symlinked to Antigravity)"
+echo "   📋 Workflows → .agent/workflows/ (this project)"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""

package/skills/code-review/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: code-review
+description: >
+  Systematic code review checklist for TypeScript/NestJS projects.
+  Covers type safety, architecture compliance, performance, error handling,
+  and DDD pattern verification.
+---
+
+# Code Review Checklist
+
+## How to Use
+
+When reviewing code (your own or others'), go through each section below.
+Flag issues with severity:
+
+- 🔴 **Critical** — Must fix before merge (bugs, security, data loss)
+- 🟡 **Warning** — Should fix (tech debt, performance, maintainability)
+- 🟢 **Suggestion** — Nice to have (readability, consistency)
+
+---
+
+## 1. Type Safety
+
+- [ ] No `any` types anywhere
+- [ ] All exported functions have explicit return types
+- [ ] DTOs use `class-validator` decorators for input validation
+- [ ] No unsafe type assertions (`as X` without prior validation)
+- [ ] Nullable types handled explicitly (`?:` or `| null`)
+- [ ] No implicit `any` from untyped imports
+
+## 2. Architecture Compliance
+
+### For DDD Modules
+
+- [ ] Domain layer has NO imports from Infrastructure or Framework
+- [ ] Aggregates enforce business invariants internally
+- [ ] Use Cases have single `execute()` method
+- [ ] Repository interfaces defined in Domain, implemented in Infrastructure
+- [ ] DTOs only in Presentation layer, domain objects internally
+- [ ] Cross-aggregate references by ID only (not by object)
+
+### For Legacy Modules
+
+- [ ] Service contains business logic (not controller)
+- [ ] Controller is thin — routing + validation only
+- [ ] Entity relationships properly defined
+
+## 3. Error Handling
+
+- [ ] No empty catch blocks (`catch (e) {}`)
+- [ ] Errors have meaningful messages with context
+- [ ] Custom exceptions for domain-specific errors
+- [ ] HTTP exceptions only in Controller/Presentation layer
+- [ ] Async operations have proper error boundaries
+
+## 4. Performance
+
+- [ ] No N+1 queries (check `find` calls in loops)
+- [ ] Queries use appropriate `relations` / `join` when needed
+- [ ] No synchronous heavy operations blocking event loop
+- [ ] Pagination for list endpoints
+- [ ] Indexing for frequently queried fields
+
+## 5. Code Quality
+
+- [ ] Functions < 20 lines, single responsibility
+- [ ] No dead code or unused imports
+- [ ] No TODO/FIXME without linked issue
+- [ ] Naming follows conventions (PascalCase/camelCase/kebab-case)
+- [ ] No magic numbers — use named constants
+- [ ] No duplicated logic — extract to shared utilities
+
+## 6. Testing
+
+- [ ] New public methods have unit tests
+- [ ] Tests follow Arrange-Act-Assert pattern
+- [ ] Test names describe behavior, not implementation
+- [ ] Mocks/stubs for external dependencies
+- [ ] Edge cases covered (null, empty, boundary values)
+
+## 7. Security
+
+- [ ] No secrets or credentials in code
+- [ ] Input validation on all external data
+- [ ] Authorization checks where needed
+- [ ] SQL injection prevention (parameterized queries)
+- [ ] No sensitive data in logs
+
+## 8. Documentation
+
+- [ ] Public APIs have JSDoc comments
+- [ ] Complex business logic explained with comments
+- [ ] Breaking changes documented
+- [ ] README updated if architecture changed

package/skills/ddd-core-rules/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ddd-core-rules
+description: >
+  DDD best practices for any project. Aggregate rules, layer dependencies,
+  tactical patterns (Entity, Value Object, Domain Event, Port/Adapter).
+  Sources: Eric Evans, Martin Fowler, nestjslatam/ddd.
+---
+
+# DDD Core Rules
+
+## Strategic Patterns
+
+- **Ubiquitous Language**: Shared terms between code and domain experts. Name classes, methods, and variables using domain language.
+- **Bounded Context**: Clear boundary where a domain model applies. Do not leak models across contexts.
+- **Context Mapping**: Define relationships between bounded contexts (Shared Kernel, Anti-Corruption Layer, Conformist, etc.)
+
+## Tactical Patterns
+
+### Aggregates
+
+- Transactional consistency boundary with a single root entity
+- Keep aggregates small — prefer fewer entities per aggregate
+- Reference other aggregates by ID, never by direct object reference
+- One transaction per aggregate — never modify multiple aggregates in one transaction
+- Encapsulate business rules within the aggregate root
+
+### Entities
+
+- Identity-based objects with lifecycle
+- Equality determined by ID, not attributes
+- Can change state through defined methods
+
+### Value Objects
+
+- Immutable — always create new instances for changes
+- Equality determined by all attributes, not identity
+- No ID — purely defined by their values
+- Examples: Money, Address, DateRange, Email
+
+### Domain Events
+
+- Communicate changes across aggregates
+- Named in past tense: `OrderPlaced`, `PaymentProcessed`
+- Carry only necessary data, not the entire aggregate
+
+### Ports / Adapters (Hexagonal Architecture)
+
+- Domain defines interfaces (Ports)
+- Infrastructure implements them (Adapters)
+- Domain NEVER depends on infrastructure
+
+## Layer Dependency Rules
+
+```
+Domain ← Application ← Infrastructure ← Presentation
+
+Domain layer MUST NOT import from:
+  - Framework (NestJS, Express, Spring)
+  - ORM (TypeORM, Prisma, Sequelize)
+  - External services (Stripe, AWS, SendGrid)
+
+Application layer:
+  - Orchestrates domain logic via Use Cases / Command Handlers
+  - Each Use Case = single execute() method
+  - Depends on domain interfaces (Ports), never on implementations
+
+Infrastructure layer:
+  - Implements domain Ports (Repository interfaces, Gateway interfaces)
+  - Contains ORM entities, API clients, queue consumers, email services
+  - Handles serialization/deserialization between domain and persistence
+
+Presentation layer:
+  - HTTP controllers, GraphQL resolvers, CLI handlers
+  - Thin — only routing + validation + DTO mapping
+  - Never contains business logic
+```
+
+## Anti-Patterns to Avoid
+
+- ❌ Anemic Domain Model — entities with only getters/setters, no behavior
+- ❌ God Aggregate — aggregate with too many entities and responsibilities
+- ❌ Cross-aggregate transactions — modifying multiple aggregates in one transaction
+- ❌ Domain depending on infrastructure — importing ORM or framework in domain layer
+- ❌ Leaking domain objects to presentation — always use DTOs at boundaries
+
+## References
+
+- Eric Evans, "Domain-Driven Design: Tackling Complexity in the Heart of Software" (Blue Book)
+- Martin Fowler, Patterns of Enterprise Application Architecture
+- [nestjslatam/ddd](https://github.com/nestjslatam/ddd) — NestJS + CQRS + Sagas
+- [Sairyss/domain-driven-hexagon](https://github.com/Sairyss/domain-driven-hexagon) — Reference architecture (3.5k⭐)

package/skills/git-workflow/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: git-workflow
+description: >
+  Git conventions for branch naming, commit messages, PR workflow, and
+  release management. Follows Conventional Commits standard.
+---
+
+# Git Workflow
+
+## Branch Naming
+
+```
+<type>/<ticket-id>-<short-description>
+
+# Examples
+feature/HR-123-add-leave-approval
+fix/HR-456-quota-calculation-error
+refactor/HR-789-extract-pricing-service
+chore/update-dependencies
+```
+
+| Type        | When to use                             |
+| ----------- | --------------------------------------- |
+| `feature/`  | New functionality                       |
+| `fix/`      | Bug fix                                 |
+| `refactor/` | Code restructuring (no behavior change) |
+| `chore/`    | Dependencies, configs, tooling          |
+| `hotfix/`   | Urgent production fix                   |
+
+## Commit Messages (Conventional Commits)
+
+```
+<type>(<scope>): <description>
+
+[optional body]
+
+[optional footer]
+```
+
+### Types
+
+| Type       | Description                         | Example                                       |
+| ---------- | ----------------------------------- | --------------------------------------------- |
+| `feat`     | New feature                         | `feat(leave): add auto-approval for < 3 days` |
+| `fix`      | Bug fix                             | `fix(billing): correct proration calculation` |
+| `refactor` | Restructure without behavior change | `refactor(auth): extract token service`       |
+| `docs`     | Documentation only                  | `docs(api): update endpoint descriptions`     |
+| `test`     | Add or fix tests                    | `test(billing): add proration edge cases`     |
+| `chore`    | Build, tooling, deps                | `chore: upgrade TypeORM to 0.3.20`            |
+| `perf`     | Performance improvement             | `perf(query): add index for leave lookups`    |
+
+### Rules
+
+- Subject line: imperative mood, lowercase, no period, max 72 chars
+- Body: wrap at 72 chars, explain WHY not WHAT
+- Footer: `BREAKING CHANGE:` for breaking changes, `Closes #123` for issues
+
+### Examples
+
+```
+feat(billing): implement interval change with proration
+
+Allow subscription interval change from monthly to yearly.
+Proration calculated proportionally for remaining days.
+
+Closes HR-567
+```
+
+```
+fix(saga): prevent duplicate invoice creation
+
+The AdminOnboardingSaga was creating duplicate invoices when
+the user clicked submit twice rapidly. Added idempotency check
+using metadata key.
+
+Closes HR-890
+```
+
+## PR Workflow
+
+### Before Creating PR
+
+1. Rebase on latest `develop`
+2. Run `npx tsc --noEmit` — zero errors
+3. Run tests — all pass
+4. Self-review the diff
+
+### PR Description Template
+
+```markdown
+## What
+
+Brief description of the change.
+
+## Why
+
+Business context or bug report.
+
+## How
+
+Technical approach taken.
+
+## Testing
+
+- [ ] Unit tests added/updated
+- [ ] Manual testing done
+- [ ] Edge cases covered
+
+## Screenshots (if UI)
+```
+
+### Review Process
+
+1. Author creates PR and assigns reviewers
+2. Reviewer uses code-review SKILL.md checklist
+3. Address feedback — resolve conversations
+4. Squash merge to `develop`
+
+## Release Flow
+
+```
+feature/* → develop → staging → main
+              ↑                   ↓
+           hotfix/* ←────── main (tag)
+```
+
+| Branch    | Purpose             | Deploy to           |
+| --------- | ------------------- | ------------------- |
+| `develop` | Integration branch  | Dev environment     |
+| `staging` | Pre-release testing | Staging environment |
+| `main`    | Production ready    | Production          |

package/skills/typescript-mastery/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: typescript-mastery
+description: >
+  Advanced TypeScript patterns for production codebases. Strict typing, generics,
+  utility types, type guards, discriminated unions, branded types, and common pitfalls.
+---
+
+# TypeScript Mastery
+
+## Core Principles
+
+1. **No `any`** — ever. Use `unknown` + type guards when type is truly unknown.
+2. **Explicit return types** on all exported functions and methods.
+3. **Strict mode** always enabled (`strict: true` in tsconfig).
+
+## Type Design
+
+### Prefer `interface` for Object Shapes
+
+```typescript
+// ✅ Good — extendable, clear intent
+interface UserProfile {
+  readonly id: string;
+  name: string;
+  email: string;
+}
+
+// ✅ Good — `type` for unions and intersections
+type PaymentStatus = "pending" | "completed" | "failed";
+type AdminUser = UserProfile & { role: "admin" };
+```
+
+### Discriminated Unions for State
+
+```typescript
+// ✅ Use discriminated unions — exhaustive checking
+type AsyncState<T> =
+  | { status: "idle" }
+  | { status: "loading" }
+  | { status: "success"; data: T }
+  | { status: "error"; error: Error };
+```
+
+### Branded Types for Domain Safety
+
+```typescript
+type UserId = string & { readonly __brand: 'UserId' };
+type OrderId = string & { readonly __brand: 'OrderId' };
+
+// Prevents accidental swapping of userId and orderId
+function getOrder(userId: UserId, orderId: OrderId): Order { ... }
+```
+
+## Type Guards
+
+```typescript
+// ✅ Custom type guard
+function isUser(value: unknown): value is User {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "id" in value &&
+    "email" in value
+  );
+}
+
+// ✅ Discriminated union guard
+function isSuccess<T>(
+  state: AsyncState<T>,
+): state is { status: "success"; data: T } {
+  return state.status === "success";
+}
+```
+
+## Immutability
+
+```typescript
+// ✅ Readonly for data that shouldn't change
+interface Config {
+  readonly apiUrl: string;
+  readonly timeout: number;
+}
+
+// ✅ as const for literal values
+const ROLES = ['admin', 'user', 'guest'] as const;
+type Role = (typeof ROLES)[number]; // 'admin' | 'user' | 'guest'
+
+// ✅ Readonly arrays and tuples
+function processItems(items: readonly Item[]): void { ... }
+```
+
+## Generics
+
+```typescript
+// ✅ Constrained generics
+function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
+  return obj[key];
+}
+
+// ✅ Generic with default
+interface Repository<T extends BaseEntity = BaseEntity> {
+  findById(id: string): Promise<T | null>;
+  save(entity: T): Promise<T>;
+}
+
+// ✅ Utility type composition
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+```
+
+## Function Patterns
+
+```typescript
+// ✅ RO-RO (Receive Object, Return Object) for 3+ params
+interface CreateUserParams {
+  readonly name: string;
+  readonly email: string;
+  readonly role?: Role;
+}
+
+interface CreateUserResult {
+  readonly user: User;
+  readonly token: string;
+}
+
+function createUser(params: CreateUserParams): CreateUserResult { ... }
+
+// ✅ Overloads for different return types
+function parse(input: string): number;
+function parse(input: string, asArray: true): number[];
+function parse(input: string, asArray?: boolean): number | number[] { ... }
+```
+
+## Common Pitfalls
+
+### ❌ Don't
+
+```typescript
+// ❌ Using `any`
+function process(data: any) { ... }
+
+// ❌ Type assertion without validation
+const user = data as User;
+
+// ❌ Optional chaining without null handling
+const name = user?.profile?.name; // name is string | undefined — handle it
+
+// ❌ Enum (prefer union types or const objects)
+enum Status { Active, Inactive }
+```
+
+### ✅ Do Instead
+
+```typescript
+// ✅ Type guard + unknown
+function process(data: unknown): ProcessedResult {
+  if (!isValidInput(data)) throw new InvalidInputError(data);
+  return transform(data);
+}
+
+// ✅ Runtime validation before assertion
+const user = validateUser(data); // throws if invalid
+
+// ✅ Handle undefined explicitly
+const name = user?.profile?.name ?? "Anonymous";
+
+// ✅ Const object instead of enum
+const Status = { Active: "active", Inactive: "inactive" } as const;
+type Status = (typeof Status)[keyof typeof Status];
+```
+
+## Naming Conventions
+
+| Type                         | Convention                 | Example                                   |
+| ---------------------------- | -------------------------- | ----------------------------------------- |
+| Class / Interface / Type     | PascalCase                 | `UserProfile`, `IRepository`              |
+| Variable / Function / Method | camelCase                  | `getUserById`, `isValid`                  |
+| File / Directory             | kebab-case                 | `user-profile.ts`, `auth-service.ts`      |
+| Constant                     | UPPER_SNAKE_CASE           | `MAX_RETRIES`, `API_URL`                  |
+| Boolean variable             | `is/has/can/should` prefix | `isLoading`, `hasPermission`              |
+| Function                     | verb-first                 | `getUser`, `createOrder`, `validateInput` |

package/user-rules/memory-rules.md

@@ -0,0 +1,115 @@
+# User Rules (MEMORY[user_global])
+
+Copy this entire block into your IDE → Settings → User Rules.
+
+```
+SYSTEM INSTRUCTIONS: ANTIGRAVITY CODING PROTOCOL
+
+I. STRICT MODE: NO AUTO-EDIT (HIGHEST PRIORITY)
+1. PROPOSAL ONLY: When analyzing a problem, NEVER jump to a full solution. ONLY propose the analysis/strategy text first.
+2. STOP & ASK: You are STRICTLY FORBIDDEN from calling tools (editing files) until you explicitly ask: "Shall I apply this?" and receive user Confirmation.
+3. ITERATIVE CLARIFICATION: If the logic is complex (> 1 step) or requirements are vague, DO NOT provide a full plan. Break it down -> Analyze Part 1 -> Ask User -> Analyze Part 2 -> Ask User.
+
+II. RESPONSE PROTOCOL (MANDATORY)
+4. Stop & Analyze:
+   - If the request involves planning, logic, or new features -> STRICTLY NO CODE BLOCKS initially.
+   - Force yourself to identify missing information and Ask 1-2 clarifying questions before proposing a full strategy.
+5. Report First: Every response must start with a "Conceptual Report" in Vietnamese. Includes:
+   - Analysis: Your understanding.
+   - Strategy: Proposed logic/architecture.
+   - Constraints: Types, potential risks.
+   - Question Gate: End with a specific question to clarify ambiguous points OR a request for confirmation to proceed to the next analysis phase.
+6. Formatting: Use a Horizontal Rule ("---") to separate sections. Code must ALWAYS be at the very end, and ONLY after Confirmation.
+
+III. TYPESCRIPT ESSENTIALS (Always Active)
+7. Never use `any`. Use `unknown` + type guards if type is truly unknown.
+8. Always declare return types for functions and methods.
+9. Prefer `interface` for object shapes, `type` for unions/intersections.
+10. Use `readonly` for data that should not change after creation.
+11. Naming: PascalCase for classes/interfaces/types, camelCase for variables/methods, kebab-case for files.
+12. Functions: single purpose, <20 lines, verb-first naming (getUser, createOrder, isValid).
+13. Use Receive-Object-Return-Object (RO-RO) pattern for 3+ parameters.
+14. DTOs: validate inputs with class-validator. Declare simple types for outputs.
+15. Prefer composition over inheritance. Follow SOLID principles.
+16. Use `as const` for literals, `readonly` arrays/tuples where applicable.
+
+IV. PROJECT AWARENESS
+17. Existing Context: Adapt to existing styles.
+18. Language Rule: Vietnamese for Reports, English for Technical.
+
+V. WORKFLOW ORCHESTRATION
+19. Plan Mode Default:
+    - Enter plan mode for ANY non-trivial task (3+ steps or architectural decisions)
+    - If something goes sideways, STOP and re-plan immediately — don't keep pushing
+    - Use plan mode for verification steps, not just building
+    - Write detailed specs upfront to reduce ambiguity
+20. Self-Improvement Loop:
+    - After ANY correction from the user: update `tasks/lessons.md` with the pattern
+    - Write rules for yourself that prevent the same mistake
+    - Review lessons at session start for relevant project
+21. Demand Elegance (Balanced):
+    - For non-trivial changes: pause and ask "is there a more elegant way?"
+    - If a fix feels hacky: "Knowing everything I know now, implement the elegant solution"
+    - Skip this for simple, obvious fixes — don't over-engineer
+    - Challenge your own work before presenting it
+22. Autonomous Bug Fixing:
+    - When given a bug report: just fix it. Don't ask for hand-holding
+    - Point at logs, errors, failing tests — then resolve them
+    - Zero context switching required from the user
+
+VI. TASK MANAGEMENT
+23. Plan First: Write plan to `tasks/todo.md` with checkable items
+24. Verify Plan: Check in before starting implementation
+25. Track Progress: Mark items complete as you go
+26. Document Results: Add review section to `tasks/todo.md`
+27. Capture Lessons: Update `tasks/lessons.md` after corrections
+    - `tasks/lessons.md` = AI session notes (temporary, self-improvement)
+    - `docs/<module>/decisions/` = permanent team knowledge (committed to git)
+
+VII. CORE PRINCIPLES
+28. Simplicity First: Make every change as simple as possible. Impact minimal code.
+29. No Laziness: Find root causes. No temporary fixes. Senior developer standards.
+30. Minimal Impact: Changes should only touch what's necessary. Avoid introducing bugs.
+
+VIII. CONTEXT-AWARE CODING
+31. Always read project-context SKILL.md FIRST when starting work
+32. Auto-detect module pattern (DDD vs Legacy) before writing code
+33. Proactively flag: N+1 queries, missing types, circular deps
+34. When planning in DDD modules, always identify the layer sequence:
+    Domain (Aggregate/Port) → Application (UseCase/Saga) → Infra → Presentation
+
+IX. KNOWLEDGE ROUTING (Self-Organizing)
+35. After every task, evaluate: "Is there knowledge worth preserving?"
+36. Classify → Route → Confirm with user before saving
+37. Target locations:
+    - Business decisions → docs/<module>/decisions/
+    - Patterns/conventions → project-context SKILL.md
+    - Repeatable processes → .agent/workflows/
+    - Lessons learned → docs/<module>/decisions/
+38. After corrections, update docs with the lesson learned
+
+X. VERIFICATION BEFORE DONE (MANDATORY)
+39. Before declaring ANY task complete, you MUST:
+    a. Re-read the original plan/checklist
+    b. Confirm EACH item is actually implemented (not just "addressed")
+    c. Run `npx tsc --noEmit` for TypeScript projects and fix ALL errors
+    d. If ANY lint/type error remains, fix it BEFORE reporting done
+40. If implementation is partial, EXPLICITLY state:
+    - ✅ What IS done (with file list)
+    - ❌ What is NOT done yet (with reasons)
+    - NEVER say "done" or "complete" when items remain
+41. After code changes, always verify:
+    - File compiles without errors
+    - Imports are correct and used
+    - Types match interfaces
+    - No placeholder or TODO left behind
+
+XI. LANGUAGE RULE (STRICT)
+42. User may prompt in Vietnamese, but ALL output MUST be English:
+    - Code, variable names, function names
+    - Code comments
+    - Documentation files (docs/, README.md)
+    - SKILL.md files, workflow files
+    - Commit messages
+    - NEVER write Vietnamese in project files, even if user prompts in Vietnamese
+```

package/workflows/debug.md

@@ -0,0 +1,12 @@
+---
+description: Step-by-step debugging methodology. Trace data flow through layers.
+---
+
+1. Read project-context SKILL.md
+2. Reproduce: Understand the exact error/symptom
+3. Hypothesize: Form 2-3 likely root causes
+4. Investigate: Check logs, trace data flow
+5. For DDD: Trace Use Case → Service → Port → Gateway
+6. For Legacy: Trace Controller → Service → Repository
+7. Fix: Propose minimal fix
+8. Verify: Suggest how to verify the fix works

package/workflows/plan.md

@@ -0,0 +1,14 @@
+---
+description: Structured planning for any feature or bugfix. Auto-detects module pattern.
+---
+
+// turbo-all
+
+1. Read the project-context SKILL.md first
+2. Identify which module(s) are affected
+3. Detect module pattern (DDD vs Legacy)
+4. Create a plan in `tasks/todo.md` with checkable items
+5. For DDD modules, identify: Aggregate → Use Case → Port → Gateway
+6. For Legacy modules, identify: Controller → Service → Entity
+7. List files to create/modify
+8. Ask user to confirm plan before proceeding

package/workflows/review.md

@@ -0,0 +1,12 @@
+---
+description: Systematic code review checklist. Checks patterns, types, errors, performance.
+---
+
+1. Read project-context SKILL.md
+2. Check: Does the code follow the correct module pattern?
+3. Check: Type safety (no `any`, proper interfaces)
+4. Check: Error handling (no silent catches)
+5. Check: N+1 queries (missing relations/joins)
+6. Check: Missing test coverage
+7. Check: Unused imports and dead code
+8. Present findings as a checklist with severity levels

package/workflows/verify.md

@@ -0,0 +1,15 @@
+---
+description: Verification checklist before declaring any task complete. Evidence-based completion.
+---
+
+1. Re-read the original plan/checklist
+2. For EACH checklist item, verify it is actually implemented:
+   - Open the file and confirm the change exists
+   - Not just "addressed" — actually working
+3. Run type check: `npx tsc --noEmit`
+4. Fix any type/lint errors found
+5. Report explicitly:
+   - ✅ Done items (with file paths)
+   - ❌ Remaining items (with reasons)
+   - ⚠️ Blocked items (needs user input)
+6. Only declare "done" when ALL items are ✅