open-agents-ai 0.138.79 → 0.138.81

package/dist/index.js

@@ -5653,6 +5653,35 @@ async function handleCmd(cmd) {
         var _cpiConfidence = parseFloat(args.confidence || '0.7');
         if (!_cpiInsight) { writeResp(id, { ok: false, output: 'insight text required' }); break; }
         try {
+          // Detect local model tier from warm model
+          var _cpiTier = 'unknown';
+          try {
+            var _cpiOllamaUrl = process.env.OLLAMA_HOST || 'http://localhost:11434';
+            if (_cLastModel) {
+              var _cpiTagsResp = await fetch(_cpiOllamaUrl + '/api/tags');
+              var _cpiTags = await _cpiTagsResp.json();
+              var _cpiModel = (_cpiTags.models || []).find(function(m) { return m.name === _cLastModel; });
+              if (_cpiModel) {
+                var _cpiSizeGB = (_cpiModel.size || 0) / (1024*1024*1024);
+                _cpiTier = _cpiSizeGB >= 20 ? 'large' : _cpiSizeGB >= 5 ? 'medium' : 'small';
+              }
+            }
+          } catch {}
+          // WO-DL4: IPFS pin the insight content for persistence + cross-node retrieval
+          var _cpiCid = null;
+          try {
+            var _cpiHeliaReady = await _ensureHelia();
+            if (_cpiHeliaReady && _heliaFs) {
+              var _cpiBytes = new TextEncoder().encode(JSON.stringify({ insight: _cpiInsight, category: _cpiCategory, confidence: _cpiConfidence, tier: _cpiTier, agent: agentName, ts: Date.now() }));
+              var _cpiCidObj = await _heliaFs.addBytes(_cpiBytes);
+              for await (var _cpiPin of _heliaNode.pins.add(_cpiCidObj)) {}
+              _cpiCid = _cpiCidObj.toString();
+              dlog('IPFS pinned insight: ' + _cpiCid);
+            }
+          } catch (_cpiIpfsErr) {
+            dlog('IPFS pin failed (graceful): ' + (_cpiIpfsErr.message || _cpiIpfsErr));
+          }
+
           var _cpiDelta = {
             type: 'cohere.learning',
             delta_id: 'insight-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 6),
@@ -5661,7 +5690,8 @@ async function handleCmd(cmd) {
             insight: String(_cpiInsight).slice(0, 500),
             category: _cpiCategory,
             confidence: _cpiConfidence,
-            model_tier: 'unknown',
+            model_tier: _cpiTier,
+            cid: _cpiCid,  // null if IPFS unavailable, CID string if pinned
             timestamp: Date.now(),
           };
           _natsConn.publish('nexus.cohere.learning', _natsCodec.encode(JSON.stringify(_cpiDelta)));
@@ -6887,6 +6917,47 @@ process.on('unhandledRejection', (reason) => {
             if (!_lData.insight || !_lData.source_peer) continue;
             // Skip our own insights
             if (_lData.source_peer === nexus.peerId) continue;
+
+            // WO-DL2: Model-tier-aware ingestion filtering
+            // Determine local model tier from warm model size
+            var _lLocalTier = 'unknown';
+            try {
+              var _lOllamaUrl = process.env.OLLAMA_HOST || 'http://localhost:11434';
+              if (_cLastModel) {
+                var _lTagsResp = await fetch(_lOllamaUrl + '/api/tags');
+                var _lTags = await _lTagsResp.json();
+                var _lModel = (_lTags.models || []).find(function(m) { return m.name === _cLastModel; });
+                if (_lModel) {
+                  var _lSizeGB = (_lModel.size || 0) / (1024*1024*1024);
+                  _lLocalTier = _lSizeGB >= 20 ? 'large' : _lSizeGB >= 5 ? 'medium' : 'small';
+                }
+              }
+            } catch {}
+
+            var _lSourceTier = _lData.model_tier || 'unknown';
+            var _lCategory = _lData.category || 'strategy';
+            var _lConfidence = _lData.confidence || 0.5;
+
+            // Tier filtering rules:
+            // - Same or lower tier \u2192 always ingest
+            // - Higher tier \u2192 only if confidence > 0.8 AND category is recovery (model-agnostic)
+            // - Never ingest complex strategies from much larger models to tiny models
+            var _lTierOrder = { 'small': 0, 'medium': 1, 'large': 2, 'unknown': 1 };
+            var _lLocalLevel = _lTierOrder[_lLocalTier] || 1;
+            var _lSourceLevel = _lTierOrder[_lSourceTier] || 1;
+
+            if (_lSourceLevel > _lLocalLevel) {
+              // Insight from a LARGER model \u2014 apply strict filtering
+              if (_lConfidence < 0.8) {
+                dlog('COHERE learning SKIPPED (low confidence from higher tier): ' + _lCategory + ' conf=' + _lConfidence);
+                continue;
+              }
+              if (_lCategory !== 'recovery' && _lCategory !== 'debug_heuristic') {
+                dlog('COHERE learning SKIPPED (non-recovery from higher tier): ' + _lCategory);
+                continue;
+              }
+            }
+
             // Ingest: write to local metabolism store
             var _lStoreDir = join(nexusDir, '..', 'memory', 'metabolism');
             var _lStoreFile = join(_lStoreDir, 'store.json');
@@ -6916,6 +6987,31 @@ process.on('unhandledRejection', (reason) => {
             mkdirSync(_lStoreDir, { recursive: true });
             writeFileSync(_lStoreFile, JSON.stringify(_lStore, null, 2));
             dlog('COHERE learning ingested from ' + (_lData.source_agent || 'unknown') + ': ' + String(_lData.insight).slice(0, 60));
+
+            // WO-DL4: Cross-pin the CID locally if provided (content persistence)
+            if (_lData.cid && _lData.cid.startsWith('bafy')) {
+              try {
+                var _lCidDir = join(nexusDir, 'ipfs', 'cid-registry');
+                mkdirSync(_lCidDir, { recursive: true });
+                var _lCidFile = join(_lCidDir, 'learning-cids.json');
+                var _lCids = {};
+                try { if (existsSync(_lCidFile)) _lCids = JSON.parse(readFileSync(_lCidFile, 'utf8')); } catch {}
+                _lCids[_lData.delta_id] = { cid: _lData.cid, source: _lData.source_agent, pinned: false, timestamp: Date.now() };
+                writeFileSync(_lCidFile, JSON.stringify(_lCids, null, 2));
+                dlog('CID registered: ' + _lData.cid.slice(0, 20) + '... from ' + _lData.source_agent);
+                // Attempt cross-pin if Helia is ready
+                try {
+                  if (_heliaReady && _heliaNode) {
+                    var { CID: CIDClass } = await import('multiformats/cid');
+                    var _lCidObj = CIDClass.parse(_lData.cid);
+                    for await (var _lPin of _heliaNode.pins.add(_lCidObj)) {}
+                    _lCids[_lData.delta_id].pinned = true;
+                    writeFileSync(_lCidFile, JSON.stringify(_lCids, null, 2));
+                    dlog('Cross-pinned CID: ' + _lData.cid.slice(0, 20));
+                  }
+                } catch {}
+              } catch {}
+            }
           } catch {}
         }
       })().catch(function(e) { dlog('COHERE learning listener error: ' + (e.message || e)); });
@@ -6977,6 +7073,69 @@ process.on('unhandledRejection', (reason) => {
         if (cohereActive) _publishCapacityAnnouncement();
       }, 60000);
 
+      // \u2500\u2500 WO-DL3: Epoch sync \u2014 hash-based state comparison every 5 min \u2500\u2500
+      // Each node publishes a lightweight fingerprint of its memory state.
+      // If hashes differ between same-tier nodes, the lagging node can
+      // request missing insights via nexus.cohere.learning.request.
+      var _epochCounter = 0;
+      function _publishEpochSync() {
+        if (!cohereActive || !_natsConn || !_natsCodec) return;
+        try {
+          // Read local memory store for fingerprinting
+          var _esStoreFile = join(nexusDir, '..', 'memory', 'metabolism', 'store.json');
+          var _esStore = [];
+          try { if (existsSync(_esStoreFile)) _esStore = JSON.parse(readFileSync(_esStoreFile, 'utf8')); } catch {}
+
+          // Compute top-10 memory IDs sorted by utility*confidence (deterministic)
+          var _esFiltered = _esStore
+            .filter(function(m) { return m.type !== 'quarantine' && m.scores && m.scores.confidence > 0.15; })
+            .sort(function(a, b) { return (b.scores.utility * b.scores.confidence) - (a.scores.utility * a.scores.confidence); })
+            .slice(0, 10);
+          var _esTopIds = _esFiltered.map(function(m) { return m.id; }).sort().join(',');
+
+          // SHA-256 hash of top-10 IDs for compact comparison
+          var _esHash = require('crypto').createHash('sha256').update(_esTopIds).digest('hex').slice(0, 16);
+
+          _epochCounter++;
+          var _esAnnouncement = {
+            type: 'cohere.epoch',
+            peer: nexus.peerId,
+            agentName: agentName,
+            epoch: _epochCounter,
+            memoryCount: _esStore.length,
+            topHash: _esHash,
+            insightsAvailable: _esFiltered.length,
+            timestamp: Date.now(),
+          };
+          _natsConn.publish('nexus.cohere.learning.epoch', _natsCodec.encode(JSON.stringify(_esAnnouncement)));
+          dlog('Epoch sync published: epoch=' + _epochCounter + ' memories=' + _esStore.length + ' hash=' + _esHash);
+        } catch (e) {
+          dlog('Epoch sync error: ' + (e.message || e));
+        }
+      }
+
+      // Epoch sync every 5 minutes
+      setInterval(function() {
+        if (cohereActive) _publishEpochSync();
+      }, 300000);
+      // Also publish on startup after a brief delay
+      setTimeout(function() { if (cohereActive) _publishEpochSync(); }, 10000);
+
+      // Listen for epoch announcements from other nodes
+      var _epochSub = _natsConn.subscribe('nexus.cohere.learning.epoch');
+      (async function() {
+        for await (var _eMsg of _epochSub) {
+          try {
+            var _eData = JSON.parse(_natsCodec.decode(_eMsg.data));
+            if (!_eData.peer || _eData.peer === nexus.peerId) continue;
+            // Log peer epoch state for dashboard visibility
+            dlog('Epoch from ' + (_eData.agentName || 'peer') + ': epoch=' + _eData.epoch + ' memories=' + _eData.memoryCount + ' hash=' + _eData.topHash);
+            // Future: if our hash differs and they have more insights, request sync
+          } catch {}
+        }
+      })().catch(function(e) { dlog('Epoch listener error: ' + (e.message || e)); });
+      dlog('Epoch sync listener active on nexus.cohere.learning.epoch');
+
       // Lazy-init IPFS in background (non-blocking)
       _ensureHelia().catch(function() {});
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.138.79",
+  "version": "0.138.81",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",