aios-core 4.2.12 → 4.2.13

package/.aios-core/core/code-intel/registry-syncer.js

@@ -0,0 +1,331 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+const { getClient, isCodeIntelAvailable } = require('../code-intel');
+const { RegistryLoader, DEFAULT_REGISTRY_PATH } = require('../ids/registry-loader');
+
+// Role inference from entity path (order matters: more specific patterns first)
+const ROLE_MAP = [
+  ['tasks/', 'task'],
+  ['templates/', 'template'],
+  ['agents/', 'agent'],
+  ['workflows/', 'workflow'],
+  ['scripts/', 'script'],
+  ['/data/', 'config'],
+  ['/core/', 'module'],
+];
+
+/**
+ * Infer entity role from its file path.
+ * @param {string} entityPath - Entity source path
+ * @returns {string} Inferred role
+ */
+function inferRole(entityPath) {
+  if (!entityPath) return 'unknown';
+  const normalized = entityPath.replace(/\\/g, '/');
+  for (const [pattern, role] of ROLE_MAP) {
+    if (normalized.includes(pattern)) return role;
+  }
+  return 'unknown';
+}
+
+/**
+ * RegistrySyncer — Enriches entity registry with code intelligence data.
+ *
+ * Features:
+ * - Batch enrichment of usedBy, dependencies, keywords via code intelligence
+ * - Incremental sync (mtime-based) and full resync (--full flag)
+ * - Atomic write (temp file + rename) to prevent registry corruption
+ * - Graceful fallback when no provider is available
+ */
+class RegistrySyncer {
+  /**
+   * @param {Object} [options]
+   * @param {string} [options.registryPath] - Path to entity-registry.yaml
+   * @param {string} [options.repoRoot] - Repository root for resolving entity paths
+   * @param {Object} [options.client] - Code intel client (for testing injection)
+   * @param {Function} [options.logger] - Logger function (defaults to console.log)
+   */
+  constructor(options = {}) {
+    this._registryPath = options.registryPath || DEFAULT_REGISTRY_PATH;
+    this._repoRoot = options.repoRoot || path.resolve(__dirname, '../../../');
+    this._client = options.client || null;
+    this._logger = options.logger || console.log;
+    this._stats = { processed: 0, skipped: 0, errors: 0, total: 0 };
+  }
+
+  /**
+   * Get code intel client (lazy, allows injection for testing).
+   * @returns {Object|null}
+   */
+  _getClient() {
+    if (this._client) return this._client;
+    return getClient();
+  }
+
+  /**
+   * Sync the entity registry with code intelligence data.
+   * @param {Object} [options]
+   * @param {boolean} [options.full=false] - Force full resync (ignore lastSynced)
+   * @returns {Promise<Object>} Sync stats
+   */
+  async sync(options = {}) {
+    const isFull = options.full === true;
+
+    // AC5: Fallback — check provider availability first
+    if (!this._isProviderAvailable()) {
+      this._logger('[registry-syncer] No code intelligence provider available, skipping enrichment');
+      return { processed: 0, skipped: 0, errors: 0, total: 0, aborted: true };
+    }
+
+    // Load registry
+    const loader = new RegistryLoader(this._registryPath);
+    const registry = loader.load();
+    const entities = registry.entities || {};
+
+    // Flatten all entities for iteration
+    const allEntities = [];
+    for (const [category, categoryEntities] of Object.entries(entities)) {
+      if (!categoryEntities || typeof categoryEntities !== 'object') continue;
+      for (const [entityId, entityData] of Object.entries(categoryEntities)) {
+        allEntities.push({ id: entityId, category, data: entityData });
+      }
+    }
+
+    this._stats = { processed: 0, skipped: 0, errors: 0, total: allEntities.length };
+    this._logger(`[registry-syncer] Starting ${isFull ? 'full' : 'incremental'} sync of ${allEntities.length} entities`);
+
+    // Iterate and enrich
+    for (const entity of allEntities) {
+      try {
+        const wasProcessed = await this.syncEntity(entity, entities, isFull);
+        if (wasProcessed) {
+          this._stats.processed++;
+        } else {
+          this._stats.skipped++;
+        }
+      } catch (error) {
+        this._stats.errors++;
+        this._logger(`[registry-syncer] Error enriching ${entity.id}: ${error.message}`);
+      }
+    }
+
+    // Update metadata
+    registry.metadata = registry.metadata || {};
+    registry.metadata.lastUpdated = new Date().toISOString();
+    registry.metadata.entityCount = allEntities.length;
+
+    // Atomic write
+    this._atomicWrite(this._registryPath, registry);
+
+    this._logger(`[registry-syncer] Sync complete: ${this._stats.processed} processed, ${this._stats.skipped} skipped, ${this._stats.errors} errors`);
+    return { ...this._stats };
+  }
+
+  /**
+   * Enrich a single entity with code intelligence data.
+   * @param {Object} entity - { id, category, data }
+   * @param {Object} entities - Full entities map (for cross-reference)
+   * @param {boolean} isFull - Force full resync
+   * @returns {Promise<boolean>} true if entity was processed, false if skipped
+   */
+  async syncEntity(entity, entities, isFull) {
+    const { id, data } = entity;
+    const sourcePath = data.path;
+
+    // Skip entities without source path
+    if (!sourcePath) {
+      return false;
+    }
+
+    // AC6: Incremental sync — check mtime vs lastSynced
+    if (!isFull) {
+      const shouldSkip = this._shouldSkipIncremental(data);
+      if (shouldSkip) {
+        return false;
+      }
+    }
+
+    const client = this._getClient();
+    const now = new Date().toISOString();
+
+    // AC2: Populate usedBy via findReferences
+    const usedByIds = await this._findUsedBy(client, id, entities);
+    if (usedByIds !== null) {
+      data.usedBy = usedByIds;
+    }
+
+    // AC3: Populate dependencies via analyzeDependencies (JS/TS files only)
+    const deps = await this._findDependencies(client, sourcePath);
+    if (deps !== null) {
+      data.dependencies = deps;
+    }
+
+    // AC4: Populate codeIntelMetadata
+    const callerCount = Array.isArray(data.usedBy) ? data.usedBy.length : 0;
+    data.codeIntelMetadata = {
+      callerCount,
+      role: inferRole(sourcePath),
+      lastSynced: now,
+      provider: client._activeProvider ? client._activeProvider.name : 'unknown',
+    };
+
+    return true;
+  }
+
+  /**
+   * Check if provider is available.
+   * @returns {boolean}
+   * @private
+   */
+  _isProviderAvailable() {
+    if (this._client) {
+      return typeof this._client.findReferences === 'function';
+    }
+    return isCodeIntelAvailable();
+  }
+
+  /**
+   * Check if entity should be skipped in incremental mode.
+   * @param {Object} entityData
+   * @returns {boolean} true if should skip
+   * @private
+   */
+  _shouldSkipIncremental(entityData) {
+    const metadata = entityData.codeIntelMetadata;
+
+    // Entities without lastSynced are always processed (AC6)
+    if (!metadata || !metadata.lastSynced) {
+      return false;
+    }
+
+    // Get file mtime
+    const sourcePath = entityData.path;
+    if (!sourcePath) return true;
+
+    const fullPath = path.resolve(this._repoRoot, sourcePath);
+    try {
+      const stat = fs.statSync(fullPath);
+      const lastSyncedMs = new Date(metadata.lastSynced).getTime();
+      // Skip if file hasn't changed since last sync
+      return stat.mtimeMs <= lastSyncedMs;
+    } catch (_error) {
+      // File doesn't exist — clear metadata and skip
+      this._logger(`[registry-syncer] Warning: source file not found for ${sourcePath}, skipping`);
+      return true;
+    }
+  }
+
+  /**
+   * Find entities that reference this entity (usedBy).
+   * @param {Object} client - Code intel client
+   * @param {string} entityId - Entity ID to search for
+   * @param {Object} entities - Full entities map for cross-referencing
+   * @returns {Promise<string[]|null>} Array of entity IDs or null on failure
+   * @private
+   */
+  async _findUsedBy(client, entityId, entities) {
+    try {
+      const references = await client.findReferences(entityId);
+      if (!references || !Array.isArray(references)) return null;
+
+      // Cross-reference with registry to get entity IDs
+      const usedByIds = [];
+      for (const ref of references) {
+        const refPath = ref.file || ref.path || ref;
+        if (typeof refPath !== 'string') continue;
+
+        const matchedId = this._findEntityByPath(refPath, entities);
+        if (matchedId && matchedId !== entityId) {
+          usedByIds.push(matchedId);
+        }
+      }
+
+      return [...new Set(usedByIds)]; // Deduplicate
+    } catch (_error) {
+      return null;
+    }
+  }
+
+  /**
+   * Find dependencies of a source file.
+   * @param {Object} client - Code intel client
+   * @param {string} sourcePath - Source file path
+   * @returns {Promise<string[]|null>} Array of dependency names or null on failure
+   * @private
+   */
+  async _findDependencies(client, sourcePath) {
+    // Only analyze JS/TS files for import dependencies
+    if (!sourcePath.match(/\.(js|ts|mjs|cjs)$/)) return null;
+
+    try {
+      const fullPath = path.resolve(this._repoRoot, sourcePath);
+      const result = await client.analyzeDependencies(fullPath);
+      if (!result) return null;
+
+      // Filter to internal project dependencies only
+      const deps = [];
+      const items = result.dependencies || result.imports || result;
+      if (!Array.isArray(items)) return null;
+
+      for (const dep of items) {
+        const depPath = dep.path || dep.source || dep;
+        if (typeof depPath !== 'string') continue;
+        // Internal deps: relative paths or project paths (not node_modules)
+        if (depPath.startsWith('.') || depPath.startsWith('/') || depPath.includes('.aios-core')) {
+          deps.push(depPath);
+        }
+      }
+
+      return deps;
+    } catch (_error) {
+      return null;
+    }
+  }
+
+  /**
+   * Find entity ID by file path (cross-reference lookup).
+   * @param {string} filePath - File path from reference
+   * @param {Object} entities - Full entities map
+   * @returns {string|null} Entity ID or null
+   * @private
+   */
+  _findEntityByPath(filePath, entities) {
+    const normalized = filePath.replace(/\\/g, '/');
+    for (const [_category, categoryEntities] of Object.entries(entities)) {
+      if (!categoryEntities || typeof categoryEntities !== 'object') continue;
+      for (const [entityId, entityData] of Object.entries(categoryEntities)) {
+        if (entityData.path && normalized.includes(entityData.path.replace(/\\/g, '/'))) {
+          return entityId;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Atomic write: write to temp file then rename.
+   * Prevents partial corruption if process crashes mid-write.
+   * @param {string} registryPath - Target path
+   * @param {Object} registry - Registry data to write
+   * @private
+   */
+  _atomicWrite(registryPath, registry) {
+    const tmpPath = registryPath + '.tmp';
+    const content = yaml.dump(registry, { lineWidth: 120, noRefs: true });
+    fs.writeFileSync(tmpPath, content, 'utf8');
+    fs.renameSync(tmpPath, registryPath);
+  }
+
+  /**
+   * Get sync statistics from last run.
+   * @returns {Object}
+   */
+  getStats() {
+    return { ...this._stats };
+  }
+}
+
+module.exports = { RegistrySyncer, inferRole, ROLE_MAP };

package/.aios-core/core/ids/registry-loader.js

@@ -232,6 +232,35 @@ class RegistryLoader {
     return entity;
   }
 
+  /**
+   * Get entity with code intelligence metadata (Story NOG-2).
+   * @param {string} entityId - Entity ID
+   * @returns {Object|null} Entity with codeIntelMetadata or null
+   */
+  getEntityWithIntel(entityId) {
+    const entity = this._findById(entityId);
+    if (!entity) return null;
+    return {
+      ...entity,
+      codeIntelMetadata: entity.codeIntelMetadata || null,
+    };
+  }
+
+  /**
+   * Query entities by keywords with optional role filter (Story NOG-2).
+   * @param {string[]} keywords - Keywords to search
+   * @param {Object} [options]
+   * @param {string} [options.role] - Filter by codeIntelMetadata.role
+   * @returns {Object[]} Matching entities
+   */
+  findByKeyword(keywords, options = {}) {
+    const results = this.queryByKeywords(keywords);
+    if (!options.role) return results;
+    return results.filter(
+      (e) => e.codeIntelMetadata && e.codeIntelMetadata.role === options.role,
+    );
+  }
+
   /**
    * Get registry metadata.
    */

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

@@ -6,7 +6,7 @@ const fs = require('fs');
 /**
  * Resolve runtime dependencies for Synapse hook execution.
  *
- * @param {{cwd?: string, sessionId?: string}} input
+ * @param {{cwd?: string, session_id?: string, sessionId?: string}} input
  * @returns {{
  *   engine: import('../engine').SynapseEngine,
  *   session: Object
@@ -14,7 +14,7 @@ const fs = require('fs');
  */
 function resolveHookRuntime(input) {
   const cwd = input && input.cwd;
-  const sessionId = input && input.sessionId;
+  const sessionId = input && (input.session_id || input.sessionId);
   if (!cwd || typeof cwd !== 'string') return null;
 
   const synapsePath = path.join(cwd, '.synapse');

package/.aios-core/data/entity-registry.yaml

@@ -1,7 +1,7 @@
 metadata:
   version: 1.0.0
-  lastUpdated: '2026-02-16T04:49:07.416Z'
-  entityCount: 506
+  lastUpdated: '2026-02-16T20:22:35.905Z'
+  entityCount: 508
   checksumAlgorithm: sha256
 entities:
   tasks:
@@ -3909,6 +3909,24 @@ entities:
         extensionPoints: []
       checksum: sha256:f7a0bb8fed5663c88ad691b8871fdf7a861b6a7c02599f0c2db3eb9393d353c8
       lastVerified: '2026-02-16T01:21:26.585Z'
+    sync-registry-intel:
+      path: .aios-core/development/tasks/sync-registry-intel.md
+      type: task
+      purpose: 'Task: Sync Registry Intel'
+      keywords:
+        - sync
+        - registry
+        - intel
+        - 'task:'
+      usedBy: []
+      dependencies:
+        - registry-syncer
+      adaptability:
+        score: 0.8
+        constraints: []
+        extensionPoints: []
+      checksum: sha256:0e69435307db814563823896e7ba9b29a4a9c10d90f6dedec5cb7a6d6f7ba936
+      lastVerified: '2026-02-16T20:19:27.659Z'
   templates:
     activation-instructions-inline-greeting:
       path: .aios-core/product/templates/activation-instructions-inline-greeting.yaml
@@ -5979,6 +5997,24 @@ entities:
       checksum: sha256:310884d94b81be976a346987822306a16a73ba812c08c3b805f4a03216ffef38
       lastVerified: '2026-02-15T19:28:17.743Z'
   modules:
+    registry-syncer:
+      path: .aios-core/core/code-intel/registry-syncer.js
+      type: module
+      purpose: Entity at .aios-core\core\code-intel\registry-syncer.js
+      keywords:
+        - registry
+        - syncer
+      usedBy:
+        - sync-registry-intel
+      dependencies:
+        - code-intel
+        - registry-loader
+      adaptability:
+        score: 0.4
+        constraints: []
+        extensionPoints: []
+      checksum: sha256:011318e2ba5c250daae2e565a8e8fb1570c99b7569e631276a2bf46e887fc514
+      lastVerified: '2026-02-16T20:19:27.658Z'
     index.esm:
       path: .aios-core/core/index.esm.js
       type: module
@@ -6562,6 +6598,7 @@ entities:
         - registry
         - loader
       usedBy:
+        - registry-syncer
         - index
         - framework-governor
       dependencies: []
@@ -6569,8 +6606,8 @@ entities:
         score: 0.4
         constraints: []
         extensionPoints: []
-      checksum: sha256:7fb2edb5a605765757d5ca7201025a7ff4cf7bfa9b18f35a311e2b658532a865
-      lastVerified: '2026-02-08T13:33:24.336Z'
+      checksum: sha256:88c67bace0a5ab6a14cb1d096e3f9cab9f5edc0dd8377788e27b692ccefbd487
+      lastVerified: '2026-02-16T20:19:27.659Z'
     manifest-generator:
       path: .aios-core/core/manifest/manifest-generator.js
       type: module
@@ -8536,7 +8573,7 @@ entities:
     hook-runtime:
       path: .aios-core/core/synapse/runtime/hook-runtime.js
       type: module
-      purpose: Entity at .aios-core/core/synapse/runtime/hook-runtime.js
+      purpose: Entity at .aios-core\core\synapse\runtime\hook-runtime.js
       keywords:
         - hook
         - runtime
@@ -8546,8 +8583,8 @@ entities:
         score: 0.4
         constraints: []
         extensionPoints: []
-      checksum: sha256:441bdee8bbfea448f4e20eeb0ff1277352b33e79c9cf6cde9012c6d150fee08b
-      lastVerified: '2026-02-15T19:28:17.742Z'
+      checksum: sha256:2fdd54f36a1bbb4ba05d6577c607cf2d6711dcf9a06284fc935676189a461fa2
+      lastVerified: '2026-02-16T20:22:35.904Z'
     migration-config:
       path: .aios-core/core/migration/migration-config.yaml
       type: module
@@ -8819,8 +8856,8 @@ entities:
         score: 0.3
         constraints: []
         extensionPoints: []
-      checksum: sha256:538fff4398eba7c2492b446fce3a1d9115e5f1c6f494f0c3b45a991526c2295a
-      lastVerified: '2026-02-10T16:04:17.827Z'
+      checksum: sha256:092161d318ab523b8cd5c3dc8a2bd19accc23ab7fa731d5b4fa11c5afb8b5a08
+      lastVerified: '2026-02-16T19:52:18.846Z'
     analyst:
       path: .aios-core/development/agents/analyst.md
       type: agent

package/.aios-core/data/registry-update-log.jsonl

@@ -177,3 +177,15 @@
 {"timestamp":"2026-02-16T01:46:56.302Z","action":"change","path":".aios-core/core/code-intel/code-intel-enricher.js","trigger":"watcher"}
 {"timestamp":"2026-02-16T01:46:56.302Z","action":"change","path":".aios-core/core/code-intel/index.js","trigger":"watcher"}
 {"timestamp":"2026-02-16T01:46:56.303Z","action":"change","path":".aios-core/core/code-intel/providers/code-graph-provider.js","trigger":"watcher"}
+{"timestamp":"2026-02-16T19:52:18.842Z","action":"add","path":".aios-core/core/code-intel/registry-syncer.js","trigger":"watcher"}
+{"timestamp":"2026-02-16T19:52:18.845Z","action":"change","path":".aios-core/core/ids/registry-loader.js","trigger":"watcher"}
+{"timestamp":"2026-02-16T19:52:18.846Z","action":"change","path":".aios-core/development/agents/aios-master.md","trigger":"watcher"}
+{"timestamp":"2026-02-16T19:52:18.847Z","action":"add","path":".aios-core/development/tasks/sync-registry-intel.md","trigger":"watcher"}
+{"timestamp":"2026-02-16T20:19:21.429Z","action":"change","path":".aios-core/core/code-intel/registry-syncer.js","trigger":"watcher"}
+{"timestamp":"2026-02-16T20:19:21.430Z","action":"change","path":".aios-core/core/ids/registry-loader.js","trigger":"watcher"}
+{"timestamp":"2026-02-16T20:19:21.431Z","action":"change","path":".aios-core/development/tasks/sync-registry-intel.md","trigger":"watcher"}
+{"timestamp":"2026-02-16T20:19:27.658Z","action":"change","path":".aios-core/core/code-intel/registry-syncer.js","trigger":"watcher"}
+{"timestamp":"2026-02-16T20:19:27.659Z","action":"change","path":".aios-core/core/ids/registry-loader.js","trigger":"watcher"}
+{"timestamp":"2026-02-16T20:19:27.659Z","action":"change","path":".aios-core/development/tasks/sync-registry-intel.md","trigger":"watcher"}
+{"timestamp":"2026-02-16T20:22:31.161Z","action":"change","path":".aios-core/core/synapse/runtime/hook-runtime.js","trigger":"watcher"}
+{"timestamp":"2026-02-16T20:22:35.904Z","action":"change","path":".aios-core/core/synapse/runtime/hook-runtime.js","trigger":"watcher"}

package/.aios-core/development/agents/aios-master.md

@@ -217,6 +217,11 @@ commands:
   - name: ids stats
     description: 'Registry statistics (entity count by type, categories, health score)'
 
+  # Code Intelligence — Registry Enrichment (Story NOG-2)
+  - name: sync-registry-intel
+    args: '[--full]'
+    description: 'Enrich entity registry with code intelligence data (usedBy, dependencies, codeIntelMetadata). Use --full to force full resync.'
+
 # IDS Pre-Action Hooks (Story IDS-7)
 # These hooks run BEFORE *create and *modify commands as advisory (non-blocking) steps.
 ids_hooks:
@@ -282,6 +287,7 @@ dependencies:
     - run-workflow.md
     - run-workflow-engine.md
     - ids-governor.md
+    - sync-registry-intel.md
   # Delegated tasks (Story 6.1.2.3):
   #   brownfield-create-epic.md → @pm
   #   brownfield-create-story.md → @pm

package/.aios-core/development/tasks/sync-registry-intel.md

@@ -0,0 +1,79 @@
+# Task: Sync Registry Intel
+
+## Metadata
+- **Task ID:** sync-registry-intel
+- **Agent:** @aios-master
+- **Story:** NOG-2
+- **Type:** Command Task
+- **Elicit:** false
+
+---
+
+## Description
+
+Enrich the entity registry with code intelligence data (usedBy, dependencies, codeIntelMetadata) using the configured code intelligence provider.
+
+---
+
+## Prerequisites
+
+- Code intelligence provider available (NOG-1 complete)
+- Entity registry exists at `.aios-core/data/entity-registry.yaml`
+
+---
+
+## Execution Steps
+
+### Step 1: Parse Arguments
+
+```text
+Arguments:
+  --full    Force full resync (reprocess all entities regardless of lastSynced)
+
+Default: Incremental sync (only entities whose source file mtime > lastSynced)
+```
+
+### Step 2: Execute Sync
+
+```javascript
+const { RegistrySyncer } = require('.aios-core/core/code-intel/registry-syncer');
+
+const syncer = new RegistrySyncer();
+const stats = await syncer.sync({ full: hasFullFlag });
+```
+
+### Step 3: Report Results
+
+Display sync statistics:
+- Total entities in registry
+- Entities processed (enriched)
+- Entities skipped (unchanged)
+- Errors encountered
+
+### Step 4: Handle Fallback
+
+If no code intelligence provider is available:
+- Display: "No code intelligence provider available, skipping enrichment"
+- Exit gracefully with zero modifications
+
+---
+
+## Output
+
+```yaml
+success: true
+stats:
+  total: 506
+  processed: 42
+  skipped: 464
+  errors: 0
+```
+
+---
+
+## Error Handling
+
+- **No provider:** Graceful exit, zero modifications
+- **Registry not found:** Error message, exit
+- **Partial failure:** Continue batch, log errors, report count
+- **Write failure:** Atomic write prevents corruption (temp + rename)

package/.aios-core/install-manifest.yaml

@@ -7,10 +7,10 @@
 # - SHA256 hashes for change detection
 # - File types for categorization
 #
-version: 4.2.12
-generated_at: "2026-02-16T18:30:15.483Z"
+version: 4.2.13
+generated_at: "2026-02-16T21:09:06.284Z"
 generator: scripts/generate-install-manifest.js
-file_count: 1004
+file_count: 1006
 files:
   - path: cli/commands/config/index.js
     hash: sha256:ebcad2ce3807eda29dcddff76d7a95ddc9b7fa160df21fd608f94b802237e862
@@ -200,6 +200,10 @@ files:
     hash: sha256:7d16aa715155e9c077720a6bffc7e9e5411b65f821b6b4e5e909f226796e7acb
     type: core
     size: 3079
+  - path: core/code-intel/registry-syncer.js
+    hash: sha256:011318e2ba5c250daae2e565a8e8fb1570c99b7569e631276a2bf46e887fc514
+    type: core
+    size: 10891
   - path: core/config/config-cache.js
     hash: sha256:527a788cbe650aa6b13d1101ebc16419489bfef20b2ee93042f6eb6a51e898e9
     type: core
@@ -565,9 +569,9 @@ files:
     type: core
     size: 26179
   - path: core/ids/registry-loader.js
-    hash: sha256:e98cee3af79091e972b379786345d15ae451afbcba968c10fb3da9bf981bb363
+    hash: sha256:88c67bace0a5ab6a14cb1d096e3f9cab9f5edc0dd8377788e27b692ccefbd487
     type: core
-    size: 7170
+    size: 8096
   - path: core/ids/registry-updater.js
     hash: sha256:6d87ec21d32acff1ba9b9d13025118c106ce6db59c1339c3a6ef4b2a02fd7f52
     type: core
@@ -985,9 +989,9 @@ files:
     type: core
     size: 16418
   - path: core/synapse/runtime/hook-runtime.js
-    hash: sha256:441bdee8bbfea448f4e20eeb0ff1277352b33e79c9cf6cde9012c6d150fee08b
+    hash: sha256:2fdd54f36a1bbb4ba05d6577c607cf2d6711dcf9a06284fc935676189a461fa2
     type: core
-    size: 1529
+    size: 1572
   - path: core/synapse/scripts/generate-constitution.js
     hash: sha256:65405d3e4ee080d19a25fb8967e159360a289e773c15253a351ee163b469e877
     type: script
@@ -1037,9 +1041,9 @@ files:
     type: data
     size: 34251
   - path: data/entity-registry.yaml
-    hash: sha256:7b9bb3a5354107f9ec29105b5948d5c538e2a3b19d49fa42e2e785e4a767c38b
+    hash: sha256:fefd5d2eba3de2c49a3dbf6219cda466062b05a05b894dc2f89886b1f937bd21
     type: data
-    size: 289966
+    size: 291072
   - path: data/learned-patterns.yaml
     hash: sha256:24ac0b160615583a0ff783d3da8af80b7f94191575d6db2054ec8e10a3f945dc
     type: data
@@ -1085,9 +1089,9 @@ files:
     type: development
     size: 5012
   - path: development/agents/aios-master.md
-    hash: sha256:538fff4398eba7c2492b446fce3a1d9115e5f1c6f494f0c3b45a991526c2295a
+    hash: sha256:092161d318ab523b8cd5c3dc8a2bd19accc23ab7fa731d5b4fa11c5afb8b5a08
     type: agent
-    size: 17534
+    size: 17821
   - path: development/agents/analyst.md
     hash: sha256:470384d9ee05d1373fe7519602f135179a88a35895252277823b35339dafd2a3
     type: agent
@@ -2180,6 +2184,10 @@ files:
     hash: sha256:caa2077e7a5bbbba9269b04e878b7772a71422ed6fd138447fe5cfb7345f96fb
     type: task
     size: 23362
+  - path: development/tasks/sync-registry-intel.md
+    hash: sha256:0e69435307db814563823896e7ba9b29a4a9c10d90f6dedec5cb7a6d6f7ba936
+    type: task
+    size: 1664
   - path: development/tasks/tailwind-upgrade.md
     hash: sha256:c369df0a28d8be7f0092405ecaed669a40075841427337990e2346b8c1d43c3a
     type: task

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aios-core",
-  "version": "4.2.12",
+  "version": "4.2.13",
   "description": "Synkra AIOS: AI-Orchestrated System for Full Stack Development - Core Framework",
   "bin": {
     "aios": "bin/aios.js",

package/packages/installer/src/wizard/pro-setup.js

@@ -395,7 +395,34 @@ async function loginWithRetry(client, email) {
       // Activate Pro
       return activateProByAuth(client, loginResult.sessionToken);
     } catch (loginError) {
-      if (loginError.code === 'INVALID_CREDENTIALS') {
+      if (loginError.code === 'EMAIL_NOT_VERIFIED') {
+        // Email not verified — poll by retrying login until verified
+        spinner.info('Email not verified yet. Please check your inbox and click the verification link.');
+        console.log(colors.dim('  (Checking every 5 seconds... timeout in 10 minutes)'));
+
+        const startTime = Date.now();
+        while (Date.now() - startTime < VERIFY_POLL_TIMEOUT_MS) {
+          await new Promise((resolve) => setTimeout(resolve, VERIFY_POLL_INTERVAL_MS));
+          try {
+            const retryLogin = await client.login(email, password);
+            showSuccess('Email verified!');
+            if (!retryLogin.emailVerified) {
+              const verifyResult = await waitForEmailVerification(client, retryLogin.sessionToken, email);
+              if (!verifyResult.success) return verifyResult;
+            }
+            return activateProByAuth(client, retryLogin.sessionToken);
+          } catch (retryError) {
+            if (retryError.code !== 'EMAIL_NOT_VERIFIED') {
+              return { success: false, error: retryError.message };
+            }
+            // Still not verified, continue polling
+          }
+        }
+
+        showError('Email verification timed out after 10 minutes.');
+        showInfo('Run the installer again to retry.');
+        return { success: false, error: 'Email verification timed out.' };
+      } else if (loginError.code === 'INVALID_CREDENTIALS') {
         const remaining = MAX_RETRIES - attempt;
         if (remaining > 0) {
           spinner.fail(`Incorrect password. ${remaining} attempt${remaining > 1 ? 's' : ''} remaining.`);

package/pro/license/license-api.js

@@ -151,7 +151,24 @@ class LicenseApiClient {
         break;
 
       case 401:
-        reject(LicenseActivationError.invalidKey());
+        // Preserve server error code (e.g., INVALID_CREDENTIALS, EMAIL_NOT_VERIFIED)
+        reject(
+          new LicenseActivationError(
+            message || 'Unauthorized',
+            code || 'INVALID_KEY',
+            details,
+          ),
+        );
+        break;
+
+      case 409:
+        reject(
+          new LicenseActivationError(
+            message || 'Conflict',
+            code || 'CONFLICT',
+            details,
+          ),
+        );
         break;
 
       case 403:
@@ -198,11 +215,12 @@ class LicenseApiClient {
         break;
 
       default:
+        // Preserve server error code/message when available
         reject(
           new LicenseActivationError(
-            `Unexpected response: ${statusCode}`,
-            'UNEXPECTED_STATUS',
-            { statusCode, response },
+            message || `Unexpected response: ${statusCode}`,
+            code || 'UNEXPECTED_STATUS',
+            details || { statusCode, response },
           ),
         );
     }
@@ -402,7 +420,10 @@ class LicenseApiClient {
         message: response.message || 'Verification email sent. Please check your inbox.',
       };
     } catch (error) {
-      if (error.code === 'BAD_REQUEST' && error.message.includes('already')) {
+      if (
+        error.code === 'EMAIL_ALREADY_REGISTERED' ||
+        (error.code === 'BAD_REQUEST' && error.message.includes('already'))
+      ) {
         throw AuthError.emailAlreadyRegistered();
       }
       if (error.code === 'RATE_LIMITED') {
@@ -437,7 +458,14 @@ class LicenseApiClient {
         emailVerified: response.emailVerified !== false,
       };
     } catch (error) {
-      if (error.code === 'INVALID_KEY' || error.code === 'BAD_REQUEST') {
+      if (error.code === 'EMAIL_NOT_VERIFIED') {
+        throw AuthError.emailNotVerified();
+      }
+      if (
+        error.code === 'INVALID_KEY' ||
+        error.code === 'INVALID_CREDENTIALS' ||
+        error.code === 'BAD_REQUEST'
+      ) {
         throw AuthError.invalidCredentials();
       }
       if (error.code === 'RATE_LIMITED') {