pumuki-ast-hooks 5.3.27 → 5.3.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki-ast-hooks",
-  "version": "5.3.27",
+  "version": "5.3.29",
   "description": "Enterprise-grade AST Intelligence System with multi-platform support (iOS, Android, Backend, Frontend) and Feature-First + DDD + Clean Architecture enforcement. Includes dynamic violations API for intelligent querying.",
   "main": "index.js",
   "bin": {

package/scripts/hooks-system/application/services/installation/GitEnvironmentService.js

@@ -117,27 +117,19 @@ if [ -f "node_modules/.bin/ast-hooks" ]; then
     exit $EXIT_CODE
   fi
   # Block commits only when there are actual CRITICAL/HIGH violations.
-  # Do NOT block on summary lines like: "CRITICAL=0 HIGH=0".
-  if echo "$OUTPUT" | grep -qE "CRITICAL=[1-9]|HIGH=[1-9]|\[CRITICAL\]|\[HIGH\]"; then
+  # Source of truth is the AST SUMMARY LEVELS line.
+  SUMMARY_LINE=$(echo "$OUTPUT" | grep -E "^AST SUMMARY LEVELS:" | tail -1)
+  CRITICAL_COUNT=$(echo "$SUMMARY_LINE" | grep -oE "CRITICAL=[0-9]+" | head -1 | cut -d= -f2)
+  HIGH_COUNT=$(echo "$SUMMARY_LINE" | grep -oE "HIGH=[0-9]+" | head -1 | cut -d= -f2)
+  CRITICAL_COUNT=$(printf '%s' "$CRITICAL_COUNT" | tr -cd '0-9')
+  HIGH_COUNT=$(printf '%s' "$HIGH_COUNT" | tr -cd '0-9')
+  [ -z "$CRITICAL_COUNT" ] && CRITICAL_COUNT=0
+  [ -z "$HIGH_COUNT" ] && HIGH_COUNT=0
+
+  if [ "$CRITICAL_COUNT" -gt 0 ] || [ "$HIGH_COUNT" -gt 0 ]; then
     echo ""
     echo "❌ Commit blocked: Critical or High violations detected in staged files"
     
-    # Extract counts (best-effort) for notification.
-    # Prefer explicit totals (CRITICAL=, HIGH=) and fallback to tag counts.
-    CRITICAL_COUNT=$(echo "$OUTPUT" | grep -oE "CRITICAL=[0-9]+" | head -1 | cut -d= -f2)
-    HIGH_COUNT=$(echo "$OUTPUT" | grep -oE "HIGH=[0-9]+" | head -1 | cut -d= -f2)
-
-    if [ -z "$CRITICAL_COUNT" ]; then
-      CRITICAL_COUNT=$(echo "$OUTPUT" | grep -oE "\[CRITICAL\]" | wc -l | tr -d ' ')
-    fi
-    if [ -z "$HIGH_COUNT" ]; then
-      HIGH_COUNT=$(echo "$OUTPUT" | grep -oE "\[HIGH\]" | wc -l | tr -d ' ')
-    fi
-
-    CRITICAL_COUNT=$(printf '%s' "$CRITICAL_COUNT" | tr -cd '0-9')
-    HIGH_COUNT=$(printf '%s' "$HIGH_COUNT" | tr -cd '0-9')
-    [ -z "$CRITICAL_COUNT" ] && CRITICAL_COUNT=0
-    [ -z "$HIGH_COUNT" ] && HIGH_COUNT=0
     TOTAL_VIOLATIONS=$((CRITICAL_COUNT + HIGH_COUNT))
     [ "$TOTAL_VIOLATIONS" -le 0 ] && TOTAL_VIOLATIONS=1
     

package/scripts/hooks-system/application/services/logging/UnifiedLogger.js

@@ -38,7 +38,7 @@ class UnifiedLogger {
             try {
                 fs.mkdirSync(dir, { recursive: true });
             } catch (error) {
-                // Directory creation might fail if race condition, can be ignored as next write will retry or fail
+                console.warn(`[UnifiedLogger] Failed to create directory ${dir}:`, error.message);
             }
         }
     }

package/scripts/hooks-system/application/services/monitoring/EvidenceMonitor.js

@@ -14,6 +14,80 @@ class EvidenceMonitor {
         this.evidencePath = path.join(repoRoot, '.AI_EVIDENCE.json');
         this.tempDir = path.join(repoRoot, '.audit_tmp');
         this.updateScript = this.resolveUpdateEvidenceScript();
+        this.refreshInFlight = false;
+        this.refreshTimeoutMs = options.refreshTimeoutMs || 120000;
+        this.refreshLockFile = path.join(this.tempDir, 'evidence-refresh.lock');
+    }
+
+    isPidRunning(pid) {
+        if (!pid || !Number.isFinite(pid) || pid <= 0) return false;
+        try {
+            process.kill(pid, 0);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    acquireRefreshLock() {
+        try {
+            fs.mkdirSync(this.tempDir, { recursive: true });
+        } catch (error) {
+            console.warn('[EvidenceMonitor] Failed to ensure temp dir:', error.message);
+        }
+
+        try {
+            const fd = fs.openSync(this.refreshLockFile, 'wx');
+            const payload = JSON.stringify({ pid: process.pid, timestamp: new Date().toISOString() });
+            fs.writeFileSync(fd, payload, { encoding: 'utf8' });
+            fs.closeSync(fd);
+            return { acquired: true };
+        } catch (error) {
+            if (error && error.code !== 'EEXIST') {
+                return { acquired: false, reason: 'error', error };
+            }
+
+            try {
+                const raw = String(fs.readFileSync(this.refreshLockFile, 'utf8') || '').trim();
+                const data = raw ? JSON.parse(raw) : null;
+                const lockPid = data && Number(data.pid);
+                if (lockPid && this.isPidRunning(lockPid)) {
+                    return { acquired: false, reason: 'locked', pid: lockPid };
+                }
+            } catch (error) {
+                console.warn('[EvidenceMonitor] Failed to read refresh lock file:', error.message);
+            }
+
+            try {
+                fs.unlinkSync(this.refreshLockFile);
+            } catch (error) {
+                console.warn('[EvidenceMonitor] Failed to remove stale refresh lock:', error.message);
+            }
+
+            try {
+                const fd = fs.openSync(this.refreshLockFile, 'wx');
+                const payload = JSON.stringify({ pid: process.pid, timestamp: new Date().toISOString() });
+                fs.writeFileSync(fd, payload, { encoding: 'utf8' });
+                fs.closeSync(fd);
+                return { acquired: true };
+            } catch (retryError) {
+                return { acquired: false, reason: 'locked', error: retryError };
+            }
+        }
+    }
+
+    releaseRefreshLock() {
+        try {
+            if (!fs.existsSync(this.refreshLockFile)) return;
+            const raw = String(fs.readFileSync(this.refreshLockFile, 'utf8') || '').trim();
+            const data = raw ? JSON.parse(raw) : null;
+            const lockPid = data && Number(data.pid);
+            if (lockPid === process.pid) {
+                fs.unlinkSync(this.refreshLockFile);
+            }
+        } catch (error) {
+            console.warn('[EvidenceMonitor] Failed to release refresh lock:', error.message);
+        }
     }
 
     resolveUpdateEvidenceScript() {
@@ -51,6 +125,17 @@ class EvidenceMonitor {
             throw new ConfigurationError('Update evidence script not found', 'updateScript');
         }
 
+        if (this.refreshInFlight) {
+            return '';
+        }
+
+        const lock = this.acquireRefreshLock();
+        if (!lock.acquired) {
+            return '';
+        }
+
+        this.refreshInFlight = true;
+
         return new Promise((resolve, reject) => {
             const child = require('child_process').spawn('bash', [this.updateScript, '--auto', '--refresh-only'], {
                 cwd: this.repoRoot,
@@ -62,7 +147,18 @@ class EvidenceMonitor {
                 output += data.toString();
             });
 
+            const timeoutId = setTimeout(() => {
+                try {
+                    child.kill('SIGKILL');
+                } catch (error) {
+                    console.warn('[EvidenceMonitor] Failed to kill timed-out refresh process:', error.message);
+                }
+            }, this.refreshTimeoutMs);
+
             child.on('close', (code) => {
+                clearTimeout(timeoutId);
+                this.refreshInFlight = false;
+                this.releaseRefreshLock();
                 if (code === 0) {
                     resolve(output);
                 } else {
@@ -70,7 +166,12 @@ class EvidenceMonitor {
                 }
             });
 
-            child.on('error', reject);
+            child.on('error', (err) => {
+                clearTimeout(timeoutId);
+                this.refreshInFlight = false;
+                this.releaseRefreshLock();
+                reject(err);
+            });
         });
     }
 

package/scripts/hooks-system/application/services/notification/NotificationCenterService.js

@@ -31,7 +31,7 @@ class NotificationCenterService {
         try {
             fs.mkdirSync(path.dirname(defaultLogPath), { recursive: true });
         } catch (e) {
-            // Ignore if it already exists or permissions issues during init
+            console.warn(`[NotificationCenter] Failed to create log directory:`, e.message);
         }
 
         this.logger = config.logger || new UnifiedLogger({

package/scripts/hooks-system/bin/kill-mcp-zombies.sh

@@ -16,8 +16,12 @@ NC='\033[0m'
 echo -e "${YELLOW}🧟 Searching for zombie MCP processes...${NC}"
 echo ""
 
-# Find all mcp-ai-evidence-watcher processes
-PIDS=$(pgrep -f "mcp-ai-evidence-watcher" || true)
+# Find all MCP-related processes
+PIDS=$( (
+  pgrep -f "mcp-ai-evidence-watcher" || true
+  pgrep -f "scripts/hooks-system/infrastructure/mcp/ast-intelligence-automation\.js" || true
+  pgrep -f "update-evidence\.sh.*--auto.*--refresh-only" || true
+) | sort -u || true )
 
 if [[ -z "$PIDS" ]]; then
   echo -e "${GREEN}✅ No zombie processes found!${NC}"

package/scripts/hooks-system/domain/exceptions/index.js

@@ -20,15 +20,18 @@ class BaseException extends Error {
     }
 
     toJSON() {
-        return {
+        const result = {
             name: this.name,
             message: this.message,
             code: this.code,
             statusCode: this.statusCode,
             timestamp: this.timestamp,
-            context: this.context,
-            stack: this.stack
+            context: this.context
         };
+        if (process.env.NODE_ENV !== 'production') {
+            result.stack = this.stack;
+        }
+        return result;
     }
 }
 

package/scripts/hooks-system/infrastructure/ast/ast-intelligence.js

@@ -368,18 +368,36 @@ function generateOutput(findings, context, project, root) {
 
   // Top violations
   const grouped = {};
+  const levelRank = { LOW: 1, MEDIUM: 2, HIGH: 3, CRITICAL: 4 };
+  const emojiForLevel = (level) => (level === 'CRITICAL' || level === 'HIGH' ? '🔴' : '🔵');
+
   findings.forEach(f => {
-    grouped[f.ruleId] = (grouped[f.ruleId] || 0) + 1;
+    if (!f || !f.ruleId) return;
+    const level = mapToLevel(f.severity);
+    if (!grouped[f.ruleId]) {
+      grouped[f.ruleId] = { count: 0, worstLevel: level };
+    }
+    grouped[f.ruleId].count += 1;
+    if ((levelRank[level] || 0) > (levelRank[grouped[f.ruleId].worstLevel] || 0)) {
+      grouped[f.ruleId].worstLevel = level;
+    }
+  });
+
+  const entries = Object.entries(grouped)
+    .map(([ruleId, data]) => ({ ruleId, count: data.count, worstLevel: data.worstLevel }))
+    .sort((a, b) => b.count - a.count);
+
+  const blockers = entries.filter(e => e.worstLevel === 'CRITICAL' || e.worstLevel === 'HIGH');
+  const nonBlockers = entries.filter(e => e.worstLevel !== 'CRITICAL' && e.worstLevel !== 'HIGH');
+
+  blockers.forEach(({ ruleId, count, worstLevel }) => {
+    console.error(`${emojiForLevel(worstLevel)} ${ruleId} - ${count} violations`);
   });
 
-  Object.entries(grouped)
-    .sort((a, b) => b[1] - a[1])
-    .slice(0, 20)
-    .forEach(([ruleId, count]) => {
-      const severity = ruleId.includes("types.any") || ruleId.includes("security.") || ruleId.includes("architecture.") ? "error" :
-        ruleId.includes("performance.") || ruleId.includes("debug.") ? "warning" : "info";
-      const emoji = severity === "error" ? "🔴" : severity === "warning" ? "🟡" : "🔵";
-      console.error(`${emoji} ${ruleId} - ${count} violations`);
+  nonBlockers
+    .slice(0, Math.max(0, 20 - blockers.length))
+    .forEach(({ ruleId, count, worstLevel }) => {
+      console.error(`${emojiForLevel(worstLevel)} ${ruleId} - ${count} violations`);
     });
 
   // Summary

package/scripts/hooks-system/infrastructure/ast/backend/ast-backend.js

@@ -504,7 +504,7 @@ function runBackendIntelligence(project, findings, platform) {
 
     sf.getDescendantsOfKind(SyntaxKind.ClassDeclaration).forEach((cls) => {
       const name = cls.getName();
-      if (name && /Dto|DTO|Request|Response/.test(name)) {
+      if (name && /Dto|DTO|Request|Response/.test(name) && !/Exception|Error/.test(name)) {
         const hasValidation = sf.getFullText().includes("@IsString") ||
           sf.getFullText().includes("@IsEmail") ||
           sf.getFullText().includes("@IsNotEmpty") ||
@@ -1604,7 +1604,7 @@ function runBackendIntelligence(project, findings, platform) {
     if (fullText.includes('extends HttpException') || fullText.includes('extends Error')) {
       const hasFilter = fullText.includes('@Catch(');
 
-      if (!hasFilter && filePath.includes('/exceptions/')) {
+      if (!hasFilter && filePath.includes('/exceptions/') && !fullText.includes('class ') && !fullText.includes('extends BaseException')) {
         pushFinding(
           "backend.error_handling.missing_exception_filter",
           "high",

package/scripts/hooks-system/infrastructure/ast/ios/ast-ios.js

@@ -1803,7 +1803,7 @@ async function runIOSIntelligence(project, findings, platform) {
       );
     }
 
-    if (content.includes('Keychain') && !content.includes('SecItemAdd') && !content.includes('KeychainSwift')) {
+    if (!filePath.includes('Package.swift') && content.includes('Keychain') && !content.includes('SecItemAdd') && !content.includes('KeychainSwift')) {
       pushFinding(
         "ios.security.keychain_usage",
         "low",

package/scripts/hooks-system/infrastructure/mcp/ast-intelligence-automation.js

@@ -56,6 +56,9 @@ const REPO_ROOT = resolveRepoRoot();
 const MCP_LOCK_DIR = path.join(REPO_ROOT, '.audit_tmp', 'mcp-singleton.lock');
 const MCP_LOCK_PID = path.join(MCP_LOCK_DIR, 'pid');
 
+let MCP_IS_PRIMARY = true;
+let MCP_PRIMARY_PID = null;
+
 function isPidRunning(pid) {
     if (!pid || !Number.isFinite(pid) || pid <= 0) return false;
     try {
@@ -107,8 +110,10 @@ function acquireSingletonLock() {
     } catch (error) {
         const existingPid = safeReadPid(MCP_LOCK_PID);
         if (existingPid && isPidRunning(existingPid)) {
-            process.stderr.write(`[MCP] Another instance is already running (pid ${existingPid}). Exiting.\n`);
-            process.exit(0);
+            MCP_IS_PRIMARY = false;
+            MCP_PRIMARY_PID = existingPid;
+            process.stderr.write(`[MCP] Another instance is already running (pid ${existingPid}). Secondary mode enabled.\n`);
+            return { acquired: false, pid: existingPid };
         }
 
         removeLockDir();
@@ -137,6 +142,8 @@ function acquireSingletonLock() {
         cleanup();
         process.exit(0);
     });
+
+    return { acquired: true, pid: process.pid };
 }
 
 acquireSingletonLock();
@@ -760,6 +767,17 @@ async function handleMcpMessage(message) {
     try {
         const request = JSON.parse(message);
 
+        if (!MCP_IS_PRIMARY && request.method !== 'initialize' && request.method !== 'resources/list' && request.method !== 'resources/read' && request.method !== 'tools/list') {
+            return {
+                jsonrpc: '2.0',
+                id: request.id,
+                error: {
+                    code: -32603,
+                    message: `MCP instance already running (pid ${MCP_PRIMARY_PID || 'unknown'}). Please restart the IDE or kill the running instance.`
+                }
+            };
+        }
+
         if ((typeof request.id === 'undefined' || request.id === null) && request.method?.startsWith('notifications/')) {
             return null;
         }
@@ -1054,163 +1072,167 @@ protocolHandler.start(handleMcpMessage);
 /**
  * Polling loop for background notifications and automations
  */
-setInterval(async () => {
-    try {
-        const now = Date.now();
-        const gitFlowService = getCompositionRoot().getGitFlowService();
-        const gitQuery = getCompositionRoot().getGitQueryAdapter();
-        const evidenceMonitor = getCompositionRoot().getEvidenceMonitor();
-        const orchestrator = getCompositionRoot().getOrchestrator();
-
-        const currentBranch = gitFlowService.getCurrentBranch();
-        const baseBranch = process.env.AST_BASE_BRANCH || 'develop';
-        const isProtectedBranch = ['main', 'master', baseBranch].includes(currentBranch);
-
-        const uncommittedChanges = gitQuery.getUncommittedChanges();
-        const hasUncommittedChanges = uncommittedChanges && uncommittedChanges.length > 0;
-
-        // 1. Protected Branch Guard
-        if (isProtectedBranch && hasUncommittedChanges) {
-            if (now - lastGitFlowNotification > NOTIFICATION_COOLDOWN) {
-                const state = gitQuery.getBranchState(currentBranch);
-                sendNotification(
-                    '⚠️ Git Flow Violation',
-                    `branch=${currentBranch} changes detected on protected branch. Create a feature branch.`,
-                    'Basso'
-                );
-                lastGitFlowNotification = now;
-            }
-        }
-
-        // 2. Evidence Freshness Guard
-        if (evidenceMonitor.isStale() && (now - lastEvidenceNotification > NOTIFICATION_COOLDOWN)) {
-            try {
-                await evidenceMonitor.refresh();
-                sendNotification('🔄 Evidence Auto-Updated', 'AI Evidence has been refreshed automatically', 'Purr');
-            } catch (err) {
-                sendNotification('⚠️ Evidence Stale', `Failed to auto-refresh evidence: ${err.message}`, 'Basso');
+if (MCP_IS_PRIMARY) {
+    setInterval(async () => {
+        try {
+            const now = Date.now();
+            const gitFlowService = getCompositionRoot().getGitFlowService();
+            const gitQuery = getCompositionRoot().getGitQueryAdapter();
+            const evidenceMonitor = getCompositionRoot().getEvidenceMonitor();
+            const orchestrator = getCompositionRoot().getOrchestrator();
+
+            const currentBranch = gitFlowService.getCurrentBranch();
+            const baseBranch = process.env.AST_BASE_BRANCH || 'develop';
+            const isProtectedBranch = ['main', 'master', baseBranch].includes(currentBranch);
+
+            const uncommittedChanges = gitQuery.getUncommittedChanges();
+            const hasUncommittedChanges = uncommittedChanges && uncommittedChanges.length > 0;
+
+            // 1. Protected Branch Guard
+            if (isProtectedBranch && hasUncommittedChanges) {
+                if (now - lastGitFlowNotification > NOTIFICATION_COOLDOWN) {
+                    const state = gitQuery.getBranchState(currentBranch);
+                    sendNotification(
+                        '⚠️ Git Flow Violation',
+                        `branch=${currentBranch} changes detected on protected branch. Create a feature branch.`,
+                        'Basso'
+                    );
+                    lastGitFlowNotification = now;
+                }
             }
-            lastEvidenceNotification = now;
-        }
 
-        // 3. Autonomous Orchestration
-        if (orchestrator.shouldReanalyze()) {
-            const decision = await orchestrator.analyzeContext();
-            if (decision.action === 'auto-execute' && decision.platforms.length > 0) {
+            // 2. Evidence Freshness Guard
+            if (evidenceMonitor.isStale() && (now - lastEvidenceNotification > NOTIFICATION_COOLDOWN)) {
                 try {
                     await evidenceMonitor.refresh();
-                    sendNotification('✅ AI Start Executed', `Platforms: ${decision.platforms.map(p => p.platform.toUpperCase()).join(', ')}`, 'Glass');
-                } catch (e) {
-                    sendNotification('❌ AI Start Error', `Failed to execute: ${e.message}`, 'Basso');
+                    sendNotification('🔄 Evidence Auto-Updated', 'AI Evidence has been refreshed automatically', 'Purr');
+                } catch (err) {
+                    sendNotification('⚠️ Evidence Stale', `Failed to auto-refresh evidence: ${err.message}`, 'Basso');
                 }
+                lastEvidenceNotification = now;
             }
-        }
 
-    } catch (error) {
-        if (process.env.DEBUG) console.error('[MCP] Polling loop error:', error);
-    }
-}, 30000);
+            // 3. Autonomous Orchestration
+            if (orchestrator.shouldReanalyze()) {
+                const decision = await orchestrator.analyzeContext();
+                if (decision.action === 'auto-execute' && decision.platforms.length > 0) {
+                    try {
+                        await evidenceMonitor.refresh();
+                        sendNotification('✅ AI Start Executed', `Platforms: ${decision.platforms.map(p => p.platform.toUpperCase()).join(', ')}`, 'Glass');
+                    } catch (e) {
+                        sendNotification('❌ AI Start Error', `Failed to execute: ${e.message}`, 'Basso');
+                    }
+                }
+            }
 
-// AUTO-COMMIT: Only for project code changes (no node_modules, no library)
-setInterval(async () => {
-    if (!AUTO_COMMIT_ENABLED) {
-        return;
-    }
+        } catch (error) {
+            if (process.env.DEBUG) console.error('[MCP] Polling loop error:', error);
+        }
+    }, 30000);
+}
 
-    const now = Date.now();
-    if (now - lastAutoCommitTime < AUTO_COMMIT_INTERVAL) return;
+// AUTO-COMMIT: Only for project code changes (no node_modules, no library)
+if (MCP_IS_PRIMARY) {
+    setInterval(async () => {
+        if (!AUTO_COMMIT_ENABLED) {
+            return;
+        }
 
-    try {
-        const gitFlowService = getCompositionRoot().getGitFlowService();
-        const gitQuery = getCompositionRoot().getGitQueryAdapter();
-        const gitCommand = getCompositionRoot().getGitCommandAdapter();
+        const now = Date.now();
+        if (now - lastAutoCommitTime < AUTO_COMMIT_INTERVAL) return;
 
-        const currentBranch = gitFlowService.getCurrentBranch();
-        const isFeatureBranch = currentBranch.match(/^(feature|fix|hotfix)\//);
+        try {
+            const gitFlowService = getCompositionRoot().getGitFlowService();
+            const gitQuery = getCompositionRoot().getGitQueryAdapter();
+            const gitCommand = getCompositionRoot().getGitCommandAdapter();
 
-        if (!isFeatureBranch) {
-            return;
-        }
+            const currentBranch = gitFlowService.getCurrentBranch();
+            const isFeatureBranch = currentBranch.match(/^(feature|fix|hotfix)\//);
 
-        if (gitFlowService.isClean()) {
-            return;
-        }
+            if (!isFeatureBranch) {
+                return;
+            }
 
-        // Get uncommitted changes
-        const uncommittedChanges = gitQuery.getUncommittedChanges();
-
-        // Detect library installation path
-        const libraryPath = getLibraryInstallPath();
-
-        // Filter changes: project code only
-        const filesToCommit = uncommittedChanges.filter(file => {
-            // Exclude noise
-            if (file.startsWith('node_modules/') ||
-                file.includes('package-lock.json') ||
-                file.startsWith('.git/') ||
-                file.startsWith('.cursor/') ||
-                file.startsWith('.ast-intelligence/') ||
-                file.startsWith('.vscode/') ||
-                file.startsWith('.idea/')) {
-                return false;
+            if (gitFlowService.isClean()) {
+                return;
             }
 
-            // Exclude library itself
-            if (libraryPath && file.startsWith(libraryPath + '/')) {
-                return false;
+            // Get uncommitted changes
+            const uncommittedChanges = gitQuery.getUncommittedChanges();
+
+            // Detect library installation path
+            const libraryPath = getLibraryInstallPath();
+
+            // Filter changes: project code only
+            const filesToCommit = uncommittedChanges.filter(file => {
+                // Exclude noise
+                if (file.startsWith('node_modules/') ||
+                    file.includes('package-lock.json') ||
+                    file.startsWith('.git/') ||
+                    file.startsWith('.cursor/') ||
+                    file.startsWith('.ast-intelligence/') ||
+                    file.startsWith('.vscode/') ||
+                    file.startsWith('.idea/')) {
+                    return false;
+                }
+
+                // Exclude library itself
+                if (libraryPath && file.startsWith(libraryPath + '/')) {
+                    return false;
+                }
+
+                // Code/Doc files only
+                const codeExtensions = ['.ts', '.tsx', '.js', '.jsx', '.swift', '.kt', '.py', '.java', '.go', '.rs', '.md', '.json', '.yaml', '.yml'];
+                return codeExtensions.some(ext => file.endsWith(ext));
+            });
+
+            if (filesToCommit.length === 0) {
+                return;
             }
 
-            // Code/Doc files only
-            const codeExtensions = ['.ts', '.tsx', '.js', '.jsx', '.swift', '.kt', '.py', '.java', '.go', '.rs', '.md', '.json', '.yaml', '.yml'];
-            return codeExtensions.some(ext => file.endsWith(ext));
-        });
+            // Stage files
+            filesToCommit.forEach(file => {
+                gitCommand.add(file);
+            });
 
-        if (filesToCommit.length === 0) {
-            return;
-        }
+            const branchType = currentBranch.split('/')[0];
+            const branchName = currentBranch.split('/').slice(1).join('/');
+            const commitMessage = `${branchType}(auto): ${branchName} - ${filesToCommit.length} files`;
 
-        // Stage files
-        filesToCommit.forEach(file => {
-            gitCommand.add(file);
-        });
+            // Commit
+            gitCommand.commit(commitMessage);
 
-        const branchType = currentBranch.split('/')[0];
-        const branchName = currentBranch.split('/').slice(1).join('/');
-        const commitMessage = `${branchType}(auto): ${branchName} - ${filesToCommit.length} files`;
+            sendNotification('✅ Auto-Commit', `${filesToCommit.length} files in ${currentBranch}`, 'Purr');
+            lastAutoCommitTime = now;
 
-        // Commit
-        gitCommand.commit(commitMessage);
+            if (AUTO_PUSH_ENABLED) {
+                if (gitFlowService.isGitHubAvailable()) {
+                    try {
+                        gitCommand.push('origin', currentBranch);
+                        sendNotification('✅ Auto-Push', `Pushed to origin/${currentBranch}`, 'Glass');
 
-        sendNotification('✅ Auto-Commit', `${filesToCommit.length} files in ${currentBranch}`, 'Purr');
-        lastAutoCommitTime = now;
+                        if (AUTO_PR_ENABLED) {
+                            const baseBranch = process.env.AST_BASE_BRANCH || 'develop';
+                            const branchState = gitQuery.getBranchState(currentBranch);
 
-        if (AUTO_PUSH_ENABLED) {
-            if (gitFlowService.isGitHubAvailable()) {
-                try {
-                    gitCommand.push('origin', currentBranch);
-                    sendNotification('✅ Auto-Push', `Pushed to origin/${currentBranch}`, 'Glass');
-
-                    if (AUTO_PR_ENABLED) {
-                        const baseBranch = process.env.AST_BASE_BRANCH || 'develop';
-                        const branchState = gitQuery.getBranchState(currentBranch);
-
-                        if (branchState.ahead >= 3) {
-                            const prTitle = `Auto-PR: ${branchName}`;
-                            const prUrl = gitFlowService.createPullRequest(currentBranch, baseBranch, prTitle, 'Automated PR by Pumuki Git Flow');
-                            if (prUrl) {
-                                sendNotification('✅ Auto-PR Created', prTitle, 'Hero');
+                            if (branchState.ahead >= 3) {
+                                const prTitle = `Auto-PR: ${branchName}`;
+                                const prUrl = gitFlowService.createPullRequest(currentBranch, baseBranch, prTitle, 'Automated PR by Pumuki Git Flow');
+                                if (prUrl) {
+                                    sendNotification('✅ Auto-PR Created', prTitle, 'Hero');
+                                }
                             }
                         }
-                    }
-                } catch (e) {
-                    if (!e.message.includes('No remote')) {
-                        sendNotification('⚠️ Auto-Push Failed', 'Push manual required', 'Basso');
+                    } catch (e) {
+                        if (!e.message.includes('No remote')) {
+                            sendNotification('⚠️ Auto-Push Failed', 'Push manual required', 'Basso');
+                        }
                     }
                 }
             }
-        }
 
-    } catch (error) {
-        if (process.env.DEBUG) console.error('[MCP] Auto-commit error:', error);
-    }
-}, AUTO_COMMIT_INTERVAL);
+        } catch (error) {
+            if (process.env.DEBUG) console.error('[MCP] Auto-commit error:', error);
+        }
+    }, AUTO_COMMIT_INTERVAL);
+}

package/scripts/hooks-system/infrastructure/repositories/datasources/CursorApiDataSource.js

@@ -11,6 +11,42 @@ class CursorApiDataSource {
         this.apiToken = apiToken;
         this.fetch = fetchImpl;
         this.logger = logger;
+        this.failureCount = 0;
+        this.failureThreshold = 5;
+        this.circuitOpenUntil = null;
+        this.circuitResetTimeoutMs = 60000;
+    }
+
+    isCircuitOpen() {
+        if (!this.circuitOpenUntil) return false;
+        if (Date.now() >= this.circuitOpenUntil) {
+            this.circuitOpenUntil = null;
+            this.failureCount = 0;
+            return false;
+        }
+        return true;
+    }
+
+    recordFailure() {
+        this.failureCount++;
+        if (this.failureCount >= this.failureThreshold) {
+            this.circuitOpenUntil = Date.now() + this.circuitResetTimeoutMs;
+            if (this.logger && this.logger.warn) {
+                this.logger.warn('CURSOR_API_CIRCUIT_BREAKER_OPEN', {
+                    failureCount: this.failureCount,
+                    resetTimeoutMs: this.circuitResetTimeoutMs
+                });
+            }
+        }
+    }
+
+    recordSuccess() {
+        this.failureCount = 0;
+        this.circuitOpenUntil = null;
+    }
+
+    circuitBreaker() {
+        return this.isCircuitOpen();
     }
 
     async fetchUsage(maxRetries = 3, initialDelayMs = 1000) {
@@ -18,6 +54,13 @@ class CursorApiDataSource {
             return null;
         }
 
+        if (this.isCircuitOpen()) {
+            if (this.logger && this.logger.warn) {
+                this.logger.warn('CURSOR_API_CIRCUIT_BREAKER_OPEN', { message: 'Circuit is open, skipping request' });
+            }
+            return null;
+        }
+
         const retryPolicy = { maxAttempts: maxRetries, backoff: 'exponential' };
         const requestTimeoutMs = 30000;
 
@@ -43,6 +86,7 @@ class CursorApiDataSource {
                         return null;
                     }
 
+                    this.recordSuccess();
                     return payload;
                 } catch (fetchError) {
                     if (timeoutId) clearTimeout(timeoutId);
@@ -54,6 +98,7 @@ class CursorApiDataSource {
             } catch (error) {
                 const isLastAttempt = attempt === retryPolicy.maxAttempts;
                 if (isLastAttempt) {
+                    this.recordFailure();
                     if (this.logger && this.logger.warn) {
                         this.logger.warn('CURSOR_API_DATASOURCE_FAILED', { error: error.message, attempts: attempt + 1 });
                     }