pumuki-ast-hooks 5.3.20 → 5.3.22

package/scripts/hooks-system/application/services/PlatformDetectionService.js

@@ -1,19 +1,9 @@
 
-const {
-  createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 const fs = require('fs').promises;
 const path = require('path');
 
 class PlatformDetectionService {
   constructor() {
-    const m_constructor = createMetricScope({
-      hook: 'platform_detection_service',
-      operation: 'constructor'
-    });
-
-    m_constructor.started();
     this.cache = {
       detections: new Map(),
       timestamp: 0,
@@ -53,7 +43,6 @@ class PlatformDetectionService {
         '*.java',
       ],
     };
-    m_constructor.success();
   }
 
   async detectPlatforms(targetPath) {
@@ -153,12 +142,6 @@ class PlatformDetectionService {
   }
 
   getAmbiguityScore(filePath) {
-    const m_get_ambiguity_score = createMetricScope({
-      hook: 'platform_detection_service',
-      operation: 'get_ambiguity_score'
-    });
-
-    m_get_ambiguity_score.started();
     const platform = this._detectPlatformUncached(filePath);
     const lowerPath = filePath.toLowerCase();
     const ext = path.extname(filePath);
@@ -173,8 +156,6 @@ class PlatformDetectionService {
     if (ext === '.ts' || ext === '.tsx') return 60;
     if (ext === '.js' || ext === '.jsx') return 70;
 
-    m_get_ambiguity_score.success();
-
     return 100;
   }
 

package/scripts/hooks-system/application/services/PlaybookRunner.js

@@ -2,27 +2,13 @@ const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const { DomainError, NotFoundError } = require('../../domain/errors');
-const { NotFoundException } = require('../domain/exceptions');
-
-const { recordMetric } = require('../../../infrastructure/telemetry/metrics-logger');
-
-const {
-  createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
 
 const PLAYBOOKS_PATH = path.join(process.cwd(), 'scripts', 'hooks-system', 'config', 'playbooks.json');
 
 class PlaybookRunner {
   constructor(options = {}) {
-    const m_constructor = createMetricScope({
-      hook: 'playbook_runner',
-      operation: 'constructor'
-    });
-
-    m_constructor.started();
     this.cwd = options.cwd || process.cwd();
     this.playbooks = JSON.parse(fs.readFileSync(PLAYBOOKS_PATH, 'utf8'));
-    m_constructor.success();
   }
 
   list() {
@@ -30,15 +16,9 @@ class PlaybookRunner {
   }
 
   run(id) {
-    const m_run = createMetricScope({
-      hook: 'playbook_runner',
-      operation: 'run'
-    });
-
-    m_run.started();
     const playbook = this.playbooks[id];
     if (!playbook) {
-      throw new NotFoundException('Playbook', { id });
+      throw new NotFoundError(`Playbook '${id}'`);
     }
 
     for (const step of playbook.steps) {
@@ -53,7 +33,6 @@ class PlaybookRunner {
         }
       }
     }
-    m_run.success();
   }
 }
 

package/scripts/hooks-system/application/services/PredictiveHookAdvisor.js

@@ -1,22 +1,11 @@
 const fs = require('fs');
 const path = require('path');
 
-const {
-  createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 const METRICS_FILE = path.join(process.cwd(), '.audit_tmp', 'hook-metrics.jsonl');
 
 class PredictiveHookAdvisor {
   constructor({ windowSize = 200 } = {}) {
-    const m_constructor = createMetricScope({
-      hook: 'predictive_hook_advisor',
-      operation: 'constructor'
-    });
-
-    m_constructor.started();
     this.windowSize = windowSize;
-    m_constructor.success();
   }
 
   loadMetrics() {
@@ -35,12 +24,6 @@ class PredictiveHookAdvisor {
   }
 
   getFailureProbabilities() {
-    const m_get_failure_probabilities = createMetricScope({
-      hook: 'predictive_hook_advisor',
-      operation: 'get_failure_probabilities'
-    });
-
-    m_get_failure_probabilities.started();
     const metrics = this.loadMetrics();
     const stats = {};
 
@@ -55,8 +38,6 @@ class PredictiveHookAdvisor {
       }
     }
 
-    m_get_failure_probabilities.success();
-
     return Object.entries(stats)
       .map(([hook, { total, failures }]) => ({
         hook,

package/scripts/hooks-system/application/services/RealtimeGuardPlugin.js

@@ -1,9 +1,5 @@
 const EvidenceMonitorService = require('./monitoring/EvidenceMonitorService');
 
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 class EvidenceRealtimeGuardPlugin {
     constructor({
         repoRoot = process.cwd(),
@@ -11,12 +7,6 @@ class EvidenceRealtimeGuardPlugin {
         logger = console,
         evidenceMonitor = null
     } = {}) {
-        const m_constructor = createMetricScope({
-            hook: 'realtime_guard_plugin',
-            operation: 'constructor'
-        });
-
-        m_constructor.started();
         this.repoRoot = repoRoot;
         this.notificationCenter = notificationCenter;
         this.logger = logger || console;
@@ -26,33 +16,18 @@ class EvidenceRealtimeGuardPlugin {
             logger: this.logger,
             notifier: payload => this.forwardNotification(payload)
         });
-        m_constructor.success();
     }
 
     start() {
-        const m_start = createMetricScope({
-            hook: 'realtime_guard_plugin',
-            operation: 'start'
-        });
-
-        m_start.started();
         if (typeof this.evidenceMonitor.start === 'function') {
             this.evidenceMonitor.start();
         }
-        m_start.success();
     }
 
     stop() {
-        const m_stop = createMetricScope({
-            hook: 'realtime_guard_plugin',
-            operation: 'stop'
-        });
-
-        m_stop.started();
         if (typeof this.evidenceMonitor.stop === 'function') {
             this.evidenceMonitor.stop();
         }
-        m_stop.success();
     }
 
     forwardNotification(payload) {

package/scripts/hooks-system/application/services/RealtimeGuardService.js

@@ -1,12 +1,9 @@
 const fs = require('fs');
 const path = require('path');
 const { getGitTreeState, isTreeBeyondLimit } = require('./GitTreeState');
-
-const { recordMetric } = require('../../../infrastructure/telemetry/metrics-logger');
-
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
+const AuditLogger = require('./logging/AuditLogger');
+const { recordMetric } = require('../../infrastructure/telemetry/metrics-logger');
+const env = require('../../../config/env');
 
 class RealtimeGuardService {
     /**
@@ -18,13 +15,6 @@ class RealtimeGuardService {
      * @param {Object} dependencies.config
      */
     constructor(dependencies = {}) {
-        recordMetric({
-            hook: 'realtime_guard_service',
-            operation: 'constructor',
-            status: 'started',
-            hasDependencies: !!dependencies
-        });
-
         const {
             logger,
             notificationService,
@@ -43,45 +33,42 @@ class RealtimeGuardService {
         this.monitors = monitors || {};
         this.orchestration = orchestration;
         this.config = config || {};
+        this.auditLogger = dependencies.auditLogger || new AuditLogger({ repoRoot: process.cwd(), logger: this.logger });
 
         if (!this.config.debugLogPath) {
             this.config.debugLogPath = path.join(process.cwd(), '.audit-reports', 'guard-debug.log');
         }
 
         this.evidencePath = this.config.evidencePath || path.join(process.cwd(), '.AI_EVIDENCE.json');
-        this.staleThresholdMs = Number(process.env.HOOK_GUARD_EVIDENCE_STALE_THRESHOLD || 60000);
-        this.reminderIntervalMs = Number(process.env.HOOK_GUARD_EVIDENCE_REMINDER_INTERVAL || 60000);
-        this.inactivityGraceMs = Number(process.env.HOOK_GUARD_INACTIVITY_GRACE_MS || 120000);
-        this.pollIntervalMs = Number(process.env.HOOK_GUARD_EVIDENCE_POLL_INTERVAL || 30000);
+        this.staleThresholdMs = env.getNumber('HOOK_GUARD_EVIDENCE_STALE_THRESHOLD', 60000);
+        this.reminderIntervalMs = env.getNumber('HOOK_GUARD_EVIDENCE_REMINDER_INTERVAL', 60000);
+        this.inactivityGraceMs = env.getNumber('HOOK_GUARD_INACTIVITY_GRACE_MS', 120000);
+        this.pollIntervalMs = env.getNumber('HOOK_GUARD_EVIDENCE_POLL_INTERVAL', 30000);
         this.pollTimer = null;
         this.lastStaleNotification = 0;
         this.lastUserActivityAt = 0;
 
-        this.gitTreeStagedThreshold = Number(process.env.HOOK_GUARD_DIRTY_TREE_STAGED_LIMIT || 10);
-        this.gitTreeUnstagedThreshold = Number(process.env.HOOK_GUARD_DIRTY_TREE_UNSTAGED_LIMIT || 15);
-        this.gitTreeTotalThreshold = Number(process.env.HOOK_GUARD_DIRTY_TREE_TOTAL_LIMIT || 20);
-        this.gitTreeCheckIntervalMs = Number(process.env.HOOK_GUARD_DIRTY_TREE_INTERVAL || 60000);
-        this.gitTreeReminderMs = Number(process.env.HOOK_GUARD_DIRTY_TREE_REMINDER || 300000);
+        this.gitTreeStagedThreshold = env.getNumber('HOOK_GUARD_DIRTY_TREE_STAGED_LIMIT', 10);
+        this.gitTreeUnstagedThreshold = env.getNumber('HOOK_GUARD_DIRTY_TREE_UNSTAGED_LIMIT', 15);
+        this.gitTreeTotalThreshold = env.getNumber('HOOK_GUARD_DIRTY_TREE_TOTAL_LIMIT', 20);
+        this.gitTreeCheckIntervalMs = env.getNumber('HOOK_GUARD_DIRTY_TREE_INTERVAL', 60000);
+        this.gitTreeReminderMs = env.getNumber('HOOK_GUARD_DIRTY_TREE_REMINDER', 300000);
         this.gitTreeTimer = null;
         this.lastDirtyTreeNotification = 0;
         this.dirtyTreeActive = false;
 
-        this.autoRefreshCooldownMs = Number(process.env.HOOK_GUARD_EVIDENCE_AUTO_REFRESH_COOLDOWN || 180000);
+        this.autoRefreshCooldownMs = env.getNumber('HOOK_GUARD_EVIDENCE_AUTO_REFRESH_COOLDOWN', 180000);
         this.lastAutoRefresh = 0;
         this.autoRefreshInFlight = false;
 
         this.watchers = [];
-        this.embedTokenMonitor = process.env.HOOK_GUARD_EMBEDDED_TOKEN_MONITOR === 'true';
+        this.embedTokenMonitor = env.getBool('HOOK_GUARD_EMBEDDED_TOKEN_MONITOR', false);
     }
 
     start() {
-        const m_start = createMetricScope({
-            hook: 'realtime_guard_service',
-            operation: 'start'
-        });
-
-        m_start.started();
         this.logger.info('Starting RealtimeGuardService...');
+        this.auditLogger.record({ action: 'guard.realtime.start', resource: 'realtime_guard', status: 'success' });
+        recordMetric({ hook: 'realtime_guard', status: 'start' });
 
         // Start all monitors
         this._startEvidenceMonitoring();
@@ -97,17 +84,12 @@ class RealtimeGuardService {
         this._startGitFlowSync();
 
         this.logger.info('[RealtimeGuardService] All services started');
-        m_start.success();
     }
 
     stop() {
-        const m_stop = createMetricScope({
-            hook: 'realtime_guard_service',
-            operation: 'stop'
-        });
-
-        m_stop.started();
         this.logger.info('Stopping RealtimeGuardService...');
+        this.auditLogger.record({ action: 'guard.realtime.stop', resource: 'realtime_guard', status: 'success' });
+        recordMetric({ hook: 'realtime_guard', status: 'stop' });
 
         this.watchers.forEach(w => w.close());
         this.watchers = [];
@@ -119,7 +101,6 @@ class RealtimeGuardService {
         });
 
         this.logger.info('[RealtimeGuardService] All services stopped');
-        m_stop.success();
     }
 
     _startEvidenceMonitoring() {
@@ -130,14 +111,27 @@ class RealtimeGuardService {
     }
 
     _startGitTreeMonitoring() {
-        if (process.env.HOOK_GUARD_DIRTY_TREE_DISABLED === 'true') return;
+        if (env.getBool('HOOK_GUARD_DIRTY_TREE_DISABLED', false)) return;
 
         this.monitors.gitTree.startMonitoring((state) => {
             if (state.isBeyondLimit) {
                 const message = `Git tree has too many files: ${state.total} total (${state.staged} staged, ${state.unstaged} unstaged)`;
                 this.notify(message, 'error', { forceDialog: true });
+                this.auditLogger.record({
+                    action: 'guard.git_tree.dirty',
+                    resource: 'git_tree',
+                    status: 'warning',
+                    meta: { total: state.total, staged: state.staged, unstaged: state.unstaged }
+                });
+                recordMetric({ hook: 'git_tree', status: 'dirty', total: state.total, staged: state.staged, unstaged: state.unstaged });
             } else {
                 this.notify('✅ Git tree is clean', 'success');
+                this.auditLogger.record({
+                    action: 'guard.git_tree.clean',
+                    resource: 'git_tree',
+                    status: 'success'
+                });
+                recordMetric({ hook: 'git_tree', status: 'clean' });
             }
         });
     }
@@ -151,22 +145,44 @@ class RealtimeGuardService {
         try {
             this.monitors.token.start();
             this.notify('🔋 Token monitor started', 'info');
+            this.auditLogger.record({
+                action: 'guard.token_monitor.start',
+                resource: 'token_monitor',
+                status: 'success'
+            });
+            recordMetric({ hook: 'token_monitor', status: 'start' });
         } catch (error) {
             this.notify(`Failed to start token monitor: ${error.message}`, 'error');
+            this.auditLogger.record({
+                action: 'guard.token_monitor.start',
+                resource: 'token_monitor',
+                status: 'fail',
+                meta: { message: error.message }
+            });
+            recordMetric({ hook: 'token_monitor', status: 'fail' });
         }
     }
 
     _startGitFlowSync() {
         if (!this.monitors.gitFlow.autoSyncEnabled) return;
 
+        this.auditLogger.record({
+            action: 'guard.gitflow.autosync.enabled',
+            resource: 'gitflow',
+            status: 'success',
+            meta: { intervalMs: env.getNumber('HOOK_GUARD_GITFLOW_AUTOSYNC_INTERVAL', 300000) }
+        });
+        recordMetric({ hook: 'gitflow_autosync', status: 'enabled' });
+
         const syncInterval = setInterval(() => {
             if (this.monitors.gitFlow.isClean()) {
                 const result = this.monitors.gitFlow.syncBranches();
                 if (result.success) {
                     this.notify('🔄 Branches synchronized', 'info');
+                    recordMetric({ hook: 'gitflow_autosync', status: 'sync_success' });
                 }
             }
-        }, Number(process.env.HOOK_GUARD_GITFLOW_AUTOSYNC_INTERVAL || 300000));
+        }, env.getNumber('HOOK_GUARD_GITFLOW_AUTOSYNC_INTERVAL', 300000));
 
         syncInterval.unref();
     }
@@ -274,11 +290,18 @@ class RealtimeGuardService {
         this.lastStaleNotification = now;
         const ageSec = Math.floor(ageMs / 1000);
         this.notify(`Evidence has been stale for ${ageSec}s (source: ${source}).`, 'warn', { forceDialog: true });
+        this.auditLogger.record({
+            action: 'guard.evidence.stale',
+            resource: 'evidence',
+            status: 'warning',
+            meta: { ageSec, source }
+        });
+        recordMetric({ hook: 'evidence', status: 'stale', ageSec, source });
         void this.attemptAutoRefresh('stale');
     }
 
     async attemptAutoRefresh(reason = 'manual') {
-        if (process.env.HOOK_GUARD_AUTO_REFRESH !== 'true') {
+        if (!env.getBool('HOOK_GUARD_AUTO_REFRESH', false)) {
             return;
         }
 
@@ -311,6 +334,13 @@ class RealtimeGuardService {
         try {
             await this.runDirectEvidenceRefresh(reason);
             this.lastAutoRefresh = now;
+            this.auditLogger.record({
+                action: 'guard.evidence.auto_refresh',
+                resource: 'evidence',
+                status: 'success',
+                meta: { reason }
+            });
+            recordMetric({ hook: 'evidence', status: 'auto_refresh_success', reason });
         } finally {
             this.autoRefreshInFlight = false;
         }

package/scripts/hooks-system/application/services/SmartDirtyTreeAnalyzer.js

@@ -3,22 +3,12 @@ const FileContextGrouper = require('./smart-commit/FileContextGrouper');
 const CommitMessageSuggester = require('./smart-commit/CommitMessageSuggester');
 const SmartCommitSummaryBuilder = require('./smart-commit/SmartCommitSummaryBuilder');
 
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 class SmartDirtyTreeAnalyzer {
     constructor({
         platformDetector = null,
         repoRoot = process.cwd(),
         logger = console
     } = {}) {
-        const m_constructor = createMetricScope({
-            hook: 'smart_dirty_tree_analyzer',
-            operation: 'constructor'
-        });
-
-        m_constructor.started();
         this.repoRoot = repoRoot;
         this.logger = logger;
 
@@ -26,7 +16,6 @@ class SmartDirtyTreeAnalyzer {
         this.grouper = new FileContextGrouper(this.featureDetector, platformDetector);
         this.suggester = new CommitMessageSuggester(this.featureDetector);
         this.summaryBuilder = new SmartCommitSummaryBuilder();
-        m_constructor.success();
     }
 
     analyze(files) {

package/scripts/hooks-system/application/services/commit/CommitMessageGenerator.js

@@ -1,17 +1,6 @@
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 class CommitMessageGenerator {
     constructor(logger = console) {
-        const m_constructor = createMetricScope({
-            hook: 'commit_message_generator',
-            operation: 'constructor'
-        });
-
-        m_constructor.started();
         this.logger = logger;
-        m_constructor.success();
     }
 
     /**

package/scripts/hooks-system/application/services/commit/FeatureDetector.js

@@ -1,17 +1,6 @@
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 class FeatureDetector {
     constructor(logger = console) {
-        const m_constructor = createMetricScope({
-            hook: 'feature_detector',
-            operation: 'constructor'
-        });
-
-        m_constructor.started();
         this.logger = logger;
-        m_constructor.success();
     }
 
     /**

package/scripts/hooks-system/application/services/evidence/EvidenceContextManager.js

@@ -3,10 +3,6 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 const { DomainError } = require('../../../domain/errors');
 
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
-
 const DEFAULT_PLATFORMS = ['1', '2', '3', '4'];
 
 function resolveUpdateEvidenceScript(repoRoot) {
@@ -37,12 +33,6 @@ class EvidenceContextManager {
         timers = { setInterval, clearInterval },
         runCommand = EvidenceContextManager.runUpdateScript
     } = {}) {
-        const m_constructor = createMetricScope({
-            hook: 'evidence_context_manager',
-            operation: 'constructor'
-        });
-
-        m_constructor.started();
         this.repoRoot = repoRoot;
         this.updateScript = updateScript;
         this.thresholdSeconds = thresholdSeconds;
@@ -54,7 +44,6 @@ class EvidenceContextManager {
         this.runCommand = runCommand;
         this.timerRef = null;
         this.refreshInProgress = false;
-        m_constructor.success();
     }
 
     static runUpdateScript(scriptPath, platforms) {
@@ -72,12 +61,6 @@ class EvidenceContextManager {
     }
 
     start(reason = 'startup') {
-        const m_start = createMetricScope({
-            hook: 'evidence_context_manager',
-            operation: 'start'
-        });
-
-        m_start.started();
         this.ensureFresh(reason).catch(error => {
             this.log('error', 'EVIDENCE_STARTUP_REFRESH_FAILED', { error: error.message });
         });
@@ -91,21 +74,13 @@ class EvidenceContextManager {
                 this.timerRef.unref();
             }
         }
-        m_start.success();
     }
 
     stop() {
-        const m_stop = createMetricScope({
-            hook: 'evidence_context_manager',
-            operation: 'stop'
-        });
-
-        m_stop.started();
         if (this.timerRef) {
             this.timers.clearInterval(this.timerRef);
             this.timerRef = null;
         }
-        m_stop.success();
     }
 
     async ensureFresh(reason = 'manual') {

package/scripts/hooks-system/application/services/guard/GuardAutoManagerService.js

@@ -10,10 +10,9 @@ const GuardConfig = require('./GuardConfig');
 const GuardNotificationHandler = require('./GuardNotificationHandler');
 const GuardMonitorLoop = require('./GuardMonitorLoop');
 const GuardHealthReminder = require('./GuardHealthReminder');
-
-const {
-    createMetricScope: createMetricScope
-} = require('../../../infrastructure/telemetry/metric-scope');
+const AuditLogger = require('../logging/AuditLogger');
+const envHelper = require('../../../config/env');
+const { recordMetric } = require('../../../infrastructure/telemetry/metrics-logger');
 
 class GuardAutoManagerService {
     constructor({
@@ -23,16 +22,11 @@ class GuardAutoManagerService {
         fsModule = fs,
         childProcess = { spawnSync },
         timers = { setInterval, clearInterval },
-        env = process.env,
+        env = envHelper,
         processRef = process,
-        heartbeatMonitor = null
+        heartbeatMonitor = null,
+        auditLogger = null
     } = {}) {
-        const m_constructor = createMetricScope({
-            hook: 'guard_auto_manager_service',
-            operation: 'constructor'
-        });
-
-        m_constructor.started();
         this.process = processRef;
 
         // Configuration & Infrastructure
@@ -40,6 +34,7 @@ class GuardAutoManagerService {
         this.eventLogger = new GuardEventLogger({ repoRoot, logger, fsModule });
         this.lockManager = new GuardLockManager({ repoRoot, logger, fsModule });
         this.processManager = new GuardProcessManager({ repoRoot, logger, fsModule, childProcess });
+        this.auditLogger = auditLogger || new AuditLogger({ repoRoot, logger });
 
         // Monitors & Handlers
         this.heartbeatMonitor = heartbeatMonitor || new GuardHeartbeatMonitor({
@@ -59,7 +54,6 @@ class GuardAutoManagerService {
         this.lastHeartbeatState = { healthy: true, reason: 'healthy' };
         this.lastHeartbeatRestart = 0;
         this.shuttingDown = false;
-        m_constructor.success();
     }
 
     notifyUser(message, level = 'info', metadata = {}) {
@@ -68,25 +62,21 @@ class GuardAutoManagerService {
     }
 
     start() {
-        const m_start = createMetricScope({
-            hook: 'guard_auto_manager_service',
-            operation: 'start'
-        });
-
-        m_start.started();
         if (!this.lockManager.acquireLock()) {
             this.eventLogger.log('Another guard auto manager instance detected. Exiting.');
-            m_start.success();
+            this.auditLogger.record({ action: 'guard.lock.acquire', resource: 'guard_auto_manager', status: 'fail', meta: { reason: 'lock_exists' } });
+            recordMetric({ hook: 'guard_auto_manager', status: 'lock_fail' });
             return false;
         }
         this.lockManager.writePidFile();
         this.eventLogger.log('Guard auto manager started');
+        this.auditLogger.record({ action: 'guard.manager.start', resource: 'guard_auto_manager', status: 'success' });
+        recordMetric({ hook: 'guard_auto_manager', status: 'start' });
 
         this.ensureSupervisor('initial-start');
         this._startReminder();
         this.monitorLoop.start();
         this.registerProcessHooks();
-        m_start.success();
         return true;
     }
 
@@ -113,6 +103,12 @@ class GuardAutoManagerService {
     handleMissingSupervisor() {
         this.lastHeartbeatState = { healthy: false, reason: 'missing-supervisor' };
         this.eventLogger.recordEvent('Guard supervisor no se encuentra en ejecución; reinicio automático.');
+        this.auditLogger.record({
+            action: 'guard.supervisor.missing',
+            resource: 'guard_supervisor',
+            status: 'fail',
+            meta: { reason: 'missing-supervisor' }
+        });
         this.ensureSupervisor('missing-supervisor');
     }
 
@@ -125,9 +121,21 @@ class GuardAutoManagerService {
                 this.eventLogger.log(`Heartbeat degraded (${heartbeat.reason}); attempting supervisor ensure.`);
                 this.lastHeartbeatRestart = now;
                 this.ensureSupervisor(`heartbeat-${heartbeat.reason}`);
+                this.auditLogger.record({
+                    action: 'guard.supervisor.ensure',
+                    resource: 'guard_supervisor',
+                    status: 'success',
+                    meta: { reason: heartbeat.reason }
+                });
             } else {
                 this.eventLogger.log(`Heartbeat degraded (${heartbeat.reason}); restart suppressed (cooldown).`);
                 this.eventLogger.recordEvent(`Heartbeat degradado (${heartbeat.reason}); reinicio omitido por cooldown.`);
+                this.auditLogger.record({
+                    action: 'guard.supervisor.ensure',
+                    resource: 'guard_supervisor',
+                    status: 'fail',
+                    meta: { reason: heartbeat.reason, suppressed: true }
+                });
             }
         } else {
             this.eventLogger.recordEvent(`Heartbeat en estado ${heartbeat.reason}; reinicio no requerido.`);
@@ -167,6 +175,8 @@ class GuardAutoManagerService {
         this.lockManager.removePidFile();
         this.lockManager.releaseLock();
         this.healthReminder.stop();
+        this.auditLogger.record({ action: 'guard.manager.stop', resource: 'guard_auto_manager', status: 'success' });
+        recordMetric({ hook: 'guard_auto_manager', status: 'stop' });
     }
 
     ensureSupervisor(reason) {