@evomap/evolver 1.88.0 → 1.88.1

package/index.js

@@ -1332,6 +1332,7 @@ async function main() {
         // Hoist module refs used inside the loop to avoid repeated module lookups per cycle
         const idleScheduler = require('./src/gep/idleScheduler');
         const { shouldDistillFromFailures: shouldDF, autoDistillFromFailures: autoDF } = require('./src/gep/skillDistiller');
+        const { autoDistillLlm } = require('./src/gep/autoDistillLlm'); // P3: autonomous LLM distillation (shadow-first, off by default)
         const { tryExplore } = require('./src/gep/explore');
 
         let currentSleepMs = minSleepMs;
@@ -1454,6 +1455,21 @@ async function main() {
                 } catch (e) {
                   if (isVerbose) console.warn('[OMLS] Distill error: ' + (e.message || e));
                 }
+                // P3: autonomous LLM-quality distillation of SUCCESS capsules.
+                // Default off; shadow logs a candidate; enforce upserts (after a
+                // real run-green gate). Reuses the P1 exec bridge under the hood.
+                if ((process.env.EVOLVER_AUTO_DISTILL_LLM || 'off') !== 'off') {
+                  try {
+                    const llmRes = await autoDistillLlm();
+                    if (llmRes && llmRes.ok && llmRes.gene) {
+                      console.log('[OMLS] Idle-window LLM distillation enforced gene: ' + llmRes.gene.id);
+                    } else if (llmRes && llmRes.reason === 'shadow_logged') {
+                      console.log('[OMLS] LLM distillation shadow candidate: ' + (llmRes.candidate && llmRes.candidate.id));
+                    }
+                  } catch (e) {
+                    if (isVerbose) console.warn('[OMLS] LLM distill error (non-fatal): ' + (e.message || e));
+                  }
+                }
               }
               if (schedule.should_explore) {
                 try {
@@ -1465,6 +1481,22 @@ async function main() {
                   if (isVerbose) console.warn('[OMLS] Explore error: ' + (e.message || e));
                 }
               }
+              // P2: conversation capability -> distilled gene (shadow-only v1).
+              // Deliberately OUTSIDE the should_distill guard: should_distill is
+              // true only at aggressive/deep intensity, but headless/air-gapped
+              // hosts fall back to 'normal', which would make P2 a dead feature.
+              // A freshly-discovered capability is time-relevant; gate it solely on
+              // its own flag + the per-slug cooldown + a non-empty queue (all of
+              // which already bound spend). Default off => zero behavior change.
+              if ((process.env.EVOLVER_CONV_DISTILL_ENABLED || 'off') !== 'off') {
+                try {
+                  const { autoDistillConversation } = require('./src/gep/autoDistillConv');
+                  const convRes = await autoDistillConversation();
+                  if (convRes && convRes.ok) console.log('[P2] conv-distill ' + convRes.mode + ' candidate: ' + (convRes.gene_id || convRes.reason));
+                } catch (e) {
+                  if (isVerbose) console.warn('[P2] conv-distill error (non-fatal): ' + (e.message || e));
+                }
+              }
               if (isVerbose && schedule.idle_seconds >= 0) {
                 console.log(`[OMLS] idle=${schedule.idle_seconds}s intensity=${schedule.intensity} multiplier=${omlsMultiplier}`);
               }
@@ -1691,6 +1723,60 @@ async function main() {
       console.error('[SOLIDIFY] Error:', error);
       process.exit(2);
     }
+  } else if (command === 'exec') {
+    // node index.js exec --harness=claude-code [--once] [--max-cycles N]
+    // P1 auto-exec bridge: run the Brain, scrape its sessions_spawn(...), spawn
+    // the Hand (headless claude) to apply + solidify. Shadow-first opt-in.
+    if (String(process.env.EVOLVE_EXEC_BRIDGE || '').toLowerCase() !== 'true') {
+      console.error('[exec] EVOLVE_EXEC_BRIDGE is not "true". The auto-exec bridge is opt-in. Refusing.');
+      process.exit(2);
+    }
+    const getFlag = (n) => {
+      const i = args.findIndex(a => a === `--${n}` || a.startsWith(`--${n}=`));
+      if (i === -1) return undefined;
+      const h = args[i];
+      if (h.includes('=')) return h.split('=').slice(1).join('='); // --n=value
+      // bare --n: if the next token is a value (not another --flag), consume it
+      // (#179 r6: support `--max-cycles N` space-separated, not just =N). A
+      // trailing bare flag with no following value stays boolean true (e.g. --once).
+      const next = args[i + 1];
+      return (next !== undefined && !next.startsWith('--')) ? next : true;
+    };
+    const harness = String(getFlag('harness') || 'claude-code');
+    const once = getFlag('once') === true;
+    // #179 r7: validate --max-cycles. Number('foo')||0 silently became 0 =
+    // unbounded daemon — a typo must fail fast, not run forever. Absent flag =>
+    // 0 (intentional unbounded). A present value must be a non-negative integer.
+    const rawMaxCycles = getFlag('max-cycles');
+    let maxCycles = 0;
+    if (rawMaxCycles !== undefined && rawMaxCycles !== true) {
+      const n = Number(rawMaxCycles);
+      if (!Number.isInteger(n) || n < 0) {
+        console.error(`[exec] invalid --max-cycles '${rawMaxCycles}' (expected a non-negative integer; 0 or omit = unbounded)`);
+        process.exit(2);
+      }
+      maxCycles = n;
+    } else if (rawMaxCycles === true) {
+      console.error('[exec] --max-cycles requires a value (e.g. --max-cycles 5 or --max-cycles=5)');
+      process.exit(2);
+    }
+    if (!['claude-code', 'openclaw'].includes(harness)) {
+      console.error(`[exec] unknown --harness '${harness}' (expected claude-code | openclaw)`);
+      process.exit(2);
+    }
+    try {
+      const { runExecBridge } = require('./src/gep/execBridge');
+      const res = await runExecBridge({ harness, once, maxCycles });
+      console.log(`[exec] done: cycles=${res.cycles} lastOutcome=${res.lastOutcome}`);
+      // Exit 0 only on a genuine success. A bounded/daemon run that ended in
+      // hand_failed/brain_failed/no_spawn must report non-zero to shells & CI
+      // (Bugbot #179: do not exit 0 on failure just because cycles>0).
+      process.exit(res.lastOutcome === 'success' ? 0 : 1);
+    } catch (error) {
+      console.error('[exec] bridge error:', error && error.message ? error.message : error);
+      process.exit(1);
+    }
+
   } else if (command === 'distill') {
     const responseFileFlag = args.find(a => typeof a === 'string' && a.startsWith('--response-file='));
     if (!responseFileFlag) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver",
-  "version": "1.88.0",
+  "version": "1.88.1",
   "description": "A GEP-powered self-evolution engine for AI agents. Features automated log analysis and Genome Evolution Protocol (GEP) for auditable, reusable evolution assets.",
   "main": "index.js",
   "bin": {