neuronlayer 0.1.3 → 0.1.4

package/dist/index.js

@@ -21072,6 +21072,15 @@ function initializeDatabase(dbPath) {
     CREATE INDEX IF NOT EXISTS idx_test_index_file ON test_index(file_path);
     CREATE INDEX IF NOT EXISTS idx_test_index_name ON test_index(test_name);
     CREATE INDEX IF NOT EXISTS idx_test_covers_files ON test_index(covers_files);
+
+    -- Intelligent Refresh System: State persistence
+    CREATE TABLE IF NOT EXISTS refresh_state (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER DEFAULT (unixepoch())
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_refresh_state_key ON refresh_state(key);
   `);
   return db;
 }
@@ -23303,6 +23312,9 @@ var LearningEngine = class {
   MAX_CACHE_SIZE = 50;
   CACHE_TTL_MS = 30 * 60 * 1e3;
   // 30 minutes
+  lastImportanceUpdate = 0;
+  IMPORTANCE_UPDATE_INTERVAL_MS = 5 * 60 * 1e3;
+  // 5 minutes
   constructor(db) {
     this.db = db;
   }
@@ -23571,11 +23583,35 @@ var LearningEngine = class {
     const result = stmt.run(daysToKeep);
     return result.changes;
   }
+  /**
+   * Check if importance update should be skipped
+   * Returns true if we've already updated within the last 5 minutes
+   */
+  shouldSkipImportanceUpdate() {
+    const now = Date.now();
+    return now - this.lastImportanceUpdate < this.IMPORTANCE_UPDATE_INTERVAL_MS;
+  }
+  /**
+   * Get time since last importance update in milliseconds
+   */
+  getTimeSinceLastImportanceUpdate() {
+    return Date.now() - this.lastImportanceUpdate;
+  }
+  /**
+   * Get the last importance update timestamp
+   */
+  getLastImportanceUpdateTime() {
+    return this.lastImportanceUpdate;
+  }
   /**
    * Update importance scores for all files based on usage patterns
    * Called by background intelligence loop
+   * Gated to run at most once per 5 minutes
    */
   updateImportanceScores() {
+    if (this.shouldSkipImportanceUpdate()) {
+      return;
+    }
     try {
       const stmt = this.db.prepare(`
         SELECT f.id, f.path, fa.access_count, fa.last_accessed, fa.relevance_score
@@ -23602,6 +23638,7 @@ var LearningEngine = class {
           importance
         );
       }
+      this.lastImportanceUpdate = Date.now();
     } catch (error2) {
       console.error("Error updating importance scores:", error2);
     }
@@ -23819,6 +23856,27 @@ var FileSummarizer = class {
     if (!summary) return true;
     return fileLastModified > summary.generatedAt;
   }
+  // Invalidate summary when file changes (event-driven)
+  invalidateSummary(fileId) {
+    try {
+      const result = this.db.prepare("DELETE FROM file_summaries WHERE file_id = ?").run(fileId);
+      return result.changes > 0;
+    } catch {
+      return false;
+    }
+  }
+  // Invalidate summary by file path
+  invalidateSummaryByPath(filePath) {
+    try {
+      const file2 = this.db.prepare("SELECT id FROM files WHERE path = ?").get(filePath);
+      if (file2) {
+        return this.invalidateSummary(file2.id);
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
   // Get compression ratio stats
   getCompressionStats() {
     const stmt = this.db.prepare(`
@@ -25989,6 +26047,7 @@ var LivingDocumentationEngine = class {
   }
   async generateArchitectureDocs() {
     const doc = await this.archGen.generate();
+    this.storeDocumentation("_architecture", "architecture", JSON.stringify(doc));
     this.activityTracker.logActivity(
       "doc_generation",
       "Generated architecture documentation",
@@ -25997,6 +26056,12 @@ var LivingDocumentationEngine = class {
     );
     return doc;
   }
+  /**
+   * Get the activity tracker for external use
+   */
+  getActivityTracker() {
+    return this.activityTracker;
+  }
   async generateComponentDoc(filePath) {
     const doc = await this.compGen.generate(filePath);
     this.storeDocumentation(filePath, "component", JSON.stringify(doc));
@@ -26022,6 +26087,17 @@ var LivingDocumentationEngine = class {
   }
   storeDocumentation(filePath, docType, content) {
     try {
+      if (filePath === "_architecture") {
+        const stmt = this.db.prepare(`
+          INSERT INTO documentation (file_id, doc_type, content, generated_at)
+          VALUES (0, ?, ?, unixepoch())
+          ON CONFLICT(file_id, doc_type) DO UPDATE SET
+            content = excluded.content,
+            generated_at = unixepoch()
+        `);
+        stmt.run(docType, content);
+        return;
+      }
       const fileStmt = this.db.prepare("SELECT id FROM files WHERE path = ?");
       const fileRow = fileStmt.get(filePath);
       if (fileRow) {
@@ -28227,6 +28303,75 @@ ${bestMatch.fixDiff.slice(0, 200)}`;
     }
     return null;
   }
+  /**
+   * Scan git history for fix commits and auto-record as bugs
+   * Looks for commits with "fix:", "bugfix:", "hotfix:" prefixes or "fixes #" references
+   */
+  scanForBugFixes() {
+    try {
+      const fixCommits = this.db.prepare(`
+        SELECT DISTINCT commit_hash, commit_message, file, diff, timestamp
+        FROM change_history
+        WHERE (
+          LOWER(commit_message) LIKE 'fix:%' OR
+          LOWER(commit_message) LIKE 'fix(%' OR
+          LOWER(commit_message) LIKE 'bugfix:%' OR
+          LOWER(commit_message) LIKE 'hotfix:%' OR
+          LOWER(commit_message) LIKE '%fixes #%' OR
+          LOWER(commit_message) LIKE '%fixed #%' OR
+          LOWER(commit_message) LIKE '%closes #%'
+        )
+        ORDER BY timestamp DESC
+        LIMIT 50
+      `).all();
+      let recorded = 0;
+      for (const commit of fixCommits) {
+        const existing = this.db.prepare(`
+          SELECT id FROM bug_history
+          WHERE fixed_by = ? OR related_changes LIKE ?
+        `).get(commit.commit_hash, `%${commit.commit_hash}%`);
+        if (existing) continue;
+        const errorDescription = this.extractErrorFromCommitMessage(commit.commit_message);
+        const id = randomUUID6();
+        this.db.prepare(`
+          INSERT INTO bug_history (id, error, file, timestamp, status, fixed_by, fixed_at, fix_diff, cause)
+          VALUES (?, ?, ?, ?, 'fixed', ?, ?, ?, ?)
+        `).run(
+          id,
+          errorDescription,
+          commit.file,
+          commit.timestamp,
+          commit.commit_hash,
+          commit.timestamp,
+          commit.diff?.slice(0, 2e3) || null,
+          commit.commit_message
+        );
+        recorded++;
+      }
+      return recorded;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Extract a bug/error description from a fix commit message
+   */
+  extractErrorFromCommitMessage(message) {
+    let cleaned = message.replace(/^fix\s*[:\(]/i, "").replace(/^bugfix\s*[:\(]/i, "").replace(/^hotfix\s*[:\(]/i, "").replace(/\):\s*/, ": ").trim();
+    const issueMatch = cleaned.match(/(?:fixes|fixed|closes)\s*#(\d+)/i);
+    if (issueMatch) {
+      cleaned = cleaned.replace(/(?:fixes|fixed|closes)\s*#\d+/gi, "").trim();
+      if (cleaned) {
+        cleaned = `Issue #${issueMatch[1]}: ${cleaned}`;
+      } else {
+        cleaned = `Issue #${issueMatch[1]}`;
+      }
+    }
+    if (cleaned.length > 0) {
+      cleaned = cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+    }
+    return cleaned || message;
+  }
   // Get bug statistics
   getBugStats() {
     const stats = this.db.prepare(`
@@ -28547,6 +28692,8 @@ var ChangeIntelligence = class {
   bugCorrelator;
   fixSuggester;
   initialized = false;
+  lastKnownHead = null;
+  lastBugScanHead = null;
   constructor(projectPath, db, tier2, embeddingGenerator) {
     this.changeTracker = new ChangeTracker(projectPath, db);
     this.bugCorrelator = new BugCorrelator(db, this.changeTracker, tier2, embeddingGenerator);
@@ -28559,6 +28706,34 @@ var ChangeIntelligence = class {
     this.initialized = true;
     return synced;
   }
+  // Sync recent git changes on-demand (event-driven alternative to polling)
+  syncFromGit(limit = 20) {
+    return this.changeTracker.syncFromGit(limit);
+  }
+  /**
+   * Get the last known HEAD commit
+   */
+  getLastKnownHead() {
+    return this.lastKnownHead;
+  }
+  /**
+   * Update the last known HEAD (call this after syncing)
+   */
+  setLastKnownHead(head) {
+    this.lastKnownHead = head;
+  }
+  /**
+   * Get the last HEAD where we scanned for bug fixes
+   */
+  getLastBugScanHead() {
+    return this.lastBugScanHead;
+  }
+  /**
+   * Update the last bug scan HEAD (call this after scanning)
+   */
+  setLastBugScanHead(head) {
+    this.lastBugScanHead = head;
+  }
   // Query what changed
   whatChanged(options = {}) {
     return this.changeTracker.queryChanges(options);
@@ -28591,6 +28766,13 @@ var ChangeIntelligence = class {
   recordFix(bugId, fixDiff, cause) {
     return this.bugCorrelator.recordFix(bugId, fixDiff, cause);
   }
+  /**
+   * Scan git history for fix commits and auto-record as bugs
+   * Called by background intelligence loop
+   */
+  scanForBugFixes() {
+    return this.bugCorrelator.scanForBugFixes();
+  }
   // Search changes by keyword
   searchChanges(keyword, limit) {
     return this.changeTracker.searchChanges(keyword, limit);
@@ -32835,6 +33017,278 @@ var CodeVerifier = class {
   }
 };
 
+// src/core/refresh/git-staleness-checker.ts
+import { execSync as execSync6 } from "child_process";
+var GitStalenessChecker = class {
+  cachedHead = null;
+  lastCheckTime = 0;
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  /**
+   * Get the current HEAD commit hash
+   * This is a cheap operation (~5ms)
+   */
+  getCurrentHead() {
+    try {
+      const head = execSync6("git rev-parse HEAD", {
+        cwd: this.projectPath,
+        encoding: "utf-8",
+        timeout: 5e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      return head;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if there are new commits since the last check
+   * Returns true if HEAD has changed (meaning we need to sync)
+   */
+  hasNewCommits() {
+    const current = this.getCurrentHead();
+    this.lastCheckTime = Date.now();
+    if (current === null) {
+      return false;
+    }
+    if (this.cachedHead === null) {
+      this.cachedHead = current;
+      return false;
+    }
+    if (current !== this.cachedHead) {
+      this.cachedHead = current;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Force update the cached HEAD (call after successful sync)
+   */
+  updateCachedHead() {
+    this.cachedHead = this.getCurrentHead();
+    this.lastCheckTime = Date.now();
+  }
+  /**
+   * Get the cached HEAD without checking git
+   */
+  getCachedHead() {
+    return this.cachedHead;
+  }
+  /**
+   * Get the time of the last check
+   */
+  getLastCheckTime() {
+    return this.lastCheckTime;
+  }
+  /**
+   * Get time since last check in milliseconds
+   */
+  getTimeSinceLastCheck() {
+    return Date.now() - this.lastCheckTime;
+  }
+  /**
+   * Check if enough time has passed since last check
+   * Default threshold is 30 seconds
+   */
+  shouldCheck(thresholdMs = 3e4) {
+    return this.getTimeSinceLastCheck() > thresholdMs;
+  }
+  /**
+   * Reset the checker state (useful for testing)
+   */
+  reset() {
+    this.cachedHead = null;
+    this.lastCheckTime = 0;
+  }
+};
+
+// src/core/refresh/activity-gate.ts
+var ActivityGate = class {
+  lastActivity = Date.now();
+  idleTasks = [];
+  monitoringInterval = null;
+  isExecutingTask = false;
+  currentTaskIndex = 0;
+  constructor() {
+    this.recordActivity();
+  }
+  /**
+   * Record user activity (call this on API method invocations)
+   */
+  recordActivity() {
+    this.lastActivity = Date.now();
+  }
+  /**
+   * Get the timestamp of the last recorded activity
+   */
+  getLastActivity() {
+    return this.lastActivity;
+  }
+  /**
+   * Check if the user has been idle for at least the given threshold
+   */
+  isIdle(thresholdMs = 3e4) {
+    return Date.now() - this.lastActivity > thresholdMs;
+  }
+  /**
+   * Get the duration of the current idle period in milliseconds
+   */
+  getIdleDuration() {
+    return Date.now() - this.lastActivity;
+  }
+  /**
+   * Register an idle-time task
+   * Tasks are executed during idle periods, one at a time
+   */
+  registerIdleTask(name, callback, options = {}) {
+    const { minIdleMs = 3e4, intervalMs = 3e5 } = options;
+    this.idleTasks = this.idleTasks.filter((t) => t.name !== name);
+    this.idleTasks.push({
+      name,
+      callback,
+      minIdleMs,
+      lastRun: 0,
+      intervalMs
+    });
+  }
+  /**
+   * Unregister an idle-time task
+   */
+  unregisterIdleTask(name) {
+    const initialLength = this.idleTasks.length;
+    this.idleTasks = this.idleTasks.filter((t) => t.name !== name);
+    return this.idleTasks.length < initialLength;
+  }
+  /**
+   * Get all registered idle tasks
+   */
+  getIdleTasks() {
+    return this.idleTasks;
+  }
+  /**
+   * Start monitoring for idle periods
+   * Will check every checkIntervalMs and execute tasks when idle
+   */
+  startIdleMonitoring(checkIntervalMs = 1e4) {
+    if (this.monitoringInterval) {
+      return;
+    }
+    this.monitoringInterval = setInterval(() => {
+      this.executeNextIdleTaskIfReady();
+    }, checkIntervalMs);
+  }
+  /**
+   * Stop idle monitoring
+   */
+  stopIdleMonitoring() {
+    if (this.monitoringInterval) {
+      clearInterval(this.monitoringInterval);
+      this.monitoringInterval = null;
+    }
+  }
+  /**
+   * Execute the next idle task if conditions are met
+   * - User must be idle
+   * - No other task is currently executing
+   * - Task's minimum idle time must be met
+   * - Task's minimum interval since last run must be met
+   */
+  async executeNextIdleTaskIfReady() {
+    if (this.isExecutingTask) {
+      return;
+    }
+    if (this.idleTasks.length === 0) {
+      return;
+    }
+    const now = Date.now();
+    const idleDuration = this.getIdleDuration();
+    for (let i = 0; i < this.idleTasks.length; i++) {
+      const taskIndex = (this.currentTaskIndex + i) % this.idleTasks.length;
+      const task = this.idleTasks[taskIndex];
+      if (!task) continue;
+      if (idleDuration < task.minIdleMs) {
+        continue;
+      }
+      if (now - task.lastRun < task.intervalMs) {
+        continue;
+      }
+      this.currentTaskIndex = (taskIndex + 1) % this.idleTasks.length;
+      await this.executeTask(task);
+      return;
+    }
+  }
+  /**
+   * Execute a specific task
+   */
+  async executeTask(task) {
+    this.isExecutingTask = true;
+    try {
+      await Promise.resolve(task.callback());
+      task.lastRun = Date.now();
+    } catch (error2) {
+      console.error(`Idle task '${task.name}' failed:`, error2);
+      task.lastRun = Date.now();
+    } finally {
+      this.isExecutingTask = false;
+    }
+  }
+  /**
+   * Manually trigger execution of all ready idle tasks
+   * Useful for testing or manual refresh
+   */
+  async executeReadyTasks() {
+    const executed = [];
+    const now = Date.now();
+    const idleDuration = this.getIdleDuration();
+    for (const task of this.idleTasks) {
+      if (idleDuration >= task.minIdleMs && now - task.lastRun >= task.intervalMs) {
+        await this.executeTask(task);
+        executed.push(task.name);
+      }
+    }
+    return executed;
+  }
+  /**
+   * Force immediate execution of a specific task by name
+   * Ignores idle and interval requirements
+   */
+  async forceExecuteTask(name) {
+    const task = this.idleTasks.find((t) => t.name === name);
+    if (!task) {
+      return false;
+    }
+    await this.executeTask(task);
+    return true;
+  }
+  /**
+   * Get status of all idle tasks
+   */
+  getStatus() {
+    const now = Date.now();
+    const idleDuration = this.getIdleDuration();
+    return {
+      isIdle: this.isIdle(),
+      idleDuration,
+      isExecutingTask: this.isExecutingTask,
+      tasks: this.idleTasks.map((task) => ({
+        name: task.name,
+        lastRun: task.lastRun,
+        timeSinceRun: now - task.lastRun,
+        readyToRun: idleDuration >= task.minIdleMs && now - task.lastRun >= task.intervalMs
+      }))
+    };
+  }
+  /**
+   * Shutdown the activity gate
+   */
+  shutdown() {
+    this.stopIdleMonitoring();
+    this.idleTasks = [];
+  }
+};
+
 // src/core/engine.ts
 var MemoryLayerEngine = class {
   config;
@@ -32859,13 +33313,11 @@ var MemoryLayerEngine = class {
   ghostMode;
   dejaVu;
   codeVerifier;
-  backgroundInterval = null;
+  gitStalenessChecker;
+  activityGate;
   initialized = false;
   initializationStatus = "pending";
   indexingProgress = { indexed: 0, total: 0 };
-  // Background intelligence settings
-  BACKGROUND_REFRESH_INTERVAL_MS = 5 * 60 * 1e3;
-  // 5 minutes
   constructor(config2) {
     this.config = config2;
     if (!existsSync13(config2.dataDir)) {
@@ -32931,6 +33383,8 @@ var MemoryLayerEngine = class {
       this.indexer.getEmbeddingGenerator()
     );
     this.codeVerifier = new CodeVerifier(config2.projectPath);
+    this.gitStalenessChecker = new GitStalenessChecker(config2.projectPath);
+    this.activityGate = new ActivityGate();
     const projectInfo = this.projectManager.registerProject(config2.projectPath);
     this.projectManager.setActiveProject(projectInfo.id);
     this.setupIndexerEvents();
@@ -32952,6 +33406,12 @@ var MemoryLayerEngine = class {
       this.indexingProgress = { indexed: stats.indexed, total: stats.total };
       if (stats.indexed > 0) {
         console.error(`Indexing complete: ${stats.indexed} files indexed`);
+        this.livingDocs.getActivityTracker().logActivity(
+          "indexing_complete",
+          `Indexed ${stats.indexed} files`,
+          void 0,
+          { total: stats.total, indexed: stats.indexed }
+        );
       } else {
         console.error(`Index up to date (${stats.total} files)`);
       }
@@ -32961,6 +33421,7 @@ var MemoryLayerEngine = class {
     });
     this.indexer.on("fileIndexed", (path) => {
       this.featureContextManager.onFileOpened(path);
+      this.summarizer.invalidateSummaryByPath(path);
     });
     this.indexer.on("error", (error2) => {
       console.error("Indexer error:", error2);
@@ -32985,7 +33446,10 @@ var MemoryLayerEngine = class {
       if (testResult.testsIndexed > 0) {
         console.error(`Test awareness: ${testResult.testsIndexed} tests indexed (${testResult.framework})`);
       }
-      this.startBackgroundIntelligence();
+      this.changeIntelligence.scanForBugFixes();
+      this.gitStalenessChecker.updateCachedHead();
+      this.registerIdleTasks();
+      this.activityGate.startIdleMonitoring(1e4);
       this.initialized = true;
       this.initializationStatus = "ready";
       console.error("MemoryLayer initialized");
@@ -33005,23 +33469,99 @@ var MemoryLayerEngine = class {
     };
   }
   /**
-   * Background Intelligence Loop - continuously learn and update without user intervention
+   * Register idle-time maintenance tasks
    */
-  startBackgroundIntelligence() {
-    if (this.backgroundInterval) {
-      clearInterval(this.backgroundInterval);
-    }
-    this.backgroundInterval = setInterval(() => {
-      try {
+  registerIdleTasks() {
+    this.activityGate.registerIdleTask("git-sync", () => {
+      if (this.gitStalenessChecker.hasNewCommits()) {
         const synced = this.changeIntelligence.syncFromGit(20);
         if (synced > 0) {
-          console.error(`[Background] Synced ${synced} recent changes from git`);
+          this.changeIntelligence.scanForBugFixes();
+          console.error(`Idle sync: ${synced} git changes synced`);
         }
-        this.learningEngine.updateImportanceScores();
-      } catch (error2) {
-        console.error("[Background] Error in intelligence loop:", error2);
       }
-    }, this.BACKGROUND_REFRESH_INTERVAL_MS);
+    }, {
+      minIdleMs: 3e4,
+      // 30 seconds idle
+      intervalMs: 6e4
+      // Check at most every minute
+    });
+    this.activityGate.registerIdleTask("importance-update", () => {
+      this.learningEngine.updateImportanceScores();
+    }, {
+      minIdleMs: 6e4,
+      // 1 minute idle
+      intervalMs: 3e5
+      // Max once per 5 minutes
+    });
+  }
+  /**
+   * Sync git changes on-demand with cheap pre-check
+   * Only syncs if HEAD has changed, otherwise returns 0
+   */
+  syncGitChanges(limit = 20) {
+    this.activityGate.recordActivity();
+    try {
+      if (!this.gitStalenessChecker.hasNewCommits()) {
+        return 0;
+      }
+      const synced = this.changeIntelligence.syncFromGit(limit);
+      if (synced > 0) {
+        this.changeIntelligence.scanForBugFixes();
+      }
+      return synced;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Force sync git changes, bypassing the staleness check
+   */
+  forceSyncGitChanges(limit = 20) {
+    this.activityGate.recordActivity();
+    this.gitStalenessChecker.updateCachedHead();
+    try {
+      const synced = this.changeIntelligence.syncFromGit(limit);
+      if (synced > 0) {
+        this.changeIntelligence.scanForBugFixes();
+      }
+      return synced;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Trigger a full refresh of the memory layer
+   * Syncs git changes, updates importance scores, etc.
+   */
+  triggerRefresh() {
+    this.activityGate.recordActivity();
+    this.gitStalenessChecker.updateCachedHead();
+    const gitSynced = this.forceSyncGitChanges();
+    this.learningEngine.updateImportanceScores();
+    return {
+      gitSynced,
+      importanceUpdated: true,
+      tasksExecuted: ["git-sync", "importance-update"]
+    };
+  }
+  /**
+   * Get refresh system status
+   */
+  getRefreshStatus() {
+    const status = this.activityGate.getStatus();
+    return {
+      lastActivity: this.activityGate.getLastActivity(),
+      isIdle: status.isIdle,
+      idleDuration: status.idleDuration,
+      gitHead: this.gitStalenessChecker.getCachedHead(),
+      hasNewCommits: this.gitStalenessChecker.hasNewCommits(),
+      idleTasks: status.tasks.map((t) => ({
+        name: t.name,
+        lastRun: t.lastRun,
+        readyToRun: t.readyToRun
+      }))
+    };
   }
   /**
    * Record AI feedback - learn from what suggestions were actually used
@@ -33036,6 +33576,7 @@ var MemoryLayerEngine = class {
     }
   }
   async getContext(query, currentFile, maxTokens) {
+    this.activityGate.recordActivity();
     this.learningEngine.trackEvent({ eventType: "query", query });
     const expandedQueries = this.learningEngine.expandQuery(query);
     const result = await this.contextAssembler.assemble(query, {
@@ -33050,13 +33591,31 @@ var MemoryLayerEngine = class {
     return result;
   }
   async searchCodebase(query, limit = 10) {
+    this.activityGate.recordActivity();
     const embedding = await this.indexer.getEmbeddingGenerator().embed(query);
     let results = this.tier2.search(embedding, limit * 2);
     results = this.learningEngine.applyPersonalizedRanking(results);
     return results.slice(0, limit);
   }
   async recordDecision(title, description, files, tags) {
-    return this.decisionTracker.recordDecision(title, description, files || [], tags || []);
+    this.activityGate.recordActivity();
+    const decision = await this.decisionTracker.recordDecision(title, description, files || [], tags || []);
+    this.livingDocs.getActivityTracker().logActivity(
+      "decision_recorded",
+      `Decision: ${title}`,
+      void 0,
+      { decisionId: decision.id }
+    );
+    this.contextRotPrevention.markCritical(
+      `Decision: ${title}
+${description}`,
+      {
+        type: "decision",
+        reason: "Architectural decision",
+        source: "auto"
+      }
+    );
+    return decision;
   }
   getRecentDecisions(limit = 10) {
     return this.decisionTracker.getRecentDecisions(limit);
@@ -33069,6 +33628,7 @@ var MemoryLayerEngine = class {
     return this.tier2.searchDecisions(embedding, limit);
   }
   async getFileContext(filePath) {
+    this.activityGate.recordActivity();
     const absolutePath = join14(this.config.projectPath, filePath);
     if (!existsSync13(absolutePath)) {
       return null;
@@ -33837,11 +34397,8 @@ ${description}`;
   }
   shutdown() {
     console.error("Shutting down MemoryLayer...");
-    if (this.backgroundInterval) {
-      clearInterval(this.backgroundInterval);
-      this.backgroundInterval = null;
-    }
     this.indexer.stopWatching();
+    this.activityGate.shutdown();
     this.tier1.save();
     this.featureContextManager.shutdown();
     closeDatabase(this.db);
@@ -37241,6 +37798,45 @@ async function handleToolCall(engine, toolName, args) {
         message: coverage.coveragePercent === 100 ? `Full test coverage for ${file2}` : coverage.uncoveredFunctions.length > 0 ? `${coverage.coveragePercent}% coverage - ${coverage.uncoveredFunctions.length} function(s) need tests` : `${coverage.totalTests} test(s) cover ${file2}`
       };
     }
+    // Intelligent Refresh System tools
+    case "memory_refresh": {
+      const force = args.force;
+      if (force) {
+        const result = engine.triggerRefresh();
+        return {
+          success: true,
+          forced: true,
+          git_synced: result.gitSynced,
+          importance_updated: result.importanceUpdated,
+          tasks_executed: result.tasksExecuted,
+          message: `Force refresh complete: ${result.gitSynced} git changes synced`
+        };
+      } else {
+        const gitSynced = engine.syncGitChanges();
+        return {
+          success: true,
+          forced: false,
+          git_synced: gitSynced,
+          message: gitSynced > 0 ? `Refresh complete: ${gitSynced} git changes synced` : "No new changes to sync"
+        };
+      }
+    }
+    case "get_refresh_status": {
+      const status = engine.getRefreshStatus();
+      return {
+        last_activity: new Date(status.lastActivity).toISOString(),
+        is_idle: status.isIdle,
+        idle_duration_seconds: Math.round(status.idleDuration / 1e3),
+        git_head: status.gitHead?.slice(0, 7) || null,
+        has_pending_changes: status.hasNewCommits,
+        idle_tasks: status.idleTasks.map((t) => ({
+          name: t.name,
+          last_run: t.lastRun > 0 ? new Date(t.lastRun).toISOString() : "never",
+          ready_to_run: t.readyToRun
+        })),
+        message: status.isIdle ? `System idle for ${Math.round(status.idleDuration / 1e3)}s, ${status.idleTasks.filter((t) => t.readyToRun).length} task(s) ready` : "System active"
+      };
+    }
     default:
       throw new Error(`Unknown tool: ${toolName}`);
   }