@evomap/evolver 1.31.0 → 1.32.2

package/index.js

@@ -282,7 +282,7 @@ async function main() {
 
       if (res && res.ok && !dryRun) {
         try {
-          const { shouldDistill, prepareDistillation } = require('./src/gep/skillDistiller');
+          const { shouldDistill, prepareDistillation, autoDistill } = require('./src/gep/skillDistiller');
           const { readStateForSolidify } = require('./src/gep/solidify');
           const solidifyState = readStateForSolidify();
           const count = solidifyState.solidify_count || 0;
@@ -290,16 +290,21 @@ async function main() {
           const autoTrigger = count > 0 && count % autoDistillInterval === 0;
 
           if (autoTrigger || shouldDistill()) {
-            const dr = prepareDistillation();
-            if (dr && dr.ok && dr.promptPath) {
-              const trigger = autoTrigger ? `auto (every ${autoDistillInterval} solidifies, count=${count})` : 'threshold';
-              console.log('\n[DISTILL_REQUEST]');
-              console.log(`Distillation triggered: ${trigger}`);
-              console.log('Read the prompt file, process it with your LLM,');
-              console.log('save the LLM response to a file, then run:');
-              console.log('  node index.js distill --response-file=<path_to_llm_response>');
-              console.log('Prompt file: ' + dr.promptPath);
-              console.log('[/DISTILL_REQUEST]');
+            const auto = autoDistill();
+            if (auto && auto.ok && auto.gene) {
+              console.log('[Distiller] Auto-distilled gene: ' + auto.gene.id);
+            } else {
+              const dr = prepareDistillation();
+              if (dr && dr.ok && dr.promptPath) {
+                const trigger = autoTrigger ? `auto (every ${autoDistillInterval} solidifies, count=${count})` : 'threshold';
+                console.log('\n[DISTILL_REQUEST]');
+                console.log(`Distillation triggered: ${trigger}`);
+                console.log('Read the prompt file, process it with your LLM,');
+                console.log('save the LLM response to a file, then run:');
+                console.log('  node index.js distill --response-file=<path_to_llm_response>');
+                console.log('Prompt file: ' + dr.promptPath);
+                console.log('[/DISTILL_REQUEST]');
+              }
             }
           }
         } catch (e) {
@@ -454,7 +459,9 @@ async function main() {
           const s = readJsonSafe(sp);
           if (s && s.last_run) {
             s.last_solidify = { run_id: s.last_run.run_id, rejected: true, timestamp: new Date().toISOString() };
-            fs.writeFileSync(sp, JSON.stringify(s, null, 2));
+            const tmpReject = `${sp}.tmp`;
+            fs.writeFileSync(tmpReject, JSON.stringify(s, null, 2) + '\n', 'utf8');
+            fs.renameSync(tmpReject, sp);
           }
         }
         console.log('[Review] Changes rolled back.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver",
-  "version": "1.31.0",
+  "version": "1.32.2",
   "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": {

package/src/evolve.js

@@ -39,6 +39,8 @@ const { getEvolutionDir } = require('./gep/paths');
 const { shouldReflect, buildReflectionContext, recordReflection } = require('./gep/reflection');
 const { loadNarrativeSummary } = require('./gep/narrativeMemory');
 const { maybeReportIssue } = require('./gep/issueReporter');
+const { resolveStrategy } = require('./gep/strategy');
+const { expandSignals } = require('./gep/learningSignals');
 
 const REPO_ROOT = getRepoRoot();
 
@@ -352,6 +354,73 @@ function readRecentLog(filePath, size = 10000) {
   }
 }
 
+function computeAdaptiveStrategyPolicy(opts) {
+  const recentEvents = Array.isArray(opts && opts.recentEvents) ? opts.recentEvents : [];
+  const selectedGene = opts && opts.selectedGene ? opts.selectedGene : null;
+  const signals = Array.isArray(opts && opts.signals) ? opts.signals : [];
+  const baseStrategy = resolveStrategy({ signals: signals });
+
+  const tail = recentEvents.slice(-8);
+  let repairStreak = 0;
+  for (let i = tail.length - 1; i >= 0; i--) {
+    if (tail[i] && tail[i].intent === 'repair') repairStreak++;
+    else break;
+  }
+  let failureStreak = 0;
+  for (let i = tail.length - 1; i >= 0; i--) {
+    if (tail[i] && tail[i].outcome && tail[i].outcome.status === 'failed') failureStreak++;
+    else break;
+  }
+
+  const antiPatterns = selectedGene && Array.isArray(selectedGene.anti_patterns) ? selectedGene.anti_patterns.slice(-5) : [];
+  const learningHistory = selectedGene && Array.isArray(selectedGene.learning_history) ? selectedGene.learning_history.slice(-6) : [];
+  const signalTags = new Set(expandSignals(signals, ''));
+  const overlappingAntiPatterns = antiPatterns.filter(function (ap) {
+    return ap && Array.isArray(ap.learning_signals) && ap.learning_signals.some(function (tag) {
+      return signalTags.has(String(tag));
+    });
+  });
+  const hardFailures = overlappingAntiPatterns.filter(function (ap) { return ap && ap.mode === 'hard'; }).length;
+  const softFailures = overlappingAntiPatterns.filter(function (ap) { return ap && ap.mode !== 'hard'; }).length;
+  const recentSuccesses = learningHistory.filter(function (x) { return x && x.outcome === 'success'; }).length;
+
+  const stagnation = signals.includes('stable_success_plateau') ||
+    signals.includes('evolution_saturation') ||
+    signals.includes('empty_cycle_loop_detected') ||
+    failureStreak >= 3 ||
+    repairStreak >= 3;
+
+  const forceInnovate = stagnation && !signals.includes('log_error');
+  const highRiskGene = hardFailures >= 1 || (softFailures >= 2 && recentSuccesses === 0);
+  const cautiousExecution = highRiskGene || failureStreak >= 2;
+
+  let blastRadiusMaxFiles = selectedGene && selectedGene.constraints && Number.isFinite(Number(selectedGene.constraints.max_files))
+    ? Number(selectedGene.constraints.max_files)
+    : 12;
+  if (cautiousExecution) blastRadiusMaxFiles = Math.max(2, Math.min(blastRadiusMaxFiles, 6));
+  else if (forceInnovate) blastRadiusMaxFiles = Math.max(3, Math.min(blastRadiusMaxFiles, 10));
+
+  const directives = [];
+  directives.push('Base strategy: ' + baseStrategy.label + ' (' + baseStrategy.description + ')');
+  if (forceInnovate) directives.push('Force strategy shift: prefer innovate over repeating repair/optimize.');
+  if (highRiskGene) directives.push('Selected gene is high risk for current signals; keep blast radius narrow and prefer smallest viable change.');
+  if (failureStreak >= 2) directives.push('Recent failure streak detected; avoid repeating recent failed approach.');
+  directives.push('Target max files for this cycle: ' + blastRadiusMaxFiles + '.');
+
+  return {
+    name: baseStrategy.name,
+    label: baseStrategy.label,
+    description: baseStrategy.description,
+    forceInnovate: forceInnovate,
+    cautiousExecution: cautiousExecution,
+    highRiskGene: highRiskGene,
+    repairStreak: repairStreak,
+    failureStreak: failureStreak,
+    blastRadiusMaxFiles: blastRadiusMaxFiles,
+    directives: directives,
+  };
+}
+
 function checkSystemHealth() {
   const report = [];
   try {
@@ -1279,6 +1348,7 @@ async function run() {
   const newCandidates = extractCapabilityCandidates({
     recentSessionTranscript: recentMasterLog,
     signals,
+    recentFailedCapsules: readRecentFailedCapsules(50),
   });
   for (const c of newCandidates) {
     try {
@@ -1433,6 +1503,11 @@ async function run() {
     ? capsuleCandidates.map(c => (c && c.id ? String(c.id) : null)).filter(Boolean)
     : [];
   const selectedCapsuleId = capsulesUsed.length ? capsulesUsed[0] : null;
+  const strategyPolicy = computeAdaptiveStrategyPolicy({
+    recentEvents,
+    selectedGene,
+    signals,
+  });
 
   // Personality selection (natural selection + small mutation when triggered).
   // This state is persisted in MEMORY_DIR and is treated as an evolution control surface (not role-play).
@@ -1463,9 +1538,9 @@ async function run() {
     tailAvgScore >= 0.7;
   const forceInnovation =
     String(process.env.FORCE_INNOVATION || process.env.EVOLVE_FORCE_INNOVATION || '').toLowerCase() === 'true';
-  const mutationInnovateMode = !!IS_RANDOM_DRIFT || !!innovationPressure || !!forceInnovation;
+  const mutationInnovateMode = !!IS_RANDOM_DRIFT || !!innovationPressure || !!forceInnovation || !!strategyPolicy.forceInnovate;
   const mutationSignals = innovationPressure ? [...(Array.isArray(signals) ? signals : []), 'stable_success_plateau'] : signals;
-  const mutationSignalsEffective = forceInnovation
+  const mutationSignalsEffective = (forceInnovation || strategyPolicy.forceInnovate)
     ? [...(Array.isArray(mutationSignals) ? mutationSignals : []), 'force_innovation']
     : mutationSignals;
 
@@ -1565,10 +1640,13 @@ async function run() {
       console.warn('[SolidifyState] Failed to read git HEAD:', e && e.message || e);
     }
 
-    const maxFiles =
-      selectedGene && selectedGene.constraints && Number.isFinite(Number(selectedGene.constraints.max_files))
-        ? Number(selectedGene.constraints.max_files)
-        : 12;
+    const maxFiles = strategyPolicy && Number.isFinite(Number(strategyPolicy.blastRadiusMaxFiles))
+      ? Number(strategyPolicy.blastRadiusMaxFiles)
+      : (
+        selectedGene && selectedGene.constraints && Number.isFinite(Number(selectedGene.constraints.max_files))
+          ? Number(selectedGene.constraints.max_files)
+          : 12
+      );
     const blastRadiusEstimate = {
       files: Number.isFinite(maxFiles) && maxFiles > 0 ? maxFiles : 0,
       lines: Number.isFinite(maxFiles) && maxFiles > 0 ? Math.round(maxFiles * 80) : 0,
@@ -1602,6 +1680,7 @@ async function run() {
         baseline_untracked: baselineUntracked,
         baseline_git_head: baselineHead,
         blast_radius_estimate: blastRadiusEstimate,
+        strategy_policy: strategyPolicy,
         active_task_id: activeTask ? (activeTask.id || activeTask.task_id || null) : null,
         active_task_title: activeTask ? (activeTask.title || null) : null,
         worker_assignment_id: activeTask ? (activeTask._worker_assignment_id || null) : null,
@@ -1739,6 +1818,7 @@ ${mutationDirective}
         capabilityCandidatesPreview,
         externalCandidatesPreview,
         hubMatchedBlock,
+        strategyPolicy,
         failedCapsules: recentFailedCapsules,
         hubLessons,
       });
@@ -1827,5 +1907,5 @@ ${mutationDirective}
   }
 }
 
-module.exports = { run };
+module.exports = { run, computeAdaptiveStrategyPolicy };
 

package/src/gep/a2aProtocol.js

@@ -305,7 +305,9 @@ function unwrapAssetFromMessage(input) {
 function ensureDir(dir) {
   try {
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  } catch (e) {}
+  } catch (e) {
+    console.warn('[a2aProtocol] ensureDir failed:', dir, e && e.message || e);
+  }
 }
 
 function defaultA2ADir() {
@@ -337,7 +339,9 @@ function fileTransportReceive(opts) {
           if (msg && msg.protocol === PROTOCOL_NAME) messages.push(msg);
         } catch (e) {}
       }
-    } catch (e) {}
+    } catch (e) {
+      console.warn('[a2aProtocol] Failed to read inbox file:', files[fi], e && e.message || e);
+    }
   }
   return messages;
 }
@@ -407,6 +411,8 @@ var _latestNoveltyHint = null;
 var _latestCapabilityGaps = [];
 var _pendingCommitmentUpdates = [];
 var _cachedHubNodeSecret = null;
+var _cachedHubNodeSecretAt = 0;
+var _SECRET_CACHE_TTL_MS = 60000;
 var _heartbeatIntervalMs = 0;
 var _heartbeatRunning = false;
 
@@ -428,7 +434,9 @@ function _persistNodeSecret(secret) {
       fs.mkdirSync(NODE_ID_DIR, { recursive: true, mode: 0o700 });
     }
     fs.writeFileSync(NODE_SECRET_FILE, secret, { encoding: 'utf8', mode: 0o600 });
-  } catch {}
+  } catch (e) {
+    console.warn('[a2aProtocol] Failed to persist node secret:', e && e.message || e);
+  }
 }
 
 function getHubUrl() {
@@ -464,6 +472,7 @@ function sendHelloToHub() {
         || null;
       if (secret && /^[a-f0-9]{64}$/i.test(secret)) {
         _cachedHubNodeSecret = secret;
+        _cachedHubNodeSecretAt = Date.now();
         _persistNodeSecret(secret);
       }
       return { ok: true, response: data };
@@ -473,10 +482,14 @@ function sendHelloToHub() {
 
 function getHubNodeSecret() {
   if (process.env.A2A_NODE_SECRET) return process.env.A2A_NODE_SECRET;
-  if (_cachedHubNodeSecret) return _cachedHubNodeSecret;
+  var now = Date.now();
+  if (_cachedHubNodeSecret && (now - _cachedHubNodeSecretAt) < _SECRET_CACHE_TTL_MS) {
+    return _cachedHubNodeSecret;
+  }
   var persisted = _loadPersistedNodeSecret();
   if (persisted) {
     _cachedHubNodeSecret = persisted;
+    _cachedHubNodeSecretAt = now;
     return persisted;
   }
   if (process.env.A2A_HUB_TOKEN) return process.env.A2A_HUB_TOKEN;
@@ -529,7 +542,9 @@ function sendHeartbeat() {
         meta.env_fingerprint = fp;
         _heartbeatFpSent = true;
       }
-    } catch {}
+    } catch (e) {
+      console.warn('[a2aProtocol] Failed to capture env fingerprint:', e && e.message || e);
+    }
   }
 
   if (Object.keys(meta).length > 0) {

package/src/gep/assetStore.js

@@ -100,7 +100,9 @@ function loadGenes() {
         }
       });
     }
-  } catch(e) {}
+  } catch(e) {
+    console.warn('[AssetStore] Failed to read genes.jsonl:', e && e.message || e);
+  }
 
   // Combine and deduplicate by ID (JSONL takes precedence if newer, but here we just merge)
   const combined = [...jsonGenes, ...jsonlGenes];
@@ -124,7 +126,9 @@ function loadCapsules() {
         }
       });
     }
-  } catch(e) {}
+  } catch(e) {
+    console.warn('[AssetStore] Failed to read capsules.jsonl:', e && e.message || e);
+  }
   
   // Combine and deduplicate by ID
   const combined = [...legacy, ...jsonlCapsules];
@@ -144,7 +148,10 @@ function getLastEventId() {
     if (lines.length === 0) return null;
     const last = JSON.parse(lines[lines.length - 1]);
     return last && typeof last.id === 'string' ? last.id : null;
-  } catch { return null; }
+  } catch (e) {
+    console.warn('[AssetStore] Failed to read last event ID:', e && e.message || e);
+    return null;
+  }
 }
 
 function readAllEvents() {
@@ -155,7 +162,10 @@ function readAllEvents() {
     return raw.split('\n').map(l => l.trim()).filter(Boolean).map(l => {
       try { return JSON.parse(l); } catch { return null; }
     }).filter(Boolean);
-  } catch { return []; }
+  } catch (e) {
+    console.warn('[AssetStore] Failed to read events.jsonl:', e && e.message || e);
+    return [];
+  }
 }
 
 function appendEventJsonl(eventObj) {
@@ -198,7 +208,10 @@ function readRecentCandidates(limit = 20) {
     } finally {
       fs.closeSync(fd);
     }
-  } catch { return []; }
+  } catch (e) {
+    console.warn('[AssetStore] Failed to read candidates.jsonl:', e && e.message || e);
+    return [];
+  }
 }
 
 function readRecentExternalCandidates(limit = 50) {
@@ -225,14 +238,21 @@ function readRecentExternalCandidates(limit = 50) {
     } finally {
       fs.closeSync(fd);
     }
-  } catch { return []; }
+  } catch (e) {
+    console.warn('[AssetStore] Failed to read external_candidates.jsonl:', e && e.message || e);
+    return [];
+  }
 }
 
 // Safety net: ensure schema_version and asset_id are present before writing.
 function ensureSchemaFields(obj) {
   if (!obj || typeof obj !== 'object') return obj;
   if (!obj.schema_version) obj.schema_version = SCHEMA_VERSION;
-  if (!obj.asset_id) { try { obj.asset_id = computeAssetId(obj); } catch (e) {} }
+  if (!obj.asset_id) {
+    try { obj.asset_id = computeAssetId(obj); } catch (e) {
+      console.warn('[AssetStore] Failed to compute asset ID:', e && e.message || e);
+    }
+  }
   return obj;
 }
 
@@ -287,6 +307,7 @@ function readRecentFailedCapsules(limit) {
     var list = Array.isArray(current.failed_capsules) ? current.failed_capsules : [];
     return list.slice(Math.max(0, list.length - n));
   } catch (e) {
+    console.warn('[AssetStore] Failed to read failed_capsules.json:', e && e.message || e);
     return [];
   }
 }

package/src/gep/candidates.js

@@ -1,3 +1,5 @@
+const { expandSignals } = require('./learningSignals');
+
 function stableHash(input) {
   // Deterministic lightweight hash (not cryptographic).
   const s = String(input || '');
@@ -60,13 +62,15 @@ function buildFiveQuestionsShape({ title, signals, evidence }) {
   };
 }
 
-function extractCapabilityCandidates({ recentSessionTranscript, signals }) {
+function extractCapabilityCandidates({ recentSessionTranscript, signals, recentFailedCapsules }) {
   const candidates = [];
+  const signalList = Array.isArray(signals) ? signals : [];
+  const expandedTags = expandSignals(signalList, recentSessionTranscript);
   const toolCalls = extractToolCalls(recentSessionTranscript);
   const freq = countFreq(toolCalls);
 
   for (const [tool, count] of freq.entries()) {
-    if (count < 2) continue;
+    if (count < 3) continue;
     const title = `Repeated tool usage: ${tool}`;
     const evidence = `Observed ${count} occurrences of tool call marker for ${tool}.`;
     const shape = buildFiveQuestionsShape({ title, signals, evidence });
@@ -76,13 +80,13 @@ function extractCapabilityCandidates({ recentSessionTranscript, signals }) {
       title,
       source: 'transcript',
       created_at: new Date().toISOString(),
-      signals: Array.isArray(signals) ? signals : [],
+      signals: signalList,
+      tags: expandedTags,
       shape,
     });
   }
 
   // Signals-as-candidates: capture recurring pain points as reusable capability shapes.
-  const signalList = Array.isArray(signals) ? signals : [];
   const signalCandidates = [
     // Defensive signals
     { signal: 'log_error', title: 'Repair recurring runtime errors' },
@@ -109,10 +113,67 @@ function extractCapabilityCandidates({ recentSessionTranscript, signals }) {
       source: 'signals',
       created_at: new Date().toISOString(),
       signals: signalList,
+      tags: expandedTags,
       shape,
     });
   }
 
+  var failedCapsules = Array.isArray(recentFailedCapsules) ? recentFailedCapsules : [];
+  var groups = {};
+  var problemPriority = [
+    'problem:performance',
+    'problem:protocol',
+    'problem:reliability',
+    'problem:stagnation',
+    'problem:capability',
+  ];
+  for (var i = 0; i < failedCapsules.length; i++) {
+    var fc = failedCapsules[i];
+    if (!fc || fc.outcome && fc.outcome.status === 'success') continue;
+    var reason = String(fc.failure_reason || '').trim();
+    var failureTags = expandSignals((fc.trigger || []).concat(signalList), reason).filter(function (t) {
+      return t.indexOf('problem:') === 0 || t.indexOf('risk:') === 0 || t.indexOf('area:') === 0 || t.indexOf('action:') === 0;
+    });
+    if (failureTags.length === 0) continue;
+    var dominantProblem = null;
+    for (var p = 0; p < problemPriority.length; p++) {
+      if (failureTags.indexOf(problemPriority[p]) !== -1) {
+        dominantProblem = problemPriority[p];
+        break;
+      }
+    }
+    var groupingTags = dominantProblem
+      ? [dominantProblem]
+      : failureTags.filter(function (tag) { return tag.indexOf('area:') === 0 || tag.indexOf('risk:') === 0; }).slice(0, 1);
+    var key = groupingTags.join('|');
+    if (!groups[key]) groups[key] = { count: 0, tags: failureTags, reasons: [], gene: fc.gene || null };
+    groups[key].count += 1;
+    if (reason) groups[key].reasons.push(reason);
+  }
+
+  Object.keys(groups).forEach(function (key) {
+    var group = groups[key];
+    if (!group || group.count < 2) return;
+    var title = 'Learn from recurring failed evolution paths';
+    if (group.tags.indexOf('problem:performance') !== -1) title = 'Resolve recurring performance regressions';
+    else if (group.tags.indexOf('problem:protocol') !== -1) title = 'Prevent recurring protocol and validation regressions';
+    else if (group.tags.indexOf('problem:reliability') !== -1) title = 'Repair recurring reliability failures';
+    else if (group.tags.indexOf('problem:stagnation') !== -1) title = 'Break repeated stagnation loops with a new strategy';
+    else if (group.tags.indexOf('area:orchestration') !== -1) title = 'Stabilize task and orchestration behavior';
+    var evidence = 'Observed ' + group.count + ' recent failed evolutions with similar learning tags. ' +
+      (group.reasons[0] ? 'Latest reason: ' + clip(group.reasons[0], 180) : '');
+    candidates.push({
+      type: 'CapabilityCandidate',
+      id: 'cand_' + stableHash('failed:' + key),
+      title: title,
+      source: 'failed_capsules',
+      created_at: new Date().toISOString(),
+      signals: signalList,
+      tags: group.tags,
+      shape: buildFiveQuestionsShape({ title: title, signals: signalList, evidence: evidence }),
+    });
+  });
+
   // Dedup by id
   const seen = new Set();
   return candidates.filter(c => {
@@ -142,5 +203,6 @@ function renderCandidatesPreview(candidates, maxChars = 1400) {
 module.exports = {
   extractCapabilityCandidates,
   renderCandidatesPreview,
+  expandSignals,
 };
 

package/src/gep/learningSignals.js

@@ -0,0 +1,89 @@
+// Structured learning signal expansion: raw signals -> categorized tags for gene selection and evolution feedback.
+function unique(items) {
+  return Array.from(new Set((Array.isArray(items) ? items : []).filter(Boolean).map(function (x) {
+    return String(x).trim();
+  }).filter(Boolean)));
+}
+
+function add(tags, value) {
+  if (!value) return;
+  tags.push(String(value).trim());
+}
+
+function expandSignals(signals, extraText) {
+  var raw = Array.isArray(signals) ? signals.map(function (s) { return String(s); }) : [];
+  var tags = [];
+
+  for (var i = 0; i < raw.length; i++) {
+    var signal = raw[i];
+    add(tags, signal);
+    var base = signal.split(':')[0];
+    if (base && base !== signal) add(tags, base);
+  }
+
+  var text = (raw.join(' ') + ' ' + String(extraText || '')).toLowerCase();
+
+  if (/(error|exception|failed|unstable|log_error|runtime|429)/.test(text)) {
+    add(tags, 'problem:reliability');
+    add(tags, 'action:repair');
+  }
+  if (/(protocol|prompt|audit|gep|schema|drift)/.test(text)) {
+    add(tags, 'problem:protocol');
+    add(tags, 'action:optimize');
+    add(tags, 'area:prompt');
+  }
+  if (/(perf|performance|bottleneck|latency|slow|throughput)/.test(text)) {
+    add(tags, 'problem:performance');
+    add(tags, 'action:optimize');
+  }
+  if (/(feature|capability_gap|user_feature_request|external_opportunity|stagnation recommendation)/.test(text)) {
+    add(tags, 'problem:capability');
+    add(tags, 'action:innovate');
+  }
+  if (/(stagnation|plateau|steady_state|saturation|empty_cycle_loop|loop_detected|recurring)/.test(text)) {
+    add(tags, 'problem:stagnation');
+    add(tags, 'action:innovate');
+  }
+  if (/(task|worker|heartbeat|hub|commitment|assignment|orchestration)/.test(text)) {
+    add(tags, 'area:orchestration');
+  }
+  if (/(memory|narrative|reflection)/.test(text)) {
+    add(tags, 'area:memory');
+  }
+  if (/(skill|dashboard)/.test(text)) {
+    add(tags, 'area:skills');
+  }
+  if (/(validation|canary|rollback|constraint|blast radius|destructive)/.test(text)) {
+    add(tags, 'risk:validation');
+  }
+
+  return unique(tags);
+}
+
+function geneTags(gene) {
+  if (!gene || typeof gene !== 'object') return [];
+  var inputs = [];
+  if (gene.category) inputs.push('action:' + String(gene.category).toLowerCase());
+  if (Array.isArray(gene.signals_match)) inputs = inputs.concat(gene.signals_match);
+  if (typeof gene.id === 'string') inputs.push(gene.id);
+  if (typeof gene.summary === 'string') inputs.push(gene.summary);
+  return expandSignals(inputs, '');
+}
+
+function scoreTagOverlap(gene, signals) {
+  var signalTags = expandSignals(signals, '');
+  var geneTagList = geneTags(gene);
+  if (signalTags.length === 0 || geneTagList.length === 0) return 0;
+  var signalSet = new Set(signalTags);
+  var hits = 0;
+  for (var i = 0; i < geneTagList.length; i++) {
+    if (signalSet.has(geneTagList[i])) hits++;
+  }
+  return hits;
+}
+
+module.exports = {
+  expandSignals: expandSignals,
+  geneTags: geneTags,
+  scoreTagOverlap: scoreTagOverlap,
+};

package/src/gep/prompt.js

@@ -266,6 +266,7 @@ function buildGepPrompt({
   recentHistory,
   failedCapsules,
   hubLessons,
+  strategyPolicy,
 }) {
   const parentValue = parentEventId ? `"${parentEventId}"` : 'null';
   const selectedGeneId = selectedGene && selectedGene.id ? selectedGene.id : 'gene_<name>';
@@ -289,6 +290,15 @@ ACTIVE STRATEGY (Generic):
 3. Apply minimal, safe changes.
 4. Validate changes strictly.
 5. Solidify knowledge.
+`.trim();
+  }
+  let strategyPolicyBlock = '';
+  if (strategyPolicy && Array.isArray(strategyPolicy.directives) && strategyPolicy.directives.length > 0) {
+    strategyPolicyBlock = `
+ADAPTIVE STRATEGY POLICY:
+${strategyPolicy.directives.map((s, i) => `${i + 1}. ${s}`).join('\n')}
+${strategyPolicy.forceInnovate ? 'You MUST prefer INNOVATE unless a critical blocking error is present.' : ''}
+${strategyPolicy.cautiousExecution ? 'You MUST reduce blast radius and avoid broad refactors in this cycle.' : ''}
 `.trim();
   }
   
@@ -384,6 +394,7 @@ II. Directives & Logic
 
 2. Selection: Selected Gene "${selectedGeneId}".
 ${strategyBlock}
+${strategyPolicyBlock ? '\n' + strategyPolicyBlock : ''}
 
 3. Execution: Apply changes (tool calls). Repair/Optimize: small/reversible. Innovate: new skills in \`skills/<name>/\`.
 4. Validation: Run gene's validation steps. Fail = ROLLBACK.