auroq-os 1.0.0

package/.auroq-core/core/synapse/layers/l3-workflow.js

@@ -0,0 +1,94 @@
+/**
+ * L3 Workflow Layer Processor
+ *
+ * Injects workflow-specific rules based on the currently active workflow.
+ * Detects the active workflow from session.active_workflow.id and finds
+ * the matching domain via workflowTrigger in the manifest.
+ *
+ * Includes current phase metadata from session.active_workflow.current_phase.
+ *
+ * @module core/synapse/layers/l3-workflow
+ * @version 1.0.0
+ * @created Story SYN-4 - Layer Processors L0-L3
+ */
+
+const path = require('path');
+const { loadDomainFile } = require('../domain/domain-loader');
+const LayerProcessor = require('./layer-processor');
+
+/**
+ * L3 Workflow Processor
+ *
+ * Loads workflow-specific domain file when a workflow is active.
+ * Returns null if no workflow is active or no matching domain found.
+ *
+ * @extends LayerProcessor
+ */
+class L3WorkflowProcessor extends LayerProcessor {
+  constructor() {
+    super({ name: 'workflow', layer: 3, timeout: 15 });
+  }
+
+  /**
+   * Load workflow-specific rules based on active workflow.
+   *
+   * Detection flow:
+   * 1. Get active workflow ID from session.active_workflow.id
+   * 2. Find domain with matching workflowTrigger in manifest
+   * 3. Load domain file via domain-loader
+   * 4. Include phase metadata from session
+   *
+   * @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 { session, config } = context;
+    const { manifest, synapsePath } = config;
+
+    // 1. Get active workflow ID
+    const workflowId = session.active_workflow?.id;
+    if (!workflowId) {
+      return null;
+    }
+
+    // 2. Find domain with matching workflowTrigger
+    const domainKey = Object.keys(manifest.domains || {})
+      .find(k => manifest.domains[k].workflowTrigger === workflowId);
+
+    if (!domainKey) {
+      return null;
+    }
+
+    // 3. Load domain file
+    const domain = manifest.domains[domainKey];
+    const domainFile = domain.file
+      ? path.join(synapsePath, domain.file)
+      : path.join(synapsePath, `workflow-${workflowId}`);
+
+    const rules = loadDomainFile(domainFile);
+
+    // Graceful degradation: domain file missing or empty
+    if (!rules || rules.length === 0) {
+      return null;
+    }
+
+    // 4. Build metadata with phase info
+    const phase = session.active_workflow?.current_phase || null;
+
+    return {
+      rules,
+      metadata: {
+        layer: 3,
+        source: `workflow-${workflowId}`,
+        workflow: workflowId,
+        phase,
+      },
+    };
+  }
+}
+
+module.exports = L3WorkflowProcessor;

package/.auroq-core/core/synapse/layers/l4-task.js

@@ -0,0 +1,83 @@
+/**
+ * L4 Task Layer Processor
+ *
+ * Injects task-specific context based on the currently active task.
+ * Detects the active task from session.active_task and formats
+ * task ID, story, and executor type as injectable rules.
+ *
+ * Returns null if no task is active (graceful skip).
+ *
+ * @module core/synapse/layers/l4-task
+ * @version 1.0.0
+ * @created Story SYN-5 - Layer Processors L4-L7
+ */
+
+const LayerProcessor = require('./layer-processor');
+
+/**
+ * L4 Task Processor
+ *
+ * Loads task context when a task is active in the session.
+ * Returns null if no active task or task has no ID.
+ *
+ * @extends LayerProcessor
+ */
+class L4TaskProcessor extends LayerProcessor {
+  constructor() {
+    super({ name: 'task', layer: 4, timeout: 20 });
+  }
+
+  /**
+   * Load task-specific context as injectable rules.
+   *
+   * Detection flow:
+   * 1. Get active task from session.active_task
+   * 2. Validate task has an ID
+   * 3. Extract id, story, executor_type
+   * 4. Format as injectable rules
+   *
+   * @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 { session } = context;
+
+    // 1. Get active task
+    const task = session.active_task;
+    if (!task || !task.id) {
+      return null;
+    }
+
+    // 2. Extract task fields
+    const taskId = task.id;
+    const story = task.story || null;
+    const executorType = task.executor_type || null;
+
+    // 3. Format as injectable rules
+    const rules = [];
+    rules.push(`Active Task: ${taskId}`);
+    if (story) {
+      rules.push(`Story: ${story}`);
+    }
+    if (executorType) {
+      rules.push(`Executor: ${executorType}`);
+    }
+
+    // 4. Return rules with metadata
+    return {
+      rules,
+      metadata: {
+        layer: 4,
+        taskId,
+        story,
+        executorType,
+      },
+    };
+  }
+}
+
+module.exports = L4TaskProcessor;

package/.auroq-core/core/synapse/layers/l5-squad.js

@@ -0,0 +1,244 @@
+/**
+ * L5 Squad Layer Processor
+ *
+ * Discovers and merges domain rules from installed squads.
+ * Scans squads/ directory for .synapse/manifest files,
+ * namespaces domain keys with {SQUAD_NAME}_ prefix,
+ * and applies merge rules (extend/override/none).
+ *
+ * Implements a 60-second TTL cache to minimize filesystem scans.
+ * Prioritizes active squad domains when session.active_squad is set.
+ *
+ * @module core/synapse/layers/l5-squad
+ * @version 1.0.0
+ * @created Story SYN-5 - Layer Processors L4-L7
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { parseManifest, loadDomainFile } = require('../domain/domain-loader');
+const LayerProcessor = require('./layer-processor');
+
+/** Cache TTL in milliseconds (60 seconds) */
+const CACHE_TTL_MS = 60000;
+
+/**
+ * L5 Squad Processor
+ *
+ * Discovers squads with .synapse/manifest files and merges their
+ * domain rules into the pipeline. Returns null if no squads found
+ * or squads/ directory is missing.
+ *
+ * @extends LayerProcessor
+ */
+class L5SquadProcessor extends LayerProcessor {
+  constructor() {
+    super({ name: 'squad', layer: 5, timeout: 20 });
+  }
+
+  /**
+   * Discover squad domains and merge rules.
+   *
+   * Detection flow:
+   * 1. Resolve squads/ directory relative to synapsePath parent
+   * 2. Check cache (TTL 60s), use if fresh
+   * 3. Scan squads/ for .synapse/manifest files
+   * 4. Namespace domain keys: {SQUAD_NAME_UPPER}_{DOMAIN_KEY}
+   * 5. Read merge rules from {SQUAD}_EXTENDS key
+   * 6. Prioritize active squad if session.active_squad set
+   * 7. Load domain files and collect rules
+   *
+   * @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 { session, config } = context;
+    const { synapsePath } = config;
+
+    // 1. Resolve agents/ directory (sibling of .synapse/)
+    const projectRoot = path.dirname(synapsePath);
+    const squadsDir = path.join(projectRoot, 'agents');
+
+    // Graceful: missing squads/ directory
+    if (!fs.existsSync(squadsDir)) {
+      return null;
+    }
+
+    // 2. Check cache
+    const cacheDir = path.join(synapsePath, 'cache');
+    const cachePath = path.join(cacheDir, 'squad-manifests.json');
+    const cachedData = this._readCache(cachePath);
+
+    // 3. Discover squads (from cache or scan)
+    let squadManifests;
+    if (cachedData) {
+      squadManifests = cachedData.manifests;
+    } else {
+      squadManifests = this._scanSquads(squadsDir);
+      this._writeCache(cachePath, cacheDir, squadManifests);
+    }
+
+    if (Object.keys(squadManifests).length === 0) {
+      return null;
+    }
+
+    // 4. Determine active squad for prioritization
+    const activeSquadName = session.active_squad?.name || null;
+
+    // 5. Collect rules from all squads
+    const allRules = [];
+    const domainsLoaded = [];
+
+    // Process active squad first (priority)
+    const squadNames = Object.keys(squadManifests);
+    if (activeSquadName && squadManifests[activeSquadName]) {
+      this._loadSquadDomains(
+        activeSquadName, squadManifests[activeSquadName],
+        squadsDir, allRules, domainsLoaded,
+      );
+    }
+
+    // Process remaining squads
+    for (const squadName of squadNames) {
+      if (squadName === activeSquadName) continue;
+      this._loadSquadDomains(
+        squadName, squadManifests[squadName],
+        squadsDir, allRules, domainsLoaded,
+      );
+    }
+
+    if (allRules.length === 0) {
+      return null;
+    }
+
+    return {
+      rules: allRules,
+      metadata: {
+        layer: 5,
+        squadsFound: Object.keys(squadManifests).length,
+        domainsLoaded,
+      },
+    };
+  }
+
+  /**
+   * Load domain rules from a single squad.
+   *
+   * @param {string} squadName - Squad directory name
+   * @param {object} manifest - Parsed squad manifest
+   * @param {string} squadsDir - Path to squads/ directory
+   * @param {string[]} allRules - Accumulator for rules
+   * @param {string[]} domainsLoaded - Accumulator for domain names
+   * @private
+   */
+  _loadSquadDomains(squadName, manifest, squadsDir, allRules, domainsLoaded) {
+    const squadUpper = squadName.toUpperCase();
+    const squadSynapsePath = path.join(squadsDir, squadName, '.synapse');
+
+    // Check merge mode from {SQUAD}_EXTENDS key
+    const extendsKey = `${squadUpper}_EXTENDS`;
+    const mergeMode = manifest.domains?.[extendsKey]?.file || 'extend';
+    const resolvedMerge = ['extend', 'override', 'none'].includes(mergeMode)
+      ? mergeMode : 'extend';
+
+    if (resolvedMerge === 'none') {
+      return; // Squad opted out of rule injection
+    }
+
+    for (const [domainKey, domain] of Object.entries(manifest.domains || {})) {
+      // Skip the EXTENDS meta-key
+      if (domainKey === extendsKey) continue;
+
+      const namespacedKey = `${squadUpper}_${domainKey}`;
+      const domainFile = domain.file
+        ? path.join(squadSynapsePath, domain.file)
+        : path.join(squadSynapsePath, domainKey.toLowerCase().replace(/_/g, '-'));
+
+      const rules = loadDomainFile(domainFile);
+      if (rules && rules.length > 0) {
+        allRules.push(...rules);
+        domainsLoaded.push(namespacedKey);
+      }
+    }
+  }
+
+  /**
+   * Read cache file if it exists and is not stale.
+   *
+   * @param {string} cachePath - Path to cache JSON file
+   * @returns {object|null} Cached data or null if miss/stale/error
+   * @private
+   */
+  _readCache(cachePath) {
+    try {
+      const raw = fs.readFileSync(cachePath, 'utf8');
+      const cached = JSON.parse(raw);
+      if (cached.timestamp && (Date.now() - cached.timestamp) < CACHE_TTL_MS) {
+        return cached;
+      }
+      return null; // Stale
+    } catch (_error) {
+      return null; // Missing or corrupt
+    }
+  }
+
+  /**
+   * Write cache file with current timestamp.
+   *
+   * @param {string} cachePath - Path to cache JSON file
+   * @param {string} cacheDir - Path to cache directory
+   * @param {object} manifests - Squad manifests to cache
+   * @private
+   */
+  _writeCache(cachePath, cacheDir, manifests) {
+    try {
+      if (!fs.existsSync(cacheDir)) {
+        fs.mkdirSync(cacheDir, { recursive: true });
+      }
+      fs.writeFileSync(cachePath, JSON.stringify({
+        timestamp: Date.now(),
+        manifests,
+      }));
+    } catch (_error) {
+      // Graceful: cache write failure is non-fatal
+    }
+  }
+
+  /**
+   * Scan squads/ directory for .synapse/manifest files.
+   *
+   * @param {string} squadsDir - Path to squads/ directory
+   * @returns {object} Map of squadName -> parsed manifest
+   * @private
+   */
+  _scanSquads(squadsDir) {
+    const manifests = {};
+
+    let entries;
+    try {
+      entries = fs.readdirSync(squadsDir, { withFileTypes: true });
+    } catch (_error) {
+      return manifests;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+
+      const manifestPath = path.join(squadsDir, entry.name, '.synapse', 'manifest');
+      if (!fs.existsSync(manifestPath)) continue;
+
+      const parsed = parseManifest(manifestPath);
+      if (parsed && Object.keys(parsed.domains).length > 0) {
+        manifests[entry.name] = parsed;
+      }
+    }
+
+    return manifests;
+  }
+}
+
+module.exports = L5SquadProcessor;

package/.auroq-core/core/synapse/layers/l6-keyword.js

@@ -0,0 +1,154 @@
+/**
+ * L6 Keyword Layer Processor
+ *
+ * Scans manifest domains for recall keywords and matches them
+ * against the user prompt. Loads domain files for matching domains.
+ * Respects exclusion rules and deduplicates against previous layers.
+ *
+ * CARL parity: identical keyword matching behavior using domain-loader
+ * matchKeywords() and isExcluded() functions.
+ *
+ * @module core/synapse/layers/l6-keyword
+ * @version 1.0.0
+ * @created Story SYN-5 - Layer Processors L4-L7
+ */
+
+const path = require('path');
+const { loadDomainFile, matchKeywords, isExcluded } = require('../domain/domain-loader');
+const LayerProcessor = require('./layer-processor');
+
+/**
+ * L6 Keyword Processor
+ *
+ * Matches recall keywords in manifest domains against the prompt.
+ * Deduplicates domains already loaded by previous layers.
+ * Returns null if no keyword matches.
+ *
+ * @extends LayerProcessor
+ */
+class L6KeywordProcessor extends LayerProcessor {
+  constructor() {
+    super({ name: 'keyword', layer: 6, timeout: 15 });
+  }
+
+  /**
+   * Match keywords and load corresponding domain rules.
+   *
+   * Detection flow:
+   * 1. Build set of already-loaded domains from previousLayers
+   * 2. Iterate manifest domains with recall keywords
+   * 3. Check exclusion (global + domain)
+   * 4. Check keyword match against prompt
+   * 5. Skip if domain already loaded by previous layer
+   * 6. Load domain file and collect rules
+   *
+   * @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, previousLayers } = context;
+    const { manifest, synapsePath } = config;
+
+    if (!prompt) {
+      return null;
+    }
+
+    // 1. Build set of already-loaded domain sources
+    const loadedSources = this._extractLoadedSources(previousLayers || []);
+
+    const allRules = [];
+    const matchedDomains = [];
+    const skippedDuplicates = [];
+
+    const globalExclude = manifest.globalExclude || [];
+
+    // 2. Iterate domains with recall keywords
+    for (const [domainName, domain] of Object.entries(manifest.domains || {})) {
+      if (!domain.recall || domain.recall.length === 0) {
+        continue;
+      }
+
+      // 3. Check exclusion
+      if (isExcluded(prompt, globalExclude, domain.exclude || [])) {
+        continue;
+      }
+
+      // 4. Check keyword match
+      if (!matchKeywords(prompt, domain.recall)) {
+        continue;
+      }
+
+      // 5. Check dedup against previous layers
+      if (loadedSources.has(domainName)) {
+        skippedDuplicates.push(domainName);
+        continue;
+      }
+
+      // 6. Load domain file
+      const domainFile = domain.file
+        ? path.join(synapsePath, domain.file)
+        : path.join(synapsePath, domainName.toLowerCase().replace(/_/g, '-'));
+
+      const rules = loadDomainFile(domainFile);
+      if (rules && rules.length > 0) {
+        allRules.push(...rules);
+        matchedDomains.push(domainName);
+      }
+    }
+
+    if (allRules.length === 0) {
+      return null;
+    }
+
+    return {
+      rules: allRules,
+      metadata: {
+        layer: 6,
+        matchedDomains,
+        skippedDuplicates,
+      },
+    };
+  }
+
+  /**
+   * Extract domain source identifiers from previous layer results.
+   *
+   * Looks at metadata.source and metadata.agentId from previous layers
+   * to build a set of domain names that are already loaded.
+   *
+   * @param {object[]} previousLayers - Array of { name, metadata } from prior layers
+   * @returns {Set<string>} Set of loaded domain identifiers
+   * @private
+   */
+  _extractLoadedSources(previousLayers) {
+    const sources = new Set();
+
+    for (const layer of previousLayers) {
+      if (!layer || !layer.metadata) continue;
+
+      // Extract source identifier from metadata
+      const source = layer.metadata.source;
+      if (source) {
+        sources.add(source);
+        // Also add the uppercase domain key form
+        const upperKey = source.toUpperCase().replace(/-/g, '_');
+        sources.add(upperKey);
+      }
+
+      // Track loaded domains from squad layer
+      if (layer.metadata.domainsLoaded) {
+        for (const d of layer.metadata.domainsLoaded) {
+          sources.add(d);
+        }
+      }
+    }
+
+    return sources;
+  }
+}
+
+module.exports = L6KeywordProcessor;