@leejungkiin/awkit 1.1.1 → 1.1.3

package/bin/awk.js

@@ -28,17 +28,75 @@ const path = require('path');
 const https = require('https');
 const { execSync, spawnSync } = require('child_process');
 
-// ─── Constants ────────────────────────────────────────────────────────────────
-
 const AWK_VERSION = fs.readFileSync(path.join(__dirname, '..', 'VERSION'), 'utf8').trim();
 const AWK_ROOT = path.join(__dirname, '..');
 const HOME = process.env.HOME || process.env.USERPROFILE;
 
+const { generateClineRules, generateClineWorkflows, generateClineSkills } = require('./cline-generators');
+const { generateCodexAgentsMd, generateCodexSkills, generateCodexAgents } = require('./codex-generators');
+
+// ─── Platform Definitions ──────────────────────────────────────────────────
+
+const PLATFORMS = {
+    antigravity: {
+        name: 'Antigravity (Gemini Code Assist)',
+        globalRoot: path.join(HOME, '.gemini', 'antigravity'),
+        rulesFile: path.join(HOME, '.gemini', 'GEMINI.md'),
+        versionFile: path.join(HOME, '.gemini', 'awk_version'),
+        dirs: {
+            workflows: 'global_workflows',
+            skills: 'skills',
+            schemas: 'schemas',
+            templates: 'templates',
+        },
+        supportsCustomModes: false,
+        supportsSubagents: false,
+    },
+    cline: {
+        name: 'Cline (VS Code)',
+        globalRoot: process.cwd(), // Local to project
+        rulesFile: path.join(HOME, '.cline', 'rules', 'antigravity-rules.md'),
+        versionFile: path.join(HOME, '.cline', 'awk_version'),
+        dirs: {
+            workflows: '.clinerules',
+            skills: '.clinerules/skills',
+        },
+    },
+    codex: {
+        name: 'Codex (OpenAI)',
+        globalRoot: path.join(HOME, '.codex'),
+        rulesFile: path.join(HOME, '.codex', 'AGENTS.md'),
+        versionFile: path.join(HOME, '.codex', 'awk_version'),
+        dirs: {
+            agents: 'agents',
+            skills: '../.agents/skills',
+        },
+    }
+};
+
+const PLATFORM_FILE = path.join(HOME, '.awkit_platform');
+
+/**
+ * Get the currently configured platform.
+ * Reads from ~/.awkit_platform, defaults to 'antigravity'.
+ */
+function getActivePlatform() {
+    return 'antigravity';
+}
+
+function savePlatform(platform) {
+    fs.writeFileSync(PLATFORM_FILE, platform, 'utf8');
+}
+
+// Active platform — resolved at install time or from saved config
+let activePlatform = 'antigravity';
+
+// Legacy compat: TARGETS object derived from active platform
 const TARGETS = {
-    antigravity: path.join(HOME, '.gemini', 'antigravity'),
-    geminiMd: path.join(HOME, '.gemini', 'GEMINI.md'),
-    versionFile: path.join(HOME, '.gemini', 'awk_version'),
-    agentsDir: null, // Set per-project
+    get antigravity() { return PLATFORMS[activePlatform].globalRoot; },
+    get geminiMd() { return PLATFORMS[activePlatform].rulesFile || path.join(HOME, '.gemini', 'GEMINI.md'); },
+    get versionFile() { return PLATFORMS[activePlatform].versionFile; },
+    agentsDir: null,
 };
 
 // Mapping: source dir in package → target dir in antigravity
@@ -87,6 +145,22 @@ function promptYN(question) {
     }
 }
 
+/**
+ * Prompt user for a choice, returning the raw answer string.
+ * Returns defaultVal if user presses Enter without input.
+ */
+function promptChoice(question, defaultVal = '') {
+    try {
+        const answer = execSync(
+            `bash -c 'read -p "${question} (default: ${defaultVal}): " ans; echo $ans'`,
+            { stdio: ['inherit', 'pipe', 'inherit'] }
+        ).toString().trim();
+        return answer || defaultVal;
+    } catch (e) {
+        return defaultVal;
+    }
+}
+
 // ─── Utility Functions ──────────────────────────────────────────────────────
 
 /**
@@ -238,24 +312,38 @@ function installSymphony({ silent = false } = {}) {
     }
 }
 
-function cmdInstall() {
+function cmdInstall(platformArg) {
     log('');
     log(`${C.cyan}${C.bold}╔══════════════════════════════════════════════════════════╗${C.reset}`);
     log(`${C.cyan}${C.bold}║     🚀 AWK v${AWK_VERSION} — Antigravity Workflow Kit        ║${C.reset}`);
     log(`${C.cyan}${C.bold}╚══════════════════════════════════════════════════════════╝${C.reset}`);
     log('');
 
-    const target = TARGETS.antigravity;
+    // Platform selection
+    let platform = platformArg || getActivePlatform();
+
+    if (!PLATFORMS[platform]) {
+        err(`Unknown platform: ${platform}.`);
+        return;
+    }
+
+    activePlatform = platform;
+    savePlatform(platform);
 
-    // 0. Install Symphony if missing
+    const plat = PLATFORMS[platform];
+    const target = plat.globalRoot;
+
+    info(`Installing for ${C.bold}${plat.name}${C.reset}...`);
     log('');
+
+    // 0. Install Symphony if missing (shared dependency)
     info('Checking dependencies...');
     installSymphony();
 
     // 1. Ensure target dirs exist
     info('Creating directories...');
-    const dirs = ['global_workflows', 'skills', 'schemas', 'templates'];
-    for (const dir of dirs) {
+    const dirKeys = Object.values(plat.dirs);
+    for (const dir of dirKeys) {
         const fullPath = path.join(target, dir);
         if (!fs.existsSync(fullPath)) {
             fs.mkdirSync(fullPath, { recursive: true });
@@ -263,72 +351,104 @@ function cmdInstall() {
     }
     ok('Directories ready');
 
-    // 2. Sync GEMINI.md
-    info('Syncing GEMINI.md...');
-    syncGeminiMd();
-
-    // 3. Backup and flatten workflows
-    info('Installing workflows...');
-    const wfSrc = path.join(AWK_ROOT, 'workflows');
-    const wfDest = path.join(target, 'global_workflows');
-
-    // Backup existing global_workflows to a zip file
-    if (fs.existsSync(wfDest)) {
-        const backupDir = path.join(target, 'backup');
-        if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true });
+    // 2. Sync rules (platform-specific)
+    if (platform === 'antigravity') {
+        info('Syncing GEMINI.md...');
+        syncGeminiMd();
+    } else if (platform === 'cline') {
+        info('Generating Cline global rules...');
+        generateClineRules(path.join(AWK_ROOT, 'core', 'GEMINI.md'), plat.rulesFile);
+    } else if (platform === 'codex') {
+        info('Generating Codex AGENTS.md...');
+        generateCodexAgentsMd(path.join(AWK_ROOT, 'core', 'GEMINI.md'), plat.rulesFile);
+    }
+
+    // 3. Backup and install workflows
+    if (plat.dirs.workflows) {
+        info('Installing workflows...');
+        const wfSrc = path.join(AWK_ROOT, 'workflows');
+        const wfDest = path.join(target, plat.dirs.workflows);
+
+        // Backup existing workflows
+        if (fs.existsSync(wfDest)) {
+            const backupDir = path.join(target, 'backup');
+            if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true });
+
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const zipFile = path.join(backupDir, `workflows_${timestamp}.bak.zip`);
+            try {
+                execSync(`zip -r "${zipFile}" .`, { cwd: wfDest, stdio: 'ignore' });
+                dim(`Backup: ${zipFile}`);
+            } catch (e) {
+                warn(`Failed to create backup: ${e.message}`);
+            }
+        }
 
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        const zipFile = path.join(backupDir, `global_workflows_${timestamp}.bak.zip`);
-        try {
-            info('Creating zip backup of global_workflows...');
-            execSync(`zip -r "${zipFile}" .`, { cwd: wfDest, stdio: 'ignore' });
-            ok(`Backup created: ${zipFile}`);
-        } catch (e) {
-            warn(`Failed to create backup zip: ${e.message}`);
+        if (platform === 'cline') {
+            generateClineWorkflows(wfSrc, wfDest);
+        } else if (platform !== 'codex') {
+            const wfCount = flattenWorkflows(wfSrc, wfDest);
+            ok(`${wfCount} workflows installed`);
         }
     }
 
-    const wfCount = flattenWorkflows(wfSrc, wfDest);
-    ok(`${wfCount} workflows installed`);
-
     // 4. Copy AGENTS.md
-    const agentsSrc = path.join(AWK_ROOT, 'core', 'AGENTS.md');
-    const agentsDest = path.join(target, 'global_workflows', 'AGENTS.md');
-    if (fs.existsSync(agentsSrc)) {
-        fs.copyFileSync(agentsSrc, agentsDest);
-        ok('AGENTS.md installed');
+    if (platform === 'antigravity' && plat.dirs.workflows) {
+        const agentsSrc = path.join(AWK_ROOT, 'core', 'AGENTS.md');
+        const agentsDest = path.join(target, plat.dirs.workflows, 'AGENTS.md');
+        if (fs.existsSync(agentsSrc)) {
+            fs.copyFileSync(agentsSrc, agentsDest);
+            ok('AGENTS.md installed');
+        }
     }
 
     // 5. Copy skills
-    info('Installing skills...');
-    const skillsSrc = path.join(AWK_ROOT, 'skills');
-    const skillsDest = path.join(target, 'skills');
-    const skillCount = copyDirRecursive(skillsSrc, skillsDest);
-    ok(`${skillCount} skill files installed`);
+    if (plat.dirs.skills) {
+        info('Installing skills...');
+        const skillsSrc = path.join(AWK_ROOT, 'skills');
+        const skillsDest = path.join(target, plat.dirs.skills);
+
+        if (platform === 'cline') {
+            generateClineSkills(skillsSrc, skillsDest);
+        } else if (platform === 'codex') {
+            generateCodexSkills(skillsSrc, skillsDest);
+            const agentsDest = path.join(target, plat.dirs.agents);
+            generateCodexAgents(skillsSrc, agentsDest);
+        } else {
+            const skillCount = copyDirRecursive(skillsSrc, skillsDest);
+            ok(`${skillCount} skill files installed`);
+        }
+    }
 
     // 6. Copy orchestrator
-    const orchSrc = path.join(AWK_ROOT, 'core', 'orchestrator.md');
-    const orchDestDir = path.join(target, 'skills', 'orchestrator');
-    if (!fs.existsSync(orchDestDir)) fs.mkdirSync(orchDestDir, { recursive: true });
-    fs.copyFileSync(orchSrc, path.join(orchDestDir, 'SKILL.md'));
-    ok('Orchestrator skill installed');
+    if (platform === 'antigravity') {
+        const orchSrc = path.join(AWK_ROOT, 'core', 'orchestrator.md');
+        const orchDestDir = path.join(target, plat.dirs.skills, 'orchestrator');
+        if (!fs.existsSync(orchDestDir)) fs.mkdirSync(orchDestDir, { recursive: true });
+        fs.copyFileSync(orchSrc, path.join(orchDestDir, 'SKILL.md'));
+        ok('Orchestrator skill installed');
+    }
 
     // 7. Copy schemas (always overwrite)
-    info('Installing schemas...');
-    const schemaSrc = path.join(AWK_ROOT, 'schemas');
-    const schemaDest = path.join(target, 'schemas');
-    const schemaCount = copyDirRecursive(schemaSrc, schemaDest);
-    ok(`${schemaCount} schemas installed`);
+    if (plat.dirs.schemas) {
+        info('Installing schemas...');
+        const schemaSrc = path.join(AWK_ROOT, 'schemas');
+        const schemaDest = path.join(target, plat.dirs.schemas);
+        const schemaCount = copyDirRecursive(schemaSrc, schemaDest);
+        ok(`${schemaCount} schemas installed`);
+    }
 
     // 8. Copy templates (don't overwrite existing)
-    info('Installing templates...');
-    const tmplSrc = path.join(AWK_ROOT, 'templates');
-    const tmplDest = path.join(target, 'templates');
-    const tmplCount = copyDirRecursive(tmplSrc, tmplDest, { overwrite: false });
-    ok(`${tmplCount} templates installed`);
+    if (plat.dirs.templates) {
+        info('Installing templates...');
+        const tmplSrc = path.join(AWK_ROOT, 'templates');
+        const tmplDest = path.join(target, plat.dirs.templates);
+        const tmplCount = copyDirRecursive(tmplSrc, tmplDest, { overwrite: false });
+        ok(`${tmplCount} templates installed`);
+    }
 
     // 9. Save version
-    fs.writeFileSync(TARGETS.versionFile, AWK_VERSION);
+    fs.writeFileSync(plat.versionFile, AWK_VERSION);
     ok(`Version ${AWK_VERSION} saved`);
 
     // 10. Install default skill packs
@@ -337,21 +457,34 @@ function cmdInstall() {
     // 11. Summary
     log('');
     log(`${C.gray}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
-    log(`${C.yellow}${C.bold}🎉 AWK v${AWK_VERSION} installed successfully!${C.reset}`);
+    log(`${C.yellow}${C.bold}🎉 AWK v${AWK_VERSION} installed for ${plat.name}!${C.reset}`);
     log('');
-    dim(`Workflows:  ${path.join(target, 'global_workflows')}`);
-    dim(`Skills:     ${path.join(target, 'skills')}`);
-    dim(`Schemas:    ${path.join(target, 'schemas')}`);
-    dim(`Templates:  ${path.join(target, 'templates')}`);
-    dim(`GEMINI.md:  ${TARGETS.geminiMd}`);
+    dim(`Platform:   ${plat.name}`);
+    if (plat.dirs.workflows) dim(`Workflows:  ${path.join(target, plat.dirs.workflows)}`);
+    if (plat.dirs.skills) dim(`Skills:     ${path.join(target, plat.dirs.skills)}`);
+    if (plat.dirs.schemas) dim(`Schemas:    ${path.join(target, plat.dirs.schemas)}`);
+    if (plat.dirs.templates) dim(`Templates:  ${path.join(target, plat.dirs.templates)}`);
+    if (plat.dirs.agents) dim(`Agents:     ${path.join(target, plat.dirs.agents)}`);
+
+    if (plat.rulesFile) {
+        dim(`Global Rules: ${plat.rulesFile}`);
+    }
     if (defaultPacks.length > 0) {
         dim(`Packs:      ${defaultPacks.join(', ')} (auto-enabled)`);
     }
-    const bdVer = (() => { try { return execSync('bd --version', { encoding: 'utf8' }).trim().split('\n')[0]; } catch (_) { return 'installed'; } })();
-    dim(`Symphony:     task tracking ready`);
+    if (platform === 'antigravity') {
+        dim(`Symphony:   task tracking ready`);
+    }
     log('');
-    log(`${C.cyan}👉 Type '/plan' in your AI chat to get started.${C.reset}`);
-    log(`${C.cyan}👉 Run 'awkit init' in any project to initialize it.${C.reset}`);
+
+    if (platform === 'antigravity') {
+        log(`${C.cyan}👉 Type '/plan' in your AI chat to get started.${C.reset}`);
+        log(`${C.cyan}👉 Run 'awkit init' in any project to initialize it.${C.reset}`);
+    } else if (platform === 'cline') {
+        log(`${C.cyan}👉 Type '/plan' in Cline chat to get started.${C.reset}`);
+    } else if (platform === 'codex') {
+        log(`${C.cyan}👉 Type '$skill' in Codex to invoke skills.${C.reset}`);
+    }
     log(`${C.cyan}👉 Run 'awkit doctor' to verify installation.${C.reset}`);
     log('');
 }
@@ -1962,7 +2095,17 @@ switch (command) {
         cmdInit(args.includes('--force'));
         break;
     case 'install':
-        cmdInstall();
+        // Parse platform from either first arg or --platform flag
+        {
+            const pIdx = args.indexOf('--platform');
+            let platformArg = null;
+            if (pIdx !== -1 && args[pIdx + 1]) {
+                platformArg = args[pIdx + 1];
+            } else if (args[0] && !args[0].startsWith('-')) {
+                platformArg = args[0];
+            }
+            cmdInstall(platformArg);
+        }
         break;
     case 'uninstall':
         cmdUninstall();

package/bin/cline-generators.js

@@ -0,0 +1,73 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Generates Cline global rules from GEMINI.md
+ * @param {string} sourcePath Path to core/GEMINI.md
+ * @param {string} destPath Destination path (e.g. ~/.cline/rules/antigravity.md)
+ */
+function generateClineRules(sourcePath, destPath) {
+    if (!fs.existsSync(sourcePath)) return;
+
+    let content = fs.readFileSync(sourcePath, 'utf8');
+    const preamble = `
+# Antigravity Rules for Cline
+
+${content}
+`;
+
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.writeFileSync(destPath, preamble.trim() + '\n');
+    console.log(`✅ Cline global rules generated at: ${destPath}`);
+}
+
+/**
+ * Copies workflow markdown files to the given directory.
+ */
+function generateClineWorkflows(srcDir, destDir) {
+    if (!fs.existsSync(srcDir)) return;
+
+    fs.mkdirSync(destDir, { recursive: true });
+    const items = fs.readdirSync(srcDir);
+
+    let count = 0;
+    for (const item of items) {
+        if (!item.endsWith('.md')) continue;
+        const srcPath = path.join(srcDir, item);
+        const destPath = path.join(destDir, item);
+        fs.copyFileSync(srcPath, destPath);
+        count++;
+    }
+    console.log(`✅ Copied ${count} workflows to ${destDir}`);
+}
+
+/**
+ * Copies SKILL.md from each skill directory to the given directory.
+ */
+function generateClineSkills(srcDir, destDir) {
+    if (!fs.existsSync(srcDir)) return;
+
+    fs.mkdirSync(destDir, { recursive: true });
+    const skills = fs.readdirSync(srcDir);
+
+    let count = 0;
+    for (const skill of skills) {
+        const skillDir = path.join(srcDir, skill);
+        if (!fs.statSync(skillDir).isDirectory()) continue;
+
+        const skillFile = path.join(skillDir, 'SKILL.md');
+        if (fs.existsSync(skillFile)) {
+            // Copy SKILL.md as <skillname>.md
+            const destPath = path.join(destDir, `${skill}.md`);
+            fs.copyFileSync(skillFile, destPath);
+            count++;
+        }
+    }
+    console.log(`✅ Copied ${count} skills to ${destDir}`);
+}
+
+module.exports = {
+    generateClineRules,
+    generateClineWorkflows,
+    generateClineSkills
+};

package/bin/codex-generators.js

@@ -0,0 +1,108 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Generates Codex global agents.md from GEMINI.md
+ * @param {string} sourcePath Path to core/GEMINI.md
+ * @param {string} destPath Destination path (e.g. ~/.codex/AGENTS.md)
+ */
+function generateCodexAgentsMd(sourcePath, destPath) {
+    if (!fs.existsSync(sourcePath)) return;
+
+    let content = fs.readFileSync(sourcePath, 'utf8');
+
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.writeFileSync(destPath, content.trim() + '\n');
+    console.log(`✅ Codex AGENTS.md generated at: ${destPath}`);
+}
+
+/**
+ * Generates Codex skills directory structure.
+ * Copies SKILL.md and parses it.
+ */
+function generateCodexSkills(srcDir, destDir) {
+    if (!fs.existsSync(srcDir)) return;
+
+    fs.mkdirSync(destDir, { recursive: true });
+    const skills = fs.readdirSync(srcDir);
+
+    let count = 0;
+    for (const skill of skills) {
+        const skillDir = path.join(srcDir, skill);
+        if (!fs.statSync(skillDir).isDirectory()) continue;
+
+        const skillFile = path.join(skillDir, 'SKILL.md');
+        if (fs.existsSync(skillFile)) {
+            const destSkillDir = path.join(destDir, skill);
+            fs.mkdirSync(destSkillDir, { recursive: true });
+
+            const destPath = path.join(destSkillDir, 'SKILL.md');
+
+            let content = fs.readFileSync(skillFile, 'utf8');
+
+            if (content.startsWith('---\n')) {
+                if (!content.match(/^name:/m)) {
+                    content = content.replace('---\n', `---\nname: ${skill}\n`);
+                }
+            } else {
+                const preamble = `---\nname: ${skill}\ndescription: Antigravity skill ${skill}\n---\n`;
+                content = preamble + content;
+            }
+
+            fs.writeFileSync(destPath, content);
+            count++;
+        }
+    }
+    console.log(`✅ Generated ${count} Codex skills in ${destDir}`);
+}
+
+/**
+ * Generates Codex custom agents (.toml) for specific skills.
+ */
+function generateCodexAgents(srcDir, destDir) {
+    if (!fs.existsSync(srcDir)) return;
+
+    fs.mkdirSync(destDir, { recursive: true });
+    const skills = fs.readdirSync(srcDir);
+
+    const SPECIALIST_SKILLS = [
+        'ios-engineer',
+        'smali-to-kotlin',
+        'smali-to-swift',
+        'problem-solving-pro',
+        'swiftui-pro',
+        'android-re-analyzer',
+        'brainstorm-agent'
+    ];
+
+    let count = 0;
+    for (const skill of skills) {
+        if (!SPECIALIST_SKILLS.includes(skill)) continue;
+
+        const skillDir = path.join(srcDir, skill);
+        if (!fs.statSync(skillDir).isDirectory()) continue;
+
+        const skillFile = path.join(skillDir, 'SKILL.md');
+        if (fs.existsSync(skillFile)) {
+            const content = fs.readFileSync(skillFile, 'utf8');
+
+            const tomlContent = `name = "${skill}"
+description = "Antigravity specialist ${skill}"
+developer_instructions = """
+${content.replace(/"""/g, '\\"\\"\\"')}
+"""
+`;
+
+            const destPath = path.join(destDir, `${skill}.toml`);
+            fs.writeFileSync(destPath, tomlContent);
+            count++;
+        }
+    }
+    console.log(`✅ Generated ${count} Codex custom agents in ${destDir}`);
+}
+
+module.exports = {
+    generateCodexAgentsMd,
+    generateCodexSkills,
+    generateCodexAgents
+};

package/core/GEMINI.md

@@ -1,6 +1,6 @@
-# GEMINI.md — Antigravity v10.0
+# GEMINI.md — Antigravity v11.0
 
-> Rules + routing only. Gate details → skills. Updated: 2026-03-10
+> Rules + routing only. Gate details → skills. Updated: 2026-03-18
 
 ---
 
@@ -8,7 +8,6 @@
 
 - Bạn là **Antigravity Orchestrator**.
 - Pragmatic. Regression-averse. Symphony-first. Multi-project.
-- Luôn khai báo mô hình trước mỗi câu trả lời
 
 ---
 
@@ -33,8 +32,9 @@ Mỗi skill tự xử lý gate logic riêng — xem SKILL.md của từng skill.
 
 ### Exit Protocol
 
-- Task done → `nm-memory-sync` auto-save (W1–W4 triggers).
-- Brainstorm/analysis artifact tạo → auto POST metadata vào Symphony Notes (W7 trigger).
+- Task done → auto-complete Symphony → **BẮT BUỘC** `symphony next` + present gợi ý.
+- Kết thúc message → **LUÔN** kèm "Next steps" section.
+- `nm-memory-sync` auto-save (W1–W4 triggers).
 - Deploy/push → kiểm tra in-progress tasks trước, confirm với user.
 
 ---
@@ -50,6 +50,11 @@ Mỗi skill tự xử lý gate logic riêng — xem SKILL.md của từng skill.
 - AI models: Gemini 2.5+ only.
 - Firebase: Firebase AI Logic SDK.
 
+### Spec-First (NEW v11.0)
+- PLANNING mode PHẢI đọc `docs/specs/` **trước** khi viết `implementation_plan.md`.
+- Mỗi task trong plan NÊN có format XML `<task>` (xem `templates/specs/task-spec-template.xml`).
+- `implementation_plan.md` PHẢI reference `TECH-SPEC.md` constraints khi relevant.
+
 ### NeuralMemory
 - Brain = projectId. Switch trước mọi nmem call.
 - Mọi `nmem_remember()` PHẢI tag projectId.
@@ -62,16 +67,8 @@ Mỗi skill tự xử lý gate logic riêng — xem SKILL.md của từng skill.
 - Kết thúc task: Tóm tắt + Test + Next steps.
 - Không rõ: Hỏi lại, tối đa 2 lần.
 
-### Project Context (CODEBASE Gate)
-
-> [!CAUTION]
-> TRƯỚC KHI dùng `grep_search` / `codebase_search` / `list_dir` → **PHẢI đọc CODEBASE.md** của project đó.
-> Bỏ qua = vi phạm. KHÔNG CÓ NGOẠI LỆ.
-
-- **Quy trình bắt buộc:** Đọc CODEBASE.md → xác định file/layer target → search cụ thể.
-- **KHÔNG search "mù"** (search mà chưa biết project structure).
-- CODEBASE.md là **bản đồ project** — dạng compact (path + purpose). Đọc nhanh, tốn ít context.
-- KHÔNG scan raw directory (`list_dir`, `find_by_name`) nếu đã có CODEBASE.md.
+### Project Context
+- CODEBASE.md tồn tại → KHÔNG scan raw directory.
 - KHÔNG hỏi user về project structure.
 - CODEBASE.md outdated → ghi chú "⚠️ dùng /codebase-sync".
 
@@ -88,9 +85,9 @@ Mỗi skill tự xử lý gate logic riêng — xem SKILL.md của từng skill.
 
 ## Routing
 
-- **Execution order:** `symphony-orchestrator` → `awf-session-restore` → `nm-memory-sync` → `orchestrator` → action
+- **Execution order:** `symphony-orchestrator` → `awf-session-restore` → `nm-memory-sync` → `symphony-enforcer` → `orchestrator` → action
 - **Skill catalog:** xem `orchestrator/SKILL.md`
-- **Workflows:** 75+ (`/xxx`). Core: `/plan` `/code` `/debug` `/recap` `/next` `/todo`
+- **Workflows:** 75+ (`/xxx`). Core: `/init` `/code` `/debug` `/recap` `/next` `/todo`
 - **Shortcuts:** `/todo` `/done` `/next`
 
 ---

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@leejungkiin/awkit",
-  "version": "1.1.1",
-  "description": "AWKit v1.0.9 — Antigravity Workflow Kit. Unified AI agent orchestration system.",
+  "version": "1.1.3",
+  "description": "Antigravity Workflow Kit. Unified AI agent orchestration system.",
   "main": "bin/awk.js",
   "bin": {
     "awkit": "bin/awk.js",