open-agents-ai 0.186.50 → 0.186.52

package/dist/index.js

@@ -8446,10 +8446,19 @@ process.on('unhandledRejection', (reason) => {
               _saveStats();
 
               dlog('COHERE response: ' + _cData.queryId + ' model=' + _cModel + ' tier=' + ['trivial','moderate','complex','expert'][_cTier] + ' ' + _cLatency + 'ms' + (_cReviewed ? ' (reviewed)' : ''));
+              // IK-01: Update identity on query success
+              _updateIdentity({ type: 'query_served', outcome: 1.0, details: {
+                latencyMs: _cLatency, toolsUsed: _cToolsUsed, model: _cModel,
+                summary: (_cData.query || '').slice(0, 60)
+              }});
             } catch (_cErr) {
               dlog('COHERE inference error: ' + (_cErr.message || _cErr));
               _cohereStats.queriesErrors++;
               _saveStats();
+              // IK-01: Update identity on query failure
+              _updateIdentity({ type: 'query_failed', outcome: 0, details: {
+                error: (_cErr.message || String(_cErr)).slice(0, 100), summary: 'inference error'
+              }});
             }
           } catch (_cParseErr) {
             // Malformed message \u2014 skip
@@ -8552,6 +8561,11 @@ process.on('unhandledRejection', (reason) => {
                 timestamp: Date.now(),
               })));
               dlog('CO-06 review: ' + _dData.queryId + ' verdict=' + _dVerdict + ' model=' + _dReviewModel);
+              // IK-01: Update identity on review given (Emergent Social Conventions)
+              _updateIdentity({ type: 'review_given', outcome: 1.0, details: {
+                peerId: _dData.provider, peerName: _dData.agentName || _dData.provider.slice(0, 12),
+                verdict: _dVerdict, summary: 'reviewed draft for ' + _dData.queryId
+              }});
             } catch (_dRevErr) {
               dlog('CO-06 review error: ' + (_dRevErr.message || _dRevErr));
             }
@@ -8569,6 +8583,11 @@ process.on('unhandledRejection', (reason) => {
             // Store review for the drafter to pick up
             _draftReviews.set(_rData.queryId, _rData);
             dlog('CO-06: review received for ' + _rData.queryId + ' verdict=' + _rData.verdict + ' from ' + (_rData.reviewerAgent || _rData.reviewer.slice(0, 12)));
+            // IK-01: Update identity on review received
+            _updateIdentity({ type: 'review_received', outcome: 1.0, details: {
+              peerId: _rData.reviewer, peerName: _rData.reviewerAgent || _rData.reviewer.slice(0, 12),
+              verdict: _rData.verdict, summary: 'review for ' + _rData.queryId
+            }});
           } catch {}
         }
       })().catch(function() {});
@@ -8654,6 +8673,11 @@ 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));
+            // IK-01: Update identity on learning ingested
+            _updateIdentity({ type: 'learning_ingested', outcome: _lConfidence, details: {
+              category: _lCategory, source: _lData.source_agent,
+              summary: 'ingested ' + _lCategory + ' from ' + (_lData.source_agent || 'peer')
+            }});
 
             // WO-DL4: Cross-pin the CID locally if provided (content persistence)
             if (_lData.cid && _lData.cid.startsWith('bafy')) {
@@ -8843,6 +8867,378 @@ process.on('unhandledRejection', (reason) => {
         if (cohereActive) _publishCapacityAnnouncement();
       }, 60000);
 
+      // \u2550\u2550\u2550 IK-01: Identity Kernel Evolution \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+      // Paper: MemoryOS (arXiv:2506.06326) \u2014 three-tier consolidation
+      // Paper: A-MEM (arXiv:2502.12110) \u2014 retroactive memory refinement
+      // Paper: MemRL (arXiv:2601.03192) \u2014 value-based retrieval
+      // Paper: Memory-R1 (arXiv:2508.19828) \u2014 ADD/UPDATE/DELETE/NOOP ops
+      // Paper: Emergent Social Conventions (arXiv:2410.08948) \u2014 peer tracking
+      // Paper: Spontaneous Individuality (arXiv:2411.03252) \u2014 emergent identity
+      // Paper: EvoSkill (arXiv:2603.02766) \u2014 tool-based specialization discovery
+      //
+      // Called from: query completion, query failure, self-play, learning
+      //              ingestion, review given, review received.
+      function _updateIdentity(event) {
+        try {
+          var ikFile = join(nexusDir, '..', 'identity', 'self-state.json');
+          if (!existsSync(ikFile)) return;
+          var state = JSON.parse(readFileSync(ikFile, 'utf8'));
+
+          // Memory-R1 ADD: Initialize new fields if missing
+          if (!state.stats) state.stats = {
+            queries_served: 0, self_play_cycles: 0, learnings_published: 0,
+            learnings_ingested: 0, reviews_given: 0, reviews_received: 0,
+            avg_latency_ms: 0, tool_use_count: 0,
+          };
+          if (!state.peer_relationships) state.peer_relationships = {};
+          if (!state.specializations) state.specializations = [];
+          if (!state.completed_goals) state.completed_goals = [];
+          if (!state.homeostasis) state.homeostasis = { uncertainty: 0.1, coherence: 1.0, goal_tension: 0.0, memory_trust: 1.0, boundary_breach: 0.0, latency_stress: 0.0 };
+
+          switch (event.type) {
+            case 'query_served':
+              state.stats.queries_served++;
+              // MemoryOS: reduce uncertainty on success (mid\u2192long consolidation)
+              state.homeostasis.uncertainty = Math.max(0, state.homeostasis.uncertainty - 0.01);
+              state.homeostasis.coherence = Math.min(1, state.homeostasis.coherence + 0.005);
+              // Latency stress tracking
+              if (event.details && event.details.latencyMs) {
+                state.homeostasis.latency_stress = event.details.latencyMs > 30000
+                  ? Math.min(1, state.homeostasis.latency_stress + 0.02)
+                  : Math.max(0, state.homeostasis.latency_stress - 0.01);
+                // Running average latency
+                var prevAvg = state.stats.avg_latency_ms || 0;
+                var n = state.stats.queries_served;
+                state.stats.avg_latency_ms = n > 1 ? Math.round((prevAvg * (n - 1) + event.details.latencyMs) / n) : event.details.latencyMs;
+              }
+              // EvoSkill: discover specializations from tool patterns
+              if (event.details && event.details.toolsUsed && event.details.toolsUsed.length > 0) {
+                state.stats.tool_use_count = (state.stats.tool_use_count || 0) + event.details.toolsUsed.length;
+                for (var _ikti = 0; _ikti < event.details.toolsUsed.length; _ikti++) {
+                  var t = event.details.toolsUsed[_ikti];
+                  var spec = (t === 'web_search' || t === 'web_fetch') ? 'web-research'
+                           : (t === 'shell') ? 'code-execution'
+                           : (t === 'file_read' || t === 'file_write' || t === 'file_edit') ? 'file-operations'
+                           : null;
+                  if (spec && state.specializations.indexOf(spec) < 0) {
+                    state.specializations.push(spec);
+                    dlog('IK-01: specialization discovered: ' + spec);
+                  }
+                }
+              }
+              break;
+
+            case 'query_failed':
+              state.stats.queries_served++;
+              state.homeostasis.uncertainty = Math.min(1, state.homeostasis.uncertainty + 0.03);
+              state.homeostasis.coherence = Math.max(0, state.homeostasis.coherence - 0.02);
+              break;
+
+            case 'self_play':
+              state.stats.self_play_cycles++;
+              if (event.outcome >= 0.5) {
+                state.homeostasis.uncertainty = Math.max(0, state.homeostasis.uncertainty - 0.02);
+              } else {
+                state.homeostasis.uncertainty = Math.min(1, state.homeostasis.uncertainty + 0.01);
+              }
+              break;
+
+            case 'learning_ingested':
+              state.stats.learnings_ingested++;
+              state.homeostasis.memory_trust = Math.min(1, state.homeostasis.memory_trust + 0.005);
+              break;
+
+            case 'learning_published':
+              state.stats.learnings_published++;
+              break;
+
+            case 'review_given':
+              state.stats.reviews_given++;
+              // Emergent Social Conventions: track peer relationships
+              if (event.details && event.details.peerName) {
+                var pgn = event.details.peerName;
+                if (!state.peer_relationships[pgn]) state.peer_relationships[pgn] = { interactions: 0, reviews_given: 0, reviews_received: 0, trust: 0.5 };
+                state.peer_relationships[pgn].interactions++;
+                state.peer_relationships[pgn].reviews_given++;
+                state.peer_relationships[pgn].trust = Math.min(1.0, state.peer_relationships[pgn].trust + 0.02);
+              }
+              break;
+
+            case 'review_received':
+              state.stats.reviews_received++;
+              if (event.details && event.details.verdict === 'approved') {
+                state.homeostasis.coherence = Math.min(1, state.homeostasis.coherence + 0.01);
+              } else if (event.details && event.details.verdict === 'corrected') {
+                state.homeostasis.uncertainty = Math.min(1, state.homeostasis.uncertainty + 0.01);
+              }
+              if (event.details && event.details.peerName) {
+                var rpn = event.details.peerName;
+                if (!state.peer_relationships[rpn]) state.peer_relationships[rpn] = { interactions: 0, reviews_given: 0, reviews_received: 0, trust: 0.5 };
+                state.peer_relationships[rpn].interactions++;
+                state.peer_relationships[rpn].reviews_received++;
+                state.peer_relationships[rpn].trust = Math.min(1.0, state.peer_relationships[rpn].trust + 0.02);
+              }
+              break;
+          }
+
+          // \u2500\u2500 Spontaneous Individuality: goal progression from stats, not pre-programmed \u2500\u2500
+          if (state.stats.queries_served >= 10 && state.active_goals && state.active_goals.indexOf('establish-network-identity') >= 0) {
+            state.active_goals = state.active_goals.filter(function(g) { return g !== 'establish-network-identity'; });
+            state.completed_goals.push('establish-network-identity');
+            state.homeostasis.goal_tension = Math.max(0, state.homeostasis.goal_tension - 0.1);
+            dlog('IK-01: goal completed: establish-network-identity');
+          }
+          if (state.stats.reviews_given >= 3 && (!state.completed_goals || state.completed_goals.indexOf('first-peer-review') < 0)) {
+            state.completed_goals.push('first-peer-review');
+            dlog('IK-01: goal completed: first-peer-review');
+          }
+          if (state.stats.self_play_cycles >= 5 && state.active_goals && state.active_goals.indexOf('self-improvement-active') < 0 &&
+              (!state.completed_goals || state.completed_goals.indexOf('self-improvement-active') < 0)) {
+            state.active_goals.push('self-improvement-active');
+            state.homeostasis.goal_tension = Math.min(1, state.homeostasis.goal_tension + 0.03);
+          }
+
+          // \u2500\u2500 A-MEM: Retroactive narrative update every 10 versions \u2500\u2500
+          state.version = (state.version || 0) + 1;
+          if (state.version % 10 === 0) {
+            var specList = (state.specializations || []).join(', ') || 'general-purpose';
+            var peerCount = Object.keys(state.peer_relationships || {}).length;
+            var peerNames = Object.keys(state.peer_relationships || {}).slice(0, 3).join(', ');
+            state.narrative_summary = 'Agent ' + (state.self_id || agentName) +
+              ' \u2014 ' + state.stats.queries_served + ' queries served' +
+              (state.specializations.length > 0 ? ', specializes in ' + specList : '') +
+              (peerCount > 0 ? '. Collaborates with ' + peerNames + ' (' + peerCount + ' peers)' : '') +
+              '. Self-play: ' + state.stats.self_play_cycles + ' cycles' +
+              '. Coherence: ' + state.homeostasis.coherence.toFixed(2) +
+              ', uncertainty: ' + state.homeostasis.uncertainty.toFixed(2) + '.';
+            dlog('IK-01: narrative updated (v' + state.version + '): ' + state.narrative_summary.slice(0, 100));
+          }
+
+          // Memory-R1: Version history with pruning
+          if (!state.version_history) state.version_history = [];
+          state.version_history.push({
+            version: state.version,
+            change: event.type + (event.details && event.details.summary ? ': ' + event.details.summary : ''),
+            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');
+        } catch (e) {
+          dlog('IK-01: update error: ' + (e.message || e));
+        }
+      }
+
+      // \u2550\u2550\u2550 SP-01: Self-Play Idle Loop \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+      // Paper: SPELL (arXiv:2509.23863) three-role self-play (Q/R/V)
+      // Paper: SeRL (arXiv:2505.20347) self-instruction + online filtering
+      // Paper: Sol-Ver (arXiv:2502.14948) solver-verifier dual improvement
+      // Paper: Meta-Rewarding (arXiv:2407.19594) judge saturation prevention
+      // Paper: Exp. Reflective Learning (arXiv:2603.24639) heuristic extraction
+      //
+      // Fires every 90s when idle (no inbound query for >30s).
+      // Routes through AgenticRunner /v1/run with cohere-mesh profile.
+      var _spCycleCount = 0;
+      var _spSuccessCount = 0;
+      var _spScoreHistory = []; // Meta-Rewarding: track last 20 scores for variance check
+      var _spConsecutiveSuccesses = 0;
+      var _spTaskBank = [
+        { q: 'Search the web for the top AI news story today. Summarize in 2 sentences.', verify: 'tool_use', minTools: 1 },
+        { q: 'What is the current price of Bitcoin? Search the web.', verify: 'tool_use', minTools: 1 },
+        { q: 'Find the latest weather forecast for New York City using web search.', verify: 'tool_use', minTools: 1 },
+        { q: 'Explain the difference between TCP and UDP in exactly 3 sentences.', verify: 'length', maxChars: 600 },
+        { q: 'What is the time complexity of merge sort and why?', verify: 'length', maxChars: 800 },
+        { q: 'Compare solar and wind energy: give 2 advantages of each.', verify: 'structure', mustContain: ['solar', 'wind'] },
+        { q: 'List 3 programming languages with pattern matching and explain one example.', verify: 'structure', mustContain: ['match'] },
+      ];
+
+      // SeRL self-instruction: add dynamic tasks from failure patterns
+      function _spGetTask() {
+        var bank = _spTaskBank.slice();
+        try {
+          var storeFile = join(nexusDir, '..', 'memory', 'metabolism', 'store.json');
+          if (existsSync(storeFile)) {
+            var store = JSON.parse(readFileSync(storeFile, 'utf8'));
+            var failures = store.filter(function(m) { return m.type === 'recovery' && m.scores && m.scores.confidence > 0.3; });
+            for (var fi = 0; fi < Math.min(failures.length, 3); fi++) {
+              bank.push({ q: 'Validate: ' + failures[fi].content.slice(0, 150), verify: 'length', maxChars: 1000 });
+            }
+          }
+        } catch {}
+        return bank[Math.floor(Math.random() * bank.length)];
+      }
+
+      // Sol-Ver: Solver-Verifier dual evaluation
+      function _spEvaluate(result, task) {
+        var score = 0;
+        var details = [];
+        var content = (result.output || result.summary || '').trim();
+        if (result.status === 'completed') { score += 0.2; details.push('completed'); }
+        else { details.push('FAIL:' + (result.status || 'unknown')); return { score: 0, details: details }; }
+        // Tool use check
+        var summary = result.summary || '';
+        var hasTools = /tool call/i.test(summary);
+        if (task.verify === 'tool_use') {
+          if (hasTools) { score += 0.4; details.push('tools:yes'); }
+          else { details.push('FAIL:no_tools'); }
+        }
+        // Length check
+        if (task.verify === 'length') {
+          if (content.length > 30 && content.length < (task.maxChars || 2000)) { score += 0.3; details.push('len:' + content.length); }
+          else { details.push('FAIL:length=' + content.length); }
+        }
+        // Structure check
+        if (task.verify === 'structure' && task.mustContain) {
+          var found = 0;
+          for (var ki = 0; ki < task.mustContain.length; ki++) {
+            if (content.toLowerCase().indexOf(task.mustContain[ki]) >= 0) found++;
+          }
+          if (found === task.mustContain.length) { score += 0.3; details.push('keywords:' + found); }
+          else { details.push('FAIL:keywords=' + found + '/' + task.mustContain.length); }
+        }
+        // Quality: non-empty, no error messages
+        if (content.length > 50 && !/[COHERE error]|Backend error/i.test(content.slice(0, 200))) { score += 0.2; details.push('quality:ok'); }
+        else { details.push('FAIL:quality'); }
+        // Latency bonus
+        if (result.durationMs && result.durationMs < 30000) { score += 0.1; details.push('fast:' + result.durationMs + 'ms'); }
+        return { score: Math.min(1.0, score), details: details };
+      }
+
+      // Meta-Rewarding (arXiv:2407.19594): Detect judge saturation
+      function _spCheckMetaJudge() {
+        if (_spScoreHistory.length < 8) return true;
+        var recent = _spScoreHistory.slice(-8);
+        var mean = recent.reduce(function(a, b) { return a + b; }, 0) / recent.length;
+        var variance = recent.reduce(function(a, b) { return a + (b - mean) * (b - mean); }, 0) / recent.length;
+        if (variance < 0.005) {
+          dlog('SP-01: META-JUDGE \u2014 score variance collapsed (' + variance.toFixed(4) + '). Injecting diversity.');
+          _spTaskBank.push(
+            { q: 'Search the web for something unexpected that happened this week.', verify: 'tool_use', minTools: 1 },
+            { q: 'Argue for and against the use of nuclear energy in 4 sentences.', verify: 'length', maxChars: 800 }
+          );
+          _spConsecutiveSuccesses = 0;
+          return false;
+        }
+        return true;
+      }
+
+      // SPELL adaptive curriculum: increase difficulty after consecutive wins
+      function _spAdaptDifficulty(score) {
+        if (score >= 0.7) {
+          _spConsecutiveSuccesses++;
+          if (_spConsecutiveSuccesses >= 3) {
+            _spTaskBank.push(
+              { q: 'Search the web for 2 different sources about a current event and compare their coverage.', verify: 'tool_use', minTools: 2 },
+              { q: 'Find a recent scientific discovery and explain why it matters in simple terms.', verify: 'tool_use', minTools: 1 }
+            );
+            _spConsecutiveSuccesses = 0;
+            dlog('SP-01: SPELL curriculum \u2014 added harder tasks');
+          }
+        } else { _spConsecutiveSuccesses = 0; }
+      }
+
+      // Exp. Reflective Learning (arXiv:2603.24639): Extract heuristic, NOT trajectory
+      function _spPublishLearning(task, result, evaluation) {
+        var summary = result.summary || '';
+        var hasTools = /tool call/i.test(summary);
+        var duration = result.durationMs || 0;
+        var heuristic = '';
+        if (hasTools) {
+          heuristic = 'Tool strategy: web_search effective for "' + task.q.slice(0, 50) + '" (' + Math.round(duration / 1000) + 's, score ' + evaluation.score.toFixed(1) + ')';
+        } else if (evaluation.score >= 0.7) {
+          heuristic = 'Direct answer effective for "' + task.q.slice(0, 50) + '" (no tools needed, score ' + evaluation.score.toFixed(1) + ')';
+        } else { return; }
+        var category = hasTools ? 'web_strategy' : 'reasoning';
+        // Write to metabolism store (ExpeL experience gathering)
+        try {
+          var storeFile = join(nexusDir, '..', 'memory', 'metabolism', 'store.json');
+          var store = [];
+          try { if (existsSync(storeFile)) store = JSON.parse(readFileSync(storeFile, 'utf8')); } catch {}
+          var entryId = 'sp-' + Date.now() + '-' + Math.random().toString(36).slice(2, 6);
+          store.push({
+            id: entryId, type: 'procedural',
+            content: heuristic, sourceTrace: 'self-play:' + agentName,
+            scores: { novelty: 0.6, utility: evaluation.score, confidence: evaluation.score * 0.9, identityRelevance: 0.3 },
+            decision: { action: 'admit', reason: 'Self-play heuristic (score ' + evaluation.score.toFixed(2) + ')' },
+            createdAt: new Date().toISOString(), lastAccessedAt: new Date().toISOString(), accessCount: 0,
+          });
+          // EvoSkill Pareto: keep top 80 by utility*confidence
+          if (store.length > 100) {
+            store.sort(function(a, b) { return (b.scores.utility * b.scores.confidence) - (a.scores.utility * a.scores.confidence); });
+            store = store.slice(0, 80);
+          }
+          mkdirSync(join(nexusDir, '..', 'memory', 'metabolism'), { recursive: true });
+          writeFileSync(storeFile, JSON.stringify(store, null, 2), 'utf8');
+          dlog('SP-01: heuristic stored: ' + heuristic.slice(0, 80));
+        } catch (e) { dlog('SP-01: store error: ' + (e.message || e)); }
+        // Publish to mesh if high confidence
+        if (_natsConn && _natsCodec && evaluation.score >= 0.7) {
+          _natsConn.publish('nexus.cohere.learning', _natsCodec.encode(JSON.stringify({
+            type: 'cohere.learning',
+            delta_id: 'sp-' + Date.now() + '-' + (nexus.peerId || '').slice(0, 8),
+            insight: heuristic, category: category,
+            confidence: evaluation.score, model_tier: 'small',
+            source_peer: nexus.peerId, source_agent: agentName,
+            timestamp: Date.now(),
+          })));
+          dlog('SP-01: learning published to mesh (' + category + ')');
+        }
+      }
+
+      // Main self-play cycle
+      function _selfPlayCycle() {
+        if (!cohereActive) return;
+        if (Date.now() - (_cohereStats.lastQueryAt || 0) < 30000) return;
+        if (!_spCheckMetaJudge()) { dlog('SP-01: skipping (meta-judge diversity injection)'); return; }
+        // AgentCgroup (arXiv:2602.09345): Don't hog resources
+        _collectSysMetrics().then(function(metrics) {
+          if (metrics && metrics.cpu && metrics.cpu.utilization > 80) { dlog('SP-01: skipping (CPU ' + metrics.cpu.utilization + '%)'); return; }
+          _spCycleCount++;
+          var task = _spGetTask();
+          dlog('SP-01: cycle ' + _spCycleCount + ' \u2014 ' + task.q.slice(0, 60));
+          var _spApi = 'http://localhost:11435';
+          fetch(_spApi + '/v1/run', {
+            method: 'POST', headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ task: task.q, max_turns: 4, timeout_s: 45, sandbox: 'none', profile: 'cohere-mesh' }),
+            signal: AbortSignal.timeout(60000),
+          }).then(function(r) { return r.json(); }).then(function(job) {
+            var jobId = job.run_id || job.id;
+            if (!jobId) { dlog('SP-01: no job ID'); return; }
+            var pollN = 0;
+            var poller = setInterval(function() {
+              pollN++;
+              if (pollN > 30) { clearInterval(poller); dlog('SP-01: poll timeout for ' + jobId); return; }
+              fetch(_spApi + '/v1/runs/' + jobId, { signal: AbortSignal.timeout(5000) })
+                .then(function(r) { return r.json(); }).then(function(res) {
+                  if (res.status === 'completed' || res.status === 'failed' || res.status === 'error') {
+                    clearInterval(poller);
+                    var ev = _spEvaluate(res, task);
+                    _spScoreHistory.push(ev.score);
+                    if (_spScoreHistory.length > 20) _spScoreHistory.shift();
+                    _spAdaptDifficulty(ev.score);
+                    if (ev.score >= 0.5) _spSuccessCount++;
+                    dlog('SP-01: result \u2014 score=' + ev.score.toFixed(2) + ' [' + ev.details.join(', ') + '] total=' + _spCycleCount + ' success=' + _spSuccessCount);
+                    // IK-01: Update identity from self-play outcome
+                    _updateIdentity({ type: 'self_play', outcome: ev.score, details: {
+                      task: task.q.slice(0, 60), score: ev.score, summary: 'self-play score ' + ev.score.toFixed(2)
+                    }});
+                    if (ev.score >= 0.6) _spPublishLearning(task, res, ev);
+                  }
+                }).catch(function() {});
+            }, 2000);
+          }).catch(function(err) { dlog('SP-01: error: ' + (err.message || err)); });
+        }).catch(function() {});
+      }
+
+      // Self-play interval: 90s when idle
+      setInterval(function() {
+        if (cohereActive && Date.now() - (_cohereStats.lastQueryAt || 0) > 30000) _selfPlayCycle();
+      }, 90000);
+      // First cycle after 60s startup delay
+      setTimeout(function() { if (cohereActive) _selfPlayCycle(); }, 60000);
+      dlog('SP-01: self-play idle loop initialized (90s interval, SPELL/SeRL/Sol-Ver)');
+
       // \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

package/package.json

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