@evomap/evolver 1.69.7 → 1.69.10

package/CONTRIBUTING.md

@@ -0,0 +1,11 @@
+## Contributing
+
+Thank you for contributing. Please follow these rules:
+
+- Do not use emoji (except the DNA emoji in documentation if needed).
+- Keep changes small and reviewable.
+- Update related documentation when you change behavior.
+- Run `node index.js` for a quick sanity check.
+
+Submit PRs with clear intent and scope.
+

package/assets/gep/candidates.jsonl

@@ -1,3 +1,3 @@
-{"type":"CapabilityCandidate","id":"cand_b9a66a5c","title":"Harden session log detection and fallback behavior","source":"signals","created_at":"2026-04-21T03:36:02.298Z","signals":["memory_missing","user_missing","session_logs_missing"],"tags":["memory_missing","user_missing","session_logs_missing","area:memory"],"shape":{"title":"Harden session log detection and fallback behavior","input":"Recent session transcript + memory snippets + user instructions","output":"A safe, auditable evolution patch guided by GEP assets","invariants":"Protocol order, small reversible patches, validation, append-only events","params":"Signals: memory_missing, user_missing, session_logs_missing","failure_points":"Missing signals, over-broad changes, skipped validation, missing knowledge solidification","evidence":"Signal present: session_logs_missing"}}
-{"type":"CapabilityCandidate","id":"cand_b9a66a5c","title":"Harden session log detection and fallback behavior","source":"signals","created_at":"2026-04-21T03:36:04.194Z","signals":["memory_missing","user_missing","session_logs_missing"],"tags":["memory_missing","user_missing","session_logs_missing","area:memory"],"shape":{"title":"Harden session log detection and fallback behavior","input":"Recent session transcript + memory snippets + user instructions","output":"A safe, auditable evolution patch guided by GEP assets","invariants":"Protocol order, small reversible patches, validation, append-only events","params":"Signals: memory_missing, user_missing, session_logs_missing","failure_points":"Missing signals, over-broad changes, skipped validation, missing knowledge solidification","evidence":"Signal present: session_logs_missing"}}
-{"type":"CapabilityCandidate","id":"cand_b9a66a5c","title":"Harden session log detection and fallback behavior","source":"signals","created_at":"2026-04-21T03:36:05.981Z","signals":["memory_missing","user_missing","session_logs_missing"],"tags":["memory_missing","user_missing","session_logs_missing","area:memory"],"shape":{"title":"Harden session log detection and fallback behavior","input":"Recent session transcript + memory snippets + user instructions","output":"A safe, auditable evolution patch guided by GEP assets","invariants":"Protocol order, small reversible patches, validation, append-only events","params":"Signals: memory_missing, user_missing, session_logs_missing","failure_points":"Missing signals, over-broad changes, skipped validation, missing knowledge solidification","evidence":"Signal present: session_logs_missing"}}
+{"type":"CapabilityCandidate","id":"cand_b9a66a5c","title":"Harden session log detection and fallback behavior","source":"signals","created_at":"2026-04-21T12:13:16.977Z","signals":["memory_missing","user_missing","session_logs_missing"],"tags":["memory_missing","user_missing","session_logs_missing","area:memory"],"shape":{"title":"Harden session log detection and fallback behavior","input":"Recent session transcript + memory snippets + user instructions","output":"A safe, auditable evolution patch guided by GEP assets","invariants":"Protocol order, small reversible patches, validation, append-only events","params":"Signals: memory_missing, user_missing, session_logs_missing","failure_points":"Missing signals, over-broad changes, skipped validation, missing knowledge solidification","evidence":"Signal present: session_logs_missing"}}
+{"type":"CapabilityCandidate","id":"cand_b9a66a5c","title":"Harden session log detection and fallback behavior","source":"signals","created_at":"2026-04-21T12:13:18.789Z","signals":["memory_missing","user_missing","session_logs_missing"],"tags":["memory_missing","user_missing","session_logs_missing","area:memory"],"shape":{"title":"Harden session log detection and fallback behavior","input":"Recent session transcript + memory snippets + user instructions","output":"A safe, auditable evolution patch guided by GEP assets","invariants":"Protocol order, small reversible patches, validation, append-only events","params":"Signals: memory_missing, user_missing, session_logs_missing","failure_points":"Missing signals, over-broad changes, skipped validation, missing knowledge solidification","evidence":"Signal present: session_logs_missing"}}
+{"type":"CapabilityCandidate","id":"cand_b9a66a5c","title":"Harden session log detection and fallback behavior","source":"signals","created_at":"2026-04-21T12:13:20.587Z","signals":["memory_missing","user_missing","session_logs_missing"],"tags":["memory_missing","user_missing","session_logs_missing","area:memory"],"shape":{"title":"Harden session log detection and fallback behavior","input":"Recent session transcript + memory snippets + user instructions","output":"A safe, auditable evolution patch guided by GEP assets","invariants":"Protocol order, small reversible patches, validation, append-only events","params":"Signals: memory_missing, user_missing, session_logs_missing","failure_points":"Missing signals, over-broad changes, skipped validation, missing knowledge solidification","evidence":"Signal present: session_logs_missing"}}

package/assets/gep/capsules.json

@@ -1,4 +1 @@
-{
-  "version": 1,
-  "capsules": []
-}
+{"version":1,"capsules":[]}

package/index.js

@@ -563,6 +563,7 @@ async function main() {
     const { getEvolutionDir, getRepoRoot } = require('./src/gep/paths');
     const { loadGenes } = require('./src/gep/assetStore');
     const { execSync } = require('child_process');
+    const MAX_EXEC_BUFFER = 10 * 1024 * 1024; // 10MB; see GHSA reports / #451
 
     const statePath = path.join(getEvolutionDir(), 'evolution_solidify_state.json');
     const state = readJsonSafe(statePath);
@@ -583,9 +584,9 @@ async function main() {
     const repoRoot = getRepoRoot();
     let diff = '';
     try {
-      const unstaged = execSync('git diff', { cwd: repoRoot, encoding: 'utf8', timeout: 30000 }).trim();
-      const staged = execSync('git diff --cached', { cwd: repoRoot, encoding: 'utf8', timeout: 30000 }).trim();
-      const untracked = execSync('git ls-files --others --exclude-standard', { cwd: repoRoot, encoding: 'utf8', timeout: 10000 }).trim();
+      const unstaged = execSync('git diff', { cwd: repoRoot, encoding: 'utf8', timeout: 30000, maxBuffer: MAX_EXEC_BUFFER }).trim();
+      const staged = execSync('git diff --cached', { cwd: repoRoot, encoding: 'utf8', timeout: 30000, maxBuffer: MAX_EXEC_BUFFER }).trim();
+      const untracked = execSync('git ls-files --others --exclude-standard', { cwd: repoRoot, encoding: 'utf8', timeout: 10000, maxBuffer: MAX_EXEC_BUFFER }).trim();
       if (staged) diff += '=== Staged Changes ===\n' + staged + '\n\n';
       if (unstaged) diff += '=== Unstaged Changes ===\n' + unstaged + '\n\n';
       if (untracked) diff += '=== Untracked Files ===\n' + untracked + '\n';
@@ -667,8 +668,8 @@ async function main() {
     } else if (args.includes('--reject')) {
       console.log('\n[Review] Rejected. Rolling back changes...');
       try {
-        execSync('git checkout -- .', { cwd: repoRoot, encoding: 'utf8', timeout: 30000 });
-        execSync('git clean -fd', { cwd: repoRoot, encoding: 'utf8', timeout: 30000 });
+        execSync('git checkout -- .', { cwd: repoRoot, encoding: 'utf8', timeout: 30000, maxBuffer: MAX_EXEC_BUFFER });
+        execSync('git clean -fd', { cwd: repoRoot, encoding: 'utf8', timeout: 30000, maxBuffer: MAX_EXEC_BUFFER });
         const evolDir = getEvolutionDir();
         const sp = path.join(evolDir, 'evolution_solidify_state.json');
         if (fs.existsSync(sp)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver",
-  "version": "1.69.7",
+  "version": "1.69.10",
   "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": {
@@ -37,5 +37,17 @@
   },
   "devDependencies": {
     "javascript-obfuscator": "^5.4.1"
-  }
+  },
+  "files": [
+    "assets/",
+    "index.js",
+    "src/",
+    "scripts/",
+    "README.md",
+    "README.zh-CN.md",
+    "README.ja-JP.md",
+    "SKILL.md",
+    "CONTRIBUTING.md",
+    "LICENSE"
+  ]
 }

package/scripts/a2a_export.js

@@ -0,0 +1,63 @@
+const { loadGenes, loadCapsules, readAllEvents } = require('../src/gep/assetStore');
+const { exportEligibleCapsules, exportEligibleGenes, isAllowedA2AAsset } = require('../src/gep/a2a');
+const { buildPublish, buildHello, getTransport } = require('../src/gep/a2aProtocol');
+const { computeAssetId, SCHEMA_VERSION } = require('../src/gep/contentHash');
+
+function main() {
+  var args = process.argv.slice(2);
+  var asJson = args.includes('--json');
+  var asProtocol = args.includes('--protocol');
+  var withHello = args.includes('--hello');
+  var persist = args.includes('--persist');
+  var includeEvents = args.includes('--include-events');
+
+  var capsules = loadCapsules();
+  var genes = loadGenes();
+  var events = readAllEvents();
+
+  // Build eligible list: Capsules (filtered) + Genes (filtered) + Events (opt-in)
+  var eligibleCapsules = exportEligibleCapsules({ capsules: capsules, events: events });
+  var eligibleGenes = exportEligibleGenes({ genes: genes });
+  var eligible = eligibleCapsules.concat(eligibleGenes);
+
+  if (includeEvents) {
+    var eligibleEvents = (Array.isArray(events) ? events : []).filter(function (e) {
+      return isAllowedA2AAsset(e) && e.type === 'EvolutionEvent';
+    });
+    for (var ei = 0; ei < eligibleEvents.length; ei++) {
+      var ev = eligibleEvents[ei];
+      if (!ev.schema_version) ev.schema_version = SCHEMA_VERSION;
+      if (!ev.asset_id) { try { ev.asset_id = computeAssetId(ev); } catch (e) {} }
+    }
+    eligible = eligible.concat(eligibleEvents);
+  }
+
+  if (withHello || asProtocol) {
+    var hello = buildHello({ geneCount: genes.length, capsuleCount: capsules.length });
+    process.stdout.write(JSON.stringify(hello) + '\n');
+    if (persist) { try { getTransport().send(hello); } catch (e) {} }
+  }
+
+  if (asProtocol) {
+    for (var i = 0; i < eligible.length; i++) {
+      var msg = buildPublish({ asset: eligible[i] });
+      process.stdout.write(JSON.stringify(msg) + '\n');
+      if (persist) { try { getTransport().send(msg); } catch (e) {} }
+    }
+    return;
+  }
+
+  if (asJson) {
+    process.stdout.write(JSON.stringify(eligible, null, 2) + '\n');
+    return;
+  }
+
+  for (var j = 0; j < eligible.length; j++) {
+    process.stdout.write(JSON.stringify(eligible[j]) + '\n');
+  }
+}
+
+try { main(); } catch (e) {
+  process.stderr.write((e && e.message ? e.message : String(e)) + '\n');
+  process.exit(1);
+}

package/scripts/a2a_ingest.js

@@ -0,0 +1,79 @@
+var fs = require('fs');
+var assetStore = require('../src/gep/assetStore');
+var a2a = require('../src/gep/a2a');
+var memGraph = require('../src/gep/memoryGraphAdapter');
+var contentHash = require('../src/gep/contentHash');
+var a2aProto = require('../src/gep/a2aProtocol');
+
+function readStdin() {
+  try { return fs.readFileSync(0, 'utf8'); } catch (e) { return ''; }
+}
+
+function parseSignalsFromEnv() {
+  var raw = process.env.A2A_SIGNALS || '';
+  if (!raw) return [];
+  try {
+    var maybe = JSON.parse(raw);
+    if (Array.isArray(maybe)) return maybe.map(String).filter(Boolean);
+  } catch (e) {}
+  return String(raw).split(',').map(function (s) { return s.trim(); }).filter(Boolean);
+}
+
+function main() {
+  var args = process.argv.slice(2);
+  var inputPath = '';
+  for (var i = 0; i < args.length; i++) {
+    if (args[i] && !args[i].startsWith('--')) { inputPath = args[i]; break; }
+  }
+  var source = process.env.A2A_SOURCE || 'external';
+  var factor = Number.isFinite(Number(process.env.A2A_EXTERNAL_CONFIDENCE_FACTOR))
+    ? Number(process.env.A2A_EXTERNAL_CONFIDENCE_FACTOR) : 0.6;
+
+  var text = inputPath ? a2a.readTextIfExists(inputPath) : readStdin();
+  var parsed = a2a.parseA2AInput(text);
+  var signals = parseSignalsFromEnv();
+
+  var accepted = 0;
+  var rejected = 0;
+  var emitDecisions = process.env.A2A_EMIT_DECISIONS === 'true';
+
+  for (var j = 0; j < parsed.length; j++) {
+    var obj = parsed[j];
+    if (!a2a.isAllowedA2AAsset(obj)) continue;
+
+    if (obj.asset_id && typeof obj.asset_id === 'string') {
+      if (!contentHash.verifyAssetId(obj)) {
+        rejected += 1;
+        if (emitDecisions) {
+          try {
+            var dm = a2aProto.buildDecision({ assetId: obj.asset_id, localId: obj.id, decision: 'reject', reason: 'asset_id integrity check failed' });
+            a2aProto.getTransport().send(dm);
+          } catch (e) {}
+        }
+        continue;
+      }
+    }
+
+    var staged = a2a.lowerConfidence(obj, { source: source, factor: factor });
+    if (!staged) continue;
+
+    assetStore.appendExternalCandidateJsonl(staged);
+    try { memGraph.recordExternalCandidate({ asset: staged, source: source, signals: signals }); } catch (e) {}
+
+    if (emitDecisions) {
+      try {
+        var dm2 = a2aProto.buildDecision({ assetId: staged.asset_id, localId: staged.id, decision: 'quarantine', reason: 'staged as external candidate' });
+        a2aProto.getTransport().send(dm2);
+      } catch (e) {}
+    }
+
+    accepted += 1;
+  }
+
+  process.stdout.write('accepted=' + accepted + ' rejected=' + rejected + '\n');
+}
+
+try { main(); } catch (e) {
+  process.stderr.write((e && e.message ? e.message : String(e)) + '\n');
+  process.exit(1);
+}

package/scripts/a2a_promote.js

@@ -0,0 +1,118 @@
+var assetStore = require('../src/gep/assetStore');
+var solidifyMod = require('../src/gep/solidify');
+var contentHash = require('../src/gep/contentHash');
+var a2aProto = require('../src/gep/a2aProtocol');
+
+function parseArgs(argv) {
+  var out = { flags: new Set(), kv: new Map(), positionals: [] };
+  for (var i = 0; i < argv.length; i++) {
+    var a = argv[i];
+    if (!a) continue;
+    if (a.startsWith('--')) {
+      var eq = a.indexOf('=');
+      if (eq > -1) { out.kv.set(a.slice(2, eq), a.slice(eq + 1)); }
+      else {
+        var key = a.slice(2);
+        var next = argv[i + 1];
+        if (next && !String(next).startsWith('--')) { out.kv.set(key, next); i++; }
+        else { out.flags.add(key); }
+      }
+    } else { out.positionals.push(a); }
+  }
+  return out;
+}
+
+function main() {
+  var args = parseArgs(process.argv.slice(2));
+  var id = String(args.kv.get('id') || '').trim();
+  var typeRaw = String(args.kv.get('type') || '').trim().toLowerCase();
+  var validated = args.flags.has('validated') || String(args.kv.get('validated') || '') === 'true';
+  var limit = Number.isFinite(Number(args.kv.get('limit'))) ? Number(args.kv.get('limit')) : 500;
+
+  if (!id || !typeRaw) throw new Error('Usage: node scripts/a2a_promote.js --type capsule|gene|event --id <id> --validated');
+  if (!validated) throw new Error('Refusing to promote without --validated (local verification must be done first).');
+
+  var type = typeRaw === 'capsule' ? 'Capsule' : typeRaw === 'gene' ? 'Gene' : typeRaw === 'event' ? 'EvolutionEvent' : '';
+  if (!type) throw new Error('Invalid --type. Use capsule, gene, or event.');
+
+  var external = assetStore.readRecentExternalCandidates(limit);
+  var candidate = null;
+  for (var i = 0; i < external.length; i++) {
+    if (external[i] && external[i].type === type && String(external[i].id) === id) { candidate = external[i]; break; }
+  }
+  if (!candidate) throw new Error('Candidate not found in external zone: type=' + type + ' id=' + id);
+
+  if (type === 'Gene') {
+    var validation = Array.isArray(candidate.validation) ? candidate.validation : [];
+    for (var j = 0; j < validation.length; j++) {
+      var c = String(validation[j] || '').trim();
+      if (!c) continue;
+      if (!solidifyMod.isValidationCommandAllowed(c)) {
+        throw new Error('Refusing to promote Gene ' + id + ': validation command rejected by safety check: "' + c + '". Only node/npm/npx commands without shell operators are allowed.');
+      }
+    }
+  }
+
+  var promoted = JSON.parse(JSON.stringify(candidate));
+  if (!promoted.a2a || typeof promoted.a2a !== 'object') promoted.a2a = {};
+  promoted.a2a.status = 'promoted';
+  promoted.a2a.promoted_at = new Date().toISOString();
+  if (!promoted.schema_version) promoted.schema_version = contentHash.SCHEMA_VERSION;
+  promoted.asset_id = contentHash.computeAssetId(promoted);
+
+  var emitDecisions = process.env.A2A_EMIT_DECISIONS === 'true';
+
+  if (type === 'EvolutionEvent') {
+    assetStore.appendEventJsonl(promoted);
+    if (emitDecisions) {
+      try {
+        var dmEv = a2aProto.buildDecision({ assetId: promoted.asset_id, localId: id, decision: 'accept', reason: 'event promoted for provenance tracking' });
+        a2aProto.getTransport().send(dmEv);
+      } catch (e) {}
+    }
+    process.stdout.write('promoted_event=' + id + '\n');
+    return;
+  }
+
+  if (type === 'Capsule') {
+    assetStore.appendCapsule(promoted);
+    if (emitDecisions) {
+      try {
+        var dm = a2aProto.buildDecision({ assetId: promoted.asset_id, localId: id, decision: 'accept', reason: 'capsule promoted after validation' });
+        a2aProto.getTransport().send(dm);
+      } catch (e) {}
+    }
+    process.stdout.write('promoted_capsule=' + id + '\n');
+    return;
+  }
+
+  var localGenes = assetStore.loadGenes();
+  var exists = false;
+  for (var k = 0; k < localGenes.length; k++) {
+    if (localGenes[k] && localGenes[k].type === 'Gene' && String(localGenes[k].id) === id) { exists = true; break; }
+  }
+  if (exists) {
+    if (emitDecisions) {
+      try {
+        var dm2 = a2aProto.buildDecision({ assetId: promoted.asset_id, localId: id, decision: 'reject', reason: 'local gene with same ID already exists' });
+        a2aProto.getTransport().send(dm2);
+      } catch (e) {}
+    }
+    process.stdout.write('conflict_keep_local_gene=' + id + '\n');
+    return;
+  }
+
+  assetStore.upsertGene(promoted);
+  if (emitDecisions) {
+    try {
+      var dm3 = a2aProto.buildDecision({ assetId: promoted.asset_id, localId: id, decision: 'accept', reason: 'gene promoted after safety audit' });
+      a2aProto.getTransport().send(dm3);
+    } catch (e) {}
+  }
+  process.stdout.write('promoted_gene=' + id + '\n');
+}
+
+try { main(); } catch (e) {
+  process.stderr.write((e && e.message ? e.message : String(e)) + '\n');
+  process.exit(1);
+}

package/scripts/analyze_by_skill.js

@@ -0,0 +1,121 @@
+const fs = require('fs');
+const path = require('path');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const LOG_FILE = path.join(REPO_ROOT, 'evolution_history_full.md');
+const OUT_FILE = path.join(REPO_ROOT, 'evolution_detailed_report.md');
+
+function analyzeEvolution() {
+    if (!fs.existsSync(LOG_FILE)) {
+        console.error("Source file missing.");
+        return;
+    }
+
+    const content = fs.readFileSync(LOG_FILE, 'utf8');
+    // Split by divider
+    const entries = content.split('---').map(e => e.trim()).filter(e => e.length > 0);
+
+    const skillUpdates = {}; // Map<SkillName, Array<Changes>>
+    const generalUpdates = []; // Array<Changes>
+
+    // Regex to detect skills/paths
+    // e.g. `skills/feishu-card/send.js` or **Target**: `skills/git-sync`
+    const skillRegex = /skills\/([a-zA-Z0-9\-_]+)/;
+    const actionRegex = /Action:\s*([\s\S]*?)(?=\n\n|\n[A-Z]|$)/i; // Capture Action text
+    const statusRegex = /Status:\s*\[?([A-Z\s_]+)\]?/i;
+
+    entries.forEach(entry => {
+        // Extract basic info
+        const statusMatch = entry.match(statusRegex);
+        const status = statusMatch ? statusMatch[1].trim().toUpperCase() : 'UNKNOWN';
+        
+        // Skip routine checks if we want a *detailed evolution* report (focus on changes)
+        // But user asked for "what happened", so routine scans might be boring unless they found something.
+        // Let's filter out "STABILITY" or "RUNNING" unless there is a clear "Mutated" or "Fixed" keyword.
+        const isInteresting = 
+            entry.includes('Fixed') || 
+            entry.includes('Hardened') || 
+            entry.includes('Optimized') || 
+            entry.includes('Patched') || 
+            entry.includes('Created') || 
+            entry.includes('Added') ||
+            status === 'SUCCESS' ||
+            status === 'COMPLETED';
+
+        if (!isInteresting) return;
+
+        // Find associated skill
+        const skillMatch = entry.match(skillRegex);
+        let skillName = 'General / System';
+        if (skillMatch) {
+            skillName = skillMatch[1];
+        } else {
+            // Try heuristics
+            if (entry.toLowerCase().includes('feishu card')) skillName = 'feishu-card';
+            else if (entry.toLowerCase().includes('git sync')) skillName = 'git-sync';
+            else if (entry.toLowerCase().includes('logger')) skillName = 'interaction-logger';
+            else if (entry.toLowerCase().includes('evolve')) skillName = 'capability-evolver';
+        }
+
+        // Extract description
+        let description = "";
+        const actionMatch = entry.match(actionRegex);
+        if (actionMatch) {
+            description = actionMatch[1].trim();
+        } else {
+            // Fallback: take lines that look like bullet points or text after header
+            const lines = entry.split('\n');
+            description = lines.filter(l => l.match(/^[•\-\*]|\w/)).slice(1).join('\n').trim();
+        }
+
+        // Clean up description (remove duplicate "Action:" prefix if captured)
+        description = description.replace(/^Action:\s*/i, '');
+
+        if (!skillUpdates[skillName]) skillUpdates[skillName] = [];
+        
+        // Dedup descriptions slightly (simple check)
+        const isDuplicate = skillUpdates[skillName].some(u => u.desc.includes(description.substring(0, 20)));
+        if (!isDuplicate) {
+            // Extract Date if possible
+            const dateMatch = entry.match(/\((\d{4}\/\d{1,2}\/\d{1,2}.*?)\)/);
+            const date = dateMatch ? dateMatch[1] : 'Unknown';
+            
+            skillUpdates[skillName].push({
+                date,
+                status,
+                desc: description
+            });
+        }
+    });
+
+    // Generate Markdown
+    let md = "# Detailed Evolution Report (By Skill)\n\n> Comprehensive breakdown of system changes.\n\n";
+
+    // Sort skills alphabetically
+    const sortedSkills = Object.keys(skillUpdates).sort();
+
+    sortedSkills.forEach(skill => {
+        md += `## ${skill}\n`;
+        const updates = skillUpdates[skill];
+        
+        updates.forEach(u => {
+            // Icon based on content
+            let icon = '*';
+            const lowerDesc = u.desc.toLowerCase();
+            if (lowerDesc.includes('optimiz')) icon = '[optimize]';
+            if (lowerDesc.includes('secur') || lowerDesc.includes('harden') || lowerDesc.includes('permission')) icon = '[security]';
+            if (lowerDesc.includes('fix') || lowerDesc.includes('patch')) icon = '[repair]';
+            if (lowerDesc.includes('creat') || lowerDesc.includes('add')) icon = '[add]';
+
+            md += `### ${icon} ${u.date}\n`;
+            md += `${u.desc}\n\n`;
+        });
+        md += `---\n`;
+    });
+
+    fs.writeFileSync(OUT_FILE, md);
+    console.log(`Generated report for ${sortedSkills.length} skills.`);
+}
+
+analyzeEvolution();
+

package/scripts/check_wrapper_compat.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+/**
+ * check_wrapper_compat.js
+ *
+ * Checks whether recent evolver changes affect interfaces used by feishu-evolver-wrapper.
+ * Run manually or via cursor rule to detect breaking changes early.
+ *
+ * Usage:
+ *   node scripts/check_wrapper_compat.js           # check all interfaces
+ *   node scripts/check_wrapper_compat.js --diff     # check only files in git diff
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+
+const INTERFACE_CONTRACT = [
+  {
+    file: 'src/ops/self_repair.js',
+    requiredExports: ['repair'],
+    description: 'wrapper calls selfRepair.repair()',
+  },
+  {
+    file: 'src/ops/commentary.js',
+    requiredExports: ['getComment'],
+    description: 'wrapper calls getComment(type, dur, ok, persona)',
+  },
+  {
+    file: 'src/ops/cleanup.js',
+    requiredExports: ['run'],
+    description: 'wrapper calls cleanup.run()',
+  },
+  {
+    file: 'src/ops/skills_monitor.js',
+    requiredExports: ['run'],
+    description: 'wrapper calls skills_monitor.run()',
+  },
+  {
+    file: 'src/ops/health_check.js',
+    requiredExports: ['runHealthCheck'],
+    description: 'wrapper calls runHealthCheck()',
+  },
+  {
+    file: 'src/gep/bridge.js',
+    requiredExports: ['renderSessionsSpawnCall'],
+    description: 'wrapper parses sessions_spawn() output from bridge',
+  },
+];
+
+function getChangedFiles() {
+  try {
+    const out = execSync('git diff --name-only HEAD~1', { cwd: ROOT, encoding: 'utf8' }).trim();
+    return out ? out.split('\n') : [];
+  } catch (e) {
+    return [];
+  }
+}
+
+function checkInterface(spec) {
+  const fullPath = path.join(ROOT, spec.file);
+  if (!fs.existsSync(fullPath)) {
+    return { file: spec.file, status: 'MISSING', detail: 'file does not exist' };
+  }
+
+  try {
+    const mod = require(fullPath);
+    const missing = spec.requiredExports.filter(name => typeof mod[name] !== 'function');
+    if (missing.length > 0) {
+      return {
+        file: spec.file,
+        status: 'BROKEN',
+        detail: `missing exports: ${missing.join(', ')} -- ${spec.description}`,
+      };
+    }
+    return { file: spec.file, status: 'OK' };
+  } catch (e) {
+    return { file: spec.file, status: 'ERROR', detail: `require failed: ${e.message}` };
+  }
+}
+
+function main() {
+  const diffMode = process.argv.includes('--diff');
+  let contracts = INTERFACE_CONTRACT;
+
+  if (diffMode) {
+    const changed = getChangedFiles();
+    contracts = contracts.filter(c => changed.includes(c.file));
+    if (contracts.length === 0) {
+      process.stdout.write('No wrapper-affecting files changed.\n');
+      process.exit(0);
+    }
+  }
+
+  const results = contracts.map(checkInterface);
+  const broken = results.filter(r => r.status !== 'OK');
+
+  for (const r of results) {
+    const icon = r.status === 'OK' ? '[OK]' : '[!!]';
+    process.stdout.write(`${icon} ${r.file}${r.detail ? ' -- ' + r.detail : ''}\n`);
+  }
+
+  if (broken.length > 0) {
+    process.stdout.write(`\n${broken.length} interface(s) broken. feishu-evolver-wrapper needs update.\n`);
+    process.stdout.write('Check the feishu-evolver-wrapper repo for required updates.\n');
+    process.exit(1);
+  } else {
+    process.stdout.write(`\nAll ${results.length} interface(s) compatible.\n`);
+  }
+}
+
+main();