open-agents-ai 0.138.77 → 0.138.79

package/dist/index.js

@@ -5644,6 +5644,37 @@ 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 {
+          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: 'unknown',
+            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 +6877,50 @@ 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;
+            // 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 +7053,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 +7294,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 };
           }
@@ -54257,7 +54340,7 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
   try {
     const { MemoryMetabolismTool: MemoryMetabolismTool2 } = __require("@open-agents/execution");
     const mm = new MemoryMetabolismTool2(repoRoot);
-    const metabolismMemories = mm.getTopMemoriesSync(5, taskType || void 0);
+    const metabolismMemories = mm.getTopMemoriesSync(2, taskType || void 0);
     if (metabolismMemories) {
       dynamicContext += `
 
@@ -58078,6 +58161,90 @@ async function runWithTUI(task, config, repoPath) {
       }
     } catch {
     }
+    try {
+      const ts = handle.runner?.taskState;
+      if (ts && ts.toolCallCount > 2) {
+        let category = "strategy";
+        let lesson = "";
+        if (ts.failedApproaches && ts.failedApproaches.length > 0) {
+          category = "recovery";
+          const failed = ts.failedApproaches.slice(0, 2).join("; ");
+          const worked = ts.completedSteps?.slice(-2).join(" \u2192 ") || "completed task";
+          lesson = `[recovery] Avoid: ${failed}. Instead: ${worked}`;
+        } else if (ts.completedSteps && ts.completedSteps.length > 1) {
+          lesson = `[strategy] ${ts.completedSteps.slice(-3).join(" \u2192 ")}`;
+        } else {
+          lesson = `[strategy] Solved: ${task.slice(0, 150)}`;
+        }
+        if (lesson) {
+          const metaDir = join59(repoRoot, ".oa", "memory", "metabolism");
+          const storeFile = join59(metaDir, "store.json");
+          let store = [];
+          try {
+            if (existsSync43(storeFile))
+              store = JSON.parse(readFileSync32(storeFile, "utf8"));
+          } catch {
+          }
+          store.push({
+            id: `mem-traj-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+            type: "procedural",
+            content: lesson.slice(0, 500),
+            sourceTrace: "trajectory-extraction",
+            scores: {
+              novelty: 0.6,
+              utility: category === "recovery" ? 0.8 : 0.6,
+              confidence: 0.7,
+              identityRelevance: 0.3
+            },
+            decision: { action: "admit", reason: `Auto-extracted ${category} from task (${ts.toolCallCount} tool calls)` },
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            accessCount: 0
+          });
+          if (store.length > 100)
+            store = store.slice(-100);
+          mkdirSync19(metaDir, { recursive: true });
+          writeFileSync18(storeFile, JSON.stringify(store, null, 2));
+        }
+      }
+    } 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.77",
+  "version": "0.138.79",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",