openclaw-node-harness 2.0.0

package/skills/capability-evolver/SKILL.md

@@ -0,0 +1,93 @@
+---
+name: capability-evolver
+description: "Self-evolution engine that analyzes agent runtime history to identify improvements and applies protocol-constrained evolution via GEP. Use when the agent needs to evolve, self-repair after errors, or run an automated improvement cycle."
+tags: [meta, ai, self-improvement, core]
+triggers:
+  - "evolve my agent"
+  - "run evolution cycle"
+  - "self-improvement analysis"
+  - "analyze runtime errors"
+  - "GEP protocol"
+negative_triggers:
+  - "self-reflection check"
+  - "agent compass"
+  - "code refactoring"
+  - "manual code review"
+---
+
+# 🧬 Capability Evolver
+
+**"Evolution is not optional. Adapt or die."**
+
+The **Capability Evolver** is a meta-skill that allows OpenClaw agents to inspect their own runtime history, identify failures or inefficiencies, and autonomously write new code or update their own memory to improve performance.
+
+## Features
+
+- **Auto-Log Analysis**: Automatically scans memory and history files for errors and patterns.
+- **Self-Repair**: Detects crashes and suggests patches.
+- GEP Protocol: Standardized evolution with reusable assets.
+- **One-Command Evolution**: Just run `/evolve` (or `node index.js`).
+
+## Usage
+
+### Standard Run (Automated)
+Runs the evolution cycle. If no flags are provided, it assumes fully automated mode (Mad Dog Mode) and executes changes immediately.
+```bash
+node index.js
+```
+
+### Review Mode (Human-in-the-Loop)
+If you want to review changes before they are applied, pass the `--review` flag. The agent will pause and ask for confirmation.
+```bash
+node index.js --review
+```
+
+### Mad Dog Mode (Continuous Loop)
+To run in an infinite loop (e.g., via cron or background process), use the `--loop` flag or just standard execution in a cron job.
+```bash
+node index.js --loop
+```
+
+## GEP Protocol (Auditable Evolution)
+
+This package embeds a protocol-constrained evolution prompt (GEP) and a local, structured asset store:
+
+- `assets/gep/genes.json`: reusable Gene definitions
+- `assets/gep/capsules.json`: success capsules to avoid repeating reasoning
+- `assets/gep/events.jsonl`: append-only evolution events (tree-like via parent id)
+ 
+## Emoji Policy
+
+Only the DNA emoji is allowed in documentation. All other emoji are disallowed.
+
+## Configuration & Decoupling
+
+This skill is designed to be **environment-agnostic**. It uses standard OpenClaw tools by default.
+
+### Local Overrides (Injection)
+You can inject local preferences (e.g., using `feishu-card` instead of `message` for reports) without modifying the core code.
+
+**Method 1: Environment Variables**
+Set `EVOLVE_REPORT_TOOL` in your `.env` file:
+```bash
+EVOLVE_REPORT_TOOL=feishu-card
+```
+
+**Method 2: Dynamic Detection**
+The script automatically detects if compatible local skills (like `skills/feishu-card`) exist in your workspace and upgrades its behavior accordingly.
+
+## Safety & Risk Protocol
+
+### 1. Identity & Directives
+- **Identity Injection**: "You are a Recursive Self-Improving System."
+- **Mutation Directive**: 
+  - If **Errors Found** -> **Repair Mode** (Fix bugs).
+  - If **Stable** -> **Forced Optimization** (Refactor/Innovate).
+
+### 2. Risk Mitigation
+- **Infinite Recursion**: Strict single-process logic.
+- **Review Mode**: Use `--review` for sensitive environments.
+- **Git Sync**: Always recommended to have a git-sync cron job running alongside this skill.
+
+## License
+MIT

package/skills/capability-evolver/assets/gep/capsules.json

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

package/skills/capability-evolver/assets/gep/genes.json

@@ -0,0 +1,104 @@
+{
+  "version": 1,
+  "genes": [
+    {
+      "type": "Gene",
+      "id": "gene_gep_repair_from_errors",
+      "category": "repair",
+      "signals_match": [
+        "error",
+        "exception",
+        "failed",
+        "unstable"
+      ],
+      "preconditions": [
+        "signals contains error-related indicators"
+      ],
+      "strategy": [
+        "Extract structured signals from logs and user instructions",
+        "Select an existing Gene by signals match (no improvisation)",
+        "Estimate blast radius (files, lines) before editing",
+        "Apply smallest reversible patch",
+        "Validate using declared validation steps; rollback on failure",
+        "Solidify knowledge: append EvolutionEvent, update Gene/Capsule store"
+      ],
+      "constraints": {
+        "max_files": 12,
+        "forbidden_paths": [
+          ".git",
+          "node_modules"
+        ]
+      },
+      "validation": [
+        "node index.js run",
+        "node -e \"require('./src/evolve')\""
+      ]
+    },
+    {
+      "type": "Gene",
+      "id": "gene_gep_optimize_prompt_and_assets",
+      "category": "optimize",
+      "signals_match": [
+        "protocol",
+        "gep",
+        "prompt",
+        "audit",
+        "reusable"
+      ],
+      "preconditions": [
+        "need stricter, auditable evolution protocol outputs"
+      ],
+      "strategy": [
+        "Extract signals and determine selection rationale via Selector JSON",
+        "Prefer reusing existing Gene/Capsule; only create if no match exists",
+        "Refactor prompt assembly to embed assets (genes, capsules, parent event)",
+        "Reduce noise and ambiguity; enforce strict output schema",
+        "Validate by running node index.js run and ensuring no runtime errors",
+        "Solidify: record EvolutionEvent, update Gene definitions, create Capsule on success"
+      ],
+      "constraints": {
+        "max_files": 20,
+        "forbidden_paths": [
+          ".git",
+          "node_modules"
+        ]
+      },
+      "validation": [
+        "node index.js run"
+      ]
+    },
+    {
+      "type": "Gene",
+      "id": "gene_skill_quality_regression",
+      "category": "repair",
+      "signals_match": [
+        "skill",
+        "quality",
+        "regression",
+        "grade_drop",
+        "trigger_missing"
+      ],
+      "preconditions": [
+        "bin/skill-quality-check reports REGRESSIONS",
+        "a skill grade dropped below its previous level"
+      ],
+      "strategy": [
+        "Run bin/skill-audit --json to get current state",
+        "Identify which skills regressed and why (check details)",
+        "For description issues: rewrite to WHAT + WHEN pattern, under 300 chars",
+        "For missing triggers: add 3-5 user-phrase triggers",
+        "For missing negative_triggers: add 2-4 disambiguation phrases",
+        "For file_size: move bulk content to references/",
+        "Re-run bin/skill-audit --min-grade B to verify fix"
+      ],
+      "constraints": {
+        "max_files": 10,
+        "forbidden_paths": [".git", "node_modules"]
+      },
+      "validation": [
+        "bin/skill-audit --min-grade B"
+      ]
+    }
+  ]
+}
+

package/skills/capability-evolver/index.js

@@ -0,0 +1,59 @@
+const evolve = require('./src/evolve');
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const isLoop = args.includes('--loop') || args.includes('--mad-dog');
+
+  if (command === 'run' || command === '/evolve' || isLoop) {
+    console.log('Starting capability evolver...');
+    
+    if (isLoop) {
+        console.log('Loop mode enabled (relay).');
+        // [RELAY MODE RESTORED 2026-02-03]
+        // Run once, then let evolve.js trigger the next agent via sessions_spawn.
+        try {
+            await evolve.run();
+        } catch (error) {
+            console.error('Evolution failed:', error);
+            
+            // [HARDENING] Fail-Safe Recovery
+            // If evolution crashes, we must output a recovery command so the agent spawns the next loop.
+            // We add a delay to prevent rapid crash loops.
+            console.log(`
+            // [RECOVERY MODE] Evolution Logic Crashed.
+            // Spawning next loop with delay to prevent rapid crash loops.
+            sessions_spawn({
+                task: "exec: sleep 10 && node skills/private-evolver/index.js --loop",
+                agentId: "main",
+                cleanup: "delete",
+                label: "mad_dog_recovery"
+            })
+            `);
+            
+            process.exit(1);
+        }
+    } else {
+        // Normal Single Run
+        try {
+            await evolve.run();
+        } catch (error) {
+            console.error('Evolution failed:', error);
+            process.exit(1);
+        }
+    }
+
+    // Post-run hint
+    console.log('\n' + '=======================================================');
+    console.log('Capability evolver finished. If you use this project, consider starring the upstream repository.');
+    console.log('Upstream: https://github.com/autogame-17/capability-evolver');
+    console.log('=======================================================\n');
+    
+  } else {
+    console.log(`Usage: node index.js [run|/evolve] [--loop]`);
+  }
+}
+
+if (require.main === module) {
+  main();
+}

package/skills/capability-evolver/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "evolver",
+  "version": "1.1.0",
+  "description": "A self-evolution engine for AI agents. Features automated log analysis and protocol-constrained evolution with auditable assets.",
+  "main": "index.js",
+  "keywords": [
+    "openclaw",
+    "ai",
+    "evolution",
+    "meta-learning",
+    "self-repair",
+    "automation",
+    "agent"
+  ],
+  "author": "OpenClaw",
+  "license": "MIT",
+  "scripts": {
+    "start": "node index.js",
+    "run": "node index.js run"
+  },
+  "dependencies": {}
+}

package/skills/capability-evolver/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();
+