@leejungkiin/awkit 1.4.0 → 1.4.2

package/bin/awk.js

@@ -36,6 +36,7 @@ const HOME = process.env.HOME || process.env.USERPROFILE;
 
 const { generateClineRules, generateClineWorkflows, generateClineSkills } = require('./cline-generators');
 const { generateCodexAgentsMd, generateCodexSkills, generateCodexAgents } = require('./codex-generators');
+const { generateClaudeRules, generateClaudeSkills } = require('./claude-generators');
 
 // ─── Platform Definitions ──────────────────────────────────────────────────
 
@@ -73,6 +74,15 @@ const PLATFORMS = {
             agents: 'agents',
             skills: '../.agents/skills',
         },
+    },
+    claude: {
+        name: 'Claude Code',
+        globalRoot: process.cwd(), // Local to project
+        rulesFile: 'CLAUDE.md',
+        versionFile: '.claude/awk_version',
+        dirs: {
+            skills: '.claude/skills',
+        },
     }
 };
 
@@ -304,8 +314,9 @@ function cmdInstall(args = []) {
         selectedPlatforms = Object.keys(PLATFORMS);
     } else {
         if (args.includes('--gemini') || args.includes('-g') || args.includes('antigravity')) selectedPlatforms.push('antigravity');
-        if (args.includes('--claude') || args.includes('-c') || args.includes('cline')) selectedPlatforms.push('cline');
+        if (args.includes('--cline') || args.includes('cline')) selectedPlatforms.push('cline');
         if (args.includes('--codex') || args.includes('-x')) selectedPlatforms.push('codex');
+        if (args.includes('--claude-code') || args.includes('--claude') || args.includes('-c') || args.includes('claude')) selectedPlatforms.push('claude');
 
         const pIdx = args.indexOf('--platform');
         let legacyArg = null;
@@ -324,19 +335,21 @@ function cmdInstall(args = []) {
         if (isUpdate) {
             selectedPlatforms = [getActivePlatform()];
         } else {
-            log(`${C.cyan}Select platforms to install (e.g., type "1,2", "all", or "1,2,3"):${C.reset}`);
+            log(`${C.cyan}Select platforms to install (e.g., type "1,2", "all", or "1,2,3,4"):${C.reset}`);
             log(`  1. Gemini Code Assist (antigravity)`);
-            log(`  2. Claude Code (cline - local project)`);
+            log(`  2. Cline (VS Code)`);
             log(`  3. Codex CLI (codex)`);
-            log(`  4. All of the above`);
-            const choice = promptChoice('Choice', '4').trim().toLowerCase();
+            log(`  4. Claude Code (.claude/)`);
+            log(`  5. All of the above`);
+            const choice = promptChoice('Choice', '5').trim().toLowerCase();
             
-            if (choice === '4' || choice === 'all' || choice === '') {
+            if (choice === '5' || choice === 'all' || choice === '') {
                 selectedPlatforms = Object.keys(PLATFORMS);
             } else {
                 if (choice.includes('1')) selectedPlatforms.push('antigravity');
                 if (choice.includes('2')) selectedPlatforms.push('cline');
                 if (choice.includes('3')) selectedPlatforms.push('codex');
+                if (choice.includes('4')) selectedPlatforms.push('claude');
             }
         }
     }
@@ -391,6 +404,11 @@ function cmdInstall(args = []) {
     } else if (platform === 'codex') {
         info('Generating Codex AGENTS.md...');
         generateCodexAgentsMd(path.join(AWK_ROOT, 'core', 'GEMINI.md'), plat.rulesFile);
+    } else if (platform === 'claude') {
+        info('Generating Claude Code CLAUDE.md...');
+        const claudeTemplateSrc = path.join(AWK_ROOT, 'core', 'CLAUDE.md');
+        const claudeRulesDest = path.join(target, plat.rulesFile);
+        generateClaudeRules(claudeTemplateSrc, claudeRulesDest);
     }
 
     // 3. Backup and install workflows
@@ -444,6 +462,8 @@ function cmdInstall(args = []) {
             generateCodexSkills(skillsSrc, skillsDest);
             const agentsDest = path.join(target, plat.dirs.agents);
             generateCodexAgents(skillsSrc, agentsDest);
+        } else if (platform === 'claude') {
+            generateClaudeSkills(skillsSrc, skillsDest);
         } else {
             const skillCount = copyDirRecursive(skillsSrc, skillsDest);
             ok(`${skillCount} skill files installed`);
@@ -716,6 +736,77 @@ function cmdDoctor() {
     log('');
 }
 
+/**
+ * Handle browser-related tasks (e.g., cleaning up recordings).
+ */
+function cmdBrowser(args) {
+    if (args[0] !== 'clean') {
+        err('Unknown browser command. Use "awkit browser clean".');
+        return;
+    }
+
+    const recordingsDir = path.join(TARGETS.antigravity, 'browser_recordings');
+    
+    log('');
+    log(`${C.cyan}${C.bold}🧹 AWK Browser Cleanup${C.reset}`);
+    log('');
+
+    if (!fs.existsSync(recordingsDir)) {
+        ok(`No browser_recordings directory found at ${recordingsDir}. Nothing to clean.`);
+        return;
+    }
+
+    const files = fs.readdirSync(recordingsDir).filter(f => f.endsWith('.webm') || f.endsWith('.webp') || f.endsWith('.mp4'));
+    if (files.length === 0) {
+        ok('No browser recordings found. Nothing to clean.');
+        return;
+    }
+
+    let keepDays = 7; // default 7 days
+    const daysArgIdx = args.indexOf('--days');
+    if (daysArgIdx !== -1 && args[daysArgIdx + 1]) {
+        keepDays = parseInt(args[daysArgIdx + 1], 10);
+    } else if (args.includes('--all')) {
+        keepDays = 0;
+    }
+
+    if (keepDays === 0) {
+        log(`Cleaning ${C.yellow}ALL${C.reset} browser recordings...`);
+    } else {
+        log(`Cleaning browser recordings older than ${C.yellow}${keepDays} days${C.reset}...`);
+    }
+    
+    const now = Date.now();
+    const cutoff = now - (keepDays * 24 * 60 * 60 * 1000);
+    let deletedCount = 0;
+    let totalSizeFreed = 0;
+
+    for (const file of files) {
+        const filePath = path.join(recordingsDir, file);
+        try {
+            const stats = fs.statSync(filePath);
+            if (stats.mtimeMs < cutoff) {
+                totalSizeFreed += stats.size;
+                fs.unlinkSync(filePath);
+                deletedCount++;
+                dim(`Deleted: ${file}`);
+            }
+        } catch (e) {
+            warn(`Failed to process ${file}: ${e.message}`);
+        }
+    }
+
+    log('');
+    const sizeMb = (totalSizeFreed / (1024 * 1024)).toFixed(2);
+    if (deletedCount > 0) {
+        ok(`Cleaned ${C.green}${C.bold}${deletedCount}${C.reset} recording(s).`);
+        ok(`Freed ${C.green}${C.bold}${sizeMb} MB${C.reset} of disk space.`);
+    } else {
+        ok(`No recordings older than ${keepDays} days found. Disk space is already optimized.`);
+    }
+    log('');
+}
+
 /**
  * Find a compatible Python interpreter meeting the minimum version requirement.
  * Tries python3.13, python3.12, python3.11, python3, python in order.
@@ -1420,6 +1511,55 @@ async function cmdAdmin() {
     }
 }
 
+async function cmdRestart() {
+    info('Đang restart service awkit (Symphony)...');
+    try {
+        const { execSync, spawn } = require('child_process');
+        try {
+            // Find and kill process on port 3100
+            const pids = execSync('lsof -t -i:3100').toString().trim().split('\n');
+            for (const pid of pids) {
+                if (pid) {
+                    process.kill(parseInt(pid, 10), 'SIGTERM');
+                }
+            }
+            info('Đã dừng service hiện tại.');
+        } catch (e) {
+            // Probably no process running on port 3100
+            dim('Không tìm thấy service đang chạy.');
+        }
+        
+        await new Promise(r => setTimeout(r, 1000));
+        
+        // Auto-build production bundle so code changes take effect
+        const symphonyDir = path.join(AWK_ROOT, '..', 'symphony');
+        if (fs.existsSync(path.join(symphonyDir, 'package.json'))) {
+            info('Đang build production bundle...');
+            try {
+                execSync('npm run build', { cwd: symphonyDir, stdio: 'pipe' });
+                log(`${C.green}✅ Build thành công!${C.reset}`);
+            } catch (buildErr) {
+                warn('Build thất bại, sử dụng bundle cũ.');
+                dim(buildErr.message?.slice(0, 200));
+            }
+        }
+        
+        info('Đang khởi động lại service ngầm...');
+        const child = spawn('symphony', ['start'], {
+            detached: true,
+            stdio: 'ignore'
+        });
+        child.unref();
+        
+        info('Vui lòng đợi 3 giây để service khởi động...');
+        await new Promise(r => setTimeout(r, 3000));
+        
+        log(`${C.green}✅ Restart thành công!${C.reset}`);
+    } catch (e) {
+        err('Lỗi khi restart service: ' + e.message);
+    }
+}
+
 function cmdHelp() {
     const line = `${C.gray}${'─'.repeat(56)}${C.reset}`;
     log('');
@@ -1447,6 +1587,15 @@ function cmdHelp() {
     log(`  ${C.gray}             CODEBASE.md, .symphony/ (Symphony task DB)${C.reset}`);
     log('');
 
+    // Maintenance
+    log(`${C.bold}🧹  Maintenance${C.reset}`);
+    log(line);
+    log(`  ${C.green}serve${C.reset} [dir] [-p <port>] Start local HTTP server for assets in CWD`);
+    log(`  ${C.green}browser clean${C.reset}       Clean browser recordings`);
+    log(`  ${C.gray}  --days <N>${C.reset}         Keep recordings from last N days (default: 7)`);
+    log(`  ${C.gray}  --all${C.reset}              Delete all recordings`);
+    log('');
+
     // Sync
     log(`${C.bold}🔄  Sync${C.reset}`);
     log(line);
@@ -2219,6 +2368,178 @@ function cmdTelegram(args) {
     }
 }
 
+// ─── Credentials Management ───────────────────────────────────────────────────
+
+const CREDENTIALS_CONFIG_PATH = path.join(TARGETS.antigravity, '.credentials.json');
+
+function credentialsLoad() {
+    if (!fs.existsSync(CREDENTIALS_CONFIG_PATH)) return {};
+    try {
+        return JSON.parse(fs.readFileSync(CREDENTIALS_CONFIG_PATH, 'utf8'));
+    } catch (_) {
+        return {};
+    }
+}
+
+function credentialsSave(config) {
+    const dir = path.dirname(CREDENTIALS_CONFIG_PATH);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(CREDENTIALS_CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
+}
+
+function credentialsHelp() {
+    log('');
+    log(`${C.cyan}${C.bold}🔑 Credentials Commands${C.reset}`);
+    log('');
+    log(`  ${C.green}awkit credentials list${C.reset}                    List all stored credentials`);
+    log(`  ${C.green}awkit credentials set${C.reset} <key> <value>       Set a credential`);
+    log(`  ${C.green}awkit credentials get${C.reset} <key>              Get a credential value`);
+    log(`  ${C.green}awkit credentials remove${C.reset} <key>           Remove a credential`);
+    log(`  ${C.green}awkit credentials setup${C.reset}                   Interactive setup wizard`);
+    log('');
+    log(`  ${C.gray}Known keys: gemini_api_key, lucylab_bearer${C.reset}`);
+    log(`  ${C.gray}Config: ${CREDENTIALS_CONFIG_PATH}${C.reset}`);
+    log('');
+}
+
+async function credentialsSetup() {
+    log('');
+    log(`${C.cyan}${C.bold}🔑 API Credentials Setup${C.reset}`);
+    log('');
+    log(`${C.gray}  Credentials are stored in: ${CREDENTIALS_CONFIG_PATH}${C.reset}`);
+    log(`${C.gray}  Used by Short Maker, Symphony Admin, and other services.${C.reset}`);
+    log('');
+
+    const readline = require('readline');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    const question = (query) => new Promise(resolve => rl.question(query, resolve));
+    const sanitize = (s) => s.trim().replace(/^bearer\s+/i, '').replace(/\s+/g, '');
+
+    const config = credentialsLoad();
+
+    try {
+        // Gemini API Key
+        log(`${C.gray}  Get your key at: https://aistudio.google.com/apikey${C.reset}`);
+        const geminiKey = sanitize(await question(`  ${C.yellow}Gemini API Key${config.gemini_api_key ? ` [${config.gemini_api_key.slice(0, 8)}...]` : ''}: ${C.reset}`));
+        if (geminiKey) {
+            config.gemini_api_key = geminiKey;
+            ok('Gemini API Key saved');
+        } else if (config.gemini_api_key) {
+            dim('Kept existing Gemini API Key');
+        }
+
+        log('');
+
+        // LucyLab Bearer
+        log(`${C.gray}  LucyLab TTS bearer token for voice generation${C.reset}`);
+        const lucylabToken = sanitize(await question(`  ${C.yellow}LucyLab Bearer${config.lucylab_bearer ? ` [${config.lucylab_bearer.slice(0, 8)}...]` : ''}: ${C.reset}`));
+        if (lucylabToken) {
+            config.lucylab_bearer = lucylabToken;
+            ok('LucyLab Bearer saved');
+        } else if (config.lucylab_bearer) {
+            dim('Kept existing LucyLab Bearer');
+        }
+
+        credentialsSave(config);
+        log('');
+        ok(`Credentials saved to ${CREDENTIALS_CONFIG_PATH}`);
+        log('');
+    } catch (e) {
+        warn(`Failed to setup credentials: ${e.message}`);
+    } finally {
+        rl.close();
+    }
+}
+
+function cmdCredentials(args) {
+    const subCmd = args[0];
+    const key = args[1];
+    const value = args.slice(2).join(' ');
+
+    switch (subCmd) {
+        case 'list': {
+            const config = credentialsLoad();
+            const keys = Object.keys(config);
+            if (keys.length === 0) {
+                warn('No credentials stored. Run "awkit credentials setup" to configure.');
+                return;
+            }
+            log('');
+            log(`${C.cyan}${C.bold}🔑 Stored Credentials${C.reset}`);
+            log('');
+            for (const k of keys) {
+                const val = config[k];
+                const masked = val ? `${val.slice(0, 8)}${'•'.repeat(Math.max(0, val.length - 8))}` : '(empty)';
+                log(`  ${C.green}${k}${C.reset} = ${C.gray}${masked}${C.reset}`);
+            }
+            log('');
+            dim(`Config: ${CREDENTIALS_CONFIG_PATH}`);
+            log('');
+            break;
+        }
+
+        case 'set': {
+            let valueToSet = value;
+            if (valueToSet) {
+                valueToSet = valueToSet.trim().replace(/^bearer\s+/i, '').replace(/\s+/g, '');
+            }
+            if (!key || !valueToSet) {
+                err('Usage: awkit credentials set <key> <value>');
+                dim('Example: awkit credentials set gemini_api_key AIzaSy...');
+                return;
+            }
+            const config = credentialsLoad();
+            config[key] = valueToSet;
+            credentialsSave(config);
+            ok(`${key} saved ✅`);
+            break;
+        }
+
+        case 'get': {
+            if (!key) {
+                err('Usage: awkit credentials get <key>');
+                return;
+            }
+            const config = credentialsLoad();
+            if (config[key]) {
+                log(config[key]);
+            } else {
+                warn(`Key "${key}" not found.`);
+            }
+            break;
+        }
+
+        case 'remove':
+        case 'delete': {
+            if (!key) {
+                err('Usage: awkit credentials remove <key>');
+                return;
+            }
+            const config = credentialsLoad();
+            if (config[key]) {
+                delete config[key];
+                credentialsSave(config);
+                ok(`${key} removed`);
+            } else {
+                warn(`Key "${key}" not found.`);
+            }
+            break;
+        }
+
+        case 'setup':
+            credentialsSetup();
+            break;
+
+        default:
+            credentialsHelp();
+            break;
+    }
+}
+
 // ─── Trello Integration ───────────────────────────────────────────────────────
 
 /**
@@ -2490,6 +2811,98 @@ function checkAutoUpdate() {
     }
 }
 
+// ─── Native HTTP Server ───────────────────────────────────────────────────────
+
+function cmdServe(args) {
+    const http = require('http');
+    
+    let port = 8080;
+    let serveDir = process.cwd();
+
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--port' || args[i] === '-p') {
+            port = parseInt(args[++i], 10) || 8080;
+        } else if (!args[i].startsWith('-')) {
+            serveDir = path.resolve(process.cwd(), args[i]);
+        }
+    }
+
+    if (!fs.existsSync(serveDir)) {
+        err(`Directory not found: ${serveDir}`);
+        return;
+    }
+
+    const mimeTypes = {
+        '.html': 'text/html',
+        '.js': 'text/javascript',
+        '.css': 'text/css',
+        '.json': 'application/json',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.svg': 'image/svg+xml',
+        '.wav': 'audio/wav',
+        '.mp4': 'video/mp4',
+        '.woff': 'application/font-woff',
+        '.ttf': 'application/font-ttf',
+        '.eot': 'application/vnd.ms-fontobject',
+        '.otf': 'application/font-otf',
+        '.wasm': 'application/wasm'
+    };
+
+    const server = http.createServer((request, response) => {
+        response.setHeader('Access-Control-Allow-Origin', '*');
+        response.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+        response.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+        if (request.method === 'OPTIONS') {
+            response.writeHead(200);
+            response.end();
+            return;
+        }
+
+        let filePath = '.' + request.url.split('?')[0];
+        if (filePath === './') {
+            filePath = './index.html';
+        }
+
+        const absPath = path.join(serveDir, filePath);
+        const extname = String(path.extname(absPath)).toLowerCase();
+        const contentType = mimeTypes[extname] || 'application/octet-stream';
+
+        fs.readFile(absPath, (error, content) => {
+            if (error) {
+                if (error.code === 'ENOENT') {
+                    response.writeHead(404, { 'Content-Type': 'text/plain' });
+                    response.end('404 Not Found', 'utf-8');
+                } else {
+                    response.writeHead(500, { 'Content-Type': 'text/plain' });
+                    response.end('500 Internal Server Error: ' + error.code, 'utf-8');
+                }
+            } else {
+                response.writeHead(200, { 'Content-Type': contentType });
+                response.end(content, 'utf-8');
+            }
+        });
+    });
+
+    server.listen(port, '0.0.0.0', () => {
+        log('');
+        log(`${C.cyan}${C.bold}🚀 awkit serve running at:${C.reset}`);
+        log(`${C.green}   http://localhost:${port}${C.reset}`);
+        dim(`Serving directory: ${serveDir}`);
+        dim(`Press Ctrl+C to stop`);
+        log('');
+    }).on('error', (e) => {
+        if (e.code === 'EADDRINUSE') {
+            err(`Port ${port} is already in use. Try a different port with --port <number>`);
+        } else {
+            err(`Server error: ${e.message}`);
+        }
+    });
+}
+
 // ─── Main ────────────────────────────────────────────────────────────────────
 
 // Check for updates (max once per day) before continuing
@@ -2523,6 +2936,9 @@ const [, , command, ...args] = process.argv;
         case 'doctor':
             cmdDoctor();
             break;
+        case 'browser':
+            cmdBrowser(args);
+            break;
         case 'enable-pack':
             cmdEnablePack(args[0]);
             break;
@@ -2547,9 +2963,19 @@ const [, , command, ...args] = process.argv;
         case 'telegram':
             cmdTelegram(args);
             break;
+        case 'credentials':
+        case 'creds':
+            cmdCredentials(args);
+            break;
+        case 'serve':
+            cmdServe(args);
+            break;
         case 'admin':
             cmdAdmin();
             break;
+        case 'restart':
+            await cmdRestart();
+            break;
         case 'help':
         case '--help':
         case '-h':

package/bin/claude-generators.js

@@ -0,0 +1,122 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Generates Claude Code CLAUDE.md from core/GEMINI.md template.
+ * Replaces Antigravity-specific paths and references with Claude Code equivalents.
+ * @param {string} sourcePath Path to core/CLAUDE.md (pre-adapted template)
+ * @param {string} destPath Destination path (e.g. <project>/CLAUDE.md)
+ */
+function generateClaudeRules(sourcePath, destPath) {
+    if (!fs.existsSync(sourcePath)) {
+        console.log(`⚠️  Template not found: ${sourcePath}`);
+        return;
+    }
+
+    const content = fs.readFileSync(sourcePath, 'utf8');
+
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.writeFileSync(destPath, content.trim() + '\n');
+    console.log(`✅ Claude Code CLAUDE.md generated at: ${destPath}`);
+}
+
+/**
+ * Copies skill directories to Claude Code .claude/skills/ structure.
+ * Preserves full directory structure: <skill-name>/SKILL.md + scripts/ + templates/
+ * Injects YAML frontmatter if missing.
+ */
+function generateClaudeSkills(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 skillSrcDir = path.join(srcDir, skill);
+        if (!fs.statSync(skillSrcDir).isDirectory()) continue;
+        if (skill === '.DS_Store') continue;
+
+        // Skip non-skill directories (schemas, skills, workflows nested dirs)
+        const skillFile = path.join(skillSrcDir, 'SKILL.md');
+        if (!fs.existsSync(skillFile)) continue;
+
+        const skillDestDir = path.join(destDir, skill);
+        const fileCount = copySkillDir(skillSrcDir, skillDestDir);
+
+        // Ensure SKILL.md has YAML frontmatter
+        ensureFrontmatter(path.join(skillDestDir, 'SKILL.md'), skill);
+
+        count++;
+    }
+    console.log(`✅ Generated ${count} Claude Code skills in ${destDir}`);
+}
+
+/**
+ * Recursively copies a skill directory preserving structure.
+ */
+function copySkillDir(src, dest) {
+    if (!fs.existsSync(src)) return 0;
+    fs.mkdirSync(dest, { recursive: true });
+
+    let count = 0;
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    for (const entry of entries) {
+        if (entry.name === '.DS_Store') continue;
+        if (entry.name === '__pycache__') continue;
+
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+
+        if (entry.isDirectory()) {
+            count += copySkillDir(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+            count++;
+        }
+    }
+    return count;
+}
+
+/**
+ * Ensures a SKILL.md file has proper YAML frontmatter.
+ * If missing, injects name and description extracted from content.
+ */
+function ensureFrontmatter(filePath, skillName) {
+    if (!fs.existsSync(filePath)) return;
+
+    let content = fs.readFileSync(filePath, 'utf8');
+
+    // Already has frontmatter
+    if (content.startsWith('---\n')) {
+        // Ensure 'name' field exists
+        if (!content.match(/^name:/m)) {
+            content = content.replace('---\n', `---\nname: ${skillName}\n`);
+            fs.writeFileSync(filePath, content);
+        }
+        return;
+    }
+
+    // Extract description from first line or heading
+    let description = `Antigravity skill: ${skillName}`;
+    const descMatch = content.match(/^#\s+(.+)/m);
+    if (descMatch) {
+        description = descMatch[1].replace(/[`*_]/g, '').trim();
+    }
+
+    // Also try to extract from YAML-like description in body
+    const bodyDescMatch = content.match(/^description:\s*(.+)/m);
+    if (bodyDescMatch) {
+        description = bodyDescMatch[1].trim();
+    }
+
+    const frontmatter = `---\nname: ${skillName}\ndescription: "${description}"\n---\n`;
+    content = frontmatter + content;
+    fs.writeFileSync(filePath, content);
+}
+
+module.exports = {
+    generateClaudeRules,
+    generateClaudeSkills,
+};

package/core/AGENTS.md

@@ -36,3 +36,19 @@ symphony_status                   # Check system status
 - NEVER stop before pushing — that leaves work stranded locally
 - NEVER say "ready to push when you are" — YOU must push
 - If push fails, resolve and retry until it succeeds
+
+## AUTO-COMMIT RULE
+
+**After a successful build (0 errors)**, commit immediately — do NOT wait for session end.
+
+```bash
+git add -A
+git commit -m "fix: <concise description>"   # conventional commit format
+git push                                       # non-force push, safe to auto-run
+```
+
+**Rules:**
+- Commit NGAY sau build 0 errors — không gom lại cuối session.
+- `git push` (non-force) được phép chạy tự động.
+- Push fail → `git pull --rebase && git push` (retry 1 lần).
+- Vẫn fail → báo user, KHÔNG force push.