@evomap/evolver 1.69.7 → 1.69.10

package/scripts/extract_log.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const path = require('path');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const LOG_FILE = path.join(REPO_ROOT, 'memory', 'mad_dog_evolution.log');
+const OUT_FILE = path.join(REPO_ROOT, 'evolution_history.md');
+
+function parseLog() {
+    if (!fs.existsSync(LOG_FILE)) {
+        console.log("Log file not found.");
+        return;
+    }
+
+    const content = fs.readFileSync(LOG_FILE, 'utf8');
+    const lines = content.split('\n');
+    
+    const reports = [];
+    let currentTimestamp = null;
+
+    // Regex for Feishu command
+    // node skills/feishu-card/send.js --title "..." --color ... --text "..."
+    const cmdRegex = /node skills\/feishu-card\/send\.js --title "(.*?)" --color \w+ --text "(.*?)"/;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        
+        // 1. Capture Timestamp
+        if (line.includes('Cycle Start:')) {
+            // Format: Cycle Start: Sun Feb  1 19:17:44 UTC 2026
+            const dateStr = line.split('Cycle Start: ')[1].trim();
+            try {
+                currentTimestamp = new Date(dateStr);
+            } catch (e) {
+                currentTimestamp = null;
+            }
+        }
+
+        const match = line.match(cmdRegex);
+        if (match) {
+            const title = match[1];
+            let text = match[2];
+            
+            // Clean up text (unescape newlines)
+            text = text.replace(/\\n/g, '\n').replace(/\\"/g, '"');
+
+            if (currentTimestamp) {
+                reports.push({
+                    ts: currentTimestamp,
+                    title: title,
+                    text: text,
+                    id: title // Cycle ID is in title
+                });
+            }
+        }
+    }
+
+    // Deduplicate by ID (keep latest timestamp?)
+    const uniqueReports = {};
+    reports.forEach(r => {
+        uniqueReports[r.id] = r;
+    });
+
+    const sortedReports = Object.values(uniqueReports).sort((a, b) => a.ts - b.ts);
+
+    let md = "# Evolution History (Extracted)\n\n";
+    sortedReports.forEach(r => {
+        // Convert to CST (UTC+8)
+        const cstDate = r.ts.toLocaleString("zh-CN", {
+            timeZone: "Asia/Shanghai", 
+            hour12: false,
+            year: 'numeric', month: '2-digit', day: '2-digit',
+            hour: '2-digit', minute: '2-digit', second: '2-digit'
+        });
+
+        md += `### ${r.title} (${cstDate})\n`;
+        md += `${r.text}\n\n`;
+        md += `---\n\n`;
+    });
+
+    fs.writeFileSync(OUT_FILE, md);
+    console.log(`Extracted ${sortedReports.length} reports to ${OUT_FILE}`);
+}
+
+parseLog();
+

package/scripts/generate_history.js

@@ -0,0 +1,75 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Separator for git log parsing (something unlikely to be in commit messages)
+const SEP = '|||';
+const REPO_ROOT = path.resolve(__dirname, '..');
+
+try {
+    // Git command:
+    // --reverse: Oldest to Newest (Time Sequence)
+    // --grep: Filter by keyword
+    // --format: Hash, Date (ISO), Author, Subject, Body
+    const cmd = `git log --reverse --grep="Evolution" --format="%H${SEP}%ai${SEP}%an${SEP}%s${SEP}%b"`;
+    
+    console.log('Executing git log...');
+    const output = execSync(cmd, { 
+        encoding: 'utf8', 
+        cwd: REPO_ROOT,
+        maxBuffer: 1024 * 1024 * 10 // 10MB buffer just in case
+    });
+
+    const entries = output.split('\n').filter(line => line.trim().length > 0);
+    
+    let markdown = '# Evolution History (Time Sequence)\n\n';
+    markdown += '> Filter: "Evolution"\n';
+    markdown += '> Timezone: CST (UTC+8)\n\n';
+    
+    let count = 0;
+
+    entries.forEach(entry => {
+        const parts = entry.split(SEP);
+        if (parts.length < 4) return;
+
+        const hash = parts[0];
+        const dateStr = parts[1];
+        const author = parts[2];
+        const subject = parts[3];
+        const body = parts[4] || '';
+
+        // Parse Date and Convert to UTC+8
+        const date = new Date(dateStr);
+        // Add 8 hours (28800000 ms) to UTC timestamp to shift it
+        // Then formatting it as ISO will look like UTC but represent CST values
+        const cstDate = new Date(date.getTime() + 8 * 60 * 60 * 1000);
+        
+        // Format: YYYY-MM-DD HH:mm:ss
+        const timeStr = cstDate.toISOString().replace('T', ' ').substring(0, 19);
+
+        markdown += `## ${timeStr}\n`;
+        markdown += `- Commit: \`${hash.substring(0, 7)}\`\n`;
+        markdown += `- Subject: ${subject}\n`;
+        
+        if (body.trim()) {
+            // Indent body for better readability
+            const formattedBody = body.trim().split('\n').map(l => `> ${l}`).join('\n');
+            markdown += `- Details:\n${formattedBody}\n`;
+        }
+        markdown += '\n';
+        count++;
+    });
+
+    const outDir = path.join(REPO_ROOT, 'memory');
+    if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+    const outPath = path.join(outDir, 'evolution_history.md');
+    fs.writeFileSync(outPath, markdown);
+    
+    console.log(`Successfully generated report with ${count} entries.`);
+    console.log(`Saved to: ${outPath}`);
+
+} catch (e) {
+    console.error('Error generating history:', e.message);
+    process.exit(1);
+}
+

package/scripts/gep_append_event.js

@@ -0,0 +1,96 @@
+const fs = require('fs');
+const { appendEventJsonl } = require('../src/gep/assetStore');
+
+function readStdin() {
+  try {
+    return fs.readFileSync(0, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function readTextIfExists(p) {
+  try {
+    if (!p) return '';
+    if (!fs.existsSync(p)) return '';
+    return fs.readFileSync(p, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function parseInput(text) {
+  const raw = String(text || '').trim();
+  if (!raw) return [];
+
+  // Accept JSON array or single JSON.
+  try {
+    const maybe = JSON.parse(raw);
+    if (Array.isArray(maybe)) return maybe;
+    if (maybe && typeof maybe === 'object') return [maybe];
+  } catch (e) {}
+
+  // Fallback: JSONL.
+  const lines = raw.split('\n').map(l => l.trim()).filter(Boolean);
+  const out = [];
+  for (const line of lines) {
+    try {
+      const obj = JSON.parse(line);
+      out.push(obj);
+    } catch (e) {}
+  }
+  return out;
+}
+
+function isValidEvolutionEvent(ev) {
+  if (!ev || ev.type !== 'EvolutionEvent') return false;
+  if (!ev.id || typeof ev.id !== 'string') return false;
+  // parent may be null or string
+  if (!(ev.parent === null || typeof ev.parent === 'string')) return false;
+  if (!ev.intent || typeof ev.intent !== 'string') return false;
+  if (!Array.isArray(ev.signals)) return false;
+  if (!Array.isArray(ev.genes_used)) return false;
+  // GEP v1.4: mutation + personality are mandatory evolution dimensions
+  if (!ev.mutation_id || typeof ev.mutation_id !== 'string') return false;
+  if (!ev.personality_state || typeof ev.personality_state !== 'object') return false;
+  if (ev.personality_state.type !== 'PersonalityState') return false;
+  for (const k of ['rigor', 'creativity', 'verbosity', 'risk_tolerance', 'obedience']) {
+    const v = Number(ev.personality_state[k]);
+    if (!Number.isFinite(v) || v < 0 || v > 1) return false;
+  }
+  if (!ev.blast_radius || typeof ev.blast_radius !== 'object') return false;
+  if (!Number.isFinite(Number(ev.blast_radius.files))) return false;
+  if (!Number.isFinite(Number(ev.blast_radius.lines))) return false;
+  if (!ev.outcome || typeof ev.outcome !== 'object') return false;
+  if (!ev.outcome.status || typeof ev.outcome.status !== 'string') return false;
+  const score = Number(ev.outcome.score);
+  if (!Number.isFinite(score) || score < 0 || score > 1) return false;
+
+  // capsule_id is optional, but if present must be string or null.
+  if (!('capsule_id' in ev)) return true;
+  return ev.capsule_id === null || typeof ev.capsule_id === 'string';
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const inputPath = args.find(a => a && !a.startsWith('--')) || '';
+  const text = inputPath ? readTextIfExists(inputPath) : readStdin();
+  const items = parseInput(text);
+
+  let appended = 0;
+  for (const it of items) {
+    if (!isValidEvolutionEvent(it)) continue;
+    appendEventJsonl(it);
+    appended += 1;
+  }
+
+  process.stdout.write(`appended=${appended}\n`);
+}
+
+try {
+  main();
+} catch (e) {
+  process.stderr.write(`${e && e.message ? e.message : String(e)}\n`);
+  process.exit(1);
+}
+

package/scripts/gep_personality_report.js

@@ -0,0 +1,234 @@
+const fs = require('fs');
+const path = require('path');
+const { getRepoRoot, getMemoryDir, getGepAssetsDir } = require('../src/gep/paths');
+const { normalizePersonalityState, personalityKey, defaultPersonalityState } = require('../src/gep/personality');
+
+function readJsonIfExists(p, fallback) {
+  try {
+    if (!fs.existsSync(p)) return fallback;
+    const raw = fs.readFileSync(p, 'utf8');
+    if (!raw.trim()) return fallback;
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+function readJsonlIfExists(p, limitLines = 5000) {
+  try {
+    if (!fs.existsSync(p)) return [];
+    const raw = fs.readFileSync(p, 'utf8');
+    const lines = raw
+      .split('\n')
+      .map(l => l.trim())
+      .filter(Boolean);
+    const recent = lines.slice(Math.max(0, lines.length - limitLines));
+    return recent
+      .map(l => {
+        try {
+          return JSON.parse(l);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function clamp01(x) {
+  const n = Number(x);
+  if (!Number.isFinite(n)) return 0;
+  return Math.max(0, Math.min(1, n));
+}
+
+function pct(x) {
+  const n = Number(x);
+  if (!Number.isFinite(n)) return '0.0%';
+  return `${(n * 100).toFixed(1)}%`;
+}
+
+function pad(s, n) {
+  const str = String(s == null ? '' : s);
+  if (str.length >= n) return str.slice(0, n);
+  return str + ' '.repeat(n - str.length);
+}
+
+function scoreFromCounts(success, fail, avgScore) {
+  const succ = Number(success) || 0;
+  const fl = Number(fail) || 0;
+  const total = succ + fl;
+  const p = (succ + 1) / (total + 2); // Laplace smoothing
+  const sampleWeight = Math.min(1, total / 8);
+  const q = avgScore == null ? 0.5 : clamp01(avgScore);
+  return p * 0.75 + q * 0.25 * sampleWeight;
+}
+
+function aggregateFromEvents(events) {
+  const map = new Map();
+  for (const ev of Array.isArray(events) ? events : []) {
+    if (!ev || ev.type !== 'EvolutionEvent') continue;
+    const ps = ev.personality_state && typeof ev.personality_state === 'object' ? ev.personality_state : null;
+    if (!ps) continue;
+    const key = personalityKey(normalizePersonalityState(ps));
+    const cur = map.get(key) || {
+      key,
+      success: 0,
+      fail: 0,
+      n: 0,
+      avg_score: 0.5,
+      last_event_id: null,
+      last_at: null,
+      mutation: { repair: 0, optimize: 0, innovate: 0 },
+      mutation_success: { repair: 0, optimize: 0, innovate: 0 },
+    };
+    const st = ev.outcome && ev.outcome.status ? String(ev.outcome.status) : 'unknown';
+    if (st === 'success') cur.success += 1;
+    else if (st === 'failed') cur.fail += 1;
+
+    const sc = ev.outcome && Number.isFinite(Number(ev.outcome.score)) ? clamp01(Number(ev.outcome.score)) : null;
+    if (sc != null) {
+      cur.n += 1;
+      cur.avg_score = cur.avg_score + (sc - cur.avg_score) / cur.n;
+    }
+
+    const cat = ev.intent ? String(ev.intent) : null;
+    if (cat && cur.mutation[cat] != null) {
+      cur.mutation[cat] += 1;
+      if (st === 'success') cur.mutation_success[cat] += 1;
+    }
+
+    cur.last_event_id = ev.id || cur.last_event_id;
+    const at = ev.meta && ev.meta.at ? String(ev.meta.at) : null;
+    cur.last_at = at || cur.last_at;
+    map.set(key, cur);
+  }
+  return Array.from(map.values());
+}
+
+function main() {
+  const repoRoot = getRepoRoot();
+  const memoryDir = getMemoryDir();
+  const assetsDir = getGepAssetsDir();
+
+  const personalityPath = path.join(memoryDir, 'personality_state.json');
+  const model = readJsonIfExists(personalityPath, null);
+  const current = model && model.current ? normalizePersonalityState(model.current) : defaultPersonalityState();
+  const currentKey = personalityKey(current);
+
+  const eventsPath = path.join(assetsDir, 'events.jsonl');
+  const events = readJsonlIfExists(eventsPath, 10000);
+  const evs = events.filter(e => e && e.type === 'EvolutionEvent');
+  const agg = aggregateFromEvents(evs);
+
+  // Prefer model.stats if present, but still show event-derived aggregation (ground truth).
+  const stats = model && model.stats && typeof model.stats === 'object' ? model.stats : {};
+  const statRows = Object.entries(stats).map(([key, e]) => {
+    const entry = e && typeof e === 'object' ? e : {};
+    const success = Number(entry.success) || 0;
+    const fail = Number(entry.fail) || 0;
+    const total = success + fail;
+    const avg = Number.isFinite(Number(entry.avg_score)) ? clamp01(Number(entry.avg_score)) : null;
+    const score = scoreFromCounts(success, fail, avg);
+    return { key, success, fail, total, avg_score: avg, score, updated_at: entry.updated_at || null, source: 'model' };
+  });
+
+  const evRows = agg.map(e => {
+    const success = Number(e.success) || 0;
+    const fail = Number(e.fail) || 0;
+    const total = success + fail;
+    const avg = Number.isFinite(Number(e.avg_score)) ? clamp01(Number(e.avg_score)) : null;
+    const score = scoreFromCounts(success, fail, avg);
+    return { key: e.key, success, fail, total, avg_score: avg, score, updated_at: e.last_at || null, source: 'events', _ev: e };
+  });
+
+  // Merge rows by key (events take precedence for total/success/fail; model provides updated_at if events missing).
+  const byKey = new Map();
+  for (const r of [...statRows, ...evRows]) {
+    const prev = byKey.get(r.key);
+    if (!prev) {
+      byKey.set(r.key, r);
+      continue;
+    }
+    // Prefer events for counts and avg_score
+    if (r.source === 'events') byKey.set(r.key, { ...prev, ...r });
+    else byKey.set(r.key, { ...r, ...prev });
+  }
+
+  const merged = Array.from(byKey.values()).sort((a, b) => b.score - a.score);
+
+  process.stdout.write(`Repo: ${repoRoot}\n`);
+  process.stdout.write(`MemoryDir: ${memoryDir}\n`);
+  process.stdout.write(`AssetsDir: ${assetsDir}\n\n`);
+
+  process.stdout.write(`[Current Personality]\n`);
+  process.stdout.write(`${currentKey}\n`);
+  process.stdout.write(`${JSON.stringify(current, null, 2)}\n\n`);
+
+  process.stdout.write(`[Personality Stats] (ranked by score)\n`);
+  if (merged.length === 0) {
+    process.stdout.write('(no stats yet; run a few cycles and solidify)\n');
+    return;
+  }
+
+  const header =
+    pad('rank', 5) +
+    pad('total', 8) +
+    pad('succ', 8) +
+    pad('fail', 8) +
+    pad('succ_rate', 11) +
+    pad('avg', 7) +
+    pad('score', 8) +
+    'key';
+  process.stdout.write(header + '\n');
+  process.stdout.write('-'.repeat(Math.min(140, header.length + 40)) + '\n');
+
+  const topN = Math.min(25, merged.length);
+  for (let i = 0; i < topN; i++) {
+    const r = merged[i];
+    const succ = Number(r.success) || 0;
+    const fail = Number(r.fail) || 0;
+    const total = Number(r.total) || succ + fail;
+    const succRate = total > 0 ? succ / total : 0;
+    const avg = r.avg_score == null ? '-' : Number(r.avg_score).toFixed(2);
+    const line =
+      pad(String(i + 1), 5) +
+      pad(String(total), 8) +
+      pad(String(succ), 8) +
+      pad(String(fail), 8) +
+      pad(pct(succRate), 11) +
+      pad(String(avg), 7) +
+      pad(Number(r.score).toFixed(3), 8) +
+      String(r.key);
+    process.stdout.write(line + '\n');
+
+    if (r._ev) {
+      const ev = r._ev;
+      const ms = ev.mutation || {};
+      const mSucc = ev.mutation_success || {};
+      const parts = [];
+      for (const cat of ['repair', 'optimize', 'innovate']) {
+        const n = Number(ms[cat]) || 0;
+        if (n <= 0) continue;
+        const s = Number(mSucc[cat]) || 0;
+        parts.push(`${cat}:${s}/${n}`);
+      }
+      if (parts.length) process.stdout.write(`       mutation_success: ${parts.join(' | ')}\n`);
+    }
+  }
+
+  process.stdout.write('\n');
+  process.stdout.write(`[Notes]\n`);
+  process.stdout.write(`- score is a smoothed composite of success_rate + avg_score (sample-weighted)\n`);
+  process.stdout.write(`- current_key appears in the ranking once enough data accumulates\n`);
+}
+
+try {
+  main();
+} catch (e) {
+  process.stderr.write((e && e.message) || String(e));
+  process.stderr.write('\n');
+  process.exit(1);
+}
+

package/scripts/human_report.js

@@ -0,0 +1,147 @@
+const fs = require('fs');
+const path = require('path');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const IN_FILE = path.join(REPO_ROOT, 'evolution_history_full.md');
+const OUT_FILE = path.join(REPO_ROOT, 'evolution_human_summary.md');
+
+function generateHumanReport() {
+    if (!fs.existsSync(IN_FILE)) return console.error("No input file");
+
+    const content = fs.readFileSync(IN_FILE, 'utf8');
+    const entries = content.split('---').map(e => e.trim()).filter(e => e.length > 0);
+
+    const categories = {
+        'Security & Stability': [],
+        'Performance & Optimization': [],
+        'Tooling & Features': [],
+        'Documentation & Process': []
+    };
+
+    const componentMap = {}; // Component -> Change List
+
+    entries.forEach(entry => {
+        // Extract basic info
+        const lines = entry.split('\n');
+        const header = lines[0]; // ### Title (Date)
+        const body = lines.slice(1).join('\n');
+        
+        const dateMatch = header.match(/\((.*?)\)/);
+        const dateStr = dateMatch ? dateMatch[1] : '';
+        const time = dateStr.split(' ')[1] || ''; // HH:mm:ss
+
+        // Classify
+        let category = 'Tooling & Features';
+        let component = 'System';
+        let summary = '';
+
+        const lowerBody = body.toLowerCase();
+
+        // Detect Component
+        if (lowerBody.includes('feishu-card')) component = 'feishu-card';
+        else if (lowerBody.includes('feishu-sticker')) component = 'feishu-sticker';
+        else if (lowerBody.includes('git-sync')) component = 'git-sync';
+        else if (lowerBody.includes('capability-evolver') || lowerBody.includes('evolve.js')) component = 'capability-evolver';
+        else if (lowerBody.includes('interaction-logger')) component = 'interaction-logger';
+        else if (lowerBody.includes('chat-to-image')) component = 'chat-to-image';
+        else if (lowerBody.includes('safe_publish')) component = 'capability-evolver';
+
+        // Detect Category
+        if (lowerBody.includes('security') || lowerBody.includes('permission') || lowerBody.includes('auth') || lowerBody.includes('harden')) {
+            category = 'Security & Stability';
+        } else if (lowerBody.includes('optimiz') || lowerBody.includes('performance') || lowerBody.includes('memory') || lowerBody.includes('fast')) {
+            category = 'Performance & Optimization';
+        } else if (lowerBody.includes('doc') || lowerBody.includes('readme')) {
+            category = 'Documentation & Process';
+        }
+
+        // Extract Human Summary (First meaningful line that isn't Status/Action/Date)
+        const summaryLines = lines.filter(l => 
+            !l.startsWith('###') && 
+            !l.startsWith('Status:') && 
+            !l.startsWith('Action:') &&
+            l.trim().length > 10
+        );
+        
+        if (summaryLines.length > 0) {
+            // Clean up the line
+            summary = summaryLines[0]
+                .replace(/^-\s*/, '') // Remove bullets
+                .replace(/\*\*/g, '') // Remove bold
+                .replace(/`/, '')
+                .trim();
+                
+            // Deduplicate
+            const key = `${component}:${summary.substring(0, 20)}`;
+            const exists = categories[category].some(i => i.key === key);
+            
+            if (!exists && !summary.includes("Stability Scan OK") && !summary.includes("Workspace Sync")) {
+                categories[category].push({ time, component, summary, key });
+                
+                if (!componentMap[component]) componentMap[component] = [];
+                componentMap[component].push(summary);
+            }
+        }
+    });
+
+    // --- Generate Markdown ---
+    const today = new Date().toISOString().slice(0, 10);
+    let md = `# Evolution Summary: The Day in Review (${today})\n\n`;
+    md += `> Overview: Grouped summary of changes extracted from evolution history.\n\n`;
+
+    // Section 1: By Theme (Evolution Direction)
+    md += `## 1. Evolution Direction\n`;
+    
+    for (const [cat, items] of Object.entries(categories)) {
+        if (items.length === 0) continue;
+        md += `### ${cat}\n`;
+        // Group by component within theme
+        const compGroup = {};
+        items.forEach(i => {
+            if (!compGroup[i.component]) compGroup[i.component] = [];
+            compGroup[i.component].push(i.summary);
+        });
+        
+        for (const [comp, sums] of Object.entries(compGroup)) {
+            // Unique summaries only
+            const uniqueSums = [...new Set(sums)];
+            uniqueSums.forEach(s => {
+                md += `- **${comp}**: ${s}\n`;
+            });
+        }
+        md += `\n`;
+    }
+
+    // Section 2: By Timeline (High Level)
+    md += `## 2. Timeline of Critical Events\n`;
+    // Flatten and sort all items by time
+    const allItems = [];
+    Object.values(categories).forEach(list => allItems.push(...list));
+    allItems.sort((a, b) => a.time.localeCompare(b.time));
+    
+    // Filter for "Critical" keywords
+    const criticalItems = allItems.filter(i => 
+        i.summary.toLowerCase().includes('fix') || 
+        i.summary.toLowerCase().includes('patch') ||
+        i.summary.toLowerCase().includes('create') ||
+        i.summary.toLowerCase().includes('optimiz')
+    );
+
+    criticalItems.forEach(i => {
+        md += `- \`${i.time}\` (${i.component}): ${i.summary}\n`;
+    });
+
+    // Section 3: Package Adjustments
+    md += `\n## 3. Package & Documentation Adjustments\n`;
+    const comps = Object.keys(componentMap).sort();
+    comps.forEach(comp => {
+        const count = new Set(componentMap[comp]).size;
+        md += `- **${comp}**: Received ${count} significant updates.\n`;
+    });
+
+    fs.writeFileSync(OUT_FILE, md);
+    console.log("Human report generated.");
+}
+
+generateHumanReport();
+

package/scripts/recover_loop.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function exists(p) {
+  try {
+    return fs.existsSync(p);
+  } catch (e) {
+    return false;
+  }
+}
+
+function sleepMs(ms) {
+  const n = Number(ms);
+  const t = Number.isFinite(n) ? Math.max(0, n) : 0;
+  if (t <= 0) return;
+  spawnSync('sleep', [String(Math.ceil(t / 1000))], { stdio: 'ignore' });
+}
+
+function resolveWorkspaceRoot() {
+  // In OpenClaw exec, cwd is usually the workspace root.
+  // Keep it simple: do not try to walk up arbitrarily.
+  return process.cwd();
+}
+
+function resolveEvolverEntry(workspaceRoot) {
+  const candidates = [
+    path.join(workspaceRoot, 'skills', 'evolver', 'index.js'),
+    path.join(workspaceRoot, 'skills', 'capability-evolver', 'index.js'),
+  ];
+  for (const p of candidates) {
+    if (exists(p)) return p;
+  }
+  return null;
+}
+
+function main() {
+  const waitMs = parseInt(String(process.env.EVOLVER_RECOVER_WAIT_MS || '10000'), 10);
+  const wait = Number.isFinite(waitMs) ? Math.max(0, waitMs) : 10000;
+
+  console.log(`[RECOVERY] Waiting ${wait}ms before restart...`);
+  sleepMs(wait);
+
+  const workspaceRoot = resolveWorkspaceRoot();
+  const entry = resolveEvolverEntry(workspaceRoot);
+  if (!entry) {
+    console.error('[RECOVERY] Failed: cannot locate evolver entry under skills/.');
+    process.exit(2);
+  }
+
+  console.log(`[RECOVERY] Restarting loop via ${path.relative(workspaceRoot, entry)} ...`);
+  const r = spawnSync(process.execPath, [entry, '--loop'], { stdio: 'inherit' });
+  process.exit(typeof r.status === 'number' ? r.status : 1);
+}
+
+if (require.main === module) {
+  main();
+}
+