aios-core 4.0.0 → 4.0.2

package/.aios-core/cli/commands/pro/index.js

@@ -23,8 +23,40 @@ const path = require('path');
 const fs = require('fs');
 const readline = require('readline');
 
-// Resolve license modules (relative from .aios-core/cli/commands/pro/)
-const licensePath = path.resolve(__dirname, '..', '..', '..', '..', 'pro', 'license');
+// BUG-6 fix (INS-1): Dynamic licensePath resolution
+// In framework-dev: __dirname = aios-core/.aios-core/cli/commands/pro → ../../../../pro/license
+// In project-dev: pro is installed via npm as @aios-fullstack/pro
+function resolveLicensePath() {
+  // 1. Try relative path (framework-dev mode)
+  const relativePath = path.resolve(__dirname, '..', '..', '..', '..', 'pro', 'license');
+  if (fs.existsSync(relativePath)) {
+    return relativePath;
+  }
+
+  // 2. Try node_modules/@aios-fullstack/pro/license (project-dev mode)
+  try {
+    const proPkg = require.resolve('@aios-fullstack/pro/package.json');
+    const proDir = path.dirname(proPkg);
+    const npmPath = path.join(proDir, 'license');
+    if (fs.existsSync(npmPath)) {
+      return npmPath;
+    }
+  } catch {
+    // @aios-fullstack/pro not installed via npm
+  }
+
+  // 3. Try project root node_modules (fallback)
+  const projectRoot = process.cwd();
+  const cwdPath = path.join(projectRoot, 'node_modules', '@aios-fullstack', 'pro', 'license');
+  if (fs.existsSync(cwdPath)) {
+    return cwdPath;
+  }
+
+  // Return relative path as default (will fail gracefully in loadLicenseModules)
+  return relativePath;
+}
+
+const licensePath = resolveLicensePath();
 
 /**
  * Lazy-load license modules (avoids failing if pro module not installed)
@@ -65,7 +97,7 @@ function loadLicenseModules() {
     };
   } catch (error) {
     console.error('AIOS Pro license module not available.');
-    console.error('Install AIOS Pro: npm install @aios/pro');
+    console.error('Install AIOS Pro: npm install @aios-fullstack/pro');
     process.exit(1);
   }
 }
@@ -487,172 +519,75 @@ async function validateAction() {
 // ---------------------------------------------------------------------------
 
 /**
- * Setup GitHub Packages access for @aios/pro installation.
+ * Setup and verify @aios-fullstack/pro installation.
  *
- * This command helps users configure their .npmrc to access
- * the private @aios scope on GitHub Packages.
+ * Since @aios-fullstack/pro is published on the public npm registry,
+ * no special token or .npmrc configuration is needed. This command
+ * installs the package and verifies it's working.
  *
  * @param {object} options - Command options
- * @param {string} options.token - GitHub Personal Access Token
- * @param {boolean} options.global - Configure globally vs project-level
+ * @param {boolean} options.verify - Only verify without installing
  */
 async function setupAction(options) {
-  const os = require('os');
-  const homedir = os.homedir();
-
-  console.log('\nAIOS Pro - GitHub Packages Setup\n');
-  console.log('This will configure npm to access @aios/pro from GitHub Packages.');
-  console.log('');
+  console.log('\nAIOS Pro - Setup\n');
 
-  // Determine .npmrc location
-  const npmrcPath = options.global
-    ? path.join(homedir, '.npmrc')
-    : path.join(process.cwd(), '.npmrc');
+  if (options.verify) {
+    // Verify-only mode
+    console.log('Verifying @aios-fullstack/pro installation...\n');
 
-  const scopeConfig = '@aios:registry=https://npm.pkg.github.com';
-  const tokenConfig = '//npm.pkg.github.com/:_authToken=';
-
-  // Check if token provided
-  let token = options.token;
-
-  if (!token) {
-    console.log('To install @aios/pro, you need a GitHub Personal Access Token (PAT)');
-    console.log('with the "read:packages" scope.');
-    console.log('');
-    console.log('Create one at: https://github.com/settings/tokens/new');
-    console.log('');
-    console.log('Required scopes:');
-    console.log('  - read:packages (download packages from GitHub Packages)');
-    console.log('');
-
-    // Interactive token input
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-
-    token = await new Promise((resolve) => {
-      rl.question('Enter your GitHub PAT (or press Enter to skip): ', (answer) => {
-        rl.close();
-        resolve(answer.trim());
-      });
-    });
-
-    if (!token) {
-      console.log('\nSetup cancelled. You can run this command again with:');
-      console.log('  aios pro setup --token <YOUR_GITHUB_PAT>');
-      console.log('');
-      console.log('Or manually add to your .npmrc:');
-      console.log(`  ${scopeConfig}`);
-      console.log(`  ${tokenConfig}<YOUR_GITHUB_PAT>`);
-      return;
-    }
-  }
-
-  // Validate token format (basic check)
-  if (!token.startsWith('ghp_') && !token.startsWith('github_pat_')) {
-    console.log('\n⚠️  Warning: Token does not appear to be a valid GitHub PAT.');
-    console.log('Expected format: ghp_... or github_pat_...');
-
-    const confirmed = await confirm('Continue anyway? (y/N): ');
-    if (!confirmed) {
-      console.log('Setup cancelled.');
-      return;
-    }
-  }
-
-  // Read existing .npmrc or create new
-  let npmrcContent = '';
-  try {
-    npmrcContent = fs.readFileSync(npmrcPath, 'utf8');
-  } catch {
-    // File doesn't exist, will create new
-  }
-
-  // Check if already configured
-  if (npmrcContent.includes('@aios:registry')) {
-    console.log(`\n⚠️  @aios registry already configured in ${npmrcPath}`);
-
-    const overwrite = await confirm('Overwrite existing configuration? (y/N): ');
-    if (!overwrite) {
-      console.log('Setup cancelled. Existing configuration preserved.');
-      return;
-    }
-
-    // Remove existing @aios config
-    npmrcContent = npmrcContent
-      .split('\n')
-      .filter((line) => !line.includes('@aios:') && !line.includes('npm.pkg.github.com/:_authToken'))
-      .join('\n');
-  }
-
-  // Add new configuration
-  const newConfig = [
-    '',
-    '# AIOS Pro - GitHub Packages (added by aios pro setup)',
-    scopeConfig,
-    `${tokenConfig}${token}`,
-    '',
-  ].join('\n');
-
-  npmrcContent = npmrcContent.trimEnd() + newConfig;
-
-  // Write .npmrc
-  try {
-    fs.writeFileSync(npmrcPath, npmrcContent, 'utf8');
-    console.log(`\n✅ Configuration written to ${npmrcPath}`);
-  } catch (error) {
-    console.error(`\n❌ Failed to write ${npmrcPath}: ${error.message}`);
-    console.log('\nManually add these lines to your .npmrc:');
-    console.log(`  ${scopeConfig}`);
-    console.log(`  ${tokenConfig}<YOUR_TOKEN>`);
-    process.exit(1);
-  }
-
-  // Add .npmrc to .gitignore if project-level
-  if (!options.global) {
-    const gitignorePath = path.join(process.cwd(), '.gitignore');
     try {
-      let gitignore = '';
-      try {
-        gitignore = fs.readFileSync(gitignorePath, 'utf8');
-      } catch {
-        // No .gitignore exists
-      }
-
-      if (!gitignore.includes('.npmrc')) {
-        gitignore += '\n# AIOS Pro credentials (DO NOT COMMIT)\n.npmrc\n';
-        fs.writeFileSync(gitignorePath, gitignore, 'utf8');
-        console.log('✅ Added .npmrc to .gitignore');
+      const { execSync } = require('child_process');
+      const result = execSync('npm ls @aios-fullstack/pro --json', {
+        stdio: 'pipe',
+        timeout: 15000,
+      });
+      const parsed = JSON.parse(result.toString());
+      const deps = parsed.dependencies || {};
+      if (deps['@aios-fullstack/pro']) {
+        console.log(`✅ @aios-fullstack/pro@${deps['@aios-fullstack/pro'].version} is installed`);
+      } else {
+        console.log('❌ @aios-fullstack/pro is not installed');
+        console.log('');
+        console.log('Install with:');
+        console.log('  npm install @aios-fullstack/pro');
       }
     } catch {
-      console.log('⚠️  Could not update .gitignore. Please add .npmrc manually.');
+      console.log('❌ @aios-fullstack/pro is not installed');
+      console.log('');
+      console.log('Install with:');
+      console.log('  npm install @aios-fullstack/pro');
     }
+    return;
   }
 
-  // Verify access
-  console.log('\nVerifying access to GitHub Packages...');
+  // Install mode
+  console.log('@aios-fullstack/pro is available on the public npm registry.');
+  console.log('No special tokens or configuration needed.\n');
+
+  console.log('Installing @aios-fullstack/pro...\n');
 
   try {
     const { execSync } = require('child_process');
-    execSync('npm view @aios/pro --registry=https://npm.pkg.github.com', {
-      stdio: 'pipe',
-      timeout: 15000,
+    execSync('npm install @aios-fullstack/pro', {
+      stdio: 'inherit',
+      timeout: 120000,
     });
-    console.log('✅ Access verified! You can now install @aios/pro');
-  } catch {
-    console.log('⚠️  Could not verify access (package may not be published yet)');
-    console.log('   Configuration is saved. Try: npm install @aios/pro');
+    console.log('\n✅ @aios-fullstack/pro installed successfully!');
+  } catch (error) {
+    console.error(`\n❌ Installation failed: ${error.message}`);
+    console.log('\nTry manually:');
+    console.log('  npm install @aios-fullstack/pro');
+    process.exit(1);
   }
 
   console.log('\n--- Setup Complete ---');
   console.log('');
-  console.log('To install AIOS Pro:');
-  console.log('  npm install @aios/pro');
-  console.log('');
   console.log('To activate your license:');
   console.log('  aios pro activate --key PRO-XXXX-XXXX-XXXX-XXXX');
   console.log('');
+  console.log('To check license status:');
+  console.log('  aios pro status');
+  console.log('');
   console.log('Documentation: https://synkra.ai/pro/docs');
   console.log('');
 }
@@ -704,9 +639,8 @@ function createProCommand() {
   // aios pro setup (AC-12: Install-gate)
   proCmd
     .command('setup')
-    .description('Configure GitHub Packages access for @aios/pro')
-    .option('-t, --token <token>', 'GitHub Personal Access Token')
-    .option('-g, --global', 'Configure globally (~/.npmrc) instead of project-level')
+    .description('Install and verify @aios-fullstack/pro')
+    .option('--verify', 'Only verify installation without installing')
     .action(setupAction);
 
   return proCmd;

package/.aios-core/core/synapse/domain/domain-loader.js

@@ -169,7 +169,7 @@ function loadDomainFile(domainPath) {
   // First pass: detect if file uses KEY=VALUE format
   for (const line of lines) {
     const trimmed = line.trim();
-    if (trimmed && !trimmed.startsWith('#') && /^[A-Z_]+_RULE_\d+=/.test(trimmed)) {
+    if (trimmed && !trimmed.startsWith('#') && /^[A-Z][A-Z0-9_]*=/.test(trimmed)) {
       hasKeyValueFormat = true;
       break;
     }
@@ -185,7 +185,7 @@ function loadDomainFile(domainPath) {
 
     if (hasKeyValueFormat) {
       // KEY=VALUE format: extract value from DOMAIN_RULE_N=text
-      const match = trimmed.match(/^[A-Z_]+_RULE_\d+=(.+)$/);
+      const match = trimmed.match(/^[A-Z][A-Z0-9_]*=(.+)$/);
       if (match) {
         rules.push(match[1].trim());
       }

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

@@ -20,6 +20,7 @@ const {
 } = require('./context/context-tracker');
 
 const { formatSynapseRules } = require('./output/formatter');
+const { MemoryBridge } = require('./memory/memory-bridge');
 
 // ---------------------------------------------------------------------------
 // Layer Imports (graceful — layers from SYN-4/SYN-5 may not exist yet)
@@ -186,6 +187,9 @@ class SynapseEngine {
     /** @type {Array<import('./layers/layer-processor')>} */
     this.layers = [];
 
+    /** @type {MemoryBridge} Feature-gated MIS consumer (SYN-10) */
+    this.memoryBridge = new MemoryBridge();
+
     for (const mod of LAYER_MODULES) {
       const LayerClass = loadLayerModule(mod.path);
       if (LayerClass) {
@@ -211,9 +215,9 @@ class SynapseEngine {
    * @param {object} session - Session state (SYN-2 schema)
    * @param {number} [session.prompt_count=0] - Number of prompts so far
    * @param {object} [processConfig] - Per-call config overrides
-   * @returns {{ xml: string, metrics: object }}
+   * @returns {Promise<{ xml: string, metrics: object }>}
    */
-  process(prompt, session, processConfig) {
+  async process(prompt, session, processConfig) {
     const safeProcessConfig = (processConfig && typeof processConfig === 'object') ? processConfig : {};
     const mergedConfig = { ...this.config, ...safeProcessConfig };
     const metrics = new PipelineMetrics();
@@ -283,9 +287,18 @@ class SynapseEngine {
       }
     }
 
-    // 3. Memory bridge placeholders (SYN-10 future — no-op)
+    // 3. Memory bridge (SYN-10) — feature-gated MIS consumer
     if (needsMemoryHints(bracket)) {
-      // Placeholder: SYN-10 will inject memory hints here
+      const hints = await this.memoryBridge.getMemoryHints(
+        (session && session.activeAgent) || (session && session.active_agent) || '',
+        bracket,
+        tokenBudget,
+      );
+      if (hints.length > 0) {
+        const memoryResult = { layer: 'memory', rules: hints, metadata: { layer: 'memory', source: 'memory' } };
+        results.push(memoryResult);
+        previousLayers.push(memoryResult);
+      }
     }
 
     metrics.totalEnd = Date.now();

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

@@ -0,0 +1,246 @@
+/**
+ * Memory Bridge — Feature-gated MIS consumer for SYNAPSE engine.
+ *
+ * Connects SynapseEngine to the Memory Intelligence System (MIS)
+ * via MemoryLoader API. 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.
+ *
+ * @module core/synapse/memory/memory-bridge
+ * @version 1.0.0
+ * @created Story SYN-10 - Pro Memory Bridge (Feature-Gated MIS Consumer)
+ */
+
+'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 — Feature-gated MIS consumer.
+ *
+ * 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
+ */
+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._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.
+   *
+   * @private
+   * @returns {object|null} Provider instance or null
+   */
+  _getProvider() {
+    if (this._provider) return this._provider;
+
+    try {
+      const { SynapseMemoryProvider } = require('../../../../pro/memory/synapse-memory-provider');
+      this._provider = new SynapseMemoryProvider();
+      return this._provider;
+    } catch {
+      // Provider not available
+      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:
+   * - Pro feature is unavailable
+   * - 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. Feature gate check (sync, <1ms)
+      this._init();
+      if (!this._featureGate || !this._featureGate.isAvailable('pro.memory.synapse')) {
+        return [];
+      }
+
+      // 2. Bracket check — FRESH needs no memory
+      const bracketConfig = BRACKET_LAYER_MAP[bracket];
+      if (!bracketConfig || bracketConfig.layer === 0) {
+        return [];
+      }
+
+      // 3. Calculate effective token budget
+      const effectiveBudget = Math.min(
+        bracketConfig.maxTokens,
+        tokenBudget > 0 ? tokenBudget : bracketConfig.maxTokens,
+      );
+
+      if (effectiveBudget <= 0) {
+        return [];
+      }
+
+      // 4. Load provider
+      const provider = this._getProvider();
+      if (!provider) {
+        return [];
+      }
+
+      // 5. Execute with timeout protection
+      const hints = await this._executeWithTimeout(
+        () => provider.getMemories(agentId, bracket, effectiveBudget),
+        this._timeout,
+      );
+
+      // 6. 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._featureGate = null;
+    this._initialized = false;
+  }
+}
+
+module.exports = {
+  MemoryBridge,
+  BRACKET_LAYER_MAP,
+  BRIDGE_TIMEOUT_MS,
+  DEFAULT_SECTORS,
+};

package/.aios-core/core/synapse/output/formatter.js

@@ -10,6 +10,8 @@
  * @created Story SYN-6 - SynapseEngine Orchestrator + Output Formatter
  */
 
+const { estimateTokens } = require('../utils/tokens');
+
 // ---------------------------------------------------------------------------
 // Section ordering (DESIGN doc section 14)
 // ---------------------------------------------------------------------------
@@ -29,6 +31,7 @@ const SECTION_ORDER = [
   'TASK',
   'SQUAD',
   'KEYWORD',
+  'MEMORY_HINTS',
   'STAR_COMMANDS',
   'DEVMODE',
   'SUMMARY',
@@ -45,6 +48,7 @@ const LAYER_TO_SECTION = {
   task: 'TASK',
   squad: 'SQUAD',
   keyword: 'KEYWORD',
+  memory: 'MEMORY_HINTS',
   'star-command': 'STAR_COMMANDS',
 };
 
@@ -237,6 +241,34 @@ function formatStarCommands(result) {
   return lines.join('\n');
 }
 
+// ---------------------------------------------------------------------------
+// Memory Hints Section (SYN-10)
+// ---------------------------------------------------------------------------
+
+/**
+ * Format the MEMORY HINTS section.
+ *
+ * Only included when hints array is non-empty.
+ * Each hint displays source, relevance, and content.
+ *
+ * @param {object} result - Layer result { rules (hint objects), metadata }
+ * @returns {string}
+ */
+function formatMemoryHints(result) {
+  const lines = ['[MEMORY HINTS]'];
+
+  for (const hint of result.rules) {
+    const source = hint.source || 'memory';
+    const relevance = typeof hint.relevance === 'number'
+      ? `${(hint.relevance * 100).toFixed(0)}%`
+      : '?%';
+    const content = hint.content || '';
+    lines.push(`  [${source}] (relevance: ${relevance}) ${content}`);
+  }
+
+  return lines.join('\n');
+}
+
 // ---------------------------------------------------------------------------
 // DEVMODE Section (DESIGN doc section 13)
 // ---------------------------------------------------------------------------
@@ -346,18 +378,6 @@ function formatSummary(results, _metrics) {
 // Token Budget Enforcement
 // ---------------------------------------------------------------------------
 
-/**
- * Estimate the number of tokens from a string.
- *
- * Uses the proven heuristic: tokens ~ string.length / 4
- *
- * @param {string} text - Text to estimate
- * @returns {number} Estimated token count
- */
-function estimateTokens(text) {
-  return Math.ceil((text || '').length / 4);
-}
-
 /**
  * Enforce a token budget by removing sections from the end.
  *
@@ -381,6 +401,7 @@ function enforceTokenBudget(sections, sectionIds, tokenBudget) {
   const TRUNCATION_ORDER = [
     'SUMMARY',
     'KEYWORD',
+    'MEMORY_HINTS',
     'SQUAD',
     'STAR_COMMANDS',
     'DEVMODE',
@@ -428,6 +449,7 @@ const SECTION_FORMATTERS = {
   TASK: formatTask,
   SQUAD: formatSquad,
   KEYWORD: formatKeyword,
+  MEMORY_HINTS: formatMemoryHints,
   STAR_COMMANDS: formatStarCommands,
 };