@leejungkiin/awkit 1.7.4 → 1.7.5

package/bin/awk.js

@@ -1945,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('');
 }
@@ -2026,6 +2042,63 @@ function cmdBuild() {
     }
 }
 
+// ─── 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 {
@@ -2115,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('');
@@ -2138,9 +2264,13 @@ function cmdHelp() {
             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}${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 (_) {}
@@ -2158,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
@@ -2169,6 +2303,7 @@ function cmdHelp() {
     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
@@ -2195,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
@@ -2222,11 +2368,23 @@ function cmdHelp() {
     log('');
 
     // Pipeline
-    log(`${C.bold}🔗  Pipeline${C.reset}`);
+    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 (Opus 4.6 via agy)`);
-    log(`  ${C.green}pipeline ui${C.reset} <Feature>     Thiết kế shell & GUI assets (Codex)`);
-    log(`  ${C.green}pipeline code${C.reset} <Feature>   Thực thi viết code & review (Gemini + Critic)`);
+    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
@@ -2252,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
@@ -4172,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;
     }
 }
@@ -4352,6 +4536,14 @@ function cmdIdentity(args = []) {
         } 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
@@ -4488,6 +4680,335 @@ function cmdServe(args) {
     });
 }
 
+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;
+    }
+}
+
+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;
@@ -4498,6 +5019,15 @@ const [, , command, ...args] = process.argv;
         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;
@@ -4514,7 +5044,11 @@ 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'));
@@ -4562,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) {
@@ -4603,11 +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':
-            cmdIdentity(args);
+        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':