auroq-os 1.0.0

package/.auroq-core/core/synapse/layers/l7-star-command.js

@@ -0,0 +1,169 @@
+/**
+ * L7 Star-Command Layer Processor
+ *
+ * Detects *command patterns in the user prompt and loads
+ * corresponding rules from the .synapse/commands domain file.
+ *
+ * Command blocks in the domain file are delimited by [*command]
+ * headers. Multiple star-commands in a single prompt are supported.
+ *
+ * @module core/synapse/layers/l7-star-command
+ * @version 1.0.0
+ * @created Story SYN-5 - Layer Processors L4-L7
+ */
+
+const path = require('path');
+const { loadDomainFile } = require('../domain/domain-loader');
+const LayerProcessor = require('./layer-processor');
+
+/** Regex to detect star-commands in prompt */
+const STAR_COMMAND_REGEX = /\*([a-z][\w-]*)/gi;
+
+/**
+ * L7 Star-Command Processor
+ *
+ * Detects *command patterns in the prompt, loads the commands
+ * domain file, and extracts rules for matching command blocks.
+ * Returns null if no star-commands detected.
+ *
+ * @extends LayerProcessor
+ */
+class L7StarCommandProcessor extends LayerProcessor {
+  constructor() {
+    super({ name: 'star-command', layer: 7, timeout: 5 });
+  }
+
+  /**
+   * Detect star-commands and load matching rules.
+   *
+   * Detection flow:
+   * 1. Scan prompt for *command patterns via regex
+   * 2. Deduplicate detected commands
+   * 3. Load .synapse/commands domain file
+   * 4. Parse command blocks delimited by [*command]
+   * 5. Collect rules for detected commands
+   *
+   * @param {object} context
+   * @param {string} context.prompt - Current prompt text
+   * @param {object} context.session - Session state (SYN-2 schema)
+   * @param {object} context.config - Config with synapsePath and manifest
+   * @param {object[]} context.previousLayers - Results from previous layers
+   * @returns {{ rules: string[], metadata: object } | null}
+   */
+  process(context) {
+    const { prompt, config } = context;
+    const { synapsePath } = config;
+
+    if (!prompt) {
+      return null;
+    }
+
+    // 1. Detect star-commands in prompt
+    const commands = this._detectCommands(prompt);
+    if (commands.length === 0) {
+      return null;
+    }
+
+    // 2. Load commands domain file
+    const commandsFilePath = path.join(synapsePath, 'commands');
+    const rawRules = loadDomainFile(commandsFilePath);
+
+    if (!rawRules || rawRules.length === 0) {
+      return null;
+    }
+
+    // 3. Parse command blocks from raw rules
+    const commandBlocks = this._parseCommandBlocks(rawRules);
+
+    // 4. Collect rules for detected commands
+    const allRules = [];
+    const matchedCommands = [];
+
+    for (const cmd of commands) {
+      const block = commandBlocks[cmd];
+      if (block && block.length > 0) {
+        allRules.push(...block);
+        matchedCommands.push(cmd);
+      }
+    }
+
+    if (allRules.length === 0) {
+      return null;
+    }
+
+    return {
+      rules: allRules,
+      metadata: {
+        layer: 7,
+        commands: matchedCommands,
+      },
+    };
+  }
+
+  /**
+   * Detect star-command patterns in prompt text.
+   *
+   * @param {string} prompt - User prompt text
+   * @returns {string[]} Deduplicated list of command names (lowercase)
+   * @private
+   */
+  _detectCommands(prompt) {
+    const matches = [];
+    let match;
+
+    // Reset regex state
+    STAR_COMMAND_REGEX.lastIndex = 0;
+
+    while ((match = STAR_COMMAND_REGEX.exec(prompt)) !== null) {
+      matches.push(match[1].toLowerCase());
+    }
+
+    return [...new Set(matches)];
+  }
+
+  /**
+   * Parse command blocks from domain file rules.
+   *
+   * Format:
+   * [*command] COMMAND:
+   *   0. Rule text here
+   *   1. Another rule
+   *
+   * Each [*command] header starts a new block.
+   * Rules within a block are the lines following the header.
+   *
+   * @param {string[]} rules - Raw rules from loadDomainFile
+   * @returns {object} Map of command name -> rule strings
+   * @private
+   */
+  _parseCommandBlocks(rules) {
+    const blocks = {};
+    let currentCommand = null;
+
+    for (const rule of rules) {
+      // Check if this line is a command header: [*command]
+      const headerMatch = rule.match(/^\[\*([a-z][\w-]*)\]/i);
+      if (headerMatch) {
+        currentCommand = headerMatch[1].toLowerCase();
+        if (!blocks[currentCommand]) {
+          blocks[currentCommand] = [];
+        }
+        // If there's content after the header on the same line, include it
+        const afterHeader = rule.substring(headerMatch[0].length).trim();
+        if (afterHeader && !afterHeader.endsWith(':')) {
+          blocks[currentCommand].push(afterHeader);
+        }
+        continue;
+      }
+
+      // Add rule to current command block
+      if (currentCommand && rule.trim()) {
+        blocks[currentCommand].push(rule.trim());
+      }
+    }
+
+    return blocks;
+  }
+}
+
+module.exports = L7StarCommandProcessor;

package/.auroq-core/core/synapse/layers/layer-processor.js

@@ -0,0 +1,82 @@
+/**
+ * LayerProcessor — Abstract Base Class
+ *
+ * Defines the contract for all 8 SYNAPSE layer processors.
+ * Each layer implements process() to inject contextual rules
+ * into the prompt pipeline. The _safeProcess() wrapper provides
+ * timeout monitoring and error recovery (graceful degradation).
+ *
+ * @module core/synapse/layers/layer-processor
+ * @version 1.0.0
+ * @created Story SYN-4 - Layer Processors L0-L3
+ */
+
+/**
+ * Abstract base class for SYNAPSE layer processors.
+ *
+ * Subclasses MUST override process() with their layer-specific logic.
+ * Use _safeProcess() as the public entry point — it wraps process()
+ * with timeout monitoring and error handling.
+ *
+ * @abstract
+ */
+class LayerProcessor {
+  /**
+   * @param {object} options
+   * @param {string} options.name - Layer name (e.g., 'constitution', 'global')
+   * @param {number} options.layer - Layer number (0-7)
+   * @param {number} [options.timeout=15] - Timeout budget in milliseconds
+   */
+  constructor({ name, layer, timeout = 15 }) {
+    if (new.target === LayerProcessor) {
+      throw new Error('LayerProcessor is abstract and cannot be instantiated directly');
+    }
+    this.name = name;
+    this.layer = layer;
+    this.timeout = timeout;
+  }
+
+  /**
+   * Process the layer and return contextual rules.
+   *
+   * Subclasses MUST override this method.
+   *
+   * @param {object} context
+   * @param {string} context.prompt - Current prompt text
+   * @param {object} context.session - Session state (SYN-2 schema)
+   * @param {object} context.config - Config with synapsePath and manifest
+   * @param {string} context.config.synapsePath - Base path to .synapse/ directory
+   * @param {object} context.config.manifest - Parsed manifest from parseManifest()
+   * @param {object[]} context.previousLayers - Results from previous layers
+   * @returns {{ rules: string[], metadata: object } | null} Rules and metadata, or null to skip
+   */
+  process(context) {
+    throw new Error(`${this.name}: process() must be implemented by subclass`);
+  }
+
+  /**
+   * Safe wrapper with timeout guard and error recovery.
+   *
+   * Calls process() and monitors execution time against the timeout budget.
+   * On error, logs a warning and returns null (graceful degradation).
+   *
+   * @param {object} context - Same as process()
+   * @returns {{ rules: string[], metadata: object } | null} Result or null on error/timeout
+   */
+  _safeProcess(context) {
+    const start = Date.now();
+    try {
+      const result = this.process(context);
+      const elapsed = Date.now() - start;
+      if (elapsed > this.timeout) {
+        console.warn(`[synapse:${this.name}] Warning: Layer exceeded timeout (${elapsed}ms > ${this.timeout}ms)`);
+      }
+      return result;
+    } catch (error) {
+      console.warn(`[synapse:${this.name}] Error: ${error.message}`);
+      return null;
+    }
+  }
+}
+
+module.exports = LayerProcessor;

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

@@ -0,0 +1,220 @@
+/**
+ * Memory Bridge — MIS consumer for SYNAPSE engine.
+ *
+ * Connects SynapseEngine to the Memory Intelligence System (MIS)
+ * 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 MIS module is not installed.
+ *
+ * @module core/synapse/memory/memory-bridge
+ * @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';
+
+const { estimateTokens } = require('../utils/tokens');
+
+/** Memory bridge timeout in milliseconds. */
+const BRIDGE_TIMEOUT_MS = 15;
+
+/**
+ * Bracket-to-memory-layer mapping.
+ *
+ * FRESH   → skip (no memory needed)
+ * MODERATE → Layer 1 metadata (~50 tokens)
+ * DEPLETED → Layer 2 chunks (~200 tokens)
+ * CRITICAL → Layer 3 full content (~1000 tokens)
+ */
+const BRACKET_LAYER_MAP = {
+  FRESH: { layer: 0, maxTokens: 0 },
+  MODERATE: { layer: 1, maxTokens: 50 },
+  DEPLETED: { layer: 2, maxTokens: 200 },
+  CRITICAL: { layer: 3, maxTokens: 1000 },
+};
+
+/** Default sector for unknown agents. */
+const DEFAULT_SECTORS = ['semantic'];
+
+/**
+ * MemoryBridge — MIS consumer for SYNAPSE engine.
+ *
+ * Provides bracket-aware memory retrieval with:
+ * - 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 {
+  /**
+   * @param {object} [options={}]
+   * @param {number} [options.timeout=15] - Max execution time in ms
+   */
+  constructor(options = {}) {
+    this._timeout = options.timeout || BRIDGE_TIMEOUT_MS;
+    this._provider = null;
+    this._initialized = false;
+  }
+
+  /**
+   * Lazy-load the SynapseMemoryProvider (open-source).
+   * Gracefully returns null if MIS dependencies are not available.
+   *
+   * @private
+   * @returns {object|null} Provider instance or null
+   */
+  _getProvider() {
+    if (this._provider) return this._provider;
+
+    try {
+      const { SynapseMemoryProvider } = require('./synapse-memory-provider');
+      this._provider = new SynapseMemoryProvider();
+      return this._provider;
+    } catch {
+      // Provider or MIS not available — graceful degradation
+      return null;
+    }
+  }
+
+  /**
+   * Get memory hints for the current prompt context.
+   *
+   * Returns an array of memory hint objects suitable for injection
+   * into the SYNAPSE pipeline. Gracefully returns [] when:
+   * - MIS module is not installed
+   * - Bracket is FRESH (no memory needed)
+   * - Provider fails or times out
+   * - Any error occurs
+   *
+   * @param {string} agentId - Active agent ID (e.g., 'dev', 'qa')
+   * @param {string} bracket - Context bracket (FRESH, MODERATE, DEPLETED, CRITICAL)
+   * @param {number} tokenBudget - Max tokens available for memory hints
+   * @returns {Promise<Array<{content: string, source: string, relevance: number, tokens: number}>>}
+   */
+  async getMemoryHints(agentId, bracket, tokenBudget) {
+    try {
+      // 1. Bracket check — FRESH needs no memory
+      const bracketConfig = BRACKET_LAYER_MAP[bracket];
+      if (!bracketConfig || bracketConfig.layer === 0) {
+        return [];
+      }
+
+      // 2. Calculate effective token budget
+      const effectiveBudget = Math.min(
+        bracketConfig.maxTokens,
+        tokenBudget > 0 ? tokenBudget : bracketConfig.maxTokens,
+      );
+
+      if (effectiveBudget <= 0) {
+        return [];
+      }
+
+      // 3. Load provider
+      const provider = this._getProvider();
+      if (!provider) {
+        return [];
+      }
+
+      // 4. Execute with timeout protection
+      const hints = await this._executeWithTimeout(
+        () => provider.getMemories(agentId, bracket, effectiveBudget),
+        this._timeout,
+      );
+
+      // 5. Enforce token budget on results
+      return this._enforceTokenBudget(hints || [], effectiveBudget);
+    } catch (error) {
+      // Catch-all: warn and proceed with empty results
+      console.warn(`[synapse:memory-bridge] Error getting memory hints: ${error.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * Execute a function with timeout protection.
+   *
+   * @private
+   * @param {Function} fn - Async function to execute
+   * @param {number} timeoutMs - Timeout in milliseconds
+   * @returns {Promise<*>} Result or empty array on timeout
+   */
+  async _executeWithTimeout(fn, timeoutMs) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        console.warn(`[synapse:memory-bridge] Timeout after ${timeoutMs}ms`);
+        resolve([]);
+      }, timeoutMs);
+
+      Promise.resolve(fn())
+        .then((result) => {
+          clearTimeout(timer);
+          resolve(result);
+        })
+        .catch((error) => {
+          clearTimeout(timer);
+          console.warn(`[synapse:memory-bridge] Provider error: ${error.message}`);
+          resolve([]);
+        });
+    });
+  }
+
+  /**
+   * Enforce token budget on hint array.
+   * Removes hints from end until within budget.
+   *
+   * @private
+   * @param {Array<{content: string, tokens: number}>} hints
+   * @param {number} budget
+   * @returns {Array}
+   */
+  _enforceTokenBudget(hints, budget) {
+    if (!Array.isArray(hints) || hints.length === 0) {
+      return [];
+    }
+
+    const result = [];
+    let tokensUsed = 0;
+
+    for (const hint of hints) {
+      const hintTokens = hint.tokens || estimateTokens(hint.content || '');
+      if (tokensUsed + hintTokens > budget) {
+        break;
+      }
+      result.push({ ...hint, tokens: hintTokens });
+      tokensUsed += hintTokens;
+    }
+
+    return result;
+  }
+
+  /**
+   * Clear provider cache. Used for testing and session reset.
+   */
+  clearCache() {
+    if (this._provider && typeof this._provider.clearCache === 'function') {
+      this._provider.clearCache();
+    }
+  }
+
+  /**
+   * Reset internal state. Used for testing.
+   *
+   * @private
+   */
+  _reset() {
+    this._provider = null;
+    this._initialized = false;
+  }
+}
+
+module.exports = {
+  MemoryBridge,
+  BRACKET_LAYER_MAP,
+  BRIDGE_TIMEOUT_MS,
+  DEFAULT_SECTORS,
+};

package/.auroq-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,
+};