aios-core 4.3.0 → 4.4.0

package/.aios-core/core/doctor/checks/ide-sync.js

@@ -35,14 +35,31 @@ async function run(context) {
     };
   }
 
-  const sourceAgents = fs.readdirSync(agentsSourceDir)
-    .filter((entry) => {
-      const entryPath = path.join(agentsSourceDir, entry);
-      return fs.statSync(entryPath).isDirectory();
-    });
+  let sourceAgents, ideFiles;
+  try {
+    sourceAgents = fs.readdirSync(agentsSourceDir)
+      .filter((f) => f.endsWith('.md'))
+      .map((f) => f.replace('.md', ''));
+  } catch (_err) {
+    return {
+      check: name,
+      status: 'FAIL',
+      message: 'Cannot read source agents directory',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
 
-  const ideFiles = fs.readdirSync(agentsIdeDir)
-    .filter((f) => f.endsWith('.md'));
+  try {
+    ideFiles = fs.readdirSync(agentsIdeDir)
+      .filter((f) => f.endsWith('.md'));
+  } catch (_err) {
+    return {
+      check: name,
+      status: 'WARN',
+      message: 'Cannot read IDE agents directory',
+      fixCommand: 'npx aios-core install --force',
+    };
+  }
 
   const ideAgents = ideFiles.map((f) => f.replace('.md', ''));
   const sourceCount = sourceAgents.length;

package/.aios-core/core/synapse/memory/memory-bridge.js

@@ -1,16 +1,17 @@
 /**
- * Memory Bridge — Feature-gated MIS consumer for SYNAPSE engine.
+ * Memory Bridge — MIS consumer for SYNAPSE engine.
  *
  * Connects SynapseEngine to the Memory Intelligence System (MIS)
- * via MemoryLoader API. Implements bracket-aware retrieval with
+ * via SynapseMemoryProvider. Implements bracket-aware retrieval with
  * agent-scoped sector filtering and token budget enforcement.
  *
  * Consumer-only: reads from MIS APIs, never modifies memory stores.
- * Graceful no-op when pro feature is unavailable.
+ * Graceful no-op when MIS module is not installed.
  *
  * @module core/synapse/memory/memory-bridge
- * @version 1.0.0
+ * @version 2.0.0
  * @created Story SYN-10 - Pro Memory Bridge (Feature-Gated MIS Consumer)
+ * @migrated Story INS-4.11 - Removed pro feature gate (AC9)
  */
 
 'use strict';
@@ -39,15 +40,15 @@ const BRACKET_LAYER_MAP = {
 const DEFAULT_SECTORS = ['semantic'];
 
 /**
- * MemoryBridge — Feature-gated MIS consumer.
+ * MemoryBridge — MIS consumer for SYNAPSE engine.
  *
  * Provides bracket-aware memory retrieval with:
- * - Feature gate check (sync, <1ms)
  * - Agent-scoped sector filtering
  * - Token budget enforcement
  * - Session-level caching
  * - Timeout protection (<15ms)
  * - Error catch-all with warn-and-proceed
+ * - Graceful no-op when MIS module is not installed
  */
 class MemoryBridge {
   /**
@@ -57,32 +58,12 @@ class MemoryBridge {
   constructor(options = {}) {
     this._timeout = options.timeout || BRIDGE_TIMEOUT_MS;
     this._provider = null;
-    this._featureGate = null;
     this._initialized = false;
   }
 
   /**
-   * Lazy-load feature gate and provider.
-   * Isolates pro dependency to runtime only.
-   *
-   * @private
-   */
-  _init() {
-    if (this._initialized) return;
-    this._initialized = true;
-
-    try {
-      const { featureGate } = require('../../../../pro/license/feature-gate');
-      this._featureGate = featureGate;
-    } catch {
-      // Pro not installed — feature gate unavailable
-      this._featureGate = null;
-    }
-  }
-
-  /**
-   * Lazy-load the SynapseMemoryProvider (pro).
-   * Only loaded when feature gate confirms availability.
+   * Lazy-load the SynapseMemoryProvider (open-source).
+   * Gracefully returns null if MIS dependencies are not available.
    *
    * @private
    * @returns {object|null} Provider instance or null
@@ -91,11 +72,11 @@ class MemoryBridge {
     if (this._provider) return this._provider;
 
     try {
-      const { SynapseMemoryProvider } = require('../../../../pro/memory/synapse-memory-provider');
+      const { SynapseMemoryProvider } = require('./synapse-memory-provider');
       this._provider = new SynapseMemoryProvider();
       return this._provider;
     } catch {
-      // Provider not available
+      // Provider or MIS not available — graceful degradation
       return null;
     }
   }
@@ -105,7 +86,7 @@ class MemoryBridge {
    *
    * Returns an array of memory hint objects suitable for injection
    * into the SYNAPSE pipeline. Gracefully returns [] when:
-   * - Pro feature is unavailable
+   * - MIS module is not installed
    * - Bracket is FRESH (no memory needed)
    * - Provider fails or times out
    * - Any error occurs
@@ -117,19 +98,13 @@ class MemoryBridge {
    */
   async getMemoryHints(agentId, bracket, tokenBudget) {
     try {
-      // 1. Feature gate check (sync, <1ms)
-      this._init();
-      if (!this._featureGate || !this._featureGate.isAvailable('pro.memory.synapse')) {
-        return [];
-      }
-
-      // 2. Bracket check — FRESH needs no memory
+      // 1. Bracket check — FRESH needs no memory
       const bracketConfig = BRACKET_LAYER_MAP[bracket];
       if (!bracketConfig || bracketConfig.layer === 0) {
         return [];
       }
 
-      // 3. Calculate effective token budget
+      // 2. Calculate effective token budget
       const effectiveBudget = Math.min(
         bracketConfig.maxTokens,
         tokenBudget > 0 ? tokenBudget : bracketConfig.maxTokens,
@@ -139,19 +114,19 @@ class MemoryBridge {
         return [];
       }
 
-      // 4. Load provider
+      // 3. Load provider
       const provider = this._getProvider();
       if (!provider) {
         return [];
       }
 
-      // 5. Execute with timeout protection
+      // 4. Execute with timeout protection
       const hints = await this._executeWithTimeout(
         () => provider.getMemories(agentId, bracket, effectiveBudget),
         this._timeout,
       );
 
-      // 6. Enforce token budget on results
+      // 5. Enforce token budget on results
       return this._enforceTokenBudget(hints || [], effectiveBudget);
     } catch (error) {
       // Catch-all: warn and proceed with empty results
@@ -233,7 +208,6 @@ class MemoryBridge {
    */
   _reset() {
     this._provider = null;
-    this._featureGate = null;
     this._initialized = false;
   }
 }

package/.aios-core/core/synapse/memory/synapse-memory-provider.js

@@ -0,0 +1,201 @@
+/**
+ * Synapse Memory Provider — MIS retrieval for SYNAPSE engine.
+ *
+ * Implements the provider interface consumed by MemoryBridge.
+ * Open-source: no feature gate required.
+ *
+ * Responsibilities:
+ * - Agent-scoped memory retrieval using AGENT_SECTOR_PREFERENCES
+ * - Progressive disclosure layer selection based on bracket
+ * - Session-level caching (keyed by agentId-bracket)
+ * - Token budget respect
+ *
+ * @module core/synapse/memory/synapse-memory-provider
+ * @version 2.0.0
+ * @created Story SYN-10 - Pro Memory Bridge (Feature-Gated MIS Consumer)
+ * @migrated Story INS-4.11 - Moved from pro/ to open-source (AC9)
+ */
+
+'use strict';
+
+const { estimateTokens } = require('../utils/tokens');
+
+/** Default sectors for unknown agents. */
+const DEFAULT_SECTORS = ['semantic'];
+
+/**
+ * Agent sector preferences for memory retrieval.
+ * Defines which cognitive sectors each agent prefers.
+ *
+ * Moved from pro/memory/memory-loader.js to open-source.
+ */
+const AGENT_SECTOR_PREFERENCES = {
+  dev: ['procedural', 'semantic'],
+  qa: ['reflective', 'episodic'],
+  architect: ['semantic', 'reflective'],
+  pm: ['episodic', 'semantic'],
+  po: ['episodic', 'semantic'],
+  sm: ['procedural', 'episodic'],
+  devops: ['procedural', 'episodic'],
+  analyst: ['semantic', 'reflective'],
+  'data-engineer': ['procedural', 'semantic'],
+  'ux-design-expert': ['reflective', 'procedural'],
+};
+
+/**
+ * Bracket → retrieval configuration.
+ */
+const BRACKET_CONFIG = {
+  MODERATE: { layer: 1, limit: 3, minRelevance: 0.7 },
+  DEPLETED: { layer: 2, limit: 5, minRelevance: 0.5 },
+  CRITICAL: { layer: 3, limit: 10, minRelevance: 0.3 },
+};
+
+/**
+ * SynapseMemoryProvider — Open-source memory retrieval.
+ *
+ * Provides memories from MIS for SYNAPSE engine injection.
+ * Session-level caching avoids repeated MIS queries for
+ * the same agent + bracket combination.
+ *
+ * Uses lazy-loading for MemoryLoader to gracefully degrade
+ * when the MIS module is not installed.
+ */
+class SynapseMemoryProvider {
+  /**
+   * @param {object} [options={}]
+   * @param {string} [options.projectDir] - Project directory for MemoryLoader
+   */
+  constructor(options = {}) {
+    this._projectDir = options.projectDir || process.cwd();
+    this._loader = null;
+    /** @type {Map<string, Array>} Session-level cache keyed by `${agentId}-${bracket}` */
+    this._cache = new Map();
+  }
+
+  /**
+   * Lazy-load MemoryLoader.
+   * Gracefully returns null if pro/memory module is not available.
+   *
+   * @private
+   * @returns {object|null}
+   */
+  _getLoader() {
+    if (this._loader) return this._loader;
+
+    try {
+      const { MemoryLoader } = require('../../../../pro/memory/memory-loader');
+      this._loader = new MemoryLoader(this._projectDir);
+      return this._loader;
+    } catch {
+      // MIS module not available — graceful degradation
+      return null;
+    }
+  }
+
+  /**
+   * Get memories for SYNAPSE engine injection.
+   *
+   * Uses bracket to determine:
+   * - Which MIS layer to query (1=metadata, 2=chunks, 3=full)
+   * - How many results to return
+   * - Minimum relevance threshold
+   *
+   * Results are cached per session (agentId + bracket).
+   *
+   * @param {string} agentId - Active agent ID
+   * @param {string} bracket - Context bracket (MODERATE, DEPLETED, CRITICAL)
+   * @param {number} tokenBudget - Max tokens for memory hints
+   * @returns {Promise<Array<{content: string, source: string, relevance: number, tokens: number}>>}
+   */
+  async getMemories(agentId, bracket, tokenBudget) {
+    // Cache lookup
+    const cacheKey = `${agentId}-${bracket}`;
+    if (this._cache.has(cacheKey)) {
+      return this._cache.get(cacheKey);
+    }
+
+    // Get bracket config
+    const config = BRACKET_CONFIG[bracket];
+    if (!config) {
+      return [];
+    }
+
+    // Get loader (lazy-load, graceful if unavailable)
+    const loader = this._getLoader();
+    if (!loader) {
+      return [];
+    }
+
+    // Get agent sectors
+    const sectors = AGENT_SECTOR_PREFERENCES[agentId] || DEFAULT_SECTORS;
+
+    // Query MIS via MemoryLoader
+    const memories = await loader.queryMemories(agentId, {
+      sectors,
+      layer: config.layer,
+      limit: config.limit,
+      minRelevance: config.minRelevance,
+      tokenBudget,
+    });
+
+    // Transform to hint format
+    const hints = this._transformToHints(memories, tokenBudget);
+
+    // Cache results
+    this._cache.set(cacheKey, hints);
+
+    return hints;
+  }
+
+  /**
+   * Transform MIS memory results into hint format.
+   *
+   * @private
+   * @param {Array} memories - Raw memories from MemoryLoader
+   * @param {number} tokenBudget - Max tokens
+   * @returns {Array<{content: string, source: string, relevance: number, tokens: number}>}
+   */
+  _transformToHints(memories, tokenBudget) {
+    if (!Array.isArray(memories) || memories.length === 0) {
+      return [];
+    }
+
+    const hints = [];
+    let tokensUsed = 0;
+
+    for (const memory of memories) {
+      const content = memory.content || memory.summary || memory.title || '';
+      const tokens = estimateTokens(content);
+
+      if (tokensUsed + tokens > tokenBudget) {
+        break;
+      }
+
+      hints.push({
+        content,
+        source: memory.source || memory.sector || 'memory',
+        relevance: memory.relevance || memory.attention || 0,
+        tokens,
+      });
+
+      tokensUsed += tokens;
+    }
+
+    return hints;
+  }
+
+  /**
+   * Clear the session cache.
+   */
+  clearCache() {
+    this._cache.clear();
+  }
+}
+
+module.exports = {
+  SynapseMemoryProvider,
+  AGENT_SECTOR_PREFERENCES,
+  BRACKET_CONFIG,
+  DEFAULT_SECTORS,
+};