aios-core 4.2.15 → 4.4.0

package/.aios-core/core/synapse/engine.js

@@ -172,6 +172,14 @@ class PipelineMetrics {
 /** Hard pipeline timeout in milliseconds. */
 const PIPELINE_TIMEOUT_MS = 100;
 
+/**
+ * NOG-18: Default active layers (L0-L2 only).
+ * L3-L7 produced 0 rules in NOG-17 audit — disabled for performance.
+ * Set SYNAPSE_LEGACY_MODE=true to re-enable full 8-layer processing.
+ */
+const DEFAULT_ACTIVE_LAYERS = [0, 1, 2];
+const LEGACY_MODE = process.env.SYNAPSE_LEGACY_MODE === 'true';
+
 /**
  * Orchestrates the 8-layer SYNAPSE context injection pipeline.
  *
@@ -229,21 +237,33 @@ class SynapseEngine {
     const metrics = new PipelineMetrics();
     metrics.totalStart = process.hrtime.bigint();
 
-    // 1. Calculate bracket
+    // 1. Calculate bracket (or use fixed layers in non-legacy mode)
     const promptCount = (session && session.prompt_count) || 0;
-    const contextPercent = estimateContextPercent(promptCount);
-    const bracket = calculateBracket(contextPercent);
-    const layerConfig = getActiveLayers(bracket);
-    const tokenBudget = getTokenBudget(bracket);
-
-    // Guard: no layer config (invalid bracket — should not happen)
-    if (!layerConfig) {
-      metrics.totalEnd = process.hrtime.bigint();
-      return { xml: '', metrics: metrics.getSummary() };
+    let contextPercent, bracket, activeLayers, tokenBudget;
+
+    if (LEGACY_MODE) {
+      // Full 8-layer processing with bracket-based filtering
+      contextPercent = estimateContextPercent(promptCount);
+      bracket = calculateBracket(contextPercent);
+      const layerConfig = getActiveLayers(bracket);
+      tokenBudget = getTokenBudget(bracket);
+
+      // Guard: no layer config (invalid bracket — should not happen)
+      if (!layerConfig) {
+        metrics.totalEnd = process.hrtime.bigint();
+        return { xml: '', metrics: metrics.getSummary() };
+      }
+      activeLayers = layerConfig.layers;
+    } else {
+      // NOG-18: Simplified — always load L0-L2, skip bracket calculation.
+      // L3-L7 produced 0 rules (require session context that never exists).
+      // Bracket management replaced by native /compact.
+      contextPercent = estimateContextPercent(promptCount);
+      bracket = calculateBracket(contextPercent);
+      activeLayers = DEFAULT_ACTIVE_LAYERS;
+      tokenBudget = getTokenBudget(bracket);
     }
 
-    const activeLayers = layerConfig.layers;
-
     // 2. Execute layers sequentially
     const results = [];
     const previousLayers = [];
@@ -323,7 +343,7 @@ class SynapseEngine {
       needsHandoffWarning(bracket),
     );
 
-    return { xml, metrics: summary };
+    return { xml, metrics: summary, bracket };
   }
 
   /**

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,
+};

package/.aios-core/core/synapse/runtime/hook-runtime.js

@@ -3,9 +3,34 @@
 const path = require('path');
 const fs = require('fs');
 
+const DEFAULT_STALE_TTL_HOURS = 168; // 7 days
+
+/**
+ * Read stale session TTL from core-config.yaml.
+ * Falls back to DEFAULT_STALE_TTL_HOURS (168h = 7 days).
+ *
+ * @param {string} cwd - Working directory
+ * @returns {number} TTL in hours
+ */
+function getStaleSessionTTL(cwd) {
+  try {
+    const yaml = require('js-yaml');
+    const configPath = path.join(cwd, '.aios-core', 'core-config.yaml');
+    if (!fs.existsSync(configPath)) return DEFAULT_STALE_TTL_HOURS;
+    const config = yaml.load(fs.readFileSync(configPath, 'utf8'));
+    const ttl = config && config.synapse && config.synapse.session && config.synapse.session.staleTTLHours;
+    return typeof ttl === 'number' && ttl > 0 ? ttl : DEFAULT_STALE_TTL_HOURS;
+  } catch (_err) {
+    return DEFAULT_STALE_TTL_HOURS;
+  }
+}
+
 /**
  * Resolve runtime dependencies for Synapse hook execution.
  *
+ * On the first prompt of a session (prompt_count === 0), runs
+ * cleanStaleSessions() fire-and-forget to remove expired sessions.
+ *
  * @param {{cwd?: string, session_id?: string, sessionId?: string}} input
  * @returns {{
  *   engine: import('../engine').SynapseEngine,
@@ -21,7 +46,7 @@ function resolveHookRuntime(input) {
   if (!fs.existsSync(synapsePath)) return null;
 
   try {
-    const { loadSession } = require(
+    const { loadSession, cleanStaleSessions } = require(
       path.join(cwd, '.aios-core', 'core', 'synapse', 'session', 'session-manager.js'),
     );
     const { SynapseEngine } = require(
@@ -32,7 +57,20 @@ function resolveHookRuntime(input) {
     const session = loadSession(sessionId, sessionsDir) || { prompt_count: 0 };
     const engine = new SynapseEngine(synapsePath);
 
-    return { engine, session };
+    // AC3: Run cleanup on first prompt only (fire-and-forget)
+    if (session.prompt_count === 0) {
+      try {
+        const ttlHours = getStaleSessionTTL(cwd);
+        const removed = cleanStaleSessions(sessionsDir, ttlHours);
+        if (removed > 0 && process.env.DEBUG === '1') {
+          console.error(`[hook-runtime] Cleaned ${removed} stale session(s) (TTL: ${ttlHours}h)`);
+        }
+      } catch (_cleanupErr) {
+        // Fire-and-forget: never block hook execution
+      }
+    }
+
+    return { engine, session, sessionId, sessionsDir, cwd };
   } catch (error) {
     if (process.env.DEBUG === '1') {
       console.error(`[hook-runtime] Failed to resolve runtime: ${error.message}`);

package/.aios-core/core/synapse/session/session-manager.js

@@ -17,6 +17,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { atomicWriteSync } = require('../utils/atomic-write');
 
 const SCHEMA_VERSION = '2.0';
 const DEFAULT_MAX_AGE_HOURS = 24;
@@ -132,7 +133,7 @@ function createSession(sessionId, cwd, sessionsDir) {
   const filePath = resolveSessionFile(sessionId, dir);
 
   try {
-    fs.writeFileSync(filePath, JSON.stringify(session, null, 2), 'utf8');
+    atomicWriteSync(filePath, JSON.stringify(session, null, 2));
   } catch (error) {
     if (error.code === 'EACCES' || error.code === 'EPERM') {
       console.error(`[synapse:session] Error: Permission denied creating session ${sessionId}`);
@@ -227,7 +228,7 @@ function updateSession(sessionId, sessionsDir, updates) {
   const filePath = resolveSessionFile(sessionId, sessionsDir);
 
   try {
-    fs.writeFileSync(filePath, JSON.stringify(session, null, 2), 'utf8');
+    atomicWriteSync(filePath, JSON.stringify(session, null, 2));
   } catch (error) {
     if (error.code === 'EACCES' || error.code === 'EPERM') {
       console.error(`[synapse:session] Error: Permission denied writing session ${sessionId}`);

package/.aios-core/core/synapse/utils/atomic-write.js

@@ -0,0 +1,79 @@
+/**
+ * Atomic Write Utility
+ *
+ * Writes files atomically using write-to-tmp + rename pattern.
+ * Prevents file corruption on unexpected exit (crash, kill, power loss).
+ *
+ * Pattern:
+ *   1. Write data to {filePath}.tmp.{pid}
+ *   2. On Windows: unlink target if exists (rename won't overwrite)
+ *   3. Rename tmp → target (atomic on POSIX, near-atomic on Windows)
+ *   4. On failure: clean up tmp file
+ *
+ * @module core/synapse/utils/atomic-write
+ * @version 1.0.0
+ * @created Story NOG-12 - State Persistence Hardening
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const IS_WINDOWS = process.platform === 'win32';
+
+/**
+ * Write data to a file atomically.
+ *
+ * Writes to a temporary file first, then renames to the target path.
+ * If the process crashes between write and rename, the original file
+ * remains intact and the orphaned .tmp file is harmless.
+ *
+ * @param {string} filePath - Target file path
+ * @param {string} data - Data to write
+ * @param {string} [encoding='utf8'] - File encoding
+ * @throws {Error} If write or rename fails (original file preserved)
+ */
+function atomicWriteSync(filePath, data, encoding = 'utf8') {
+  const tmpPath = `${filePath}.tmp.${process.pid}`;
+
+  try {
+    // Ensure parent directory exists
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    // Step 1: Write to temporary file
+    fs.writeFileSync(tmpPath, data, encoding);
+
+    // Step 2: On Windows, unlink target first (rename won't overwrite)
+    if (IS_WINDOWS) {
+      try {
+        fs.unlinkSync(filePath);
+      } catch (err) {
+        if (err.code !== 'ENOENT') {
+          throw err;
+        }
+        // ENOENT = target doesn't exist yet, that's fine
+      }
+    }
+
+    // Step 3: Atomic rename
+    fs.renameSync(tmpPath, filePath);
+  } catch (error) {
+    // Clean up tmp file on failure
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch (_cleanupErr) {
+      // Ignore cleanup errors
+    }
+
+    console.error(`[atomic-write] Failed to write ${filePath}: ${error.message}`);
+    throw error;
+  }
+}
+
+module.exports = {
+  atomicWriteSync,
+};

package/.aios-core/core-config.yaml

@@ -162,6 +162,9 @@ projectStatus:
   statusFile: .aios/project-status.yaml
   maxModifiedFiles: 5
   maxRecentCommits: 2
+synapse:
+  session:
+    staleTTLHours: 168 # 7 days — sessions older than this are cleaned up on first prompt
 agentIdentity:
   greeting:
     preference: auto
@@ -321,7 +324,7 @@ ideSync:
     github-copilot:
       enabled: true
       path: .github/agents
-      format: full-markdown-yaml
+      format: github-copilot
     cursor:
       enabled: true
       path: .cursor/rules/agents
@@ -352,4 +355,34 @@ autoClaude:
     enabled: false
   qa:
     enabled: false
+# Boundary Mapping — Framework-Project Separation (Epic BM)
+# Controls deterministic protection of framework core files via Claude Code deny rules.
+# When frameworkProtection is true (default), .claude/settings.json includes deny rules
+# that block Edit/Write operations on L1/L2 paths listed in 'protected' below.
+# Set to false for framework contributors who need to edit core files directly.
+# NOTE: This flag is read by the installer during settings.json generation.
+# Changing this value alone does NOT add/remove deny rules — re-run the installer.
+# SINGLE SOURCE OF TRUTH: Both pre-commit hook (framework-guard.js) and
+# the installer read protected/exceptions from here. Do NOT hardcode paths elsewhere.
+boundary:
+  frameworkProtection: false # TEMPORARY: TOK-3 contributor mode — re-enable after story
+  # L1/L2 paths — blocked from editing in project mode
+  # Glob syntax: ** matches any depth, * matches single segment
+  protected:
+    - .aios-core/core/**
+    - .aios-core/development/tasks/**
+    - .aios-core/development/templates/**
+    - .aios-core/development/checklists/**
+    - .aios-core/development/workflows/**
+    - .aios-core/infrastructure/**
+    - .aios-core/constitution.md
+    - bin/aios.js
+    - bin/aios-init.js
+  # L3 paths — mutable exceptions (allowed even within .aios-core/)
+  exceptions:
+    - .aios-core/data/**
+    - .aios-core/development/agents/*/MEMORY.md
+    - .aios-core/core/config/schemas/**
+    - .aios-core/core/config/template-overrides.js
+
 # Memory Intelligence System (Epic MIS) configuration placeholder — MIS-2+

package/.aios-core/data/aios-kb.md

@@ -86,7 +86,7 @@ AIOS transforms you into a "Vibe CEO" - directing a team of specialized AI agent
 
 ```bash
 # Interactive installation (recommended)
-npx @synkra/aios-core install
+npx aios-core install
 ```
 
 **Installation Steps**:
@@ -889,7 +889,7 @@ Squads extend AIOS-Method beyond traditional software development into ANY domai
 3. **Install via CLI**:
 
    ```bash
-   npx @synkra/aios-core install
+   npx aios-core install
    # Select "Install squad" option
    ```