@evomap/evolver 1.89.4 → 1.89.5

package/index.js

@@ -1,4 +1,65 @@
 #!/usr/bin/env node
+function _printProxyTokenUsage(out = process.stderr) {
+  out.write('Usage: node index.js proxy-token [--settings FILE]\n');
+}
+
+function _readProxyTokenFromSettingsFile(fs, settingsFile) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
+    return parsed && parsed.proxy && typeof parsed.proxy.token === 'string'
+      ? parsed.proxy.token
+      : '';
+  } catch {
+    return '';
+  }
+}
+
+// `proxy-token` is a credential helper for Codex. Handle it before loading any
+// project .env so a workspace cannot change EVOLVER_SETTINGS_DIR or other local
+// state used to find the proxy token.
+if (process.argv[2] === 'proxy-token') {
+  try {
+    const _fs = require('fs');
+    const _os = require('os');
+    const _path = require('path');
+    let settingsFile = '';
+    for (let i = 3; i < process.argv.length; i++) {
+      const arg = process.argv[i];
+      if (arg === '-h' || arg === '--help') {
+        _printProxyTokenUsage(process.stdout);
+        process.exit(0);
+      }
+      if (arg === '--settings') {
+        if (!process.argv[i + 1]) {
+          _printProxyTokenUsage();
+          console.error('[proxy-token] missing value for --settings');
+          process.exit(2);
+        }
+        settingsFile = process.argv[i + 1];
+        i++;
+        continue;
+      }
+      _printProxyTokenUsage();
+      console.error('[proxy-token] unknown argument');
+      process.exit(2);
+    }
+    const defaultSettingsFile = _path.join(
+      process.env.EVOLVER_SETTINGS_DIR || _path.join(_os.homedir(), '.evolver'),
+      'settings.json',
+    );
+    const token = _readProxyTokenFromSettingsFile(_fs, settingsFile || defaultSettingsFile);
+    if (!token) {
+      console.error('[proxy-token] no active proxy token found; start evolver with EVOMAP_PROXY=1 first');
+      process.exit(1);
+    }
+    process.stdout.write(token + '\n');
+    process.exit(0);
+  } catch (e) {
+    console.error('[proxy-token] Failed:', e && e.message || e);
+    process.exit(1);
+  }
+}
+
 // Load .env BEFORE any internal require so that a2aProtocol and ATP
 // modules see A2A_NODE_SECRET / A2A_NODE_ID / A2A_HUB_URL at first
 // access and never fall back to a stale persisted/cached secret.
@@ -625,7 +686,7 @@ async function main() {
     // failure mode obvious.
     try {
       const { execSync } = require('child_process');
-      execSync('git --version', { stdio: 'ignore', timeout: 5000 });
+      execSync('git --version', { stdio: 'ignore', timeout: 5000, windowsHide: true });
     } catch (_gitErr) {
       console.error('');
       console.error('[Preflight] Could not run "git --version". Evolver requires git to be installed and available on PATH.');
@@ -1166,6 +1227,24 @@ async function main() {
             const { registerMailboxTransport } = require('./src/gep/mailboxTransport');
             registerMailboxTransport();
             process.env.A2A_TRANSPORT = 'mailbox';
+            try {
+              const a2a = require('./src/gep/a2aProtocol');
+              a2a.startSystemdNotifyWatchdog(function () {
+                try {
+                  const proxy = proxyInfo && proxyInfo.proxy;
+                  const lifecycle = proxy && proxy.lifecycle;
+                  if (lifecycle && typeof lifecycle.getHeartbeatStats === 'function') {
+                    const stats = lifecycle.getHeartbeatStats();
+                    // Hub-backed lifecycle stats are authoritative even when stopped;
+                    // systemd should starve and restart instead of seeing a false ping.
+                    if (stats && (stats.running || proxy.hubUrl)) return stats;
+                  }
+                } catch (_) {}
+                return { running: true, consecutiveFailures: 0, lastTickAt: Date.now() };
+              });
+            } catch (sdErr) {
+              console.warn('[Heartbeat] systemd notify/watchdog setup failed: ' + (sdErr && sdErr.message || sdErr));
+            }
           } else {
             const a2a = require('./src/gep/a2aProtocol');
             try { a2a.startHeartbeat(); }
@@ -1825,9 +1904,9 @@ async function main() {
     const repoRoot = getRepoRoot();
     let diff = '';
     try {
-      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();
+      const unstaged = execSync('git diff', { cwd: repoRoot, encoding: 'utf8', timeout: 30000, maxBuffer: MAX_EXEC_BUFFER, windowsHide: true }).trim();
+      const staged = execSync('git diff --cached', { cwd: repoRoot, encoding: 'utf8', timeout: 30000, maxBuffer: MAX_EXEC_BUFFER, windowsHide: true }).trim();
+      const untracked = execSync('git ls-files --others --exclude-standard', { cwd: repoRoot, encoding: 'utf8', timeout: 10000, maxBuffer: MAX_EXEC_BUFFER, windowsHide: true }).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';
@@ -1909,13 +1988,13 @@ 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, maxBuffer: MAX_EXEC_BUFFER });
+        execSync('git checkout -- .', { cwd: repoRoot, encoding: 'utf8', timeout: 30000, maxBuffer: MAX_EXEC_BUFFER, windowsHide: true });
         // Preserve user state on reject: .env files, node_modules, runtime
         // PID files, and a dedicated workspace/ dir (if one exists) MUST NOT
         // be wiped by an automated rollback. Users have reported losing
         // secrets and runtime caches to an aggressive git clean.
         execSync('git clean -fd -e node_modules -e workspace -e .env -e ".env.*" -e "*.pid"', {
-          cwd: repoRoot, encoding: 'utf8', timeout: 30000, maxBuffer: MAX_EXEC_BUFFER,
+          cwd: repoRoot, encoding: 'utf8', timeout: 30000, maxBuffer: MAX_EXEC_BUFFER, windowsHide: true,
         });
         const evolDir = getEvolutionDir();
         const sp = path.join(evolDir, 'evolution_solidify_state.json');
@@ -2948,9 +3027,10 @@ async function main() {
     }
 
   } else {
-    console.log(`Usage: node index.js [run|/evolve|login|logout|solidify|review|distill|fetch|sync|asset-log|webui|setup-hooks|recipe|buy|orders|verify|atp|atp-complete|experiment] [--loop]
+    console.log(`Usage: node index.js [run|/evolve|login|logout|proxy-token|solidify|review|distill|fetch|sync|asset-log|webui|setup-hooks|recipe|buy|orders|verify|atp|atp-complete|experiment] [--loop]
   - login                      (authorize this device via the hub, gh-auth-login style; stores an OAuth token used instead of node_secret)
   - logout                     (remove the stored OAuth token)
+  - proxy-token                (print the local proxy bearer token for command-backed client auth)
   - experiment flags:
     - --task="..." --metric="..."              (required; same task, baseline vs variant)
     - --gene=<geneId>                          (variant arm reuses this gene's strategy)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver",
-  "version": "1.89.4",
+  "version": "1.89.5",
   "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": {
@@ -28,12 +28,10 @@
     "run": "node index.js run",
     "solidify": "node index.js solidify",
     "review": "node index.js review",
-    "distill": "node index.js distill",
-    "webui": "node index.js webui",
-    "test": "node -e \"const fs=require('fs'),cp=require('child_process');const all=fs.readdirSync('test').filter(f=>f.endsWith('.test.js'));const iso=new Set(['solidifyIntegration.test.js']);const others=all.filter(f=>!iso.has(f)).map(f=>'test/'+f);const isoFiles=all.filter(f=>iso.has(f)).map(f=>'test/'+f);if(others.length)cp.execSync('node --test '+others.join(' '),{stdio:'inherit'});if(isoFiles.length)cp.execSync('node --test '+isoFiles.join(' '),{stdio:'inherit'})\"",
     "a2a:export": "node scripts/a2a_export.js",
     "a2a:ingest": "node scripts/a2a_ingest.js",
-    "a2a:promote": "node scripts/a2a_promote.js"
+    "a2a:promote": "node scripts/a2a_promote.js",
+    "test": "node -e \"const fs=require('fs'),cp=require('child_process');const all=fs.readdirSync('test').filter(f=>f.endsWith('.test.js'));const iso=new Set(['solidifyIntegration.test.js']);const others=all.filter(f=>!iso.has(f)).map(f=>'test/'+f);const isoFiles=all.filter(f=>iso.has(f)).map(f=>'test/'+f);if(others.length)cp.execSync('node --test '+others.join(' '),{stdio:'inherit'});if(isoFiles.length)cp.execSync('node --test '+isoFiles.join(' '),{stdio:'inherit'})\""
   },
   "engines": {
     "node": ">=22.12"
@@ -50,5 +48,18 @@
   },
   "optionalDependencies": {
     "@napi-rs/keyring": "^1.1.6"
-  }
+  },
+  "files": [
+    "assets/",
+    "index.js",
+    "src/",
+    "scripts/",
+    "skills/",
+    "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();
+