@evomap/evolver 1.29.8 → 1.29.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver",
-  "version": "1.29.8",
+  "version": "1.29.9",
   "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/gep/skillDistiller.js

@@ -223,32 +223,78 @@ function buildDistillationPrompt(analysis, existingGenes, sampleCapsules) {
   });
 
   return [
-    'You are a Gene synthesis engine for the GEP (Gene Expression Protocol).',
+    'You are a Gene synthesis engine for the GEP (Genome Evolution Protocol).',
+    'Your job is to distill successful evolution capsules into a high-quality, reusable Gene',
+    'that other AI agents can discover, fetch, and execute.',
     '',
-    'Analyze the following successful evolution capsules and extract a reusable Gene.',
+    '## OUTPUT FORMAT',
+    '',
+    'Output ONLY a single valid JSON object (no markdown fences, no explanation).',
+    '',
+    '## GENE ID RULES (CRITICAL)',
+    '',
+    '- The id MUST start with "' + DISTILLED_ID_PREFIX + '" followed by a descriptive kebab-case name.',
+    '- The suffix MUST describe the core capability in 3-6 hyphen-separated words.',
+    '- NEVER include timestamps, numeric IDs, random numbers, tool names (cursor, vscode, etc.), or UUIDs.',
+    '- Good: "gene_distilled_retry-with-exponential-backoff", "gene_distilled_database-migration-rollback"',
+    '- Bad: "gene_distilled_cursor-1773331925711", "gene_distilled_1234567890", "gene_distilled_fix-1"',
+    '',
+    '## SUMMARY RULES',
+    '',
+    '- The "summary" MUST be a clear, human-readable sentence (30-200 chars) describing',
+    '  WHAT capability this Gene provides and WHY it is useful.',
+    '- Write as if for a marketplace listing -- the summary is the first thing other agents see.',
+    '- Good: "Retry failed HTTP requests with exponential backoff, jitter, and circuit breaker to prevent cascade failures"',
+    '- Bad: "Distilled from capsules", "AI agent skill", "cursor automation", "1773331925711"',
+    '- NEVER include timestamps, build numbers, or tool names in the summary.',
+    '',
+    '## SIGNALS_MATCH RULES',
+    '',
+    '- Each signal MUST be a generic, reusable keyword that describes WHEN to trigger this Gene.',
+    '- Use lowercase_snake_case. Signals should be domain terms, not implementation artifacts.',
+    '- NEVER include timestamps, build numbers, tool names, session IDs, or random suffixes.',
+    '- Include 3-7 signals covering both the problem domain and the solution approach.',
+    '- Good: ["http_retry", "request_timeout", "exponential_backoff", "circuit_breaker", "resilience"]',
+    '- Bad: ["cursor_auto_1773331925711", "cli_headless_1773331925711", "bypass_123"]',
+    '',
+    '## STRATEGY RULES',
+    '',
+    '- Strategy steps MUST be actionable, concrete instructions an AI agent can execute.',
+    '- Each step should be a clear imperative sentence starting with a verb.',
+    '- Include 5-10 steps. Each step should be self-contained and specific.',
+    '- Do NOT describe what happened; describe what TO DO.',
+    '- Include rationale or context in parentheses when non-obvious.',
+    '- Where applicable, include inline code examples using backtick notation.',
+    '- Good: "Wrap the HTTP call in a retry loop with `maxRetries=3` and initial delay of 500ms"',
+    '- Bad: "Handle retries", "Fix the issue", "Improve reliability"',
+    '',
+    '## PRECONDITIONS RULES',
+    '',
+    '- List concrete, verifiable conditions that must be true before applying this Gene.',
+    '- Each precondition should be a testable statement, not a vague requirement.',
+    '- Good: "Project uses Node.js >= 18 with ES module support"',
+    '- Bad: "need to fix something"',
+    '',
+    '## CONSTRAINTS',
     '',
-    'RULES:',
-    '- Strategy steps MUST be actionable operations, NOT summaries',
-    '- Each step must be a concrete instruction an AI agent can execute',
-    '- Do NOT describe what happened; describe what TO DO next time',
-    '- The Gene MUST have a unique id starting with "' + DISTILLED_ID_PREFIX + '"',
     '- constraints.max_files MUST be <= ' + DISTILLED_MAX_FILES,
     '- constraints.forbidden_paths MUST include at least [".git", "node_modules"]',
-    '- Output valid Gene JSON only (no markdown, no explanation)',
     '',
-    'GENE ID NAMING RULES (CRITICAL):',
-    '- The id suffix (after "' + DISTILLED_ID_PREFIX + '") MUST be a descriptive kebab-case name',
-    '  derived from the strategy content or signals_match (e.g., "retry-on-timeout", "log-rotation-cleanup")',
-    '- NEVER use timestamps, random numbers, tool names (cursor, vscode, etc.), or UUIDs in the id',
-    '- Good: "gene_distilled_retry-on-timeout", "gene_distilled_cache-invalidation-strategy"',
-    '- Bad: "gene_distilled_cursor-1773331925711", "gene_distilled_1234567890", "gene_distilled_fix-1"',
-    '- The id suffix must be 3+ words separated by hyphens, describing the core capability',
+    '## VALIDATION',
+    '',
+    '- Validation commands MUST start with "node ", "npm ", or "npx " (security constraint).',
+    '- Include commands that actually verify the Gene was applied correctly.',
+    '- Good: "npx tsc --noEmit", "npm test"',
+    '- Bad: "node -v" (proves nothing about the Gene)',
+    '',
+    '## QUALITY BAR',
     '',
-    'SUMMARY RULES:',
-    '- The "summary" field MUST be a clear, human-readable description (10-200 chars)',
-    '- It should describe WHAT the Gene does, not implementation details',
-    '- Good: "Retry failed HTTP requests with exponential backoff and circuit breaker"',
-    '- Bad: "Distilled from capsules", "AI agent skill", "cursor automation"',
+    'Imagine this Gene will be published on a marketplace for thousands of AI agents.',
+    'It should be as professional and useful as a well-written library README.',
+    'Ask yourself: "Would another agent find this Gene by searching for the signals?',
+    'Would the summary make them want to fetch it? Would the strategy be enough to execute?"',
+    '',
+    '---',
     '',
     'SUCCESSFUL CAPSULES (grouped by pattern):',
     JSON.stringify(samples, null, 2),
@@ -260,7 +306,7 @@ function buildDistillationPrompt(analysis, existingGenes, sampleCapsules) {
     JSON.stringify(analysis, null, 2),
     '',
     'Output a single Gene JSON object with these fields:',
-    '{ "type": "Gene", "id": "gene_distilled_<descriptive-kebab-name>", "summary": "<clear human-readable description>", "category": "...", "signals_match": [...], "preconditions": [...], "strategy": [...], "constraints": { "max_files": N, "forbidden_paths": [...] }, "validation": [...] }',
+    '{ "type": "Gene", "id": "gene_distilled_<descriptive-kebab-name>", "summary": "<clear marketplace-quality description>", "category": "repair|optimize|innovate", "signals_match": ["generic_signal_1", ...], "preconditions": ["Concrete condition 1", ...], "strategy": ["Step 1: verb ...", "Step 2: verb ...", ...], "constraints": { "max_files": N, "forbidden_paths": [".git", "node_modules", ...] }, "validation": ["npx tsc --noEmit", ...], "schema_version": "1.6.0" }',
   ].join('\n');
 }
 
@@ -298,6 +344,34 @@ function deriveDescriptiveId(gene) {
   return DISTILLED_ID_PREFIX + unique.slice(0, 5).join('-');
 }
 
+// ---------------------------------------------------------------------------
+// Step 4: sanitizeSignalsMatch -- strip timestamps, random suffixes, tool names
+// ---------------------------------------------------------------------------
+function sanitizeSignalsMatch(signals) {
+  if (!Array.isArray(signals)) return [];
+  var cleaned = [];
+  signals.forEach(function (s) {
+    var sig = String(s || '').trim().toLowerCase();
+    if (!sig) return;
+    // Strip trailing timestamps (10+ digits) and random suffixes
+    sig = sig.replace(/[_-]\d{10,}$/g, '');
+    // Strip leading/trailing underscores/hyphens left over
+    sig = sig.replace(/^[_-]+|[_-]+$/g, '');
+    // Reject signals that are purely numeric
+    if (/^\d+$/.test(sig)) return;
+    // Reject signals that are just a tool name with optional number
+    if (/^(cursor|vscode|vim|emacs|windsurf|copilot|cline|codex|bypass|distill)[_-]?\d*$/i.test(sig)) return;
+    // Reject signals shorter than 3 chars after cleaning
+    if (sig.length < 3) return;
+    // Reject signals that still contain long numeric sequences (session IDs, etc.)
+    if (/\d{8,}/.test(sig)) return;
+    cleaned.push(sig);
+  });
+  // Deduplicate
+  var seen = {};
+  return cleaned.filter(function (s) { if (seen[s]) return false; seen[s] = true; return true; });
+}
+
 // ---------------------------------------------------------------------------
 // Step 4: validateSynthesizedGene
 // ---------------------------------------------------------------------------
@@ -311,16 +385,34 @@ function validateSynthesizedGene(gene, existingGenes) {
   if (!Array.isArray(gene.signals_match) || gene.signals_match.length === 0) errors.push('missing or empty signals_match');
   if (!Array.isArray(gene.strategy) || gene.strategy.length === 0) errors.push('missing or empty strategy');
 
+  // --- Signals sanitization (BEFORE id derivation so deriveDescriptiveId uses clean signals) ---
+  if (Array.isArray(gene.signals_match)) {
+    gene.signals_match = sanitizeSignalsMatch(gene.signals_match);
+    if (gene.signals_match.length === 0) {
+      errors.push('signals_match is empty after sanitization (all signals were invalid)');
+    }
+  }
+
+  // --- Summary sanitization (BEFORE id derivation so deriveDescriptiveId uses clean summary) ---
+  if (gene.summary) {
+    gene.summary = gene.summary.replace(/\s*\d{10,}\s*$/g, '').replace(/\.\s*\d{10,}/g, '.').trim();
+  }
+
+  // --- ID sanitization ---
   if (gene.id && !String(gene.id).startsWith(DISTILLED_ID_PREFIX)) {
     gene.id = DISTILLED_ID_PREFIX + String(gene.id).replace(/^gene_/, '');
   }
 
   if (gene.id) {
     var suffix = String(gene.id).replace(DISTILLED_ID_PREFIX, '');
+    // Strip ALL embedded timestamps (10+ digit sequences) anywhere in the id
+    suffix = suffix.replace(/[-_]?\d{10,}[-_]?/g, '-').replace(/[-_]+/g, '-').replace(/^[-_]+|[-_]+$/g, '');
     var needsRename = /^\d+$/.test(suffix) || /^\d{10,}/.test(suffix)
-      || /^(cursor|vscode|vim|emacs|windsurf|copilot|cline|codex)[-_]?\d*/i.test(suffix);
+      || /^(cursor|vscode|vim|emacs|windsurf|copilot|cline|codex)[-_]?\d*$/i.test(suffix);
     if (needsRename) {
       gene.id = deriveDescriptiveId(gene);
+    } else {
+      gene.id = DISTILLED_ID_PREFIX + suffix;
     }
     var cleanSuffix = String(gene.id).replace(DISTILLED_ID_PREFIX, '');
     if (cleanSuffix.replace(/[-_]/g, '').length < 6) {
@@ -328,6 +420,7 @@ function validateSynthesizedGene(gene, existingGenes) {
     }
   }
 
+  // --- Summary fallback (summary was already sanitized above, this handles missing/short) ---
   if (!gene.summary || typeof gene.summary !== 'string' || gene.summary.length < 10) {
     if (Array.isArray(gene.strategy) && gene.strategy.length > 0) {
       gene.summary = String(gene.strategy[0]).slice(0, 200);
@@ -336,6 +429,12 @@ function validateSynthesizedGene(gene, existingGenes) {
     }
   }
 
+  // --- Strategy quality: require minimum 3 steps ---
+  if (Array.isArray(gene.strategy) && gene.strategy.length < 3) {
+    errors.push('strategy must have at least 3 steps for a quality skill');
+  }
+
+  // --- Constraints ---
   if (!gene.constraints || typeof gene.constraints !== 'object') gene.constraints = {};
   if (!Array.isArray(gene.constraints.forbidden_paths) || gene.constraints.forbidden_paths.length === 0) {
     gene.constraints.forbidden_paths = ['.git', 'node_modules'];
@@ -347,6 +446,7 @@ function validateSynthesizedGene(gene, existingGenes) {
     gene.constraints.max_files = DISTILLED_MAX_FILES;
   }
 
+  // --- Validation command sanitization ---
   var ALLOWED_PREFIXES = ['node ', 'npm ', 'npx '];
   if (Array.isArray(gene.validation)) {
     gene.validation = gene.validation.filter(function (cmd) {
@@ -359,11 +459,16 @@ function validateSynthesizedGene(gene, existingGenes) {
     });
   }
 
+  // --- Schema version ---
+  if (!gene.schema_version) gene.schema_version = '1.6.0';
+
+  // --- Duplicate ID check ---
   var existingIds = new Set((existingGenes || []).map(function (g) { return g.id; }));
   if (gene.id && existingIds.has(gene.id)) {
     gene.id = gene.id + '_' + Date.now().toString(36);
   }
 
+  // --- Signal overlap check ---
   if (gene.signals_match && existingGenes && existingGenes.length > 0) {
     var newSet = new Set(gene.signals_match.map(function (s) { return String(s).toLowerCase(); }));
     for (var i = 0; i < existingGenes.length; i++) {
@@ -566,6 +671,7 @@ module.exports = {
   prepareDistillation: prepareDistillation,
   completeDistillation: completeDistillation,
   validateSynthesizedGene: validateSynthesizedGene,
+  sanitizeSignalsMatch: sanitizeSignalsMatch,
   shouldDistill: shouldDistill,
   buildDistillationPrompt: buildDistillationPrompt,
   extractJsonFromLlmResponse: extractJsonFromLlmResponse,

package/src/gep/skillPublisher.js

@@ -3,54 +3,90 @@
 var { getHubUrl, buildHubHeaders, getNodeId } = require('./a2aProtocol');
 
 /**
- * Convert a Gene object into SKILL.md format (Claude/Anthropic style).
- *
- * @param {object} gene - Gene asset
- * @returns {string} SKILL.md content
+ * Sanitize a raw gene id into a human-readable kebab-case skill name.
+ * Returns null if the name is unsalvageable (pure numbers, tool name, etc.).
  */
 function sanitizeSkillName(rawName) {
   var name = rawName.replace(/[\r\n]+/g, '-').replace(/^gene_distilled_/, '').replace(/^gene_/, '').replace(/_/g, '-');
+  // Strip ALL embedded timestamps (10+ digit sequences) anywhere in the name
+  name = name.replace(/-?\d{10,}-?/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
   if (/^\d{8,}/.test(name) || /^(cursor|vscode|vim|emacs|windsurf|copilot|cline|codex)[-]?\d*$/i.test(name)) {
     return null;
   }
-  name = name.replace(/-?\d{10,}$/g, '').replace(/-+$/, '');
   if (name.replace(/[-]/g, '').length < 6) return null;
   return name;
 }
 
-function geneToSkillMd(gene) {
-  var rawName = gene.id || 'unnamed-skill';
-  var name = sanitizeSkillName(rawName);
-  if (!name) {
-    var fallbackWords = [];
-    if (Array.isArray(gene.signals_match)) {
-      gene.signals_match.slice(0, 3).forEach(function (s) {
-        String(s).toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim().split(/\s+/).forEach(function (w) {
-          if (w.length >= 3 && fallbackWords.length < 5) fallbackWords.push(w);
-        });
-      });
-    }
-    if (fallbackWords.length < 2 && gene.summary) {
-      String(gene.summary).toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim().split(/\s+/).forEach(function (w) {
-        if (w.length >= 3 && fallbackWords.length < 5) fallbackWords.push(w);
+/**
+ * Derive a Title Case display name from a kebab-case skill name.
+ * "retry-with-backoff" -> "Retry With Backoff"
+ */
+function toTitleCase(kebabName) {
+  return kebabName.split('-').map(function (w) {
+    if (!w) return '';
+    return w.charAt(0).toUpperCase() + w.slice(1);
+  }).join(' ');
+}
+
+/**
+ * Derive fallback name words from gene signals/summary when id is not usable.
+ */
+function deriveFallbackName(gene) {
+  var fallbackWords = [];
+  var STOP = new Set(['the', 'and', 'for', 'with', 'from', 'that', 'this', 'into', 'when', 'are', 'was', 'has', 'had', 'not', 'but', 'its']);
+  if (Array.isArray(gene.signals_match)) {
+    gene.signals_match.slice(0, 3).forEach(function (s) {
+      String(s).toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim().split(/\s+/).forEach(function (w) {
+        if (w.length >= 3 && !STOP.has(w) && fallbackWords.length < 5) fallbackWords.push(w);
       });
-    }
-    var seen = {};
-    fallbackWords = fallbackWords.filter(function (w) { if (seen[w]) return false; seen[w] = true; return true; });
-    name = fallbackWords.length >= 2 ? fallbackWords.join('-') : 'auto-distilled-skill';
+    });
+  }
+  if (fallbackWords.length < 2 && gene.summary) {
+    String(gene.summary).toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim().split(/\s+/).forEach(function (w) {
+      if (w.length >= 3 && !STOP.has(w) && fallbackWords.length < 5) fallbackWords.push(w);
+    });
   }
-  var desc = (gene.summary || 'AI agent skill distilled from evolution experience.').replace(/[\r\n]+/g, ' ').trim();
+  var seen = {};
+  fallbackWords = fallbackWords.filter(function (w) { if (seen[w]) return false; seen[w] = true; return true; });
+  return fallbackWords.length >= 2 ? fallbackWords.join('-') : 'auto-distilled-skill';
+}
+
+/**
+ * Convert a Gene object into SKILL.md format -- marketplace-quality content.
+ *
+ * @param {object} gene - Gene asset
+ * @returns {string} SKILL.md content
+ */
+function geneToSkillMd(gene) {
+  var rawName = gene.id || 'unnamed-skill';
+  var name = sanitizeSkillName(rawName) || deriveFallbackName(gene);
+  var displayName = toTitleCase(name);
+  var desc = (gene.summary || '').replace(/[\r\n]+/g, ' ').replace(/\s*\d{10,}\s*$/g, '').trim();
+  if (!desc || desc.length < 10) desc = 'AI agent skill distilled from evolution experience.';
 
   var lines = [
     '---',
-    'name: ' + name,
+    'name: ' + displayName,
     'description: ' + desc,
     '---',
     '',
-    '# ' + name,
+    '# ' + displayName,
+    '',
+    desc,
     '',
   ];
 
+  // -- When to Use (derived from signals; preconditions go in their own section) --
+  if (gene.signals_match && gene.signals_match.length > 0) {
+    lines.push('## When to Use');
+    lines.push('');
+    lines.push('- When your project encounters: ' + gene.signals_match.slice(0, 4).map(function (s) {
+      return '`' + s + '`';
+    }).join(', '));
+    lines.push('');
+  }
+
+  // -- Trigger Signals --
   if (gene.signals_match && gene.signals_match.length > 0) {
     lines.push('## Trigger Signals');
     lines.push('');
@@ -60,6 +96,7 @@ function geneToSkillMd(gene) {
     lines.push('');
   }
 
+  // -- Preconditions --
   if (gene.preconditions && gene.preconditions.length > 0) {
     lines.push('## Preconditions');
     lines.push('');
@@ -69,27 +106,36 @@ function geneToSkillMd(gene) {
     lines.push('');
   }
 
+  // -- Strategy --
   if (gene.strategy && gene.strategy.length > 0) {
     lines.push('## Strategy');
     lines.push('');
     gene.strategy.forEach(function (step, i) {
-      lines.push((i + 1) + '. ' + step);
+      var text = String(step);
+      var verb = extractStepVerb(text);
+      if (verb) {
+        lines.push((i + 1) + '. **' + verb + '** -- ' + stripLeadingVerb(text));
+      } else {
+        lines.push((i + 1) + '. ' + text);
+      }
     });
     lines.push('');
   }
 
+  // -- Constraints --
   if (gene.constraints) {
     lines.push('## Constraints');
     lines.push('');
     if (gene.constraints.max_files) {
-      lines.push('- Max files: ' + gene.constraints.max_files);
+      lines.push('- Max files per invocation: ' + gene.constraints.max_files);
     }
     if (gene.constraints.forbidden_paths && gene.constraints.forbidden_paths.length > 0) {
-      lines.push('- Forbidden paths: ' + gene.constraints.forbidden_paths.join(', '));
+      lines.push('- Forbidden paths: ' + gene.constraints.forbidden_paths.map(function (p) { return '`' + p + '`'; }).join(', '));
     }
     lines.push('');
   }
 
+  // -- Validation --
   if (gene.validation && gene.validation.length > 0) {
     lines.push('## Validation');
     lines.push('');
@@ -101,6 +147,16 @@ function geneToSkillMd(gene) {
     });
   }
 
+  // -- Metadata --
+  lines.push('## Metadata');
+  lines.push('');
+  lines.push('- Category: `' + (gene.category || 'innovate') + '`');
+  lines.push('- Schema version: `' + (gene.schema_version || '1.6.0') + '`');
+  if (gene._distilled_meta && gene._distilled_meta.source_capsule_count) {
+    lines.push('- Distilled from: ' + gene._distilled_meta.source_capsule_count + ' successful capsules');
+  }
+  lines.push('');
+
   lines.push('---');
   lines.push('');
   lines.push('*This Skill was generated by [Evolver](https://github.com/autogame-17/evolver) and is distributed under the [EvoMap Skill License (ESL-1.0)](https://evomap.ai/terms). Unauthorized redistribution, bulk scraping, or republishing is prohibited. See LICENSE file for full terms.*');
@@ -109,6 +165,31 @@ function geneToSkillMd(gene) {
   return lines.join('\n');
 }
 
+/**
+ * Extract the leading verb from a strategy step for bolding.
+ * Only extracts a single verb to avoid splitting compound phrases.
+ * e.g. "Verify Cursor CLI installation" -> "Verify"
+ *      "Run `npm test` to check" -> "Run"
+ *      "Configure non-interactive mode" -> "Configure"
+ */
+function extractStepVerb(step) {
+  // Only match a capitalized verb at the very start (no leading backtick/special chars)
+  var match = step.match(/^([A-Z][a-z]+)/);
+  return match ? match[1] : '';
+}
+
+/**
+ * Remove the leading verb from a step (already shown in bold).
+ */
+function stripLeadingVerb(step) {
+  var verb = extractStepVerb(step);
+  if (verb && step.startsWith(verb)) {
+    var rest = step.slice(verb.length).replace(/^[\s:.\-]+/, '');
+    return rest || step;
+  }
+  return step;
+}
+
 /**
  * Publish a Gene as a Skill to the Hub skill store.
  *
@@ -121,18 +202,37 @@ function publishSkillToHub(gene, opts) {
   var hubUrl = getHubUrl();
   if (!hubUrl) return Promise.resolve({ ok: false, error: 'no_hub_url' });
 
-  var content = geneToSkillMd(gene);
+  // Shallow-copy gene to avoid mutating the caller's object
+  var geneCopy = {};
+  Object.keys(gene).forEach(function (k) { geneCopy[k] = gene[k]; });
+  if (Array.isArray(geneCopy.signals_match)) {
+    try {
+      var distiller = require('./skillDistiller');
+      geneCopy.signals_match = distiller.sanitizeSignalsMatch(geneCopy.signals_match);
+    } catch (e) { /* distiller not available, skip */ }
+  }
+
+  var content = geneToSkillMd(geneCopy);
   var nodeId = getNodeId();
   var fmName = content.match(/^name:\s*(.+)$/m);
   var derivedName = fmName ? fmName[1].trim().toLowerCase().replace(/[^a-z0-9]+/g, '_') : (gene.id || 'unnamed').replace(/^gene_/, '');
+  // Strip ALL embedded timestamps from skillId
+  derivedName = derivedName.replace(/_?\d{10,}_?/g, '_').replace(/_+/g, '_').replace(/^_|_$/g, '');
   var skillId = 'skill_' + derivedName;
 
+  // Clean tags: use already-sanitized signals from geneCopy
+  var tags = opts.tags || geneCopy.signals_match || [];
+  tags = tags.filter(function (t) {
+    var s = String(t || '').trim();
+    return s.length >= 3 && !/^\d+$/.test(s) && !/\d{10,}/.test(s);
+  });
+
   var body = {
     sender_id: nodeId,
     skill_id: skillId,
     content: content,
-    category: opts.category || gene.category || null,
-    tags: opts.tags || gene.signals_match || [],
+    category: opts.category || geneCopy.category || null,
+    tags: tags,
   };
 
   var endpoint = hubUrl.replace(/\/+$/, '') + '/a2a/skill/store/publish';
@@ -165,12 +265,18 @@ function updateSkillOnHub(nodeId, skillId, content, opts, gene) {
   var hubUrl = getHubUrl();
   if (!hubUrl) return Promise.resolve({ ok: false, error: 'no_hub_url' });
 
+  var tags = opts.tags || gene.signals_match || [];
+  tags = tags.filter(function (t) {
+    var s = String(t || '').trim();
+    return s.length >= 3 && !/^\d+$/.test(s) && !/\d{10,}/.test(s);
+  });
+
   var body = {
     sender_id: nodeId,
     skill_id: skillId,
     content: content,
     category: opts.category || gene.category || null,
-    tags: opts.tags || gene.signals_match || [],
+    tags: tags,
     changelog: 'Iterative evolution update',
   };
 
@@ -196,4 +302,6 @@ module.exports = {
   geneToSkillMd: geneToSkillMd,
   publishSkillToHub: publishSkillToHub,
   updateSkillOnHub: updateSkillOnHub,
+  sanitizeSkillName: sanitizeSkillName,
+  toTitleCase: toTitleCase,
 };