@leejungkiin/awkit 1.4.3 → 1.5.1

package/bin/awk.js

@@ -5,7 +5,8 @@
  * Unified installer, updater, and manager for AI agent workflows.
  * 
  * Usage:
- *   awkit install        Install AWK into ~/.gemini/antigravity/
+ *   awkit install        Install AWK into the active platform runtime
+ *   awkit install --all  Install AWK into every supported platform
  *   awkit uninstall      Remove AWK from system
  *   awkit update         Update to latest version
  *   awkit init           Init a new mobile project with Firebase setup
@@ -122,6 +123,9 @@ const SYNC_MAP = {
     'templates': 'templates',
 };
 
+const SKILL_RUNTIME_MANIFEST = path.join(AWK_ROOT, 'core', 'skill-runtime-manifest.json');
+const INSTALL_STATE_FILENAME = '.awkit-install-state.json';
+
 // ─── Colors ──────────────────────────────────────────────────────────────────
 
 const C = {
@@ -175,6 +179,156 @@ function promptChoice(question, defaultVal = '') {
 
 // ─── Utility Functions ──────────────────────────────────────────────────────
 
+function readJsonFile(filePath, fallback = null) {
+    if (!fs.existsSync(filePath)) return fallback;
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch (_) {
+        return fallback;
+    }
+}
+
+function listSkillDirs(rootDir) {
+    if (!fs.existsSync(rootDir)) return [];
+    return fs.readdirSync(rootDir, { withFileTypes: true })
+        .filter(d => d.isDirectory() && fs.existsSync(path.join(rootDir, d.name, 'SKILL.md')))
+        .map(d => d.name)
+        .sort();
+}
+
+function loadSkillRuntimeManifest() {
+    const manifest = readJsonFile(SKILL_RUNTIME_MANIFEST);
+    if (!manifest?.profiles || !manifest.defaultProfile || !manifest.profiles[manifest.defaultProfile]) {
+        throw new Error(`Invalid skill runtime manifest: ${SKILL_RUNTIME_MANIFEST}`);
+    }
+    return manifest;
+}
+
+function getDefaultSkillProfileName() {
+    return loadSkillRuntimeManifest().defaultProfile;
+}
+
+function getDefaultRuntimeSkills() {
+    const manifest = loadSkillRuntimeManifest();
+    return manifest.profiles[manifest.defaultProfile].skills || [];
+}
+
+function getPackSkillNames(packName) {
+    const packSrc = path.join(AWK_ROOT, 'skill-packs', packName);
+    const config = readJsonFile(path.join(packSrc, 'pack.json'), {});
+    if (Array.isArray(config.skills) && config.skills.length > 0) {
+        return [...config.skills];
+    }
+    return listSkillDirs(path.join(packSrc, 'skills'));
+}
+
+function resolvePackSkillSources(packName) {
+    const packSrc = path.join(AWK_ROOT, 'skill-packs', packName);
+    const packSkillsDir = path.join(packSrc, 'skills');
+    const localSkills = listSkillDirs(packSkillsDir);
+
+    if (localSkills.length > 0) {
+        return localSkills.map(skill => ({
+            name: skill,
+            src: path.join(packSkillsDir, skill)
+        }));
+    }
+
+    return getPackSkillNames(packName)
+        .map(skill => ({
+            name: skill,
+            src: path.join(AWK_ROOT, 'skills', skill)
+        }))
+        .filter(item => fs.existsSync(path.join(item.src, 'SKILL.md')));
+}
+
+function getManagedSkillNames() {
+    const managed = new Set(listSkillDirs(path.join(AWK_ROOT, 'skills')));
+    const packsDir = path.join(AWK_ROOT, 'skill-packs');
+    if (!fs.existsSync(packsDir)) return managed;
+
+    const packs = fs.readdirSync(packsDir, { withFileTypes: true }).filter(d => d.isDirectory());
+    for (const pack of packs) {
+        for (const skill of getPackSkillNames(pack.name)) {
+            managed.add(skill);
+        }
+    }
+    return managed;
+}
+
+function getPlatformStateRoot(platform = activePlatform) {
+    const plat = PLATFORMS[platform];
+    switch (platform) {
+        case 'cline':
+            return path.join(plat.globalRoot, '.clinerules');
+        case 'claude':
+            return path.join(plat.globalRoot, '.claude');
+        default:
+            return plat.globalRoot;
+    }
+}
+
+function getPlatformBackupRoot(platform = activePlatform) {
+    return path.join(getPlatformStateRoot(platform), 'backup');
+}
+
+function getInstallStatePath(platform = activePlatform) {
+    return path.join(getPlatformStateRoot(platform), INSTALL_STATE_FILENAME);
+}
+
+function readInstallState(platform = activePlatform) {
+    const fallback = {
+        version: 1,
+        profile: getDefaultSkillProfileName(),
+        enabledPacks: []
+    };
+    return readJsonFile(getInstallStatePath(platform), fallback) || fallback;
+}
+
+function writeInstallState(state, platform = activePlatform) {
+    const filePath = getInstallStatePath(platform);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(state, null, 2) + '\n');
+}
+
+function getDesiredSkillSet(enabledPacks = []) {
+    const desired = new Set(getDefaultRuntimeSkills());
+    for (const packName of enabledPacks) {
+        for (const skill of getPackSkillNames(packName)) {
+            desired.add(skill);
+        }
+    }
+    return desired;
+}
+
+function collectFileBasenames(dir, ext = '*') {
+    const result = new Set();
+    if (!fs.existsSync(dir)) return result;
+
+    function walk(current) {
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+            if (entry.name === '.DS_Store') continue;
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                walk(fullPath);
+            } else if (ext === '*' || entry.name.endsWith(ext)) {
+                result.add(entry.name);
+            }
+        }
+    }
+
+    walk(dir);
+    return result;
+}
+
+function getPackWorkflowNames(packName) {
+    return collectFileBasenames(path.join(AWK_ROOT, 'skill-packs', packName, 'workflows'));
+}
+
+function getPackSchemaNames(packName) {
+    return collectFileBasenames(path.join(AWK_ROOT, 'skill-packs', packName, 'schemas'), '.json');
+}
+
 /**
  * Recursively copy directory, preserving structure.
  * Does NOT overwrite files prefixed with `.` (user configs).
@@ -220,6 +374,49 @@ function copyDirRecursive(src, dest, options = {}) {
     return count;
 }
 
+function copySelectedSkillDirs(srcDir, destDir, selectedSkills) {
+    const wanted = new Set(selectedSkills);
+    let count = 0;
+
+    if (!fs.existsSync(srcDir)) return count;
+    if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+
+    for (const skill of wanted) {
+        const skillSrc = path.join(srcDir, skill);
+        if (!fs.existsSync(path.join(skillSrc, 'SKILL.md'))) continue;
+        const skillDest = path.join(destDir, skill);
+        count += copyDirRecursive(skillSrc, skillDest);
+    }
+
+    return count;
+}
+
+function backupAndPruneManagedSkills(destDir, desiredSkills) {
+    if (!fs.existsSync(destDir)) return 0;
+
+    const managed = getManagedSkillNames();
+    const installed = fs.readdirSync(destDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+
+    const stale = installed.filter(skill => managed.has(skill) && !desiredSkills.has(skill));
+    if (stale.length === 0) return 0;
+
+    const backupRoot = path.join(getPlatformBackupRoot(), 'pruned-skills');
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupDir = path.join(backupRoot, timestamp);
+    fs.mkdirSync(backupDir, { recursive: true });
+
+    for (const skill of stale) {
+        const from = path.join(destDir, skill);
+        const to = path.join(backupDir, skill);
+        fs.renameSync(from, to);
+        dim(`Archived optional skill: ${skill}`);
+    }
+
+    return stale.length;
+}
+
 /**
  * Flatten workflow category dirs into single global_workflows dir.
  * workflows/lifecycle/code.md → global_workflows/code.md
@@ -335,15 +532,19 @@ function cmdInstall(args = []) {
         if (isUpdate) {
             selectedPlatforms = [getActivePlatform()];
         } else {
+            const platformOrder = ['antigravity', 'cline', 'codex', 'claude'];
+            const defaultPlatform = getActivePlatform();
+            const defaultChoice = String(Math.max(platformOrder.indexOf(defaultPlatform), 0) + 1);
             log(`${C.cyan}Select platforms to install (e.g., type "1,2", "all", or "1,2,3,4"):${C.reset}`);
             log(`  1. Gemini Code Assist (antigravity)`);
             log(`  2. Cline (VS Code)`);
             log(`  3. Codex CLI (codex)`);
             log(`  4. Claude Code (.claude/)`);
             log(`  5. All of the above`);
-            const choice = promptChoice('Choice', '5').trim().toLowerCase();
+            log(`${C.gray}Press Enter to install only the active platform: ${PLATFORMS[defaultPlatform].name}.${C.reset}`);
+            const choice = promptChoice('Choice', defaultChoice).trim().toLowerCase();
             
-            if (choice === '5' || choice === 'all' || choice === '') {
+            if (choice === '5' || choice === 'all') {
                 selectedPlatforms = Object.keys(PLATFORMS);
             } else {
                 if (choice.includes('1')) selectedPlatforms.push('antigravity');
@@ -374,6 +575,8 @@ function cmdInstall(args = []) {
 
         const plat = PLATFORMS[platform];
         const target = plat.globalRoot;
+        const coreSkills = getDefaultRuntimeSkills();
+        const previousState = readInstallState(platform);
 
         log('');
         info(`Installing for ${C.bold}${plat.name}${C.reset}...`);
@@ -419,7 +622,7 @@ function cmdInstall(args = []) {
 
         // Backup existing workflows
         if (fs.existsSync(wfDest)) {
-            const backupDir = path.join(target, 'backup');
+            const backupDir = getPlatformBackupRoot(platform);
             if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true });
 
             const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
@@ -451,24 +654,24 @@ function cmdInstall(args = []) {
     }
 
     // 5. Copy skills
-    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 if (platform === 'claude') {
-            generateClaudeSkills(skillsSrc, skillsDest);
-        } else {
-            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, coreSkills);
+            } else if (platform === 'codex') {
+                generateCodexSkills(skillsSrc, skillsDest, coreSkills);
+                const agentsDest = path.join(target, plat.dirs.agents);
+                generateCodexAgents(skillsSrc, agentsDest, coreSkills);
+            } else if (platform === 'claude') {
+                generateClaudeSkills(skillsSrc, skillsDest, coreSkills);
+            } else {
+                const skillCount = copySelectedSkillDirs(skillsSrc, skillsDest, coreSkills);
+                ok(`${skillCount} core skill files installed`);
+            }
         }
-    }
 
     // 6. Copy orchestrator
     if (platform === 'antigravity') {
@@ -501,10 +704,34 @@ function cmdInstall(args = []) {
     fs.writeFileSync(plat.versionFile, AWK_VERSION);
     ok(`Version ${AWK_VERSION} saved`);
 
-    // 10. Install default skill packs
-    const defaultPacks = installDefaultPacks();
+        // 10. Install default skill packs
+        const defaultPacks = installDefaultPacks();
+        const activePacks = [...new Set([...(previousState.enabledPacks || []), ...defaultPacks])].sort();
+
+        for (const packName of activePacks) {
+            if (defaultPacks.includes(packName)) continue;
+            info(`Re-enabling preserved pack: ${packName}`);
+            cmdEnablePack(packName, { autoMode: true });
+        }
+
+        const desiredSkills = getDesiredSkillSet(activePacks);
 
-    // 11. Summary
+        if (plat.dirs.skills) {
+            const skillsDest = path.join(target, plat.dirs.skills);
+            const removedSkills = backupAndPruneManagedSkills(skillsDest, desiredSkills);
+            if (removedSkills > 0) {
+                ok(`${removedSkills} managed optional skill(s) archived from runtime`);
+            }
+        }
+
+        writeInstallState({
+            version: 1,
+            profile: getDefaultSkillProfileName(),
+            enabledPacks: activePacks
+        }, platform);
+        ok(`Install state saved (${desiredSkills.size} active skills)`);
+
+        // 11. Summary
     log('');
     log(`${C.gray}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
     log(`${C.yellow}${C.bold}🎉 AWK v${AWK_VERSION} installed for ${plat.name}!${C.reset}`);
@@ -519,8 +746,8 @@ function cmdInstall(args = []) {
     if (plat.rulesFile) {
         dim(`Global Rules: ${plat.rulesFile}`);
     }
-    if (defaultPacks.length > 0) {
-        dim(`Packs:      ${defaultPacks.join(', ')} (auto-enabled)`);
+    if (activePacks.length > 0) {
+        dim(`Packs:      ${activePacks.join(', ')}`);
     }
     if (platform === 'antigravity') {
         dim(`Symphony:   task tracking ready`);
@@ -662,6 +889,7 @@ function cmdDoctor() {
     log('');
 
     let issues = 0;
+    const installState = readInstallState();
 
     // 1. Check GEMINI.md
     if (fs.existsSync(TARGETS.geminiMd)) {
@@ -695,12 +923,20 @@ function cmdDoctor() {
             .map(d => d.name);
         ok(`${skills.length} skills found`);
 
-        // Check essential skills
-        const essentialSkills = ['orchestrator', 'symphony-orchestrator', 'awf-session-restore'];
-        for (const s of essentialSkills) {
-            if (!skills.includes(s)) {
-                warn(`Essential skill missing: ${s}`); issues++;
+        // Check expected skills based on manifest and enabled packs
+        try {
+            const expectedSkills = getDesiredSkillSet(installState.enabledPacks || []);
+            let missingSkills = [];
+            for (const s of expectedSkills) {
+                if (!skills.includes(s)) missingSkills.push(s);
             }
+            if (missingSkills.length > 0) {
+                warn(`Missing ${missingSkills.length} expected skill(s): ${missingSkills.join(', ')}`); issues++;
+            } else {
+                ok('All expected skills are present');
+            }
+        } catch (e) {
+            warn(`Failed to validate expected skills: ${e.message}`); issues++;
         }
     } else {
         err('skills/ directory missing'); issues++;
@@ -726,6 +962,11 @@ function cmdDoctor() {
         warn('Version file missing. Run "awkit install" first.'); issues++;
     }
 
+    log('');
+    log(`${C.bold}Runtime Profile:${C.reset}`);
+    log(`  Profile: ${C.cyan}${installState.profile}${C.reset}`);
+    log(`  Optional packs: ${installState.enabledPacks?.length ? installState.enabledPacks.join(', ') : C.gray + 'none' + C.reset}`);
+
     // Summary
     log('');
     if (issues === 0) {
@@ -1142,16 +1383,14 @@ function cmdEnablePack(packName, { autoMode = false } = {}) {
     info(`Enabling skill pack: ${packName}`);
     let totalCount = 0;
 
-    // 1. Copy skills/ subdirs → ~/.gemini/antigravity/skills/
-    const packSkillsDir = path.join(packSrc, 'skills');
-    if (fs.existsSync(packSkillsDir)) {
-        const skillDirs = fs.readdirSync(packSkillsDir, { withFileTypes: true }).filter(d => d.isDirectory());
-        for (const skillDir of skillDirs) {
-            const src = path.join(packSkillsDir, skillDir.name);
-            const dest = path.join(TARGETS.antigravity, 'skills', skillDir.name);
-            const n = copyDirRecursive(src, dest);
+    // 1. Copy pack skills into runtime.
+    const packSkills = resolvePackSkillSources(packName);
+    if (packSkills.length > 0) {
+        for (const skill of packSkills) {
+            const dest = path.join(TARGETS.antigravity, 'skills', skill.name);
+            const n = copyDirRecursive(skill.src, dest);
             totalCount += n;
-            dim(`Skill: ${skillDir.name} (${n} files)`);
+            dim(`Skill: ${skill.name} (${n} files)`);
         }
     }
 
@@ -1178,6 +1417,15 @@ function cmdEnablePack(packName, { autoMode = false } = {}) {
     // Handle pack.json requirements (pip deps, post-install, MCP setup)
     handlePackRequirements(packSrc, packName, { autoMode });
 
+    const state = readInstallState();
+    const enabledPacks = new Set(state.enabledPacks || []);
+    enabledPacks.add(packName);
+    writeInstallState({
+        version: 1,
+        profile: getDefaultSkillProfileName(),
+        enabledPacks: [...enabledPacks].sort()
+    });
+
     log('');
     log(`${C.cyan}👉 Skills available: type skill name in your AI chat.${C.reset}`);
     log(`${C.cyan}👉 Workflows available: use /nm-recall, /memory-audit, etc.${C.reset}`);
@@ -1197,15 +1445,17 @@ function cmdDisablePack(packName) {
         return;
     }
 
-    // Get list of skill dirs from pack/skills/
-    const packSkillsDir = path.join(packSrc, 'skills');
-    const skillDirs = fs.existsSync(packSkillsDir)
-        ? fs.readdirSync(packSkillsDir, { withFileTypes: true }).filter(d => d.isDirectory()).map(d => d.name)
-        : [];
+    const skillDirs = getPackSkillNames(packName);
 
     const target = path.join(TARGETS.antigravity, 'skills');
-    const backupDir = path.join(TARGETS.antigravity, 'backup', 'skills');
+    const backupDir = path.join(getPlatformBackupRoot(), 'skills');
     if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true });
+    const coreSkills = new Set(getDefaultRuntimeSkills());
+    const coreSkillsSrc = path.join(AWK_ROOT, 'skills');
+    const workflowTarget = path.join(TARGETS.antigravity, 'global_workflows');
+    const workflowBackupDir = path.join(getPlatformBackupRoot(), 'workflows');
+    const schemaTarget = path.join(TARGETS.antigravity, 'schemas');
+    const schemaBackupDir = path.join(getPlatformBackupRoot(), 'schemas');
 
     for (const skillDir of skillDirs) {
         const destPath = path.join(target, skillDir);
@@ -1213,8 +1463,39 @@ function cmdDisablePack(packName) {
             fs.renameSync(destPath, path.join(backupDir, skillDir));
             dim(`Moved to backup: ${skillDir}`);
         }
+
+        if (coreSkills.has(skillDir)) {
+            const srcPath = path.join(coreSkillsSrc, skillDir);
+            if (fs.existsSync(path.join(srcPath, 'SKILL.md'))) {
+                copyDirRecursive(srcPath, destPath);
+                dim(`Restored core skill: ${skillDir}`);
+            }
+        }
+    }
+
+    if (!fs.existsSync(workflowBackupDir)) fs.mkdirSync(workflowBackupDir, { recursive: true });
+    for (const workflowFile of getPackWorkflowNames(packName)) {
+        const livePath = path.join(workflowTarget, workflowFile);
+        if (!fs.existsSync(livePath)) continue;
+        fs.renameSync(livePath, path.join(workflowBackupDir, workflowFile));
+        dim(`Moved workflow to backup: ${workflowFile}`);
+    }
+
+    if (!fs.existsSync(schemaBackupDir)) fs.mkdirSync(schemaBackupDir, { recursive: true });
+    for (const schemaFile of getPackSchemaNames(packName)) {
+        const livePath = path.join(schemaTarget, schemaFile);
+        if (!fs.existsSync(livePath)) continue;
+        fs.renameSync(livePath, path.join(schemaBackupDir, schemaFile));
+        dim(`Moved schema to backup: ${schemaFile}`);
     }
 
+    const state = readInstallState();
+    writeInstallState({
+        version: 1,
+        profile: getDefaultSkillProfileName(),
+        enabledPacks: (state.enabledPacks || []).filter(name => name !== packName)
+    });
+
     ok(`Skill pack "${packName}" disabled (skills backed up to ${backupDir})`);
 }
 
@@ -1240,11 +1521,16 @@ function cmdListPacks() {
 
     for (const pack of packs) {
         const readmePath = path.join(packsDir, pack.name, 'README.md');
+        const configPath = path.join(packsDir, pack.name, 'pack.json');
         let desc = '';
         if (fs.existsSync(readmePath)) {
             const content = fs.readFileSync(readmePath, 'utf8');
             desc = content.split('\n').find(l => l.trim() && !l.startsWith('#')) || '';
         }
+        if (!desc && fs.existsSync(configPath)) {
+            const config = readJsonFile(configPath, {});
+            desc = config.description || '';
+        }
         log(`  ${C.green}${pack.name}${C.reset}  ${C.gray}${desc}${C.reset}`);
     }
 
@@ -1340,23 +1626,6 @@ function cmdLint() {
 
 // ─── Status: Diff repo vs installed ──────────────────────────────────────────
 
-/**
- * Collect all .md files under a directory (recursively, flat list of basenames)
- */
-function collectFiles(dir, ext = '.md') {
-    const result = new Set();
-    if (!fs.existsSync(dir)) return result;
-    function walk(current) {
-        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
-            if (entry.name === '.DS_Store') continue;
-            if (entry.isDirectory()) { walk(path.join(current, entry.name)); }
-            else if (entry.name.endsWith(ext) || ext === '*') { result.add(entry.name); }
-        }
-    }
-    walk(dir);
-    return result;
-}
-
 function cmdStatus() {
     log('');
     log(`${C.cyan}${C.bold}📊 AWK Status — Repo vs Installed${C.reset}`);
@@ -1364,13 +1633,19 @@ function cmdStatus() {
 
     const repoWfDir = path.join(AWK_ROOT, 'workflows');
     const liveWfDir = path.join(TARGETS.antigravity, 'global_workflows');
-    const repoSkillDir = path.join(AWK_ROOT, 'skills');
     const liveSkillDir = path.join(TARGETS.antigravity, 'skills');
+    const installState = readInstallState();
+    const expectedSkills = getDesiredSkillSet(installState.enabledPacks || []);
 
     // ── Workflows ──────────────────────────────────────────────────────────
     log(`${C.bold}Workflows:${C.reset}`);
-    const repoWf = collectFiles(repoWfDir);
-    const liveWf = collectFiles(liveWfDir);
+    const repoWf = collectFileBasenames(repoWfDir);
+    for (const packName of installState.enabledPacks || []) {
+        for (const wf of getPackWorkflowNames(packName)) {
+            repoWf.add(wf);
+        }
+    }
+    const liveWf = collectFileBasenames(liveWfDir);
 
     const onlyInRepo = [...repoWf].filter(f => !liveWf.has(f));
     const onlyInLive = [...liveWf].filter(f => !repoWf.has(f));
@@ -1393,15 +1668,14 @@ function cmdStatus() {
 
     // ── Skills ─────────────────────────────────────────────────────────────
     log(`${C.bold}Skills:${C.reset}`);
-    const repoSkills = fs.existsSync(repoSkillDir)
-        ? new Set(fs.readdirSync(repoSkillDir, { withFileTypes: true }).filter(d => d.isDirectory()).map(d => d.name))
-        : new Set();
+    const repoSkills = new Set(expectedSkills);
     const liveSkills = fs.existsSync(liveSkillDir)
         ? new Set(fs.readdirSync(liveSkillDir, { withFileTypes: true }).filter(d => d.isDirectory()).map(d => d.name))
         : new Set();
 
     const skillsOnlyRepo = [...repoSkills].filter(s => !liveSkills.has(s));
-    const skillsOnlyLive = [...liveSkills].filter(s => !repoSkills.has(s));
+    const managedSkills = getManagedSkillNames();
+    const skillsOnlyLive = [...liveSkills].filter(s => managedSkills.has(s) && !repoSkills.has(s));
     const skillsInBoth = [...repoSkills].filter(s => liveSkills.has(s));
 
     log(`  ${C.green}✅ In sync:${C.reset}        ${skillsInBoth.length} skills`);
@@ -1417,6 +1691,9 @@ function cmdStatus() {
         log(`  ${C.green}Perfect sync! ✨${C.reset}`);
     }
 
+    log(`  ${C.gray}Profile:${C.reset}         ${installState.profile}`);
+    log(`  ${C.gray}Optional packs:${C.reset}  ${installState.enabledPacks?.length ? installState.enabledPacks.join(', ') : 'none'}`);
+
     log('');
 
     // ── Versions ───────────────────────────────────────────────────────────
@@ -1584,7 +1861,7 @@ function cmdHelp() {
     log(`  ${C.green}init${C.reset}                Init mobile project (Firebase) in CWD`);
     log(`  ${C.gray}  --force${C.reset}            Overwrite existing files`);
     log(`  ${C.gray}  Generates: .project-identity, <Name>.code-workspace,${C.reset}`);
-    log(`  ${C.gray}             CODEBASE.md, .symphony/ (Symphony task DB)${C.reset}`);
+    log(`  ${C.gray}             CODEBASE.md, thiết lập router (AGENTS.md, CLAUDE.md)${C.reset}`);
     log('');
 
     // Maintenance
@@ -1672,7 +1949,8 @@ function cmdHelp() {
     log(line);
     log(`  ${C.cyan}# First time setup${C.reset}`);
     log(`  ${C.gray}npm install -g @leejungkiin/awkit${C.reset}`);
-    log(`  ${C.gray}awkit install${C.reset}`);
+    log(`  ${C.gray}awkit install        # Active platform only${C.reset}`);
+    log(`  ${C.gray}awkit install --all  # All supported platforms${C.reset}`);
     log(`  ${C.gray}awkit doctor${C.reset}`);
     log('');
     log(`  ${C.cyan}# Daily usage${C.reset}`);
@@ -1986,7 +2264,7 @@ function buildCodebaseMd(projectName, projectType, identity) {
  *   .project-identity
  *   <ProjectName>.code-workspace
  *   CODEBASE.md
- *   .symphony/ (via Symphony)
+ *   Router files (AGENTS.md, CLAUDE.md)
  */
 async function cmdInit(forceFlag = false) {
     const cwd = process.cwd();
@@ -2141,21 +2419,95 @@ async function cmdInit(forceFlag = false) {
         ok('CODEBASE.md created');
     }
 
-    // ── 5. Symphony folder ───────────────────────────────────────────────────────
-    const symphonyDir = path.join(cwd, '.symphony');
-    if (fs.existsSync(symphonyDir) && !forceFlag) {
-        warn('.symphony/ folder already exists');
+    // ── 4.1. IDE Agent Router Files (AGENTS.md & CLAUDE.md) ───────────────────
+    const agentRouterContent = `# AI Agent Strategy
+> **NOTICE:** This project uses Antigravity (AWKit) as the central orchestrator.
+> All core system rules, behaviors, and workflows are defined globally.
+
+**CRITICAL INSTRUCTION FOR ALL AI AGENTS:**
+Before reading any other context or starting work, you MUST read the global system instructions file located at:
+
+\`\`\`bash
+cat ~/.gemini/antigravity/GEMINI.md
+\`\`\`
+
+If you cannot read the file directly, you must ask the user to provide its contents. 
+Please follow ALL rules defined in that global file.
+
+Additional project context can be found in:
+- \`.project-identity\`
+- \`CODEBASE.md\`
+`;
+
+    const routerFiles = ['AGENTS.md', 'CLAUDE.md'];
+    for (const file of routerFiles) {
+        const filePath = path.join(cwd, file);
+        if (fs.existsSync(filePath)) {
+            const bakPath = path.join(cwd, `${file}.bak`);
+            fs.copyFileSync(filePath, bakPath);
+            warn(`Backed up existing ${file} to ${file}.bak`);
+        }
+        info(`Creating ${file} (Router to GEMINI.md)...`);
+        fs.writeFileSync(filePath, agentRouterContent);
+        ok(`${file} created/updated`);
+    }
+
+    // ── 4.2. Help Documentation (help.html) ───────────────────────────────────
+    const helpPath = path.join(cwd, 'help.html');
+    if (fs.existsSync(helpPath) && !forceFlag) {
+        warn('help.html already exists — skipping (use --force to overwrite)');
     } else {
-        info('Creating .symphony/ folder to mark project context...');
-        fs.mkdirSync(symphonyDir, { recursive: true });
-        // Create an empty .gitignore just in case
-        fs.writeFileSync(path.join(symphonyDir, '.gitignore'), '*\n');
-        ok('Symphony project marker created (.symphony/)');
-        
-        const symReady = checkSymphony({ silent: true });
-        if (!symReady) {
-            dim('Symphony CLI is not installed. Run: npm i -g @leejungkiin/awkit-symphony');
+        info('Creating help.html...');
+        const tmplHelpPath = path.join(AWK_ROOT, 'templates', 'help.html');
+        if (fs.existsSync(tmplHelpPath)) {
+            fs.copyFileSync(tmplHelpPath, helpPath);
+            ok('help.html created');
+        } else {
+            warn('Template help.html not found, skipped.');
+        }
+    }
+
+    // ── 4.5. .gitignore ────────────────────────────────────────────────────────
+    const gitignorePath = path.join(cwd, '.gitignore');
+    const ignoreRules = ['log.txt', 'tmp/', '.gitnexus/', 'node_modules/'];
+    
+    if (fs.existsSync(gitignorePath)) {
+        let content = fs.readFileSync(gitignorePath, 'utf8');
+        let added = 0;
+        for (const rule of ignoreRules) {
+            // Very simple check to avoid duplicates, might not be perfect for regexes but good for simple literal paths.
+            if (!content.includes(rule)) {
+                if (!content.endsWith('\n') && content.length > 0 && added === 0) content += '\n';
+                content += `${rule}\n`;
+                added++;
+            }
+        }
+        if (added > 0) {
+            fs.writeFileSync(gitignorePath, content);
+            ok('Updated .gitignore with AWKit ignore rules');
+        } else {
+            dim('.gitignore already has AWKit ignore rules');
+        }
+    } else {
+        info('Creating .gitignore...');
+        fs.writeFileSync(gitignorePath, ignoreRules.join('\n') + '\n');
+        ok('.gitignore created');
+    }
+
+    // ── 5. Symphony CLI Initialization ───────────────────────────────────────────
+    info('Checking Symphony CLI...');
+    const symReady = checkSymphony({ silent: true });
+    if (!symReady) {
+        info('Symphony CLI is not installed. Installing automatically...');
+        try {
+            execSync('npm install -g @leejungkiin/awkit-symphony', { stdio: 'inherit' });
+            ok('Symphony CLI installed successfully.');
+        } catch (e) {
+            err('Failed to auto-install Symphony CLI.');
+            dim('Please install manually: npm i -g @leejungkiin/awkit-symphony');
         }
+    } else {
+        ok('Symphony CLI is ready.');
     }
 
     // ── 5.5. GitNexus: Code Intelligence Index ──────────────────────────────