@leejungkiin/awkit 1.6.4 → 1.6.5

package/bin/awk.js

@@ -38,7 +38,9 @@ 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');
+const { generateCursorRules, generateCursorSkills } = require('./cursor-generators');
 const { cmdGate } = require('../scripts/automation-gate');
+const { cmdObsidian } = require('../scripts/obsidian-sync');
 
 // ─── Platform Definitions ──────────────────────────────────────────────────
 
@@ -85,6 +87,24 @@ const PLATFORMS = {
         dirs: {
             skills: '.claude/skills',
         },
+    },
+    qwen: {
+        name: 'Qwen Code',
+        globalRoot: path.join(HOME, '.qwen'),
+        rulesFile: null,
+        versionFile: path.join(HOME, '.qwen', 'awk_version'),
+        dirs: {
+            skills: 'skills',
+        },
+    },
+    cursor: {
+        name: 'Cursor AI',
+        globalRoot: process.cwd(), // Local to project
+        rulesFile: '.cursor/rules/antigravity-rules.mdc',
+        versionFile: '.cursor/awk_version',
+        dirs: {
+            skills: '.cursor/rules',
+        },
     }
 };
 
@@ -516,6 +536,8 @@ function cmdInstall(args = []) {
         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');
+        if (args.includes('--qwen') || args.includes('--qwen-code') || args.includes('-q') || args.includes('qwen')) selectedPlatforms.push('qwen');
+        if (args.includes('--cursor') || args.includes('cursor')) selectedPlatforms.push('cursor');
 
         const pIdx = args.indexOf('--platform');
         let legacyArg = null;
@@ -534,25 +556,29 @@ function cmdInstall(args = []) {
         if (isUpdate) {
             selectedPlatforms = [getActivePlatform()];
         } else {
-            const platformOrder = ['antigravity', 'cline', 'codex', 'claude'];
+            const platformOrder = ['antigravity', 'cline', 'codex', 'claude', 'qwen', 'cursor'];
             const defaultPlatform = getActivePlatform();
             const defaultChoice = String(Math.max(platformOrder.indexOf(defaultPlatform), 0) + 1);
-            log(`${C.cyan}Select platforms to install (e.g., type "1,2", "all", or "1,2,3,4"):${C.reset}`);
+            log(`${C.cyan}Select platforms to install (e.g., type "1,2", "all", or "1-6"):${C.reset}`);
             log(`  1. Gemini Code Assist (antigravity)`);
             log(`  2. Cline (VS Code)`);
             log(`  3. Codex CLI (codex)`);
             log(`  4. Claude Code (.claude/)`);
-            log(`  5. All of the above`);
+            log(`  5. Qwen Code (~/.qwen/)`);
+            log(`  6. Cursor AI (.cursor/rules/)`);
+            log(`  7. All of the above`);
             log(`${C.gray}Press Enter to install only the active platform: ${PLATFORMS[defaultPlatform].name}.${C.reset}`);
             const choice = promptChoice('Choice', defaultChoice).trim().toLowerCase();
 
-            if (choice === '5' || choice === 'all') {
+            if (choice === '7' || choice === 'all') {
                 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');
+                if (choice.includes('5')) selectedPlatforms.push('qwen');
+                if (choice.includes('6')) selectedPlatforms.push('cursor');
             }
         }
     }
@@ -614,6 +640,10 @@ function cmdInstall(args = []) {
             const claudeTemplateSrc = path.join(AWK_ROOT, 'core', 'CLAUDE.md');
             const claudeRulesDest = path.join(target, plat.rulesFile);
             generateClaudeRules(claudeTemplateSrc, claudeRulesDest);
+        } else if (platform === 'cursor') {
+            info('Generating Cursor AI .mdc rules...');
+            const cursorRulesDest = path.join(target, plat.rulesFile);
+            generateCursorRules(path.join(AWK_ROOT, 'core', 'GEMINI.md'), cursorRulesDest);
         }
 
         // 3. Backup and install workflows
@@ -668,7 +698,11 @@ function cmdInstall(args = []) {
                 const agentsDest = path.join(target, plat.dirs.agents);
                 generateCodexAgents(skillsSrc, agentsDest, coreSkills);
             } else if (platform === 'claude') {
-                generateClaudeSkills(skillsSrc, skillsDest, coreSkills);
+                generateClaudeSkills(skillsSrc, skillsDest, coreSkills, 'Claude Code');
+            } else if (platform === 'qwen') {
+                generateClaudeSkills(skillsSrc, skillsDest, coreSkills, 'Qwen Code'); // Shares the same format with Claude
+            } else if (platform === 'cursor') {
+                generateCursorSkills(skillsSrc, skillsDest, coreSkills);
             } else {
                 const skillCount = copySelectedSkillDirs(skillsSrc, skillsDest, coreSkills);
                 ok(`${skillCount} core skill files installed`);
@@ -2298,6 +2332,25 @@ function buildProjectIdentity(projectName, projectType, cwd, date) {
             list: 'Your List Name',
             card: 'Your Card Name',
         },
+        automation: {
+            autoQA: true,
+            maxSelfCorrectionLoops: 3,
+            telegram: {
+                enabled: true,
+                chatId: "",
+                topicId: "",
+                triggers: { git_push: true, task_complete: false, deploy: true }
+            },
+            trello: {
+                enabled: true,
+                autoSync: true,
+                triggers: { task_complete: true, milestone: true, blocked: true }
+            },
+            git: {
+                autoCommit: true,
+                autoPush: true
+            }
+        },
         projectStage: 'development',
         codingStandards: cfg.codingStandards,
         projectGoals: [],
@@ -2505,6 +2558,8 @@ async function cmdInit(forceFlag = false) {
         const currentIdentity = JSON.parse(fs.readFileSync(identityPath, 'utf8'));
         if (!currentIdentity.automation) {
             currentIdentity.automation = {
+                autoQA: true,
+                maxSelfCorrectionLoops: 3,
                 telegram: {
                     enabled: true,
                     chatId: "",
@@ -2523,6 +2578,12 @@ async function cmdInit(forceFlag = false) {
             };
             fs.writeFileSync(identityPath, JSON.stringify(currentIdentity, null, 2) + '\n');
             ok('Added Automation config placeholder to .project-identity');
+        } else if (currentIdentity.automation.autoQA === undefined) {
+            // Update existing automation block with new QA fields
+            currentIdentity.automation.autoQA = true;
+            currentIdentity.automation.maxSelfCorrectionLoops = 3;
+            fs.writeFileSync(identityPath, JSON.stringify(currentIdentity, null, 2) + '\n');
+            ok('Updated Automation config with autoQA defaults in .project-identity');
         }
     } catch (_) { /* ignore */ }
 
@@ -3867,6 +3928,10 @@ const [, , command, ...args] = process.argv;
         case 'gate':
             cmdGate(args);
             break;
+        case 'obsidian':
+        case 'obs':
+            cmdObsidian(args);
+            break;
         case 'admin':
             cmdAdmin();
             break;

package/bin/claude-generators.js

@@ -25,7 +25,7 @@ function generateClaudeRules(sourcePath, destPath) {
  * Preserves full directory structure: <skill-name>/SKILL.md + scripts/ + templates/
  * Injects YAML frontmatter if missing.
  */
-function generateClaudeSkills(srcDir, destDir, selectedSkills = null) {
+function generateClaudeSkills(srcDir, destDir, selectedSkills = null, platformName = 'Claude Code') {
     if (!fs.existsSync(srcDir)) return;
 
     fs.mkdirSync(destDir, { recursive: true });
@@ -51,7 +51,7 @@ function generateClaudeSkills(srcDir, destDir, selectedSkills = null) {
 
         count++;
     }
-    console.log(`✅ Generated ${count} Claude Code skills in ${destDir}`);
+    console.log(`✅ Generated ${count} ${platformName} skills in ${destDir}`);
 }
 
 /**

package/bin/cursor-generators.js

@@ -0,0 +1,256 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Cursor Rules Generator for AWKit
+ * 
+ * Follows Cursor's official rule design:
+ * - 4 activation modes: Always Apply, Auto Attached (Globs), Agent Requested, Manual
+ * - Token efficiency: alwaysApply rules must be concise
+ * - Skills → Agent Requested mode (description only, no globs)
+ * - Global rules → Always Apply mode (concise, essential only)
+ * 
+ * @see https://docs.cursor.com/docs/rules
+ */
+
+/**
+ * Generate Cursor rule files from core templates.
+ * Creates TWO files following Cursor's best practices:
+ * 1. antigravity-rules.mdc (Always Apply) — concise identity + protocol (~30 lines)
+ * 2. antigravity-detailed.mdc (Agent Requested) — full rules loaded when relevant
+ * 
+ * @param {string} sourcePath Path to core/GEMINI.md (used to auto-detect core dir)
+ * @param {string} destPath Destination .cursor/rules/antigravity-rules.mdc
+ */
+function generateCursorRules(sourcePath, destPath) {
+    const coreDir = path.dirname(sourcePath);
+    const destDir = path.dirname(destPath);
+    fs.mkdirSync(destDir, { recursive: true });
+
+    // --- File 1: Always Apply (concise identity + protocol) ---
+    const cursorTemplate = path.join(coreDir, 'CURSOR.md');
+    const actualSource = fs.existsSync(cursorTemplate) ? cursorTemplate : sourcePath;
+
+    if (!fs.existsSync(actualSource)) {
+        console.log(`⚠️  Template not found: ${actualSource}`);
+        return;
+    }
+
+    const content = fs.readFileSync(actualSource, 'utf8');
+    const alwaysFrontmatter = [
+        '---',
+        'description: "MANDATORY Antigravity Orchestrator identity and session protocol. You MUST follow these rules in EVERY conversation."',
+        'alwaysApply: true',
+        '---',
+        '', '',
+    ].join('\n');
+
+    fs.writeFileSync(destPath, alwaysFrontmatter + content.trim() + '\n');
+    console.log(`✅ Cursor Rules (Always Apply) → ${path.basename(destPath)}`);
+
+    // --- File 2: Agent Requested (detailed operational rules) ---
+    const detailedSource = path.join(coreDir, 'CURSOR_DETAILED.md');
+    if (fs.existsSync(detailedSource)) {
+        const detailedContent = fs.readFileSync(detailedSource, 'utf8');
+        const detailedFrontmatter = [
+            '---',
+            'description: "Antigravity detailed rules: 7-Gate system, code standards, safety guardrails, NeuralMemory protocol, GitNexus integration, and decision principles. Load when planning, coding, debugging, or reviewing."',
+            '---',
+            '', '',
+        ].join('\n');
+
+        const detailedDest = path.join(destDir, 'antigravity-detailed.mdc');
+        fs.writeFileSync(detailedDest, detailedFrontmatter + detailedContent.trim() + '\n');
+        console.log(`✅ Cursor Rules (Agent Requested) → antigravity-detailed.mdc`);
+    }
+}
+
+/**
+ * Convert AWKit skills to Cursor .mdc rules using proper activation modes.
+ * 
+ * Activation mode strategy:
+ * - Skills with clear triggers → Agent Requested (description only)
+ * - Skills that are always needed → alwaysApply: true (rare)
+ * - All skills: NO globs (skills are concept-based, not file-based)
+ * 
+ * @param {string} srcDir Source skills directory
+ * @param {string} destDir Destination .cursor/rules directory
+ * @param {string[]} selectedSkills Optional list of skill names to include
+ */
+function generateCursorSkills(srcDir, destDir, selectedSkills = null) {
+    if (!fs.existsSync(srcDir)) return;
+
+    fs.mkdirSync(destDir, { recursive: true });
+    const skills = fs.readdirSync(srcDir);
+    const allowed = selectedSkills ? new Set(selectedSkills) : null;
+
+    let count = 0;
+    for (const skill of skills) {
+        if (allowed && !allowed.has(skill)) continue;
+        const skillSrcDir = path.join(srcDir, skill);
+        if (!fs.statSync(skillSrcDir).isDirectory()) continue;
+        if (skill === '.DS_Store') continue;
+
+        const skillFile = path.join(skillSrcDir, 'SKILL.md');
+        if (!fs.existsSync(skillFile)) continue;
+
+        const destFile = path.join(destDir, `${skill}.mdc`);
+        let content = fs.readFileSync(skillFile, 'utf8');
+
+        // Extract description from existing frontmatter or content
+        let description = extractDescription(content, skill);
+
+        // Strip existing frontmatter (we'll generate Cursor-specific one)
+        content = stripFrontmatter(content);
+
+        // Determine activation mode based on skill nature
+        const mode = getSkillActivationMode(skill);
+
+        // Build Cursor-compatible frontmatter
+        const frontmatter = buildFrontmatter(description, mode);
+
+        fs.writeFileSync(destFile, frontmatter + content.trim() + '\n');
+
+        // Copy scripts subdirectory if exists (reference for AI)
+        const scriptsSrc = path.join(skillSrcDir, 'scripts');
+        if (fs.existsSync(scriptsSrc)) {
+            const scriptsDest = path.join(destDir, 'scripts', skill);
+            copyRecursive(scriptsSrc, scriptsDest);
+        }
+
+        count++;
+    }
+    console.log(`✅ Generated ${count} Cursor rules (.mdc) in ${destDir}`);
+}
+
+/**
+ * Extract a clean description from skill content.
+ * Handles both single-line and YAML folded block scalar (>-) descriptions.
+ */
+function extractDescription(content, skillName) {
+    // Try YAML frontmatter description
+    if (content.startsWith('---\n')) {
+        const endIdx = content.indexOf('\n---\n', 4);
+        if (endIdx !== -1) {
+            const frontmatter = content.slice(4, endIdx);
+
+            // Handle folded (>-) or literal (|) block scalar: description: >- or description: |
+            const foldedMatch = frontmatter.match(/^description:\s*[>|]-?\s*\n((?:\s{2,}.+\n?)+)/m);
+            if (foldedMatch) {
+                // Join indented continuation lines, strip leading whitespace
+                const lines = foldedMatch[1].split('\n')
+                    .map(l => l.trim())
+                    .filter(l => l.length > 0);
+                return lines.join(' ');
+            }
+
+            // Handle single-line: description: "value" or description: value
+            const singleMatch = frontmatter.match(/^description:\s*"?([^"\n]+)"?\s*$/m);
+            if (singleMatch) return singleMatch[1].trim();
+        }
+    }
+
+    // Fallback: try first markdown heading
+    const headingMatch = content.match(/^#\s+(.+)/m);
+    if (headingMatch) {
+        return headingMatch[1].replace(/[`*_]/g, '').trim();
+    }
+
+    return `Antigravity skill: ${skillName}`;
+}
+
+/**
+ * Strip existing YAML frontmatter from content.
+ */
+function stripFrontmatter(content) {
+    if (content.startsWith('---\n')) {
+        const endIdx = content.indexOf('\n---\n', 4);
+        if (endIdx !== -1) {
+            return content.slice(endIdx + 5).trimStart();
+        }
+    }
+    return content;
+}
+
+/**
+ * Determine the Cursor activation mode for a skill.
+ * 
+ * Modes:
+ * - "always"    → alwaysApply: true  (very few skills)
+ * - "agent"     → Agent Requested: description only (most skills)
+ * - "globs"     → Auto Attached: for file-type-specific skills
+ * 
+ * @returns {{mode: string, globs?: string[]}}
+ */
+function getSkillActivationMode(skillName) {
+    // Skills that should always be available (critical orchestration)
+    const alwaysApplySkills = [
+        'orchestrator',
+    ];
+
+    // Skills with file-type affinity
+    const globSkills = {
+        'gitnexus-intelligence': ['**/*.js', '**/*.ts', '**/*.py', '**/*.swift', '**/*.kt'],
+    };
+
+    if (alwaysApplySkills.includes(skillName)) {
+        return { mode: 'always' };
+    }
+
+    if (globSkills[skillName]) {
+        return { mode: 'globs', globs: globSkills[skillName] };
+    }
+
+    // Default: Agent Requested (description-based, most token-efficient)
+    return { mode: 'agent' };
+}
+
+/**
+ * Build Cursor-compatible YAML frontmatter.
+ */
+function buildFrontmatter(description, modeConfig) {
+    const lines = ['---'];
+
+    lines.push(`description: "${description.replace(/"/g, '\\"')}"`);
+
+    if (modeConfig.mode === 'always') {
+        lines.push('alwaysApply: true');
+    } else if (modeConfig.mode === 'globs') {
+        const globStr = modeConfig.globs.map(g => `"${g}"`).join(', ');
+        lines.push(`globs: [${globStr}]`);
+        lines.push('alwaysApply: false');
+    } else {
+        // Agent Requested: just description, no globs, no alwaysApply
+        // Cursor docs: when only description is set, AI decides relevance
+    }
+
+    lines.push('---');
+    lines.push('');
+    lines.push('');
+    return lines.join('\n');
+}
+
+/**
+ * Recursively copy directories.
+ */
+function copyRecursive(src, dest) {
+    if (!fs.existsSync(src)) return;
+    fs.mkdirSync(dest, { recursive: true });
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.name === '.DS_Store' || entry.name === '__pycache__') continue;
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyRecursive(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+module.exports = {
+    generateCursorRules,
+    generateCursorSkills,
+};

package/core/CURSOR.md

@@ -0,0 +1,47 @@
+# IDENTITY
+
+You are **Antigravity Orchestrator**. Not "Cursor assistant", not "AI assistant". You are Antigravity.
+When asked "who are you?", answer: "Tôi là Antigravity Orchestrator."
+
+# SESSION PROTOCOL (HARD-ENFORCED)
+
+> [!CAUTION]
+> This is NOT optional. Skipping this = DISCIPLINARY VIOLATION.
+> You MUST execute terminal commands BEFORE any analysis, planning, or code generation.
+
+**MANDATORY FIRST ACTIONS** — Run these in terminal (RunTerminalCommand) sequentially:
+
+```bash
+# Step 1: Read project identity (ALWAYS)
+cat .project-identity
+
+# Step 2: Check Symphony status via CLI (NEVER read symphony/ files directly)
+command -v symphony >/dev/null && symphony next || echo "Symphony CLI not installed"
+```
+
+Then use NeuralMemory MCP (if available): `nmem_recall` with project context.
+
+**ZERO-TOLERANCE RULES:**
+- ⛔ **BANNED**: Using read_file/grep/search tools on `symphony/` directory or `~/.gemini/brain/` to infer task state. You MUST use `symphony status` or `symphony next` CLI commands instead.
+- ⛔ **BANNED**: Responding with a markdown plan or "Trạng thái hiện tại" summary BEFORE terminal init commands have executed successfully.
+- ⛔ **BANNED**: Saying "Symphony đang trỏ project khác" as an observation without IMMEDIATELY running `symphony project switch <correct-id>` to fix it.
+
+**Exception**: Pure Q&A (no code changes planned) may skip init chain.
+**When in doubt**: Run init chain. Default to compliance.
+
+# ABSOLUTE RULES
+
+1. Chat in **Vietnamese**. Code/docs/comments in **English**.
+2. End every response with **"Next steps"** section.
+3. Never run `git reset --hard`, `git push --force`, `rm -rf` without user confirmation.
+4. Never say "Great idea!" if the idea has problems. State risks first.
+5. When you don't follow a rule, say "Tôi đã không tuân thủ rule X" — never rationalize.
+6. **Git commits**: Use `awkit gate git auto "message"` — NEVER use raw `git commit` in terminal.
+
+# ANTI-EVASION
+
+- Do NOT reinterpret rules to avoid compliance.
+- Do NOT blame "environment limitations" to skip rules. If a tool is missing, say so once, then do what you CAN.
+- Do NOT separate "I am Cursor" from "Antigravity Orchestrator". You are one entity.
+- Do NOT write paragraphs explaining why a rule doesn't apply. Follow it or state the violation.
+- Do NOT read static files to "understand context" as a substitute for running CLI commands. The CLI commands exist to ensure correct state synchronization.

package/core/CURSOR_DETAILED.md

@@ -0,0 +1,102 @@
+# Antigravity Detailed Rules
+
+> This file contains detailed operational rules. Loaded by Cursor when relevant to the task.
+
+## 7-Gate Autonomous System
+
+Triage complexity before every task:
+
+| Complexity | Gates Required |
+|---|---|
+| TRIVIAL | Skip to Gate 4 (code directly) |
+| MODERATE | Gate 3 → 4 → 5 |
+| COMPLEX | All 7 Gates sequentially |
+
+### Gates
+1. **Gate 1 (Spec)**: Brainstorm → BRIEF.md
+2. **Gate 1.5 (Module Spec)**: Per-module product specs (COMPLEX + >3 modules only)
+3. **Gate 2 (Architecture)**: Design doc + user approve
+4. **Gate 2.5 (Visual Design)**: UI agreement (skip for backend-only tasks)
+5. **Gate 3 (Tasks)**: Create task tickets via Symphony
+6. **Gate 4 (Execution)**: Code to ticket, verify against design doc
+7. **Gate 5 (Verification)**: Test + code review
+
+### Gate 4 Three-Phase (COMPLEX + UI only)
+- **Phase A** 🏗️ Infrastructure: dependencies, navigation skeleton → build check
+- **Phase B** 🎨 UI Shell: all screens with mock data → USER TEST CHECKPOINT
+- **Phase C** ⚡ Logic: replace mock with real data → USER TEST per feature
+- ⛔ NEVER code logic before user confirms UI is OK.
+
+## Symphony Interaction Protocol (MANDATORY)
+
+> [!WARNING]
+> These rules prevent the #1 compliance failure: agents bypassing Symphony by reading raw files.
+
+### BANNED Actions
+| Action | Why Banned | Correct Alternative |
+|--------|-----------|-------------------|
+| `read_file("symphony/tasks/*.json")` | Bypasses state sync, gets stale data | `symphony task list` in terminal |
+| `read_file("symphony/agents/*.json")` | Reads unfiltered cross-project data | `symphony status` in terminal |
+| `grep_search("symphony/")` | Static sniffing ≠ live state | `symphony next` in terminal |
+| Writing markdown plan before init | Gives illusion of progress, skips context | Run terminal init first, then plan |
+
+### REQUIRED Actions
+| Situation | Terminal Command |
+|-----------|-----------------|
+| Start of session | `cat .project-identity && symphony next` |
+| User asks "what's next?" | `symphony next` |
+| Need task list | `symphony task list` |
+| Project mismatch detected | `symphony project switch <projectId>` |
+| Task completed | `awkit gate git auto "feat: description"` |
+| Check current state | `symphony status` |
+
+### Project ID Mismatch Hard-Stop
+If you detect that Symphony's active project differs from `.project-identity`'s `projectId`:
+1. **STOP ALL ANALYSIS IMMEDIATELY** — do not brainstorm, plan, or summarize.
+2. Run: `symphony project switch <correct-projectId>` in terminal.
+3. Run: `symphony next` to get correct context.
+4. ONLY THEN proceed with the user's request.
+
+## Code Standards
+- Production quality. Files < 500 lines.
+- Don't modify code outside scope.
+- Don't hardcode secrets → use `.env`.
+- AI models: Gemini 2.5+ only.
+- Firebase: Firebase AI Logic SDK.
+
+## Auto-Commit Protocol
+- Build success (0 errors) → use `awkit gate git auto "type: message"`.
+- ⛔ **NEVER** use raw `git commit` or `git push` in terminal. Always use `awkit gate git auto`.
+- Commit message: conventional format (`fix:`, `feat:`, `refactor:`, `chore:`).
+- Push fail → gate handles retry automatically. Never force push.
+
+## NeuralMemory Protocol
+- Brain = projectId (from `.project-identity`). Switch brain before any nmem call.
+- Tag every `nmem_remember()` with projectId.
+- Cross-brain queries: `nmem_recall(query, brains=["default", projectId])`.
+
+## Safety Guardrails
+Never auto-run these without user confirmation:
+- `rm -rf`, `rm -r` (recursive delete)
+- `git push --force`, `git reset --hard`, `git clean -fd`
+- `DROP TABLE`, `DROP DATABASE`, `DELETE FROM` (without WHERE)
+- `npm publish`, `pod trunk push`
+- Any production deploy command
+
+## 6 Decision Principles (when deciding without user)
+1. Complete > Shortcuts
+2. Evidence > Assumptions
+3. Standard > Custom
+4. Explicit > Implicit
+5. Test > Trust
+6. Small > Big
+
+## Project Context
+- `.project-identity` exists → READ IT FIRST for projectId, techStack, goals.
+- `CODEBASE.md` exists → don't scan raw directory.
+
+## GitNexus (Code Intelligence)
+- `.gitnexus/` exists → MUST use GitNexus tools.
+- Before editing a symbol → `gitnexus_impact` check blast radius.
+- Before committing → `gitnexus_detect_changes()` verify scope.
+- HIGH/CRITICAL risk → WARN user before editing.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@leejungkiin/awkit",
-  "version": "1.6.4",
-  "description": "Antigravity Workflow Kit v12.5. Unified AI agent orchestration system with Mindful Checkpoints.",
+  "version": "1.6.5",
+  "description": "Antigravity Workflow Kit v1.6 Unified AI agent orchestration system with Mindful Checkpoints.",
   "main": "bin/awk.js",
   "bin": {
     "awkit": "bin/awk.js",

package/scripts/automation-gate.js

@@ -19,6 +19,19 @@ const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 
+// Lazy-load obsidian-sync to avoid circular dependencies
+let _autoSyncObsidian = null;
+function getAutoSyncObsidian() {
+    if (!_autoSyncObsidian) {
+        try {
+            _autoSyncObsidian = require('./obsidian-sync').autoSyncObsidian;
+        } catch (_) {
+            _autoSyncObsidian = () => {}; // Graceful fallback
+        }
+    }
+    return _autoSyncObsidian;
+}
+
 // ─── Color helpers (borrowed from main CLI) ──────────────────────────────────
 
 const C = {
@@ -224,6 +237,9 @@ function execGitAuto(message) {
         }
     }
 
+    // Trigger Obsidian sync after successful git auto
+    getAutoSyncObsidian()();
+
     return true;
 }
 
@@ -240,6 +256,8 @@ function execTrelloAction(action, args) {
     try {
         const cmd = `awkit trello ${action} ${args.map(a => `"${a}"`).join(' ')}`;
         execSync(cmd, { stdio: 'inherit' });
+        // Trigger Obsidian sync after successful trello action
+        getAutoSyncObsidian()();
         return true;
     } catch (e) {
         err(`Trello ${action} failed: ${e.message}`);