open-agents-ai 0.138.80 → 0.138.81

package/dist/index.js

@@ -5667,6 +5667,21 @@ async function handleCmd(cmd) {
               }
             }
           } 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),
@@ -5676,6 +5691,7 @@ async function handleCmd(cmd) {
             category: _cpiCategory,
             confidence: _cpiConfidence,
             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)));
@@ -6971,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)); });
@@ -7032,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.80",
+  "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",