@leejungkiin/awkit 1.6.2 → 1.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leejungkiin/awkit",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "description": "Antigravity Workflow Kit v12.5. Unified AI agent orchestration system with Mindful Checkpoints.",
   "main": "bin/awk.js",
   "bin": {
@@ -33,11 +33,12 @@
     "schemas/",
     "templates/",
     "docs/",
+    "scripts/",
     "README.md",
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@leejungkiin/awkit-symphony": "^1.5.0",
+    "@leejungkiin/awkit-symphony": "^0.1.0",
     "@duytransipher/gitnexus": "latest"
   }
 }

package/scripts/automation-gate.js

@@ -0,0 +1,384 @@
+#!/usr/bin/env node
+
+/**
+ * Automation Gate — Enforces .project-identity automation config.
+ *
+ * Reads automation.git / automation.trello / automation.telegram from
+ * .project-identity BEFORE executing any operation. Blocks if disabled.
+ *
+ * Usage (via awkit CLI):
+ *   awkit gate git commit "feat: add feature"
+ *   awkit gate git push
+ *   awkit gate git auto "feat: add feature"
+ *   awkit gate trello complete "Task name"
+ *   awkit gate trello comment "Note"
+ *   awkit gate telegram send "Message"
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// ─── Color helpers (borrowed from main CLI) ──────────────────────────────────
+
+const C = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+    bold: '\x1b[1m',
+};
+
+const log = (msg) => console.log(msg);
+const ok = (msg) => log(`${C.green}✔${C.reset} ${msg}`);
+const warn = (msg) => log(`${C.yellow}⚠${C.reset} ${msg}`);
+const err = (msg) => log(`${C.red}✖${C.reset} ${msg}`);
+const info = (msg) => log(`${C.cyan}ℹ${C.reset} ${msg}`);
+const dim = (msg) => log(`${C.gray}${msg}${C.reset}`);
+
+// ─── .project-identity reader ─────────────────────────────────────────────────
+
+/**
+ * Walk up directories from `startDir` to find .project-identity.
+ * Returns parsed JSON or null.
+ */
+function readProjectIdentity(startDir = process.cwd()) {
+    let dir = path.resolve(startDir);
+    const root = path.parse(dir).root;
+
+    while (dir !== root) {
+        const candidate = path.join(dir, '.project-identity');
+        if (fs.existsSync(candidate)) {
+            try {
+                return JSON.parse(fs.readFileSync(candidate, 'utf8'));
+            } catch (e) {
+                warn(`Failed to parse ${candidate}: ${e.message}`);
+                return null;
+            }
+        }
+        dir = path.dirname(dir);
+    }
+    return null;
+}
+
+// ─── Gate checker ─────────────────────────────────────────────────────────────
+
+/**
+ * Check if an automation action is allowed.
+ *
+ * @param {string} domain - 'git' | 'trello' | 'telegram'
+ * @param {string} action - Domain-specific action name
+ * @returns {{ allowed: boolean, config: object|null, reason: string }}
+ */
+function checkGate(domain, action) {
+    const identity = readProjectIdentity();
+
+    if (!identity) {
+        return { allowed: true, config: null, reason: 'No .project-identity found — default allow' };
+    }
+
+    const automation = identity.automation;
+    if (!automation) {
+        return { allowed: true, config: null, reason: 'No automation config — default allow' };
+    }
+
+    switch (domain) {
+        case 'git': {
+            const gitConfig = automation.git;
+            if (!gitConfig) {
+                return { allowed: true, config: null, reason: 'No automation.git config — default allow' };
+            }
+            if (action === 'commit' && gitConfig.autoCommit === false) {
+                return { allowed: false, config: gitConfig, reason: 'automation.git.autoCommit is false' };
+            }
+            if (action === 'push' && gitConfig.autoPush === false) {
+                return { allowed: false, config: gitConfig, reason: 'automation.git.autoPush is false' };
+            }
+            return { allowed: true, config: gitConfig, reason: 'automation.git allows this action' };
+        }
+
+        case 'trello': {
+            const trelloConfig = automation.trello;
+            if (!trelloConfig) {
+                return { allowed: true, config: null, reason: 'No automation.trello config — default allow' };
+            }
+            if (trelloConfig.enabled === false || trelloConfig.autoSync === false) {
+                return { allowed: false, config: trelloConfig, reason: 'automation.trello is disabled (enabled=false or autoSync=false)' };
+            }
+            // Check trigger-level gates
+            if (trelloConfig.triggers) {
+                const triggerMap = {
+                    'complete': 'task_complete',
+                    'comment': 'milestone',
+                    'block': 'blocked',
+                };
+                const trigger = triggerMap[action];
+                if (trigger && trelloConfig.triggers[trigger] === false) {
+                    return { allowed: false, config: trelloConfig, reason: `automation.trello.triggers.${trigger} is false` };
+                }
+            }
+            return { allowed: true, config: trelloConfig, reason: 'automation.trello allows this action' };
+        }
+
+        case 'telegram': {
+            const tgConfig = automation.telegram;
+            if (!tgConfig) {
+                return { allowed: true, config: null, reason: 'No automation.telegram config — default allow' };
+            }
+            if (tgConfig.enabled === false) {
+                return { allowed: false, config: tgConfig, reason: 'automation.telegram.enabled is false' };
+            }
+            // Check trigger-level gates
+            if (tgConfig.triggers && action !== 'send') {
+                const triggerMap = {
+                    'git_push': 'git_push',
+                    'task_complete': 'task_complete',
+                    'deploy': 'deploy',
+                };
+                const trigger = triggerMap[action];
+                if (trigger && tgConfig.triggers[trigger] === false) {
+                    return { allowed: false, config: tgConfig, reason: `automation.telegram.triggers.${trigger} is false` };
+                }
+            }
+            return { allowed: true, config: tgConfig, reason: 'automation.telegram allows this action' };
+        }
+
+        default:
+            return { allowed: true, config: null, reason: `Unknown domain '${domain}' — default allow` };
+    }
+}
+
+// ─── Git executors ────────────────────────────────────────────────────────────
+
+function execGitCommit(message) {
+    const gate = checkGate('git', 'commit');
+    if (!gate.allowed) {
+        err(`🚫 GIT COMMIT BLOCKED: ${gate.reason}`);
+        dim('  Modify .project-identity automation.git.autoCommit to change this.');
+        return false;
+    }
+
+    try {
+        execSync('git add -A', { stdio: 'inherit' });
+        execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, { stdio: 'inherit' });
+        ok(`Committed: ${message}`);
+        return true;
+    } catch (e) {
+        // git commit returns non-zero if nothing to commit
+        if (e.status === 1) {
+            warn('Nothing to commit (working tree clean).');
+            return true;
+        }
+        err(`Git commit failed: ${e.message}`);
+        return false;
+    }
+}
+
+function execGitPush() {
+    const gate = checkGate('git', 'push');
+    if (!gate.allowed) {
+        err(`🚫 GIT PUSH BLOCKED: ${gate.reason}`);
+        dim('  Modify .project-identity automation.git.autoPush to change this.');
+        return false;
+    }
+
+    try {
+        execSync('git push', { stdio: 'inherit' });
+        ok('Pushed successfully.');
+        return true;
+    } catch (e) {
+        warn('Push failed. Retrying with git pull --rebase...');
+        try {
+            execSync('git pull --rebase && git push', { stdio: 'inherit' });
+            ok('Pushed successfully after rebase.');
+            return true;
+        } catch (e2) {
+            err(`Push failed after retry: ${e2.message}`);
+            err('Please resolve conflicts manually. DO NOT force push.');
+            return false;
+        }
+    }
+}
+
+function execGitAuto(message) {
+    log('');
+    log(`${C.cyan}${C.bold}🔒 Automation Gate — Git Auto${C.reset}`);
+    dim(`  Checking .project-identity...`);
+
+    const committed = execGitCommit(message);
+    if (!committed) return false;
+
+    const pushed = execGitPush();
+    if (!pushed) return false;
+
+    // Trigger Telegram notification if git_push trigger is enabled
+    const tgGate = checkGate('telegram', 'git_push');
+    if (tgGate.allowed) {
+        info('Triggering Telegram notification...');
+        try {
+            execSync(`awkit tg send "✅ Pushed: ${message.replace(/"/g, '\\"')}"`, { stdio: 'inherit' });
+        } catch (_) {
+            dim('Telegram notification skipped (not configured or failed).');
+        }
+    }
+
+    return true;
+}
+
+// ─── Trello executors ─────────────────────────────────────────────────────────
+
+function execTrelloAction(action, args) {
+    const gate = checkGate('trello', action);
+    if (!gate.allowed) {
+        err(`🚫 TRELLO ${action.toUpperCase()} BLOCKED: ${gate.reason}`);
+        dim('  Modify .project-identity automation.trello to change this.');
+        return false;
+    }
+
+    try {
+        const cmd = `awkit trello ${action} ${args.map(a => `"${a}"`).join(' ')}`;
+        execSync(cmd, { stdio: 'inherit' });
+        return true;
+    } catch (e) {
+        err(`Trello ${action} failed: ${e.message}`);
+        return false;
+    }
+}
+
+// ─── Telegram executor ────────────────────────────────────────────────────────
+
+function execTelegramSend(args) {
+    const gate = checkGate('telegram', 'send');
+    if (!gate.allowed) {
+        err(`🚫 TELEGRAM BLOCKED: ${gate.reason}`);
+        dim('  Modify .project-identity automation.telegram to change this.');
+        return false;
+    }
+
+    try {
+        const cmd = `awkit tg send ${args.map(a => `"${a}"`).join(' ')}`;
+        execSync(cmd, { stdio: 'inherit' });
+        return true;
+    } catch (e) {
+        err(`Telegram send failed: ${e.message}`);
+        return false;
+    }
+}
+
+// ─── CLI handler ──────────────────────────────────────────────────────────────
+
+function gateHelp() {
+    log('');
+    log(`${C.cyan}${C.bold}🔒 Automation Gate${C.reset}`);
+    log(`${C.gray}  Enforces .project-identity automation config before executing.${C.reset}`);
+    log('');
+    log(`  ${C.green}awkit gate git commit${C.reset} <message>     Gated git add + commit`);
+    log(`  ${C.green}awkit gate git push${C.reset}                  Gated git push`);
+    log(`  ${C.green}awkit gate git auto${C.reset} <message>       Commit + push + telegram`);
+    log('');
+    log(`  ${C.green}awkit gate trello complete${C.reset} <name>   Gated trello complete`);
+    log(`  ${C.green}awkit gate trello comment${C.reset} <text>    Gated trello comment`);
+    log(`  ${C.green}awkit gate trello block${C.reset} <reason>    Gated trello block`);
+    log('');
+    log(`  ${C.green}awkit gate telegram send${C.reset} <message>  Gated telegram send`);
+    log('');
+    log(`  ${C.green}awkit gate check${C.reset} <domain>           Check gate status (dry-run)`);
+    log('');
+}
+
+function gateCheck(domain) {
+    log('');
+    log(`${C.cyan}${C.bold}🔒 Gate Status — ${domain || 'all'}${C.reset}`);
+    log('');
+
+    const domains = domain ? [domain] : ['git', 'trello', 'telegram'];
+    const actions = {
+        git: ['commit', 'push'],
+        trello: ['complete', 'comment', 'block'],
+        telegram: ['send', 'git_push', 'task_complete', 'deploy'],
+    };
+
+    for (const d of domains) {
+        log(`  ${C.bold}${d}${C.reset}`);
+        for (const a of (actions[d] || [])) {
+            const gate = checkGate(d, a);
+            const icon = gate.allowed ? `${C.green}✔${C.reset}` : `${C.red}✖${C.reset}`;
+            log(`    ${icon} ${a}: ${C.gray}${gate.reason}${C.reset}`);
+        }
+        log('');
+    }
+}
+
+/**
+ * Main handler for `awkit gate` subcommand.
+ * @param {string[]} args - CLI args after 'gate'
+ */
+function cmdGate(args) {
+    const domain = args[0];
+    const action = args[1];
+    const rest = args.slice(2);
+
+    if (!domain || domain === 'help' || domain === '--help' || domain === '-h') {
+        gateHelp();
+        return;
+    }
+
+    if (domain === 'check') {
+        gateCheck(action); // action is optional domain filter
+        return;
+    }
+
+    switch (domain) {
+        case 'git':
+            switch (action) {
+                case 'commit':
+                    execGitCommit(rest.join(' ') || 'chore: update');
+                    break;
+                case 'push':
+                    execGitPush();
+                    break;
+                case 'auto':
+                    execGitAuto(rest.join(' ') || 'chore: update');
+                    break;
+                default:
+                    err(`Unknown git action: ${action}`);
+                    gateHelp();
+                    break;
+            }
+            break;
+
+        case 'trello':
+            if (!action || !rest.length) {
+                err(`Usage: awkit gate trello <action> <text>`);
+                gateHelp();
+                return;
+            }
+            execTrelloAction(action, rest);
+            break;
+
+        case 'telegram':
+        case 'tg':
+            if (action === 'send') {
+                execTelegramSend(rest);
+            } else {
+                err(`Unknown telegram action: ${action}`);
+                gateHelp();
+            }
+            break;
+
+        default:
+            err(`Unknown gate domain: ${domain}`);
+            gateHelp();
+            break;
+    }
+}
+
+// ─── Exports ──────────────────────────────────────────────────────────────────
+
+module.exports = {
+    cmdGate,
+    checkGate,
+    readProjectIdentity,
+};

package/scripts/bootstrap.js

@@ -0,0 +1,122 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME = os.homedir();
+const MAIN_AWF_DIR = path.join(__dirname, '..');
+
+// Nguồn v4 (Chi tiết, Persona, Auto-test loop)
+const AWF_V4_DIR = path.join(HOME, 'Dev', 'NodeJS', 'awf');
+// Nguồn v5 (Symphony, Brain, Fast execution)
+const ANTIGRAVITY_V5_DIR = path.join(HOME, '.gemini', 'antigravity');
+
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function copyFile(src, dest) {
+    if (fs.existsSync(src)) {
+        ensureDir(path.dirname(dest));
+        fs.copyFileSync(src, dest);
+        console.log(`✅ Copied: ${path.basename(dest)}`);
+        return true;
+    } else {
+        console.log(`❌ Source not found: ${src}`);
+        return false;
+    }
+}
+
+function copySkill(skillName, destDir) {
+    const destPath = path.join(MAIN_AWF_DIR, 'skills', destDir || skillName, 'SKILL.md');
+
+    // Try sources in order of priority
+    const sources = [
+        path.join(ANTIGRAVITY_V5_DIR, 'skills', `awf-${skillName}`, 'SKILL.md'),
+        path.join(ANTIGRAVITY_V5_DIR, 'skills', skillName, 'SKILL.md'),
+        path.join(AWF_V4_DIR, 'awf_skills', `awf-${skillName}`, 'SKILL.md')
+    ];
+
+    for (const src of sources) {
+        if (fs.existsSync(src)) {
+            ensureDir(path.dirname(destPath));
+            fs.copyFileSync(src, destPath);
+            console.log(`✅ Skill installed: ${skillName}`);
+            return;
+        }
+    }
+    console.log(`⚠️ Skill NOT found: ${skillName}`);
+}
+
+async function run() {
+    console.log('🚀 Bootstrapping AWF v6.0 Workflows & Skills...\n');
+
+    // 1. CURATE LIFECYCLE WORKFLOWS
+    console.log('--- Lifecycle Workflows ---');
+    // V4 is better for deep planning & coding
+    copyFile(path.join(AWF_V4_DIR, 'workflows', 'code.md'), path.join(MAIN_AWF_DIR, 'workflows', 'lifecycle', 'code.md'));
+    copyFile(path.join(AWF_V4_DIR, 'workflows', 'plan.md'), path.join(MAIN_AWF_DIR, 'workflows', 'lifecycle', 'plan.md'));
+    copyFile(path.join(AWF_V4_DIR, 'workflows', 'debug.md'), path.join(MAIN_AWF_DIR, 'workflows', 'lifecycle', 'debug.md'));
+    copyFile(path.join(AWF_V4_DIR, 'workflows', 'brainstorm.md'), path.join(MAIN_AWF_DIR, 'workflows', 'lifecycle', 'brainstorm.md'));
+    copyFile(path.join(AWF_V4_DIR, 'workflows', 'test.md'), path.join(MAIN_AWF_DIR, 'workflows', 'lifecycle', 'test.md'));
+    copyFile(path.join(AWF_V4_DIR, 'workflows', 'deploy.md'), path.join(MAIN_AWF_DIR, 'workflows', 'lifecycle', 'deploy.md'));
+    copyFile(path.join(AWF_V4_DIR, 'workflows', 'refactor.md'), path.join(MAIN_AWF_DIR, 'workflows', 'lifecycle', 'refactor.md'));
+    // V5 is better for init (has project-identity integration)
+    copyFile(path.join(ANTIGRAVITY_V5_DIR, 'global_workflows', 'init.md'), path.join(MAIN_AWF_DIR, 'workflows', 'lifecycle', 'init.md'));
+
+    // 2. CURATE CONTEXT WORKFLOWS
+    console.log('\n--- Context Workflows ---');
+    // Both from V5
+    copyFile(path.join(ANTIGRAVITY_V5_DIR, 'global_workflows', 'save-brain.md'), path.join(MAIN_AWF_DIR, 'workflows', 'context', 'save-brain.md'));
+    copyFile(path.join(ANTIGRAVITY_V5_DIR, 'global_workflows', 'recap.md'), path.join(MAIN_AWF_DIR, 'workflows', 'context', 'recap.md'));
+    copyFile(path.join(ANTIGRAVITY_V5_DIR, 'global_workflows', 'next.md'), path.join(MAIN_AWF_DIR, 'workflows', 'context', 'next.md'));
+
+    // 3. CURATE QUALITY & UI WORKFLOWS (From v5)
+    console.log('\n--- Quality & UI Workflows ---');
+    const v5Workflows = [
+        ['audit.md', 'quality'],
+        ['performance-audit.md', 'quality'],
+        ['ux-audit.md', 'quality'],
+        ['visualize.md', 'ui'],
+        ['design-to-ui.md', 'ui'],
+        ['ui-review.md', 'ui'],
+        ['ads-audit.md', 'ads'],
+        ['ads-optimize.md', 'ads'],
+        ['adsExpert.md', 'ads'],
+        ['git-commit-workflow.md', 'git', 'commit.md'],
+        ['hotfix.md', 'git'],
+        ['planExpert.md', 'expert'],
+        ['codeExpert.md', 'expert'],
+        ['debugExpert.md', 'expert']
+    ];
+
+    for (const [file, category, rename] of v5Workflows) {
+        const src = path.join(ANTIGRAVITY_V5_DIR, 'global_workflows', file);
+        const dest = path.join(MAIN_AWF_DIR, 'workflows', category, rename || file);
+        copyFile(src, dest);
+    }
+
+    // 4. CURATE META WORKFLOWS (From v4)
+    console.log('\n--- Meta Workflows ---');
+    copyFile(path.join(AWF_V4_DIR, 'workflows', 'customize.md'), path.join(MAIN_AWF_DIR, 'workflows', 'meta', 'customize.md'));
+    copyFile(path.join(AWF_V4_DIR, 'workflows', 'help.md'), path.join(MAIN_AWF_DIR, 'workflows', 'meta', 'help.md'));
+    copyFile(path.join(AWF_V4_DIR, 'workflows', 'awf-update.md'), path.join(MAIN_AWF_DIR, 'workflows', 'meta', 'awf-update.md'));
+    copyFile(path.join(AWF_V4_DIR, 'workflows', 'rollback.md'), path.join(MAIN_AWF_DIR, 'workflows', 'meta', 'rollback.md'));
+
+    // 5. CURATE CORE SKILLS
+    console.log('\n--- Core Skills ---');
+    const coreSkills = [
+        'session-restore',
+        'auto-save',
+        'adaptive-language',
+        'error-translator',
+        'context-help',
+        'symphony-orchestrator'
+    ];
+    for (const skill of coreSkills) {
+        copySkill(skill, skill);
+    }
+
+    console.log('\n✅ Bootstrap Complete! Essential framework files synchronized.');
+}
+
+run().catch(console.error);

package/scripts/harvest.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+/**
+ * AWK Harvest Script — Phase 1 Migration
+ * Pulls all workflows, skills, and GEMINI.md from the live ~/.gemini/antigravity/
+ * into main-awf/ so that main-awf becomes the Single Source of Truth.
+ *
+ * Usage: node scripts/harvest.js [--dry-run]
+ * Created by Kien AI
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME = os.homedir();
+const AWK_ROOT = path.join(__dirname, '..');
+const ANTIGRAVITY = path.join(HOME, '.gemini', 'antigravity');
+const GEMINI_MD_SRC = path.join(HOME, '.gemini', 'GEMINI.md');
+
+const DRY_RUN = process.argv.includes('--dry-run');
+
+// ─── Colors ───────────────────────────────────────────────────────────────────
+const C = {
+    reset: '\x1b[0m', red: '\x1b[31m', green: '\x1b[32m',
+    yellow: '\x1b[33m', cyan: '\x1b[36m', gray: '\x1b[90m', bold: '\x1b[1m',
+};
+const ok = (m) => console.log(`${C.green}✅ ${m}${C.reset}`);
+const warn = (m) => console.log(`${C.yellow}⚠️  ${m}${C.reset}`);
+const info = (m) => console.log(`${C.cyan}ℹ️  ${m}${C.reset}`);
+const dim = (m) => console.log(`${C.gray}   ${m}${C.reset}`);
+const err = (m) => console.log(`${C.red}❌ ${m}${C.reset}`);
+const head = (m) => console.log(`\n${C.cyan}${C.bold}── ${m} ──${C.reset}`);
+
+// ─── Workflow Category Map ─────────────────────────────────────────────────────
+// Maps workflow filename → destination category folder
+const WORKFLOW_CATEGORIES = {
+    // Lifecycle
+    'brainstorm.md': 'lifecycle', 'plan.md': 'lifecycle', 'planExpert.md': 'expert',
+    'code.md': 'lifecycle', 'codeExpert.md': 'expert', 'debug.md': 'lifecycle',
+    'debugExpert.md': 'expert', 'test.md': 'lifecycle', 'deploy.md': 'lifecycle',
+    'refactor.md': 'lifecycle', 'init.md': 'lifecycle', 'run.md': 'lifecycle',
+    'migration.md': 'lifecycle', 'hotfix.md': 'git',
+    // Context & Memory
+    'recap.md': 'context', 'next.md': 'context', 'save-brain.md': 'context',
+    'codebase-sync.md': 'context', 'auto-execution-workflow.md': 'context',
+    'auto-implement.md': 'context',
+    // Quality
+    'audit.md': 'quality', 'performance-audit.md': 'quality', 'ux-audit.md': 'quality',
+    'code-quality-rules.md': 'quality', 'accessibility-audit.md': 'quality',
+    'project-audit.md': 'quality', 'ui-review.md': 'quality', 'visual-debug.md': 'quality',
+    'bug-hunter.md': 'quality', 'code-janitor.md': 'quality', 'self-healing-test.md': 'quality',
+    // UI/UX
+    'visualize.md': 'ui', 'design-to-ui.md': 'ui', 'ui-first-methodology.md': 'ui',
+    'app-screen-analyzer.md': 'ui', 'create-feature.md': 'ui', 'feature-completion.md': 'ui',
+    'create-spec-architect.md': 'ui',
+    // Ads
+    'ads-audit.md': 'ads', 'ads-optimize.md': 'ads', 'adsExpert.md': 'ads',
+    'ads-analyst.md': 'ads', 'ads-targeting.md': 'ads', 'admob.md': 'ads',
+    'smali-ads-config.md': 'ads', 'smali-ads-flow.md': 'ads',
+    'smali-ads-interstitial.md': 'ads', 'smali-ads-native.md': 'ads',
+    // Mobile
+    'maestro-qa-workflow.md': 'mobile', 'maestro-test-workflow.md': 'mobile',
+    'turbo-mobile-build.md': 'mobile', 'app-analysis.md': 'mobile',
+    'structure-clean-architect.md': 'mobile',
+    // Git
+    'git-commit-workflow.md': 'git', 'smart-git-ops.md': 'git', 'rollback.md': 'git',
+    'release-notes.md': 'git', 'cloudflare-tunnel.md': 'git',
+    // Roles
+    'tech-lead-workflow.md': 'roles', 'product-manager-workflow.md': 'roles',
+    'qa-engineer-workflow.md': 'roles', 'ui-ux-designer-workflow.md': 'roles',
+    'vibe-coding-master-workflow.md': 'roles', 'oracle.md': 'roles',
+    // Meta / Config
+    'customize.md': 'meta', 'base-rules.md': 'meta', 'file-protection-rules.md': 'meta',
+    'project-identity-enforcement.md': 'meta', 'help.html': 'meta',
+    // Workflows & Logic
+    'plan.md': 'lifecycle', 'logic-reasoning-workflow.md': 'context',
+    'user-intent-analysis-workflow.md': 'context', 'master-code-workflow.md': 'lifecycle',
+};
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        if (!DRY_RUN) fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+
+function copyFile(src, dest, label) {
+    if (!fs.existsSync(src)) { warn(`Not found: ${label || path.basename(src)}`); return false; }
+    ensureDir(path.dirname(dest));
+    if (!DRY_RUN) fs.copyFileSync(src, dest);
+    dim(`${DRY_RUN ? '[DRY] ' : ''}${label || path.basename(src)}`);
+    return true;
+}
+
+function copyDirRecursive(src, dest) {
+    if (!fs.existsSync(src)) return 0;
+    ensureDir(dest);
+    let count = 0;
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        if (entry.name === '.DS_Store') continue;
+        if (entry.name === '.git') continue;
+        if (entry.name === '__pycache__') continue;
+        if (entry.name === 'node_modules') continue;
+        if (entry.name === '.venv') continue;
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            count += copyDirRecursive(srcPath, destPath);
+        } else {
+            if (!DRY_RUN) fs.copyFileSync(srcPath, destPath);
+            count++;
+        }
+    }
+    return count;
+}
+
+// ─── Main Harvest ─────────────────────────────────────────────────────────────
+async function harvest() {
+    console.log('');
+    console.log(`${C.cyan}${C.bold}╔══════════════════════════════════════════════════════════╗${C.reset}`);
+    console.log(`${C.cyan}${C.bold}║   🌾 AWK Harvest — Pulling from ~/.gemini/antigravity/   ║${C.reset}`);
+    console.log(`${C.cyan}${C.bold}╚══════════════════════════════════════════════════════════╝${C.reset}`);
+    if (DRY_RUN) warn('DRY RUN MODE — No files will be written');
+    console.log('');
+
+    // Verify source exists
+    if (!fs.existsSync(ANTIGRAVITY)) {
+        err(`Source not found: ${ANTIGRAVITY}`);
+        process.exit(1);
+    }
+
+    const stats = { workflows: 0, skills: 0, misc: 0 };
+
+    // ── 1. Harvest GEMINI.md ──────────────────────────────────────────────────
+    head('GEMINI.md');
+    if (fs.existsSync(GEMINI_MD_SRC)) {
+        const destGemini = path.join(AWK_ROOT, 'core', 'GEMINI.md');
+        // Backup existing
+        if (fs.existsSync(destGemini)) {
+            const bak = destGemini + '.bak';
+            if (!DRY_RUN) fs.copyFileSync(destGemini, bak);
+            dim(`Backed up existing → core/GEMINI.md.bak`);
+        }
+        copyFile(GEMINI_MD_SRC, destGemini, 'GEMINI.md → core/GEMINI.md');
+        ok('GEMINI.md harvested');
+        stats.misc++;
+    } else {
+        warn('GEMINI.md not found at ~/.gemini/GEMINI.md');
+    }
+
+    // ── 2. Harvest Workflows ──────────────────────────────────────────────────
+    head('Workflows (77 files → categorized)');
+    const wfSrc = path.join(ANTIGRAVITY, 'global_workflows');
+
+    if (!fs.existsSync(wfSrc)) {
+        err(`global_workflows not found: ${wfSrc}`);
+    } else {
+        const files = fs.readdirSync(wfSrc).filter(f => f.endsWith('.md') || f.endsWith('.html'));
+        let categorized = 0, uncategorized = 0;
+
+        for (const file of files) {
+            // Skip AGENTS.md — handled separately
+            if (file === 'AGENTS.md') continue;
+
+            const srcFile = path.join(wfSrc, file);
+            const category = WORKFLOW_CATEGORIES[file] || '_uncategorized';
+
+            if (!WORKFLOW_CATEGORIES[file]) {
+                uncategorized++;
+                dim(`→ _uncategorized/${file}`);
+            } else {
+                categorized++;
+            }
+
+            const destFile = path.join(AWK_ROOT, 'workflows', category, file);
+            copyFile(srcFile, destFile, `${file} → workflows/${category}/`);
+            stats.workflows++;
+        }
+
+        ok(`${stats.workflows} workflow files harvested (${categorized} categorized, ${uncategorized} → _uncategorized)`);
+    }
+
+    // ── 3. Harvest Skills ─────────────────────────────────────────────────────
+    head('Skills');
+    const skillSrc = path.join(ANTIGRAVITY, 'skills');
+
+    if (!fs.existsSync(skillSrc)) {
+        warn('skills/ not found in antigravity');
+    } else {
+        const skillDirs = fs.readdirSync(skillSrc, { withFileTypes: true })
+            .filter(d => d.isDirectory() && d.name !== '.DS_Store');
+
+        for (const skillDir of skillDirs) {
+            const src = path.join(skillSrc, skillDir.name);
+            const dest = path.join(AWK_ROOT, 'skills', skillDir.name);
+            const count = copyDirRecursive(src, dest);
+            dim(`${skillDir.name}/ (${count} files)`);
+            stats.skills++;
+        }
+
+        ok(`${stats.skills} skills harvested`);
+    }
+
+    // ── 4. Harvest brain/ambient-brain skill (special case in main-awf) ───────
+    head('Special Skills from main-awf legacy');
+    const ambientBrainSrc = path.join(AWK_ROOT, 'skills', 'ambient-brain');
+    if (fs.existsSync(ambientBrainSrc)) {
+        // Rename ambient-brain → memory-sync if memory-sync not already there from harvest
+        const memorySyncDest = path.join(AWK_ROOT, 'skills', 'memory-sync');
+        if (!fs.existsSync(memorySyncDest)) {
+            if (!DRY_RUN) fs.renameSync(ambientBrainSrc, memorySyncDest);
+            ok('ambient-brain → memory-sync (renamed)');
+        } else {
+            dim('memory-sync already exists (from harvest), ambient-brain kept for reference');
+        }
+    }
+
+    // ── 5. Harvest AGENTS.md ──────────────────────────────────────────────────
+    head('AGENTS.md');
+    const agentsSrc = path.join(ANTIGRAVITY, 'global_workflows', 'AGENTS.md');
+    if (fs.existsSync(agentsSrc)) {
+        copyFile(agentsSrc, path.join(AWK_ROOT, 'core', 'AGENTS.md'), 'AGENTS.md → core/AGENTS.md');
+        ok('AGENTS.md harvested');
+        stats.misc++;
+    }
+
+    // ── 6. Harvest schemas & templates ────────────────────────────────────────
+    head('Schemas & Templates');
+    const schemasSrc = path.join(ANTIGRAVITY, 'schemas');
+    if (fs.existsSync(schemasSrc)) {
+        const count = copyDirRecursive(schemasSrc, path.join(AWK_ROOT, 'schemas'));
+        ok(`${count} schemas harvested`);
+    }
+    const tmplSrc = path.join(ANTIGRAVITY, 'templates');
+    if (fs.existsSync(tmplSrc)) {
+        const count = copyDirRecursive(tmplSrc, path.join(AWK_ROOT, 'templates'));
+        ok(`${count} templates harvested`);
+    }
+
+    // ── Summary ───────────────────────────────────────────────────────────────
+    console.log('');
+    console.log(`${C.gray}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
+    console.log(`${C.yellow}${C.bold}🎉 Harvest Complete!${DRY_RUN ? ' (DRY RUN)' : ''}${C.reset}`);
+    console.log('');
+    dim(`Workflows: ${stats.workflows} files`);
+    dim(`Skills:    ${stats.skills} directories`);
+    dim(`Misc:      ${stats.misc} files (GEMINI.md, AGENTS.md)`);
+    console.log('');
+    console.log(`${C.cyan}Next: node scripts/rename-to-awk.js${C.reset}`);
+    console.log('');
+}
+
+harvest().catch(console.error);

package/scripts/rename-to-awk.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/**
+ * AWK Rename Script — Renames awf → awk throughout main-awf
+ * Updates: package.json, VERSION, copies awf.js → awk.js
+ * Created by Kien AI
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const AWK_ROOT = path.join(__dirname, '..');
+const C = {
+    reset: '\x1b[0m', green: '\x1b[32m', yellow: '\x1b[33m',
+    cyan: '\x1b[36m', gray: '\x1b[90m', bold: '\x1b[1m',
+};
+const ok = (m) => console.log(`${C.green}✅ ${m}${C.reset}`);
+const info = (m) => console.log(`${C.cyan}ℹ️  ${m}${C.reset}`);
+const dim = (m) => console.log(`${C.gray}   ${m}${C.reset}`);
+const head = (m) => console.log(`\n${C.cyan}${C.bold}── ${m} ──${C.reset}`);
+
+async function run() {
+    console.log('');
+    console.log(`${C.cyan}${C.bold}╔══════════════════════════════════════════════════════════╗${C.reset}`);
+    console.log(`${C.cyan}${C.bold}║         🔤 AWK Rename — awf → awk everywhere             ║${C.reset}`);
+    console.log(`${C.cyan}${C.bold}╚══════════════════════════════════════════════════════════╝${C.reset}`);
+    console.log('');
+
+    // ── 1. Update package.json ─────────────────────────────────────────────────
+    head('package.json');
+    const pkgPath = path.join(AWK_ROOT, 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+
+    pkg.name = '@zeroteam/awk';
+    pkg.version = '7.0.0';
+    pkg.description = 'AWK v7.0 — Antigravity Workflow Kit. Unified AI agent orchestration system.';
+    pkg.bin = { awk: 'bin/awk.js' };
+    pkg.scripts = {
+        ...pkg.scripts,
+        'install-global': 'node bin/awk.js install',
+        'uninstall-global': 'node bin/awk.js uninstall',
+        update: 'node bin/awk.js update',
+        test: 'node bin/awk.js doctor',
+        harvest: 'node scripts/harvest.js',
+        'harvest-dry': 'node scripts/harvest.js --dry-run',
+    };
+    pkg.keywords = ['awk', 'antigravity-workflow-kit', 'ai-agent', 'workflow', 'gemini', 'claude'];
+
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    ok('package.json updated → @zeroteam/awk v7.0.0');
+    dim('bin: { awk: "bin/awk.js" }');
+
+    // ── 2. Bump VERSION ────────────────────────────────────────────────────────
+    head('VERSION');
+    const versionPath = path.join(AWK_ROOT, 'VERSION');
+    fs.writeFileSync(versionPath, '7.0.0\n');
+    ok('VERSION → 7.0.0');
+
+    // ── 3. Copy awf.js → awk.js (with updated references) ─────────────────────
+    head('bin/awk.js');
+    const awfJsPath = path.join(AWK_ROOT, 'bin', 'awf.js');
+    const awkJsPath = path.join(AWK_ROOT, 'bin', 'awk.js');
+
+    let content = fs.readFileSync(awfJsPath, 'utf8');
+
+    // Update banner and references
+    content = content
+        .replace(/AWF v\$\{AWF_VERSION\}/g, 'AWK v${AWK_VERSION}')
+        .replace(/AWF v\$\{AWF_VERSION\}/g, 'AWK v${AWK_VERSION}')
+        .replace(/const AWF_VERSION/g, 'const AWK_VERSION')
+        .replace(/const AWF_ROOT/g, 'const AWK_ROOT')
+        .replace(/AWF_VERSION/g, 'AWK_VERSION')
+        .replace(/AWF_ROOT/g, 'AWK_ROOT')
+        .replace(/AWF v6\.0 CLI/g, 'AWK v7.0 CLI')
+        .replace(/AWF v6\.0 — Antigravity Workflow Framework/g, 'AWK v7.0 — Antigravity Workflow Kit')
+        .replace(/Antigravity Workflow Framework/g, 'Antigravity Workflow Kit')
+        .replace(/AWF v\$\{/g, 'AWK v${')
+        .replace(/AWF installed/g, 'AWK installed')
+        .replace(/AWF is healthy/g, 'AWK is healthy')
+        .replace(/AWF Health Check/g, 'AWK Health Check')
+        .replace(/\bawf\b(?! skills| v| update| version)/g, 'awk')
+        // Fix awf_version path reference
+        .replace(/awf_version/g, 'awk_version');
+
+    // Update TARGETS to use awk_version
+    content = content.replace(
+        "versionFile: path.join(HOME, '.gemini', 'awf_version')",
+        "versionFile: path.join(HOME, '.gemini', 'awk_version')"
+    );
+
+    // Update script header comment
+    content = content.replace(
+        `#!/usr/bin/env node
+
+/**
+ * AWF v6.0 CLI — Antigravity Workflow Framework`,
+        `#!/usr/bin/env node
+
+/**
+ * AWK v7.0 CLI — Antigravity Workflow Kit`
+    );
+
+    fs.writeFileSync(awkJsPath, content);
+    ok('bin/awk.js created');
+    dim('All AWF → AWK references updated');
+
+    // Make executable
+    try {
+        const { execSync } = require('child_process');
+        execSync(`chmod +x "${awkJsPath}"`);
+        ok('bin/awk.js is now executable');
+    } catch (e) {
+        // Ignore
+    }
+
+    // ── 4. Update core/GEMINI.md references ───────────────────────────────────
+    head('core/GEMINI.md — Update binary references');
+    const geminiPath = path.join(AWK_ROOT, 'core', 'GEMINI.md');
+    if (fs.existsSync(geminiPath)) {
+        let gemini = fs.readFileSync(geminiPath, 'utf8');
+        // Update references from awf install to awk install
+        gemini = gemini
+            .replace(/\bawf install\b/g, 'awk install')
+            .replace(/\bawf doctor\b/g, 'awk doctor')
+            .replace(/\bawf update\b/g, 'awk update')
+            .replace(/\bnode bin\/awf\.js\b/g, 'node bin/awk.js');
+        fs.writeFileSync(geminiPath, gemini);
+        ok('core/GEMINI.md binary references updated');
+    }
+
+    // ── 5. Summary ────────────────────────────────────────────────────────────
+    console.log('');
+    console.log(`${C.gray}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
+    console.log(`${C.yellow}${C.bold}🎉 Rename Complete! main-awf is now AWK v7.0${C.reset}`);
+    console.log('');
+    dim('Package:   @zeroteam/awk v7.0.0');
+    dim('Binary:    bin/awk.js');
+    dim('Command:   awk install / awk doctor / awk update');
+    console.log('');
+    console.log(`${C.cyan}Next: node bin/awk.js doctor${C.reset}`);
+    console.log('');
+}
+
+run().catch(console.error);