@leejungkiin/awkit 1.1.2 → 1.1.3

package/bin/awk.js

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

package/bin/cline-generators.js

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

package/bin/codex-generators.js

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

package/package.json

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

package/skill-packs/superpowers/README.md

@@ -0,0 +1,59 @@
+# 🦸 Superpowers Skill Pack
+
+> Structured development workflows ported from Claude Code Superpowers.
+
+Origin: [skainguyen1412/antigravity-superpowers](https://github.com/skainguyen1412/antigravity-superpowers)
+
+---
+
+## Install
+
+```bash
+awk enable-pack superpowers
+```
+
+Installs 13 skills into `~/.gemini/antigravity/skills/`:
+
+| # | Skill | Purpose |
+|---|-------|---------|
+| 1 | `brainstorming` | Design-first exploration before creative work |
+| 2 | `executing-plans` | Load and execute plans with review checkpoints |
+| 3 | `finishing-a-development-branch` | Structured branch completion: merge/PR/keep/discard |
+| 4 | `receiving-code-review` | Technical evaluation of review feedback |
+| 5 | `requesting-code-review` | Structured review pass before merge |
+| 6 | `single-flow-task-execution` | **One-task-at-a-time with two-stage review loop** |
+| 7 | `systematic-debugging` | Root cause analysis before fixing |
+| 8 | `test-driven-development` | Red-Green-Refactor TDD cycle |
+| 9 | `using-git-worktrees` | Isolated workspaces via git worktrees |
+| 10 | `using-superpowers` | Skill-first routing and loading |
+| 11 | `verification-before-completion` | Evidence-based completion claims |
+| 12 | `writing-plans` | Create bite-sized implementation plans |
+| 13 | `writing-skills` | TDD-based skill authoring |
+
+---
+
+## Key Feature: Two-Stage Review Loop
+
+The `single-flow-task-execution` skill introduces a disciplined review process:
+
+1. **Implement** → Self-review → Commit
+2. **Spec compliance review** → "Did we build what was requested?"
+3. **Code quality review** → "Is the code clean and maintainable?"
+4. Both pass → Next task
+
+This prevents the common failure of "code is clean but doesn't match requirements."
+
+---
+
+## Overlap with AWF Skills
+
+| Superpowers Skill | AWF Equivalent | Recommendation |
+|-------------------|---------------|----------------|
+| `brainstorming` | `brainstorm-agent` | AWF version is more comprehensive (3 modes, Vietnamese) |
+| `using-superpowers` | `orchestrator` | AWF version has Symphony + NeuralMemory integration |
+
+Both versions can coexist — they have different names and slightly different trigger patterns.
+
+---
+
+*Superpowers Skill Pack for AWK · Ported from Claude Code*

package/skill-packs/superpowers/pack.json

@@ -0,0 +1,15 @@
+{
+    "name": "superpowers",
+    "auto_install": false,
+    "description": "Structured development workflows ported from Claude Code Superpowers: TDD, code review, planning, debugging, git worktree isolation, and two-stage review loops",
+    "origin": "https://github.com/skainguyen1412/antigravity-superpowers",
+    "requires": [],
+    "post_install": [],
+    "notes": {
+        "overlap": [
+            "brainstorming ↔ brainstorm-agent (AWF version is more comprehensive)",
+            "using-superpowers ↔ orchestrator (AWF version has Symphony integration)"
+        ],
+        "key_skill": "single-flow-task-execution — Two-stage review loop (spec compliance → code quality)"
+    }
+}