@leejungkiin/awkit 1.7.1 → 1.7.5

package/bin/awk.js

@@ -19,6 +19,7 @@
  *   awkit list-packs     List available skill packs
  *   awkit tg setup       Setup Telegram Bot API credentials
  *   awkit tg send        Send a message via Telegram Bot API
+ *   awkit build          Run project build command securely based on configuration
  *   awkit version        Show current version
  * 
  * Created by Kien AI
@@ -43,6 +44,11 @@ const { cmdGate } = require('../scripts/automation-gate');
 const { cmdObsidian } = require('../scripts/obsidian-sync');
 const { cmdQuota } = require('../scripts/cockpit-quota');
 const { cmdVideo } = require('../scripts/video-analyzer');
+const { cmdI18n } = require('../scripts/i18n-helper');
+const { cmdStorage } = require('../scripts/artifact-storage');
+const { cmdPipeline } = require('../scripts/multi-model-pipeline');
+const depManager = require('../scripts/dependency-manager');
+
 
 // ─── Platform Definitions ──────────────────────────────────────────────────
 
@@ -368,7 +374,7 @@ function copyDirRecursive(src, dest, options = {}) {
     const entries = fs.readdirSync(src, { withFileTypes: true });
 
     for (const entry of entries) {
-        if (entry.name === '.DS_Store' || entry.name === '.git') continue;
+        if (entry.name === '.DS_Store' || entry.name === '.git' || entry.name === '.venv' || entry.name === 'node_modules') continue;
 
         const srcPath = path.join(src, entry.name);
 
@@ -898,14 +904,19 @@ function cmdUpdate() {
     log(`${C.gray}   local repo:  v${AWK_VERSION}${C.reset}`);
     log('');
 
-    // 3. Already up-to-date?
-    if (npmLatest && npmLatest === installedVersion) {
-        ok(`Already on the latest version (v${installedVersion}) 🎉`);
-        return;
+    // 3. Already up-to-date or newer?
+    if (npmLatest) {
+        if (npmLatest === installedVersion) {
+            ok(`Already on the latest version (v${installedVersion}) 🎉`);
+            return;
+        } else if (isNewerVersion(installedVersion, npmLatest)) {
+            ok(`Your installed version (v${installedVersion}) is newer than the npm registry version (v${npmLatest}) 🎉`);
+            return;
+        }
     }
 
     // 4. New version available on npm → install from registry
-    if (npmLatest && npmLatest !== installedVersion) {
+    if (npmLatest && isNewerVersion(npmLatest, installedVersion)) {
         info(`Upgrading: v${installedVersion} → v${npmLatest}`);
         info('Running: npm install -g @leejungkiin/awkit');
         try {
@@ -924,13 +935,15 @@ function cmdUpdate() {
     // 5. Offline fallback: compare AWK_VERSION (local repo) vs installed
     if (installedVersion === AWK_VERSION) {
         ok(`Already on latest version (v${AWK_VERSION}) — could not verify with npm`);
-    } else {
+    } else if (isNewerVersion(AWK_VERSION, installedVersion)) {
         info(`Upgrading from v${installedVersion} → v${AWK_VERSION} (local only, npm unreachable)`);
         cmdInstall(['--update']);
+    } else {
+        ok(`Your installed version (v${installedVersion}) is newer than or equal to local repo version (v${AWK_VERSION})`);
     }
 }
 
-function cmdDoctor() {
+async function cmdDoctor() {
     log('');
     log(`${C.cyan}${C.bold}🏥 AWK Health Check${C.reset}`);
     log('');
@@ -998,16 +1011,27 @@ function cmdDoctor() {
         warn('schemas/ directory missing'); issues++;
     }
 
-    // 4.5. Check RTK Integration
-    try {
-        const { checkRtk } = require('../scripts/exec-rtk');
-        if (checkRtk()) {
-            ok('RTK (Rust Token Killer) is installed and active');
+    // 4.5. Check RTK & GitNexus Integration
+    if (depManager.checkRtk()) {
+        ok(`RTK (Rust Token Killer) is installed (v${depManager.getRtkVersion() || 'unknown'})`);
+    } else {
+        warn('RTK (Rust Token Killer) not found.');
+        if (promptYN('Would you like to install RTK automatically now?')) {
+            depManager.installRtk();
         } else {
-            warn('RTK (Rust Token Killer) not found. Run "awkit rtk setup" to optimize token usage.');
+            issues++;
+        }
+    }
+
+    if (depManager.checkGitnexus()) {
+        ok('GitNexus (Code Intelligence Indexer) is installed and active');
+    } else {
+        warn('GitNexus (Code Intelligence Indexer) not found.');
+        if (promptYN('Would you like to install GitNexus globally now?')) {
+            depManager.installGitnexus();
+        } else {
+            issues++;
         }
-    } catch (e) {
-        warn(`RTK check failed: ${e.message}`);
     }
 
     // 5. Check version
@@ -1021,6 +1045,25 @@ function cmdDoctor() {
         warn('Version file missing. Run "awkit install" first.'); issues++;
     }
 
+    // 5.5. Check Updates
+    try {
+        const updates = await depManager.checkUpdates(AWK_VERSION);
+        if (updates.latestAwkit && isNewerVersion(updates.latestAwkit, AWK_VERSION)) {
+            warn(`AWKit update available: v${updates.latestAwkit} (current: v${AWK_VERSION})`);
+        } else {
+            ok('AWKit is up-to-date');
+        }
+        
+        const currentRtk = depManager.getRtkVersion();
+        if (updates.latestRtk && currentRtk && isNewerVersion(updates.latestRtk, currentRtk)) {
+            warn(`RTK update available: v${updates.latestRtk} (current: v${currentRtk})`);
+        } else if (currentRtk) {
+            ok('RTK is up-to-date');
+        }
+    } catch (e) {
+        warn(`Update check failed: ${e.message}`);
+    }
+
     log('');
     log(`${C.bold}Runtime Profile:${C.reset}`);
     log(`  Profile: ${C.cyan}${installState.profile}${C.reset}`);
@@ -1710,15 +1753,19 @@ 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');
+        const config = fs.existsSync(configPath) ? readJsonFile(configPath, {}) : {};
+        if (config.hidden === true) {
+            continue;
+        }
+
+        const readmePath = path.join(packsDir, pack.name, 'README.md');
         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, {});
+        if (!desc) {
             desc = config.description || '';
         }
         log(`  ${C.green}${pack.name}${C.reset}  ${C.gray}${desc}${C.reset}`);
@@ -1898,6 +1945,22 @@ function cmdStatus() {
     }
 
     log('');
+    
+    // ── GitNexus Info ──────────────────────────────────────────────────────
+    const cwd = process.cwd();
+    const gitnexusDir = path.join(cwd, '.gitnexus');
+    if (fs.existsSync(gitnexusDir)) {
+        const registry = readGitnexusRegistry();
+        const match = registry.find(r => r.path === cwd);
+        if (match) {
+            const stats = match.stats || {};
+            log(`${C.bold}GitNexus Info:${C.reset}`);
+            log(`  Active repo: ${C.green}${match.name}${C.reset} (${stats.nodes || 0} nodes, ${stats.edges || 0} relations)`);
+            log(`  Tip: Run 'awkit index' to refresh index or 'awkit status gn' for details.`);
+            log('');
+        }
+    }
+
     log(`${C.gray}Tip: 'awkit sync' = harvest (pull live→repo) + install (push repo→live)${C.reset}`);
     log('');
 }
@@ -1938,6 +2001,104 @@ function cmdSync() {
     log('');
 }
 
+// ─── Build: Safe project-specific compilation ────────────────────────────────
+
+function cmdBuild() {
+    log('');
+    log(`${C.cyan}${C.bold}🔨 AWK Build Control${C.reset}`);
+    log('');
+
+    const pjPath = path.join(process.cwd(), '.project-identity');
+    const pj = readJsonFile(pjPath, {});
+
+    if (!pj.automation || !pj.automation.build) {
+        warn('No build configuration found in .project-identity under "automation.build".');
+        log('Skipping build...');
+        return;
+    }
+
+    const { enabled, command } = pj.automation.build;
+
+    if (!enabled) {
+        warn('Build is disabled for this project (automation.build.enabled is false).');
+        log('Skipping build...');
+        return;
+    }
+
+    if (!command) {
+        err('Build command is not configured in .project-identity (automation.build.command is empty).');
+        return;
+    }
+
+    info(`Running build command: ${C.bold}${command}${C.reset}`);
+    try {
+        execSync(command, { stdio: 'inherit' });
+        log('');
+        ok('Build successful!');
+    } catch (e) {
+        log('');
+        err(`Build failed: ${e.message}`);
+        process.exit(1);
+    }
+}
+
+// ─── Run: Safe project-specific run/start script execution ──────────────────
+
+function cmdRun(runArgs = []) {
+    log('');
+    log(`${C.cyan}${C.bold}🚀 AWK Run Control${C.reset}`);
+    log('');
+
+    const pjPath = path.join(process.cwd(), '.project-identity');
+    const pj = readJsonFile(pjPath, {});
+
+    if (!pj.automation || !pj.automation.run) {
+        warn('No run configuration found in .project-identity under "automation.run".');
+        log('Skipping run...');
+        return;
+    }
+
+    const { enabled, command } = pj.automation.run;
+
+    if (!enabled) {
+        warn('Run is disabled for this project (automation.run.enabled is false).');
+        log('Skipping run...');
+        return;
+    }
+
+    if (!command) {
+        err('Run command is not configured in .project-identity (automation.run.command is empty).');
+        return;
+    }
+
+    const fullCommand = runArgs.length > 0 ? `${command} ${runArgs.join(' ')}` : command;
+
+    info(`Running command: ${C.bold}${fullCommand}${C.reset}`);
+    try {
+        execSync(fullCommand, { stdio: 'inherit' });
+    } catch (e) {
+        log('');
+        err(`Run failed: ${e.message}`);
+        process.exit(e.status || 1);
+    }
+}
+
+function cmdTask(taskArgs = []) {
+    try {
+        execSync(`symphony task ${taskArgs.join(' ')}`, { stdio: 'inherit' });
+    } catch (e) {
+        process.exit(e.status || 1);
+    }
+}
+
+function cmdProject(projectArgs = []) {
+    try {
+        execSync(`symphony project ${projectArgs.join(' ')}`, { stdio: 'inherit' });
+    } catch (e) {
+        process.exit(e.status || 1);
+    }
+}
+
 async function cmdAdmin() {
     info('Mở Symphony Dashboard...');
     try {
@@ -2027,6 +2188,59 @@ async function cmdRestart() {
     }
 }
 
+function cmdGreet(args) {
+    let name = 'Guest';
+    let lang = 'en';
+    let timezone = undefined;
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--help' || arg === '-h') {
+            log('');
+            log(`${C.cyan}${C.bold}👋 awkit greet — Personalized greetings${C.reset}`);
+            log('');
+            log('Usage:');
+            log('  awkit greet [options]');
+            log('');
+            log('Options:');
+            log('  -n, --name <name>      Name of the person to greet (default: "Guest")');
+            log('  -l, --lang <lang>      Language code (en, vi, ja) (default: "en")');
+            log('  -t, --timezone <tz>    Timezone string (default: system timezone)');
+            log('  -h, --help             Show this help message');
+            log('');
+            return;
+        }
+        if ((arg === '--name' || arg === '-n') && args[i + 1] && !args[i + 1].startsWith('-')) {
+            name = args[i + 1];
+            i++;
+        } else if (arg.startsWith('--name=')) {
+            name = arg.split('=')[1];
+        } else if ((arg === '--lang' || arg === '-l') && args[i + 1] && !args[i + 1].startsWith('-')) {
+            lang = args[i + 1];
+            i++;
+        } else if (arg.startsWith('--lang=')) {
+            lang = arg.split('=')[1];
+        } else if ((arg === '--timezone' || arg === '-t') && args[i + 1] && !args[i + 1].startsWith('-')) {
+            timezone = args[i + 1];
+            i++;
+        } else if (arg.startsWith('--timezone=')) {
+            timezone = arg.split('=')[1];
+        }
+    }
+
+    try {
+        const GreetingEngine = require('../core/GreetingEngine');
+        const result = GreetingEngine.generateGreeting({ name, lang, timezone });
+        if (result.status === 'success') {
+            log(result.data.message);
+        } else {
+            err('Failed to generate greeting');
+        }
+    } catch (e) {
+        err('Failed to execute Greeting Engine: ' + e.message);
+    }
+}
+
 function cmdHelp() {
     const line = `${C.gray}${'─'.repeat(56)}${C.reset}`;
     log('');
@@ -2035,6 +2249,33 @@ function cmdHelp() {
     log(`${C.cyan}${C.bold}╚═══════════════════════════════════════════════════════╝${C.reset}`);
     log('');
 
+    // Project Context Detector
+    const cwd = process.cwd();
+    const identityPath = path.join(cwd, '.project-identity');
+    if (fs.existsSync(identityPath)) {
+        try {
+            const raw = fs.readFileSync(identityPath, 'utf8');
+            const identity = JSON.parse(raw);
+            const icon = identity.icon || '⚡';
+            const name = identity.projectName || 'Unnamed Project';
+            const pType = identity.projectType ? `Type: ${identity.projectType}` : 'Type: Generic';
+            
+            let bCmd = 'Disabled';
+            if (identity.automation && identity.automation.build && identity.automation.build.enabled) {
+                bCmd = identity.automation.build.command || 'Enabled';
+            }
+            let rCmd = 'Disabled';
+            if (identity.automation && identity.automation.run && identity.automation.run.enabled) {
+                rCmd = identity.automation.run.command || 'Enabled';
+            }
+
+            log(`${C.cyan}👉 Active Project: ${icon} ${C.bold}${name}${C.reset}`);
+            log(`   [${pType} | Build Control: ${bCmd === 'Disabled' ? C.yellow + 'Manual' : C.green + bCmd} | Run Control: ${rCmd === 'Disabled' ? C.yellow + 'Manual' : C.green + rCmd}${C.reset}]`);
+            log(`   Run ${C.green}awkit identity${C.reset} for full configuration details.`);
+            log('');
+        } catch (_) {}
+    }
+
     // Install
     log(`${C.bold}⚙️  Setup${C.reset}`);
     log(line);
@@ -2047,6 +2288,10 @@ function cmdHelp() {
     log(`  ${C.green}credentials list${C.reset}    List stored API keys`);
     log(`  ${C.green}credentials set${C.reset} <k> <v> Set API key (e.g., gemini_api_key, openrouter_api_key)`);
     log(`  ${C.green}set-openrouter${C.reset} <key>  Shorthand for setting OpenRouter API Key`);
+    log(`  ${C.green}config-global list${C.reset}  List all global configurations`);
+    log(`  ${C.green}config-global set${C.reset} <k> <v> Set global configuration`);
+    log(`  ${C.green}config-global audio${C.reset} <on|off> Turn audio alerts on/off globally`);
+    log(`  ${C.green}config audio${C.reset} <on|off>  Shorthand to turn audio alerts on/off globally`);
     log('');
 
     // Project Init
@@ -2056,6 +2301,9 @@ function cmdHelp() {
     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, thiết lập router (AGENTS.md, CLAUDE.md)${C.reset}`);
+    log(`  ${C.green}identity${C.reset}            Show project identity & active configurations (alias: config)`);
+    log(`  ${C.green}build${C.reset}               Run project build based on .project-identity config`);
+    log(`  ${C.green}run${C.reset} [args]            Run project-specific start/dev commands based on config`);
     log('');
 
     // Maintenance
@@ -2082,10 +2330,21 @@ function cmdHelp() {
     log(`  ${C.green}sync${C.reset}                Full sync: harvest + install (one shot)`);
     log('');
 
+    // GreetingApp
+    log(`${C.bold}👋  GreetingApp${C.reset}`);
+    log(line);
+    log(`  ${C.green}greet${C.reset} [options]      Generate personalized dynamic greeting`);
+    log(`  ${C.gray}  -n, --name <name>${C.reset}  User name to greet (default: Guest)`);
+    log(`  ${C.gray}  -l, --lang <lang>${C.reset}  Language code: en, vi, ja (default: en)`);
+    log(`  ${C.gray}  -t, --timezone <tz>${C.reset} Timezone parameter`);
+    log('');
+
     // Symphony
     log(`${C.bold}🎶  Symphony${C.reset}`);
     log(line);
     log(`  ${C.green}admin${C.reset}               Khởi động Symphony Dashboard`);
+    log(`  ${C.green}task${C.reset} [args]         Manage Symphony tasks directly`);
+    log(`  ${C.green}project${C.reset} [args]      Manage Symphony projects directly`);
     log('');
 
     // Packs
@@ -2098,6 +2357,36 @@ function cmdHelp() {
     log(`  ${C.green}disable-pack${C.reset} <name> Uninstall a skill pack (backed up)`);
     log('');
 
+    // Storage
+    log(`${C.bold}🗄️  Storage${C.reset}`);
+    log(line);
+    log(`  ${C.green}storage set${C.reset} <key> <val>  Save key-value pair`);
+    log(`  ${C.green}storage get${C.reset} <key>        Retrieve value by key`);
+    log(`  ${C.green}storage delete${C.reset} <key>     Delete key`);
+    log(`  ${C.green}storage list${C.reset} [prefix]    List keys with optional prefix`);
+    log(`  ${C.gray}  --shared                  Access shared storage space${C.reset}`);
+    log('');
+
+    // Pipeline
+    log(`${C.bold}🔗  Pipeline & Sub-Agents${C.reset}`);
+    log(line);
+    log(`  ${C.green}pipeline plan${C.reset} <Feature>   Lập kế hoạch kiến trúc (Claude / Gemini fallback)`);
+    log(`  ${C.green}pipeline ui${C.reset} <Feature>     Thiết kế shell & GUI assets (Codex / Gemini fallback)`);
+    log(`  ${C.green}pipeline code${C.reset} <Feature>   Thực thi viết code & review (Qwen / Gemini fallback)`);
+    log('');
+    log(`  ${C.bold}🤖  Multi-Agent Collaborative System${C.reset}`);
+    log(`     AWKit integrates third-party CLI agents to optimize reasoning quality & costs:`);
+    log(`     • ${C.cyan}Claude Code${C.reset}  ➜ Architect planning & complex reasoning (Gate 2/4)`);
+    log(`     • ${C.cyan}Codex CLI${C.reset}    ➜ UI shell design, asset generation & reviews (Gate 2.5/5)`);
+    log(`     • ${C.cyan}Qwen Coder${C.reset}   ➜ Fast local boilerplate code execution (Gate 4)`);
+    log(`     • ${C.cyan}Gemini Flash${C.reset} ➜ Central coordination, active context & fallback router`);
+    log('');
+    log(`     To query or configure active runners and alerts:`);
+    log(`     - Run ${C.green}awkit config list${C.reset}    to show current settings`);
+    log(`     - Run ${C.green}awkit config runners${C.reset} to check paths & binary availability`);
+    log(`     - Run ${C.green}awkit config <runner> <on|off>${C.reset} to toggle specific runner`);
+    log('');
+
     // Trello
     log(`${C.bold}📋  Trello${C.reset}`);
     log(line);
@@ -2121,15 +2410,16 @@ function cmdHelp() {
     log('');
 
     // GitNexus
-    log(`${C.bold}🔍  GitNexus${C.reset}`);
+    log(`${C.bold}🔍  GitNexus (Shortcuts: index, clean, list)${C.reset}`);
     log(line);
-    log(`  ${C.green}gitnexus list${C.reset}       List all indexed repositories`);
-    log(`  ${C.green}gitnexus status${C.reset}     Show current project index info`);
-    log(`  ${C.green}gitnexus clean${C.reset}      Interactive cleanup of old indexes`);
-    log(`  ${C.green}gitnexus clean${C.reset} ${C.gray}<name...>${C.reset}  Remove specific repo(s) by name`);
+    log(`  ${C.green}index${C.reset}               Index/refresh current codebase (alias: analyze)`);
+    log(`  ${C.green}list${C.reset}                List all indexed repositories`);
+    log(`  ${C.green}status gn${C.reset}           Show current project index info (or 'gn status')`);
+    log(`  ${C.green}clean${C.reset}               Interactive cleanup of old indexes`);
+    log(`  ${C.green}clean${C.reset} ${C.gray}<name...>${C.reset}         Remove specific repo(s) by name`);
     log(`  ${C.gray}  --stale${C.reset}            Auto-remove repos with missing paths`);
     log(`  ${C.gray}  --all${C.reset}              Remove all except current project`);
-    log(`  ${C.gray}  Alias: gn${C.reset}`);
+    log(`  ${C.gray}  Alias: gn / gitnexus${C.reset}`);
     log('');
 
     // Available packs
@@ -2139,6 +2429,11 @@ function cmdHelp() {
         if (packs.length) {
             log(`  Available packs:`);
             for (const p of packs) {
+                const configPath = path.join(packsDir, p.name, 'pack.json');
+                const config = fs.existsSync(configPath) ? readJsonFile(configPath, {}) : {};
+                if (config.hidden === true) {
+                    continue;
+                }
                 const readmePath = path.join(packsDir, p.name, 'README.md');
                 let tagline = '';
                 if (fs.existsSync(readmePath)) {
@@ -2212,10 +2507,55 @@ function detectProjectType(cwd) {
     if (entries.includes('pubspec.yaml')) {
         return 'flutter';
     }
+    
+    // JS/Node project check
+    if (entries.includes('package.json')) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (pkg.bin) {
+                return 'cli';
+            }
+            if (deps['next']) {
+                return 'web-nextjs';
+            }
+            if (deps['@nestjs/core']) {
+                return 'backend-nestjs';
+            }
+            return 'node';
+        } catch (_) { /* continue */ }
+    }
+    
     // Default: generic mobile-firebase
     return 'mobile-firebase';
 }
 
+/**
+ * Get the default safe build command based on projectType.
+ */
+function getDefaultBuildCommand(projectType) {
+    switch (projectType) {
+        case 'ios':
+            return 'xcodebuild -scheme YourScheme -sdk iphonesimulator -configuration Debug';
+        case 'android':
+            return './gradlew assembleDebug';
+        case 'expo':
+            return 'npx expo prebuild';
+        case 'flutter':
+            return 'flutter build apk --debug';
+        case 'web-nextjs':
+            return 'npm run build';
+        case 'backend-nestjs':
+            return 'npm run build';
+        case 'cli':
+        case 'node':
+            return 'npm test';
+        case 'mobile-firebase':
+        default:
+            return 'npm run build';
+    }
+}
+
 /**
  * Build .project-identity object from detected type + project name.
  */
@@ -2326,6 +2666,70 @@ function buildProjectIdentity(projectName, projectType, cwd, date) {
             servicesDir: 'lib/shared/services',
             modelsDir: 'lib/shared/models',
         },
+        cli: {
+            projectType: 'cli',
+            techStack: {
+                platform: 'CLI',
+                language: 'JavaScript / TypeScript',
+                runtime: 'Node.js',
+                framework: 'Vanilla NodeJS',
+                testing: 'Jest / doctor',
+            },
+            codingStandards: { language: 'en', namingConvention: 'camelCase', indentation: 'spaces-4', lineLength: 120 },
+            architecture: 'Modular',
+            featuresDir: 'src/commands',
+            sharedUIDir: 'src/ui',
+            servicesDir: 'src/services',
+            modelsDir: 'src/models',
+        },
+        node: {
+            projectType: 'node',
+            techStack: {
+                platform: 'NodeJS Backend/App',
+                language: 'JavaScript / TypeScript',
+                runtime: 'Node.js',
+                testing: 'Jest',
+            },
+            codingStandards: { language: 'en', namingConvention: 'camelCase', indentation: 'spaces-4', lineLength: 120 },
+            architecture: 'Modular',
+            featuresDir: 'src/features',
+            sharedUIDir: 'src/views',
+            servicesDir: 'src/services',
+            modelsDir: 'src/models',
+        },
+        'web-nextjs': {
+            projectType: 'web-nextjs',
+            techStack: {
+                platform: 'Web',
+                language: 'TypeScript / JavaScript',
+                framework: 'Next.js',
+                styling: 'Tailwind CSS / CSS Modules',
+                stateManagement: 'Zustand / Redux Toolkit / React Context',
+                networking: 'Axios / Fetch',
+            },
+            codingStandards: { language: 'en', namingConvention: 'camelCase', indentation: 'spaces-2', lineLength: 100 },
+            architecture: 'App Router / Pages Router',
+            featuresDir: 'src/app',
+            sharedUIDir: 'src/components',
+            servicesDir: 'src/services',
+            modelsDir: 'src/models',
+        },
+        'backend-nestjs': {
+            projectType: 'backend-nestjs',
+            techStack: {
+                platform: 'Backend',
+                language: 'TypeScript',
+                framework: 'NestJS',
+                database: 'PostgreSQL / MySQL / MongoDB',
+                orm: 'Prisma / TypeORM / Mongoose',
+            },
+            codingStandards: { language: 'en', namingConvention: 'camelCase', indentation: 'spaces-2', lineLength: 100 },
+            architecture: 'Controller-Service-Repository',
+            featuresDir: 'src/modules',
+            sharedUIDir: 'src/common',
+            servicesDir: 'src/services',
+            modelsDir: 'src/models',
+        },
     };
 
     // Fallback: generic mobile-firebase
@@ -2394,6 +2798,10 @@ function buildProjectIdentity(projectName, projectType, cwd, date) {
                 "pixel-mcp": {
                     enabled: false
                 }
+            },
+            build: {
+                enabled: false,
+                command: getDefaultBuildCommand(projectType)
             }
         },
         modelPolicy: {
@@ -2637,6 +3045,10 @@ async function cmdInit(forceFlag = false) {
                     "pixel-mcp": {
                         enabled: false
                     }
+                },
+                build: {
+                    enabled: false,
+                    command: getDefaultBuildCommand(projectType)
                 }
             };
             fs.writeFileSync(identityPath, JSON.stringify(currentIdentity, null, 2) + '\n');
@@ -2657,6 +3069,18 @@ async function cmdInit(forceFlag = false) {
                 currentIdentity.automation.mcp = { "pixel-mcp": { enabled: false } };
                 changed = true;
             }
+            if (!currentIdentity.projectType) {
+                currentIdentity.projectType = projectType;
+                changed = true;
+            }
+            if (!currentIdentity.automation.build) {
+                const detectedType = currentIdentity.projectType || projectType || 'mobile-firebase';
+                currentIdentity.automation.build = { 
+                    enabled: false, 
+                    command: getDefaultBuildCommand(detectedType) 
+                };
+                changed = true;
+            }
             if (!currentIdentity.modelPolicy) {
                 currentIdentity.modelPolicy = {
                     mode: "auto",
@@ -2841,17 +3265,20 @@ Additional project context can be found in:
         ).trim();
 
         if (hasSource) {
-            execSync('npx -y gitnexus analyze', {
+            const usePnpm = fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'));
+            const indexCmd = usePnpm ? 'pnpm dlx gitnexus analyze' : 'npx -y gitnexus analyze';
+            info(`Running index with: ${indexCmd}...`);
+            execSync(indexCmd, {
                 cwd,
                 stdio: 'ignore',
             });
             ok('GitNexus index created (.gitnexus/)');
         } else {
-            dim('No source files found — skipping GitNexus index (run later: npx gitnexus analyze)');
+            dim('No source files found — skipping GitNexus index (run later: pnpm dlx gitnexus analyze or npx gitnexus analyze)');
         }
     } catch (e) {
         warn(`GitNexus indexing failed: ${e.message}`);
-        dim('Run manually later: npx gitnexus analyze');
+        dim('Run manually later: pnpm dlx gitnexus analyze or npx gitnexus analyze');
     }
 
     // ── 6. Summary ─────────────────────────────────────────────────────────────
@@ -2866,9 +3293,10 @@ Additional project context can be found in:
     dim(`GitNexus:   code intelligence index`);
     log('');
     log(`${C.cyan}👉 Open ${workspaceName} in VS Code to get started.${C.reset}`);
+    log(`${C.cyan}👉 Run '/init' in AI chat to activate Smart Ecosystem Setup (SAEE) & recommendations.${C.reset}`);
     log(`${C.cyan}👉 Run '/codebase-sync' in AI chat to keep CODEBASE.md updated.${C.reset}`);
     log(`${C.cyan}👉 Run 'symphony task list' to manage tasks.${C.reset}`);
-    log(`${C.cyan}👉 Run 'npx gitnexus analyze' after major changes to refresh index.${C.reset}`);
+    log(`${C.cyan}👉 Run 'pnpm dlx gitnexus analyze' (or 'npx gitnexus analyze') after major changes to refresh index.${C.reset}`);
     log('');
 
     // ── 7. Open Documentation ───────────────────────────────────────────────────
@@ -3520,41 +3948,90 @@ function cmdTrello(args) {
     }
 }
 
-// ─── Auto-Update Checker ──────────────────────────────────────────────────────
-
-function checkAutoUpdate() {
-    const checkFile = path.join(TARGETS.antigravity, '.awk_update_check');
-    const now = Date.now();
-    const ONEDAY = 24 * 60 * 60 * 1000;
+/**
+ * Helper to check if semantic version `latest` is newer than `current`.
+ */
+function isNewerVersion(latest, current) {
+    if (!latest || !current) return false;
+    const clean = v => v.replace(/^v/, '');
+    const lClean = clean(latest);
+    const cClean = clean(current);
+    if (lClean === cClean) return false;
+
+    const parse = v => {
+        const parts = v.split('-');
+        const numbers = parts[0].split('.').map(Number);
+        const prerelease = parts[1] ? parts[1].split('.') : [];
+        return { numbers, prerelease };
+    };
 
-    if (fs.existsSync(checkFile)) {
-        try {
-            const lastCheck = parseInt(fs.readFileSync(checkFile, 'utf8'), 10);
-            if (!isNaN(lastCheck) && (now - lastCheck < ONEDAY)) {
-                return; // already checked recently
-            }
-        } catch (_) { }
+    const l = parse(lClean);
+    const c = parse(cClean);
+
+    // Compare main version numbers
+    for (let i = 0; i < 3; i++) {
+        const ln = l.numbers[i] || 0;
+        const cn = c.numbers[i] || 0;
+        if (ln > cn) return true;
+        if (ln < cn) return false;
+    }
+
+    const lIsPrerelease = l.prerelease.length > 0;
+    const cIsPrerelease = c.prerelease.length > 0;
+
+    if (lIsPrerelease && !cIsPrerelease) return false;
+    if (!lIsPrerelease && cIsPrerelease) return true;
+
+    const maxLength = Math.max(l.prerelease.length, c.prerelease.length);
+    for (let i = 0; i < maxLength; i++) {
+        const lp = l.prerelease[i];
+        const cp = c.prerelease[i];
+        if (lp === undefined) return false;
+        if (cp === undefined) return true;
+        const lpNum = parseInt(lp, 10);
+        const cpNum = parseInt(cp, 10);
+        const lpIsNum = !isNaN(lpNum);
+        const cpIsNum = !isNaN(cpNum);
+        if (lpIsNum && cpIsNum) {
+            if (lpNum > cpNum) return true;
+            if (lpNum < cpNum) return false;
+        } else if (lpIsNum) {
+            return false;
+        } else if (cpIsNum) {
+            return true;
+        } else {
+            if (lp > cp) return true;
+            if (lp < cp) return false;
+        }
     }
+    return false;
+}
 
-    // Touch the file so we don't retry immediately on failure
-    try { fs.writeFileSync(checkFile, now.toString()); } catch (_) { }
+// ─── Auto-Update Checker ──────────────────────────────────────────────────────
 
-    // Check for update using npm registry
+async function checkAutoUpdate() {
     try {
-        const output = execSync('npm view @leejungkiin/awkit version', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000 });
-        const npmVersion = output.trim();
-
-        // Simple string comparison for versions like "1.0.0" (Assumes SemVer)
-        if (npmVersion && npmVersion !== AWK_VERSION) {
+        const updates = await depManager.checkUpdates(AWK_VERSION);
+        if (updates.latestAwkit && isNewerVersion(updates.latestAwkit, AWK_VERSION)) {
             log('');
-            log(`${C.yellow}${C.bold}🌟 [Thông báo] Có phiên bản mới cho AWKit! (v${npmVersion})${C.reset}`);
+            log(`${C.yellow}${C.bold}🌟 [Thông báo] Có phiên bản mới cho AWKit! (v${updates.latestAwkit})${C.reset}`);
             log(`${C.gray}   Phiên bản hiện tại: v${AWK_VERSION}${C.reset}`);
             log(`${C.gray}   Chạy lệnh sau để nâng cấp:${C.reset}`);
             log(`${C.cyan}   npm i -g @leejungkiin/awkit && awkit install${C.reset}`);
             log('');
         }
+        
+        const currentRtk = depManager.getRtkVersion();
+        if (updates.latestRtk && currentRtk && isNewerVersion(updates.latestRtk, currentRtk)) {
+            log('');
+            log(`${C.yellow}${C.bold}🌟 [Thông báo] Có phiên bản mới cho RTK! (v${updates.latestRtk})${C.reset}`);
+            log(`${C.gray}   Phiên bản hiện tại: v${currentRtk}${C.reset}`);
+            log(`${C.gray}   Chạy lệnh sau để nâng cấp:${C.reset}`);
+            log(`${C.cyan}   awkit rtk setup${C.reset}`);
+            log('');
+        }
     } catch (_) {
-        // Fail silently (offline, npm not installed, package not published yet)
+        // Fail silently in auto check
     }
 }
 
@@ -3585,7 +4062,7 @@ function cmdGitnexus(args) {
             const registry = readGitnexusRegistry();
             if (registry.length === 0) {
                 info('No GitNexus indexed repositories found.');
-                dim('Run `npx gitnexus analyze` in a project to index it.');
+                dim('Run `pnpm dlx gitnexus analyze` or `npx gitnexus analyze` in a project to index it.');
                 return;
             }
 
@@ -3618,7 +4095,7 @@ function cmdGitnexus(args) {
 
             if (!match) {
                 warn('Current directory is not indexed by GitNexus.');
-                dim('Run `npx gitnexus analyze` to index this project.');
+                dim('Run `pnpm dlx gitnexus analyze` or `npx gitnexus analyze` to index this project.');
                 return;
             }
 
@@ -3644,7 +4121,7 @@ function cmdGitnexus(args) {
             if (stale) {
                 log('');
                 warn(`Index is ${ageDays} days old. Consider refreshing:`);
-                dim('  npx gitnexus analyze');
+                dim('  pnpm dlx gitnexus analyze  (or npx gitnexus analyze)');
             }
 
             // Show projectId from .project-identity if available
@@ -3854,9 +4331,34 @@ function cmdGitnexus(args) {
             break;
         }
 
+        case 'index':
+        case 'analyze':
+        case 'build': {
+            const cwd = process.cwd();
+            const usePnpm = fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'));
+            const indexCmd = usePnpm ? 'pnpm' : 'npx';
+            const indexArgs = usePnpm ? ['dlx', 'gitnexus', 'analyze'] : ['-y', 'gitnexus', 'analyze'];
+            
+            info(`Indexing codebase with GitNexus (${usePnpm ? 'pnpm' : 'npx'})...`);
+            dim(`Running: ${indexCmd} ${indexArgs.join(' ')}`);
+            
+            const result = spawnSync(indexCmd, indexArgs, {
+                cwd,
+                stdio: 'inherit',
+                shell: true
+            });
+            
+            if (result.status === 0) {
+                ok('GitNexus index successfully refreshed! ✨');
+            } else {
+                err(`GitNexus indexing failed with exit code ${result.status}`);
+            }
+            break;
+        }
+
         default:
             err(`Unknown gitnexus sub-command: ${sub}`);
-            log(`  Available: list, status, clean`);
+            log(`  Available: index, list, status, clean`);
             break;
     }
 }
@@ -3868,43 +4370,77 @@ async function cmdRtkSetup() {
     log(`${C.cyan}${C.bold}║          ⚙️  RTK Auto-Setup & Configuration           ║${C.reset}`);
     log(`${C.cyan}${C.bold}╚═══════════════════════════════════════════════════════╝${C.reset}`);
 
-    log(`\nChecking dependencies...`);
-    try {
-        execSync('which cargo', { stdio: 'ignore' });
-        ok('Cargo is installed.');
-    } catch (_) {
-        err('Cargo/Rust not found. Please install Rust (https://rustup.rs/) and retry.');
-        return;
-    }
-
-    log(`\nInstalling RTK (Rust Token Killer) via Cargo...`);
-    try {
-        execSync('cargo install --git https://github.com/rtk-ai/rtk', { stdio: 'inherit' });
-        ok('RTK successfully installed/updated via Cargo.');
-    } catch (e) {
-        err(`Failed to install RTK: ${e.message}`);
-        return;
-    }
+    const installed = depManager.installRtk();
+    if (!installed) return;
 
     const zshrcPath = path.join(HOME, '.zshrc');
     log(`\nConfiguring Shell Aliases in ~/.zshrc...`);
     if (fs.existsSync(zshrcPath)) {
-        const zshrc = fs.readFileSync(zshrcPath, 'utf8');
-        const aliasBlock = `
-# RTK Alias for AI Agents (AWKit)
-alias git="rtk git"
-alias npm="rtk npm"
-alias pnpm="rtk pnpm"
-alias yarn="rtk yarn"
-alias cargo="rtk cargo"
+        let zshrc = fs.readFileSync(zshrcPath, 'utf8');
+        
+        // Clean up old aliases to avoid collision
+        const oldAliases = [
+            'alias git="rtk git"',
+            'alias npm="rtk npm"',
+            'alias pnpm="rtk pnpm"',
+            'alias yarn="rtk yarn"',
+            'alias cargo="rtk cargo"'
+        ];
+        for (const oldAlias of oldAliases) {
+            if (zshrc.includes(oldAlias)) {
+                zshrc = zshrc.replace(new RegExp(`\\n?${oldAlias}\\n?`, 'g'), '\n');
+            }
+        }
+
+        const functionBlock = `
+# RTK Integration for AI Agents (AWKit)
+unalias npm pnpm yarn cargo git 2>/dev/null
+npm() {
+    if [[ "$1" == "login" || "$1" == "adduser" || "$1" == "publish" ]]; then
+        command npm "$@"
+    else
+        rtk npm "$@"
+    fi
+}
+pnpm() {
+    if [[ "$1" == "login" || "$1" == "publish" ]]; then
+        command pnpm "$@"
+    else
+        rtk pnpm "$@"
+    fi
+}
+yarn() {
+    if [[ "$1" == "login" || "$1" == "publish" ]]; then
+        command yarn "$@"
+    else
+        rtk yarn "$@"
+    fi
+}
+cargo() {
+    if [[ "$1" == "login" || "$1" == "publish" ]]; then
+        command cargo "$@"
+    else
+        rtk cargo "$@"
+    fi
+}
+git() {
+    if [[ "$1" == "rebase" ]]; then
+        command git "$@"
+    else
+        rtk git "$@"
+    fi
+}
 `;
-        if (zshrc.includes('alias git="rtk git"')) {
-            ok('Aliases already present in ~/.zshrc.');
-        } else {
-            fs.appendFileSync(zshrcPath, aliasBlock, 'utf8');
-            ok('Shell aliases successfully added to ~/.zshrc.');
-            log(`\n${C.cyan}Please reload your shell (source ~/.zshrc) to apply shifts.${C.reset}`);
+        // Clean up old RTK integration block if exists to allow updating
+        if (zshrc.includes('# RTK Integration for AI Agents (AWKit)')) {
+            const startIdx = zshrc.indexOf('# RTK Integration for AI Agents (AWKit)');
+            zshrc = zshrc.substring(0, startIdx);
         }
+        
+        zshrc += functionBlock;
+        fs.writeFileSync(zshrcPath, zshrc, 'utf8');
+        ok('Shell wrappers successfully added/updated in ~/.zshrc.');
+        log(`\n${C.cyan}Please reload your shell (source ~/.zshrc) to apply shifts.${C.reset}`);
     } else {
         warn('~/.zshrc not found. Skipping alias setup.');
     }
@@ -3920,6 +4456,138 @@ async function cmdRtk(args) {
     }
 }
 
+// ─── Project Identity CLI View ───────────────────────────────────────────────
+
+function cmdIdentity(args = []) {
+    const cwd = process.cwd();
+    const identityPath = path.join(cwd, '.project-identity');
+
+    if (!fs.existsSync(identityPath)) {
+        err('No .project-identity found in the current directory.');
+        log(`  Run ${C.cyan}awkit init${C.reset} to create one for this project.`);
+        return;
+    }
+
+    try {
+        const raw = fs.readFileSync(identityPath, 'utf8');
+        const identity = JSON.parse(raw);
+
+        // Handle specific field querying
+        if (args.length > 0) {
+            const query = args[0];
+
+            if (query === '--keys') {
+                console.log(Object.keys(identity).join('\n'));
+                return;
+            }
+
+            if (query === '--json') {
+                console.log(JSON.stringify(identity, null, 2));
+                return;
+            }
+
+            // Helper to get nested value by dot notation (e.g., automation.build.enabled)
+            const getNested = (obj, path) => {
+                return path.split('.').reduce((acc, part) => acc && acc[part], obj);
+            };
+
+            const val = getNested(identity, query);
+            if (val !== undefined) {
+                if (typeof val === 'object') {
+                    console.log(JSON.stringify(val));
+                } else {
+                    console.log(val);
+                }
+            }
+            return; // Exit silently if undefined, ideal for bash scripts
+        }
+
+        const border = `${C.cyan}${C.bold}╔═══════════════════════════════════════════════════════╗${C.reset}`;
+        const bottom = `${C.cyan}${C.bold}╚═══════════════════════════════════════════════════════╝${C.reset}`;
+        const line = `${C.gray}${'─'.repeat(56)}${C.reset}`;
+
+        log('');
+        log(border);
+        log(`${C.cyan}${C.bold}║ 🆔  PROJECT IDENTITY: ${C.green}${C.bold}${String(identity.projectName || 'Unnamed Project').padEnd(30)}${C.cyan}${C.bold} ║${C.reset}`);
+        log(bottom);
+        log('');
+
+        // Basic Info
+        log(`${C.bold}ℹ️   Basic Information${C.reset}`);
+        log(line);
+        log(`  ${C.bold}Project Stage:${C.reset}      ${identity.projectStage || 'development'}`);
+        log(`  ${C.bold}Project Type:${C.reset}       ${identity.projectType ? C.green + identity.projectType + C.reset : C.yellow + 'Not configured' + C.reset}`);
+        log(`  ${C.bold}Primary Lang:${C.reset}       ${identity.primaryLanguage || 'en'}`);
+        if (identity.techStack) {
+            const rt = Array.isArray(identity.techStack.runtime) ? identity.techStack.runtime.join(', ') : 'N/A';
+            const lang = Array.isArray(identity.techStack.languages) ? identity.techStack.languages.join(', ') : 'N/A';
+            log(`  ${C.bold}Runtime/Lang:${C.reset}       ${rt} / ${lang}`);
+        }
+        log('');
+
+        // Build Configuration
+        log(`${C.bold}🛠️   Build & Run Control${C.reset}`);
+        log(line);
+        if (identity.automation && identity.automation.build) {
+            const b = identity.automation.build;
+            const statusStr = b.enabled ? `${C.green}Enabled (Safe Auto-Run via awkit build)${C.reset}` : `${C.yellow}Disabled / Manual Only${C.reset}`;
+            log(`  ${C.bold}Build Control:${C.reset}      ${statusStr}`);
+            log(`  ${C.bold}Build Command:${C.reset}      ${C.cyan}${b.command || 'N/A'}${C.reset}`);
+        } else {
+            log(`  ${C.bold}Build Control:${C.reset}      ${C.yellow}Not Configured (Manual Mode)${C.reset}`);
+        }
+        if (identity.automation && identity.automation.run) {
+            const r = identity.automation.run;
+            const statusStr = r.enabled ? `${C.green}Enabled (Safe Auto-Run via awkit run)${C.reset}` : `${C.yellow}Disabled / Manual Only${C.reset}`;
+            log(`  ${C.bold}Run Control:${C.reset}        ${statusStr}`);
+            log(`  ${C.bold}Run Command:${C.reset}        ${C.cyan}${r.command || 'N/A'}${C.reset}`);
+        } else {
+            log(`  ${C.bold}Run Control:${C.reset}        ${C.yellow}Not Configured (Manual Mode)${C.reset}`);
+        }
+        log('');
+
+        // Automation Gates
+        log(`${C.bold}🔒  Automation & Sync Gates${C.reset}`);
+        log(line);
+        if (identity.automation) {
+            const git = identity.automation.git || {};
+            log(`  ${C.bold}Git AutoCommit:${C.reset}     ${git.autoCommit ? C.green + 'true' : C.red + 'false'}${C.reset}`);
+            log(`  ${C.bold}Git AutoPush:${C.reset}       ${git.autoPush ? C.green + 'true' : C.red + 'false'}${C.reset}`);
+
+            const trello = identity.automation.trello || {};
+            const syncStr = trello.enabled 
+                ? `${C.green}Enabled${C.reset} (AutoSync: ${trello.autoSync ? C.green + 'true' : C.red + 'false'}${C.reset})`
+                : `${C.red}Disabled${C.reset}`;
+            log(`  ${C.bold}Trello Sync:${C.reset}        ${syncStr}`);
+            if (identity.trello) {
+                log(`  ${C.bold}Trello Board:${C.reset}       ${identity.trello.board || 'N/A'}`);
+                log(`  ${C.bold}Trello Card:${C.reset}        ${identity.trello.card || 'N/A'}`);
+            }
+
+            const tg = identity.automation.telegram || {};
+            const tgStr = tg.enabled ? `${C.green}Enabled${C.reset}` : `${C.red}Disabled${C.reset}`;
+            log(`  ${C.bold}Telegram Alerts:${C.reset}    ${tgStr}`);
+            if (tg.triggers) {
+                const trigs = Object.keys(tg.triggers).filter(k => tg.triggers[k]).join(', ');
+                log(`  ${C.bold}Alert Triggers:${C.reset}     ${C.gray}${trigs || 'None'}${C.reset}`);
+            }
+        }
+        log('');
+
+        // Caveman Mode
+        if (identity.communication && identity.communication.cavemanMode) {
+            const cm = identity.communication.cavemanMode;
+            log(`${C.bold}💬  Communication Mode${C.reset}`);
+            log(line);
+            log(`  ${C.bold}Caveman Mode:${C.reset}       ${cm.enabled ? C.green + 'Enabled (' + cm.level + ')' : C.red + 'Disabled'}${C.reset}`);
+            log('');
+        }
+
+    } catch (e) {
+        err(`Failed to parse .project-identity: ${e.message}`);
+    }
+}
+
 // ─── Native HTTP Server ───────────────────────────────────────────────────────
 
 function cmdServe(args) {
@@ -4012,15 +4680,354 @@ function cmdServe(args) {
     });
 }
 
-// ─── Main ────────────────────────────────────────────────────────────────────
+const GLOBAL_CONFIG_PATH = path.join(HOME, '.awkit_config.json');
+
+function readGlobalConfig() {
+    const defaultConf = {
+        audioAlerts: true,
+        runners: {
+            claude: true,
+            codex: true,
+            qwen: true
+        }
+    };
+    if (!fs.existsSync(GLOBAL_CONFIG_PATH)) return defaultConf;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(GLOBAL_CONFIG_PATH, 'utf8'));
+        return {
+            ...defaultConf,
+            ...parsed,
+            runners: {
+                ...defaultConf.runners,
+                ...(parsed.runners || {})
+            }
+        };
+    } catch (_) {
+        return defaultConf;
+    }
+}
 
-// Check for updates (max once per day) before continuing
-checkAutoUpdate();
+function writeGlobalConfig(config) {
+    try {
+        fs.writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf8');
+        return true;
+    } catch (e) {
+        err(`Failed to write global config: ${e.message}`);
+        return false;
+    }
+}
+
+function findClaudePath() {
+    let localConfig = {};
+    try {
+        const p = path.join(process.cwd(), '.project-identity');
+        if (fs.existsSync(p)) {
+            localConfig = JSON.parse(fs.readFileSync(p, 'utf8'));
+        }
+    } catch (_) {}
+
+    if (localConfig.automation?.multiAgent?.runners?.claude) {
+        const p = localConfig.automation.multiAgent.runners.claude;
+        if (fs.existsSync(p)) return p;
+    }
+    const homeClaude = path.join(os.homedir(), '.claude', 'local', 'claude');
+    if (fs.existsSync(homeClaude)) return homeClaude;
+
+    try {
+        const shell = process.env.SHELL || '/bin/zsh';
+        const shellCmd = shell.endsWith('zsh') ? 'zsh -lc "which claude"' : 'bash -lc "which claude"';
+        const detected = execSync(shellCmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        if (detected && fs.existsSync(detected)) return detected;
+    } catch (_) {}
+
+    return 'claude';
+}
+
+function findCodexPath() {
+    let localConfig = {};
+    try {
+        const p = path.join(process.cwd(), '.project-identity');
+        if (fs.existsSync(p)) {
+            localConfig = JSON.parse(fs.readFileSync(p, 'utf8'));
+        }
+    } catch (_) {}
+
+    if (localConfig.automation?.multiAgent?.runners?.codex) {
+        const p = localConfig.automation.multiAgent.runners.codex;
+        if (fs.existsSync(p)) return p;
+    }
+    try {
+        const shell = process.env.SHELL || '/bin/zsh';
+        const shellCmd = shell.endsWith('zsh') ? 'zsh -lc "which codex"' : 'bash -lc "which codex"';
+        const detected = execSync(shellCmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        if (detected && fs.existsSync(detected)) return detected;
+    } catch (_) {}
+    return 'codex';
+}
+
+function findQwenPath() {
+    let localConfig = {};
+    try {
+        const p = path.join(process.cwd(), '.project-identity');
+        if (fs.existsSync(p)) {
+            localConfig = JSON.parse(fs.readFileSync(p, 'utf8'));
+        }
+    } catch (_) {}
+
+    if (localConfig.automation?.multiAgent?.runners?.qwen) {
+        const p = localConfig.automation.multiAgent.runners.qwen;
+        if (fs.existsSync(p)) return p;
+    }
+    try {
+        const shell = process.env.SHELL || '/bin/zsh';
+        const shellCmd = shell.endsWith('zsh') ? 'zsh -lc "which qwen"' : 'bash -lc "which qwen"';
+        const detected = execSync(shellCmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+        if (detected && fs.existsSync(detected)) return detected;
+    } catch (_) {}
+    return 'qwen';
+}
+
+function isRunnerEnabled(runnerName) {
+    let localConfig = {};
+    try {
+        const p = path.join(process.cwd(), '.project-identity');
+        if (fs.existsSync(p)) {
+            localConfig = JSON.parse(fs.readFileSync(p, 'utf8'));
+        }
+    } catch (_) {}
+
+    const localVal = localConfig.automation?.multiAgent?.runnersEnabled?.[runnerName];
+    if (localVal !== undefined) return localVal;
+
+    const globalConfig = readGlobalConfig();
+    const globalVal = globalConfig.runners?.[runnerName];
+    if (globalVal !== undefined) return globalVal;
+
+    return true;
+}
+
+function isRunnerAvailable(runnerName) {
+    if (!isRunnerEnabled(runnerName)) return false;
+    let p;
+    if (runnerName === 'claude') p = findClaudePath();
+    else if (runnerName === 'codex') p = findCodexPath();
+    else if (runnerName === 'qwen') p = findQwenPath();
+    else return false;
+
+    if (fs.existsSync(p)) return true;
+    try {
+        execSync(`which ${p} || command -v ${p}`, { stdio: 'ignore' });
+        return true;
+    } catch (_) {
+        return false;
+    }
+}
+
+function cmdGlobalConfig(args = []) {
+    const sub = args[0];
+    if (sub === 'audio') {
+        const config = readGlobalConfig();
+        const action = args[1];
+        if (!action) {
+            info(`Audio Alerts: ${config.audioAlerts ? 'ON' : 'OFF'}`);
+            return;
+        }
+        if (action === 'on' || action === 'true' || action === '1') {
+            config.audioAlerts = true;
+            if (writeGlobalConfig(config)) {
+                ok('Audio alerts turned ON globally.');
+            }
+        } else if (action === 'off' || action === 'false' || action === '0') {
+            config.audioAlerts = false;
+            if (writeGlobalConfig(config)) {
+                ok('Audio alerts turned OFF globally.');
+            }
+        } else {
+            err(`Invalid audio option: ${action}. Use 'on' or 'off'.`);
+        }
+        return;
+    }
+
+    if (sub === 'claude' || sub === 'codex' || sub === 'qwen') {
+        const config = readGlobalConfig();
+        const action = args[1];
+        if (!action) {
+            info(`${sub.toUpperCase()} Runner: ${config.runners?.[sub] !== false ? 'ON' : 'OFF'}`);
+            return;
+        }
+        if (action === 'on' || action === 'true' || action === '1') {
+            config.runners = config.runners || {};
+            config.runners[sub] = true;
+            if (writeGlobalConfig(config)) {
+                ok(`${sub.toUpperCase()} runner turned ON globally.`);
+            }
+        } else if (action === 'off' || action === 'false' || action === '0') {
+            config.runners = config.runners || {};
+            config.runners[sub] = false;
+            if (writeGlobalConfig(config)) {
+                ok(`${sub.toUpperCase()} runner turned OFF globally.`);
+            }
+        } else {
+            err(`Invalid runner option: ${action}. Use 'on' or 'off'.`);
+        }
+        return;
+    }
+
+    if (sub === 'runners' || sub === 'runner') {
+        const line = `${C.gray}${'─'.repeat(60)}${C.reset}`;
+        log('');
+        log(`${C.cyan}${C.bold}🏃 RUNNER AGENTS STATUS${C.reset}`);
+        log(line);
+        
+        const runners = ['claude', 'codex', 'qwen'];
+        for (const r of runners) {
+            const enabled = isRunnerEnabled(r);
+            const path = r === 'claude' ? findClaudePath() : (r === 'codex' ? findCodexPath() : findQwenPath());
+            const available = isRunnerAvailable(r);
+            
+            const statusStr = enabled ? `${C.green}ON${C.reset}` : `${C.red}OFF${C.reset}`;
+            const availStr = available ? `${C.green}✅ Available${C.reset}` : `${C.red}❌ Unavailable${C.reset}`;
+            
+            log(`  ● ${C.bold}${r.padEnd(8)}${C.reset} Status: [${statusStr}]  Path: ${path.padEnd(30)} [${availStr}]`);
+        }
+        log('');
+        return;
+    }
+
+    if (sub === 'models' || sub === 'model') {
+        const line = `${C.gray}${'─'.repeat(60)}${C.reset}`;
+        log('');
+        log(`${C.cyan}${C.bold}🤖 MODEL ROUTING POLICY${C.reset}`);
+        log(line);
+
+        let localConfig = {};
+        let projectLoaded = false;
+        try {
+            const p = path.join(process.cwd(), '.project-identity');
+            if (fs.existsSync(p)) {
+                localConfig = JSON.parse(fs.readFileSync(p, 'utf8'));
+                projectLoaded = true;
+            }
+        } catch (_) {}
+
+        if (projectLoaded) {
+            log(`  Project:         ${C.green}${C.bold}${localConfig.projectName || 'Active Project'}${C.reset}`);
+            const policy = localConfig.modelPolicy || {};
+            log(`  Routing Mode:    ${C.cyan}${policy.mode || 'auto'}${C.reset}`);
+            log(`  Default Tier:    ${C.cyan}${policy.defaultTier || 'STANDARD'}${C.reset}`);
+            
+            if (policy.tierOverrides && Object.keys(policy.tierOverrides).length > 0) {
+                log(`  Tier Overrides:`);
+                for (const [pattern, tier] of Object.entries(policy.tierOverrides)) {
+                    log(`    * ${pattern.padEnd(20)} ➜ ${C.yellow}${tier}${C.reset}`);
+                }
+            }
+        } else {
+            log(`  No project loaded in current directory.`);
+        }
+        
+        log(line);
+        log(`  ${C.bold}Default Models:${C.reset}`);
+        log(`    * Standard execution:  ${C.green}gemini-3.5-flash${C.reset} (Fast & cost-efficient)`);
+        log(`    * Heavy / Spec tasks:  ${C.green}gemini-3.1-pro${C.reset} (High reasoning quality)`);
+        log(`    * Light tasks:         ${C.green}gemini-3.1-flash-lite${C.reset} (Ultra-low latency)`);
+        log('');
+        return;
+    }
+
+    if (!sub || sub === 'list') {
+        const config = readGlobalConfig();
+        const line = `${C.gray}${'─'.repeat(60)}${C.reset}`;
+        log('');
+        log(`${C.cyan}${C.bold}⚙️  AWK CLI CONFIGURATION${C.reset}`);
+        log(line);
+        
+        const formatBool = (val) => val !== false ? `${C.green}ON${C.reset}` : `${C.red}OFF${C.reset}`;
+        
+        log(`  ${C.bold}audioAlerts${C.reset.padEnd(20)} ${formatBool(config.audioAlerts).padEnd(15)} Play speech and chimes on complete`);
+        log(`  ${C.bold}runners.claude${C.reset.padEnd(20)} ${formatBool(config.runners?.claude).padEnd(15)} Use Claude Code CLI for planning`);
+        log(`  ${C.bold}runners.codex${C.reset.padEnd(20)} ${formatBool(config.runners?.codex).padEnd(15)} Use Codex CLI for UI and assets`);
+        log(`  ${C.bold}runners.qwen${C.reset.padEnd(20)} ${formatBool(config.runners?.qwen).padEnd(15)} Use Qwen Coder CLI for execution`);
+        log(line);
+        log(`💡 To toggle, run: ${C.cyan}awkit config <param> <on|off>${C.reset}`);
+        log(`   Example:        ${C.cyan}awkit config claude off${C.reset}`);
+        log('');
+        return;
+    }
+
+    if (sub === 'get' && args[1]) {
+        const config = readGlobalConfig();
+        const key = args[1];
+        let val;
+        if (key.includes('.')) {
+            val = key.split('.').reduce((acc, part) => acc && acc[part], config);
+        } else {
+            val = config[key];
+        }
+        if (val !== undefined) {
+            console.log(val);
+        } else {
+            err(`Key "${key}" not found in global config.`);
+        }
+        return;
+    }
+
+    if (sub === 'set' && args[1] && args[2] !== undefined) {
+        const config = readGlobalConfig();
+        const key = args[1];
+        let val = args[2];
+        if (val === 'true') val = true;
+        if (val === 'false') val = false;
+
+        if (key.includes('.')) {
+            const parts = key.split('.');
+            let current = config;
+            for (let i = 0; i < parts.length - 1; i++) {
+                current[parts[i]] = current[parts[i]] || {};
+                current = current[parts[i]];
+            }
+            current[parts[parts.length - 1]] = val;
+        } else {
+            config[key] = val;
+        }
+
+        if (writeGlobalConfig(config)) {
+            ok(`Global config updated: "${key}" = ${val}`);
+        }
+        return;
+    }
+
+    err('Usage:');
+    log('  awkit config list');
+    log('  awkit config get <key>');
+    log('  awkit config set <key> <value>');
+    log('  awkit config audio <on|off>');
+    log('  awkit config claude <on|off>');
+    log('  awkit config codex <on|off>');
+    log('  awkit config qwen <on|off>');
+    log('  awkit config runners');
+    log('  awkit config models');
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
 
 const [, , command, ...args] = process.argv;
 
 (async () => {
+    await checkAutoUpdate();
     switch (command) {
+        case 'build':
+            cmdBuild();
+            break;
+        case 'run':
+            cmdRun(args);
+            break;
+        case 'task':
+            cmdTask(args);
+            break;
+        case 'project':
+            cmdProject(args);
+            break;
         case 'init':
             await cmdInit(args.includes('--force'));
             break;
@@ -4037,13 +5044,23 @@ const [, , command, ...args] = process.argv;
             cmdSync();
             break;
         case 'status':
-            cmdStatus();
+            if (args[0] === 'gn' || args[0] === 'gitnexus') {
+                cmdGitnexus(['status']);
+            } else {
+                cmdStatus();
+            }
             break;
         case 'harvest':
             cmdHarvest(args.includes('--dry-run'));
             break;
         case 'doctor':
-            cmdDoctor();
+            await cmdDoctor();
+            break;
+        case 'storage':
+            cmdStorage(args);
+            break;
+        case 'pipeline':
+            cmdPipeline(args);
             break;
         case 'browser':
             cmdBrowser(args);
@@ -4079,6 +5096,16 @@ const [, , command, ...args] = process.argv;
         case 'creds':
             cmdCredentials(args);
             break;
+        case 'index':
+        case 'analyze':
+            cmdGitnexus(['index', ...args]);
+            break;
+        case 'clean':
+            cmdGitnexus(['clean', ...args]);
+            break;
+        case 'list':
+            cmdGitnexus(['list', ...args]);
+            break;
         case 'set-openrouter': {
             const key = args[0];
             if (!key) {
@@ -4094,6 +5121,10 @@ const [, , command, ...args] = process.argv;
         case 'rtk':
             await cmdRtk(args);
             break;
+        case 'i18n':
+            await cmdI18n(args);
+            break;
+
         case 'gitnexus':
         case 'gn':
             cmdGitnexus(args);
@@ -4116,6 +5147,31 @@ const [, , command, ...args] = process.argv;
         case 'restart':
             await cmdRestart();
             break;
+        case 'greet':
+            cmdGreet(args);
+            break;
+        case 'config-global':
+            cmdGlobalConfig(args);
+            break;
+        case 'identity':
+        case 'config':
+        case 'project': {
+            const isGlobalSub = command === 'config' && (
+                args.length === 0 ||
+                ['audio', 'claude', 'codex', 'qwen', 'runners', 'runner', 'models', 'model', 'list', 'get', 'set'].includes(args[0])
+            );
+            if (isGlobalSub) {
+                // If there are no arguments but a project identity exists, show project identity as default
+                if (args.length === 0 && fs.existsSync(path.join(process.cwd(), '.project-identity'))) {
+                    cmdIdentity(args);
+                } else {
+                    cmdGlobalConfig(args);
+                }
+            } else {
+                cmdIdentity(args);
+            }
+            break;
+        }
         case 'help':
         case '--help':
         case '-h':