open-agents-ai 0.186.53 → 0.186.55

package/dist/index.js

@@ -9372,20 +9372,138 @@ process.on('unhandledRejection', (reason) => {
             _natsConn.publish('nexus.cohere.kernel.delta', _natsCodec.encode(JSON.stringify({
               type: 'cohere.kernel.delta',
               provider: nexus.peerId,
+              providerName: agentName,
               target: _krData.requestor,
               version: _krState.version,
               delta: _krDelta.slice(-10), // cap at 10 most recent entries
               values: _krState.values_stack || [],
               commitments: _krState.active_commitments || [],
+              specializations: _krState.specializations || [],
+              stats: _krState.stats || {},
               coherence: _krState.homeostasis ? _krState.homeostasis.coherence : 0.5,
               timestamp: Date.now(),
             })));
-            dlog('CM-11c: Sent kernel delta to ' + _krData.requestor.slice(0, 12) + ' (' + _krDelta.length + ' entries)');
+            dlog('CM-11c: Sent kernel delta to ' + _krData.requestor.slice(0, 12) + ' (' + _krDelta.length + ' entries, ' + (_krState.specializations || []).length + ' specs)');
           } catch {}
         }
       })().catch(function() {});
 
-      // CM-11c: Listen for kernel deltas and apply via confidence-weighted voting
+      // \u2550\u2550\u2550 IK-02: Active Peer Delta Merge (CM-11c completion) \u2550\u2550\u2550\u2550\u2550\u2550\u2550
+      // Paper: Collective Constitutional AI (arXiv:2406.07814) \u2014 democratic value convergence
+      // Paper: RLCD (arXiv:2307.12950) \u2014 contrastive alignment
+      // Paper: Emergent Coordination (arXiv:2510.05174) \u2014 measurement of real emergence
+      // Paper: Emergent Social Conventions (arXiv:2410.08948) \u2014 convention formation
+      //
+      // Replaces passive disk storage with active merge.
+      // Selectively adopts: specializations, commitments, values.
+      // Tracks merge provenance in version_history.
+      function _mergeKernelDelta(deltaData) {
+        try {
+          var ikFile = join(nexusDir, '..', 'identity', 'self-state.json');
+          if (!existsSync(ikFile)) return false;
+          var state = JSON.parse(readFileSync(ikFile, 'utf8'));
+          var merged = false;
+          var mergeLog = [];
+
+          var peerCoherence = deltaData.coherence || 0;
+          var peerName = deltaData.providerName || (deltaData.provider || '').slice(0, 12);
+
+          // Emergent Social Conventions: track this peer in relationships
+          if (!state.peer_relationships) state.peer_relationships = {};
+          if (!state.peer_relationships[peerName]) {
+            state.peer_relationships[peerName] = { interactions: 0, deltas_received: 0, trust: 0.5 };
+          }
+          state.peer_relationships[peerName].interactions++;
+          state.peer_relationships[peerName].deltas_received = (state.peer_relationships[peerName].deltas_received || 0) + 1;
+          // Trust increases slightly with each delta exchange
+          state.peer_relationships[peerName].trust = Math.min(1.0, state.peer_relationships[peerName].trust + 0.03);
+
+          // \u2500\u2500 Adopt specializations from peer (EvoSkill zero-shot transfer) \u2500\u2500
+          if (deltaData.specializations && deltaData.specializations.length > 0) {
+            if (!state.specializations) state.specializations = [];
+            for (var si = 0; si < deltaData.specializations.length; si++) {
+              var spec = deltaData.specializations[si];
+              if (state.specializations.indexOf(spec) < 0) {
+                state.specializations.push(spec);
+                merged = true;
+                mergeLog.push('spec:' + spec);
+              }
+            }
+          }
+
+          // \u2500\u2500 Adopt commitments from high-coherence peers (Collective Constitutional AI) \u2500\u2500
+          if (peerCoherence >= 0.85 && deltaData.commitments && deltaData.commitments.length > 0) {
+            if (!state.active_commitments) state.active_commitments = [];
+            for (var ci = 0; ci < deltaData.commitments.length; ci++) {
+              var commitment = deltaData.commitments[ci];
+              if (state.active_commitments.indexOf(commitment) < 0) {
+                state.active_commitments.push(commitment);
+                merged = true;
+                mergeLog.push('commitment:' + commitment);
+              }
+            }
+          }
+
+          // \u2500\u2500 Adopt values from highly trusted peers (RLCD contrastive alignment) \u2500\u2500
+          // Only adopt values we don't already have, and only from peers with coherence > 0.9
+          if (peerCoherence >= 0.9 && deltaData.values && deltaData.values.length > 0) {
+            if (!state.values_stack) state.values_stack = [];
+            for (var vi = 0; vi < deltaData.values.length; vi++) {
+              var value = deltaData.values[vi];
+              if (state.values_stack.indexOf(value) < 0 && state.values_stack.length < 10) {
+                state.values_stack.push(value);
+                merged = true;
+                mergeLog.push('value:' + value);
+              }
+            }
+          }
+
+          // \u2500\u2500 Extract learnings from peer version history \u2500\u2500
+          // Peer's version history entries may contain useful heuristics
+          if (deltaData.delta && deltaData.delta.length > 0) {
+            for (var di = 0; di < deltaData.delta.length; di++) {
+              var entry = deltaData.delta[di];
+              if (!entry.change) continue;
+              // Look for specialization mentions
+              var specMatch = entry.change.match(/specialization[:s]+(S+)/i);
+              if (specMatch && state.specializations && state.specializations.indexOf(specMatch[1]) < 0) {
+                state.specializations.push(specMatch[1]);
+                merged = true;
+                mergeLog.push('spec-from-history:' + specMatch[1]);
+              }
+            }
+          }
+
+          // \u2500\u2500 Update kernel version + history if anything merged \u2500\u2500
+          if (merged) {
+            state.version = (state.version || 0) + 1;
+            if (!state.version_history) state.version_history = [];
+            state.version_history.push({
+              version: state.version,
+              change: 'Merged peer delta from ' + peerName + ' (coherence=' + peerCoherence.toFixed(2) + '): ' + mergeLog.join(', '),
+              timestamp: new Date().toISOString(),
+            });
+            if (state.version_history.length > 200) state.version_history = state.version_history.slice(-200);
+            state.updated_at = new Date().toISOString();
+            writeFileSync(ikFile, JSON.stringify(state, null, 2), 'utf8');
+            dlog('IK-02: MERGED delta from ' + peerName + ' \u2014 [' + mergeLog.join(', ') + '] \u2192 v' + state.version);
+          } else {
+            dlog('IK-02: delta from ' + peerName + ' had nothing new to merge (already synchronized)');
+          }
+
+          // Also update identity via standard _updateIdentity for peer interaction tracking
+          _updateIdentity({ type: 'review_received', outcome: 1.0, details: {
+            peerName: peerName, verdict: 'delta', summary: 'kernel delta merge'
+          }});
+
+          return merged;
+        } catch (e) {
+          dlog('IK-02: merge error: ' + (e.message || e));
+          return false;
+        }
+      }
+
+      // CM-11c: Listen for kernel deltas and ACTIVELY MERGE (replaces passive storage)
       var _kernelDeltaSub = _natsConn.subscribe('nexus.cohere.kernel.delta');
       (async function() {
         for await (var _kdMsg of _kernelDeltaSub) {
@@ -9394,16 +9512,19 @@ process.on('unhandledRejection', (reason) => {
             if (_kdData.target !== nexus.peerId) continue;
             // Only apply high-confidence learnings (coherence > 0.7)
             if ((_kdData.coherence || 0) < 0.7) {
-              dlog('CM-11c: Ignoring low-confidence delta from ' + _kdData.provider.slice(0, 12) + ' (coherence=' + _kdData.coherence + ')');
+              dlog('CM-11c: Ignoring low-confidence delta from ' + (_kdData.providerName || _kdData.provider.slice(0, 12)) + ' (coherence=' + _kdData.coherence + ')');
               continue;
             }
-            // Log received delta \u2014 actual merging would require identity kernel tool
-            dlog('CM-11c: Received kernel delta from ' + _kdData.provider.slice(0, 12) + ': v' + _kdData.version + ', ' + (_kdData.delta || []).length + ' entries, coherence=' + _kdData.coherence);
-            // Store received learnings for offline merge
+            dlog('CM-11c: Received delta from ' + (_kdData.providerName || _kdData.provider.slice(0, 12)) + ': v' + _kdData.version + ', ' + (_kdData.delta || []).length + ' entries, ' + (_kdData.specializations || []).length + ' specs, coherence=' + _kdData.coherence);
+
+            // ACTIVE MERGE (IK-02) \u2014 replaces passive "store to disk" approach
+            _mergeKernelDelta(_kdData);
+
+            // Also store to disk for audit trail
             try {
               var _kdLearnDir = join(nexusDir, '..', 'identity', 'peer-deltas');
               mkdirSync(_kdLearnDir, { recursive: true });
-              writeFileSync(join(_kdLearnDir, _kdData.provider.slice(0, 16) + '.json'), JSON.stringify(_kdData, null, 2), 'utf8');
+              writeFileSync(join(_kdLearnDir, (_kdData.providerName || _kdData.provider.slice(0, 16)) + '.json'), JSON.stringify(_kdData, null, 2), 'utf8');
             } catch {}
           } catch {}
         }
@@ -303115,14 +303236,15 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
             ikState.stats.avg_latency_ms = n2 > 1 ? Math.round(((ikState.stats.avg_latency_ms || 0) * (n2 - 1) + result.durationMs) / n2) : result.durationMs;
             ikState.homeostasis.latency_stress = result.durationMs > 3e4 ? Math.min(1, (ikState.homeostasis.latency_stress || 0) + 0.02) : Math.max(0, (ikState.homeostasis.latency_stress || 0) - 0.01);
           }
-          if (result.toolCalls > 0 && result.summary) {
-            if (/web_search|web_fetch/i.test(result.summary) && !ikState.specializations.includes("web-research")) {
+          if (result.toolCalls > 0) {
+            const toolEvidence = result.summary || "";
+            if (/web_search|web_fetch|searched|search.*web|fetched.*http|url/i.test(toolEvidence) && !ikState.specializations.includes("web-research")) {
               ikState.specializations.push("web-research");
             }
-            if (/shell|grep_search|glob_find/i.test(result.summary) && !ikState.specializations.includes("code-execution")) {
+            if (/shell|grep_search|glob_find|executed.*command/i.test(toolEvidence) && !ikState.specializations.includes("code-execution")) {
               ikState.specializations.push("code-execution");
             }
-            if (/file_write|file_edit/i.test(result.summary) && !ikState.specializations.includes("file-operations")) {
+            if (/file_write|file_edit|wrote.*file|edited.*file/i.test(toolEvidence) && !ikState.specializations.includes("file-operations")) {
               ikState.specializations.push("file-operations");
             }
             ikState.stats.tool_use_count = (ikState.stats.tool_use_count || 0) + result.toolCalls;

package/package.json

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