open-agents-ai 0.138.78 → 0.138.80

package/dist/index.js

@@ -5644,6 +5644,51 @@ async function handleCmd(cmd) {
         break;
       }
 
+      // \u2500\u2500 COHERE distributed learning \u2014 publish insight to mesh \u2500\u2500\u2500\u2500\u2500\u2500
+      case 'cohere_publish_insight': {
+        if (!cohereActive) { writeResp(id, { ok: false, output: 'COHERE not active' }); break; }
+        if (!_natsConn || !_natsCodec) { writeResp(id, { ok: false, output: 'NATS not connected' }); break; }
+        var _cpiInsight = args.insight || '';
+        var _cpiCategory = args.category || 'strategy';
+        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 {}
+          var _cpiDelta = {
+            type: 'cohere.learning',
+            delta_id: 'insight-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 6),
+            source_peer: nexus.peerId,
+            source_agent: agentName,
+            insight: String(_cpiInsight).slice(0, 500),
+            category: _cpiCategory,
+            confidence: _cpiConfidence,
+            model_tier: _cpiTier,
+            timestamp: Date.now(),
+          };
+          _natsConn.publish('nexus.cohere.learning', _natsCodec.encode(JSON.stringify(_cpiDelta)));
+          _cohereStats.queriesSent = (_cohereStats.queriesSent || 0) + 1;
+          _saveStats();
+          dlog('COHERE learning published: ' + _cpiCategory + ' \u2014 ' + String(_cpiInsight).slice(0, 80));
+          writeResp(id, { ok: true, output: 'Insight published to COHERE mesh: ' + _cpiDelta.delta_id });
+        } catch (_cpiErr) {
+          writeResp(id, { ok: false, output: 'Publish error: ' + (_cpiErr.message || _cpiErr) });
+        }
+        break;
+      }
+
       // \u2500\u2500 Metered Inference Exposure \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
       case 'expose': {
         // Clear old inference capabilities before registering new ones
@@ -6846,6 +6891,91 @@ process.on('unhandledRejection', (reason) => {
       })().catch(function(e) { dlog('COHERE claim listener error: ' + (e.message || e)); });
       dlog('COHERE claim listener subscribed to nexus.cohere.claimed');
 
+      // \u2500\u2500 WO-DL1: Learning ingestion \u2014 receive insights from other nodes \u2500\u2500
+      const _learnSub = _natsConn.subscribe('nexus.cohere.learning');
+      (async function() {
+        for await (const _lMsg of _learnSub) {
+          if (!cohereActive) continue;
+          try {
+            var _lData = JSON.parse(_natsCodec.decode(_lMsg.data));
+            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');
+            var _lStore = [];
+            try {
+              if (existsSync(_lStoreFile)) _lStore = JSON.parse(readFileSync(_lStoreFile, 'utf8'));
+            } catch {}
+            // Dedup: skip if we already have this insight (by delta_id)
+            if (_lStore.some(function(m) { return m.id === _lData.delta_id; })) continue;
+            _lStore.push({
+              id: _lData.delta_id,
+              type: 'procedural',
+              content: '[mesh:' + (_lData.source_agent || 'peer').slice(0, 20) + '] ' + _lData.insight,
+              sourceTrace: 'cohere-mesh:' + (_lData.source_peer || '').slice(0, 16),
+              scores: {
+                novelty: 0.7,
+                utility: Math.min(1, _lData.confidence || 0.5),
+                confidence: Math.min(1, (_lData.confidence || 0.5) * 0.8), // discount remote slightly
+                identityRelevance: 0.2,
+              },
+              decision: { action: 'admit', reason: 'Ingested from COHERE mesh peer' },
+              createdAt: new Date().toISOString(),
+              lastAccessedAt: new Date().toISOString(),
+              accessCount: 0,
+            });
+            if (_lStore.length > 100) _lStore = _lStore.slice(-100);
+            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));
+          } catch {}
+        }
+      })().catch(function(e) { dlog('COHERE learning listener error: ' + (e.message || e)); });
+      dlog('COHERE learning listener subscribed to nexus.cohere.learning');
+
       // \u2500\u2500 WO-1.5: Capacity announcement \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
       // Publish what models we have, system metrics, and warm model status
       // so other nodes can make intelligent routing decisions.
@@ -6978,7 +7108,8 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
               "cohere_allow_model",
               "cohere_deny_model",
               "cohere_list_models",
-              "ipfs_add"
+              "ipfs_add",
+              "cohere_publish_insight"
             ],
             description: "The nexus action. MUST call 'connect' first (spawns daemon). Then: join_room, send_message, discover_peers, expose, status, cohere_stats, cohere_enable, cohere_disable, cohere_allow_model, cohere_deny_model, cohere_list_models, ipfs_add, etc."
           },
@@ -7218,6 +7349,13 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             case "ipfs_add":
               result = await this.sendDaemonCmd("ipfs_add", { content: String(args.content ?? args.message ?? "") });
               break;
+            case "cohere_publish_insight":
+              result = await this.sendDaemonCmd("cohere_publish_insight", {
+                insight: String(args.insight ?? args.content ?? ""),
+                category: String(args.category ?? "strategy"),
+                confidence: String(args.confidence ?? "0.7")
+              });
+              break;
             default:
               return { success: false, output: "", error: `Unknown nexus action: ${action}`, durationMs: Date.now() - start };
           }
@@ -58126,6 +58264,42 @@ async function runWithTUI(task, config, repoPath) {
       }
     } catch {
     }
+    try {
+      const cohereSettingsFile = join59(repoRoot, ".oa", "settings.json");
+      let cohereActive = false;
+      try {
+        if (existsSync43(cohereSettingsFile)) {
+          const settings = JSON.parse(readFileSync32(cohereSettingsFile, "utf8"));
+          cohereActive = settings.cohere === true;
+        }
+      } catch {
+      }
+      if (cohereActive) {
+        const metaFile = join59(repoRoot, ".oa", "memory", "metabolism", "store.json");
+        if (existsSync43(metaFile)) {
+          const store = JSON.parse(readFileSync32(metaFile, "utf8"));
+          const latest = store.filter((m) => m.sourceTrace === "trajectory-extraction").slice(-1)[0];
+          if (latest && latest.scores?.confidence >= 0.6) {
+            try {
+              const { NexusTool: NexusTool2 } = __require("@open-agents/execution");
+              const nexus = new NexusTool2(repoRoot);
+              Promise.race([
+                nexus.execute({
+                  action: "cohere_publish_insight",
+                  insight: latest.content,
+                  category: latest.content.startsWith("[recovery]") ? "recovery" : "strategy",
+                  confidence: String(latest.scores.confidence)
+                }),
+                new Promise((r) => setTimeout(r, 2e3))
+              ]).catch(() => {
+              });
+            } catch {
+            }
+          }
+        }
+      }
+    } catch {
+    }
   } catch (err) {
     try {
       const ikFile = join59(repoRoot, ".oa", "identity", "self-state.json");

package/package.json

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